I really need to get out of the habit of starting these posts with “gee, it’s been a while since I posted on the blog”

I’ve been working on mech game for about six months now (according to Bitbucket I started it on February 9th), and shockingly I’m still making slow progress on it. Networked multiplayer works, the base code for all weapons is largely implemented, and I’ve even got some basic animation done for the Geon 3 chassis.

And yet, once in a while still get this overwhelming “what the fuck am I doing?” feeling. The sense that I’m biting off way more than I can chew with this project, and it’s never gonna get done or work right. Even though I’ve got the basics all laid out already, I still feel like I won’t finish it. Like it’s gonna be shit. And both of those things could realistically happen. That’s a pretty intimidating feeling at times.

Part of it comes from this tendency I have of reading into things and getting super granular on subjects that I really shouldn’t be worrying about right now. For example, yesterday I was researching different ways of handling the network aspect of the game and the Low Level API offered by Unity, which is basically a multiplatform UDP implementation. Right now I’m using unity’s High Level API, which does a lot of things behind the scenes to make stuff work, and for the most part it’s fine – but there’s a part of me that doesn’t like the black box nature of it and wants to get a deeper understanding and tighter handle on what’s happening. So I started reading up on the LLAPI and spinning your own networking code and serializing data to send as packets and packet compression and suddenly I’m drowning in this pool of information that realistically is totally unnecessary right now.

This isn’t the first time I’ve done this. A couple years back I felt that Unity was too much of a black box, so I went about writing my own entity component game engine in C++ with SDL2.


I did get it working (and pretty well too, all things considered), but it took me months just to write up a framework that created a window and bounced some sprites around. Whereas if I had just dealt with my weird feelings towards Unity I could’ve written a 3D pong clone in a fraction of the time.

So after delving down the rabbit hole that is advanced networking techniques, I started getting all those dreaded “this project is too big and I just suck so let’s quit and be done with it” thoughts. It took a good chunk of time, focus, and lecturing from my better half to remind me that I gotta keep this stuff broken into manageable parts. This morning I started writing the code for the weapon management system, so I think that’s a good step in the right direction.

This was a far longer ramble than I intended it to be, apologies for the longwindedness about largely nothing. Future posts should be a bit shorter as I’ll be posting more frequently about smaller updates on mech game.


Livestreaming and Level Editing


I’ve recently discovered I have an affinity for level design. I love the idea of crafting a space that you can then run around in and explore. I also love Doom. So naturally, it seems to make sense that I’d like to make spaces you can run around and explore, with the added bonus of shooting demons in the face.

I just started playing with the tools for creating levels in Doom in the last month or so, so I’m still relatively new to the subject. However, I feel that I’ve reached a point of comfort where I can livestream myself trudging along in GZDoom Builder. The first of these went live last night at around 9:45 or so, and you can watch the whole thing on YouTube if that’s your cup of tea/coffee/kool-aid.

I’m aiming to livestream every night or two for at least an hour. It helps keep me focused, and scheduling it makes sure I actually work on stuff and get something accomplished. I’ll probably write something more in-depth on my thinking and process at some point, but for the time being you can catch my livestreams to see what I’m making and chat with me about level design/games/Doom/whatever.

House Rules Re-Release (v2)

I’m happy to announce the re-release of my first print and play board game, House Rules! You can download it from itch.io by clicking here or on the logo above.

From the game page:

House Rules is a print-and-play party game for people with a penchant for making their friends do ridiculous things.Take turns racing around the board, drawing cards with rules on them each step of the way. One turn you might get a Board Rule that advances you three spaces. On your next you might get a Player Rule telling you to:

  • Win a 10 second round of Charades
  • Sketch a player AND get their approval
  • Do your best Chewbacca impersonation
  • Prank call a friend on someone else’s phone and keep them on the line for five minutes
  • Play “Truth or Dare” with the player to your left – they get to ask/dare you

Sound ridiculous? It is. Download it, print it, and start playing

The game is free to download, but if you can donate a couple bucks it’s much appreciated. If you can’t donate but still want to help me out, tell me what you think of the game! It’s still work in progress to a certain degree, so feedback of any sort will definitely help make the game better.

Be sure to follow the House Rules Twitter account, and tweet your best Player Rules with hashtag #MyPlayerRule!

SUPER BotRunner

Hey, first post for a new project! I’ve decided to re-learn Unity (again), and figured a good way to do that would be to remake Botrunner. Before I get into the details, I thought I’d just post a few little videos of what I’ve done so far:

So basically what’s going on here is I’m toying with both 2D and 3D physics, using a sprite character in a traditional platformer format but using 3D models instead of traditional sprite tiles. And so far, it’s working pretty well! Naturally, I’ve still got plenty of stuff to work out. Here’s what’s at the top of the list right now:

    • How to handle level data – do I want to make one main model in Blender or do I want to create lots of little “tile” models?
    • Should I just make a separate scene for each stage, or design some sort of “stage loader”?
    • Camera code – it must be sexy
    • What version control system should I use for this thing?

