using System;
using System.IO;
using System.Collections.Generic;
using System.Collections;
using System.Xml;
using System.Net;
using System.Net.Sockets;
using System.Text;
using System.Threading;
//#using System.Windows.Forms;
using das.sit;
using das.disk;

namespace das.hra {
/******************************************************************************/
public static class KONSTANTY
/******************************************************************************/
{
  public const int KUN = 1;
  public const int TAH = 2;
  public const int PENIZE = 3;
  public const int DISTANC = 4;
  public const int NAHODA = 5;
  public const int FINANCE = 6;
  public const int PARKOVISTE = 7;
  public const int TRENER = 8;
  public const int PREPRAVA = 9;
  public const int STAJE = 10;
  public const int DOPING = 11;
}

public static class prenos
{
  public static string data;
}

/******************************************************************************/
public class trida_stolba
/******************************************************************************/
{
  public Hashtable seznam_konu = new Hashtable();
  public Hashtable staje = new Hashtable();
  public Hashtable dostihy = new Hashtable();
  public Hashtable sazky = new Hashtable();

  int flag_kun = 0;
  int flag_jmeno = 0;
  int flag_cena = 0;
  int flag_staj = 0;
  int flag_dostih1 = 0;
  int flag_dostih2 = 0;
  int flag_dostih3 = 0;
  int flag_dostih4 = 0;
  int flag_hlavnidostih = 0;
  int flag_naklady = 0;
  int flag_nakladyhlavni = 0;
  int flag_prohlidka = 0;
  string staj ="";

  public trida_stolba()
  {
    nacti_kone();
    zobraz_kone();
//    Environment.Exit(0);
  }

  public void zobraz_kone()
  {
    foreach(DictionaryEntry d in seznam_konu) {
    trida_kun kk = (trida_kun)d.Value;
    zpravy.log("Key = "+ d.Key + ", Value = "+kk.get_jmeno());
    zpravy.log("* pořizovací cena koně: " + kk.get_cena());
    zpravy.log("* prohlídka stáje: " + kk.get_prohlidka_staje()); 
    zpravy.log("* zisk z jednoho dostihu: " + kk.get_dostih1());
    zpravy.log("* zisk ze dvou dostihů: " + kk.get_dostih2());
    zpravy.log("* zisk ze tří dostihů: " + kk.get_dostih3());
    zpravy.log("* zisk ze čtyř dostihů: " + kk.get_dostih4());
    zpravy.log("* zisk z hlavního dostihu sezony: " + kk.get_dostih_hlavni());
    zpravy.log("* náklady na přípravu koně na každý nový dostih: " + kk.get_naklady_dostih());
    zpravy.log("* staj: " + zjisti_staj_kone(kk.get_jmeno()));
    }
  }

  public void vynuluj_dostihy()
  {
    dostihy.Clear();
  }

  public string jmenny_seznam_koni()
  {
    string seznam = "";
    foreach(DictionaryEntry d in seznam_konu) {
      trida_kun kk = (trida_kun)d.Value;
      seznam = seznam + kk.get_jmeno() + " ";
    }
    return seznam;
  }

  public List<string> get_seznam_konu_ve_staji(string staj)
  {
    return (List<string>)staje[staj];
  }

  public void kup_dostih(string kun)
  {
    try {
      dostihy.Add(kun, 1);
    } catch {
      dostihy[kun] = (int)dostihy[kun] + 1;
    }
  }

  public int pocet_dostihu(string kun)
  {
    try {
      return (int)dostihy[kun];
    } catch {
      return 0;
    }
  }

  public void zrus_dostih(string kun)
  {
    if (pocet_dostihu(kun) > 0) {
      dostihy[kun] = (int)dostihy[kun] - 1;
    }
  }

  public void zrus_vsechny_dostihy(string kun)
  {
    dostihy[kun] = 0;
  }

  void prirad_kone_do_staje (string staj, string kun)
  {
    if (staje.ContainsKey(staj)) {
      List<string> list_konu = (List<string>)staje[staj];
      list_konu.Add(kun);
    } else {
      List<string> list_konu = new List<string>();
      list_konu.Add(kun);
      staje.Add(staj, list_konu);
    }
  }

  public void vsad_na_kone(string kun, int sazka)
  {
    try {
      sazky.Add(kun, sazka);
    } catch {
      zpravy.log("na kone je jiz vsazeno"+kun+" "+sazka);
    }
  }

  public int kolik_je_vsazeno_na_kone(string kun)
  {
    try {
      return (int)sazky[kun];
    } catch {
      return 0;
    }
  }

  public void zrus_sazky()
  {
    sazky.Clear();
  }

  public string zjisti_staj_kone(string kun)
  {
    foreach (DictionaryEntry polozka in staje) {
      foreach (string s in (List<string>)polozka.Value)
      {
        if (kun == s) {
          return (string)polozka.Key;
        }
      }
    }
    return "nema staj";
  }

  void reset_flagu ()
  {
    flag_jmeno = 0;
    flag_cena = 0;
    flag_staj = 0;
    flag_prohlidka = 0;
    flag_dostih1 = 0;
    flag_dostih2 = 0;
    flag_dostih3 = 0;
    flag_dostih4 = 0;
    flag_hlavnidostih = 0;
    flag_naklady = 0;
    flag_nakladyhlavni = 0;
    staj = "";
  }

  public void nacti_kone() 
  {
    reset_flagu();
    trida_kun k = new trida_kun("new");
    XmlTextReader reader = null;

    try {
      reader = new XmlTextReader("kone.xml");
    } catch {
      zpravy.log("chybi kone.xml");
      Environment.Exit(1);
    }

    while (reader.Read()) { 
      switch (reader.NodeType) { 
        case XmlNodeType.Element: 
          switch (reader.Name) {
            case "kun"          : flag_kun = 1;
              k = new trida_kun("kun");
              break;
            case "jmeno"        : flag_jmeno = 1; break;
            case "cena"         : flag_cena = 1; break;
            case "staj"         : flag_staj = 1; break;
            case "prohlidka"    : flag_prohlidka = 1; break;
            case "dostih1"      : flag_dostih1 = 1; break;
            case "dostih2"      : flag_dostih2 = 1; break;
            case "dostih3"      : flag_dostih3 = 1; break;
            case "dostih4"      : flag_dostih4 = 1; break;
            case "hlavnidostih" : flag_hlavnidostih = 1; break;
            case "naklady"      : flag_naklady = 1; break;
            case "nakladyhlavni": flag_nakladyhlavni = 1; break;
          }
          break;
        case XmlNodeType.EndElement: 
          switch (reader.Name) {
            case "kun"          : 
              flag_kun = 0;
              seznam_konu.Add(k.get_jmeno(), k);
              prirad_kone_do_staje(staj, k.get_jmeno());
              reset_flagu();
              break;
            case "jmeno"        : flag_jmeno = 0; break;
            case "cena"         : flag_cena = 0; break;
            case "staj"         : flag_staj = 0; break;
            case "prohlidka"    : flag_prohlidka = 0; break;
            case "dostih1"      : flag_dostih1 = 0; break;
            case "dostih2"      : flag_dostih2 = 0; break;
            case "dostih3"      : flag_dostih3 = 0; break;
            case "dostih4"      : flag_dostih4 = 0; break;
            case "hlavnidostih" : flag_hlavnidostih = 0; break;
            case "naklady"      : flag_naklady = 0; break;
            case "nakladyhlavni": flag_nakladyhlavni = 0; break;
          }
          break;
        case XmlNodeType.Text:
          string parametr = reader.Value;
          if (flag_kun == 1) {
            if (flag_jmeno == 1) {k.set_jmeno(parametr);}
            if (flag_cena == 1) {k.set_cena(Convert.ToInt32(parametr));}
            if (flag_prohlidka == 1) {k.set_prohlidka_staje(Convert.ToInt32(parametr));}
            if (flag_staj == 1) {staj = parametr;}
            if (flag_dostih1 == 1) {k.set_dostih1(Convert.ToInt32(parametr));}
            if (flag_dostih2 == 1) {k.set_dostih2(Convert.ToInt32(parametr));}
            if (flag_dostih3 == 1) {k.set_dostih3(Convert.ToInt32(parametr));}
            if (flag_dostih4 == 1) {k.set_dostih4(Convert.ToInt32(parametr));}
            if (flag_hlavnidostih == 1) {k.set_dostih_hlavni(Convert.ToInt32(parametr));}
            if (flag_naklady == 1) {k.set_naklady_dostih(Convert.ToInt32(parametr));}     
            if (flag_nakladyhlavni == 1) {k.set_naklady_dostih_hlavni(Convert.ToInt32(parametr));}
          }
          break;
        default:break;
      }
    }//while
  }

  public trida_kun get_kun(string jmeno)
  {
    if (!seznam_konu.ContainsKey(jmeno)) {
      throw new System.InvalidOperationException("neznamy kun");
    }
    trida_kun xx = (trida_kun)seznam_konu[jmeno];
    return xx;
  }
}

/******************************************************************************/
public class trida_figurka {
/******************************************************************************/
  List<string> stado = new List<string>();
  string barva;
  int pozice;
//  int kolo;
  int distanc;
  int penize;
  string jmeno;
  public int stop;
  public int typ;  //1 clovek, 0 pocitac
  private bool cervena_cisla = false;

  public void pocitac() {
    typ = 0;
  }
  public void clovek() {
    typ = 1;
  }

  public bool je_clovek() {
    if (typ == 1) {return true;}
    return false;
  }

  public void koupit_kone(string k, int cena_kone)
  {
    stado.Add(k);
    penize -= cena_kone;
  }

  public void vratit_kone(string k)
  {
    stado.Remove(k);
  }

  public bool bankrot()
  {
    return cervena_cisla;
  }

  public void zbankrotuj()
  {
    cervena_cisla = true;
  }

  public List<string> get_stado()
  {
    return stado;
  }

  public void set_stado (List<string> x)
  {
    stado = x;
  }

  public void prohlidka_staji(int i)
  {
    penize -= i;
  }

  public bool zaplat(int i)
  {
    if (penize >=  Math.Abs(i)) {
      penize -= Math.Abs(i);
      return true;
    } else {
      return false;
    }
  }

  public void vydelej(int i)
  {
    penize += Math.Abs(i);
  }

  public void prodat_kone(string k)
  {
    bool vysledek = stado.Remove(k);
    zpravy.log("Odebrat kone"+vysledek);
  }

  public bool vlastni_kone(string jmeno_kone)
  {
    return stado.Exists(element => element == jmeno_kone);
  }

  public trida_figurka(string b, int p, int m)
  {
    barva = b;
    pozice = p;
//    kolo = 0;
    penize = m;
    jmeno = "";
  }

/*  public trida_figurka(int p, int m)
//  {
    pozice = p;
//    kolo = 0;
    penize = m;
    jmeno = "";
  }*/

  public int get_penize()
  {
    return penize;
  }

  public void set_penize(int p)
  {
    penize = p;
  }

  public int get_pozice()
  {
    return pozice;
  }

  public void set_pozice(int p)
  {
    pozice = p;
  }

  public string get_jmeno()
  {
    return jmeno;
  }

  public void set_jmeno(string j)
  {
    jmeno = j;
  }

  public int get_distanc() {
    return distanc;
  }

  public string get_barva() {
    return barva;
  }

  public void set_barva(string s) {
    barva = s;
  }

  public void set_distanc(int d) {
    distanc = d;
  }
  
  public bool ceka () {
    return (stop > 0);
  }

  public void probehlo_kolo () {
    if (ceka()) {stop--;}
  }

  public void jdi_na_distanc () {
    distanc = 1;
    pozice = 10;
  }
}

/******************************************************************************/
public class trida_kostka {
/******************************************************************************/
  Random randObj;
  public trida_kostka() {
    randObj = new Random();
  }
  public int hod() {
    return randObj.Next(6) + 1;
  }
}

/******************************************************************************/
public class trida_banker {
/******************************************************************************/
  int bank;
  int[] ucet = new int[6];

