use array,graph,io,math,ui,time;

roz=graph.full(true);
graph.size(roz[0],roz[1]);
o=[];
o['obtiznost']=1;
o['strana']=9;
o['zacina']=0;
o['procentder']=10;
o['cervena']=0xFF2020;
o['modra']=0x8080FF;
o['pozadi']=0xA040A0;
o['prubehbarva']=o['modra'];
o['sirka']=graph.size()[0];
o['vyska']=graph.size()[1];
o['menusirka']=math.floor(o['vyska']/6);
o['menuvyska']=math.floor(o['vyska']/12);
o['menufont']=math.round(o['menuvyska']/2);
o['napovedasirka']=math.floor(o['vyska']/12);
o['napovedavyska']=math.floor(o['vyska']/12);
o['napovedafont']=math.round(o['napovedavyska']/2);
o['hodnocenisirka']=math.floor(o['sirka']/2);
o['hodnocenivyska']=math.floor(o['vyska']/10);
o['hodnocenifont']=math.floor(o['vyska']/15);
o['jazyk']=0;

lang=['English','česky'];

text=[
'menu': ['Menu','Menu'],
'continue': ['Continue Game','Pokračovat ve hře'],
'newgame': ['Restart Game','Nová hra'],
'level': ['Difficulty','Obtížnost'],
'easy': ['Easy','lehká'],
'hard': ['Hard','těžká'],
'veryhard': ['Very hard','velice těžká'],
'warninglongthinking': ['Warning: thinking of computer may be VERY long.'+' It\'s recommended use it on small board only or on ending of game.\nContinue?','Upozornění: počítač může přemýšlet VELICE dlouho.'+' Je doporučeno tuto obtížnost používat pouze na malých polích nebo v koncovkách.\nPokračovat?'],
'warning': ['Warning','Upozornění'],
'firstmove': ['First Move','První tah'],
'wholost': ['Who Lost','kdo prohrál'],
'human': ['Human','člověk'],
'computer': ['Computer','počítač'],
'holepercent': ['Percent of Holes','Procent děr'],
'boardsize': ['Board Size','Velikost pole'],
'lang': ['Language','Jazyk'],
'rules': ['Game Rules','Pravidla hry'],
'about': ['About Game','O hře'],
'quit': ['Quit Game','Skončit hru'],
'gpl': ['Game is distributed under GPL, so share, improve and enjoy it ;-)\n\nMore info at','Hra je uvolněna pod GPL. Šiřte, vylepšujte a užívejte ;-)\n\nVíce informací na'],
'rulestext1': ['Your task is to have more your stones (red) than your opponent (blue).','Vaším úkolem je získat co nejvíce svých (červených) kamenů na úkor modrého protihráče.'],
'rulestext2': ['Control:\nClick on your stone and choose turn.\n\nThere are two types of movement:\n'+'- when you choose near field (green one), than your stone is cloned\n'+'- when you choose field 2 fields far (yellow or red highlighted), your stone is moved there','Ovládání:\nKlikněte na červený kámen a vyberte tah.\n\nJsou dva typy tahů:\n'+'- pokud zahrajete na políčko vedle (vyznačeno zeleně), kámen se rozmnoží\n'+'-pokud zahrajete ob jedno políčko (vyznačeno žlutě nebo červeně), kámen tam přeskočí'],
'rulestext3': ['After this all opponent\'s stones near yours new is turned to yours.','Po výběru tahu se všechny protihráčovy kameny v blízkosti nového kamene přebarví.'],
'tie': ['Tie','Remíza'],
'youwin': ['You win, congratulations!','Vyhrál jsi, gratuluji!'],
'youlost': ['You lost, I\'m afraid..','Prohrál jsi, bohužel..'],
'gameover': ['Game Over','Konec hry']
];

try
  proud=io.open('KyblHexxagon.cfg',false,io.utf8);
  nastav=code(io.read(proud,5));
  o['jazyk']=nastav[0];
  o['obtiznost']=nastav[1];
  o['zacina']=nastav[2];
  o['procentder']=nastav[3];
  o['strana']=nastav[4];
  io.close(proud);
catch e by
end;
o['strana_nova']=o['strana'];
.rozdilpoctukamenu=0;

function text(co)
  return .text[co][.o['jazyk']];
end;

