====== Entity-Parameter ======

Vollständige Auflistung der konfigurierbaren Parameter für Spielobjekte die einerseits in unserem Dateiformat gespeichert werden soll und andererseits in ein komponentenbasiertes Entity-Design abgebildet.

===== Entity =====

== Map-Editor ==

  * //flag// placeable - Ist das Objekt im Mapeditor platzierbar.
  * category - In welcher Kategorie steht es im Editor zur Auswahl.

== Movement ==

  * movement speed
  * turn speed - Wie schnell sich die Einheit dreht, wenn sie die Richtung wechselt. 

== Abilities ==

  * //list of// abilities - Liste der (an anderer Stelle definierter) Spezialfähigkeiten.

== Physics ==

  * collision size - Für Path-Finding.
  * wreckage collision size

== Interface ==

  * interface renderable
  * (various interface text elements(?)
  * //enum// mini-map-icon (robot, tank, building)

== Sound ==

  * **(not yet implemented)** movement sound - Fahr- oder Schrittgeräusche.
  * **(not yet implemented)** production sound
  * **(not yet implemented)** //sound set// unit voice set

== Building ==

  * //list of// units available for production
  * number of turrets
  * //list of// positions of turrets
  * //set of// legal turrets
  * unit spawn position
  * unit exit position
  * exit opening time

== Tank ==

  * //flag// driver
  * //flag// visible driver
  * //flag// hatch - Gibt es eine Klappe aus der der Fahrer herausschauen kann?
  * //set of// legal drivers
  * number of passengers
  * //flag// visible passengers
  * //list of// passenger positions
  * //set of// legal passengers

== Robot ==

  * probability for opening the hatch
  * driver renderable
  * passenger renderable
  * //flag// can shoot as passenger

== Other parameters ==

  * renderable
  * object name(?)
  * maximum health
  * regeneration speed
  * armor type
  * build time
  * repair multiplier
  * //flag// destructible
  * wreckage fade out time - Ein an Shader übergebbarer Parameter leitet sich hieraus ab mit dem das Wrack sanft ausgeblendet werden kann.
  * //flag// vulnerable - Ein Gebäude könnte beispielsweise verwundbar, aber nicht endgültig zerstörbar sein.
  * **(not yet implemented)** unit classification(?) - Eventuell Klassifikation die unterschiedliches AI-Verhalten hervorruft? Oder besser das aus den Kanonen der Einheit ableiten?
  * **(not yet implemented)** formation priority(?) - Angenommen man hätte eine Option gruppierte Einheiten automatisch zu formieren so würden diejenigen mit höherer Priorität sich an die Spitze stellen.
  * target selection range - Ab welcher Distanz versucht eine Einheit eine feindliche anzugreifen, auch wenn sie nicht selbst beschossen wurde.
  * out of range movement buffer - Wie weit bewegt sich eine Einheit wenn sie selbstständig ein Ziel erfasst hat, es aber außer Reichweite ist.
  * //flag// fixed yaw - Neigt sich die Einheit auf dem Terrain, oder steht sie immer gerade?
  * //list of// **cannons**

==== Cannon ====

  * //flag// integrated - Kanone hat keine eigene Node und ist nicht drehbar.
  * turning point
  * turning axis
  * exit point
  * horizontal turning speed
  * horizontal maximum turning angle
  * vertical turning speed(?)
  * vertical maximum turning angle(?)
  * projectile renderable
  * projectile speed
  * hit effect/renderable
  * barrel effect/renderable
  * projectile angle - In was für einem Bogen wird das Geschoss abgefeuert.
  * //flag// homing missile - Zielsuchendes Geschoss?
  * //list of// base damage, dice number, dice side number
  * //list of// damage radius
  * **(not yet implemented)** //list of// firing sounds
  * **(not yet implemented)** //list of// hit sounds
  * **(not yet implemented)** projectile sound
  * delay between shots
  * shot duration - Schussanimationen werden skaliert um der Schussdauer zu entsprechen.
  * missile exit time - Zeitpunkt in der Schussanimation an dem das Geschoss austritt.
  * //list of// allowed target types

===== Renderable =====

  * //tree of// renderable nodes
  * //list of// states

==== Renderable Node ====

  * position
  * orientation
  * scale
  * role - Welche logische Komponente wird durch die Node repräsentiert?
  * either mesh or particle effect

=== Mesh ===
  * //mapping between// renderable parameters and shader parameters
  * mesh
  * material 
  * colour/alpha map
  * normal/specular map
  * tint map
  * additional map 1
  * additional map 2 

=== Particle Effect ===  
  * particle effect
  * material 
  * map 1
  * map 2
  * map 3
  * //mapping between// animation states and effect states


==== State ====

  * //list of// renderable node overrides

=== Renderable Node Override ===

  * either mesh override or particle effect override

== Mesh Override ==

  * //mapping between// animation states and mesh animations
  * material 
  * colour/alpha map
  * normal/specular map
  * tint map
  * additional map 1
  * additional map 2 

== Particle Effect Override ==

  * material 
  * map 1
  * map 2
  * map 3
  * //mapping between// animation states and effect states

===== Beispiel =====

 
  Entity testEntity
  {
    renderable = "test object renderable" (string)
    entityName = "test object" (string)
    maxHealth = 30.0 (float)
    regenSpeed = 4.0 (float)
    armorType = "test object armor" (string)
    buildTime = 90.5 (float)
    destructible = true (bool)
    vulnerable = true (bool)
    wreckageFadeTime = 15.5 (float)
    targetSelectionRange = 600 (float)
    targetMovementBuffer = 200 (float)
    fixedYaw = false (bool)
    editorPlaceable = true (bool)
    editorCategory = "Test Objects" (string)
    moveSpeed = 270 (float)
    turnSpeed = 180 (float)
    abilities = ("radar", "repair") (list of string)
    collisionRadius = 5.5 (float)
    wreckageCollisionRadius = 0.0 (float)
    interfaceRenderable = "test object interface renderable" (string)
    canProduce = ("grunt", "psycho", "rocket") (list of string)
    numTurrets = 2 (int)
    turretPos = ((2.0, 4.0, 5.0), (4.0, 4.0, 5.0)) (list of vector3)
    allowedTurrets = ("turret rocket", "turret gatling") (list of string)
    spawnPos = (1.0, 0.0, 2.0) (vector3)
    exitPos = (3.0, 0.0, 2.0) (vector3)
    gateOpeningTime = 2.5 (float)
    hasDriver = true (bool)
    driverVisible = true (bool)
    hasHatch = true (bool)
    allowedDrivers = ("grunt", "sniper", "laser") (list of string)
    passengersVisible = true (bool)
    numPassengers = 3 (int)
    passengerPos = ((1.0, 2.0, 3.0), (2.0, 1.0, 1.0), (2.4, 3.4, 1.3)) (list of vector3)
    allowedPassengers = ("grunt", "sniper", "laser") (list of string)
    passengersShoot = true (bool)
    Cannon cannon1 
    {
      isIntegrated = false (bool)
      anchorPoint = (1.0, 2.0, 1.0) (vector3)
      anchorAxis = (0.0, 1.0, 0.0) (vector3)
      exitPoint = (2.0, 2.0, 1.0) (vector3)
      horzTurnSpeed = 80 (float)
      horzMaxAngle = 150 (float)
      vertTurnSpeed = 50 (float)
      vertMaxAngle = 40 (float)
      projectileRenderable = "test projectile" (string)
      projectileSpeed = 1200 (float)
      hitEffect = "test hit effect" (string)
      barrelEffect = "test barrel effect" (string)
      firingAngle = 45 (float)
      steeringProjectile = true (bool)
      damage = (15+1d3, 10+1d2, 5) (list of damage w. dice)
      damageRadius = (3, 10, 15) (list of float)
      shootDelay = 2.1 (float)
      shotDuration = 0.85 (float)
      missileExitTime = 0.5 (float)
      allowedTargets = ("robot", "tank", "building") (list of string)
    }
    Cannon cannon2
    {
      isIntegrated = true
      exitPoint = (3.0, 2.0, 1.0)
      projectileSpeed = 0
      hitEffect = "test hit effect 2"
      barrelEffect = "test barrel effect 2"
      firingAngle = 0
      damage = (4)
      damageRadius = (0)
      shootDelay = 2.1
      shotDuration = 0.55
      missileExitTime = 0.2
      allowedTargets = ("robot")
    }
  }

  Renderable test_renderable
  {
    NodeTree tree
    {
      Node root
      {
        position = (0.0, 0.0, 0.0) (vector3)
        scale = (1.0, 1.0, 1.0) (vector3)
        orientation = (1.0, 0.0, 0.0, 0.0) (vector3)
        role = "none" (string)
        Mesh mesh
        {
          meshName = "test.mesh" (string)
          materialName = "object_material" (string)
          colourMapName = "test_colour.dds" (string)
          normalSpecMapName = "test_normal.dds" (string)
          tintMapName = "test_tint.dds" (string)
          envMapName = "test_env.dds" (string)
          boneMapping = (("bone1", "hatch")) (list of string-pairs)
          animMapping = (("move_anim1", "move"), ("move_anim2", "move"), ("idle_anim1", "idle")) (list of string-pairs)
          paramMapping = (("playerColour", "tintColour"), ("chainMovement", "chainMove")) (list of string-pairs) 
        }
        Node driver
        {
          position = (0.0, 0.0, 0.0) 
          scale = (1.0, 1.0, 1.0) 
          orientation = (1.0, 0.0, 0.0, 0.0)
          role = "driverAnchor"
        }
      }
    }
    State normal
    {
    }
    State damaged
    {
      NodeOverwrite root
      {
        position = (0.0, 0.0, 0.0) (vector3)
        scale = (1.0, 1.0, 1.0) (vector3)
        orientation = (1.0, 0.0, 0.0, 0.0) (vector3)
        role = "none" (string)
        MeshOverwrite
        {
          materialName = "object_damaged_material" (string)
          colourMapName = "test_damaged_colour.dds" (string)
          normalSpecMapName = "test_damaged_normal.dds" (string)
          tintMapName = "test_damaged_tint.dds" (string)
          envMapName = "test_damaged_env.dds" (string)
          boneMapping = (("bone1", "hatch")) (list of string-pairs)
          animMapping = (("move_anim1", "move"), ("move_anim2", "move"), ("idle_anim1", "idle")) (list of string-pairs)
          paramMapping = (("playerColour", "tintColour"), ("chainMovement", "chainMove")) (list of string-pairs) 
        }
      }
    }
  }