  public trida_banker()
  {
    for (int i = 0; i < 6; i++) {
      ucet[i] = 0;
    }
    bank = 199700;
  }

  public int max_bank()
  {
    return 199700;
  }

  public bool pujcit(int hrac, int obnos)
  {
    if (bank >= obnos) {
      ucet[hrac] -= obnos;
      bank -= obnos;
      return true;
    }
    return false;
  }

  public void vratit(int hrac, int obnos)
  {
    ucet[hrac] += obnos;
  }

  public int zakladni_jmeni()
  {
    bank -= 30000;
    return 30000;
  }

  public int get_bank() {
    return bank;
  }

  public void set_bank(int b) {
    bank = b;
  }

  public void vloz_do_banku(int i)
  {
    bank += i;
  }
  public void vezmi_z_banku(int i)
  {
    bank -= i;
  }
}

/******************************************************************************/
public class trida_karta
/******************************************************************************/
{
  public string text {get; set;}
  public int penize;
  public int posun;
  public int kam;
  public int dostih;
  public int hdostih;
  public int akce;
  public int typ;
  public int stop;
  public string nejblizsi;
  public int osvobozeni;
}

/******************************************************************************/
public class trida_sluzby
/******************************************************************************/
{
  public int preprava;
  public int staj;
  public int[] trener = new int[4];
  public int osvobozeni;

  public int cena_staji = 3000;
  public int cena_prepravy = 3000;
  public int cena_trenera = 1000;

  public trida_sluzby()
  {
    for (int i = 0; i < 4; i++) {
      trener[i] = -1;
    }
    preprava = -1;
    staj = -1;
    osvobozeni = -1;
  }

  public void koupit_trenera(int hrac, int id_trenera)
  {
    zpravy.log ("trida_sluzby.koupit_trenera("+hrac+","+id_trenera+")");
    trener[id_trenera - 1] = hrac;
  }

  public void prodat_trenera(int id_trenera)
  {
    zpravy.log ("trida_sluzby.prodat_trenera("+id_trenera+")");
    trener[id_trenera - 1] = -1;
  }

  public void koupit_prepravu(int hrac)
  {
    preprava = hrac;
  }

  public void koupit_staje(int hrac)
  {
    staj = hrac;
  }

  public bool prodat_prepravu(int hrac)
  {
    if (preprava == hrac) {
      preprava = -1;
      return true;
    }
    return false;
  }

  public bool prodat_staje(int hrac)
  {
    if (staj == hrac) {
      staj = -1;
      return true;
    }
    return false;
  }

  public void prodat_prepravu()
  {
    preprava = -1;
  }

  public void prodat_staje()
  {
    staj = -1;
  }

  public int vlastnik_staje()
  {
    return staj;
  }

  public int vlastnik_prepravy()
  {
    return preprava;
  }

  public int vlastnik_trenera(int id_trenera)
  {
    return trener[id_trenera - 1];
  }

  public int vlastnik(string nazev_sluzby)
  {
    int navrat = -1;
    switch (nazev_sluzby) {
      case "trener1": navrat = vlastnik_trenera(1); break;
      case "trener2": navrat = vlastnik_trenera(2); break;
      case "trener3": navrat = vlastnik_trenera(3); break;
      case "trener4": navrat = vlastnik_trenera(4); break;
      case "staje":   navrat = vlastnik_staje(); break;
      case "preprava":navrat = vlastnik_prepravy(); break;
    }
    return navrat;
  }

  public int prodej_sluzbu_podle_jmena(string nazev_sluzby)
  {
    int navrat = -1;
    switch (nazev_sluzby) {
      case "trener1": navrat = cena_trenera; prodat_trenera(1); break;
      case "trener2": navrat = cena_trenera; prodat_trenera(2); break;
      case "trener3": navrat = cena_trenera; prodat_trenera(3); break;
      case "trener4": navrat = cena_trenera; prodat_trenera(4); break;
      case "staje":   navrat = cena_staji; prodat_staje(); break;
      case "preprava":navrat = cena_prepravy; prodat_prepravu(); break;
    }
    return navrat;
  }

  public int pocet_vlastnenych_treneru(int hrac)
  {
    int pocet = 0;
    for (int i = 0; i < 4; i++) {
      if (trener[i] == hrac) {pocet++;}
    }
    return pocet;
  }

  public void preved(string co, int odkoho, int komu)
  {
    zpravy.log ("trida_sluzby.preved("+co+","+odkoho+","+komu+")");
    if (odkoho == -1) {
      zpravy.log ("trida_sluzby.preved: vlastnik neznamy koncim");
      return;
    }
    switch (co) {
      case "trener1": prodat_trenera(1); koupit_trenera(komu,1); break;
      case "trener2": prodat_trenera(2); koupit_trenera(komu,2); break;
      case "trener3": prodat_trenera(3); koupit_trenera(komu,3); break;
      case "trener4": prodat_trenera(4); koupit_trenera(komu,4); break;
      case "staje": prodat_staje(odkoho); koupit_staje(komu); break;
      case "preprava": prodat_prepravu(odkoho); koupit_prepravu(komu); break;
    }
  }

}

/******************************************************************************/
public class trida_fortuna
/******************************************************************************/
{
//  Hashtable fn = new Hashtable();

  Queue<trida_karta> finance = new Queue<trida_karta>();
  Queue<trida_karta> nahoda = new Queue<trida_karta>();
  trida_karta pomocna_karta;
  
  int flag_akce;
//  int flag_fn;
  int flag_typ;
  int flag_text;
  int flag_posun;
  int flag_kam;
  int flag_penize;
  int flag_dostih;
  int flag_hdostih;
  int flag_stop;
  int flag_nejblizsi;
  int flag_osvobozeni;
//  string nejblizsi;
//flagy na dodelani:hrac

  public trida_fortuna()
  {
    nacti_fn();
    //Environment.Exit(0);
  } 

  void reset_flagu ()
  {
//    flag_fn = 0;
    flag_typ = 0;
    flag_text = 0;
    flag_posun = 0;
    flag_kam = -1;
    flag_penize = 0;
    flag_dostih = 0;
    flag_hdostih = 0;
    flag_stop = 0;
    flag_nejblizsi = 0;
    flag_osvobozeni = 0;
  }

  public trida_karta vytahni_karticku_finance()
  {
    trida_karta pk;
    pk = finance.Dequeue();
    finance.Enqueue(pk);
    return pk;
  }

  public trida_karta vytahni_karticku_nahoda()
  { 
    trida_karta pk;
    pk = nahoda.Dequeue();
    nahoda.Enqueue(pk);
    return pk;
  }

  public void nacti_fn()
  {
    string text;
    int penize = 0;
    int posun = 0;
    int kam = -1;
    int dostih = 0;
    int hdostih = 0;
    int stop = 0;
    int osvobozeni = 0;
    string nejblizsi = "";
    text = "";

    reset_flagu();
    XmlTextReader reader = null;
    try {
    reader = new XmlTextReader("fn.xml");
    } catch {
      zpravy.log("chybi fn.xml");
      Environment.Exit(1);
    }

    zpravy.log("nacti_fn(): start");

    while (reader.Read()) {
      switch (reader.NodeType) {
        case XmlNodeType.Element:
          switch (reader.Name) {
            case "akce" : flag_akce = 1; break;
            case "fn" : flag_typ = 1; break;
            case "text" : flag_text = 1; break;
            case "posun" : flag_posun = 1; break;
            case "kam" : flag_kam = 1; break;
            case "penize" : flag_penize = 1; break;
            case "dostih" : flag_dostih = 1; break;
            case "hdostih" : flag_hdostih = 1; break;
            case "stop" : flag_stop = 1; break;
            case "nejblizsi" : flag_nejblizsi = 1; break;
            case "osvobozeni" : flag_osvobozeni = 1; break;
          }
          if (reader.HasAttributes)  {
            for (int i = 0; i < reader.AttributeCount; i++) {
              reader.MoveToAttribute(i);
              zpravy.log("nacti_fn(): name: " + reader.Name + " value:" + reader.Value);
              if (reader.Name == "typ") {
                if (reader.Value == "Finance") {
                  flag_typ = 1;
                }
                if (reader.Value == "Náhoda"){
                  flag_typ = 2;
                }
              }
            }
          }

          break;
        case XmlNodeType.EndElement:
          switch (reader.Name) {
            case "akce": flag_akce = 0; reset_flagu(); break;
            case "text": flag_text = 0; break;
            case "posun": flag_posun = 0; break;
            case "kam": flag_kam = 0; break;
            case "penize": flag_penize = 0; break;
            case "dostih": flag_dostih = 0; break;
            case "hdostih": flag_hdostih = 0; break;
            case "stop": flag_stop = 0; break;
            case "osvobozeni": flag_osvobozeni = 0; break;
            case "nejblizsi" : flag_nejblizsi = 0; break;
            case "fn": 
              //flag_fn = 0; 
              if (flag_akce == 1) {
                pomocna_karta = new trida_karta();
                pomocna_karta.text = text;
                if (flag_typ == 1) {
                  pomocna_karta.penize = penize;
                  pomocna_karta.dostih = dostih;
                  pomocna_karta.hdostih = hdostih;
                  finance.Enqueue(pomocna_karta);
                  zpravy.log(" pomocna karta: typ1:"+penize+","+dostih+","+hdostih);
                }
                if (flag_typ == 2) {
                  pomocna_karta.posun = posun;
                  pomocna_karta.kam = kam;
                  pomocna_karta.stop = stop;
                  pomocna_karta.nejblizsi = nejblizsi;
                  pomocna_karta.osvobozeni = osvobozeni;
                  zpravy.log(" pomocna karta: typ2:"+posun+","+kam+","+stop+","+nejblizsi+","+osvobozeni);
                  nahoda.Enqueue(pomocna_karta);
                }
                reset_flagu();
                //reset hodnot
                penize = 0;
                posun = 0;
                kam = -1;
                dostih = 0;
                hdostih = 0;
                stop = 0;
                nejblizsi = "";
                osvobozeni = 0;

              }
              break;
          }
          break;
        case XmlNodeType.Text:
          string parametr = reader.Value;
          if (flag_text == 1) {
            text = parametr;
          }
          if (flag_posun == 1) {
            posun = Convert.ToInt32(parametr);
          }
          if (flag_kam == 1) {
            kam = Convert.ToInt32(parametr);
          }
          if (flag_penize == 1) {
            penize = Convert.ToInt32(parametr);
          }
          if (flag_dostih == 1) {
            dostih = Convert.ToInt32(parametr);
          }
          if (flag_hdostih == 1) {
            hdostih = Convert.ToInt32(parametr);
          }
          if (flag_stop == 1) {
            stop = Convert.ToInt32(parametr);
          }
          if (flag_osvobozeni == 1) {
            osvobozeni = 1;
          }
          if (flag_nejblizsi == 1) {
            nejblizsi = parametr;
          }
          break;
        case XmlNodeType.Attribute:
          break;
        default:break;
      }
    }//while
  }
}


/******************************************************************************/
public class trida_akce
/******************************************************************************/
{
  int typ;
  int tah;
  int distanc;
  string k;
  int penize;

  public int trener_id;

  public trida_akce (int t) 
  {
    typ = t;
    tah = 0;
    distanc = 0;
    penize = 0;
    trener_id = 0;
    k = "";
  }

  public int get_distanc() 
  {
    return distanc;
  }

  public void set_distanc(int d) 
  {
    distanc = d;
  }

  public int get_typ() 
  {
    return typ;
  }

  public void set_typ(int a) {
    typ = a;
  }

  //typ akce je kun, penize, tah, distanc
  public string get_kun() 
  {
    if (typ == KONSTANTY.KUN) {
      return k;
    } else {
      return null;
    }
  }

  public void set_kun(string i)
  {
    k = i;
  }

  public int get_penize(){ return penize;}
  public void set_penize(int p){ penize = p;}
  public int get_tah(){return tah;}
  public void set_tah(int t){
    tah = t;
  }

}

/******************************************************************************/
public class trida_kun
/******************************************************************************/
{
  int cena;
  string jmeno;

  int prohlidka_staje;
  int dostih1;
  int dostih2;
  int dostih3;
  int dostih4;
  int dostih_hlavni;
  int naklady_dostih_hlavni;
  int naklady_dostih;

  public trida_kun(string j) {
    jmeno = j;
  }

  public string get_jmeno() {
    return jmeno;
  }

  public void set_jmeno(string j) {
    jmeno = j;
  }

  public int get_cena() {
    return cena;
  }

  public void set_cena(int c) {
    cena = c;
  }
  
  public int get_prohlidka_staje() {
    return prohlidka_staje;
  }

  public void set_prohlidka_staje(int x) {
    prohlidka_staje = x;
  }

  public int get_dostih1() {
    return dostih1;
  }

  public void set_dostih1(int x) {
    dostih1 = x;
  }

  public int get_dostih2() {
    return dostih2;
  }

  public void set_dostih2(int x) {
    dostih2 = x;
  }

  public int get_dostih3() {
    return dostih3;
  }

  public void set_dostih3(int x) {
    dostih3 = x;
  }

  public int get_dostih4() {
    return dostih4;
  }

  public void set_dostih4(int x) {
    dostih4 = x;
  }

  public int get_dostih_hlavni() {
    return dostih_hlavni;
  }

  public void set_dostih_hlavni(int x) {
    dostih_hlavni = x;
  }

  public int get_naklady_dostih() {
    return naklady_dostih;
  }

  public void set_naklady_dostih(int x) {
    naklady_dostih = x;
  }

  public int get_naklady_dostih_hlavni() {
    return naklady_dostih_hlavni;
  }

  public void set_naklady_dostih_hlavni(int x) {
    naklady_dostih_hlavni = x;
  }

}

// class ukol {}

/******************************************************************************/
public class trida_hraci_plocha
/******************************************************************************/
{
  public trida_akce[] policka = new trida_akce[40];
  public trida_figurka[] figurka = new trida_figurka[6];
  public trida_kostka kostka;

  int kolo;

  public trida_hraci_plocha () 
  {
    kostka = new trida_kostka();
    nacti_plochu();
  }


  public int get_kolo() 
  {
    return kolo;
  }

  public void set_kolo(int k) 
  {
    kolo = k;
  }

  public void nove_kolo() 
  {
    kolo++;
  }

  public int nejblizsi_trener(int pozice)
  {
    int i = 0;
    int j = 0;

    for (i = pozice; i < 40; i++) {
      if (policka[i].get_typ() == KONSTANTY.TRENER) {break;}
    }
    for (j = pozice; j > 0; j++) {
      if (policka[j].get_typ() == KONSTANTY.TRENER) {break;}
    }
    if (pozice - j > i - pozice) {
      return i;
    } else {
      return j;
    }
  }

  public int nejblizsi(int pozice, int co)
  {
    int i = 0;
    int j = 0;

    for (i = pozice; i < 40; i++) {
      if (policka[i].get_typ() == co) {break;}
    }
    for (j = pozice; j > 0; j--) {
      if (policka[j].get_typ() == co) {break;}
    }
    if (pozice - j > i - pozice) {
      return i;
    } else {
      return j;
    }
  }

  public int cislo_hrace_podle_jmena(string jmeno)
  {
    for (int i = 0; i < 6; i++) {
      if (figurka[i].get_jmeno() == jmeno) {
        return i;
      }
    }
    return -1;
  }

  public void nacti_plochu ()
  {
    int pole_flag = 0;
    int akce_flag = 0;
    int typ_akce = 0;
    int pole_id = 0;
    int hodnota_penez = 0;
    string jmeno_kone = "";
    int delka_distanc = 0;
    int trener_id = 0;

    try {

      XmlTextReader reader = null;
      try {
        reader = new XmlTextReader("hraci_plocha.xml");
      } catch {
        zpravy.log("chybi hraci_plocha.xml");
        Environment.Exit(1);
      }

      while (reader.Read()) {
        switch (reader.NodeType) {
          case XmlNodeType.Element:
            //string strURI = reader.NamespaceURI;
            if (reader.Name == "pole") {
              pole_flag = 1; 
            }
            if (reader.Name == "akce") {
              akce_flag = 1; 
            }
            if (reader.Name == "staj") {
              //staj_flag = 1; 
            }
            if (reader.HasAttributes) { 
              for (int i = 0; i < reader.AttributeCount; i++) { 
                reader.MoveToAttribute(i); 
                if (pole_flag == 1 && reader.Name == "id") {
                  pole_id = Convert.ToInt32(reader.Value);
                  typ_akce = 0; 
                }
                if (akce_flag == 1 && reader.Name == "typ") {
                  switch (reader.Value) { 
                    case "kun":     typ_akce = KONSTANTY.KUN;     zpravy.log("nasel kone " + reader.Name);break;
                    case "penize":  typ_akce = KONSTANTY.PENIZE;  zpravy.log("nasel penize (veterina) " + reader.Name);break;
                    case "trener":  typ_akce = KONSTANTY.TRENER;  zpravy.log("nasel trener " + reader.Name);break;
                    case "distanc": typ_akce = KONSTANTY.DISTANC; zpravy.log("nasel distanc " + reader.Name);break;
                    case "nahoda":
                    case "náhoda":  typ_akce = KONSTANTY.NAHODA;  zpravy.log("nasel nahoda " + reader.Name);break;
                    case "finance": typ_akce = KONSTANTY.FINANCE; zpravy.log("nasel finance " + reader.Name);break;
                    case "preprava": typ_akce = KONSTANTY.PREPRAVA; zpravy.log("nasel preprava " + reader.Name);break;
                    case "staje": typ_akce = KONSTANTY.STAJE; zpravy.log("nasel staje " + reader.Name);break;
                    case "nic": typ_akce = KONSTANTY.PARKOVISTE;  zpravy.log("nasel parking " + reader.Name);break;
                    case "doping": typ_akce = KONSTANTY.DOPING;  zpravy.log("nasel doping " + reader.Name);break;
                    default: break;
                  }
                }
              }
            }
            break; 
          case XmlNodeType.EndElement: 
            if (reader.Name == "pole") {
              pole_flag = 0;
              zpravy.log(" policko:" + pole_id + " akce:" + typ_akce + " jmeno kone:" + jmeno_kone + " trener_id:" + trener_id + " penize:"+hodnota_penez+ " doping:"+delka_distanc);
              policka[pole_id] = new trida_akce(typ_akce);
              switch (typ_akce) { 
                case KONSTANTY.KUN: 
                  policka[pole_id].set_kun(jmeno_kone);
                  jmeno_kone = "";
                break;
                case KONSTANTY.PENIZE:
                  policka[pole_id].set_penize(hodnota_penez);
                  hodnota_penez = 0;
                break;
                case KONSTANTY.DISTANC: 
                  policka[pole_id].set_distanc(delka_distanc);
                  delka_distanc = 0;
                break; 
                case KONSTANTY.TRENER: 
                  policka[pole_id].trener_id = trener_id;
                  trener_id = 0;
                break; 
                case KONSTANTY.DOPING: 
                  policka[pole_id].set_distanc(delka_distanc);
                  delka_distanc = 0;
                break; 
                case KONSTANTY.NAHODA:
                break;
                case KONSTANTY.FINANCE:
                break;
                default: break;
              }
            }
            if (reader.Name == "akce") {akce_flag = 0;}
            if (reader.Name == "staj") {}
            break;
          case XmlNodeType.Text:
            if (akce_flag == 1 && typ_akce != 0){
              switch (typ_akce) { 
                case KONSTANTY.KUN: jmeno_kone = reader.Value; break;
                case KONSTANTY.PENIZE: hodnota_penez = Convert.ToInt32(reader.Value); break;
                case KONSTANTY.DISTANC: delka_distanc = Convert.ToInt32(reader.Value); break; 
                case KONSTANTY.DOPING: delka_distanc = Convert.ToInt32(reader.Value); break; 
                case KONSTANTY.TRENER: trener_id = Convert.ToInt32(reader.Value); break;
                case KONSTANTY.PREPRAVA: break;
                case KONSTANTY.STAJE:  break;
                case KONSTANTY.FINANCE: break;
                case KONSTANTY.NAHODA:  break;
                default: break;
              }
            }
            break;
          default: 
          break; 
        }
      } 
    } catch (XmlException e) { 
      zpravy.log("error occured: " + e.Message); 
    } 
  }
}


/******************************************************************************/
public class trida_manazer
/******************************************************************************/
{
  trida_hraci_plocha hra = new trida_hraci_plocha();
  trida_stolba kone = new trida_stolba();
  trida_fortuna fn = new trida_fortuna();
  trida_sluzby sluzby = new trida_sluzby();
  trida_banker banker = new trida_banker();

  int pocet_lidi;
  int pocet_pocitacu;

  public trida_manazer(int lide, int pocitace)
  {
    for (int ii = 0; ii < 6; ii++) {
      hra.figurka[ii] = new trida_figurka("", 0, banker.zakladni_jmeni());
    }
    for (int i = 0; i < lide; i++) {
      hra.figurka[i].typ = 1;
    }
    for (int i = 0; i < pocitace; i++) {
      hra.figurka[i+lide].typ = 0;
    }
    nastav_barvy_figurek();
    pocet_lidi = lide;
    pocet_pocitacu = pocitace;
  }


public void uvolni_kone(string jmeno_kone)
{
//fixme
}

  public void nastav_barvy_figurek()
  {
    hra.figurka[0].set_barva("cervena");
    hra.figurka[1].set_barva("zelena");
    hra.figurka[2].set_barva("zluta");
    hra.figurka[3].set_barva("modra");
    hra.figurka[4].set_barva("bila");
    hra.figurka[5].set_barva("cerna");
  }

  public void inicializuj_sit(int hraci)
  {
    net.StartListening();

    zpravy.log(" inicializuj_sit():cekam na prihlaseni hracu");

    try{
      //ceka na zalogovani vsech hracu pak skonci a program pokracuje
      for (int xxx = 0;  xxx < hraci; xxx++) {
         net.allDone.Reset();
         zpravy.log("Cekam na hrace cislo "+xxx);
         net.listener.BeginAccept(new AsyncCallback(net.AcceptCallback), net.listener);
         net.allDone.WaitOne();
         zpravy.log("Hrac cislo "+xxx+" se prihlasil");
         hra.figurka[xxx].clovek();
         net.Send(net.handler_pole[xxx], "DAS\n");
      }

    } catch (Exception e) {
        zpravy.log("inicializuj_sit(): chyba "+e.ToString());
    }
    zpravy.log("Vsichni hraci prihlaseni");

    for(int i = 0; i < net.sitovy_hraci; i++) {
      net.Send( net.handler_pole[i], "Vitejte v programu hraci "+i+"\n");
    }
  }


  public int pocet_dostihu_hrace(trida_figurka f)
  {
    int dostihy = 0;
    foreach (string i in f.get_stado()) {
      if (kone.pocet_dostihu(i) < 5) {
        dostihy += kone.pocet_dostihu(i);
      }
    }
    return dostihy;
  }

  public int pocet_hdostihu_hrace(trida_figurka f)
  {
    int dostihy = 0;
    foreach (string i in f.get_stado()) {
      if (kone.pocet_dostihu(i) == 5) {
        dostihy ++;
      }
    }
    return dostihy;
  }

  public void tah(trida_figurka f, int posun)
  {
    int poz = f.get_pozice() + posun;
    if (poz >= 39) {
      poz -= 39;
      f.set_penize(f.get_penize() + 4000);
      zpravy.log(f.get_barva()+ f.get_jmeno() + "prosel startem, zaplaceno 4000");
    }
    f.set_pozice(poz);
  }

  public int vlastnik_kone(string jmeno_kone) 
  {
    for (int ii = 0; ii < 6; ii++) {
      if (hra.figurka[ii].vlastni_kone(jmeno_kone)) {
        return ii;
      }
    }
    return -1;
  }

  public void zobraz_stado(int hrac)
  {
    Console.Write("Seznam:");
    foreach (string i in hra.figurka[hrac].get_stado()) {
      Console.Write(i);
      Console.Write("*{0}({1})", kone.pocet_dostihu(i), kone.zjisti_staj_kone(i));
      Console.Write(" ");
    }
    Console.WriteLine(".");
  }

  public string stado_popis(int hrac)
  {
    string s = "tvoje_kone ";
    s += hrac;
    s += " ";
    foreach (string i in hra.figurka[hrac].get_stado()) {
      s += k_k(i);
      s += ";"+kone.pocet_dostihu(i);
      s += ";"+kone.zjisti_staj_kone(i);
      s += " ";
    }
    s += ".";
    return s;
  }

  public void nakresli_plochu() 
  {
    try {Console.SetCursorPosition(0, 0);}catch{}
    Console.WriteLine("* kolo {0}", hra.get_kolo());
    try{Console.SetCursorPosition(0, 1);}catch{}
    for (int ip = 0; ip < 40; ip++) {
      string what_to_draw = "*";
      for (int ih = 0; ih < 6; ih++) {
        if (hra.figurka[ih].get_pozice() == ip) {
          what_to_draw = ih.ToString();
        }
      }
      Console.Write(what_to_draw);
    }

    try{Console.SetCursorPosition(0, 2);}catch{}
    for (int ih = 0; ih < 6; ih++) {
      if (hra.figurka[ih].get_distanc() > 0) {
        Console.Write("D ");
      }
      Console.Write ("hrac {0} (${1}):", ih, hra.figurka[ih].get_penize());
      zobraz_stado(ih);
    }
  }

  bool ma_celou_staj(int hrac, string staj)
  {
    bool ma_staj = true;
    List<string> hrac_list = hra.figurka[hrac].get_stado();
    List<string> list_konu = kone.get_seznam_konu_ve_staji(staj);
    foreach (string i in list_konu) {
      if (!hrac_list.Contains(i)) {
        ma_staj = false;
      }
    }
    return ma_staj;
  }

  private void vyhlas_bankrot(int hrac)
  {
////fixme hrac, uz nic nema, pokud neco ma tak se mu to vezme
//hrac se pri kole preskoci

    foreach (string i in hra.figurka[hrac].get_stado()) {
      int cena_dostihu = kone.pocet_dostihu(i) * kone.get_kun(i).get_naklady_dostih();
      zpravy.log("vyhlas_bankrot: cena dostihu="+cena_dostihu);
      banker.vloz_do_banku(cena_dostihu);
      kone.zrus_vsechny_dostihy(i);
    }

    if (sluzby.vlastnik_staje() == hrac) {
      sluzby.prodat_staje(hrac);
      banker.vloz_do_banku(sluzby.cena_staji);
    }
    if (sluzby.vlastnik_prepravy()  == hrac) {
      sluzby.prodat_prepravu(hrac);
      banker.vloz_do_banku(sluzby.cena_prepravy);
    }
    for (int j = 1; j < 5; j++) {
      if (sluzby.vlastnik_trenera(j)  == hrac){
        sluzby.prodat_trenera(j);
        banker.vloz_do_banku(sluzby.cena_trenera);
      }
    }
  //vyprazdni stado, kone jsou potom volni
    hra.figurka[hrac].get_stado().Clear();

  //vrat zbytek penez
    hra.figurka[hrac].zaplat(hra.figurka[hrac].get_penize());
  //sbohem
    hra.figurka[hrac].zbankrotuj();
  }

  public bool ma_dost_penez(int hrac, int penize)
  {
    if (hra.figurka[hrac].get_penize() >= penize) {
      return true;
    }
    return false;
  }

  private bool sezen_penize_nebo_bankrot(int hrac, int cena)
  {
    List<string> zalozni_stado = new List<string>();
  
    if (hra.figurka[hrac].get_penize() >= cena) {
      return true;
    }

    if (banker.pujcit(hrac, cena)) {
      return true;
    }

    if (sluzby.prodat_staje(hrac)) {
      hra.figurka[hrac].vydelej(sluzby.cena_staji);
    }
    if (ma_dost_penez(hrac, cena)) {return true;}

    if (sluzby.prodat_prepravu(hrac)) {
      hra.figurka[hrac].vydelej(sluzby.cena_prepravy);
    }
    if (ma_dost_penez(hrac, cena)) {return true;}
//prodej dostihy
//pro vsechny kone
//zrus dostih, zjisti jestli uz je dost

    int cena_dostihu = 0;

    foreach (string k in hra.figurka[hrac].get_stado()) {

      switch (kone.pocet_dostihu(k)) {
        case 1:
        case 2:
        case 3:
        case 4: cena_dostihu = kone.get_kun(k).get_naklady_dostih(); break;
        case 5: cena_dostihu = kone.get_kun(k).get_naklady_dostih_hlavni(); break;
        default: cena_dostihu = 0; break;
      }

      if (kone.pocet_dostihu(k) > 0) {
        kone.zrus_dostih(k);
        hra.figurka[hrac].vydelej(cena_dostihu / 2);
      }
      if (ma_dost_penez(hrac, cena)) {return true;}
    }

//    prodej kone
    foreach (string k in hra.figurka[hrac].get_stado()) {
      zalozni_stado.Add(k);
    }

    foreach (string k in zalozni_stado) {
      hra.figurka[hrac].prodat_kone(k);
      hra.figurka[hrac].vydelej(kone.get_kun(k).get_cena());
      if (ma_dost_penez(hrac, cena)) {return true;}
    }

    if (hra.figurka[hrac].get_penize() >= cena) {
      return true;
    }
    return false;
  }

  private void osetrene_zaplat(int hrac, int cena)
  {
    if (sezen_penize_nebo_bankrot(hrac, cena)) {
      hra.figurka[hrac].zaplat(cena);
    } else {
      vyhlas_bankrot(hrac);
    };
  }

  private void tahni_pocitacovou_figurkou(int ii, int hod)
  {
    trida_karta pk;
    int trener_id = -1;
    int vlastnik = -1;
    int vlastnik_staje = -1;
    int vlastnik_prepravy = -1;
    int cena = 0;

    int poz = hra.figurka[ii].get_pozice();
    int typ = hra.policka[poz].get_typ();
    zpravy.log("tahni_pocitacovou_figurkou("+ii+", "+hod+"):  policko je typu " + typ);
    switch (typ) {
      case KONSTANTY.NAHODA:
        pk = fn.vytahni_karticku_nahoda();
        Console.WriteLine("Nahoda text:{0}", pk.text);

        //posun se posune po plose
        //kam skoci na pole
        //nejblizsi skoci na nejblizsi pole
        //penize
        if (pk.osvobozeni == 1) {
          sluzby.osvobozeni = ii;
        }

        if (pk.nejblizsi != "") {
          int kam_poz = 0;
          switch (pk.nejblizsi) {
            case "finance": kam_poz = hra.nejblizsi(hra.figurka[ii].get_pozice(), KONSTANTY.FINANCE); break;
            case "trener": kam_poz = hra.nejblizsi(hra.figurka[ii].get_pozice(), KONSTANTY.TRENER); break;
          }
          zpravy.log(" skoc na nejblizsi "+pk.nejblizsi+" na pozici "+kam_poz);
          hra.figurka[ii].set_pozice(kam_poz);
        }

        if (pk.stop > 0) {
          hra.figurka[ii].stop = pk.stop;
        }

        if (pk.posun != 0) {
          hra.figurka[ii].set_pozice(hra.figurka[ii].get_pozice() + pk.posun);
          Console.WriteLine("  posun o {0} poli", pk.posun);
        }

        if (pk.kam >= 0) {
          Console.WriteLine("  skok na pozici {0}", pk.kam);
          if (pk.kam == 10) { //distanc
            hra.figurka[ii].jdi_na_distanc();
            Console.WriteLine(" a to je distanc");
          } else {
            hra.figurka[ii].set_pozice(pk.kam);
          }
        }
        posli_info(ii, "stoupl na nahodu");
      break;
      case KONSTANTY.FINANCE:
        pk = fn.vytahni_karticku_finance();
        zpravy.log("  finance text: "+pk.text+" $"+pk.penize);
        if (pk.penize > 0) {
          hra.figurka[ii].vydelej(pk.penize);
        }
        if (pk.penize < 0) {
          osetrene_zaplat(ii, pk.penize);
        }
        if (pk.dostih != 0 || pk.dostih != 0) {
          if (sezen_penize_nebo_bankrot(ii, pocet_dostihu_hrace(hra.figurka[ii]) * pk.dostih + pocet_hdostihu_hrace(hra.figurka[ii]) * pk.hdostih)) {
            hra.figurka[ii].zaplat(pocet_dostihu_hrace(hra.figurka[ii]) * pk.dostih);
            hra.figurka[ii].zaplat(pocet_hdostihu_hrace(hra.figurka[ii]) * pk.hdostih);
          } else {
            vyhlas_bankrot(ii);
          };
        }
        posli_info(ii, "stoupl na finance");
      break;
      case KONSTANTY.DISTANC:
        zpravy.log("pocitac "+ii+"Distanc");
        hra.figurka[ii].set_distanc(hra.policka[poz].get_distanc());
        posli_info(ii, "ma distanc");
        break;
      case KONSTANTY.TAH:
        zpravy.log("Tah");
        tah(hra.figurka[ii], hra.policka[poz].get_tah());
        posli_info(ii, "tahne znovu");
        break;
      case KONSTANTY.PENIZE:
        osetrene_zaplat(ii, hra.policka[poz].get_penize());
        Console.WriteLine("  veterina zaplaceno:{0}", hra.policka[poz].get_penize());
        posli_info(ii, "stoupl na veterinu");
        break;
      case KONSTANTY.PREPRAVA:
        vlastnik_staje = sluzby.vlastnik_staje();
        vlastnik_prepravy = sluzby.vlastnik_staje();
        if (vlastnik_prepravy == -1) {
          zpravy.log("pocitac "+ii+" kupuje prepravu");
          if (hra.figurka[ii].get_penize() >= 3000) {
            sluzby.koupit_prepravu(ii);
            posli_sluzby_info();
            hra.figurka[ii].zaplat(3000);
            posli_info(ii, "koupil prepravu");
          }
        }
        if (vlastnik_staje > -1 && vlastnik_staje != ii) {
          zpravy.log("pocitac zaplat_za_prepravu");
          cena = cena_za_prepravu_nebo_staje(ii, hod);
          if (sezen_penize_nebo_bankrot(ii, cena)) {
            hra.figurka[ii].zaplat(cena);
            hra.figurka[vlastnik_prepravy].vydelej(cena);
          } else {
            vyhlas_bankrot(ii);
          };
        }
        posli_info(ii, "stoupl na prepravu");
        break;
      case KONSTANTY.STAJE:
        vlastnik_staje = sluzby.vlastnik_staje();
        vlastnik_prepravy = sluzby.vlastnik_staje();
        if (vlastnik_staje == -1) {
          zpravy.log("pocitac "+ii+" kupuje staje");
          if (hra.figurka[ii].get_penize() > 3000) {
            sluzby.koupit_staje(ii);
            posli_sluzby_info();
          }
        }
        if (vlastnik_staje > -1 && vlastnik_staje != ii) {
          zpravy.log("pocitac zaplat_za_staj");
          cena = cena_za_prepravu_nebo_staje(ii, hod);
          if (sezen_penize_nebo_bankrot(ii, cena)) {
            hra.figurka[ii].zaplat(cena);
            hra.figurka[vlastnik_staje].vydelej(cena);
          } else {
            vyhlas_bankrot(ii);
          };
        }
        posli_info(ii, "stoupl na staje");
        break;
      case KONSTANTY.TRENER:
        trener_id = hra.policka[poz].trener_id;
        zpravy.log("KONSTANTY.TRENER: trener id:"+trener_id+"\n");
        int vlastnik_trenera = sluzby.vlastnik_trenera(trener_id);
        zpravy.log("KONSTANTY.TRENER: vlastnik:"+vlastnik+"\n");

        posli_info(ii, "stoupl na trenera");

        if (vlastnik == -1) {
          //nici, koupit
          if (hra.figurka[ii].get_penize() >= 4000) {
            sluzby.koupit_trenera(ii, trener_id);
            hra.figurka[ii].zaplat(4000);
            posli_info(ii, "koupil trenera");
          }
        } else if (vlastnik != ii) {
           cena = 1000 * sluzby.pocet_vlastnenych_treneru(vlastnik_trenera);
           zpravy.log("pocitac zaplatit za trenera: vlastnik"+vlastnik_trenera+"cena:"+cena);
           hra.figurka[vlastnik_trenera].vydelej(cena);
        } else {
        }
        break;
      case KONSTANTY.KUN:
        string temp = hra.policka[poz].get_kun();
        vlastnik = vlastnik_kone(temp);

        zpravy.log("Kun "+ temp);
        zpravy.log("vlastnik kone "+ vlastnik);

        posli_info(ii, "stoupl na kone");

        if (vlastnik == ii) {
          Console.WriteLine("Stoupnuti na vlastniho kone {0}", temp);
          //mam celou staj? pokud ano kup dostih
          if (ma_celou_staj(ii, kone.zjisti_staj_kone(temp))) {
            Console.WriteLine(" ma celou staj a to {0}", kone.zjisti_staj_kone(temp));
            if (kone.pocet_dostihu(temp) < 5) {
              kone.kup_dostih(temp);
              osetrene_zaplat(ii, kone.get_kun(temp).get_naklady_dostih());
            } else {
              Console.WriteLine("Nakoupen plny pocet dostihu");
            }
          } else {
            Console.WriteLine(" nema celou staj", temp);
          }
        }  else if (vlastnik == -1) {
          if (hra.figurka[ii].get_penize() >= kone.get_kun(temp).get_cena()) {
            hra.figurka[ii].koupit_kone(temp, kone.get_kun(temp).get_cena());
            zpravy.log("Koupen kun "+temp+" za "+kone.get_kun(temp).get_cena());
          }
        } else {
          zpravy.log("pocitac: Stoupnuti na ciziho kone "+temp);
          int castka = poplatek_za_stoupnuti_na_kone(temp);
          if (kone.pocet_dostihu(temp) > 0) {
            zpravy.log("Zaplaceno za dostihy");
          } else {
            zpravy.log("Prohlidka staji");
          }
          osetrene_zaplat(ii, castka);
          hra.figurka[vlastnik].vydelej(castka);
          uctenka(vlastnik);
        }
        break;
      case KONSTANTY.DOPING:
        zpravy.log("pocitas stoupl na doping");
        posli_info(ii,"stop");
        hra.figurka[ii].stop = 1;
        break;
      default:
        Console.WriteLine("Prozatim neobslouzene pole");
        hra.figurka[ii].set_pozice(poz);
      break;
    }
  }

  public int poplatek_za_stoupnuti_na_kone(string temp)
  {
    trida_kun docasny_kun;
    int castka;
    int vlastnik = vlastnik_kone(temp);

    docasny_kun = kone.get_kun(temp);

    if (kone.pocet_dostihu(temp) > 0 && hra.figurka[vlastnik].get_distanc() == 0) {
      switch (kone.pocet_dostihu(temp)) {
        case 1: 
          castka = docasny_kun.get_dostih1();
          break;
        case 2:
          castka = docasny_kun.get_dostih2();
          break;
        case 3:
          castka = docasny_kun.get_dostih3();
          break;
        case 4:
          castka = docasny_kun.get_dostih4();
          break;
        default:
          castka = docasny_kun.get_dostih_hlavni();
          break;
      }
      Console.WriteLine("Zaplaceno za dostihy");
    } else {
      castka = docasny_kun.get_prohlidka_staje();
      Console.WriteLine("Prohlidka staji");
    }
    return  castka;
  }

  public void posli_info(int hrac, string text)
  {
    net.posli_vsem("info_o_vsech "+hrac+" "+k_k("...")+" "+text+"\n");
  }

  public void posli_info(int hrac, string text, string parametr)
  {
    net.posli_vsem("info_o_vsech "+hrac+" "+k_k(parametr)+" "+text+"\n");
  }

  public void uctenka(int ii)
  {
    net.Send(net.handler_pole[ii], "potvrzeni_o_zaplaceni "+hra.figurka[ii].get_penize()+"\n");
  }

  public void zpracuj_ostatni_udalosti()
  {
    string udalost;
    string zprava;
    int castka;
    string s;
    string jmeno_kone;
    string jmeno_hrace;
    string[] parametry = new string[100];

    for (int ii = 0; ii < pocet_lidi + pocet_pocitacu; ii++) {

      if (!hra.figurka[ii].je_clovek()) {continue;}
      udalost = zpravy.ostatni_udalosti(ii);

      if (string.IsNullOrEmpty(udalost)) {
        continue;
      }

      zpravy.log("zpracuj_ostatni_udalosti():/"+udalost+"/");
      zprava = zpravy.parametry_ostatni_udalosti(ii);

      try {
        parametry = zprava.Split(' ');
      } catch {
        zpravy.log("zpracuj_ostatni_udalosti() selhalo /"+udalost+zprava+"/");
      }

      if (udalost == "uloz_hru") {
        string soubor = parametry[0];
        string jmeno;
        zpravy.log("zpracuj_ostatni_udalosti(): uloz_hru("+d_k(soubor)+").");

        serializator xml = new serializator();
        for (int ih = 0; ih < 6; ih++) {
          if (hra.figurka[ih].je_clovek()) {
            jmeno =  hra.figurka[ih].get_jmeno();
          } else {
            jmeno = "pocitac"+ih;
          }

          xml.napln_hrace(
            hra.figurka[ih].get_stado(),
            hra.figurka[ih].get_barva(),
            hra.figurka[ih].get_pozice(),
            hra.figurka[ih].get_distanc(),
            hra.figurka[ih].get_penize(),
            jmeno,
            hra.figurka[ih].stop,
            hra.figurka[ih].typ
          );
        }
        xml.napln_sluzby(sluzby.staj, sluzby.preprava, sluzby.trener);
        xml.napln_dostihy(kone.dostihy);
        xml.uloz(d_k(soubor));
        zpravy.smaz_ostatni_udalosti(ii);
      }

      if (udalost == "nacti_hru") {
        string soubor = parametry[0];

        zpravy.log("zpracuj_ostatni_udalosti(): nahraj_hru("+d_k(soubor)+").");

//vynuluj_hru();

        serializator xml = new serializator();
        das.disk.hra x;
        string jmeno;
        int hrac_id;
        int pocet;
        int penize_hracu = 0;

        x = xml.nahraj(d_k(soubor));
        foreach (das.disk.hrac hr in x.hraci){
          jmeno = hr.jmeno;
          hrac_id = vrat_cislo_hrace_podle_jmena(jmeno);
          if (hrac_id == -1) {continue;}
          zpravy.log("pozitivni hrac "+hrac_id+" jmenem "+jmeno+".");
          hra.figurka[hrac_id].set_stado(hr.stado);
          hra.figurka[hrac_id].set_barva(hr.barva);
          hra.figurka[hrac_id].set_pozice(hr.pozice);
          hra.figurka[hrac_id].set_distanc(hr.distanc);
          hra.figurka[hrac_id].set_penize(hr.penize);
          hra.figurka[hrac_id].stop = hr.stop;
          hra.figurka[hrac_id].typ = hr.typ;

          penize_hracu += hra.figurka[hrac_id].get_penize();
        }
        sluzby.staj = x.s.s;
        sluzby.preprava = x.s.p;
        sluzby.trener = x.s.t;

        kone.vynuluj_dostihy();
        foreach (das.disk.dostih d in x.dostihy) {
          jmeno = d.jmeno;
          pocet = d.pocet;
          kone.dostihy.Add(jmeno, pocet);
        }

        banker.set_bank(banker.max_bank() - penize_hracu);

        posli_sluzby_info();
        posli_vlastniky_koni();
        posli_souhrnne_informace();
        uctenka(ii);

        zpravy.smaz_ostatni_udalosti(ii);
      }

      if (udalost == "osvobodit_se") {
        hra.figurka[ii].set_distanc(0);
        zpravy.log("osvobodit_info " + sluzby.osvobozeni);
        s = "osvobodit_info " + sluzby.osvobozeni + "\n";
        net.Send(net.handler_pole[ii], s);
        zpravy.smaz_ostatni_udalosti(ii);
      }

      if (udalost == "vzdat_se") {
        zpravy.log("zpracuj_ostatni_udalosti(): vzdat_se");
        vyhlas_bankrot(ii);
        zpravy.smaz_ostatni_udalosti(ii);
        s = "vzdal_se " + ii + "\n";
        net.posli_vsem(s);
      }

      if (udalost == "sazim_na_kone") {
        jmeno_kone = parametry[0];
        castka = int.Parse(parametry[1]);
        zpravy.log("zpracuj_ostatni_udalosti(): sazim_na_kone("+jmeno_kone+castka+").");
        zpravy.smaz_ostatni_udalosti(ii);
        hra.figurka[ii].zaplat(castka);
        kone.vsad_na_kone(jmeno_kone,castka);
        uctenka(ii);
      }

      if (udalost == "ahoj") {
        s = parametry[0];
        hra.figurka[ii].set_jmeno(s);
        zpravy.smaz_ostatni_udalosti(ii);
        zpravy.log("zpracuj_ostatni_udalosti() jmeno hrace"+ii+s+".");
      }

      if (udalost == "vratit_do_banky") {
        castka = int.Parse(parametry[0]);
        if (hra.figurka[ii].get_penize() < castka) {
          net.Send(net.handler_pole[ii], "nemas_penize");
        } else {
          banker.vratit(ii, castka);
          zpravy.smaz_ostatni_udalosti(ii);
          hra.figurka[ii].zaplat(castka);
          uctenka(ii);
        }
      }

      if (udalost == "prodej_kone") {
        jmeno_kone = parametry[0];
        jmeno_hrace = parametry[1];
        castka = int.Parse(parametry[2]);

        //cislo hrace ze jmena 
        int cilovy_hrac = hra.cislo_hrace_podle_jmena(jmeno_hrace);

        if (jmeno_hrace == "banka") {
          //fixme pokud proda bance kone a ten ma dostihy, prodaji se automaticky dostihy cele staji
          //prodat kone do banky
          zpravy.log("udalost prodej_kone pro bankere, tj. vracim kone\n");
          hra.figurka[ii].get_stado().Remove(jmeno_kone);
          //vrat zbytek penez
          hra.figurka[ii].vydelej(kone.get_kun(jmeno_kone).get_cena());
          net.Send(net.handler_pole[ii], stado_popis(ii)+"\n");
          uctenka(ii);
        }

        zpravy.log("udalost prodej_kone pro "+cilovy_hrac+"\n");
        s = "koupis_kone_od_jineho " + jmeno_kone + " " +  castka + "\n";
        //fixme nabidka pocitaci  
        if (cilovy_hrac > -1) {
          if (hra.figurka[cilovy_hrac].je_clovek()) {
            net.Send(net.handler_pole[cilovy_hrac], s);
          }
        }
        zpravy.smaz_ostatni_udalosti(ii);
      }

      if (udalost == "prodej_sluzbu") {
        string ssluzba;
        ssluzba = parametry[0];
        jmeno_hrace = parametry[1];
        castka = int.Parse(parametry[2]);

        if (jmeno_hrace == "banka") {
          zpravy.log("udalost prodej_sluzbu pro bankere, tj. vracim\n");
          int cena = sluzby.prodej_sluzbu_podle_jmena(ssluzba);
          hra.figurka[ii].vydelej(cena);
          posli_sluzby_info();
          uctenka(ii);
        }

        //cislo hrace ze jmena 
        int cilovy_hrac = hra.cislo_hrace_podle_jmena(jmeno_hrace);
        s = "koupis_sluzbu_od_jineho " + ssluzba + " " +  castka + "\n";
        zpravy.log("udalost prodej_sluzbu pro "+cilovy_hrac+" posilam:"+s+"\n");
        //fixme nabidka pocitaci  
        if (cilovy_hrac > -1) {
          if (hra.figurka[cilovy_hrac].je_clovek()) {
            net.Send(net.handler_pole[cilovy_hrac], s);
          }
        }
        zpravy.smaz_ostatni_udalosti(ii);
      }

      if (udalost == "preved_kone") {
        jmeno_kone = parametry[0];
        jmeno_hrace = parametry[1];
        castka = int.Parse(parametry[2]);
        //cislo hrace ze jmena 
        int cilovy_hrac = hra.cislo_hrace_podle_jmena(jmeno_hrace);
        net.Send(net.handler_pole[ii], "OK");
        //preved_kone
        int puvodni_vlastnik = vlastnik_kone(jmeno_kone);

        zpravy.log("udalost preved_kone od: " + puvodni_vlastnik + "komu: "+cilovy_hrac+"\n");

        hra.figurka[puvodni_vlastnik].prodat_kone(jmeno_kone);//odstrani kone
        hra.figurka[ii].koupit_kone(jmeno_kone, castka);
        hra.figurka[puvodni_vlastnik].vydelej(castka);
        zpravy.smaz_ostatni_udalosti(ii);
        //posli novy seznam konu obema ucastnikum prevodu
        net.Send(net.handler_pole[ii], stado_popis(ii)+"\n");
        net.Send(net.handler_pole[puvodni_vlastnik], stado_popis(puvodni_vlastnik)+"\n");
      }

      if (udalost == "preved_sluzbu") {
        string ssluzba = parametry[0];
        jmeno_hrace = parametry[1];
        castka = int.Parse(parametry[2]);

        //cislo hrace ze jmena 
        int cilovy_hrac = hra.cislo_hrace_podle_jmena(jmeno_hrace);
        int puvodni_vlastnik = sluzby.vlastnik(ssluzba);

        zpravy.log("udalost preved_sluzbu: sluzba: "+ssluzba+" od: " + puvodni_vlastnik + " komu: "+cilovy_hrac+"\n");

        sluzby.preved(ssluzba, puvodni_vlastnik, ii);

        hra.figurka[ii].zaplat(castka);
        hra.figurka[puvodni_vlastnik].vydelej(castka);

        zpravy.smaz_ostatni_udalosti(ii);
        net.Send(net.handler_pole[ii], "OK");
       //posli novy seznam vsem ucastnikum
        posli_sluzby_info();
      }

      if (udalost == "pujcit_z_banky") {
        castka = int.Parse(parametry[0]);
        if (banker.pujcit(ii, castka)) {
          hra.figurka[ii].vydelej(castka);
          s = "pujcka_ok\n";
          net.Send(net.handler_pole[ii], s);
          zpravy.smaz_ostatni_udalosti(ii);
          uctenka(ii);
        } else {
          s = "nejsou_penize\n";
          net.Send(net.handler_pole[ii], s);
          zpravy.smaz_ostatni_udalosti(ii);
        }
      }
    }
  }

  public void cekej_a_spi()
  {
    zpracuj_ostatni_udalosti();
    System.Threading.Thread.Sleep(50);
  }

  public int cena_za_prepravu_nebo_staje(int ii, int hod)
  {
    int vlastnik_staje = sluzby.vlastnik_staje();
    int vlastnik_prepravy = sluzby.vlastnik_prepravy();
    int cena;
    if (vlastnik_staje == vlastnik_prepravy) {
      cena = 200 * hod;
    } else {
      cena = 80 * hod;
    }
    return cena;
  }

  public string zjisti_kone_na_pozici(int hrac)
  {
    int pozice = hra.figurka[hrac].get_pozice();
    int typ = hra.policka[pozice].get_typ();
    if  (typ == KONSTANTY.KUN) {
      string temp = hra.policka[pozice].get_kun();
      return temp;
    } else {
      return "neni kun";
    }
  }

  public int vyhodnot_sazky(int hrac)
  {
    string potencionalni_vyhra = zjisti_kone_na_pozici(hrac);
    int vyhra = kone.kolik_je_vsazeno_na_kone(potencionalni_vyhra);
    if (vyhra > 0) {
      net.Send(net.handler_pole[hrac], "vyhrals_sazku " + vyhra);
      hra.figurka[hrac].vydelej(vyhra);
      uctenka(hrac);
      zpravy.log("clovek "+hrac+" vyhral sazku "+potencionalni_vyhra+",  "+vyhra);
    } else {
      zpravy.log("sazka nevysla "+hrac);
    }
    kone.zrus_sazky();
    return vyhra;
  }

  public string stoupnuto_na_kone(int ii, int poz)
  {
    string temp = hra.policka[poz].get_kun();
    int vlastnik = vlastnik_kone(temp);
    string udalost,s;

    zpravy.log("clovek "+ii+" stoupl na kone "+temp+", vlastnikem je "+vlastnik);

    posli_info(ii, "stoupl na kone", temp);

    udalost = "zadna udalost";
    if (vlastnik == ii) {
      zpravy.log("Stoupnuti na vlastniho kone " + temp);
      udalost = "kupuji_dostih";

      s = "tvuj_kun "+
      k_k(temp) + " "+
      kone.get_kun(temp).get_naklady_dostih() + " " +
      kone.get_kun(temp).get_naklady_dostih_hlavni() + " " +
      kone.zjisti_staj_kone(temp) + " " +
      (ma_celou_staj(ii, kone.zjisti_staj_kone(temp))?"1":"0");

      net.Send(net.handler_pole[ii], s+"\n");
    } else if (vlastnik == -1) {
      //zpravy.notifikuj(ii,"kun");
      zpravy.log("Stoupnuti na volneho kone " + temp);
      udalost = "koupit kone";
      //volny_kun jmeno cena staj
      s = "volny_kun "+k_k(temp)+" "+kone.get_kun(temp).get_cena()+" "+kone.zjisti_staj_kone(temp);
      net.Send(net.handler_pole[ii], s+"\n");
    } else {
      //cizi_kun jmeno poplatek staj
      if (vyhodnot_sazky(ii) == 0 ) { //hrac nevsadil na spravneho kone, plati
        udalost = "cizi kun";
        zpravy.log("Stoupnuti na ciziho kone "+ temp);
        int castka = poplatek_za_stoupnuti_na_kone(temp);
        s = "cizi_kun "+k_k(temp)+" "+vlastnik_kone(temp) +" "+castka+" "+kone.zjisti_staj_kone(temp);
        net.Send(net.handler_pole[ii], s+"\n");
      }
    }
    return udalost;
  }

  public void nemas_na_to(int hrac)
  {
    //bankrot
    string s = "nemas_penize\n";
    net.Send(net.handler_pole[hrac], s);
//    hra.figurka[hrac].zbankrotuj();
  }

  public void tahni_cloveci_figurkou(int ii, int hod)
  {
    trida_karta pk = new trida_karta();
    string udalost = "nic";
    int trener_id = -1;
    int vlastnik_trenera = -1;
    int vlastnik_prepravy = -1;
    int vlastnik_staje = -1;
    int cena = 0;

    int poz = hra.figurka[ii].get_pozice();
    int typ = hra.policka[poz].get_typ();
    string s; //pro posilani po siti
    string hlaseni = "policko je typu "+typ+"\n";
    net.Send(net.handler_pole[ii], hlaseni);
    zpravy.log(hlaseni);

    switch (typ) {
      case KONSTANTY.NAHODA:
        posli_info(ii, "stoupl na nahodu");
        pk = fn.vytahni_karticku_nahoda();
        udalost = "nahoda";
        string ntext = zpravy.base64Encode(pk.text);
        zpravy.log("Nahoda text: "+ ntext);
        s = "nahoda "+ntext;
        net.Send(net.handler_pole[ii], s+"\n");
      break;
      case KONSTANTY.FINANCE:
        posli_info(ii, "stoupl na finance");
        zpravy.log("  Finance");
        pk = fn.vytahni_karticku_finance();
        string ftext = zpravy.base64Encode(pk.text);
        zpravy.log("clovek "+ii+" finance text"+ftext+" $"+pk.penize);
        zpravy.notifikuj(ii,"finance");
        udalost = "finance";
        s = "finance "+ftext+" "+pk.penize;
        net.Send(net.handler_pole[ii], s+"\n");
      break;
      case KONSTANTY.DISTANC:
        posli_info(ii, "ma distanc");
        zpravy.log("Distanc");
        hra.figurka[ii].set_distanc(hra.policka[poz].get_distanc());
        net.Send(net.handler_pole[ii], "mas_distanc\n");
        break;
      case KONSTANTY.TAH:
        posli_info(ii, "tahne znovu");
        zpravy.log("Tah");
        tah(hra.figurka[ii], hra.policka[poz].get_tah());
        //tady se to bude muset zavolat rekurzivne znovu, ve hre neni mozna situace zacykleni
        break;
      case KONSTANTY.PENIZE:
        posli_info(ii, "stoupl na veterinu");
        zpravy.log("penize(veterina)");
        s = "zaplat_penize " + hra.policka[poz].get_penize()+"\n";
        net.Send(net.handler_pole[ii], s);
        udalost = "penize";
        break;
      case KONSTANTY.PREPRAVA:
        posli_info(ii, "stoupl na prepravu");
        vlastnik_prepravy = sluzby.vlastnik_prepravy();
        zpravy.log("preprava, vlastnik "+ vlastnik_prepravy);
        if (vlastnik_prepravy == -1) {
          udalost = "koupit_prepravu";
          zpravy.log("koupit_prepravu");
          s = "koupit_prepravu 3000\n";
          net.Send(net.handler_pole[ii], s);
        }
        if (vlastnik_prepravy > -1 && vlastnik_prepravy != ii) {
          udalost = "zaplat_za_prepravu";
          zpravy.log("zaplat_za_prepravu");
          s = "zaplat_za_prepravu " + cena_za_prepravu_nebo_staje(ii, hod)+"\n";
          net.Send(net.handler_pole[ii], s);
        }
        break;
      case KONSTANTY.STAJE:
        posli_info(ii, "stoupl na staje");
        vlastnik_staje = sluzby.vlastnik_staje();
        zpravy.log("staje, vlastnik "+ vlastnik_staje);
        if (vlastnik_staje == -1) {
          udalost = "koupit_staje";
          zpravy.log("koupit_staje");
          s = "koupit_staje 3000\n";
          net.Send(net.handler_pole[ii], s);
        }
        if (vlastnik_staje > -1 && vlastnik_staje != ii) {
          udalost = "zaplat_za_staj";
          zpravy.log("zaplat_za_staj");
          s = "zaplat_za_staj " + cena_za_prepravu_nebo_staje(ii, hod)+"\n";
          net.Send(net.handler_pole[ii], s);
        }
        break;
      case KONSTANTY.TRENER:
        posli_info(ii, "stoupl na trenera");
        trener_id =  hra.policka[poz].trener_id;
        vlastnik_trenera = sluzby.vlastnik_trenera(trener_id);
        zpravy.log("trener cislo " + trener_id + "|" + vlastnik_trenera);

        if (vlastnik_trenera == -1) {
          udalost = "trener_koupit";
          zpravy.log("koupit trenera");
          s = "koupit_trenera " + trener_id + " 4000"+"\n";
          net.Send(net.handler_pole[ii], s);
        }
        if (vlastnik_trenera > -1 && vlastnik_trenera != ii) {
          udalost = "trener_zaplat";
          cena = 1000 * sluzby.pocet_vlastnenych_treneru(vlastnik_trenera);
          zpravy.log("zaplatit za trenera: vlastnik"+vlastnik_trenera+"cena:"+cena);
          s = "zaplat_za_trenera " + cena + "\n";
          net.Send(net.handler_pole[ii], s);
        }
        break;
      case KONSTANTY.KUN:
      //stoupnuto na kone
        posli_info(ii, "stoupl na kone");
        udalost = stoupnuto_na_kone(ii, poz);
        break;
      case KONSTANTY.DOPING:
        s = "stop 1\n";
        net.Send(net.handler_pole[ii], s);
        zpravy.log("Udalost doping");
        udalost = "stop";
        break;
      default:
        zpravy.log("Prozatim neobslouzene pole");
        hra.figurka[ii].set_pozice(poz);
      break;
    }

    //zpracuj odpoved
    switch (udalost) {
      case "cizi kun":
        while (true) {
          if (zpravy.udalost(ii) == "zaplacena_prohlidka" ) {
            string temp = hra.policka[poz].get_kun();
            int castka = poplatek_za_stoupnuti_na_kone(temp);
            int vlastnik = vlastnik_kone(temp);
            hra.figurka[ii].zaplat(castka);
            hra.figurka[vlastnik].vydelej(castka);
            net.Send(net.handler_pole[ii], "potvrzeni_o_zaplaceni "+hra.figurka[ii].get_penize()+"\n");
            zpravy.smaz_udalost(ii);
            posli_info(ii,"stoupl na ciziho kone ", temp);
            break;
          }
          cekej_a_spi();
        }
        break;
      case "kupuji_dostih":
        zpravy.log("cekam na koupeni dostihu");
        while (true) {
          if (zpravy.udalost(ii) == "kupuji_dostih" ) {
            //mam celou staj? pokud ano kup dostih
            string temp = hra.policka[poz].get_kun();
            if (ma_celou_staj(ii, kone.zjisti_staj_kone(temp))) {
              zpravy.log(" ma celou staj "+kone.zjisti_staj_kone(temp));
              if (kone.pocet_dostihu(temp) < 5) {
                cena = kone.get_kun(temp).get_naklady_dostih();
                if (hra.figurka[ii].get_penize() >= cena) {
                  kone.kup_dostih(temp);
                  hra.figurka[ii].zaplat(cena);
                  net.Send(net.handler_pole[ii], "koupils_dostih\n");
                  posli_info(ii,"koupil dostih");
                } else {
                  nemas_na_to(ii);
                }
                uctenka(ii);
              } else {
                zpravy.log("Nakoupen plny pocet dostihu");
                net.Send(net.handler_pole[ii], "maximum_dostihy\n");
              }
            } else {
              zpravy.log("nema celou staj "+temp);
              net.Send(net.handler_pole[ii], "nemas_staj\n");
            }
            zpravy.smaz_udalost(ii);
            break;
          }
          if (zpravy.udalost(ii) == "pokracuj" ) {
            zpravy.smaz_udalost(ii);
            break;
          }
          cekej_a_spi();
        }
        zpravy.log("dostih je poresen");
        break;
      case "koupit kone":
        zpravy.log("cekam na koupeni kone");
        while (true) {
          if (zpravy.udalost(ii) == "kupuji_kone" ) {
            string temp = hra.policka[poz].get_kun();
            if (hra.figurka[ii].get_penize() >= kone.get_kun(temp).get_cena()) {
              hra.figurka[ii].koupit_kone(temp, kone.get_kun(temp).get_cena());
              net.Send(net.handler_pole[ii], "koupils_kone "+k_k(temp)+"\n");
              uctenka(ii);
              posli_vlastniky_koni();
              posli_info(ii,"koupil kone");
            } else {
              zpravy.log("nemas na kone "+ temp +" za $"+ kone.get_kun(temp).get_cena());
            }
            udalost = "nic";
            zpravy.smaz_udalost(ii);
            net.Send(net.handler_pole[ii], stado_popis(ii)+"\n");
            break;
          }
          if (zpravy.udalost(ii) == "pokracuj") {
            udalost = "nic";
            zpravy.smaz_udalost(ii);
            net.Send(net.handler_pole[ii], "pokracujes\n");
            break;
          }
          //cekej
          cekej_a_spi();
        }
        zpravy.log("kun je poresen");
        break;
      case "nahoda":
        while (true) {
          //posun se posune po plose
          //kam skoci na pole
          //nejblizsi skoci na nejblizsi pole
          //penize

          if (zpravy.udalost(ii) == "akceptuji_nahodu" ) {

            zpravy.log("nahoda: "+pk.kam+" "+pk.osvobozeni+" "+pk.nejblizsi+" "+pk.stop+" "+pk.posun+" "+pk.kam);

            if (pk.osvobozeni == 1) {
              sluzby.osvobozeni = ii;
            }

            if (pk.nejblizsi != "") {
              int kam_poz = 0;
              switch (pk.nejblizsi) {
                case "finance": kam_poz = hra.nejblizsi(hra.figurka[ii].get_pozice(), KONSTANTY.FINANCE); break;
                case "trener": kam_poz = hra.nejblizsi(hra.figurka[ii].get_pozice(), KONSTANTY.TRENER); break;
              }
              zpravy.log(" skoc na nejblizsi " + pk.nejblizsi + " " + kam_poz);
              hra.figurka[ii].set_pozice(kam_poz);
            }

            if (pk.stop > 0) {
              hra.figurka[ii].stop = pk.stop;
              zpravy.log(" stop ");
            }

            if (pk.posun != 0) {
              hra.figurka[ii].set_pozice(hra.figurka[ii].get_pozice() + pk.posun);
              zpravy.log("  posun o " + pk.posun);
            }

            if (pk.kam >= 0) {
              zpravy.log("  skok na pozici " + pk.kam);
              if (pk.kam == 10) { //distanc
                hra.figurka[ii].jdi_na_distanc();
                zpravy.log(" a to je distanc");
              } else {
                hra.figurka[ii].set_pozice(pk.kam);
              }
            }

            udalost = "nic";
            zpravy.smaz_udalost(ii);
            net.Send(net.handler_pole[ii], "OK\n");
            uctenka(ii);
            posli_info(ii,"stoupl na nahodu");
            break;
          }
          cekej_a_spi();
        }
        break;
      case "penize":
        while (true) {
          if (zpravy.udalost(ii) == "zaplaceno_penize" ) {
            hra.figurka[ii].zaplat(hra.policka[poz].get_penize());
            net.Send(net.handler_pole[ii], "potvrzeni_o_zaplaceni "+hra.figurka[ii].get_penize()+"\n");
            udalost = "nic";
            zpravy.smaz_udalost(ii);
            uctenka(ii);
            posli_info(ii,"zaplatil");
            break;
          }
          cekej_a_spi();
        }
        break;

      case "trener_koupit":
        trener_id = hra.policka[poz].trener_id;
        vlastnik_trenera = sluzby.vlastnik_trenera(trener_id);

        zpravy.log("clovek "+ii+" stoupl na volneho trenera "+ trener_id +", vlastnikem je "+ vlastnik_trenera +"a chce ho koupit");

        while (true) {
          if (zpravy.udalost(ii) == "kupuji_trenera" ) {
            if (hra.figurka[ii].get_penize() >= 4000) {
              sluzby.koupit_trenera(ii, trener_id);
              hra.figurka[ii].zaplat(4000);
              posli_sluzby_info();
              posli_info(ii,"koupil trenera");
            } else {
              nemas_na_to(ii);
            }
            uctenka(ii);
            zpravy.smaz_udalost(ii);
            break;
          }
          if (zpravy.udalost(ii) == "pokracuj") {
            udalost = "nic";
            zpravy.smaz_udalost(ii);
            net.Send(net.handler_pole[ii], "pokracujes\n");
            break;
          }
          cekej_a_spi();
        }
        break;
      case "trener_zaplat":
        trener_id =  hra.policka[poz].trener_id;
        vlastnik_trenera = sluzby.vlastnik_trenera(trener_id);

        zpravy.log("zaplat, clovek "+ii+" stoupl na trenera "+ trener_id +", vlastnikem je " + vlastnik_trenera);

        while (true) {
          if (zpravy.udalost(ii) == "platim_za_trenera" ) {
            udalost = "nic";
            int vydelek = 1000 * sluzby.pocet_vlastnenych_treneru(vlastnik_trenera);

            if (hra.figurka[ii].get_penize() >= vydelek) {
              hra.figurka[ii].zaplat(vydelek);
              hra.figurka[vlastnik_trenera].vydelej(vydelek);
              posli_info(ii,"plati za trenink");
            } else {
              nemas_na_to(ii);
            }
            zpravy.smaz_udalost(ii);
            uctenka(ii);
            break;
          }
          cekej_a_spi();
        }
        break;

      case "koupit_prepravu":
        vlastnik_prepravy = sluzby.vlastnik_prepravy();

        zpravy.log("clovek "+ii+" stoupl na prepravu, vlastnikem je "+ vlastnik_prepravy);

        while (true) {
          if (zpravy.udalost(ii) == "kupuji_prepravu" ) {
            if (hra.figurka[ii].get_penize() >= 3000) {
              sluzby.koupit_prepravu(ii);
              hra.figurka[ii].zaplat(3000);
              posli_sluzby_info();
              posli_info(ii,"koupil prepravu");
            } else {
              nemas_na_to(ii);
            }
            uctenka(ii);
            zpravy.smaz_udalost(ii);
            break;
          }
          if (zpravy.udalost(ii) == "pokracuj") {
            udalost = "nic";
            zpravy.smaz_udalost(ii);
            net.Send(net.handler_pole[ii], "pokracujes\n");
            break;
          }
          cekej_a_spi();
        }
        break;

      case "koupit_staje":
        vlastnik_staje = sluzby.vlastnik_staje();

        zpravy.log("clovek "+ii+" stoupl na staje, vlastnikem je "+ vlastnik_staje);

        while (true) {
          if (zpravy.udalost(ii) == "kupuji_staje" ) {
            if (hra.figurka[ii].get_penize() >= 3000) {
              sluzby.koupit_staje(ii);
              hra.figurka[ii].zaplat(3000);
              posli_sluzby_info();
              posli_info(ii,"koupil staje");
            } else {
              nemas_na_to(ii);
            }
            uctenka(ii);
            break;
          }
          if (zpravy.udalost(ii) == "pokracuj") {
            udalost = "nic";
            zpravy.smaz_udalost(ii);
            net.Send(net.handler_pole[ii], "pokracujes\n");
            break;
          }
          cekej_a_spi();
        }
        break;

      case "zaplat_za_prepravu":
        vlastnik_prepravy = sluzby.vlastnik_prepravy();

        zpravy.log("zaplat_za_prepravu, clovek "+ii+" stoupl na prepravu, vlastnikem je " + vlastnik_prepravy);

        while (true) {
          if (zpravy.udalost(ii) == "platim_za_prepravu" ) {
            int platit = cena_za_prepravu_nebo_staje(ii, hod);
            zpravy.log("zaplat_za_preprav, plati "+platit);

            if (hra.figurka[ii].get_penize() >= platit) {
              hra.figurka[ii].zaplat(platit);
              hra.figurka[vlastnik_prepravy].vydelej(platit);
            } else {
              nemas_na_to(ii);
            }
            zpravy.smaz_udalost(ii);
            uctenka(ii);
            break;
          }
          cekej_a_spi();
        }
        break;

      case "zaplat_za_staje":
        vlastnik_staje = sluzby.vlastnik_staje();

        zpravy.log("zaplat_za_staje, clovek "+ii+" stoupl na staj "+ trener_id +", vlastnikem je " + vlastnik_trenera);

        while (true) {
          if (zpravy.udalost(ii) == "platim_za_staje" ) {

            int platit = cena_za_prepravu_nebo_staje(ii, hod);
            zpravy.log("zaplat_za_staje, plati "+platit);

            if (hra.figurka[ii].get_penize() >= platit) {
              hra.figurka[ii].zaplat(platit);
              hra.figurka[vlastnik_staje].vydelej(platit);
              posli_info(ii,"plati za staje");
            } else {
              nemas_na_to(ii);
            }
            zpravy.smaz_udalost(ii);
            uctenka(ii);
            break;
          }
          cekej_a_spi();
        }
        break;

      case "finance":
        while (true) {
          if (zpravy.udalost(ii) == "akceptuji_finance" ) {

            if (pk.penize > 0) {
              hra.figurka[ii].vydelej(pk.penize);
            }
            if (pk.penize < 0) {
              hra.figurka[ii].zaplat(pk.penize);
            }
            if (pk.dostih != 0 || pk.dostih != 0) {
              hra.figurka[ii].zaplat(pocet_dostihu_hrace(hra.figurka[ii]) * pk.dostih);
              hra.figurka[ii].zaplat(pocet_hdostihu_hrace(hra.figurka[ii]) * pk.hdostih);
            }
            udalost = "nic";
            zpravy.smaz_udalost(ii);
            uctenka(ii);
            net.Send(net.handler_pole[ii], "OK\n");
            posli_info(ii,"stoupl na finance");
            break;
          }
          cekej_a_spi();
        }
        break;
      case "stop":
        while (true) {
          if (zpravy.udalost(ii) == "akceptuji_stop" ) {
            posli_info(ii,"stop");
            hra.figurka[ii].stop = 1;
            udalost = "nic";
            zpravy.smaz_udalost(ii);
            net.Send(net.handler_pole[ii], "OK\n");
            posli_info(ii,"stop");
            break;
          }
          cekej_a_spi();
        }
        break;
      default:
        break;
    }
  }

  public void info_o_hracich(int pocet_hracu, int pocet_pocitacu)
  {
    string s = "";
    string jh = "";
    //posli pred zapocetim hry informace o hracich
    for (int ii = 0; ii < pocet_hracu + pocet_pocitacu; ii++) {
      if (hra.figurka[ii].je_clovek()) {
        jh = hra.figurka[ii].get_jmeno();
      } else {
        jh = "pocitac"+ii;
      }
      if (jh == "") {
        jh = "hrac";
      }
      s = "info_o_hraci "+ ii + " " + hra.figurka[ii].get_barva() + " " + jh + " xxx\n";
      zpravy.log(s);
      net.posli_vsem(s);
    }

  }

  public void posli_sluzby_info()
  {
    string s;
    for (int trener = 1; trener < 5; trener++) {
      s = "trener_info "+ trener + " " + sluzby.vlastnik_trenera(trener) + "\n";
      net.posli_vsem(s);
    }

    s = "staje_info " + sluzby.vlastnik_staje() + "\n";
    net.posli_vsem(s);
    s = "preprava_info " + sluzby.vlastnik_prepravy() + "\n";
    net.posli_vsem(s);
  }

  public void posli_souhrnne_informace()
  {
    string s;
    for (int ii = 0; ii < pocet_lidi + pocet_pocitacu; ii++) {
      if (hra.figurka[ii].je_clovek()) {
        for (int ih = 0; ih < pocet_lidi + pocet_pocitacu; ih++) {
          s = "pozice_hrace " + ih + " " + hra.figurka[ih].get_pozice() + "\n";
          net.Send(net.handler_pole[ii], s);
        }
      }
    }

    for (int ii = 0; ii < pocet_lidi + pocet_pocitacu; ii++) {
      if (hra.figurka[ii].je_clovek()) {
        s = "identifikator_hrace " + ii + " " + hra.figurka[ii].get_jmeno() + " blah\n";
        net.Send(net.handler_pole[ii], s);
      }
    }

    posli_sluzby_info();
    posli_vlastniky_koni();
  }

  int vrat_cislo_hrace_podle_jmena(string jmeno)
  {
   zpravy.log ("vrat_cislo_hrace_podle_jmena:"+jmeno+".");
    for (int i = 0; i < 6; i++) {
      if (hra.figurka[i].get_jmeno() ==  jmeno) {
        return i;
      }
    }
    return -1;
  }

  bool hraci_maji_jmena()
  {
    bool ret = false;
    for (int i = 0; i < 6; i++) {
      if (hra.figurka[i].je_clovek()) {
        zpravy.log ("hraci_maji_jmena(): testuji, delka jmena je "+hra.figurka[i].get_jmeno().Length+".");
        if (hra.figurka[i].get_jmeno().Length > 0) {
          ret = true;
        } else {
          ret = false;
        }
      }
    }
    zpravy.log ("hraci_maji_jmena():ret je "+ret+".");

    return ret;
  }

  private void posli_vlastniky_koni()
  {
    string seznam = "vlastnici_koni ";
    foreach(DictionaryEntry d in kone.seznam_konu) {
      trida_kun kk = (trida_kun)d.Value;
      seznam += k_k(kk.get_jmeno()) + ">" + vlastnik_kone(kk.get_jmeno()) + ">" + kone.pocet_dostihu(kk.get_jmeno()) + " ";
    }
    seznam += "\n";
    net.posli_vsem(seznam);
  }

  //koduj kone
  public string k_k(string k)
  {
    return zpravy.base64Encode(k);
  }

  //dekoduj kone
  public string d_k(string k)
  {
    return zpravy.base64Decode(k);
  }

  public void server_hlaska()
  {
    string s = "";
    for (int i = 0; i < pocet_lidi; i++) {
      s += i + ":" + net.ip_pole[i] + " " +hra.figurka[i].get_jmeno()+ "\n";
    }
    prenos.data = s;
  }

  public void hraj()
  {
    string s;

    try {
      Console.Clear();
    } catch {
      //opraveni chyby pod cygwinem
    }

    int pocet_hracu = pocet_lidi;

    do {
      zpravy.log ("hraj():cekam na jmena hracu");
      zpracuj_ostatni_udalosti();
      System.Threading.Thread.Sleep(50);
    } while (!hraci_maji_jmena());


    zpravy.log ("hraj():lidi="+pocet_hracu+" poce="+ pocet_pocitacu);
    info_o_hracich(pocet_hracu, pocet_pocitacu);

    string[] separe = kone.jmenny_seznam_koni().Split(' ');

    for (int ic = 0; ic < separe.Length; ic++) {
      separe[ic] = k_k(separe[ic]);
    }
    string kodovane = string.Join(" ", separe);

    net.posli_vsem("vsechny_kone " + kodovane + "\n");
    zpracuj_ostatni_udalosti();

    net.posli_vsem("zahajena_hra\n");

    server_hlaska();

//kola
    for (int i = 0; i < 500; i++) {

      server_hlaska();

      zpravy.log ("hraj():kolo "+i);

      kone.zrus_sazky();
      posli_souhrnne_informace();

//hraci
      for (int ii = 0; ii < pocet_hracu + pocet_pocitacu; ii++) {

        /*for (int ihr = 0; ihr < 6; ihr++) {
          posli_info(ihr, "ceka na tah");
        }*/

bool vzdal_se = false;

        if (hra.figurka[ii].bankrot()) {continue;}

        net.Send(net.handler_pole[ii], "pozice_hrace "+ ii + " " + hra.figurka[ii].get_pozice() + "\n");

        if (hra.figurka[ii].je_clovek()) {
          zpravy.log("distanc_info " + hra.figurka[ii].get_distanc());
          s = "distanc_info " + hra.figurka[ii].get_distanc() + "\n";
          net.Send(net.handler_pole[ii], s);
        }

        if (hra.figurka[ii].ceka()) {
          zpravy.log("hrac " + ii + " ceka protoze ma stop ");
          hra.figurka[ii].probehlo_kolo();
          if (hra.figurka[ii].je_clovek()) {
            zpravy.log("hrac " + ii + " je clovek, posilam mu zpravu ze ceka");
            net.Send(net.handler_pole[ii], "cekas "+ii+"\n");
          }
          continue;
        }

        int hod = hra.kostka.hod();
        zpravy.log ("hraj():hod "+hod+" hrace "+ii);

        if (hod == 6) {
          if (hra.figurka[ii].get_distanc() > 0) {
            hra.figurka[ii].set_distanc(0);
            hod = 0;
          }
          hod += hra.kostka.hod();
        }

        if (hod == 12) {
          tah(hra.figurka[ii], hod);
          hra.figurka[ii].jdi_na_distanc();
          posli_info(ii, "ma distanc");
        } else {
          //posun figurku o hod
          if (hra.figurka[ii].get_distanc() == 0) {
            tah(hra.figurka[ii], hod);
          }
        }

        if (hra.figurka[ii].je_clovek()) {
          net.Send(net.handler_pole[ii], "tahni "+ii+"\n");

          zpravy.log("hraj(): cekam na zpravu hazim_kostkou");
          while (true) {
            if (zpravy.udalost(ii) == "hazim_kostkou") {
              zpravy.log("udalost hod");
              zpravy.smaz_udalost(ii);
              break;

            }
            if (zpravy.udalost(ii) == "uz_nehazim") {
              zpravy.log("udalost hod, po vzdani se");
              zpravy.smaz_udalost(ii);
              vzdal_se = true;
              break;
            }

            //cekej (zde je cas na sazeni a splaceni apod)
            cekej_a_spi();
          }
          net.Send(net.handler_pole[ii], "hodils "+ii+" "+hod+"\n");
          net.Send(net.handler_pole[ii], "pozice_hrace "+ ii + " " + hra.figurka[ii].get_pozice() + "\n");
          zpravy.log("hrac "+ii+"  hodil "+hod+"\n");
        }

        if (vzdal_se) {continue;}

        s = "figurka"+
        hra.figurka[ii].get_pozice() + " " +
        hod + " " +
        hra.figurka[ii].get_penize()+" ";

        zpravy.log(s);

        if (hra.figurka[ii].je_clovek()) {
          net.Send(net.handler_pole[ii], "zprava_o_stavu "+ii+" "+s+"\n");
          net.Send(net.handler_pole[ii], stado_popis(ii)+"\n");
        }

        zpracuj_ostatni_udalosti();

        if (hra.figurka[ii].get_distanc() == 0) {
          if (hra.figurka[ii].je_clovek()) {
            tahni_cloveci_figurkou(ii, hra.figurka[ii].get_pozice());
          } else {
            tahni_pocitacovou_figurkou(ii, hra.figurka[ii].get_pozice());
          }
        }
        nakresli_plochu();

        if (!hra.figurka[ii].je_clovek()) {
          Console.WriteLine("Hrac {0} postoupil na pozici {1} ${2}", ii, hra.figurka[ii].get_pozice(),hra.figurka[ii].get_penize());
        }

        zpravy.log("Hrac "+ii+" postoupil na pozici "+hra.figurka[ii].get_pozice()+" a ma $"+hra.figurka[ii].get_penize());

        if (hra.figurka[ii].je_clovek()) {
          s = "pozice_hrace "+ ii + " " + hra.figurka[ii].get_pozice() + "\n";
          net.posli_vsem(s);
          net.Send(net.handler_pole[ii], "konec_tahu "+ii+"\n");
        }
      }
      hra.nove_kolo();
    }
  }
}

}