function vp(pol,hlaska=true)
          //vypise pole
  if pol = null then vysl='@null'
  elsif isboolean(pol) then
    if pol then vysl='@true' else vysl='@false' end;
  elsif isnum(pol) then vysl=str(pol);
  elsif isstr(pol) then vysl=pol;
  elsif isarray(pol) then
    vysl='[';
    i=0;
    for klic in keys(pol) do
      if klic = null then
        vysl=vysl+vp(pol[i],false)+', ';
      else
        vysl=vysl+klic+': '+vp(pol[klic],false)+', ';
      end;
      i++;
    end;
    if len(vysl) > 1 then
      vysl=substr(vysl,0,len(vysl)-2);
    end;
    vysl=vysl+']';
  else
    vysl='';
  end;
  if hlaska then
    ui.msg(vysl);
  end;
  return vysl;
end;

function uloznastaveni()
  try
    proud=io.create('KyblHexxagon.cfg',io.utf8);
    io.write(proud,char([.o['jazyk'],.o['obtiznost'],.o['zacina'],.o['procentder'],.o['strana_nova']]));
    io.close(proud);
  catch e by
  end;
end;

function napismenu()
  while true do
    obt=[null,'easy','hard','veryhard'];
    obt=obt[.o['obtiznost']];

    case .o['zacina']
      in 0: zacina='wholost';
      in 1: zacina='human';
      in 2: zacina='computer';
      else throw 'Neznámá hodnota: '+.o['zacina'];
    end;

    poz=ui.list([text('continue'),text('newgame'),text('level')+': '+text(obt),text('firstmove')+': '+text(zacina),text('holepercent')+': '+str(.o['procentder'])+' %',text('boardsize')+': '+str(math.ceil(.o['strana_nova']/2)),text('lang')+': '+.lang[.o['jazyk']],text('rules'),text('about'),text('quit')],false,[],'KýblHexxagon');

    if poz = null then
      break;
    end;
    case poz[0]
      in 0: break;
      in 1: return 'restart';
      in 2:
        obtiznost=ui.list([text('easy'),text('hard'),text('veryhard')],false,[.o['obtiznost']-1],text('level'));
        if obtiznost # null then
          if obtiznost[0] < 2 or ui.confirm(text('warninglongthinking'),text('warning')) then
            .o['obtiznost']=obtiznost[0]+1;
            uloznastaveni();
          end;
        end;
      in 3:
        zacina=ui.list([text('wholost'),text('human'),text('computer')],false,[.o['zacina']],text('firstmove'));
        if zacina # null then
          .o['zacina']=zacina[0];
          uloznastaveni();
        end;
      in 4:
        try
          procent=ui.query(text('holepercent'),'KýblHexxagon',.o['procentder']);
        catch e by
          procent=null;
        end;
        if procent # null then
          if procent < 0 then
            procent=0;
          end;
          if procent > 50 then
            procent=50;
          end;
          .o['procentder']=math.floor(procent);
          uloznastaveni();
        end;
      in 5:
        try
          strana=ui.query(text('boardsize'),'KýblHexxagon',math.ceil(.o['strana_nova']/2));
        catch e by
          strana=null;
        end;
        if strana # null then
          if strana < 3 then
            strana=3;
          end;
          if strana > 10 then
            strana=10;
          end;
          .o['strana_nova']=(math.floor(strana)*2)-1;
          uloznastaveni();
        end;
      in 6:
        jazyk=ui.list(.lang,false,[.o['jazyk']],text('lang'));
        if jazyk # null then
          .o['jazyk']=jazyk[0];
          uloznastaveni();
        end;
      in 7:
        ui.msg(text('rulestext1'),text('rules')+' (1/3)');
        ui.msg(text('rulestext2'),text('rules')+' (2/3)');
        ui.msg(text('rulestext3'),text('rules')+' (3/3)');
      in 8: ui.msg('KýblHexxagon v1.11\n\nCopyleft Aleš Janda, KÝBLSoft 2008\n\n'+text('gpl')+' www.kyblsoft.cz/mobil',text('about'));  //please don't edit this license text. Thanks :-)
      in 9: return 'konec';
    end;
  end;
end;

function validnipozice(x,y,pole)
  return (not (x < 0 or y < 0 or y >= len(pole) or x >= len(pole[y]) or pole[y][x] = null));
end;

