module Brick_Escape
	(
		CLOCK_50,						//	On Board 50 MHz
		// Your inputs and outputs here
        KEY,
        SW,
		// The ports below are for the VGA output.  Do not change.
		VGA_CLK,   						//	VGA Clock
		VGA_HS,							//	VGA H_SYNC
		VGA_VS,							//	VGA V_SYNC
		VGA_BLANK_N,						//	VGA BLANK
		VGA_SYNC_N,						//	VGA SYNC
		VGA_R,   						//	VGA Red[9:0]
		VGA_G,	 						//	VGA Green[9:0]
		VGA_B   						//	VGA Blue[9:0]
	);

	input			CLOCK_50;				//	50 MHz
	input   [9:0]   SW;
	input   [3:0]   KEY;

	// Declare your inputs and outputs here
	// Do not change the following outputs
	output			VGA_CLK;   				//	VGA Clock
	output			VGA_HS;					//	VGA H_SYNC
	output			VGA_VS;					//	VGA V_SYNC
	output			VGA_BLANK_N;				//	VGA BLANK
	output			VGA_SYNC_N;				//	VGA SYNC
	output	[9:0]	VGA_R;   				//	VGA Red[9:0]
	output	[9:0]	VGA_G;	 				//	VGA Green[9:0]
	output	[9:0]	VGA_B;   				//	VGA Blue[9:0]

	wire resetn;
	assign resetn = ~SW[0];

	// Create the colour, x, y and writeEn wires that are inputs to the controller.
	wire [2:0] colour;
	wire [6:0] x;
	wire [6:0] y;

	// writeEn will always be high
	wire writeEn = 1'b1;

	// Create an Instance of a VGA controller - there can be only one!
	// Define the number of colours as well as the initial background
	// image file (.MIF) for the controller.
	vga_adapter VGA(
			.resetn(resetn),
			.clock(CLOCK_50),
			.colour(colour),
			.x(x),
			.y(y),
			.plot(writeEn),
			/* Signals for the DAC to drive the monitor. */
			.VGA_R(VGA_R),
			.VGA_G(VGA_G),
			.VGA_B(VGA_B),
			.VGA_HS(VGA_HS),
			.VGA_VS(VGA_VS),
			.VGA_BLANK(VGA_BLANK_N),
			.VGA_SYNC(VGA_SYNC_N),
			.VGA_CLK(VGA_CLK));
		defparam VGA.RESOLUTION = "160x120";
		defparam VGA.MONOCHROME = "FALSE";
		defparam VGA.BITS_PER_COLOUR_CHANNEL = 1;
		defparam VGA.BACKGROUND_IMAGE = "black.mif";

	 // RATE DIVIDER TO SLOW DOWN THE UPDATE PROCESS FOR PLAYER AND ENEMIES
	 wire update;		// Will be used to update position of player and enemies
	 rateDivider ratedivider(CLOCK_50, update);


	 // PLAYER PROPERTIES /////////////////////////////////////////////////////////////////
	 wire [6:0] playerx;		// x position of the player
	 wire [6:0] playery;		// y position of the player
	 wire collided;

	 Player player(CLOCK_50, update, resetn, playerx, playery, KEY, collided);


	 // ENEMIES PROPERTIES ////////////////////////////////////////////////////////////////
	 wire [6:0] enemyx;
	 wire [6:0] enemyy;
	 wire [6:0] collisionx;
	 wire [6:0] collisiony;
	 wire [3:0] enemyIterator;
	 wire [3:0] collisionIterator;

	 EnemyController enemies(CLOCK_50, update, resetn, enemyx, enemyy, collisionx, collisiony, enemyIterator, collisionIterator);

	 // COLLISION /////////////////////////////////////////////////////////////////////
	 Collision collision(CLOCK_50, playerx, playery, collisionx, collisiony, collided, collisionIterator);

	 // CONTROL AND DATAPATH PROPERTIES ///////////////////////////////////
	 wire go_next, print_path, update_player, update_enemy, wait_screen;	// ENABLE SIGNALS

	 Controller controller(CLOCK_50, resetn, go_next, print_path, update_player, update_enemy, wait_screen);

	 Datapath datapath(CLOCK_50, resetn, go_next, print_path, update_player, update_enemy, wait_screen, playerx, playery, enemyx, enemyy, enemyIterator, x, y, colour);

