Full LibGDX Game Tutorial – Entities using Ashley(ECS)

Sharing is caring!

Full LibGDX Game Tutorial – Entities using Ashley the ECS

Welcome to part 10 of our Full LibGDX Game Tutorial. This part will focus on improving our current system by using Ashley an Entity Component System. If you haven’t seen the earlier parts of this tutorial I advise you to start at Full LibGDX Game Tutorial – Project setup as this tutorial continues from these earlier parts. For those of you who have come from part 9, you can continue on.

We currently have a system in place that allows us to start loading our assets, which then goes to a menu and from there we can start the game. The game so far allows us to control a player character to some extent. This current system is hard coded and makes it difficult to update with new features and new mechanics. This is where the Entity Component System (ECS) comes in handy. The ECS will allow us to break our game model down into sections that can be easier to maintain and modify. Our model will be broken down into Engine, Systems, Entities and Components. How are we going to do this? you ask. Well, we’re going to use Ashley the ECS  designed to run with Libgdx. The Ashley wiki contains more information on the ECS than this guide will go into available here.

Ashley

As mentioned earlier Ashley breaks the model down into Engine, System, Entities and Components. The Engine is the controller that will run they systems we define. It will also control the creating and destroying of systems, entities and components. In games we have different sections that require logic such as rendering images, physics, collisions etc, this is where the Systems comes in. We will use a system for each area of logic. So we will have a Rendering system which solely focuses on rendering textures. Next, we have components. Components are simple classes which store data such as an image or the position of our player and finally, we have our Entities. The Entities will be a collection of components used to define an in-game object.

For example, we have a player entity which has 2 components: ImageComponent(stores an image) and PositionComponent(stores the player position). Next, we have a RenderSystem which takes any entity that has an ImageComponent and a PositionComponent and then renders it. We tell our engine to make the entities and tell the engine that it needs to run the render system. Now When our engine runs any entity created that has an ImageComponent and a Position Component will be drawn. We can then create another entity this time an enemy with an ImageComponent and PositionComponent and it will automatically be added to the render system and rendered. We can then add new components for animations, AI, collisions and add their respective systems until we have all our game logic defined.

Adding Ashley to our project

To add Ashley to our project we are going to update our build.gradle file for our box2dtut project. In our main project box2dtut, scroll down to the build.gradle file and open it. Update the repositories to match this code:

Next, add the Ashley compile code for each platform as shown below:

Refresh the grade dependencies for each project to make sure that Ashley has been added. Ashley should now be added and you can continue to add the code.

Creating A Component

The first thing we’re going to do now we have Ashley ion our project is to define our Components. Components are classes used solely for storing information for a specific set of data. Our first component will be for storing our positional data. So let’s make that now.

That’s it.  A simple class that implements the Ashley Component interface and a few values. Cool, now let’s add a component for a texture:

Yay, another easy one….Well, they’re all easy as these are only for holding bits of data for our entities. Here are all the other Components we will be using:

That’s all the Components currently needed in our game.

Systems

Let’s move on to doing a system which will be used to render our entities. Our system will loop through all entities that have the TransformComponent and TextureComponent and then use the data in these components to draw the texture in the correct location.

This code was adapted from code created by Barry @ https://github.com/RoaringCatGames to fit into this tutorial. I have added comments on all the parts I think may need explanation. Basically, this system will get all Entities that have a TextureComponent and a TransformComponent then loops through each one and draw it to the screen using the SpriteBatch.

In order for this system to work, we need to create the ZComparator system which is:

Now onto all the other systems used:

I’m sure a lot of you are thinking about how much code I just spurted out just now. But be assured this code is laying a foundation for us so we don’t have to write as much code later and our code is nicely organised into specific areas which allow us to add/remove/update new features later with minimal hassle.

Adding the Engine

Now we have all the components and systems in place we can make a start on removing the model and adding our Engine in our MainScreen. Since we are no longer using the model we need to add all the necessary parts used in the model to our main screen. this includes things like the sounds, atlas and the box2d world. Update your MainScreen constructor to match the following:

Here you can see we moved all the required items to our MainScreen and added some new stuff. The first new item we added was the RenderingSystem. This is the RenderingSystem we just added at the start of this chapter. Next, we created a PooledEngine. This is supplied by the Ashley system and the Pooled version reuses objects instead of creating new ones reducing lag from Garbage Collection. Then we continue to add all our other systems we made and finally we create some objects in our world, a player and some platforms. The code for these objects is in the next section.

Adding Entities

We got components, systems and engines, but no entities. Let’s fix that now by adding them. As you seen were adding them using these 3 methods; createPlayer(), createPlatform(x,y) and createFloor(); The createPlayer() method below shows how we add a player entity:

Here we first use the engine to create and empty Entity. We then use the Engine to create all the components that make up the player entity. We then create all the data that fills up the components such as image, position and box2d body. Next, we add the components to the Player Entity and finally add the player Entity to the engine.

The createPlatform(x,y) and createFloor() are pretty much the same as above but they require less components. Code below:

There’s one more thing to do before our game will work and that is to update our Box2dContactListener to update Entities when they contact other items. The new updated Contact Listener is:

Here you can see we got rid of all the bloat and now only need to update the entity collisionComponent when something is hit.

Before we can run this code we need to update our MainScreen’s render method to make the engine run.

 

You should now be able to run the project and control the player and make it jump on the platforms.

As usual, the code for this part can be downloaded from StorMyVids here.

In the next part we will add infinite level generation using simplex noise.

← Scene2D

— Contents —

Simplex Noise Level Gen →

 

Sharing is caring!