function vratpolohu(sour,pole)
  sour[0]-=.o['okrajx'];
  sour[1]-=.o['okrajy'];

  pozx=math.floor(sour[0]/.o['rozmer']);
  zbx=sour[0]%.o['rozmer'];
  sour[1]-=pozx*(.o['rozmer']/2);
  sour[1]+=.o['rozmer']*.o['strana']/2/.o['strana']*math.floor(.o['strana']/2);
  pozy=math.floor(sour[1]/.o['rozmer']);
  zby=sour[1]%.o['rozmer'];

  if zbx < math.floor(.o['rozmer']/2) then
    if zby < math.floor(.o['rozmer']/2) then
      if zbx < (math.floor(.o['rozmer']/2)-zby) then
        pozx--;
      end;
    else
      if (zby-math.floor(.o['rozmer']/2)) > zbx then
        pozx--;
        pozy++;
      end;
    end;
  end;

  if not validnipozice(pozx,pozy,pole) then
    return null;
  end;

  return [pozx, pozy];
end;

function polevalidnich(hodnoty,pole,ivolne,ihracecislo)
  vysl=[];
  for hodnota in hodnoty do
    x=hodnota[0];
    y=hodnota[1];

    if validnipozice(x,y,pole) then
      if pole[y][x] = 0 then
        if ivolne then
          append(vysl,hodnota);
        end;
      else
        if pole[y][x] = ihracecislo then
          append(vysl,hodnota);
        end;
      end;
    end;
  end;
  return vysl;
end;

function vratsousedni(x,y,pole,ivolne,ihracecislo,idruhauroven)
  prvni=[[x,y-1],[x+1,y-1],[x+1,y],[x,y+1],[x-1,y+1],[x-1,y]];
  prvni=polevalidnich(prvni,pole,ivolne,ihracecislo);

  if idruhauroven then
    druhy=[[x,y-2],[x+1,y-2],[x+2,y-2],[x+2,y-1],[x+2,y],[x+1,y+1],[x,y+2],[x-1,y+2],[x-2,y+2],[x-2,y+1],[x-2,y],[x-1,y-1]];
    druhy=polevalidnich(druhy,pole,ivolne,ihracecislo);
  else
    druhy=[];
  end;

  return [[x,y],prvni,druhy];
end;

function jevpoli(co,pol)
  for p in pol do
    if p[0]=co[0] and p[1]=co[1] then
      return true;
    end;
  end;
  return false;
end;

function nakreslihexagon(pozx,pozy,hrac,hranice=null)
  if hranice = null then
    hranice=.o['pozadi'];
  end;
  x=pozx*.o['rozmer']+.o['okrajx'];
  y=pozy*.o['rozmer']+pozx*.o['rozmer']/2-math.floor(.o['strana']/2)*.o['rozmer']/2+.o['okrajy'];
  l=.o['rozmer'];
  graph.pen(hranice);
  graph.brush(.o['pozadi']);

  graph.poly([x+l/2,x+l,x+3/2*l-1,x+l,x+l/2,x+1],[y+1,y+1,y+l/2,y+l-1,y+l-1,y+l/2]);
  if hrac # 0 then
    case hrac
      in 1: graph.brush(.o['cervena']);
      in 2: graph.brush(.o['modra']);
    end;
    graph.pen(graph.black);
    graph.circle(x+3/4*l-3/8*l,y+1/8*l,3/4*l);
  end;
end;

function nakresliplochu()
  graph.pen(graph.black);
  graph.brush(graph.black);
  graph.rect(0,0,.o['sirka'],.o['vyska']);

  pole=[];
  
  for pozy=0 to (.o['strana']-1) do
    append(pole,[]);
    for pozx=0 to (.o['strana']-1) do
      if math.random() > .o['procentder']/100 then
        append(pole[pozy],0);
      else         //dira
        append(pole[pozy],null);
      end;
    end;
  end;

  for pozy=0 to math.floor(.o['strana']/2)-1 do
    for pozx=math.floor(.o['strana']/2)-1-pozy to 0 by -1 do
      pole[pozy][pozx]=null;
    end;
  end;

  for pozy=math.floor(.o['strana']/2)+1 to (.o['strana']-1) do
    for pozx=.o['strana']-(pozy-math.floor(.o['strana']/2)) to (.o['strana']-1) do
      pole[pozy][pozx]=null;
    end;
  end;

  pole[math.floor(.o['strana']/2)][0]=1;
  pole[.o['strana']-1][0]=2;
  pole[.o['strana']-1][math.floor(.o['strana']/2)]=1;
  pole[math.floor(.o['strana']/2)][.o['strana']-1]=2;
  pole[0][.o['strana']-1]=1;
  pole[0][math.floor(.o['strana']/2)]=2;

  for pozy=0 to (.o['strana']-1) do
    for pozx=0 to (.o['strana']-1) do
      if pole[pozy][pozx] # null then
        nakreslihexagon(pozx,pozy,pole[pozy][pozx]);
      end;
    end;
  end;
  return pole;
