Serialized Form
Package de.farafin.snEADy |
f
java.awt.Font[] f
STRBUFFCAPACITY
int STRBUFFCAPACITY
strBuff
java.lang.StringBuffer strBuff
Package de.farafin.snEADy.control |
name
java.lang.String name
Package de.farafin.snEADy.control.GaphixStuff |
sel_arena
GrSelCanvas sel_arena
butt_loadArena
GrButton butt_loadArena
butt_arenaOK
GrButton butt_arenaOK
area_infoArena
GrTextArea area_infoArena
scroll_arena
GrScroll scroll_arena
filt
java.io.FilenameFilter filt
cf_text
java.awt.TextField cf_text
cf_lab
java.awt.Label cf_lab
commandHist
java.lang.String[] commandHist
selectedCommand
int selectedCommand
lastInserted
int lastInserted
butt_run
GrButton butt_run
butt_stop
GrButton butt_stop
butt_min
GrButton butt_min
butt_quit
GrButton butt_quit
butt_replay
GrButton butt_replay
butt_arena
GrButton butt_arena
butt_player
GrButton butt_player
butt_options
GrButton butt_options
butt_credits
GrButton butt_credits
butt_rmPlayer
GrButton[] butt_rmPlayer
monPosX
int monPosX
monPosY
int monPosY
monWidth
int monWidth
monHeight
int monHeight
text_exitT
GrTextField text_exitT
text_suddenDT
GrTextField text_suddenDT
text_iLength
GrTextField text_iLength
text_iDelay
GrTextField text_iDelay
text_aGrow
GrTextField text_aGrow
text_aSlowd
GrTextField text_aSlowd
text_maxDelay
GrTextField text_maxDelay
text_pLength
GrTextField text_pLength
text_pSpeed
GrTextField text_pSpeed
text_pSlowd
GrTextField text_pSlowd
text_pPoints
GrTextField text_pPoints
text_maxTime
GrTextField text_maxTime
text_maxMem
GrTextField text_maxMem
text_minCycleMS
GrTextField text_minCycleMS
tgl_controlPlayer
GrButton tgl_controlPlayer
tgl_timeKill
GrButton tgl_timeKill
tgl_memKill
GrButton tgl_memKill
tgl_showSC
GrButton tgl_showSC
tgl_debugMon
GrButton tgl_debugMon
tgl_autoGameSpeed
GrButton tgl_autoGameSpeed
tgl_pPTime
GrButton tgl_pPTime
tgl_pPMem
GrButton tgl_pPMem
tgl_log
GrButton tgl_log
text_hPlayerName
GrTextField text_hPlayerName
butt_addHPlayer
GrButton butt_addHPlayer
butt_addCPlayer
GrButton butt_addCPlayer
butt_plOK
GrButton butt_plOK
sel_player
GrSelCanvas sel_player
area_infoPlayer
GrTextArea area_infoPlayer
scroll_player
GrScroll scroll_player
filt
java.io.FilenameFilter filt
sel_replay
GrSelCanvas sel_replay
butt_loadReplay
GrButton butt_loadReplay
butt_ejectReplay
GrButton butt_ejectReplay
butt_replayOK
GrButton butt_replayOK
tgl_record
GrButton tgl_record
tgl_reversed
GrButton tgl_reversed
tgl_step
GrButton tgl_step
area_loadedReplay
GrTextArea area_loadedReplay
area_infoReplay
GrTextArea area_infoReplay
text_recordName
GrTextField text_recordName
text_replayMinCycleMS
GrTextField text_replayMinCycleMS
text_stepRange
GrTextField text_stepRange
scroll_replay
GrScroll scroll_replay
filt
java.io.FilenameFilter filt
iData
int iData
bMode
int bMode
bState
int bState
oldBState
int oldBState
bImage
java.awt.image.BufferedImage bImage
w
int w
h
int h
sbutt_quit
GrButton sbutt_quit
sbutt_min
GrButton sbutt_min
SCROLL_NONE
int SCROLL_NONE
SCROLL_UP
int SCROLL_UP
SCROLL_DOWN
int SCROLL_DOWN
SCROLL_BAR
int SCROLL_BAR
sState
int sState
w
int w
h
int h
max
int max
range
int range
pos
float pos
dy_bar
int dy_bar
dMover
int dMover
selectC
GrTextArea selectC
img_scroll
java.awt.image.BufferedImage img_scroll
list
java.lang.String[] list
img_list
java.awt.image.VolatileImage img_list
img_listSel
java.awt.image.VolatileImage img_listSel
selected
int selected
border
java.awt.image.VolatileImage[] border
w
int w
h
int h
borderW
int borderW
showW
int showW
showH
int showH
lines
int lines
columns
int columns
showedLinesStart
int showedLinesStart
text
java.lang.StringBuffer text
drawText
java.lang.StringBuffer drawText
lim
boolean lim
img_text
java.awt.image.VolatileImage img_text
drawMode
int drawMode
alligment
int alligment
carr
boolean carr
numbersOnly
boolean numbersOnly
comm
java.lang.String comm
troot
GrTextField troot
img_bg
java.awt.image.BufferedImage img_bg
sroot
GrWindow sroot
w
int w
h
int h
Package de.farafin.snEADy.inOut |
Package de.farafin.snEADy.player |
gameTime
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
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
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
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
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
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
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
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
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
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
long min_move_delay
- The minimum delay for snakes to move
max_move_delay
long max_move_delay
- The maximum delay for snakes to move
auto_grow_delay
int auto_grow_delay
- each auto_grow_delay number of world cycles, the snake grows by one segment
auto_slowdown_delay
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
int max_goody_occ_delay
- the maximal time between two goody occurances. The time is equal distributed.
goody_speed_occ
int goody_speed_occ
- estimation that a new goody is a speed goody. propability: goody_speed_occ/Sum(goody_..._occ)
goody_slowdown_occ
int goody_slowdown_occ
- estimation that a new goody is a slowdown goody. propability: goody_slowdown_occ/Sum(goody_..._occ)
goody_length_occ
int goody_length_occ
- estimation that a new goody is a length goody. propability: goody_length_occ/Sum(goody_..._occ)
goody_points_occ
int goody_points_occ
- estimation that a new goody is a points goody. propability: goody_points_occ/Sum(goody_..._occ)
goody_shorter_occ
int goody_shorter_occ
- estimation that a new goody is a shorter goody. propability: goody_points_occ/Sum(goody_..._occ)
goody_length_value
int goody_length_value
- the number of segments a snake gets longer, if it eats a length goody
goody_points_value
int goody_points_value
- the number of points a snake gets, if it eats a points goody
goody_shorter_value
int goody_shorter_value
- the number of segments a snake looses, if it eats a shorter goody
survival_points
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
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.
levelName
java.lang.String levelName
- The name of the Level / playfield
Der Name des Levels / Spielfeldes.
height
int height
- The height of the playField (the same value as playField.length)
Die Höhe des Spielfeldes (der gleiche Wert wie auch playField.length)
width
int width
- The width of playField (the same value as playField[0].length)
Die Breite des Spielfeldes (dar gleiche Wert wie auch playField[0].length)
playField
char[][] playField
- The playfield. It is a 2 dimensional array of char values. For more informations about the
meaning of this values visit PubConstants. The play field is stored like a matrix
(visit Horst's script around page 63). The upper left corner is the origin with coordinats (0, 0).
The first index represents the line, the second the row. The playfield cells are adressed
with playField[line][row]. Please don't get deranged by this, we had to decide
for one representation and we choosed this one. If you learn this representation for one
time, you will never be confused again which index of Horst's matrixes means the line or row...
Das Spielfeld. Es ist ein 2-Dimensionaler Array von char-Werten. Mehr über deren Bedeutung siehe
PubConstants. Das Spielfeld wird wie eine Matrix gespeichert (siehe Horst's Skript ungefär Seite 63).
Die obere linke Ecke ist der Ursprung mit den Koordinaten (0, 0). Der erste Index repräsentiert die
Zeile, der zweite die Spalte. Die Spielfeldzellen werden mit playFiled[line][row] adressiert.
Bitte lasst euch davon nicht verwirren, wir mussten uns für eine Darstellung entscheiden und
haben diese gewählt. Wenn ihr diese Darstellung ein mal gelernt habt, werdet ihr euch nie
wieder von den Indizes von Horsts Matrizen irritieren lassen ;-).
- See Also:
PubConstants
nextMoveTime
long nextMoveTime
- nextMoveTime is the gameTime cycle the snake will move next time. It moves directly
after the player finished his thinking method and before the next player starts his
calculation.
nextMoveTime ist der gameTime Zyklus wenn die Schlange das nächste mal ziehen wird. Sie zieht
direkt nach dem der spieler seine calculate-methode beendet hat, noch bevor der nächste spieler
seine überlegung startet.
- See Also:
GameInfo.gameTime
lastCalculatedMemUsage
long lastCalculatedMemUsage
- lastCalculatedMemUsage is how the name sais, the memory usage of the player at
it was calculated last time. The calculation of this is very time consumting, thats
why it is not done every gameCycle.
lastCalculatedMemUsage ist wie der Name sagt, der Speicherplatz, den der Spieler belegt
hat, als das letzte mal kontrolliert wurde. Die Berechnung ist sehr Zeitaufwendig
und erfolgt deswegen nicht in jedem game Zyklus.
headDirection
int headDirection
- This is the directon in which the head of the snake points. This is important because
the player decided if the head should turn left, right or doesn't turn at all. So the move
direction depends on the turn of the player and the direction the snakes head pointed before.
Dies ist die Richtung in die der Kopf der Schlange schaut. Das ist wichtig, weil der Spieler
entscheiden muss ob sich der Kopf nach links, rechts oder gar nicht drehen soll. Also hängt
die Richtung in die die Schlange sich als nächstes bewegt von der aktuellen richtung des Kopfes
und der richtung ab in die der spieler lenkt.
- See Also:
PubConstants.NORTH
,
PubConstants.EAST
,
PubConstants.SOUTH
,
PubConstants.WEST
turnDirection
int turnDirection
- The direction the head of the snake should turn to.
Die Richtung in die sich der Kopf der schlange drehen soll.
- See Also:
PubConstants.TURN_LEFT
,
PubConstants.TURN_NONE
,
PubConstants.TURN_RIGHT
startTime
long startTime
- Here is the system time stored at which the players calculation method was started.
It will be renewed every time the player starts his calculation.
Hier wird die Systemzeit gespeichert an der der Spieler seine Berechnung
gestartet hat. Der wert wird jedes mal neu gesetzt wenn der Spieler seine
Berechnung startet.
maxTime
long maxTime
- The maximal amount of time in milliseconds the player is allowed to think.
Die maximale Anzahl an Millisekunden, die der Spieler überlegen darf.
monitor
C_DebugMonitor monitor
- This is the small window for debug informations of the player
Dies ist das kleine Fenster für die debug-ausgaben der Spieler.
playerName
java.lang.String playerName
- The name of the player who controls the snake.
Der Name des Spielers der die Schlange steuert.
snakeChar
char snakeChar
- The char value of the snake in the playField.
Der char-Wert des Spielers auf dem Spielfeld.
- See Also:
PubConstants.PLAYER_0
headPosLine
int headPosLine
- The line of the snakes heads position at the play field:
playField[headPosLine][headPosRow].
Die Zeile der Kopfposition der Schlange auf dem Spielfeld:
playField[headPosLine][headPosRow].
- See Also:
LevelInfo.playField
headPosRow
int headPosRow
- The row of the snakes heads position at the play field:
playField[headPosLine][headPosRow].
Die Spalte der Kopfposition der Schlange auf dem Spielfeld:
playField[headPosLine][headPosRow].
- See Also:
LevelInfo.playField
points
int points
- The points the player, which controls the snake.
Die Punkte des Spielers, der die Schlange steuert.
snakeLength
int snakeLength
- The number of visable segments of the snake which is equal to the current
length of the snake.
Die Anzahl der sichtbaren Schlangensegmente was gleichbedeutend mit der
Länge der Schlange ist.
waitCycles
long waitCycles
- Like it is described at GameInfo.gameTime, consists the game as a sequence of game cycles.
To realize different velocities for the snakes, are the snakes not moving each game cycle.
So the player thinks waitCycles times and than the snake moves one time. The fastest
imaginable speed is that the snake moves (one field) each game cycle. For the tournament
might be the value higher. visit www.snEADy.de for more informations about this.
So you can imagine waitCycles as a strange kind of speed. The less waitCycles is, the more
often the snake will move, but the less often the player will have time to think what he is
doing next. waitCycles is the number of cycles, the snake waits between two moves.
Wie bereits in GameInfo.gameTime beschrieben, besteht das Spiel aus einer Folge von spiel zyklen.
Um verschiedene Geschwindigkeiten der Schlangen zu realisieren, ziehen sie nicht jeden Zyklus.
Das bedeutet, ein Spieler denkt erst waitCycles mal nach bevor die Schlange ein mal zieht.
Die höchste denkbare Geschwindigkeit ist, dass die Schlange jede Runde (ein Feld) zieht.
Für das Turnier werden wir den Wert veilleicht erhöhen, schaut einfach auf www.snEADy.de
vorbei um euch da genauer zu informieren.
Man kann sich waitCycles also auch als eine art Geschwindigkeit vorstellen. Je kleiner waitCycles
ist, desto öfter bewegt sich die Schlange, aber desto weniger kann ein spieler über den nächsten
Zug nachdenken. waitCycles ist die Anzahl der zyklen die die Schlange zwischen zwei mal bewegen
warten muss.
- See Also:
GameInfo.gameTime
snakeStatus
int snakeStatus
- The status of the snake. Possible is: IN_ACTION, IN_HEAVAN and IN_EXIT.
The status gives informations if the snake is still running around (IN_ACTION),
died (IN_HEAVEN) or went out of the arena through the exit (IN_EXIT).
For more details see PubConstants.
Der Status der Schlange. Möglich ist: IN_ACTION, IN_HEAVAN und IN_EXIT.
Der Status gibt an, ob die Schlange noch auf dem Spielfeld aktiv ist (IN_ACTION),
gestorben ist (IN_HEAVEN) oder durch den exit das Spielfeld verlassen hat (IN_EXIT).
Siehe PubConstants für mehr Details.
- See Also:
PubConstants.IN_ACTION
,
PubConstants.IN_HEAVEN
,
PubConstants.IN_EXIT