{
//CHARACTER SPECIFIC DECISIONS
 var timing = fun(id,frame,smp,tmp,shp,thp){
  if (id == 0){return true
 }else if (id == 1){return true
 }else if (id == 2){if (frame >= 70 && frame <= 72){return false}else{return true}
 }else if (id == 4){return true
 }else if (id == 5){return true
 }else if (id == 6){return true
 }else if (id == 7){if (frame >= 70 && frame <= 74){return false}else{return true}
 }else if (id == 8){return true
 }else if (id == 9){return true
 }else if (id == 10){return true
 }else if (id == 11){if ((frame >= 70 && frame <= 73) || frame >= 305){return false}else{return true}
 }else{return true}
 }
//SETTINGS
 var defense = 1    //0: none, 1: aktive, 2: always
 var evasion = 1   //0: none, 1: aktive, 2: always
 var control = 1  //0: none, 1: follow, 2: flee
 var facing = 1  //0: none, 1: against, 2: same
 var attack = 1 //0: none, 1: aktive, 2: always
 var basic = 0 //0: basic AI, 1: no basic AI (enable control & facing)
//VARIABLES
 var xdst = self.x-target.x
 var ydst = self.y-target.y
 var zdst = self.z-target.z
 var zbgu = self.z-bg_zwidth1
 var zbgb = bg_zwidth2-self.z
 var xbgr = bg_width-self.x
 var xabs = abs(xdst)
 var yabs = abs(ydst)
 var zabs = abs(zdst)
 var xdir = xdst*(2*self.facing-1)
 
//COMBOS
 if (target.state == 16 || target.state == 8){
//ground
  if (target.hp <= 50){A();return basic}
  else if (target.state == 16 && target.hp <= 71){{if (xdst > 0){left()}else {right()};return basic}}
  else if (target.state == 16 && self.frame == 212){A();return 1}
  else if (target.state == 16){J();return 1}
  else {A();return basic}
}else if (target.frame == 181 || target.frame == 187){
//juggling
  if (self.state <= 1){if (xdst > 0){left()}else {right()};return 1}
  else if (self.state == 2){A();return 1}
 }
 
//DASH
 if (self.state == 5){A();return basic}
 
//CATCH
 if (self.state == 9){
  if (self.ctimer <= 50 && target.hp <= 30){if (self.x < xbgr){right()}else{left()}}
  A();return basic}
if (self.state == 12){print(target.ctimer)}
 
//EVASION
 if (evasion == 1){
//aktive
  if (self.state == 12 && (target.frame == 234 || (target.id == 6 && target.ctimer == 250 && target.frame != 247))){J();return basic}
  else if (self.state == 12 && (target.state == 3 || target.state == 301) && timing(target.id,target.frame,self.mp,target.mp,self.hp,target.hp)){J();print(target.frame);return basic}
  else if (self.frame == 215 && (target.state == 3 || target.state == 301)){D();return basic}
}else if (evasion == 2){
//always
  if (self.state == 12){J();return basic}
  else if (self.frame == 215){D();return basic}
 }
 
//DEFENSE
 if (defense == 1 && (target.state == 3 || target.state == 301) && xabs <= 80 && zabs <= 10 && timing(target.id,target.frame,self.mp,target.mp,self.hp,target.hp)){D();print(target.frame)}
//aktive
 else if (defense == 2){D()}
//always
 if (self.frame == 110 && target.facing == self.facing){if (self.facing == 1){right()}else{left()};return basic}
//defend against target
 
//ATTACK
 if (attack == 1 && self.state <= 1 && target.y <= 10 && xdir <= 60 && xdir >= -15 && zabs <= 10){A();return basic}
//aktive
 else if (attack == 2){A();return basic}
//always
 
//CONTROL
 if (basic == 1){
//none
  if (control == 0 && self.state == 2){if (self.facing == 0){left()}else {right()};return basic}
//follow
  if (control == 1){
   if (zabs > 5){if (zdst < 0){down()}else {up()}}
   if (xabs > 60){if (xdst > 0){left()}else {right()};return basic}
   else if (self.state == 2){if (xdst < 0){left()}else {right()};return basic}
//flee
 }else if (control == 2){
   if (zabs < 50){if (zdst > 0 && zbgb > 10){down()}else if(zdst < 0 && zbgu > 10){up()}}
   if (xabs < 300){if (xdir < 0 && self.x > 150){left()}else  if(xdir > 0 && xbgr > 150){right()}}
   if (self.state == 2 && (xabs > 300 || self.x < 150 || xbgr < 150)){if (self.facing == 0){left()}else {right()};return basic}
  }
//FACING
  if (facing == 2 && target.facing != self.facing && (self.state == 0 || self.state == 7)){if (self.facing == 1){right()}else{left()};return basic
//same
 }else if (facing == 1 && target.facing == self.facing && (self.state == 0 || self.state == 7)){if (self.facing == 1){right()}else{left()};return basic}
//against
 }
 
//BASIC
 return basic
}