endmodule

module Collision(clk, playerx, playery, enemyx, enemyy, collided, collisionIterator);
	input clk;
	input [6:0] playerx;
	input [6:0] playery;
	input [6:0] enemyx;
	input [6:0] enemyy;
	output reg collided;
	output reg [3:0] collisionIterator;

	always @(posedge clk)
	begin
//		if((playerx == enemyx) && (playery == enemyy) ||
//			!((7'd20 < playerx && playerx < 7'd30) && (7'd0 < playery && playery < 7'd50)) ||
//			!((7'd20 < playerx && playerx < 7'd50) && (7'd50 < playery && playery < 7'd60)) ||
//			!((7'd50 < playerx && playerx < 7'd60) && (7'd10 < playery && playery < 7'd60)) ||
//			!((7'd60 < playerx && playerx < 7'd65) && (7'd10 < playery && playery < 7'd20)) ||
//			!((7'd65 < playerx && playerx < 7'd75) && (7'd10 < playery && playery < 7'd100)) ||
//			!((7'd75 < playerx && playerx < 7'd95) && (7'd90 < playery && playery < 7'd100)) ||
//			!((7'd95 < playerx && playerx < 7'd105) && (7'd35 < playery && playery < 7'd100)) ||
//			!((7'd105 < playerx && playerx < 7'd127) && (7'd35 < playery && playery < 7'd45)))
		collisionIterator = collisionIterator + 1'd1;
		if(collisionIterator > 4'd10)
		begin
			collisionIterator = 1'd0;
		end
		else
		begin
			if((playerx == enemyx) && (playery == enemyy))
			begin
				collided = 1'd1;
			end
			else
			begin
				collided = 1'd0;
			end
		end
	end
endmodule

module Datapath(clk, resetn, go_next, print_path, update_player, update_enemy, wait_screen, playerx, playery, enemyx, enemyy, enemyIterator, x, y, colour);
	input clk;
	input resetn;
	input print_path;
	input update_player;
	input update_enemy;
	input wait_screen;
	input [6:0] playerx;
	input [6:0] playery;
	input [6:0] enemyx;
	input [6:0] enemyy;
	parameter NUMOFENEMIES = 10;
	reg [30:0] wait_screen_counter;
	reg [6:0] screen_x;
	reg [6:0] clear_screen_y;
	output reg [3:0] enemyIterator;
	output reg go_next;
	output reg [6:0] x;
	output reg [6:0] y;
	output reg [2:0] colour;

	// REGs for path datapath
	reg path1;
	reg path2;
	reg path3;
	reg path4;
	reg path5;
	reg path6;
	reg path7;
	reg path8;
	reg get_new_path;
	reg [6:0] pathx_beg;
	reg [6:0] pathy_beg;
	reg [6:0] pathx_end;
	reg [6:0] pathy_end;

	initial begin
		get_new_path = 1'd1;
	end

	always@(posedge clk)
		begin
			if(~resetn)		// Basic reset functionality
				begin
					go_next = 1'd0;
					x = 1'd0;
					y = 1'd0;
					colour = 3'b000;
				end
			else
				begin
					if(print_path)
					begin
						go_next = 1'd0;
						colour = 3'b111;
						if(!path1 && get_new_path == 1'd1)
						begin
							pathx_beg = 7'd20;
							pathy_beg = 7'd0;
							x = pathx_beg;
							y = pathy_beg;
							pathx_end = 7'd30;
							pathy_end = 7'd50;
							get_new_path = 1'd0;
						end
						if(!path2 && get_new_path == 1'd1)
						begin
							pathx_beg = 7'd20;
							pathy_beg = 7'd50;
							x = pathx_beg;
							y = pathy_beg;
							pathx_end = 7'd50;
							pathy_end = 7'd60;
							get_new_path = 1'd0;
						end
						if(!path3 && get_new_path == 1'd1)
						begin
							pathx_beg = 7'd50;
							pathy_beg = 7'd10;
							x = pathx_beg;
							y = pathy_beg;
							pathx_end = 7'd60;
							pathy_end = 7'd60;
							get_new_path = 1'd0;
						end
						if(!path4 && get_new_path == 1'd1)
						begin
							pathx_beg = 7'd60;
							pathy_beg = 7'd10;
							x = pathx_beg;
							y = pathy_beg;
							pathx_end = 7'd65;
							pathy_end = 7'd20;
							get_new_path = 1'd0;
						end
						if(!path5 && get_new_path == 1'd1)
						begin
							pathx_beg = 7'd65;
							pathy_beg = 7'd10;
							x = pathx_beg;
							y = pathy_beg;
							pathx_end = 7'd75;
							pathy_end = 7'd100;
							get_new_path = 1'd0;
						end
						if(!path6 && get_new_path == 1'd1)
						begin
							pathx_beg = 7'd75;
							pathy_beg = 7'd90;
							x = pathx_beg;
							y = pathy_beg;
							pathx_end = 7'd95;
							pathy_end = 7'd100;
							get_new_path = 1'd0;
						end
						if(!path7 && get_new_path == 1'd1)
						begin
							pathx_beg = 7'd95;
							pathy_beg = 7'd35;
							x = pathx_beg;
							y = pathy_beg;
							pathx_end = 7'd105;
							pathy_end = 7'd100;
							get_new_path = 1'd0;
						end
						if(!path8 && get_new_path == 1'd1)
						begin
							pathx_beg = 7'd105;
							pathy_beg = 7'd35;
							x = pathx_beg;
							y = pathy_beg;
							pathx_end = 7'd126;
							pathy_end = 7'd45;
							get_new_path = 1'd0;
						end
						if(x > pathx_end)
						begin
							x = pathx_beg;
							y = y + 1'd1;
						end
						else if(x == pathx_end && y == pathy_end)
						begin
							get_new_path = 1'd1;
							if(!path1)
								path1 <= 1'd1;
							else if(!path2)
								path2 <= 1'd1;
							else if(!path3)
								path3 <= 1'd1;
							else if(!path4)
								path4 <= 1'd1;
							else if(!path5)
								path5 <= 1'd1;
							else if(!path6)
								path6 <= 1'd1;
							else if(!path7)
								path7 <= 1'd1;
							else if(!path8)
							begin
								go_next = 1'd1;
								path1 = 1'd0;
								path2 = 1'd0;
								path3 = 1'd0;
								path4 = 1'd0;
								path5 = 1'd0;
								path6 = 1'd0;
								path7 = 1'd0;
							end
						end
						x = x + 1'd1;
					end
					/* This will re-display the updated x and y position of the player
					*/
					if(update_player)
					begin
						go_next = 1'd0;
						x = playerx;
						y = playery;
						colour = 3'b100;
						go_next = 1'd1;
					end
					/* This will re-display the updated x and y position of each enemy
					*/
					if(update_enemy)
					begin
						go_next = 1'd0;
						x = enemyx;
						y = enemyy;
						colour = 3'b100;
						enemyIterator = enemyIterator + 1'd1;
						if(enemyIterator >= NUMOFENEMIES)
						begin
							go_next = 1'd1;
							enemyIterator = 1'd0;
						end
					end
					/* Acts as the end of the refresh
					*/
					if(wait_screen)
					begin
						go_next = 1'd1;
					end
				end
		end
endmodule

module Controller(clk, resetn, go_next, print_path, update_player, update_enemy, wait_screen);
	input clk;
	input resetn;
	input go_next;
	output reg print_path;
	output reg update_player;
	output reg update_enemy;
	output reg wait_screen;

	reg [1:0] current_state, next_state;

	// Represents the different states of the finite state machine
	localparam	S_PRINT_PATH		= 2'd0,
					S_UPDATE_PLAYER	= 2'd1,
					S_UPDATE_ENEMY		= 2'd2,
					S_WAIT_SCREEN		= 2'd3;

	always @(*)
		begin: state_table
			case (current_state)
				S_PRINT_PATH:	 	next_state = go_next ? S_UPDATE_PLAYER :	S_PRINT_PATH;
				S_UPDATE_PLAYER: 	next_state = go_next ? S_UPDATE_ENEMY	:	S_UPDATE_PLAYER;
				S_UPDATE_ENEMY:	next_state = go_next ? S_WAIT_SCREEN	:	S_UPDATE_ENEMY;
				S_WAIT_SCREEN:		next_state = go_next ? S_PRINT_PATH		:	S_WAIT_SCREEN;
				default: next_state = S_UPDATE_PLAYER;
			endcase
		end

	always @(*)
		begin: enable_signals
			print_path = 1'd0;
			update_player = 1'd0;
			update_enemy = 1'd0;
			wait_screen = 1'd0;
			case (current_state)
				S_PRINT_PATH:
					begin
						print_path = 1'd1;
					end
				S_UPDATE_PLAYER:
					begin
						update_player = 1'd1;
					end
				S_UPDATE_ENEMY:
					begin
						update_enemy = 1'd1;
					end
				S_WAIT_SCREEN:
					begin
						wait_screen = 1'd1;
					end
			endcase
		end

	always @(posedge clk)
		begin: curr_state_FSM
			if(~resetn)
				current_state <= S_PRINT_PATH;
			else
				current_state <= next_state;
		end

endmodule

module EnemyController(clk, update, resetn, enemyx, enemyy, collisionx, collisiony, enemyIterator, collisionIterator);
	 input update;
	 input resetn;
	 input clk;
	 input [3:0] enemyIterator;
	 input [3:0] collisionIterator;
	 parameter NUMOFENEMIES = 10;
	 output reg [6:0] enemyx;			// x position of the current enemy
	 output reg [6:0] enemyy;			// y position of the current enemy
	 output reg [6:0] collisionx;
	 output reg [6:0] collisiony;
	 wire [6:0] enemyx_array [0:NUMOFENEMIES-1];	// x position of all enemies
	 wire [6:0] enemyy_array [0:NUMOFENEMIES-1];	// y position of all enemies

	 Enemy enemy1(update, resetn, enemyx_array[0], enemyy_array[0], 1'b0, 7'd50, 7'd50);
	 Enemy enemy2(update, resetn, enemyx_array[1], enemyy_array[1], 1'b1, 7'd90, 7'd90);
	 Enemy enemy3(update, resetn, enemyx_array[2], enemyy_array[2], 1'b1, 7'd100, 7'd100);
	 Enemy enemy4(update, resetn, enemyx_array[3], enemyy_array[3], 1'b0, 7'd40, 7'd40);
	 Enemy enemy5(update, resetn, enemyx_array[4], enemyy_array[4], 1'b1, 7'd70, 7'd12);
	 Enemy enemy6(update, resetn, enemyx_array[5], enemyy_array[5], 1'b0, 7'd23, 7'd90);
	 Enemy enemy7(update, resetn, enemyx_array[6], enemyy_array[6], 1'b0, 7'd45, 7'd89);
	 Enemy enemy8(update, resetn, enemyx_array[7], enemyy_array[7], 1'b1, 7'd45, 7'd50);
	 Enemy enemy9(update, resetn, enemyx_array[8], enemyy_array[8], 1'b1, 7'd8, 7'd12);
	 Enemy enemy10(update, resetn, enemyx_array[9], enemyy_array[9], 1'b1, 7'd5, 7'd100);

	 always @(posedge clk)
	 begin
		enemyx = enemyx_array[enemyIterator];
		enemyy = enemyy_array[enemyIterator];
		collisionx = enemyx_array[collisionIterator];
		collisiony = enemyy_array[collisionIterator];
	 end

endmodule

module Enemy(update, resetn, enemyx, enemyy, left_and_right, enemyx_init, enemyy_init);

	input update;
	input resetn;
	input left_and_right; // if 0 the enemy will move up and down, if 1 the enemy will move left and right
	input [6:0] enemyx_init;
	input [6:0] enemyy_init;
	reg [3:0] movement_position;
	reg left_right;	// if 0 move left, if 1 move right
	reg up_down;		// if 0 move up, if 1 move down
	output reg [6:0] enemyx;
	output reg [6:0] enemyy;
	reg initialize;

	initial
	begin
		initialize = 1'd1;
	end

	always @(posedge update)
	begin
		if(initialize)
		begin
			enemyx = enemyx_init;
			enemyy = enemyy_init;
			initialize = 1'd0;
		end
		else if(~resetn)
		begin
			enemyx = 1'd0;
			enemyy = 1'd0;
		end
		else
		begin
			if(left_and_right)	// Enemy will move left and right
			begin
				if(movement_position == 4'd10)	// Change direction every time it moves 10 pixels left or right
				begin
					left_right = ~left_right;
					movement_position = 1'd0;
				end
				if(left_right == 1'b0)
				begin
					enemyx = enemyx - 1'd1;			// Move enemy to the left by one pixel
				end
				else
				begin
					enemyx = enemyx + 1'd1;			// Move enemy to the right by one pixel
				end
			end
			else		// Enemy will move up and down
			begin
				if(movement_position == 4'd10)	// Change direction everytime it moves 10 pixels up or down
				begin
					up_down = ~up_down;
					movement_position = 1'd0;
				end
				if(up_down == 1'b0)
				begin
					enemyy = enemyy + 1'd1;			// Move enemy down by one pixel
				end
				else
				begin
					enemyy = enemyy - 1'd1;			// Move enemy up by one pixel
				end
			end
			movement_position <= movement_position + 1'b1;	// Iterate how much pixels the enemy has moved by 1
		end
	end
endmodule

module Player(clk, update, resetn, playerx, playery, KEY, collided);
	input update;
	input resetn;
	input collided;
	input clk;
	output reg [6:0] playerx;
	output reg [6:0] playery;
	input [3:0] KEY;

	// Initialize the starting position of the player
	initial
	begin
		playerx = 7'd25;
		playery = 7'd25;
	end

	/* This will constantly check for player input and move the player
		accordingly.
	*/
	always @(posedge clk)
	begin
		if(collided)
		begin
			playerx = 7'd25;
			playery = 7'd25;
		end
		else if(~resetn)
		begin
			playerx = 1'b0;
			playery = 1'b0;
		end
		else
		begin
			if(update)
			begin
				if(~KEY[3]) // MOVE PLAYER LEFT
				begin
					playerx = playerx - 1'b1;
				end
				else if(~KEY[2]) // MOVE PLAYER UP
				begin
					playery = playery - 1'b1;
				end
				else if(~KEY[1]) // MOVE PLAYER DOWN
				begin
					playery = playery + 1'b1;
				end
				else if(~KEY[0]) // MOVE PLAYER RIGHT
				begin
					playerx = playerx + 1'b1;
				end
			end
		end
	end
endmodule

module rateDivider(clk, update);
	input clk;
	output reg update;
	reg [25:0] counter;

	always @(posedge clk)
	begin
		counter = counter + 1'd1;
		if(counter > 26'd3124999)
		begin
			counter = 1'd0;
		end
		update = (counter == 1'd0) ? 1 : 0;
	end

endmodule