Merge pull request #27 from Ewpratten/shop2

Merge shop code with master, while doing a bunch of UI updates

assets/tileEditor/index.html

@@ -0,0 +1,8 @@
+<style>
+    html {
+        background-color: #1e1e1e;
+    }
+</style>
+<canvas id="game" width="1080" height="720"></canvas>
+<script src="game.js"></script>
+<script src="main.js"></script>

assets/tileEditor/main.js

@@ -0,0 +1,314 @@
+images = ["", "tileset.png"];
+
+var map = [];
+var boolMap = [];
+
+// 0 1 2 3
+// 4 5 6 7
+// 8 9 1011
+// 12131415
+
+// up right down left
+var types = [
+    [0, 0, 0, 0, 15],
+    [0, 0, 0, 1, 14],
+    [0, 0, 1, 0, 3],
+    [0, 0, 1, 1, 2],
+    [0, 1, 0, 0, 12],
+    [0, 1, 0, 1, 13],
+    [0, 1, 1, 0, 0],
+    [0, 1, 1, 1, 1],
+    [1, 0, 0, 0, 11],
+    [1, 0, 0, 1, 10],
+    [1, 0, 1, 0, 7],
+    [1, 0, 1, 1, 6],
+    [1, 1, 0, 0, 8],
+    [1, 1, 0, 1, 9],
+    [1, 1, 1, 0, 4],
+    [1, 1, 1, 1, 5]
+];
+
+var brushSize = 1;
+
+var collisions = [];
+
+for (var y = 0; y < 216; y++) {
+    var arr = [];
+    var arr2 = [];
+    for (var x = 0; x < 72; x++) {
+        arr.push(0);
+        arr2.push(false);
+    }
+    map.push(arr);
+    boolMap.push(arr2);
+}
+
+setup(60);
+
+function onAssetsLoaded() {
+    for (var y = 0; y < 4; y++) {
+        for (var x = 0; x < 4; x++) {
+            var newCanv = document.createElement("canvas");
+            newCanv.width = 10;
+            newCanv.height = 10;
+            var newCtx = newCanv.getContext("2d");
+            newCtx.drawImage(sprites.tileset.spr, x * 10, y * 10, 10, 10, 0, 0, 10, 10);
+            sprites[x + y * 4] = { spr: newCanv, drawLimitSize: 10 };
+        }
+    }
+    parseMap();
+}
+
+function update() {}
+
+function input() {
+    if (keyDown[k.w]) {
+        moveCamera(0, -5);
+    }
+    if (keyDown[k.s]) {
+        moveCamera(0, 5);
+    }
+    if (keyDown[k.a]) {
+        moveCamera(-5, 0);
+    }
+    if (keyDown[k.d]) {
+        moveCamera(5, 0);
+    }
+
+    if (keyPress[k.q]) {
+        if (brushSize > 1) {
+            brushSize--;
+        }
+    }
+    if (keyPress[k.e]) {
+        brushSize++;
+    }
+
+    camera.zoom += scroll;
+    if (camera.zoom < 1) {
+        camera.zoom = 1;
+    }
+
+    if (keyPress[k.ENTER]) {
+        renderMap();
+    }
+
+    if (keyPress[k.SPACE]) {
+        collisions = makeOptimizedCollision();
+    }
+
+    var x = Math.floor(mousePosition().x / 10);
+    var y = Math.floor(mousePosition().y / 10);
+    x = x < 0 ? 0 : x;
+    y = y < 0 ? 0 : y;
+    x = x > map[0].length - 1 ? map[0].length - 1 : x;
+    y = y > map.length - 1 ? map.length - 1 : y;
+    if (mouseDown[0]) {
+        for (var yy = -brushSize / 2; yy < brushSize / 2; yy++) {
+            for (var xx = -brushSize / 2; xx < brushSize / 2; xx++) {
+                var posX = ~~(1 + xx + x);
+                var posY = ~~(1 + yy + y);
+                if (posX > -1 && posY > -1 && posY < map.length && posX < map[0].length) {
+                    boolMap[posY][posX] = true;
+                }
+            }
+        }
+    }
+    if (mouseDown[2]) {
+        for (var yy = -brushSize / 2; yy < brushSize / 2; yy++) {
+            for (var xx = -brushSize / 2; xx < brushSize / 2; xx++) {
+                var posX = ~~(1 + xx + x);
+                var posY = ~~(1 + yy + y);
+                if (posX > -1 && posY > -1 && posY < map.length && posX < map[0].length) {
+                    boolMap[posY][posX] = false;
+                }
+            }
+        }
+    }
+}
+
+function draw() {
+    parseMap();
+    var w = map[0].length * 10;
+    var h = map.length * 10;
+    rect(w / 2, h / 2, w, h, "blue");
+    for (var y = 0; y < map.length; y++) {
+        for (var x = 0; x < map[0].length; x++) {
+            if (map[y][x] !== -1) {
+                img(sprites[map[y][x]], x * 10 + 5, y * 10 + 5);
+            }
+        }
+    }
+
+    for(var i=0;i<collisions.length;i++) {
+        rectOut(collisions[i].x,collisions[i].y,collisions[i].width,collisions[i].height,"#ff0000");
+    }
+}
+
+function renderMap() {
+    var renderCvs = document.createElement("canvas");
+    renderCvs.width = map[0].length * 10;
+    renderCvs.height = map.length * 10;
+    var renderCtx = renderCvs.getContext("2d");
+    camera.x = 0;
+    camera.y = 0;
+    drawMode = 0;
+    absDraw = true;
+    curCtx = renderCtx;
+    for (var y = 0; y < map.length; y++) {
+        for (var x = 0; x < map[0].length; x++) {
+            if (map[y][x] !== -1) {
+                img(sprites[map[y][x]], x * 10 + 5, y * 10 + 5);
+
+                if (map[y][x] === 5) {
+                    var closest = 6;
+                    for (var y2 = -4; y2 < 5; y2++) {
+                        for (var x2 = -4; x2 < 5; x2++) {
+                            if(y2 === 0 && x2 === 0) {
+                                continue;
+                            }
+                            var posX = x + x2;
+                            var posY = y + y2;
+                            if (posX > -1 && posY > -1 && posY < map.length && posX < map[0].length) {
+                                if (boolMap[posY][posX] === false) {
+                                    var distance = dist({ x: x, y: y }, { x: posX, y: posY });
+                                    if (distance < closest) {
+                                        closest = distance;
+                                    }
+                                }
+                            }
+                        }
+                    }
+                    if (closest > 1) {
+                        rect(x * 10 + 5, y * 10 + 5, 10, 10, `#000000${Math.round(map_range(closest, 1, 6, 50, 255)).toString(16)}`);
+                    }
+                }
+            }
+        }
+    }
+    document.body.appendChild(renderCvs);
+
+    collisions = makeOptimizedCollision();
+
+    var txt = document.createElement("textarea");
+    txt.innerText = JSON.stringify(collisions);
+    document.body.appendChild(txt);
+}
+
+function map_range(value, low1, high1, low2, high2) {
+    return low2 + ((high2 - low2) * (value - low1)) / (high1 - low1);
+}
+
+function parseMap() {
+    for (var y = 0; y < map.length; y++) {
+        for (var x = 0; x < map[0].length; x++) {
+            if (boolMap[y][x] === false) {
+                map[y][x] = -1;
+                continue;
+            }
+            var t = 0,
+                b = 0,
+                l = 0,
+                r = 0;
+            if (y === 0) {
+                t = 1;
+            } else {
+                t = boolMap[y - 1][x] ? 1 : 0;
+            }
+            if (x === 0) {
+                l = 1;
+            } else {
+                l = boolMap[y][x - 1] ? 1 : 0;
+            }
+            if (y === map.length - 1) {
+                b = 1;
+            } else {
+                b = boolMap[y + 1][x] ? 1 : 0;
+            }
+            if (x === map[0].length - 1) {
+                r = 1;
+            } else {
+                r = boolMap[y][x + 1] ? 1 : 0;
+            }
+            for (var i = 0; i < 16; i++) {
+                if (types[i][0] === t && types[i][1] === r && types[i][2] === b && types[i][3] === l) {
+                    map[y][x] = types[i][4];
+                    break;
+                }
+            }
+        }
+    }
+}
+
+
+function makeOptimizedCollision() {
+    var tileCount = 0;
+    var worldW = map[0].length;
+    var worldH = map.length;
+    cols = [];
+
+    // 2d array of booleans for if a tile has gotten a collision made for it
+    var hasCollision = [];
+
+    // fill arrays
+    for (var y = 0; y < worldH; y++) {
+        var hasCollisionRow = [];
+        for (var x = 0; x < worldW; x++) {
+            hasCollisionRow.push(false);
+        }
+        hasCollision.push(hasCollisionRow);
+    }
+
+    // try to make large rectangles that cover multiple walls to make collision more efficient
+
+    for (var y = 0; y < worldH; y++) {
+        for (var x = 0; x < worldW; x++) {
+            if (!hasCollision[y][x] && boolMap[y][x]) {
+                // find right limit
+                var xPos = x;
+                while (xPos < worldW && boolMap[y][xPos]) {
+                    xPos++;
+                }
+                xPos--;
+
+                // find bottom limit
+                var yPos = y;
+                var fullRow = true;
+                // go down row by row
+                while (yPos < worldH-1 && boolMap[yPos][xPos] && fullRow) {
+                    yPos++;
+                    // go through the whole row, make sure it is full
+                    var rowX = xPos;
+                    while (rowX > -1 && boolMap[yPos][rowX]) {
+                        rowX--;
+                    }
+                    // if the row is not full, stop
+                    if (rowX + 1 !== x) {
+                        fullRow = false;
+                        yPos--;
+                    }
+                }
+
+                // track what tiles have gotten collision
+                for (var y2 = y; y2 < yPos + 1; y2++) {
+                    for (var x2 = x; x2 < xPos + 1; x2++) {
+                        hasCollision[y2][x2] = true;
+                        tileCount++;
+                    }
+                }
+
+                // find collider dimensions
+                var colX = (x + xPos + 1) / 2;
+                var colY = (y + yPos + 1) / 2;
+                var colW = xPos - x + 1;
+                var colH = yPos - y + 1;
+
+                // add collider
+                cols.push({ x: colX * 10, y: colY * 10, width: colW * 10, height: colH * 10 });
+            }
+        }
+    }
+
+    console.log(`tiles: ${tileCount}, boxes: ${cols.length}`)
+    return cols;
+}

src/gamecore.rs

@@ -25,6 +25,7 @@ pub enum GameState {
     GameQuit,
     InGame,
     GameEnd,
+    InShop
 }
 
 impl fmt::Display for GameState {
@@ -76,6 +77,22 @@ impl GameProgress {
 
         Ok(())
     }
+
+    pub fn update(&mut self, new_progress: &GameProgress) {
+
+        // Bring in new data
+        self.coins = new_progress.coins;
+        self.inventory = new_progress.inventory.clone();
+        self.max_depth = self.max_depth.max(new_progress.max_depth);
+        // self.fastest_time = self.fastest_time.min(new_progress.fastest_time);
+
+        // Write to file
+        let result = self.to_file("./assets/savestate.json".to_string());
+        if result.is_err() {
+            println!("Could not save game state. Holding in RAM");
+        }
+
+    }
 }
 
 /// This structure contains the entire game state, and should be passed around to various logic functions.

src/items.rs

@@ -1,9 +1,20 @@
+use raylib::texture::Texture2D;
 use serde::{Deserialize, Serialize};
 
+pub trait ItemBase {
+    fn get_cost(&self) -> u32;
+    fn get_level(&self) -> u8;
+    fn get_name(&self) -> String;
+    fn get_description(&self) -> String;
+    fn get_texture(&self) -> &Texture2D;
+}
+
 #[derive(Debug, PartialEq, Clone, Serialize, Deserialize)]
 pub struct StunGun {
     pub range: f32,
     pub duration: f64,
+    pub level: u8,
+    cost: u32,
 }
 
 impl StunGun {
@@ -11,46 +22,201 @@ impl StunGun {
         Self {
             range: 30.0,
             duration: 0.75,
+            level: 1,
+            cost: 30,
         }
     }
     pub fn lvl2() -> Self {
         Self {
             range: 60.0,
             duration: 1.25,
+            level: 2,
+            cost: 40,
+        }
+    }
+    pub fn lvl3() -> Self {
+        Self {
+            range: 80.0,
+            duration: 1.0,
+            level: 3,
+            cost: 50,
         }
     }
 }
 
+impl ItemBase for StunGun {
+    fn get_cost(&self) -> u32 {
+        self.cost
+    }
+
+    fn get_name(&self) -> String {
+        return "Stun Gun".to_string();
+    }
+
+    fn get_description(&self) -> String {
+        return "Stun your enemies! Just don't point it at yourself.".to_string();
+    }
+
+    fn get_texture(&self) -> &Texture2D {
+        todo!()
+    }
+    fn get_level(&self) -> u8 {
+        self.level
+    }
+}
+
 #[derive(Debug, PartialEq, Clone, Serialize, Deserialize)]
-pub struct AirBag;
+pub struct AirBag {
+    extra_oxygen: u32,
+    pub level: u8,
+    cost: u32,
+}
+
+impl AirBag {
+    pub fn lvl1() -> Self {
+        Self {
+            extra_oxygen: 15,
+            level: 1,
+            cost: 30,
+        }
+    }
+    pub fn lvl2() -> Self {
+        Self {
+            extra_oxygen: 30,
+            level: 2,
+            cost: 40,
+        }
+    }
+    pub fn lvl3() -> Self {
+        Self {
+            extra_oxygen: 45,
+            level: 3,
+            cost: 50,
+        }
+    }
+}
+
+impl ItemBase for AirBag {
+    fn get_cost(&self) -> u32 {
+        self.cost
+    }
+
+    fn get_name(&self) -> String {
+        return "Bag of Air".to_string();
+    }
+
+    fn get_description(&self) -> String {
+        return "Its.. a bag. Filled with air. Duh".to_string();
+    }
+
+    fn get_texture(&self) -> &Texture2D {
+        todo!()
+    }
+    fn get_level(&self) -> u8 {
+        self.level
+    }
+}
 
 #[derive(Debug, PartialEq, Clone, Serialize, Deserialize)]
 pub struct Flashlight {
-    pub radius: f32
+    pub radius: f32,
+    pub level: u8,
+    cost: u32,
 }
 
 impl Flashlight {
     pub fn lvl1() -> Self {
         Self {
-            radius: 0.25
+            radius: 0.25,
+            level: 1,
+            cost: 40,
         }
     }
+    pub fn lvl2() -> Self {
+        Self {
+            radius: 0.5,
+            level: 2,
+            cost: 50,
+        }
+    }
+    pub fn lvl3() -> Self {
+        Self {
+            radius: 1.0,
+            level: 3,
+            cost: 60,
+        }
+    }
+}
+
+impl ItemBase for Flashlight {
+    fn get_cost(&self) -> u32 {
+        self.cost
+    }
+
+    fn get_name(&self) -> String {
+        return "Flashlight".to_string();
+    }
+
+    fn get_description(&self) -> String {
+        return "See better for longer".to_string();
+    }
+
+    fn get_texture(&self) -> &Texture2D {
+        todo!()
+    }
+    fn get_level(&self) -> u8 {
+        self.level
+    }
 }
 
 #[derive(Debug, PartialEq, Clone, Serialize, Deserialize)]
 pub struct Flippers {
     pub speed_increase: f32,
+    pub level: u8,
+    cost: u32,
 }
 
 impl Flippers {
     pub fn lvl1() -> Self {
         Self {
-            speed_increase: 1.2
+            speed_increase: 1.2,
+            level: 1,
+            cost: 30,
         }
     }
     pub fn lvl2() -> Self {
         Self {
-            speed_increase: 1.5
+            speed_increase: 1.5,
+            level: 2,
+            cost: 40,
+        }
+    }
+    pub fn lvl3() -> Self {
+        Self {
+            speed_increase: 1.8,
+            level: 3,
+            cost: 50,
         }
     }
 }
+
+impl ItemBase for Flippers {
+    fn get_cost(&self) -> u32 {
+        self.cost
+    }
+
+    fn get_name(&self) -> String {
+        return "Flippers".to_string();
+    }
+
+    fn get_description(&self) -> String {
+        return "Swim faster, and look stupid at the same time!".to_string();
+    }
+
+    fn get_texture(&self) -> &Texture2D {
+        todo!()
+    }
+    fn get_level(&self) -> u8 {
+        self.level
+    }
+}

src/lib/utils/button.rs

@@ -0,0 +1,71 @@
+use raylib::prelude::*;
+
+pub struct OnScreenButton {
+    bounds: Rectangle,
+    text: String,
+    background: Color,
+    border: Color,
+    border_hover: Color,
+    font_px: i32,
+    draw_border: bool,
+}
+
+impl OnScreenButton {
+    pub fn new(
+        text: String,
+        bounds: Rectangle,
+        background: Color,
+        border: Color,
+        border_hover: Color,
+        font_px: i32,
+        draw_border: bool,
+    ) -> Self {
+        Self {
+            bounds,
+            text,
+            background,
+            border,
+            border_hover,
+            font_px,
+            draw_border,
+        }
+    }
+
+    pub fn is_hovered(&self, draw_handle: &RaylibDrawHandle) -> bool {
+        return self
+            .bounds
+            .check_collision_point_rec(draw_handle.get_mouse_position());
+    }
+
+    pub fn render(&self, draw_handle: &mut RaylibDrawHandle) {
+        // Draw the button background
+        draw_handle.draw_rectangle_rec(self.bounds, self.background);
+
+        // Check mouse info
+        let is_being_hovered = self.is_hovered(draw_handle);
+
+        // Render the border
+        if self.draw_border {
+            draw_handle.draw_rectangle_lines_ex(
+                self.bounds,
+                3,
+                match is_being_hovered {
+                    true => self.border_hover,
+                    false => self.border,
+                },
+            );
+        }
+
+        // Render the text
+        draw_handle.draw_text(
+            &self.text,
+            self.bounds.x as i32 + 10,
+            self.bounds.y as i32 + ((self.bounds.height as i32 - self.font_px) / 2),
+            self.font_px,
+            match is_being_hovered && !self.draw_border {
+                true => self.border_hover,
+                false => self.border,
+            },
+        )
+    }
+}

src/lib/utils/mod.rs

@@ -1,5 +1,6 @@
 pub mod profiler;
 pub mod triangles;
+pub mod button;
 
 pub fn calculate_linear_slide(playthrough_percent: f64) -> f64 {
     if playthrough_percent < 0.25 {

src/logic/mainmenu.rs

@@ -1,6 +1,10 @@
 use raylib::prelude::*;
 
-use crate::{gamecore::{GameCore, GameState}, lib::wrappers::audio::player::AudioPlayer, pallette::WATER_DARK};
+use crate::{
+    gamecore::{GameCore, GameState},
+    lib::wrappers::audio::player::AudioPlayer,
+    pallette::WATER_DARK,
+};
 
 use super::screen::Screen;
 
@@ -40,8 +44,10 @@ impl Screen for MainMenuScreen {
         let mouse_position = draw_handle.get_mouse_position();
         let hovering_play_button = mouse_position.y > (win_width as f32 / 4.0)
             && mouse_position.y < (win_width as f32 / 4.0) + 60.0;
-        let hovering_quit_button = mouse_position.y > (win_width as f32 / 4.0) + 100.0
+        let hovering_shop_button = mouse_position.y > (win_width as f32 / 4.0) + 100.0
             && mouse_position.y < (win_width as f32 / 4.0) + 160.0;
+        let hovering_quit_button = mouse_position.y > (win_width as f32 / 4.0) + 200.0
+            && mouse_position.y < (win_width as f32 / 4.0) + 260.0;
 
         // Play and quit
         draw_handle.draw_text(
@@ -54,10 +60,20 @@ impl Screen for MainMenuScreen {
                 false => Color::BLACK,
             },
         );
+        draw_handle.draw_text(
+            "Shop",
+            (win_height / 2) + 120,
+            (win_width / 4) + 100,
+            60,
+            match hovering_shop_button {
+                true => Color::GREEN,
+                false => Color::BLACK,
+            },
+        );
         draw_handle.draw_text(
             "Quit",
             (win_height / 2) + 130,
-            (win_width / 4) + 100,
+            (win_width / 4) + 200,
             60,
             match hovering_quit_button {
                 true => Color::GREEN,
@@ -71,8 +87,14 @@ impl Screen for MainMenuScreen {
         // Check clicks
         if mouse_clicked {
             if hovering_play_button {
+                // Reset the world
+                game_core.world.reset(&mut game_core.player);
+
+                // Start playing
                 return Some(GameState::InGame);
-            } else if hovering_quit_button {
+            } else if hovering_shop_button {
+                return Some(GameState::InShop);
+            }else if hovering_quit_button {
                 return Some(GameState::GameQuit);
             }
         }

src/logic/mod.rs

@@ -4,3 +4,4 @@ pub mod mainmenu;
 pub mod pausemenu;
 pub mod ingame;
 pub mod gameend;
+pub mod shop;

src/logic/pausemenu.rs

@@ -2,7 +2,7 @@ use raylib::prelude::*;
 
 use crate::{
     gamecore::{GameCore, GameState},
-    lib::wrappers::audio::player::AudioPlayer,
+    lib::{utils::button::OnScreenButton, wrappers::audio::player::AudioPlayer},
 };
 
 use super::screen::Screen;
@@ -127,7 +127,8 @@ impl Screen for PauseMenuScreen {
             Color::BLACK,
         );
 
-        // Close and quit buttons
+        // Bottom buttons
+
         let bottom_left_button_dimensions = Rectangle {
             x: (win_width as f32 / 2.0) - (SCREEN_PANEL_SIZE.x / 2.0) + 5.0,
             y: (win_height as f32 / 2.0) + (SCREEN_PANEL_SIZE.y / 2.0) - 50.0,
@@ -141,49 +142,34 @@ impl Screen for PauseMenuScreen {
             height: bottom_left_button_dimensions.height,
         };
 
-        // Check if the mouse is over either button
+        let menu_button = OnScreenButton::new(
-        let mouse_over_bottom_left_button =
+            "Menu".to_string(),
-            bottom_left_button_dimensions.check_collision_point_rec(mouse_position);
-        let mouse_over_bottom_right_button =
-            bottom_right_button_dimensions.check_collision_point_rec(mouse_position);
-
-        // Render buttons
-        draw_handle.draw_rectangle_lines_ex(
             bottom_left_button_dimensions,
-            3,
+            Color::WHITE,
-            match mouse_over_bottom_left_button {
-                true => Color::GRAY,
-                false => Color::BLACK,
-            },
-        );
-        draw_handle.draw_text(
-            "Quit",
-            bottom_left_button_dimensions.x as i32 + 15,
-            bottom_left_button_dimensions.y as i32 + 5,
-            30,
             Color::BLACK,
+            Color::GRAY,
+            30,
+            true,
         );
-        draw_handle.draw_rectangle_lines_ex(
+        let close_button = OnScreenButton::new(
+            "Close".to_string(),
             bottom_right_button_dimensions,
-            3,
+            Color::WHITE,
-            match mouse_over_bottom_right_button {
-                true => Color::GRAY,
-                false => Color::BLACK,
-            },
-        );
-        draw_handle.draw_text(
-            "Close",
-            bottom_right_button_dimensions.x as i32 + 15,
-            bottom_right_button_dimensions.y as i32 + 5,
-            30,
             Color::BLACK,
+            Color::GRAY,
+            30,
+            true,
         );
 
+        // Render both
+        menu_button.render(draw_handle);
+        close_button.render(draw_handle);
+
         // Handle click actions on the buttons
         if draw_handle.is_mouse_button_pressed(MouseButton::MOUSE_LEFT_BUTTON) {
-            if mouse_over_bottom_left_button {
+            if menu_button.is_hovered(draw_handle) {
-                return Some(GameState::GameQuit);
+                return Some(GameState::MainMenu);
-            } else if mouse_over_bottom_right_button {
+            } else if close_button.is_hovered(draw_handle) {
                 return Some(game_core.last_state);
             }
         }

src/logic/shop/item.rs

@@ -0,0 +1,68 @@
+use std::marker::PhantomData;
+
+use raylib::prelude::*;
+
+use crate::{items::ItemBase, player::Player, world::World};
+
+use super::itemui::ShopItemUi;
+
+pub struct ShopItemWrapper<T: ItemBase + Clone> {
+    bounds: Rectangle,
+    ui: ShopItemUi,
+    item: T,
+}
+
+impl<T: ItemBase + Clone> ShopItemWrapper<T> {
+    pub fn new(
+        item: T,
+        from_inventory: &Option<T>,
+        first_item_bounds: Rectangle,
+        index: u8
+    ) -> Self {
+        // Build new bounds for the UI row
+        let new_bounds = Rectangle {
+            x: first_item_bounds.x,
+            y: first_item_bounds.y + ((first_item_bounds.height + 5.0) * index as f32),
+            width: first_item_bounds.width,
+            height: first_item_bounds.height,
+        };
+
+        Self {
+            bounds: new_bounds,
+            ui: ShopItemUi::new(
+                item.get_name(),
+                match from_inventory {
+                    Some(x) => x.get_level(),
+                    None => 0,
+                },
+                3,
+                item.get_cost(),
+            ),
+            item,
+        }
+    }
+
+    pub fn get_item(&self) -> &T {
+        &self.item
+    }
+
+    pub fn can_player_afford(&self, player: &Player) -> bool {
+        return player.coins >= self.item.get_cost();
+    }
+
+    pub fn purchase(&self, player: &mut Player) -> T {
+        // Take the currency from the player
+        player.coins -= self.item.get_cost();
+
+        // Return a clone of the item
+        return self.item.clone();
+    }
+
+    pub fn user_clicked_buy(&self, draw_handle: &mut RaylibDrawHandle) -> bool {
+        return self.ui.buy_button_hovered && draw_handle.is_mouse_button_pressed(MouseButton::MOUSE_LEFT_BUTTON);
+    }
+
+    pub fn render(&mut self, draw_handle: &mut RaylibDrawHandle, player: &Player) {
+        self.ui.render(draw_handle, self.bounds, self.can_player_afford(player));
+    }
+}

src/logic/shop/itemui.rs

@@ -0,0 +1,63 @@
+use crate::lib::utils::button::OnScreenButton;
+use raylib::prelude::*;
+
+pub struct ShopItemUi {
+    name: String,
+    current_level: u8,
+    max_level: u8,
+    pub cost: u32,
+    pub buy_button_hovered: bool,
+}
+
+impl ShopItemUi {
+    pub fn new(name: String, current_level: u8, max_level: u8, cost: u32) -> Self {
+        Self {
+            name,
+            current_level,
+            max_level,
+            cost,
+            buy_button_hovered: false,
+        }
+    }
+
+    pub fn render(
+        &mut self,
+        draw_handle: &mut RaylibDrawHandle,
+        bounds: Rectangle,
+        can_be_bought: bool,
+    ) {
+        // Render the background box
+        draw_handle.draw_rectangle_rec(bounds, Color::WHITE);
+        draw_handle.draw_rectangle_lines_ex(bounds, 3, Color::BLACK);
+
+        // Render the name
+        draw_handle.draw_text(
+            &format!("{}: {}/{}", self.name, self.current_level, self.max_level),
+            bounds.x as i32 + 10,
+            bounds.y as i32 + ((bounds.height as i32 - 20) / 2),
+            20,
+            Color::BLACK,
+        );
+
+        // Render the buy button
+        let buy_button = OnScreenButton::new(
+            format!("Buy - {}f", self.cost),
+            Rectangle {
+                x: bounds.x + bounds.width - 150.0,
+                y: bounds.y + 5.0,
+                width: 145.0,
+                height: bounds.height - 10.0,
+            },
+            match can_be_bought {
+                true => Color::WHITE,
+                false => Color::GRAY,
+            },
+            Color::BLACK,
+            Color::GRAY,
+            20,
+            true,
+        );
+        buy_button.render(draw_handle);
+        self.buy_button_hovered = buy_button.is_hovered(draw_handle);
+    }
+}

src/logic/shop/mainui.rs

@@ -0,0 +1,187 @@
+use raylib::prelude::*;
+
+use crate::{gamecore::{GameCore, GameState}, items::{AirBag, Flashlight, Flippers, ItemBase, StunGun}, lib::{utils::button::OnScreenButton, wrappers::audio::player::AudioPlayer}};
+
+use super::{item::ShopItemWrapper, itemui::ShopItemUi};
+
+pub fn render_shop(
+    draw_handle: &mut RaylibDrawHandle,
+    _thread: &RaylibThread,
+    audio_system: &mut AudioPlayer,
+    game_core: &mut GameCore,
+    bounds: Rectangle,
+) -> Option<GameState> {
+    // Render background
+    draw_handle.draw_rectangle_rec(bounds, Color::WHITE);
+    draw_handle.draw_rectangle_lines_ex(bounds, 3, Color::BLACK);
+
+    // Title
+    draw_handle.draw_text(
+        "SHOP",
+        bounds.x as i32 + (bounds.width / 2.0) as i32 - 50,
+        bounds.y as i32 + 20,
+        40,
+        Color::BLACK,
+    );
+
+    // Bounds for use in item row sizing
+    let first_bounds = Rectangle {
+        x: bounds.x + 5.0,
+        y: bounds.y + 100.0,
+        width: bounds.width - 10.0,
+        height: 50.0,
+    };
+
+    // Create items
+    let mut stun_gun_buy_ui = ShopItemWrapper::new(
+        match &game_core.player.inventory.stun_gun {
+            Some(x) => match x.get_level() {
+                1 => StunGun::lvl2(),
+                _ => StunGun::lvl3(),
+            },
+            None => StunGun::lvl1(),
+        },
+        &game_core.player.inventory.stun_gun,
+        first_bounds,
+        0,
+    );
+    let mut air_bag_buy_ui = ShopItemWrapper::new(
+        match &game_core.player.inventory.air_bag {
+            Some(x) => match x.get_level() {
+                1 => AirBag::lvl2(),
+                _ => AirBag::lvl3(),
+            },
+            None => AirBag::lvl1(),
+        },
+        &game_core.player.inventory.air_bag,
+        first_bounds,
+        1,
+    );
+    let mut flashlight_buy_ui = ShopItemWrapper::new(
+        match &game_core.player.inventory.flashlight {
+            Some(x) => match x.get_level() {
+                1 => Flashlight::lvl2(),
+                _ => Flashlight::lvl3(),
+            },
+            None => Flashlight::lvl1(),
+        },
+        &game_core.player.inventory.flashlight,
+        first_bounds,
+        2,
+    );
+    let mut flippers_buy_ui = ShopItemWrapper::new(
+        match &game_core.player.inventory.flippers {
+            Some(x) => match x.get_level() {
+                1 => Flippers::lvl2(),
+                _ => Flippers::lvl3(),
+            },
+            None => Flippers::lvl1(),
+        },
+        &game_core.player.inventory.flippers,
+        first_bounds,
+        3,
+    );
+
+    // Render items
+    stun_gun_buy_ui.render(draw_handle, &game_core.player);
+    air_bag_buy_ui.render(draw_handle, &game_core.player);
+    flashlight_buy_ui.render(draw_handle, &game_core.player);
+    flippers_buy_ui.render(draw_handle, &game_core.player);
+
+    // Handle buying items
+    if stun_gun_buy_ui.can_player_afford(&game_core.player) && stun_gun_buy_ui.user_clicked_buy(draw_handle) {
+        let item = stun_gun_buy_ui.purchase(&mut game_core.player);
+        game_core.player.inventory.stun_gun = Some(item);
+    }
+    if air_bag_buy_ui.can_player_afford(&game_core.player) && air_bag_buy_ui.user_clicked_buy(draw_handle) {
+        let item = air_bag_buy_ui.purchase(&mut game_core.player);
+        game_core.player.inventory.air_bag = Some(item);
+    }
+    if flashlight_buy_ui.can_player_afford(&game_core.player) && flashlight_buy_ui.user_clicked_buy(draw_handle) {
+        let item = flashlight_buy_ui.purchase(&mut game_core.player);
+        game_core.player.inventory.flashlight = Some(item);
+    }
+    if flippers_buy_ui.can_player_afford(&game_core.player) && flippers_buy_ui.user_clicked_buy(draw_handle) {
+        let item = flippers_buy_ui.purchase(&mut game_core.player);
+        game_core.player.inventory.flippers = Some(item);
+    }
+
+
+    // Handle exit buttons
+    let bottom_left_button_dimensions = Rectangle {
+        x: bounds.x + 5.0,
+        y: bounds.y + bounds.height - 50.0,
+        width: (bounds.width / 2.0) - 15.0,
+        height: 40.0,
+    };
+    let bottom_right_button_dimensions = Rectangle {
+        x: (bounds.x + bottom_left_button_dimensions.width ) + 15.0,
+        y: bottom_left_button_dimensions.y,
+        width: bottom_left_button_dimensions.width,
+        height: bottom_left_button_dimensions.height,
+    };
+
+    let menu_button = OnScreenButton::new(
+        "Menu".to_string(),
+        bottom_left_button_dimensions,
+        Color::WHITE,
+        Color::BLACK,
+        Color::GRAY,
+        30,
+        true,
+    );
+    let play_button = OnScreenButton::new(
+        "Play".to_string(),
+        bottom_right_button_dimensions,
+        Color::WHITE,
+        Color::BLACK,
+        Color::GRAY,
+        30,
+        true,
+    );
+
+    // Render both
+    menu_button.render(draw_handle);
+    play_button.render(draw_handle);
+
+    // Handle click actions on the buttons
+    if draw_handle.is_mouse_button_pressed(MouseButton::MOUSE_LEFT_BUTTON) {
+
+        // Handle saving core state
+        if menu_button.is_hovered(draw_handle)  || play_button.is_hovered(draw_handle) {
+            let new_progress = game_core.player.create_statistics(game_core, draw_handle.get_time());
+            game_core.progress.update(&new_progress);
+        }
+
+        if menu_button.is_hovered(draw_handle) {
+            return Some(GameState::MainMenu);
+        } else if play_button.is_hovered(draw_handle) {
+            // Reset the world
+            game_core.world.reset(&mut game_core.player);
+
+            // Start playing
+            return Some(GameState::InGame);
+        }
+    }
+
+    return None;
+}
+
+pub fn render_stats(
+    draw_handle: &mut RaylibDrawHandle,
+    game_core: &mut GameCore,
+    bounds: Rectangle,
+) {
+    // Render background
+    draw_handle.draw_rectangle_rec(bounds, Color::WHITE);
+    draw_handle.draw_rectangle_lines_ex(bounds, 3, Color::BLACK);
+
+    // Coins
+    draw_handle.draw_text(
+        &format!("Fish: {}", game_core.player.coins.min(99)),
+        bounds.x as i32 + 5,
+        bounds.y as i32 + 5,
+        20,
+        Color::BLACK,
+    );
+}

src/logic/shop/mod.rs

@@ -0,0 +1,239 @@
+mod mainui;
+mod itemui;
+mod item;
+
+use raylib::prelude::*;
+
+use crate::{
+    gamecore::{GameCore, GameState},
+    lib::wrappers::audio::player::AudioPlayer,
+};
+
+use self::mainui::{render_shop, render_stats};
+
+use super::screen::Screen;
+
+const SCREEN_PANEL_SIZE: Vector2 = Vector2 { x: 300.0, y: 380.0 };
+
+#[derive(Debug, Default)]
+pub struct ShopScreen {
+    // shop_items: Vec<Item>,
+}
+
+impl ShopScreen {
+    pub fn new() -> Self {
+        Self {
+            ..Default::default()
+        }
+    }
+
+    // // Creates all the items
+    // pub fn create_items(&mut self, screen_dimension: Vector2) {
+    //     // gets every item.. hacky
+    //     let items = ShopItems::get_inital_items();
+
+    //     // sets sizes any random number is just a number I think looks good
+    //     let screen_width = screen_dimension.x as f32;
+    //     let screen_height = screen_dimension.y as f32;
+
+    //     let box_height = screen_height * 0.15;
+    //     let box_width = screen_width * 0.1;
+
+    //     let start_width = screen_width - (box_width * 4.0) - 40.0;
+    //     let draw_height = screen_height - 20.0 - box_height;
+
+    //     let mut item_vec = Vec::new();
+
+    //     for box_num in 0..4 {
+    //         let x_pose = start_width + box_width * box_num as f32;
+
+    //         // adds an item struct to the item list
+    //         item_vec.push(Item {
+    //             x_pose: ((x_pose + (5 * box_num) as f32) as i32),
+    //             y_pose: (draw_height as i32),
+    //             width: (box_width as i32),
+    //             height: (box_height as i32),
+    //             // Crazy hacky but this gets the data from the enum
+    //             cost: (ShopItems::get_cost(&items.get(box_num).unwrap())),
+    //             level: (ShopItems::get_level(&items.get(box_num).unwrap())),
+    //             name: (ShopItems::get_name(&items.get(box_num).unwrap())),
+    //         });
+    //     }
+
+    //     self.shop_items = item_vec;
+    // }
+}
+
+impl Screen for ShopScreen {
+    fn render(
+        &mut self,
+        draw_handle: &mut RaylibDrawHandle,
+        thread: &RaylibThread,
+        audio_system: &mut AudioPlayer,
+        game_core: &mut GameCore,
+    ) -> Option<GameState> {
+        let mouse_position = draw_handle.get_mouse_position();
+        
+        
+        // Render the background
+        draw_handle.draw_texture(&game_core.resources.shop_background, 0, 0, Color::WHITE);
+
+        // Window dimensions
+        let win_height = draw_handle.get_screen_height();
+        let win_width = draw_handle.get_screen_width();
+
+        // Build a rect for the shop UI to sit inside
+        let shop_ui_bounds = Rectangle {
+            x: win_width as f32 - (win_width as f32 / 2.0),
+            y: 10.0,
+            width: (win_width as f32 / 2.0) - 10.0,
+            height: win_height as f32 - 20.0,
+        };
+        let stats_ui_bounds = Rectangle {
+            x: win_width as f32 - (win_width as f32 / 2.0) - 130.0,
+            y: 10.0,
+            width: 120.0,
+            height: 30.0,
+        };
+
+        // Render the shop UI
+        let next_state =
+            render_shop(draw_handle, thread, audio_system, game_core, shop_ui_bounds);
+
+        // Render the stats UI
+        render_stats(draw_handle, game_core, stats_ui_bounds);
+
+        return next_state;
+    }
+}
+// pub fn render_shop(
+//     draw_handle: &mut RaylibDrawHandle,
+//     game_core: &mut GameCore,
+//     inGameScreen: &mut InGameScreen,
+// ) {
+//     // Pressing F exits from buying
+//     if draw_handle.is_key_pressed(KeyboardKey::KEY_F) {
+//         inGameScreen.current_state = InGameState::SWIMMING;
+//     }
+
+//     let mouse_position = draw_handle.get_mouse_position();
+
+//     draw_handle.draw_text(
+//         &format!("Coins: {}", game_core.player.coins),
+//         15,
+//         15,
+//         30,
+//         Color::WHITE,
+//     );
+
+//     // Draws shop boxes
+//     for mut item in inGameScreen.shop.shop_items.iter_mut() {
+//         // If hovering on square draw full
+//         if mouse_position.x >= item.x_pose as f32
+//             && mouse_position.x <= item.x_pose as f32 + item.width as f32
+//             && mouse_position.y >= item.y_pose as f32
+//             && mouse_position.y <= item.y_pose as f32 + item.width as f32
+//         {
+//             // Draw rect
+//             draw_handle.draw_rectangle(
+//                 item.x_pose,
+//                 item.y_pose,
+//                 item.width,
+//                 item.height,
+//                 Color::BLACK,
+//             );
+
+//             // Preform purchasing functions
+//             if draw_handle.is_mouse_button_pressed(MouseButton::MOUSE_LEFT_BUTTON)
+//                 && game_core.player.coins >= item.cost as u32
+//             {
+//                 // Remove currency
+//                 game_core.world.spend_coins(item.cost.into());
+//                 game_core.player.coins -= item.cost as u32;
+
+//                 // Upgrade item in inventory
+//                 match &(item.name)[..] {
+//                     "Stun Gun" => {
+//                         match item.level {
+//                             0 => game_core.player.inventory.stun_gun = Some(items::StunGun::lvl1()),
+//                             1 => game_core.player.inventory.stun_gun = Some(items::StunGun::lvl2()),
+//                             2 => game_core.player.inventory.stun_gun = Some(items::StunGun::lvl3()),
+//                             _ => (return),
+//                         };
+//                         item.cost += 5;
+//                         item.level += 1;
+//                     }
+//                     "Air Bag" => {
+//                         match item.level {
+//                             0 => {
+//                                 game_core.player.inventory.air_bag = Some(items::AirBag::lvl1());
+//                             }
+//                             1 => {
+//                                 game_core.player.inventory.air_bag = Some(items::AirBag::lvl2());
+//                             }
+//                             2 => {
+//                                 game_core.player.inventory.air_bag = Some(items::AirBag::lvl3());
+//                             }
+//                             _ => (return),
+//                         };
+//                         item.cost += 5;
+//                         item.level += 1;
+//                     }
+//                     "Flash Light" => {
+//                         match item.level {
+//                             0 => {
+//                                 game_core.player.inventory.flashlight =
+//                                     Some(items::Flashlight::lvl1());
+//                             }
+//                             1 => {
+//                                 game_core.player.inventory.flashlight =
+//                                     Some(items::Flashlight::lvl2());
+//                             }
+//                             2 => {
+//                                 game_core.player.inventory.flashlight =
+//                                     Some(items::Flashlight::lvl3());
+//                             }
+//                             _ => (return),
+//                         };
+//                         item.cost += 5;
+//                         item.level += 1;
+//                     }
+//                     "Flippers" => {
+//                         match item.level {
+//                             0 => {
+//                                 game_core.player.inventory.flippers = Some(items::Flippers::lvl1());
+//                             }
+//                             1 => {
+//                                 game_core.player.inventory.flippers = Some(items::Flippers::lvl2());
+//                             }
+//                             2 => {
+//                                 game_core.player.inventory.flippers = Some(items::Flippers::lvl3());
+//                             }
+//                             _ => (return),
+//                         };
+//                         item.cost += 5;
+//                         item.level += 1;
+//                     }
+//                     _ => (return),
+//                 };
+//             }
+//         } else {
+//             // outlines if not hovered
+//             draw_handle.draw_rectangle_lines(
+//                 item.x_pose,
+//                 item.y_pose,
+//                 item.width,
+//                 item.height,
+//                 Color::BLACK,
+//             );
+//         }
+//         // Draw text about object
+//         draw_handle.draw_text(
+//             &format!("{}: ${}", item.name, item.cost),
+//             item.x_pose + 5,
+//             item.y_pose + 5,
+//             12,
+//             Color::BLACK,
+//         );
+//     }
+// }

src/main.rs

@@ -1,19 +1,22 @@
+mod entities;
 mod gamecore;
+mod items;
 mod lib;
 mod logic;
-mod resources;
-mod player;
-mod world;
 mod pallette;
-mod entities;
+mod player;
-mod items;
+mod resources;
+mod world;
 
 use gamecore::{GameCore, GameProgress, GameState};
 use lib::{utils::profiler::GameProfiler, wrappers::audio::player::AudioPlayer};
 use log::info;
-use logic::{gameend::GameEndScreen, ingame::InGameScreen, loadingscreen::LoadingScreen, mainmenu::MainMenuScreen, pausemenu::PauseMenuScreen, screen::Screen};
+use logic::{
+    gameend::GameEndScreen, ingame::InGameScreen, loadingscreen::LoadingScreen,
+    mainmenu::MainMenuScreen, pausemenu::PauseMenuScreen, screen::Screen, shop::ShopScreen,
+};
 use raylib::prelude::*;
-use world::{World, load_world_colliders};
+use world::{load_world_colliders, World};
 
 // Game Launch Configuration
 const DEFAULT_WINDOW_DIMENSIONS: Vector2 = Vector2 {
@@ -32,7 +35,8 @@ fn main() {
         .size(
             DEFAULT_WINDOW_DIMENSIONS.x as i32,
             DEFAULT_WINDOW_DIMENSIONS.y as i32,
-        ).msaa_4x()
+        )
+        .msaa_4x()
         .title(WINDOW_TITLE)
         .build();
     raylib.set_target_fps(MAX_FPS);
@@ -41,14 +45,21 @@ fn main() {
     raylib.set_exit_key(None);
 
     // Load the world
-    let world_colliders = load_world_colliders("./assets/img/map/cave.json".to_string()).expect("Failed to load world colliders");
+    let world_colliders = load_world_colliders("./assets/img/map/cave.json".to_string())
-    let world = World::load_from_json("./assets/worlds/mainworld.json".to_string(), world_colliders).expect("Failed to load main world JSON");
+        .expect("Failed to load world colliders");
+    let world = World::load_from_json(
+        "./assets/worlds/mainworld.json".to_string(),
+        world_colliders,
+    )
+    .expect("Failed to load main world JSON");
 
     // Load the game progress
     let game_progress = GameProgress::try_from_file("./assets/savestate.json".to_string());
 
     // Set up the game's core state
     let mut game_core = GameCore::new(&mut raylib, &raylib_thread, world, game_progress);
+    game_core.player.inventory = game_core.progress.inventory.clone();
+    game_core.player.coins = game_core.progress.coins;
 
     // Set up the game's profiler
     let mut profiler = GameProfiler::new();
@@ -63,6 +74,7 @@ fn main() {
     let mut pause_menu_screen = PauseMenuScreen::new();
     let mut ingame_screen = InGameScreen::new();
     let mut game_end_screen = GameEndScreen::new();
+    let mut shop_screen = ShopScreen::new();
 
     // Main rendering loop
     while !raylib.window_should_close() {
@@ -101,6 +113,12 @@ fn main() {
                 &mut audio_system,
                 &mut game_core,
             ),
+            GameState::InShop => shop_screen.render(
+                &mut draw_handle,
+                &raylib_thread,
+                &mut audio_system,
+                &mut game_core,
+            ),
         };
 
         // If needed, update the global state
@@ -109,6 +127,12 @@ fn main() {
 
             // Handle game quit
             if new_state == GameState::GameQuit {
+                // Save the game state
+                let new_progress = game_core
+                    .player
+                    .create_statistics(&game_core, draw_handle.get_time());
+                game_core.progress.update(&new_progress);
+
                 // For now, just quit
                 // This also throws a SEGFAULT.. yay for unsafe code..
                 info!("User quit game");
@@ -165,6 +189,12 @@ fn main() {
         game_core.last_frame_time = draw_handle.get_time();
     }
 
+    // Save the game state
+    let new_progress = game_core
+        .player
+        .create_statistics(&game_core, raylib.get_time());
+    game_core.progress.update(&new_progress);
+
     // Cleanup
     profiler.stop();
 }

src/player.rs

@@ -24,8 +24,8 @@ pub struct PlayerInventory {
 impl PlayerInventory {
     pub fn new() -> Self {
         Self {
-            stun_gun: Some(StunGun::lvl1()), //TMP
+            // stun_gun: Some(StunGun::lvl1()), //TMP
-            flashlight: Some(Flashlight::lvl1()), //TMP
+            // flashlight: Some(Flashlight::lvl1()), //TMP
             ..Default::default()
         }
     }
@@ -62,6 +62,12 @@ impl Player {
         }
     }
 
+    pub fn reset(&mut self, position: Vector2) {
+        self.position = position;
+        self.breath_percent = 1.0;
+        self.boost_percent = 1.0;
+    }
+
     pub fn collides_with_rec(&self, rectangle: &Rectangle) -> bool {
         // // Build a bounding box of the player by their corners
         // let top_left_corner = self.position - (self.size / 2.0);

src/resources.rs

@@ -26,7 +26,11 @@ pub struct GlobalResources {
     pub jellyfish_animation_attack: FrameAnimationWrapper,
 
     // Darkness layer
-    pub darkness_overlay: Texture2D
+    pub darkness_overlay: Texture2D,
+
+    // Shop & items
+    pub shop_background: Texture2D,
+
 }
 
 impl GlobalResources {
@@ -102,6 +106,10 @@ impl GlobalResources {
                 &thread,
                 &Image::load_image("./assets/img/map/darkness.png")?,
             )?,
+            shop_background: raylib.load_texture_from_image(
+                &thread,
+                &Image::load_image("./assets/img/map/shopHighRes.png")?,
+            )?,
         })
     }
 }

src/world.rs

@@ -5,7 +5,7 @@ use serde::{Deserialize, Serialize};
 use std::io::Read;
 use failure::Error;
 
-use crate::entities::{enemy::{jellyfish::JellyFish, octopus::Octopus}, fish::FishEntity};
+use crate::{entities::{enemy::{jellyfish::JellyFish, octopus::Octopus}, fish::FishEntity}, player::Player};
 
 #[derive(Debug, Serialize, Deserialize, Clone)]
 pub struct World {
@@ -52,16 +52,18 @@ impl World {
         Ok(result)
     }
 
-    pub fn spend_coins(&mut self, count: usize) {
+    // pub fn spend_coins(&mut self, count: usize) {
-        for _ in 0..count {
+    //     for _ in 0..count {
-            self.fish.pop();
+    //         self.fish.pop();
-        }
+    //     }
-    }
+    // }
 
-    pub fn reset(&mut self) {
+    pub fn reset(&mut self, player: &mut Player) {
-        for fish in self.fish.iter_mut() {
+        // Init all fish
-            fish.following_player = false;
+        self.fish = FishEntity::new_from_positions(&self.fish_positions);
-        }
+
+        // Reset the player
+        player.reset(self.player_spawn);
     }
 }