Mapping Genealogy in Neo4J

This summer I’ve worked on a behavior and trait mapper in C++ that establishes entirely dynamic AI routines, allowing actors to propagate and interact with each other in unique ways. You can think of it as a super sophisticated Langton's Ant, where the goal was to identify the reflective sociological impacts of personal traits from as minute and mundane as a vegan to criminal desires like burglary, sexual preferences like pansexual or uncontrollable hunger desires of a cannibal, etc. The graphing of the application was with Vis.js. ...

July 26, 2019 · 2 min

Runtime Pipeline Patterns

Introduction Pipeline patterns are most commonly used for simple data workflows like general functional composition or user registration processes. After briefly describing the basics, this article focuses on a couple of behavioral software design patterns under the strategy pattern we’ll refer to as “runtime patterns” for use with pipelines. Their power in modern applications is allowing pipelines to expand or contract dynamically. Whether it be through behavior modeling with ai, blueprint fulfilling or more basic conditional pipeline adaptation, the runtime patterns are helpful and with forethought can be simply understood and implemented. ...

February 25, 2019 · 4 min

Async Await Chaining

Creating synchronously chained functions is straight forward. Codepen. const UserCollectionSync = { find(id=''){ document.writeln('1'); return this; }, update(){ document.writeln('2'); return this; }, save(){ document.writeln('3'); return this; } } UserCollectionSync .find() .update() .save(); But when we decide to just throw some ‘async’ ‘await’ flags on those functions everything doesn’t work. FOLLOWING CODE IS WRONG: Codepen. // delay is used to represent some asynchronous work function delay(ms){ return new Promise(resolve => setTimeout(resolve, ms)); } //end delay() const UserCollectionAsync = { async find(id=''){ await delay(1000) document.writeln('1'); return this; }, async updateFor(options={}){ await delay(50); document.writeln('2'); return this; }, async save(){ await delay(50); document.writeln('3'); return this; } } UserCollectionAsync .find() .updateFor('') .save(); The reason it fails is because when the ‘find()’ is called it returns a promise that hasn’t resolved instead of the ‘UserCollectionAsync’ object (Factory pattern.) Therefor you can’t find a function ‘update()’ on a promise. One common way of solving the issue is by allowing the factory to maintain a queue and force the user to add ‘done()’ at the end of the chain: Codepen. ...

January 6, 2019 · 3 min

Meander Algorithm

The meander algorithm is a combination of using mazes to allow a meandering with bresenhams line. Below you can see the actual algorithm in simplicity. Obviously you could use noise maps to created heighted terrain based on the river to make it look pretty. Choose a starting map edge and ending map edge, acquire the terminal points based on those edges. Usually this would be a random point on those edges. Maybe you’d want to weight it so it’s predominately in the center, or you could restrict it to a certain part. Create Bresenhams line between the terminal points. This is called the pathing vector. Break up the pathing vector into chunks of 9x9 where the pathing vector crosses the center. There may be left-over of the pathing vector. For each chunk, perform a recursive maze generation algorithm on the chunk. Repeat this step until there is a path from the start of the pathing vector within the chunk to the end of the pathing vector in the chunk. A* pathing algorithm can be used for the pathing. Merely use Bresenhams line to wrap up the extraneous pathing vector not covered by chunks, alternatively break up the remaining path into the largest odd number and chunk and process it similarly to the previous part of the algorithm to make it more consistent. Left overs in this optional way would still be filled in with bresenhams line. Recursive Maze Generation: ...

September 4, 2018 · 2 min

Generating Exhumed River Channel

I recently did some work in generating rivers in a 2d game. Revisiting this work to create an exhumed river channel, I decided it might be fun to revisit how to generate it to make the channel look more realistic. Instead of using a drunken walker, this is a more expensive but interesting map generator: Start by generating 2d simplex noise where less <0.6 is floor rest is walls Generate terminal lines at each map exit (north, south, east, west). Shuffle those lines and randomly choose a start and end location for the river based on two of those lines. Later you can add another line with terminal point to allow a split river channel ...

