20 files changed, 545 insertions, 180 deletions

diff --git a/src/demo.c b/src/demo.c
index 22ee8b7..4fa1be2 100644
--- a/src/demo.c
+++ b/src/demo.c
@@ -11,19 +11,14 @@
 #include "engine/draw_screen.h"
 #include "engine/player_controller.h"
 #include "engine/sprite_controller.h"
-#include "GameLoop/startingScreen.h"
+#include "engine/level_const.h"
 
-
-typedef enum {
-	hh_e_STATE_startingScreen,
-	hh_e_STATE_Shop,
-	hh_e_STATE_Gameplay,
-	hh_e_STATE_GameOver,
-	hh_e_STATE_HighScore
-} hh_e_GameState;
-hh_e_GameState hh_gameStates;
+#include "game_loop/starting_screen.h"
+#include "game_loop/gameplay.h"
+#include "game_loop/shop.h"
 
 
+hh_g_all_levels hh_game;
 
 uint16_t g_hh_pos_x = 1000; // 0b0000 0001 0011 0110
 uint16_t g_hh_pos_y;
@@ -43,69 +38,56 @@ typedef struct {
 }hh_s_tiles;
 
 
-hh_entity hh_g_player, hh_g_player_new;
+hh_e_game_state hh_game_states;
+ hh_entity hh_g_player, hh_g_player_new;
 void hh_demo_setup() {
 
 	hh_setup_palettes();
-	// hh_setup_screen();
-
-
+	hh_game = hh_init_game_levels();
 }
 
 void hh_demo_loop(unsigned long frame) {
 
 	
-	switch (hh_gameStates)
+	switch (hh_game_states)
 	{
-	case hh_e_STATE_startingScreen:
-		bool ret = hh_show_startingScreen();
+	case hh_e_state_starting_screen:
+		bool ret = hh_show_starting_screen();
 		if(ret){
-			hh_gameStates = hh_e_STATE_Shop;
+			hh_game_states = hh_e_state_shop;
 		}	
 		break;
-	case hh_e_STATE_Shop:
-		// TODO:
-		//  if(hh_show_Shop()){
-			hh_clear_screen();
-			hh_clear_sprite();
-			hh_setup_screen();
-			hh_clear_sprite();
-			hh_gameStates = hh_e_STATE_Gameplay;
-		// }
-		// function: new level is chosen goto level
+	case hh_e_state_shop:
+		hh_shop(&hh_game_states);
 		break;
-	case hh_e_STATE_Gameplay:
-		hh_player_actions();
-
-		// TODO:
-		// function: if level complete goto shop
-		// function: if player is dead goto game over
+	case hh_e_state_gameplay:
+		hh_gameplay(hh_game, &hh_game_states);
 		break;
-	case hh_e_STATE_GameOver:
-		// TODO:
+	case hh_e_state_game_over:
+		// todo:
 		// function: show game over screen
 		// function: after time goto high score
 		break;
-	case hh_e_STATE_HighScore:
-		// TODO:
+	case hh_e_state_high_score:
+		// todo:
 		// fucntion: show all previously scored points
 		// function: button pressed goto starting screen
 		break;
 	default:
-			hh_gameStates = hh_e_STATE_startingScreen;
+			hh_game_states = hh_e_state_starting_screen;
 		break;
 	}
 }
 
-// void sendData(uint8_t address, uint16_t data) {
-// 	uint8_t bitData[3];
-// 	bitData[2] = data & 0xff;
-// 	bitData[1] = (data >> 8);
-// 	bitData[0] = address; // first byte is address
+// void send_data(uint8_t address, uint16_t data) {
+// 	uint8_t bit_data[3];
+// 	bit_data[2] = data & 0xff;
+// 	bit_data[1] = (data >> 8);
+// 	bit_data[0] = address; // first byte is address
 //
-// 	HAL_GPIO_WritePin(GPIOA, GPIO_PIN_9, GPIO_PIN_RESET);
-// 	HAL_SPI_Transmit(&hspi1, bitData, 3, 100); //2*8 bit data
-// 	HAL_GPIO_WritePin(GPIOA, GPIO_PIN_9, GPIO_PIN_SET);
+// 	hal_gpio_write_pin(gpioa, gpio_pin_9, gpio_pin_reset);
+// 	hal_spi_transmit(&hspi1, bit_data, 3, 100); //2*8 bit data
+// 	hal_gpio_write_pin(gpioa, gpio_pin_9, gpio_pin_set);
 // }
 
 
diff --git a/src/engine/animator.c b/src/engine/animator.c
index 58c50d8..1af8dde 100644
--- a/src/engine/animator.c
+++ b/src/engine/animator.c
@@ -23,6 +23,7 @@ void hh_animate(hh_s_rendering* in, uint16_t start, uint16_t end, uint8_t step)
 	}
 }
 
