Changes for GameProgress and its Persistent sibling

[programaker]

Writing the tests for the Game Steps that require a GameProgress made me think that this class is not so well designed - for example, Gen[GameProgress] is using GameProgress logic, which means code that need to be tested is being used as input to other tests =/

[programaker]

Ideas:

• Make it a pure data class, no behavior.
• Encode the behaviour through type-classes (?) (see if cats can help).

Current data:

• mainCharacter: MainCharacter
• mainCharacterExperience: Experience
• invasions: List[Invasion] // these are the required ones; there are some derived data for optimisation purposes

Current behavior:

• invasionByIndex: Index => Option[Invasion]
• isInvasionDefeated: Index => Boolean
• increaseMainCharacterExperience: Experience => GameProgress
• allInvasionsDefeated: Boolean
• defeatInvasion: Index => GameProgress

[programaker]

New ideas:

• Make GameProgress a simple ADT, no behavior.
• Its current behaviors are only needed in specific Game Steps; move them to the Steps.
• Turn GameProgress into a sum type, reflecting its state transitions (start, battle, mission accomplished, ...). This change can eliminate some data structure manipulation (even the structures themselves), increase type safety and improve PBT data generation (less worries about consistency).

[programaker]

/* typeclass? object? distributed through app? */
//
//invasionByIndex: Index => Option[Invasion]
//invasionDefeated: Index => Boolean (move to HumanArmy as a kind of battlefield report)
//allInvasionsDefeated: Boolean (actually will be just a gameProgress match)
//defeatInvasion: Index => GameProgress (move to HumanArmy as: City.Invaded => City.Free)

sealed abstract class GameProgress extends Product with Serializable

object GameProgress {
    //invasionByIndex: Index => Option[Invasion] = cities.get(index)
    //invasionDefeated: Index => Boolean = false
    //allInvasionsDefeated: Boolean = false
    //defeatInvasion: Index => GameProgress = GameProgress.InBattle(...)
    final case class Start(
        mainCharacter: MainCharacter, 
        cities: Vector[City.Invaded]
    ) extends GameProgress

    //invasionByIndex: Index => Option[Invasion] = cities.get(index)
    //invasionDefeated: Index => Boolean = cities.get(index) then match 
    //allInvasionsDefeated: Boolean = defeatInvasions === cities.size
    //defeatInvasion: Index => GameProgress = GameProgress.InBattle(...) | GameProgress.MissionAccomplished
    final case class InBattle(
        mainCharacter: MainCharacter,
      cities: Vector[City], //cities invaded and free mixed
      defeatedInvasions: Count
    ) extends GameProgress

    //flag indicating the end of the game
    //invasionIsDefeated: Index => Boolean = true
    //allInvasionsDefeated: Boolean = true
    case object MissionAccomplished extends GameProgress
}

//////

final case class MainCharacter(
  name: Name,
  gender: Gender,
  age: Age,
  experience: Experience
)

//////

sealed abstract class City extends Product with Serializable

object City {
    final case class Free(name: Name, country: Country)
    final case class Invaded(city: City.Free, terraformDevice: TerraformDevice)
}

[programaker]

Ah... another idea! In the last sketch, we have different GameProgresses representing different states. What about moving the behavior to a typeclass?

GameProgress behavior would still be close to the data, but not in the data itself. Also, the typeclass will allow the game steps to deal with the progresses polymorphically

[programaker]

Not necessary; we've chosen to just add a flag defeated to the Invasion. Also, GameProgress behavior became stand-alone functions in the package game.progress