end;

function prekreslinutne(co,pole,ohraniceni)

  barva=.o['pozadi'];
  if ohraniceni then
    barva=graph.white;
  end;
  if co[0] # null then
    nakreslihexagon(co[0][0],co[0][1],pole[co[0][1]][co[0][0]],barva);
  end;

  if ohraniceni then
    barva=graph.green;
  end;
  for sous in co[1] do
    x=sous[0];
    y=sous[1];

    nakreslihexagon(x,y,pole[y][x],barva);
  end;

  for sous in co[2] do
    if ohraniceni then
      if len(vratsousedni(sous[0],sous[1],pole,false,1,false)[1]) > 0 then
        barva=graph.red;
      else
        barva=graph.yellow;
      end;
    end;
    nakreslihexagon(sous[0],sous[1],pole[sous[1]][sous[0]],barva);
  end;
end;

function vratdruhehohrace(hrac)
  case hrac
    in 1: return 2;
    in 2: return 1;
  end;
  ui.error('Špatný hráč!');
end;

function prebarvisousedni(x,y,pole,naco)
  prebarvit=vratsousedni(x,y,pole,false,vratdruhehohrace(naco),false);
  for pr in prebarvit[1] do
    pole[pr[1]][pr[0]]=naco;
  end;
  return prebarvit;
end;

function vratvyhodnosthrace(pole,hrac)
  vysl=[0,0,0];
  for y=0 to (.o['strana']-1) do
    for x=0 to (.o['strana']-1) do
      case pole[y][x]
        in 1: vysl[1]++;
        in 2: vysl[2]++;
      end;
    end;
  end;
  case hrac
    in 1: vysl[0]=vysl[1]-vysl[2];
    in 2: vysl[0]=vysl[2]-vysl[1];
    else throw 'Neznámý hráč!';
  end;
  return vysl;
end;

function vypisprubeh(prubeh)
  if prubeh = null then
    graph.pen(graph.black);
    graph.brush(graph.black);
    graph.rect(0,(.o['vyska']-1)-math.ceil(.o['menuvyska']/2),.o['menusirka'],math.ceil(.o['menuvyska']/2));
    return;
  end;

  if prubeh > 1 then
    prubeh=1;
  end;

  graph.pen(.o['prubehbarva']);
  graph.brush(graph.black);
  graph.rect(0,(.o['vyska']-1)-math.ceil(.o['menuvyska']/2),.o['menusirka'],math.ceil(.o['menuvyska']/2));
  graph.brush(.o['prubehbarva']);
  graph.rect(1,(.o['vyska']-1)-math.ceil(.o['menuvyska']/2)+1,math.round(prubeh*(.o['menusirka']-2)),math.ceil(.o['menuvyska']/2)-2);
  graph.show();
end;

function vypisstav(pole)
  stav=vratvyhodnosthrace(pole,2);

  graph.pen(graph.black);
  if stav[0] < 0 then
    graph.brush(.o['cervena']);
  elsif stav[0] = 0 then
    graph.brush(graph.white);
  else
    graph.brush(.o['modra']);
  end;

  graph.rect(0,0,.o['hodnocenisirka'],.o['hodnocenivyska']);
  graph.brush(graph.black);
  graph.rect(math.round(.o['hodnocenivyska']*1/7),math.round(.o['hodnocenivyska']*1/7),.o['hodnocenisirka']-2*math.round(.o['hodnocenivyska']*1/7),.o['hodnocenivyska']-2*math.round(.o['hodnocenivyska']*1/7));

  graph.font(['SwissA',.o['hodnocenifont'],true,false]);
  
  graph.pen(.o['cervena']);
  graph.text(math.round(.o['hodnocenisirka']*1/13),math.round(.o['hodnocenivyska']*3/4),str(stav[1]));
  graph.pen(.o['modra']);
  graph.text(math.round(.o['hodnocenisirka']*4.5/13),math.round(.o['hodnocenivyska']*3/4),str(stav[2]));
  
  graph.font(['SwissA',math.round(.o['hodnocenifont']*5/6),true,false]);
  graph.pen(0xB0B0B0);
  graph.text(math.round(.o['hodnocenisirka']*8/13),math.round(.o['hodnocenivyska']*3/4)-math.floor(.o['hodnocenifont']*1/12),str(-(stav[0]+.rozdilpoctukamenu)/2));
  .rozdilpoctukamenu=stav[0];
