quiver-dev / template-beat-em-up Goto Github PK

Create 2 or 3 different types of enemies using the same systems as the player character but with some basic AI behaviors

Also create one boss to show the difference between a normal enemy implementation and a more complex enemy implementation

Saving Highscores, player progression in "story mode", extra unlockables or things like that.

Have the damage calculation and any other logic that uses the Character Attributes for combat in a separate file/entity that both Player and Enemies can consume.

#8
The Skin should take care of the "visual" part of the character, and have a public interface to allow for controlling animations as well as signals to give information back to whoever might need it.

As each actual character skin will have many peculiarities the Base Skin should be a scene with not much, just the really essential stuff:

• AnimationPlayer
• AnimationTree
• Logic for changing animation states, maybe just "virtual" functions

Maybe it could actually be just a script with the AnimationPlayer and AnimationTree dependencies, as inherited scenes with AnimationPlayers can get messy if you're not saving the animations correctly or if you inherit from another character skin instead of the BaseSkin.

For now I think I could move some properties that are on the states like Speed and Jump Force to this Attributes Resource, and add health. This should be enough for now as This Resource will grow as we add more features to the template in general

Related to #7

Support for loading things in the background, both in a "invisible" way as well as reporting percentages for Loading Screens

It sure would be useful, but we want this on the template at this time or not?

The Base Character Scene should be very simple at this point.

It needs to have a Skin dependency and either a basic StateMachine with a single Idle State or a StateMachine dependency.
For characters I think it's important to make them all inherit from the same base scene as we can then have somewhere we can add or change functionality for all of them.

Don't know if the template needs this or not, depends on how complex we want to get.

But if we add things like poison bombs/pools or molotovs/flame throwers, we might want to have short status ailments affecting players?

Right now I disable collisions while jumping so that the player can jump beyond the "upper" limit of where they can walk.

But just disabling collisions makes it possible for them to ignore lateral walls as well. So instead of disabling all collisions I should have some sort of "ceiling" Collision Layer and toggle collisions only with that layer

Use the systems created (skin, behavors, attributes) to create two different characters as an example of how the user can use and customize this systems

Have an easy way to add/configure difficulty modifiers for attributes
Maybe also to tweak enemy AI
If easily configurable, could become an assist mode, beyond just easy/medium/hard/very hard?

To be used for heavier scene changing. Should use the Transitions System to get into the loading screen and out of it, and also the Resource Loading System to do the actual loading

Could be a part of the Resource Loading System but I worry a bit about coupling functionality in it that is not really it's responsibility, as the Resource Loading System can be used to load anything, not just stage scenes

Create a generic call_state or call_action ai state so I can call any attack (or other state) from the "actions" state machine.
Also, to that in a better way, try to use advanced custom properties to generate a list of possible actions and select them in the inspector

Character will need Reusable "Blocks" of logic, which will probably be States in a State Machine.

Requirements:

• Should be usable by player character as well as enemy AI
• Interact with a "Skin" System that will handle animations
• Implemented characters should have examples of behaviors the user will want to use in his game like:
  • combos
  • combo variations for different context (ex: air combos)
  • being able to cancel or interrupt actions in favor of higher priority actions (like specials)

Related Tasks

• #44
• #45
• #46
• #47

Areas can have Hazards like bottomless pits, flame throwers, electric cables, poison pools, you name it.

Create one or two examples of hazards and how to place them on levels?

I think hazards can have art or not. For example, bottomless pits will usually be integrated in the background art, so the hazard that makes it work should just be an area.

A electrical cable might have it's own art or might just be an area over an animated part of the background

A demolition ball can be interacted with so it should be a hazard that has it's own art and special "logic"

For the example hazards I think at least the bottomless pit is necessary, the others we can see as we go?

Use this issue to go through githubs documentation to learn how this thing works and how I can use it to help me. Or if I want to use it.

Should have it's own persistence
Needs to be able to:

• set audio properties (sound, sfx, volume for each of these)
• set video properties (at least fullscreen or window mode)
• Language Settings (if we choose to have basic localization support on the template)

This ones are simple objects that have a health and when destroyed spawn a pick up item

As usual should have a base scene with this functionality that can be inherited to be customized.

So the player can choose to play any individual stage on it's own, if they have already unlocked it on story mode.
Tracks best score for each level

I think rather than being a "system" it could be just simple examples of how to do a animated sequence that can be skipped
Also as an example of how to play them at beginning/ending of stages.

This part any game could be wildly different, one can choose to play videos rather than animate cutscenes in godot, or one could want to have interactive dialogue cutscenes integrated with plugins like Dialogic, so we just need to show how to load a scene before/after an Area and how that scene needs to integrate with StageHandler and other parts of the game.

Things like:

