///Bounce against walls

move_bounce_all(true);
move_outside_all(direction, 100);

///Bounce against walls

move_bounce_all(true);
move_outside_all(direction, 100);

  // Create surface, draw everything to it, deactivate all other objects
 
surf = surface_create(room_width, room_height); 
    // creates a surface which is the same height and width as the room.
    // A surface is basically a clear drawing surface on the screen.
  
surface_set_target(surf);   
    // Sets aside room in memory for surface and begins drawing on it

draw_clear_alpha (c_red, .5); 
    // Clears surface of buffer noise and sets color and alpha 
    // (0= fully transparent, 1 = fully opaque, .5=50% transparent)

surface_reset_target();
    // Tells GM to stop drawing on the surface and 
    // allows drawing directly on the screen again (and thus the draw GUI below)
 
instance_deactivate_object (obj_ball);
    // Deactivates the ball without destroying it.

visible = true; 		
    //This object is visible.  
    //Adding the command is not strictly necessary since we already set the object to visible.

draw_set_font(fnt_pause);
	// GML commands, also called functions,  are set up in categories.
	// Draw_ gives you access to draw functions.
	// Instance_ functions give you access to things dealing with instances of objects.
	// Draw_set_ commands establish parameters for your draw actions.
	// This one changes your draw font to your pause font (set it up, if you haven’t).

draw_set_color(c_black);
	// This one sets the color.
	// typing c_ will give you a list of different color options.

draw_set_halign(fa_center);
	// Sets the horizontal alignment of the font to center.

draw_surface(surf, 0, 0);
	// This function draws the surface over the room.  
	// The surface that it draws is called surf (which is what we called it in the create event).
	// It draws it starting at 0x and 0y in the room.

draw_text(room_width/2, room_height/2, "Game Paused:  Press Space to Continue");
	// This draws text.  It looks for (x,y,string) which means the programmer 
	// decides where the it goes.  room_width / 2 is right in the center of the room.
	// A string is a series of text in “”. The text is in black and centered because of the above 
	// draw_set_ functions.

draw_set_halign(fa_left);
	// Since the text of the scoreboard is aligned to the left, we need to reset the alignment.

/// Unpause, clear surface, re-activate all objects.

surface_free(surf); 
	// Free up the memory from the surface.
	// Essentially this deletes the surface.
	// By the way, we are starting code now because there are no commands in 
	// drag and drop programming that deal with surfaces.

instance_activate_all(); 
	// Activate all the objects again
	// We could have also used instance_activate_object (obj_ball); 
	// since that is the only thing we deactivated in the create event.

instance_destroy(self);  
	// Destroy the pause object.
	
	// As you look at this code, remember that instance_ functions are used
	// to control instances of objects in the room.  As we get further along, we 
	// will use more code blocks,  so it is important to be aware of the general 
	// language rules because you won’t always know what the exact command 
	// will be for an operation. 
	
	// In the code block autocomplete will help you find the right one.  If you know
	// you are dealing with an instance, you can start typing “instance_” and will be
	// given a list of possible things which could finish that command.  

// Make sure that only the active player is able to fire the gun.
// Also, no players should be able to fire if we are between turns 
// (transitioning from player to player)

if (obj_controller.WhoseTurn == myName) and (obj_controller.Transitioning == false){
    
    // Check to see if the the spacebar is released.
    if (keyboard_check_released(vk_space)){
   	 

   	 // The xdistance and ydistance is the difference between the origin 
 // position of the cannon and the end of the barrel at any given rotation.  

 // This value is basic trigonometry for a right triangle if you know the   
 // hypotenuse (the barrel sprite width -- in this case 64) and the angle.
   	 ydistance = 64 * (sin(degtorad(Barrel_Rotation)));
   	 xdistance = 64 * (cos(degtorad(Barrel_Rotation)));
   
   
         // instance_create_depth will create an object at a specific depth.  (100 is generally the
   	 // background.  We are creating obj_bullet at the x and y of the firing turret and shifting the
   	 // bullet based on the angle of the barrel.  
   	 
   	 // Because we are using "with" the things within the { } will apply to the thing being created.
   	 // In this case, we are giving the bullet the barrel rotation value of the turret which is
   	 // shooting it off.  We have to use other. because we are actually doing this from within the
   	 // bullet object, not the turret.

   	 with instance_create_depth(x+xdistance,y-ydistance,50,obj_bullet)
   		 {
   			 direction = other.Barrel_Rotation;
   		 }
   		 
   	 // We are adding an alarm in obj_controller and setting letting the game know we are between turns
   	 // so that players can't fire off multiple bullets and can't accidently fire off their opponent's
   	 // shot.  

   	 // We use room_speed for the alarm because we can multiply our Frames per second by a time in 
   	 // seconds for a more intuitive control.  At 30 FPS, we could have also put in a value of 30.
   	 obj_controller.alarm[1]= room_speed * 1 //seconds;
   	 obj_controller.Transitioning = true;
    }
}

// We will finish off our step event by turning the gravity back on if the turret
// is not moving and there is nothing under it (a box just got destroyed for
// instance) OR if there is fire directly under the turret.  We want the turret
// to fall into the fire.

if ((speed == 0 and place_empty(x,y+1)) or place_meeting(x,y+1,obj_fire))
{
    gravity = 1;
}

///Bounce against walls

move_bounce_all(true);
move_outside_all(direction, 100);

