Add scenes

src/lib/object.c

@@ -1,11 +1,20 @@
 #include "object.h"
 #include <debug.h>
 
-#define Object_log(msg) dbg_sprintf(dbgout, "[Object] %s\n", msg)
+#define Object_log(msg) dbg_sprintf(dbgout, "[Object %d] %s\n", self->id, msg)
 
-void Object_update(Object* self){}
+static int id_counter;
+
+void Object_update(Object* self){
+    #ifdef LOG_UPDATE
+    Object_log("Updating object");
+    #endif
+}
 
 void Object_draw(Object* self){
+    #ifdef LOG_DRAW
+    Object_log("Drawing object");
+    #endif
     if(self->scale.x + self->scale.y != 0){
         gfx_ScaledSprite_NoClip(
             self->sprite->data, self->x, self->y,
@@ -31,6 +40,8 @@ void free_Object(Object* self){
 
 Object* new_Object(int x, int y){
     Object* self = (Object*)malloc(sizeof(Object));
+    Object_log("Creating object");
+    self->id = id_counter++;
     self->x = x;
     self->y = y;
     self->scale.x = self->scale.y = 1;

src/lib/object.h

@@ -11,6 +11,7 @@ typedef struct Scale {
 typedef void (*Object_func)(struct Object*);
 typedef int (*Object_func_int)(struct Object*);
 typedef struct Object {
+    int id;
     int x;
     int y;
     Scale scale;
@@ -22,6 +23,7 @@ typedef struct Object {
     Object_func_int width;
 } Object;
 
+void Object_draw(Object* self);
 void free_Object(Object* self);
 Object* new_Object(int x, int y);
 

src/lib/scene.c

@@ -0,0 +1,75 @@
+#include "../main.h"
+#include "scene.h"
+#include <debug.h>
+#include <keypadc.h>
+
+#define Scene_log(msg) dbg_sprintf(dbgout, "[Scene %s] %s\n", self->name, msg)
+
+Scene* current_scene = NULL;
+
+bool Scene_add_object(Scene* self, Object* object){
+    return self->objects->consume(self->objects, object);
+}
+
+bool Scene_add_sprite(Scene* self, Sprite* sprite){
+    return self->sprites->consume(self->sprites, sprite);
+}
+
+void Scene_update(Scene* self){
+    int i;
+    Object* object;
+    Vector* objects = self->objects;
+    #ifdef LOG_UPDATE
+    Scene_log("Updating scene");
+    #endif
+    kb_Scan();
+    for(i = 0; i < objects->count(objects); i++){
+        object = objects->get(objects, i);
+        object->update(object);
+    }
+}
+
+void Scene_draw(Scene* self){
+    int i;
+    Object* object;
+    Vector* objects = self->objects;
+    #ifdef LOG_DRAW
+    Scene_log("Drawing scene");
+    #endif
+    gfx_FillScreen(0);
+    for(i = 0; i < objects->count(objects); i++){
+        object = objects->get(objects, i);
+        object->draw(object);
+    }
+    gfx_BlitBuffer();
+}
+
+void free_Scene(struct Scene* self){
+    Scene_log("Freeing scene");
+    free(self->objects);
+    free(self->sprites);
+    free(self->name);
+    free(self);
+    current_scene = NULL;
+}
+
+Scene* new_Scene(const char* name){
+    Scene* self = (Scene*)malloc(sizeof(Scene));
+    if(current_scene != NULL){
+        free_Scene(current_scene);
+    }
+    current_scene = self;
+    self->name = name;
+    Scene_log("Creating scene");
+    self->objects = new_Vector(0, sizeof(Object), &free_Object);
+    self->sprites = new_Vector(0, sizeof(Sprite), &free_Sprite);
+    self->add_object = &Scene_add_object;
+    self->add_sprite = &Scene_add_sprite;
+    self->update = &Scene_update;
+    self->draw = &Scene_draw;
+    return self;
+}
+
+Scene* current_Scene(){
+    return current_scene;
+}

src/lib/scene.h

@@ -0,0 +1,26 @@
+#ifndef SCENE_H_
+#define SCENE_H_
+
+#include "vector.h"
+#include "sprite.h"
+#include "object.h"
+
+typedef void (*Scene_func)(struct Scene*);
+typedef bool (*Scene_func_add_object)(struct Scene*, Object*);
+typedef bool (*Scene_func_add_sprite)(struct Scene*, Sprite*);
+typedef struct Scene {
+    char* name;
+    Vector* objects;
+    Vector* sprites;
+
+    Scene_func_add_object add_object;
+    Scene_func_add_sprite add_sprite;
+    Scene_func update;
+    Scene_func draw;
+} Scene;
+
+void free_Scene(struct Scene* self);
+Scene* new_Scene(const char* name);
+Scene* current_Scene();
+
+#endif

src/main.c

@@ -1,34 +1,18 @@
-#include <tice.h>
 #include <graphx.h>
 #include <keypadc.h>
-#include <debug.h>
 #include <compression.h>
 
 #include "gfx/main_gfx.h"
-#include "lib/vector.h"
-#include "lib/sprite.h"
-#include "lib/object.h"
-
-int walk_speed = 1;
-int run_speed = 3;
-float scale = 3.0;
-int frameskip = 10;
-// #define RESIZE_SPRITES
-
-#define log(msg) dbg_sprintf(dbgout, "[TBP] %s\n", msg)
+#include "main.h"
+#include "objects/player.h"
 
 int main(void){
-    kb_key_t arrows;
-    int max_width = LCD_WIDTH;
-    int max_height = LCD_HEIGHT;
-    int frame = 0;
     size_t i;
-    int speed;
-    Object* object;
+    Scene* scene = new_Scene("Main");
     Sprite* sprite;
-    Object* player = new_Object(0, 0);
-    Vector* objects = new_Vector(1, sizeof(Object), &free_Object);
-    Vector* sprites = new_Vector(22, sizeof(Sprite), &free_Sprite);
+    Object* player = new_Player();
+    Vector* objects = scene->objects;
+    Vector* sprites = scene->sprites;
     if(!sprites->consume(sprites, new_Sprite(bm1_width, bm1_height, bm1_compressed)) ||
         !sprites->consume(sprites, new_Sprite(bm2_width, bm2_height, bm2_compressed)) ||
         !sprites->consume(sprites, new_Sprite(bm3_width, bm3_height, bm3_compressed)) ||
@@ -53,19 +37,15 @@ int main(void){
         !sprites->consume(sprites, new_Sprite(bm22_width, bm22_height, bm22_compressed))
     ){
         log("Failed to load sprites");
-        free_Object(player);
-        free_Vector(objects);
-        free_Vector(sprites);
+        free_Scene(scene);
         return 1;
     }
 
-    if(!objects->push(objects, player)){
+    if(!objects->consume(objects, player)){
         log("Unable to add player to stack");
-        free_Vector(objects);
-        free_Object(player);
+        free_Scene(scene);
         return 1;
     }
-    free_Object(player);
     player = objects->get(objects, 0);
     player->sprite = sprites->get(sprites, 0);
     log("Get max sizes");
@@ -75,14 +55,14 @@ int main(void){
     dbg_sprintf(dbgout, "[Player] %d x %d\n", player->sprite->data->width, player->sprite->data->height);
     for(i = 0; i < sprites->count(sprites); i++){
         sprite = sprites->get(sprites, i);
-        sprite->resize(sprite, sprite->data->width * scale, sprite->data->height * scale);
+        sprite->resize(sprite, sprite->data->width * SCALE, sprite->data->height * SCALE);
     }
     dbg_sprintf(dbgout, "[Player] %d x %d\n", player->sprite->data->width, player->sprite->data->height);
     #else
-    player->scale.x = scale;
-    player->scale.y = scale;
-    max_width -= player->width(player);
-    max_height -= player->height(player);
+    player->scale.x = SCALE;
+    player->scale.y = SCALE;
+    MAX_WIDTH -= player->width(player);
+    MAX_HEIGHT -= player->height(player);
     #endif
 
     log("Start graphics");
@@ -92,78 +72,12 @@ int main(void){
 
     log("Main loop");
     do{
-        player->sprite = sprites->get(sprites, 0);
+        scene->update(scene);
         kb_Scan();
-        if(kb_Data[2] & kb_Alpha){
-            speed = run_speed;
-        }else{
-            speed = walk_speed;
-        }
-        arrows = kb_Data[7];
-        if(arrows & kb_Down){
-            if(player->y < max_height){
-                player->y += speed;
-                if(frame > 2){
-                    player->sprite = sprites->get(sprites, 2);
-                }else{
-                    player->sprite = sprites->get(sprites, 4);
-                }
-            }
-        }else if(arrows & kb_Up){
-            if(player->y > 0){
-                player->y -= speed;
-                if(frame > 2){
-                    player->sprite = sprites->get(sprites, 18);
-                }else{
-                    player->sprite = sprites->get(sprites, 20);
-                }
-            }
-        }
-        if(arrows & kb_Right){
-            if(player->x < max_width){
-                player->x += speed;
-                if(frame > 2){
-                    player->sprite = sprites->get(sprites, 10);
-                }else{
-                    player->sprite = sprites->get(sprites, 12);
-                }
-            }
-        }else if(arrows & kb_Left){
-            if(player->x > 0){
-                player->x -= speed;
-                if(frame > 2){
-                    player->sprite = sprites->get(sprites, 6);
-                }else{
-                    player->sprite = sprites->get(sprites, 8);
-                }
-            }
-        }
-        if(player->x < 0){
-            player->x = 0;
-        }else if(player->x >= max_width){
-            player->x = max_width;
-        }
-        if(player->y < 0){
-            player->y = 0;
-        }else if(player->y >= max_height){
-            player->y = max_height;
-        }
-        gfx_FillScreen(0);
-        for(i = 0; i < objects->count(objects); i++){
-            object = objects->get(objects, i);
-            object->draw(object);
-        }
-        gfx_BlitBuffer();
-        frame++;
-        if(frame > frameskip){
-            frame = 0;
-        }
+        scene->draw(scene);
     }while (! (kb_Data[6] & kb_Clear));
-    log("Freeing sprites stack");
-    free_Vector(sprites);
-    player->sprite = NULL;
-    log("Freeing objects stack");
-    free_Vector(objects);
+    log("Freeing memory");
+    free_Scene(scene);
     log("End graphics");
     gfx_End();
     log("Done");

src/main.h

@@ -0,0 +1,20 @@
+#ifndef MAIN_H_
+#define MAIN_H_
+
+#include <tice.h>
+#include <debug.h>
+#include "lib/scene.h"
+
+#define WALK_SPEED 1;
+#define RUN_SPEED 3;
+#define SCALE 3.0;
+// #define RESIZE_SPRITES
+
+//#define LOG_UPDATE
+//#define LOG_DRAW
+
+#define log(msg) dbg_sprintf(dbgout, "[TBP] %s\n", msg)
+static int MAX_WIDTH = LCD_WIDTH;
+static int MAX_HEIGHT = LCD_HEIGHT;
+
+#endif

src/objects/player.c

@@ -0,0 +1,83 @@
+#include <keypadc.h>
+#include "../main.h"
+
+#define Player_log(msg) dbg_sprintf(dbgout, "[Object(Player) %d] %s\n", self->id, msg)
+
+void Player_update(Object* self){
+    Scene* scene = current_Scene();
+    Vector* sprites = scene->sprites;
+    Sprite* sprite;
+    kb_key_t arrows = kb_Data[7];
+    int x = self->x;
+    int y = self->y;
+    int speed;
+    #ifdef LOG_UPDATE
+    Player_log("Drawing player");
+    #endif
+    if(kb_Data[2] & kb_Alpha){
+        speed = RUN_SPEED;
+    }else{
+        speed = WALK_SPEED;
+    }
+    if(arrows & kb_Down){
+        if(self->y < MAX_HEIGHT){
+            self->y += speed;
+            sprite = sprites->get(sprites, 2);
+            if(sprite != self->sprite){
+                self->sprite = sprite;
+            }else{
+                self->sprite = sprites->get(sprites, 4);
+            }
+        }
+    }else if(arrows & kb_Up){
+        if(self->y > 0){
+            self->y -= speed;
+            sprite = sprites->get(sprites, 18);
+            if(sprite != self->sprite){
+                self->sprite = sprite;
+            }else{
+                self->sprite = sprites->get(sprites, 20);
+            }
+        }
+    }
+    if(arrows & kb_Right){
+        if(self->x < MAX_WIDTH){
+            self->x += speed;
+            sprite = sprites->get(sprites, 10);
+            if(sprite != self->sprite){
+                self->sprite = sprite;
+            }else{
+                self->sprite = sprites->get(sprites, 12);
+            }
+        }
+    }else if(arrows & kb_Left){
+        if(self->x > 0){
+            self->x -= speed;
+            sprite = sprites->get(sprites, 6);
+            if(sprite != self->sprite){
+                self->sprite = sprite;
+            }else{
+                self->sprite = sprites->get(sprites, 8);
+            }
+        }
+    }
+    if(self->x < 0){
+        self->x = 0;
+    }else if(self->x >= MAX_WIDTH){
+        self->x = MAX_WIDTH;
+    }
+    if(self->y < 0){
+        self->y = 0;
+    }else if(self->y >= MAX_HEIGHT){
+        self->y = MAX_HEIGHT;
+    }
+    if(x == self->x && y == self->y){
+        self->sprite = sprites->get(sprites, 0);
+    }
+}
+
+Object* new_Player(){
+    Object* self = new_Object(0,0);
+    self->update = &Player_update;
+    return self;
+}

src/objects/player.h

@@ -0,0 +1,7 @@
+#ifndef PLAYER_H_
+#define PLAYER_H_
+#include "../lib/object.h"
+
+Object* new_Player();
+
+#endif