Game Objects

Game Objects are the main feature of the engine and can be used to implement lots of different things. The most important method GameObjects have is called "declare()" when a GameObject calls declare() it gets added to a List in the ObjectHandler. The ObjectHandler uses this List in 2 different threads, the first thread is the logic thread that calls the "frameEvent()" method of every GameObject in the list 30 times a second. The other thread is the draw thread which calls the "draw()" method of every GameObject in the List as many times as possible.

The frameEvent method of each GameObject is built using inheritance and is used to control how the Object behaves. The draw() function is responsible for drawing the object's sprite at its current x and y coordinates.

Other noteable fields of GameObject's include

• An image or animation that defines its appearance called a sprite that can be changed at any time on the fly
• A rectangle called a hitbox that can be configured manually or set to the size of their sprite. The object can detect what other object's hitboxes are intersecting with their own
• A X and Y position that can be changed on the fly
• A Value to signify the "render priority" of the object that determines what order the objects are drawn in. Indirectly determining what objects are drawn on top of what objects

Other noteable functionallity of GameObject's include

• Abillity to turn off rendering or logic while leaving the other one on
• Abillity to make collisions only count when non transparent pixels of each objects sprites are touching in at least one place
• A seperate "pausedEvent" method that is run instead of "frameEvent" on every object when the game is paused
• Prebuilt animations for despawning object such as flickering out or exploding into fragments
• Seperate methods for setting X and Y that will fail if the new position puts the object in a wall, out of bounds, or any other place that its not allowed to go

Maps

The 16BL game engine has a built-in map interpreter. The maps could be filled with tiles and objects you can also specify certain information about the objects called object variants that is passed on to the objects once they are constructed

The format for these maps was originally a custom file type called a CMF (Compressed Map File) that could be exported from a custom application called the 16BL map editor and read by the game engine

The 16BL map editor version 1.0 had only basic functionallity like placing/erasing tiles and objects. It was too cumbersome to use efficently so I upgraded it to the version 2.0 and changed the map file format to a new format called "RMF" (Raw Map File). Version 2.0 had much more advanced features like

• Undo/Redo
• Copy/Paste
• New variant menu with custom variants
• Backgrounds
• Layers
• Easier Map Resizing
• Toggleable Gridlines
• Regions of tiles can be placed all at once
• More Fluid Zooming

Unfortunately even with all these new features the map editor proved to be too annoying to use consistently, a map editor 3.0 was planned and started development but after a while I decided that it was more trouble than it was worth and pivoted to using an existing map editor called "Tiled" by making the 16BL game engine able to interpret maps outputted from Tiled

Map Editor Source Github

Other

• Sprite system with custom configuration files for parsing animations from png files also includes image scaling rotation and recoloring
• Textbox system with a set of "~ commands" that you can use to cause text effects (changing color, font size, scroll speed, ect) mid sentence
• Tile Entity type that adds behavior to certain tiles
• System to read input from keyboards and mouse
• System to play wav files