Dustin Gibson

HJEngine2


HJEngine2 is an ongoing 2D game engine colloberation project among a couple of friends. I am not very into video games, but I like the challenge of doing something different and applying what I learned in Mathematics. We have competed in two Lundum Dare game jams with our own engine written Python. HJEngine2 is written in C++ using OpenGL and is meant to provide more flexibility and performance compared to the first iteration.

Code samples can be found at the bottom of this page.

Team:


Git Link
Latest Build: Map Editor
Latest Build: HJEngine2


Map Editor (C#):
  • Import, add tile, and remove tile from tilesets
  • Add objects and properties
  • Add and modify tile collision
  • Place, fill, delete, and copy tiles and objects
  • Add and remove layers
  • Mini-map, grid, and zoom display
  • Expand or shrink map area
Engine (C++):
  • Draw images using map file produced by the editor
  • State machine to handle game, objects, and menu lifecycles
  • Visibility algorithm to hide view
  • Few effects
  • Supports fragment and vertex shaders




    Code Design
    • Object-Oriented - HJEngine2 is heavily centered on objected oriented design. Due to the demand of creating and removing objects on the fly, the factory pattern is the most common design pattern used. Inheritance is used throughout the code. For an example: individual effects are represented as individual classes and are inhearited by the abstract Effect class with common properties and methods.
    • OpenGL and SDL - The rendering API used is OpenGL. However, SDL is used to provide input and timer methods. Box2D is used for physics and collision detection.
    • Compactness - A lot of game programs have an issue of having multiple files spread out. This becomes a pain to manage. Almost everything is in one map file produced by the map editor. Everything in the file is managed by the map editor.


    Challenges and Lessons Learned:
    • OpenGL is very challenging to learn since it’s much more technical than most APIs I have written with. Writing shaders requires working in a different paradigm. Drawing a simple image requires converting the image into a texture, binding it, set up buffers that determines the properties of textures, running it through shaders, and then drawing it.
    • As for the map editor, the .NET framework isn’t a library that comes to mind when dealing with image manipulation. With .NET Bitmap object and picturebox widgets, it can be difficult to display exactly what you want the user to see. In hindsight, I would have used Qt since it integrates with OpenGL and SDL very nicely.
    Code Samples

    Unpack Data (C++)

    			
				

void TileMap::LoadData()
{
	unsigned char* main_buffer = GetByteArray();
	name = TraverseToString(main_buffer,20);
	//Tile Width
	tile_width = TraverseToInt(main_buffer,2); 
	//Tile Height
	tile_height = TraverseToInt(main_buffer,2);
	//Rows
	row_num = TraverseToInt(main_buffer,2);
	//Columns
	col_num = TraverseToInt(main_buffer,2);
	//Tile Sheet Columns
	tile_set_x = TraverseToInt(main_buffer,2);
	//Tile Sheet Rows
	tile_set_y = TraverseToInt(main_buffer,2);
	//Tile Set MaxCol
	max_col = TraverseToInt(main_buffer,2);
	tile_set = new TileSet(tile_width,tile_height,tile_set_x,tile_set_y);
	//Number of Layers
	int layer_count = TraverseToInt(main_buffer,2);
	//Tile Set Images
	for(int i=0; i < tile_set_x; i++)
		for(int j=0; j < tile_set_y; j++)
		{
			if( j == tile_set_y - 1 && max_col < i)
				break;
			int img_size = TraverseToInt(main_buffer,4);
			TraverseToBitmap(main_buffer,img_size);
			//tile_set->AddTile(bitmap_val,CPoint(i,j));

		}
	//Full Bitmap Size
	int full_bitmap_size = TraverseToInt(main_buffer,4);
	//Full Bitmap
	this->full_sheet = TraverseToBitmap(main_buffer,full_bitmap_size);
	//Map Set
	for(int i = 0; i < layer_count; i++)
	{
		std::map* map_set = new std::map();
		std::vector*>* temp_vect_x = new std::vector*>();
		for(int j = 0; j < col_num; j++) {
			std::vector* temp_vect_y = new std::vector();
			for(int k=0; k < row_num; k++) {
				int tmp_x = TraverseToInt(main_buffer,2);
				int tmp_y = TraverseToInt(main_buffer,2);
				int tmp_val_x = (short)TraverseToInt(main_buffer,2);
				int tmp_val_y = (short)TraverseToInt(main_buffer,2);
				unsigned char* tmp_col = TraverseToBytes(main_buffer,2);
				CPoint key_pnt = CPoint(tmp_x,tmp_y);
				CPoint val_pnt = CPoint(tmp_val_x,tmp_val_y);
				TileValue tile_val = TileValue(tile_world,val_pnt,tmp_col);
				temp_vect_y->insert(temp_vect_y->end(),tile_val);
			}
			temp_vect_x->insert(temp_vect_x->end(),temp_vect_y);
		}
		layer_set->insert(layer_set->begin(),temp_vect_x);
	}
	//Number of object templates
	int num_obj_template = TraverseToInt(main_buffer, 2);
	for(int i=0; i < num_obj_template; i++)
	{
		std::map* prop_map = new std::map();
		ImageStates image_states = ImageStates();
		//Object Name
		std::string obj_name = TraverseToString(main_buffer, 20);
		//Number of Properties
		int prop_num = TraverseToInt(main_buffer, 4);
		for(int j=0; j < prop_num; j++)
		{
			//Property name
			std::string prop_name = TraverseToString(main_buffer, 20);
			//Property data type
			std::string prop_data_type = TraverseToString(main_buffer, 20);
			Property temp_prop = Property(prop_name, prop_data_type, 0, NULL);
			prop_map->insert(std::make_pair(prop_name, temp_prop));
		}
		//Number of States
		int state_num = TraverseToInt(main_buffer, 2);
		for(int j=0; j < state_num; j++)
		{
			//State name
			std::string state_name = TraverseToString(main_buffer, 20);
			//Bitmap size
			int state_size = TraverseToInt(main_buffer, 4);
			//Bitmap itself
			TextureGroup* state_image = TraverseToBitmap(main_buffer, state_size);
			image_states.AddState(state_name,state_image);
		}
		object_factory->AddTemplate(obj_name,prop_map,image_states);
	}
	//Number of Object Instance
	int obj_instance_num = TraverseToInt(main_buffer,2);
	for(int j=0; j < obj_instance_num; j++)
	{
		std::map* cur_prop_map = new std::map();
		//Name of Object
		std::string obj_inst_name = TraverseToString(main_buffer,20);
		//Visible
		int visible = TraverseToInt(main_buffer,2);
		//Int x
		int x_inst = TraverseToInt(main_buffer, 2);
		//Int y
		int y_inst = TraverseToInt(main_buffer, 2);
		//Number of Properties
		int prop_num = TraverseToInt(main_buffer, 2);
		for(int j=0; j < prop_num; j++)
		{
			//Property name
			std::string prop_name = TraverseToString(main_buffer,20);
			//Propety Data Type
			std::string prop_data_type = TraverseToString(main_buffer, 20);
			//User asset?
			int use_asset = TraverseToInt(main_buffer, 2);
			//Asset name
			std::string asset_name = TraverseToString(main_buffer, 20);
			//Property size
			int prop_size = TraverseToInt(main_buffer, 4);
			//Propety value
			unsigned char* prop_value = TraverseToBytes(main_buffer, prop_size);
			Property* prop_temp = new Property(prop_name, prop_data_type, use_asset, asset_name, prop_size, prop_value);
			cur_prop_map->insert(std::make_pair(prop_name,prop_temp));
		}
		CPoint inst_point = CPoint(x_inst, y_inst);
		//ObjectInstance* obj_instance = new ObjectInstance(obj_inst_name, cur_prop_map, inst_point, visible);
		object_factory->AddObject(obj_inst_name, cur_prop_map, inst_point, visible);
		//obj_instance_list->insert(obj_instance_list->begin(), obj_instance);
	}
	//Number of Assets
	int num_assets = (short)TraverseToInt(main_buffer, 2);
	for(int i = 0; i < num_assets; i++)
	{
		//Asset name
		std::string asset_name = TraverseToString(main_buffer, 20);
		//Asset data type
		std::string asset_data_type = TraverseToString(main_buffer, 20);
		//Asset size
		int asset_size = TraverseToInt(main_buffer, 4);
		//Asset buffer
		unsigned char* asset_buffer = TraverseToBytes(main_buffer, asset_size);
		object_factory->AddAssetMap(asset_name,asset_data_type,asset_size,asset_buffer);
	}
}