jwmccowan / rpg Goto Github PK

Create an input controller that will allow classes to register to it to receive notifications of.. well.. input..
I'll post more details in comments as I develop the idea further.

Component that calculates hit bonus. Right now we have it as its own stat, but we will probably remove that, or at least ignore it, and will calculate it dynamically. This will allow us to attach vce for eg being flanked or point blank shot.

Character sheet should instantiate its own stats, since you can't have one without the other. Maybe this will change, we'll see.

Model a 'turn'. It will know information like, who's turn is it, which will also include all their abilities, location, etc. Also will include what they have done and what they can still do. Right now, I'll model a standard action, a move action, and a full round action.

We need to create a way to store states in our game, both in a macro sense, such as if we are loading, battling, or walking around a map, but also in a micro sense, like states to micromanage the parts of a turn.

Make a pathfinding algorithm in the Board class to highlight reachable squares within a certain range. Let the range and what constitutes "reachable" be sent in through a delegate.

The notification system will exist such that:
-Any client can register as a listener using a string as the message key
-The client send in a 'callback function' that takes the sender as the first parameter and a object (args) as the second

This will be the start of an input controller, so that states can uniformly react to movement, but will also come in handy when it comes time to implement stats, stat changes, and exceptions

Add a few sprites to liven up the place. TBH, I got a few assets from the asset store and implemented them, it looked really cool having a knight walk around the board and attack and stuff, plus a way nicer sky box, before realizing I can't host that stuff on GitHub. Bummer. So until I learn how to model and animate (might be a while), we'll just improve the tiles. I commented out the animator triggers lest we forget.

Here will be an initial implementation of calculating damage. As the stats are currently in flux (and the architecture of the stats reflects that for ease of changes), this is liable to change in the future. The plan is to make it flexible enough to conform easily to most changes.

Just a quick wrapper class for HP, using class levels

Create a component that holds Unit specific information. Right now that will just include directions and some functions regarding position, but it will expand as the game logic grows

Create a reusable set of UI anchor based on the native Unity anchors to speed up UI development, and a Panel class we can extend for all of our menu panels

This issue represents the conversion from Pathfinder to Avatar style bending, to be closed when we reach the same level of functionality as the last checkin to master, but removing all Pathfinder specific details and replacing them with bending. Confused? Read on...

Alright, so as I was making this project, I realized the vast number of options for Pathfinder was getting crazy to implement, which is kind of fine, but the UI would be a bit too much for a team of one who just wanted a nice simple fun game.
Which led to two possible options, simplify pathfinder (I would never), or come up with my own ruleset. I have chosen to do the latter.
Inspired by Avatar: The Last Airbender, I have decided to make a bending themed tactics RPG. You will be able to choose the stats and fighting style and element of your character, and there will be other characters with their own stats and fighting styles (and for some, elements).

The rule set is still being decided on, but in general, we will use:

• Four ability scores (for now): Might, Mobility, Constitution, and Perception
• Two (maybe three) defenses: 1 for blocking regular attacks, 1 for blocking mental attacks
• Might represents magnitude of abilities, such as damage dealt or healing healed. Also contributes to Resolve Defense
• Mobility adds to Physical Defense, increases initiative bonus, and somehow will help movement speed
• Constitution affects HP as well as Resolve Defense
• Perception affects accuracy as well as Physical Defense
• Attack Roll for to hit. Thinking a D100 but maybe D20
• Crits will be based on rolling above a threshold
• Basic attack (unique to the character) plus abilities as you level up (each character can choose from certain abilities)

Everything else is still being developed.

A UI to show character stats (not sure which yet).

A start to having class levels. This will obviously be a work in progress, so lets put a 'done' condition on this. Once we have the ability to attach class levels that provide stat bonuses, with room to attach other things as well (abilities etc). Now we gotta decide whether we want to support multiclassing. There's quite a bit of decision making to do actually. Check the branch to see what we decided, and I'll comment when I think about it.

These are temporary (or not) status effects that change stats. The start of feats.

Create another panel, a bit like the conversation panel, that is navigable and sets the battle state accordingly. We'll have some placeholders for attacks and such for now, and just implement movement.

When equipping an item requires unequipping more than one item, only the first item is unequipped.

Create an object pool class that can create gameObjects of a type, and pool n amount of them, depooling as required.

-Each poolable gameObject needs a 'Poolable' component
-Our pool data controller will map a string 'key' to a pool, so that we can have one pool controller instead of one for each type of item
-This pool data controller will persist between scenes (Singleton and dontdestroyonload)
-Pool data controller will create gameObject if it does not exist

We saw shadows of it in the last feature, but its time we use a dice rolling class of some kind. I'm thinking an instantiated object, so that we can store them in class object (hint that's next) but with static roll method so we can roll whenever.

Create the general idea of equipment, and with it, attachable bonuses. Right now we can change stats, but have no framework to make those stats stick (well, they stick just fine, but we can not track and un-stick them).

Get to it!

Highlight and track the tiles in range of a unit's ability. Good first start.
We'll do:
-Constant Range, like an archer (or technically melee)
-Cone
-Line
-Self

A user can program conversation assets, and use a conversation controller to show conversation panels. They should be configurable with custom speaker sprites. A further wrapper that uses characters instead of sprites is outside the scope, might be implemented later.

Our little characters need to be able to move around the board. In order to do this, we will need some sort of pathfinding for our pathfinders. Movement is normally 30 ft, but for now we will default to something smaller to fit the board, but make it configurable.

Action items:
Pathfinding algorithm on the board itself, so we can query reachable tiles within range.
Movement components that can be added to a Unit
Which means a Unit component to attach to our heroes

We will build a movement component that can be inherited. This component will be able to query the board for a list of reachable tiles, and will hold the delegate to send to customize the algorithm.

Implementing stats! The backbone of any RPG! I am still going back and forth on how to implement them, so bear with me time wise.

This will require a few objects. We have already made a Point struct, which will hold location data.
-Tile.cs: simple class, will know it's own location and if anyone is on it. Also knows its prefab
-Board.cs: will hold data of all the tiles and probably and searching that needs done. That might move.
Will comment as I make more classes.

The beginning of getting usable abilities on our green blobs.

Initiative controller - tracks initiative and controls turn order