Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## de.farafin.snEADy.player
Class GameInfo

    java.lang.Object
      de.farafin.snEADy.player.GameInfo

    public class GameInfo

extends java.lang.Object

This is just a class for storing informations. It doesnt contain methods because it doesnt need to calculate anything. Its just a set of informations for the player.
GameInfo contains global informations about the game.
Diese Klasse ist zum Speichern von Informationen gedacht. Sie enthällt keine Methoden weil sie nichts berechnen muss. Es ist nur eine Menge von Informationen für den Spieler.
GameInfo enthällt allgemeinte Informationen über das Spiel.

Author:
  roland, lars

Field Summary
`long` | `analyseMS` To allow the player an analyse of the playfield, he gets more milliseconds at gameTime == 0.
`int` | `auto_grow_delay` each auto_grow_delay number of world cycles, the snake grows by one segment
`int` | `auto_slowdown_delay` each auto_slowdown_delay number of world cycles, the snakes waitCycles increase by one.
`float` | `damage_length_grow` The amount of segments (part of a segment) that a snake grows if an other snake runns into it.
`int` | `damage_points_radius` The Distance in which snakes gain points if an other snake looses a segment.
`int` | `easy_points` if a snake bites it self, this number of points are given all snakes, that touches the biting snake at at least one segments.
`long` | `exitTime` exitTime is the game cycle in which the exit is opened.
`long` | `gameTime` snEADy is a round based game.
`int` | `goody_length_occ` estimation that a new goody is a length goody. propability: goody_length_occ/Sum(goody_...
`int` | `goody_length_value` the number of segments a snake gets longer, if it eats a length goody
`int` | `goody_points_occ` estimation that a new goody is a points goody. propability: goody_points_occ/Sum(goody_...
`int` | `goody_points_value` the number of points a snake gets, if it eats a points goody
`int` | `goody_shorter_occ` estimation that a new goody is a shorter goody. propability: goody_points_occ/Sum(goody_...
`int` | `goody_shorter_value` the number of segments a snake looses, if it eats a shorter goody
`int` | `goody_slowdown_occ` estimation that a new goody is a slowdown goody. propability: goody_slowdown_occ/Sum(goody_...
`int` | `goody_speed_occ` estimation that a new goody is a speed goody. propability: goody_speed_occ/Sum(goody_...
`int` | `kill_point_goodies` The number of goodies which spread out when a snake dies.
`int` | `kill_points_radius` The Distance in which snakes gain points if an other snake dies.
`int` | `max_goody_occ_delay` the maximal time between two goody occurances.
`long` | `max_move_delay` The maximum delay for snakes to move
`long` | `maxMem` This is the maximal size in kB, a player is allowed to allocate.
`long` | `min_move_delay` The minimum delay for snakes to move
`long` | `suddenDeathTime` To force an final decision for each game, there is a sudden death phasis.
`int` | `survival_points` the number of points a player gets if he reaches the exit.
`long` | `thinkingMS` thinkingMS is the (real) time in milliseconds a player is allowed to think about his move.

Constructor Summary
`GameInfo()`

Method Summary

Methods inherited from class java.lang.Object
`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

Field Detail

### gameTime

    public long gameTime

  snEADy is a round based game. That means in snEADy is the time no continoue, but discrete value. So you can image the game as a sequence of stats. We can count this states and the counter is gameTime. Like in a party game, thinks each player each round about what he does next. gameTime exists tp mesure the snEADy-time.
  snEADy ist ein Runden basierendes Spiel. Das bedeutet, in snEADy ist die Zeit keine kontinuierliche, sondern eine diskrete Größe. Das Spiel besteht also aus einer Folge von Zuständen. Diese Zustände können wir zählen und der Zähler ist gameTime. Wie in einem Gesellschaftsspiel ist jeder Spieler in jeder Runde ein mal dran und kann darüber nachdenken was er als nächstes macht. Damit die snEADy-Zeit messbar wird, gibt es gameTime.

### exitTime

    public long exitTime

  exitTime is the game cycle in which the exit is opened. If gameTime is less then exitTime, the exit fields in the game field will work like a normal wall. If gameTime is greater equal than exitTime, the exit is opened and the snakes are able to leave the arena.
  exitTime ist die Spiel-Runde, in der der Ausgang geöffnet wird. Wenn gameTime kleiner ist als exitTime, dann werden die Exit-Felder wie eine normale Wand behandelt. Ist gameTime größer gleich exitTime, dann is der Ausgang geöffnet und die Schlangen können die Arena verlassen.

### suddenDeathTime

    public long suddenDeathTime

  To force an final decision for each game, there is a sudden death phasis. This is made for forcing the snakes to leave the arena. suddenDeathTime is the like exitTime a gameTime cycle in which the sudden death starts. The sudden death usually starts some game cycles after the exit was opended.
  Um eine endgültige Entscheidung bei einem Spiel zu erzwingen, gibt es die Sudden Death Phase. Sie ist dazu da, die Schlangen zum Verlassen der Arena zu zwingen. suddenDeathTime ist so ähnlich wie exitTime die gameTime in der der Sudden Death beginnen soll.

### thinkingMS

    public long thinkingMS

  thinkingMS is the (real) time in milliseconds a player is allowed to think about his move. After this time he is supposed to finish his calculation.
  thinkingMS ist die (reale) Zeit in Millisekunden die ein spieler Zeit hat über seinen Zug nachzudenken. Nach dieser Zeit muss er mit der Berechnung fertig sein.

### analyseMS

    public long analyseMS

  To allow the player an analyse of the playfield, he gets more milliseconds at gameTime == 0. So the first time his calculate method is called, he gets additional analyseMS to thinkingMS.
  Um dem spieler eine Analyse des Spielfeldes zu erlauben, bekommt er bei gameTime == 0 mehr millisekunden. Das bedeutet, wenn seine calculate-methode zum ersten mal aufgerufen wird, bekomt er zusäzlich zu seinen thinkingMS noch die analyseMS.

### maxMem

    public long maxMem

  This is the maximal size in kB, a player is allowed to allocate. If the player needs more, his snake will die. Dies ist die maximal erlaubte Menge von Speicher in kB, die ein Spieler belegen darf. Wenn er mehr benutzt, wird seine schlange getötet.

  See Also:
    `OwnSnakeInfo.lastCalculatedMemUsage`

### damage_points_radius

    public int damage_points_radius

  The Distance in which snakes gain points if an other snake looses a segment. The number of points is damage_points_radius - (dist = deltaRow + deltaLine)

### kill_points_radius

    public int kill_points_radius

  The Distance in which snakes gain points if an other snake dies. The number of points is kill_points_radius - (dist = deltaRow + deltaLine)

### kill_point_goodies

    public int kill_point_goodies

  The number of goodies which spread out when a snake dies. The Radius where they occure is the same as kill_points_radius Sometimes it may happen, that there is very little space where goodies could be placed. Because the placing rutine is random, it may happen, that there is after 100 trys no free place found. Than this goody is not placed. So dont wonder of there are less than kill_point_goodies goodies around sometimes.

### damage_length_grow

    public float damage_length_grow

  The amount of segments (part of a segment) that a snake grows if an other snake runns into it.

### min_move_delay

    public long min_move_delay

  The minimum delay for snakes to move

### max_move_delay

    public long max_move_delay

  The maximum delay for snakes to move

### auto_grow_delay

    public int auto_grow_delay

  each auto_grow_delay number of world cycles, the snake grows by one segment

### auto_slowdown_delay

    public int auto_slowdown_delay

  each auto_slowdown_delay number of world cycles, the snakes waitCycles increase by one. If the snake eats a speed up or a slw down goodie, the time starts new.

### max_goody_occ_delay

    public int max_goody_occ_delay

  the maximal time between two goody occurances. The time is equal distributed.

### goody_speed_occ

    public int goody_speed_occ

  estimation that a new goody is a speed goody. propability: goody_speed_occ/Sum(goody_..._occ)

### goody_slowdown_occ

    public int goody_slowdown_occ

  estimation that a new goody is a slowdown goody. propability: goody_slowdown_occ/Sum(goody_..._occ)

### goody_length_occ

    public int goody_length_occ

  estimation that a new goody is a length goody. propability: goody_length_occ/Sum(goody_..._occ)

### goody_points_occ

    public int goody_points_occ

  estimation that a new goody is a points goody. propability: goody_points_occ/Sum(goody_..._occ)

### goody_shorter_occ

    public int goody_shorter_occ

  estimation that a new goody is a shorter goody. propability: goody_points_occ/Sum(goody_..._occ)

### goody_length_value

    public int goody_length_value

  the number of segments a snake gets longer, if it eats a length goody

### goody_points_value

    public int goody_points_value

  the number of points a snake gets, if it eats a points goody

### goody_shorter_value

    public int goody_shorter_value

  the number of segments a snake looses, if it eats a shorter goody

### survival_points

    public int survival_points

  the number of points a player gets if he reaches the exit. the later a player goes into the exit, the more points are made.

### easy_points

    public int easy_points

  if a snake bites it self, this number of points are given all snakes, that touches the biting snake at at least one segments. that meens the bodys touches each other.

Constructor Detail

### GameInfo

    public GameInfo()

Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD