#dynamic code

Creating #plugins for your apps for #developers #completedevpod

If an application is around for long enough, eventually the users will want to modify the behavior of the application for themselves. If your application is of sufficient size, it quickly becomes impossible to cover every use case that your users might have. Whether it is the import and export of data, integrations with other system, or additional functionality, it’s hard to predict how your…

This week was pretty cool. Not as in depth as last week, as there was a bit more clean up done here and there to strip out test debug code we don’t need anymore. However, we did get to add one sweet new thing that’s gonna make that live edit super awesome.

Day 1

We updated the way the game DLL was being reloaded so that it was only done after it saw a new write time on the file. Previously we were reloading every frame regardless, so this is a small but useful change.

Day 2

First, we started rendering a small white square as the player. We incorporated some simple movement for it as well as a basic jump using a sine wave, but mostly this was to test the more important thing we added: live state looping.

This started out as live input looping, where we’d just repeat the input we used over and over again. This led to some weird glitches where the input matched, but if we changed something about the character or its position, then we’d get dissimilar results each loop. We quickly extended it to store any relevant information in the game state so we could loop that as well. We set it up so that pressing ‘L’ would record the loop. Then we moved our little square guy around and jumped, then ended the recording, which at the time automatically started the loop playback.

Now in conjunction with the live DLL game reloading, this means that we could change (almost*) whatever we wanted and the loop would update using the new information. So if we wanted to change the jump height, or the movement speed, or the background color, we could do it, build the game DLL, and everything would update instantly. The loop would continue but would use any new variable data for the character instead.

Man, so awesome.

*If we end up changing something outside of the game loop, like the window creation, or we add or remove or otherwise change the contents of a struct, then we’d have to close out the game and reload it. However, for tuning and testing, having the ability to hot load and loop is much better than not having it.

Day 3

Not a lot going on here, just bug fixing and code clean up in preparation to wrap up this prototype platform layer.

Day 4

We added mouse input handling. We drew another box on the cursor and added new boxes that pop when pressing any of the three primary mouse buttons or two thumb buttons.

We also set up the state looping to handle more than one state and adjusted the code so that we could stop the loop playback. One other big issue we had with the state looping was that the initialization was taking a great long time (for me it was like 7-10 seconds) before it would start recording; there was also a noticeable hiccup when the loop would start over.

I believe this was caused by the CopyMemory() call we were using to initialize the memory for the recording as well as the size of the file we were creating (initially over a GB!). We swapped it out with our own memory handling, removed that function call, and lowered the size of the state file, and everything became very snappy--just what we were looking for!

The last thing we did was strip out the test pattern background and the tone sound output, because that was just to make sure we were doing things properly in the prototype platform layer.

Day 5

This stream was just a primer for game architecture, so no code was harmed in the learning of this information.

Day 6

Set up the code to start drawing a rectangle. Mostly this was to prep for the next day’s stream, which was the initial tile map creation.

Day 7

Lastly, we set up the tile map. We had just a simple grid of squares using a basic two-dimensional array to store the grid. After that, it was just a matter of drawing pretty boxes at each grid location. We also started drawing the player character as a slightly smaller, yellower box, and fixed an issue with frame timing that was causing the player movement to be choppy and slow.

Summary

So, we finished our prototype platform layer and are moving headlong into starting to build the actual game code. That means that now we get into the really interesting stuff. As always, Casey is presenting everything in a way that makes it really easy for any would-be programmer to understand what’s going on (okay, like 97% of the time), and it’s really keeping me interested in what’s next.

I’m also finding that I really like the “compression programming” that he advocates. I usually use a similar approach when scripting, but this is a bit more refined than even I’m used to.

One more thing: someone in one of the streams asked how long a shippable platform layer would take to write, and I was a little dismayed to hear that it would take something like 50 days on stream to finish. Hopefully that’s just conservative padding, but if not, there will be a lot of drudgework late in the project.

I need to teach myself php, specifically the kind of code that can be useful in setting up an easily updatable site such as a webcomic or art portfolio.

I'd like to be able to do the dynamically updating sort of thing where if i upload numbered images to the site, links and new pages are automatically generated. such as i have 10 pages of comics on the site already, if i upload the image for the 11th comic, the php does the rest and sets up the page for it to display, with the "back" and "archive" links already there, etc. 

Right now I'm working on reverse-engineering this from other webcomics that are successful in doing what I want to do, but any advice on which code tags I should be looking for would be really helpful!