• How many points the player should get for each action
• End Level multipliers
• How Combo multiplier works
• Does the player get some reward after some specific score?
• Also in the code, an easy interface for character actions to interact with and give points
• Probably also under this system, or at least closely related to it, a UI to show the current combo and it's "grade" in a flashy way?

Just a UI to show/consume the Settings/Options system

A class or scene template to base character skins on.

This scene should be able to handle everything related to animations and integrate/be used by other systems

Related Tasks:

• #42
• #43

This one will be a little more complicated as it involves:

• Making the player behavior and animations change based on weapon picked
• New actions for player like throwing weapon
• Weapons themselves probably need to use the Attributes System
• They must be "equipable" and follow player animation (probably something with a RemoteTransform2D?)

This should Inherit the BaseCharacter Scene.
Then we add in the skin we created and add basic movement logic with player input.

Requirements:

• should consume some kind of resource, be it "tokens" (like stars in SoR) or a special bar (like River City Girls)
• integrated with Behavior Blocks/States or a "specialized" Block/State

Have a base scene for pickups that the player recognizes, can interact with, and once interacted give an effect and disappear

Then create some variations inherited/extending it:

• Health pick ups
• Poins pick ups
• Special resource (stars in SoR4, this one only needed if the special will be based on tokens)

Also, don't know if we want to do this or not. It might be cool as a "module" of the template which you can use or not, or as a simple example of how to do it.

There are Beat em' ups that have progression systems, like the River City Franchise, but the more "Arcade" one usually don't have it.

Usually should follow player but should have support for limiting the "battle stage", either by preventing the player from going back or by locking position until a requirement is met (usually, clearing all enemies)

Should also have some for of "collision" with its "edges" or "walls", to prevent enemies from going off screen once they are in screen and allow for more possibilities of combos by bouncing enemies back off it's "walls"

• Should recognize user device (keyboard/mouse or what kind of controller)
• Change Input Hints accordingly
• Have support for input mapping

Probably should make available a ready to use Input Hint scene that already uses this system and the player just have to select with "input action" he wants the hint to show. I already did this for my game on steam, and shared the repository that does this as a library on github. It is under MIT license so we can use it as base but it's old code and for Godot 3 so it would have to be updated.

Always starts at stage 1
Saves player progress between level and allows player to continue from it

Attack must be at least a One-Two Combo, so we can start exploring on how to make this reusable to build more complex combos later

Also try to refactor them so that they can be more "generic"
Make things like states you're changing to into export vars or advanced export properties and see if we can use "Generic" scripts most of the time

Character Attribute System must contain things like

Basic Attributes

• Health
• Strength
• Speed

More Complex Attributes

• Weight? (Might be more like "weight category" like light or heavy, to determine things like bounce and throws)
• Superarmor ?
• aggression level ?
• stun/stagger properties?

Always start on stage 1
No continues, if you lose all your lives it's "permadeath"
Level Scores are added up to a general Score

With a basic player scene that can move and attack, now we can start our enemies.

In this task see what needs to be adapted in the states so that an AI controlled entity can reuse them. If we can reuse the same exact state even better, but I guess it would be fine to have a collection of "Player States" and a similar collection of "AI States"

For transitioning to and from any scene

It must be a scene that can easily be inherited and extended to create new Stage Areas.

An Area must have a background the player must advance through and one or more "Rooms".

"Rooms" are sections of the Area where the camera will be locked and enemies will be spawned and the camera will only be unlocked once all enemies have been cleared

This scene should have some logic every area will use, to facilitate delimiting Rooms, spawning enemies, knowing when each room is completed and knowing when the area itself is completed.

Don't know if this should be a part of the template but it could be nice to have a placeholder place to add unlockables like:

• Art Galleries
• Credits (could go in the options as well or even the Start menu)
• Character Info

Scene to be used on game Areas to spawn enemies

Might not be needed at first, and we may just put the enemies directly on the scene, but if the player wants to do a big area, with lot's of Rooms and lot's of enemies, it might be better to not have them all loaded with the level, and let spawners load and spawn enemies as needed

Would also be good if the spawner could have a preview of the enemy you choose, and some options like "initial state", "initial direction" and "initial speed" to be able to spawn enemies that "jump" into the Room, but maybe this could be an "extra" feature if we have the time?

Should inherit the BaseSkin Scene/Script
Add placeholder art and one frame animations just so you can use this system instead of having to refactor later

There are many kinds of "collisions" and we should have a good example of how to organize and deal with them:

• Using physics layers
• Have HurtBoxes and HitBoxes
• walking through characters/grabbing
• Bouncing from walls and floor

A Stage is a collection of "Areas".
I'm thinking of implementing it as a Resource that can take an array of "Area Scenes" and can be used by a "StageHandler" singleton to load them in order as the player goes through the areas and shows the end screen once it reaches the end of this array.