end;

function dokoncihru(pole,inaobrazovce)
    //dobarvi vsechna pole okolo
  do
    zmena=false;
    for y=0 to (.o['strana']-1) do
      for x=0 to (.o['strana']-1) do
        if pole[y][x] = 0 then
          if len(vratsousedni(x,y,pole,false,1,false)[1]) > 0 then
            pole[y][x]=1;
            if inaobrazovce then
              nakreslihexagon(x,y,1);
            end;
            zmena=true;
          elsif len(vratsousedni(x,y,pole,false,2,false)[1]) > 0 then
            pole[y][x]=2;
            if inaobrazovce then
              nakreslihexagon(x,y,2);
            end;
            zmena=true;
          end;
        end;
      end;
    end;
  until not zmena;

  if inaobrazovce then
    vypisstav(pole);
    graph.show();
    vysl=vratvyhodnosthrace(pole,2)[0];
    if vysl = 0 then
      ui.msg(text('tie'),text('gameover'));
      .tedzacina=math.floor(math.random()*2)+1;
    elsif vysl < 0 then
      ui.msg(text('youwin'),text('gameover'));
      .tedzacina=2;
    else
      ui.msg(text('youlost'),text('gameover'));
      .tedzacina=1;
    end;
  end;
end;

function makamhrat(pole,hrac)
  for y=0 to (.o['strana']-1) do
    for x=0 to (.o['strana']-1) do
      if pole[y][x] = hrac then
        sousedni=vratsousedni(x,y,pole,true,0,true);
        if len(sousedni[1]) > 0 or len(sousedni[2]) > 0 then
          return true;
        end;
      end;
    end;
  end;
  return false;
end;  

function vratnejlepsitah(pole,hrac,hloubka,muzedokoncit,stacimax,pisprubeh) forward;

function arraycopy(pole)
  navrat=array.create(len(pole),null);
  for y=0 to (len(pole)-1) do
    navrat[y]=array.copy(pole[y]);
  end;
  return navrat;
end;

function vratvyhodnosttahu(x,y,odx,ody,pole,vysl,vzdal,hrac,druhyhrac,pocvyhodnost,vyhodnost,hloubka,stacimax)

  if hloubka = 1 then
    hodnota=pocvyhodnost+vyhodnost;
  else     //vetsi hloubka
    tmppole=arraycopy(pole);
    tmppole[y][x]=hrac;
    if vzdal = 2 then
      tmppole[ody][odx]=0;
    end;
    prebarvisousedni(x,y,tmppole,hrac);
    hodnotapole=vratnejlepsitah(tmppole,druhyhrac,hloubka-1,false,stacimax,false);
    if hodnotapole=null then //uz je skonceno
      return;
    end;
    hodnota=-hodnotapole['hodnota'];
  end;
  if hodnota > vysl['nejlepsihodnota'] then
    vysl['nejlepsipole']=[];
    vysl['nejlepsihodnota']=hodnota;
  end;
  if hodnota = vysl['nejlepsihodnota'] then
    append(vysl['nejlepsipole'],['vzdal': vzdal, 'hodnota': hodnota, 'od': [odx,ody], 'do': [x,y]]);
  end;
end;