+//TODO: if entity not inside of screen, don't update idx
 uint16_t hh_update_sprite(uint16_t idx, hh_entity* in, vec_cor cam) {
 	hh_animate_hit(&in->render, in->is_hit);
 	hh_s_ppu_loc_fam_entry temp = in->render.fam;
diff --git a/src/engine/bullet.c b/src/engine/bullet.c
index b97ed5c..e6ca6df 100644
--- a/src/engine/bullet.c
+++ b/src/engine/bullet.c
@@ -1,44 +1,35 @@
 #include "bullet.h"
-#include "engine/sprite_controller.h"
 
 
-void shootBullet(vec2 playerPos, Bullet* bullet){
-	// Set bullet's x and y coordinates to player's coordinates
-    bullet->x = playerPos.x;
-    bullet->y = playerPos.y;
-    // Set bullet's velocity to a fixed value
-    bullet->velocity = 1;
-    // Set bullet's status to active
-    bullet->isActive = true;
-}
-void updateBullet(Bullet* bullet, int deltaTime){
-    // Only update bullet if it is active   
-	 static int latestLocationBullet = 0;
-    if (bullet->isActive) {
-        // Move bullet based on velocity and deltaTime
-        bullet->x += bullet->velocity * deltaTime;
-		drawBullet(bullet);
-        // Check if bullet has moved 16 pixels
-        if (bullet->x - latestLocationBullet > 32) {
-            // Set bullet's status to inactive
-            bullet->isActive = false;
-            drawBullet(&(Bullet){.x = -16,.y = -16});
-        }
-    }
-	 else{
-		latestLocationBullet = bullet->x;
-	 }
+
+// TODO: use hh_entity as bullet struct
+void hh_shoot_bullet(vec2 player, vec_cor cam_pos, hh_entity* bullet){
+	vec2 temp;
+	if(g_hh_controller_p1.button_secondary){
+		if(bullet->is_grounded){
+			bullet->is_grounded=false;
+			bullet->pos = player;
+		}
+	}
+	else{
+		if(!bullet->is_grounded){
+			hh_update_bullet(bullet , cam_pos);
+			hh_draw_bullet(*bullet);
+		}
+	}
+	
+
 }
-void drawBullet(Bullet* bullet){
 
+void hh_update_bullet(hh_entity* bullet, vec_cor cam_pos){
+	bullet->pos.x += 1;
 
-	hh_ppu_update_foreground(10, (hh_s_ppu_loc_fam_entry)
-			{
-                .position_x = bullet->x,
-                .position_y = bullet->y,
-				.horizontal_flip = false,
-				.vertical_flip = false,
-				.palette_index = 7,
-				.tilemap_index = 84, // change tilemap to the correct foreground index;
-			});
+	// update bullet sprite on ppu
+	bullet->render.fam.position_x = (bullet->pos.x-cam_pos.x);
+	bullet->render.fam.position_y = (bullet->pos.y-cam_pos.y);
+
+}
+void hh_draw_bullet(hh_entity bullet){
+	hh_s_ppu_loc_fam_entry temp = bullet.render.fam;
+	hh_ppu_update_foreground(10,temp);
 }
diff --git a/src/engine/bullet.h b/src/engine/bullet.h
index ad67d84..5f07b2e 100644
--- a/src/engine/bullet.h
+++ b/src/engine/bullet.h
@@ -1,16 +1,11 @@
 #pragma once
 #include "player_controller.h"
+#include "engine/sprite_controller.h"
+#include "input.h"
 
-typedef struct {
-    int x;
-    int y;
-    int velocity;
-    int isActive;
-    int hit;
-} Bullet;
 
+void hh_shoot_bullet(vec2 playerPos, vec_cor cam_pos, hh_entity*);
 
-//Bullet* createBullet(float x, float y, float velocity, float direction);
-void shootBullet(vec2 playerPos, Bullet* bullet);
-void updateBullet(Bullet* bullet, int deltaTime);
-void drawBullet(Bullet* bullet);
+void hh_update_bullet(hh_entity* , vec_cor );
+
+void hh_draw_bullet(hh_entity);
diff --git a/src/engine/camera.c b/src/engine/camera.c
index 2c3e517..6898430 100644
--- a/src/engine/camera.c
+++ b/src/engine/camera.c
@@ -4,12 +4,13 @@
 
 
 vec_cor hh_update_camera(vec_cen new, vec2 min, vec2 max){
-
 	//TODO: change floating point math to fix point math
 	//TODO: remove magic number at y camera offset
 
 	// new = vec_cen2cor(new,(vec2){.x=max.x/2,.y=max.y/2});
-	new = vec_cen2cor((vec2){.x=new.x+(HH_PPU_SPRITE_WIDTH),.y=new.y+(HH_PPU_SPRITE_HEIGHT*8)},(vec2){.x=max.x/2,.y=max.y/2});
+	new = vec_cen2cor((vec2){.x=new.x+(HH_PPU_SPRITE_WIDTH),.y=new.y+(HH_PPU_SPRITE_HEIGHT*8)},(vec2){.x=(max.x	- min.x)/2,.y=(max.y	- min.y)/2});
+	// new = vec_cen2cor((vec2){.x=new.x+(HH_PPU_SPRITE_WIDTH),.y=new.y+(HH_PPU_SPRITE_HEIGHT*8)},(vec2){.x=max.x/2,.y=max.y/2});
+
 	// new.x = new.x << HH_MATH_FIXED_POINT;
 	// new.y = new.y << HH_MATH_FIXED_POINT;
 	static vec_cor old;
@@ -30,6 +31,8 @@ vec_cor hh_update_camera(vec_cen new, vec2 min, vec2 max){
 	old.x = CLAMP(new.x,min.x,max.x);
 	old.y = CLAMP(new.y,min.y,max.y);
 
+	//printf("camera new %d min %d max %d\n",new.y,min.y,max.y);
 	return old;
 }
 
+
diff --git a/src/engine/draw_screen.c b/src/engine/draw_screen.c
index a34a20b..823c284 100644
--- a/src/engine/draw_screen.c
+++ b/src/engine/draw_screen.c
@@ -1,72 +1,106 @@
 #include "engine/draw_screen.h"
-#include "engine/sprite_controller.h"
-
-static struct draw_screen
-{
-	void* levels[12]
-};
-
 
+hh_level_entity level;
+uint64_t offsetY=0;
+uint64_t offsetX=0;
 uint8_t hh_world_to_tile(vec2 pos){
-	//TODO: remove magic file name here
-    FILE* level = fopen("static/level1_test.bin", "rb"); /* open binary file */
-    if (!level) { /* check if file opened successfully */
-        fprintf(stderr, "Error: Failed to open file.\n");
-        return 0;
-    }
-	int index = ((pos.y/16)*40 + pos.x/16);//TODO: remove magic number(s)
-	fseek(level, (index * sizeof(int)) + sizeof(int), SEEK_SET);
-	int tile;// = (int*)malloc(sizeof(int));
-   fread(&tile, sizeof(int), 1, level); // read 1 tile from binary
-
-	fclose(level);
-	// int val = tile;
-	// free(tile);
+	
+	int index = (((pos.y/HH_PPU_SPRITE_HEIGHT)*level.size.x) + (pos.x/HH_PPU_SPRITE_WIDTH));//TODO: remove magic number(s)
+	int tile= level.place[index];
 	return tile;
 }
 
+void hh_update_screen(vec2 view, vec2 player){
+	int current_tile_y = view.y / HH_PPU_SPRITE_HEIGHT;
+	int current_tile_x = view.x / HH_PPU_SPRITE_WIDTH;
+	int offset_py = view.y - (offsetY / 40 * HH_PPU_SPRITE_HEIGHT);
+	int offset_px = view.x - offsetX * HH_PPU_SPRITE_WIDTH;
+	static int prev_offset = 0;
 
-// remeber old value to know which part to update.
-vec2 previousViewport = { .x = 0, .y = 0 };
-void hh_draw_screen(vec_cor viewport){
-	if (viewport.x == previousViewport.x && viewport.y == previousViewport.y) return;
-	
-	hh_ppu_update_aux((hh_s_ppu_loc_aux){
-		.bg_shift_x = viewport.x,
-		.bg_shift_y = viewport.y,
-		.fg_fetch	= 0,
-		.sysreset	= 0,
-	});
-
-	// update previous viewport values
-	previousViewport = viewport;
-}
+	int size = MIN(HH_PPU_BG_CANVAS_TILES_H,level.size.x) * MIN(HH_PPU_BG_CANVAS_TILES_V,level.size.y);
+	if( (offset_py == 0 || offset_py > 230) && level.size.y > level.size.x && prev_offset != offset_py){
+		if(offset_py==0){
+			offsetY = MAX(current_tile_y-14,0) * level.size.x;
+		}
+		else{
+			offsetY = current_tile_y * level.size.x;
+		}
 
-void hh_setup_screen(){
-	//(HH_map_size_X*HH_map_size_Y)
-	int size = 2400; // max X = 40 en max Y = 80
-	//TODO: remove magic file name here
-	FILE* level = fopen("static/level1_test.bin", "rb"); /* open binary file */
-	if (!level) { /* check if file opened successfully */
-		fprintf(stderr, "Error: Failed to open level file.\n");
-		return;
+		// Update the background screen
+		for (int BAM_index = 0; BAM_index < size; BAM_index++) {
+			hh_ppu_update_background(BAM_index, (hh_s_ppu_loc_bam_entry){
+				.horizontal_flip = false,
+				.vertical_flip = false,
+				.palette_index = hh_get_palette(level.place[offsetY + BAM_index]),
+				.tilemap_index = level.place[offsetY + BAM_index],
+			});
+		}
+		prev_offset = offset_py;
+	}
+	else if ((offset_px == 0 || offset_px > 310) && level.size.x > level.size.y && prev_offset != offset_px)
+	{
+		if(offset_px==0){
+			offsetX = MAX((current_tile_x - 14),0);
+		}
+		else{
+			offsetX = current_tile_x;
+		}
+		// Update the background screen
+		for (int BAM_index = 0; BAM_index < size; BAM_index++) {
+			int var = (BAM_index / HH_PPU_BG_CANVAS_TILES_H) * level.size.x + MIN((BAM_index % HH_PPU_BG_CANVAS_TILES_H + offsetX),level.size.x);
+			hh_ppu_update_background(BAM_index, (hh_s_ppu_loc_bam_entry){
+				.horizontal_flip = false,
+				.vertical_flip = false,
+				.palette_index = hh_get_palette(level.place[var]),
+				.tilemap_index = level.place[var],
+			});
+		}
 	}
-	fseek(level, (0* sizeof(int)) + sizeof(int), SEEK_SET);
-	int* tile = (int*)malloc(size*sizeof(int));
-   fread(tile, sizeof(int), size, level); // read 1 tile from binary
-
-	fclose(level);
 
-	for(int BAM_index = 0; BAM_index < size; BAM_index++){
+	prev_offset = offset_px;
+	
+}
+void hh_setup_screen(hh_level_entity currentlevel){
+	hh_clear_screen();
+	hh_clear_sprite();
+	level = currentlevel;
+	offsetY=0;
+	offsetX=0;
+	int size = MIN(HH_PPU_BG_CANVAS_TILES_H, level.size.x) * MIN(HH_PPU_BG_CANVAS_TILES_V, level.size.y);
+	for (int BAM_index = 0; BAM_index < size; BAM_index++) {
+		int var = (BAM_index / HH_PPU_BG_CANVAS_TILES_H) * level.size.x + BAM_index % HH_PPU_BG_CANVAS_TILES_H;
 		hh_ppu_update_background(BAM_index, (hh_s_ppu_loc_bam_entry){
 			.horizontal_flip = false,
 			.vertical_flip   = false,
-			.palette_index   = hh_get_palette(tile[BAM_index]),
-			.tilemap_index   = tile[BAM_index],
+			.palette_index   = hh_get_palette(currentlevel.place[var]),
+			.tilemap_index   = currentlevel.place[var],
 		});
 	}
-	free(tile);
 }
+vec_cor hh_draw_screen(vec2 player) {
+   static vec_cor previousViewport = {0, 0};
+	int offset_py = offsetY / 40 * HH_PPU_SPRITE_HEIGHT;
+	
+	int offset_px = (offsetX * HH_PPU_SPRITE_WIDTH) ;
+	vec_cor viewport = hh_update_camera(player,(vec2){.x = offset_px, .y = offset_py},(vec2){.x = HH_PPU_SCREEN_WIDTH + offset_px, .y = 480 + offset_py});//TODO: remove magic number(s)
+	viewport.x = CLAMP(viewport.x, 0, level.size.x * HH_PPU_SPRITE_WIDTH - HH_PPU_SCREEN_WIDTH);
+	viewport.y = CLAMP(viewport.y, 0, level.size.y * HH_PPU_SPRITE_HEIGHT - HH_PPU_SCREEN_HEIGHT);
+	
+	hh_update_screen((vec2){.y=viewport.y,.x=viewport.x},player);
+   if (viewport.x == previousViewport.x && viewport.y == previousViewport.y){}
+	else{
+		hh_ppu_update_aux((hh_s_ppu_loc_aux){
+			.bg_shift_x = viewport.x - offset_px,
+			.bg_shift_y = viewport.y - offset_py,
+			.fg_fetch	= 0,
+			.sysreset	= 0,
+		});
+		previousViewport = viewport;
+	}
+
+	return viewport;
+}
+
 void hh_clear_screen(){
 	// (HH_PPU_SCREEN_HEIGHT*HH_PPU_SCREEN_WIDTH)/(HH_PPU_SPRITE_HEIGHT*HH_PPU_SPRITE_WIDTH)
 	for (int i = 0; i < HH_PPU_BG_CANVAS_TILES_H*HH_PPU_BG_CANVAS_TILES_V; i++) {
@@ -88,8 +122,8 @@ void hh_clear_screen(){
 void hh_clear_sprite(){
 	for (int i = 0; i < HH_PPU_FG_SPRITE_COUNT; i++) {
 		hh_ppu_update_foreground(i,(hh_s_ppu_loc_fam_entry){
-			.position_x = -16,
-			.position_y = -16,
+			.position_x = -HH_PPU_SPRITE_WIDTH,
+			.position_y = -HH_PPU_SPRITE_HEIGHT,
 		});
 	}
 }
diff --git a/src/engine/draw_screen.h b/src/engine/draw_screen.h
index 95765e5..9130842 100644
--- a/src/engine/draw_screen.h
+++ b/src/engine/draw_screen.h
@@ -3,24 +3,32 @@
 
 // every function call for drawing the screen goes here.
 #include "engine/maths.h"
-#include "ppu/consts.h"
 #include "ppu/ppu.h"
-
+#include "engine/level_const.h"
+#include "engine/sprite_controller.h"
 #include <stdio.h>
 #include <stdint.h>
 #include <stdlib.h>
+#include "engine/camera.h"
 
-
-#define HH_map_size_X 80
-#define HH_map_size_Y 60
+#define hh_max_x_size 40 
+#define hh_max_y_size 30
 
 /** @brief return a single tile from world binary */
 uint8_t hh_world_to_tile(vec2 pos);
+
 /** @brief shift to level if viewport changed position */
-void hh_draw_screen(vec2 viewport);
+vec_cor hh_draw_screen(vec2 player);
+
 /** @brief send data to BAM memory from binary level */
-void hh_setup_screen();
+void hh_setup_screen(hh_level_entity currentlevel);
+/** @brief updates screen based on view and maybe player position if it needs to turn back*/
+void hh_update_screen(vec2 view, vec2 );
+
 /** @brief send black screen to background memory */
 void hh_clear_screen();
+
 /** @brief clears all sprite data */
 void hh_clear_sprite();
+/** @brief send data to BAM memory from binary from shop */
+void hh_setup_Shop();
diff --git a/src/engine/entity.h b/src/engine/entity.h
index 43fd5dd..68b450d 100644
--- a/src/engine/entity.h
+++ b/src/engine/entity.h
@@ -7,7 +7,7 @@
 #include "ppu/types.h"
 #include "engine/maths.h"
 #include "engine/types.h"
-#include "engine/animator.h"
+// #include "engine/animator.h"
 
 // TODO: make a sprite update function (and required data structs?)
 
diff --git a/src/engine/level_const.c b/src/engine/level_const.c
new file mode 100644
index 0000000..3847ad8
--- /dev/null
+++ b/src/engine/level_const.c
@@ -0,0 +1,46 @@
+#include "engine/level_const.h"
+
+#include <stdio.h>
+
+hh_g_all_levels hh_init_game_levels(){
+	hh_g_all_levels levels;
+	levels.current_level=0;
+	
+	levels.level[0].size.x=40;
+	levels.level[0].size.y=100;
+	levels.level[0].hh_level_completed=false;
+
+	levels.level[1].size.x=100;
+	levels.level[1].size.y=28;
+	levels.level[1].hh_level_completed=false;
+
+	FILE *fp = fopen("../test/bin/level1_test.bin", "rb");
+	if (fp == NULL) {
+		printf("level1_test.bin not found!\n");
+		return levels;
+	} 
+	fseek(fp, 0, SEEK_END);
+	int size = ftell(fp) / sizeof(int);
+	fseek(fp, (0 * sizeof(int)) + sizeof(int), SEEK_SET);
+	int* hh_game_level1 = malloc(size * sizeof(int));
+	fread(hh_game_level1, sizeof(int), size, fp);
+	fclose(fp);
+
+	FILE *lvl2 = fopen("../test/bin/level2_test.bin", "rb");
+	if (lvl2 == NULL) {
+		printf("level2_test.bin not found!\n");
+		return levels;
+	}
+	fseek(lvl2, 0, SEEK_END);
+	size = ftell(lvl2) / sizeof(int);
+	fseek(lvl2, (0 * sizeof(int)) + sizeof(int), SEEK_SET);
+	int* hh_game_level2 = malloc(size * sizeof(int));
+	fread(hh_game_level2, sizeof(int), size, lvl2);
+	fclose(lvl2);
+
+	levels.level[0].place = hh_game_level1;
+	levels.level[1].place = hh_game_level2;
+
+	return levels;
+}
+
diff --git a/src/engine/level_const.h b/src/engine/level_const.h
new file mode 100644
index 0000000..b86ae7b
--- /dev/null
+++ b/src/engine/level_const.h
@@ -0,0 +1,31 @@
+#pragma once
+#include <stdio.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <stdbool.h>
+#include "engine/maths.h"
+#include "engine/entity.h"
+
+typedef enum {
+	hh_e_state_starting_screen,
+	hh_e_state_shop,
+	hh_e_state_gameplay,
+	hh_e_state_game_over,
+	hh_e_state_high_score
+} hh_e_game_state;
+//entity array met enemeies
+typedef struct  {
+	vec2 size;
+	int hh_total_enemies;
+	int* place;
+	bool hh_level_completed;
+}hh_level_entity;
+
+typedef struct  {
+	hh_level_entity level[2];
+	int current_level;
+
+
+}hh_g_all_levels;
+
+hh_g_all_levels hh_init_game_levels();
diff --git a/src/engine/player_controller.c b/src/engine/player_controller.c
index 7d2847e..cec28df 100644
--- a/src/engine/player_controller.c
+++ b/src/engine/player_controller.c
@@ -8,9 +8,6 @@
 #include "engine/animator.h"
 #include "engine/bullet.h"
 void hh_player_actions() {
-	static Bullet bullet ={
-		.isActive=false,
-	};
 	static hh_entity player={
 		.hp = 4,
 		.speed = 6,
@@ -33,6 +30,25 @@ void hh_player_actions() {
 		}
 	}, player_new = {0};
 
+    static hh_entity bullet={
+//        .hp = 4,
+        .speed = 6,
+        .is_grounded = true,
+        .is_hit = false,
+        .radius = 8,
+        .pos = (vec2){-16,-16},
+        .vel = (vec2){0,0},
+        .render = {
+            .frame0 = 84,
+            .palette = 3,
+            .fam = (hh_s_ppu_loc_fam_entry){
+                .horizontal_flip = false,
+                .vertical_flip = false,
+                .palette_index = 7,
+                .tilemap_index = 84,
+            }
+        }
+    };
 
 	static hh_entity enemy={
 		.hp = 4,
@@ -119,13 +135,6 @@ void hh_player_actions() {
 	} else if (player.vel.y < 6){
 		 player.vel.y += 1; //gravity
 	}
-
-	if(g_hh_controller_p1.button_secondary==true){
-		shootBullet(player.pos,&bullet);
-	}
-	updateBullet(&bullet,5);
-
-
 	
 /*
 	player.vel = (vec2){.x = (-1 * g_hh_controller_p1.dpad_left) + (1 * g_hh_controller_p1.dpad_right),
@@ -143,11 +152,6 @@ void hh_player_actions() {
 	};
 
 	player_new = hh_enemy_collision(player, enemy);
-	
-
-	//END OF VECTOR CHANGES
-	// player.vel.y = CLAMP(player.vel.y,-32,32);
-	// player.vel.x = CLAMP(player.vel.x,-32,32);
 
 	player_new.pos = (vec2){
 		.x = player.pos.x + player_new.vel.x,
@@ -158,11 +162,11 @@ void hh_player_actions() {
 	player =  hh_background_collision( player, player_new);
 	
 	vec_cor cam_pos;//value in tiles
-	cam_pos = hh_update_camera(player.pos,(vec2){0,0},(vec2){.x=20*16,.y=30*16});//TODO: remove magic number(s)
+	cam_pos = hh_draw_screen(player.pos);
+	hh_shoot_bullet(player.pos, cam_pos ,&bullet);
 	uint16_t idx = 16;
 	idx = hh_update_sprite(idx, &player, cam_pos);
 	idx = hh_update_sprite(idx, &enemy, cam_pos);
-	hh_draw_screen(cam_pos);
 
 	idx =16;
 
@@ -191,7 +195,7 @@ void hh_player_actions() {
 
 	// }
 
-	hh_ppu_update_foreground(4, enemy.render.fam);
+	// hh_ppu_update_foreground(4, enemy.render.fam);
 
 }
 
diff --git a/src/game_loop/game_over.c b/src/game_loop/game_over.c
new file mode 100644
index 0000000..f5b70cf
--- /dev/null
+++ b/src/game_loop/game_over.c
@@ -0,0 +1,28 @@
+#include "game_over.h"
+
+
+void hh_game_over(hh_e_game_state* hh_game_state){
+	static hh_e_game_over hh_e_states_game_over = hh_e_game_over_show;
+
+	switch (hh_e_states_game_over)
+	{
+	case hh_e_game_over_show:
+		hh_clear_screen();
+		hh_clear_sprite();
+		// todo: make function to show game over
+		hh_e_states_game_over = hh_e_game_over_input;
+		break;
+	case hh_e_game_over_input:
+		if(g_hh_controller_p1.button_primary){
+			hh_e_states_game_over = hh_e_game_over_end;
+		}
+		break;
+	case hh_e_game_over_end:
+		hh_e_states_game_over = hh_e_game_over_show;
+		*hh_game_state = hh_e_state_game_over;
+		break;
+	default:
+		hh_e_states_game_over = hh_e_game_over_show;
+		break;
+	}
+}
diff --git a/src/game_loop/game_over.h b/src/game_loop/game_over.h
new file mode 100644
index 0000000..80db667
--- /dev/null
+++ b/src/game_loop/game_over.h
@@ -0,0 +1,18 @@
+#pragma once
+
+#include "input.h"
+#include "engine/draw_screen.h"
+#include "engine/level_const.h"
+
+
+#include <stdint.h>
+#include <stdbool.h>
+
+typedef enum {
+	hh_e_game_over_show,
+	hh_e_game_over_input,
+	hh_e_game_over_end,
+} hh_e_game_over;
+
+
+void hh_game_over(hh_e_game_state*);
diff --git a/src/game_loop/gameplay.c b/src/game_loop/gameplay.c
new file mode 100644
index 0000000..295eb5d
--- /dev/null
+++ b/src/game_loop/gameplay.c
@@ -0,0 +1,47 @@
+#include "gameplay.h"
+
+// player struct
+
+
+void hh_gameplay(hh_g_all_levels game, hh_e_game_state* hh_game_state){
+	static hh_e_gameplay gameplay = hh_e_setup_screen;
+
+	switch (gameplay)
+	{
+	case hh_e_setup_screen:
+		hh_setup_screen(game.level[game.current_level]);
+		gameplay = hh_e_play_level;
+		break;
+	case hh_e_play_level:
+		// todo: here come all the different functions for the gameplay
+		hh_player_actions();
+
+
+
+
+
+		if(game.level[game.current_level].hh_level_completed){
+			gameplay = hh_e_level_complete;
+		}
+		break;
+	case hh_e_level_complete:
+		if(game.current_level < 3){
+			game.current_level++;
+			gameplay = hh_e_setup_screen;
+		}
+		else {
+         gameplay = hh_e_game_over;
+      }
+		break;
+	case hh_e_game_over:
+		// todo make reset levels
+		hh_reset_levels();
+		gameplay = hh_e_setup_screen;
+		*hh_game_state = 	hh_e_state_game_over;
+		break;
+	default:
+		break;
+	}
+	
+}
+void hh_reset_levels(){}
diff --git a/src/game_loop/gameplay.h b/src/game_loop/gameplay.h
new file mode 100644
index 0000000..d309e78
--- /dev/null
+++ b/src/game_loop/gameplay.h
@@ -0,0 +1,17 @@
+#pragma once
+#include "engine/draw_screen.h"
+#include "engine/player_controller.h"
+#include "engine/sprite_controller.h"
+#include "game_loop/starting_screen.h"
+#include "engine/level_const.h"
+
+typedef enum {
+	hh_e_setup_screen,
+	hh_e_play_level,
+	hh_e_level_complete,
+	hh_e_game_over,
+}hh_e_gameplay;
+
+void hh_reset_levels();
+void hh_gameplay(hh_g_all_levels, hh_e_game_state*);
+
diff --git a/src/game_loop/shop.c b/src/game_loop/shop.c
new file mode 100644
index 0000000..ea75d46
--- /dev/null
+++ b/src/game_loop/shop.c
@@ -0,0 +1,76 @@
+#include "shop.h"
+#include "engine/maths.h"
+#include "ppu/ppu.h"
+
+void hh_shop(hh_e_game_state* hh_game_state){
+	static hh_e_shop_states hh_e_shop = hh_e_shop_show;
+	static hh_e_upgrades upgrades[HH_SHOP_UPG_DISPLAY] = {0};
+	static uint8_t selected = 0;
+
+	switch (hh_e_shop)
+	{
+	case hh_e_shop_show:
+		hh_clear_screen();
+		hh_clear_sprite();
+		// TODO: make function to show shop
+		//hh_setup_shop();
+		hh_shop_init(&upgrades);
+		selected = HH_SHOP_UPG_DISPLAY/2;
+		// hh_shop_display(selected, &upgrades);
+		hh_e_shop = hh_e_shop_main;
+		break;
+	case hh_e_shop_main:
+		if(g_hh_controller_p1.dpad_left || g_hh_controller_p1.dpad_right){
+			hh_shift_selected(&selected,(g_hh_controller_p1.dpad_right?1:0),0,HH_SHOP_UPG_DISPLAY);
+			// hh_shop_display(selected, &upgrades);
+		}
+		// if(g_hh_controller_p1.button_primary){
+		// 	//apply selected upgrade
+		// 	hh_e_shop = hh_e_shop_end;
+		// }
+		if(g_hh_controller_p1.button_secondary){//Quick exit
+			hh_e_shop = hh_e_shop_end;
+		}
+		break;
+	case hh_e_shop_end:
+		hh_e_shop = hh_e_shop_show;
+		*hh_game_state = hh_e_state_gameplay;
+		break;
+	default:
+		hh_e_shop = hh_e_shop_show;
+		break;
+	}
+}
+
+void hh_shop_init(hh_e_upgrades* in) {
+	for (int i = 0; i < HH_SHOP_UPG_DISPLAY; i++) {
+		in[i] = i%HH_SHOP_UPG_COUNT;
+	}
+}
+
+void hh_shop_display(uint8_t selected, hh_e_upgrades* upgrades) {
+	const vec_cor start = {48,16};
+	const uint8_t up = 8,
+					space = 24+8;
+
+	for (int i = 0; i < HH_SHOP_UPG_DISPLAY; i++) {
+		hh_ppu_update_foreground(i+16,
+		(hh_s_ppu_loc_fam_entry){
+			.horizontal_flip = false, .vertical_flip = false,
+			.position_x = i*space+start.x, .position_y = start.y + (i==selected?up:0),
+			.palette_index = 7,
+			.tilemap_index = 8
+		});
+	}
+}
+
+void hh_shift_selected(uint8_t* pos, bool dir, uint8_t min, uint8_t max) {
+	if (dir) {
+		pos = CLAMP(++pos,min,max);
+	} else {
+		if (pos > 0) {
+			pos--;
+		}
+	}
+}
+
diff --git a/src/game_loop/shop.h b/src/game_loop/shop.h
new file mode 100644
index 0000000..b0ad5e4
--- /dev/null
+++ b/src/game_loop/shop.h
@@ -0,0 +1,35 @@
+#pragma once
+
+#include "input.h"
+#include "engine/draw_screen.h"
+#include "engine/level_const.h"
+
+
+#include <stdint.h>
+#include <stdbool.h>
+
+typedef enum {
+	hh_e_shop_show,
+	hh_e_shop_main,
+	hh_e_shop_end,
+} hh_e_shop_states;
+
+/** @brief amount of upgrade types */
+#define HH_SHOP_UPG_COUNT 2
+/** @brief count of visible upgrades in shop */
+#define HH_SHOP_UPG_DISPLAY 4
+/** @brief all possible upgrades */
+typedef enum {
+	hh_e_upg_jump,
+	hh_e_upg_heal,
+	hh_e_upg_max_health,
+} hh_e_upgrades;
+
+/** @brief init */
+void hh_shop_init(hh_e_upgrades* in);
+/** @brief deals with displayed entity rendering */
+void hh_shop_display(uint8_t selected, hh_e_upgrades* upgrades);
+/** @brief moves 'cursor' through selection field */
+void hh_shift_selected(uint8_t* pos, bool dir, uint8_t min, uint8_t max);
+
+void hh_shop(hh_e_game_state*);
diff --git a/src/game_loop/starting_screen.c b/src/game_loop/starting_screen.c
new file mode 100644
index 0000000..6ab0278
--- /dev/null
+++ b/src/game_loop/starting_screen.c
@@ -0,0 +1,32 @@
+#include "starting_screen.h""
+#include "input.h"
+#include "engine/title_screen.h"
+#include "engine/draw_screen.h"
+// #include "engine/player_controller.h"
+
+bool hh_show_starting_screen(){
+	static hh_e_screen_states hh_e_starting_screen = hh_e_state_show;
+	
+	switch (hh_e_starting_screen)
+	{
+	case hh_e_state_show:
+		hh_clear_screen();
+		hh_init_title_screen();
+		hh_e_starting_screen = hh_e_state_input;
+		return false;
+		break;
+	case hh_e_state_input:
+		if(g_hh_controller_p1.button_primary){
+			hh_e_starting_screen = hh_e_state_end;
+		}
+		break;
+	case hh_e_state_end:
+		hh_e_starting_screen = hh_e_state_show;
+		return true;
+		break;
+	default:
+		hh_e_starting_screen = hh_e_state_show;
+		break;
+	}
+	return false;
+}
diff --git a/src/game_loop/starting_screen.h b/src/game_loop/starting_screen.h
new file mode 100644
index 0000000..4228f38
--- /dev/null
+++ b/src/game_loop/starting_screen.h
@@ -0,0 +1,14 @@
+#pragma once
+
+#include <stdint.h>
+#include <stdbool.h>
+
+typedef enum {
+	hh_e_state_show,
+	hh_e_state_input,
+	hh_e_state_end
+} hh_e_screen_states;
+
+
+bool hh_show_starting_screen();
+
diff --git a/src/makefile b/src/makefile
index aac3856..c30840d 100644
--- a/src/makefile
+++ b/src/makefile
@@ -40,9 +40,12 @@ LOCAL_SRCS += main.c \
 							engine/entity.c \
 							engine/bullet.c \
 							engine/title_screen.c \
+							engine/level_const.c \
 							engine/animator.c \
-							GameLoop/shop.c \
-							GameLoop/startingScreen.c
+							game_loop/shop.c \
+							game_loop/gameplay.c \
+							game_loop/game_over.c \
+							game_loop/starting_screen.c
 
 CFLAGS += $(SHARED_FLAGS)
 LFLAGS += $(SHARED_FLAGS)