codesanitize

In Search of Exploration Video games

Android Development

codesanitize

19 August 2024

(This text is spoiler-free.)

Previously few years, I’ve fallen in love with exploration in video video games.

This mechanic is vital in video games like Outer Wilds or Subnautica. You’re dropped into the center of a world and are given free reign to go wherever, discovering many surprises alongside the best way.

I would like extra! Nevertheless, suggestions for exploration video games typically embrace entries I’ve performed but don’t think about to be in the identical style. Breath of the Wild, Elden Ring, Dying Stranding… all video games I really like, and whereas they offer you a lot freedom, they by no means gave me the identical sense of exploration as with Outer Wilds or Subnautica.

I’ve been ruminating on why I don’t get the identical sense of exploration from these video games, and I believe I’ve lastly figured it out: it’s not simply exploration that’s required, but additionally the sense of discovery that makes these video games magical.

Discovery

By “discovery”, I imply going out into the sport to seek out belongings you did not know have been there.

These may be narrative or mechanical in nature. You would possibly be taught extra in regards to the world, ahead the plot, or unravel a thriller. You would possibly determine the hidden guidelines of a puzzle, a trick to open locked doorways, or the path to stroll to keep away from an enemy noticing you.

What makes a recreation have excessive vs low discoverability? It’s all in regards to the participant’s information of what you’ll be able to uncover.

In a recreation with low discoverability, you usually know what you’re going to seek out in every single place you go. For instance, in Breath of the Wild, you knew that every space you entered would have enemies, crafting gadgets, and loot. Positive, you don’t know which enemies, gadgets, or loot you’d discover – however you hardly ever discovered one thing completely sudden.

In contrast, a recreation with excessive discoverability has a big “???” on its map. It’s the unknown unknowns; what you would possibly discover isn’t even one thing you might preconceive. What is going to occur whenever you land on a brand new planet in Outer Wilds? Who is aware of!

(As an apart, excessive discoverability may be fairly annoying if a recreation severely punishes you when you’re exploring. This facet is performed to comedic impact in I Wanna Be The Man however in video games like Don’t Starve it typically feels unfair to die hours right into a session due to one thing you couldn’t have anticipated.)

Now, discoverability alone just isn’t sufficient to make an exploration recreation. A linear recreation (like What Stays of Edith Finch or INSIDE) has narrative surprises round each nook, however you’re not exploring a lot as strolling a linear path right into a darkish, unknown forest.

That brings us to the second key factor to a great exploration recreation: branching.

Branching

Branching is the variety of selections the sport presents to a participant.

Sid Meier as soon as stated that “video games are a sequence of attention-grabbing choices.” Should you had no selections, it will stop to be a recreation – you’d simply be watching a video.

There’s a gigantic vary of what selections you give to gamers. Much like discovery, these may be narrative or mechanical in nature. Possibly you’ll be able to select which order you discuss to characters, which characters to avoid wasting from a monster, or what ending you get. Or you’ll be able to select which path a personality strikes, how they battle, and even the digital camera angle.

A superb exploration recreation requires some narrative or mechanical branching. If not, you then wouldn’t be exploring something!

For instance, in Breath of the Wild, you simply decide a path and begin strolling. The sport doesn’t maintain you again! Distinction that with a level-based recreation, like Tremendous Mario Bros, which (in addition to warp tunnels) provides you little alternative on how you can proceed in addition to strolling proper.

Exhausting, Scientific Information

As an train, right here’s my private (i.e. subjective) discovery/branching scores on video games which individuals have stated are “exploration” video games that I’ve performed to completion. The nearer the sport is to the upper-right quadrant, the extra discovery/branching it has.

Scatter plot of games, where the X-axis is "branching" and the Y-axis is "discovery." The upper-right quadrant are qualified as exploration games.

The higher proper quadrant is the candy spot I dub “exploration video games.”

Nothing about this chart is in regards to the high quality of the sport – for instance, Journey is considered one of my favourite video games of all time, however it hardly ranks excessive in any respect as an exploration recreation. Slightly, it’s nearly whether or not the design of the sport provides me the nice feeling of exploration.

