include "cj_types.j"

globals
 stack array STACK
 trackable array ctr
 trackable array atb_tr
 int current //отряд, чей сейчас ход
endglobals
constant int MS = 55, ATB_W = 11
constant int ME = 30
struct stack
 int N, att, def, min, max, life, hp, sp, shoots, cell
 real C, ini
 unit mdl
 real array EFF_T[30]
 bool fly, huge
 real GetIni(void) {
  real val = ini
  if life == 0 {return 0.001}
  if EFF_T[4] - ATB_GT > 0 {val*=0.8} //замедление
  if EFF_T[5] - ATB_GT > 0 {val*=1.25} //ускорение
  return val
 }
endstruct

//ATB-Scale
globals
real ATB_GT, ATB_MT//глобальное и минимальное время
real array ATB_C//циклы отрядов
int array ATB_Scale//выходной массив
int ATB_I //какая клетка шкалы сейчас заполняется
endglobals

void ATB_Start (void) {int i = 0
ATB_Scale[0] = current
ATB_GT = 0.
ATB_I = 1
while (i<=MS) {ATB_C[i] = STACK[i].C; i++}
ExecuteFunc("ATB_Effects")}

void ATB_Effects (void) {
 int i = 0; real u = 0
 ATB_MT = 99999.999
 while (i<=MS) {u = 0.1*(STACK[i].EFF_T[4] - ATB_GT); if u < ATB_MT {ATB_MT=u}; i++}; i=0 //замедление
 while (i<=MS) {u = 0.1*(STACK[i].EFF_T[5] - ATB_GT); if u < ATB_MT {ATB_MT=u}; i++} //ускорение
 ExecuteFunc("ATB_Stacks")}
 
void ATB_Stacks (void) {
  int i = 0; real u = 0
  while (i<=MS) {u = (100-ATB_C[i])/STACK[i].GetIni(); if u<ATB_MT {ATB_MT=u}; i++}
  }

void ATB_Upgrade (void) {
 int i = 0; bool b = false; int f = 0
 ATB_GT += 10*ATB_MT
 while (i<=MS) {
  if STACK[i].life > 0 {ATB_C[i]+=STACK[i].GetIni()*ATB_MT
   if ATB_C[i] > 99.9 and ATB_C[i] > ATB_C[f] {f=i; b=true}}
  i++}
  if b {ATB_Scale[ATB_I] = f; ATB_I++}
  if ATB_I > ATB_W {ExecuteFunc("ATB_Finish")} else {ExecuteFunc("ATB_Effects")}}
  
void ATB_Finish (void) {
ATB_GT = 0.
// Теперь построим шкалу и продолжим

}

// Основная система с пошаговостью
globals
real Ini_MT
endglobals

void Ini_Effects (void) {int i = 0, j; real u
while (i<=MS) {j = 0
 while (j<=ME) {u = 0.1*STACK[i].EFF_T[j]; if Ini_MT > u and u > 0 {Ini_MT = u}; j++}
i++}
ExecuteFunc("Ini_Stacks")}

void Ini_Stacks (void) {int i = 0; real u
while (i<=MS) {u = (100.-STACK[i].C)/STACK[i].GetIni(); if Ini_MT > u and STACK[i].life > 0 {Ini_MT = u}; i++}
ExecuteFunc("Ini_UpgradeEffects")}

void Ini_UpgradeEffects (void) {int i = 0, j
while (i<=MS) {j = 0
 while (j<=ME) {
  STACK[i].EFF_T[j] -= Ini_MT * 10.
  j++}
i++}
ExecuteFunc("Ini_LastUpgrade")}

void Ini_LastUpgrade (void) {int i = 0, f = 0; bool b = false
while (i<=MS) {
 if STACK[i].life > 0 {STACK[i].C += STACK[i].GetIni()*Ini_MT; if STACK[i].C >= 99.9 and STACK[i].C > STACK[f].C {f=i; b=true}}
i++}
if b {current = f; ExecuteFunc("StartMove")} else {ExecuteFunc("Ini_Effects")}}

void StartMove (void) { //Начать ход #######################################################
                                   //#######################################################
                                   //#######################################################
}

//Алгоритм нахождения пути
globals
int array CS //Индексы клеток-источников
int array CW //Номера волн, в которых эти клетки проверяются
real array CL //Длина пути до клеток
bool array CF //Занята ли клетка
int wave //Номер текущей волны
int curr //Номер текущей клетки
bool FLYING, BIG //Флаги летающего/большого существа
unit array cell
endglobals
constant int mx = 11, my = 9
constant int mc = 119

bool GetCellPathability (int cx, int cy) { //Функция проверки проходимости одной клетки
if cx < 0 or cy < 0 or cx > mx or cy > my {return false}
return FLYING or not CF[cx + cy*mx]}

bool GCP (int cx, int cy) {//Функция проверки проходимости клеток для существа
if not BIG {return GetCellPathability(cx, cy)}
return GetCellPathability(cx, cy) and GetCellPathability(cx+1, cy) and GetCellPathability(cx, cy+1) and GetCellPathability(cx+1, cy+1)}

void CellFunc (void) { //Проверка текущей клетки
int dx = -1, dy, i, nx, ny; real nd
while (dx<=1) {dy = -1; while (dy<=1) {
 nx = ModuloInteger(curr, mx+1) + dx
 ny = curr/mx
 i = nx + ny*mx
 nd = CL[curr] + SquareRoot(dx*dx+dy*dy)
 if GCP(nx, ny) and CL[i] > nd {
  CS[i] = curr
  CW[i] = wave + 1
  CL[i] = nd
 }
dy++}dx++}
}

void NextCell (void) {int i = curr; bool b = false //main function
while (i <= mc {
 if CW[i] == wave {
  curr = i
  ExecuteFunc("CellFunc")
  return
 }
 if CW[i] == wave+1 {b = true}
i++}
if not b {} //Все, что можно, размечено
curr = 0; wave++; ExecuteFunc("NextCell")}

void WaveStart (void) {

}