diagram.plantuml

@startuml

package com.knightwars {
  class KnightWars {
    create()
    render()
    dispose()
  }


  package userInterface {
    class Display {
      - gameManager : GameManager
      + displayGame()
      + displayMainMenu()
    }
    class EventHandler {
      - actorHUD : GameActorHUD
      - gameState : KnightWarsGame
      + handleDrag(posTouchDown : Vector2, posTouchDragged : Vector2)
      + handleTouchUp(lastTouchDown : Vector2, lastTouchUp : Vector2)
    }
    class GameInputProcessor {
      - eventHandler : EventHandler
      + touchDown(screenX : int, screenY : int)
      + touchDragged(screenX : int, screenY : int)
      + touchUp(screenX : int, screenY : int)
    }
    class GameScreen {
      + render(delta : float)
      + resize(width : int, height : int)
    }
    class MainMenuScreen {
      + render(delta : float)
      + resize(width : int, height : int)
    }
    class MainMenuBackground {
      + draw(batch : Batch, parentAlpha : float)
    }
    class MainMenuBackground {
      + draw(batch : Batch, parentAlpha : float)
    }
    class EndGameScreen {
      + draw(batch : Batch, parentAlpha : float)
    }


    package gameActors {
      class Arrow {
        + getWidth() : float
        + getHeight() : float
        + getOriginX() : float
        + getOriginY() : float
        + getRotation() : float
      }
      class GameActorBuildings {
        - gameState : KnightWarsGame
        + draw(batch : Batch, parentAlpha : float)
      }
      class GameActorHUD {
        - arrow : Arrow
        + draw(batch : Batch, parentAlpha : float)
        + createArrow(selectedBuildingCoords : Vector2, currentCoords : Vector2)
        + deleteArrow()
      }
      class GameActorUnit {
        - gameState : KnightWarsGame
        + draw(batch : Batch, parentAlpha : float)
      }
    }
  }


  package desktop {
    class DesktopLauncher {
      + DesktopLauncher()
      + main(arg : String[]) {static}
    }
  }


  package game {

    class GameManager {
      - game : KnightWarsGame
      + getKnightWarsGame() : KnightWarsGame
      + update(dt : float)
    }

    class KnightWarsGame {
      - map : Map
      + attributeBuildings()
      + getMap() : Map
      + getPlayerBlue() : Player
      + getPlayerNeutral() : Player
      + getPlayerRed() : Player
      + update(dt : float)
    }

    class YamlParser {
      yamlValidity(javaMap : Map<String, Map<String, Integer>>, superClass : Class<?> , objPackage : String)
    }

    package environment {

      abstract class Building {
        - owner : Player
        + getCoordinates() : Vector2
        + getDefenseLevel() : float
        + getGoldGeneration() : float
        + getHitPoints() : float
        + getKnights() : int
        + getOwner() : Player
        + isSelected(coordinates : Vector2) : Boolean
        + update(dt : float)
      }

      class Map {
        - buildings : ArrayList<Building>
        + getBuildings() : ArrayList<Building>
        + getSize() : Vector2
        + getUnits() : ArrayList<Unit>
        + sendUnit(departureBuilding : Building, arrivalBuilding : Building, percentage : float)
        + update(dt : float)
      }

      class MapFactory {
        + createProceduralMap(width : float, height : float, buildings : int, defaultPlayer : Player) : Map {static}
        - fileToString(fileName : String) : String {static}
        + importMapFromFile(fileName : String, defaultPlayer : Player) : Map {static}
        - isValidPoint(map : Map, point : Vector2) : Boolean {static}
      }

      class Path {
        + getArrivalPoint() : Vector2
        + getCurrentPosition() : Vector2
        + update(dt : float)
      }

      class Unit {
        - departureBuilding : Building
        - destinationBuilding : Building
        - owner : Player
        - path : Path
        + isArrived(threshold : float) : boolean
        + setSpeed(speed : float)
        + update(dt : float)
      }

      package players {
          class ComputerPlayer
          class HumanPlayer
          class NeutralPlayer

          class Player {
            - color : ColorPlayer
            + getColor() : ColorPlayer
            + getGold() : float
            + getName() : String
            + getUnitLevel() : float
            + removeGold(gold : float)
            + upgradeUnits()
        }

        enum ColorPlayer {
          + BLUE {static}
          + NEUTRAL {static}
          + RED {static}
        }
      }

      package buildings {
        class ClassicCastle
        class FortifiedCastle
        class CitadelCastle1
        class ForgeCastle1
        class GarrisonCastle1
        class MarketCastle1
      }

      class TroopMovement {
        - owner: Player
        - departureBuilding : Building
        - destinationBuilding : Building
        - originalPath : Path
        + removeUnit(unit: Unit)
        + update(dt : float)
      }
    }
  }
}

' knightwars
DesktopLauncher ..> KnightWars: crée
KnightWars ..> Display: crée
KnightWars ..> GameManager: crée

' Frontend
Display ..> GameScreen: affiche
Display ..> MainMenuScreen: affiche
Display ..> EndGameScreen: affiche
MainMenuScreen o-- MainMenuBackground
GameScreen o-- GameActorHUD
GameScreen o-- GameActorBuildings
GameScreen o-- GameActorUnit
GameActorHUD o-- Arrow
GameInputProcessor o-- EventHandler
EventHandler o-- GameActorHUD

' Backend
MapFactory ..> Map: crée
GameManager o-- KnightWarsGame
KnightWarsGame o-- Map
Map o-- Unit
Map o-- TroopMovement
TroopMovement o-- Player
TroopMovement o-- Path

Unit o-- Building
Unit o-- Path
Building o-- Player
Player o-- ColorPlayer
ComputerPlayer --|> Player
NeutralPlayer --|> Player
HumanPlayer --|> Player
ClassicCastle --|> Building
FortifiedCastle --|> Building
CitadelCastle1 --|> Building
ForgeCastle1 --|> Building
GarrisonCastle1 --|> Building
MarketCastle1 --|> Building

' Liens frontend - backend
EventHandler o-- KnightWarsGame

@enduml