{
 //TODO
 //instant leap attack after super punch (rest)
 //rebound D>A blasts
 //define variables
 var sfac = 2*self.facing-1              //own direction (-1: left, 1: right)
 var tfac = 2*target.facing-1           //target direction (-1: left, 1: right)
 var bfac = self.facing+target.facing-1//both facing (-1: left, 0: against, 1: right)
 var stxd = self.x-target.x           //x distance (left > 0 > right)
 var styd = self.y-target.y          //y distance (above > 0 > below)
 var stzd = abs(self.z-target.z)    //z distance
 var dist = stxd*sfac              //directional distance
 var test = 0 //0: no testing, 1: defensive, 2: open, 3: offensive, 4: passive
 var tmp = target.mp
 var smp = self.mp
 //no mp combo
 if (dist >= 0 && target.state == 12 && styd > 60 && styd < 90){
  if (self.state <= 1){if (stxd > 0){left()}else {right()};return 1}//run
  else if (self.state == 2){A();return 1}                           //attack
 }
 //combo breaker
 if (test != 4 && stzd < 10 && dist < 75 && dist >= -5 && target.y == 0 && (self.frame == 111 || self.state == 8 || self.state == 11 || self.state == 16)){
  if (smp >= 225 && self.frame != 111){DuA()}else if (smp >= 75 && self.frame == 111 && (tmp < 193 || smp >= 293)){DdA()}else if (((target.frame >= 280 && target.frame <= 278 && smp >= 225) || tmp < 70) && (target.frame < 70 && target.frame > 72) && test <= 1){D()};return 1
 }//flip
 else if (self.state == 12 && test != 4){
  if (target.frame == 301 || (target.frame >= 290 && target.frame <= 293) || target.frame == 75){J()}
 }//dash, roll
 else if (self.frame == 215 && self.bdefend >= 20 && test != 4){
  if (dist > 0 && target.frame < 290 && target.frame > 293){J()}else {D()}
 }
 //facing
 if (bfac != 0 && self.state == 7 && stzd < 10 && target.y == 0 && test != 4){//defense
  if (sfac < 0){left()}else {right()}//turn
 }
 else if (stzd < 10 && dist < 0 && self.state != 1 && self.state != 7 && test != 4){//normal
  if (stxd > 0){left()}else {right()}//turn
 }
 //defending
 if (stzd < 10 && self.state != 7 && target.state == 3 && abs(dist) < 100 && target.y == 0 && ((target.frame >= 280 && target.frame <= 278 && smp >= 225) || tmp < 70) && (target.frame < 70 && target.frame > 72) && test <= 1){D()}//combos
 else if (stzd < 10 && dist < 70 && dist >= -5 && test != 4){
  if (target.hp > 0 && target.hp <= 114 && smp >= 225 && target.state != 12 && target.state != 7){DuA();return 1}//finisher
  else if (self.frame == 39 && target.state == 12){J();return 1}                                                 //super combo
  else if ((self.frame == 278 || self.frame == 279) && tmp >= 225 && target.shake > 0){DuA();return 1}           //safe combo
  else if ((target.state == 16 || target.state == 8) && smp >= 150 && (tmp < 193 || smp >= 293)){DdA();return 1} //starter
  else if (target.state == 16 && self.state == 0 && tmp >= 225){if (stxd > 0){left()}else {right()};return 1}    //grab
  else if ((self.frame == 281 || self.frame == 282) && target.state == 12){if (smp >= 450){DuA();return 1}       //doubleDstart
   else if (smp >= 100){J();return 1}else if (stxd > 0){left()}else {right()};return 1}                          //low mp start
  else if (target.hp > 0 && target.state == 12 && styd > 90 && self.frame == 215 && smp >= 225){DuA();return 1}  //double dragon
  else if ((target.frame == 181 || target.frame == 187) && target.hp > 0 && smp >= 225){DuA();return 1}          //fall dragon
 }
 //opportunities
 if (self.state == 5 || self.state == 9 || (self.frame == 292 && styd < 7)){//dash,grab,leap attack
  if ((target.hp <= 138 || self.ctimer < 40) && self.state == 9 && smp >= 300){DdA()}      //finisher
  else if ((target.hp <= 114 || self.ctimer < 40) && self.state == 9 && smp >= 225){DuA()}//finisher
  else if (self.ctimer < 40 && self.state == 9 && smp >= 75 && tmp < 225){DdA();return 1}//end
  else {A()};return 1}                                                                  //attack
 else if (self.frame == 292 || self.frame == 87){return 1}                             //wait
 //void unwanted inputs
 if (self.DrA >= 2 || self.DlA >= 2 || self.DuA >= 2 || self.DdA >= 2 || self.DuJ >= 2){
  if (self.z - target.z < 0){down()}else {up()}
 } 
 //test control
 if (test == 1 || test == 2 || test == 4){//defensive, open, passive
  if (stzd > 5){if (self.z - target.z < 0){down()}else {up()}}  //zfollow
  if (abs(stxd) > 100){if (stxd > 0){left()}else {right()}}     //xfollow
  else if (self.state == 2){if (stxd < 0){left()}else {right()}}//stop
  return 1
 }
 else if (test == 3){                                      //offensive
  if (self.state == 0){A()}                                //attack
  if (self.state == 2){if (stxd < 0){left()}else {right()}}//stop
  return 1
 }
 else {return 0}//free
}

