logic

package com.game

import com.game.model._

import scala.annotation.tailrec

object MyGame {

  val worldState = new WorldState

  def main(args: Array[String]): Unit = {

    val gameEvent = GameEvent(
      "Падает кирпич на голову", InLocation("dormitory_area"), Seq(
        FollowDecision(
          "Уклониться", IncreasePlayerStat("luck", "1"), PlayerStatApplicability("agility", GreaterThan, "10"),
          Seq(LastDecision("Охереть", NothingChanged, AlwaysApplicable, "Вы просто охерели")), "Вы ловко уклоняетесь"
        ),
        LastDecision("Устремить свой взгляд в небо", Death, AlwaysApplicable, "Типа все")
      ), "Вот уж ситуация!"
    )

    receiveEvent(gameEvent)
  }

  def receiveEvent(event: GameEvent): Unit = {
    println(event.text)

    handleDecisions(event.decisions.filter(_.isApplicableTo(worldState)))
  }

  @tailrec
  def handleDecisions(decisions: Seq[Decision]): Unit = {

    val selectedDecision = promptForDecision(decisions)
    println(selectedDecision.followingText)

    selectedDecision match {
      case FollowDecision(name, consequence, _, followDecisions, _) =>
        println(name)
        applyConsequence(consequence)
        handleDecisions(followDecisions.filter(_.isApplicableTo(worldState)))
      case LastDecision(name, consequence, _, _) =>
        println(name)
        applyConsequence(consequence)
    }
  }

  def applyConsequence(consequence: Consequence): Unit =
    worldState.change(consequence)

  // Assume for simplicity always first
  def promptForDecision(decisions: Seq[Decision]): Decision = decisions.head
}

package com.game

package object model {

  trait Consequence
  case class IncreasePlayerStat(statName: String, value: String) extends Consequence
  case object NothingChanged extends Consequence
  case object Death extends Consequence

  trait TypeOfEquality
  case object GreaterThan extends TypeOfEquality
  case object LessThan extends TypeOfEquality
  case object Equality extends TypeOfEquality

  trait Applicability {
    // Будет ли отображаться это действие в списке
    def isApplicable(worldState: WorldState): Boolean = ???
  }
  case class PlayerStatApplicability(statName: String, equality: TypeOfEquality, value: String) extends Applicability
  case object AlwaysApplicable extends Applicability

  class Decision(name: String, consequence: Consequence, applicability: Applicability, text: String) {
    // проверить применимость действия
    def isApplicableTo(worldState: WorldState): Boolean = applicability.isApplicable(worldState)

    def followingText: String = text
  }

  case class FollowDecision(name: String,
                            consequence: Consequence,
                            applicability: Applicability,
                            decisions: Seq[Decision],
                            text: String
                           ) extends Decision(name, consequence, applicability, text)

  case class LastDecision(name: String,
                          consequence: Consequence,
                          applicability: Applicability,
                          text: String
                         ) extends Decision(name, consequence, applicability, text)

  case class GameEvent(name: String,
                       condition: Condition,
                       decisions: Seq[Decision],
                       text: String)

  trait Condition {
    def isMet(worldState: WorldState): Boolean
  }

  case class InLocation(name: String) extends Condition {
    // Проверяем что игрок находится на нужной локации
    override def isMet(worldState: WorldState): Boolean = ???
  }

  class WorldState {
    // Нужно описывать игрока, локацию и т.д.
    def change(consequence: Consequence): Unit = {}
  }

}