#PROCJAM, University and Final Year Project

Yesterday marks the end of #PROCJAM, a games jam all about procedural generation, or the idea of generating stuff from algorithms. For a whole week, your goal is to either produce a game that uses procedural generation in some way (and possibly follow the optional theme of INFINITY), or a tool that procedurally generates stuff to help out other developers. ProcJam is a games jam I’ve been pursuing because it’s a topic I’ve been gaining interest in for the last few months, with games like Spelunky and Rouge Legacy being really popular and the whole idea about creating fully usable stuff out of code, and being able to create new and different stuff every time is awesome.

Which is why I attended the open day conference at Goldsmiths (University of London) to hear speakers like Mark Johnson, the developer of the massive Ultima Ratio Regum and Hazel McKendrick who works on No Man’s Sky, to get an idea of what I can do with procedural generation. Unfortunately, I am also back at University, doing important work in my final year to get my degree, so I don’t have as much time as I want to make a major game in a week, especially since my degree requires me to make at least three games or game like projects in a semester. But I also have an advantage as my final year project/dissertation is on Procedural Content Generation, so I can use the jam to help with my research!

Which is why my submission entry isn’t a game, or not really a tool of much detail, but more a series of algorithm implementations for a programming language that doesn’t have much deserved attention. Introducing the:

Procedural Noise Algorithms for Haxe

I have used some prior reading the week of procjam to investigate different procedural algorithms, mostly noise but also maze algorithms. After a week of reading, programming, debugging and trying out different algorithms, I have come up with pure Haxe implementations of Value Noise, Worley Noise, Midpoint Displacement and Prim’s Algorithm. Below are actual screenshots of what the algorithms have made:

Working on the algorithms and looking at examples made this really challenging and fun, I did also look at Perlin Noise, Simplex Noise, Depth-First Search and Kruskal’s algorithm, although those had some challenges with them. My challenge was to write them in classes that could be used statically, so an object didn’t have to be initialized for it to be used. I also didn’t want to rely on additional libraries (such as HaxeFlixel or Format) for certain tasks, meaning these rely on the base dynamic variables as well as both the Std library and Math libraries, a few cases involved writing basic classes to make stuff possible.

You can check it out here: http://gamepopper.itch.io/procedural-noise-for-haxe

I’ve uploaded the source code to GitHub here: https://github.com/gamepopper/HaxeNoise-Demo

Now I’ve got to get back to University work, I have to help build a C# Game Engine, a Multiplayer Game and a 3D Graphics program! Hopefully will have stuff to show you later on in the year!


One thought on “#PROCJAM, University and Final Year Project

  1. Pingback: Procedural Meshes: Generating Gemstones Part 1 | GAMEPOPPER

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s