diagram.puml

'You may preview the uml using www.planttext.com/planttext
@startuml
title LP24 - Dungeon of Legends

skinparam {
    nodesep 30
    ranksep 51
    backgroundcolor #888888
}

enum Direction{
    UP
    DOWN
    LEFT
    RIGHT
}
enum ConsumableType{
    POT
    SCROLL
    toString(): String
}

enum WeaponType{
    BOW
    SWORD
    WAND
    toString(): String
}

enum ArmorType{
    BREAST_PLATE
    GLOVES
    HELMET
    BOOTS
    PANTS
    toInt(): int
    fromInt(a: int): ArmorType
    toString(): String
}
enum StorableObjectType{
    WEAPON
    ARMOR
    CONSUMABLE
}

enum LivingThingType{
    PLAYER
    MOB
}

enum Tile{
    WALL
    ROOM
    CORRIDOR
    OPENED_DOOR
    CLOSED_DOOR
    STAIR_UP
    STAIR_DOWN
    UNKNOWN
}

LivingThingType -[hidden]right- StorableObjectType
ArmorType -[hidden]left- StorableObjectType
WeaponType -[hidden]left- ArmorType
WeaponType -[hidden]right- ConsumableType

interface StorableObject{
    + getType(): StorableObjectType
    + toString(): String
}


interface Consumable{
    + trigger(livingThing: LivingThing): void
    + nextTick(): boolean
    + getConsumableType(): ConsumableType
}
StorableObject <|-- Consumable


class Armor{
    - defensePowerModifier: int
    - attackPowerModifier: int
    - type: ArmorType
    + Armor(defensePowerModifier, ...)
    + getDefensePowerModifier(): int
    + getAttackPowerModifier(): int
    + getArmorType(): ArmorType
}
Armor -[hidden]up-> StorableObject
Consumable -[hidden]right- Armor
StorableObject <|.. Armor

class Weapon{
    - attackPowerModifier: int
    - range: byte
    - manaCost: byte
    - type: WeaponType
    + Weapon(damageModifier, ...)
    + getWeaponType(): WeaponType
    + getAttackPowerModifier(): int
    + getRange(): byte
    + getManaCost(): byte
}
StorableObject <|.. Weapon

class Scroll{
    - healthModifierPerTick: int
    - healthModifierModifierPerTick: int
    - name: String
    - turns: byte
    + Scroll(turns, ...)

    'For saving purposes
    + getHMPT(): int
    + getHMMPT(): int
}

class Pot{
    - healthModifier: int
    - defensePowerModifier: int
    - attackPowerModifier: int
    - name: String
    - turns: byte
    + Pot(healthModifier,...)

    'For saving purposes
    + getHM(): int
    + getDPM(): int
    + getAPM(): int
}
Pot -[hidden]up-> Consumable
Scroll -[hidden]up-> Consumable
Pot -[hidden]right- Scroll
Consumable <|.. (Pot, Scroll)

abstract class LivingThing{
    - sight: Tile[][]
    - level: int
    - maxHitPoints: int
    - hitPoints: int
    - attackPower: int
    - defensePower: int
    - position: Vector2i
    - requestedAttack: Direction
    - requestedMove: Direction
    + print(): void
    + updateSight(newSight: Tile[][]): void
    + getSight(): Tile[][]
    + getLevel(): int
    + getMaxHitPoints(): int
    + getHitPoints(): int
    + getDamagePower(): int
    + getDefensePower(): int
    + getPosition(): Vector2i
    + getRequestedAttack(): Direction
    + getRequestedMove(): Direction
    + setPosition()
    + damage(): void
    + isAlive(): boolean
    + live(): void
    + getType(): LivingThingType
}

class Player{
    - maxStorageCapacity: int
    - maxMana: int
    - mana: int
    - abilityPower: int
    - armor[5]: Armor
    - weapon: Weapon
    - name: String
    + passedStairs: boolean
    + Player(name, ...)
    + getMana(): int
    + addToInventory(storable: StorableObject)
    + useMana(consumption: int): boolean
    - equipWith(equiment: Equipement)

    'For saving purposes
    + getEquipedArmor(): Armor[5]
    + getEquipedWeapon(): Weapon
    + getInventory(): StorableObject[]
}

Player *-right-> StorableObject
Player -[hidden]up-> LivingThing

class Mob{
    + Mob(attackPower, ...)
    - keepPatroling(): void
    - chase(): void
    - wander(): void
}
Mob -left-> State
Mob -[hidden]right- Player
Mob -[hidden]up-> LivingThing
LivingThing <|-- (Mob, Player)

class Game {
    + launch(numberOfPlayers: byte, ...): void
    - Game()
    - nextTick(): void
    - loadSave(): boolean
    - save(): void
}
Game *-up-> Mob
Game "1,2" *-up-> Player
Game --> Map
Game -left-> HUD

class Map {
    + MIN_ROOM_WIDTH: final int
    + MAX_ROOM_WIDTH: final int
    + MIN_ROOM_HEIGHT: final int
    + MAX_ROOM_HEIGHT: final int
    + MIN_LEVEL_HEIGHT: final int;
    + MAX_LEVEL_HEIGHT: final int;
    - seed: Seed
    - stairsUpPosition: Vector2i
    - stairsDownPosition: Vector2i
    - map: Tile[][]
    + Map()
    + Map(seed: Seed, stairsUpPosition: Vector2i)
    + triggerTile(position: Vector2i, target: LivingThing): void
    + getStairsUpPosition(): Vector2i
    + getStairsDownPosition(): Vector2i
    + getAlphaSeed(): int
    + getBetaSeed(): int
    + getTile(position: Vector2i): Tile
    + getLOS(position: Vector2i, visionRange: byte): Tile[][]
    + getSize(): Vector2i
    + generateLevel(level: int): void
    + restoreLevel(level: int): void
    - isVisibleFrom(tilePosition: Vector2i,watcherPosition: Vector2i) : boolean
    - generateLevel(level: int, withEntities: boolean): void
}
Map *--> InteractiveObject
Map *-left-> Tile
Map --> Seed

class Seed {
    - alphaSeed: long
    - betaSeed: long
    + Seed()
    + Seed(alphaSeed: int, betaSeed: int)
    + getAlphaSeed(): int
    + getBetaSeed(): int
    + getRandomizer(level: int): Random
}

enum State{
    PATROLING
    STANDING
    SLEEPING
    WANDERING
    CHASING
}

class HUD {
    - players: Player[]
    + print(): void
    + setPlayers(players: Player[]): void
}

class InteractiveObject{
    - isTrap: boolean
    - manaModifier: int
    - hpModifier: int
    - loot: StorableObject
    - target: LivingThingType
    - position: Vector2i
    + InteractiveObject(isTrap: boolean, position: Vector2i)
    + getPosition(): Vector2i
    + trigger(LivingThing: LivingThing): boolean
    + isActivableOn(type: LivingThingType): boolean
    + print(): void
}

class Vector2i{
    + x: int
    + y: int
    + Vector2i(x: int, y: int)
    + Vector2i()
    + Vector2i(v: Vector2i)
    + set(x: int, y: int): void
    + equals(vect: Vector2i): boolean
    + add(dir: Direction): void
    + x(): int
    + y(): int
}
Vector2i *-[hidden]right-> LivingThing
@enduml