LionEngine - The Web Site

Introduction

Platform game tools are provided by the lionengine-game-platform module, giving an oriented platform game type development with specific classes and architecture.

In this section we will see how to use these main tools, and the way of we should use them.

---

Advanced entity

The aim of an entity is to represent the player and the opponents, and also general objects which may interact which each of them. An entity can handle a gameplay, by using different states.

• Define the entity states: code

  This is were are defined the different states of the entity (describing its actions)

• Implement the entity with a basic gameplay: code

  The EntityPlatform already includes a standard architecture, including the action definition, movement, collision, and the animation. It can also be configured from an external file.

• Define a scene that will handle your entity and control it: code
• Program test: code

  You can now see the projectile system in action. It is possible to create a more complex system by allowing a weapon switching system, and creating more complex launcher with different projectiles.

  • Complete example
  • And its resources
• Output:

---

Background system

The background is a very important part of any game, as it represents the overall game atmosphere. A good background is not necessary complex, but being able of making complex background improves the chance of making a great game atmosphere.

• Implements your own clouds: code

  This class allows to create a simple parallax scrolling, by controlling each line speed and location easily.

• Create a rastered element for the moon: code

  By using this class base you will be able to add a raster bar effet to the used sprite. This allow to render more colors than the base one.

• Prepare the water implementation: code

  Read carefully how this class is working. We are using BackgroundComponent to add complex element to our background, which will be rendered in the foreground (explained later).

• Implements the full background by using our previous classes: code

  This is the main background container, creating each part of our background. The complex middle parallax is simply done by using the Parallax class. Our implementation add a simple backdrop (gradient color).

• Define a scene that will handle your background and move it: code
• Program test: code

  You can now see the background system in action. You can see that we are using different class for the background, which are used in a single main one. This way it is easy to choose what we want to use and how.

  • Complete example
  • And its resources
• Output:

---

Advanced tile system

Collisions are not the easiest part in a game, as they me be tricky to define, even for a simple game. Hopefully, the integrated architecture already does a lot of for us.

• Define the different collision types: code

  This is were are defined the different collision types (such as ground, slope, spike...)

• Implement the default tile: code
• Use the tile collision editor to define your collision:

  final TileCollisionEditor<TileCollision, Tile> editor = new TileCollisionEditor<>(new Map(), TileCollision.class);
  editor.start();

• Create a simple map that will handle the tiles: code

  The map is responsible in tile creation. This is from this object that we will be able to access to the tiles.

• Implement a simple entity to test the collision and display them: code
• Define a scene that will show the collision in action: code
• Program test: code

  You can now see the projectile system in action. It is possible to create a more complex system by allowing a weapon switching system, and creating more complex launcher with different projectiles.

  • Complete example
  • And its resources
• Output:

---

Map collision

This example will show how to completely use the collision from an entity to a map and its tiles. It will also show how group collision by category for a better accuracy.

• Define the entity collision: code

  This is were are defined the different entity collision types (such as ground, slope...)

• Define the different tile collision types: code

  This is were are defined the different collision types (such as ground, slope, spike...)

• Define the entity collision category: code

  This is were are defined the different entity collision category (such as center, knees, hands...)

• Implement the entity that will also define its collision and set them: code

  Collision groups will be used here.

• Use the LionEngine Editor to define your collision:

  final TileCollisionEditor<TileCollision, Tile> editor = new TileCollisionEditor<>(new Map(), TileCollision.class);
  editor.start();

  
• Create a simple map that will handle the tiles: code

  The map is responsible in tile creation. This is from this object that we will be able to access to the tiles.

• Define a scene that will show the complete collision in action: code
• Program test: code

  You can now see the projectile system in action. It is possible to create a more complex system by allowing a weapon switching system, and creating more complex launcher with different projectiles.

  • Complete example
  • And its resources
• Output:

---

Tutorial Mario

This full tutorial will show how to create a simple prototype of mario, with a scrolling map and its collision, plus some additional entities and their interactions.

Tutorials are splited and sorted by letters, starting at "a" package.

• Complete tutorial
• And its resources
• Output:

Read next page: Strategy games