// Pac Man Ghost Movement Code
if (place_snapped(64,64)){
	var changed = false;
	var randomDir = irandom_range(1,4);
	
	if (hspeed == 0){
		if (randomDir == 1){
			if (!place_meeting(x - ghostSpeed, y, obj_wall)){
				speed = ghostSpeed
				direction = 180;
				changed = true;
			}
		} else if (randomDir == 2){
			if (!place_meeting(x + ghostSpeed, y, obj_wall)){
				speed = ghostSpeed
				direction = 0;
				changed = true;
			}
		}
	}
	if (vspeed == 0 and changed == false){
		if (randomDir == 1){
			if (!place_meeting(x, y - ghostSpeed, obj_wall)){
				speed = ghostSpeed
				direction = 90; 
			}
		} else if (randomDir == 2){
			if (!place_meeting(x, y + ghostSpeed, obj_wall)){
				speed = ghostSpeed
				direction = 270;
			}
		}
	}
}

// Run This Function in END STEP event
/*
 INSTRUCTIONS: 
 This function requires passing in arguments playerSpeed (not hspeed or speed) 
 and a gravity value.
 
 You should also make an optional argument maxFall with a value of 15
 
 In addition, you need to have two variables in the create event
 of your object:
 
     jumpSpeed = 0
     canJump = true
	 
optional:  Jumping variable (needed in create if you are going to have
		   a jumping animation (controlled in step).

*/



/*********************/
/*Horizontal Movement*/
/*********************/

var move = -keyboard_check(vk_left) + keyboard_check(vk_right);
var collision = instance_place(x+playerSpeed, y+vspeed, all);

// You are moving right
if (move == 1){
	
	if (collision < 0 or !object_get_solid(collision.object_index)){
		x += playerSpeed;
	}
	
	// Move to wall, if there is a SOLID wall to your right
	else{  
		move_contact_solid(0, playerSpeed);
	}
}

// You are moving left
else if (move == -1){
	collision = instance_place(x-playerSpeed, y+vspeed, all)
	if ( collision < 0 or !object_get_solid(collision.object_index)){
		x -= playerSpeed;
	}
	
	// Move to wall, if there is a solid wall to your left
	else{
		move_contact_solid(180, playerSpeed);		
	}
}



/*******************/
/*Vertical Movement*/
/*******************/

jumping = false;
collision = instance_place(x, y - jumpSpeed, all);
// Check to see if you are in the air or are about to jump.
if (place_empty(x, y + 1) or jumpSpeed > 0 or (collision > 0 and !object_get_solid(collision.object_index))){
	jumping = true;
}

// if you are jumping...
if (jumping){
	
	
	// Move up or down if there is no collision this frame.
	if (collision < 0 or !object_get_solid(collision.object_index)){
		y -= jumpSpeed;
	}
	
	// Check for a SOLID object below you
	else if (jumpSpeed < 0  and  object_get_solid(collision.object_index)){
		move_contact_solid(270, jumpSpeed)
		jumpSpeed = 0
	}
	
	// Check for a SOLID object above you
	else if (jumpSpeed > 0  and  object_get_solid(collision.object_index)){
		move_contact_solid(90, jumpSpeed)
		jumpSpeed = -0.1
	}
	jumpSpeed -= grav;
	if (jumpSpeed < -maxFall){
		jumpSpeed = -maxFall;
	}
}

// If you are on SOLID ground, allow the player to jump again.
if (!place_empty(x, y+1) and instance_place(x, y + 1, all) > 0 and object_get_solid( instance_place(x, y + 1, all).object_index)){
	canJump = true;
}

var dir = -keyboard_check(vk_left) + keyboard_check(vk_right)

//put your sprite names here:
var jump_right = sMario_jumpR
var walk_right = sMario_right
var jump_left = sMario_jumpL
var walk_left = sMario_left

image_speed = 3
if (dir == 1){
	if (jumping){
		sprite_index = jump_right;
	}
	else {
		sprite_index = walk_right;
	}
}
else if (dir == -1){
	if (jumping){
		sprite_index = jump_left;
	}
	else {
		sprite_index = walk_left;
	}
}
else {
	if (!jumping and sprite_index = jump_right){
		sprite_index = walk_right;
	} else if (!jumping and sprite_index = jump_left){
		sprite_index = walk_left;
	} else if (jumping and sprite_index = walk_right) {
		sprite_index = jump_right;
	} else if (jumping and sprite_index = walk_left) {
		sprite_index = jump_left;
	}
	image_speed = 0;
	image_index = 0;
}
	

var collision = instance_place(x+hspeed, y+vspeed, all);
var collisionBelowRight = instance_place(x+hspeed+sprite_width, y+1, all)
var collisionBelowLeft = instance_place(x+hspeed-sprite_width, y+1, all)

if (hspeed > 0){
	if (place_empty(x+hspeed+sprite_width, y+1) or
	   (collision >-0 and object_get_solid(collision.object_index)) or
	   (!place_empty(x+hspeed+sprite_width, y+1) and collisionBelowRight > 0 and object_get_solid(collisionBelowRight.object_index) == false )){
		hspeed = -hspeed;
	}
}
else if (hspeed < 0){
	if (place_empty(x+hspeed-sprite_width, y+1) or 
	   (collision >-0 and object_get_solid(collision.object_index)) or
	   (!place_empty(x+hspeed-sprite_width, y+1) and collisionBelowLeft > 0 and object_get_solid(collisionBelowLeft.object_index) == false )){
		hspeed = -hspeed;
	}
}

if (y < other.y and jumpSpeed <= 0){
	instance_destroy(other)
} 
else {
	instance_destroy(self)	
}