Batalja spaziale

Rules of the game

The game is a variation of a game named Galcon.

It is a two player game, each player starts with a planet of some size from which the player can send his fleet to neutral planets or opponent's planets.

A player can only send half of the fleet available at a given planet.

A player can take ownership of another planet by sending a larger fleet then the fleet defending the planet.

Every turn new spaceships are produced and added to the planet's fleet depending on the planet's size.

The game is over when:

A player looses its entire fleet
A player takes more then 100ms to answer
A player's answer is invalid
A player forfeits
A player needs more moves then the size (x*y) of the field

How to participate

The competition is structured into two phases, namely development phase, and tournament phase

In the development phase an automatic hudden tournament is available

To submit your player to the hidden tournament you must create a directory in your home folder of your student account named "bataljaspaziale". The folder should contant your player's source code

After the development phase ends, a tournament will be announced in which players will be ranked by playing amongst each other.

Download

Evaluator.jar - the actual game
Gui.jar - graphical interface for Evaluator.jar
GuiGL.zip - graphical interface for Evaluator.jar with OpenGl support
Igralec.java - a sample player

How to run the game is outlined in the Instructions for running the game.

Instructions for creating a player

A player must be a standard java program, that uses the standard input and standard output to communicate with the game.
The player's main function must be in the file named Igralec.java - without the use of packages, jars, ..
A player MUST NOT:

use the network
access (not even read) the filesystem outside of its directory
run system commands
try to win the game by any other means then the commands outlined below
be a copy of another player :)
The above lines will be filled if the need arises and will be enforced retroactively

Commands that a player sends to the game are in the form:

<character that simoblizes the command> <parameters>

All available commands:

command	parameters	description	sender
U	<int>,<int>,<string>	Universe - size (x in y) playing field (allways 100,100), and your color	game
P	<int>,<int>,<int>,<float>,<int>,<string>	Planet: - name (number), - position x, - position y, - planet size, - fleet size, - planet color (red, blue or null)	game
F	<int>,<int>,<int>,<int>,<int>,<int>	Fleet: - flee name (number), - fleet size - origin planet - destination planet - current turn - number of needed turns	igra
S	-	Start - when a player receives this command from the game, it must answer with a series of `A`, followed by an `E`	game
A	<int>,<int>	Attack: - origin planet - destination planet	player
E	-	Player sends at the end of an attack	player
L	<String>	Player can send this command to forfeit the game, the parameters are displayed as the reason for forfeiting	igra, player

Example of a played game:

game	player
U 100 100 red P 1 10 20 0.6 60 red P 2 90 80 0.6 60 blue S P 1 10 20 0.6 36 red P 2 90 80 0.6 66 blue F 1 30 1 2 1 8 S ...	A 1 2 E ...	The game sends the size of the playing field The game sends the data for the first planet The game sends the data for the second planet The game signals the player so it can start with its attacks Player attacks Player ends with the attacks The game sends the data for the first planet The game sends the data for the second planet The game sends data about the fleet The game signals the player so it can start with its attacks

game

player

U 100 100 red
P 1 10 20 0.6 60 red
P 2 90 80 0.6 60 blue
S


P 1 10 20 0.6 36 red
P 2 90 80 0.6 66 blue
F 1 30 1 2 1 8
S
...





A 1 2
E




...

The game sends the size of the playing field
The game sends the data for the first planet
The game sends the data for the second planet
The game signals the player so it can start with its attacks
Player attacks
Player ends with the attacks
The game sends the data for the first planet
The game sends the data for the second planet
The game sends data about the fleet
The game signals the player so it can start with its attacks

Instructions for running the game

The game is ran by moving into the directory you downloaded Evaluator.jar to, and by running:

java -jar Evaluator.jar SpaceBattleship <player1> <player2>

as an example, if you moved the downloaded player into the folder TestPlayer and the folder MyPlayer contains the code of the player you are developing, you run the game as:

java -jar Evaluator.jar SpaceBattleship TestPlayer MyPlayer

If you also want to download Gui.jar, that draws the game realtime you can run it as:

java -jar Evaluator.jar SpaceBattleship <Player1> <Player2> | java -jar Gui.jar

If you want to download GuiGL.zip, that draws the game realtime using OpenGl you can run it as:

java -jar Evaluator.jar SpaceBattleship <Player1> <Player2> | java -Djava.library.path=GuiGL_lib -jar GuiGL.jar

FAQ

Direct your questions to Aleksandar

How much time do we have for developing our player?

It depends on the activity. When contestants stop updating their players for a longer period of time, the development phase will conclude.

Are there any prizes for the winning players

Yes! The details of the prizes are yet to be announced as they will be adjusted depending on the number of players in the tournament.
The rewards are funded by the Student Council of UP FAMNIT and the Department of Information Sciences and Technologies.

Can I compete?

If you are a batchelor student on UP FAMNIT, you can!

Will all players compete in the final tournament?

Depends on the participation. If a lot of players are submited, only a percentage of best players will face in the final tournament.