chamons / arenags Goto Github PK

Instead of jerking.

MapScripts?

A multitude of tiles / arenas / decorations.

If a view is not invalidated, no reason to re-draw it. We can just return the view's surface.

• Each actor as a CT associated with them that decreases as actions are taken
• Engine cycles all actors increasing until one hit a limits and goes
• Some player actions will not consume a turn (cancel for example)

We should animate the following at least:

• Projectile skills

And possibly the following

• Characters moving

We are doing at least one dictionary lookup, since we don't know the theme until paint.

If we restructured things, this could be more efficient.

MapTileVariants is looking up the byte [] in a dictionary for every cell. This isn't super fast.

However, since the mapview gets a "new" map every draw, and does not know if it has changed or not, it is hard to safely do much faster without getting ugly.

We should improve this if it becomes a bottleneck.

Some reduced ct cost.
Some happen later and ct doesn't recharge until done.

• Movement to start out with, then all new features as they happen

Can you use while recharging?

Bleed
Slow

Review all usages of static.

Right now we have ugliness like this:

		Skill skill = character.Skills.First (x => x.ID == script.SkillID);
		state = state.WithReplaceCharacter (character.WithReplaceSkill (skill.WithCooldownReduced ()));
		character = state.UpdateCharacterReference (character);
		skill = character.UpdateSkillReference (skill);

		if (!skill.UnderCooldown)
		{
			state = state.WithRemovedScript (script);
			if (skill.Resources.RechargedAmmoOnCooldown && skill.Resources.CurrentAmmo < skill.Resources.MaxAmmo)
			{
				state = state.WithReplaceCharacter (character.WithReplaceSkill (skill.WithIncrementedAmmo ()));
				character = state.UpdateCharacterReference (character);
				skill = character.UpdateSkillReference (skill);

				if (skill.Resources.CurrentAmmo < skill.Resources.MaxAmmo)
				{
					state = state.WithReplaceCharacter (character.WithReplaceSkill (skill.WithCooldownSet ()));
					skill = character.UpdateSkillReference (skill);
					character = state.UpdateCharacterReference (character);
					state = state.WithAddedScript (Generator.CreateCooldownScript (0, character, skill));
				}
			}
		}

with the root of the problem being stale references to characters / skills after the game state mutates.

This is ugly, error prone, and almost worst than if it was all mutable.

The plan is as follows:

• Create a type safe ID holder, so we don't confuse ID with ID, since they are all int under the hood.
• Convert most/all internal APIs used on the engine to take ID instead of character/skills/etc.
• Rename Collections on GameState from Foo to FooCollection. Create nice APIs to easily lookup the object based on ID.
• Nuke UpdateFooReference APIs
• Convert tests to use them in most cases. Where it can't, we can use {} to limited scope.
• Reevaluate as we go.

• Display on each skill remaining ammo/cooldown

Some skills want you to be able to go diagonal like movement and moveanddamage, but int ranges don't work there.

In addition to the ammo/cd system, should we have secondary resources systems?

• Combo points
• Builder/Spenders
• Procs for abilities

• MapTileVariants is terrible in allocating byte arrays \ rng
• MapThemePainter is allocating a string for every map tile when we look it up. :(

How wasteful is the immutable gamestate?
How many GCs are we running when you run across the room?

https://github.com/Clancey/gMusic/blob/master/MusicPlayer.OSX/Helpers/NGraphicsExtensions.cs

Since there are no bump attacks, for basic interactions we'll need

• Action bar
• Targetting

Pool that recharges every turn.

We'll need enemies to chase the player.

We have test code like this:

	state = state.WithEnemies (state.Enemies.Select (x => x.WithAdditionalCT (Time.CTNededForAction)).ToImmutableList ());
	closest = state.Enemies.First (x => x.ID == closest.ID);

Where we have a enemy of question, update the world, and have to re-get them to do stuff. If we forget, we get stale data. This is terrible.

We need to resurface all Skill and Physics APIs to take an actor ID, not the reference itself. We also need nice APIs on GameState to look up via this ID.

• Serialize state and load back
• Write save file in OS friendly location
• Close window saves before exit
• Startup looks for save and loads it if exists (and then deletes)
• Allow "quit" button to quit without saving