Diff: map.cpp

Revision:

1:10330bce85cb

Child:

2:4947d6a82971

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/map.cpp	Fri Oct 23 16:18:39 2020 -0400
@@ -0,0 +1,203 @@
+#include "map.h"
+
+#include "globals.h"
+#include "graphics.h"
+
+/**
+ * The Map structure. This holds a HashTable for all the MapItems, along with
+ * values for the width and height of the Map.
+ */
+struct Map {
+    HashTable* items;
+    int w, h;
+};
+
+#define NUM_MAPS 1
+static Map maps[NUM_MAPS];
+static int active_map;
+
+static const MapItem CLEAR_SENTINEL = {
+    .type = CLEAR,
+    .draw = draw_nothing
+};
+
+/**
+ * The first step in HashTable access for the map is turning the two-dimensional
+ * key information (x, y) into a one-dimensional unsigned integer.
+ * This function should uniquely map (x,y) onto the space of unsigned integers.
+ */
+static unsigned XY_KEY(int X, int Y) {
+     // TODO: Fix me!
+}
+
+/**
+ * This is the hash function actually passed into createHashTable. It takes an
+ * unsigned key (the output of XY_KEY) and turns it into a hash value (some
+ * small non-negative integer).
+ */
+unsigned map_hash(unsigned key)
+{
+    // TODO: Fix me!
+}
+
+void maps_init()
+{
+    // TODO: Implement!    
+    // Initialize hash table
+    // Set width & height
+}
+
+Map* get_active_map()
+{
+    return &maps[active_map];
+}
+
+Map* set_active_map(int m)
+{
+    active_map = m;
+    return &maps[active_map];
+}
+
+void print_map()
+{
+    char lookup[] = {'W', 'D', 'P', 'A', 'K', 'C', 'N',' ','S'};
+    Map* map = get_active_map();
+    for(int j = 0; j < map->h; j++)
+    {
+        for (int i = 0; i < map->w; i++)
+        {
+            MapItem* item = (MapItem*)getItem(map->items, XY_KEY(i, j));
+            if (item) pc.printf("%c", lookup[item->type]);
+            else pc.printf(" ");
+        }
+        pc.printf("\r\n");
+    }
+}
+
+int map_width()
+{
+
+}
+
+int map_height()
+{
+
+}
+
+int map_area()
+{
+
+}
+MapItem* get_current(int x, int y)
+{
+    
+}
+MapItem* get_north(int x, int y)
+{
+    
+}
+MapItem* get_south(int x, int y)
+{
+    
+}
+
+MapItem* get_east(int x, int y)
+{
+    
+}
+
+MapItem* get_west(int x, int y)
+{
+
+}
+
+MapItem* get_here(int x, int y)
+{
+
+}
+
+void map_erase(int x, int y)
+{
+
+}
+
+void add_wall(int x, int y, int dir, int len)
+{
+    for(int i = 0; i < len; i++)
+    {
+        MapItem* w1 = (MapItem*) malloc(sizeof(MapItem));
+        w1->type = WALL;
+        w1->draw = draw_wall;
+        w1->walkable = false;
+        w1->data = NULL;
+        unsigned key = (dir == HORIZONTAL) ? XY_KEY(x+i, y) : XY_KEY(x, y+i);
+        void* val = insertItem(get_active_map()->items, key, w1);
+        if (val) free(val); // If something is already there, free it
+    }
+}
+
+void add_plant(int x, int y)
+{
+    MapItem* w1 = (MapItem*) malloc(sizeof(MapItem));
+    w1->type = PLANT;
+    w1->draw = draw_plant;
+    w1->walkable = false;
+    w1->data = NULL;
+    void* val = insertItem(get_active_map()->items, XY_KEY(x, y), w1);
+    if (val) free(val); // If something is already there, free it
+}
+
+void add_goodie(int x, int y)
+{
+    MapItem* w1 = (MapItem*) malloc(sizeof(MapItem));
+    w1->type = GOODIE;
+    w1->draw = draw_goodie;
+    w1->walkable = true;
+    w1->data = NULL;
+    void* val = insertItem(get_active_map()->items, XY_KEY(x, y), w1);
+    if (val) free(val); // If something is already there, free it
+}
+
+void remove_goodie(int x, int y) // I'm lazy so overwrite it with a plant
+{
+    MapItem* w1 = (MapItem*) malloc(sizeof(MapItem));
+    w1->type = PLANT;
+    w1->draw = draw_plant;
+    w1->walkable = true;
+    w1->data = NULL;
+    void* val = insertItem(get_active_map()->items, XY_KEY(x, y), w1);
+    if (val) free(val); // If something is already there, free it
+}
+
+void add_snake_body(int x, int y)
+{
+    MapItem* w1 = (MapItem*) malloc(sizeof(MapItem));
+    w1->type = SNAKE_BODY;
+    w1->draw = draw_snake_body;
+    w1->walkable = false;
+    w1->data = NULL;
+    void* val = insertItem(get_active_map()->items, XY_KEY(x, y), w1);
+    if (val) free(val); // If something is already there, free it
+}
+
+void add_snake_head(int x, int y)
+{
+    MapItem* w1 = (MapItem*) malloc(sizeof(MapItem));
+    w1->type = SNAKE_BODY;
+    w1->draw = draw_snake_head;
+    w1->walkable = false;
+    w1->data = NULL;
+    void* val = insertItem(get_active_map()->items, XY_KEY(x, y), w1);
+    if (val) free(val); // If something is already there, free it
+}
+
+void add_snake_tail(int x, int y)
+{
+    MapItem* w1 = (MapItem*) malloc(sizeof(MapItem));
+    w1->type = SNAKE_BODY;
+    w1->draw = draw_snake_tail;
+    w1->walkable = false;
+    w1->data = NULL;
+    void* val = insertItem(get_active_map()->items, XY_KEY(x, y), w1);
+    if (val) free(val); // If something is already there, free it
+}