//true if within z range
bool zdst(int range){
 if(abs(self.z-target.z)<=range){return true;}
 else{return false;}
}
//true if within x range
bool xdst(int close, int far){
 if(abs(self.x-target.x)>=close && abs(self.x-target.x)<=far){return true;}
 else{return false;}
}
//true if self/target facing
bool facing(int tar){
 if(tar==0){
  if((self.x-target.x)*(2*(self.facing?1:0)-1)>0){return true;}
  else{return false;}
 }
 else{
  if((target.x-self.x)*(2*(target.facing?1:0)-1)>0){return true;}
  else{return false;}
 }
}
//true if hitable
bool canhit(int fall){
 if(fall==2 && (target.state==16||target.state==8)){return true;}
 else if(fall>=1 && target.state==12){return false;}
 else if(target.blink!=0 || target.state==14 || target.state==6){return false;}
 else{return true;}
}
//true if within frame range
bool frame(int first, int last){
 if(self.frame>=first && self.frame<=last){return true;}
 else{return false;}
}
//perform D<>A towards target
void DfA(){
 if((self.x-target.x)<0){DrA();}
 else{DlA();}
}
//perform D<>J towards target
void DJ(){
 if((self.z-target.z)<0){DdJ();}
 else{DuJ();}
}
//perform Dv^J towards target
void DfJ(){
 if((self.x-target.x)<0){DrJ();}
 else{DlJ();}
}
//void unwanted inputs
void inputs(){
 if(self.DuA>=2||self.DrA>=2||self.DlA>=2||self.DdA>=2||self.DuJ>=2||self.DrJ>=2||self.DlJ>=2||self.DdJ>=2){up();down();}
}
//is attacking?
bool attack(){
 if(target.id==self.id && (target.frame==256||target.frame==173||target.frame==193)){return false;}
 int x=target.state;
 int i=0;
 do{x/=10;i++;}while(x>0);
 x=1;for(i; i > 1; --i){x*=10;}
 if(target.state/x==3){return true;}else{return false;}
}
 
