Cheater101

robot.js

var x_target = -1;
var y_target = -1;
var target_valid = false;
var idle_counter = 0;

var time_frame = 0;
var last_reverse = -10000;
var last_turn = -10000;
var at_wall = false;
var clockwise = true;

var first_run = true;

var cannon_clockwise_scan = false;
var last_cannon_clockwise_scan = false;
var scan_count = 0;

var debug = 0;

//FightCode can only understand your robot
//if its class is called Robot
var Robot = function(robot) {
  if(!debug)
  robot.clone();
}; 

Robot.prototype.ndeg=function(deg) {
	return (deg%360+360)%360;
};

Robot.prototype.in_range=function(deg, deg_start, deg_end) {
	//clockwise range
  return this.ndeg(deg - deg_start) <= this.ndeg(deg_end - deg_start);
};

Robot.prototype.onIdle = function(ev) {
    var robot = ev.robot;
  
  	if(first_run && robot.parentId != null)
    {
      robot.turn(90);
    	first_run = false;
    }
  
  	
  	//robot.rotateCannon(-0.0005);
  	//i'll add a clone but i need to refactor collision
  	//robot.clone();
  	var x = robot.position.x;
  	var y = robot.position.y;
  	var pi = Math.PI;
  
    var dx = x_target - x;
    var dy = y_target - y;
    //var degree = Math.atan2(dy,dx)*180/pi;

    var distance = Math.sqrt(dx*dx+dy*dy);

    var angle = Math.atan2(dx,-dy)*180/pi;

    var canon_angle = robot.cannonAbsoluteAngle - 90;

  	if(idle_counter > 60)
    {
      target_valid = false;
      idle_counter = 0;
    }
  
  	if(!at_wall && robot.parentId == null)
    {
      //x_target = robot.arenaWidth / 2;
      //y_target = robot.arenaHeight / 2;


      var width = robot.arenaWidth;
      var height = robot.arenaHeight;
      x_ahead = x <= width / 2;
      y_ahead = y <= height / 2;
      var cos = Math.cos(robot.angle);
      var sin = Math.sin(robot.angle);
      var disX = (x_ahead ? x : (width - x)) / Math.abs(sin);
			var disY = (y_ahead ? y : (height - y)) / Math.abs(cos);
      //clockwise = (disX < disY) ? (x_ahead ^ (sin<0)) :(y_ahead ^ (cos<0));
      clockwise = (disX < disY) ? (!x_ahead) :(!y_ahead);
              
      //console.log(clockwise,(disX < disY),x,y,robot.angle,disX,disY);
      robot.log(clockwise,(disX < disY));
      //robot.turn(-robot.angle+180);         
      clockwise ?  robot.back(500) : robot.ahead(500);
    }   
  	else
    {
    	clockwise ?  robot.back() : robot.ahead();
    }
  
  	if(!target_valid ||debug)
    {
      if(x_target != -1 && scan_count < 2 || debug)
      {
        //search in range
       
        var range_width = 500/2 + 200*scan_count;
        var range_degree = Math.atan(range_width/distance)*180/pi;
        var max_deg = this.ndeg(angle + range_degree);
        var min_deg = this.ndeg(angle - range_degree);
        var th_deg = this.ndeg(angle + 180);
        if(this.in_range(canon_angle, max_deg, th_deg))
        {
            //over max range
            cannon_clockwise_scan = false;
            //robot.log(max_deg,min_deg,th_deg);
        }
        else if(this.in_range(canon_angle, th_deg, min_deg))
        {
            cannon_clockwise_scan = true;
            //robot.log(max_deg,min_deg,th_deg,"max");
        }
        if(last_cannon_clockwise_scan != cannon_clockwise_scan)
          scan_count++;
        last_cannon_clockwise_scan = cannon_clockwise_scan;
      } 
        
    	//x_target = robot.arenaWidth / 2;
      //y_target = robot.arenaHeight / 2;
      /*if(x<20 && robot.cannonAbsoluteAngle >= 135 && robot.cannonAbsoluteAngle <= 135+90)
      {
      	robot.rotateCannon(-90);
      } */
      
      robot.rotateCannon(cannon_clockwise_scan ? 1 : -1);
    }
  	else
    {

      //var ddeg = (degree+180-robot.cannonAbsoluteAngle+180 + 360*10)%360-180;
      var ddeg = this.ndeg(angle-canon_angle+180)-180;
      robot.rotateCannon(ddeg);
      idle_counter++;
    }

    //if(!debug && at_wall && x_target != -1)
    //  robot.fire();
    
  	time_frame++;
  	//if (ddeg > 10 || ddeg < 10)
  	//	console.log(ddeg,idle_counter); 
		  
};

Robot.prototype.onScannedRobot = function(ev) {
   var robot = ev.robot;
   var scanned =ev.scannedRobot;
	 if(scanned.id !== robot.parentId && scanned.parentId !== robot.id) {
    if(!debug)robot.fire();
		//robot.rotateCannon(-10);
  	//robot.rotateCannon(15);
    if(scanned.parentId == null)
    {
      x_target = scanned.position.x;
      y_target = scanned.position.y;
      target_valid = true;
      scan_count = 0;
      idle_counter = 0;
    }
   }else{
     
   }
  	
   time_frame++;
  	
};
Robot.prototype.onHitByBullet = function(ev) {
    var robot = ev.robot;
  
    if (this.in_range(ev.bearing, -15, 15) || this.in_range(ev.bearing+180, -15, 15))
    {
      //var turndeg = (ev.bearing+45+180+360*10)%360-180
      var bearing_angle = this.ndeg(ev.bearing+180)-180;
      //if(Math.abs(bearing_angle)>90)
      bearing_angle %= 90;
      var turn_angle = bearing_angle > 0 ? -90+bearing_angle : 90+bearing_angle;
      robot.turn(turn_angle);
      robot.log('ct', ev.bearing);
    }
    else
      robot.log('nct', this.ndeg(ev.bearing));

  	if(robot.parentId == null && time_frame - last_reverse > 100 && time_frame - last_turn > 150)
    {
      clockwise = !clockwise;
      last_reverse = time_frame;
    }

    if(at_wall)
    {
      clockwise ? robot.back(150) : robot.ahead(150);
    }
    else
    {
      clockwise ? robot.back(150) : robot.ahead(150);
    }
	
};
    
Robot.prototype.onRobotCollision = function(ev) {
    var robot = ev.robot;
  	//robot.rotateCannon(90);
  	//if(ev.myFault)
    if(robot.parentId == null)
    	clockwise = -clockwise;
};

Robot.prototype.onWallCollision = function(ev) {
    var robot = ev.robot;
    //robot.turn(-90+ev.bearing);
    var turn_angle = this.ndeg(-90+ev.bearing+180)-180;
    if(Math.abs(turn_angle) > 90)
      turn_angle %= 90;

    robot.turn(turn_angle);

    robot.log('wall', clockwise, turn_angle);
    if(at_wall)
      last_turn = time_frame;
  	at_wall = true;
  	
};