de.farafin.snEADy.player
Class GameInfo

java.lang.Object
  extended by de.farafin.snEADy.player.GameInfo
All Implemented Interfaces:
java.io.Serializable

public class GameInfo
extends java.lang.Object
implements java.io.Serializable

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
See Also:
Serialized Form

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()