Conclusion

Clearly, which video games provide you with that grand sense of journey by way of exploration is subjective. You and I’d fee a video games’ discovery and branching otherwise. However no less than now I’ve a framework from which to guage exploration video games.

Now, to get again to the purpose of this text – are you able to assist me discover extra exploration video games? Go away recommendations within the feedback beneath!

Take a look at-Driving HTML Templates

Software Development

codesanitize

19 August 2024

foo

Let’s examine the right way to do it in phases: we begin with the next take a look at that
tries to compile the template. In Go we use the usual html/template bundle.

  func Test_wellFormedHtml(t *testing.T) {
    templ := template.Should(template.ParseFiles("index.tmpl"))
    _ = templ
  }

In Java, we use jmustache
as a result of it is quite simple to make use of; Freemarker or
Velocity are different widespread selections.

Java

  @Take a look at
  void indexIsSoundHtml() {
      var template = Mustache.compiler().compile(
              new InputStreamReader(
                      getClass().getResourceAsStream("/index.tmpl")));
  }

If we run this take a look at, it can fail, as a result of the index.tmpl file does
not exist. So we create it, with the above damaged HTML. Now the take a look at ought to cross.

Then we create a mannequin for the template to make use of. The appliance manages a todo-list, and
we are able to create a minimal mannequin for demonstration functions.

  func Test_wellFormedHtml(t *testing.T) {
    templ := template.Should(template.ParseFiles("index.tmpl"))
    mannequin := todo.NewList()
    _ = templ
    _ = mannequin
  }

Java

  @Take a look at
  void indexIsSoundHtml() {
      var template = Mustache.compiler().compile(
              new InputStreamReader(
                      getClass().getResourceAsStream("/index.tmpl")));
      var mannequin = new TodoList();
  }

Now we render the template, saving the leads to a bytes buffer (Go) or as a String (Java).

  func Test_wellFormedHtml(t *testing.T) {
    templ := template.Should(template.ParseFiles("index.tmpl"))
    mannequin := todo.NewList()
    var buf bytes.Buffer
    err := templ.Execute(&buf, mannequin)
    if err != nil {
      panic(err)
    }
  }

Java

  @Take a look at
  void indexIsSoundHtml() {
      var template = Mustache.compiler().compile(
              new InputStreamReader(
                      getClass().getResourceAsStream("/index.tmpl")));
      var mannequin = new TodoList();
  
      var html = template.execute(mannequin);
  }

At this level, we need to parse the HTML and we count on to see an
error, as a result of in our damaged HTML there’s a div aspect that
is closed by a p aspect. There may be an HTML parser within the Go
normal library, however it’s too lenient: if we run it on our damaged HTML, we do not get an
error. Fortunately, the Go normal library additionally has an XML parser that may be
configured to parse HTML (due to this Stack Overflow reply)

  func Test_wellFormedHtml(t *testing.T) {
    templ := template.Should(template.ParseFiles("index.tmpl"))
    mannequin := todo.NewList()
    
    // render the template right into a buffer
    var buf bytes.Buffer
    err := templ.Execute(&buf, mannequin)
    if err != nil {
      panic(err)
    }
  
    // verify that the template will be parsed as (lenient) XML
    decoder := xml.NewDecoder(bytes.NewReader(buf.Bytes()))
    decoder.Strict = false
    decoder.AutoClose = xml.HTMLAutoClose
    decoder.Entity = xml.HTMLEntity
    for {
      _, err := decoder.Token()
      change err {
      case io.EOF:
        return // We're achieved, it is legitimate!
      case nil:
        // do nothing
      default:
        t.Fatalf("Error parsing html: %s", err)
      }
    }
  }

supply

This code configures the HTML parser to have the fitting stage of leniency
for HTML, after which parses the HTML token by token. Certainly, we see the error
message we wished:

--- FAIL: Test_wellFormedHtml (0.00s)
    index_template_test.go:61: Error parsing html: XML syntax error on line 4: surprising finish aspect

In Java, a flexible library to make use of is jsoup:

Java

  @Take a look at
  void indexIsSoundHtml() {
      var template = Mustache.compiler().compile(
              new InputStreamReader(
                      getClass().getResourceAsStream("/index.tmpl")));
      var mannequin = new TodoList();
  
      var html = template.execute(mannequin);
  
      var parser = Parser.htmlParser().setTrackErrors(10);
      Jsoup.parse(html, "", parser);
      assertThat(parser.getErrors()).isEmpty();
  }

supply

And we see it fail:

java.lang.AssertionError: 
Anticipating empty however was:<[<1:13>: Unexpected EndTag token [] when in state [InBody],

Success! Now if we copy over the contents of the TodoMVC
template to our index.tmpl file, the take a look at passes.

The take a look at, nonetheless, is just too verbose: we extract two helper capabilities, in
order to make the intention of the take a look at clearer, and we get

  func Test_wellFormedHtml(t *testing.T) {
    mannequin := todo.NewList()
  
    buf := renderTemplate("index.tmpl", mannequin)
  
    assertWellFormedHtml(t, buf)
  }

supply

Java

  @Take a look at
  void indexIsSoundHtml() {
      var mannequin = new TodoList();
  
      var html = renderTemplate("/index.tmpl", mannequin);
  
      assertSoundHtml(html);
  }

supply

Stage 2: testing HTML construction

What else ought to we take a look at?

We all know that the seems of a web page can solely be examined, in the end, by a
human how it’s rendered in a browser. Nonetheless, there’s typically
logic in templates, and we would like to have the ability to take a look at that logic.

One may be tempted to check the rendered HTML with string equality,
however this method fails in observe, as a result of templates comprise loads of
particulars that make string equality assertions impractical. The assertions
change into very verbose, and when studying the assertion, it turns into troublesome
to grasp what it’s that we’re attempting to show.

What we want
is a way to claim that some elements of the rendered HTML
correspond to what we count on, and to ignore all the main points we do not
care about. A technique to do that is by working queries with the CSS selector language:
it’s a highly effective language that permits us to pick out the
components that we care about from the entire HTML doc. As soon as we’ve
chosen these components, we (1) depend that the variety of aspect returned
is what we count on, and (2) that they comprise the textual content or different content material
that we count on.

The UI that we’re imagined to generate seems like this:

There are a number of particulars which are rendered dynamically:

The variety of objects and their textual content content material change, clearly
The model of the todo-item adjustments when it is accomplished (e.g., the
second)
The “2 objects left” textual content will change with the variety of non-completed
objects
One of many three buttons “All”, “Energetic”, “Accomplished” will likely be
highlighted, relying on the present url; for example if we resolve that the
url that reveals solely the “Energetic” objects is /lively, then when the present url
is /lively, the “Energetic” button ought to be surrounded by a skinny crimson
rectangle
The “Clear accomplished” button ought to solely be seen if any merchandise is
accomplished

Every of this issues will be examined with the assistance of CSS selectors.

This can be a snippet from the TodoMVC template (barely simplified). I
haven’t but added the dynamic bits, so what we see right here is static
content material, offered for example:

index.tmpl

supply

c# – Unable to hook up with Distant Server utilizing Selenium Chrome RemoteWebDriver

Purchase or Lease IPv4 Addresses: What is the Finest Choice?

Purchase or lease?

Supplier Pricing

When to Purchase

When to lease

Balancing execs and cons

Complete Information to Android 15 Safety and Privateness Enhancements

Android 15 Delicate App Permissions

Android 15 Display Sharing Safety

Android 15 Intent Filtering Capabilities

Android 15 Non-public Area

Android 15 Chosen Photographs Entry

Android 15 Finish-to-Finish Encryption

NowSecure Options Safeguard Android 15 Apps

In Search of Exploration Video games

Discovery

Branching

Exhausting, Scientific Information

Conclusion

Take a look at-Driving HTML Templates

Stage 2: testing HTML construction

What else ought to we take a look at?

ABOUT US