August 6, 2018 · 1 min

Generating Cliffs for 2d Game

Source code available on github here.\n\nA recurring problem in 2d games is how to represent depth. In isometric games this is easily solved but in discretely top-down games it’s harder to solve. After doing a lot of research I fell onto a simple idea: do the best you can insinuating the depth and leave the rest to the imagination. Here’s the algorithm I used to create 2d top-down cliffs: Create a small map of perlin noise and a wide map of perlin noise. Add the two together and give the large map a weight of 3 with the small a weight of 1 and render the result with different breakpoints. This is ref map A. Less than 0.01 on A is deep water ...

July 31, 2018 · 1 min

Generating 2d Rivers

Rivers are really hard to generate for 2d top-down games for multiple reasons: Rivers primarily form based on heightmaps which are hard to display in top-down Displaying fluidity when working with sectors or grid-based rendering can be complicated, bresenham’s line algorithm only goes so far to make things look smooth naturally occurring mechanisms of nature have numerous factors in play that caused them to exist. Simulating all of these factors isn’t reasonable. I was able to make relatively decent 2d rivers using a few techniques. ...

July 11, 2018 · 1 min

Balancing Game Mechanics

Two of the most influential components to decreasing LOE in balancing game mechanics is automating the most essential parts of testing those mechanics, and providing meaningful and easy to understand graphs. Some meaningful questions to better lay the foundation of balancing and creating these components: What are the actual ‘core stat(s)’ that identify survival? (Usually health) What are the ‘ancillary stat(s)’ that help facilitate the increase or decrease that core? (damage, strength, dexterity, etc.) I’m assuming all actors here are equal and we aren’t comparing apples and oranges. What are the ‘supplemental stat(s)’ that may contribute to the increase or decrease of the ancillary stats? (class, rank, level) What are the ’extraneous stat(s)’ that don’t affect the other stats already identified. I found that creating a tree by drawing lines connecting these identified stats provided incredible insight and direction. ...

June 6, 2018 · 1 min

Pigeon Hole Stepping v2

I had originally written an article on how to implement PHS. Having found the maps generated slightly redundant I decided to take another look. Here are the steps taken to successfully generate a more realistic town. It’s essentially a drunken walker like Diffusion Limited Aggregation mixed with a hallway constraint that mimics the large part of PHS. Start somewhere in the middle, add this and all possible directions up to a certain dynamic length (I used a standard deviation of 1.4 with a mean of 5, ) as nodes: [{x,y,direction},...]. We will be looping until all nodes and edges (we’ll describe that shortly,) are gone. When we have node then check to see if the path between it’s ‘x,y’ and ‘x2,y2’ (given the length and direction) is clear. If it is, then add the entire path minus the start and end as edges, and add the end as a new node. Shuffle nodes after adding a new one. After building the path run through the path array randomly attempting to build a room in all directions. (this won’t be entirely possible and will leave negative space to fill with edges.) If there are no nodes, repeat step 3 except with edges (this helps fill the map negative space.) After all nodes and edges are gone then cover all cells adjacent to floors with walls if it’s empty. I found it helpful to use this simple formula to generate hallway lengths with a mean and standard deviation constraint. Both the x and y would work fine, here we’re using the y only. ...

May 8, 2018 · 2 min

Generating Ancient Ruins

While creating algorithms for random continent generation, I came across an old algorithm I had worked with called Coupled Map Lattice. Using that to create a continent was hard but I was able to accomplish it doing layers of filters: generate map with noise between -1 and 1 apply CML using Spatiotemporal Intermittency settings (a = 1.75, ε = 0.6) I found that using something too chaotic didn’t have a noticeable affect compared to just generating noise in general. normalize values to between 0 and 255 apply a gaussian blur normalize values to between 0 and 1 apply slight height restrictions based on distance to center of map ...

May 3, 2018 · 1 min