Anywho, I figure I’ll be posting a good deal about this in here. As always, any and all input is greatly appreciated. More updates soon!



At BGSJAM 3 this past weekend, the theme was Let’s Get Weird!, which was a pretty awesome theme IMO. To that end, Damon McKernan and I made this awesome game called Thumbwars.

Thumbwars is an intense, two-player thumb wrestling game. Each player picks one of the two sticks on a Xbox 360 pad – moving the pad moves your hand, while clicking it locks your thumb down. Hold your thumb down to accrue points, but if the other player manages to pin your thumb you’ll lose a TON of points while trying to shake off the pin. Give it a go, it’s a lot of fun!

p.s. – I made the 3D models for this game, which might get included in the $20 tier reward of this awesome Kickstarter you should totally back.

BGSJAM 3 – Or, Why I’m Dropping My Custom Engine (For Now)

A Very Valuable Lesson

I learned a very valuable lesson this weekend – if I want to make games, I should probably make games.

For the last year or so (Jesus, that’s a long time) I’ve been messing around with what I’ve been calling cldECS. It’s a framework in C++ for creating programs using the Entity-Component-System method. It’s pretty simple, but it works well enough. Originally I wanted to use this framework to build a 2D game engine to make stuff with.

Goddamn, did I bite off more than I could chew.

In that time, all I’ve done is made a few little programs that put some text to the screen, and one that had some bouncing sprites. But nothing came close to the complexity that is even a simple game engine. Nothing.


On the last day of BGSJAM 3 I was messing around with some more advanced features I knew I’d need in a simple engine (serialization, JSON library integration, that sort of thing) and I realized two things:

  1. The level of stress I was getting just trying to get a simple library to do what I wanted was something I didn’t want to deal with
  2. I was dooming myself to spend more time reinventing the wheel (badly) than making an actual game

I want to make games. I really do. But a little voice in my head keeps saying “dude, you gotta do it from scratch, that’s the only real way to make a game.” And that’s bullshit. This is the part where I tell you why.

Why It’s Bullshit

There are SO MANY GAMES out there that are made in things like Unity or GameMaker. SO MANY. Games that I love, even! Hotline Miami. Fotonica. Super Crate Box. Thomas Was Alone. Shadowrun Returns. Superhot. I mean, why WOULDN’T I want to make a game using one of these engines? Clearly they’re beefy enough to make games I would want to both make and play.

“Well,” says my brain, “don’t you think you’re smart enough to spin your own solution? What are you, an idiot or something?” Yes, I am an idiot. For thinking that I should try to make something as ridiculously complex as an engine right now. I’m by no means a great programmer. I’m not even a very good one. And that’s okay.

I think that’s the hardest part I’ve had trying to use other engines like Unity in the past. A part of me tells me I’m somehow failing by using an engine or solution I didn’t create myself. And that, quite frankly, is fucking insanity. When someone has created an engine that better, easier to use, and more supported than anything I could make on my own, why the hell wouldn’t I use it?  Because of my pride? Fucking please. I gotta get over that shit and just make rad stuff.

What’s Next

I’m gonna do the unthinkable – blank my desktop harddrive and make it purely a Windows machine. Don’t get me wrong, I still love Linux. But I want to work in Unity, which means it’s Windows time. And having that be my sole OS will make it that much easier for me to get into dev mode (much like booting straight into Linux has had me doing way more C++ coding lately).

Sooooo, yeah. TL;DR, I’m getting back into Unity. Again. Let’s hope for some rad stuff.

cldECS – Quick Update



What’s Shakin’

Just a quick update on the Entity Component System framework project! Yes, I’ve been working away on it, and it’s now running swimmingly. While I’m still working on some example projects using it, you’re more than welcome to download it and try it out for yourself. The docs (that is, the README) aren’t all that fleshed out, but the headers all have pretty solid explanations of what everything does. There’s only four of them, so it shouldn’t be too tough a read. https://github.com/hellocld/CLD-ECS

Cool Graphic

As you can see from the image above, I went ahead and made a logo for it. While I might be getting a bit too excited about things with that, I made it for a good reason; one which will be evident hopefully in the coming weeks. And those shapes in the logo weren’t just picked out of a hat. 😉

Landing What?

Finally, I’m confident enough in this simple framework that I also made a little landing page for it. Right now it doesn’t have much other than the logo that links to the GitHub project, but it’s something to keep an eye on. http://cldecs.hellocld.com/


CLD CES – First Post

In the past I’ve dabbled a bit with the component-entity system model of design, and with my recent endeavors in teaching myself C++ I thought it’d be a good project to create a simple CES framework. If you don’t know what the CES or ECS design model is, I’d recommend giving the Wikipedia article on it a read before continuing.

