The Basics of GameObjects

The Basics of GameObjects

Content of this chapter:

1. What is a GameObject
2. Default Components
3. Moving a GameObject
4. Additional info, tips and tricks

What is a GameObject?

A GameObject is...

• a ComponentParent, which means that it can have Components and that it has a Transform (-> A Vector2f position, Dimensions and a Rotation)

• Drawable, which means that it has the method draw(SaltyGraphics), which is called on every repaint for drawing it

• a FixedTickRoutine, which mean that it has the method onFixedTick(), which is called every fixed tick (e.g. 10ms, look at the basics chapter for more info (!TODO: Write wiki-chapter about the basics!)) and can be used for game logic

• CollideAble, which means that it has the method onCollision(CollisionEvent), which is called whenever it collides with another GameObject

• InitializeAble, which means that it has the method initialize(), which is called once after the GameObject was added to a Scene. It's important to use this method for as many initialization processes as possible instead of the constructor, because it is called after the Scene is the current one, and after the GameObject was fully added to the Scene

GameObject has multiple constructors, but all aim to have the Transform of it, for example like this: float xPos, float yPos, float width, float height, as well as a tag. This is a String and can be used for processing collisions. An example for a tag would be "de.edgelord.superGame.player", or just "player". It is highly recommended to store those tags as static final Strings in e.g. a separate class called "GameObjects" or something, so you don't have to use magic values.

Default Components

Every GameObject has three default Components, these are:

• a SimplePhysicsComponent for some simple physics like acceleration and stopping on collision
• a RecalculateHitboxComponent, which recalculates the position of the default Hitbox
• a HitboxCollider, which detects collisions from the default Hitbox

Moving a GameObject

Using the default SimplePhysicsComponent, you can accelerate the GameObject in a somewhat realistic way, because after the acceleration is gone, the velocity of the GameObject will slowly fade out. The SimplePhysicsComponent is powered by Forces. A Force has a name, a Direction and an acceleration as well as a velocity. You can add Forces to the SimplePhysicsComponent using the method addForce().

You can also accelerate with GameObject#accelerate(float, Direction), and accelerate to a specific velocity directly using GameObject#accelerateTo(float, Direction). With the latter, there will be no velocity fade in, nor fade out, which is the better choice for most games. Using this methods, you would have to call them periodically, because their acceleration or velocity (depends on which method you use), is reset each fixed tick. Just experiment a bit to find out the perfect way of using it for your game. You could try an acceleration of 2500f and adjust from there.

Direction is an enum within the class Directions. There are four values:

• Direction.RIGHT
• Direction.LEFT
• Direction.UP
• Direction.DOWN

You can also use these two methods with a Directions (notice the "s"!), which has a collection of any Directions (notice the "s" being outside of the code-block!). Knowing this, making the player control can be very easy, here is a short example:

private final float speed = 2500f;

// ...

@Override
public void onFixedTick() {

    accelerateTo(speed, Input.getInput());
}

Input.getInput() returns an instance of Directions with all the Directions that the player is currently inputting. For more information on that, please read the page about Input

Additional info, tips and tricks

• For GameObjects like obstacles, you can set it to stationary using setStationary(boolean), which increases the performance noticeably in bigger scenes. The documentation of this feature:

If this is set to true, this GameObject will not have a collision detection. Use this for
stationary objects like obstacles, houses and generally all kind of GameObjects that
aren't moving, due to heavy performance improvements.
Whenever the  GameObject#onCollision(CollisionEvent) implementation is empty, set this to true
to improve the performance of the game a lot. Other GameObjects still collide with this one then,
but this one will never collide with others which is redundant when the onCollision(CollisionEvent)
implementation is empty.
Please note that gravity and other forces won't take effect on stationary GameObjects

• You can add Components to a GameObject by using GameObject#addComponent(Component), remove one by calling GameObject#removeComponent(Component) or GameObject#removeComponent(String) and get one by its name using GameObject#getComponent(String) for more info on that, please read the chapter about Components. (!TODO: Wiki chapter about components!)

• every GameObject has a mass. This float-value effects the physics. You can set it using GameObject#setMass(float). The default value is 1f.

• GameObject has a method called onCollisionDetectionFinish(List<CollisionEvent>), which is called every fixedTick, when the collision detection for this GameObject is finished. You can override this method for handling collisions in a more complex way, e.g. for seeing if this GameObject is catched between two others. For more info about that, please read the wiki chapter about collision detection and handling (!TODO: Write wiki-chapter about collision detection and handling!)

• you can also move a GameObject directly by using the methods GameObject#move(float, Direction), GameObject#moveY(float) and GameObject#moveX(float), but then, it may move into other GameObjects, so for in-game moving, please use the method described above.

• if you want to have the initialize() method called again at any point, you only have to call GameObject#setInitialized(false)