int ego(){ 
//dodge
 if(facing(1) && self.state<=1 && zdst(13) && attack()){J();A();return 1;}
 else if(facing(1) && frame(110,111) && zdst(13) && attack()){DJ();return 1;}
 else if(facing(1) && self.state==2 && zdst(13) && attack()){D();A();return 1;}
//counters
 else if(frame(111,111)){
  if(self.mp>=300 && self.hp>=200 && xdst(150,300) && zdst(30)){DdA();}
  else if(self.mp>=145 && canhit(1) && xdst(235,650) && zdst(20)){DfA();}
  else if(self.mp>=250 && canhit(1) && xdst(0,190) && zdst(10)){DfJ();}
  else if(self.mp>=200 && canhit(1) && xdst(0,235) && zdst(80)){DJ();}
  else if(xdst(0,80) && zdst(10)){A();}
  else if(self.dark_hp-self.hp>=75){J();}return 1;
 }
//combos
//DA keep in line
 else if(frame(193,193) && target.state == 12 && zdst(10)){return 1;}
//DJ move away
 else if(frame(172,173) && attack() && zdst(13)){if(self.z-target.z>=0){down();}else{up();}return 1;}
//DJ move closer
 else if(frame(172,173) && !attack()){if(self.z-target.z>=0){up();}else{down();}return 1;}
//Dv^J close in
 else if(frame(256,256)||frame(282,282)){if(self.z-target.z>=0){down();}else{up();}return 1;}
//D<>A continue
 else if(self.mp>=45 && (frame(243,245)||frame(252,252)) && canhit(1) && xdst(235,650) && zdst(20)){A();}
//D<>J combo back
 else if(self.mp>=100 && frame(267,269) && canhit(0) && (facing(0)||(!facing(0) && (xdst(131,150)||(target.y==0&&target.state!=12)))) && zdst(10)){DfJ(); return 1;}
//super punch skip
 else if(self.mp>=175 && frame(77,77) && canhit(0) && facing(0) && zdst(10)){D(); return 1;}
//super punch leap
 else if(frame(77,77) && canhit(0) && facing(0) && zdst(10)){J(); return 1;}
//super punch slice D<>J
 else if(frame(48,48) && canhit(0) && facing(0) && zdst(10)){DfJ(); return 1;}
//D<>J continue
 else if((frame(258,258)||frame(23,23)) && canhit(0) && facing(0) && xdst(0,150) && zdst(10)){J(); return 1;}
//D<>J prevent
 else if((frame(258,258)||frame(23,23)) && !zdst(10)){return 1;}
//start
 else if(self.mp>=360 && self.hp>=140 && xdst(150,300) && zdst(30)){DdA();}
 else if(self.mp>=90 && canhit(1) && xdst(250,650) && zdst(20)){DfA();}
 else if(self.mp>=160 && canhit(1) && xdst(90,190) && zdst(10) && !frame(260,399)){DfJ();}
 else if(self.mp>=160 && canhit(2) && xdst(0,80) && zdst(10) && !frame(260,399)){DfJ();}
 else if(self.mp>=110 && canhit(1) && facing(0) && xdst(0,235) && zdst(80)){DJ();}
 else{inputs();}
 return 0;
}

int ego(){
//close range:
if (target.y == 0 && abs(target.z-self.z) < 9 && (self.x-target.x)*((self.facing?1:0)*2-1) < 0 && (self.x-target.x)*((self.facing?1:0)*2-1) < 100 && target.state == 16 && self.mp >= 250){
 if (abs(self.x-target.x) > 0 && (self.state == 2 || self.state == 0)){
  if (self.x-target.x > 0){left();}         //turn back
  else {right();}
 }
 else if (self.x-target.x < 0){left();}  //adjust x for D^A
 else {right();}
 return 1;
}//basic move conditions:
else if (target.y == 0 && abs(target.z-self.z) < 9 && (self.x-target.x)*((self.facing?1:0)*2-1) > 0 && (self.x-target.x)*((self.facing?1:0)*2-1) < 100){
 if (target.state == 16 && self.mp >= 250 && abs(self.x-target.x) > 50){DuA();} //D^A against DoP
 else if (target.state == 16 && self.mp >= 250){                              //adjust x for D^A
  if (self.x-target.x < 0){left();}
  else {right();}
  return 1;
 }
 else if (target.state == 8 || target.state == 16){DdA();}    //DvA against DoP and broken defense
 else if (target.state == 3 && self.mp >= 75){D();}          //D against attacks with enough mp
 if (self.state == 7 && self.bdefend >= 20){DdA();}         //DvA from critical defense
}
//long/mid range:
else if (self.x-target.x != 0){
 if (target.state != 12 && abs(100*(self.z-target.z)/((self.x-target.x)*((self.facing?1:0)*2-1))) <= 15 && abs(self.x-target.x) < 200 && abs(self.x-target.x) > 80){
  if (self.x-target.x > 0){DlJ();}         //D<J
  else if (self.x-target.x < 0){DrJ();}   //D>J
 }
 else if (abs(100*(self.z-target.z)/((self.x-target.x)*((self.facing?1:0)*2-1))) <= 15 && abs(self.x-target.x) < 400 && abs(self.x-target.x) > 200){
  if (self.x-target.x > 0){DlA();}         //D<A
  else if (self.x-target.x < 0){DrA();}   //D>A
 }
}
//instant attacks
if (self.state == 5){A();}                                               //dash attack
if ((self.frame == 75 || self.frame == 275) && target.state == 12){J();}//leap
if (self.frame == 319){A();}                                           //leap attack
if (self.frame == 94 && target.state == 12){A();}                     //slide kick
if (self.frame == 215 && target.state == 12){J();}                   //dash combo
return 0;
}