Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV NEXT | FRAMES NO FRAMES

# Serialized Form

Package de.farafin.snEADy

Class de.farafin.snEADy.C_DebugMonitor extends java.awt.Frame implements Serializable

Serialized Fields

### f

    java.awt.Font[] f

### STRBUFFCAPACITY

    int STRBUFFCAPACITY

### strBuff

    java.lang.StringBuffer strBuff

Package de.farafin.snEADy.control

Class de.farafin.snEADy.control.C_Dummy extends Player implements Serializable

Class de.farafin.snEADy.control.C_Human extends Player implements Serializable

Serialized Fields

### name

    java.lang.String name

Package de.farafin.snEADy.control.GaphixStuff

Class de.farafin.snEADy.control.GaphixStuff.C_WindowArena extends GrDlgWindow implements Serializable

Serialized Fields

### 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

Class de.farafin.snEADy.control.GaphixStuff.C_WindowCommand extends java.awt.Frame implements Serializable

Serialized Fields

### 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

Class de.farafin.snEADy.control.GaphixStuff.C_WindowMain extends GrWindow implements Serializable

Serialized Fields

### 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

Class de.farafin.snEADy.control.GaphixStuff.C_WindowOptions extends GrDlgWindow implements Serializable

Serialized Fields

### 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

Class de.farafin.snEADy.control.GaphixStuff.C_WindowPlayer extends GrDlgWindow implements Serializable

Serialized Fields

### 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

Class de.farafin.snEADy.control.GaphixStuff.C_WindowReplay extends GrDlgWindow implements Serializable

Serialized Fields

### 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

Class de.farafin.snEADy.control.GaphixStuff.GrButton extends java.awt.Canvas implements Serializable

Serialized Fields

### iData

    int iData

### bMode

    int bMode

### bState

    int bState

### oldBState

    int oldBState

### bImage

    java.awt.image.BufferedImage bImage

### w

    int w

### h

    int h

Class de.farafin.snEADy.control.GaphixStuff.GrDlgWindow extends GrWindow implements Serializable

Serialized Fields

### sbutt_quit

    GrButton sbutt_quit

### sbutt_min

    GrButton sbutt_min

Class de.farafin.snEADy.control.GaphixStuff.GrScroll extends java.awt.Canvas implements Serializable

Serialized Fields

### 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

Class de.farafin.snEADy.control.GaphixStuff.GrSelCanvas extends GrTextArea implements Serializable

Serialized Fields

### list

    java.lang.String[] list

### img_list

    java.awt.image.VolatileImage img_list

### img_listSel

    java.awt.image.VolatileImage img_listSel

### selected

    int selected

Class de.farafin.snEADy.control.GaphixStuff.GrTextArea extends java.awt.Canvas implements Serializable

Serialized Fields

### 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

Class de.farafin.snEADy.control.GaphixStuff.GrTextField extends GrTextArea implements Serializable

Serialized Fields

### carr

    boolean carr

### numbersOnly

    boolean numbersOnly

### comm

    java.lang.String comm

### troot

    GrTextField troot

Class de.farafin.snEADy.control.GaphixStuff.GrWindow extends java.awt.Frame implements Serializable

Serialized Fields

### img_bg

    java.awt.image.BufferedImage img_bg

### sroot

    GrWindow sroot

### w

    int w

### h

    int h

Package de.farafin.snEADy.inOut

Class de.farafin.snEADy.inOut.E_LevelFileException extends java.io.IOException implements Serializable

Package de.farafin.snEADy.player

Class de.farafin.snEADy.player.GameInfo extends java.lang.Object implements Serializable

Serialized Fields

### 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.

Class de.farafin.snEADy.player.LevelInfo extends java.lang.Object implements Serializable

Serialized Fields

### 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`

Class de.farafin.snEADy.player.OwnSnakeInfo extends SnakeInfo implements Serializable

Serialized Fields

### 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`

Class de.farafin.snEADy.player.Player extends java.lang.Object implements Serializable

Serialized Fields

### 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.

Class de.farafin.snEADy.player.SnakeInfo extends java.lang.Object implements Serializable

Serialized Fields

### 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`

Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV NEXT | FRAMES NO FRAMES