package {
	import flash.display.Sprite;
	import flash.display.Bitmap;
	import flash.display.BitmapData;
	import flash.display.BlendMode;
	import flash.geom.Point;
	import flash.geom.Rectangle;
	import flash.geom.Matrix;
	import flash.events.Event;
	import flash.events.MouseEvent;
	import flash.events.KeyboardEvent;
 
	public class worms extends Sprite {
 
		public var terrain_bmpd:BitmapData=new BitmapData(550,200,true,0xFF00FF00);
		public var terrain_bmp:Bitmap=new Bitmap(terrain_bmpd);
		public var character:Sprite=new Sprite();
		public var x_speed:Number=0;
		public var y_speed:Number=0;
		public var hole:Sprite=new Sprite();
		public var hole_matrix:Matrix;
		public var left_key:Boolean;
		public var right_key:Boolean;
		public var space_key:Boolean;
		public var i:int;
		public var x_diff:Number;//x_diff and y_diff will be the difference between the character and the explosion centre
		public var y_diff:Number;
		public var explosion_radius:Number=100;//That's the radius of the explosion. If the character is inside the radius, it will move away.
		public var explosion_intensity:Number=10;//The explosion intensity is the speed (pixels/frame) that the character will
		//get if the distance between the explosion and the character is 0 (the closest one).
		public var distance:Number;//We will use that variable to store the distance between the character and the explosion
		public var angle:Number;//and that one to store the angle
		public var applied_speed:Number;//That will be the total speed we need to apply (the vector length).
		public var applied_x:Number;//Then, we will separate the applied_speed in applied_x
		public var applied_y:Number;//and applied_y
		public var ground_friction:Number=0.2;//The ground has more friction than the air,
		public var air_friction:Number=0.05;//so I have used different variables
		public function worms() {
			draw_objects();
 
			stage.addEventListener(Event.ENTER_FRAME,move_character);
			stage.addEventListener(MouseEvent.MOUSE_UP,mouse_up);
			stage.addEventListener(KeyboardEvent.KEY_DOWN,key_down);
			stage.addEventListener(KeyboardEvent.KEY_UP,key_up);
		}
 
		public function move_character(e:Event) {
			if (left_key&&x_speed==0) {//If the player is moving, we won't be able to control it
				for (i=0; i<3; i++) {
					if (! terrain_bmpd.hitTest(new Point(terrain_bmp.x,terrain_bmp.y),0x01,new Rectangle(character.x-6,character.y-10,1,17))) {
						character.x--;
						while (terrain_bmpd.hitTest(new Point(terrain_bmp.x,terrain_bmp.y),0x01,new Rectangle(character.x-5,character.y+9,10,1))) {
							character.y--;
						}
					}
				}
			}
			if (right_key&&x_speed==0) {//Let's do the same with the right key...
				for (i=0; i<3; i++) {
					if (! terrain_bmpd.hitTest(new Point(terrain_bmp.x,terrain_bmp.y),0x01,new Rectangle(character.x+5,character.y-10,1,17))) {
						character.x++;
						while (terrain_bmpd.hitTest(new Point(terrain_bmp.x,terrain_bmp.y),0x01,new Rectangle(character.x-5,character.y+9,10,1))) {
							character.y--;
						}
					}
				}
			}
			if (x_speed<0) {//This block is similar; however, we don't know the speed,
				for (i=0; i<Math.abs(x_speed); i++) {//so the for loop will use x_speed (there's a bug, read KNOWN BUGS)
					if (! terrain_bmpd.hitTest(new Point(terrain_bmp.x,terrain_bmp.y),0x01,new Rectangle(character.x-6,character.y-10,1,17))) {
						character.x--;
						while (terrain_bmpd.hitTest(new Point(terrain_bmp.x,terrain_bmp.y),0x01,new Rectangle(character.x-5,character.y+9,10,1))) {
							character.y--;
						}
					} else {//If the player hits a wall, it must stop(!). Otherwise, when the wall is removed,
						//the player will continue moving
						x_speed=0;
					}
				}
			} else {//That's the same, but with left key
				for (i=0; i<x_speed; i++) {
					if (! terrain_bmpd.hitTest(new Point(terrain_bmp.x,terrain_bmp.y),0x01,new Rectangle(character.x+5,character.y-10,1,17))) {
						character.x++;
						while (terrain_bmpd.hitTest(new Point(terrain_bmp.x,terrain_bmp.y),0x01,new Rectangle(character.x-5,character.y+9,10,1))) {
							character.y--;
						}
					} else {
						x_speed=0;
					}
				}
			}
			if (space_key&&terrain_bmpd.hitTest(new Point(terrain_bmp.x,terrain_bmp.y),0x01,new Rectangle(character.x-5,character.y+10,10,1))) {
				y_speed=-10;//Instead of using the jumping variable, I check if the character is on the ground
			}
			if (terrain_bmpd.hitTest(new Point(terrain_bmp.x,terrain_bmp.y),0x01,new Rectangle(character.x-5,character.y+10,10,1))) {
				x_speed*=1-ground_friction;//Again, I check if the character is on the ground (to apply ground or air friction)
			} else {
				x_speed*=1-air_friction;
			}
 
			if (Math.abs(x_speed)<0.1) {
				x_speed=0;
			}/*I don't want the character to move at 0.0000000001 pixels/frame,
			so if the x_speed is less than 0.1 we will stop it*/
			y_speed++;
			if (y_speed>0) {
				for (i=0; i<y_speed; i++) {
					if (! terrain_bmpd.hitTest(new Point(terrain_bmp.x,terrain_bmp.y),0x01,new Rectangle(character.x-5,character.y+10,10,1))) {//I changed character.y+9--> character.y+10
						character.y++;
					} else {
						y_speed=0;
					}
				}
			} else {
				for (i=0; i<Math.abs(y_speed); i++) {
					if (! terrain_bmpd.hitTest(new Point(terrain_bmp.x,terrain_bmp.y),0x01,new Rectangle(character.x-5,character.y-10,10,1))) {
						character.y--;
					} else {
						y_speed=0;
					}
				}
			}
		}
 
		public function mouse_up(e:MouseEvent) {
			hole_matrix=new Matrix();
			hole_matrix.translate(e.stageX-terrain_bmp.x,e.stageY-terrain_bmp.y);
			terrain_bmpd.draw(hole,hole_matrix,null,BlendMode.ERASE);
			//Let's calculate the impulse. You'll have to understand trigonometric functions
			x_diff=character.x-e.stageX;//If we invert that, the character will move to the centre of the explosion instead of moving away
			y_diff=character.y-e.stageY;
			angle=Math.atan2(y_diff,x_diff);//We calculate the angle
			distance=Math.sqrt(x_diff*x_diff+y_diff*y_diff);//Then, we use Pythagorean theorem
			if (distance<explosion_radius) {
				applied_speed = (1 - distance / explosion_radius) * explosion_intensity;
				//Maybe that's difficult to understand:
				//How_far_is_the_character = distance / explosion_radius
				//How_near_is_the_character = 1 - How_far_is_the_character
				//applied_speed = How_near_is_the_character * explosion_intensity
 
				applied_x=Math.cos(angle)*applied_speed;//We separate the applied_speed in x...
				applied_y=Math.sin(angle)*applied_speed;//... and y
				y_speed+=applied_y;
				x_speed+=applied_x;
			}
		}
 
		public function key_down(e:KeyboardEvent) {
			if (e.keyCode==37) {
				left_key=true;
			}
			if (e.keyCode==39) {
				right_key=true;
			}
			if (e.keyCode==32) {
				space_key=true;
			}
		}
		public function key_up(e:KeyboardEvent) {
			if (e.keyCode==37) {
				left_key=false;
			}
			if (e.keyCode==39) {
				right_key=false;
			}
			if (e.keyCode==32) {
				space_key=false;
			}
		}
 
		public function draw_objects() {
			terrain_bmp.y=200;
			stage.addChild(terrain_bmp);
 
			character.graphics.beginFill(0x0000FF);
			character.graphics.drawRect(-5,-10,10,20);
			character.x=250;
			stage.addChild(character);
 
			hole.graphics.beginFill(0x000000);
			hole.graphics.drawCircle(0,0,30);
		}
	}
}