There are different types of actors in a game. In LibLOL, there are some pre-defined kinds of actors, and they have certain behaviors and properties attached to them, as described below:
The hero is usually, but not always, the focal point of the game. Whenever a hero collides with something, it's probably important: it could be an enemy that causes harm to the hero, an obstacle that re-enables the hero's ability to jump, a goodie to collect, etc.
Every hero in the game has a certain amount of strength (initially set to 1), and when a hero's strength drops to 0, that hero is removed from the game. If all the heroes are gone, then the level ends in defeat. You can also specify that once a certain number of heroes are gone, the level ends in defeat, to capture the idea that you need to keep 3 of 5 heroes from being defeated.
Heroes are usually the focal point for controlling the movement of the game. In tilt games, the hero usually moves with the tilt of the phone, and otherwise there are usually buttons for making the hero move, jump, and duck. But that's not always the case. For example, sometimes it's useful to have an invisible enemy at the bottom of the screen, with enemies falling from the sky.
These are the "bad guys" in a game. They have an amount of damage assigned to them, so that whenever the hero collides with the enemy, it loses strength. Strictly speaking, when a hero collides with an enemy, we check if the hero strength is greater than the enemy's damage value. If it is, the hero's strength decreases and the enemy disappears. Otherwise, the enemy's damage decreases and the hero disappears.
Enemies can take all sorts of forms and shapes. An invisible enemy at the bottom of a pit is a good way to detect when the hero fails to make a tricky jump. Every fireball shooting from the dragon's mouth is probably an enemy. Spikes and fires are probably enemies. And actors who move around and get in the way of the hero are often enemies.
There are a few ways to defeat an enemy. As described above, you can defeat an enemy by colliding it with a hero, as long as the hero has more strength than the enemy has damage. Enemies can also be marked so that they are defeated by colliding with a hero who is crawling or jumping (in which case the hero strength does not change). By default, an invincible hero will defeat any enemy it touches (but you can disable this for certain enemies). It's also possible to defeat an enemy by throwing projectiles at it, or by colliding it with an obstacle that has a collide callback. Naturally, you can find examples of all these behaviors in the levels of the sample game.
This might sound trite, but when in doubt, consider using an obstacle. Obstacles in LibLOL have grown from being static objects like walls and floors into being the primary mechanism for handling callbacks. By using the "toggleCollisionEffect", you can make it so that your obstacle doesn't impede the movement of other actors, while still causing a callback to run. There are many pre-defined callbacks (such as for boosting a hero's velocity when it collides with the obstacle). When you can't find the behavior you need, your next best bet is to use a collision callback. You can use these to defeat enemies (by calling remove() on the enemy), to win or lose the game, to change the score, etc.
In another post, I'll talk about how to make "infinite" games by using collisions with obstacles as a way to know when to draw the next part of the level.
Goodies are things that the hero collects. As a hero collects goodies, they disappear, and they get added to one of four score counters. It's possible to use these score counters as a way to activate destinations, or even to win the game ("win by collecting two apples, a banana, and six celery"). Goodies can be configured to increase the hero's strength, or to cause the hero to become invincible.
Projectiles are things the hero throws. Normally, the idea is that the hero throws projectiles at the enemy, to defeat it. But don't let that get in the way of being creative... perhaps the projectile is a basketball, and the enemy is an invisible spot in the middle of the basketball hoop, so that each successful basket gets counted via the mechanism for defeating enemies.
If we made a projectile every time a projectile needed to be thrown, we could end up making thousands of projectiles. That would be inefficient. Instead, LibLOL has a projectile pool. Once you've configured the pool, any attempt to throw a projectile begins by choosing one from the pool. This is more efficient when your game is running, but it saves you code, too, since you can configure a pool once, and then avoid configuring each projectile that is thrown.
Projectiles always are thrown by a hero, and they depart from some point on the hero's body. The offset parameters to the pool specify where the projectile should start.
When throwing a projectile, there are two techniques: you can either throw at a fixed velocity, or you can throw at an angle. This latter technique is very nice: when you press the screen, the hero will throw toward the point that you pressed. By altering the projectile gravity, and by modifying how it behaves upon collision with obstacles, you can achieve projectiles that behave like bullets, grenades, and basketballs, to name a few.
Some games, especially mazes, require a hero to reach a destination. In LibLOL, there is a special actor for this. Destinations are pretty simple: they can hold as many heroes as you allow them to hold, and they can be configured so that they don't hold any heroes until a certain score is achieved (a certain number of goodies are collected).
Depending on when you read this document, there might be an actor type for SVG lines. If so, ignore it. It's going away soon.
There are behaviors and properties that are common to all actors, like animation, route-based movement, and collision callbacks. Be sure to look at the LibLOL JavaDocs for more information.