Advertisement
leviaiz

Untitled

Aug 22nd, 2017
74
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C 7.31 KB | None | 0 0
  1. bool currentFacing = false;
  2.  
  3. //true if within z range
  4. bool zdst(int range){
  5.  if(abs(self.z-target.z)<=range){return true;}
  6.  else{return false;}
  7. }
  8. //true if within x range
  9. bool xdst(int close, int far){
  10.  if(abs(self.x-target.x)>=close && abs(self.x-target.x)<=far){return true;}
  11.  else{return false;}
  12. }
  13.  
  14. int zxratio() {
  15.  return abs(self.z-target.z)*100/(abs(self.x-target.x)+1);
  16. }
  17.  
  18. //
  19. bool face(){
  20.  return (self.x-target.x) >0;
  21. }
  22. //true if hitable
  23. bool canhit(int fall){
  24.  if(fall==2 && (target.state==16||target.state==8)){return true;}
  25.  else if(fall>=1 && target.state==12){return false;}
  26.  else if(target.blink!=0 || target.state==14 || target.state==6){return false;}
  27.  else{return true;}
  28. }
  29.  
  30. bool loosehit(){
  31.  if(target.state==16||target.state==8 || target.state==12){return true;}
  32.  else if(target.blink!=0 || target.state==14 || target.state==6){return false;}
  33.  else{return true;}
  34. }
  35. //true if within frame range
  36. bool frame(int first, int last){
  37.  if(self.frame>=first && self.frame<=last){return true;}
  38.  else{return false;}
  39. }
  40. //perform D<>A towards target
  41. void DfA(){
  42.  if(face()) {
  43.     DlA();
  44.     currentFacing = false;
  45.  }
  46.  else {
  47.     currentFacing = true;
  48.     DrA();
  49.  }
  50. }
  51. //perform D<>J towards target
  52. void DfJ(){
  53.  if(face()) {
  54.     DlJ();
  55.  }
  56.  else {
  57.     DrJ();
  58.  }
  59. }
  60. //void unwanted inputs
  61. void inputs(){
  62.  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();}
  63. }
  64. //is attacking?
  65. bool attack(){
  66.  int x=target.state;
  67.  int i=0;
  68.  do{x/=10;i++;}while(x>0);
  69.  x=1;for(i; i > 1; --i){x*=10;}
  70.  if(target.state/x==3){return true;}else{return false;}
  71. }
  72. //turn against
  73. void turn(){
  74.  if(face()){if(self.facing==true){right();}else{left();}}
  75. }
  76.  
  77. void loadClosestE() {
  78.     // Load nearest enemy
  79.     int k = 0;
  80.     int tx = 9999;
  81.     for (int i = 0; i < 400; ++i){
  82.     if (loadTarget(i) != -1 && target.type == 0 && target.team != self.team && abs(self.x-target.x)<tx){
  83.       tx = abs(self.x-target.x);
  84.       k = i;
  85.      }
  86.     }
  87.     loadTarget(k);
  88. }
  89.  
  90. bool loadClosestH() {
  91.     bool hexist = false;
  92.     // Load nearest heavy weapon
  93.     int k = 0;
  94.     int tx = 9999;
  95.     for (int i = 0; i < 400; ++i){
  96.     if (loadTarget(i) != -1 && target.type == 2 && abs(self.x-target.x)<tx && zxratio()<0.15){
  97.       tx = abs(self.x-target.x);
  98.       k = i;
  99.       hexist = true;
  100.      }
  101.     }
  102.     loadTarget(k);
  103.     return hexist;
  104. }
  105.  
  106. bool loadClosestP() {
  107.     bool pexist = false;
  108.     // Load nearest hostile projectile
  109.     int k = 0;
  110.     int tx = 9999;
  111.     for (int i = 0; i < 400; ++i){
  112.     if (loadTarget(i) != -1 && target.type > 0 && target.type != 5
  113.     && (target.state == 1001 ||target.state == 1002 ||target.state == 3005 ||target.state == 3006 ||target.state == 3000 ||target.state == 15)
  114.     && target.team != self.team && abs(self.x-target.x)<tx && zxratio()<0.15){
  115.       tx = abs(self.x-target.x);
  116.       k = i;
  117.       pexist = true;
  118.      }
  119.     }
  120.     loadTarget(k);
  121.     return pexist;
  122. }
  123.  
  124. bool distance_attack_danger()
  125. {
  126.     if (xdst(0,400) && zxratio()<15)
  127.         return true;
  128.     else
  129.         return false;
  130. }
  131. bool distance_attack_alert()
  132. {
  133.     if (xdst(200,450) && zxratio()<15)
  134.         return true;
  135.     else
  136.         return false;
  137. }
  138. bool diagonal_attack_danger()
  139. {
  140.     if (xdst(0,80) && zxratio()>15)
  141.         return true;
  142.     else
  143.         return false;
  144. }
  145. bool zero_range_danger()
  146. {
  147.     if (xdst(0,90) && zxratio()<15)
  148.         return true;
  149.     else
  150.         return false;
  151. }
  152.  
  153. int projectx()
  154. {
  155.     return target.x + 2* target.x_velocity;
  156. }
  157. int projectz()
  158. {
  159.     return target.z + 2* target.z_velocity;
  160. }
  161. //true if within z range
  162. bool zprojdst(int range){
  163.  if(abs(self.z-projectz())<=range){return true;}
  164.  else{return false;}
  165. }
  166. //true if within x range
  167. bool xprojdst(int close, int far){
  168.  if(abs(self.x-projectx())>=close && abs(self.x-projectx())<=far){return true;}
  169.  else{return false;}
  170. }
  171. int ego() {
  172.    
  173.     // Debug prints and hblock detection
  174.  
  175.     clr();
  176.     loadClosestE();
  177.     print("self x=" + self.x + "\n");
  178.     print("self z=" + self.z + "\n");
  179.     print("enemy z proj des=" + abs(self.x-projectx()) + "\n");
  180.     print("enemy z proj des=" + abs(self.z-projectz()) + "\n");
  181.     print("enemy x distance=" + abs(self.x-target.x) + "\n");
  182.     print("enemy z distance=" + abs(self.z-target.z) + "\n");
  183.     print("enemy z proj des=" + abs(self.x-projectx()) + "\n");
  184.     print("enemy z proj des=" + abs(self.z-projectz()) + "\n");
  185.     print("enemy zx ratio=" + zxratio() + "\n");
  186.     print("enemy can hit=" + canhit(1) + "\n");
  187.     print("enemy state=" + target.state + "\n");
  188.     print("self.framee=" + self.frame + "\n");
  189.    
  190.     if (loadClosestP())
  191.         if (distance_attack_danger())
  192.             print("distance_attack_danger\n");
  193.            
  194.     loadClosestE();
  195.     if (distance_attack_alert())
  196.         print("distance_attack_alert\n");
  197.     if (diagonal_attack_danger())
  198.         print("diagonal_attack_danger\n");
  199.     if (zero_range_danger())
  200.         print("zero_range_danger\n");
  201.  
  202.     bool hblock = false;
  203.  
  204.     // Detects if heavy object is on the way
  205.     if (loadClosestH()) {
  206.         bool hface = face();
  207.         int hdis = abs(self.x-target.x);
  208.         loadClosestE();
  209.         if (face() == hface && abs(self.x-target.x)>hdis) {
  210.             hblock = true;
  211.         }
  212.     }
  213.    
  214.     //combos
  215.     //DfA+A
  216.    
  217.      else if (distance_attack_alert() && rand(15)>12) {
  218.         if(bg_zwidth2-self.z > self.z-bg_zwidth1 && rand(5)>2) {
  219.             up();
  220.             return 0;
  221.         }
  222.         else {
  223.             down();
  224.             return 0;
  225.         }
  226.      }
  227.      
  228.      
  229.      else if(frame(243,244)
  230.      && rand(10)>2
  231.      && !hblock
  232.      && !zero_range_danger() ) {
  233.         A();
  234.         return 0;
  235.      }
  236.     //DfA+A+A
  237.      else if(frame(250,250)
  238.      && rand(10)>2
  239.      && !hblock ) {
  240.         A();
  241.         return 0;
  242.      }
  243.  
  244.      // D^J
  245.      else if (xdst(0,120)
  246.      && abs(zxratio())>40
  247.      && abs(zxratio())<80
  248.      && !zero_range_danger()
  249.      && !distance_attack_danger()
  250.      && rand(10)>3
  251.      && self.mp>=200) {
  252.         DuJ();
  253.      }
  254.      // D^J
  255.      else if (xdst(0,120)
  256.      && abs(zxratio())<100
  257.      && target.state == 16
  258.      && !distance_attack_danger()
  259.      && self.mp>=200) {
  260.         DuJ();
  261.      }
  262.      
  263.      // start DvA
  264.      else if(xdst(40,110)
  265.      &&self.mp>=25
  266.      && (rand(10)>3 || target.state==16 || target.state==11 || target.state==12)
  267.      && (abs(zxratio())<15)) {
  268.         DdA();
  269.      }
  270.      
  271.      else if(xdst(40,110)
  272.      // start DvA
  273.      &&self.mp>=25
  274.      && (rand(10)>3 || target.state==16 || target.state==11 || target.state==12)
  275.      && (abs(zxratio())<15)) {
  276.         DdA();
  277.      }
  278.  
  279.      // start D>J
  280.      else if(loosehit()
  281.      &&xdst(60,180)
  282.      &&self.mp>=200
  283.      && (abs(zxratio())<15)
  284.      && !distance_attack_danger()) {
  285.         DfJ();
  286.      }
  287.      
  288.     //start D>A (triangular fork area)
  289.      else if(loosehit() && !zero_range_danger()
  290.      &&xdst(120,500)
  291.      &&self.mp>=150
  292.      && (abs(zxratio())<1 || (abs(zxratio())<10 &&abs(zxratio())<13))
  293.      && !hblock
  294.      && !zero_range_danger()) {
  295.         DfA();
  296.      }
  297.      else if(loosehit()
  298.      &&xdst(80,120)
  299.      &&self.mp>=150
  300.      && (abs(zxratio())<5)
  301.      && !hblock) {
  302.         DfA();
  303.      }
  304.     else{inputs();}
  305.     return 0;
  306. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement