Merge pull request #58 from UnavailableDev/dev

Dynamic tilemap

16 files changed, 291 insertions, 91 deletions

diff --git a/src/engine/animator.c b/src/engine/animator.c
index 1af8dde..e293eb1 100644
--- a/src/engine/animator.c
+++ b/src/engine/animator.c
@@ -16,40 +16,26 @@ void hh_animate_hit(hh_s_rendering* in, bool hit) {
 }
 
 void hh_animate(hh_s_rendering* in, uint16_t start, uint16_t end, uint8_t step) {
-	if (in->fam.palette_index >= start && in->fam.palette_index < end) {
-		in->fam.palette_index += step;
+	if (in->fam.tilemap_index >= start && in->fam.tilemap_index < end) {
+		in->fam.tilemap_index += step;
 	} else {// rollover
-		in->fam.palette_index = start;
+		in->fam.tilemap_index = start;
 	}
 }
 
-//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) {
+//TODO: if entity not inside of screen, don't update idx (problems with old idx not being overwritten anymore)
+void 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;
 	for (int y = 0; y < CEILI(in->size.y,16); y++) {
 		temp.position_y = CLAMP(in->pos.y - cam.y + y*HH_PPU_SPRITE_HEIGHT, -16, HH_PPU_SCREEN_HEIGHT);
 		for (int x = 0; x < CEILI(in->size.x,16); x++) {
 			temp.position_x = CLAMP(in->pos.x - cam.x + x*HH_PPU_SPRITE_WIDTH, -16, HH_PPU_SCREEN_WIDTH);
-			hh_ppu_update_foreground(++idx, temp);	
-			temp.tilemap_index++;
+			// if (temp.position_x != -16 && temp.position_y != -16) {// removes redundant sprites
+				hh_ppu_update_foreground(++*idx, temp);
+				temp.tilemap_index++;
+				// hh_animate(&in->render, start+counter,end+counter,4);
+			// }
 		}
 	}
-	return idx;
 }
-
-
-// void hh_update_sprite(hh_entity* in, vec_cor cam) {
-// 	hh_animate_hit(&in->render, in->is_hit);
-// 	// uint16_t idx = in->render.ppu_foreground_index;
-// 	uint16_t idx = 0;
-// 	hh_s_ppu_loc_fam_entry temp = in->render.fam;
-// 	for (int y = 0; y < CEILI(in->size.y,16); y++) {
-// 		temp.position_y = CLAMP(in->pos.y - cam.y + y*HH_PPU_SPRITE_HEIGHT, -16, HH_PPU_SCREEN_HEIGHT);
-// 		for (int x = 0; x < CEILI(in->size.x,16); x++) {
-// 			temp.position_x = CLAMP(in->pos.x - cam.x + x*HH_PPU_SPRITE_WIDTH, -16, HH_PPU_SCREEN_WIDTH);
-// 			hh_ppu_update_foreground(idx++, temp);	
-// 			temp.tilemap_index++;
-// 		}
-// 	}
-// }
diff --git a/src/engine/animator.h b/src/engine/animator.h
index 10fa321..2f6e00d 100644
--- a/src/engine/animator.h
+++ b/src/engine/animator.h
@@ -11,4 +11,4 @@ void hh_animate_hit(hh_s_rendering*, bool hit);
 void hh_animate(hh_s_rendering*, uint16_t start, uint16_t end, uint8_t step);
 
 /** @brief passively updates sprite*/
-uint16_t hh_update_sprite(uint16_t idx, hh_entity* in, vec_cor cam);
+void hh_update_sprite(uint16_t* idx, hh_entity* in, vec_cor cam);
diff --git a/src/engine/bullet.c b/src/engine/bullet.c
index 55b20cc..3251472 100644
--- a/src/engine/bullet.c
+++ b/src/engine/bullet.c
@@ -18,13 +18,13 @@ hh_entity* hh_init_bullets(int size) {
         .vel = (vec2){0,0},
         .size = (vec2) { 13,16},
         .render = {
-            .frame0 = 84,
+            .frame0 = HH_TM_BULLET_OFFSET,
             .palette = 3,
             .fam = (hh_s_ppu_loc_fam_entry){
                 .horizontal_flip = false,
                 .vertical_flip = false,
                 .palette_index = 7,
-                .tilemap_index = 84,
+                .tilemap_index = HH_TM_BULLET_OFFSET,
             }
         }
     };
@@ -42,12 +42,47 @@ bool rising_edge(bool signal, bool* prev) {
     return edge;
 }
 bool prev_signal = false;
+void hh_handle_bullet_direction(hh_entity* bullet){
+	bullet->vel = (vec2){0,0};
+	if (g_hh_controller_p1.dpad_left) {
+		if (g_hh_controller_p1.dpad_up) {
+			bullet->vel.x = -1;
+			bullet->vel.y = -1;
+		} else if (g_hh_controller_p1.dpad_down) {
+			bullet->vel.x = -1;
+			bullet->vel.y = 1;
+		} else {
+			bullet->vel.x = -1;
+		}
+	}else if (g_hh_controller_p1.dpad_right) {
+		if (g_hh_controller_p1.dpad_up) {
+			bullet->vel.x = 1;
+			bullet->vel.y = -1;
+		} else if (g_hh_controller_p1.dpad_down) {
+			bullet->vel.x = 1;
+			bullet->vel.y = 1;
+		} else {
+			bullet->vel.x = 1;
+		}
+	} else if (g_hh_controller_p1.dpad_up){
+		bullet->vel.y = -1;
+	} else if (g_hh_controller_p1.dpad_down){
+		bullet->vel.y = 1;
+	}
+	else{
+		bullet->vel.x = 1;
+	}
+	bullet->render.fam.horizontal_flip = (bullet->vel.x < 0);
+	bullet->render.fam.vertical_flip = (bullet->vel.y != 0);
+	
+}
 void hh_shoot_bullet(vec2 player, hh_entity* bullet){
 	vec2 temp;
 	if(rising_edge(g_hh_controller_p1.button_secondary,&prev_signal) && bullet->is_grounded){
 			bullet->is_grounded=false;
 			bullet->pos = player;
 			current_bullet = (current_bullet + 1) % bullets_size;
+			hh_handle_bullet_direction(bullet);
 	}
 
 }
@@ -55,11 +90,10 @@ void hh_shoot_bullet(vec2 player, hh_entity* bullet){
 void hh_update_bullet(hh_entity* bullet){
 	if(hh_background_collision_bulllet(*bullet)){
 		hh_bullet_death(bullet);
-
-		// printf("x %d y %d\n",(bullet->pos.x-cam_pos.x),(bullet->pos.y-cam_pos.y));
 	}
 	else{
-		bullet->pos.x += bullet->speed;	
+		bullet->pos.x = bullet->pos.x + bullet->vel.x * bullet->speed;	
+		bullet->pos.y = bullet->pos.y  + bullet->vel.y * bullet->speed;	
 	}
 
 }
diff --git a/src/engine/enemy.c b/src/engine/enemy.c
index 186cfa0..4ed48a2 100644
--- a/src/engine/enemy.c
+++ b/src/engine/enemy.c
@@ -1,14 +1,9 @@
 #include "engine/enemy.h"
 
-void hh_update_enemy(hh_entity* enemy, vec_cor cam_pos){
-	//Bjorn functions
 
-
-}
-
-void hh_multiple_enemies( vec_cor cam_pos, hh_entity* enemies, int total_enemies){
+void hh_multiple_enemies(hh_entity* enemies, hh_entity player, vec_cor cam_pos, int total_enemies){
 	for(int i=0; i < total_enemies;i++){
-			hh_update_enemy(&enemies[i] , cam_pos);
+			hh_update_enemy(&enemies[i] , player, cam_pos);
 		}
 
 }
@@ -22,6 +17,7 @@ void hh_enemy_death_check(hh_entity* enemy){
 		enemy->hp--;
 	}
 }
+
 void hh_solve_hitted_enemies(hh_entity* enemies, int total_enemies){
 	for(int i = 0; i < total_enemies; i++){
 		if(enemies[i].is_hit){
diff --git a/src/engine/enemy.h b/src/engine/enemy.h
index 80498f5..c8a3f20 100644
--- a/src/engine/enemy.h
+++ b/src/engine/enemy.h
@@ -1,14 +1,13 @@
 #pragma once
 #include "player_controller.h"
 #include "engine/sprite_controller.h"
+#include "engine/enemy_ai.h"
 #include "types.h"
 #include "input.h"
 
-/** @brief updates a single enemy locations TODO: Bjorn sets functions in here*/
-void hh_update_enemy(hh_entity* , vec_cor );
 
 /** @brief calculates all the given enemies positions*/
-void hh_multiple_enemies( vec_cor cam_pos, hh_entity* enemies, int total_enemies);
+void hh_multiple_enemies(hh_entity* enemies, hh_entity player, vec_cor cam_pos, int total_enemies);
 
 /** @brief checks if the enemy has zero hp else it takes hp from the enemy */
 void hh_enemy_death_check(hh_entity* enemy);
diff --git a/src/engine/enemy_ai.c b/src/engine/enemy_ai.c
new file mode 100644
index 0000000..81d04d9
--- /dev/null
+++ b/src/engine/enemy_ai.c
@@ -0,0 +1,99 @@
+#include "engine/enemy_ai.h"
+
+int8_t hh_get_direction(int32_t player_x, int32_t enemy_x){
+	int movement_direction = player_x - enemy_x; // = player.pos.x - player.prev_pos.x;
+	if (movement_direction > 0) {
+		return 1; // move in positive direction
+	} else if (movement_direction < 0) {
+		return -1; // move in negative direction
+	} else {
+		return 0; // don't move
+	}
+}
+void hh_update_enemy_movement(hh_entity* enemy){
+	hh_entity enemy_new = {0};
+	enemy_new = *enemy;
+	enemy_new.vel = (vec2){
+		.x = enemy->vel.x,
+		.y = enemy->vel.y,
+	};
+	
+	enemy_new.pos = (vec2){
+		.x = enemy->pos.x + enemy_new.vel.x,
+		.y = enemy->pos.y + enemy_new.vel.y,
+	};
+
+
+	*enemy =  hh_background_collision ( *enemy, enemy_new);
+}
+void hh_slime_ai(hh_entity* enemy, hh_entity player){
+	int8_t direction = hh_get_direction(player.pos.x, enemy->pos.x);
+	if((player.pos.x - enemy->pos.x) >= -hunt_player && (player.pos.x - enemy->pos.x) <= hunt_player){
+   	hh_movement_entity(enemy, direction);
+	}
+	hh_gravity_entity(enemy);
+	hh_update_enemy_movement(enemy);
+
+}
+
+void hh_jump_slime_ai(hh_entity* enemy, hh_entity player){
+	int8_t direction = hh_get_direction(player.pos.x, enemy->pos.x);
+	hh_gravity_entity(enemy);
+	if((player.pos.x - enemy->pos.x) >= -hunt_player && (player.pos.x - enemy->pos.x) <= hunt_player){
+   	hh_movement_entity(enemy, direction);
+		// TODO: fix this if statement and make it cleaner. this makes the enemy jump when the player mets the condition
+		if((player.pos.y - enemy->pos.y) < -16 && (player.pos.y - enemy->pos.y) >= -100 && (player.pos.x - enemy->pos.x) >= -10 && (player.pos.x - enemy->pos.x) <= 10){
+			hh_jump_entity(enemy);
+		}
+	}
+
+	hh_update_enemy_movement(enemy);
+
+}
+#define terror_owl_attack_timer 100
+#define terror_owl_follow_player_delay 5 
+#define terror_owl_attack_player_delay 12
+#define terror_owl_dive_speed 3
+#define delay_frames 2
+#define terror_owl_minimal_distance_from_player 100
+void hh_terror_owl_ai(hh_entity* enemy, hh_entity player){
+	static int count=0;
+	static int last_y_location=0;
+    
+	if (count < terror_owl_attack_timer) {
+		// Move towards player position smoothly
+		int delta_x = (-50 + player.pos.x - enemy->pos.x) / terror_owl_follow_player_delay;
+		enemy->pos.x += delta_x;
+		enemy->pos.y = player.pos.y - terror_owl_minimal_distance_from_player;
+
+		count++;
+		last_y_location=player.pos.y;
+	} else {
+		if(enemy->pos.y <= last_y_location){
+			int delta_x = (player.pos.x - enemy->pos.x) / terror_owl_attack_player_delay;
+			enemy->pos.x += delta_x;
+			enemy->pos.y += terror_owl_dive_speed;
+		}
+		else{
+			count = 0;
+		}
+	}
+
+}
+void hh_update_enemy(hh_entity* enemy ,  hh_entity player, vec_cor cam_pos){
+	// static hh_e_entity_type type;
+	switch (enemy->object_type)
+	{
+	case slime:
+		hh_slime_ai(enemy,player);
+		break;
+	case jumping_slime:
+		hh_jump_slime_ai(enemy,player);
+		break;
+	case terror_owl:
+		hh_terror_owl_ai(enemy,player);
+		break;
+	default:
+		break;
+	}
+}
diff --git a/src/engine/enemy_ai.h b/src/engine/enemy_ai.h
new file mode 100644
index 0000000..d68f50f
--- /dev/null
+++ b/src/engine/enemy_ai.h
@@ -0,0 +1,10 @@
+#pragma once
+#include "player_controller.h"
+#include "engine/sprite_controller.h"
+#include "types.h"
+#include "input.h"
+#include <math.h>
+
+
+#define hunt_player 100
+void hh_update_enemy(hh_entity* enemy ,  hh_entity player, vec_cor cam_pos);
diff --git a/src/engine/entity.c b/src/engine/entity.c
index 1cb88be..eba6481 100644
--- a/src/engine/entity.c
+++ b/src/engine/entity.c
@@ -43,6 +43,7 @@ void hh_solve_collision(vec2 pos_environment, hh_entity* entity){
 	// 	entity->vel.x = 0;
 	// } 
 }
+
 hh_entity hh_background_collision (hh_entity temp_old_entity,hh_entity temp_new_entity){
 
 		temp_new_entity.is_grounded = false;
@@ -119,6 +120,7 @@ bool hh_background_collision_bulllet (hh_entity temp_old_entity){
 	// temp_old_entity.vel = temp_new_entity.vel;
 	return false;
 }
+
 hh_entity hh_enemy_collision(hh_entity temp_player, hh_entity temp_enemy){
 	
 	bool collide = hh_distance_circles( temp_player.pos,  temp_enemy.pos, temp_player.radius, temp_enemy.radius);
@@ -138,7 +140,7 @@ hh_entity hh_enemy_collision(hh_entity temp_player, hh_entity temp_enemy){
 			temp_player.vel.x = 8;
 		}
 		// ghost mode / invulnerable or other things on hit
-		//	temp_player.hp--;
+		temp_player.hp--;
 			
 	} else {
 		temp_player.is_hit = false;
@@ -170,14 +172,35 @@ void hh_jump_entity(hh_entity* object_1){
 	}
 }
 void hh_gravity_entity(hh_entity* object_1){
-	if (object_1->is_grounded == false && object_1->vel.y < 6) {
+	if (object_1->is_grounded == false) {
 		object_1->vel.y += 1; //gravity
 	}
 }
-void hh_hit_entity(hh_entity* object_1, int8_t* hit_timer, int8_t* direction){
+
+void hh_movement_entity(hh_entity* object_1, int8_t* direction){
+	if(direction != 0){
+		if(object_1->vel.x > -1 * object_1->speed && object_1->vel.x < object_1->speed) {
+			object_1->vel.x = object_1->vel.x + direction;
+		} else {
+			if (object_1->vel.x > 0) {
+				object_1->vel.x--;
+			} else if(object_1->vel.x < 0) {
+				object_1->vel.x++; 
+			}
+		}
+	} else {
+		if (object_1->vel.x > 0) {
+			object_1->vel.x--;
+		} else if(object_1->vel.x < 0) {
+		object_1->vel.x++; 
+		}
+	}
+	
+}
+void hh_player_move_hit(hh_entity* object_1, int8_t* hit_timer, int8_t* direction){
 	if(object_1->is_hit == true){
 		hit_timer = 9;
-		object_1->is_hit = false;	
+		//object_1->is_hit = false;
 	} 
 	if(hit_timer > -10){
 			hit_timer--;
diff --git a/src/engine/entity.h b/src/engine/entity.h
index fde9341..fb1c905 100644
--- a/src/engine/entity.h
+++ b/src/engine/entity.h
@@ -51,9 +51,12 @@ void hh_jump_entity(hh_entity* );
 /** @brief looks if the player is grounded and if not it sets the position down */
 void hh_gravity_entity(hh_entity* );
 /** @brief if object is hit bounches in specific direction and moves the object */
-void hh_hit_entity(hh_entity* object_1, int8_t* hit_timer, int8_t* direction);
+void hh_player_move_hit(hh_entity* object_1, int8_t* hit_timer, int8_t* direction);
+
+void hh_movement_entity(hh_entity* object_1, int8_t* direction);
 
 /** @brief specific bullet background collisions detection */
 bool hh_background_collision_bulllet (hh_entity temp_old_entity);
 /** @brief checks any entity has a hit on each othe*/
 void hh_check_all_collisions(hh_entity* player, hh_entity* enemies, int total_enemies, hh_entity* bullets, int total_bullets, vec_cor cam_pos);
+
diff --git a/src/engine/level_const.c b/src/engine/level_const.c
index 896d0e0..2522814 100644
--- a/src/engine/level_const.c
+++ b/src/engine/level_const.c
@@ -4,7 +4,11 @@
 
 hh_g_all_levels hh_init_game_levels(){
 	hh_g_all_levels levels;
-	levels.current_level=0;
+	levels.current_level=1;
+
+	levels.shop.size.x=40;
+	levels.shop.size.y=15;
+	levels.shop.hh_level_completed=false;
 	
 	levels.level[0].size.x=40;
 	levels.level[0].size.y=100;
@@ -14,9 +18,9 @@ hh_g_all_levels hh_init_game_levels(){
 	levels.level[1].size.y=28;
 	levels.level[1].hh_level_completed=false;
 
-	FILE *fp = fopen("../test/bin/level1_test.bin", "rb");
+	FILE *fp = fopen("static/shop_new.bin", "rb");
 	if (fp == NULL) {
-		printf("level1_test.bin not found!\n");
+		printf("shop_new.bin not found!\n");
 		return levels;
 	} 
 	fseek(fp, 0, SEEK_END);
@@ -38,6 +42,19 @@ hh_g_all_levels hh_init_game_levels(){
 	fread(hh_game_level2, sizeof(int), size, lvl2);
 	fclose(lvl2);
 
+	FILE *shop = fopen("static/shop_new.bin", "rb");
+	if (shop == NULL) {
+		printf("shop.bin not found!\n");
+		return levels;
+	}
+	fseek(shop, 0, SEEK_END);
+	size = ftell(shop) / sizeof(int);
+	fseek(shop, (0 * sizeof(int)) + sizeof(int), SEEK_SET);
+	int* hh_game_shop = malloc(size * sizeof(int));
+	fread(hh_game_shop, sizeof(int), size, shop);
+	fclose(shop);
+
+	levels.shop.place = hh_game_shop;
 	levels.level[0].place = hh_game_level1;
 	levels.level[1].place = hh_game_level2;
 
diff --git a/src/engine/level_const.h b/src/engine/level_const.h
index 6275b72..a17993e 100644
--- a/src/engine/level_const.h
+++ b/src/engine/level_const.h
@@ -23,6 +23,7 @@ typedef struct  {
 
 typedef struct  {
 	hh_level_entity level[2];
+	hh_level_entity shop;
 	int current_level;
 
 
diff --git a/src/engine/player_controller.c b/src/engine/player_controller.c
index 83c5966..0148792 100644
--- a/src/engine/player_controller.c
+++ b/src/engine/player_controller.c
@@ -5,6 +5,8 @@
 #include "engine/player_controller.h"
 #include "input.h"
 
+#include "static/tilemap.h"
+
 #include "engine/animator.h"
 #include "engine/bullet.h"
 void hh_player_actions(hh_entity* player){
@@ -16,7 +18,7 @@ void hh_player_actions(hh_entity* player){
 	int8_t direction_x = (-1 * g_hh_controller_p1.dpad_left) + (1 * g_hh_controller_p1.dpad_right);
 	int8_t direction_y = (-1 * g_hh_controller_p1.dpad_up) + (1 * g_hh_controller_p1.dpad_down);
 
-	hh_hit_entity(player,hit_timer,direction_x);
+	hh_player_move_hit(player,hit_timer,direction_x);
 	hh_gravity_entity(player);
 	if(g_hh_controller_p1.button_primary){
 		hh_jump_entity(player);
diff --git a/src/engine/sprite_controller.c b/src/engine/sprite_controller.c
index b38b647..d386d0f 100644
--- a/src/engine/sprite_controller.c
+++ b/src/engine/sprite_controller.c
@@ -5,8 +5,18 @@
 #include "ppu/consts.h"
 #include "ppu/ppu.h"
 
+#include "static/tilemap.h"
+
+
 uint8_t hh_get_palette(uint8_t tile_idx) {
-	return hh_g_sprite_palette[tile_idx];
+	for (int i = 0; i < HH_TM_GROUPS; i++) {		
+		if (hh_palette_lut[i] > tile_idx){
+			return hh_g_sprite_palette[i-1];
+		}
+	}	
+	
+	return 0; //not found
+	// return hh_g_sprite_palette[tile_idx];
 }
 
 void hh_setup_palettes(){
diff --git a/src/engine/sprite_controller.h b/src/engine/sprite_controller.h
index fc6d3d3..3693850 100644
--- a/src/engine/sprite_controller.h
+++ b/src/engine/sprite_controller.h
@@ -3,6 +3,8 @@
 
 #include "ppu/types.h"
 
+#include "static/tilemap.h"
+
 // handles sprites
 
 // Bg sprites
@@ -11,27 +13,29 @@
 
 //TODO: pack data inside of sprite_palette LUT
 //HH_PPU_PALETTE_COUNT
-#define HH_SPRITE_COUNT 80
-#define HH_PAL_IDX_SKY 512
+
+#define HH_PAL_IDX_SKY 0
 #define HH_PAL_IDX_BRICK 1
-const static uint8_t hh_g_sprite_palette[HH_SPRITE_COUNT] = {
-	//TODO: make a buffer of 16 no-collider sprites (instead of the current 1)
-	0,1,1,1,1,1,1,1,1,1, //1+9
-	1,1,1,1,1,1,1,1,1,1, //6+4
-	1,1,1,1,1,1,1,1,1,	//9
-	7,7,7,2,7,7,1,2,7,
-	7,7,7,7, //?? 
+#define HH_PAL_IDX_SLIME 2
+#define HH_PAL_IDX_CRATE 4
+#define HH_PAL_IDX_SHOP 5
+#define HH_PAL_IDX_TITLE_SCREEN_ICON 3
+#define HH_PAL_IDX_FONT 6
+#define HH_PAL_IDX_DEV 7
+const static uint8_t hh_g_sprite_palette[HH_TM_GROUPS] = {
+	HH_PAL_IDX_SKY,
+	HH_PAL_IDX_BRICK,
+	HH_PAL_IDX_CRATE,
+	HH_PAL_IDX_SHOP,
+	// HH_PAL_IDX_SHOP,
+	HH_PAL_IDX_TITLE_SCREEN_ICON,
+	HH_PAL_IDX_FONT,
+	HH_PAL_IDX_SKY,
+	HH_PAL_IDX_DEV,
+	HH_PAL_IDX_SLIME,
+	HH_PAL_IDX_DEV
+	// HH_PAL_IDX_FONT
 
-	7,6,6,6,6,6,6,6, //baskets
-	7,7,7,7,7,7,7,7,7,7, //shop
-	7,7,7,7,7, //shop
-	6,6,6,6,6, //(hi-)score
-	
-	3,3,3,3,3,3, //title_screen icon
-	6,6,6,6,/*6,6,6,6,6,6, //title_screen large letters
-	6,6,6,6,*/
-	//other palettes here:
-	// [HH_PAL_IDX_SKY] = 0,
 };
 
 
@@ -47,13 +51,13 @@ const static hh_ppu_loc_palette_table_t hh_g_palette = {
 		{0x0,0x0,0x0}},
 	{//Bricks
 		{0x1,0x2,0x3},//01
-		{0xd,0x8,0xa},//24
 		{0x0,0x0,0x1},//25
 		{0x1,0x1,0x1},//26
 		{0x1,0x1,0x2},//27
 		{0x2,0x2,0x3},//28
 		{0x3,0x4,0x5},//29
-		{0x5,0x1,0x7}},
+		{0x5,0x1,0x7},
+		{0xd,0x8,0xa}},//24
 	{//slime
 		{0x1,0x2,0x3},
 		{0x1,0x3,0x2},
@@ -69,27 +73,35 @@ const static hh_ppu_loc_palette_table_t hh_g_palette = {
 		{0x4,0x2,0x5},
 		{0x7,0x3,0x7},
 		{0xe,0xe,0xe}, 
-		{0xe,0xe,0xe}, //elemental
-		{0x0,0x0,0x0},
-		{0x0,0x0,0x0}},
-	{
-		{0x0,0x0,0x0},
-		{0x0,0x0,0x0},
-		{0x0,0x0,0x0},
-		{0x0,0x0,0x0},
-		{0x0,0x0,0x0},
-		{0x0,0x0,0x0},
-		{0x0,0x0,0x0},
-		{0x0,0x0,0x0}},
-	{//elemental
-		{0x0,0x0,0x0},
-		{0x0,0x0,0x0},
-		{0x0,0x0,0x0},
-		{0x0,0x0,0x0},
-		{0x0,0x0,0x0},
+		{0x7,0x2,0x3}, //elemental
+		{0xc,0x5,0x3},
+		{0xe,0xc,0x7}},
+	{//crates
+		{0x5,0x7,0x7},
+		{0x3,0x1,0x2},
+		{0x6,0x2,0x2},
+		{0x7,0x4,0x4},
+		{0xa,0x7,0x5},
 		{0x0,0x0,0x0},
 		{0x0,0x0,0x0},
 		{0x0,0x0,0x0}},
+	{//shop
+		// {0x1,0x2,0x3},
+		// {0x0,0x0,0x1},
+		// {0x0,0x0,0x0},
+		// {0x0,0x0,0x0},
+		// {0x0,0x0,0x0},
+		// {0x0,0x0,0x0},
+		// {0x0,0x0,0x0},
+		// {0x0,0x0,0x0}},
+		{0x1, 0x2, 0x3},//0
+		{0x0, 0x0, 0x1},//1
+		{0x6, 0x2, 0x2},//2
+		{0x7, 0x4, 0x4},//3
+		{0xc, 0x9, 0x7},//4
+		{0xd, 0xb, 0x9},//5
+		{0x3, 0x4, 0x5},//6
+		{0x8, 0x9, 0x9}},
 	{//white
 		{0x1,0x2,0x3},
 		{0xf,0xf,0xf},
@@ -112,7 +124,9 @@ const static hh_ppu_loc_palette_table_t hh_g_palette = {
 
 void hh_setup_palettes();
 
+//TODO: UPDATE THIS FUNCTION
 /** @brief return palette index that belongs to tilemap index */
 uint8_t hh_get_palette(uint8_t tile_idx);
 
+//TODO: UPDATE THIS FUNCTION
 bool hh_colidable(uint8_t tile_idx);
diff --git a/src/engine/title_screen.c b/src/engine/title_screen.c
index 9c7ed48..1e9e586 100644
--- a/src/engine/title_screen.c
+++ b/src/engine/title_screen.c
@@ -2,6 +2,8 @@
 #include "ppu/types.h"
 #include "ppu/consts.h"
 
+#include "static/tilemap.h"
+
 
 #include "engine/draw_screen.h"
 #include "engine/entity.h"
@@ -12,7 +14,7 @@ void hh_init_title_screen(){
 
 	//send data
 	uint8_t idx = 0;
-	const uint8_t tilemap_offset = 59;
+	const uint8_t tilemap_offset = HH_TM_TITLE_SCREEN_ICON_OFFSET;
 	int tiles_h = HH_PPU_BG_CANVAS_TILES_H;
 	int vp_h = HH_PPU_SCREEN_WIDTH/HH_PPU_SPRITE_WIDTH; //screen_h in tiles
 	int vert_offset = tiles_h*3;
@@ -45,7 +47,7 @@ void hh_init_title_screen(){
 	}
 	
 
-	const uint8_t letters_offset = 66;
+	const uint8_t letters_offset = HH_TM_TITLE_SCREEN_LETTERES_LARGE_OFFSET;
 	const int _size_hooded = 7, _size_v = 2;
 
 	// char* hh = "hooded";
diff --git a/src/engine/types.h b/src/engine/types.h
index 00b381b..8040e46 100644
--- a/src/engine/types.h
+++ b/src/engine/types.h
@@ -4,6 +4,9 @@
 
 typedef uint8_t hh_ppu_fg_idx;
 // typedef uint16_t hh_bg_idx;
+typedef enum {
+	slime, jumping_slime, terror_owl,
+}hh_e_all_objects_game_type;
 
 typedef enum {
 	fire, ice, poison
@@ -31,6 +34,7 @@ typedef struct {
 	vec2 pos, vel, size;
 	bool is_grounded;
 	bool is_hit;
+	hh_e_all_objects_game_type object_type;
 	uint8_t radius;
 	int8_t hp;
 	int8_t speed;