function vratnejlepsitah(pole,hrac,hloubka,muzedokoncit,stacimax,pisprubeh)
  vysl=[];
  vysl['nejlepsipole']=[];
  vysl['nejlepsihodnota']=-10000;
  druhyhrac=vratdruhehohrace(hrac);
  pocvyhodnost=vratvyhodnosthrace(pole,hrac)[0];
  if pisprubeh then
    vypisprubeh(0);
    casnapsaniprubehu=time.get();
  end;

  for y=0 to (.o['strana']-1) do
    for x=0 to (.o['strana']-1) do
      if pole[y][x] = 0 then
        if pisprubeh then
          casted=time.get();
          if casted > casnapsaniprubehu+0.1 then
            vypisprubeh(y/(.o['strana']-0.6)+x/.o['strana']/(.o['strana']-1));
            casnapsaniprubehu=casted;
          end;
        end;

        sousedni=vratsousedni(x,y,pole,false,hrac,true);

        if len(sousedni[1]) > 0 then
          sezrat=vratsousedni(x,y,pole,false,druhyhrac,false);
          vratvyhodnosttahu(x,y,sousedni[1][0][0],sousedni[1][0][1],pole,vysl,1,hrac,druhyhrac,pocvyhodnost,len(sezrat[1])*2+1,hloubka,-vysl['nejlepsihodnota']);
          if vysl['nejlepsihodnota'] > stacimax then
            return vysl['nejlepsipole'][len(vysl['nejlepsipole'])-1];
          end;
        end;
        if len(sousedni[2]) > 0 and (len(sousedni[1]) = 0 or hloubka > 2) then
          sezrat=vratsousedni(x,y,pole,false,druhyhrac,false);
          for sous in sousedni[2] do
            vratvyhodnosttahu(x,y,sous[0],sous[1],pole,vysl,2,hrac,druhyhrac,pocvyhodnost,len(sezrat[1])*2,hloubka,-vysl['nejlepsihodnota']);
            if vysl['nejlepsihodnota'] > stacimax then
              return vysl['nejlepsipole'][len(vysl['nejlepsipole'])-1];
            end;
          end;
        end;
      end;
    end;
  end;
  if len(vysl['nejlepsipole']) > 0 then
    poz=math.floor(math.random()*len(vysl['nejlepsipole']));
    return vysl['nejlepsipole'][poz];
  else    //nema kam hrat
    if muzedokoncit then
      dokoncihru(pole,true);
    else
      tmppole=arraycopy(pole);
      dokoncihru(tmppole,false);
      return ['hodnota': vratvyhodnosthrace(pole,hrac)[0]];
    end;
    return null;
  end;
end;

function pocitachraje(pole)
  tah=vratnejlepsitah(pole,2,.o['obtiznost'],true,10000,true);
  vypisprubeh(null);
  if tah = null then
    return false;    //konec hry
  end;

  if tah['vzdal'] = 2 then
    pole[tah['od'][1]][tah['od'][0]]=0;
  end;
  pole[tah['do'][1]][tah['do'][0]]=2;
  prekreslinutne([[tah['od'][0],tah['od'][1]],[],[]],pole,true);
  pouzivane=vratsousedni(tah['do'][0],tah['do'][1],pole,false,1,false);
  prekreslinutne(pouzivane,pole,true);
  graph.show();
  sleep(500);
  pouzivane=prebarvisousedni(tah['do'][0],tah['do'][1],pole,2);
  prekreslinutne([[tah['od'][0],tah['od'][1]],[],[]],pole,false);
  prekreslinutne(pouzivane,pole,false);
  pouzivane=[null,[],[]];
  vypisstav(pole);

  graph.show();

  return true;
end;

function sezermysdouvolneni()
  while true do
    ui.ptr(false);
    vstup=ui.cmd();
    if isarray(vstup) and vstup[2] = 0 then
      break;
    end;
  end;
end;

.tedzacina=1;
    //standardne zacina clovek