The approach I’m taking is very bare-bones, and for good reason IMO. I’d like it to be as simple as possible, so it doesn’t necessarily become restricted to being a “game engine”. Currently I’m using four objects in the framework:

  • Component: The Component class is just a base for other custom Components that will simply store data. I’m using simple class inheritance here.
  • Library: The Library will contain a database of all Entities and their corresponding Components. The database is an unordered map, with the key being an int that represents an Entity and the value being another unordered map that holds the Components. That “Component” map’s keys are the typeid of the Component object (so as not to store duplicate Component types) and a pointer to the Component itself. The Library also serves as a “Librarian” that can provide information on the Components and Entities; things like a vector of all Entities that contain Component X, a specific Component of a particular Entity, or whether or not an Entity contains a Component of type X. Creation and destruction of Entities is handled by the Library, as is addition and removal of Components to/from Entities.
  • System: The Systems will be where the messiness comes in, but that’s all up to the developer using the framework. It will have the ability to communicate with the Library contained in the System’s World (see below), access all the Library’s public methods and alter the data in Components.
  • World: The World is the encompassing object that holds a set of Systems and the Library they can access. It initializes all Systems and connects each to the Library. The World is also responsible for the main program loop that runs through each System one at a time, updating each.

I’m fairly certain that while I’ve got a good idea of how I want the framework to function I’m still a good ways off from having it in a relatively solid, functional state. For instance, I’m probably going to need to create some sort of messaging system so systems will have a better way of interacting with one another (Messages could easily be they’re own Component type).

You can follow the development of the framework at Github.

DUNGEONEERING (WIP Title) And Other Ramblings on GGJ14

TL;DR – Damon and I made a board game. It’s a little clunky, but definitely fun and playable. Click here to download the current version.

This was my second year participating in Global Game Jam, and I was all sorts of stoked for it. We were hosting the local jam at Buffalo Game Space (UB held it last year), and we had a pretty solid turnout! Coming off the heels of our own jam as well, everyone was pretty amped to be making more games.

The theme, revealed Friday night, was “We don’t see things as they are, we see them as we are.” This lead to a biiiiiiig discussion full of ideas for different games.

The BGS whiteboard, covered with all the ideas from Friday night of GGJ ’14.

We ended up all settling on two separate projects, one video game and one board game. From the get-go I was planning on making some sort of board game, partly because I didn’t want to lug my rig back and forth again, and partly because I just really wanted to make another fun print-and-play game. And I think we (myself and and Damon McKernan, co-developer) succeeded in doing just that.


Our game is (tentatively) titled “Dungeoneering“. It’s a sort of dungeon crawler, where two to four players have to complete randomly assigned objectives; the first to finish their objectives wins the game. The initial gameplay involves players constructing the board from a set of map cards (each a 4×4 tile grid), and populates it with item tokens that function similarly to the item boxes in Mario Kart. Each player starts at the “Spawn” tile, with one objective card and one item card. Items can be shown to other players, but objectives should be kept secret (tying in with the theme of “seeing things as you see yourself” while not seeing everything as it is).

The main gameplay consists of trying to complete your objective. Players take turns rolling a die to determine how many AP (Action Points) they have for that turn. AP can be used for moving (1 AP per tile) or using items. Items, represented by cards in your hand, can be weapons, spells, traps, or “use” items. Most, but not all, items have an AP cost associated with them. Some items also require a second roll to see if they succeed in whatever action they conduct, and some are also restricted to a certain range in tiles. Here’s an example turn:

  • I roll for AP, and get a 4
  • My objective is to kill the player to my left, and they’re three spaces away from me, so I move two spaces to get closer to them. This leaves me with 2 AP this turn.
  • In my items I’m carrying a Spear, which has a range of two. This means the player I’m targeting is just within range. I make clear I’m attacking the player by telling them and showing my spear card to prove I actually have it
  • The Spear has a check roll to see if I can actually hit my target, which I use a second die to roll for. If I roll a 5 or a 6 I hit; otherwise the attack failed. I rolled a 5, so I succeeded in killing the player!
  • When a player is killed, you can take an item from their inventory. The player shows me the backs of all their cards, and I pick one at random. They then return to their starting point at the Spawn tile.
The Dungeoneering map, populated with item tokens and player pieces.

If that was all my objective was, then I get a point, play my objective card face up on the table, return to my spawn point, discard my inventory, and take another objective card and an item card.

And I’m sure by this point you’re probably incredibly confused as to how to play at all. It’s way easier than it sounds though, and the next iteration of it will be even easier to play. There’s a way to pick up more items while playing, but the current mechanic is super sloppy and tedious. We’ve come up with a way to make it infinitely easier, so that’s why I’m not getting into that right now. Traps are another element that really spice the game up, but it’d be easier to show once we’ve got some better graphics for it.

All in all, I’d call GGJ14 a huge success for Damon and myself. While I probably didn’t do a good job of describing the game, we’ve got a very solid core game built that was a lot of fun for everyone to play. Naturally it’s a jam game, so it needs a bit of polishing and tweaking. Fortunately we want to do just that, and eventually make it into a full-fleged, well tested, exceptionally fun game. Expect more updates on it soon!