Gra symultaniczna
-----------------
Waszym zadaniem bedzie napisanie srodowiska, w ktorym beda prowadzone rozgrywki
w prosta zabijankowa gre.

Gra odbywa sie na planszy o rozmiarach 50x50 i bierze w niej udzial co najmniej
dwoch zawodnikow. Zawodnicy na przemian wykonuja ruchy. Jeden ruch polega na
przesunieciu sie na sasiednie pole lub oddaniu strzalu w dowolnym kierunku na
odleglosc 3.  Jesli oznaczymy zawodnika przez Z, to w jednym ruchu moze sie on
przesunac na pola oznaczone przez R:

                             R
                            RZR
                             R

Pod ostarzalem zawodnika na polu Z znajduja sie pola na oznaczone przez S:

                             S
                             S
                             S
                          SSSZSSS
                             S
                             S
                             S

Strzal "zatrzymuje sie" na pierwszym trafionym zawodniku. Strzal jest
wykonywany w konkretne pole pod ostrzalem. Nie mozna rownoczesnie wykonac ruchu
i strzalu.  To musza byc dwa oddzielne ruchy.

Na poczatku zawodnicy sa wrzucani w losowe miejsce planszy.  Trafiony zawodnik
jest zabijany, co oznacza, ze jego zabojca otrzymuje 1pkt (frag) a zabity
zmartwychwstaje w losowym miejscu.  Wygrywa ten, kto po 1000 turach ruchow
(jedna tura = 1 ruch dla kazdego zawodnika) zdobedzie najwiecej punktow.

Zawodnik nie moze wejsc na pole, na ktorym stoi inny zawodnik (lepiej jest go
zabic!).

Zadaniem bedzie napisanie infrastruktury do tej gry i przykladowej strategii
gry (patrz ponizej). Dostepne musza byc nastepujace funkcje:

1) wyswietlanie przebiegu gry.
2) zastopowanie i wznowienie gry.
3) ustawienie tempa gry (jaki jest odstep miedzy poszczegolnymi ruchami).
4) puszczenie gry bez wyswietlania.
5) przerwanie gry.
6) rozpoczecie nowej gry.
7) wyswietlenie stanu punktacji (najlepiej on-line).

Strategie zawodnikow
--------------------
Zawodnik jest klasa, ktora zawiera definicje jego strategii. Program bedacy
infrastruktura jest kompilowany z kilkoma programami zawodnikow, ktorzy beda
walczyc na planszy.

Zawodnik musi udostepniac konstruktor bezargumentowy oraz metode ruch, ktorej
argumentami jest liczba ruchow postalych do konca gry (n), polozenie zawodnika
(x i y), aktualny stan planszy (p): 

Smalltalk	ruchNr: n zX: x zY: y naPlanszy: p
C++/Java	Ruch ruch(int n, int x, int y, Plansza p)

Wynikiem zwracanym przez te metode jest obiekt typu Ruch, ktory z punktu
widzenia zawodnika ma jedynie konstruktor z trzema argumentami: rodzaj ruchu
(0 = przesuniecie, 1 = strzal), x i y (pozycja ostrzeliwana, lub pozycja na
ktora przechodzimy).

Smalltalk	Ruch new: rodzaj naX: x naY: y
C++/Java	Ruch(rodzaj, x, y)

Zawodnik, ktory wykona nielegalny ruch jest dyskwalifikowany.

Obiekt Plansza ma metode czyJest, ktora pozwala sprawdzic czy na polu x, y
znajduje sie zawodnik.

Smalltalk       czyJestNaX: x naY: y
C++/Java        int czyJest(x, y) 

Wynikiem jest wartosc logiczna (prawda jesli na x, y znajduje sie jakis
zawodnik).  Zawodnik moze pytac o dowolne pole planszy, ktora mu przekazano
jako argument metody ruch.

Wpolrzedne pol planszy sa liczbami calkowitymi z przedzialu 0..49.  Punkt (0,0)
znajduje sie w lewym dolnym rogu.

Prosze trzymac sie tego protokolu, aby zawodnicy roznych studentow mogli ze
soba powalczyc wkompilowani w jedna infrastrukture.

Wasz zawodnik musi byc podklasa klasy abstrakcyjnej zawodnik, lub musi
realizowac interfejs Zawodnik (w Javie).

Zaliczenie
----------
Zaliczenie bedzie polegalo na obejrzeniu jak dzialaja Wasze infrastruktury i
obejrzeniu przykladowej gry, w ktorej udzial wezmie kilka egzemplarzy Waszego
przykladowego gracza.  Mile widziane beda rozwiazania zawierajace wiecej
strategii zawodnikow.  Bedziemy chcieli porownac takze strategie zawodnikow
roznych studentow.

Do otrzymania bdb nie jest wymagane napisanie super strategii. Ocenie podlega
raczej dopracowanie infrastruktury i zachowanie opisane powyzej interfejsu.
Chociaz mamy nadzieje obudzic w Was ducha rywalizacji przeprowadzajac zawody
miedzy programami napisanymi w tych samych jezykach programowania.

Jezyk programowania
-------------------
Do wyboru Java/C++/Smalltalk.

Definicje w C++
---------------
class Plansza {
  public:
    int czyJest(int x, int y);
  // ewentualnie inne
};

class Ruch {
  public:
    Ruch (int rodzaj, int x, int y);
  // ewentualnie inne
};

class Zawodnik {
  public:
    Zawodnik() {}
    virtual Ruch ruch(int n, int x, int y, Plansza p) = 0;
};

Definicje w Java
----------------
class Plansza {
  public 
  int czyJest(int x, int y) { return 0; // oczywscie cos innego tu musi byc 
                            }
  // ewentualnie inne
} 

class Ruch {
  public 
    Ruch (int rodzaj, int x, int y) {}
  // ewentualnie inne
} 

interface Zawodnik {
  public 
    Ruch ruch(int n, int x, int y, Plansza p);
}

Definicje w Smalltalku
----------------------
Klasa Plansza musi miec metode instancyjna, ktora zwraca true/false:

  czyJestNaX: x naY: y

Klasa Ruch musi miec metode klasowa (konstruktor):

  new: rodzaj naX: x naY: y

Klasa Zawodnik musi miec metode instancyjna, ktora zwraca obiekt klasy Ruch.
  
  ruchNr: n zX: x zY: y naPlanszy: p

Powodzenia
----------
Wszystkie pytania kierowac do Krzysztofa Stencla: stencel@mimuw.edu.pl