do
  skoncit=false;

  o['strana']=o['strana_nova'];  //mohla se zmenit nastavenim

  o['rozmer']=o['sirka']/(o['strana']+0.5);
  if o['rozmer'] > o['vyska']/o['strana'] then
    o['rozmer']=o['vyska']/o['strana'];
  end;
  o['rozmer']=math.floor(o['rozmer']/2)*2;

  o['okrajx']=math.floor((o['sirka']-o['strana']*o['rozmer']-o['rozmer']/2)/2);
  o['okrajy']=math.floor((o['vyska']-o['strana']*o['rozmer'])/2);

  .rozdilpoctukamenu=0;

  pole=nakresliplochu();
  vypisstav(pole);


  graph.pen(0x303030);
  graph.brush(0x707070);
  graph.rect(o['sirka']-o['menusirka'],o['vyska']-o['menuvyska'],o['menusirka'],o['menuvyska']);

  graph.pen(graph.black);
  graph.font(['SwissA',o['menufont'],true,false]);
  graph.text(o['sirka']-math.round(o['menusirka']*5/6),o['vyska']-math.round(o['menuvyska']/3),text('menu'));

  graph.show();
  pouzivane=[null,[],[]];

  case o['zacina']
    in 0: if .tedzacina = 2 then
             pocitachraje(pole);
           end;
    in 2: pocitachraje(pole);
  end;

  while true do
    if not makamhrat(pole,1) then
      dokoncihru(pole,true);
      break;
    end;

    do
      ui.ptr(false);
      ui.keys(false);
      vstup=ui.cmd();
    until isarray(vstup);

    if vstup[2] = 1 then //stisknuti
      if vstup[0] > o['sirka']-o['menusirka'] and vstup[1] > o['vyska']-o['menuvyska'] then
        case napismenu()
          in 'restart': break;
          in 'konec': skoncit=true;
            break;
        end;
      end;

      if vstup[0] < o['napovedasirka'] and vstup[1] > o['vyska']-o['napovedavyska'] then
        tah=vratnejlepsitah(pole,1,o['obtiznost'],true,10000,false);
        if tah # null then
          prekreslinutne(pouzivane,pole,false);
          pouzivaneted=[tah['od'],[],[tah['do']]];
          prekreslinutne(pouzivaneted,pole,true);

          graph.show();
          sezermysdouvolneni();

          prekreslinutne(pouzivaneted,pole,false);
          prekreslinutne(pouzivane,pole,true);
        end;
      end;

      poloha=vratpolohu(vstup,pole);
      if poloha # null then
        x=poloha[0];
        y=poloha[1];

        if jevpoli(poloha,pouzivane[1]) or jevpoli(poloha,pouzivane[2]) then
          if jevpoli(poloha,pouzivane[2]) then
            pole[pouzivane[0][1]][pouzivane[0][0]]=0;
          end;
          pole[y][x]=1;
          prekreslinutne(pouzivane,pole,false);
          pouzivane=vratsousedni(x,y,pole,false,2,false);
          prekreslinutne(pouzivane,pole,true);
          graph.show();
          sleep(500);
          pouzivane=prebarvisousedni(x,y,pole,1);
          prekreslinutne(pouzivane,pole,false);
          pouzivane=[null,[],[]];
          vypisstav(pole);
          graph.show();
        
          if not pocitachraje(pole) then
            break;
          end;
        else//oznaceni moznych tahu
          if pole[y][x] = 0 then
            prekreslinutne(pouzivane,pole,false);
            pouzivane=vratsousedni(x,y,pole,false,1,true);
            if len(pouzivane[1]) > 0 or len(pouzivane[2]) > 0 then //zobrazim, cim se na to policko da dostat
              for pouz in pouzivane[1] do  
                nakreslihexagon(pouz[0],pouz[1],pole[pouz[1]][pouz[0]],graph.white);
              end;

              for pouz in pouzivane[2] do
                nakreslihexagon(pouz[0],pouz[1],pole[pouz[1]][pouz[0]],graph.white);
              end;

              graph.show();
              sezermysdouvolneni();

              for pouz in pouzivane[1] do  
                nakreslihexagon(pouz[0],pouz[1],pole[pouz[1]][pouz[0]],o['pozadi']);
              end;

              for pouz in pouzivane[2] do
                nakreslihexagon(pouz[0],pouz[1],pole[pouz[1]][pouz[0]],o['pozadi']);
              end;
              pouzivane=[null,[],[]];
            end;
          elsif pole[y][x] = 1 then
            prekreslinutne(pouzivane,pole,false);
            pouzivane=vratsousedni(x,y,pole,true,0,true);
            if len(pouzivane[1]) = 0 and len(pouzivane[2]) = 0 then //timto nelze tahnout, zobrazim cim tahnout jde
              lzetahnout=[];
              for y=0 to (o['strana']-1) do
                for x=0 to (o['strana']-1) do
                  if pole[y][x] = 1 then
                    tmpmozne=vratsousedni(x,y,pole,true,0,true);
                    if len(tmpmozne[1]) > 0 or len(tmpmozne[2]) > 0 then
                      append(lzetahnout,[x,y]);
                      nakreslihexagon(x,y,pole[y][x],graph.white);
                    end;
                  end;
                end;
              end;

              graph.show();
              sezermysdouvolneni();
              for poztmp in lzetahnout do
                nakreslihexagon(poztmp[0],poztmp[1],pole[poztmp[1]][poztmp[0]],o['pozadi']);
              end;
              pouzivane=[null,[],[]];
            else
              prekreslinutne(pouzivane,pole,true);
            end;
          end;
        end;
      end;
      graph.show();
    end;
  end;

until skoncit;