<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom"><channel><title>Posts on Sven's Dev Journal</title><link>https://shendriks.dev/posts/</link><description>Recent content in Posts on Sven's Dev Journal</description><generator>Hugo -- gohugo.io</generator><language>en-us</language><lastBuildDate>Sat, 10 May 2025 00:00:00 +0000</lastBuildDate><atom:link href="https://shendriks.dev/posts/index.xml" rel="self" type="application/rss+xml"/><item><title>Loosely Coupled Game Architecture with Events and Commands</title><link>https://shendriks.dev/posts/2025-05-10-loosely-coupled-game-architecture-with-events-and-commands/</link><pubDate>Sat, 10 May 2025 00:00:00 +0000</pubDate><guid>https://shendriks.dev/posts/2025-05-10-loosely-coupled-game-architecture-with-events-and-commands/</guid><description>This article introduces events and commands as a way to decouple game components. A (very) basic space shooter example illustrates how the pattern can be applied in practice.</description><content type="html"><![CDATA[<h2 id="introduction">Introduction</h2>
<p>A game is usually made up of many components, such as a scene, which contains various game objects, such as
the character, enemies, bosses, power-ups, a tile map, explosions and particle effects. In addition, there
could be a HUD that shows the score, health points and possibly a mini-map with the positions of various objects and
items.</p>
<p>It is usually necessary for all of these components, or at least some of them, to exchange information with each other.
For example, if the character is hit by an enemy, it loses health points, which causes the HUD to update. If the
character destroys an enemy, the player is credited points and the defeated enemy could leave a power-up behind. The
possibilities are endless.</p>
<p>You could now have the components communicate directly with each other. However, this
often results in complex dependencies between different components, which can make the code difficult to understand and
maintain.</p>
<p>Instead of making the components directly dependent on each other, another idea is to set up kind of central hub on
which the components depend and through which all communication takes place. The components do not even have to know
each other, but only that hub.</p>
<h2 id="events-and-commands">Events and Commands</h2>
<p>The basic idea is that components can do two things: first, they can register message handlers to receive messages, and
second, they can send messages to the hub, which are then forwarded to the appropriate handlers.</p>
<p>Messages typically come in two flavors: events and commands. While technically they are both implemented more or less
similarly, there is a semantic difference between them:</p>
<p>An <strong>event</strong> is a fact that happened in the past, and to which other components (a.k.a. observers) can subscribe in order
to react to them, e.g. a power up was collected.</p>
<p>A <strong>command</strong> is an instruction to perform an action, e.g. add a game object to the scene. While events can have multiple
subscribers, commands can only have one subscriber, and this subscriber is responsible for executing the command. Additionally,
a command can have a return value.</p>
<p>Distinguishing between events and commands can help keeping the code more clear and easier to maintain.</p>
<h2 id="implementation">Implementation</h2>
<h3 id="quick-overview">Quick Overview</h3>
<p>Since this hub receives messages and forwards them to the appropriate handlers, the component can be named message dispatcher.</p>
<p>Here is a quick diagram showing the flow of events and commands from some components via the message dispatcher forwarded to other components:</p>
<figure class="center" role="img" aria-label="A message dispatcher as a central hub for events and commands" style="width: 100%">
    <?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
<svg xmlns="http://www.w3.org/2000/svg" style="background: #ffffff; background-color: var(--ge-dark-color, #121212); color-scheme: dark;" xmlns:xlink="http://www.w3.org/1999/xlink" version="1.1" width="621px" height="301px" viewBox="0 0 621 301"><defs/><rect fill="#ffffff" width="100%" height="100%" x="0" y="0" style="fill: var(--ge-dark-color, #121212);"/><g><g data-cell-id="0"><g data-cell-id="1"><g data-cell-id="k7scYC8v7eUuEwf4sQOG-2"/><g data-cell-id="UmFBGxWu7A4jjFx_JnYR-1"/><g data-cell-id="UmFBGxWu7A4jjFx_JnYR-2"/><g data-cell-id="UmFBGxWu7A4jjFx_JnYR-3"/><g data-cell-id="UmFBGxWu7A4jjFx_JnYR-4"/><g data-cell-id="UmFBGxWu7A4jjFx_JnYR-6"/><g data-cell-id="UmFBGxWu7A4jjFx_JnYR-7"/><g data-cell-id="UmFBGxWu7A4jjFx_JnYR-8"/><g data-cell-id="UmFBGxWu7A4jjFx_JnYR-9"><g data-cell-id="UmFBGxWu7A4jjFx_JnYR-10"/></g><g data-cell-id="UmFBGxWu7A4jjFx_JnYR-11"><g data-cell-id="UmFBGxWu7A4jjFx_JnYR-12"/></g><g data-cell-id="UmFBGxWu7A4jjFx_JnYR-13"><g data-cell-id="UmFBGxWu7A4jjFx_JnYR-14"/></g><g data-cell-id="UmFBGxWu7A4jjFx_JnYR-15"><g data-cell-id="UmFBGxWu7A4jjFx_JnYR-16"/></g><g data-cell-id="UmFBGxWu7A4jjFx_JnYR-17"><g data-cell-id="UmFBGxWu7A4jjFx_JnYR-25"/></g><g data-cell-id="UmFBGxWu7A4jjFx_JnYR-19"><g data-cell-id="UmFBGxWu7A4jjFx_JnYR-20"/></g><g data-cell-id="UmFBGxWu7A4jjFx_JnYR-21"><g data-cell-id="k7scYC8v7eUuEwf4sQOG-4"/></g><g data-cell-id="UmFBGxWu7A4jjFx_JnYR-23"><g data-cell-id="UmFBGxWu7A4jjFx_JnYR-24"/></g><g data-cell-id="k7scYC8v7eUuEwf4sQOG-1"/><g data-cell-id="k7scYC8v7eUuEwf4sQOG-5"><g transform="translate(0.5,0.5)"><rect x="240" y="20" width="130" height="260" rx="19.5" ry="19.5" fill="#008a00" stroke="#005700" pointer-events="all" style="fill: rgb(0, 138, 0); stroke: rgb(0, 87, 0);"/></g><g><g><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe flex-start; justify-content: unsafe center; width: 128px; height: 1px; padding-top: 27px; margin-left: 241px;"><div style="box-sizing: border-box; font-size: 0; text-align: center; color: #ffffff; "><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: #ffffff; line-height: 1.2; pointer-events: all; white-space: normal; word-wrap: normal; ">Message Dispatcher</div></div></div></foreignObject><text x="305" y="39" fill="#ffffff" font-family="Helvetica" font-size="12px" text-anchor="middle">Message Dispatcher</text></switch></g></g></g><g data-cell-id="k7scYC8v7eUuEwf4sQOG-6"><g transform="translate(0.5,0.5)"><rect x="250" y="50" width="110" height="140" rx="16.5" ry="16.5" fill="#60a917" stroke="#2d7600" pointer-events="all" style="fill: rgb(96, 169, 23); stroke: rgb(45, 118, 0);"/></g><g><g><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 108px; height: 1px; padding-top: 120px; margin-left: 251px;"><div style="box-sizing: border-box; font-size: 0; text-align: center; color: #ffffff; "><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: #ffffff; line-height: 1.2; pointer-events: all; white-space: normal; word-wrap: normal; ">Event Dispatcher</div></div></div></foreignObject><text x="305" y="124" fill="#ffffff" font-family="Helvetica" font-size="12px" text-anchor="middle">Event Dispatcher</text></switch></g></g></g><g data-cell-id="k7scYC8v7eUuEwf4sQOG-30"><g transform="translate(0.5,0.5)"><path d="M 140 80 L 243.63 80" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="stroke" style="stroke: rgb(255, 255, 255);"/><path d="M 248.88 80 L 241.88 83.5 L 243.63 80 L 241.88 76.5 Z" fill="#000000" stroke="#000000" stroke-miterlimit="10" pointer-events="all" style="fill: rgb(255, 255, 255); stroke: rgb(255, 255, 255);"/></g><g data-cell-id="k7scYC8v7eUuEwf4sQOG-31"><g><g><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 1px; height: 1px; padding-top: 81px; margin-left: 190px;"><div style="box-sizing: border-box; font-size: 0; text-align: center; color: #000000; background-color: #ffffff; "><div style="display: inline-block; font-size: 11px; font-family: Helvetica; color: #ffffff; line-height: 1.2; pointer-events: all; background-color: var(--ge-dark-color, #121212); white-space: nowrap; "> Event X </div></div></div></foreignObject><text x="190" y="84" fill="light-dark(#000000, #ffffff)" font-family="Helvetica" font-size="11px" text-anchor="middle"> Event X </text></switch></g></g></g></g><g data-cell-id="k7scYC8v7eUuEwf4sQOG-7"><g transform="translate(0.5,0.5)"><rect x="20" y="50" width="120" height="60" rx="9" ry="9" fill="#1ba1e2" stroke="#006eaf" pointer-events="all" style="fill: rgb(27, 161, 226); stroke: rgb(0, 110, 175);"/></g><g><g><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 118px; height: 1px; padding-top: 80px; margin-left: 21px;"><div style="box-sizing: border-box; font-size: 0; text-align: center; color: #ffffff; "><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: #ffffff; line-height: 1.2; pointer-events: all; white-space: normal; word-wrap: normal; ">Component A</div></div></div></foreignObject><text x="80" y="84" fill="#ffffff" font-family="Helvetica" font-size="12px" text-anchor="middle">Component A</text></switch></g></g></g><g data-cell-id="k7scYC8v7eUuEwf4sQOG-32"><g transform="translate(0.5,0.5)"><path d="M 140 160.16 L 243.85 160.44" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="stroke" style="stroke: rgb(255, 255, 255);"/><path d="M 249.1 160.46 L 242.09 163.94 L 243.85 160.44 L 242.11 156.94 Z" fill="#000000" stroke="#000000" stroke-miterlimit="10" pointer-events="all" style="fill: rgb(255, 255, 255); stroke: rgb(255, 255, 255);"/></g><g data-cell-id="k7scYC8v7eUuEwf4sQOG-33"><g><g><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 1px; height: 1px; padding-top: 161px; margin-left: 192px;"><div style="box-sizing: border-box; font-size: 0; text-align: center; color: #000000; background-color: #ffffff; "><div style="display: inline-block; font-size: 11px; font-family: Helvetica; color: #ffffff; line-height: 1.2; pointer-events: all; background-color: var(--ge-dark-color, #121212); white-space: nowrap; "> Event Y </div></div></div></foreignObject><text x="192" y="164" fill="light-dark(#000000, #ffffff)" font-family="Helvetica" font-size="11px" text-anchor="middle"> Event Y </text></switch></g></g></g></g><g data-cell-id="k7scYC8v7eUuEwf4sQOG-8"><g transform="translate(0.5,0.5)"><rect x="20" y="130" width="120" height="60" rx="9" ry="9" fill="#1ba1e2" stroke="#006eaf" pointer-events="all" style="fill: rgb(27, 161, 226); stroke: rgb(0, 110, 175);"/></g><g><g><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 118px; height: 1px; padding-top: 160px; margin-left: 21px;"><div style="box-sizing: border-box; font-size: 0; text-align: center; color: #ffffff; "><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: #ffffff; line-height: 1.2; pointer-events: all; white-space: normal; word-wrap: normal; ">Component B</div></div></div></foreignObject><text x="80" y="164" fill="#ffffff" font-family="Helvetica" font-size="12px" text-anchor="middle">Component B</text></switch></g></g></g><g data-cell-id="k7scYC8v7eUuEwf4sQOG-34"><g transform="translate(0.5,0.5)"><path d="M 140 240 L 243.63 240" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="stroke" style="stroke: rgb(255, 255, 255);"/><path d="M 248.88 240 L 241.88 243.5 L 243.63 240 L 241.88 236.5 Z" fill="#000000" stroke="#000000" stroke-miterlimit="10" pointer-events="all" style="fill: rgb(255, 255, 255); stroke: rgb(255, 255, 255);"/></g><g data-cell-id="k7scYC8v7eUuEwf4sQOG-35"><g><g><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 1px; height: 1px; padding-top: 241px; margin-left: 191px;"><div style="box-sizing: border-box; font-size: 0; text-align: center; color: #000000; background-color: #ffffff; "><div style="display: inline-block; font-size: 11px; font-family: Helvetica; color: #ffffff; line-height: 1.2; pointer-events: all; background-color: var(--ge-dark-color, #121212); white-space: nowrap; "> Command Z </div></div></div></foreignObject><text x="191" y="244" fill="light-dark(#000000, #ffffff)" font-family="Helvetica" font-size="11px" text-anchor="middle"> Command Z </text></switch></g></g></g></g><g data-cell-id="k7scYC8v7eUuEwf4sQOG-9"><g transform="translate(0.5,0.5)"><rect x="20" y="210" width="120" height="60" rx="9" ry="9" fill="#1ba1e2" stroke="#006eaf" pointer-events="all" style="fill: rgb(27, 161, 226); stroke: rgb(0, 110, 175);"/></g><g><g><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 118px; height: 1px; padding-top: 240px; margin-left: 21px;"><div style="box-sizing: border-box; font-size: 0; text-align: center; color: #ffffff; "><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: #ffffff; line-height: 1.2; pointer-events: all; white-space: normal; word-wrap: normal; ">Component C</div></div></div></foreignObject><text x="80" y="244" fill="#ffffff" font-family="Helvetica" font-size="12px" text-anchor="middle">Component C</text></switch></g></g></g><g data-cell-id="k7scYC8v7eUuEwf4sQOG-10"><g transform="translate(0.5,0.5)"><rect x="480" y="50" width="120" height="60" rx="9" ry="9" fill="#1ba1e2" stroke="#006eaf" pointer-events="all" style="fill: rgb(27, 161, 226); stroke: rgb(0, 110, 175);"/></g><g><g><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 118px; height: 1px; padding-top: 80px; margin-left: 481px;"><div style="box-sizing: border-box; font-size: 0; text-align: center; color: #ffffff; "><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: #ffffff; line-height: 1.2; pointer-events: all; white-space: normal; word-wrap: normal; ">Component D</div></div></div></foreignObject><text x="540" y="84" fill="#ffffff" font-family="Helvetica" font-size="12px" text-anchor="middle">Component D</text></switch></g></g></g><g data-cell-id="k7scYC8v7eUuEwf4sQOG-11"><g transform="translate(0.5,0.5)"><rect x="480" y="130" width="120" height="60" rx="9" ry="9" fill="#1ba1e2" stroke="#006eaf" pointer-events="all" style="fill: rgb(27, 161, 226); stroke: rgb(0, 110, 175);"/></g><g><g><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 118px; height: 1px; padding-top: 160px; margin-left: 481px;"><div style="box-sizing: border-box; font-size: 0; text-align: center; color: #ffffff; "><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: #ffffff; line-height: 1.2; pointer-events: all; white-space: normal; word-wrap: normal; ">Component E</div></div></div></foreignObject><text x="540" y="164" fill="#ffffff" font-family="Helvetica" font-size="12px" text-anchor="middle">Component E</text></switch></g></g></g><g data-cell-id="k7scYC8v7eUuEwf4sQOG-12"><g transform="translate(0.5,0.5)"><rect x="480" y="210" width="120" height="60" rx="9" ry="9" fill="#1ba1e2" stroke="#006eaf" pointer-events="all" style="fill: rgb(27, 161, 226); stroke: rgb(0, 110, 175);"/></g><g><g><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 118px; height: 1px; padding-top: 240px; margin-left: 481px;"><div style="box-sizing: border-box; font-size: 0; text-align: center; color: #ffffff; "><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: #ffffff; line-height: 1.2; pointer-events: all; white-space: normal; word-wrap: normal; ">Component F</div></div></div></foreignObject><text x="540" y="244" fill="#ffffff" font-family="Helvetica" font-size="12px" text-anchor="middle">Component F</text></switch></g></g></g><g data-cell-id="k7scYC8v7eUuEwf4sQOG-29"><g transform="translate(0.5,0.5)"><rect x="250" y="210" width="110" height="60" rx="9" ry="9" fill="#60a917" stroke="#2d7600" pointer-events="all" style="fill: rgb(96, 169, 23); stroke: rgb(45, 118, 0);"/></g><g><g><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 108px; height: 1px; padding-top: 240px; margin-left: 251px;"><div style="box-sizing: border-box; font-size: 0; text-align: center; color: #ffffff; "><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: #ffffff; line-height: 1.2; pointer-events: all; white-space: normal; word-wrap: normal; ">Command Dispatcher</div></div></div></foreignObject><text x="305" y="244" fill="#ffffff" font-family="Helvetica" font-size="12px" text-anchor="middle">Command Dispatcher</text></switch></g></g></g><g data-cell-id="k7scYC8v7eUuEwf4sQOG-36"><g transform="translate(0.5,0.5)"><path d="M 359.78 80.24 L 473.63 80.01" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="stroke" style="stroke: rgb(255, 255, 255);"/><path d="M 478.88 80 L 471.89 83.52 L 473.63 80.01 L 471.88 76.52 Z" fill="#000000" stroke="#000000" stroke-miterlimit="10" pointer-events="all" style="fill: rgb(255, 255, 255); stroke: rgb(255, 255, 255);"/></g><g data-cell-id="k7scYC8v7eUuEwf4sQOG-37"><g><g><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 1px; height: 1px; padding-top: 81px; margin-left: 420px;"><div style="box-sizing: border-box; font-size: 0; text-align: center; color: #000000; background-color: #ffffff; "><div style="display: inline-block; font-size: 11px; font-family: Helvetica; color: #ffffff; line-height: 1.2; pointer-events: all; background-color: var(--ge-dark-color, #121212); white-space: nowrap; "> Event X </div></div></div></foreignObject><text x="420" y="84" fill="light-dark(#000000, #ffffff)" font-family="Helvetica" font-size="11px" text-anchor="middle"> Event X </text></switch></g></g></g></g><g data-cell-id="k7scYC8v7eUuEwf4sQOG-38"><g transform="translate(0.5,0.5)"><path d="M 360 85 L 474.3 142.15" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="stroke" style="stroke: rgb(255, 255, 255);"/><path d="M 479 144.5 L 471.17 144.5 L 474.3 142.15 L 474.3 138.24 Z" fill="#000000" stroke="#000000" stroke-miterlimit="10" pointer-events="all" style="fill: rgb(255, 255, 255); stroke: rgb(255, 255, 255);"/></g><g data-cell-id="k7scYC8v7eUuEwf4sQOG-39"><g><g transform="rotate(26 396.4735516737496 103.2902527085414)"><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 1px; height: 1px; padding-top: 103px; margin-left: 396px;"><div style="box-sizing: border-box; font-size: 0; text-align: center; color: #000000; background-color: #ffffff; "><div style="display: inline-block; font-size: 11px; font-family: Helvetica; color: #ffffff; line-height: 1.2; pointer-events: all; background-color: var(--ge-dark-color, #121212); white-space: nowrap; "> Event X </div></div></div></foreignObject><text x="396" y="107" fill="light-dark(#000000, #ffffff)" font-family="Helvetica" font-size="11px" text-anchor="middle"> Event X </text></switch></g></g></g></g><g data-cell-id="k7scYC8v7eUuEwf4sQOG-40"><g transform="translate(0.5,0.5)"><path d="M 359.23 159.34 L 473.63 159.97" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="stroke" style="stroke: rgb(255, 255, 255);"/><path d="M 478.88 159.99 L 471.86 163.46 L 473.63 159.97 L 471.9 156.46 Z" fill="#000000" stroke="#000000" stroke-miterlimit="10" pointer-events="all" style="fill: rgb(255, 255, 255); stroke: rgb(255, 255, 255);"/></g><g data-cell-id="k7scYC8v7eUuEwf4sQOG-41"><g><g><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 1px; height: 1px; padding-top: 160px; margin-left: 421px;"><div style="box-sizing: border-box; font-size: 0; text-align: center; color: #000000; background-color: #ffffff; "><div style="display: inline-block; font-size: 11px; font-family: Helvetica; color: #ffffff; line-height: 1.2; pointer-events: all; background-color: var(--ge-dark-color, #121212); white-space: nowrap; "> Event Y </div></div></div></foreignObject><text x="421" y="163" fill="light-dark(#000000, #ffffff)" font-family="Helvetica" font-size="11px" text-anchor="middle"> Event Y </text></switch></g></g></g></g><g data-cell-id="k7scYC8v7eUuEwf4sQOG-42"><g transform="translate(0.5,0.5)"><path d="M 360 155 L 474.3 97.85" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="stroke" style="stroke: rgb(255, 255, 255);"/><path d="M 479 95.5 L 474.3 101.76 L 474.3 97.85 L 471.17 95.5 Z" fill="#000000" stroke="#000000" stroke-miterlimit="10" pointer-events="all" style="fill: rgb(255, 255, 255); stroke: rgb(255, 255, 255);"/></g><g data-cell-id="k7scYC8v7eUuEwf4sQOG-43"><g><g transform="rotate(332 401.9195498018171 135.58506790303932)"><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 1px; height: 1px; padding-top: 136px; margin-left: 402px;"><div style="box-sizing: border-box; font-size: 0; text-align: center; color: #000000; background-color: #ffffff; "><div style="display: inline-block; font-size: 11px; font-family: Helvetica; color: #ffffff; line-height: 1.2; pointer-events: all; background-color: var(--ge-dark-color, #121212); white-space: nowrap; "> Event Y </div></div></div></foreignObject><text x="402" y="139" fill="light-dark(#000000, #ffffff)" font-family="Helvetica" font-size="11px" text-anchor="middle"> Event Y </text></switch></g></g></g></g><g data-cell-id="k7scYC8v7eUuEwf4sQOG-44"><g transform="translate(0.5,0.5)"><path d="M 358.13 239.58 L 473.63 239.98" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="stroke" style="stroke: rgb(255, 255, 255);"/><path d="M 478.88 240 L 471.87 243.47 L 473.63 239.98 L 471.89 236.47 Z" fill="#000000" stroke="#000000" stroke-miterlimit="10" pointer-events="all" style="fill: rgb(255, 255, 255); stroke: rgb(255, 255, 255);"/></g><g data-cell-id="k7scYC8v7eUuEwf4sQOG-45"><g><g><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 1px; height: 1px; padding-top: 240px; margin-left: 421px;"><div style="box-sizing: border-box; font-size: 0; text-align: center; color: #000000; background-color: #ffffff; "><div style="display: inline-block; font-size: 11px; font-family: Helvetica; color: #ffffff; line-height: 1.2; pointer-events: all; background-color: var(--ge-dark-color, #121212); white-space: nowrap; "> Command Z </div></div></div></foreignObject><text x="421" y="244" fill="light-dark(#000000, #ffffff)" font-family="Helvetica" font-size="11px" text-anchor="middle"> Command Z </text></switch></g></g></g></g></g></g></g></svg>
    <figcaption>
        <p>A message dispatcher as a central hub for events and commands</p>
    </figcaption>
</figure>

<p>Internally, the message dispatcher consists of an event dispatcher and a command dispatcher. Both could as well be
components of their own, we&rsquo;ll just put them both into one message dispatcher for simplicity.</p>
<p>Two components A and B, each publishing an event X and Y respectively to the message dispatcher, which in turn
forwards the events to components D, E for them to handle. A component C sends a command Z to the message dispatcher, which
forwards it to component F. Components A, B and C don&rsquo;t know anything about components D, E and F and vice versa. All
they all know of is the message dispatcher, which acts as a kind of switchboard.</p>
<p>Here&rsquo;s a possible implementation in C# - first, we&rsquo;ll create two marker interfaces for events and commands, and then
we&rsquo;ll define interfaces for event and command related functionality:</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-csharp" data-lang="csharp"><span class="line"><span class="cl"><span class="kd">public</span> <span class="k">interface</span> <span class="nc">IEvent</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="kd">public</span> <span class="k">interface</span> <span class="nc">ICommand</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="kd">public</span> <span class="k">interface</span> <span class="nc">IEventDispatcher</span>
</span></span><span class="line"><span class="cl"><span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="k">void</span> <span class="n">Subscribe</span><span class="p">&lt;</span><span class="n">TEvent</span><span class="p">&gt;(</span><span class="n">Action</span><span class="p">&lt;</span><span class="n">TEvent</span><span class="p">&gt;</span> <span class="n">eventHandler</span><span class="p">)</span> <span class="k">where</span> <span class="n">TEvent</span> <span class="p">:</span> <span class="n">IEvent</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="k">void</span> <span class="n">Unsubscribe</span><span class="p">&lt;</span><span class="n">TEvent</span><span class="p">&gt;(</span><span class="n">Action</span><span class="p">&lt;</span><span class="n">TEvent</span><span class="p">&gt;</span> <span class="n">eventHandler</span><span class="p">)</span> <span class="k">where</span> <span class="n">TEvent</span> <span class="p">:</span> <span class="n">IEvent</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="k">void</span> <span class="n">Publish</span><span class="p">&lt;</span><span class="n">TEvent</span><span class="p">&gt;(</span><span class="n">TEvent</span> <span class="n">@event</span><span class="p">)</span> <span class="k">where</span> <span class="n">TEvent</span> <span class="p">:</span> <span class="n">IEvent</span><span class="p">;</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="kd">public</span> <span class="k">interface</span> <span class="nc">ICommandDispatcher</span>
</span></span><span class="line"><span class="cl"><span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="k">void</span> <span class="n">Register</span><span class="p">&lt;</span><span class="n">TCommand</span><span class="p">&gt;(</span><span class="n">Action</span><span class="p">&lt;</span><span class="n">TCommand</span><span class="p">&gt;</span> <span class="n">commandHandler</span><span class="p">)</span> <span class="k">where</span> <span class="n">TCommand</span> <span class="p">:</span> <span class="n">ICommand</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">    <span class="k">void</span> <span class="n">Unregister</span><span class="p">&lt;</span><span class="n">TCommand</span><span class="p">&gt;(</span><span class="n">Action</span><span class="p">&lt;</span><span class="n">TCommand</span><span class="p">&gt;</span> <span class="n">commandHandler</span><span class="p">)</span> <span class="k">where</span> <span class="n">TCommand</span> <span class="p">:</span> <span class="n">ICommand</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">    <span class="k">void</span> <span class="n">Send</span><span class="p">&lt;</span><span class="n">TCommand</span><span class="p">&gt;(</span><span class="n">TCommand</span> <span class="n">command</span><span class="p">)</span> <span class="k">where</span> <span class="n">TCommand</span> <span class="p">:</span> <span class="n">ICommand</span><span class="p">;</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span></code></pre></div><p>Then, we create a combined message dispatcher interface and a concrete implementation:</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-csharp" data-lang="csharp"><span class="line"><span class="cl"><span class="kd">public</span> <span class="k">interface</span> <span class="nc">IMessageDispatcher</span> <span class="p">:</span> <span class="n">IEventDispatcher</span><span class="p">,</span> <span class="n">ICommandDispatcher</span><span class="p">;</span>
</span></span></code></pre></div><div class="highlight"><pre tabindex="0" class="chroma"><code class="language-csharp" data-lang="csharp"><span class="line"><span class="cl"><span class="kd">public</span> <span class="k">class</span> <span class="nc">MessageDispatcher</span> <span class="p">:</span> <span class="n">IMessageDispatcher</span>
</span></span><span class="line"><span class="cl"><span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="kd">private</span> <span class="k">readonly</span> <span class="n">Dictionary</span><span class="p">&lt;</span><span class="n">Type</span><span class="p">,</span> <span class="n">List</span><span class="p">&lt;</span><span class="n">Delegate</span><span class="p">&gt;&gt;</span> <span class="n">_eventHandlers</span> <span class="p">=</span> <span class="k">new</span><span class="p">();</span>
</span></span><span class="line"><span class="cl">    <span class="kd">private</span> <span class="k">readonly</span> <span class="n">Dictionary</span><span class="p">&lt;</span><span class="n">Type</span><span class="p">,</span> <span class="n">Delegate</span><span class="p">&gt;</span> <span class="n">_commandHandlers</span> <span class="p">=</span> <span class="k">new</span><span class="p">();</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="k">void</span> <span class="n">Subscribe</span><span class="p">&lt;</span><span class="n">TEvent</span><span class="p">&gt;(</span><span class="n">Action</span><span class="p">&lt;</span><span class="n">TEvent</span><span class="p">&gt;</span> <span class="n">eventHandler</span><span class="p">)</span> <span class="k">where</span> <span class="n">TEvent</span> <span class="p">:</span> <span class="n">IEvent</span>
</span></span><span class="line"><span class="cl">    <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="kt">var</span> <span class="n">eventType</span> <span class="p">=</span> <span class="k">typeof</span><span class="p">(</span><span class="n">TEvent</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">        <span class="k">if</span> <span class="p">(!</span><span class="n">_eventHandlers</span><span class="p">.</span><span class="n">TryGetValue</span><span class="p">(</span><span class="n">eventType</span><span class="p">,</span> <span class="k">out</span> <span class="kt">var</span> <span class="n">@delegate</span><span class="p">))</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">            <span class="n">@delegate</span> <span class="p">=</span> <span class="p">[];</span>
</span></span><span class="line"><span class="cl">            <span class="n">_eventHandlers</span><span class="p">[</span><span class="n">eventType</span><span class="p">]</span> <span class="p">=</span> <span class="n">@delegate</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">        <span class="p">}</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">        <span class="n">@delegate</span><span class="p">.</span><span class="n">Add</span><span class="p">(</span><span class="n">eventHandler</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="k">void</span> <span class="n">Unsubscribe</span><span class="p">&lt;</span><span class="n">TEvent</span><span class="p">&gt;(</span><span class="n">Action</span><span class="p">&lt;</span><span class="n">TEvent</span><span class="p">&gt;</span> <span class="n">eventHandler</span><span class="p">)</span> <span class="k">where</span> <span class="n">TEvent</span> <span class="p">:</span> <span class="n">IEvent</span>
</span></span><span class="line"><span class="cl">    <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="kt">var</span> <span class="n">eventType</span> <span class="p">=</span> <span class="k">typeof</span><span class="p">(</span><span class="n">TEvent</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">        <span class="k">if</span> <span class="p">(</span><span class="n">_eventHandlers</span><span class="p">.</span><span class="n">TryGetValue</span><span class="p">(</span><span class="n">eventType</span><span class="p">,</span> <span class="k">out</span> <span class="kt">var</span> <span class="n">handlers</span><span class="p">))</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">            <span class="n">handlers</span><span class="p">.</span><span class="n">Remove</span><span class="p">(</span><span class="n">eventHandler</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">        <span class="p">}</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="k">void</span> <span class="n">Publish</span><span class="p">&lt;</span><span class="n">TEvent</span><span class="p">&gt;(</span><span class="n">TEvent</span> <span class="n">@event</span><span class="p">)</span> <span class="k">where</span> <span class="n">TEvent</span> <span class="p">:</span> <span class="n">IEvent</span>
</span></span><span class="line"><span class="cl">    <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="kt">var</span> <span class="n">eventType</span> <span class="p">=</span> <span class="k">typeof</span><span class="p">(</span><span class="n">TEvent</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">        <span class="k">if</span> <span class="p">(!</span><span class="n">_eventHandlers</span><span class="p">.</span><span class="n">TryGetValue</span><span class="p">(</span><span class="n">eventType</span><span class="p">,</span> <span class="k">out</span> <span class="kt">var</span> <span class="n">handlers</span><span class="p">))</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">            <span class="k">return</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">        <span class="p">}</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">        <span class="k">foreach</span> <span class="p">(</span><span class="kt">var</span> <span class="n">handler</span> <span class="k">in</span> <span class="n">handlers</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">            <span class="k">if</span> <span class="p">(</span><span class="n">handler</span> <span class="k">is</span> <span class="n">Action</span><span class="p">&lt;</span><span class="n">TEvent</span><span class="p">&gt;</span> <span class="n">action</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">                <span class="n">action</span><span class="p">(</span><span class="n">@event</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">                <span class="k">continue</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">            <span class="p">}</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">            <span class="c1">// Fallback for when @event is only an IEvent</span>
</span></span><span class="line"><span class="cl">            <span class="n">handler</span><span class="p">.</span><span class="n">DynamicInvoke</span><span class="p">(</span><span class="n">@event</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">        <span class="p">}</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="k">void</span> <span class="n">Register</span><span class="p">&lt;</span><span class="n">TCommand</span><span class="p">&gt;(</span><span class="n">Action</span><span class="p">&lt;</span><span class="n">TCommand</span><span class="p">&gt;</span> <span class="n">commandHandler</span><span class="p">)</span> <span class="k">where</span> <span class="n">TCommand</span> <span class="p">:</span> <span class="n">ICommand</span>
</span></span><span class="line"><span class="cl">    <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="kt">var</span> <span class="n">commandType</span> <span class="p">=</span> <span class="k">typeof</span><span class="p">(</span><span class="n">TCommand</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">        <span class="k">if</span> <span class="p">(!</span><span class="n">_commandHandlers</span><span class="p">.</span><span class="n">TryAdd</span><span class="p">(</span><span class="n">commandType</span><span class="p">,</span> <span class="n">commandHandler</span><span class="p">))</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">            <span class="k">throw</span> <span class="k">new</span> <span class="n">InvalidOperationException</span><span class="p">(</span><span class="s">$&#34;Handler already registered for {commandType.Name}&#34;</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">        <span class="p">}</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="k">void</span> <span class="n">Unregister</span><span class="p">&lt;</span><span class="n">TCommand</span><span class="p">&gt;(</span><span class="n">Action</span><span class="p">&lt;</span><span class="n">TCommand</span><span class="p">&gt;</span> <span class="n">commandHandler</span><span class="p">)</span> <span class="k">where</span> <span class="n">TCommand</span> <span class="p">:</span> <span class="n">ICommand</span>
</span></span><span class="line"><span class="cl">    <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="n">_commandHandlers</span><span class="p">.</span><span class="n">Remove</span><span class="p">(</span><span class="k">typeof</span><span class="p">(</span><span class="n">TCommand</span><span class="p">));</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="k">void</span> <span class="n">Send</span><span class="p">&lt;</span><span class="n">TCommand</span><span class="p">&gt;(</span><span class="n">TCommand</span> <span class="n">command</span><span class="p">)</span> <span class="k">where</span> <span class="n">TCommand</span> <span class="p">:</span> <span class="n">ICommand</span>
</span></span><span class="line"><span class="cl">    <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="kt">var</span> <span class="n">commandType</span> <span class="p">=</span> <span class="k">typeof</span><span class="p">(</span><span class="n">TCommand</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">        <span class="k">if</span> <span class="p">(</span><span class="n">_commandHandlers</span><span class="p">.</span><span class="n">TryGetValue</span><span class="p">(</span><span class="n">commandType</span><span class="p">,</span> <span class="k">out</span> <span class="kt">var</span> <span class="n">handler</span><span class="p">))</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">            <span class="k">if</span> <span class="p">(</span><span class="n">handler</span> <span class="k">is</span> <span class="n">Action</span><span class="p">&lt;</span><span class="n">TCommand</span><span class="p">&gt;</span> <span class="n">action</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">                <span class="n">action</span><span class="p">(</span><span class="n">command</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">                <span class="k">return</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">            <span class="p">}</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">            <span class="c1">// Fallback for when command is only an ICommand</span>
</span></span><span class="line"><span class="cl">            <span class="n">handler</span><span class="p">.</span><span class="n">DynamicInvoke</span><span class="p">(</span><span class="n">command</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">            <span class="k">return</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">        <span class="p">}</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">        <span class="k">throw</span> <span class="k">new</span> <span class="n">InvalidOperationException</span><span class="p">(</span><span class="s">$&#34;No handler registered for command {commandType}&#34;</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span></code></pre></div><h3 id="application">Application</h3>
<p>Now, how can we use this in a game? Let&rsquo;s look at the following example: we want to implement a space shooter where the
player steers a ship which is always on the brink of being damaged by enemy bullets. An enemy ship spawns a bullet, which
hits the player ship. As a result, the player ship loses health points and the bullet is destroyed.</p>
<p>Let&rsquo;s further assume that we organize all our game objects through a scene component, which holds everything together, i.e.
is responsible for spawning and destroying game objects, calling the <code>Update</code> (and <code>Draw</code>) methods, and probably more.</p>
<p>The scene and the game objects know the message dispatcher. The scene also knows the game objects. The game objects,
on the other hand, know nothing about other game objects or the scene. These should remain decoupled. Here is a small
UML diagram that shows the dependencies:</p>
<figure class="center" role="img" aria-label="Message Dispatcher" style="width: 100%">
    <?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
<svg xmlns="http://www.w3.org/2000/svg" style="background: #ffffff; background-color: var(--ge-dark-color, #121212); color-scheme: dark;" xmlns:xlink="http://www.w3.org/1999/xlink" version="1.1" width="381px" height="366px" viewBox="0 0 381 366"><defs/><rect fill="#ffffff" width="100%" height="100%" x="0" y="0" style="fill: var(--ge-dark-color, #121212);"/><g><g data-cell-id="0"><g data-cell-id="1"><g data-cell-id="9fPMvop0K27eDY4zUqDH-1"><g transform="translate(0.5,0.5)"><rect x="240" y="140" width="120" height="60" fill="#ffffff" stroke="#000000" pointer-events="all" style="fill: var(--ge-dark-color, #121212); stroke: rgb(255, 255, 255);"/></g><g><g><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 118px; height: 1px; padding-top: 170px; margin-left: 241px;"><div style="box-sizing: border-box; font-size: 0; text-align: center; color: #000000; "><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: #ffffff; line-height: 1.2; pointer-events: all; white-space: normal; word-wrap: normal; "><div>&lt;&lt;Interface&gt;&gt;</div>IMessageDispatcher</div></div></div></foreignObject><text x="300" y="174" fill="light-dark(#000000, #ffffff)" font-family="Helvetica" font-size="12px" text-anchor="middle">&lt;&lt;Interface&gt;&gt;IMessag...</text></switch></g></g></g><g data-cell-id="9fPMvop0K27eDY4zUqDH-2"><g transform="translate(0.5,0.5)"><rect x="240" y="20" width="120" height="60" fill="#ffffff" stroke="#000000" pointer-events="all" style="fill: var(--ge-dark-color, #121212); stroke: rgb(255, 255, 255);"/></g><g><g><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 118px; height: 1px; padding-top: 50px; margin-left: 241px;"><div style="box-sizing: border-box; font-size: 0; text-align: center; color: #000000; "><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: #ffffff; line-height: 1.2; pointer-events: all; white-space: normal; word-wrap: normal; ">MessageDispatcher</div></div></div></foreignObject><text x="300" y="54" fill="light-dark(#000000, #ffffff)" font-family="Helvetica" font-size="12px" text-anchor="middle">MessageDispatcher</text></switch></g></g></g><g data-cell-id="9fPMvop0K27eDY4zUqDH-3"><g transform="translate(0.5,0.5)"><rect x="20" y="140" width="120" height="60" fill="#ffffff" stroke="#000000" pointer-events="all" style="fill: var(--ge-dark-color, #121212); stroke: rgb(255, 255, 255);"/></g><g><g><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 118px; height: 1px; padding-top: 170px; margin-left: 21px;"><div style="box-sizing: border-box; font-size: 0; text-align: center; color: #000000; "><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: #ffffff; line-height: 1.2; pointer-events: all; white-space: normal; word-wrap: normal; ">Scene</div></div></div></foreignObject><text x="80" y="174" fill="light-dark(#000000, #ffffff)" font-family="Helvetica" font-size="12px" text-anchor="middle">Scene</text></switch></g></g></g><g data-cell-id="9fPMvop0K27eDY4zUqDH-4"><g transform="translate(0.5,0.5)"><rect x="20" y="285" width="120" height="60" fill="#ffffff" stroke="#000000" pointer-events="all" style="fill: var(--ge-dark-color, #121212); stroke: rgb(255, 255, 255);"/></g><g><g><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 118px; height: 1px; padding-top: 315px; margin-left: 21px;"><div style="box-sizing: border-box; font-size: 0; text-align: center; color: #000000; "><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: #ffffff; line-height: 1.2; pointer-events: all; white-space: normal; word-wrap: normal; "><div>&lt;&lt;abstract&gt;&gt;</div>GameObject</div></div></div></foreignObject><text x="80" y="319" fill="light-dark(#000000, #ffffff)" font-family="Helvetica" font-size="12px" text-anchor="middle">&lt;&lt;abstract&gt;&gt;GameObje...</text></switch></g></g></g><g data-cell-id="9fPMvop0K27eDY4zUqDH-5"><g transform="translate(0.5,0.5)"><path d="M 300 80 L 300 125.88" fill="none" stroke="#000000" stroke-miterlimit="10" stroke-dasharray="3 3" pointer-events="stroke" style="stroke: rgb(255, 255, 255);"/><path d="M 300 138.88 L 293.5 125.88 L 306.5 125.88 Z" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="all" style="stroke: rgb(255, 255, 255);"/></g></g><g data-cell-id="9fPMvop0K27eDY4zUqDH-6"><g transform="translate(0.5,0.5)"><path d="M 80 215.99 L 80 282.76" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="stroke" style="stroke: rgb(255, 255, 255);"/><path d="M 80 200.99 L 84.41 208.49 L 80 215.99 L 75.59 208.49 Z" fill="#000000" stroke="#000000" stroke-miterlimit="10" pointer-events="all" style="fill: rgb(255, 255, 255); stroke: rgb(255, 255, 255);"/><path d="M 73.5 270.88 L 80 283.88 L 86.5 270.88" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="all" style="stroke: rgb(255, 255, 255);"/></g><g><g><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe flex-end; justify-content: unsafe flex-start; width: 1px; height: 1px; padding-top: 215px; margin-left: 93px;"><div style="box-sizing: border-box; font-size: 0; text-align: left; color: #000000; background-color: #ffffff; "><div style="display: inline-block; font-size: 11px; font-family: Helvetica; color: #ffffff; line-height: 1.2; pointer-events: all; background-color: var(--ge-dark-color, #121212); white-space: nowrap; ">1</div></div></div></foreignObject><text x="93" y="215" fill="light-dark(#000000, #ffffff)" font-family="Helvetica" font-size="11px">1</text></switch></g></g></g><g data-cell-id="9fPMvop0K27eDY4zUqDH-7"><g transform="translate(0.5,0.5)"><rect x="73" y="259" width="60" height="30" fill="none" stroke="none" pointer-events="all"/></g><g><g><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 58px; height: 1px; padding-top: 274px; margin-left: 74px;"><div style="box-sizing: border-box; font-size: 0; text-align: center; color: #000000; "><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: #ffffff; line-height: 1.2; pointer-events: all; white-space: normal; word-wrap: normal; ">0..*</div></div></div></foreignObject><text x="103" y="278" fill="light-dark(#000000, #ffffff)" font-family="Helvetica" font-size="12px" text-anchor="middle">0..*</text></switch></g></g></g><g data-cell-id="9fPMvop0K27eDY4zUqDH-8"><g transform="translate(0.5,0.5)"><path d="M 140 170 L 231.88 170" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="stroke" style="stroke: rgb(255, 255, 255);"/><path d="M 238.88 170 L 231.88 173.5 L 231.88 166.5 Z" fill="#000000" stroke="#000000" stroke-miterlimit="10" pointer-events="all" style="fill: rgb(255, 255, 255); stroke: rgb(255, 255, 255);"/></g></g><g data-cell-id="9fPMvop0K27eDY4zUqDH-10"><g transform="translate(0.5,0.5)"><path d="M 140 315 L 300 315 L 300 208.12" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="stroke" style="stroke: rgb(255, 255, 255);"/><path d="M 300 201.12 L 303.5 208.12 L 296.5 208.12 Z" fill="#000000" stroke="#000000" stroke-miterlimit="10" pointer-events="all" style="fill: rgb(255, 255, 255); stroke: rgb(255, 255, 255);"/></g></g></g></g></g></svg>
    <figcaption>
        <p>Message Dispatcher</p>
    </figcaption>
</figure>

<p>Now, let&rsquo;s look at the example above regarding the player ship being damaged by enemy bullets. We have the following commands:</p>
<ul>
<li><code>SpawnBulletCommand</code> - this command is sent to the message dispatcher when a bullet should be spawned and added to the scene.</li>
<li><code>DestroyBulletCommand</code> - this command is sent to the message dispatcher when a bullet should be destroyed and removed from the scene.</li>
</ul>
<p>Then, we have the following event:</p>
<ul>
<li><code>HealthChangedEvent</code> - this event is published when the player ship&rsquo;s health points change.</li>
</ul>
<p>The collision between the enemy bullet and the player ship could also be seen as an event, however, we&rsquo;ll leave that out
of our example and simply assume that the bullet and the ship are notified about their collision by some sort of collision
detection system.</p>
<p>Below is a sequence diagram showing a possible sequence of steps for the example above. Since the message dispatcher is a central
component, it is highlighted with a green background. Click image to enlarge.</p>




<figure style="margin: 0; display: block;">
    <a href="/https/shendriks.dev/posts/2025-05-10-loosely-coupled-game-architecture-with-events-and-commands/index-4.svg" class="diagram-dark">
        <img src="/https/shendriks.dev/posts/2025-05-10-loosely-coupled-game-architecture-with-events-and-commands/index-4.svg" alt="Sequence Diagram" class="diagram" />
    </a>
    
    <a href="/https/shendriks.dev/posts/2025-05-10-loosely-coupled-game-architecture-with-events-and-commands/index-4-light.svg" class="diagram-light">
        <img src="/https/shendriks.dev/posts/2025-05-10-loosely-coupled-game-architecture-with-events-and-commands/index-4-light.svg" alt="Sequence Diagram" class="diagram" />
    </a>
    
    <figcaption><p>A sequence diagram showing the flow of commands and events</p></figcaption>
</figure>
<p>To keep the diagram from getting even more cluttered, we&rsquo;ll omit the details of registering and subscribing to commands
and events.</p>
<p>The steps in detail:</p>
<ol>
<li>At some point an enemy ship sends a <code>SpawnBulletCommand</code> to the message dispatcher</li>
<li>The message dispatcher calls the scene&rsquo;s handler for the <code>SpawnBulletCommand</code></li>
<li>The scene spawns an enemy bullet and adds it to the list of game objects</li>
<li>A few frames later, the enemy bullet collides with the player ship</li>
<li>The bullet sends a <code>DestroyBulletCommand</code> to the message dispatcher …</li>
<li>… which in turn calls the scene&rsquo;s handler for removing the bullet from the scene</li>
<li>The bullet is removed from the scene</li>
<li>Then, the player ship loses health points …</li>
<li>… and publishes a <code>HealthChangedEvent</code></li>
<li>The message dispatcher calls the HUD&rsquo;s handler …</li>
<li>… for updating the health bar</li>
<li>The message dispatcher calls the audio player&rsquo;s handler …</li>
<li>… for playing the sound when health points have changed</li>
</ol>
<p>Note that there is only one handler for the command, but two handlers for the event.</p>
<p>Now, let&rsquo;s whip up a few classes, all boiled down to the absolute minimum. First, we need a command for spawning bullets at
a certain position and a command for destroying bullets and removing them from the scene:</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-csharp" data-lang="csharp"><span class="line"><span class="cl"><span class="kd">public</span> <span class="k">class</span> <span class="nc">SpawnBulletCommand</span> <span class="p">:</span> <span class="n">ICommand</span>
</span></span><span class="line"><span class="cl"><span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="n">required</span> <span class="n">Vector2</span> <span class="n">Position</span> <span class="p">{</span> <span class="k">get</span><span class="p">;</span> <span class="k">init</span><span class="p">;</span> <span class="p">}</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="kd">public</span> <span class="k">class</span> <span class="nc">DestroyBulletCommand</span> <span class="p">:</span> <span class="n">ICommand</span>
</span></span><span class="line"><span class="cl"><span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="n">required</span> <span class="n">GameObject</span> <span class="n">Bullet</span> <span class="p">{</span> <span class="k">get</span><span class="p">;</span> <span class="k">init</span><span class="p">;</span> <span class="p">}</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span></code></pre></div><p>Next, we need an event for when the player ship loses health points:</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-csharp" data-lang="csharp"><span class="line"><span class="cl"><span class="kd">public</span> <span class="k">class</span> <span class="nc">HealthChangedEvent</span> <span class="p">:</span> <span class="n">IEvent</span>
</span></span><span class="line"><span class="cl"><span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="n">required</span> <span class="kt">int</span> <span class="n">Health</span> <span class="p">{</span> <span class="k">get</span><span class="p">;</span> <span class="k">init</span><span class="p">;</span> <span class="p">}</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span></code></pre></div><p>Then we need an abstract base class for game objects. A game object needs a position in the game world, and it needs a
reference to the message dispatcher to be able to send commands, publish events, but also to be able to subscribe to events, should the
need arise:</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-csharp" data-lang="csharp"><span class="line"><span class="cl"><span class="kd">public</span> <span class="kd">abstract</span> <span class="k">class</span> <span class="nc">GameObject</span><span class="p">(</span><span class="n">IMessageDispatcher</span> <span class="n">messageDispatcher</span><span class="p">)</span>
</span></span><span class="line"><span class="cl"><span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="kd">protected</span> <span class="n">IMessageDispatcher</span> <span class="n">MessageDispatcher</span> <span class="p">=&gt;</span> <span class="n">messageDispatcher</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="n">Vector2</span> <span class="n">Position</span> <span class="p">{</span> <span class="k">get</span><span class="p">;</span> <span class="k">set</span><span class="p">;</span> <span class="p">}</span>
</span></span><span class="line"><span class="cl">    
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="k">virtual</span> <span class="k">void</span> <span class="n">Update</span><span class="p">(</span><span class="n">GameTime</span> <span class="n">gameTime</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">    <span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl">    
</span></span><span class="line"><span class="cl">    <span class="c1">// ...</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span></code></pre></div><p>Now that we have a base class for game objects, we can define concrete classes for our game objects.
Let&rsquo;s begin with an interface that defines the contract for game objects that can deal damage, like enemy bullets:</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-csharp" data-lang="csharp"><span class="line"><span class="cl"><span class="kd">public</span> <span class="k">interface</span> <span class="nc">IDamaging</span>
</span></span><span class="line"><span class="cl"><span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="kt">int</span> <span class="n">Damage</span> <span class="p">{</span> <span class="k">get</span><span class="p">;</span> <span class="p">}</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span></code></pre></div><p>Now the concrete game objects:</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-csharp" data-lang="csharp"><span class="line"><span class="cl"><span class="kd">public</span> <span class="k">class</span> <span class="nc">EnemyShip</span><span class="p">(</span><span class="n">IMessageDispatcher</span> <span class="n">messageDispatcher</span><span class="p">)</span> <span class="p">:</span> <span class="n">GameObject</span><span class="p">(</span><span class="n">messageDispatcher</span><span class="p">)</span>
</span></span><span class="line"><span class="cl"><span class="p">{</span>   
</span></span><span class="line"><span class="cl">    <span class="kd">private</span> <span class="kt">float</span> <span class="n">_coolDown</span> <span class="p">=</span> <span class="m">2000f</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">     
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="kd">override</span> <span class="k">void</span> <span class="n">Update</span><span class="p">(</span><span class="n">GameTime</span> <span class="n">gameTime</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">    <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="c1">// Spawn a bullet every two seconds</span>
</span></span><span class="line"><span class="cl">        
</span></span><span class="line"><span class="cl">        <span class="n">_coolDown</span> <span class="p">-=</span> <span class="n">gameTime</span><span class="p">.</span><span class="n">ElapsedGameTime</span><span class="p">.</span><span class="n">TotalMilliseconds</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">        
</span></span><span class="line"><span class="cl">        <span class="k">if</span> <span class="p">(</span><span class="n">_coolDown</span> <span class="p">&lt;=</span> <span class="m">0</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">            <span class="n">_coolDown</span> <span class="p">=</span> <span class="m">2000f</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">            <span class="n">MessageDispatcher</span><span class="p">.</span><span class="n">Send</span><span class="p">(</span><span class="k">new</span> <span class="n">SpawnBulletCommand</span> <span class="p">{</span> <span class="n">Position</span> <span class="p">=</span> <span class="n">Position</span> <span class="p">});</span>
</span></span><span class="line"><span class="cl">        <span class="p">}</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="kd">public</span> <span class="k">class</span> <span class="nc">EnemyBullet</span><span class="p">(</span><span class="n">IMessageDispatcher</span> <span class="n">messageDispatcher</span><span class="p">)</span> <span class="p">:</span> <span class="n">GameObject</span><span class="p">(</span><span class="n">messageDispatcher</span><span class="p">),</span> <span class="n">IDamaging</span>
</span></span><span class="line"><span class="cl"><span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="kt">int</span> <span class="n">Damage</span> <span class="p">=&gt;</span> <span class="m">10</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">    
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="kd">override</span> <span class="k">void</span> <span class="n">Update</span><span class="p">(</span><span class="n">GameTime</span> <span class="n">gameTime</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">    <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="c1">// move bullet</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl">    
</span></span><span class="line"><span class="cl">    <span class="c1">// This method is called magically by some sort of collision detection system</span>
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="k">void</span> <span class="n">OnCollisionEnter</span><span class="p">(</span><span class="n">GameObject</span> <span class="n">_</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">    <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="n">MessageDispatcher</span><span class="p">.</span><span class="n">Send</span><span class="p">(</span><span class="k">new</span> <span class="n">DestroyBulletCommand</span> <span class="p">{</span> <span class="n">Bullet</span> <span class="p">=</span> <span class="k">this</span> <span class="p">});</span>  
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="kd">public</span> <span class="k">class</span> <span class="nc">Ship</span><span class="p">(</span><span class="n">IMessageDispatcher</span> <span class="n">messageDispatcher</span><span class="p">)</span> <span class="p">:</span> <span class="n">GameObject</span><span class="p">(</span><span class="n">messageDispatcher</span><span class="p">)</span>
</span></span><span class="line"><span class="cl"><span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="kd">private</span> <span class="kt">int</span> <span class="n">_health</span> <span class="p">=</span> <span class="m">100</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">    
</span></span><span class="line"><span class="cl">    <span class="c1">// This method is called magically by some sort of collision detection system</span>
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="k">void</span> <span class="n">OnCollisionEnter</span><span class="p">(</span><span class="n">GameObject</span> <span class="n">other</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">    <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="k">if</span> <span class="p">(</span><span class="n">other</span> <span class="k">is</span> <span class="n">IDamaging</span> <span class="n">damaging</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">            <span class="n">_health</span> <span class="p">-=</span> <span class="n">damaging</span><span class="p">.</span><span class="n">Damage</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">            <span class="n">MessageDispatcher</span><span class="p">.</span><span class="n">Publish</span><span class="p">(</span><span class="k">new</span> <span class="n">HealthChangedEvent</span> <span class="p">{</span> <span class="n">Health</span> <span class="p">=</span> <span class="n">_health</span> <span class="p">});</span>
</span></span><span class="line"><span class="cl">            
</span></span><span class="line"><span class="cl">            <span class="k">if</span> <span class="p">(</span><span class="n">_health</span> <span class="p">&lt;=</span> <span class="m">0</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">                <span class="c1">// Game Over</span>
</span></span><span class="line"><span class="cl">            <span class="p">}</span>       
</span></span><span class="line"><span class="cl">        <span class="p">}</span>                
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span></code></pre></div><p>Every two seconds, the enemy ship’s <code>Update</code> method sends a <code>SpawnBulletCommand</code> to the message dispatcher. We hand of the task of
creating bullets to somewhere else, we needn&rsquo;t bother with this here. Later we&rsquo;ll look at how to handle bullet spawning.</p>
<p>Let&rsquo;s look at the <code>EnemyBullet</code> class next. It has a method <code>OnCollisionEnter</code> that is called magically by some sort of
collision detection system, and which is responsible for handling collisions. If the bullet collides with anything,
we want it destroyed. To do that, we send a <code>DestroyBulletCommand</code> to the message dispatcher.</p>
<p>Then, there is the <code>Ship</code> class which represents the player ship. It too has a method <code>OnCollisionEnter</code> that is called
by a collision detection system. On collision it checks whether the other object is damaging, and if so, decreases the
ship&rsquo;s health and publishes a <code>HealthChangedEvent</code> event with the current health as payload.</p>
<p>Next, we need classes for the HUD, the audio player, and the scene that holds it all together:</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-csharp" data-lang="csharp"><span class="line"><span class="cl"><span class="kd">public</span> <span class="k">class</span> <span class="nc">HUD</span>
</span></span><span class="line"><span class="cl"><span class="p">{</span>    
</span></span><span class="line"><span class="cl">    <span class="kd">private</span> <span class="kt">int</span> <span class="n">_playerHealth</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">    
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="n">HUD</span><span class="p">(</span><span class="n">IMessageDispatcher</span> <span class="n">messageDispatcher</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">    <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="n">messageDispatcher</span><span class="p">.</span><span class="n">Subscribe</span><span class="p">&lt;</span><span class="n">HealthChangedEvent</span><span class="p">&gt;(</span><span class="n">OnHealthChanged</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>   
</span></span><span class="line"><span class="cl">    
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="k">void</span> <span class="n">OnHealthChanged</span><span class="p">(</span><span class="n">HealthChangedEvent</span> <span class="n">@event</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">    <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="n">_playerHealth</span> <span class="p">=</span> <span class="n">@event</span><span class="p">.</span><span class="n">Health</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl">    
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="k">void</span> <span class="n">Draw</span><span class="p">()</span>
</span></span><span class="line"><span class="cl">    <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="c1">// draw health bar</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="kd">public</span> <span class="k">class</span> <span class="nc">AudioPlayer</span>
</span></span><span class="line"><span class="cl"><span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="n">AudioPlayer</span><span class="p">(</span><span class="n">IMessageDispatcher</span> <span class="n">messageDispatcher</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">    <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="n">messageDispatcher</span><span class="p">.</span><span class="n">Subscribe</span><span class="p">&lt;</span><span class="n">HealthChangedEvent</span><span class="p">&gt;(</span><span class="n">OnHealthChanged</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl">    
</span></span><span class="line"><span class="cl">    <span class="kd">private</span> <span class="k">void</span> <span class="n">OnHealthChanged</span><span class="p">(</span><span class="n">HealthChangedEvent</span> <span class="n">@event</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">    <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="c1">// play health changed sound</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="kd">public</span> <span class="k">class</span> <span class="nc">Scene</span>
</span></span><span class="line"><span class="cl"><span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="kd">private</span> <span class="k">readonly</span> <span class="n">IMessageDispatcher</span> <span class="n">_messageDispatcher</span> <span class="p">=</span> <span class="k">new</span> <span class="n">MessageDispatcher</span><span class="p">();</span>
</span></span><span class="line"><span class="cl">    <span class="kd">private</span> <span class="k">readonly</span> <span class="n">HUD</span> <span class="n">_hud</span> <span class="p">=</span> <span class="k">new</span> <span class="n">HUD</span><span class="p">(</span><span class="n">_messageDispatcher</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">    <span class="kd">private</span> <span class="k">readonly</span> <span class="n">AudioPlayer</span> <span class="n">_audioPlayer</span> <span class="p">=</span> <span class="k">new</span> <span class="n">AudioPlayer</span><span class="p">(</span><span class="n">_messageDispatcher</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">    <span class="kd">private</span> <span class="k">readonly</span> <span class="n">List</span><span class="p">&lt;</span><span class="n">GameObject</span><span class="p">&gt;</span> <span class="n">_gameObjects</span> <span class="p">=</span> <span class="p">[];</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="n">Scene</span><span class="p">()</span>
</span></span><span class="line"><span class="cl">    <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="n">_gameObjects</span><span class="p">.</span><span class="n">Add</span><span class="p">(</span><span class="k">new</span> <span class="n">PlayerShip</span><span class="p">(</span><span class="n">_messageDispatcher</span><span class="p">));</span>
</span></span><span class="line"><span class="cl">        
</span></span><span class="line"><span class="cl">        <span class="n">_messageDispatcher</span><span class="p">.</span><span class="n">Register</span><span class="p">&lt;</span><span class="n">SpawnBulletCommand</span><span class="p">&gt;(</span><span class="n">SpawnBullet</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">        <span class="n">_messageDispatcher</span><span class="p">.</span><span class="n">Register</span><span class="p">&lt;</span><span class="n">DestroyBulletCommand</span><span class="p">&gt;(</span><span class="n">DestroyBullet</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="kd">private</span> <span class="k">void</span> <span class="n">SpawnBullet</span><span class="p">(</span><span class="n">SpawnBulletCommand</span> <span class="n">command</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">    <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="kt">var</span> <span class="n">bullet</span> <span class="p">=</span> <span class="k">new</span> <span class="n">Bullet</span><span class="p">(</span><span class="n">_messageDispatcher</span><span class="p">)</span> <span class="p">{</span> 
</span></span><span class="line"><span class="cl">            <span class="n">Position</span> <span class="p">=</span> <span class="n">@event</span><span class="p">.</span><span class="n">Position</span> 
</span></span><span class="line"><span class="cl">        <span class="p">};</span>
</span></span><span class="line"><span class="cl">        <span class="n">AddGameObjectToScene</span><span class="p">(</span><span class="n">bullet</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl">    
</span></span><span class="line"><span class="cl">    <span class="kd">private</span> <span class="k">void</span> <span class="n">DestroyBullet</span><span class="p">(</span><span class="n">DestroyBulletCommand</span> <span class="n">command</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">    <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="n">RemoveGameObjectFromScene</span><span class="p">(</span><span class="n">command</span><span class="p">.</span><span class="n">Bullet</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="k">void</span> <span class="n">Update</span><span class="p">(</span><span class="n">GameTime</span> <span class="n">gameTime</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">    <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="c1">// Update game objects</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl">    
</span></span><span class="line"><span class="cl">    <span class="kd">private</span> <span class="k">void</span> <span class="n">AddGameObjectToScene</span><span class="p">(</span><span class="n">GameObject</span> <span class="n">gameObject</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">    <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="c1">// Add game object</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl">    
</span></span><span class="line"><span class="cl">    <span class="kd">private</span> <span class="k">void</span> <span class="n">RemoveGameObjectFromScene</span><span class="p">(</span><span class="n">GameObject</span> <span class="n">gameObject</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">    <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="c1">// Remove game object</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span></code></pre></div><p>Both the HUD and the audio player register handlers for the <code>HealthChangedEvent</code>: the HUD updates the health bar, and the
audio player plays a sound effect. And that&rsquo;s essentially it.</p>
<h2 id="conclusion">Conclusion</h2>
<p>The message dispatcher helps keep your game components loosely coupled by centralizing communication. Instead of direct
dependencies, components publish and subscribe to events, and send and register for commands, making the codebase easier
to manage. This pattern isn&rsquo;t a silver bullet, but it&rsquo;s a practical way to reduce complexity as your game logic grows.</p>
]]></content></item><item><title>Framework-Independent Game Logic with Hexagonal Architecture</title><link>https://shendriks.dev/posts/2024-12-30-making-game-logic-framework-independent-with-hexagonal-architecture/</link><pubDate>Mon, 30 Dec 2024 00:00:00 +0000</pubDate><guid>https://shendriks.dev/posts/2024-12-30-making-game-logic-framework-independent-with-hexagonal-architecture/</guid><description>Implementing a classic table tennis game using MonoGame, but making it so, that the game logic is independent of the framework using Hexagonal Architecture.</description><content type="html"><![CDATA[<h2 id="introduction">Introduction</h2>
<p>Usually, when making a game, there are lots of great frameworks out there that help you get off the ground quickly.
We don&rsquo;t want to reinvent the wheel every time we make a game, right? Frameworks usually do all the &ldquo;dirty&rdquo; low-level
heavy lifting for us, so we can focus on the game logic and the fun stuff. And that&rsquo;s fine!</p>
<p>However, when using a framework, the game logic often gets tightly coupled to it. This isn&rsquo;t necessarily a
bad thing, but it can make it difficult to write tests for the game logic. Another downside is that it can be
quite difficult to switch to another framework later on, should we wish to do so.</p>
<p>So, how can we make a game that is easy to test and that is not tightly coupled to a specific framework? In this blog
post, we&rsquo;re going to take a look at hexagonal architecture and how we can use it to make the game logic framework-independent.
As an example, we&rsquo;ll implement a video game that simulates table tennis with weird gravity. Yes, yes, it&rsquo;s not
going to be a super elaborated example, but it should be enough to illustrate the concept. We&rsquo;re going to use <a href="https://github.com/kniEngine/kni"
    
    
      target="_blank" class="external-link"
    
>Kni</a>
 for that,
a <a href="https://github.com/MonoGame/MonoGame"
    
    
      target="_blank" class="external-link"
    
>MonoGame</a>
 derivative with WebGL support.</p>
<h2 id="dependencies-and-coupling">Dependencies and Coupling</h2>
<p>First of all, what is a dependency and what is meant by coupling? In easy terms, a dependency is when one module uses
some other module. A module can be a class, for example. Dependencies also have a direction. If module A uses module B,
then module A depends on module B. Hence, it is coupled to module B. Coupling is the degree to which module A is dependent on
module B.</p>
<p>Dependencies aren&rsquo;t bad, per se. In fact, we need them to build software. The challenge is to get our dependencies &ldquo;right&rdquo;
and the coupling &ldquo;loose&rdquo;.</p>
<p>When making a new game (or any piece of software, really) using a framework, it is very easy to couple the game logic to
the framework. The game logic becomes dependent on the framework, it can&rsquo;t &ldquo;work on its own&rdquo; anymore.</p>
<h3 id="example">Example</h3>
<p>Here&rsquo;s an example I stumbled upon during my own endeavours.
Let&rsquo;s say we&rsquo;re writing a game that uses MonoGame. Let&rsquo;s further assume we&rsquo;re writing a class for some game object,
like a paddle. One thing we surely need is a sprite to draw the paddle on the screen. Let&rsquo;s inject one in form of a <code>Texture2D</code>
object to the constructor.</p>
<p>And there we have it, we can&rsquo;t just unit test this class anymore, because we need a <code>Texture2D</code> object to instantiate
an object of this class. And we can&rsquo;t instantiate a <code>Texture2D</code> object without a <code>GraphicsDevice</code> object. And we can&rsquo;t
instantiate a <code>GraphicsDevice</code> object without a <code>GraphicsAdapter</code> object. And so on and so forth.</p>
<p>Ok, let&rsquo;s setter-inject the <code>Texture2D</code> object then and only set it when we need it. This allows us to instantiate an
object of this class without a <code>Texture2D</code> object, but we then have a nullable property in our class that we have to check
every time we want to use it to make sure it&rsquo;s not null.  Then, if it is null, what do we do? Is it an error? Should we
throw an exception? Should we ignore it? Should we use some kind of default <code>Texture2D</code> object? Then, where does that come from?</p>
<p>&ldquo;But, I need the <code>Texture2D</code> object to draw that paddle on the screen!&rdquo;, you might say. And you&rsquo;re right. At some point,
somewhere, we&rsquo;re going to need that <code>Texture2D</code> object. But do we need it in the game logic? It&rsquo;s a framework specific
thing, not a game logic one, isn&rsquo;t it?</p>
<div class="notice note" >
    <p class="notice-title">
        <span class="icon-notice baseline">
            <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 128 300 300">
  <path d="M150 128c82.813 0 150 67.188 150 150 0 82.813-67.188 150-150 150C67.187 428 0 360.812 0 278c0-82.813 67.188-150 150-150Zm25 243.555v-37.11c0-3.515-2.734-6.445-6.055-6.445h-37.5c-3.515 0-6.445 2.93-6.445 6.445v37.11c0 3.515 2.93 6.445 6.445 6.445h37.5c3.32 0 6.055-2.93 6.055-6.445Zm-.39-67.188 3.515-121.289c0-1.367-.586-2.734-1.953-3.516-1.172-.976-2.93-1.562-4.688-1.562h-42.968c-1.758 0-3.516.586-4.688 1.563-1.367.78-1.953 2.148-1.953 3.515l3.32 121.29c0 2.734 2.93 4.882 6.64 4.882h36.134c3.515 0 6.445-2.148 6.64-4.883Z"/>
</svg>

        </span>Note</p><p>Don&rsquo;t get me wrong, it&rsquo;s not my intention to bash MonoGame. It&rsquo;s a great framework and I like building things with it! 😻</p></div>

<h2 id="hexagonal-architecture">Hexagonal Architecture</h2>
<h3 id="quick-overview">Quick Overview</h3>
<p><a href="https://en.wikipedia.org/wiki/Hexagonal_architecture_%28software%29"
    
    
      target="_blank" class="external-link"
    
>Hexagonal Architecture</a>
, also known as Ports and Adapters,
is an architectural pattern that helps to structure the software so that the core logic is at the center and is independent
on any external things. Instead, the core logic defines so-called ports (e.g. interfaces) for interacting
with the outside world. The outside world in turn implements adapters that serve as the glue between the core logic and the outside world.</p>
<p>There are two types of ports: driving and driven ports. The driving ports are used by the outside to call into the core
logic, while the driven ports are used by the core to call out to the outside world. The outside world can be anything,
like a database, a web service, or a game framework.</p>
<div class="notice note" >
    <p class="notice-title">
        <span class="icon-notice baseline">
            <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 128 300 300">
  <path d="M150 128c82.813 0 150 67.188 150 150 0 82.813-67.188 150-150 150C67.187 428 0 360.812 0 278c0-82.813 67.188-150 150-150Zm25 243.555v-37.11c0-3.515-2.734-6.445-6.055-6.445h-37.5c-3.515 0-6.445 2.93-6.445 6.445v37.11c0 3.515 2.93 6.445 6.445 6.445h37.5c3.32 0 6.055-2.93 6.055-6.445Zm-.39-67.188 3.515-121.289c0-1.367-.586-2.734-1.953-3.516-1.172-.976-2.93-1.562-4.688-1.562h-42.968c-1.758 0-3.516.586-4.688 1.563-1.367.78-1.953 2.148-1.953 3.515l3.32 121.29c0 2.734 2.93 4.882 6.64 4.882h36.134c3.515 0 6.445-2.148 6.64-4.883Z"/>
</svg>

        </span>Note</p><p>If you want to learn more about Hexagonal Architecture, I recommend
this <a href="https://www.youtube.com/watch?v=k0ykTxw7s0Y"
    
    
      target="_blank" class="external-link"
    
>talk on YouTube</a>
 by the creator Alistair Cockburn himself.</p></div>

<h3 id="applying-hexagonal-architecture-to-our-game">Applying Hexagonal Architecture to Our Game</h3>
<p>Now, let&rsquo;s think of our little game, what ports do we probably need? What&rsquo;s needed to run a game? At the heart of every
game is something which is called the <a href="https://gameprogrammingpatterns.com/game-loop.html"
    
    
      target="_blank" class="external-link"
    
>game loop</a>
 - Quote:</p>
<blockquote>
<p>A game loop runs continuously during gameplay. Each turn of the loop, it processes user input without blocking,
updates the game state, and renders the game. It tracks the passage of time to control the rate of gameplay.</p>
</blockquote>
<p>So, we&rsquo;ll need at least one driving port for the game logic to be called from the outside. Next, we&rsquo;ll need driven ports
for reading input, rendering, and playing sounds. The following diagram illustrates this:</p>
<figure class="center"><img src="/https/shendriks.dev/posts/2024-12-30-making-game-logic-framework-independent-with-hexagonal-architecture/images/architecture.svg"
			alt="Hexagonal Architecture"><figcaption>
			<p>Hexagonal Architecture</p>
		</figcaption>
</figure>

<p>That means we have four interfaces that are <strong>defined in the game logic</strong> (not the other way around).</p>
<h4 id="the-driving-port">The Driving Port</h4>
<p>Let&rsquo;s start with the driving port. For that, we&rsquo;ll define an interface and give it a talking name: <code>IForRunningTheGame</code>.
Because it is a driving port, the interface will also be implemented in the game logic.
Thus, the interface is going to have methods for the outside world to call into our game logic, e.g. <code>Update</code> and <code>Draw</code>:</p>
<div class="notice note" >
    <p class="notice-title">
        <span class="icon-notice baseline">
            <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 128 300 300">
  <path d="M150 128c82.813 0 150 67.188 150 150 0 82.813-67.188 150-150 150C67.187 428 0 360.812 0 278c0-82.813 67.188-150 150-150Zm25 243.555v-37.11c0-3.515-2.734-6.445-6.055-6.445h-37.5c-3.515 0-6.445 2.93-6.445 6.445v37.11c0 3.515 2.93 6.445 6.445 6.445h37.5c3.32 0 6.055-2.93 6.055-6.445Zm-.39-67.188 3.515-121.289c0-1.367-.586-2.734-1.953-3.516-1.172-.976-2.93-1.562-4.688-1.562h-42.968c-1.758 0-3.516.586-4.688 1.563-1.367.78-1.953 2.148-1.953 3.515l3.32 121.29c0 2.734 2.93 4.882 6.64 4.882h36.134c3.515 0 6.445-2.148 6.64-4.883Z"/>
</svg>

        </span>Note</p><p>You can find the full source code of the game on <a href="https://github.com/shendriks/clong"
    
    
      target="_blank" class="external-link"
    
>GitHub</a>
.</p></div>

<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-csharp" data-lang="csharp"><span class="line"><span class="cl"><span class="k">using</span> <span class="nn">Clong.Core.Domain.Dto</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="k">namespace</span> <span class="nn">Clong.Core.Ports.Driving</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="kd">public</span> <span class="k">interface</span> <span class="nc">IForRunningTheGame</span>
</span></span><span class="line"><span class="cl"><span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="k">void</span> <span class="n">Update</span><span class="p">(</span><span class="n">GameTime</span> <span class="n">gameTime</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="k">void</span> <span class="n">Draw</span><span class="p">();</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span></code></pre></div><p>The implementation looks like this:</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-csharp" data-lang="csharp"><span class="line"><span class="cl"><span class="k">using</span> <span class="nn">Clong.Core.Domain.Dto</span><span class="p">;</span>
</span></span><span class="line"><span class="cl"><span class="k">using</span> <span class="nn">Clong.Core.Ports.Driving</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="k">namespace</span> <span class="nn">Clong.Core.Domain</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="kd">public</span> <span class="k">class</span> <span class="nc">Clong</span><span class="p">(</span> <span class="cm">/* ... */</span> <span class="p">)</span> <span class="p">:</span> <span class="n">IForRunningTheGame</span>
</span></span><span class="line"><span class="cl"><span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="k">void</span> <span class="n">Update</span><span class="p">(</span><span class="n">GameTime</span> <span class="n">gameTime</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">    <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="c1">// 1. Read input [*]</span>
</span></span><span class="line"><span class="cl">        <span class="c1">// 2. Update game state</span>
</span></span><span class="line"><span class="cl">        <span class="c1">// 3. Play sounds [*]</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="k">void</span> <span class="n">Draw</span><span class="p">()</span>
</span></span><span class="line"><span class="cl">    <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="c1">// 1. Render game objects [*]</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl">    
</span></span><span class="line"><span class="cl">    <span class="c1">// [*] Hint: There&#39;re driven ports for these!</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span></code></pre></div><p>You&rsquo;ll notice that the <code>Update</code> method takes a <code>GameTime</code> object as an argument. It&rsquo;s important to note that <strong>this isn&rsquo;t
the MonoGame <code>GameTime</code> object</strong>, but a custom one that we define in the game logic. We don&rsquo;t want to depend on any classes
defined by the framework. Here&rsquo;s our definition of <code>GameTime</code>:</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-csharp" data-lang="csharp"><span class="line"><span class="cl"><span class="k">namespace</span> <span class="nn">Clong.Core.Domain.Dto</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="kd">public</span> <span class="k">class</span> <span class="nc">GameTime</span>
</span></span><span class="line"><span class="cl"><span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="n">required</span> <span class="n">TimeSpan</span> <span class="n">DeltaTime</span> <span class="p">{</span> <span class="kd">internal</span> <span class="k">get</span><span class="p">;</span> <span class="k">init</span><span class="p">;</span> <span class="p">}</span>
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="n">required</span> <span class="n">TimeSpan</span> <span class="n">TotalTime</span> <span class="p">{</span> <span class="kd">internal</span> <span class="k">get</span><span class="p">;</span> <span class="k">init</span><span class="p">;</span> <span class="p">}</span>
</span></span><span class="line"><span class="cl">    <span class="kd">internal</span> <span class="kt">float</span> <span class="n">TotalSeconds</span> <span class="p">=&gt;</span> <span class="p">(</span><span class="kt">float</span><span class="p">)</span><span class="n">TotalTime</span><span class="p">.</span><span class="n">TotalSeconds</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">    <span class="kd">internal</span> <span class="kt">float</span> <span class="n">DeltaSeconds</span> <span class="p">=&gt;</span> <span class="p">(</span><span class="kt">float</span><span class="p">)</span><span class="n">DeltaTime</span><span class="p">.</span><span class="n">TotalSeconds</span><span class="p">;</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span></code></pre></div><p>As you can image, we&rsquo;ll need something on the framework side that translates the framework&rsquo;s <code>GameTime</code> object to our own, and
then calls our <code>Update</code> method with it. That sounds like an adapter:</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-csharp" data-lang="csharp"><span class="line"><span class="cl"><span class="k">using</span> <span class="nn">Clong.Core.Ports.Driving</span><span class="p">;</span>
</span></span><span class="line"><span class="cl"><span class="k">using</span> <span class="nn">Microsoft.Xna.Framework</span><span class="p">;</span>
</span></span><span class="line"><span class="cl"><span class="k">using</span> <span class="nn">DomainGameTime</span> <span class="p">=</span> <span class="n">Clong</span><span class="p">.</span><span class="n">Core</span><span class="p">.</span><span class="n">Domain</span><span class="p">.</span><span class="n">Dto</span><span class="p">.</span><span class="n">GameTime</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="k">namespace</span> <span class="nn">Clong.Kni.Adapter.Driving</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="kd">public</span> <span class="k">class</span> <span class="nc">GameController</span><span class="p">(</span><span class="n">IForRunningTheGame</span> <span class="n">game</span><span class="p">)</span>
</span></span><span class="line"><span class="cl"><span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="k">void</span> <span class="n">Update</span><span class="p">(</span><span class="n">GameTime</span> <span class="n">gameTime</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">    <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="n">game</span><span class="p">.</span><span class="n">Update</span><span class="p">(</span>
</span></span><span class="line"><span class="cl">            <span class="k">new</span> <span class="n">DomainGameTime</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">                <span class="n">DeltaTime</span> <span class="p">=</span> <span class="n">gameTime</span><span class="p">.</span><span class="n">ElapsedGameTime</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">                <span class="n">TotalTime</span> <span class="p">=</span> <span class="n">gameTime</span><span class="p">.</span><span class="n">TotalGameTime</span>
</span></span><span class="line"><span class="cl">            <span class="p">}</span>
</span></span><span class="line"><span class="cl">        <span class="p">);</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="k">void</span> <span class="n">Draw</span><span class="p">()</span>
</span></span><span class="line"><span class="cl">    <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="n">game</span><span class="p">.</span><span class="n">Draw</span><span class="p">();</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span></code></pre></div><p>The call to <code>Draw</code> is simply delegated to the game logic without any arguments.
&ldquo;But, where&rsquo;s the <code>SpriteBatch</code>?&rdquo;, you might ask. We&rsquo;ll come to that in a second.</p>
<h4 id="the-driven-ports">The Driven Ports</h4>
<p>On the driven side we need interfaces for reading input, rendering, and playing sounds. These interfaces are implemented
in the adapter component.</p>
<h5 id="reading-input">Reading Input</h5>
<p>Let&rsquo;s start with the input:</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-csharp" data-lang="csharp"><span class="line"><span class="cl"><span class="k">using</span> <span class="nn">Clong.Core.Domain.Input</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="k">namespace</span> <span class="nn">Clong.Core.Ports.Driven</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="kd">public</span> <span class="k">interface</span> <span class="nc">IForReadingInput</span>
</span></span><span class="line"><span class="cl"><span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="n">InputState</span> <span class="n">ReadInput</span><span class="p">();</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span></code></pre></div><p>The <code>InputState</code> object is a simple DTO that holds the state of the input devices, like pressed keys on the keyboard:</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-csharp" data-lang="csharp"><span class="line"><span class="cl"><span class="k">using</span> <span class="nn">Clong.Core.Domain.Enum</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="k">namespace</span> <span class="nn">Clong.Core.Domain.Input</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="kd">public</span> <span class="k">class</span> <span class="nc">InputState</span>
</span></span><span class="line"><span class="cl"><span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="n">required</span> <span class="n">Key</span><span class="p">[]</span> <span class="n">PressedKeys</span> <span class="p">{</span> <span class="k">get</span><span class="p">;</span> <span class="k">init</span><span class="p">;</span> <span class="p">}</span>
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="n">required</span> <span class="n">Key</span><span class="p">[]</span> <span class="n">PreviouslyPressedKeys</span> <span class="p">{</span> <span class="k">get</span><span class="p">;</span> <span class="k">init</span><span class="p">;</span> <span class="p">}</span>
</span></span><span class="line"><span class="cl">    <span class="kd">internal</span> <span class="kt">bool</span> <span class="n">IsKeyDown</span><span class="p">(</span><span class="n">Key</span> <span class="n">key</span><span class="p">)</span> <span class="p">=&gt;</span> <span class="n">PressedKeys</span><span class="p">.</span><span class="n">Contains</span><span class="p">(</span><span class="n">key</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">    <span class="kd">internal</span> <span class="kt">bool</span> <span class="n">WasKeyPressedInThisFrame</span><span class="p">(</span><span class="n">Key</span> <span class="n">key</span><span class="p">)</span> <span class="p">=&gt;</span> <span class="n">PressedKeys</span><span class="p">.</span><span class="n">Contains</span><span class="p">(</span><span class="n">key</span><span class="p">)</span> <span class="p">&amp;&amp;</span> <span class="p">!</span><span class="n">PreviouslyPressedKeys</span><span class="p">.</span><span class="n">Contains</span><span class="p">(</span><span class="n">key</span><span class="p">);</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span></code></pre></div><p>So, what&rsquo;s this <code>Key</code> class? It&rsquo;s an enum that defines the keys, which is basically a copy of the <code>Keys</code> enum from MonoGame:</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-csharp" data-lang="csharp"><span class="line"><span class="cl"><span class="k">namespace</span> <span class="nn">Clong.Core.Domain.Enum</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="kd">public</span> <span class="kd">enum</span> <span class="n">Key</span>
</span></span><span class="line"><span class="cl"><span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="c1">// ...</span>
</span></span><span class="line"><span class="cl">    
</span></span><span class="line"><span class="cl">    <span class="n">Left</span> <span class="p">=</span> <span class="m">37</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">    <span class="n">Up</span> <span class="p">=</span> <span class="m">38</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">    <span class="n">Right</span> <span class="p">=</span> <span class="m">39</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">    <span class="n">Down</span> <span class="p">=</span> <span class="m">40</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">    
</span></span><span class="line"><span class="cl">    <span class="c1">// ...</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span></code></pre></div><p>Yes, it&rsquo;s bit &ldquo;ugly&rdquo; that we have to define our own <code>Key</code> enum, but again, it&rsquo;s necessary and a price we have to pay to
decouple the game logic from the framework.</p>
<p>Let&rsquo;s look at the implementation of the <code>IForReadingInput</code> interface:</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-csharp" data-lang="csharp"><span class="line"><span class="cl"><span class="k">using</span> <span class="nn">Clong.Core.Domain.Input</span><span class="p">;</span>
</span></span><span class="line"><span class="cl"><span class="k">using</span> <span class="nn">Clong.Core.Ports.Driven</span><span class="p">;</span>
</span></span><span class="line"><span class="cl"><span class="k">using</span> <span class="nn">Microsoft.Xna.Framework.Input</span><span class="p">;</span>
</span></span><span class="line"><span class="cl"><span class="k">using</span> <span class="nn">DomainKey</span> <span class="p">=</span> <span class="n">Clong</span><span class="p">.</span><span class="n">Core</span><span class="p">.</span><span class="n">Domain</span><span class="p">.</span><span class="n">Enum</span><span class="p">.</span><span class="n">Key</span><span class="p">;</span>
</span></span><span class="line"><span class="cl"><span class="k">using</span> <span class="nn">MonoGameKey</span> <span class="p">=</span> <span class="n">Microsoft</span><span class="p">.</span><span class="n">Xna</span><span class="p">.</span><span class="n">Framework</span><span class="p">.</span><span class="n">Input</span><span class="p">.</span><span class="n">Keys</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="k">namespace</span> <span class="nn">Clong.Kni.Adapter.Driven.Input</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="kd">public</span> <span class="k">class</span> <span class="nc">InputReader</span> <span class="p">:</span> <span class="n">IForReadingInput</span>
</span></span><span class="line"><span class="cl"><span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="kd">private</span> <span class="kd">static</span> <span class="k">readonly</span> <span class="n">KeyMap</span> <span class="n">KeyMap</span> <span class="p">=</span> <span class="k">new</span><span class="p">();</span>
</span></span><span class="line"><span class="cl">    <span class="kd">private</span> <span class="n">DomainKey</span><span class="p">[]</span> <span class="n">_pressedDomainKeys</span> <span class="p">=</span> <span class="p">[];</span>
</span></span><span class="line"><span class="cl">    <span class="kd">private</span> <span class="n">DomainKey</span><span class="p">[]</span> <span class="n">_previouslyPressedDomainKeys</span> <span class="p">=</span> <span class="p">[];</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="n">InputState</span> <span class="n">ReadInput</span><span class="p">()</span>
</span></span><span class="line"><span class="cl">    <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="kt">var</span> <span class="n">pressedMonoGameKeys</span> <span class="p">=</span> <span class="n">Keyboard</span><span class="p">.</span><span class="n">GetState</span><span class="p">().</span><span class="n">GetPressedKeys</span><span class="p">();</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">        <span class="n">_previouslyPressedDomainKeys</span> <span class="p">=</span> <span class="n">_pressedDomainKeys</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">        <span class="n">_pressedDomainKeys</span> <span class="p">=</span> <span class="n">MapToDomainKeys</span><span class="p">(</span><span class="n">pressedMonoGameKeys</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">        <span class="k">return</span> <span class="k">new</span> <span class="n">InputState</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">            <span class="n">PressedKeys</span> <span class="p">=</span> <span class="n">_pressedDomainKeys</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">            <span class="n">PreviouslyPressedKeys</span> <span class="p">=</span> <span class="n">_previouslyPressedDomainKeys</span>
</span></span><span class="line"><span class="cl">        <span class="p">};</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="kd">private</span> <span class="kd">static</span> <span class="n">DomainKey</span><span class="p">[]</span> <span class="n">MapToDomainKeys</span><span class="p">(</span><span class="n">MonoGameKey</span><span class="p">[]</span> <span class="n">keys</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">    <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="kt">var</span> <span class="n">pressedDomainKeys</span> <span class="p">=</span> <span class="k">new</span> <span class="n">DomainKey</span><span class="p">[</span><span class="n">keys</span><span class="p">.</span><span class="n">Length</span><span class="p">];</span>
</span></span><span class="line"><span class="cl">        <span class="k">for</span> <span class="p">(</span><span class="kt">var</span> <span class="n">i</span> <span class="p">=</span> <span class="m">0</span><span class="p">;</span> <span class="n">i</span> <span class="p">&lt;</span> <span class="n">keys</span><span class="p">.</span><span class="n">Length</span><span class="p">;</span> <span class="n">i</span><span class="p">++)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">            <span class="n">pressedDomainKeys</span><span class="p">[</span><span class="n">i</span><span class="p">]</span> <span class="p">=</span> <span class="n">KeyMap</span><span class="p">[</span><span class="n">keys</span><span class="p">[</span><span class="n">i</span><span class="p">]];</span>
</span></span><span class="line"><span class="cl">        <span class="p">}</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">        <span class="k">return</span> <span class="n">pressedDomainKeys</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span></code></pre></div><p>Yes, even a bit more &ldquo;ugly&rdquo;, we need a <code>KeyMap</code> to map the MonoGame keys to our own keys:</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-csharp" data-lang="csharp"><span class="line"><span class="cl"><span class="k">using</span> <span class="nn">DomainKey</span> <span class="p">=</span> <span class="n">Clong</span><span class="p">.</span><span class="n">Core</span><span class="p">.</span><span class="n">Domain</span><span class="p">.</span><span class="n">Enum</span><span class="p">.</span><span class="n">Key</span><span class="p">;</span>
</span></span><span class="line"><span class="cl"><span class="k">using</span> <span class="nn">MonoGameKey</span> <span class="p">=</span> <span class="n">Microsoft</span><span class="p">.</span><span class="n">Xna</span><span class="p">.</span><span class="n">Framework</span><span class="p">.</span><span class="n">Input</span><span class="p">.</span><span class="n">Keys</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="k">namespace</span> <span class="nn">Clong.Kni.Adapter.Driven.Input</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="kd">public</span> <span class="k">class</span> <span class="nc">KeyMap</span>
</span></span><span class="line"><span class="cl"><span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="n">DomainKey</span> <span class="k">this</span><span class="p">[</span><span class="n">MonoGameKey</span> <span class="n">monoGameKey</span><span class="p">]</span> <span class="p">=&gt;</span> <span class="n">Map</span><span class="p">[</span><span class="n">monoGameKey</span><span class="p">];</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="kd">private</span> <span class="kd">static</span> <span class="k">readonly</span> <span class="n">Dictionary</span><span class="p">&lt;</span><span class="n">MonoGameKey</span><span class="p">,</span> <span class="n">DomainKey</span><span class="p">&gt;</span> <span class="n">Map</span> <span class="p">=</span> <span class="k">new</span><span class="p">()</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="c1">// ...</span>
</span></span><span class="line"><span class="cl">        
</span></span><span class="line"><span class="cl">        <span class="p">{</span> <span class="n">MonoGameKey</span><span class="p">.</span><span class="n">Left</span><span class="p">,</span> <span class="n">DomainKey</span><span class="p">.</span><span class="n">Left</span> <span class="p">},</span>
</span></span><span class="line"><span class="cl">        <span class="p">{</span> <span class="n">MonoGameKey</span><span class="p">.</span><span class="n">Up</span><span class="p">,</span> <span class="n">DomainKey</span><span class="p">.</span><span class="n">Up</span> <span class="p">},</span>
</span></span><span class="line"><span class="cl">        <span class="p">{</span> <span class="n">MonoGameKey</span><span class="p">.</span><span class="n">Right</span><span class="p">,</span> <span class="n">DomainKey</span><span class="p">.</span><span class="n">Right</span> <span class="p">},</span>
</span></span><span class="line"><span class="cl">        <span class="p">{</span> <span class="n">MonoGameKey</span><span class="p">.</span><span class="n">Down</span><span class="p">,</span> <span class="n">DomainKey</span><span class="p">.</span><span class="n">Down</span> <span class="p">},</span>
</span></span><span class="line"><span class="cl">        
</span></span><span class="line"><span class="cl">        <span class="c1">// ...</span>
</span></span><span class="line"><span class="cl">    <span class="p">};</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span></code></pre></div><h5 id="rendering">Rendering</h5>
<p>Next, the game logic needs a way to render the game objects. For that, we define the <code>IForRendering</code> interface:</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-csharp" data-lang="csharp"><span class="line"><span class="cl"><span class="k">using</span> <span class="nn">System.Numerics</span><span class="p">;</span>
</span></span><span class="line"><span class="cl"><span class="k">using</span> <span class="nn">Clong.Core.Domain.Enum</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="k">namespace</span> <span class="nn">Clong.Core.Ports.Driven</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="kd">public</span> <span class="k">interface</span> <span class="nc">IForRendering</span>
</span></span><span class="line"><span class="cl"><span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="k">void</span> <span class="n">DrawTexture</span><span class="p">(</span><span class="n">TextureId</span> <span class="n">texture</span><span class="p">,</span> <span class="n">Vector2</span> <span class="n">position</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">    
</span></span><span class="line"><span class="cl">    <span class="c1">// ...    </span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span></code></pre></div><p>Let&rsquo;s have a look at the <code>DrawTexture</code> method. It takes a <code>TextureId</code> enum and a <code>Vector2</code> object
(a <code>System.Numerics</code> one, not a MonoGame one) as arguments. The <code>TextureId</code> enum defines all the different textures
used in the game and is later used to identify which <code>Texture2D</code> to draw.</p>
<p>(We&rsquo;re also going to need to draw some text, but I leave that out for brevity - this blog post is already getting a bit
long 🙂).</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-csharp" data-lang="csharp"><span class="line"><span class="cl"><span class="k">namespace</span> <span class="nn">Clong.Core.Domain.Enum</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="kd">public</span> <span class="kd">enum</span> <span class="n">TextureId</span>
</span></span><span class="line"><span class="cl"><span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="n">Ball</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">    <span class="n">PaddleL</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">    <span class="n">PaddleR</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">    <span class="n">Star</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span></code></pre></div><p>The <code>IForRendering</code> interface is implemented in the adapter component:</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-csharp" data-lang="csharp"><span class="line"><span class="cl"><span class="k">using</span> <span class="nn">Clong.Core.Domain.Enum</span><span class="p">;</span>
</span></span><span class="line"><span class="cl"><span class="k">using</span> <span class="nn">Clong.Core.Ports.Driven</span><span class="p">;</span>
</span></span><span class="line"><span class="cl"><span class="k">using</span> <span class="nn">Microsoft.Xna.Framework</span><span class="p">;</span>
</span></span><span class="line"><span class="cl"><span class="k">using</span> <span class="nn">Microsoft.Xna.Framework.Graphics</span><span class="p">;</span>
</span></span><span class="line"><span class="cl"><span class="k">using</span> <span class="nn">Vector2</span> <span class="p">=</span> <span class="n">Microsoft</span><span class="p">.</span><span class="n">Xna</span><span class="p">.</span><span class="n">Framework</span><span class="p">.</span><span class="n">Vector2</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="k">namespace</span> <span class="nn">Clong.Kni.Adapter.Driven.Rendering</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="kd">public</span> <span class="k">class</span> <span class="nc">Renderer</span><span class="p">(</span><span class="n">SpriteBatch</span> <span class="n">spriteBatch</span><span class="p">,</span> <span class="n">TextureMap</span> <span class="n">textureMap</span> <span class="cm">/* ... */</span> <span class="p">)</span> <span class="p">:</span> <span class="n">IForRendering</span>
</span></span><span class="line"><span class="cl"><span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="k">void</span> <span class="n">DrawTexture</span><span class="p">(</span><span class="n">TextureId</span> <span class="n">texture</span><span class="p">,</span> <span class="n">System</span><span class="p">.</span><span class="n">Numerics</span><span class="p">.</span><span class="n">Vector2</span> <span class="n">position</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">    <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="kt">var</span> <span class="n">texture2D</span> <span class="p">=</span> <span class="n">textureMap</span><span class="p">[</span><span class="n">texture</span><span class="p">];</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">        <span class="n">spriteBatch</span><span class="p">.</span><span class="n">Draw</span><span class="p">(</span>
</span></span><span class="line"><span class="cl">            <span class="n">texture2D</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">            <span class="k">new</span> <span class="n">Vector2</span><span class="p">(</span><span class="n">position</span><span class="p">.</span><span class="n">X</span><span class="p">,</span> <span class="n">position</span><span class="p">.</span><span class="n">Y</span><span class="p">),</span>
</span></span><span class="line"><span class="cl">            <span class="kc">null</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">            <span class="n">Color</span><span class="p">.</span><span class="n">White</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">            <span class="m">0</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">            <span class="k">new</span> <span class="n">Vector2</span><span class="p">(</span><span class="n">texture2D</span><span class="p">.</span><span class="n">Width</span> <span class="p">/</span> <span class="m">2f</span><span class="p">,</span> <span class="n">texture2D</span><span class="p">.</span><span class="n">Height</span> <span class="p">/</span> <span class="m">2f</span><span class="p">),</span>
</span></span><span class="line"><span class="cl">            <span class="n">Vector2</span><span class="p">.</span><span class="n">One</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">            <span class="n">SpriteEffects</span><span class="p">.</span><span class="n">None</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">            <span class="m">0f</span>
</span></span><span class="line"><span class="cl">        <span class="p">);</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="c1">// ...</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span></code></pre></div><p>The implementation depends on a <code>SpriteBatch</code> object (there you go), and a <code>TextureMap</code> object.
The <code>TextureMap</code> object is a simple dictionary that maps the <code>TextureId</code> enum to the <code>Texture2D</code> objects:</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-csharp" data-lang="csharp"><span class="line"><span class="cl"><span class="k">using</span> <span class="nn">Clong.Core.Domain.Enum</span><span class="p">;</span>
</span></span><span class="line"><span class="cl"><span class="k">using</span> <span class="nn">Microsoft.Xna.Framework.Graphics</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="k">namespace</span> <span class="nn">Clong.Kni.Adapter.Driven.Rendering</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="kd">public</span> <span class="k">class</span> <span class="nc">TextureMap</span>
</span></span><span class="line"><span class="cl"><span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="kd">private</span> <span class="k">readonly</span> <span class="n">Dictionary</span><span class="p">&lt;</span><span class="n">TextureId</span><span class="p">,</span> <span class="n">Texture2D</span><span class="p">&gt;</span> <span class="n">_textures</span> <span class="p">=</span> <span class="k">new</span><span class="p">();</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="n">Texture2D</span> <span class="k">this</span><span class="p">[</span><span class="n">TextureId</span> <span class="n">t</span><span class="p">]</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="k">get</span> <span class="p">=&gt;</span> <span class="n">_textures</span><span class="p">[</span><span class="n">t</span><span class="p">];</span>
</span></span><span class="line"><span class="cl">        <span class="k">init</span> <span class="p">=&gt;</span> <span class="n">_textures</span><span class="p">[</span><span class="n">t</span><span class="p">]</span> <span class="p">=</span> <span class="k">value</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span></code></pre></div><p>So, in the adapter world we have something along the lines of:</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-csharp" data-lang="csharp"><span class="line"><span class="cl"><span class="k">namespace</span> <span class="nn">Clong.Kni.Adapter</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="kd">public</span> <span class="k">class</span> <span class="nc">MainGame</span> <span class="p">:</span> <span class="n">Game</span>
</span></span><span class="line"><span class="cl"><span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="c1">// ...</span>
</span></span><span class="line"><span class="cl">    
</span></span><span class="line"><span class="cl">    <span class="kd">protected</span> <span class="kd">override</span> <span class="k">void</span> <span class="n">LoadContent</span><span class="p">()</span>
</span></span><span class="line"><span class="cl">    <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="kt">var</span> <span class="n">textureMap</span> <span class="p">=</span> <span class="k">new</span> <span class="n">TextureMap</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl"><span class="na">            [TextureId.Ball]</span> <span class="p">=</span> <span class="n">Content</span><span class="p">.</span><span class="n">Load</span><span class="p">&lt;</span><span class="n">Texture2D</span><span class="p">&gt;(</span><span class="s">&#34;Textures/ball&#34;</span><span class="p">),</span>
</span></span><span class="line"><span class="cl"><span class="na">            [TextureId.PaddleL]</span> <span class="p">=</span> <span class="n">Content</span><span class="p">.</span><span class="n">Load</span><span class="p">&lt;</span><span class="n">Texture2D</span><span class="p">&gt;(</span><span class="s">&#34;Textures/paddle1&#34;</span><span class="p">),</span>
</span></span><span class="line"><span class="cl"><span class="na">            [TextureId.PaddleR]</span> <span class="p">=</span> <span class="n">Content</span><span class="p">.</span><span class="n">Load</span><span class="p">&lt;</span><span class="n">Texture2D</span><span class="p">&gt;(</span><span class="s">&#34;Textures/paddle2&#34;</span><span class="p">),</span>
</span></span><span class="line"><span class="cl"><span class="na">            [TextureId.Star]</span> <span class="p">=</span> <span class="n">Content</span><span class="p">.</span><span class="n">Load</span><span class="p">&lt;</span><span class="n">Texture2D</span><span class="p">&gt;(</span><span class="s">&#34;Textures/star&#34;</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">        <span class="p">};</span>
</span></span><span class="line"><span class="cl">        
</span></span><span class="line"><span class="cl">        <span class="c1">// ...</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl">    
</span></span><span class="line"><span class="cl">    <span class="c1">// ...   </span>
</span></span><span class="line"><span class="cl"> <span class="p">}</span>
</span></span></code></pre></div><h5 id="playing-sounds">Playing Sounds</h5>
<p>Finally, we need a way to play sounds. For that, we define the <code>IForPlayingSounds</code> interface:</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-csharp" data-lang="csharp"><span class="line"><span class="cl"><span class="k">using</span> <span class="nn">Clong.Core.Domain.Enum</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="k">namespace</span> <span class="nn">Clong.Core.Ports.Driven</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="kd">public</span> <span class="k">interface</span> <span class="nc">IForPlayingSound</span>
</span></span><span class="line"><span class="cl"><span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="k">void</span> <span class="n">PlaySound</span><span class="p">(</span><span class="n">SoundId</span> <span class="n">soundId</span><span class="p">);</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span></code></pre></div><p>The <code>SoundId</code> enum is similar to the <code>TextureId</code> enum and defines all the different sounds used in the game logic:</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-csharp" data-lang="csharp"><span class="line"><span class="cl"><span class="k">using</span> <span class="nn">Clong.Core.Domain.Enum</span><span class="p">;</span>
</span></span><span class="line"><span class="cl"><span class="k">using</span> <span class="nn">Microsoft.Xna.Framework.Audio</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="k">namespace</span> <span class="nn">Clong.Kni.Adapter.Driven.Sound</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="kd">public</span> <span class="k">class</span> <span class="nc">SoundMap</span>
</span></span><span class="line"><span class="cl"><span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="kd">private</span> <span class="k">readonly</span> <span class="n">Dictionary</span><span class="p">&lt;</span><span class="n">SoundId</span><span class="p">,</span> <span class="n">SoundEffect</span><span class="p">&gt;</span> <span class="n">_sounds</span> <span class="p">=</span> <span class="k">new</span><span class="p">();</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="n">SoundEffect</span> <span class="k">this</span><span class="p">[</span><span class="n">SoundId</span> <span class="n">t</span><span class="p">]</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="k">get</span> <span class="p">=&gt;</span> <span class="n">_sounds</span><span class="p">[</span><span class="n">t</span><span class="p">];</span>
</span></span><span class="line"><span class="cl">        <span class="k">init</span> <span class="p">=&gt;</span> <span class="n">_sounds</span><span class="p">[</span><span class="n">t</span><span class="p">]</span> <span class="p">=</span> <span class="k">value</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span></code></pre></div><p>The implementation of the interface is also quite simple:</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-csharp" data-lang="csharp"><span class="line"><span class="cl"><span class="k">using</span> <span class="nn">Clong.Core.Domain.Enum</span><span class="p">;</span>
</span></span><span class="line"><span class="cl"><span class="k">using</span> <span class="nn">Clong.Core.Ports.Driven</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="k">namespace</span> <span class="nn">Clong.Kni.Adapter.Driven.Sound</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="kd">public</span> <span class="k">class</span> <span class="nc">SoundEffectPlayer</span><span class="p">(</span><span class="n">SoundMap</span> <span class="n">soundMap</span><span class="p">)</span> <span class="p">:</span> <span class="n">IForPlayingSound</span>
</span></span><span class="line"><span class="cl"><span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="k">void</span> <span class="n">PlaySound</span><span class="p">(</span><span class="n">SoundId</span> <span class="n">soundId</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">    <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="kt">var</span> <span class="n">soundEffect</span> <span class="p">=</span> <span class="n">soundMap</span><span class="p">[</span><span class="n">soundId</span><span class="p">];</span>
</span></span><span class="line"><span class="cl">        <span class="n">soundEffect</span><span class="p">.</span><span class="n">Play</span><span class="p">();</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span></code></pre></div><p>So much for the ports. Let&rsquo;s step back a bit and take a look at the two control flows:</p>
<h4 id="control-flows">Control Flows</h4>
<p><div class="flex-container">
<figure class="flex-item flex-item-2"><img src="/https/shendriks.dev/posts/2024-12-30-making-game-logic-framework-independent-with-hexagonal-architecture/images/control-flow-for-update.svg"
			alt="Control Flow for Update" width="100%"><figcaption>
			<p>Control Flow for Update</p>
		</figcaption>
</figure>

<figure class="flex-item flex-item-2"><img src="/https/shendriks.dev/posts/2024-12-30-making-game-logic-framework-independent-with-hexagonal-architecture/images/control-flow-for-draw.svg"
			alt="Control Flow for Draw" width="100%"><figcaption>
			<p>Control Flow for Draw</p>
		</figcaption>
</figure>

</div></p>
<p>Both control flows start in the adapter component. The <code>GameController</code> object calls the <code>Update</code> method on the game logic.
The game logic then reads the input, updates the game state, and plays sounds.</p>
<p>The <code>Draw</code> method is called in a similar way. The game logic renders the game objects, which are then drawn by the <code>Renderer</code> object.</p>
<h4 id="lets-fill-in-the-gaps-in-the-game-logic">Let&rsquo;s Fill In the Gaps in the Game Logic</h4>
<p>Our game logic class <code>Clong</code> needs to know about the driven ports. We&rsquo;ll inject them into the constructor. Also, let&rsquo;s
add a paddle to illustrate how things are coming together:</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-csharp" data-lang="csharp"><span class="line"><span class="cl"><span class="k">using</span> <span class="nn">Clong.Core.Domain.Dto</span><span class="p">;</span>
</span></span><span class="line"><span class="cl"><span class="k">using</span> <span class="nn">Clong.Core.Ports.Driven</span><span class="p">;</span>
</span></span><span class="line"><span class="cl"><span class="k">using</span> <span class="nn">Clong.Core.Ports.Driving</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="k">namespace</span> <span class="nn">Clong.Core.Domain</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="kd">public</span> <span class="k">class</span> <span class="nc">Clong</span><span class="p">(</span>
</span></span><span class="line"><span class="cl">    <span class="n">IForReadingInput</span> <span class="n">inputReader</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">    <span class="n">IForRendering</span> <span class="n">renderer</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">    <span class="n">IForPlayingSound</span> <span class="n">soundPlayer</span>
</span></span><span class="line"><span class="cl"><span class="p">)</span> <span class="p">:</span> <span class="n">IForRunningTheGame</span>
</span></span><span class="line"><span class="cl"><span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="kd">private</span> <span class="k">readonly</span> <span class="n">Paddle</span> <span class="n">_paddleL</span> <span class="p">=</span> <span class="k">new</span><span class="p">()</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="n">Position</span> <span class="p">=</span> <span class="k">new</span> <span class="n">Vector2</span><span class="p">(</span><span class="m">8</span><span class="p">,</span> <span class="n">Resolution</span><span class="p">.</span><span class="n">DesignHeight</span> <span class="p">/</span> <span class="m">2f</span><span class="p">),</span>
</span></span><span class="line"><span class="cl">        <span class="n">Texture</span> <span class="p">=</span> <span class="n">TextureId</span><span class="p">.</span><span class="n">PaddleL</span>
</span></span><span class="line"><span class="cl">    <span class="p">};</span>
</span></span><span class="line"><span class="cl">    
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="k">void</span> <span class="n">Update</span><span class="p">(</span><span class="n">GameTime</span> <span class="n">gameTime</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">    <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="kt">var</span> <span class="n">inputState</span> <span class="p">=</span> <span class="n">inputReader</span><span class="p">.</span><span class="n">ReadInput</span><span class="p">();</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">        <span class="kt">var</span> <span class="n">playerLInput</span> <span class="p">=</span> <span class="n">InGameControlInput</span><span class="p">.</span><span class="n">FromInputState</span><span class="p">(</span><span class="n">inputState</span><span class="p">,</span> <span class="n">_inputConfigurationPlayerL</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">        <span class="n">_paddleL</span><span class="p">.</span><span class="n">Update</span><span class="p">(</span><span class="n">gameTime</span><span class="p">,</span> <span class="n">playerLInput</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">        <span class="n">CheckIfBallHitPaddle</span><span class="p">(</span><span class="n">_paddleL</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="k">void</span> <span class="n">Draw</span><span class="p">()</span>
</span></span><span class="line"><span class="cl">    <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="n">_paddleL</span><span class="p">.</span><span class="n">Draw</span><span class="p">(</span><span class="n">renderer</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl">    
</span></span><span class="line"><span class="cl">    <span class="kd">private</span> <span class="k">void</span> <span class="n">CheckIfBallHitPaddle</span><span class="p">(</span><span class="n">Paddle</span> <span class="n">hitPaddle</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">    <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="c1">// Some logic to check if the ball hit the paddle</span>
</span></span><span class="line"><span class="cl">        <span class="c1">// ...</span>
</span></span><span class="line"><span class="cl">        
</span></span><span class="line"><span class="cl">        <span class="n">soundPlayer</span><span class="p">.</span><span class="n">PlaySound</span><span class="p">(</span><span class="n">SoundId</span><span class="p">.</span><span class="n">BallHitPaddle</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>    
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span></code></pre></div><p>And here&rsquo;s the <code>Paddle</code> class:</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-csharp" data-lang="csharp"><span class="line"><span class="cl"><span class="k">using</span> <span class="nn">System.Numerics</span><span class="p">;</span>
</span></span><span class="line"><span class="cl"><span class="k">using</span> <span class="nn">Clong.Core.Domain.Dto</span><span class="p">;</span>
</span></span><span class="line"><span class="cl"><span class="k">using</span> <span class="nn">Clong.Core.Domain.Enum</span><span class="p">;</span>
</span></span><span class="line"><span class="cl"><span class="k">using</span> <span class="nn">Clong.Core.Domain.Input</span><span class="p">;</span>
</span></span><span class="line"><span class="cl"><span class="k">using</span> <span class="nn">Clong.Core.Ports.Driven</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="k">namespace</span> <span class="nn">Clong.Core.Domain.Entity</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="kd">internal</span> <span class="k">class</span> <span class="nc">Paddle</span>
</span></span><span class="line"><span class="cl"><span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="kd">private</span> <span class="kd">const</span> <span class="kt">float</span> <span class="n">Speed</span> <span class="p">=</span> <span class="m">500f</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="n">required</span> <span class="n">TextureId</span> <span class="n">Texture</span> <span class="p">{</span> <span class="k">get</span><span class="p">;</span> <span class="k">init</span><span class="p">;</span> <span class="p">}</span>
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="n">Vector2</span> <span class="n">Position</span> <span class="p">{</span> <span class="k">get</span><span class="p">;</span> <span class="k">set</span><span class="p">;</span> <span class="p">}</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="k">void</span> <span class="n">Update</span><span class="p">(</span><span class="n">GameTime</span> <span class="n">gameTime</span><span class="p">,</span> <span class="n">InGameControlInput</span> <span class="n">input</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">    <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="kt">var</span> <span class="n">newPositionY</span> <span class="p">=</span> <span class="n">Position</span><span class="p">.</span><span class="n">Y</span> <span class="p">+</span> <span class="n">gameTime</span><span class="p">.</span><span class="n">DeltaSeconds</span> <span class="p">*</span> <span class="n">Speed</span> <span class="p">*</span> <span class="n">input</span><span class="p">.</span><span class="n">Y</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="k">void</span> <span class="n">Draw</span><span class="p">(</span><span class="n">IForRendering</span> <span class="n">renderer</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">    <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="n">renderer</span><span class="p">.</span><span class="n">DrawTexture</span><span class="p">(</span><span class="n">Texture</span><span class="p">,</span> <span class="n">Position</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span></code></pre></div><p>And the <code>InGameControlInput</code> class that converts pressed keys to control input for the paddle:</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-csharp" data-lang="csharp"><span class="line"><span class="cl"><span class="k">namespace</span> <span class="nn">Clong.Core.Domain.Input</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="kd">internal</span> <span class="k">class</span> <span class="nc">InGameControlInput</span>
</span></span><span class="line"><span class="cl"><span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="kd">internal</span> <span class="n">required</span> <span class="kt">float</span> <span class="n">Y</span> <span class="p">{</span> <span class="k">get</span><span class="p">;</span> <span class="k">init</span><span class="p">;</span> <span class="p">}</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="kd">internal</span> <span class="kd">static</span> <span class="n">InGameControlInput</span> <span class="n">FromInputState</span><span class="p">(</span><span class="n">InputState</span> <span class="n">inputState</span><span class="p">,</span> <span class="n">InputConfiguration</span> <span class="n">configuration</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">    <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="kt">var</span> <span class="n">up</span> <span class="p">=</span> <span class="n">inputState</span><span class="p">.</span><span class="n">IsKeyDown</span><span class="p">(</span><span class="n">configuration</span><span class="p">.</span><span class="n">KeyUp</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">        <span class="kt">var</span> <span class="n">down</span> <span class="p">=</span> <span class="n">inputState</span><span class="p">.</span><span class="n">IsKeyDown</span><span class="p">(</span><span class="n">configuration</span><span class="p">.</span><span class="n">KeyDown</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">        <span class="kt">var</span> <span class="n">controlInputY</span> <span class="p">=</span> <span class="m">0f</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">        <span class="k">if</span> <span class="p">(</span><span class="n">up</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">            <span class="n">controlInputY</span> <span class="p">+=</span> <span class="p">-</span><span class="m">1f</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">        <span class="p">}</span>
</span></span><span class="line"><span class="cl">        <span class="k">if</span> <span class="p">(</span><span class="n">down</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">            <span class="n">controlInputY</span> <span class="p">+=</span> <span class="m">1f</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">        <span class="p">}</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">        <span class="k">return</span> <span class="k">new</span> <span class="n">InGameControlInput</span> <span class="p">{</span> <span class="n">Y</span> <span class="p">=</span> <span class="n">controlInputY</span> <span class="p">};</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span></code></pre></div><p>We&rsquo;ll leave the <code>InputConfiguration</code> class out here. Its purpose is to map physical keys to logical keys, and can be
used by the player to configure their own key mapping.</p>
<p>The <code>Clong</code> class is instantiated in the adapter component:</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-csharp" data-lang="csharp"><span class="line"><span class="cl"><span class="k">namespace</span> <span class="nn">Clong.Kni.Adapter</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="kd">public</span> <span class="k">class</span> <span class="nc">MainGame</span> <span class="p">:</span> <span class="n">Game</span>
</span></span><span class="line"><span class="cl"><span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="c1">// ...</span>
</span></span><span class="line"><span class="cl">    
</span></span><span class="line"><span class="cl">    <span class="kd">protected</span> <span class="kd">override</span> <span class="k">void</span> <span class="n">LoadContent</span><span class="p">()</span>
</span></span><span class="line"><span class="cl">    <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="kt">var</span> <span class="n">textureMap</span> <span class="p">=</span> <span class="k">new</span> <span class="n">TextureMap</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl"><span class="na">            [TextureId.Ball]</span> <span class="p">=</span> <span class="n">Content</span><span class="p">.</span><span class="n">Load</span><span class="p">&lt;</span><span class="n">Texture2D</span><span class="p">&gt;(</span><span class="s">&#34;Textures/ball&#34;</span><span class="p">),</span>
</span></span><span class="line"><span class="cl"><span class="na">            [TextureId.PaddleL]</span> <span class="p">=</span> <span class="n">Content</span><span class="p">.</span><span class="n">Load</span><span class="p">&lt;</span><span class="n">Texture2D</span><span class="p">&gt;(</span><span class="s">&#34;Textures/paddle1&#34;</span><span class="p">),</span>
</span></span><span class="line"><span class="cl"><span class="na">            [TextureId.PaddleR]</span> <span class="p">=</span> <span class="n">Content</span><span class="p">.</span><span class="n">Load</span><span class="p">&lt;</span><span class="n">Texture2D</span><span class="p">&gt;(</span><span class="s">&#34;Textures/paddle2&#34;</span><span class="p">),</span>
</span></span><span class="line"><span class="cl"><span class="na">            [TextureId.Star]</span> <span class="p">=</span> <span class="n">Content</span><span class="p">.</span><span class="n">Load</span><span class="p">&lt;</span><span class="n">Texture2D</span><span class="p">&gt;(</span><span class="s">&#34;Textures/star&#34;</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">        <span class="p">};</span>
</span></span><span class="line"><span class="cl">        
</span></span><span class="line"><span class="cl">        <span class="c1">// ...</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl">    
</span></span><span class="line"><span class="cl">    <span class="c1">// ...</span>
</span></span><span class="line"><span class="cl">    
</span></span><span class="line"><span class="cl">    <span class="n">_gameController</span> <span class="p">=</span> <span class="k">new</span> <span class="n">GameController</span><span class="p">(</span>
</span></span><span class="line"><span class="cl">        <span class="k">new</span> <span class="n">Core</span><span class="p">.</span><span class="n">Domain</span><span class="p">.</span><span class="n">Clong</span><span class="p">(</span>
</span></span><span class="line"><span class="cl">            <span class="k">new</span> <span class="n">InputReader</span><span class="p">(),</span>
</span></span><span class="line"><span class="cl">            <span class="k">new</span> <span class="n">Renderer</span><span class="p">(</span><span class="n">_spriteBatch</span><span class="p">,</span> <span class="n">textureMap</span><span class="p">,</span> <span class="n">font</span><span class="p">),</span>
</span></span><span class="line"><span class="cl">            <span class="k">new</span> <span class="n">SoundEffectPlayer</span><span class="p">(</span><span class="n">soundMap</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">        <span class="p">)</span>
</span></span><span class="line"><span class="cl">    <span class="p">);</span>   
</span></span><span class="line"><span class="cl"> <span class="p">}</span>
</span></span></code></pre></div><p>And that&rsquo;s basically it! Now, let&rsquo;s look at how we can add a unit test.</p>
<h4 id="add-a-unit-test">Add a Unit Test</h4>
<p>Let&rsquo;s add a quick unit test for the paddle that tests if the control input actually moves the paddle:</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-csharp" data-lang="csharp"><span class="line"><span class="cl"><span class="na">[TestFixture]</span>
</span></span><span class="line"><span class="cl"><span class="na">[TestOf(typeof(Paddle))]</span>
</span></span><span class="line"><span class="cl"><span class="kd">public</span> <span class="k">class</span> <span class="nc">PaddleTest</span>
</span></span><span class="line"><span class="cl"><span class="p">{</span>
</span></span><span class="line"><span class="cl"><span class="na">    [Test]</span>
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="k">void</span> <span class="n">TestUpdateMovesPaddle</span><span class="p">()</span>
</span></span><span class="line"><span class="cl">    <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="kt">var</span> <span class="n">paddle</span> <span class="p">=</span> <span class="k">new</span> <span class="n">Paddle</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">            <span class="n">Texture</span> <span class="p">=</span> <span class="n">TextureId</span><span class="p">.</span><span class="n">PaddleL</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">            <span class="n">Position</span> <span class="p">=</span> <span class="k">new</span> <span class="n">Vector2</span><span class="p">(</span><span class="m">0</span><span class="p">,</span> <span class="m">100</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">        <span class="p">};</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">        <span class="kd">const</span> <span class="kt">float</span> <span class="n">epsilon</span> <span class="p">=</span> <span class="m">0.001f</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">        <span class="kt">var</span> <span class="n">gameTimeBuilder</span> <span class="p">=</span> <span class="k">new</span> <span class="n">GameTimeBuilder</span><span class="p">();</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">        <span class="kt">var</span> <span class="n">gameTime</span> <span class="p">=</span> <span class="n">gameTimeBuilder</span><span class="p">.</span><span class="n">Build</span><span class="p">();</span>
</span></span><span class="line"><span class="cl">        <span class="kt">var</span> <span class="n">controlInput</span> <span class="p">=</span> <span class="k">new</span> <span class="n">InGameControlInput</span> <span class="p">{</span> <span class="n">Y</span> <span class="p">=</span> <span class="m">1</span> <span class="p">};</span>
</span></span><span class="line"><span class="cl">        <span class="n">paddle</span><span class="p">.</span><span class="n">Update</span><span class="p">(</span><span class="n">gameTime</span><span class="p">,</span> <span class="n">controlInput</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">        <span class="n">Assert</span><span class="p">.</span><span class="n">That</span><span class="p">(</span><span class="n">paddle</span><span class="p">.</span><span class="n">Position</span><span class="p">.</span><span class="n">X</span><span class="p">,</span> <span class="n">Is</span><span class="p">.</span><span class="n">EqualTo</span><span class="p">(</span><span class="m">0</span><span class="p">));</span>
</span></span><span class="line"><span class="cl">        <span class="n">Assert</span><span class="p">.</span><span class="n">That</span><span class="p">(</span><span class="n">paddle</span><span class="p">.</span><span class="n">Position</span><span class="p">.</span><span class="n">Y</span><span class="p">,</span> <span class="n">Is</span><span class="p">.</span><span class="n">EqualTo</span><span class="p">(</span><span class="m">108.333f</span><span class="p">).</span><span class="n">Within</span><span class="p">(</span><span class="n">epsilon</span><span class="p">));</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">        <span class="n">gameTime</span> <span class="p">=</span> <span class="n">gameTimeBuilder</span><span class="p">.</span><span class="n">AdvanceFrame</span><span class="p">().</span><span class="n">Build</span><span class="p">();</span>
</span></span><span class="line"><span class="cl">        <span class="n">paddle</span><span class="p">.</span><span class="n">Update</span><span class="p">(</span><span class="n">gameTime</span><span class="p">,</span> <span class="n">controlInput</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">        <span class="n">Assert</span><span class="p">.</span><span class="n">That</span><span class="p">(</span><span class="n">paddle</span><span class="p">.</span><span class="n">Position</span><span class="p">.</span><span class="n">X</span><span class="p">,</span> <span class="n">Is</span><span class="p">.</span><span class="n">EqualTo</span><span class="p">(</span><span class="m">0</span><span class="p">));</span>
</span></span><span class="line"><span class="cl">        <span class="n">Assert</span><span class="p">.</span><span class="n">That</span><span class="p">(</span><span class="n">paddle</span><span class="p">.</span><span class="n">Position</span><span class="p">.</span><span class="n">Y</span><span class="p">,</span> <span class="n">Is</span><span class="p">.</span><span class="n">EqualTo</span><span class="p">(</span><span class="m">116.666f</span><span class="p">).</span><span class="n">Within</span><span class="p">(</span><span class="n">epsilon</span><span class="p">));</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">        <span class="n">gameTime</span> <span class="p">=</span> <span class="n">gameTimeBuilder</span><span class="p">.</span><span class="n">AdvanceFrame</span><span class="p">().</span><span class="n">Build</span><span class="p">();</span>
</span></span><span class="line"><span class="cl">        <span class="n">controlInput</span> <span class="p">=</span> <span class="k">new</span> <span class="n">InGameControlInput</span> <span class="p">{</span> <span class="n">Y</span> <span class="p">=</span> <span class="p">-</span><span class="m">1</span> <span class="p">};</span>
</span></span><span class="line"><span class="cl">        <span class="n">paddle</span><span class="p">.</span><span class="n">Update</span><span class="p">(</span><span class="n">gameTime</span><span class="p">,</span> <span class="n">controlInput</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">        <span class="n">Assert</span><span class="p">.</span><span class="n">That</span><span class="p">(</span><span class="n">paddle</span><span class="p">.</span><span class="n">Position</span><span class="p">.</span><span class="n">X</span><span class="p">,</span> <span class="n">Is</span><span class="p">.</span><span class="n">EqualTo</span><span class="p">(</span><span class="m">0</span><span class="p">));</span>
</span></span><span class="line"><span class="cl">        <span class="n">Assert</span><span class="p">.</span><span class="n">That</span><span class="p">(</span><span class="n">paddle</span><span class="p">.</span><span class="n">Position</span><span class="p">.</span><span class="n">Y</span><span class="p">,</span> <span class="n">Is</span><span class="p">.</span><span class="n">EqualTo</span><span class="p">(</span><span class="m">108.333f</span><span class="p">).</span><span class="n">Within</span><span class="p">(</span><span class="n">epsilon</span><span class="p">));</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">        <span class="n">gameTime</span> <span class="p">=</span> <span class="n">gameTimeBuilder</span><span class="p">.</span><span class="n">AdvanceFrame</span><span class="p">().</span><span class="n">Build</span><span class="p">();</span>
</span></span><span class="line"><span class="cl">        <span class="n">paddle</span><span class="p">.</span><span class="n">Update</span><span class="p">(</span><span class="n">gameTime</span><span class="p">,</span> <span class="n">controlInput</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">        <span class="n">Assert</span><span class="p">.</span><span class="n">That</span><span class="p">(</span><span class="n">paddle</span><span class="p">.</span><span class="n">Position</span><span class="p">.</span><span class="n">X</span><span class="p">,</span> <span class="n">Is</span><span class="p">.</span><span class="n">EqualTo</span><span class="p">(</span><span class="m">0</span><span class="p">));</span>
</span></span><span class="line"><span class="cl">        <span class="n">Assert</span><span class="p">.</span><span class="n">That</span><span class="p">(</span><span class="n">paddle</span><span class="p">.</span><span class="n">Position</span><span class="p">.</span><span class="n">Y</span><span class="p">,</span> <span class="n">Is</span><span class="p">.</span><span class="n">EqualTo</span><span class="p">(</span><span class="m">100f</span><span class="p">).</span><span class="n">Within</span><span class="p">(</span><span class="n">epsilon</span><span class="p">));</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">        <span class="n">gameTime</span> <span class="p">=</span> <span class="n">gameTimeBuilder</span><span class="p">.</span><span class="n">AdvanceFrame</span><span class="p">().</span><span class="n">Build</span><span class="p">();</span>
</span></span><span class="line"><span class="cl">        <span class="n">controlInput</span> <span class="p">=</span> <span class="k">new</span> <span class="n">InGameControlInput</span> <span class="p">{</span> <span class="n">Y</span> <span class="p">=</span> <span class="m">0</span> <span class="p">};</span>
</span></span><span class="line"><span class="cl">        <span class="n">paddle</span><span class="p">.</span><span class="n">Update</span><span class="p">(</span><span class="n">gameTime</span><span class="p">,</span> <span class="n">controlInput</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">        <span class="n">Assert</span><span class="p">.</span><span class="n">That</span><span class="p">(</span><span class="n">paddle</span><span class="p">.</span><span class="n">Position</span><span class="p">.</span><span class="n">X</span><span class="p">,</span> <span class="n">Is</span><span class="p">.</span><span class="n">EqualTo</span><span class="p">(</span><span class="m">0</span><span class="p">));</span>
</span></span><span class="line"><span class="cl">        <span class="n">Assert</span><span class="p">.</span><span class="n">That</span><span class="p">(</span><span class="n">paddle</span><span class="p">.</span><span class="n">Position</span><span class="p">.</span><span class="n">Y</span><span class="p">,</span> <span class="n">Is</span><span class="p">.</span><span class="n">EqualTo</span><span class="p">(</span><span class="m">100f</span><span class="p">).</span><span class="n">Within</span><span class="p">(</span><span class="n">epsilon</span><span class="p">));</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="kd">public</span> <span class="k">class</span> <span class="nc">GameTimeBuilder</span>
</span></span><span class="line"><span class="cl"><span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="kd">private</span> <span class="k">readonly</span> <span class="n">TimeSpan</span> <span class="n">_deltaTime</span> <span class="p">=</span> <span class="n">TimeSpan</span><span class="p">.</span><span class="n">FromTicks</span><span class="p">(</span><span class="n">TimeSpan</span><span class="p">.</span><span class="n">TicksPerSecond</span> <span class="p">/</span> <span class="m">60</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">    <span class="kd">private</span> <span class="kt">int</span> <span class="n">_numberOfFrames</span> <span class="p">=</span> <span class="m">1</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="n">GameTimeBuilder</span> <span class="n">AdvanceFrame</span><span class="p">()</span>
</span></span><span class="line"><span class="cl">    <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="n">_numberOfFrames</span><span class="p">++;</span>
</span></span><span class="line"><span class="cl">        <span class="k">return</span> <span class="k">this</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="n">GameTime</span> <span class="n">Build</span><span class="p">()</span>
</span></span><span class="line"><span class="cl">    <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="k">return</span> <span class="k">new</span> <span class="n">GameTime</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">            <span class="n">DeltaTime</span> <span class="p">=</span> <span class="n">_deltaTime</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">            <span class="n">TotalTime</span> <span class="p">=</span> <span class="n">_deltaTime</span> <span class="p">*</span> <span class="n">_numberOfFrames</span>
</span></span><span class="line"><span class="cl">        <span class="p">};</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span></code></pre></div><div class="notice note" >
    <p class="notice-title">
        <span class="icon-notice baseline">
            <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 128 300 300">
  <path d="M150 128c82.813 0 150 67.188 150 150 0 82.813-67.188 150-150 150C67.187 428 0 360.812 0 278c0-82.813 67.188-150 150-150Zm25 243.555v-37.11c0-3.515-2.734-6.445-6.055-6.445h-37.5c-3.515 0-6.445 2.93-6.445 6.445v37.11c0 3.515 2.93 6.445 6.445 6.445h37.5c3.32 0 6.055-2.93 6.055-6.445Zm-.39-67.188 3.515-121.289c0-1.367-.586-2.734-1.953-3.516-1.172-.976-2.93-1.562-4.688-1.562h-42.968c-1.758 0-3.516.586-4.688 1.563-1.367.78-1.953 2.148-1.953 3.515l3.32 121.29c0 2.734 2.93 4.882 6.64 4.882h36.134c3.515 0 6.445-2.148 6.64-4.883Z"/>
</svg>

        </span>Note</p><p>You can find the full source code of the game on <a href="https://github.com/shendriks/clong"
    
    
      target="_blank" class="external-link"
    
>GitHub</a>
.</p></div>

<h2 id="lets-play">Let&rsquo;s Play!</h2>
<p>Let&rsquo;s have a look at the finished game. To make it a bit more interesting, we added a starfield as background and
“rotating gravity” that makes the ball’s movement a bit wonky and unpredictable.</p>
<p>
<div style="text-align: center;">
    <a href="javascript:window.open('https://clong.shendriks.dev', 'Clong', 'popup,toolbar=no,scrollbars=no,resizable=no,width=640,height=360');"> 

<figure class="center"><img src="/https/shendriks.dev/posts/2024-12-30-making-game-logic-framework-independent-with-hexagonal-architecture/images/clong.gif"
    			alt="Clong in Action"><figcaption>
    			<p>Clong in Action</p>
    		</figcaption>
    </figure>


    Click to open game in a pop-up window
    </a>
    <br>
    (I'm afraid the game doesn't work on mobile devices yet, sorry! 😢)
</div>
<br>
</p>
<div class="notice note" >
    <p class="notice-title">
        <span class="icon-notice baseline">
            <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 128 300 300">
  <path d="M150 128c82.813 0 150 67.188 150 150 0 82.813-67.188 150-150 150C67.187 428 0 360.812 0 278c0-82.813 67.188-150 150-150Zm25 243.555v-37.11c0-3.515-2.734-6.445-6.055-6.445h-37.5c-3.515 0-6.445 2.93-6.445 6.445v37.11c0 3.515 2.93 6.445 6.445 6.445h37.5c3.32 0 6.055-2.93 6.055-6.445Zm-.39-67.188 3.515-121.289c0-1.367-.586-2.734-1.953-3.516-1.172-.976-2.93-1.562-4.688-1.562h-42.968c-1.758 0-3.516.586-4.688 1.563-1.367.78-1.953 2.148-1.953 3.515l3.32 121.29c0 2.734 2.93 4.882 6.64 4.882h36.134c3.515 0 6.445-2.148 6.64-4.883Z"/>
</svg>

        </span>Note</p><p>Alternatively, you can try the game out on <a href="https://shendriks.itch.io/clong"
    
    
      target="_blank" class="external-link"
    
>itch.io</a></p></div>

<h2 id="conclusion">Conclusion</h2>
<p>Using Hexagonal Architecture for game development is a possible way to separate game logic from the framework. This
makes it easier to test, change, and maintain, but also might come at a performance cost.  Also, while this approach may
require some extra effort, like converting framework-specific elements to domain-specific ones, the advantage of clear
separation make it worthwhile.</p>
]]></content></item><item><title>A* Pathfinding in 2D Games: Addendum about Cyclic Dependencies</title><link>https://shendriks.dev/posts/2024-12-01-a-star-pathfinding-supplemental/</link><pubDate>Sun, 01 Dec 2024 00:00:00 +0000</pubDate><guid>https://shendriks.dev/posts/2024-12-01-a-star-pathfinding-supplemental/</guid><description>Putting the grid navigation in its own class to avoid a cyclic dependency and to improve separation of concerns.</description><content type="html"><![CDATA[<h2 id="introduction">Introduction</h2>
<p>In the <a href="/https/shendriks.dev/posts/2024-09-04-a-star-pathfinding-side-view/"
    
    
>previous article</a>
, we implemented the A* pathfinding
algorithm for a 2D side-view platformer scenario. We updated the logic from the top-down example and introduced
functionality to navigate through the grid more easily by using speaking method names instead of fiddling with grid
coordinates directly. The goal there was to improve the readability. However, as the reader may have already noticed, we
introduced something which is called a <strong>cyclic dependency</strong>.</p>
<h2 id="whats-a-cyclic-dependency">What&rsquo;s a Cyclic Dependency?</h2>
<p>In software engineering, cyclic dependencies occur when two or more components depend on each other. In our example it is
the grid and its cells which are interdependent. The grid depends on the cells and each cell depends on the grid.
The latter was introduced so the cell can implement and expose methods for navigating from that cell to another cell in the grid.
Here&rsquo;s a quick UML diagram that illustrates this fact:</p>
<figure class="center"><img src="/https/shendriks.dev/posts/2024-12-01-a-star-pathfinding-supplemental/images/grid-cell-dependency-01.svg"
			alt="Circular Dependency between Grid and Cell"><figcaption>
			<p>Circular Dependency between Grid and Cell</p>
		</figcaption>
</figure>

<p>Let&rsquo;s go back to the involved code for a moment and take a look at the <code>Grid</code> and <code>Cell</code> classes:</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-csharp" data-lang="csharp"><span class="line"><span class="cl"><span class="kd">public</span> <span class="k">class</span> <span class="nc">Grid</span>
</span></span><span class="line"><span class="cl"><span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="kd">private</span> <span class="k">readonly</span> <span class="n">Cell</span><span class="p">[,]</span> <span class="n">_cells</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">    
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="n">Grid</span><span class="p">(</span><span class="kt">char</span><span class="p">[,]</span> <span class="n">map</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">    <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="n">_cells</span> <span class="p">=</span> <span class="k">new</span> <span class="n">Cell</span><span class="p">[</span><span class="n">map</span><span class="p">.</span><span class="n">GetLength</span><span class="p">(</span><span class="m">1</span><span class="p">),</span> <span class="n">map</span><span class="p">.</span><span class="n">GetLength</span><span class="p">(</span><span class="m">0</span><span class="p">)];</span>
</span></span><span class="line"><span class="cl">        
</span></span><span class="line"><span class="cl">        <span class="k">for</span> <span class="p">(</span><span class="kt">var</span> <span class="n">y</span> <span class="p">=</span> <span class="m">0</span><span class="p">;</span> <span class="n">y</span> <span class="p">&lt;</span> <span class="n">map</span><span class="p">.</span><span class="n">GetLength</span><span class="p">(</span><span class="m">0</span><span class="p">);</span> <span class="n">y</span><span class="p">++)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">            <span class="k">for</span> <span class="p">(</span><span class="kt">var</span> <span class="n">x</span> <span class="p">=</span> <span class="m">0</span><span class="p">;</span> <span class="n">x</span> <span class="p">&lt;</span> <span class="n">map</span><span class="p">.</span><span class="n">GetLength</span><span class="p">(</span><span class="m">1</span><span class="p">);</span> <span class="n">x</span><span class="p">++)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">                <span class="n">_cells</span><span class="p">[</span><span class="n">x</span><span class="p">,</span> <span class="n">y</span><span class="p">]</span> <span class="p">=</span> <span class="k">new</span> <span class="n">Cell</span><span class="p">(</span><span class="n">x</span><span class="p">,</span> <span class="n">y</span><span class="p">,</span> <span class="n">CellTypeFromChar</span><span class="p">(</span><span class="n">map</span><span class="p">[</span><span class="n">y</span><span class="p">,</span> <span class="n">x</span><span class="p">]),</span> <span class="k">this</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">                <span class="c1">// ...</span>
</span></span><span class="line"><span class="cl">            <span class="p">}</span>
</span></span><span class="line"><span class="cl">        <span class="p">}</span>    
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span></code></pre></div><div class="highlight"><pre tabindex="0" class="chroma"><code class="language-csharp" data-lang="csharp"><span class="line"><span class="cl"><span class="kd">public</span> <span class="k">class</span> <span class="nc">Cell</span><span class="p">(</span><span class="kt">int</span> <span class="n">x</span><span class="p">,</span> <span class="kt">int</span> <span class="n">y</span><span class="p">,</span> <span class="n">CellType</span> <span class="n">type</span><span class="p">,</span> <span class="n">Grid</span> <span class="n">grid</span><span class="p">)</span>
</span></span><span class="line"><span class="cl"><span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="c1">// ...</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="n">Cell</span><span class="p">?</span> <span class="n">Up</span> <span class="p">=&gt;</span> <span class="n">NeighborAt</span><span class="p">(</span><span class="m">0</span><span class="p">,</span> <span class="p">-</span><span class="m">1</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="n">Cell</span><span class="p">?</span> <span class="n">Down</span> <span class="p">=&gt;</span> <span class="n">NeighborAt</span><span class="p">(</span><span class="m">0</span><span class="p">,</span> <span class="m">1</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="n">Cell</span><span class="p">?</span> <span class="n">Left</span> <span class="p">=&gt;</span> <span class="n">NeighborAt</span><span class="p">(-</span><span class="m">1</span><span class="p">,</span> <span class="m">0</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="n">Cell</span><span class="p">?</span> <span class="n">Right</span> <span class="p">=&gt;</span> <span class="n">NeighborAt</span><span class="p">(</span><span class="m">1</span><span class="p">,</span> <span class="m">0</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">    
</span></span><span class="line"><span class="cl">    <span class="c1">// ...</span>
</span></span><span class="line"><span class="cl">    
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="n">Cell</span><span class="p">?</span> <span class="n">NeighborAt</span><span class="p">(</span><span class="kt">int</span> <span class="n">deltaX</span><span class="p">,</span> <span class="kt">int</span> <span class="n">deltaY</span><span class="p">)</span> <span class="p">=&gt;</span> <span class="n">grid</span><span class="p">[</span><span class="n">X</span> <span class="p">+</span> <span class="n">deltaX</span><span class="p">,</span> <span class="n">Y</span> <span class="p">+</span> <span class="n">deltaY</span><span class="p">];</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="c1">// ...</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span> 
</span></span></code></pre></div><p>The <code>Grid</code> constructor instantiates <code>Cell</code> objects and in turn injects a reference to itself to the <code>Cell</code> constructor. So, the grid
has references to the cells and each cell has a reference to the grid. The reference to the grid is used in
the <code>NeighborAt(...)</code> method which accesses the grid.</p>
<h2 id="whats-so-bad-about-cyclic-dependencies">What&rsquo;s so bad about Cyclic Dependencies?</h2>
<p>Cyclic dependencies are problematic in that they often make the code less maintainable by making it less testable and modifiable.
For example, to write a unit test for <code>Cell</code> you can&rsquo;t simply instantiate a <code>Cell</code> object, you have to create a <code>Grid</code> object first,
which in turn creates <code>Cell</code> instances.</p>
<h2 id="how-to-avoid-cyclic-dependencies">How to avoid Cyclic Dependencies</h2>
<p>There are ways to get rid of the cyclic dependency in the code. First of all, you can ask if the interdependence is even
necessary. Often times, you&rsquo;ll find that the dependency is only needed in one direction (as is indeed the case in our example).
But, there are also cases where the interdependence is needed in both directions, in which case you can get rid of the circular
dependency by applying &hellip; <em>drumroll</em> &hellip; dependency inversion. So, what&rsquo;s dependency inversion you ask?</p>
<h3 id="dependency-inversion">Dependency Inversion</h3>
<p>Dependency inversion is one of the five <a href="https://en.wikipedia.org/wiki/SOLID"
    
    
      target="_blank" class="external-link"
    
>SOLID</a>
 principles. Here&rsquo;s what <a href="https://en.wikipedia.org/wiki/Dependency_inversion_principle"
    
    
      target="_blank" class="external-link"
    
>Wikipedia</a>

says:</p>
<blockquote>
<ol>
<li>High-level modules should not import anything from low-level modules. Both should depend on abstractions (e.g., interfaces).</li>
<li>Abstractions should not depend on details. Details (concrete implementations) should depend on abstractions.</li>
</ol>
</blockquote>
<p>Let&rsquo;s take a look at how this would look like in our example with a grid and cells.</p>
<figure class="center"><img src="/https/shendriks.dev/posts/2024-12-01-a-star-pathfinding-supplemental/images/grid-cell-dependency-02.svg"
			alt="No more circular dependency between Grid and Cell"><figcaption>
			<p>No more circular dependency between Grid and Cell</p>
		</figcaption>
</figure>

<p>Instead of the <code>Grid</code> class depending directly on the concrete <code>Cell</code> class, it now depends on an interface <code>ICell</code>
which is implemented by <code>Cell</code>. So both the grid and the cell depend now on the interface. We have broken the circle!</p>
<p>Two questions that could be asked:</p>
<ol>
<li>Can anyone tell me what exactly the <code>ICell</code> interface is about?</li>
<li>Now that the <code>Grid</code> class doesn&rsquo;t know about the <code>Cell</code> class anymore, but only about the abstraction <code>ICell</code>, how is it
supposed to instantiate concrete objects, since there is no constructor to invoke?</li>
</ol>
<p>We&rsquo;ll leave the answer to the first question open for now. For the latter, we need a mechanism for instantiating
concrete <code>Cell</code> objects. One such mechanism is a pattern called
<a href="https://en.wikipedia.org/wiki/Factory_method_pattern"
    
    
      target="_blank" class="external-link"
    
>Factory Method</a>
.</p>
<p>So what we could do is implement a factory which creates <code>Cell</code> objects and inject that factory into the <code>Grid</code> class.</p>
<figure class="center"><img src="/https/shendriks.dev/posts/2024-12-01-a-star-pathfinding-supplemental/images/grid-cell-dependency-02b.svg"
			alt="Introduce a cell factory for creating concrete cell objects"><figcaption>
			<p>Introduce a cell factory for creating concrete cell objects</p>
		</figcaption>
</figure>

<p>Here&rsquo;s a quick draft of the code (we&rsquo;re not going to fully implement this):</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-csharp" data-lang="csharp"><span class="line"><span class="cl"><span class="kd">public</span> <span class="k">interface</span> <span class="nc">ICell</span> <span class="p">{</span> <span class="cm">/* ... */</span> <span class="p">}</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="kd">public</span> <span class="k">class</span> <span class="nc">Cell</span><span class="p">(</span><span class="kt">int</span> <span class="n">x</span><span class="p">,</span> <span class="kt">int</span> <span class="n">y</span><span class="p">,</span> <span class="n">CellType</span> <span class="n">type</span><span class="p">)</span> <span class="p">:</span> <span class="n">ICell</span>
</span></span><span class="line"><span class="cl"><span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="c1">// ..</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="n">Grid</span><span class="p">?</span> <span class="n">Grid</span> <span class="p">{</span> <span class="k">get</span><span class="p">;</span> <span class="k">set</span><span class="p">;</span> <span class="p">}</span>
</span></span><span class="line"><span class="cl">    
</span></span><span class="line"><span class="cl">    <span class="c1">//...</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="kd">public</span> <span class="k">interface</span> <span class="nc">ICellFactory</span>
</span></span><span class="line"><span class="cl"><span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="n">ICell</span> <span class="n">CreateCell</span><span class="p">(</span><span class="kt">int</span> <span class="n">x</span><span class="p">,</span> <span class="kt">int</span> <span class="n">y</span><span class="p">,</span> <span class="kt">char</span> <span class="n">cellTypeChar</span><span class="p">)</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="kd">public</span> <span class="k">class</span> <span class="nc">CellFactory</span> <span class="p">:</span> <span class="n">ICellFactory</span>
</span></span><span class="line"><span class="cl"><span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="n">ICell</span> <span class="n">CreateCell</span><span class="p">(</span><span class="kt">int</span> <span class="n">x</span><span class="p">,</span> <span class="kt">int</span> <span class="n">y</span><span class="p">,</span> <span class="kt">char</span> <span class="n">cellTypeChar</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">    <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="k">return</span> <span class="k">new</span> <span class="n">Cell</span><span class="p">(</span><span class="n">x</span><span class="p">,</span> <span class="n">y</span><span class="p">,</span> <span class="n">CellTypeFromChar</span><span class="p">(</span><span class="n">cellTypeChar</span><span class="p">));</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl">    
</span></span><span class="line"><span class="cl">    <span class="kd">private</span> <span class="kd">static</span> <span class="n">CellType</span> <span class="n">CellTypeFromChar</span><span class="p">(</span><span class="kt">char</span> <span class="n">c</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">    <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="k">return</span> <span class="n">c</span> <span class="k">switch</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">            <span class="sc">&#39; &#39;</span> <span class="p">=&gt;</span> <span class="n">CellType</span><span class="p">.</span><span class="n">Empty</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">            <span class="sc">&#39;B&#39;</span> <span class="p">=&gt;</span> <span class="n">CellType</span><span class="p">.</span><span class="n">Block</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">            <span class="sc">&#39;L&#39;</span> <span class="p">=&gt;</span> <span class="n">CellType</span><span class="p">.</span><span class="n">Ladder</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">            <span class="sc">&#39;H&#39;</span> <span class="p">=&gt;</span> <span class="n">CellType</span><span class="p">.</span><span class="n">HangingBar</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">            <span class="n">_</span> <span class="p">=&gt;</span> <span class="k">throw</span> <span class="k">new</span> <span class="n">ArgumentException</span><span class="p">(</span><span class="s">$&#34;Invalid cell type: {c}&#34;</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">        <span class="p">};</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span></code></pre></div><p>&hellip; and then update the <code>Grid</code> class:</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-csharp" data-lang="csharp"><span class="line"><span class="cl"><span class="kd">public</span> <span class="k">class</span> <span class="nc">Grid</span> <span class="p">:</span> <span class="n">IEnumerable</span><span class="p">&lt;</span><span class="n">ICell</span><span class="p">&gt;</span>
</span></span><span class="line"><span class="cl"><span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="kd">private</span> <span class="k">readonly</span> <span class="n">ICell</span><span class="p">[,]</span> <span class="n">_cells</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="c1">// ...</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="n">Grid</span><span class="p">(</span><span class="kt">char</span><span class="p">[,]</span> <span class="n">map</span><span class="p">,</span> <span class="n">ICellFactory</span> <span class="n">cellFactory</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">    <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="n">_cells</span> <span class="p">=</span> <span class="k">new</span> <span class="n">ICell</span><span class="p">[</span><span class="cm">/* ... */</span><span class="p">];</span>
</span></span><span class="line"><span class="cl">        <span class="k">for</span> <span class="p">(</span><span class="kt">var</span> <span class="n">y</span> <span class="p">=</span> <span class="m">0</span><span class="p">;</span> <span class="cm">/* ... */</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">            <span class="k">for</span> <span class="p">(</span><span class="kt">var</span> <span class="n">x</span> <span class="p">=</span> <span class="m">0</span><span class="p">;</span> <span class="cm">/* ... */</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">                <span class="n">_cells</span><span class="p">[</span><span class="n">x</span><span class="p">,</span> <span class="n">y</span><span class="p">]</span> <span class="p">=</span> <span class="n">cellFactory</span><span class="p">.</span><span class="n">CreateCell</span><span class="p">(</span><span class="n">x</span><span class="p">,</span> <span class="n">y</span><span class="p">,</span> <span class="n">map</span><span class="p">[</span><span class="n">y</span><span class="p">,</span> <span class="n">x</span><span class="p">]);</span> 
</span></span><span class="line"><span class="cl">                <span class="n">_cells</span><span class="p">[</span><span class="n">x</span><span class="p">,</span> <span class="n">y</span><span class="p">].</span><span class="n">Grid</span> <span class="p">=</span> <span class="k">this</span><span class="p">;</span>                
</span></span><span class="line"><span class="cl">                <span class="c1">// ...</span>
</span></span><span class="line"><span class="cl">            <span class="p">}</span>
</span></span><span class="line"><span class="cl">        <span class="p">}</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl">    
</span></span><span class="line"><span class="cl">    <span class="c1">// ...</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span></code></pre></div><p>Now, when instantiating a <code>Grid</code> object, we need to pass in a concrete <code>CellFactory</code> object:</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-csharp" data-lang="csharp"><span class="line"><span class="cl"><span class="kd">public</span> <span class="k">class</span> <span class="nc">Pathfinding</span>
</span></span><span class="line"><span class="cl"><span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="c1">// ...</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="n">Pathfinding</span><span class="p">()</span>
</span></span><span class="line"><span class="cl">    <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="n">_grid</span> <span class="p">=</span> <span class="k">new</span> <span class="n">Grid</span><span class="p">(</span><span class="n">_map</span><span class="p">,</span> <span class="k">new</span> <span class="n">CellFactory</span><span class="p">())</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">            <span class="n">StartPosition</span> <span class="p">=</span> <span class="k">new</span> <span class="n">Point</span><span class="p">(</span><span class="m">0</span><span class="p">,</span> <span class="m">10</span><span class="p">),</span>
</span></span><span class="line"><span class="cl">            <span class="n">TargetPosition</span> <span class="p">=</span> <span class="k">new</span> <span class="n">Point</span><span class="p">(</span><span class="m">5</span><span class="p">,</span> <span class="m">1</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">        <span class="p">};</span>
</span></span><span class="line"><span class="cl">        
</span></span><span class="line"><span class="cl">        <span class="c1">// ...</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span></code></pre></div><p>While this would work, it might seem a bit too much. For example, why create an <code>ICell</code> interface if there will only ever be
one concrete implementation and thus one concrete factory? At this point, it&rsquo;s not really clear what the <code>ICell</code>
interface is about, other than being used to decouple the <code>Grid</code> class from the concrete <code>Cell</code> implementation.
Furthermore, although we have removed the cyclic dependency at a technical level, it can be argued that it still exists
at a domain level. The question is, do we really need it at the domain level?</p>
<p>Let&rsquo;s look at another possible solution to our cyclic dependency problem which is to remove the cell&rsquo;s dependency on the
grid altogether.</p>
<h3 id="moving-the-grid-navigation-logic-to-its-own-class">Moving the Grid Navigation Logic to its own Class</h3>
<p>Here&rsquo;s another way to get rid of the cyclic dependency. If you take a look at the <code>Cell</code> class and why it depends on the
<code>Grid</code> class, you&rsquo;ll see it&rsquo;s because the cell uses the grid to navigate to neighboring cells.</p>
<p>One question that arises is
why is it the cell&rsquo;s responsibility to provide functionality for navigating around the grid? A possible answer to this
question is: Well, it shouldn&rsquo;t. The logic to navigate through the grid from a particular starting point could as well
be put in its own class. Doing so would also benefit the
<a href="https://en.wikipedia.org/wiki/Separation_of_concerns"
    
    
      target="_blank" class="external-link"
    
>separation of concerns</a>
 principle.</p>
<p>So, let&rsquo;s create a new class for this, called <code>GridNavigator</code>. Its sole purpose is to implement and expose the grid-navigation
functionality. Let&rsquo;s first update our little diagram:</p>
<figure class="center"><img src="/https/shendriks.dev/posts/2024-12-01-a-star-pathfinding-supplemental/images/grid-cell-dependency-03.svg"
			alt="The Grid Navigator"><figcaption>
			<p>The Grid Navigator</p>
		</figcaption>
</figure>

<p>Now, the <code>Cell</code> class has no more dependency on the grid. The navigation functionality is now located in the <code>GridNavigator</code>
class, which depends on the <code>Grid</code> class. Here&rsquo;s a possible implementation:</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-csharp" data-lang="csharp"><span class="line"><span class="cl"><span class="kd">public</span> <span class="k">class</span> <span class="nc">GridNavigator</span><span class="p">(</span><span class="n">Grid</span> <span class="n">grid</span><span class="p">)</span>
</span></span><span class="line"><span class="cl"><span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="kd">private</span> <span class="kt">int</span> <span class="n">_x</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">    <span class="kd">private</span> <span class="kt">int</span> <span class="n">_y</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="n">GridNavigator</span> <span class="n">StartAt</span><span class="p">(</span><span class="n">Cell</span> <span class="n">cell</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">    <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="n">_x</span> <span class="p">=</span> <span class="n">cell</span><span class="p">.</span><span class="n">X</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">        <span class="n">_y</span> <span class="p">=</span> <span class="n">cell</span><span class="p">.</span><span class="n">Y</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">        <span class="k">return</span> <span class="k">this</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl">    
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="n">GridNavigator</span> <span class="n">Up</span> <span class="p">=&gt;</span> <span class="n">MoveBy</span><span class="p">(</span><span class="m">0</span><span class="p">,</span> <span class="p">-</span><span class="m">1</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="n">GridNavigator</span> <span class="n">Down</span> <span class="p">=&gt;</span> <span class="n">MoveBy</span><span class="p">(</span><span class="m">0</span><span class="p">,</span> <span class="m">1</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="n">GridNavigator</span> <span class="n">Left</span> <span class="p">=&gt;</span> <span class="n">MoveBy</span><span class="p">(-</span><span class="m">1</span><span class="p">,</span> <span class="m">0</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="n">GridNavigator</span> <span class="n">Right</span> <span class="p">=&gt;</span> <span class="n">MoveBy</span><span class="p">(</span><span class="m">1</span><span class="p">,</span> <span class="m">0</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="n">GridNavigator</span> <span class="n">DownRight</span> <span class="p">=&gt;</span> <span class="n">MoveBy</span><span class="p">(</span><span class="m">1</span><span class="p">,</span> <span class="m">1</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="n">GridNavigator</span> <span class="n">DownLeft</span> <span class="p">=&gt;</span> <span class="n">MoveBy</span><span class="p">(-</span><span class="m">1</span><span class="p">,</span> <span class="m">1</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="n">GridNavigator</span> <span class="n">UpRight</span> <span class="p">=&gt;</span> <span class="n">MoveBy</span><span class="p">(</span><span class="m">1</span><span class="p">,</span> <span class="p">-</span><span class="m">1</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="n">GridNavigator</span> <span class="n">UpLeft</span> <span class="p">=&gt;</span> <span class="n">MoveBy</span><span class="p">(-</span><span class="m">1</span><span class="p">,</span> <span class="p">-</span><span class="m">1</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="n">GridNavigator</span> <span class="n">MoveBy</span><span class="p">(</span><span class="kt">int</span> <span class="n">deltaX</span><span class="p">,</span> <span class="kt">int</span> <span class="n">deltaY</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">    <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="n">_x</span> <span class="p">+=</span> <span class="n">deltaX</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">        <span class="n">_y</span> <span class="p">+=</span> <span class="n">deltaY</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">        <span class="k">return</span> <span class="k">this</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="n">Cell</span><span class="p">?</span> <span class="n">Cell</span> <span class="p">=&gt;</span> <span class="n">grid</span><span class="p">[</span><span class="n">_x</span><span class="p">,</span> <span class="n">_y</span><span class="p">];</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span></code></pre></div><p>The idea is to first kind of initialize the navigator by setting the starting cell with a call to <code>StartAt(cell)</code>. Then,
you can navigate through the grid by calling <code>Up</code>, <code>Down</code>, <code>Left</code>, etc.
The only thing these properties do is to call <code>MoveBy(dx, dy)</code> which in turn
updates an internal &ldquo;pointer&rdquo; into the grid. Only when you access the <code>Cell</code> property will you get the cell the
internal <code>_x</code> and <code>_y</code> indexes point to or <code>null</code> if we&rsquo;re off the grid. Here&rsquo;s an exemplatory usage of this:</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-csharp" data-lang="csharp"><span class="line"><span class="cl"><span class="c1">// ...</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="kt">var</span> <span class="n">gridNavigator</span> <span class="p">=</span> <span class="k">new</span> <span class="n">GridNavigator</span><span class="p">(</span><span class="n">grid</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="kt">var</span> <span class="n">neighbor</span> <span class="p">=</span> <span class="n">gridNavigator</span><span class="p">.</span><span class="n">StartAt</span><span class="p">(</span><span class="n">cell</span><span class="p">).</span><span class="n">Up</span><span class="p">.</span><span class="n">Right</span><span class="p">.</span><span class="n">Right</span><span class="p">.</span><span class="n">Up</span><span class="p">.</span><span class="n">Cell</span><span class="p">;</span>
</span></span><span class="line"><span class="cl"><span class="kt">var</span> <span class="n">anotherNeighbor</span> <span class="p">=</span> <span class="n">gridNavigator</span><span class="p">.</span><span class="n">StartAt</span><span class="p">(</span><span class="n">anotherCell</span><span class="p">).</span><span class="n">Down</span><span class="p">.</span><span class="n">Left</span><span class="p">.</span><span class="n">Cell</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="c1">// ...</span>
</span></span></code></pre></div><p>The interface kind of resembles the <a href="https://en.wikipedia.org/wiki/Builder_pattern"
    
    
      target="_blank" class="external-link"
    
>builder pattern</a>
, when you think
about it. (Well, it&rsquo;s not really a builder to be honest, because it doesn&rsquo;t build anything, it just returns an existing
object or <code>null</code>.) One little downside of the <code>GridNavigator</code> above is the slight risk of misuse. When using it, you must
first call the <code>StartAt()</code> method to initialize the navigation logic. Failure to do so can lead to unpredictable results.</p>
<p>So, to reduce the risk of misuse, we could go even further in the direction of the builder pattern and instantiate a
new navigator object each time we need to find the neighbors of a particular cell. (It still isn&rsquo;t a builder, though.)
Let&rsquo;s look at the code:</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-csharp" data-lang="csharp"><span class="line"><span class="cl"><span class="kd">public</span> <span class="k">class</span> <span class="nc">GridNavigator</span><span class="p">(</span><span class="n">Grid</span> <span class="n">grid</span><span class="p">,</span> <span class="n">Cell</span> <span class="n">cell</span><span class="p">)</span>
</span></span><span class="line"><span class="cl"><span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="kd">private</span> <span class="kt">int</span> <span class="n">_x</span> <span class="p">=</span> <span class="n">cell</span><span class="p">.</span><span class="n">X</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">    <span class="kd">private</span> <span class="kt">int</span> <span class="n">_y</span> <span class="p">=</span> <span class="n">cell</span><span class="p">.</span><span class="n">Y</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="n">GridNavigator</span> <span class="n">Up</span> <span class="p">=&gt;</span> <span class="n">MoveBy</span><span class="p">(</span><span class="m">0</span><span class="p">,</span> <span class="p">-</span><span class="m">1</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="n">GridNavigator</span> <span class="n">Down</span> <span class="p">=&gt;</span> <span class="n">MoveBy</span><span class="p">(</span><span class="m">0</span><span class="p">,</span> <span class="m">1</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="n">GridNavigator</span> <span class="n">Left</span> <span class="p">=&gt;</span> <span class="n">MoveBy</span><span class="p">(-</span><span class="m">1</span><span class="p">,</span> <span class="m">0</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="n">GridNavigator</span> <span class="n">Right</span> <span class="p">=&gt;</span> <span class="n">MoveBy</span><span class="p">(</span><span class="m">1</span><span class="p">,</span> <span class="m">0</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="n">GridNavigator</span> <span class="n">DownRight</span> <span class="p">=&gt;</span> <span class="n">MoveBy</span><span class="p">(</span><span class="m">1</span><span class="p">,</span> <span class="m">1</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="n">GridNavigator</span> <span class="n">DownLeft</span> <span class="p">=&gt;</span> <span class="n">MoveBy</span><span class="p">(-</span><span class="m">1</span><span class="p">,</span> <span class="m">1</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="n">GridNavigator</span> <span class="n">UpRight</span> <span class="p">=&gt;</span> <span class="n">MoveBy</span><span class="p">(</span><span class="m">1</span><span class="p">,</span> <span class="p">-</span><span class="m">1</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="n">GridNavigator</span> <span class="n">UpLeft</span> <span class="p">=&gt;</span> <span class="n">MoveBy</span><span class="p">(-</span><span class="m">1</span><span class="p">,</span> <span class="p">-</span><span class="m">1</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="n">GridNavigator</span> <span class="n">MoveBy</span><span class="p">(</span><span class="kt">int</span> <span class="n">deltaX</span><span class="p">,</span> <span class="kt">int</span> <span class="n">deltaY</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">    <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="n">_x</span> <span class="p">+=</span> <span class="n">deltaX</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">        <span class="n">_y</span> <span class="p">+=</span> <span class="n">deltaY</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">        <span class="k">return</span> <span class="k">this</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="n">Cell</span><span class="p">?</span> <span class="n">Cell</span> <span class="p">=&gt;</span> <span class="n">grid</span><span class="p">[</span><span class="n">_x</span><span class="p">,</span> <span class="n">_y</span><span class="p">];</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span></code></pre></div><p>In the code example above we removed the <code>StartAt</code> method and instead inject the starting cell into the constructor.
Usage would now look like this:</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-csharp" data-lang="csharp"><span class="line"><span class="cl"><span class="c1">// ...</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="kt">var</span> <span class="n">neighbor</span> <span class="p">=</span> <span class="k">new</span> <span class="n">GridNavigator</span><span class="p">(</span><span class="n">grid</span><span class="p">,</span> <span class="n">cell</span><span class="p">).</span><span class="n">Up</span><span class="p">.</span><span class="n">Right</span><span class="p">.</span><span class="n">Right</span><span class="p">.</span><span class="n">Up</span><span class="p">.</span><span class="n">Cell</span><span class="p">;</span>
</span></span><span class="line"><span class="cl"><span class="kt">var</span> <span class="n">anotherNeighbor</span> <span class="p">=</span> <span class="k">new</span> <span class="n">GridNavigator</span><span class="p">(</span><span class="n">grid</span><span class="p">,</span> <span class="n">anotherCell</span><span class="p">).</span><span class="n">Down</span><span class="p">.</span><span class="n">Left</span><span class="p">.</span><span class="n">Cell</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="c1">// ...</span>
</span></span></code></pre></div><p>You get the idea. However, since we have a lot of cells, we&rsquo;d have to instantiate a lot of <code>GridNavigator</code> objects,
which might come at the cost of poorer performance and it also seems like a waste of main memory.</p>
<p>That&rsquo;s the thing about quality requirements. You can&rsquo;t turn them all to 11 at the same time.</p>
<div class="notice note" >
    <p class="notice-title">
        <span class="icon-notice baseline">
            <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 128 300 300">
  <path d="M150 128c82.813 0 150 67.188 150 150 0 82.813-67.188 150-150 150C67.187 428 0 360.812 0 278c0-82.813 67.188-150 150-150Zm25 243.555v-37.11c0-3.515-2.734-6.445-6.055-6.445h-37.5c-3.515 0-6.445 2.93-6.445 6.445v37.11c0 3.515 2.93 6.445 6.445 6.445h37.5c3.32 0 6.055-2.93 6.055-6.445Zm-.39-67.188 3.515-121.289c0-1.367-.586-2.734-1.953-3.516-1.172-.976-2.93-1.562-4.688-1.562h-42.968c-1.758 0-3.516.586-4.688 1.563-1.367.78-1.953 2.148-1.953 3.515l3.32 121.29c0 2.734 2.93 4.882 6.64 4.882h36.134c3.515 0 6.445-2.148 6.64-4.883Z"/>
</svg>

        </span>Note</p><p>You&rsquo;ll find the alternate implementation with the <code>GridNavigator</code> class on
<a href="https://github.com/shendriks/pathfinding-2d/tree/main/SideView.GridNavigator.BlazorGL"
    
    
      target="_blank" class="external-link"
    
>GitHub</a>

in the project <code>SideView.GridNavigator.BlazorGL</code>. It contains only the classes that differ from
the side-view project (<code>Cell</code>, <code>Grid</code>, <code>GridNavigator</code>, <code>NeighborFinder</code> and <code>Pathfinding</code>)
and shares everything else with it.</p></div>

<h3 id="is-it-all-worth-it">Is it all worth it?</h3>
<p>The question is, what are your quality requirements? Especially in game development, performance can be a key quality
requirement, in which case you might want to do without the <code>GridNavigator</code>, all the fancy, well-named methods for
convenient navigation, and just manipulate array indexes directly. But that depends on the game and the specific (quality)
requirements.</p>
<h2 id="conclusion">Conclusion</h2>
<p>We looked at the cyclic dependency between the grid and its cells. In a first attempt we removed the dependency at a
technical level by using dependency inversion. In a second attempt we removed the dependency altogether by extracting the
navigation logic into a separate class. We also took a brief look at the fact that there are quality requirements that
have a negative impact on each other, e.g. performance and maintainability.</p>
]]></content></item><item><title>A* Pathfinding in 2D Games: From Top-Down to Side-View</title><link>https://shendriks.dev/posts/2024-09-04-a-star-pathfinding-side-view/</link><pubDate>Wed, 04 Sep 2024 00:00:00 +0000</pubDate><guid>https://shendriks.dev/posts/2024-09-04-a-star-pathfinding-side-view/</guid><description>Implementing the A* algorithm for pathfinding in a 2D side-scrolling platformer with gravity, ladders and hanging bars.</description><content type="html"><![CDATA[<h2 id="introduction">Introduction</h2>
<p>In the last two articles of this series we looked at how the A* search algorithm can be applied to a simple top-down
scenario. Now let&rsquo;s finally look at what needs to change for a side-view platformer game. We will implement an example
application in <a href="https://monogame.net/"
    
    
      target="_blank" class="external-link"
    
>MonoGame</a>
 / <a href="https://github.com/kniEngine/kni"
    
    
      target="_blank" class="external-link"
    
>KNI</a>
. For this, we will update the code from the
<a href="/https/shendriks.dev/posts/2024-08-24-a-star-pathfinding-top-down-blazorgl/"
    
    
>last post</a>
.</p>
<div class="notice note" >
    <p class="notice-title">
        <span class="icon-notice baseline">
            <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 128 300 300">
  <path d="M150 128c82.813 0 150 67.188 150 150 0 82.813-67.188 150-150 150C67.187 428 0 360.812 0 278c0-82.813 67.188-150 150-150Zm25 243.555v-37.11c0-3.515-2.734-6.445-6.055-6.445h-37.5c-3.515 0-6.445 2.93-6.445 6.445v37.11c0 3.515 2.93 6.445 6.445 6.445h37.5c3.32 0 6.055-2.93 6.055-6.445Zm-.39-67.188 3.515-121.289c0-1.367-.586-2.734-1.953-3.516-1.172-.976-2.93-1.562-4.688-1.562h-42.968c-1.758 0-3.516.586-4.688 1.563-1.367.78-1.953 2.148-1.953 3.515l3.32 121.29c0 2.734 2.93 4.882 6.64 4.882h36.134c3.515 0 6.445-2.148 6.64-4.883Z"/>
</svg>

        </span>Note</p><p>You don&rsquo;t have to manually copy code snippets around. The complete project is available on <a href="https://github.com/shendriks/pathfinding-2d"
    
    
      target="_blank" class="external-link"
    
>GitHub</a>
.</p></div>

<h2 id="what-seems-to-be-the-problem-with-side-view">What Seems to Be the Problem with Side-View?</h2>
<p>First of all, in a typical side-view platformer scenario, gravity is involved, pulling every game object down to
the ground. This means that, unlike in a top-down view, a character can&rsquo;t just keep going up cells until they reach
the ceiling. (Unless the character has the ability to fly, of course. But we&rsquo;re limiting ourselves to humanoid bipeds
without wings, or a jetpack, or a magic potion that defies gravity.) The only way to move upwards would be to jump or
to climb a ladder. Another limitation is that the character needs ground under their feet to walk sideways.</p>
<p>In summary the following can be said:</p>
<ul>
<li>There is gravity involved, which limits how a character can move.</li>
<li>The character may or may not have certain capabilities such as walking, jumping, climbing ladders and using hanging bars.</li>
<li>Certain cell types can help the character to overcome specific restrictions, such as
ladders and hanging bars with which the character can defy gravity.</li>
</ul>
<h2 id="cell-types-and-capabilities">Cell Types and Capabilities</h2>
<p>We&rsquo;ll start with the cell types. Before, in the top-down world, we only had two types of cells: free and blocked. Now,
in our little side-view world, we have the following four cell types: empty, blocked, ladder and hanging bar.
Here&rsquo;s an example of what this might look like:</p>
<figure class="center"><img src="/https/shendriks.dev/posts/2024-09-04-a-star-pathfinding-side-view/images/example.png"
			alt="An example of a side-view game world"><figcaption>
			<p>An example of a side-view game world</p>
		</figcaption>
</figure>

<p>Here are the properties of the different cell types:</p>
<ul>
<li><figure class="list-item-image"><img src="/https/shendriks.dev/posts/2024-09-04-a-star-pathfinding-side-view/images/CellEmpty.png">
</figure>
 An empty cell can obviously be occupied by the game character</li>
<li><figure class="list-item-image"><img src="/https/shendriks.dev/posts/2024-09-04-a-star-pathfinding-side-view/images/CellBlock.png">
</figure>
 A block, on the other hand, cannot. The character cannot pass through it.</li>
<li><figure class="list-item-image"><img src="/https/shendriks.dev/posts/2024-09-04-a-star-pathfinding-side-view/images/CellLadder.png">
</figure>
 A ladder can be used to climb up or down</li>
<li><figure class="list-item-image"><img src="/https/shendriks.dev/posts/2024-09-04-a-star-pathfinding-side-view/images/CellHangingBar.png">
</figure>
 Hanging bars can be used to move sideways</li>
</ul>
<p>Let&rsquo;s further assume that the character has the following capabilities:</p>
<ol>
<li>Walk sideways</li>
<li>Climb ladders up and down and maybe even sideways</li>
<li>Swing along hanging bars</li>
<li>Jump sideways</li>
</ol>
<p>Furthermore, certain capabilities could be switched on and off. For example, the character might not be able to jump at the
beginning. This ability could be unlocked later, e.g. through a power-up.</p>
<h3 id="walking-climbing-swinging-and-falling">Walking, Climbing, Swinging (and Falling)</h3>
<p>Let&rsquo;s take a closer look on how we can move without jumping and what that means in terms of neighborhood:</p>
<p><div class="flex-container">
<figure class="flex-item flex-item-4"><img src="/https/shendriks.dev/posts/2024-09-04-a-star-pathfinding-side-view/images/neighbourhood-a.svg"
			alt="When the cell below is empty, then gravity takes over and the character is pulled down to the ground, which can be interpreted as &rsquo;the character can go down a cell if that cell is empty&#39;." width="100%"><figcaption>
			<p>When the cell below is empty, then gravity takes over and the character is pulled down to the ground, which can be interpreted as &rsquo;the character can go down a cell if that cell is empty'.</p>
		</figcaption>
</figure>

<figure class="flex-item flex-item-4"><img src="/https/shendriks.dev/posts/2024-09-04-a-star-pathfinding-side-view/images/neighbourhood-b.svg"
			alt="When there is ground below and the laterally adjoining cell is free, a ladder or a hanging bar, the character can walk in that direction." width="100%"><figcaption>
			<p>When there is ground below and the laterally adjoining cell is free, a ladder or a hanging bar, the character can walk in that direction.</p>
		</figcaption>
</figure>

<figure class="flex-item flex-item-4"><img src="/https/shendriks.dev/posts/2024-09-04-a-star-pathfinding-side-view/images/neighbourhood-c.svg"
			alt="When the character is on a ladder, they can walk up and down and can also walk to the side, if the respective side is empty (or also a ladder or a hanging bar)." width="100%"><figcaption>
			<p>When the character is on a ladder, they can walk up and down and can also walk to the side, if the respective side is empty (or also a ladder or a hanging bar).</p>
		</figcaption>
</figure>

<figure class="flex-item flex-item-4"><img src="/https/shendriks.dev/posts/2024-09-04-a-star-pathfinding-side-view/images/neighbourhood-d.svg"
			alt="When the character has grabbed the hanging bars, they can move sideways or they can let loose and fall down." width="100%"><figcaption>
			<p>When the character has grabbed the hanging bars, they can move sideways or they can let loose and fall down.</p>
		</figcaption>
</figure>

</div></p>
<h3 id="integrating-jumps">Integrating Jumps</h3>
<div class="notice note" >
    <p class="notice-title">
        <span class="icon-notice baseline">
            <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 128 300 300">
  <path d="M150 128c82.813 0 150 67.188 150 150 0 82.813-67.188 150-150 150C67.187 428 0 360.812 0 278c0-82.813 67.188-150 150-150Zm25 243.555v-37.11c0-3.515-2.734-6.445-6.055-6.445h-37.5c-3.515 0-6.445 2.93-6.445 6.445v37.11c0 3.515 2.93 6.445 6.445 6.445h37.5c3.32 0 6.055-2.93 6.055-6.445Zm-.39-67.188 3.515-121.289c0-1.367-.586-2.734-1.953-3.516-1.172-.976-2.93-1.562-4.688-1.562h-42.968c-1.758 0-3.516.586-4.688 1.563-1.367.78-1.953 2.148-1.953 3.515l3.32 121.29c0 2.734 2.93 4.882 6.64 4.882h36.134c3.515 0 6.445-2.148 6.64-4.883Z"/>
</svg>

        </span>Note</p><p>Jumping can be implemented very differently in terms of height, distance, speed, etc. This results in individual jump
paths depending on the specific implementation. In addition, jumps of different heights and distances or even double jumps could also be possible.
The goal of this article is to explain the basic principle in a simple way, so we&rsquo;ll keep things as straightforward as possible.
It&rsquo;s even possible that, based on the colliders you&rsquo;ve implemented, the trajectory we&rsquo;ve used here, which is a bit
idealized, doesn&rsquo;t allow a jump at all because the character bounces off the edge of a block, for example.  We will
generously ignore this here and leave it to the reader to find a jump trajectory that works for their use case.</p></div>

<p>To simplify things a bit, let&rsquo;s limit the jump capability to the following: the character can jump two cells high and
three cells to the side. Here are three example obstacles the character can overcome by jumping:</p>
<p><div class="flex-container">
<figure class="flex-item flex-item-3"><img src="/https/shendriks.dev/posts/2024-09-04-a-star-pathfinding-side-view/images/jumping-01-a.svg"
			alt="Jump onto a platform that&rsquo;s no more than two cells higher." width="100%"><figcaption>
			<p>Jump onto a platform that&rsquo;s no more than two cells higher.</p>
		</figcaption>
</figure>

<figure class="flex-item flex-item-3"><img src="/https/shendriks.dev/posts/2024-09-04-a-star-pathfinding-side-view/images/jumping-01-b.svg"
			alt="Jump over a wall that&rsquo;s no more than two cells high." width="100%"><figcaption>
			<p>Jump over a wall that&rsquo;s no more than two cells high.</p>
		</figcaption>
</figure>

<figure class="flex-item flex-item-3"><img src="/https/shendriks.dev/posts/2024-09-04-a-star-pathfinding-side-view/images/jumping-01-c.svg"
			alt="Jump over a pit that&rsquo;s no more than three cells wide." width="100%"><figcaption>
			<p>Jump over a pit that&rsquo;s no more than three cells wide.</p>
		</figcaption>
</figure>

</div></p>
<p>Looking at the example of a jump over a pit, we can see how the neighboring cells and the costs of reaching them are determined.</p>
<p><div class="flex-container">
<figure class="flex-item flex-item-3"><img src="/https/shendriks.dev/posts/2024-09-04-a-star-pathfinding-side-view/images/jumping-02-a.svg"
			alt="Each cell the jump trajectory is going through &hellip;" width="100%"><figcaption>
			<p>Each cell the jump trajectory is going through &hellip;</p>
		</figcaption>
</figure>

<figure class="flex-item flex-item-3"><img src="/https/shendriks.dev/posts/2024-09-04-a-star-pathfinding-side-view/images/jumping-02-b.svg"
			alt="&hellip; is considered a neighboring cell which is reachable." width="100%"><figcaption>
			<p>&hellip; is considered a neighboring cell which is reachable.</p>
		</figcaption>
</figure>

<figure class="flex-item flex-item-3"><img src="/https/shendriks.dev/posts/2024-09-04-a-star-pathfinding-side-view/images/jumping-02-c.svg"
			alt="The cost is calculated by applying the accumulated manhattan distance." width="100%"><figcaption>
			<p>The cost is calculated by applying the accumulated manhattan distance.</p>
		</figcaption>
</figure>

</div></p>
<p>If there is a block in the jump trajectory, the jump ends there:</p>
<p><div class="flex-container">
<figure class="flex-item flex-item-3"><img src="/https/shendriks.dev/posts/2024-09-04-a-star-pathfinding-side-view/images/jumping-03-a.svg" width="100%">
</figure>

<figure class="flex-item flex-item-3"><img src="/https/shendriks.dev/posts/2024-09-04-a-star-pathfinding-side-view/images/jumping-03-b.svg" width="100%">
</figure>

<figure class="flex-item flex-item-3"><img src="/https/shendriks.dev/posts/2024-09-04-a-star-pathfinding-side-view/images/jumping-03-c.svg" width="100%">
</figure>

</div></p>
<p>As you can see the number of neighbors is less compared to a &ldquo;full&rdquo; jump.</p>
<h2 id="lets-code">Let&rsquo;s Code!</h2>
<p>Now that we have an idea of how the concept of neighboring cells needs to change, we can cast that in code.</p>
<h3 id="updating-the-cell-class">Updating the <code>Cell</code> Class</h3>
<p>First of all, the <code>Cell</code> class from the last post needs another update. Instead of the walkabilty flag we now
need a cell type which will be implemented with an <code>enum</code>:</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-csharp" data-lang="csharp"><span class="line"><span class="cl"><span class="kd">public</span> <span class="kd">enum</span> <span class="n">CellType</span>
</span></span><span class="line"><span class="cl"><span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="n">Empty</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">    <span class="n">Block</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">    <span class="n">Ladder</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">    <span class="n">HangingBar</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span></code></pre></div><p>Here is the first update to the <code>Cell</code> class:</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-csharp" data-lang="csharp"><span class="line"><span class="cl"><span class="kd">public</span> <span class="k">class</span> <span class="nc">Cell</span><span class="p">(</span><span class="kt">int</span> <span class="n">x</span><span class="p">,</span> <span class="kt">int</span> <span class="n">y</span><span class="p">,</span> <span class="n">CellType</span> <span class="n">type</span><span class="p">)</span>
</span></span><span class="line"><span class="cl"><span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="c1">// ...</span>
</span></span><span class="line"><span class="cl">    
</span></span><span class="line"><span class="cl">    <span class="kd">private</span> <span class="n">CellType</span> <span class="n">_type</span> <span class="p">=</span> <span class="n">type</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="n">CellType</span> <span class="n">Type</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="k">get</span> <span class="p">=&gt;</span> <span class="n">_type</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">        <span class="k">set</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">            <span class="k">if</span> <span class="p">(</span><span class="k">value</span> <span class="p">==</span> <span class="n">_type</span><span class="p">)</span> <span class="k">return</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">            <span class="n">CellTypeChanged</span><span class="p">?.</span><span class="n">Invoke</span><span class="p">();</span>
</span></span><span class="line"><span class="cl">            <span class="n">_type</span> <span class="p">=</span> <span class="k">value</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">        <span class="p">}</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl">    
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="kt">bool</span> <span class="n">IsEmpty</span> <span class="p">=&gt;</span> <span class="n">Type</span> <span class="p">==</span> <span class="n">CellType</span><span class="p">.</span><span class="n">Empty</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="kt">bool</span> <span class="n">IsBlock</span> <span class="p">=&gt;</span> <span class="n">Type</span> <span class="p">==</span> <span class="n">CellType</span><span class="p">.</span><span class="n">Block</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="kt">bool</span> <span class="n">IsLadder</span> <span class="p">=&gt;</span> <span class="n">Type</span> <span class="p">==</span> <span class="n">CellType</span><span class="p">.</span><span class="n">Ladder</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="kt">bool</span> <span class="n">IsHangingBar</span> <span class="p">=&gt;</span> <span class="n">Type</span> <span class="p">==</span> <span class="n">CellType</span><span class="p">.</span><span class="n">HangingBar</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">    
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="k">event</span> <span class="n">Action</span><span class="p">?</span> <span class="n">CellTypeChanged</span><span class="p">;</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span></code></pre></div><p>We added a public property <code>Type</code> for getting and also setting the cell type. Setting of a cell type is going to happen
via the level editor. When the cell type changes, we invoke a <code>CellTypeChanged</code> event.</p>
<p>In addition we added a few convenience properties for easily checking if the cell is empty or a block and so on.</p>
<p>Now, let&rsquo;s take another look at the example diagrams above. You will notice that compared to the simpler top-down case
it is no longer sufficient to just look at the cells that are direct neighbors of the current cell. We need a way to
traverse through the grid from a specific cell so we&rsquo;re able to look at a neighbor&rsquo;s neighbor and then at the neighbor
of the neighbor&rsquo;s neighbor and so on.</p>
<p>Instead of fiddling with the grid in the find-neighbor-logic, we will extend the <code>Cell</code> class even further and
add some properties that let us go easily into a certain direction from that cell. The fiddling will then be
done and hidden in these properties. For this, the <code>Cell</code> needs to be aware of the <code>Grid</code> it is part of.</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-csharp" data-lang="csharp"><span class="line"><span class="cl"><span class="kd">public</span> <span class="k">class</span> <span class="nc">Cell</span><span class="p">(</span><span class="kt">int</span> <span class="n">x</span><span class="p">,</span> <span class="kt">int</span> <span class="n">y</span><span class="p">,</span> <span class="n">CellType</span> <span class="n">type</span><span class="p">,</span> <span class="n">Grid</span> <span class="n">grid</span><span class="p">)</span>
</span></span><span class="line"><span class="cl"><span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="c1">// ...</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="n">Cell</span><span class="p">?</span> <span class="n">NeighborAt</span><span class="p">(</span><span class="kt">int</span> <span class="n">deltaX</span><span class="p">,</span> <span class="kt">int</span> <span class="n">deltaY</span><span class="p">)</span> <span class="p">=&gt;</span> <span class="n">grid</span><span class="p">[</span><span class="n">X</span> <span class="p">+</span> <span class="n">deltaX</span><span class="p">,</span> <span class="n">Y</span> <span class="p">+</span> <span class="n">deltaY</span><span class="p">];</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="n">Cell</span><span class="p">?</span> <span class="n">Up</span> <span class="p">=&gt;</span> <span class="n">NeighborAt</span><span class="p">(</span><span class="m">0</span><span class="p">,</span> <span class="p">-</span><span class="m">1</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="n">Cell</span><span class="p">?</span> <span class="n">Down</span> <span class="p">=&gt;</span> <span class="n">NeighborAt</span><span class="p">(</span><span class="m">0</span><span class="p">,</span> <span class="m">1</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="n">Cell</span><span class="p">?</span> <span class="n">Left</span> <span class="p">=&gt;</span> <span class="n">NeighborAt</span><span class="p">(-</span><span class="m">1</span><span class="p">,</span> <span class="m">0</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="n">Cell</span><span class="p">?</span> <span class="n">Right</span> <span class="p">=&gt;</span> <span class="n">NeighborAt</span><span class="p">(</span><span class="m">1</span><span class="p">,</span> <span class="m">0</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="n">Cell</span><span class="p">?</span> <span class="n">DownRight</span> <span class="p">=&gt;</span> <span class="n">NeighborAt</span><span class="p">(</span><span class="m">1</span><span class="p">,</span> <span class="m">1</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="n">Cell</span><span class="p">?</span> <span class="n">DownLeft</span> <span class="p">=&gt;</span> <span class="n">NeighborAt</span><span class="p">(-</span><span class="m">1</span><span class="p">,</span> <span class="m">1</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="n">Cell</span><span class="p">?</span> <span class="n">UpRight</span> <span class="p">=&gt;</span> <span class="n">NeighborAt</span><span class="p">(</span><span class="m">1</span><span class="p">,</span> <span class="p">-</span><span class="m">1</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="n">Cell</span><span class="p">?</span> <span class="n">UpLeft</span> <span class="p">=&gt;</span> <span class="n">NeighborAt</span><span class="p">(-</span><span class="m">1</span><span class="p">,</span> <span class="p">-</span><span class="m">1</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">    
</span></span><span class="line"><span class="cl">    <span class="c1">// ...</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span></code></pre></div><p>As you can see we added a <code>Grid</code> parameter to the primary constructor. Then, there are a handful of properties for going up,
down, left, right, etc. from the cell and get the adjoining cell, if there is one, in the respective direction. If we
leave the grid, <code>null</code> is returned.</p>
<h3 id="updating-the-grid-class">Updating the <code>Grid</code> Class</h3>
<p>The <code>Grid</code> class also needs an update. Here is the class boiled down to the changes needed to add support for the new
cell types:</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-csharp" data-lang="csharp"><span class="line"><span class="cl"><span class="kd">public</span> <span class="k">class</span> <span class="nc">Grid</span>
</span></span><span class="line"><span class="cl"><span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="c1">// ...</span>
</span></span><span class="line"><span class="cl">    
</span></span><span class="line"><span class="cl">    <span class="kd">private</span> <span class="k">readonly</span> <span class="n">Cell</span><span class="p">[,]</span> <span class="n">_cells</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="k">event</span> <span class="n">Action</span><span class="p">?</span> <span class="n">GridChanged</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="n">Grid</span><span class="p">(</span><span class="kt">char</span><span class="p">[,]</span> <span class="n">map</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">    <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="k">if</span> <span class="p">(</span><span class="n">map</span><span class="p">.</span><span class="n">Length</span> <span class="p">==</span> <span class="m">0</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">            <span class="k">throw</span> <span class="k">new</span> <span class="n">ArgumentException</span><span class="p">(</span><span class="s">$&#34;{nameof(map)} must contain at least 1 element&#34;</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">        <span class="p">}</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">        <span class="n">_cells</span> <span class="p">=</span> <span class="k">new</span> <span class="n">Cell</span><span class="p">[</span><span class="n">map</span><span class="p">.</span><span class="n">GetLength</span><span class="p">(</span><span class="m">1</span><span class="p">),</span> <span class="n">map</span><span class="p">.</span><span class="n">GetLength</span><span class="p">(</span><span class="m">0</span><span class="p">)];</span>
</span></span><span class="line"><span class="cl">        <span class="k">for</span> <span class="p">(</span><span class="kt">var</span> <span class="n">y</span> <span class="p">=</span> <span class="m">0</span><span class="p">;</span> <span class="n">y</span> <span class="p">&lt;</span> <span class="n">map</span><span class="p">.</span><span class="n">GetLength</span><span class="p">(</span><span class="m">0</span><span class="p">);</span> <span class="n">y</span><span class="p">++)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">            <span class="k">for</span> <span class="p">(</span><span class="kt">var</span> <span class="n">x</span> <span class="p">=</span> <span class="m">0</span><span class="p">;</span> <span class="n">x</span> <span class="p">&lt;</span> <span class="n">map</span><span class="p">.</span><span class="n">GetLength</span><span class="p">(</span><span class="m">1</span><span class="p">);</span> <span class="n">x</span><span class="p">++)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">                <span class="n">_cells</span><span class="p">[</span><span class="n">x</span><span class="p">,</span> <span class="n">y</span><span class="p">]</span> <span class="p">=</span> <span class="k">new</span> <span class="n">Cell</span><span class="p">(</span><span class="n">x</span><span class="p">,</span> <span class="n">y</span><span class="p">,</span> <span class="n">CellTypeFromChar</span><span class="p">(</span><span class="n">map</span><span class="p">[</span><span class="n">y</span><span class="p">,</span> <span class="n">x</span><span class="p">]),</span> <span class="k">this</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">                <span class="n">_cells</span><span class="p">[</span><span class="n">x</span><span class="p">,</span> <span class="n">y</span><span class="p">].</span><span class="n">CellTypeChanged</span> <span class="p">+=</span> <span class="p">()</span> <span class="p">=&gt;</span> <span class="n">GridChanged</span><span class="p">?.</span><span class="n">Invoke</span><span class="p">();</span>
</span></span><span class="line"><span class="cl">            <span class="p">}</span>
</span></span><span class="line"><span class="cl">        <span class="p">}</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="kd">private</span> <span class="kd">static</span> <span class="n">CellType</span> <span class="n">CellTypeFromChar</span><span class="p">(</span><span class="kt">char</span> <span class="n">c</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">    <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="k">return</span> <span class="n">c</span> <span class="k">switch</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">            <span class="sc">&#39; &#39;</span> <span class="p">=&gt;</span> <span class="n">CellType</span><span class="p">.</span><span class="n">Empty</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">            <span class="sc">&#39;B&#39;</span> <span class="p">=&gt;</span> <span class="n">CellType</span><span class="p">.</span><span class="n">Block</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">            <span class="sc">&#39;L&#39;</span> <span class="p">=&gt;</span> <span class="n">CellType</span><span class="p">.</span><span class="n">Ladder</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">            <span class="sc">&#39;H&#39;</span> <span class="p">=&gt;</span> <span class="n">CellType</span><span class="p">.</span><span class="n">HangingBar</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">            <span class="n">_</span> <span class="p">=&gt;</span> <span class="k">throw</span> <span class="k">new</span> <span class="n">ArgumentException</span><span class="p">(</span><span class="s">$&#34;Invalid cell type: {c}&#34;</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">        <span class="p">};</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl">    
</span></span><span class="line"><span class="cl">    <span class="c1">// ...</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span></code></pre></div><p>First of all we got rid of the static constructor <code>CreateFromArray</code> and instead made the constructor public.
You&rsquo;ll also see that the map array now contains <code>char</code>s instead of <code>int</code>s, and we need to map certain characters to
certain cell types, which is implemented in <code>CellTypeFromChar</code>. This allows us to instantiate the example grid like so:</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-csharp" data-lang="csharp"><span class="line"><span class="cl"><span class="kd">public</span> <span class="k">class</span> <span class="nc">Pathfinding</span>
</span></span><span class="line"><span class="cl"><span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="c1">// ...</span>
</span></span><span class="line"><span class="cl">    
</span></span><span class="line"><span class="cl">    <span class="kd">private</span> <span class="k">readonly</span> <span class="kt">char</span><span class="p">[,]</span> <span class="n">_map</span> <span class="p">=</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="p">{</span> <span class="sc">&#39; &#39;</span><span class="p">,</span> <span class="sc">&#39; &#39;</span><span class="p">,</span> <span class="sc">&#39; &#39;</span><span class="p">,</span> <span class="sc">&#39; &#39;</span><span class="p">,</span> <span class="sc">&#39; &#39;</span><span class="p">,</span> <span class="sc">&#39; &#39;</span><span class="p">,</span> <span class="sc">&#39; &#39;</span><span class="p">,</span> <span class="sc">&#39;B&#39;</span><span class="p">,</span> <span class="sc">&#39;B&#39;</span><span class="p">,</span> <span class="sc">&#39;B&#39;</span> <span class="p">},</span>
</span></span><span class="line"><span class="cl">        <span class="p">{</span> <span class="sc">&#39; &#39;</span><span class="p">,</span> <span class="sc">&#39; &#39;</span><span class="p">,</span> <span class="sc">&#39; &#39;</span><span class="p">,</span> <span class="sc">&#39; &#39;</span><span class="p">,</span> <span class="sc">&#39; &#39;</span><span class="p">,</span> <span class="sc">&#39; &#39;</span><span class="p">,</span> <span class="sc">&#39; &#39;</span><span class="p">,</span> <span class="sc">&#39;H&#39;</span><span class="p">,</span> <span class="sc">&#39;H&#39;</span><span class="p">,</span> <span class="sc">&#39;L&#39;</span> <span class="p">},</span>
</span></span><span class="line"><span class="cl">        <span class="p">{</span> <span class="sc">&#39; &#39;</span><span class="p">,</span> <span class="sc">&#39; &#39;</span><span class="p">,</span> <span class="sc">&#39; &#39;</span><span class="p">,</span> <span class="sc">&#39; &#39;</span><span class="p">,</span> <span class="sc">&#39;B&#39;</span><span class="p">,</span> <span class="sc">&#39;B&#39;</span><span class="p">,</span> <span class="sc">&#39;B&#39;</span><span class="p">,</span> <span class="sc">&#39; &#39;</span><span class="p">,</span> <span class="sc">&#39; &#39;</span><span class="p">,</span> <span class="sc">&#39;L&#39;</span> <span class="p">},</span>
</span></span><span class="line"><span class="cl">        <span class="p">{</span> <span class="sc">&#39;B&#39;</span><span class="p">,</span> <span class="sc">&#39;B&#39;</span><span class="p">,</span> <span class="sc">&#39; &#39;</span><span class="p">,</span> <span class="sc">&#39; &#39;</span><span class="p">,</span> <span class="sc">&#39; &#39;</span><span class="p">,</span> <span class="sc">&#39;B&#39;</span><span class="p">,</span> <span class="sc">&#39;B&#39;</span><span class="p">,</span> <span class="sc">&#39; &#39;</span><span class="p">,</span> <span class="sc">&#39; &#39;</span><span class="p">,</span> <span class="sc">&#39;L&#39;</span> <span class="p">},</span>
</span></span><span class="line"><span class="cl">        <span class="p">{</span> <span class="sc">&#39; &#39;</span><span class="p">,</span> <span class="sc">&#39; &#39;</span><span class="p">,</span> <span class="sc">&#39; &#39;</span><span class="p">,</span> <span class="sc">&#39; &#39;</span><span class="p">,</span> <span class="sc">&#39; &#39;</span><span class="p">,</span> <span class="sc">&#39;B&#39;</span><span class="p">,</span> <span class="sc">&#39;B&#39;</span><span class="p">,</span> <span class="sc">&#39;B&#39;</span><span class="p">,</span> <span class="sc">&#39;B&#39;</span><span class="p">,</span> <span class="sc">&#39;L&#39;</span> <span class="p">},</span>
</span></span><span class="line"><span class="cl">        <span class="p">{</span> <span class="sc">&#39; &#39;</span><span class="p">,</span> <span class="sc">&#39; &#39;</span><span class="p">,</span> <span class="sc">&#39; &#39;</span><span class="p">,</span> <span class="sc">&#39;B&#39;</span><span class="p">,</span> <span class="sc">&#39;B&#39;</span><span class="p">,</span> <span class="sc">&#39;B&#39;</span><span class="p">,</span> <span class="sc">&#39;H&#39;</span><span class="p">,</span> <span class="sc">&#39;H&#39;</span><span class="p">,</span> <span class="sc">&#39;H&#39;</span><span class="p">,</span> <span class="sc">&#39;L&#39;</span> <span class="p">},</span>
</span></span><span class="line"><span class="cl">        <span class="p">{</span> <span class="sc">&#39; &#39;</span><span class="p">,</span> <span class="sc">&#39; &#39;</span><span class="p">,</span> <span class="sc">&#39; &#39;</span><span class="p">,</span> <span class="sc">&#39; &#39;</span><span class="p">,</span> <span class="sc">&#39; &#39;</span><span class="p">,</span> <span class="sc">&#39;B&#39;</span><span class="p">,</span> <span class="sc">&#39; &#39;</span><span class="p">,</span> <span class="sc">&#39; &#39;</span><span class="p">,</span> <span class="sc">&#39;B&#39;</span><span class="p">,</span> <span class="sc">&#39;L&#39;</span> <span class="p">},</span>
</span></span><span class="line"><span class="cl">        <span class="p">{</span> <span class="sc">&#39;B&#39;</span><span class="p">,</span> <span class="sc">&#39;B&#39;</span><span class="p">,</span> <span class="sc">&#39; &#39;</span><span class="p">,</span> <span class="sc">&#39; &#39;</span><span class="p">,</span> <span class="sc">&#39; &#39;</span><span class="p">,</span> <span class="sc">&#39;B&#39;</span><span class="p">,</span> <span class="sc">&#39;B&#39;</span><span class="p">,</span> <span class="sc">&#39; &#39;</span><span class="p">,</span> <span class="sc">&#39;B&#39;</span><span class="p">,</span> <span class="sc">&#39;L&#39;</span> <span class="p">},</span>
</span></span><span class="line"><span class="cl">        <span class="p">{</span> <span class="sc">&#39; &#39;</span><span class="p">,</span> <span class="sc">&#39; &#39;</span><span class="p">,</span> <span class="sc">&#39; &#39;</span><span class="p">,</span> <span class="sc">&#39; &#39;</span><span class="p">,</span> <span class="sc">&#39; &#39;</span><span class="p">,</span> <span class="sc">&#39; &#39;</span><span class="p">,</span> <span class="sc">&#39; &#39;</span><span class="p">,</span> <span class="sc">&#39; &#39;</span><span class="p">,</span> <span class="sc">&#39;B&#39;</span><span class="p">,</span> <span class="sc">&#39;L&#39;</span> <span class="p">},</span>
</span></span><span class="line"><span class="cl">        <span class="p">{</span> <span class="sc">&#39; &#39;</span><span class="p">,</span> <span class="sc">&#39; &#39;</span><span class="p">,</span> <span class="sc">&#39;B&#39;</span><span class="p">,</span> <span class="sc">&#39;B&#39;</span><span class="p">,</span> <span class="sc">&#39; &#39;</span><span class="p">,</span> <span class="sc">&#39; &#39;</span><span class="p">,</span> <span class="sc">&#39; &#39;</span><span class="p">,</span> <span class="sc">&#39; &#39;</span><span class="p">,</span> <span class="sc">&#39;B&#39;</span><span class="p">,</span> <span class="sc">&#39;L&#39;</span> <span class="p">},</span>
</span></span><span class="line"><span class="cl">        <span class="p">{</span> <span class="sc">&#39; &#39;</span><span class="p">,</span> <span class="sc">&#39; &#39;</span><span class="p">,</span> <span class="sc">&#39; &#39;</span><span class="p">,</span> <span class="sc">&#39; &#39;</span><span class="p">,</span> <span class="sc">&#39; &#39;</span><span class="p">,</span> <span class="sc">&#39; &#39;</span><span class="p">,</span> <span class="sc">&#39; &#39;</span><span class="p">,</span> <span class="sc">&#39; &#39;</span><span class="p">,</span> <span class="sc">&#39; &#39;</span><span class="p">,</span> <span class="sc">&#39;L&#39;</span> <span class="p">},</span>
</span></span><span class="line"><span class="cl">        <span class="p">{</span> <span class="sc">&#39;B&#39;</span><span class="p">,</span> <span class="sc">&#39;B&#39;</span><span class="p">,</span> <span class="sc">&#39;B&#39;</span><span class="p">,</span> <span class="sc">&#39;B&#39;</span><span class="p">,</span> <span class="sc">&#39;B&#39;</span><span class="p">,</span> <span class="sc">&#39;B&#39;</span><span class="p">,</span> <span class="sc">&#39;B&#39;</span><span class="p">,</span> <span class="sc">&#39;B&#39;</span><span class="p">,</span> <span class="sc">&#39;B&#39;</span><span class="p">,</span> <span class="sc">&#39;B&#39;</span> <span class="p">}</span>
</span></span><span class="line"><span class="cl">    <span class="p">};</span>
</span></span><span class="line"><span class="cl">    <span class="kd">private</span> <span class="k">readonly</span> <span class="n">Grid</span> <span class="n">_grid</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="c1">// ...</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="n">Pathfinding</span><span class="p">()</span>
</span></span><span class="line"><span class="cl">    <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="n">_grid</span> <span class="p">=</span> <span class="k">new</span> <span class="n">Grid</span><span class="p">(</span><span class="n">_map</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">            <span class="n">StartPosition</span> <span class="p">=</span> <span class="k">new</span> <span class="n">Point</span><span class="p">(</span><span class="m">0</span><span class="p">,</span> <span class="m">10</span><span class="p">),</span>
</span></span><span class="line"><span class="cl">            <span class="n">TargetPosition</span> <span class="p">=</span> <span class="k">new</span> <span class="n">Point</span><span class="p">(</span><span class="m">5</span><span class="p">,</span> <span class="m">1</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">        <span class="p">};</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">        <span class="c1">// ...</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="c1">// ...</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span></code></pre></div><h3 id="updating-the-find-neighbors-logic">Updating the Find-Neighbors Logic</h3>
<p>Now that we have that out of the way, we can update the logic that finds neighbor cells. Because the find-neighbors code
will be a bit more complicated compared to the top-down case, it seems a good idea to put this into its own class. Also,
let&rsquo;s define an interface, because why not (actually, that let&rsquo;s you easily implement different neighbor finders and
also makes unit testing easier, because you can mock the neighbor finder interface):</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-csharp" data-lang="csharp"><span class="line"><span class="cl"><span class="kd">public</span> <span class="k">interface</span> <span class="nc">INeighborFinder</span>
</span></span><span class="line"><span class="cl"><span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="n">IEnumerable</span><span class="p">&lt;</span><span class="n">CellCostPair</span><span class="p">&gt;</span> <span class="n">FindNeighbors</span><span class="p">(</span><span class="n">Cell</span> <span class="n">cell</span><span class="p">,</span> <span class="kt">bool</span> <span class="n">hasJumpCapability</span><span class="p">,</span> <span class="n">GetDistanceDelegate</span> <span class="n">getDistance</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="k">delegate</span> <span class="kt">float</span> <span class="n">GetDistanceDelegate</span><span class="p">(</span><span class="n">Cell</span> <span class="k">from</span><span class="p">,</span> <span class="n">Cell</span> <span class="n">to</span><span class="p">);</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span></code></pre></div><p>The interface contains the following:</p>
<ul>
<li>A method <code>FindNeighbors</code> which takes the current cell, whether the game character has jump capability, and a
delegate with which the distance between two cells can be calculated (which in our case will be the good old
manhattan distance).</li>
<li>A delegate called <code>GetDistanceDelegate</code> which takes two cells and returns the distance in between.</li>
</ul>
<p>You&rsquo;ll have noticed that <code>FindNeighbors</code> returns an <code>IEnumerable&lt;CellCostPair&gt;</code>. Why not return <code>Cell</code>s? Because now,
that we&rsquo;re not only looking at adjoining cells but also at neighbors of neighbors, it seems sensible to calculate the
cost to reach a certain neighboring cell right when we&rsquo;re looking at them, especially in the jumping context.
Thus, we create a simple <a href="https://martinfowler.com/eaaCatalog/dataTransferObject.html"
    
    
      target="_blank" class="external-link"
    
>DTO</a>
 which contains a cell and the cost to reach that cell:</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-csharp" data-lang="csharp"><span class="line"><span class="cl"><span class="kd">public</span> <span class="k">struct</span> <span class="nc">CellCostPair</span><span class="p">(</span><span class="n">Cell</span> <span class="n">cell</span><span class="p">,</span> <span class="kt">float</span> <span class="n">cost</span><span class="p">)</span>
</span></span><span class="line"><span class="cl"><span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="n">Cell</span> <span class="n">Cell</span> <span class="p">{</span> <span class="k">get</span><span class="p">;</span> <span class="kd">private</span> <span class="k">set</span><span class="p">;</span> <span class="p">}</span> <span class="p">=</span> <span class="n">cell</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="kt">float</span> <span class="n">Cost</span> <span class="p">{</span> <span class="k">get</span><span class="p">;</span> <span class="kd">private</span> <span class="k">set</span><span class="p">;</span> <span class="p">}</span> <span class="p">=</span> <span class="n">cost</span><span class="p">;</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span></code></pre></div><p>Let&rsquo;s continue with implementing the <code>FindNeighbors</code> method. This task can be split up into
finding neighboring cells reachable with and without jumping.</p>
<h4 id="cells-reachable-without-jumping">Cells Reachable without Jumping</h4>
<p>Here is how to find cells that are reachable without jumping:</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-csharp" data-lang="csharp"><span class="line"><span class="cl"><span class="kd">public</span> <span class="k">class</span> <span class="nc">NeighborFinder</span> <span class="p">:</span> <span class="n">INeighborFinder</span>
</span></span><span class="line"><span class="cl"><span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="c1">// ...</span>
</span></span><span class="line"><span class="cl">    
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="n">IEnumerable</span><span class="p">&lt;</span><span class="n">CellCostPair</span><span class="p">&gt;</span> <span class="n">FindNeighbors</span><span class="p">(</span>
</span></span><span class="line"><span class="cl">        <span class="n">Cell</span> <span class="n">sourceCell</span><span class="p">,</span> 
</span></span><span class="line"><span class="cl">        <span class="kt">bool</span> <span class="n">hasJumpCapability</span><span class="p">,</span> 
</span></span><span class="line"><span class="cl">        <span class="n">INeighborFinder</span><span class="p">.</span><span class="n">GetDistanceDelegate</span> <span class="n">dist</span>
</span></span><span class="line"><span class="cl">    <span class="p">)</span>
</span></span><span class="line"><span class="cl">    <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="k">foreach</span> <span class="p">(</span><span class="kt">var</span> <span class="n">cell</span> <span class="k">in</span> <span class="n">FindCellsWithoutJumping</span><span class="p">(</span><span class="n">sourceCell</span><span class="p">,</span> <span class="n">dist</span><span class="p">))</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">            <span class="k">yield</span> <span class="k">return</span> <span class="n">cell</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">        <span class="p">}</span>
</span></span><span class="line"><span class="cl">   
</span></span><span class="line"><span class="cl">        <span class="c1">// ...</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="kd">private</span> <span class="kd">static</span> <span class="n">IEnumerable</span><span class="p">&lt;</span><span class="n">CellCostPair</span><span class="p">&gt;</span> <span class="n">FindCellsWithoutJumping</span><span class="p">(</span>
</span></span><span class="line"><span class="cl">        <span class="n">Cell</span> <span class="n">cell</span><span class="p">,</span> 
</span></span><span class="line"><span class="cl">        <span class="n">INeighborFinder</span><span class="p">.</span><span class="n">GetDistanceDelegate</span> <span class="n">dist</span>
</span></span><span class="line"><span class="cl">    <span class="p">)</span>
</span></span><span class="line"><span class="cl">    <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="k">if</span> <span class="p">(</span><span class="n">cell</span><span class="p">.</span><span class="n">Down</span> <span class="k">is</span> <span class="p">{</span> <span class="n">IsBlock</span><span class="p">:</span> <span class="kc">false</span> <span class="p">})</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">            <span class="kt">var</span> <span class="n">cost</span> <span class="p">=</span> <span class="n">dist</span><span class="p">(</span><span class="n">cell</span><span class="p">,</span> <span class="n">cell</span><span class="p">.</span><span class="n">Down</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">            <span class="k">yield</span> <span class="k">return</span> <span class="k">new</span> <span class="n">CellCostPair</span><span class="p">(</span><span class="n">cell</span><span class="p">.</span><span class="n">Down</span><span class="p">,</span> <span class="n">cost</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">        <span class="p">}</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">        <span class="k">if</span> <span class="p">(</span><span class="n">cell</span> <span class="k">is</span> <span class="p">{</span> <span class="n">IsLadder</span><span class="p">:</span> <span class="kc">true</span><span class="p">,</span> <span class="n">Up</span><span class="p">.</span><span class="n">IsBlock</span><span class="p">:</span> <span class="kc">false</span> <span class="p">})</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">            <span class="kt">var</span> <span class="n">cost</span> <span class="p">=</span> <span class="n">dist</span><span class="p">(</span><span class="n">cell</span><span class="p">,</span> <span class="n">cell</span><span class="p">.</span><span class="n">Up</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">            <span class="k">yield</span> <span class="k">return</span> <span class="k">new</span> <span class="n">CellCostPair</span><span class="p">(</span><span class="n">cell</span><span class="p">.</span><span class="n">Up</span><span class="p">,</span> <span class="n">cost</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">        <span class="p">}</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">        <span class="kt">var</span> <span class="n">canMoveSideways</span> <span class="p">=</span> <span class="n">cell</span><span class="p">.</span><span class="n">Down</span> <span class="k">is</span> <span class="p">{</span> <span class="n">IsEmpty</span><span class="p">:</span> <span class="kc">false</span> <span class="p">}</span> <span class="p">||</span> <span class="n">cell</span><span class="p">.</span><span class="n">IsLadder</span> <span class="p">||</span> <span class="n">cell</span><span class="p">.</span><span class="n">IsHangingBar</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">        <span class="k">if</span> <span class="p">(!</span><span class="n">canMoveSideways</span><span class="p">)</span> <span class="k">yield</span> <span class="k">break</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">        
</span></span><span class="line"><span class="cl">        <span class="k">if</span> <span class="p">(</span><span class="n">cell</span><span class="p">.</span><span class="n">Right</span> <span class="k">is</span> <span class="p">{</span> <span class="n">IsBlock</span><span class="p">:</span> <span class="kc">false</span> <span class="p">})</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">            <span class="kt">var</span> <span class="n">cost</span> <span class="p">=</span> <span class="n">dist</span><span class="p">(</span><span class="n">cell</span><span class="p">,</span> <span class="n">cell</span><span class="p">.</span><span class="n">Right</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">            <span class="k">yield</span> <span class="k">return</span> <span class="k">new</span> <span class="n">CellCostPair</span><span class="p">(</span><span class="n">cell</span><span class="p">.</span><span class="n">Right</span><span class="p">,</span> <span class="n">cost</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">        <span class="p">}</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">        <span class="k">if</span> <span class="p">(</span><span class="n">cell</span><span class="p">.</span><span class="n">Left</span> <span class="k">is</span> <span class="p">{</span> <span class="n">IsBlock</span><span class="p">:</span> <span class="kc">false</span> <span class="p">})</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">            <span class="kt">var</span> <span class="n">cost</span> <span class="p">=</span> <span class="n">dist</span><span class="p">(</span><span class="n">cell</span><span class="p">,</span> <span class="n">cell</span><span class="p">.</span><span class="n">Left</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">            <span class="k">yield</span> <span class="k">return</span> <span class="k">new</span> <span class="n">CellCostPair</span><span class="p">(</span><span class="n">cell</span><span class="p">.</span><span class="n">Left</span><span class="p">,</span> <span class="n">cost</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">        <span class="p">}</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl">    
</span></span><span class="line"><span class="cl">    <span class="c1">// ...</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span></code></pre></div><p>A nice thing we can do now is instead of fiddling with grid coordinates, we just use speaking property names like
<code>cell.Down</code>, which we can also combine with <a href="https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/operators/patterns#property-pattern"
    
    
      target="_blank" class="external-link"
    
>property patterns</a>
 to check if certain conditions are met.</p>
<p>The first bit deals with going down one cell. If the cell below isn&rsquo;t a block then we can descend:</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-csharp" data-lang="csharp"><span class="line"><span class="cl"><span class="k">if</span> <span class="p">(</span><span class="n">cell</span><span class="p">.</span><span class="n">Down</span> <span class="k">is</span> <span class="p">{</span> <span class="n">IsBlock</span><span class="p">:</span> <span class="kc">false</span> <span class="p">})</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="kt">var</span> <span class="n">cost</span> <span class="p">=</span> <span class="n">dist</span><span class="p">(</span><span class="n">cell</span><span class="p">,</span> <span class="n">cell</span><span class="p">.</span><span class="n">Down</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">    <span class="k">yield</span> <span class="k">return</span> <span class="k">new</span> <span class="n">CellCostPair</span><span class="p">(</span><span class="n">cell</span><span class="p">.</span><span class="n">Down</span><span class="p">,</span> <span class="n">cost</span><span class="p">);</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span></code></pre></div><p>The next part handles whether we can go up one cell. If the current cell is a ladder (i.e. we&rsquo;re standing on a ladder)
and there is no block in the cell above, then we can ascend:</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-csharp" data-lang="csharp"><span class="line"><span class="cl"><span class="k">if</span> <span class="p">(</span><span class="n">cell</span> <span class="k">is</span> <span class="p">{</span> <span class="n">IsLadder</span><span class="p">:</span> <span class="kc">true</span><span class="p">,</span> <span class="n">Up</span><span class="p">.</span><span class="n">IsBlock</span><span class="p">:</span> <span class="kc">false</span> <span class="p">})</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="kt">var</span> <span class="n">cost</span> <span class="p">=</span> <span class="n">dist</span><span class="p">(</span><span class="n">cell</span><span class="p">,</span> <span class="n">cell</span><span class="p">.</span><span class="n">Up</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">    <span class="k">yield</span> <span class="k">return</span> <span class="k">new</span> <span class="n">CellCostPair</span><span class="p">(</span><span class="n">cell</span><span class="p">.</span><span class="n">Up</span><span class="p">,</span> <span class="n">cost</span><span class="p">);</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span></code></pre></div><p>The final sections focus on moving sideways. Here&rsquo;s how we can determine whether the character can move to the right:
If the cell below isn&rsquo;t empty, we&rsquo;re on a ladder, or we&rsquo;re hanging from bars, then we&rsquo;re able to move sideways.
However, if the aforementioned condition isn&rsquo;t met, then we can stop evaluating more neighbors.</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-csharp" data-lang="csharp"><span class="line"><span class="cl"><span class="kt">var</span> <span class="n">canMoveSideways</span> <span class="p">=</span> <span class="n">cell</span><span class="p">.</span><span class="n">Down</span> <span class="k">is</span> <span class="p">{</span> <span class="n">IsEmpty</span><span class="p">:</span> <span class="kc">false</span> <span class="p">}</span> <span class="p">||</span> <span class="n">cell</span><span class="p">.</span><span class="n">IsLadder</span> <span class="p">||</span> <span class="n">cell</span><span class="p">.</span><span class="n">IsHangingBar</span><span class="p">;</span>
</span></span><span class="line"><span class="cl"><span class="k">if</span> <span class="p">(!</span><span class="n">canMoveSideways</span><span class="p">)</span> <span class="k">yield</span> <span class="k">break</span><span class="p">;</span>
</span></span></code></pre></div><p>But, if we can move sideways in principle and the cell to the right isn&rsquo;t a block, we can move one cell to the right:</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-csharp" data-lang="csharp"><span class="line"><span class="cl"><span class="k">if</span> <span class="p">(</span><span class="n">cell</span><span class="p">.</span><span class="n">Right</span> <span class="k">is</span> <span class="p">{</span> <span class="n">IsBlock</span><span class="p">:</span> <span class="kc">false</span> <span class="p">})</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="kt">var</span> <span class="n">cost</span> <span class="p">=</span> <span class="n">dist</span><span class="p">(</span><span class="n">cell</span><span class="p">,</span> <span class="n">cell</span><span class="p">.</span><span class="n">Right</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">    <span class="k">yield</span> <span class="k">return</span> <span class="k">new</span> <span class="n">CellCostPair</span><span class="p">(</span><span class="n">cell</span><span class="p">.</span><span class="n">Right</span><span class="p">,</span> <span class="n">cost</span><span class="p">);</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span></code></pre></div><p>It&rsquo;s the same in the other direction, just the other way around (no kidding):</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-csharp" data-lang="csharp"><span class="line"><span class="cl"><span class="k">if</span> <span class="p">(</span><span class="n">cell</span><span class="p">.</span><span class="n">Left</span> <span class="k">is</span> <span class="p">{</span> <span class="n">IsBlock</span><span class="p">:</span> <span class="kc">false</span> <span class="p">})</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="kt">var</span> <span class="n">cost</span> <span class="p">=</span> <span class="n">dist</span><span class="p">(</span><span class="n">cell</span><span class="p">,</span> <span class="n">cell</span><span class="p">.</span><span class="n">Left</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">    <span class="k">yield</span> <span class="k">return</span> <span class="k">new</span> <span class="n">CellCostPair</span><span class="p">(</span><span class="n">cell</span><span class="p">.</span><span class="n">Left</span><span class="p">,</span> <span class="n">cost</span><span class="p">);</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span></code></pre></div><p>Now we&rsquo;re ready to look at how to evaluate additional neighboring cells with jumping incorporated.</p>
<h4 id="add-jumping-to-the-mix">Add Jumping to the Mix</h4>
<p>Without further ado, here&rsquo;s the additional code:</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-csharp" data-lang="csharp"><span class="line"><span class="cl"><span class="kd">public</span> <span class="k">class</span> <span class="nc">NeighborFinder</span> <span class="p">:</span> <span class="n">INeighborFinder</span>
</span></span><span class="line"><span class="cl"><span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="kd">private</span> <span class="kd">static</span> <span class="k">readonly</span> <span class="n">Point</span><span class="p">[]</span> <span class="n">JumpRightTrajectoryDeltas</span> <span class="p">=</span> <span class="p">[</span>
</span></span><span class="line"><span class="cl">        <span class="k">new</span><span class="p">(</span><span class="m">0</span><span class="p">,</span> <span class="p">-</span><span class="m">1</span><span class="p">),</span> <span class="k">new</span><span class="p">(</span><span class="m">0</span><span class="p">,</span> <span class="p">-</span><span class="m">2</span><span class="p">),</span> <span class="k">new</span><span class="p">(</span><span class="m">1</span><span class="p">,</span> <span class="p">-</span><span class="m">2</span><span class="p">),</span> <span class="k">new</span><span class="p">(</span><span class="m">2</span><span class="p">,</span> <span class="p">-</span><span class="m">2</span><span class="p">),</span> 
</span></span><span class="line"><span class="cl">        <span class="k">new</span><span class="p">(</span><span class="m">3</span><span class="p">,</span> <span class="p">-</span><span class="m">2</span><span class="p">),</span> <span class="k">new</span><span class="p">(</span><span class="m">4</span><span class="p">,</span> <span class="p">-</span><span class="m">2</span><span class="p">),</span> <span class="k">new</span><span class="p">(</span><span class="m">4</span><span class="p">,</span> <span class="p">-</span><span class="m">1</span><span class="p">),</span> <span class="k">new</span><span class="p">(</span><span class="m">4</span><span class="p">,</span> <span class="m">0</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">    <span class="p">];</span>
</span></span><span class="line"><span class="cl">    <span class="kd">private</span> <span class="kd">static</span> <span class="k">readonly</span> <span class="n">Point</span><span class="p">[]</span> <span class="n">JumpLeftTrajectoryDeltas</span> <span class="p">=</span> <span class="p">[</span>
</span></span><span class="line"><span class="cl">        <span class="k">new</span><span class="p">(</span><span class="m">0</span><span class="p">,</span> <span class="p">-</span><span class="m">1</span><span class="p">),</span> <span class="k">new</span><span class="p">(</span><span class="m">0</span><span class="p">,</span> <span class="p">-</span><span class="m">2</span><span class="p">),</span> <span class="k">new</span><span class="p">(-</span><span class="m">1</span><span class="p">,</span> <span class="p">-</span><span class="m">2</span><span class="p">),</span> <span class="k">new</span><span class="p">(-</span><span class="m">2</span><span class="p">,</span> <span class="p">-</span><span class="m">2</span><span class="p">),</span> 
</span></span><span class="line"><span class="cl">        <span class="k">new</span><span class="p">(-</span><span class="m">3</span><span class="p">,</span> <span class="p">-</span><span class="m">2</span><span class="p">),</span> <span class="k">new</span><span class="p">(-</span><span class="m">4</span><span class="p">,</span> <span class="p">-</span><span class="m">2</span><span class="p">),</span> <span class="k">new</span><span class="p">(-</span><span class="m">4</span><span class="p">,</span> <span class="p">-</span><span class="m">1</span><span class="p">),</span> <span class="k">new</span><span class="p">(-</span><span class="m">4</span><span class="p">,</span> <span class="m">0</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">    <span class="p">];</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="n">IEnumerable</span><span class="p">&lt;</span><span class="n">CellCostPair</span><span class="p">&gt;</span> <span class="n">FindNeighbors</span><span class="p">(</span>
</span></span><span class="line"><span class="cl">        <span class="n">Cell</span> <span class="n">sourceCell</span><span class="p">,</span> 
</span></span><span class="line"><span class="cl">        <span class="kt">bool</span> <span class="n">hasJumpCapability</span><span class="p">,</span> 
</span></span><span class="line"><span class="cl">        <span class="n">INeighborFinder</span><span class="p">.</span><span class="n">GetDistanceDelegate</span> <span class="n">dist</span>
</span></span><span class="line"><span class="cl">    <span class="p">)</span>
</span></span><span class="line"><span class="cl">    <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="c1">// ...</span>
</span></span><span class="line"><span class="cl">        
</span></span><span class="line"><span class="cl">        <span class="k">if</span> <span class="p">(!</span><span class="n">hasJumpCapability</span> <span class="p">||</span> <span class="n">sourceCell</span><span class="p">.</span><span class="n">Down</span> <span class="k">is</span> <span class="n">not</span> <span class="p">{</span> <span class="n">IsBlock</span><span class="p">:</span> <span class="kc">true</span> <span class="p">})</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">            <span class="k">yield</span> <span class="k">break</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">        <span class="p">}</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">        <span class="k">foreach</span> <span class="p">(</span><span class="kt">var</span> <span class="n">cell</span> <span class="k">in</span> <span class="n">FindCellsWithJumping</span><span class="p">(</span><span class="n">sourceCell</span><span class="p">,</span> <span class="n">dist</span><span class="p">))</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">            <span class="k">yield</span> <span class="k">return</span> <span class="n">cell</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">        <span class="p">}</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="c1">// ...</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="kd">private</span> <span class="kd">static</span> <span class="n">IEnumerable</span><span class="p">&lt;</span><span class="n">CellCostPair</span><span class="p">&gt;</span> <span class="n">FindCellsWithJumping</span><span class="p">(</span>
</span></span><span class="line"><span class="cl">        <span class="n">Cell</span> <span class="n">cell</span><span class="p">,</span> 
</span></span><span class="line"><span class="cl">        <span class="n">INeighborFinder</span><span class="p">.</span><span class="n">GetDistanceDelegate</span> <span class="n">dist</span>
</span></span><span class="line"><span class="cl">    <span class="p">)</span>
</span></span><span class="line"><span class="cl">    <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="k">if</span> <span class="p">(</span><span class="n">cell</span><span class="p">.</span><span class="n">DownRight</span> <span class="k">is</span> <span class="p">{</span> <span class="n">IsEmpty</span><span class="p">:</span> <span class="kc">true</span> <span class="p">}</span>
</span></span><span class="line"><span class="cl">            <span class="p">||</span> <span class="n">cell</span><span class="p">.</span><span class="n">Right</span><span class="p">?.</span><span class="n">Right</span> <span class="k">is</span> <span class="p">{</span> <span class="n">IsBlock</span><span class="p">:</span> <span class="kc">true</span> <span class="p">}</span>
</span></span><span class="line"><span class="cl">            <span class="p">||</span> <span class="n">cell</span><span class="p">.</span><span class="n">Right</span><span class="p">?.</span><span class="n">UpRight</span> <span class="k">is</span> <span class="p">{</span> <span class="n">IsBlock</span><span class="p">:</span> <span class="kc">true</span> <span class="p">}</span>
</span></span><span class="line"><span class="cl">        <span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">            <span class="k">foreach</span> <span class="p">(</span><span class="kt">var</span> <span class="n">cellCostPair</span> <span class="k">in</span> <span class="n">FindCellsOnJumpPath</span><span class="p">(</span><span class="n">cell</span><span class="p">,</span> <span class="n">dist</span><span class="p">,</span> <span class="n">JumpRightTrajectoryDeltas</span><span class="p">))</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">                <span class="k">yield</span> <span class="k">return</span> <span class="n">cellCostPair</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">            <span class="p">}</span>
</span></span><span class="line"><span class="cl">        <span class="p">}</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">        <span class="k">if</span> <span class="p">(</span><span class="n">cell</span><span class="p">.</span><span class="n">DownLeft</span> <span class="k">is</span> <span class="p">{</span> <span class="n">IsEmpty</span><span class="p">:</span> <span class="kc">true</span> <span class="p">}</span>
</span></span><span class="line"><span class="cl">            <span class="p">||</span> <span class="n">cell</span><span class="p">.</span><span class="n">Left</span><span class="p">?.</span><span class="n">Left</span> <span class="k">is</span> <span class="p">{</span> <span class="n">IsBlock</span><span class="p">:</span> <span class="kc">true</span> <span class="p">}</span>
</span></span><span class="line"><span class="cl">            <span class="p">||</span> <span class="n">cell</span><span class="p">.</span><span class="n">Left</span><span class="p">?.</span><span class="n">UpLeft</span> <span class="k">is</span> <span class="p">{</span> <span class="n">IsBlock</span><span class="p">:</span> <span class="kc">true</span> <span class="p">}</span>
</span></span><span class="line"><span class="cl">        <span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">            <span class="k">foreach</span> <span class="p">(</span><span class="kt">var</span> <span class="n">cellCostPair</span> <span class="k">in</span> <span class="n">FindCellsOnJumpPath</span><span class="p">(</span><span class="n">cell</span><span class="p">,</span> <span class="n">dist</span><span class="p">,</span> <span class="n">JumpLeftTrajectoryDeltas</span><span class="p">))</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">                <span class="k">yield</span> <span class="k">return</span> <span class="n">cellCostPair</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">            <span class="p">}</span>
</span></span><span class="line"><span class="cl">        <span class="p">}</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="kd">private</span> <span class="kd">static</span> <span class="n">IEnumerable</span><span class="p">&lt;</span><span class="n">CellCostPair</span><span class="p">&gt;</span> <span class="n">FindCellsOnJumpPath</span><span class="p">(</span>
</span></span><span class="line"><span class="cl">        <span class="n">Cell</span> <span class="n">cell</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">        <span class="n">INeighborFinder</span><span class="p">.</span><span class="n">GetDistanceDelegate</span> <span class="n">dist</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">        <span class="n">IEnumerable</span><span class="p">&lt;</span><span class="n">Point</span><span class="p">&gt;</span> <span class="n">deltaDirection</span>
</span></span><span class="line"><span class="cl">    <span class="p">)</span>
</span></span><span class="line"><span class="cl">    <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="kt">var</span> <span class="n">cost</span> <span class="p">=</span> <span class="m">0f</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">        <span class="kt">var</span> <span class="n">previousCell</span> <span class="p">=</span> <span class="n">cell</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">        <span class="k">foreach</span> <span class="p">(</span><span class="kt">var</span> <span class="n">delta</span> <span class="k">in</span> <span class="n">deltaDirection</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">            <span class="kt">var</span> <span class="n">potentialNeighbor</span> <span class="p">=</span> <span class="n">cell</span><span class="p">.</span><span class="n">NeighborAt</span><span class="p">(</span><span class="n">delta</span><span class="p">.</span><span class="n">X</span><span class="p">,</span> <span class="n">delta</span><span class="p">.</span><span class="n">Y</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">            <span class="k">if</span> <span class="p">(</span><span class="n">potentialNeighbor</span> <span class="k">is</span> <span class="kc">null</span> <span class="n">or</span> <span class="p">{</span> <span class="n">IsBlock</span><span class="p">:</span> <span class="kc">true</span> <span class="p">})</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">                <span class="k">yield</span> <span class="k">break</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">            <span class="p">}</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">            <span class="n">cost</span> <span class="p">+=</span> <span class="n">dist</span><span class="p">(</span><span class="n">previousCell</span><span class="p">,</span> <span class="n">potentialNeighbor</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">            <span class="k">yield</span> <span class="k">return</span> <span class="k">new</span> <span class="n">CellCostPair</span><span class="p">(</span><span class="n">potentialNeighbor</span><span class="p">,</span> <span class="n">cost</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">            <span class="n">previousCell</span> <span class="p">=</span> <span class="n">potentialNeighbor</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">        <span class="p">}</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span></code></pre></div><p>What&rsquo;s happening here? First of all, we define the jump trajectories in form of deltas from the source cell,
one for a jump to the right and another one for a jump to the left. Looking at the trajectory definitions</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-csharp" data-lang="csharp"><span class="line"><span class="cl"><span class="kd">private</span> <span class="kd">static</span> <span class="k">readonly</span> <span class="n">Point</span><span class="p">[]</span> <span class="n">JumpRightTrajectoryDeltas</span> <span class="p">=</span> <span class="p">[</span>
</span></span><span class="line"><span class="cl">    <span class="k">new</span><span class="p">(</span><span class="m">0</span><span class="p">,</span> <span class="p">-</span><span class="m">1</span><span class="p">),</span> <span class="k">new</span><span class="p">(</span><span class="m">0</span><span class="p">,</span> <span class="p">-</span><span class="m">2</span><span class="p">),</span> <span class="k">new</span><span class="p">(</span><span class="m">1</span><span class="p">,</span> <span class="p">-</span><span class="m">2</span><span class="p">),</span> <span class="k">new</span><span class="p">(</span><span class="m">2</span><span class="p">,</span> <span class="p">-</span><span class="m">2</span><span class="p">),</span> 
</span></span><span class="line"><span class="cl">    <span class="k">new</span><span class="p">(</span><span class="m">3</span><span class="p">,</span> <span class="p">-</span><span class="m">2</span><span class="p">),</span> <span class="k">new</span><span class="p">(</span><span class="m">4</span><span class="p">,</span> <span class="p">-</span><span class="m">2</span><span class="p">),</span> <span class="k">new</span><span class="p">(</span><span class="m">4</span><span class="p">,</span> <span class="p">-</span><span class="m">1</span><span class="p">),</span> <span class="k">new</span><span class="p">(</span><span class="m">4</span><span class="p">,</span> <span class="m">0</span><span class="p">)</span>
</span></span><span class="line"><span class="cl"><span class="p">];</span>
</span></span><span class="line"><span class="cl"><span class="kd">private</span> <span class="kd">static</span> <span class="k">readonly</span> <span class="n">Point</span><span class="p">[]</span> <span class="n">JumpLeftTrajectoryDeltas</span> <span class="p">=</span> <span class="p">[</span>
</span></span><span class="line"><span class="cl">    <span class="k">new</span><span class="p">(</span><span class="m">0</span><span class="p">,</span> <span class="p">-</span><span class="m">1</span><span class="p">),</span> <span class="k">new</span><span class="p">(</span><span class="m">0</span><span class="p">,</span> <span class="p">-</span><span class="m">2</span><span class="p">),</span> <span class="k">new</span><span class="p">(-</span><span class="m">1</span><span class="p">,</span> <span class="p">-</span><span class="m">2</span><span class="p">),</span> <span class="k">new</span><span class="p">(-</span><span class="m">2</span><span class="p">,</span> <span class="p">-</span><span class="m">2</span><span class="p">),</span> 
</span></span><span class="line"><span class="cl">    <span class="k">new</span><span class="p">(-</span><span class="m">3</span><span class="p">,</span> <span class="p">-</span><span class="m">2</span><span class="p">),</span> <span class="k">new</span><span class="p">(-</span><span class="m">4</span><span class="p">,</span> <span class="p">-</span><span class="m">2</span><span class="p">),</span> <span class="k">new</span><span class="p">(-</span><span class="m">4</span><span class="p">,</span> <span class="p">-</span><span class="m">1</span><span class="p">),</span> <span class="k">new</span><span class="p">(-</span><span class="m">4</span><span class="p">,</span> <span class="m">0</span><span class="p">)</span>
</span></span><span class="line"><span class="cl"><span class="p">];</span>
</span></span></code></pre></div><p>we see that applying these deltas to the start cell of a jump will unfold the jump path from earlier:</p>
<p><div class="flex-container">
<figure class="flex-item flex-item-2"><img src="/https/shendriks.dev/posts/2024-09-04-a-star-pathfinding-side-view/images/jumping-trajectory-a.svg" width="100%">
</figure>

<figure class="flex-item flex-item-2"><img src="/https/shendriks.dev/posts/2024-09-04-a-star-pathfinding-side-view/images/jumping-trajectory-b.svg" width="100%">
</figure>

</div></p>
<p>Next, in the <code>FindNeighbors</code> method we check if the character has jumping capability as well as if the cell below is a
block. If that&rsquo;s not the case, then jumping is impossible and we stop:</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-csharp" data-lang="csharp"><span class="line"><span class="cl"><span class="k">if</span> <span class="p">(!</span><span class="n">hasJumpCapability</span> <span class="p">||</span> <span class="n">sourceCell</span><span class="p">.</span><span class="n">Down</span> <span class="k">is</span> <span class="n">not</span> <span class="p">{</span> <span class="n">IsBlock</span><span class="p">:</span> <span class="kc">true</span> <span class="p">})</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="k">yield</span> <span class="k">break</span><span class="p">;</span>    
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span></code></pre></div><p>Next, we&rsquo;ll jump in the <code>FindCellsWithJumping</code> method and look at the first case, which is jumping to the right:</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-csharp" data-lang="csharp"><span class="line"><span class="cl">    <span class="kd">private</span> <span class="kd">static</span> <span class="n">IEnumerable</span><span class="p">&lt;</span><span class="n">CellCostPair</span><span class="p">&gt;</span> <span class="n">FindCellsWithJumping</span><span class="p">(</span>
</span></span><span class="line"><span class="cl">        <span class="n">Cell</span> <span class="n">cell</span><span class="p">,</span> 
</span></span><span class="line"><span class="cl">        <span class="n">INeighborFinder</span><span class="p">.</span><span class="n">GetDistanceDelegate</span> <span class="n">dist</span>
</span></span><span class="line"><span class="cl">    <span class="p">)</span>
</span></span><span class="line"><span class="cl">    <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="k">if</span> <span class="p">(</span><span class="n">cell</span><span class="p">.</span><span class="n">DownRight</span> <span class="k">is</span> <span class="p">{</span> <span class="n">IsEmpty</span><span class="p">:</span> <span class="kc">true</span> <span class="p">}</span>
</span></span><span class="line"><span class="cl">            <span class="p">||</span> <span class="n">cell</span><span class="p">.</span><span class="n">Right</span><span class="p">?.</span><span class="n">Right</span> <span class="k">is</span> <span class="p">{</span> <span class="n">IsBlock</span><span class="p">:</span> <span class="kc">true</span> <span class="p">}</span>
</span></span><span class="line"><span class="cl">            <span class="p">||</span> <span class="n">cell</span><span class="p">.</span><span class="n">Right</span><span class="p">?.</span><span class="n">UpRight</span> <span class="k">is</span> <span class="p">{</span> <span class="n">IsBlock</span><span class="p">:</span> <span class="kc">true</span> <span class="p">}</span>
</span></span><span class="line"><span class="cl">        <span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">            <span class="k">foreach</span> <span class="p">(</span><span class="kt">var</span> <span class="n">cellCostPair</span> <span class="k">in</span> <span class="n">FindCellsOnJumpPath</span><span class="p">(</span><span class="n">cell</span><span class="p">,</span> <span class="n">dist</span><span class="p">,</span> <span class="n">JumpRightTrajectoryDeltas</span><span class="p">))</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">                <span class="k">yield</span> <span class="k">return</span> <span class="n">cellCostPair</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">            <span class="p">}</span>
</span></span><span class="line"><span class="cl">        <span class="p">}</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">        <span class="c1">// ...</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span></code></pre></div><p>First, we do a simple check if it makes &ldquo;sense&rdquo; to try jumping from the current position:</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-csharp" data-lang="csharp"><span class="line"><span class="cl">        <span class="k">if</span> <span class="p">(</span><span class="n">cell</span><span class="p">.</span><span class="n">DownRight</span> <span class="k">is</span> <span class="p">{</span> <span class="n">IsEmpty</span><span class="p">:</span> <span class="kc">true</span> <span class="p">}</span>
</span></span><span class="line"><span class="cl">            <span class="p">||</span> <span class="n">cell</span><span class="p">.</span><span class="n">Right</span><span class="p">?.</span><span class="n">Right</span> <span class="k">is</span> <span class="p">{</span> <span class="n">IsBlock</span><span class="p">:</span> <span class="kc">true</span> <span class="p">}</span>
</span></span><span class="line"><span class="cl">            <span class="p">||</span> <span class="n">cell</span><span class="p">.</span><span class="n">Right</span><span class="p">?.</span><span class="n">UpRight</span> <span class="k">is</span> <span class="p">{</span> <span class="n">IsBlock</span><span class="p">:</span> <span class="kc">true</span> <span class="p">}</span>
</span></span><span class="line"><span class="cl">        <span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">            <span class="c1">// ...</span>
</span></span><span class="line"><span class="cl">        <span class="p">}</span>
</span></span></code></pre></div><p>If you look at the three conditions above you might notice that these map to the three example obstacles from earlier
(though in a different order):</p>
<ul>
<li>If <code>cell.DownRight is { IsEmpty: true }</code> is true then there&rsquo;s a pit to the right.</li>
<li>If <code>cell.Right?.Right is { IsBlock: true }</code> holds true then there&rsquo;s an obstacle to the right.</li>
<li>Finally, if <code>cell.Right?.UpRight is { IsBlock: true }</code> happens to evaluate to true then there&rsquo;s a platform we might
be able to hop onto.</li>
</ul>
<p>Again, these are only simple checks to avoid &ldquo;unnecessary&rdquo; jumps. In the following step we make use of the trajectory deltas.</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-csharp" data-lang="csharp"><span class="line"><span class="cl"><span class="kd">private</span> <span class="kd">static</span> <span class="n">IEnumerable</span><span class="p">&lt;</span><span class="n">CellCostPair</span><span class="p">&gt;</span> <span class="n">FindCellsOnJumpPath</span><span class="p">(</span>
</span></span><span class="line"><span class="cl">    <span class="n">Cell</span> <span class="n">cell</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">    <span class="n">INeighborFinder</span><span class="p">.</span><span class="n">GetDistanceDelegate</span> <span class="n">dist</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">    <span class="n">IEnumerable</span><span class="p">&lt;</span><span class="n">Point</span><span class="p">&gt;</span> <span class="n">deltaDirection</span>
</span></span><span class="line"><span class="cl"><span class="p">)</span>
</span></span><span class="line"><span class="cl"><span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="kt">var</span> <span class="n">cost</span> <span class="p">=</span> <span class="m">0f</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">    <span class="kt">var</span> <span class="n">previousCell</span> <span class="p">=</span> <span class="n">cell</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">    <span class="k">foreach</span> <span class="p">(</span><span class="kt">var</span> <span class="n">delta</span> <span class="k">in</span> <span class="n">deltaDirection</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="kt">var</span> <span class="n">potentialNeighbor</span> <span class="p">=</span> <span class="n">cell</span><span class="p">.</span><span class="n">NeighborAt</span><span class="p">(</span><span class="n">delta</span><span class="p">.</span><span class="n">X</span><span class="p">,</span> <span class="n">delta</span><span class="p">.</span><span class="n">Y</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">        <span class="k">if</span> <span class="p">(</span><span class="n">potentialNeighbor</span> <span class="k">is</span> <span class="kc">null</span> <span class="n">or</span> <span class="p">{</span> <span class="n">IsBlock</span><span class="p">:</span> <span class="kc">true</span> <span class="p">})</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">            <span class="k">yield</span> <span class="k">break</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">        <span class="p">}</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">        <span class="n">cost</span> <span class="p">+=</span> <span class="n">dist</span><span class="p">(</span><span class="n">previousCell</span><span class="p">,</span> <span class="n">potentialNeighbor</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">        <span class="k">yield</span> <span class="k">return</span> <span class="k">new</span> <span class="n">CellCostPair</span><span class="p">(</span><span class="n">potentialNeighbor</span><span class="p">,</span> <span class="n">cost</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">        <span class="n">previousCell</span> <span class="p">=</span> <span class="n">potentialNeighbor</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span></code></pre></div><p>Basically, it&rsquo;s nothing more than a loop over the trajectory deltas, adding each delta to the source cell, checking to
see if it&rsquo;s a cell at all, and if it is, if it&rsquo;s not a block either, accumulating the cost to reach each respective cell,
and yield-returning each cell and the cost. And that&rsquo;s pretty much it.</p>
<p>As you can already imagine, jumping to the left is the same as jumping to the right, just with a different set of trajectory deltas.</p>
<h3 id="updating-the-rest">Updating the Rest</h3>
<p>We also need to update the pathfinding code a bit so we can use the new neighbor finder class. Here&rsquo;s the updated code:</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-csharp" data-lang="csharp"><span class="line"><span class="cl"><span class="kd">public</span> <span class="k">class</span> <span class="nc">AStarPathfinder</span><span class="p">(</span><span class="n">Grid</span> <span class="n">grid</span><span class="p">,</span> <span class="n">INeighborFinder</span> <span class="n">neighborFinder</span><span class="p">)</span>
</span></span><span class="line"><span class="cl"><span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="kd">private</span> <span class="n">List</span><span class="p">&lt;</span><span class="n">Cell</span><span class="p">&gt;</span> <span class="n">_openSet</span> <span class="p">=</span> <span class="p">[];</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="n">IEnumerator</span> <span class="n">FindPathCoroutine</span><span class="p">(</span><span class="kt">bool</span> <span class="n">hasJumpCapability</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">    <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="n">grid</span><span class="p">.</span><span class="n">Start</span><span class="p">.</span><span class="n">CostFromStart</span> <span class="p">=</span> <span class="m">0</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">        <span class="n">grid</span><span class="p">.</span><span class="n">Start</span><span class="p">.</span><span class="n">CostToTarget</span> <span class="p">=</span> <span class="n">GetDistance</span><span class="p">(</span><span class="n">grid</span><span class="p">.</span><span class="n">Start</span><span class="p">,</span> <span class="n">grid</span><span class="p">.</span><span class="n">Target</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">        <span class="n">_openSet</span> <span class="p">=</span> <span class="p">[</span><span class="n">grid</span><span class="p">.</span><span class="n">Start</span><span class="p">];</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">        <span class="k">while</span> <span class="p">(</span><span class="n">_openSet</span><span class="p">.</span><span class="n">Count</span> <span class="p">&gt;</span> <span class="m">0</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">            <span class="kt">var</span> <span class="n">current</span> <span class="p">=</span> <span class="n">_openSet</span>
</span></span><span class="line"><span class="cl">                <span class="p">.</span><span class="n">OrderBy</span><span class="p">(</span><span class="n">c</span> <span class="p">=&gt;</span> <span class="n">c</span><span class="p">.</span><span class="n">CostToTarget</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">                <span class="p">.</span><span class="n">ThenBy</span><span class="p">(</span><span class="n">c</span> <span class="p">=&gt;</span> <span class="n">GetDistance</span><span class="p">(</span><span class="n">c</span><span class="p">,</span> <span class="n">grid</span><span class="p">.</span><span class="n">Target</span><span class="p">))</span>
</span></span><span class="line"><span class="cl">                <span class="p">.</span><span class="n">First</span><span class="p">();</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">            <span class="k">if</span> <span class="p">(</span><span class="n">current</span> <span class="p">==</span> <span class="n">grid</span><span class="p">.</span><span class="n">Target</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">                <span class="n">ReconstructPath</span><span class="p">(</span><span class="n">current</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">                <span class="k">yield</span> <span class="k">break</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">            <span class="p">}</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">            <span class="n">_openSet</span><span class="p">.</span><span class="n">Remove</span><span class="p">(</span><span class="n">current</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">            <span class="n">current</span><span class="p">.</span><span class="n">IsInOpenSet</span> <span class="p">=</span> <span class="kc">false</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">            <span class="n">current</span><span class="p">.</span><span class="n">IsCurrentlyBeingExamined</span> <span class="p">=</span> <span class="kc">true</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">            <span class="k">yield</span> <span class="k">return</span> <span class="kc">null</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">            <span class="k">foreach</span> <span class="p">(</span><span class="kt">var</span> <span class="n">neighbor</span> <span class="k">in</span> <span class="n">neighborFinder</span><span class="p">.</span><span class="n">FindNeighbors</span><span class="p">(</span><span class="n">current</span><span class="p">,</span> <span class="n">hasJumpCapability</span><span class="p">,</span> <span class="n">GetDistance</span><span class="p">))</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">                <span class="k">if</span> <span class="p">(!</span><span class="n">IsNeighborWorthTrying</span><span class="p">(</span><span class="n">current</span><span class="p">,</span> <span class="n">neighbor</span><span class="p">))</span> <span class="k">continue</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">                <span class="n">_openSet</span><span class="p">.</span><span class="n">Add</span><span class="p">(</span><span class="n">neighbor</span><span class="p">.</span><span class="n">Cell</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">                <span class="n">neighbor</span><span class="p">.</span><span class="n">Cell</span><span class="p">.</span><span class="n">WasInspected</span> <span class="p">=</span> <span class="kc">true</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">                <span class="n">neighbor</span><span class="p">.</span><span class="n">Cell</span><span class="p">.</span><span class="n">IsInOpenSet</span> <span class="p">=</span> <span class="kc">true</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">                <span class="k">yield</span> <span class="k">return</span> <span class="kc">null</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">            <span class="p">}</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">            <span class="n">current</span><span class="p">.</span><span class="n">IsCurrentlyBeingExamined</span> <span class="p">=</span> <span class="kc">false</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">        <span class="p">}</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="kd">private</span> <span class="kt">bool</span> <span class="n">IsNeighborWorthTrying</span><span class="p">(</span><span class="n">Cell</span> <span class="n">current</span><span class="p">,</span> <span class="n">CellCostPair</span> <span class="n">neighbor</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">    <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="kt">var</span> <span class="n">tentativeCost</span> <span class="p">=</span> <span class="n">current</span><span class="p">.</span><span class="n">CostFromStart</span> <span class="p">+</span> <span class="n">neighbor</span><span class="p">.</span><span class="n">Cost</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">        <span class="k">if</span> <span class="p">(</span><span class="n">tentativeCost</span> <span class="p">&gt;=</span> <span class="n">neighbor</span><span class="p">.</span><span class="n">Cell</span><span class="p">.</span><span class="n">CostFromStart</span><span class="p">)</span> <span class="k">return</span> <span class="kc">false</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">        <span class="n">neighbor</span><span class="p">.</span><span class="n">Cell</span><span class="p">.</span><span class="n">Parent</span> <span class="p">=</span> <span class="n">current</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">        <span class="n">neighbor</span><span class="p">.</span><span class="n">Cell</span><span class="p">.</span><span class="n">CostFromStart</span> <span class="p">=</span> <span class="n">tentativeCost</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">        <span class="n">neighbor</span><span class="p">.</span><span class="n">Cell</span><span class="p">.</span><span class="n">CostToTarget</span> <span class="p">=</span> <span class="n">tentativeCost</span> <span class="p">+</span> <span class="n">GetDistance</span><span class="p">(</span><span class="n">neighbor</span><span class="p">.</span><span class="n">Cell</span><span class="p">,</span> <span class="n">grid</span><span class="p">.</span><span class="n">Target</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">        <span class="k">return</span> <span class="p">!</span><span class="n">_openSet</span><span class="p">.</span><span class="n">Contains</span><span class="p">(</span><span class="n">neighbor</span><span class="p">.</span><span class="n">Cell</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="kd">private</span> <span class="kd">static</span> <span class="k">void</span> <span class="n">ReconstructPath</span><span class="p">(</span><span class="n">Cell</span> <span class="n">current</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">    <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="n">current</span><span class="p">.</span><span class="n">IsOnPath</span> <span class="p">=</span> <span class="kc">true</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">        <span class="kt">var</span> <span class="n">walkingCell</span> <span class="p">=</span> <span class="n">current</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">        <span class="k">while</span> <span class="p">(</span><span class="n">walkingCell</span><span class="p">.</span><span class="n">Parent</span> <span class="p">!=</span> <span class="kc">null</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">            <span class="n">walkingCell</span><span class="p">.</span><span class="n">Parent</span><span class="p">.</span><span class="n">IsOnPath</span> <span class="p">=</span> <span class="kc">true</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">            <span class="n">walkingCell</span> <span class="p">=</span> <span class="n">walkingCell</span><span class="p">.</span><span class="n">Parent</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">        <span class="p">}</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="kd">private</span> <span class="kd">static</span> <span class="kt">float</span> <span class="n">GetDistance</span><span class="p">(</span><span class="n">Cell</span> <span class="n">a</span><span class="p">,</span> <span class="n">Cell</span> <span class="n">b</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">    <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="k">return</span> <span class="n">Math</span><span class="p">.</span><span class="n">Abs</span><span class="p">(</span><span class="n">a</span><span class="p">.</span><span class="n">X</span> <span class="p">-</span> <span class="n">b</span><span class="p">.</span><span class="n">X</span><span class="p">)</span> <span class="p">+</span> <span class="n">Math</span><span class="p">.</span><span class="n">Abs</span><span class="p">(</span><span class="n">a</span><span class="p">.</span><span class="n">Y</span> <span class="p">-</span> <span class="n">b</span><span class="p">.</span><span class="n">Y</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span></code></pre></div><p>In addition to the <code>Grid</code> object we pass an instance of <code>INeighborFinder</code> to the primary constructor. So far so good.
The next thing that should not go unnoticed is that the method <code>FindPathCoroutine</code> now, besides receiving a boolean parameter
for whether jumping is enabled, returns an instance of the
<a href="https://learn.microsoft.com/en-us/dotnet/api/system.collections.ienumerator"
    
    
      target="_blank" class="external-link"
    
>IEnumerator interface</a>
.
But, if you take a look at the <code>yield return</code> statements, you will see that only <code>null</code> is returned. So what is this?</p>
<p>This is what might be called a <a href="https://en.wikipedia.org/wiki/Coroutine"
    
    
      target="_blank" class="external-link"
    
>coroutine</a>
, which is a component whose execution
can be suspended and resumed later. As you may recall, the previous version of this method performed a single step of
the algorithm and then returned a boolean to indicate whether the algorithm had finished. The version presented here
does something similar, but instead of returning after a single step, it yields <code>null</code>, suspends execution, and then returns
control to the consumer of the enumerator.</p>
<p>Here&rsquo;s how this thing is used, boiled down to just using the <code>AStarPathfinder</code>:</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-csharp" data-lang="csharp"><span class="line"><span class="cl"><span class="kd">public</span> <span class="k">class</span> <span class="nc">Pathfinding</span>
</span></span><span class="line"><span class="cl"><span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="c1">// ...</span>
</span></span><span class="line"><span class="cl">    
</span></span><span class="line"><span class="cl">    <span class="kd">private</span> <span class="k">readonly</span> <span class="n">ControlPanel</span> <span class="n">_controlPanel</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">    <span class="kd">private</span> <span class="k">readonly</span> <span class="n">AStarPathfinder</span> <span class="n">_pathFinder</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">    <span class="kd">private</span> <span class="k">readonly</span> <span class="n">Grid</span> <span class="n">_grid</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="c1">// ...</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="kd">private</span> <span class="n">IEnumerator</span> <span class="n">_findPathCoroutine</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">    <span class="kd">private</span> <span class="kt">bool</span> <span class="n">_hasJumpCapability</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="c1">// ...</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="n">Pathfinding</span><span class="p">()</span>
</span></span><span class="line"><span class="cl">    <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="n">_pathFinder</span> <span class="p">=</span> <span class="k">new</span> <span class="n">AStarPathfinder</span><span class="p">(</span><span class="n">_grid</span><span class="p">,</span> <span class="k">new</span> <span class="n">NeighborFinder</span><span class="p">());</span>
</span></span><span class="line"><span class="cl">        <span class="n">_findPathCoroutine</span> <span class="p">=</span> <span class="n">_pathFinder</span><span class="p">.</span><span class="n">FindPathCoroutine</span><span class="p">(</span><span class="n">_hasJumpCapability</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">        <span class="n">_controlPanel</span> <span class="p">=</span> <span class="k">new</span> <span class="n">ControlPanel</span><span class="p">(</span><span class="cm">/* ... */</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">        <span class="c1">// ...</span>
</span></span><span class="line"><span class="cl">        <span class="n">_controlPanel</span><span class="p">.</span><span class="n">StepButtonClicked</span> <span class="p">+=</span> <span class="n">Step</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">        <span class="n">_controlPanel</span><span class="p">.</span><span class="n">ResetButtonClicked</span> <span class="p">+=</span> <span class="n">Reset</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">        <span class="n">_controlPanel</span><span class="p">.</span><span class="n">JumpingButtonToggled</span> <span class="p">+=</span> <span class="n">hasJumpCapability</span> <span class="p">=&gt;</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">            <span class="n">_hasJumpCapability</span> <span class="p">=</span> <span class="n">hasJumpCapability</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">            <span class="n">Reset</span><span class="p">();</span>
</span></span><span class="line"><span class="cl">        <span class="p">};</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="c1">// ...</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="k">void</span> <span class="n">Update</span><span class="p">(</span><span class="n">GameTime</span> <span class="n">gameTime</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">    <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="c1">// ...</span>
</span></span><span class="line"><span class="cl">        <span class="n">Step</span><span class="p">();</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="kd">private</span> <span class="k">void</span> <span class="n">Step</span><span class="p">()</span>
</span></span><span class="line"><span class="cl">    <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="k">if</span> <span class="p">(</span><span class="n">_isPathfindingFinished</span><span class="p">)</span> <span class="k">return</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">        <span class="n">_isPathfindingFinished</span> <span class="p">=</span> <span class="p">!</span><span class="n">_findPathCoroutine</span><span class="p">.</span><span class="n">MoveNext</span><span class="p">();</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="kd">private</span> <span class="k">void</span> <span class="n">Reset</span><span class="p">()</span>
</span></span><span class="line"><span class="cl">    <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="n">_grid</span><span class="p">.</span><span class="n">Reset</span><span class="p">();</span>
</span></span><span class="line"><span class="cl">        <span class="n">_findPathCoroutine</span> <span class="p">=</span> <span class="n">_pathFinder</span><span class="p">.</span><span class="n">FindPathCoroutine</span><span class="p">(</span><span class="n">_hasJumpCapability</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">        <span class="n">_isPathfindingFinished</span> <span class="p">=</span> <span class="kc">false</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span></code></pre></div><p>At the beginning and whenever we need to start over (e.g. because the grid changed) we call</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-csharp" data-lang="csharp"><span class="line"><span class="cl"><span class="n">_findPathCoroutine</span> <span class="p">=</span> <span class="n">_pathFinder</span><span class="p">.</span><span class="n">FindPathCoroutine</span><span class="p">(</span><span class="n">_hasJumpCapability</span><span class="p">);</span>
</span></span></code></pre></div><p>which returns an <code>IEnumerator</code> over which we can iterate a single step by calling</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-csharp" data-lang="csharp"><span class="line"><span class="cl"><span class="n">_findPathCoroutine</span><span class="p">.</span><span class="n">MoveNext</span><span class="p">()</span>
</span></span></code></pre></div><p>which in turn returns <code>true</code> if the enumerator could be moved to the next element or <code>false</code> when we reached the end.</p>
<h2 id="interactive-example">Interactive Example</h2>
<p>At last, here&rsquo;s the interactive example you&rsquo;ve been waiting for:</p>




<div id="app-div" style="width: 320px; height: 416px;">
    <iframe
            name="app-iframe"
            id="app-iframe"
            data-src="/blazor/pathfinding-side-view/wwwroot/index.html"
            src="about:blank"
            title="Pathfinding Example App"
            allow="fullscreen"
            referrerpolicy="origin"
            width="320"
            height="416"
    >
    </iframe>
    <div id="app-div-link" class="link-load-app">
        <u>Click to load app</u>
    </div>
</div>

<p>This example lets you step through the algorithm step by step or watch it do its work. You can also manipulate
the grid by changing the cell types.</p>
<p>Compared to the other interactive example from one of the top-down posts, there&rsquo;s an additional toggle switch which let&rsquo;s you
control whether the character has jump capability. Here are the buttons explained:</p>
<ul>
<li><figure class="list-item-image"><img src="/https/shendriks.dev/posts/2024-09-04-a-star-pathfinding-side-view/images/ButtonPlay.png">
</figure>
 <figure class="list-item-image"><img src="/https/shendriks.dev/posts/2024-09-04-a-star-pathfinding-side-view/images/ButtonStop.png">
 </figure>
 <strong>Play/Stop</strong>: When first clicked, the algorithm will automatically run at a relatively slow pace so you can watch it in all its beauty; when clicked again, it will stop.</li>
<li><figure class="list-item-image"><img src="/https/shendriks.dev/posts/2024-09-04-a-star-pathfinding-side-view/images/ButtonStep.png">
</figure>
 <strong>Step</strong>: Click to execute a single step of the algorithm.</li>
<li><figure class="list-item-image"><img src="/https/shendriks.dev/posts/2024-09-04-a-star-pathfinding-side-view/images/ButtonReset.png">
</figure>
 <strong>Reset</strong>: Click to reset the algorithm.</li>
<li><figure class="list-item-image"><img src="/https/shendriks.dev/posts/2024-09-04-a-star-pathfinding-side-view/images/ToggleShowParentOff.png">
</figure>
 <figure class="list-item-image"><img src="/https/shendriks.dev/posts/2024-09-04-a-star-pathfinding-side-view/images/ToggleShowParentOn.png">
 </figure>
 <strong>Show/Hide Parent</strong>: When switched on, shows the relationship of the cells to their parent cells.</li>
<li><figure class="list-item-image"><img src="/https/shendriks.dev/posts/2024-09-04-a-star-pathfinding-side-view/images/ToggleJumpingOff.png">
</figure>
 <figure class="list-item-image"><img src="/https/shendriks.dev/posts/2024-09-04-a-star-pathfinding-side-view/images/ToggleJumpingOn.png">
 </figure>
 <strong>Toggle Jumping</strong>: When switched on, jumping is enabled.</li>
</ul>
<p>Furthermore, you can edit the game world. By clicking one cell you can cycle through the different cell types. If you
click and hold, you can &ldquo;paint&rdquo; the world with the new cell type. Plus, you can drag the start (A) and target (B) cells
around.</p>
<p>When the algorithm is running, the cells change color:</p>
<ul>
<li><figure class="list-item-image"><img src="/https/shendriks.dev/posts/2024-09-04-a-star-pathfinding-side-view/images/CellRed.png">
</figure>
 <strong>Red</strong>: This is the cell currently being examined.</li>
<li><figure class="list-item-image"><img src="/https/shendriks.dev/posts/2024-09-04-a-star-pathfinding-side-view/images/CellOrange.png">
</figure>
 <strong>Orange</strong>: These cells are in the <code>openSet</code> and are about to be examined.</li>
<li><figure class="list-item-image"><img src="/https/shendriks.dev/posts/2024-09-04-a-star-pathfinding-side-view/images/CellYellow.png">
</figure>
 <strong>Yellow</strong>: These cells have their parent cell set.</li>
<li><figure class="list-item-image"><img src="/https/shendriks.dev/posts/2024-09-04-a-star-pathfinding-side-view/images/CellGreen.png">
</figure>
 <strong>Green</strong>: These cells are part of the path from A to B.</li>
</ul>
<p>Additionally, cells that are being checked by the algorithm display two numbers. The first number in the upper left
corner displays the cost from the start cell to this cell. The second number below shows the estimated cost from the start to the
destination via that cell.</p>
<p><strong>Example</strong>: <figure class="list-item-image"><img src="/https/shendriks.dev/posts/2024-09-04-a-star-pathfinding-side-view/images/CellNumbers.png">
</figure>
 The cost from the start to this cell
is <code>2</code>, and the estimated cost from the start to the target via this cell is <code>14</code>.</p>
<h2 id="conclusion">Conclusion</h2>
<p>In a nutshell, making the switch from a top-down approach to a side-view platformer brings a few challenges,
because of the involvement of gravity and the limited movement options. Characters can&rsquo;t just go up and down in
the same way they would in a top-down scenario. Instead, they use ladders, hanging bars, and jumping to overcome obstacles in
the game world. We looked at how we could tweak the A* pathfinding algorithm and the neighbor-finding logic in particular
to make it work with these constraints.</p>
]]></content></item><item><title>A* Pathfinding in 2D Games: A Simple Top-Down Scenario Implemented with MonoGame/KNI</title><link>https://shendriks.dev/posts/2024-08-24-a-star-pathfinding-top-down-blazorgl/</link><pubDate>Sat, 24 Aug 2024 00:00:00 +0000</pubDate><guid>https://shendriks.dev/posts/2024-08-24-a-star-pathfinding-top-down-blazorgl/</guid><description>In this article we will have a look at the implementation of the A* algorithm from the previous post with KNI, a MonoGame derivate with support for BlazorGL.</description><content type="html"><![CDATA[<h2 id="introduction">Introduction</h2>
<p>In the <a href="/https/shendriks.dev/posts/2024-07-13-a-star-pathfinding-in-2d-games-the-basics-for-top-down-scenarios/"
    
    
>last article</a>
 of this
series we introduced the A* algorithm and implemented a simple console application in C# for
a top-down scenario. As a bonus, there was an interactive example implemented with the <a href="https://monogame.net/"
    
    
      target="_blank" class="external-link"
    
>MonoGame</a>

derivative called <a href="https://github.com/kniEngine/kni"
    
    
      target="_blank" class="external-link"
    
>KNI</a>
. If you don&rsquo;t know what I&rsquo;m talking about, then no worries, here it is again:</p>




<div id="app-div" style="width: 320px; height: 380px;">
    <iframe
            name="app-iframe"
            id="app-iframe"
            data-src="/blazor/pathfinding-top-down/wwwroot/index.html"
            src="about:blank"
            title="Pathfinding Example App"
            allow="fullscreen"
            referrerpolicy="origin"
            width="320"
            height="380"
    >
    </iframe>
    <div id="app-div-link" class="link-load-app">
        <u>Click to load app</u>
    </div>
</div>

<p>I know, at the end of the last post, I promised that next time we&rsquo;d look at how to go from top-down to side-view with
gravity and ladders and all that, but I thought it might be cool to shed some light on how the MonoGame version of the
application is implemented. And that&rsquo;s what we&rsquo;re going to do in this article.</p>
<div class="notice note" >
    <p class="notice-title">
        <span class="icon-notice baseline">
            <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 128 300 300">
  <path d="M150 128c82.813 0 150 67.188 150 150 0 82.813-67.188 150-150 150C67.187 428 0 360.812 0 278c0-82.813 67.188-150 150-150Zm25 243.555v-37.11c0-3.515-2.734-6.445-6.055-6.445h-37.5c-3.515 0-6.445 2.93-6.445 6.445v37.11c0 3.515 2.93 6.445 6.445 6.445h37.5c3.32 0 6.055-2.93 6.055-6.445Zm-.39-67.188 3.515-121.289c0-1.367-.586-2.734-1.953-3.516-1.172-.976-2.93-1.562-4.688-1.562h-42.968c-1.758 0-3.516.586-4.688 1.563-1.367.78-1.953 2.148-1.953 3.515l3.32 121.29c0 2.734 2.93 4.882 6.64 4.882h36.134c3.515 0 6.445-2.148 6.64-4.883Z"/>
</svg>

        </span>Note</p><p>I assume some basic knowledge about how MonoGame works. Ideally, you&rsquo;ve already built something with MonoGame yourself.
If not, I&rsquo;d recommend going through one of those <a href="https://docs.monogame.net/articles/tutorials/index.html"
    
    
      target="_blank" class="external-link"
    
>tutorials</a>
.</p></div>

<h2 id="requirements">Requirements</h2>
<p>First, let&rsquo;s list a few functional requirements for the interactive app:</p>
<ul>
<li>Display the 2D grid with its cells</li>
<li>Support two types of cells: Freely walkable cells and blocked cells that are not walkable</li>
<li>Display the start and target cell</li>
<li>Display the current state of the algorithm, e.g. by showing which cells are currently in the <code>openSet</code> etc.</li>
<li>Add an autoplay option that goes through the steps at a &ldquo;slow&rdquo; speed automatically</li>
<li>Also, let the user go through the pathfinding algorithm step by step</li>
<li>Let the user edit the grid, i.e. let the user move that start and target cell around and let them &ldquo;paint&rdquo; and erase
walls (a.k.a. level editor).</li>
</ul>
<h2 id="a-wireframe-of-the-gui">A Wireframe of the GUI</h2>
<p>Let&rsquo;s draw a quick wireframe of the GUI to get an idea of what the final app will look like (of course, you already know
what the final app will look like, but look at this awesome sketch):</p>
<figure class="center"><img src="/https/shendriks.dev/posts/2024-08-24-a-star-pathfinding-top-down-blazorgl/images/gui.svg"
			alt="A wireframe of the GUI"><figcaption>
			<p>A wireframe of the GUI</p>
		</figcaption>
</figure>

<p>At the top, you&rsquo;ll see the 10x10 grid with free and blocked cells. Blocked cells are shown with a crosshatched pattern.
The start cell is shown as A and the destination cell as B. Below the grid,
we have a control panel with four buttons: &ldquo;Play/Stop&rdquo; to automatically execute the algorithm, &ldquo;Step&rdquo; for doing one step
of the algorithm, &ldquo;Reset&rdquo; to reset the algorithm to its initial state, and &ldquo;Show Parent Relation&rdquo; for displaying the
cells&rsquo; relations to their parent cell.</p>
<h2 id="component-diagram">Component Diagram</h2>
<p>The app can be broken down into three main parts each of which consists of one or more components: the GUI and user input
handling, the data model (which includes the grid and its cells), and a component with the logic, which is based on the
A* algorithm. The basic idea is to break the whole thing down into smaller components, with each one ideally responsible
for one thing and one thing only
(See <a href="https://blog.cleancoder.com/uncle-bob/2014/05/08/SingleReponsibilityPrinciple.html"
    
    
      target="_blank" class="external-link"
    
>Single-Responsibility Principle</a>
).
Another benefit of separating the data and logic from the rendering and user input handling is that it makes the logic
easier to unit test.</p>
<p>Let&rsquo;s illustrate this with a quick component diagram:</p>
<figure class="center"><img src="/https/shendriks.dev/posts/2024-08-24-a-star-pathfinding-top-down-blazorgl/images/design.svg"
			alt="A component diagram of the app"><figcaption>
			<p>A component diagram of the app</p>
		</figcaption>
</figure>

<p>The arrows depict the flow of data (or commands) from one component to another.</p>
<h2 id="lets-code">Let&rsquo;s Code!</h2>
<h3 id="the-data-model">The Data Model</h3>
<p>Now, let&rsquo;s get our hands dirty with some code. Unlike the console application, which is something you run once and
then it&rsquo;s done, an interactive application needs to be, well, interactive. This means we need to read user input while
the algorithm runs and start and stop the algorithm on the user&rsquo;s behalf. The current state of the algorithm needs to be
displayed and even the grid needs to be editable, which means we need to build a simple level editor.</p>
<p>First, we need to extend the data model. We&rsquo;ll add a few more properties to the <code>Cell</code> class, which correspond to the current
state of the A* algorithm, e.g. we&rsquo;ll let the cell &ldquo;know&rdquo; if it&rsquo;s in the <code>openSet</code> or later if it&rsquo;s part of the path, etc.</p>
<div class="notice note" >
    <p class="notice-title">
        <span class="icon-notice baseline">
            <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 128 300 300">
  <path d="M150 128c82.813 0 150 67.188 150 150 0 82.813-67.188 150-150 150C67.187 428 0 360.812 0 278c0-82.813 67.188-150 150-150Zm25 243.555v-37.11c0-3.515-2.734-6.445-6.055-6.445h-37.5c-3.515 0-6.445 2.93-6.445 6.445v37.11c0 3.515 2.93 6.445 6.445 6.445h37.5c3.32 0 6.055-2.93 6.055-6.445Zm-.39-67.188 3.515-121.289c0-1.367-.586-2.734-1.953-3.516-1.172-.976-2.93-1.562-4.688-1.562h-42.968c-1.758 0-3.516.586-4.688 1.563-1.367.78-1.953 2.148-1.953 3.515l3.32 121.29c0 2.734 2.93 4.882 6.64 4.882h36.134c3.515 0 6.445-2.148 6.64-4.883Z"/>
</svg>

        </span>Note</p><p>By the way, you don&rsquo;t have to manually copy code snippets around. The complete project is available on
<a href="https://github.com/shendriks/pathfinding-2d"
    
    
      target="_blank" class="external-link"
    
>GitHub</a>
.</p></div>

<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-csharp" data-lang="csharp"><span class="line"><span class="cl"><span class="kd">public</span> <span class="k">class</span> <span class="nc">Cell</span><span class="p">(</span><span class="kt">int</span> <span class="n">x</span><span class="p">,</span> <span class="kt">int</span> <span class="n">y</span><span class="p">,</span> <span class="kt">bool</span> <span class="n">isWalkable</span><span class="p">)</span>
</span></span><span class="line"><span class="cl"><span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="c1">// Already familiar properties ahead</span>
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="n">Point</span> <span class="n">Position</span> <span class="p">{</span> <span class="k">get</span><span class="p">;</span> <span class="p">}</span> <span class="p">=</span> <span class="k">new</span><span class="p">(</span><span class="n">x</span><span class="p">,</span> <span class="n">y</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="kt">int</span> <span class="n">X</span> <span class="p">=&gt;</span> <span class="n">Position</span><span class="p">.</span><span class="n">X</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="kt">int</span> <span class="n">Y</span> <span class="p">=&gt;</span> <span class="n">Position</span><span class="p">.</span><span class="n">Y</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="kt">bool</span> <span class="n">IsWalkable</span> <span class="p">{</span> <span class="k">get</span><span class="p">;</span> <span class="p">}</span> <span class="p">=</span> <span class="n">isWalkable</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="kt">float</span> <span class="n">CostToTarget</span> <span class="p">{</span> <span class="k">get</span><span class="p">;</span> <span class="k">set</span><span class="p">;</span> <span class="p">}</span> <span class="p">=</span> <span class="kt">float</span><span class="p">.</span><span class="n">PositiveInfinity</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="kt">float</span> <span class="n">CostFromStart</span> <span class="p">{</span> <span class="k">get</span><span class="p">;</span> <span class="k">set</span><span class="p">;</span> <span class="p">}</span> <span class="p">=</span> <span class="kt">float</span><span class="p">.</span><span class="n">PositiveInfinity</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="n">Cell</span><span class="p">?</span> <span class="n">Parent</span> <span class="p">{</span> <span class="k">get</span><span class="p">;</span> <span class="k">set</span><span class="p">;</span> <span class="p">}</span>
</span></span><span class="line"><span class="cl">        
</span></span><span class="line"><span class="cl">    <span class="c1">// Here come the new properties</span>
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="kt">bool</span> <span class="n">IsOnPath</span> <span class="p">{</span> <span class="k">get</span><span class="p">;</span> <span class="k">set</span><span class="p">;</span> <span class="p">}</span>
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="kt">bool</span> <span class="n">IsInOpenSet</span> <span class="p">{</span> <span class="k">get</span><span class="p">;</span> <span class="k">set</span><span class="p">;</span> <span class="p">}</span>
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="kt">bool</span> <span class="n">WasInspected</span> <span class="p">{</span> <span class="k">get</span><span class="p">;</span> <span class="k">set</span><span class="p">;</span> <span class="p">}</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span></code></pre></div><p>Let’s have a quick look at the added properties.</p>
<ul>
<li><code>IsOnPath</code> will bet set to <code>true</code> when a path is found and the cell is part of the path.</li>
<li><code>IsInOpenSet</code> is set to <code>true</code> if the cell is in the <code>openSet</code>.</li>
<li><code>WasInspected</code> is set to <code>true</code> if the cell was inspected by the algorithm.</li>
</ul>
<p>In addition, we need a way to reset the cell to its initial state, e.g. in case the user hits the &ldquo;Reset&rdquo; button or the
A* algorithm needs to start over because the grid changed. For this we add a <code>Reset</code> method to the <code>Cell</code> class:</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-csharp" data-lang="csharp"><span class="line"><span class="cl"><span class="kd">public</span> <span class="k">class</span> <span class="nc">Cell</span><span class="p">(</span><span class="kt">int</span> <span class="n">x</span><span class="p">,</span> <span class="kt">int</span> <span class="n">y</span><span class="p">,</span> <span class="kt">bool</span> <span class="n">isWalkable</span><span class="p">)</span>
</span></span><span class="line"><span class="cl"><span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="c1">// ...</span>
</span></span><span class="line"><span class="cl">    
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="k">void</span> <span class="n">Reset</span><span class="p">()</span>
</span></span><span class="line"><span class="cl">    <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="n">CostToTarget</span> <span class="p">=</span> <span class="kt">float</span><span class="p">.</span><span class="n">PositiveInfinity</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">        <span class="n">CostFromStart</span> <span class="p">=</span> <span class="kt">float</span><span class="p">.</span><span class="n">PositiveInfinity</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">        <span class="n">Parent</span> <span class="p">=</span> <span class="kc">null</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">        <span class="n">IsOnPath</span> <span class="p">=</span> <span class="kc">false</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">        <span class="n">IsInOpenSet</span> <span class="p">=</span> <span class="kc">false</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">        <span class="n">WasInspected</span> <span class="p">=</span> <span class="kc">false</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span></code></pre></div><div class="notice note" >
    <p class="notice-title">
        <span class="icon-notice baseline">
            <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 128 300 300">
  <path d="M150 128c82.813 0 150 67.188 150 150 0 82.813-67.188 150-150 150C67.187 428 0 360.812 0 278c0-82.813 67.188-150 150-150Zm25 243.555v-37.11c0-3.515-2.734-6.445-6.055-6.445h-37.5c-3.515 0-6.445 2.93-6.445 6.445v37.11c0 3.515 2.93 6.445 6.445 6.445h37.5c3.32 0 6.055-2.93 6.055-6.445Zm-.39-67.188 3.515-121.289c0-1.367-.586-2.734-1.953-3.516-1.172-.976-2.93-1.562-4.688-1.562h-42.968c-1.758 0-3.516.586-4.688 1.563-1.367.78-1.953 2.148-1.953 3.515l3.32 121.29c0 2.734 2.93 4.882 6.64 4.882h36.134c3.515 0 6.445-2.148 6.64-4.883Z"/>
</svg>

        </span>Note</p><p><strong>But, isn&rsquo;t the <code>Cell</code> class doing too much?</strong></p>
<p>One could argue that the new properties (and really all properties that have something to do with the state of the A*
algorithm) and the new method shouldn&rsquo;t be part of the <code>Cell</code> class but should rather be in a data structure of their own. And you could do
that, e.g. by letting the <code>Cell</code> class store only its position and whether it&rsquo;s walkable and then have something like an
<code>AStarCell</code> class that inherits from or maybe better decorates the <code>Cell</code> class and adds the additional properties and methods
needed for the A* algorithm.</p>
<p>This would definitely help to keep things more separate into single classes (Single-Responsibility Principle, remember?).
And guess what, I gave that a shot, but I felt it would be overkill for this relatively simple example and only makes the
code unnecessarily complex and it doesn&rsquo;t really benefit anything. It just adds an additional layer of unnecessary indirection
and makes it more complicated to work with.</p>
<p>So, for the sake of simplicity and my own peace of mind we&rsquo;ll stuff all that into the <code>Cell</code> class and be done with it.</p></div>

<p>For now, let&rsquo;s move on to the <code>Grid</code> class and additionally store the start and target positions and do a few sanity checks
when setting these. Also, add two convenience properties for getting the start and target cell directly
(Note: we&rsquo;re going to use the <a href="https://docs.monogame.net/api/Microsoft.Xna.Framework.Point.html"
    
    
      target="_blank" class="external-link"
    
>MonoGame implementation of Point</a>

rather than our own):</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-csharp" data-lang="csharp"><span class="line"><span class="cl"><span class="kd">public</span> <span class="k">class</span> <span class="nc">Grid</span>
</span></span><span class="line"><span class="cl"><span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="kd">private</span> <span class="k">readonly</span> <span class="n">Cell</span><span class="p">[,]</span> <span class="n">_cells</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="kd">private</span> <span class="n">Point</span> <span class="n">_startPosition</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">    <span class="kd">private</span> <span class="n">Point</span> <span class="n">_targetPosition</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="n">Point</span> <span class="n">StartPosition</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="k">get</span> <span class="p">=&gt;</span> <span class="n">_startPosition</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">        <span class="k">set</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">            <span class="k">if</span> <span class="p">(</span><span class="n">_startPosition</span> <span class="p">==</span> <span class="k">value</span><span class="p">)</span> <span class="k">return</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">            <span class="k">if</span> <span class="p">(!</span><span class="n">IsInsideBounds</span><span class="p">(</span><span class="k">value</span><span class="p">))</span> <span class="k">return</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">            <span class="k">if</span> <span class="p">(!</span><span class="n">_cells</span><span class="p">[</span><span class="k">value</span><span class="p">.</span><span class="n">X</span><span class="p">,</span> <span class="k">value</span><span class="p">.</span><span class="n">Y</span><span class="p">].</span><span class="n">IsWalkable</span><span class="p">)</span> <span class="k">return</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">            <span class="n">_startPosition</span> <span class="p">=</span> <span class="k">value</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">        <span class="p">}</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="n">Point</span> <span class="n">TargetPosition</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="k">get</span> <span class="p">=&gt;</span> <span class="n">_targetPosition</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">        <span class="k">set</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">            <span class="k">if</span> <span class="p">(</span><span class="n">_targetPosition</span> <span class="p">==</span> <span class="k">value</span><span class="p">)</span> <span class="k">return</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">            <span class="k">if</span> <span class="p">(!</span><span class="n">IsInsideBounds</span><span class="p">(</span><span class="k">value</span><span class="p">))</span> <span class="k">return</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">            <span class="k">if</span> <span class="p">(!</span><span class="n">_cells</span><span class="p">[</span><span class="k">value</span><span class="p">.</span><span class="n">X</span><span class="p">,</span> <span class="k">value</span><span class="p">.</span><span class="n">Y</span><span class="p">].</span><span class="n">IsWalkable</span><span class="p">)</span> <span class="k">return</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">            <span class="n">_targetPosition</span> <span class="p">=</span> <span class="k">value</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">        <span class="p">}</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="n">Cell</span> <span class="n">Start</span> <span class="p">=&gt;</span> <span class="n">_cells</span><span class="p">[</span><span class="n">StartPosition</span><span class="p">.</span><span class="n">X</span><span class="p">,</span> <span class="n">StartPosition</span><span class="p">.</span><span class="n">Y</span><span class="p">];</span>
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="n">Cell</span> <span class="n">Target</span> <span class="p">=&gt;</span> <span class="n">_cells</span><span class="p">[</span><span class="n">TargetPosition</span><span class="p">.</span><span class="n">X</span><span class="p">,</span> <span class="n">TargetPosition</span><span class="p">.</span><span class="n">Y</span><span class="p">];</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="kd">private</span> <span class="n">Grid</span><span class="p">(</span><span class="n">Cell</span><span class="p">[,]</span> <span class="n">cells</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">    <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="n">_cells</span> <span class="p">=</span> <span class="n">cells</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">        <span class="c1">// ...</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="kd">static</span> <span class="n">Grid</span> <span class="n">CreateFromArray</span><span class="p">(</span><span class="kt">int</span><span class="p">[,]</span> <span class="n">map</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">    <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="c1">// ...</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="kt">bool</span> <span class="n">TryGetCellAtPosition</span><span class="p">(</span><span class="n">Point</span> <span class="n">position</span><span class="p">,</span> <span class="k">out</span> <span class="n">Cell</span> <span class="n">cell</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">    <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="c1">// ...</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="kd">private</span> <span class="kt">bool</span> <span class="n">IsInsideBounds</span><span class="p">(</span><span class="n">Point</span> <span class="n">position</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">    <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="kt">var</span> <span class="p">(</span><span class="n">x</span><span class="p">,</span> <span class="n">y</span><span class="p">)</span> <span class="p">=</span> <span class="n">position</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">        <span class="k">return</span> <span class="n">x</span> <span class="p">&gt;=</span> <span class="m">0</span>  <span class="p">&amp;&amp;</span> <span class="n">x</span> <span class="p">&lt;</span> <span class="n">_cells</span><span class="p">.</span><span class="n">GetLength</span><span class="p">(</span><span class="m">0</span><span class="p">)</span> 
</span></span><span class="line"><span class="cl">            <span class="p">&amp;&amp;</span> <span class="n">y</span> <span class="p">&gt;=</span> <span class="m">0</span>  <span class="p">&amp;&amp;</span> <span class="n">y</span> <span class="p">&lt;</span> <span class="n">_cells</span><span class="p">.</span><span class="n">GetLength</span><span class="p">(</span><span class="m">1</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span></code></pre></div><p>You might have noticed that the old <code>Grid</code> class had a public property of type <code>Cell[,]</code> with which you could access the
grid&rsquo;s cells array directly. One problem with that approach is that you can, in theory, set individual cells in the array
from outside the <code>Grid</code> class and thus break <a href="https://en.wikipedia.org/wiki/Encapsulation_%28computer_programming%29"
    
    
      target="_blank" class="external-link"
    
>data encapsulation</a>
. You could do even something
nasty and for example insert a cell with an incorrect position:</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-csharp" data-lang="csharp"><span class="line"><span class="cl"><span class="n">grid</span><span class="p">.</span><span class="n">Cells</span><span class="p">[</span><span class="m">1</span><span class="p">,</span> <span class="m">2</span><span class="p">]</span> <span class="p">=</span> <span class="k">new</span> <span class="n">Cell</span><span class="p">(</span><span class="m">17</span><span class="p">,</span> <span class="m">8</span><span class="p">,</span> <span class="kc">false</span><span class="p">);</span> <span class="c1">// Yuck!</span>
</span></span></code></pre></div><p>Now, instead of exposing the array to the outer world, we let the <code>Grid</code> class implement its own
<a href="https://learn.microsoft.com/en-us/dotnet/csharp/programming-guide/indexers/"
    
    
      target="_blank" class="external-link"
    
>indexer</a>
 so the grid can be used directly
as a 2-dimensional array of <code>Cell</code> objects which is quite nice. By omitting the setter it is now impossible to overwrite
cells in the array.</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-csharp" data-lang="csharp"><span class="line"><span class="cl"><span class="kd">public</span> <span class="k">class</span> <span class="nc">Grid</span>
</span></span><span class="line"><span class="cl"><span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="c1">// ...</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="n">Cell</span> <span class="k">this</span><span class="p">[</span><span class="kt">int</span> <span class="n">x</span><span class="p">,</span> <span class="kt">int</span> <span class="n">y</span><span class="p">]</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="k">get</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">            <span class="k">if</span> <span class="p">(!</span><span class="n">IsInsideBounds</span><span class="p">(</span><span class="k">new</span> <span class="n">Point</span><span class="p">(</span><span class="n">x</span><span class="p">,</span> <span class="n">y</span><span class="p">)))</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">                <span class="k">throw</span> <span class="k">new</span> <span class="n">IndexOutOfRangeException</span><span class="p">();</span>
</span></span><span class="line"><span class="cl">            <span class="p">}</span>
</span></span><span class="line"><span class="cl">            <span class="k">return</span> <span class="n">_cells</span><span class="p">[</span><span class="n">x</span><span class="p">,</span> <span class="n">y</span><span class="p">];</span>
</span></span><span class="line"><span class="cl">        <span class="p">}</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl">   
</span></span><span class="line"><span class="cl">    <span class="c1">// ...</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span></code></pre></div><p>You can now do something along the lines of</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-csharp" data-lang="csharp"><span class="line"><span class="cl"><span class="kt">var</span> <span class="n">cell</span> <span class="p">=</span> <span class="n">grid</span><span class="p">[</span><span class="m">3</span><span class="p">,</span><span class="m">2</span><span class="p">];</span>
</span></span></code></pre></div><p>instead of</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-csharp" data-lang="csharp"><span class="line"><span class="cl"><span class="kt">var</span> <span class="n">cell</span> <span class="p">=</span> <span class="n">grid</span><span class="p">.</span><span class="n">Cells</span><span class="p">[</span><span class="m">3</span><span class="p">,</span><span class="m">2</span><span class="p">];</span>
</span></span></code></pre></div><p>Let&rsquo;s not forget we need to be able to reset the grid, e.g. when the user tears down a wall. So, let&rsquo;s add a <code>Reset</code>
method which in turn calls the individual cells&rsquo; <code>Reset</code> methods:</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-csharp" data-lang="csharp"><span class="line"><span class="cl"><span class="kd">public</span> <span class="k">class</span> <span class="nc">Grid</span>
</span></span><span class="line"><span class="cl"><span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="c1">// ...</span>
</span></span><span class="line"><span class="cl">    
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="k">void</span> <span class="n">Reset</span><span class="p">()</span>
</span></span><span class="line"><span class="cl">    <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="k">foreach</span> <span class="p">(</span><span class="kt">var</span> <span class="n">cell</span> <span class="k">in</span> <span class="n">_cells</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">            <span class="n">cell</span><span class="p">.</span><span class="n">Reset</span><span class="p">();</span>
</span></span><span class="line"><span class="cl">        <span class="p">}</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span></code></pre></div><h3 id="the-logic">The Logic</h3>
<p>Now that we&rsquo;ve updated the data model for the grid and cells, let&rsquo;s have a look at the A* algorithm. The challenge now is
that we need to be able to go through the algorithm step by step. What we need is a method, let&rsquo;s call it &hellip; <em>drum roll</em> &hellip; <code>Step</code>, which
does one step (or rather one iteration) of the algorithm and then returns:</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-csharp" data-lang="csharp"><span class="line"><span class="cl"><span class="kd">public</span> <span class="k">class</span> <span class="nc">AStarPathfinder</span><span class="p">(</span><span class="n">Grid</span> <span class="n">grid</span><span class="p">)</span>
</span></span><span class="line"><span class="cl"><span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="kd">private</span> <span class="n">List</span><span class="p">&lt;</span><span class="n">Cell</span><span class="p">&gt;</span> <span class="n">_openSet</span> <span class="p">=</span> <span class="p">[];</span>
</span></span><span class="line"><span class="cl">    <span class="kd">private</span> <span class="kt">bool</span> <span class="n">_needsInit</span> <span class="p">=</span> <span class="kc">true</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="cs">/// &lt;summary&gt;Evaluates one step of the algorithm&lt;/summary&gt;</span>
</span></span><span class="line"><span class="cl">    <span class="cs">/// &lt;returns&gt;True if done (i.e. a path was found or there is no path), false otherwise&lt;/returns&gt;</span>
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="kt">bool</span> <span class="n">Step</span><span class="p">()</span>
</span></span><span class="line"><span class="cl">    <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="k">if</span> <span class="p">(</span><span class="n">_needsInit</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">            <span class="n">grid</span><span class="p">.</span><span class="n">Start</span><span class="p">.</span><span class="n">CostFromStart</span> <span class="p">=</span> <span class="m">0</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">            <span class="n">grid</span><span class="p">.</span><span class="n">Start</span><span class="p">.</span><span class="n">CostToTarget</span> <span class="p">=</span> <span class="n">GetDistance</span><span class="p">(</span><span class="n">grid</span><span class="p">.</span><span class="n">Start</span><span class="p">,</span> <span class="n">grid</span><span class="p">.</span><span class="n">Target</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">            <span class="n">_openSet</span> <span class="p">=</span> <span class="p">[</span><span class="n">grid</span><span class="p">.</span><span class="n">Start</span><span class="p">];</span>
</span></span><span class="line"><span class="cl">            <span class="n">_needsInit</span> <span class="p">=</span> <span class="kc">false</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">        <span class="p">}</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">        <span class="k">if</span> <span class="p">(</span><span class="n">_openSet</span><span class="p">.</span><span class="n">Count</span> <span class="p">==</span> <span class="m">0</span><span class="p">)</span> <span class="k">return</span> <span class="kc">true</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">        <span class="kt">var</span> <span class="n">current</span> <span class="p">=</span> <span class="n">_openSet</span><span class="p">.</span><span class="n">OrderBy</span><span class="p">(</span><span class="n">c</span> <span class="p">=&gt;</span> <span class="n">c</span><span class="p">.</span><span class="n">CostToTarget</span><span class="p">).</span><span class="n">First</span><span class="p">();</span>
</span></span><span class="line"><span class="cl">        <span class="k">if</span> <span class="p">(</span><span class="n">current</span> <span class="p">==</span> <span class="n">grid</span><span class="p">.</span><span class="n">Target</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">            <span class="n">ReconstructPath</span><span class="p">(</span><span class="n">current</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">            <span class="k">return</span> <span class="kc">true</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">        <span class="p">}</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">        <span class="n">_openSet</span><span class="p">.</span><span class="n">Remove</span><span class="p">(</span><span class="n">current</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">        <span class="n">current</span><span class="p">.</span><span class="n">IsInOpenSet</span> <span class="p">=</span> <span class="kc">false</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">        <span class="kt">var</span> <span class="n">tentativeCost</span> <span class="p">=</span> <span class="n">current</span><span class="p">.</span><span class="n">CostFromStart</span> <span class="p">+</span> <span class="m">1</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">        <span class="k">foreach</span> <span class="p">(</span><span class="kt">var</span> <span class="n">n</span> <span class="k">in</span> <span class="n">Neighbors</span><span class="p">(</span><span class="n">current</span><span class="p">).</span><span class="n">Where</span><span class="p">(</span><span class="n">n</span> <span class="p">=&gt;</span> <span class="n">tentativeCost</span> <span class="p">&lt;</span> <span class="n">n</span><span class="p">.</span><span class="n">CostFromStart</span><span class="p">))</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">            <span class="n">n</span><span class="p">.</span><span class="n">Parent</span> <span class="p">=</span> <span class="n">current</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">            <span class="n">n</span><span class="p">.</span><span class="n">CostFromStart</span> <span class="p">=</span> <span class="n">tentativeCost</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">            <span class="n">n</span><span class="p">.</span><span class="n">CostToTarget</span> <span class="p">=</span> <span class="n">tentativeCost</span> <span class="p">+</span> <span class="n">GetDistance</span><span class="p">(</span><span class="n">n</span><span class="p">,</span> <span class="n">grid</span><span class="p">.</span><span class="n">Target</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">            <span class="k">if</span> <span class="p">(</span><span class="n">_openSet</span><span class="p">.</span><span class="n">Contains</span><span class="p">(</span><span class="n">n</span><span class="p">))</span> <span class="k">continue</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">            <span class="n">_openSet</span><span class="p">.</span><span class="n">Add</span><span class="p">(</span><span class="n">n</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">            <span class="n">n</span><span class="p">.</span><span class="n">WasInspected</span> <span class="p">=</span> <span class="kc">true</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">            <span class="n">n</span><span class="p">.</span><span class="n">IsInOpenSet</span> <span class="p">=</span> <span class="kc">true</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">        <span class="p">}</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">        <span class="k">return</span> <span class="kc">false</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="k">void</span> <span class="n">Reset</span><span class="p">()</span>
</span></span><span class="line"><span class="cl">    <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="n">grid</span><span class="p">.</span><span class="n">Reset</span><span class="p">();</span>
</span></span><span class="line"><span class="cl">        <span class="n">_needsInit</span> <span class="p">=</span> <span class="kc">true</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="kd">private</span> <span class="kd">static</span> <span class="k">void</span> <span class="n">ReconstructPath</span><span class="p">(</span><span class="n">Cell</span> <span class="n">current</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">    <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="n">current</span><span class="p">.</span><span class="n">IsOnPath</span> <span class="p">=</span> <span class="kc">true</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">        <span class="kt">var</span> <span class="n">walkingCell</span> <span class="p">=</span> <span class="n">current</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">        <span class="k">while</span> <span class="p">(</span><span class="n">walkingCell</span><span class="p">.</span><span class="n">Parent</span> <span class="p">!=</span> <span class="kc">null</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">            <span class="n">walkingCell</span><span class="p">.</span><span class="n">Parent</span><span class="p">.</span><span class="n">IsOnPath</span> <span class="p">=</span> <span class="kc">true</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">            <span class="n">walkingCell</span> <span class="p">=</span> <span class="n">walkingCell</span><span class="p">.</span><span class="n">Parent</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">        <span class="p">}</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl">    
</span></span><span class="line"><span class="cl">    <span class="kd">private</span> <span class="kd">static</span> <span class="kt">float</span> <span class="n">GetDistance</span><span class="p">(</span><span class="n">Cell</span> <span class="n">a</span><span class="p">,</span> <span class="n">Cell</span> <span class="n">b</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">    <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="k">return</span> <span class="n">Math</span><span class="p">.</span><span class="n">Abs</span><span class="p">(</span><span class="n">a</span><span class="p">.</span><span class="n">X</span> <span class="p">-</span> <span class="n">b</span><span class="p">.</span><span class="n">X</span><span class="p">)</span> <span class="p">+</span> <span class="n">Math</span><span class="p">.</span><span class="n">Abs</span><span class="p">(</span><span class="n">a</span><span class="p">.</span><span class="n">Y</span> <span class="p">-</span> <span class="n">b</span><span class="p">.</span><span class="n">Y</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="kd">private</span> <span class="n">IEnumerable</span><span class="p">&lt;</span><span class="n">Cell</span><span class="p">&gt;</span> <span class="n">Neighbors</span><span class="p">(</span><span class="n">Cell</span> <span class="n">cell</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">    <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="kt">int</span><span class="p">[]</span> <span class="n">dx</span> <span class="p">=</span> <span class="p">[-</span><span class="m">1</span><span class="p">,</span> <span class="m">1</span><span class="p">,</span> <span class="m">0</span><span class="p">,</span> <span class="m">0</span><span class="p">];</span>
</span></span><span class="line"><span class="cl">        <span class="kt">int</span><span class="p">[]</span> <span class="n">dy</span> <span class="p">=</span> <span class="p">[</span><span class="m">0</span><span class="p">,</span> <span class="m">0</span><span class="p">,</span> <span class="p">-</span><span class="m">1</span><span class="p">,</span> <span class="m">1</span><span class="p">];</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">        <span class="k">for</span> <span class="p">(</span><span class="kt">var</span> <span class="n">i</span> <span class="p">=</span> <span class="m">0</span><span class="p">;</span> <span class="n">i</span> <span class="p">&lt;</span> <span class="m">4</span><span class="p">;</span> <span class="n">i</span><span class="p">++)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">            <span class="kt">var</span> <span class="n">checkX</span> <span class="p">=</span> <span class="n">cell</span><span class="p">.</span><span class="n">X</span> <span class="p">+</span> <span class="n">dx</span><span class="p">[</span><span class="n">i</span><span class="p">];</span>
</span></span><span class="line"><span class="cl">            <span class="kt">var</span> <span class="n">checkY</span> <span class="p">=</span> <span class="n">cell</span><span class="p">.</span><span class="n">Y</span> <span class="p">+</span> <span class="n">dy</span><span class="p">[</span><span class="n">i</span><span class="p">];</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">            <span class="k">if</span> <span class="p">(</span><span class="n">grid</span><span class="p">.</span><span class="n">TryGetCellAtPosition</span><span class="p">(</span><span class="k">new</span> <span class="n">Point</span><span class="p">(</span><span class="n">checkX</span><span class="p">,</span> <span class="n">checkY</span><span class="p">),</span> <span class="k">out</span> <span class="kt">var</span> <span class="n">neighbor</span><span class="p">)</span> <span class="p">&amp;&amp;</span> <span class="n">neighbor</span><span class="p">.</span><span class="n">IsWalkable</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">                <span class="k">yield</span> <span class="k">return</span> <span class="n">neighbor</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">            <span class="p">}</span>
</span></span><span class="line"><span class="cl">        <span class="p">}</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span></code></pre></div><p>The attentive reader will have noticed that the outer <code>while</code>-loop, which was designed to loop as long as there were
still cells in <code>openSet</code>, has disappeared. Instead, the <code>Step</code> method does exactly that, one step (or one iteration to
be precise), so each time the method is called, the algorithm advances one step until it is finished which means that
either a path was found or there are no more cells in <code>openSet</code>.</p>
<p>Another thing we got rid of is the <code>Path</code> property which was used to store the found path in the earlier version of the
class. We don&rsquo;t need that anymore because the path is now stored in the cells themselves via the <code>Parent</code> and <code>IsOnPath</code>
properties, which are updated in the <code>ReconstructPath</code> method:</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-csharp" data-lang="csharp"><span class="line"><span class="cl"><span class="kd">private</span> <span class="kd">static</span> <span class="k">void</span> <span class="n">ReconstructPath</span><span class="p">(</span><span class="n">Cell</span> <span class="n">current</span><span class="p">)</span>
</span></span><span class="line"><span class="cl"><span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="n">current</span><span class="p">.</span><span class="n">IsOnPath</span> <span class="p">=</span> <span class="kc">true</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="kt">var</span> <span class="n">walkingCell</span> <span class="p">=</span> <span class="n">current</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">    <span class="k">while</span> <span class="p">(</span><span class="n">walkingCell</span><span class="p">.</span><span class="n">Parent</span> <span class="p">!=</span> <span class="kc">null</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="n">walkingCell</span><span class="p">.</span><span class="n">Parent</span><span class="p">.</span><span class="n">IsOnPath</span> <span class="p">=</span> <span class="kc">true</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">        <span class="n">walkingCell</span> <span class="p">=</span> <span class="n">walkingCell</span><span class="p">.</span><span class="n">Parent</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span></code></pre></div><p>One last thing we needed to change is that when the <code>Step</code> method is called for the very first time or the first time after
the grid was reset, we need to do the initialization step, which is done when <code>_needsInit</code> is set to <code>true</code> via the <code>Reset</code> method
(which also calls the grid&rsquo;s <code>Reset</code> method).</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-csharp" data-lang="csharp"><span class="line"><span class="cl"><span class="kd">public</span> <span class="kt">bool</span> <span class="n">Step</span><span class="p">()</span>
</span></span><span class="line"><span class="cl"><span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="k">if</span> <span class="p">(</span><span class="n">_needsInit</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="n">grid</span><span class="p">.</span><span class="n">Start</span><span class="p">.</span><span class="n">CostFromStart</span> <span class="p">=</span> <span class="m">0</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">        <span class="n">grid</span><span class="p">.</span><span class="n">Start</span><span class="p">.</span><span class="n">CostToTarget</span> <span class="p">=</span> <span class="n">GetDistance</span><span class="p">(</span><span class="n">grid</span><span class="p">.</span><span class="n">Start</span><span class="p">,</span> <span class="n">grid</span><span class="p">.</span><span class="n">Target</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">        <span class="n">_openSet</span> <span class="p">=</span> <span class="p">[</span><span class="n">grid</span><span class="p">.</span><span class="n">Start</span><span class="p">];</span>
</span></span><span class="line"><span class="cl">        <span class="n">_needsInit</span> <span class="p">=</span> <span class="kc">false</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl">    
</span></span><span class="line"><span class="cl">    <span class="c1">// ...</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="kd">public</span> <span class="k">void</span> <span class="n">Reset</span><span class="p">()</span>
</span></span><span class="line"><span class="cl"><span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="n">grid</span><span class="p">.</span><span class="n">Reset</span><span class="p">();</span>
</span></span><span class="line"><span class="cl">    <span class="n">_needsInit</span> <span class="p">=</span> <span class="kc">true</span><span class="p">;</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span></code></pre></div><p>The rest is pretty much the same, it&rsquo;s still the A* pathfinding algorithm.</p>
<p>Up until now we have the grid and the A* algorithm capable of doing single iterations. What&rsquo;s next you ask? I think a
good next step is to render the grid and to let the A* algorithm do its work.</p>
<h3 id="rendering-the-grid">Rendering the Grid</h3>
<p>What we need is a class that takes the grid and renders it on the screen. The idea is simple: Iterate over the 2-dimensional
array of <code>Cell</code> objects and render an appropriate texture with the right color at the right position for each cell.</p>
<div class="notice note" >
    <p class="notice-title">
        <span class="icon-notice baseline">
            <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 128 300 300">
  <path d="M150 128c82.813 0 150 67.188 150 150 0 82.813-67.188 150-150 150C67.187 428 0 360.812 0 278c0-82.813 67.188-150 150-150Zm25 243.555v-37.11c0-3.515-2.734-6.445-6.055-6.445h-37.5c-3.515 0-6.445 2.93-6.445 6.445v37.11c0 3.515 2.93 6.445 6.445 6.445h37.5c3.32 0 6.055-2.93 6.055-6.445Zm-.39-67.188 3.515-121.289c0-1.367-.586-2.734-1.953-3.516-1.172-.976-2.93-1.562-4.688-1.562h-42.968c-1.758 0-3.516.586-4.688 1.563-1.367.78-1.953 2.148-1.953 3.515l3.32 121.29c0 2.734 2.93 4.882 6.64 4.882h36.134c3.515 0 6.445-2.148 6.64-4.883Z"/>
</svg>

        </span>Note</p><p>So far we haven&rsquo;t touched anything MonoGame-specific (except maybe the <code>Point</code> struct). From here on, some basic knowledge
of MonoGame would not hurt, e.g. it would be helpful to know what <code>SpriteBatch</code>, <code>ContentManager</code> or <code>Texture2D</code> are all
about, or what the heck the <code>Update</code> and <code>Draw</code> methods do and what on earth <code>GameTime</code> is supposed to be.</p></div>

<p>Let&rsquo;s create a class <code>GridRenderer</code> which is responsible for rendering a <code>Grid</code> object.</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-csharp" data-lang="csharp"><span class="line"><span class="cl"><span class="kd">public</span> <span class="k">class</span> <span class="nc">GridRenderer</span><span class="p">(</span><span class="n">Grid</span> <span class="n">grid</span><span class="p">)</span> <span class="p">:</span> <span class="n">IDrawable</span>
</span></span><span class="line"><span class="cl"><span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="kd">private</span> <span class="n">Texture2D</span><span class="p">?</span> <span class="n">_textureCellFree</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">    <span class="kd">private</span> <span class="n">Texture2D</span><span class="p">?</span> <span class="n">_textureCellBlocked</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">    <span class="kd">private</span> <span class="n">Texture2D</span><span class="p">?</span> <span class="n">_textureCellStart</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">    <span class="kd">private</span> <span class="n">Texture2D</span><span class="p">?</span> <span class="n">_textureCellTarget</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">    <span class="kd">private</span> <span class="n">SpriteFont</span><span class="p">?</span> <span class="n">_font</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="kt">bool</span> <span class="n">IsShowParent</span> <span class="p">{</span> <span class="k">get</span><span class="p">;</span> <span class="k">set</span><span class="p">;</span> <span class="p">}</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="k">void</span> <span class="n">LoadContent</span><span class="p">(</span><span class="n">ContentManager</span> <span class="n">cm</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">    <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="n">_textureCellFree</span> <span class="p">=</span> <span class="n">cm</span><span class="p">.</span><span class="n">Load</span><span class="p">&lt;</span><span class="n">Texture2D</span><span class="p">&gt;(</span><span class="s">&#34;Textures/CellFree&#34;</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">        <span class="n">_textureCellBlocked</span> <span class="p">=</span> <span class="n">cm</span><span class="p">.</span><span class="n">Load</span><span class="p">&lt;</span><span class="n">Texture2D</span><span class="p">&gt;(</span><span class="s">&#34;Textures/CellBlocked&#34;</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">        <span class="n">_textureCellStart</span> <span class="p">=</span> <span class="n">cm</span><span class="p">.</span><span class="n">Load</span><span class="p">&lt;</span><span class="n">Texture2D</span><span class="p">&gt;(</span><span class="s">&#34;Textures/CellStart&#34;</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">        <span class="n">_textureCellTarget</span> <span class="p">=</span> <span class="n">cm</span><span class="p">.</span><span class="n">Load</span><span class="p">&lt;</span><span class="n">Texture2D</span><span class="p">&gt;(</span><span class="s">&#34;Textures/CellTarget&#34;</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">        <span class="n">_font</span> <span class="p">=</span> <span class="n">cm</span><span class="p">.</span><span class="n">Load</span><span class="p">&lt;</span><span class="n">SpriteFont</span><span class="p">&gt;(</span><span class="s">&#34;Fonts/Font1&#34;</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl">    
</span></span><span class="line"><span class="cl">    <span class="c1">// ...</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span></code></pre></div><p>Let us take a brief look at what&rsquo;s going on here. First of all the <code>GrindRenderer</code> has a dependency on the <code>Grid</code> object
it is supposed to render which is passed to the <a href="https://learn.microsoft.com/en-us/dotnet/csharp/programming-guide/classes-and-structs/instance-constructors#primary-constructors"
    
    
      target="_blank" class="external-link"
    
>primary constructor</a>
.</p>
<p>Next, we have few <code>Texture2D</code> objects (which are basically images), one for each type of cell: &ldquo;free&rdquo;, &ldquo;blocked&rdquo;, &ldquo;start&rdquo;
and &ldquo;target&rdquo;. These are loaded in the <code>LoadContent</code> method with the use of a <code>ContentManager</code> instance. Because we also
want to write down a few numbers, we need a font of type <code>SpriteFont</code>, which is also loaded here. So far, nothing too
fancy. Let&rsquo;s add a <code>Draw</code> method for actually drawing things (also, that&rsquo;s what the <code>IDrawable</code> interface is about):</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-csharp" data-lang="csharp"><span class="line"><span class="cl"><span class="kd">public</span> <span class="k">class</span> <span class="nc">GridRenderer</span><span class="p">(</span><span class="n">Grid</span> <span class="n">grid</span><span class="p">)</span> <span class="p">:</span> <span class="n">IDrawable</span>
</span></span><span class="line"><span class="cl"><span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="c1">// ...</span>
</span></span><span class="line"><span class="cl">    
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="k">void</span> <span class="n">Draw</span><span class="p">(</span><span class="n">SpriteBatch</span> <span class="n">spriteBatch</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">    <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="k">foreach</span> <span class="p">(</span><span class="kt">var</span> <span class="n">cell</span> <span class="k">in</span> <span class="n">grid</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">            <span class="c1">// Draw that cell already!</span>
</span></span><span class="line"><span class="cl">        <span class="p">}</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl">    
</span></span><span class="line"><span class="cl">    <span class="c1">// ...</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span></code></pre></div><p>We now have a <code>Draw</code> method that is passed a <code>SpriteBatch</code> object which is a MonoGame class for drawing text and sprites.
This is where we iterate over the 2-dimensional array of cells &hellip; <em>Hold on!</em> &hellip; How can we iterate over the grid&rsquo;s
cells when we don&rsquo;t have direct access to the cells array anymore? Let&rsquo;s go quickly back to the <code>Grid</code> class and let it implement
the <a href="https://learn.microsoft.com/en-us/dotnet/api/system.collections.generic.ienumerable-1"
    
    
      target="_blank" class="external-link"
    
>IEnumerable interface</a>
:</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-csharp" data-lang="csharp"><span class="line"><span class="cl"><span class="kd">public</span> <span class="k">class</span> <span class="nc">Grid</span> <span class="p">:</span> <span class="n">IEnumerable</span><span class="p">&lt;</span><span class="n">Cell</span><span class="p">&gt;</span>
</span></span><span class="line"><span class="cl"><span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="kd">private</span> <span class="k">readonly</span> <span class="n">Cell</span><span class="p">[,]</span> <span class="n">_cells</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">    
</span></span><span class="line"><span class="cl">    <span class="c1">// ...</span>
</span></span><span class="line"><span class="cl">    
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="n">IEnumerator</span><span class="p">&lt;</span><span class="n">Cell</span><span class="p">&gt;</span> <span class="n">GetEnumerator</span><span class="p">()</span>
</span></span><span class="line"><span class="cl">    <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="k">for</span> <span class="p">(</span><span class="kt">var</span> <span class="n">x</span> <span class="p">=</span> <span class="m">0</span><span class="p">;</span> <span class="n">x</span> <span class="p">&lt;</span> <span class="n">_cells</span><span class="p">.</span><span class="n">GetLength</span><span class="p">(</span><span class="m">0</span><span class="p">);</span> <span class="n">x</span><span class="p">++)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">            <span class="k">for</span> <span class="p">(</span><span class="kt">var</span> <span class="n">y</span> <span class="p">=</span> <span class="m">0</span><span class="p">;</span> <span class="n">y</span> <span class="p">&lt;</span> <span class="n">_cells</span><span class="p">.</span><span class="n">GetLength</span><span class="p">(</span><span class="m">1</span><span class="p">);</span> <span class="n">y</span><span class="p">++)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">                <span class="k">yield</span> <span class="k">return</span> <span class="n">_cells</span><span class="p">[</span><span class="n">x</span><span class="p">,</span> <span class="n">y</span><span class="p">];</span>
</span></span><span class="line"><span class="cl">            <span class="p">}</span>
</span></span><span class="line"><span class="cl">        <span class="p">}</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="n">IEnumerator</span> <span class="n">IEnumerable</span><span class="p">.</span><span class="n">GetEnumerator</span><span class="p">()</span>
</span></span><span class="line"><span class="cl">    <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="k">return</span> <span class="n">GetEnumerator</span><span class="p">();</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span></code></pre></div><p>With that in place we can now indeed simply iterate over the grid&rsquo;s cells in the <code>Draw</code> method in the <code>GridRenderer</code> class:</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-csharp" data-lang="csharp"><span class="line"><span class="cl"><span class="kd">public</span> <span class="k">class</span> <span class="nc">GridRenderer</span><span class="p">(</span><span class="n">Grid</span> <span class="n">grid</span><span class="p">)</span> <span class="p">:</span> <span class="n">IDrawable</span>
</span></span><span class="line"><span class="cl"><span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="c1">// ...</span>
</span></span><span class="line"><span class="cl">    
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="k">void</span> <span class="n">Draw</span><span class="p">(</span><span class="n">SpriteBatch</span> <span class="n">spriteBatch</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">    <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="k">foreach</span> <span class="p">(</span><span class="kt">var</span> <span class="n">cell</span> <span class="k">in</span> <span class="n">grid</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">            <span class="kt">var</span> <span class="n">position</span> <span class="p">=</span> <span class="k">new</span> <span class="n">Vector2</span><span class="p">(</span><span class="n">cell</span><span class="p">.</span><span class="n">X</span><span class="p">,</span> <span class="n">cell</span><span class="p">.</span><span class="n">Y</span><span class="p">)</span> <span class="p">*</span> <span class="n">Constant</span><span class="p">.</span><span class="n">TileSize</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">            <span class="c1">// draw cell</span>
</span></span><span class="line"><span class="cl">            <span class="kt">var</span> <span class="n">texture</span> <span class="p">=</span> <span class="n">GetCellTexture</span><span class="p">(</span><span class="n">cell</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">            <span class="k">if</span> <span class="p">(</span><span class="n">texture</span> <span class="p">!=</span> <span class="kc">null</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">                <span class="n">spriteBatch</span><span class="p">.</span><span class="n">Draw</span><span class="p">(</span>
</span></span><span class="line"><span class="cl">                    <span class="n">texture</span><span class="p">:</span> <span class="n">texture</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">                    <span class="n">position</span><span class="p">:</span> <span class="n">position</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">                    <span class="n">sourceRectangle</span><span class="p">:</span> <span class="kc">null</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">                    <span class="n">color</span><span class="p">:</span> <span class="n">GetCellColor</span><span class="p">(</span><span class="n">cell</span><span class="p">),</span>
</span></span><span class="line"><span class="cl">                    <span class="n">rotation</span><span class="p">:</span> <span class="m">0</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">                    <span class="n">origin</span><span class="p">:</span> <span class="n">Vector2</span><span class="p">.</span><span class="n">Zero</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">                    <span class="n">scale</span><span class="p">:</span> <span class="n">Vector2</span><span class="p">.</span><span class="n">One</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">                    <span class="n">effects</span><span class="p">:</span> <span class="n">SpriteEffects</span><span class="p">.</span><span class="n">None</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">                    <span class="n">layerDepth</span><span class="p">:</span> <span class="m">1</span>
</span></span><span class="line"><span class="cl">                <span class="p">);</span>
</span></span><span class="line"><span class="cl">            <span class="p">}</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">            <span class="c1">// ...</span>
</span></span><span class="line"><span class="cl">        <span class="p">}</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl">    
</span></span><span class="line"><span class="cl">    <span class="kd">private</span> <span class="n">Texture2D</span><span class="p">?</span> <span class="n">GetCellTexture</span><span class="p">(</span><span class="n">Cell</span> <span class="n">cell</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">    <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="k">if</span> <span class="p">(!</span><span class="n">cell</span><span class="p">.</span><span class="n">IsWalkable</span><span class="p">)</span> <span class="k">return</span> <span class="n">_textureCellBlocked</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">        <span class="k">if</span> <span class="p">(</span><span class="n">cell</span> <span class="p">==</span> <span class="n">grid</span><span class="p">.</span><span class="n">Start</span><span class="p">)</span> <span class="k">return</span> <span class="n">_textureCellStart</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">        <span class="k">return</span> <span class="n">cell</span> <span class="p">==</span> <span class="n">grid</span><span class="p">.</span><span class="n">Target</span> <span class="p">?</span> <span class="n">_textureCellTarget</span> <span class="p">:</span> <span class="n">_textureCellFree</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl">    
</span></span><span class="line"><span class="cl">    <span class="kd">private</span> <span class="kd">static</span> <span class="n">Color</span> <span class="n">GetCellColor</span><span class="p">(</span><span class="n">Cell</span> <span class="n">cell</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">    <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="k">if</span> <span class="p">(</span><span class="n">cell</span><span class="p">.</span><span class="n">IsOnPath</span><span class="p">)</span> <span class="k">return</span> <span class="n">Color</span><span class="p">.</span><span class="n">LightGreen</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">        <span class="k">if</span> <span class="p">(</span><span class="n">cell</span><span class="p">.</span><span class="n">IsInOpenSet</span><span class="p">)</span> <span class="k">return</span> <span class="n">Color</span><span class="p">.</span><span class="n">Orange</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">        <span class="k">return</span> <span class="n">cell</span><span class="p">.</span><span class="n">Parent</span> <span class="p">!=</span> <span class="kc">null</span> <span class="p">?</span> <span class="n">Color</span><span class="p">.</span><span class="n">Yellow</span> <span class="p">:</span> <span class="n">Color</span><span class="p">.</span><span class="n">White</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl">    
</span></span><span class="line"><span class="cl">    <span class="c1">// ...</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span></code></pre></div><p>Inside the <code>foreach</code> loop we determine the appropriate texture for the cell. Then, we calculate the position of the cell
on the screen by simply multiplying its position by the size of the (quadratic) texture (or tile).
The following call to <code>spriteBatch.Draw()</code> contains one more detail which is getting the color of the cell depending
on its status with respect to the current state of the A* algorithm, e.g. whether the cell is in <code>openSet</code> etc. The
color is then used to tint the sprite:</p>
<ul>
<li>If the cell is part of a path, tint it green.</li>
<li>If it&rsquo;s in the open set for cells to examine, tint it orange.</li>
<li>If it already has a parent cell set, tint it yellow.</li>
<li>In all other cases, tint it white, which means, don&rsquo;t tint it at all.</li>
</ul>
<p>Next, add those numbers for the costs to the <code>Draw</code> method:</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-csharp" data-lang="csharp"><span class="line"><span class="cl"><span class="kd">public</span> <span class="k">class</span> <span class="nc">GridRenderer</span><span class="p">(</span><span class="n">Grid</span> <span class="n">grid</span><span class="p">)</span> <span class="p">:</span> <span class="n">IDrawable</span>
</span></span><span class="line"><span class="cl"><span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="c1">// ...</span>
</span></span><span class="line"><span class="cl">    
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="k">void</span> <span class="n">Draw</span><span class="p">(</span><span class="n">SpriteBatch</span> <span class="n">spriteBatch</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">    <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="k">foreach</span> <span class="p">(</span><span class="kt">var</span> <span class="n">cell</span> <span class="k">in</span> <span class="n">grid</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">            <span class="c1">// ...</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">            <span class="c1">// draw numbers</span>
</span></span><span class="line"><span class="cl">            <span class="k">if</span> <span class="p">(</span><span class="n">cell</span><span class="p">.</span><span class="n">CostFromStart</span> <span class="p">&lt;</span> <span class="kt">float</span><span class="p">.</span><span class="n">PositiveInfinity</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">                <span class="n">DrawNumber</span><span class="p">(</span><span class="n">spriteBatch</span><span class="p">,</span> <span class="n">cell</span><span class="p">.</span><span class="n">CostFromStart</span><span class="p">,</span> <span class="n">position</span> <span class="p">+</span> <span class="k">new</span> <span class="n">Vector2</span><span class="p">(</span><span class="m">2</span><span class="p">,</span> <span class="m">1</span><span class="p">));</span>
</span></span><span class="line"><span class="cl">            <span class="p">}</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">            <span class="k">if</span> <span class="p">(</span><span class="n">cell</span><span class="p">.</span><span class="n">CostToTarget</span> <span class="p">&lt;</span> <span class="kt">float</span><span class="p">.</span><span class="n">PositiveInfinity</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">                <span class="n">DrawNumber</span><span class="p">(</span><span class="n">spriteBatch</span><span class="p">,</span> <span class="n">cell</span><span class="p">.</span><span class="n">CostToTarget</span><span class="p">,</span> <span class="n">position</span> <span class="p">+</span> <span class="k">new</span> <span class="n">Vector2</span><span class="p">(</span><span class="m">2</span><span class="p">,</span> <span class="m">12</span><span class="p">));</span>
</span></span><span class="line"><span class="cl">            <span class="p">}</span>
</span></span><span class="line"><span class="cl">            
</span></span><span class="line"><span class="cl">            <span class="c1">// ...</span>
</span></span><span class="line"><span class="cl">        <span class="p">}</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl">    
</span></span><span class="line"><span class="cl">    <span class="kd">private</span> <span class="k">void</span> <span class="n">DrawNumber</span><span class="p">(</span><span class="n">SpriteBatch</span> <span class="n">spriteBatch</span><span class="p">,</span> <span class="kt">float</span> <span class="n">number</span><span class="p">,</span> <span class="n">Vector2</span> <span class="n">position</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">    <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="k">if</span> <span class="p">(</span><span class="n">_font</span> <span class="p">==</span> <span class="kc">null</span><span class="p">)</span> <span class="k">return</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">        <span class="n">spriteBatch</span><span class="p">.</span><span class="n">DrawString</span><span class="p">(</span>
</span></span><span class="line"><span class="cl">            <span class="n">spriteFont</span><span class="p">:</span> <span class="n">_font</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">            <span class="n">text</span><span class="p">:</span> <span class="s">$&#34;{number}&#34;</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">            <span class="n">position</span><span class="p">:</span> <span class="n">position</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">            <span class="n">color</span><span class="p">:</span> <span class="n">Color</span><span class="p">.</span><span class="n">Black</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">            <span class="n">rotation</span><span class="p">:</span> <span class="m">0</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">            <span class="n">origin</span><span class="p">:</span> <span class="n">Vector2</span><span class="p">.</span><span class="n">Zero</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">            <span class="n">scale</span><span class="p">:</span> <span class="n">Vector2</span><span class="p">.</span><span class="n">One</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">            <span class="n">effects</span><span class="p">:</span> <span class="n">SpriteEffects</span><span class="p">.</span><span class="n">None</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">            <span class="n">layerDepth</span><span class="p">:</span> <span class="m">0</span>
</span></span><span class="line"><span class="cl">        <span class="p">);</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl">    
</span></span><span class="line"><span class="cl">    <span class="c1">// ...</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span></code></pre></div><p>Pretty straight forward, no? Last, add that parent relation, i.e. when a cell has a parent then draw a line from the cell
to its parent cell:</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-csharp" data-lang="csharp"><span class="line"><span class="cl"><span class="kd">public</span> <span class="k">class</span> <span class="nc">GridRenderer</span><span class="p">(</span><span class="n">Grid</span> <span class="n">grid</span><span class="p">)</span> <span class="p">:</span> <span class="n">IDrawable</span>
</span></span><span class="line"><span class="cl"><span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="c1">// ...</span>
</span></span><span class="line"><span class="cl">    
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="k">void</span> <span class="n">Draw</span><span class="p">(</span><span class="n">SpriteBatch</span> <span class="n">spriteBatch</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">    <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="k">foreach</span> <span class="p">(</span><span class="kt">var</span> <span class="n">cell</span> <span class="k">in</span> <span class="n">grid</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">            <span class="c1">// ...</span>
</span></span><span class="line"><span class="cl">            
</span></span><span class="line"><span class="cl">            <span class="k">if</span> <span class="p">(</span><span class="n">IsShowParent</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">                <span class="n">DrawLineToParentCell</span><span class="p">(</span><span class="n">spriteBatch</span><span class="p">,</span> <span class="n">cell</span><span class="p">,</span> <span class="n">position</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">            <span class="p">}</span>
</span></span><span class="line"><span class="cl">        <span class="p">}</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl">    
</span></span><span class="line"><span class="cl">    <span class="c1">// ...</span>
</span></span><span class="line"><span class="cl">    
</span></span><span class="line"><span class="cl">    <span class="kd">private</span> <span class="kd">static</span> <span class="k">void</span> <span class="n">DrawLineToParentCell</span><span class="p">(</span><span class="n">SpriteBatch</span> <span class="n">spriteBatch</span><span class="p">,</span> <span class="n">Cell</span> <span class="n">cell</span><span class="p">,</span> <span class="n">Vector2</span> <span class="n">position</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">    <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="k">if</span> <span class="p">(</span><span class="n">cell</span><span class="p">.</span><span class="n">WasInspected</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">            <span class="n">spriteBatch</span><span class="p">.</span><span class="n">DrawPoint</span><span class="p">(</span>
</span></span><span class="line"><span class="cl">                <span class="n">position</span><span class="p">:</span> <span class="n">position</span> <span class="p">+</span> <span class="k">new</span> <span class="n">Vector2</span><span class="p">(</span><span class="n">Constant</span><span class="p">.</span><span class="n">HalfTileSize</span><span class="p">,</span> <span class="n">Constant</span><span class="p">.</span><span class="n">HalfTileSize</span> <span class="p">-</span> <span class="m">1</span><span class="p">),</span>
</span></span><span class="line"><span class="cl">                <span class="n">color</span><span class="p">:</span> <span class="n">Color</span><span class="p">.</span><span class="n">DarkSlateGray</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">                <span class="n">size</span><span class="p">:</span> <span class="n">cell</span><span class="p">.</span><span class="n">IsOnPath</span> <span class="p">?</span> <span class="m">10</span> <span class="p">:</span> <span class="m">6</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">                <span class="n">layerDepth</span><span class="p">:</span> <span class="m">0.5f</span>
</span></span><span class="line"><span class="cl">            <span class="p">);</span>
</span></span><span class="line"><span class="cl">        <span class="p">}</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">        <span class="k">if</span> <span class="p">(</span><span class="n">cell</span><span class="p">.</span><span class="n">Parent</span> <span class="p">==</span> <span class="kc">null</span><span class="p">)</span> <span class="k">return</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">        <span class="kt">var</span> <span class="n">parentPosition</span> <span class="p">=</span> <span class="k">new</span> <span class="n">Vector2</span><span class="p">(</span><span class="n">cell</span><span class="p">.</span><span class="n">Parent</span><span class="p">.</span><span class="n">X</span><span class="p">,</span> <span class="n">cell</span><span class="p">.</span><span class="n">Parent</span><span class="p">.</span><span class="n">Y</span><span class="p">)</span> <span class="p">*</span> <span class="n">Constant</span><span class="p">.</span><span class="n">TileSize</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">        <span class="n">spriteBatch</span><span class="p">.</span><span class="n">DrawLine</span><span class="p">(</span>
</span></span><span class="line"><span class="cl">            <span class="n">point1</span><span class="p">:</span> <span class="n">position</span> <span class="p">+</span> <span class="n">Vector2</span><span class="p">.</span><span class="n">One</span> <span class="p">*</span> <span class="n">Constant</span><span class="p">.</span><span class="n">HalfTileSize</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">            <span class="n">point2</span><span class="p">:</span> <span class="n">parentPosition</span> <span class="p">+</span> <span class="n">Vector2</span><span class="p">.</span><span class="n">One</span> <span class="p">*</span> <span class="n">Constant</span><span class="p">.</span><span class="n">HalfTileSize</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">            <span class="n">color</span><span class="p">:</span> <span class="n">Color</span><span class="p">.</span><span class="n">DarkSlateGray</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">            <span class="n">thickness</span><span class="p">:</span> <span class="n">cell</span><span class="p">.</span><span class="n">IsOnPath</span> <span class="p">?</span> <span class="m">6</span> <span class="p">:</span> <span class="m">2</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">            <span class="n">layerDepth</span><span class="p">:</span> <span class="m">0.5f</span>
</span></span><span class="line"><span class="cl">        <span class="p">);</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span></code></pre></div><p>That&rsquo;s basically it concerning the rendering of the grid. With what we have now we can run the algorithm once and watch it run until it finds a path from start to target. There isn&rsquo;t
much interaction yet. We&rsquo;re going to add this in the next section.</p>
<h3 id="add-the-control-panel">Add the Control Panel</h3>
<p>First, we&rsquo;ll add the control panel, which will allow the user to start and stop the automatic execution of the A* algorithm,
go stepwise through the algorithm, reset the grid, and toggle the display of the parent relationships. To do this, we need two
types of form elements: a button and a toggle (or a checkbox if you will). The button is used to step through the pathfinding process and to reset
the grid. Without further ado, here&rsquo;s the implementation:</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-csharp" data-lang="csharp"><span class="line"><span class="cl"><span class="kd">public</span> <span class="k">class</span> <span class="nc">Button</span><span class="p">(</span><span class="n">Texture2D</span> <span class="n">texture</span><span class="p">,</span> <span class="n">Point</span> <span class="n">position</span><span class="p">)</span> <span class="p">:</span> <span class="n">IDrawableUpdateable</span>
</span></span><span class="line"><span class="cl"><span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="kd">private</span> <span class="kt">bool</span> <span class="n">_isPressed</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">    <span class="kd">private</span> <span class="n">Rectangle</span> <span class="n">_worldBounds</span> <span class="p">=</span> <span class="k">new</span><span class="p">(</span><span class="n">position</span><span class="p">.</span><span class="n">X</span><span class="p">,</span> <span class="n">position</span><span class="p">.</span><span class="n">Y</span><span class="p">,</span> <span class="n">texture</span><span class="p">.</span><span class="n">Width</span><span class="p">,</span> <span class="n">texture</span><span class="p">.</span><span class="n">Height</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="k">event</span> <span class="n">Action</span><span class="p">?</span> <span class="n">Clicked</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="k">void</span> <span class="n">Update</span><span class="p">(</span><span class="n">GameTime</span> <span class="n">_</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">    <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="kt">var</span> <span class="n">mouseState</span> <span class="p">=</span> <span class="n">Mouse</span><span class="p">.</span><span class="n">GetState</span><span class="p">();</span>
</span></span><span class="line"><span class="cl">        <span class="k">if</span> <span class="p">(!</span><span class="n">_isPressed</span> <span class="p">&amp;&amp;</span> <span class="n">mouseState</span><span class="p">.</span><span class="n">LeftButton</span> <span class="p">==</span> <span class="n">ButtonState</span><span class="p">.</span><span class="n">Pressed</span> <span class="p">&amp;&amp;</span> <span class="n">_worldBounds</span><span class="p">.</span><span class="n">Contains</span><span class="p">(</span><span class="n">mouseState</span><span class="p">.</span><span class="n">Position</span><span class="p">))</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">            <span class="n">_isPressed</span> <span class="p">=</span> <span class="kc">true</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">            <span class="n">Clicked</span><span class="p">?.</span><span class="n">Invoke</span><span class="p">();</span>
</span></span><span class="line"><span class="cl">        <span class="p">}</span>
</span></span><span class="line"><span class="cl">        <span class="k">if</span> <span class="p">(</span><span class="n">mouseState</span><span class="p">.</span><span class="n">LeftButton</span> <span class="p">==</span> <span class="n">ButtonState</span><span class="p">.</span><span class="n">Released</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">            <span class="n">_isPressed</span> <span class="p">=</span> <span class="kc">false</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">        <span class="p">}</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="k">void</span> <span class="n">Draw</span><span class="p">(</span><span class="n">SpriteBatch</span> <span class="n">spriteBatch</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">    <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="n">spriteBatch</span><span class="p">.</span><span class="n">Draw</span><span class="p">(</span>
</span></span><span class="line"><span class="cl">            <span class="n">texture</span><span class="p">:</span> <span class="n">texture</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">            <span class="n">position</span><span class="p">:</span> <span class="k">new</span> <span class="n">Vector2</span><span class="p">(</span><span class="n">position</span><span class="p">.</span><span class="n">X</span><span class="p">,</span> <span class="n">position</span><span class="p">.</span><span class="n">Y</span><span class="p">),</span>
</span></span><span class="line"><span class="cl">            <span class="n">sourceRectangle</span><span class="p">:</span> <span class="kc">null</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">            <span class="n">color</span><span class="p">:</span> <span class="n">_isPressed</span> <span class="p">?</span> <span class="n">Color</span><span class="p">.</span><span class="n">White</span> <span class="p">:</span> <span class="n">Color</span><span class="p">.</span><span class="n">LightGray</span>
</span></span><span class="line"><span class="cl">        <span class="p">);</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span></code></pre></div><p>Pretty simple, right? The button has a texture (most probably with a fancy icon!) and a position in the game world.
It has a <code>Clicked</code> <a href="https://learn.microsoft.com/en-us/dotnet/standard/events/"
    
    
      target="_blank" class="external-link"
    
>event</a>
 that fires when the button is
clicked, which can be subscribed to. It has a <code>Draw</code> method that draws the button on the screen.</p>
<p>The button logic itself is implemented in the <code>Update</code> method: We read the current state of the left mouse button. If it
is pressed in the current frame and wasn&rsquo;t in the previous frame, plus the mouse pointer is inside the button&rsquo;s bounding
rectangle, then the button is being recognized as clicked and the <code>Clicked</code> event is invoked. To prevent the event from
firing repeatedly while the button is pressed, we set the flag <code>_isPressed</code> to <code>true</code>. As soon as the mouse button is
released, the flag is reset to <code>false</code>.</p>
<p>Next, we need a toggle which can be switched on and off by clicking on it. Let&rsquo;s create a <code>Toggle</code> class that&rsquo;s basically
a slightly extended version of the <code>Button</code> class we just looked at:</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-csharp" data-lang="csharp"><span class="line"><span class="cl"><span class="kd">public</span> <span class="k">class</span> <span class="nc">Toggle</span><span class="p">(</span><span class="n">Texture2D</span> <span class="n">textureSwitchedOff</span><span class="p">,</span> <span class="n">Texture2D</span> <span class="n">textureSwitchedOn</span><span class="p">,</span> <span class="n">Point</span> <span class="n">position</span><span class="p">)</span> <span class="p">:</span> <span class="n">IDrawableUpdateable</span>
</span></span><span class="line"><span class="cl"><span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="kd">private</span> <span class="kt">bool</span> <span class="n">_isPressed</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">    <span class="kd">private</span> <span class="kt">bool</span> <span class="n">_isSwitchedOn</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">    <span class="kd">private</span> <span class="n">Rectangle</span> <span class="n">_worldBounds</span> <span class="p">=</span> <span class="k">new</span><span class="p">(</span><span class="n">position</span><span class="p">.</span><span class="n">X</span><span class="p">,</span> <span class="n">position</span><span class="p">.</span><span class="n">Y</span><span class="p">,</span> <span class="n">textureSwitchedOff</span><span class="p">.</span><span class="n">Width</span><span class="p">,</span> <span class="n">textureSwitchedOff</span><span class="p">.</span><span class="n">Height</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="k">event</span> <span class="n">Action</span><span class="p">&lt;</span><span class="kt">bool</span><span class="p">&gt;?</span> <span class="n">Toggled</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="k">void</span> <span class="n">Update</span><span class="p">(</span><span class="n">GameTime</span> <span class="n">_</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">    <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="kt">var</span> <span class="n">mouseState</span> <span class="p">=</span> <span class="n">Mouse</span><span class="p">.</span><span class="n">GetState</span><span class="p">();</span>
</span></span><span class="line"><span class="cl">        <span class="k">if</span> <span class="p">(!</span><span class="n">_isPressed</span> <span class="p">&amp;&amp;</span> <span class="n">mouseState</span><span class="p">.</span><span class="n">LeftButton</span> <span class="p">==</span> <span class="n">ButtonState</span><span class="p">.</span><span class="n">Pressed</span> <span class="p">&amp;&amp;</span> <span class="n">_worldBounds</span><span class="p">.</span><span class="n">Contains</span><span class="p">(</span><span class="n">mouseState</span><span class="p">.</span><span class="n">Position</span><span class="p">))</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">            <span class="n">_isPressed</span> <span class="p">=</span> <span class="kc">true</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">            <span class="n">_isSwitchedOn</span> <span class="p">=</span> <span class="p">!</span><span class="n">_isSwitchedOn</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">            <span class="n">Toggled</span><span class="p">?.</span><span class="n">Invoke</span><span class="p">(</span><span class="n">_isSwitchedOn</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">        <span class="p">}</span>
</span></span><span class="line"><span class="cl">        <span class="k">if</span> <span class="p">(</span><span class="n">mouseState</span><span class="p">.</span><span class="n">LeftButton</span> <span class="p">==</span> <span class="n">ButtonState</span><span class="p">.</span><span class="n">Released</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">            <span class="n">_isPressed</span> <span class="p">=</span> <span class="kc">false</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">        <span class="p">}</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="k">void</span> <span class="n">Draw</span><span class="p">(</span><span class="n">SpriteBatch</span> <span class="n">spriteBatch</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">    <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="n">spriteBatch</span><span class="p">.</span><span class="n">Draw</span><span class="p">(</span>
</span></span><span class="line"><span class="cl">            <span class="n">texture</span><span class="p">:</span> <span class="n">_isSwitchedOn</span> <span class="p">?</span> <span class="n">textureSwitchedOn</span> <span class="p">:</span> <span class="n">textureSwitchedOff</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">            <span class="n">position</span><span class="p">:</span> <span class="k">new</span> <span class="n">Vector2</span><span class="p">(</span><span class="n">position</span><span class="p">.</span><span class="n">X</span><span class="p">,</span> <span class="n">position</span><span class="p">.</span><span class="n">Y</span><span class="p">),</span>
</span></span><span class="line"><span class="cl">            <span class="n">sourceRectangle</span><span class="p">:</span> <span class="kc">null</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">            <span class="n">color</span><span class="p">:</span> <span class="n">_isPressed</span> <span class="p">?</span> <span class="n">Color</span><span class="p">.</span><span class="n">White</span> <span class="p">:</span> <span class="n">Color</span><span class="p">.</span><span class="n">LightGray</span>
</span></span><span class="line"><span class="cl">        <span class="p">);</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span></code></pre></div><p>The differences to the <code>Button</code> class are:</p>
<ul>
<li>The toggle has two textures: one for when it is switched off and another one for when it is switched on.</li>
<li>It has an additional flag <code>_isSwitchedOn</code> which is used for &hellip; well, you already guessed it.</li>
<li>The event has a <code>bool</code> parameter and is fired whenever the state of the toggle changes from switched on to off and vice versa.
The current state after the switch is passed to the delegate.</li>
</ul>
<p>We need now one more class for the actual control panel:</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-csharp" data-lang="csharp"><span class="line"><span class="cl"><span class="kd">public</span> <span class="k">class</span> <span class="nc">ControlPanel</span><span class="p">(</span><span class="n">Point</span> <span class="n">position</span><span class="p">)</span> <span class="p">:</span> <span class="n">IDrawableUpdateable</span>
</span></span><span class="line"><span class="cl"><span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="kd">private</span> <span class="k">readonly</span> <span class="n">List</span><span class="p">&lt;</span><span class="n">IDrawableUpdateable</span><span class="p">&gt;</span> <span class="n">_formElements</span> <span class="p">=</span> <span class="p">[];</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="k">event</span> <span class="n">Action</span><span class="p">&lt;</span><span class="kt">bool</span><span class="p">&gt;?</span> <span class="n">PlayButtonToggled</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="k">event</span> <span class="n">Action</span><span class="p">&lt;</span><span class="kt">bool</span><span class="p">&gt;?</span> <span class="n">ShowParentButtonToggled</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="k">event</span> <span class="n">Action</span><span class="p">?</span> <span class="n">StepButtonClicked</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="k">event</span> <span class="n">Action</span><span class="p">?</span> <span class="n">ResetButtonClicked</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="k">void</span> <span class="n">LoadContent</span><span class="p">(</span><span class="n">ContentManager</span> <span class="n">cm</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">    <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="kt">var</span> <span class="n">textureButtonPlay</span> <span class="p">=</span> <span class="n">cm</span><span class="p">.</span><span class="n">Load</span><span class="p">&lt;</span><span class="n">Texture2D</span><span class="p">&gt;(</span><span class="s">&#34;Textures/ButtonPlay&#34;</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">        <span class="kt">var</span> <span class="n">textureButtonStop</span> <span class="p">=</span> <span class="n">cm</span><span class="p">.</span><span class="n">Load</span><span class="p">&lt;</span><span class="n">Texture2D</span><span class="p">&gt;(</span><span class="s">&#34;Textures/ButtonStop&#34;</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">        <span class="kt">var</span> <span class="n">textureButtonStep</span> <span class="p">=</span> <span class="n">cm</span><span class="p">.</span><span class="n">Load</span><span class="p">&lt;</span><span class="n">Texture2D</span><span class="p">&gt;(</span><span class="s">&#34;Textures/ButtonStep&#34;</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">        <span class="kt">var</span> <span class="n">textureButtonReset</span> <span class="p">=</span> <span class="n">cm</span><span class="p">.</span><span class="n">Load</span><span class="p">&lt;</span><span class="n">Texture2D</span><span class="p">&gt;(</span><span class="s">&#34;Textures/ButtonReset&#34;</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">        <span class="kt">var</span> <span class="n">textureToggleShowParentOff</span> <span class="p">=</span> <span class="n">cm</span><span class="p">.</span><span class="n">Load</span><span class="p">&lt;</span><span class="n">Texture2D</span><span class="p">&gt;(</span><span class="s">&#34;Textures/ToggleShowParentOff&#34;</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">        <span class="kt">var</span> <span class="n">textureToggleShowParentOn</span> <span class="p">=</span> <span class="n">cm</span><span class="p">.</span><span class="n">Load</span><span class="p">&lt;</span><span class="n">Texture2D</span><span class="p">&gt;(</span><span class="s">&#34;Textures/ToggleShowParentOn&#34;</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">        <span class="kt">var</span> <span class="n">togglePlay</span> <span class="p">=</span> <span class="k">new</span> <span class="n">Toggle</span><span class="p">(</span><span class="n">textureButtonPlay</span><span class="p">,</span> <span class="n">textureButtonStop</span><span class="p">,</span> <span class="n">position</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">        <span class="kt">var</span> <span class="n">buttonStep</span> <span class="p">=</span> <span class="k">new</span> <span class="n">Button</span><span class="p">(</span><span class="n">textureButtonStep</span><span class="p">,</span> <span class="n">position</span> <span class="p">+</span> <span class="k">new</span> <span class="n">Point</span><span class="p">(</span><span class="m">80</span><span class="p">,</span> <span class="m">0</span><span class="p">));</span>
</span></span><span class="line"><span class="cl">        <span class="kt">var</span> <span class="n">buttonReset</span> <span class="p">=</span> <span class="k">new</span> <span class="n">Button</span><span class="p">(</span><span class="n">textureButtonReset</span><span class="p">,</span> <span class="n">position</span> <span class="p">+</span> <span class="k">new</span> <span class="n">Point</span><span class="p">(</span><span class="m">160</span><span class="p">,</span> <span class="m">0</span><span class="p">));</span>
</span></span><span class="line"><span class="cl">        <span class="kt">var</span> <span class="n">toggleShowParent</span> <span class="p">=</span> <span class="k">new</span> <span class="n">Toggle</span><span class="p">(</span><span class="n">textureToggleShowParentOff</span><span class="p">,</span> <span class="n">textureToggleShowParentOn</span><span class="p">,</span> <span class="n">position</span> <span class="p">+</span> <span class="k">new</span> <span class="n">Point</span><span class="p">(</span><span class="m">240</span><span class="p">,</span> <span class="m">0</span><span class="p">));</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">        <span class="n">togglePlay</span><span class="p">.</span><span class="n">Toggled</span> <span class="p">+=</span> <span class="n">PlayButtonToggled</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">        <span class="n">buttonStep</span><span class="p">.</span><span class="n">Clicked</span> <span class="p">+=</span> <span class="n">StepButtonClicked</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">        <span class="n">buttonReset</span><span class="p">.</span><span class="n">Clicked</span> <span class="p">+=</span> <span class="n">ResetButtonClicked</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">        <span class="n">toggleShowParent</span><span class="p">.</span><span class="n">Toggled</span> <span class="p">+=</span> <span class="n">ShowParentButtonToggled</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">        <span class="n">_formElements</span><span class="p">.</span><span class="n">Add</span><span class="p">(</span><span class="n">togglePlay</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">        <span class="n">_formElements</span><span class="p">.</span><span class="n">Add</span><span class="p">(</span><span class="n">buttonStep</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">        <span class="n">_formElements</span><span class="p">.</span><span class="n">Add</span><span class="p">(</span><span class="n">buttonReset</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">        <span class="n">_formElements</span><span class="p">.</span><span class="n">Add</span><span class="p">(</span><span class="n">toggleShowParent</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="k">void</span> <span class="n">Update</span><span class="p">(</span><span class="n">GameTime</span> <span class="n">gameTime</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">    <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="k">foreach</span> <span class="p">(</span><span class="kt">var</span> <span class="n">formElement</span> <span class="k">in</span> <span class="n">_formElements</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">            <span class="n">formElement</span><span class="p">.</span><span class="n">Update</span><span class="p">(</span><span class="n">gameTime</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">        <span class="p">}</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="k">void</span> <span class="n">Draw</span><span class="p">(</span><span class="n">SpriteBatch</span> <span class="n">spriteBatch</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">    <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="k">foreach</span> <span class="p">(</span><span class="kt">var</span> <span class="n">formElement</span> <span class="k">in</span> <span class="n">_formElements</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">            <span class="n">formElement</span><span class="p">.</span><span class="n">Draw</span><span class="p">(</span><span class="n">spriteBatch</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">        <span class="p">}</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span></code></pre></div><p>The class <code>ControlPanel</code> is basically just a container for the two buttons and two toggles. It subscribes to the buttons'
and toggles&rsquo; events and exposes more meaningfully named events itself, plus it calls their <code>Draw</code> and <code>Update</code> methods.</p>
<h3 id="make-the-grid-editable">Make the Grid Editable</h3>
<p>The last feature we need to add is the grid editor. For that we need to detect mouse clicks and movements in the grid
and change the grid accordingly, e.g. switch cells&rsquo; statuses from free to blocked or vice versa and make the start and
target cells draggable across the grid.</p>
<p>We&rsquo;ll approach that by implementing a finite state machine by applying the
<a href="https://refactoring.guru/design-patterns/state"
    
    
      target="_blank" class="external-link"
    
>state pattern</a>
. The basic idea of the state pattern is to allow an object
to alter its behaviour based on which state it currently is in.
Each state is implemented in its own class and contains logic only for that state, e.g. there will be a class for when the
mouse button is released and another class for when the button was clicked, etc. That again helps
with separating concerns and put state-specific behaviour in a separate class rather than stuff everything into a single
class.</p>
<p>Here&rsquo;s a quick sketch of the state machine we&rsquo;re going
to build:</p>
<figure class="center"><img src="/https/shendriks.dev/posts/2024-08-24-a-star-pathfinding-top-down-blazorgl/images/grid-editor-flowchart.svg"
			alt="A finite state machine for handling user input in the grid"><figcaption>
			<p>A finite state machine for handling user input in the grid</p>
		</figcaption>
</figure>

<p>So, what&rsquo;s happening here? We start with the mouse button released. When the mouse button is clicked, we need to decide
whether we click the start or target cell or a normal cell. If we clicked the start or target cell, we simply keep making the cell the
mouse pointer currently is in the start cell or target cell respectively. We do this as long as the mouse button is
pressed. Once it&rsquo;s released, we go back to the initial state. If we clicked a normal cell, we determine whether the
cell is free or blocked and we store that information for later use. Now, as long as the button is pressed we make
the cell the mouse pointer is in the opposite of what the initial cell was, i.e. if the initial cell was free, then the
cells becomes blocked, while already blocked cells keep being blocked. If the initial cell was blocked, then the cell becomes
free. That way we can paint and erase walls with the mouse pointer. As soon as the mouse button is released, we go back
to the initial state.</p>
<p>As you can imagine, we need at least five classes, one for each state of the state machine in the diagram above. Plus,
we need something that holds everything together, keeps track of the current state and also delegates work to it (which is called
<em>Context</em> in the state pattern).</p>
<p>For a state class to do its work it needs information about the mouse, i.e. if a button is clicked, which cell the mouse
pointer is in and in what cell it was previously (i.e. during the last frame) in. Also, it needs a reference to the grid,
because it might need to read and set the start and target cells. We&rsquo;ll make all that available through the context.
In addition, at some point the current state needs to tell the context to transition to another state. Obviously,
the state class needs a reference to the context.</p>
<p>Let&rsquo;s whip up an interface <code>IContext</code> for the context and another interface <code>IState</code> for the state classes
(Btw, we&rsquo;re using the extended mouse state here from <a href="https://www.monogameextended.net/docs/features/input/mouseextended/"
    
    
      target="_blank" class="external-link"
    
>MonoGame.Extended</a>
):</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-csharp" data-lang="csharp"><span class="line"><span class="cl"><span class="kd">public</span> <span class="k">interface</span> <span class="nc">IContext</span>
</span></span><span class="line"><span class="cl"><span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="n">MouseStateExtended</span> <span class="n">MouseState</span> <span class="p">{</span> <span class="k">get</span><span class="p">;</span> <span class="p">}</span>
</span></span><span class="line"><span class="cl">    <span class="n">Cell</span> <span class="n">CurrentCell</span> <span class="p">{</span> <span class="k">get</span><span class="p">;</span> <span class="p">}</span>
</span></span><span class="line"><span class="cl">    <span class="n">Cell</span><span class="p">?</span> <span class="n">PreviousCell</span> <span class="p">{</span> <span class="k">get</span><span class="p">;</span> <span class="p">}</span>
</span></span><span class="line"><span class="cl">    <span class="n">Grid</span> <span class="n">Grid</span> <span class="p">{</span> <span class="k">get</span><span class="p">;</span> <span class="p">}</span>
</span></span><span class="line"><span class="cl">    <span class="k">void</span> <span class="n">TransitionTo</span><span class="p">(</span><span class="n">IState</span> <span class="n">state</span><span class="p">);</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="kd">public</span> <span class="k">interface</span> <span class="nc">IState</span>
</span></span><span class="line"><span class="cl"><span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="k">void</span> <span class="n">Handle</span><span class="p">(</span><span class="n">IContext</span> <span class="n">context</span><span class="p">);</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span></code></pre></div><p>Here&rsquo;s what the context implementation looks like - we&rsquo;ll use a special dummy value <code>Cell.None</code> for <code>CurrentCell</code> just so it&rsquo;s never
<code>null</code>:</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-csharp" data-lang="csharp"><span class="line"><span class="cl"><span class="kd">public</span> <span class="k">class</span> <span class="nc">Cell</span><span class="p">(</span><span class="kt">int</span> <span class="n">x</span><span class="p">,</span> <span class="kt">int</span> <span class="n">y</span><span class="p">,</span> <span class="kt">bool</span> <span class="n">isWalkable</span><span class="p">)</span>
</span></span><span class="line"><span class="cl"><span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="c1">// ...</span>
</span></span><span class="line"><span class="cl">    
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="kd">static</span> <span class="n">Cell</span> <span class="n">None</span> <span class="p">{</span> <span class="k">get</span><span class="p">;</span> <span class="p">}</span> <span class="p">=</span> <span class="k">new</span><span class="p">(</span><span class="m">0</span><span class="p">,</span> <span class="m">0</span><span class="p">,</span> <span class="kc">false</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="c1">// ...</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="kd">public</span> <span class="k">class</span> <span class="nc">GridInputContext</span><span class="p">(</span><span class="n">Grid</span> <span class="n">grid</span><span class="p">)</span> <span class="p">:</span> <span class="n">IUpdateable</span><span class="p">,</span> <span class="n">IContext</span>
</span></span><span class="line"><span class="cl"><span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="kd">private</span> <span class="n">IState</span> <span class="n">_currentState</span> <span class="p">=</span> <span class="k">new</span> <span class="n">ButtonReleasedState</span><span class="p">();</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="n">MouseStateExtended</span> <span class="n">MouseState</span> <span class="p">{</span> <span class="k">get</span><span class="p">;</span> <span class="kd">private</span> <span class="k">set</span><span class="p">;</span> <span class="p">}</span>
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="n">Cell</span> <span class="n">CurrentCell</span> <span class="p">{</span> <span class="k">get</span><span class="p">;</span> <span class="kd">private</span> <span class="k">set</span><span class="p">;</span> <span class="p">}</span> <span class="p">=</span> <span class="n">Cell</span><span class="p">.</span><span class="n">None</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="n">Cell</span><span class="p">?</span> <span class="n">PreviousCell</span> <span class="p">{</span> <span class="k">get</span><span class="p">;</span> <span class="kd">private</span> <span class="k">set</span><span class="p">;</span> <span class="p">}</span>
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="n">Grid</span> <span class="n">Grid</span> <span class="p">{</span> <span class="k">get</span><span class="p">;</span> <span class="p">}</span> <span class="p">=</span> <span class="n">grid</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="k">void</span> <span class="n">TransitionTo</span><span class="p">(</span><span class="n">IState</span> <span class="n">state</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">    <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="n">_currentState</span> <span class="p">=</span> <span class="n">state</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="k">void</span> <span class="n">Update</span><span class="p">(</span><span class="n">GameTime</span> <span class="n">_</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">    <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="n">MouseState</span> <span class="p">=</span> <span class="n">MouseExtended</span><span class="p">.</span><span class="n">GetState</span><span class="p">();</span>
</span></span><span class="line"><span class="cl">        <span class="kt">var</span> <span class="n">gridPosition</span> <span class="p">=</span> <span class="n">MouseState</span><span class="p">.</span><span class="n">Position</span><span class="p">.</span><span class="n">DivBy</span><span class="p">(</span><span class="n">Constant</span><span class="p">.</span><span class="n">TileSize</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">        <span class="k">if</span> <span class="p">(!</span><span class="n">Grid</span><span class="p">.</span><span class="n">TryGetCellAtPosition</span><span class="p">(</span><span class="n">gridPosition</span><span class="p">,</span> <span class="k">out</span> <span class="kt">var</span> <span class="n">cell</span><span class="p">))</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">            <span class="c1">// The mouse pointer isn&#39;t in the grid, do nothing.</span>
</span></span><span class="line"><span class="cl">            <span class="k">return</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">        <span class="p">}</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">        <span class="n">CurrentCell</span> <span class="p">=</span> <span class="n">cell</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">        <span class="n">_currentState</span><span class="p">.</span><span class="n">Handle</span><span class="p">(</span><span class="k">this</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">        <span class="n">PreviousCell</span> <span class="p">=</span> <span class="n">cell</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span></code></pre></div><p>You&rsquo;ll have noticed that there&rsquo;s a check in the <code>Update</code> method to test whether the mouse pointer is actually inside
the grid. If it&rsquo;s not, we can &ldquo;pause&rdquo; the state machine and just stay in the current state, because there&rsquo;s nothing
useful to do when the mouse pointer is outside the grid.</p>
<p>For the sake of brevity, we&rsquo;ll only look at one concrete state class:</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-csharp" data-lang="csharp"><span class="line"><span class="cl"><span class="kd">public</span> <span class="k">class</span> <span class="nc">ButtonReleasedState</span> <span class="p">:</span> <span class="n">IState</span>
</span></span><span class="line"><span class="cl"><span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="k">void</span> <span class="n">Handle</span><span class="p">(</span><span class="n">IContext</span> <span class="n">context</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">    <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="k">if</span> <span class="p">(!</span><span class="n">context</span><span class="p">.</span><span class="n">MouseState</span><span class="p">.</span><span class="n">WasButtonPressed</span><span class="p">(</span><span class="n">MouseButton</span><span class="p">.</span><span class="n">Left</span><span class="p">))</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">            <span class="k">return</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">        <span class="p">}</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">        <span class="k">if</span> <span class="p">(</span><span class="n">context</span><span class="p">.</span><span class="n">Grid</span><span class="p">.</span><span class="n">StartPosition</span> <span class="p">==</span> <span class="n">context</span><span class="p">.</span><span class="n">CurrentCell</span><span class="p">.</span><span class="n">Position</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">            <span class="n">context</span><span class="p">.</span><span class="n">TransitionTo</span><span class="p">(</span><span class="k">new</span> <span class="n">StartClickedState</span><span class="p">());</span>
</span></span><span class="line"><span class="cl">            <span class="k">return</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">        <span class="p">}</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">        <span class="k">if</span> <span class="p">(</span><span class="n">context</span><span class="p">.</span><span class="n">Grid</span><span class="p">.</span><span class="n">TargetPosition</span> <span class="p">==</span> <span class="n">context</span><span class="p">.</span><span class="n">CurrentCell</span><span class="p">.</span><span class="n">Position</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">            <span class="n">context</span><span class="p">.</span><span class="n">TransitionTo</span><span class="p">(</span><span class="k">new</span> <span class="n">TargetClickedState</span><span class="p">());</span>
</span></span><span class="line"><span class="cl">            <span class="k">return</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">        <span class="p">}</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">        <span class="k">if</span> <span class="p">(</span><span class="n">context</span><span class="p">.</span><span class="n">CurrentCell</span><span class="p">.</span><span class="n">IsWalkable</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">            <span class="n">context</span><span class="p">.</span><span class="n">TransitionTo</span><span class="p">(</span><span class="k">new</span> <span class="n">EmptyCellClickedState</span><span class="p">());</span>
</span></span><span class="line"><span class="cl">            <span class="k">if</span> <span class="p">(</span><span class="n">context</span><span class="p">.</span><span class="n">Grid</span><span class="p">.</span><span class="n">StartPosition</span> <span class="p">!=</span> <span class="n">context</span><span class="p">.</span><span class="n">CurrentCell</span><span class="p">.</span><span class="n">Position</span>
</span></span><span class="line"><span class="cl">                <span class="p">&amp;&amp;</span> <span class="n">context</span><span class="p">.</span><span class="n">Grid</span><span class="p">.</span><span class="n">TargetPosition</span> <span class="p">!=</span> <span class="n">context</span><span class="p">.</span><span class="n">CurrentCell</span><span class="p">.</span><span class="n">Position</span>
</span></span><span class="line"><span class="cl">            <span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">                <span class="n">context</span><span class="p">.</span><span class="n">CurrentCell</span><span class="p">.</span><span class="n">IsWalkable</span> <span class="p">=</span> <span class="kc">false</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">            <span class="p">}</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">            <span class="k">return</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">        <span class="p">}</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">        <span class="n">context</span><span class="p">.</span><span class="n">TransitionTo</span><span class="p">(</span><span class="k">new</span> <span class="n">BlockedCellClickedState</span><span class="p">());</span>
</span></span><span class="line"><span class="cl">        <span class="n">context</span><span class="p">.</span><span class="n">CurrentCell</span><span class="p">.</span><span class="n">IsWalkable</span> <span class="p">=</span> <span class="kc">true</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span></code></pre></div><p>I&rsquo;m going to leave it as an exercise for the reader to figure out what this class does. The other state classes (in fact the
whole project) you&rsquo;ll find on <a href="https://github.com/shendriks/pathfinding-2d"
    
    
      target="_blank" class="external-link"
    
>GitHub</a>
.</p>
<p>There is one more thing we need to take into consideration. Everytime the grid changes, the A* algorithm
has to be restarted. We will solve this as follows:</p>
<ul>
<li>The <code>Cell</code> class gets an event that fires when the cell changes, i.e. when its walkability changes.</li>
<li>Next, the <code>Grid</code> class gets an event that fires when one of the cells or the position of the start or target
cell changes.</li>
<li>Finally, the event of the <code>Grid</code> class is wired to the <code>Reset</code> method of the A* algorithm.</li>
</ul>
<p>Here is the additional code:</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-csharp" data-lang="csharp"><span class="line"><span class="cl"><span class="kd">public</span> <span class="k">class</span> <span class="nc">Cell</span><span class="p">(</span><span class="kt">int</span> <span class="n">x</span><span class="p">,</span> <span class="kt">int</span> <span class="n">y</span><span class="p">,</span> <span class="kt">bool</span> <span class="n">isWalkable</span><span class="p">)</span>
</span></span><span class="line"><span class="cl"><span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="c1">// ...</span>
</span></span><span class="line"><span class="cl">    
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="k">event</span> <span class="n">Action</span><span class="p">?</span> <span class="n">WalkabilityChanged</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="kt">bool</span> <span class="n">IsWalkable</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="k">get</span> <span class="p">=&gt;</span> <span class="n">_isWalkable</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">        <span class="k">set</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">            <span class="k">if</span> <span class="p">(</span><span class="k">value</span> <span class="p">==</span> <span class="n">_isWalkable</span><span class="p">)</span> <span class="k">return</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">            <span class="n">_isWalkable</span> <span class="p">=</span> <span class="k">value</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">            <span class="n">WalkabilityChanged</span><span class="p">?.</span><span class="n">Invoke</span><span class="p">();</span>
</span></span><span class="line"><span class="cl">        <span class="p">}</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl">    
</span></span><span class="line"><span class="cl">    <span class="c1">// ...</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="kd">public</span> <span class="k">class</span> <span class="nc">Grid</span> <span class="p">:</span> <span class="n">IEnumerable</span><span class="p">&lt;</span><span class="n">Cell</span><span class="p">&gt;</span>
</span></span><span class="line"><span class="cl"><span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="c1">// ...</span>
</span></span><span class="line"><span class="cl">    
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="k">event</span> <span class="n">Action</span><span class="p">?</span> <span class="n">GridChanged</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="n">Point</span> <span class="n">StartPosition</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="k">get</span> <span class="p">=&gt;</span> <span class="n">_startPosition</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">        <span class="k">set</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">            <span class="k">if</span> <span class="p">(</span><span class="n">_startPosition</span> <span class="p">==</span> <span class="k">value</span><span class="p">)</span> <span class="k">return</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">            <span class="k">if</span> <span class="p">(!</span><span class="n">IsInsideBounds</span><span class="p">(</span><span class="k">value</span><span class="p">))</span> <span class="k">return</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">            <span class="k">if</span> <span class="p">(!</span><span class="n">_cells</span><span class="p">[</span><span class="k">value</span><span class="p">.</span><span class="n">X</span><span class="p">,</span> <span class="k">value</span><span class="p">.</span><span class="n">Y</span><span class="p">].</span><span class="n">IsWalkable</span><span class="p">)</span> <span class="k">return</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">            <span class="n">_startPosition</span> <span class="p">=</span> <span class="k">value</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">            <span class="n">GridChanged</span><span class="p">?.</span><span class="n">Invoke</span><span class="p">();</span>
</span></span><span class="line"><span class="cl">        <span class="p">}</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="n">Point</span> <span class="n">TargetPosition</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="k">get</span> <span class="p">=&gt;</span> <span class="n">_targetPosition</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">        <span class="k">set</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">            <span class="k">if</span> <span class="p">(</span><span class="n">_targetPosition</span> <span class="p">==</span> <span class="k">value</span><span class="p">)</span> <span class="k">return</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">            <span class="k">if</span> <span class="p">(!</span><span class="n">IsInsideBounds</span><span class="p">(</span><span class="k">value</span><span class="p">))</span> <span class="k">return</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">            <span class="k">if</span> <span class="p">(!</span><span class="n">_cells</span><span class="p">[</span><span class="k">value</span><span class="p">.</span><span class="n">X</span><span class="p">,</span> <span class="k">value</span><span class="p">.</span><span class="n">Y</span><span class="p">].</span><span class="n">IsWalkable</span><span class="p">)</span> <span class="k">return</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">            <span class="n">_targetPosition</span> <span class="p">=</span> <span class="k">value</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">            <span class="n">GridChanged</span><span class="p">?.</span><span class="n">Invoke</span><span class="p">();</span>
</span></span><span class="line"><span class="cl">        <span class="p">}</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="kd">private</span> <span class="n">Grid</span><span class="p">(</span><span class="n">Cell</span><span class="p">[,]</span> <span class="n">cells</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">    <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="n">_cells</span> <span class="p">=</span> <span class="n">cells</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">        <span class="k">foreach</span> <span class="p">(</span><span class="kt">var</span> <span class="n">cell</span> <span class="k">in</span> <span class="n">_cells</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">            <span class="n">cell</span><span class="p">.</span><span class="n">WalkabilityChanged</span> <span class="p">+=</span> <span class="p">()</span> <span class="p">=&gt;</span> <span class="n">GridChanged</span><span class="p">?.</span><span class="n">Invoke</span><span class="p">();</span>
</span></span><span class="line"><span class="cl">        <span class="p">}</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl">    
</span></span><span class="line"><span class="cl">    <span class="c1">// ...</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span></code></pre></div><p>You might notice that that&rsquo;s actually an implementation of the <a href="https://refactoring.guru/design-patterns/observer"
    
    
      target="_blank" class="external-link"
    
>observer pattern</a>
.</p>
<div class="notice note" >
    <p class="notice-title">
        <span class="icon-notice baseline">
            <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 128 300 300">
  <path d="M150 128c82.813 0 150 67.188 150 150 0 82.813-67.188 150-150 150C67.187 428 0 360.812 0 278c0-82.813 67.188-150 150-150Zm25 243.555v-37.11c0-3.515-2.734-6.445-6.055-6.445h-37.5c-3.515 0-6.445 2.93-6.445 6.445v37.11c0 3.515 2.93 6.445 6.445 6.445h37.5c3.32 0 6.055-2.93 6.055-6.445Zm-.39-67.188 3.515-121.289c0-1.367-.586-2.734-1.953-3.516-1.172-.976-2.93-1.562-4.688-1.562h-42.968c-1.758 0-3.516.586-4.688 1.563-1.367.78-1.953 2.148-1.953 3.515l3.32 121.29c0 2.734 2.93 4.882 6.64 4.882h36.134c3.515 0 6.445-2.148 6.64-4.883Z"/>
</svg>

        </span>Note</p><p><strong>(Not) unsubscribing from Events</strong></p>
<p>In general, it&rsquo;s good practice to <a href="https://learn.microsoft.com/en-us/dotnet/csharp/programming-guide/events/how-to-subscribe-to-and-unsubscribe-from-events#unsubscribing"
    
    
      target="_blank" class="external-link"
    
>unsubscribe from events</a>
 when you no longer need them.
In this example, however, we&rsquo;ll skip the step of unsubscribing for simplicity&rsquo;s sake, because it&rsquo;s just one level, if you will, and the
&ldquo;game&rdquo; is not progressing in the sense that a new level or area needs to be loaded while the current one is being unloaded, or
new game objects are being created or existing ones are being destroyed. The only time we would need to unsubscribe is when the
whole game ends, in which case everything will end up in data nirvana anyway.</p></div>

<p>The algorithm&rsquo;s <code>Reset</code> method is going to be wired up in the next section.</p>
<h3 id="wiring-things-up">Wiring Things Up</h3>
<p>Good news: We are slowly approaching the well-deserved end of this article. Let&rsquo;s finally create a class named
<code>Pathfinding</code> (how original!) to wire everything up:</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-csharp" data-lang="csharp"><span class="line"><span class="cl"><span class="kd">public</span> <span class="k">class</span> <span class="nc">Pathfinding</span>
</span></span><span class="line"><span class="cl"><span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="kd">private</span> <span class="kd">const</span> <span class="kt">double</span> <span class="n">StepDelay</span> <span class="p">=</span> <span class="m">50</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="kd">private</span> <span class="k">readonly</span> <span class="kt">int</span><span class="p">[,]</span> <span class="n">_map</span> <span class="p">=</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="p">{</span> <span class="m">0</span><span class="p">,</span> <span class="m">0</span><span class="p">,</span> <span class="m">1</span><span class="p">,</span> <span class="m">0</span><span class="p">,</span> <span class="m">0</span><span class="p">,</span> <span class="m">0</span><span class="p">,</span> <span class="m">1</span><span class="p">,</span> <span class="m">0</span><span class="p">,</span> <span class="m">1</span><span class="p">,</span> <span class="m">0</span> <span class="p">},</span>
</span></span><span class="line"><span class="cl">        <span class="p">{</span> <span class="m">0</span><span class="p">,</span> <span class="m">0</span><span class="p">,</span> <span class="m">1</span><span class="p">,</span> <span class="m">0</span><span class="p">,</span> <span class="m">1</span><span class="p">,</span> <span class="m">1</span><span class="p">,</span> <span class="m">1</span><span class="p">,</span> <span class="m">0</span><span class="p">,</span> <span class="m">0</span><span class="p">,</span> <span class="m">0</span> <span class="p">},</span>
</span></span><span class="line"><span class="cl">        <span class="p">{</span> <span class="m">0</span><span class="p">,</span> <span class="m">0</span><span class="p">,</span> <span class="m">1</span><span class="p">,</span> <span class="m">0</span><span class="p">,</span> <span class="m">0</span><span class="p">,</span> <span class="m">0</span><span class="p">,</span> <span class="m">0</span><span class="p">,</span> <span class="m">0</span><span class="p">,</span> <span class="m">0</span><span class="p">,</span> <span class="m">0</span> <span class="p">},</span>
</span></span><span class="line"><span class="cl">        <span class="p">{</span> <span class="m">0</span><span class="p">,</span> <span class="m">0</span><span class="p">,</span> <span class="m">1</span><span class="p">,</span> <span class="m">1</span><span class="p">,</span> <span class="m">1</span><span class="p">,</span> <span class="m">1</span><span class="p">,</span> <span class="m">1</span><span class="p">,</span> <span class="m">1</span><span class="p">,</span> <span class="m">0</span><span class="p">,</span> <span class="m">0</span> <span class="p">},</span>
</span></span><span class="line"><span class="cl">        <span class="p">{</span> <span class="m">0</span><span class="p">,</span> <span class="m">0</span><span class="p">,</span> <span class="m">0</span><span class="p">,</span> <span class="m">0</span><span class="p">,</span> <span class="m">0</span><span class="p">,</span> <span class="m">0</span><span class="p">,</span> <span class="m">0</span><span class="p">,</span> <span class="m">0</span><span class="p">,</span> <span class="m">0</span><span class="p">,</span> <span class="m">0</span> <span class="p">},</span>
</span></span><span class="line"><span class="cl">        <span class="p">{</span> <span class="m">0</span><span class="p">,</span> <span class="m">1</span><span class="p">,</span> <span class="m">0</span><span class="p">,</span> <span class="m">0</span><span class="p">,</span> <span class="m">0</span><span class="p">,</span> <span class="m">0</span><span class="p">,</span> <span class="m">1</span><span class="p">,</span> <span class="m">0</span><span class="p">,</span> <span class="m">1</span><span class="p">,</span> <span class="m">1</span> <span class="p">},</span>
</span></span><span class="line"><span class="cl">        <span class="p">{</span> <span class="m">1</span><span class="p">,</span> <span class="m">1</span><span class="p">,</span> <span class="m">1</span><span class="p">,</span> <span class="m">1</span><span class="p">,</span> <span class="m">0</span><span class="p">,</span> <span class="m">1</span><span class="p">,</span> <span class="m">1</span><span class="p">,</span> <span class="m">0</span><span class="p">,</span> <span class="m">1</span><span class="p">,</span> <span class="m">0</span> <span class="p">},</span>
</span></span><span class="line"><span class="cl">        <span class="p">{</span> <span class="m">0</span><span class="p">,</span> <span class="m">0</span><span class="p">,</span> <span class="m">0</span><span class="p">,</span> <span class="m">0</span><span class="p">,</span> <span class="m">0</span><span class="p">,</span> <span class="m">1</span><span class="p">,</span> <span class="m">1</span><span class="p">,</span> <span class="m">0</span><span class="p">,</span> <span class="m">1</span><span class="p">,</span> <span class="m">0</span> <span class="p">},</span>
</span></span><span class="line"><span class="cl">        <span class="p">{</span> <span class="m">0</span><span class="p">,</span> <span class="m">1</span><span class="p">,</span> <span class="m">1</span><span class="p">,</span> <span class="m">1</span><span class="p">,</span> <span class="m">1</span><span class="p">,</span> <span class="m">1</span><span class="p">,</span> <span class="m">1</span><span class="p">,</span> <span class="m">1</span><span class="p">,</span> <span class="m">1</span><span class="p">,</span> <span class="m">0</span> <span class="p">},</span>
</span></span><span class="line"><span class="cl">        <span class="p">{</span> <span class="m">0</span><span class="p">,</span> <span class="m">0</span><span class="p">,</span> <span class="m">0</span><span class="p">,</span> <span class="m">0</span><span class="p">,</span> <span class="m">0</span><span class="p">,</span> <span class="m">0</span><span class="p">,</span> <span class="m">0</span><span class="p">,</span> <span class="m">0</span><span class="p">,</span> <span class="m">0</span><span class="p">,</span> <span class="m">0</span> <span class="p">}</span>
</span></span><span class="line"><span class="cl">    <span class="p">};</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="kd">private</span> <span class="k">readonly</span> <span class="n">GridRenderer</span> <span class="n">_gridRenderer</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">    <span class="kd">private</span> <span class="k">readonly</span> <span class="n">GridInputContext</span> <span class="n">_gridInputContext</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">    <span class="kd">private</span> <span class="k">readonly</span> <span class="n">ControlPanel</span> <span class="n">_controlPanel</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">    <span class="kd">private</span> <span class="k">readonly</span> <span class="n">AStarPathfinder</span> <span class="n">_pathFinder</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="kd">private</span> <span class="kt">bool</span> <span class="n">_isPathfindingFinished</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">    <span class="kd">private</span> <span class="kt">double</span> <span class="n">_lastStepOccurredAt</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">    <span class="kd">private</span> <span class="kt">bool</span> <span class="n">_isPlaying</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="n">Pathfinding</span><span class="p">()</span>
</span></span><span class="line"><span class="cl">    <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="kt">var</span> <span class="n">grid</span> <span class="p">=</span> <span class="n">Grid</span><span class="p">.</span><span class="n">CreateFromArray</span><span class="p">(</span><span class="n">_map</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">        <span class="n">grid</span><span class="p">.</span><span class="n">StartPosition</span> <span class="p">=</span> <span class="k">new</span> <span class="n">Point</span><span class="p">(</span><span class="m">1</span><span class="p">,</span> <span class="m">1</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">        <span class="n">grid</span><span class="p">.</span><span class="n">TargetPosition</span> <span class="p">=</span> <span class="k">new</span> <span class="n">Point</span><span class="p">(</span><span class="m">4</span><span class="p">,</span> <span class="m">2</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">        <span class="n">grid</span><span class="p">.</span><span class="n">GridChanged</span> <span class="p">+=</span> <span class="n">Reset</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">        <span class="n">_gridRenderer</span> <span class="p">=</span> <span class="k">new</span> <span class="n">GridRenderer</span><span class="p">(</span><span class="n">grid</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">        <span class="n">_gridInputContext</span> <span class="p">=</span> <span class="k">new</span> <span class="n">GridInputContext</span><span class="p">(</span><span class="n">grid</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">        <span class="n">_pathFinder</span> <span class="p">=</span> <span class="k">new</span> <span class="n">AStarPathfinder</span><span class="p">(</span><span class="n">grid</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">        <span class="n">_controlPanel</span> <span class="p">=</span> <span class="k">new</span> <span class="n">ControlPanel</span><span class="p">(</span><span class="k">new</span> <span class="n">Point</span><span class="p">(</span><span class="m">8</span><span class="p">,</span> <span class="n">_map</span><span class="p">.</span><span class="n">GetLength</span><span class="p">(</span><span class="m">1</span><span class="p">)</span> <span class="p">*</span> <span class="n">Constant</span><span class="p">.</span><span class="n">TileSize</span> <span class="p">+</span> <span class="n">Constant</span><span class="p">.</span><span class="n">HalfTileSize</span><span class="p">));</span>
</span></span><span class="line"><span class="cl">        <span class="n">_controlPanel</span><span class="p">.</span><span class="n">PlayButtonToggled</span> <span class="p">+=</span> <span class="n">isSwitchedOn</span> <span class="p">=&gt;</span> <span class="p">{</span> <span class="n">_isPlaying</span> <span class="p">=</span> <span class="n">isSwitchedOn</span><span class="p">;</span> <span class="p">};</span>
</span></span><span class="line"><span class="cl">        <span class="n">_controlPanel</span><span class="p">.</span><span class="n">StepButtonClicked</span> <span class="p">+=</span> <span class="n">Step</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">        <span class="n">_controlPanel</span><span class="p">.</span><span class="n">ResetButtonClicked</span> <span class="p">+=</span> <span class="n">Reset</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">        <span class="n">_controlPanel</span><span class="p">.</span><span class="n">ShowParentButtonToggled</span> <span class="p">+=</span> <span class="n">isSwitchedOn</span> <span class="p">=&gt;</span> <span class="p">{</span> <span class="n">_gridRenderer</span><span class="p">.</span><span class="n">IsShowParent</span> <span class="p">=</span> <span class="n">isSwitchedOn</span><span class="p">;</span> <span class="p">};</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="k">void</span> <span class="n">LoadContent</span><span class="p">(</span><span class="n">ContentManager</span> <span class="n">cm</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">    <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="n">_gridRenderer</span><span class="p">.</span><span class="n">LoadContent</span><span class="p">(</span><span class="n">cm</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">        <span class="n">_controlPanel</span><span class="p">.</span><span class="n">LoadContent</span><span class="p">(</span><span class="n">cm</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="k">void</span> <span class="n">Update</span><span class="p">(</span><span class="n">GameTime</span> <span class="n">gameTime</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">    <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="n">_gridInputContext</span><span class="p">.</span><span class="n">Update</span><span class="p">(</span><span class="n">gameTime</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">        <span class="n">_controlPanel</span><span class="p">.</span><span class="n">Update</span><span class="p">(</span><span class="n">gameTime</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">        <span class="k">if</span> <span class="p">(!</span><span class="n">_isPlaying</span><span class="p">)</span> <span class="k">return</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">        <span class="k">if</span> <span class="p">(</span><span class="n">_isPathfindingFinished</span><span class="p">)</span> <span class="k">return</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">        <span class="kt">var</span> <span class="n">timeSinceLastStep</span> <span class="p">=</span> <span class="n">gameTime</span><span class="p">.</span><span class="n">TotalGameTime</span><span class="p">.</span><span class="n">TotalMilliseconds</span> <span class="p">-</span> <span class="n">_lastStepOccurredAt</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">        <span class="k">if</span> <span class="p">(</span><span class="n">timeSinceLastStep</span> <span class="p">&lt;</span> <span class="n">StepDelay</span><span class="p">)</span> <span class="k">return</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">        <span class="n">Step</span><span class="p">();</span>
</span></span><span class="line"><span class="cl">        <span class="n">_lastStepOccurredAt</span> <span class="p">=</span> <span class="n">gameTime</span><span class="p">.</span><span class="n">TotalGameTime</span><span class="p">.</span><span class="n">TotalMilliseconds</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="k">void</span> <span class="n">Draw</span><span class="p">(</span><span class="n">SpriteBatch</span> <span class="n">spriteBatch</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">    <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="n">_controlPanel</span><span class="p">.</span><span class="n">Draw</span><span class="p">(</span><span class="n">spriteBatch</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">        <span class="n">_gridRenderer</span><span class="p">.</span><span class="n">Draw</span><span class="p">(</span><span class="n">spriteBatch</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="kd">private</span> <span class="k">void</span> <span class="n">Step</span><span class="p">()</span>
</span></span><span class="line"><span class="cl">    <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="n">_isPathfindingFinished</span> <span class="p">=</span> <span class="n">_pathFinder</span><span class="p">.</span><span class="n">Step</span><span class="p">();</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="kd">private</span> <span class="k">void</span> <span class="n">Reset</span><span class="p">()</span>
</span></span><span class="line"><span class="cl">    <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="n">_pathFinder</span><span class="p">.</span><span class="n">Reset</span><span class="p">();</span>
</span></span><span class="line"><span class="cl">        <span class="n">_isPathfindingFinished</span> <span class="p">=</span> <span class="kc">false</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span></code></pre></div><p>Let&rsquo;s now hook this up with the main game class which inherits from MonoGame&rsquo;s <code>Game</code> class. This should be familiar
for you if you&rsquo;ve already worked with MonoGame and shouldn&rsquo;t contain any big surprises:</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-csharp" data-lang="csharp"><span class="line"><span class="cl"><span class="kd">public</span> <span class="k">class</span> <span class="nc">PathfindingGame</span> <span class="p">:</span> <span class="n">Game</span>
</span></span><span class="line"><span class="cl"><span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="kd">private</span> <span class="k">readonly</span> <span class="n">Color</span> <span class="n">_backgroundColor</span> <span class="p">=</span> <span class="k">new</span><span class="p">(</span><span class="m">35</span><span class="p">,</span> <span class="m">36</span><span class="p">,</span> <span class="m">37</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="kd">private</span> <span class="n">SpriteBatch</span> <span class="n">_spriteBatch</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">    <span class="kd">private</span> <span class="n">Application</span><span class="p">.</span><span class="n">Pathfinding</span> <span class="n">_pathfinding</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="n">PathfindingGame</span><span class="p">()</span>
</span></span><span class="line"><span class="cl">    <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="n">_</span> <span class="p">=</span> <span class="k">new</span> <span class="n">GraphicsDeviceManager</span><span class="p">(</span><span class="k">this</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">        <span class="n">Content</span><span class="p">.</span><span class="n">RootDirectory</span> <span class="p">=</span> <span class="s">&#34;Content&#34;</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="kd">protected</span> <span class="kd">override</span> <span class="k">void</span> <span class="n">LoadContent</span><span class="p">()</span>
</span></span><span class="line"><span class="cl">    <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="n">_spriteBatch</span> <span class="p">=</span> <span class="k">new</span> <span class="n">SpriteBatch</span><span class="p">(</span><span class="n">GraphicsDevice</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">        <span class="n">_pathfinding</span> <span class="p">=</span> <span class="k">new</span> <span class="n">Application</span><span class="p">.</span><span class="n">Pathfinding</span><span class="p">();</span>
</span></span><span class="line"><span class="cl">        <span class="n">_pathfinding</span><span class="p">.</span><span class="n">LoadContent</span><span class="p">(</span><span class="n">Content</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="kd">protected</span> <span class="kd">override</span> <span class="k">void</span> <span class="n">UnloadContent</span><span class="p">()</span>
</span></span><span class="line"><span class="cl">    <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="n">Content</span><span class="p">.</span><span class="n">Unload</span><span class="p">();</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="kd">protected</span> <span class="kd">override</span> <span class="k">void</span> <span class="n">Update</span><span class="p">(</span><span class="n">GameTime</span> <span class="n">gameTime</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">    <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="n">_pathfinding</span><span class="p">.</span><span class="n">Update</span><span class="p">(</span><span class="n">gameTime</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">        <span class="k">base</span><span class="p">.</span><span class="n">Update</span><span class="p">(</span><span class="n">gameTime</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="kd">protected</span> <span class="kd">override</span> <span class="k">void</span> <span class="n">Draw</span><span class="p">(</span><span class="n">GameTime</span> <span class="n">gameTime</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">    <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="n">GraphicsDevice</span><span class="p">.</span><span class="n">Clear</span><span class="p">(</span><span class="n">_backgroundColor</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">        <span class="n">_spriteBatch</span><span class="p">.</span><span class="n">Begin</span><span class="p">(</span>
</span></span><span class="line"><span class="cl">            <span class="n">samplerState</span><span class="p">:</span> <span class="n">SamplerState</span><span class="p">.</span><span class="n">PointClamp</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">            <span class="n">sortMode</span><span class="p">:</span> <span class="n">SpriteSortMode</span><span class="p">.</span><span class="n">BackToFront</span>
</span></span><span class="line"><span class="cl">        <span class="p">);</span>
</span></span><span class="line"><span class="cl">        <span class="n">_pathfinding</span><span class="p">.</span><span class="n">Draw</span><span class="p">(</span><span class="n">_spriteBatch</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">        <span class="n">_spriteBatch</span><span class="p">.</span><span class="n">End</span><span class="p">();</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">        <span class="k">base</span><span class="p">.</span><span class="n">Draw</span><span class="p">(</span><span class="n">gameTime</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span></code></pre></div><p>That&rsquo;s it, you&rsquo;ve made it! I hope you found this post useful and that it wasn&rsquo;t too lengthy.</p>
<h2 id="conclusion">Conclusion</h2>
<p>In this blog post, we&rsquo;ve taken a look into implementing the interactive A* pathfinding app from the last blog post with
MonoGame. In the next part of this series, we&rsquo;ll finally move from the top-down view to a side-view scenario (or so I hope).</p>
]]></content></item><item><title>A* Pathfinding in 2D Games: The Basics for a Simple Top-Down Scenario</title><link>https://shendriks.dev/posts/2024-07-13-a-star-pathfinding-in-2d-games-the-basics-for-top-down-scenarios/</link><pubDate>Sat, 13 Jul 2024 00:00:00 +0000</pubDate><guid>https://shendriks.dev/posts/2024-07-13-a-star-pathfinding-in-2d-games-the-basics-for-top-down-scenarios/</guid><description>This article introduces the implementation of A* pathfinding in a 2D top-down game, setting the stage for more complex applications in side-scrolling platformers.</description><content type="html"><![CDATA[<h2 id="introduction">Introduction</h2>
<p>Pathfinding can be a crucial aspect of game development, for example, when you want enemy characters to chase the
player and <del>kick their butts</del> defeat them in a challenging and satisfying manner, or when an enemy is supposed to
patrol through a series of checkpoints. To achieve this, you need to find a path between two points in the game world.
But how do you find a way from one point to another? Well, there are algorithms for this, one of which is the
famous <a href="https://en.wikipedia.org/wiki/A*_search_algorithm"
    
    
      target="_blank" class="external-link"
    
>A* search algorithm</a>
.</p>
<p>The A* search algorithm is a popular choice for this purpose. It not only finds a path between two points (if there is
such a path), it finds the shortest path possible. While applying this algorithm to a game with a <a href="https://en.wikipedia.org/wiki/Video_game_graphics#Top-down_perspective"
    
    
      target="_blank" class="external-link"
    
>top-down
perspective</a>
 is straight-forward, it can become
a challenge in a side-scrolling platformer scenario.</p>
<p>We will start the series by having a look at the simple case of a top-down game and how the A* algorithm is applied.
Later in the series we&rsquo;ll look into adapting the algorithm such that it also works in a side-scrolling situation.</p>
<h2 id="a-pathfinding-in-a-top-down-game">A* Pathfinding in a Top-Down Game</h2>
<p>Let&rsquo;s assume we have a <a href="https://en.wikipedia.org/wiki/Tile-based_video_game"
    
    
      target="_blank" class="external-link"
    
>grid of square tiles</a>
 and that the
character can move freely in 4 directions being up, down, left and right.</p>
<figure class="center"><img src="/https/shendriks.dev/posts/2024-07-13-a-star-pathfinding-in-2d-games-the-basics-for-top-down-scenarios/images/directions.png"
			alt="The character can go up, down, left and right." width="320" height="320"><figcaption>
			<p>The character can go up, down, left and right.</p>
		</figcaption>
</figure>

<p>In addition some of the cells are blocked and hence are not walkable
by the character which means a path needs to go around those blocked cells. These are typically obstacles such as
walls, trees, water, or &hellip; pyramids:</p>
<figure class="center"><img src="/https/shendriks.dev/posts/2024-07-13-a-star-pathfinding-in-2d-games-the-basics-for-top-down-scenarios/images/directions-2.png"
			alt="A grid with free and blocked cells." width="320" height="320"><figcaption>
			<p>A grid with free and blocked cells.</p>
		</figcaption>
</figure>

<p>Let&rsquo;s further assume the character is at a certain position named A on the grid (i.e. in a particular cell or
tile) and they need to go to some other position B.</p>
<figure class="center"><img src="/https/shendriks.dev/posts/2024-07-13-a-star-pathfinding-in-2d-games-the-basics-for-top-down-scenarios/images/pathfinding-00.png"
			alt="We need to find a path from A to B." width="320" height="320"><figcaption>
			<p>We need to find a path from A to B.</p>
		</figcaption>
</figure>

<p>The A* algorithm&rsquo;s input is basically the grid with all its blocked and non-blocked cells, position A and position B.
Its output is the shortest path (if such a path exists) from A to B which is basically a list of cells.</p>
<h3 id="setting-up-the-environment">Setting Up the Environment</h3>
<p>First, we need to represent our game world in a way that the A* algorithm can process. This involves creating a grid
where each cell corresponds to a tile and therefore to a position in the game world. Each cell can be walkable or
unwalkable. Here&rsquo;s a possible implementation in C# for a <code>Cell</code> class - To make it easier to deal with coordinates, we
throw a struct <code>Point</code> into the mix and add a property to <code>Cell</code> accordingly:</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-csharp" data-lang="csharp"><span class="line"><span class="cl"><span class="kd">public</span> <span class="k">struct</span> <span class="nc">Point</span><span class="p">(</span><span class="kt">int</span> <span class="n">x</span><span class="p">,</span> <span class="kt">int</span> <span class="n">y</span><span class="p">)</span>
</span></span><span class="line"><span class="cl"><span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="kt">int</span> <span class="n">X</span> <span class="p">=</span> <span class="n">x</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="kt">int</span> <span class="n">Y</span> <span class="p">=</span> <span class="n">y</span><span class="p">;</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="kd">public</span> <span class="k">class</span> <span class="nc">Cell</span><span class="p">(</span><span class="kt">int</span> <span class="n">x</span><span class="p">,</span> <span class="kt">int</span> <span class="n">y</span><span class="p">,</span> <span class="kt">bool</span> <span class="n">isWalkable</span><span class="p">)</span>
</span></span><span class="line"><span class="cl"><span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="n">Point</span> <span class="n">Position</span> <span class="p">{</span> <span class="k">get</span><span class="p">;</span> <span class="p">}</span> <span class="p">=</span> <span class="k">new</span><span class="p">(</span><span class="n">x</span><span class="p">,</span> <span class="n">y</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="kt">int</span> <span class="n">X</span> <span class="p">=&gt;</span> <span class="n">Position</span><span class="p">.</span><span class="n">X</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="kt">int</span> <span class="n">Y</span> <span class="p">=&gt;</span> <span class="n">Position</span><span class="p">.</span><span class="n">Y</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="kt">bool</span> <span class="n">IsWalkable</span> <span class="p">{</span> <span class="k">get</span><span class="p">;</span> <span class="p">}</span> <span class="p">=</span> <span class="n">isWalkable</span><span class="p">;</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span></code></pre></div><p>The properties are pretty much self-explanatory: <code>Position</code>, <code>X</code>, <code>Y</code> and <code>IsWalkable</code> store the cell position in the grid and if the cell is walkable.</p>
<p>Now a grid can simply be represented by a 2-dimensional array of <code>Cell</code> objects. First we create a 2-dimensional array
of <code>int</code>, where <code>0</code> means walkable and <code>1</code> means blocked. That way we can define the game world in a simpler and more
concise way:</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-csharp" data-lang="csharp"><span class="line"><span class="cl"><span class="c1">// 0 = walkable, 1 = blocked</span>
</span></span><span class="line"><span class="cl"><span class="kt">int</span><span class="p">[,]</span> <span class="n">map</span> <span class="p">=</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="p">{</span> <span class="m">0</span><span class="p">,</span> <span class="m">0</span><span class="p">,</span> <span class="m">1</span><span class="p">,</span> <span class="m">0</span><span class="p">,</span> <span class="m">0</span><span class="p">,</span> <span class="m">0</span><span class="p">,</span> <span class="m">1</span><span class="p">,</span> <span class="m">0</span><span class="p">,</span> <span class="m">1</span><span class="p">,</span> <span class="m">0</span> <span class="p">},</span>
</span></span><span class="line"><span class="cl">        <span class="p">{</span> <span class="m">0</span><span class="p">,</span> <span class="m">0</span><span class="p">,</span> <span class="m">1</span><span class="p">,</span> <span class="m">0</span><span class="p">,</span> <span class="m">1</span><span class="p">,</span> <span class="m">1</span><span class="p">,</span> <span class="m">1</span><span class="p">,</span> <span class="m">0</span><span class="p">,</span> <span class="m">0</span><span class="p">,</span> <span class="m">0</span> <span class="p">},</span>
</span></span><span class="line"><span class="cl">        <span class="p">{</span> <span class="m">0</span><span class="p">,</span> <span class="m">0</span><span class="p">,</span> <span class="m">1</span><span class="p">,</span> <span class="m">0</span><span class="p">,</span> <span class="m">0</span><span class="p">,</span> <span class="m">0</span><span class="p">,</span> <span class="m">0</span><span class="p">,</span> <span class="m">0</span><span class="p">,</span> <span class="m">0</span><span class="p">,</span> <span class="m">0</span> <span class="p">},</span>
</span></span><span class="line"><span class="cl">        <span class="p">{</span> <span class="m">0</span><span class="p">,</span> <span class="m">0</span><span class="p">,</span> <span class="m">1</span><span class="p">,</span> <span class="m">1</span><span class="p">,</span> <span class="m">1</span><span class="p">,</span> <span class="m">1</span><span class="p">,</span> <span class="m">1</span><span class="p">,</span> <span class="m">1</span><span class="p">,</span> <span class="m">0</span><span class="p">,</span> <span class="m">0</span> <span class="p">},</span>
</span></span><span class="line"><span class="cl">        <span class="p">{</span> <span class="m">0</span><span class="p">,</span> <span class="m">0</span><span class="p">,</span> <span class="m">0</span><span class="p">,</span> <span class="m">0</span><span class="p">,</span> <span class="m">0</span><span class="p">,</span> <span class="m">0</span><span class="p">,</span> <span class="m">0</span><span class="p">,</span> <span class="m">0</span><span class="p">,</span> <span class="m">0</span><span class="p">,</span> <span class="m">0</span> <span class="p">},</span>
</span></span><span class="line"><span class="cl">        <span class="p">{</span> <span class="m">0</span><span class="p">,</span> <span class="m">1</span><span class="p">,</span> <span class="m">0</span><span class="p">,</span> <span class="m">0</span><span class="p">,</span> <span class="m">0</span><span class="p">,</span> <span class="m">0</span><span class="p">,</span> <span class="m">1</span><span class="p">,</span> <span class="m">0</span><span class="p">,</span> <span class="m">1</span><span class="p">,</span> <span class="m">1</span> <span class="p">},</span>
</span></span><span class="line"><span class="cl">        <span class="p">{</span> <span class="m">1</span><span class="p">,</span> <span class="m">1</span><span class="p">,</span> <span class="m">1</span><span class="p">,</span> <span class="m">1</span><span class="p">,</span> <span class="m">0</span><span class="p">,</span> <span class="m">1</span><span class="p">,</span> <span class="m">1</span><span class="p">,</span> <span class="m">0</span><span class="p">,</span> <span class="m">1</span><span class="p">,</span> <span class="m">0</span> <span class="p">},</span>
</span></span><span class="line"><span class="cl">        <span class="p">{</span> <span class="m">0</span><span class="p">,</span> <span class="m">0</span><span class="p">,</span> <span class="m">0</span><span class="p">,</span> <span class="m">0</span><span class="p">,</span> <span class="m">0</span><span class="p">,</span> <span class="m">1</span><span class="p">,</span> <span class="m">1</span><span class="p">,</span> <span class="m">0</span><span class="p">,</span> <span class="m">1</span><span class="p">,</span> <span class="m">0</span> <span class="p">},</span>
</span></span><span class="line"><span class="cl">        <span class="p">{</span> <span class="m">0</span><span class="p">,</span> <span class="m">1</span><span class="p">,</span> <span class="m">1</span><span class="p">,</span> <span class="m">1</span><span class="p">,</span> <span class="m">1</span><span class="p">,</span> <span class="m">1</span><span class="p">,</span> <span class="m">1</span><span class="p">,</span> <span class="m">1</span><span class="p">,</span> <span class="m">1</span><span class="p">,</span> <span class="m">0</span> <span class="p">},</span>
</span></span><span class="line"><span class="cl">        <span class="p">{</span> <span class="m">0</span><span class="p">,</span> <span class="m">0</span><span class="p">,</span> <span class="m">0</span><span class="p">,</span> <span class="m">0</span><span class="p">,</span> <span class="m">0</span><span class="p">,</span> <span class="m">0</span><span class="p">,</span> <span class="m">0</span><span class="p">,</span> <span class="m">0</span><span class="p">,</span> <span class="m">0</span><span class="p">,</span> <span class="m">0</span> <span class="p">}</span>
</span></span><span class="line"><span class="cl">    <span class="p">};</span>
</span></span></code></pre></div><p>We then turn this into an array of <code>Cell</code> objects. Since the first index is the y-coordinate but we&rsquo;d like it to be the
x-coordinate for convenience reasons we need to transpose the map matrix:</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-csharp" data-lang="csharp"><span class="line"><span class="cl"><span class="kt">var</span> <span class="n">grid</span> <span class="p">=</span> <span class="k">new</span> <span class="n">Cell</span><span class="p">[</span><span class="n">map</span><span class="p">.</span><span class="n">GetLength</span><span class="p">(</span><span class="m">1</span><span class="p">),</span> <span class="n">map</span><span class="p">.</span><span class="n">GetLength</span><span class="p">(</span><span class="m">0</span><span class="p">)];</span>
</span></span><span class="line"><span class="cl"><span class="k">for</span> <span class="p">(</span><span class="kt">var</span> <span class="n">y</span> <span class="p">=</span> <span class="m">0</span><span class="p">;</span> <span class="n">y</span> <span class="p">&lt;</span> <span class="n">map</span><span class="p">.</span><span class="n">GetLength</span><span class="p">(</span><span class="m">0</span><span class="p">);</span> <span class="n">y</span><span class="p">++)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">   <span class="k">for</span> <span class="p">(</span><span class="kt">var</span> <span class="n">x</span> <span class="p">=</span> <span class="m">0</span><span class="p">;</span> <span class="n">x</span> <span class="p">&lt;</span> <span class="n">map</span><span class="p">.</span><span class="n">GetLength</span><span class="p">(</span><span class="m">1</span><span class="p">);</span> <span class="n">x</span><span class="p">++)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">       <span class="n">grid</span><span class="p">[</span><span class="n">x</span><span class="p">,</span> <span class="n">y</span><span class="p">]</span> <span class="p">=</span> <span class="k">new</span> <span class="n">Cell</span><span class="p">(</span><span class="n">x</span><span class="p">,</span> <span class="n">y</span><span class="p">,</span> <span class="n">isWalkable</span><span class="p">:</span> <span class="n">map</span><span class="p">[</span><span class="n">y</span><span class="p">,</span> <span class="n">x</span><span class="p">]</span> <span class="p">==</span> <span class="m">0</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">   <span class="p">}</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>     
</span></span></code></pre></div><p>To make sure we don&rsquo;t end up with <code>Cell</code> objects with invalid coordinates with respect to the grid they&rsquo;re in, let&rsquo;s whip
up a <code>Grid</code> class with a static constructor which incorporates the transpose magic as well as a method for getting a cell
at a certain position following the <a href="https://learn.microsoft.com/en-us/dotnet/standard/design-guidelines/exceptions-and-performance#try-parse-pattern"
    
    
      target="_blank" class="external-link"
    
>Try-Parse Pattern</a>
:</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-csharp" data-lang="csharp"><span class="line"><span class="cl"><span class="kd">public</span> <span class="k">class</span> <span class="nc">Grid</span>
</span></span><span class="line"><span class="cl"><span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="n">required</span> <span class="n">Cell</span><span class="p">[,]</span> <span class="n">Cells</span> <span class="p">{</span> <span class="k">get</span><span class="p">;</span> <span class="k">init</span><span class="p">;</span> <span class="p">}</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="kd">private</span> <span class="n">Grid</span><span class="p">()</span> <span class="p">{</span> <span class="p">}</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="kd">static</span> <span class="n">Grid</span> <span class="n">CreateFromArray</span><span class="p">(</span><span class="kt">int</span><span class="p">[,]</span> <span class="n">map</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">    <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="kt">var</span> <span class="n">cells</span> <span class="p">=</span> <span class="k">new</span> <span class="n">Cell</span><span class="p">[</span><span class="n">map</span><span class="p">.</span><span class="n">GetLength</span><span class="p">(</span><span class="m">1</span><span class="p">),</span> <span class="n">map</span><span class="p">.</span><span class="n">GetLength</span><span class="p">(</span><span class="m">0</span><span class="p">)];</span>
</span></span><span class="line"><span class="cl">        <span class="k">for</span> <span class="p">(</span><span class="kt">var</span> <span class="n">y</span> <span class="p">=</span> <span class="m">0</span><span class="p">;</span> <span class="n">y</span> <span class="p">&lt;</span> <span class="n">map</span><span class="p">.</span><span class="n">GetLength</span><span class="p">(</span><span class="m">0</span><span class="p">);</span> <span class="n">y</span><span class="p">++)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">            <span class="k">for</span> <span class="p">(</span><span class="kt">var</span> <span class="n">x</span> <span class="p">=</span> <span class="m">0</span><span class="p">;</span> <span class="n">x</span> <span class="p">&lt;</span> <span class="n">map</span><span class="p">.</span><span class="n">GetLength</span><span class="p">(</span><span class="m">1</span><span class="p">);</span> <span class="n">x</span><span class="p">++)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">                <span class="n">cells</span><span class="p">[</span><span class="n">x</span><span class="p">,</span> <span class="n">y</span><span class="p">]</span> <span class="p">=</span> <span class="k">new</span> <span class="n">Cell</span><span class="p">(</span><span class="n">x</span><span class="p">,</span> <span class="n">y</span><span class="p">,</span> <span class="n">isWalkable</span><span class="p">:</span> <span class="n">map</span><span class="p">[</span><span class="n">y</span><span class="p">,</span> <span class="n">x</span><span class="p">]</span> <span class="p">==</span> <span class="m">0</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">            <span class="p">}</span>
</span></span><span class="line"><span class="cl">        <span class="p">}</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">        <span class="k">return</span> <span class="k">new</span> <span class="n">Grid</span> <span class="p">{</span> <span class="n">Cells</span> <span class="p">=</span> <span class="n">cells</span> <span class="p">};</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="cs">/// &lt;summary&gt;</span>
</span></span><span class="line"><span class="cl">    <span class="cs">/// Try get the cell at the given position</span>
</span></span><span class="line"><span class="cl">    <span class="cs">/// &lt;/summary&gt;</span>
</span></span><span class="line"><span class="cl">    <span class="cs">/// &lt;param name=&#34;pos&#34;&gt;The position to get the cell at from the grid&lt;/param&gt;</span>
</span></span><span class="line"><span class="cl">    <span class="cs">/// &lt;param name=&#34;cell&#34;&gt;The cell at the position if it exists&lt;/param&gt;</span>
</span></span><span class="line"><span class="cl">    <span class="cs">/// &lt;returns&gt;true on success, false on failure&lt;/returns&gt;</span>
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="kt">bool</span> <span class="n">TryGetCellAtPosition</span><span class="p">(</span><span class="n">Point</span> <span class="n">pos</span><span class="p">,</span> <span class="k">out</span> <span class="n">Cell</span> <span class="n">cell</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">    <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="k">if</span> <span class="p">(</span><span class="n">pos</span><span class="p">.</span><span class="n">X</span> <span class="p">&lt;</span> <span class="m">0</span> <span class="p">||</span> <span class="n">pos</span><span class="p">.</span><span class="n">X</span> <span class="p">&gt;=</span> <span class="n">Cells</span><span class="p">.</span><span class="n">GetLength</span><span class="p">(</span><span class="m">0</span><span class="p">)</span> <span class="p">||</span>
</span></span><span class="line"><span class="cl">            <span class="n">pos</span><span class="p">.</span><span class="n">Y</span> <span class="p">&lt;</span> <span class="m">0</span> <span class="p">||</span> <span class="n">pos</span><span class="p">.</span><span class="n">Y</span> <span class="p">&gt;=</span> <span class="n">Cells</span><span class="p">.</span><span class="n">GetLength</span><span class="p">(</span><span class="m">1</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">           <span class="p">)</span> 
</span></span><span class="line"><span class="cl">        <span class="p">{</span>
</span></span><span class="line"><span class="cl">            <span class="n">cell</span> <span class="p">=</span> <span class="k">new</span> <span class="n">Cell</span><span class="p">(</span><span class="m">0</span><span class="p">,</span> <span class="m">0</span><span class="p">,</span> <span class="kc">false</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">            <span class="k">return</span> <span class="kc">false</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">        <span class="p">}</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">        <span class="n">cell</span> <span class="p">=</span> <span class="n">Cells</span><span class="p">[</span><span class="n">pos</span><span class="p">.</span><span class="n">X</span><span class="p">,</span> <span class="n">pos</span><span class="p">.</span><span class="n">Y</span><span class="p">];</span>
</span></span><span class="line"><span class="cl">        <span class="k">return</span> <span class="kc">true</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span></code></pre></div><h3 id="a-algorithm-implementation">A* Algorithm Implementation</h3>
<p>Now that we have the grid we can move on to the algorithm itself.</p>
<p>The A* algorithm is a generalization and extension of <a href="https://en.wikipedia.org/wiki/Dijkstra%27s_algorithm"
    
    
      target="_blank" class="external-link"
    
>Dijkstra's algorithm</a>
.
It belongs to the class of so-called informed search algorithms which use an estimation function (heuristic) to search
in a targeted way and thus reduce the runtime. The A* algorithm always looks at the cells that are likely to lead quickly
to the destination first. To figure out which cell is the best bet, we assign each known cell a cost value based on a metric.
This gives us an idea of how long the path from the start to the destination would be in the best case if we used that cell.
Then, we look at the cell with the lowest value.</p>
<p>For that we need to extend the <code>Cell</code> class from earlier:</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-csharp" data-lang="csharp"><span class="line"><span class="cl"><span class="kd">public</span> <span class="k">class</span> <span class="nc">Cell</span><span class="p">(</span><span class="kt">int</span> <span class="n">x</span><span class="p">,</span> <span class="kt">int</span> <span class="n">y</span><span class="p">,</span> <span class="kt">bool</span> <span class="n">isWalkable</span><span class="p">)</span>
</span></span><span class="line"><span class="cl"><span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="n">Point</span> <span class="n">Position</span> <span class="p">{</span> <span class="k">get</span><span class="p">;</span> <span class="p">}</span> <span class="p">=</span> <span class="k">new</span><span class="p">(</span><span class="n">x</span><span class="p">,</span> <span class="n">y</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="kt">int</span> <span class="n">X</span> <span class="p">=&gt;</span> <span class="n">Position</span><span class="p">.</span><span class="n">X</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="kt">int</span> <span class="n">Y</span> <span class="p">=&gt;</span> <span class="n">Position</span><span class="p">.</span><span class="n">Y</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="kt">bool</span> <span class="n">IsWalkable</span> <span class="p">{</span> <span class="k">get</span><span class="p">;</span> <span class="p">}</span> <span class="p">=</span> <span class="n">isWalkable</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="kt">float</span> <span class="n">CostToTarget</span> <span class="p">{</span> <span class="k">get</span><span class="p">;</span> <span class="k">set</span><span class="p">;</span> <span class="p">}</span> <span class="p">=</span> <span class="kt">float</span><span class="p">.</span><span class="n">PositiveInfinity</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="kt">float</span> <span class="n">CostFromStart</span> <span class="p">{</span> <span class="k">get</span><span class="p">;</span> <span class="k">set</span><span class="p">;</span> <span class="p">}</span> <span class="p">=</span> <span class="kt">float</span><span class="p">.</span><span class="n">PositiveInfinity</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="n">Cell</span><span class="p">?</span> <span class="n">Parent</span> <span class="p">{</span> <span class="k">get</span><span class="p">;</span> <span class="k">set</span><span class="p">;</span> <span class="p">}</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span></code></pre></div><p>Let&rsquo;s have a brief look at the added properties.</p>
<ul>
<li>We already looked at <code>isWalkable</code> as well as <code>X</code>, <code>Y</code> and <code>Position</code>.</li>
<li><code>CostFromStart</code> is the cost (in our case cost is the same as distance) from the start cell to this cell. It&rsquo;s initialized
with <code>float.PositiveInfinity</code>, because we don&rsquo;t know the distance yet.</li>
<li><code>CostToTarget</code> is the heuristic estimated cost (or distance) of the path from the start cell to the target cell
passing through this cell. This is also initialized with <code>float.PositiveInfinity</code>.</li>
<li><code>Parent</code> is used to track from which cell we came from. This is later used to reconstruct the path.</li>
</ul>
<p>Here&rsquo;s the core of the A* pathfinding algorithm. We assume the cost for going from one cell to an adjacent cell is 1.
What the algorithm basically does is the following:</p>
<ol>
<li><strong>Initialization</strong>: Set the starting cell&rsquo;s cost to reach itself (<code>CostFromStart</code>) to 0 and add it to <code>openSet</code>, a set
of cells to evaluate.</li>
<li><strong>Main Loop</strong>: Run while <code>openSet</code> has cells. Get the cell with the lowest estimated cost from the start to the target
via that cell (<code>CostToTarget</code>) from <code>openSet</code>.</li>
<li><strong>Check for Target</strong>: If this cell is the target, then we&rsquo;ve found the path and the algorithm stops.</li>
<li><strong>Process Neighbors</strong>: Otherwise, for each neighbor of the cell calculate the cost to reach the cell plus one (<code>tentativeCost</code>).
If it&rsquo;s is less than the neighbor&rsquo;s current cost (which is +∞ for all cells initially), then we&rsquo;ve found a shorter path
to the neighbor. Set the neighbor&rsquo;s <code>CostFromStart = tentativeCost</code> and <code>CostToTarget = tentativeCost + GetDistance(n, target)</code>,
and update its parent cell. Then add the neighbor to <code>openSet</code> if not already present.</li>
<li><strong>Repeat</strong> until the target is found or <code>openSet</code> is empty in which case the target isn&rsquo;t reachable and thus there is no path.</li>
</ol>
<p>What is the <code>GetDistance(n, target)</code> method in step 4 above? This is the so-called heuristic whose purpose is to estimate the
distance between the current cell and the target. The typical choice in a case like ours is the <a href="https://en.wikipedia.org/wiki/Taxicab_geometry"
    
    
      target="_blank" class="external-link"
    
>Manhattan distance</a>
.
The Manhattan distance between two points in a grid is basically the sum of the absolute differences of their coordinates:</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-csharp" data-lang="csharp"><span class="line"><span class="cl"><span class="n">Math</span><span class="p">.</span><span class="n">Abs</span><span class="p">(</span><span class="n">a</span><span class="p">.</span><span class="n">X</span> <span class="p">-</span> <span class="n">b</span><span class="p">.</span><span class="n">X</span><span class="p">)</span> <span class="p">+</span> <span class="n">Math</span><span class="p">.</span><span class="n">Abs</span><span class="p">(</span><span class="n">a</span><span class="p">.</span><span class="n">Y</span> <span class="p">-</span> <span class="n">b</span><span class="p">.</span><span class="n">Y</span><span class="p">)</span>
</span></span></code></pre></div><p>It&rsquo;s also known as the Taxicab distance, because it represents the shortest path a taxi would take in a city with a
rectangular grid of streets. Unlike Euclidean distance, it only considers horizontal and vertical movements,
not diagonal ones.</p>
<p>Here&rsquo;s a flowchart visualizing the algorithm:</p>
<figure class="center"><img src="/https/shendriks.dev/posts/2024-07-13-a-star-pathfinding-in-2d-games-the-basics-for-top-down-scenarios/images/flowchart.svg"
			alt="A flowchart showing the algorithm"><figcaption>
			<p>A flowchart showing the algorithm</p>
		</figcaption>
</figure>

<p>And here&rsquo;s an implementation of the algorithm outlined above:</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-csharp" data-lang="csharp"><span class="line"><span class="cl"><span class="kd">public</span> <span class="k">class</span> <span class="nc">AStarPathfinder</span>
</span></span><span class="line"><span class="cl"><span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="n">List</span><span class="p">&lt;</span><span class="n">Cell</span><span class="p">&gt;</span> <span class="n">FindPath</span><span class="p">(</span><span class="n">Point</span> <span class="n">startPos</span><span class="p">,</span> <span class="n">Point</span> <span class="n">targetPos</span><span class="p">,</span> <span class="n">Grid</span> <span class="n">grid</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">    <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="c1">// If startPos or targetPos is out of bounds, return an empty path</span>
</span></span><span class="line"><span class="cl">        <span class="k">if</span> <span class="p">(!</span><span class="n">grid</span><span class="p">.</span><span class="n">TryGetCellAtPosition</span><span class="p">(</span><span class="n">startPos</span><span class="p">,</span> <span class="k">out</span> <span class="kt">var</span> <span class="n">start</span><span class="p">))</span> <span class="k">return</span> <span class="p">[];</span>
</span></span><span class="line"><span class="cl">        <span class="k">if</span> <span class="p">(!</span><span class="n">grid</span><span class="p">.</span><span class="n">TryGetCellAtPosition</span><span class="p">(</span><span class="n">targetPos</span><span class="p">,</span> <span class="k">out</span> <span class="kt">var</span> <span class="n">target</span><span class="p">))</span> <span class="k">return</span> <span class="p">[];</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">        <span class="n">start</span><span class="p">.</span><span class="n">CostFromStart</span> <span class="p">=</span> <span class="m">0</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">        <span class="n">start</span><span class="p">.</span><span class="n">CostToTarget</span> <span class="p">=</span> <span class="n">GetDistance</span><span class="p">(</span><span class="n">start</span><span class="p">,</span> <span class="n">target</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">        <span class="n">List</span><span class="p">&lt;</span><span class="n">Cell</span><span class="p">&gt;</span> <span class="n">openSet</span> <span class="p">=</span> <span class="p">[</span><span class="n">start</span><span class="p">];</span>
</span></span><span class="line"><span class="cl">        <span class="k">while</span> <span class="p">(</span><span class="n">openSet</span><span class="p">.</span><span class="n">Count</span> <span class="p">&gt;</span> <span class="m">0</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">            <span class="kt">var</span> <span class="n">current</span> <span class="p">=</span> <span class="n">openSet</span><span class="p">.</span><span class="n">OrderBy</span><span class="p">(</span><span class="n">c</span> <span class="p">=&gt;</span> <span class="n">c</span><span class="p">.</span><span class="n">CostToTarget</span><span class="p">).</span><span class="n">First</span><span class="p">();</span>
</span></span><span class="line"><span class="cl">            <span class="k">if</span> <span class="p">(</span><span class="n">current</span> <span class="p">==</span> <span class="n">target</span><span class="p">)</span> <span class="k">return</span> <span class="n">ReconstructPath</span><span class="p">(</span><span class="n">current</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">            <span class="n">openSet</span><span class="p">.</span><span class="n">Remove</span><span class="p">(</span><span class="n">current</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">            <span class="kt">var</span> <span class="n">tentativeCost</span> <span class="p">=</span> <span class="n">current</span><span class="p">.</span><span class="n">CostFromStart</span> <span class="p">+</span> <span class="m">1</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">            <span class="k">foreach</span> <span class="p">(</span><span class="kt">var</span> <span class="n">n</span> <span class="k">in</span> <span class="n">Neighbors</span><span class="p">(</span><span class="n">current</span><span class="p">,</span> <span class="n">grid</span><span class="p">.</span><span class="n">Cells</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">                         <span class="p">.</span><span class="n">Where</span><span class="p">(</span><span class="n">n</span> <span class="p">=&gt;</span> <span class="n">tentativeCost</span> <span class="p">&lt;</span> <span class="n">n</span><span class="p">.</span><span class="n">CostFromStart</span><span class="p">))</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">                <span class="n">n</span><span class="p">.</span><span class="n">Parent</span> <span class="p">=</span> <span class="n">current</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">                <span class="n">n</span><span class="p">.</span><span class="n">CostFromStart</span> <span class="p">=</span> <span class="n">tentativeCost</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">                <span class="n">n</span><span class="p">.</span><span class="n">CostToTarget</span> <span class="p">=</span> <span class="n">tentativeCost</span> <span class="p">+</span> <span class="n">GetDistance</span><span class="p">(</span><span class="n">n</span><span class="p">,</span> <span class="n">target</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">                <span class="k">if</span> <span class="p">(!</span><span class="n">openSet</span><span class="p">.</span><span class="n">Contains</span><span class="p">(</span><span class="n">n</span><span class="p">))</span> <span class="n">openSet</span><span class="p">.</span><span class="n">Add</span><span class="p">(</span><span class="n">n</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">            <span class="p">}</span>
</span></span><span class="line"><span class="cl">        <span class="p">}</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">        <span class="k">return</span> <span class="p">[];</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="kd">private</span> <span class="kd">static</span> <span class="n">List</span><span class="p">&lt;</span><span class="n">Cell</span><span class="p">&gt;</span> <span class="n">ReconstructPath</span><span class="p">(</span><span class="n">Cell</span> <span class="n">current</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">    <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="n">List</span><span class="p">&lt;</span><span class="n">Cell</span><span class="p">&gt;</span> <span class="n">path</span> <span class="p">=</span> <span class="p">[</span><span class="n">current</span><span class="p">];</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">        <span class="kt">var</span> <span class="n">walkingCell</span> <span class="p">=</span> <span class="n">current</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">        <span class="k">while</span> <span class="p">(</span><span class="n">walkingCell</span><span class="p">.</span><span class="n">Parent</span> <span class="p">!=</span> <span class="kc">null</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">            <span class="n">path</span><span class="p">.</span><span class="n">Insert</span><span class="p">(</span><span class="m">0</span><span class="p">,</span> <span class="n">walkingCell</span><span class="p">.</span><span class="n">Parent</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">            <span class="n">walkingCell</span> <span class="p">=</span> <span class="n">walkingCell</span><span class="p">.</span><span class="n">Parent</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">        <span class="p">}</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">        <span class="k">return</span> <span class="n">path</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="kd">private</span> <span class="kd">static</span> <span class="kt">float</span> <span class="n">GetDistance</span><span class="p">(</span><span class="n">Cell</span> <span class="n">a</span><span class="p">,</span> <span class="n">Cell</span> <span class="n">b</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">    <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="k">return</span> <span class="n">Math</span><span class="p">.</span><span class="n">Abs</span><span class="p">(</span><span class="n">a</span><span class="p">.</span><span class="n">X</span> <span class="p">-</span> <span class="n">b</span><span class="p">.</span><span class="n">X</span><span class="p">)</span> <span class="p">+</span> <span class="n">Math</span><span class="p">.</span><span class="n">Abs</span><span class="p">(</span><span class="n">a</span><span class="p">.</span><span class="n">Y</span> <span class="p">-</span> <span class="n">b</span><span class="p">.</span><span class="n">Y</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="kd">private</span> <span class="kd">static</span> <span class="n">List</span><span class="p">&lt;</span><span class="n">Cell</span><span class="p">&gt;</span> <span class="n">Neighbors</span><span class="p">(</span><span class="n">Cell</span> <span class="n">cell</span><span class="p">,</span> <span class="n">Cell</span><span class="p">[,]</span> <span class="n">grid</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">    <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="n">List</span><span class="p">&lt;</span><span class="n">Cell</span><span class="p">&gt;</span> <span class="n">neighbors</span> <span class="p">=</span> <span class="p">[];</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">        <span class="kt">int</span><span class="p">[]</span> <span class="n">dx</span> <span class="p">=</span> <span class="p">[-</span><span class="m">1</span><span class="p">,</span> <span class="m">1</span><span class="p">,</span> <span class="m">0</span><span class="p">,</span> <span class="m">0</span><span class="p">];</span>
</span></span><span class="line"><span class="cl">        <span class="kt">int</span><span class="p">[]</span> <span class="n">dy</span> <span class="p">=</span> <span class="p">[</span><span class="m">0</span><span class="p">,</span> <span class="m">0</span><span class="p">,</span> <span class="p">-</span><span class="m">1</span><span class="p">,</span> <span class="m">1</span><span class="p">];</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">        <span class="k">for</span> <span class="p">(</span><span class="kt">var</span> <span class="n">i</span> <span class="p">=</span> <span class="m">0</span><span class="p">;</span> <span class="n">i</span> <span class="p">&lt;</span> <span class="m">4</span><span class="p">;</span> <span class="n">i</span><span class="p">++)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">            <span class="kt">var</span> <span class="n">checkX</span> <span class="p">=</span> <span class="n">cell</span><span class="p">.</span><span class="n">X</span> <span class="p">+</span> <span class="n">dx</span><span class="p">[</span><span class="n">i</span><span class="p">];</span>
</span></span><span class="line"><span class="cl">            <span class="kt">var</span> <span class="n">checkY</span> <span class="p">=</span> <span class="n">cell</span><span class="p">.</span><span class="n">Y</span> <span class="p">+</span> <span class="n">dy</span><span class="p">[</span><span class="n">i</span><span class="p">];</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">            <span class="k">if</span> <span class="p">(</span><span class="n">checkX</span> <span class="p">&gt;=</span> <span class="m">0</span>
</span></span><span class="line"><span class="cl">                <span class="p">&amp;&amp;</span> <span class="n">checkX</span> <span class="p">&lt;</span> <span class="n">grid</span><span class="p">.</span><span class="n">GetLength</span><span class="p">(</span><span class="m">0</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">                <span class="p">&amp;&amp;</span> <span class="n">checkY</span> <span class="p">&gt;=</span> <span class="m">0</span>
</span></span><span class="line"><span class="cl">                <span class="p">&amp;&amp;</span> <span class="n">checkY</span> <span class="p">&lt;</span> <span class="n">grid</span><span class="p">.</span><span class="n">GetLength</span><span class="p">(</span><span class="m">1</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">                <span class="p">&amp;&amp;</span> <span class="n">grid</span><span class="p">[</span><span class="n">checkX</span><span class="p">,</span> <span class="n">checkY</span><span class="p">].</span><span class="n">IsWalkable</span>
</span></span><span class="line"><span class="cl">               <span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">                <span class="n">neighbors</span><span class="p">.</span><span class="n">Add</span><span class="p">(</span><span class="n">grid</span><span class="p">[</span><span class="n">checkX</span><span class="p">,</span> <span class="n">checkY</span><span class="p">]);</span>
</span></span><span class="line"><span class="cl">            <span class="p">}</span>
</span></span><span class="line"><span class="cl">        <span class="p">}</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">        <span class="k">return</span> <span class="n">neighbors</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span></code></pre></div><h3 id="example-grid-setup">Example Grid Setup</h3>
<p>Let&rsquo;s put everything together and whip up a console program with our example grid:</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-csharp" data-lang="csharp"><span class="line"><span class="cl"><span class="kd">public</span> <span class="kd">static</span> <span class="k">class</span> <span class="nc">Program</span>
</span></span><span class="line"><span class="cl"><span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="kd">static</span> <span class="k">void</span> <span class="n">Main</span><span class="p">(</span><span class="kt">string</span><span class="p">[]</span> <span class="n">_</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">    <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="kt">int</span><span class="p">[,]</span> <span class="n">map</span> <span class="p">=</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">            <span class="p">{</span> <span class="m">0</span><span class="p">,</span> <span class="m">0</span><span class="p">,</span> <span class="m">1</span><span class="p">,</span> <span class="m">0</span><span class="p">,</span> <span class="m">0</span><span class="p">,</span> <span class="m">0</span><span class="p">,</span> <span class="m">1</span><span class="p">,</span> <span class="m">0</span><span class="p">,</span> <span class="m">1</span><span class="p">,</span> <span class="m">0</span> <span class="p">},</span>
</span></span><span class="line"><span class="cl">            <span class="p">{</span> <span class="m">0</span><span class="p">,</span> <span class="m">0</span><span class="p">,</span> <span class="m">1</span><span class="p">,</span> <span class="m">0</span><span class="p">,</span> <span class="m">1</span><span class="p">,</span> <span class="m">1</span><span class="p">,</span> <span class="m">1</span><span class="p">,</span> <span class="m">0</span><span class="p">,</span> <span class="m">0</span><span class="p">,</span> <span class="m">0</span> <span class="p">},</span>
</span></span><span class="line"><span class="cl">            <span class="p">{</span> <span class="m">0</span><span class="p">,</span> <span class="m">0</span><span class="p">,</span> <span class="m">1</span><span class="p">,</span> <span class="m">0</span><span class="p">,</span> <span class="m">0</span><span class="p">,</span> <span class="m">0</span><span class="p">,</span> <span class="m">0</span><span class="p">,</span> <span class="m">0</span><span class="p">,</span> <span class="m">0</span><span class="p">,</span> <span class="m">0</span> <span class="p">},</span>
</span></span><span class="line"><span class="cl">            <span class="p">{</span> <span class="m">0</span><span class="p">,</span> <span class="m">0</span><span class="p">,</span> <span class="m">1</span><span class="p">,</span> <span class="m">1</span><span class="p">,</span> <span class="m">1</span><span class="p">,</span> <span class="m">1</span><span class="p">,</span> <span class="m">1</span><span class="p">,</span> <span class="m">1</span><span class="p">,</span> <span class="m">0</span><span class="p">,</span> <span class="m">0</span> <span class="p">},</span>
</span></span><span class="line"><span class="cl">            <span class="p">{</span> <span class="m">0</span><span class="p">,</span> <span class="m">0</span><span class="p">,</span> <span class="m">0</span><span class="p">,</span> <span class="m">0</span><span class="p">,</span> <span class="m">0</span><span class="p">,</span> <span class="m">0</span><span class="p">,</span> <span class="m">0</span><span class="p">,</span> <span class="m">0</span><span class="p">,</span> <span class="m">0</span><span class="p">,</span> <span class="m">0</span> <span class="p">},</span>
</span></span><span class="line"><span class="cl">            <span class="p">{</span> <span class="m">0</span><span class="p">,</span> <span class="m">1</span><span class="p">,</span> <span class="m">0</span><span class="p">,</span> <span class="m">0</span><span class="p">,</span> <span class="m">0</span><span class="p">,</span> <span class="m">0</span><span class="p">,</span> <span class="m">1</span><span class="p">,</span> <span class="m">0</span><span class="p">,</span> <span class="m">1</span><span class="p">,</span> <span class="m">1</span> <span class="p">},</span>
</span></span><span class="line"><span class="cl">            <span class="p">{</span> <span class="m">1</span><span class="p">,</span> <span class="m">1</span><span class="p">,</span> <span class="m">1</span><span class="p">,</span> <span class="m">1</span><span class="p">,</span> <span class="m">0</span><span class="p">,</span> <span class="m">1</span><span class="p">,</span> <span class="m">1</span><span class="p">,</span> <span class="m">0</span><span class="p">,</span> <span class="m">1</span><span class="p">,</span> <span class="m">0</span> <span class="p">},</span>
</span></span><span class="line"><span class="cl">            <span class="p">{</span> <span class="m">0</span><span class="p">,</span> <span class="m">0</span><span class="p">,</span> <span class="m">0</span><span class="p">,</span> <span class="m">0</span><span class="p">,</span> <span class="m">0</span><span class="p">,</span> <span class="m">1</span><span class="p">,</span> <span class="m">1</span><span class="p">,</span> <span class="m">0</span><span class="p">,</span> <span class="m">1</span><span class="p">,</span> <span class="m">0</span> <span class="p">},</span>
</span></span><span class="line"><span class="cl">            <span class="p">{</span> <span class="m">0</span><span class="p">,</span> <span class="m">1</span><span class="p">,</span> <span class="m">1</span><span class="p">,</span> <span class="m">1</span><span class="p">,</span> <span class="m">1</span><span class="p">,</span> <span class="m">1</span><span class="p">,</span> <span class="m">1</span><span class="p">,</span> <span class="m">1</span><span class="p">,</span> <span class="m">1</span><span class="p">,</span> <span class="m">0</span> <span class="p">},</span>
</span></span><span class="line"><span class="cl">            <span class="p">{</span> <span class="m">0</span><span class="p">,</span> <span class="m">0</span><span class="p">,</span> <span class="m">0</span><span class="p">,</span> <span class="m">0</span><span class="p">,</span> <span class="m">0</span><span class="p">,</span> <span class="m">0</span><span class="p">,</span> <span class="m">0</span><span class="p">,</span> <span class="m">0</span><span class="p">,</span> <span class="m">0</span><span class="p">,</span> <span class="m">0</span> <span class="p">}</span>
</span></span><span class="line"><span class="cl">        <span class="p">};</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">        <span class="kt">var</span> <span class="n">grid</span> <span class="p">=</span> <span class="n">Grid</span><span class="p">.</span><span class="n">CreateFromArray</span><span class="p">(</span><span class="n">map</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">        <span class="kt">var</span> <span class="n">pathFinder</span> <span class="p">=</span> <span class="k">new</span> <span class="n">AStarPathfinder</span><span class="p">();</span>
</span></span><span class="line"><span class="cl">        <span class="kt">var</span> <span class="n">path</span> <span class="p">=</span> <span class="n">pathFinder</span><span class="p">.</span><span class="n">FindPath</span><span class="p">(</span><span class="k">new</span> <span class="n">Point</span><span class="p">(</span><span class="m">1</span><span class="p">,</span> <span class="m">1</span><span class="p">),</span> <span class="k">new</span> <span class="n">Point</span><span class="p">(</span><span class="m">4</span><span class="p">,</span> <span class="m">2</span><span class="p">),</span> <span class="n">grid</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">        <span class="k">if</span> <span class="p">(</span><span class="n">path</span><span class="p">.</span><span class="n">Count</span> <span class="p">==</span> <span class="m">0</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">            <span class="n">System</span><span class="p">.</span><span class="n">Console</span><span class="p">.</span><span class="n">WriteLine</span><span class="p">(</span><span class="s">&#34;No path found!&#34;</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">            <span class="k">return</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">        <span class="p">}</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">        <span class="n">System</span><span class="p">.</span><span class="n">Console</span><span class="p">.</span><span class="n">OutputEncoding</span> <span class="p">=</span> <span class="n">System</span><span class="p">.</span><span class="n">Text</span><span class="p">.</span><span class="n">Encoding</span><span class="p">.</span><span class="n">UTF8</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">        <span class="n">System</span><span class="p">.</span><span class="n">Console</span><span class="p">.</span><span class="n">WriteLine</span><span class="p">(</span><span class="s">&#34;Path found:&#34;</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">        <span class="n">System</span><span class="p">.</span><span class="n">Console</span><span class="p">.</span><span class="n">WriteLine</span><span class="p">(</span><span class="n">StringFromPath</span><span class="p">(</span><span class="n">path</span><span class="p">));</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="kd">private</span> <span class="kd">static</span> <span class="kt">string</span> <span class="n">StringFromPath</span><span class="p">(</span><span class="n">IEnumerable</span><span class="p">&lt;</span><span class="n">Cell</span><span class="p">&gt;</span> <span class="n">path</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">    <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="kt">var</span> <span class="n">steps</span> <span class="p">=</span> <span class="n">path</span><span class="p">.</span><span class="n">Select</span><span class="p">(</span><span class="n">cell</span> <span class="p">=&gt;</span> <span class="s">$&#34;[{cell.X},{cell.Y}]&#34;</span><span class="p">).</span><span class="n">ToList</span><span class="p">();</span>
</span></span><span class="line"><span class="cl">        <span class="k">return</span> <span class="kt">string</span><span class="p">.</span><span class="n">Join</span><span class="p">(</span><span class="s">&#34;\u2192&#34;</span><span class="p">,</span> <span class="n">steps</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span></code></pre></div><p>When we start this program it will calculate the path from start to target and print it to the console:</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">Path found:
</span></span><span class="line"><span class="cl">[1,1]→[1,2]→[1,3]→[1,4]→[2,4]→[3,4]→[4,4]→[5,4]→[6,4]→
</span></span><span class="line"><span class="cl">[7,4]→[8,4]→[8,3]→[8,2]→[7,2]→[6,2]→[5,2]→[4,2]
</span></span></code></pre></div><div class="notice note" >
    <p class="notice-title">
        <span class="icon-notice baseline">
            <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 128 300 300">
  <path d="M150 128c82.813 0 150 67.188 150 150 0 82.813-67.188 150-150 150C67.187 428 0 360.812 0 278c0-82.813 67.188-150 150-150Zm25 243.555v-37.11c0-3.515-2.734-6.445-6.055-6.445h-37.5c-3.515 0-6.445 2.93-6.445 6.445v37.11c0 3.515 2.93 6.445 6.445 6.445h37.5c3.32 0 6.055-2.93 6.055-6.445Zm-.39-67.188 3.515-121.289c0-1.367-.586-2.734-1.953-3.516-1.172-.976-2.93-1.562-4.688-1.562h-42.968c-1.758 0-3.516.586-4.688 1.563-1.367.78-1.953 2.148-1.953 3.515l3.32 121.29c0 2.734 2.93 4.882 6.64 4.882h36.134c3.515 0 6.445-2.148 6.64-4.883Z"/>
</svg>

        </span>Note</p><p>By the way, you can find all of the above code at <a href="https://github.com/shendriks/pathfinding-2d"
    
    
      target="_blank" class="external-link"
    
>GitHub</a>
.</p></div>

<p>Here is the path visualized (the upper left cell&rsquo;s coordinates are <code>(0, 0)</code>):</p>
<figure class="center"><img src="/https/shendriks.dev/posts/2024-07-13-a-star-pathfinding-in-2d-games-the-basics-for-top-down-scenarios/images/pathfinding-01.png"
			alt="A pathfinding diagram showing a grid with green cells representing a path." width="320" height="320"><figcaption>
			<p>A pathfinding diagram showing a grid with green cells representing a path.</p>
		</figcaption>
</figure>

<h3 id="bonus-interactive-example">Bonus: Interactive Example</h3>
<p>Let&rsquo;s take the algorithm outlined above and assemble an app that lets you watch the A* algorithm at work:</p>




<div id="app-div" style="width: 320px; height: 380px;">
    <iframe
            name="app-iframe"
            id="app-iframe"
            data-src="/blazor/pathfinding-top-down/wwwroot/index.html"
            src="about:blank"
            title="Pathfinding Example App"
            allow="fullscreen"
            referrerpolicy="origin"
            width="320"
            height="380"
    >
    </iframe>
    <div id="app-div-link" class="link-load-app">
        <u>Click to load app</u>
    </div>
</div>

<p>The interactive example lets you step through the algorithm step by step or watch it do its work. You can also manipulate
the grid by changing cells to be free or blocked.</p>
<h4 id="walkthrough">Walkthrough</h4>
<div class="notice note" >
    <p class="notice-title">
        <span class="icon-notice baseline">
            <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 128 300 300">
  <path d="M150 128c82.813 0 150 67.188 150 150 0 82.813-67.188 150-150 150C67.187 428 0 360.812 0 278c0-82.813 67.188-150 150-150Zm25 243.555v-37.11c0-3.515-2.734-6.445-6.055-6.445h-37.5c-3.515 0-6.445 2.93-6.445 6.445v37.11c0 3.515 2.93 6.445 6.445 6.445h37.5c3.32 0 6.055-2.93 6.055-6.445Zm-.39-67.188 3.515-121.289c0-1.367-.586-2.734-1.953-3.516-1.172-.976-2.93-1.562-4.688-1.562h-42.968c-1.758 0-3.516.586-4.688 1.563-1.367.78-1.953 2.148-1.953 3.515l3.32 121.29c0 2.734 2.93 4.882 6.64 4.882h36.134c3.515 0 6.445-2.148 6.64-4.883Z"/>
</svg>

        </span>Note</p><p>When we say &ldquo;click&rdquo; we also mean &ldquo;touch&rdquo; interactions on touchscreen devices. You can use both mouse clicks and touch
events to interact with the app.</p></div>

<p>When you load the app, you see the same map with cells and obstacles as before. Below the map there are a few buttons:</p>
<ul>
<li><figure class="list-item-image"><img src="/https/shendriks.dev/posts/2024-07-13-a-star-pathfinding-in-2d-games-the-basics-for-top-down-scenarios/images/ButtonPlay.png">
</figure>
<br/>
<figure class="list-item-image"><img src="/https/shendriks.dev/posts/2024-07-13-a-star-pathfinding-in-2d-games-the-basics-for-top-down-scenarios/images/ButtonStop.png">
  </figure>

<strong>Play/Stop</strong>: When first clicked, the algorithm will automatically run at a relatively slow pace so you can watch it in all its beauty; when clicked again, it will stop.</li>
<li><figure class="list-item-image"><img src="/https/shendriks.dev/posts/2024-07-13-a-star-pathfinding-in-2d-games-the-basics-for-top-down-scenarios/images/ButtonStep.png">
</figure>
 <strong>Step</strong>: Click to execute a single step of the algorithm.</li>
<li><figure class="list-item-image"><img src="/https/shendriks.dev/posts/2024-07-13-a-star-pathfinding-in-2d-games-the-basics-for-top-down-scenarios/images/ButtonReset.png">
</figure>
 <strong>Reset</strong>: Click to reset the algorithm.</li>
<li><figure class="list-item-image"><img src="/https/shendriks.dev/posts/2024-07-13-a-star-pathfinding-in-2d-games-the-basics-for-top-down-scenarios/images/ToggleShowParentOff.png">
</figure>
<br/>
<figure class="list-item-image"><img src="/https/shendriks.dev/posts/2024-07-13-a-star-pathfinding-in-2d-games-the-basics-for-top-down-scenarios/images/ToggleShowParentOn.png">
  </figure>

<strong>Show/Hide Parent</strong>: When switched on, shows the relationship of the cells to their parent cells.</li>
</ul>
<p>You can even manipulate the cells:</p>
<ul>
<li><figure class="list-item-image"><img src="/https/shendriks.dev/posts/2024-07-13-a-star-pathfinding-in-2d-games-the-basics-for-top-down-scenarios/images/CellStart.png">
</figure>

<figure class="list-item-image"><img src="/https/shendriks.dev/posts/2024-07-13-a-star-pathfinding-in-2d-games-the-basics-for-top-down-scenarios/images/CellTarget.png">
  </figure>

Click and hold the start cell (A) or target cell (B) to move them around.</li>
<li><figure class="list-item-image"><img src="/https/shendriks.dev/posts/2024-07-13-a-star-pathfinding-in-2d-games-the-basics-for-top-down-scenarios/images/CellFree.png">
</figure>

<figure class="list-item-image"><img src="/https/shendriks.dev/posts/2024-07-13-a-star-pathfinding-in-2d-games-the-basics-for-top-down-scenarios/images/CellBlocked.png">
  </figure>

Click and hold a free or a blocked cell to &ldquo;paint&rdquo; or &ldquo;erase&rdquo; walls.</li>
</ul>
<p>When the algorithm is running, the cells change color:</p>
<ul>
<li><figure class="list-item-image"><img src="/https/shendriks.dev/posts/2024-07-13-a-star-pathfinding-in-2d-games-the-basics-for-top-down-scenarios/images/CellOrange.png">
</figure>
 <strong>Orange</strong>: These cells are in the <code>openSet</code> and are about to be examined.</li>
<li><figure class="list-item-image"><img src="/https/shendriks.dev/posts/2024-07-13-a-star-pathfinding-in-2d-games-the-basics-for-top-down-scenarios/images/CellYellow.png">
</figure>
 <strong>Yellow</strong>: These cells have their parent cell set.</li>
<li><figure class="list-item-image"><img src="/https/shendriks.dev/posts/2024-07-13-a-star-pathfinding-in-2d-games-the-basics-for-top-down-scenarios/images/CellGreen.png">
</figure>
 <strong>Green</strong>: These cells are part of the path from A to B.</li>
</ul>
<p>Additionally, cells that are being checked by the algorithm display two numbers. The first number in the upper left
corner displays the cost from the start cell to this cell. The second number below shows the estimated cost from the start to the
destination via that cell.</p>
<p><strong>Example</strong>: <figure class="list-item-image"><img src="/https/shendriks.dev/posts/2024-07-13-a-star-pathfinding-in-2d-games-the-basics-for-top-down-scenarios/images/CellYellowNumbers.png">
</figure>
 The cost
from the start to this cell is <code>7</code>, and the estimated cost from the start to the target via this cell is <code>10</code>.</p>
<h4 id="a-note-about-the-example-application">A Note about the Example Application</h4>
<p>The application is made with <a href="https://github.com/kniEngine/kni"
    
    
      target="_blank" class="external-link"
    
>KNI</a>
, a MonoGame derivative with support for WebGL. This may be
overkill for the task at hand, but I always wanted to try KNI and its WebGL capabilities, and this seemed like a small enough
project to give it a try.</p>
<h2 id="conclusion">Conclusion</h2>
<p>In this article, we looked at the basics of using A* pathfinding in a 2D top-down game. We set out the basics of how the
A* algorithm can find the shortest path between two points on a grid. Next, we&rsquo;ll look at how to apply A* pathfinding in
a 2D side-scrolling platformer. This will involve adapting the algorithm to account for additional challenges like gravity.</p>
]]></content></item><item><title>Using Hugo with Mermaid without client-side JavaScript</title><link>https://shendriks.dev/posts/2024-04-19-using-hugo-with-mermaid-wo-javascript/</link><pubDate>Fri, 19 Apr 2024 00:00:00 +0000</pubDate><guid>https://shendriks.dev/posts/2024-04-19-using-hugo-with-mermaid-wo-javascript/</guid><description>Convert Mermaid diagrams to SVG at build time to shift the burden of rendering diagrams from the client’s browser to the server.</description><content type="html"><![CDATA[<h2 id="introduction">Introduction</h2>
<p>If you don&rsquo;t know what Hugo and Mermaid are, then that&rsquo;s not a problem, here&rsquo;s a super quick introduction.</p>
<p><a href="https://gohugo.io/"
    
    
      target="_blank" class="external-link"
    
>Hugo</a>
 is a static website generator written in Go.
It allows you to easily create websites using markdown and content files like images. At the very basic level, you write your articles
using markdown and then Hugo converts it to HTML.</p>
<p>It also allows code blocks in your markdown files, so you can add code snippets. Besides code snippets, it
also supports diagrams that bring us to Mermaid.</p>
<p>So what is Mermaid? <a href="https://mermaid.js.org/"
    
    
      target="_blank" class="external-link"
    
>Mermaid</a>
 is a JavaScript library that allows you to generate diagrams such as
pie charts using simple text-based syntax.
Here is an example of a Mermaid code block for a pie chart:</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">```mermaid
</span></span><span class="line"><span class="cl">pie title Pizza
</span></span><span class="line"><span class="cl">    &#34;Pizza I have not yet eaten&#34;: 75
</span></span><span class="line"><span class="cl">    &#34;Pizza I have eaten&#34;: 25
</span></span><span class="line"><span class="cl">```
</span></span></code></pre></div><p>The above code block results in this nice diagram:</p>




<figure style="margin: 0; display: block;">
    <a href="/https/shendriks.dev/posts/2024-04-19-using-hugo-with-mermaid-wo-javascript/index-2.svg" class="diagram-dark">
        <img src="/https/shendriks.dev/posts/2024-04-19-using-hugo-with-mermaid-wo-javascript/index-2.svg" alt="" class="diagram" />
    </a>
    
    <a href="/https/shendriks.dev/posts/2024-04-19-using-hugo-with-mermaid-wo-javascript/index-2-light.svg" class="diagram-light">
        <img src="/https/shendriks.dev/posts/2024-04-19-using-hugo-with-mermaid-wo-javascript/index-2-light.svg" alt="" class="diagram" />
    </a>
    
    <figcaption><p></p></figcaption>
</figure>
<p>Ain&rsquo;t that easy? Usually, Mermaid diagrams are rendered in the user&rsquo;s browser using JavaScript. But if you, like me, prefer to lift that
burden from the client&rsquo;s browser and instead render those diagrams upfront and deliver the
ready-rendered charts and graphs, then what?</p>
<p>Fear not, for I too have navigated those troubled waters. Here comes Mermaid CLI
with a bit of tinkering to the rescue!</p>
<h2 id="convert-mermaid-diagrams-to-svg-image-files">Convert Mermaid diagrams to SVG image files</h2>
<p><a href="https://github.com/mermaid-js/mermaid-cli/"
    
    
      target="_blank" class="external-link"
    
>Mermaid CLI</a>
 is a command-line tool that converts Mermaid definitions to <code>svg/png/pdf</code> files. Since Hugo
doesn&rsquo;t offer a built-in solution for hooking-up external tools such as Mermaid CLI, we have to find a way around this.</p>
<p>Here&rsquo;s the idea:</p>
<ol>
<li>Have a script of some sort that recursively iterates over our markdown files and converts Mermaid code blocks to SVG files</li>
<li>Make Hugo use these SVG files instead of the embedded Mermaid code</li>
</ol>




<figure style="margin: 0; display: block;">
    <a href="/https/shendriks.dev/posts/2024-04-19-using-hugo-with-mermaid-wo-javascript/index-3.svg" class="diagram-dark">
        <img src="/https/shendriks.dev/posts/2024-04-19-using-hugo-with-mermaid-wo-javascript/index-3.svg" alt="" class="diagram" />
    </a>
    
    <a href="/https/shendriks.dev/posts/2024-04-19-using-hugo-with-mermaid-wo-javascript/index-3-light.svg" class="diagram-light">
        <img src="/https/shendriks.dev/posts/2024-04-19-using-hugo-with-mermaid-wo-javascript/index-3-light.svg" alt="" class="diagram" />
    </a>
    
    <figcaption><p></p></figcaption>
</figure>
<p>For this to work we adhere to the following convention: Each blog post lives in its own subfolder with an <code>index.md</code> file
like in the following example:</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">.
</span></span><span class="line"><span class="cl">└── content
</span></span><span class="line"><span class="cl">    └── posts
</span></span><span class="line"><span class="cl">        ├── my-first-post
</span></span><span class="line"><span class="cl">        |   └── index.md
</span></span><span class="line"><span class="cl">        └── my-second-post
</span></span><span class="line"><span class="cl">            └── index.md
</span></span></code></pre></div><p>Each <code>index.md</code> file can contain Mermaid code blocks. Then we can do something along the following lines:</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-bash" data-lang="bash"><span class="line"><span class="cl"><span class="cp">#!/bin/bash
</span></span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="nb">set</span> -euo pipefail
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="nv">MERMAID</span><span class="o">=</span>minlag/mermaid-cli:10.8.0
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">docker pull <span class="si">${</span><span class="nv">MERMAID</span><span class="si">}</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="k">while</span> <span class="nv">IFS</span><span class="o">=</span> <span class="nb">read</span> -r -d <span class="s1">&#39;&#39;</span> file
</span></span><span class="line"><span class="cl"><span class="k">do</span>
</span></span><span class="line"><span class="cl">  <span class="nv">DIR</span><span class="o">=</span><span class="k">$(</span>dirname <span class="s2">&#34;</span><span class="nv">$file</span><span class="s2">&#34;</span><span class="k">)</span>
</span></span><span class="line"><span class="cl">  docker run --rm -v ./<span class="s2">&#34;</span><span class="si">${</span><span class="nv">DIR</span><span class="si">}</span><span class="s2">&#34;</span>:/data <span class="si">${</span><span class="nv">MERMAID</span><span class="si">}</span> -i index.md -o index.svg
</span></span><span class="line"><span class="cl"><span class="k">done</span>&lt;   &lt;<span class="o">(</span>find content/ -name index.md -print0<span class="o">)</span>
</span></span></code></pre></div><p>The above script, placed in the root folder of our Hugo project, scans the <code>content</code> folder for files named <code>index.md</code>. For
each file it finds, it launches Mermaid CLI (in a Docker container) with the found file as input. It then creates separate
<code>index-&lt;n&gt;.svg</code> files, one for each block of Mermaid code it finds, numbered consecutively starting with 1
(i.e. <code>index-1.svg</code>, <code>index-2.svg</code>, and so on. Yes, I know, programmers usually start counting at 0, but here it starts at 1).</p>
<p>We then might have something like this:</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">.
</span></span><span class="line"><span class="cl">└── content
</span></span><span class="line"><span class="cl">    └── posts
</span></span><span class="line"><span class="cl">        ├── my-first-post
</span></span><span class="line"><span class="cl">        |   ├── index.md
</span></span><span class="line"><span class="cl">        |   ├── index-1.svg
</span></span><span class="line"><span class="cl">        |   └── index-2.svg
</span></span><span class="line"><span class="cl">        └── my-second-post
</span></span><span class="line"><span class="cl">            ├── index.md
</span></span><span class="line"><span class="cl">            ├── index-1.svg
</span></span><span class="line"><span class="cl">            ├── index-2.svg
</span></span><span class="line"><span class="cl">            └── index-3.svg
</span></span></code></pre></div><p>Now we only have to tell Mermaid to use the svg files. We do this by creating a so-called <a href="https://gohugo.io/render-hooks/code-blocks/"
    
    
      target="_blank" class="external-link"
    
>code block render hook</a>
.</p>
<p>We create the following file in our project:</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">.
</span></span><span class="line"><span class="cl">└── layouts
</span></span><span class="line"><span class="cl">    └── _default
</span></span><span class="line"><span class="cl">         └── _markup
</span></span><span class="line"><span class="cl">             └── render-codeblock-mermaid.html
</span></span></code></pre></div><p>&hellip; with the following content:</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-html" data-lang="html"><span class="line"><span class="cl"><span class="p">&lt;</span><span class="nt">img</span> <span class="na">src</span><span class="o">=</span><span class="s">&#34;index-{{ add .Ordinal 1 }}.svg&#34;</span><span class="p">/&gt;</span>
</span></span></code></pre></div><p>This replaces each Mermaid code block with an image tag with the <code>src</code>-attribute set to <code>index-&lt;n&gt;.svg</code> with <code>n</code> starting at 1.
<code>.Ordinal</code>is the zero-based ordinal of the code block on the page.</p>
<h2 id="there-is-a-catch">There is a catch</h2>
<p>The above solution works fine as long as there are no code blocks with other languages before a mermaid code block,
in which case the numbering of the <code>index-&lt;n&gt;.svg</code> files will not match the numbering of the generated image tags. This is because
on the one hand the mermaid cli tool only counts and numbers mermaid code blocks, and on the other hand the <code>.Ordinal</code>
method in <code>render-codeblock-mermaid.html</code> considers all code blocks.</p>
<h3 id="example">Example</h3>
<p>Let&rsquo;s consider the following example with two code blocks:</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">```csharp
</span></span><span class="line"><span class="cl">public class Program
</span></span><span class="line"><span class="cl">{
</span></span><span class="line"><span class="cl">    public static void Main(string[] args)
</span></span><span class="line"><span class="cl">    {
</span></span><span class="line"><span class="cl">        System.Console.WriteLine(&#34;Hello, Mermaid!&#34;);
</span></span><span class="line"><span class="cl">    }
</span></span><span class="line"><span class="cl">}
</span></span><span class="line"><span class="cl">```
</span></span></code></pre></div><div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">```mermaid
</span></span><span class="line"><span class="cl">flowchart LR
</span></span><span class="line"><span class="cl">    Hello --&gt; C-Sharp
</span></span><span class="line"><span class="cl">```
</span></span></code></pre></div><p>The mermaid cli only considers the one mermaid code block and creates a file named <code>index-1.svg</code> accordingly.
However, in the <code>render-codeblock-mermaid.html</code> hook, the <code>.Ordinal</code> method considers all code blocks, which results
in the following image tag being inserted:</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-html" data-lang="html"><span class="line"><span class="cl"><span class="p">&lt;</span><span class="nt">img</span> <span class="na">src</span><span class="o">=</span><span class="s">&#34;index-2.svg&#34;</span><span class="p">/&gt;</span>
</span></span></code></pre></div><p>This is because the mermaid code block is the 2nd code block in the file. Bingo, we have a 404!</p>
<p>A workaround for this problem is to rename the generated <code>index-&lt;n&gt;.svg</code> files and insert the correct numbers, correct as in
how the <code>.Ordinal</code> method counts. To do this, we grep for all opening code block fences in the <code>index.md</code> file, number them, then
grep only for the mermaid code blocks and number them again. This way we get a mapping of the form <code>wrong number -&gt; right number</code>.</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-bash" data-lang="bash"><span class="line"><span class="cl">grep -E <span class="s1">&#39;^```([a-z]+)&#39;</span> index.md <span class="p">|</span> nl -w1 <span class="p">|</span> grep mermaid <span class="p">|</span> awk <span class="s1">&#39;{print $1}&#39;</span> <span class="p">|</span> nl -w1 -s:
</span></span></code></pre></div><p>In our example above this will print out the following, meaning the generated file <code>index-1.svg</code> should really be named <code>index-2.svg</code>:</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">1:2
</span></span></code></pre></div><p>Let&rsquo;s insert this into our script:</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-bash" data-lang="bash"><span class="line"><span class="cl"><span class="cp">#!/bin/bash
</span></span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="nb">set</span> -euo pipefail
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="nv">MERMAID</span><span class="o">=</span>minlag/mermaid-cli:10.8.0
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">docker pull <span class="si">${</span><span class="nv">MERMAID</span><span class="si">}</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="k">while</span> <span class="nv">IFS</span><span class="o">=</span> <span class="nb">read</span> -r -d <span class="s1">&#39;&#39;</span> file
</span></span><span class="line"><span class="cl"><span class="k">do</span>
</span></span><span class="line"><span class="cl">  <span class="nv">DIR</span><span class="o">=</span><span class="k">$(</span>dirname <span class="s2">&#34;</span><span class="nv">$file</span><span class="s2">&#34;</span><span class="k">)</span>
</span></span><span class="line"><span class="cl">  docker run --rm -v ./<span class="s2">&#34;</span><span class="si">${</span><span class="nv">DIR</span><span class="si">}</span><span class="s2">&#34;</span>:/data <span class="si">${</span><span class="nv">MERMAID</span><span class="si">}</span> -i index.md -o index.svg
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">  <span class="c1"># Fix numbering of output files considering all code blocks found in the .md file</span>
</span></span><span class="line"><span class="cl">  readarray -t number_map &lt; &lt;<span class="o">(</span>grep -E <span class="s1">&#39;^```([a-z]+)&#39;</span> <span class="s2">&#34;</span><span class="si">${</span><span class="nv">DIR</span><span class="si">}</span><span class="s2">&#34;</span>/index.md <span class="p">|</span> nl -w1 <span class="p">|</span> grep mermaid <span class="p">|</span> awk <span class="s1">&#39;{print $1}&#39;</span> <span class="p">|</span> nl -w1 -s:<span class="o">)</span>
</span></span><span class="line"><span class="cl">  <span class="k">for</span> value in <span class="s2">&#34;</span><span class="si">${</span><span class="nv">number_map</span><span class="p">[@]</span><span class="si">}</span><span class="s2">&#34;</span>
</span></span><span class="line"><span class="cl">  <span class="k">do</span>
</span></span><span class="line"><span class="cl">    readarray -t numbers &lt; &lt;<span class="o">(</span><span class="nb">echo</span> <span class="s2">&#34;</span><span class="nv">$value</span><span class="s2">&#34;</span> <span class="p">|</span> tr <span class="s2">&#34;:&#34;</span> <span class="s2">&#34;\n&#34;</span><span class="o">)</span>
</span></span><span class="line"><span class="cl">    <span class="k">if</span> <span class="o">[[</span> <span class="s2">&#34;</span><span class="si">${</span><span class="nv">numbers</span><span class="p">[0]</span><span class="si">}</span><span class="s2">&#34;</span> !<span class="o">=</span> <span class="s2">&#34;</span><span class="si">${</span><span class="nv">numbers</span><span class="p">[1]</span><span class="si">}</span><span class="s2">&#34;</span> <span class="o">]]</span><span class="p">;</span> <span class="k">then</span>
</span></span><span class="line"><span class="cl">      mv -v <span class="s2">&#34;</span><span class="si">${</span><span class="nv">DIR</span><span class="si">}</span><span class="s2">&#34;</span>/index-<span class="s2">&#34;</span><span class="si">${</span><span class="nv">numbers</span><span class="p">[0]</span><span class="si">}</span><span class="s2">&#34;</span>.svg <span class="s2">&#34;</span><span class="si">${</span><span class="nv">DIR</span><span class="si">}</span><span class="s2">&#34;</span>/index-<span class="s2">&#34;</span><span class="si">${</span><span class="nv">numbers</span><span class="p">[1]</span><span class="si">}</span><span class="s2">&#34;</span>.svg
</span></span><span class="line"><span class="cl">    <span class="k">fi</span>
</span></span><span class="line"><span class="cl">  <span class="k">done</span>
</span></span><span class="line"><span class="cl"><span class="k">done</span>&lt;   &lt;<span class="o">(</span>find content/ -name index.md -print0<span class="o">)</span>
</span></span></code></pre></div><p>In our example above this will rename <code>index-1.svg</code> to <code>index-2.svg</code> and the image file will be found.</p>
<h2 id="conclusion">Conclusion</h2>
<p>By using Hugo with Mermaid and the Mermaid CLI, you can integrate Mermaid diagrams into static websites without relying
on client-side JavaScript. You can convert Mermaid code blocks to SVG images at build time and use a custom render code
block to shift the burden of rendering diagrams from the client’s browser to the server. This approach makes your site
load faster and gives users a smoother experience, while still letting you use the simple, elegant text-based syntax for
generating diagrams that Mermaid is known for.</p>
]]></content></item></channel></rss>