Diff: map.cpp

Revision:

3:bb6f73642f01

Parent:

2:4947d6a82971

Child:

4:697e1120f821

diff -r 4947d6a82971 -r bb6f73642f01 map.cpp
--- a/map.cpp	Fri Oct 23 16:30:18 2020 -0400
+++ b/map.cpp	Mon Nov 16 20:38:03 2020 +0000
@@ -19,8 +19,12 @@
 };
 
 #define NUM_MAPS 1
+#define MAPS_WIDTH 50
+#define MAPS_HEIGHT 50
 static Map maps[NUM_MAPS];
 static int active_map;
+unsigned int NUMBUCKETS = 10000;
+
 
 static const MapItem CLEAR_SENTINEL = {
     .type = CLEAR,
@@ -33,7 +37,10 @@
  * This function should uniquely map (x,y) onto the space of unsigned integers.
  */
 static unsigned XY_KEY(int X, int Y) {
-     // TODO: Fix me!
+     // multiply the map height by Y and adding it to X
+     unsigned XYKey = Y * map_width() + X;
+     // return the unique key
+     return XYKey;
 }
 
 /**
@@ -43,14 +50,25 @@
  */
 unsigned map_hash(unsigned key)
 {
-    // TODO: Fix me!
+    // modulo map hashing into something unique 
+    return key % NUMBUCKETS;
 }
 
+/**
+ * Initializes the internal structures for all maps. This does not populate
+ * the map with items, but allocates space for them, initializes the hash tables, 
+ * and sets the width and height.
+ */
+ 
 void maps_init()
 {
     // TODO: Implement!    
     // Initialize hash table
     // Set width & height
+    set_active_map(0)->items = createHashTable(map_hash, NUMBUCKETS); // num buckets
+    get_active_map()->w = MAPS_WIDTH; 
+    get_active_map()->h = MAPS_HEIGHT;
+    return;
 }
 
 Map* get_active_map()
@@ -80,51 +98,128 @@
     }
 }
 
+/**
+ * Returns the width of the active map.
+ */
 int map_width()
 {
-
+// get the pointer of the active map 
+// and the pointer to the variable w
+Map* map = get_active_map();
+return map->w;
 }
 
+/**
+ * Returns the heigh of the active map.
+ */
 int map_height()
 {
-
+// get the pointer of the active map
+// and the pointer to the variable h
+Map* map = get_active_map();
+return map->w;
 }
 
+/**
+ * Returns the total number of cells in the active map.
+ */
 int map_area()
 {
+// returns the product of height and width
+return map_height() * map_width();
+}
 
-}
 MapItem* get_current(int x, int y)
 {
-    
+    // return the current item in that specific map
+    return (MapItem*) get_active_map()->items;
 }
+
+/**
+ * Returns the MapItem immediately above the given location.
+ */
 MapItem* get_north(int x, int y)
 {
-    
+ // coordinate to the one block north of the current block
+ int northCoordinate = y - 1;
+ // get the items in the active map
+ HashTable* mapItem = get_active_map()->items;
+ // get the keys to the respective coordinate, placed in a specific bucket
+ unsigned keys = XY_KEY(x, northCoordinate);  
+ // we need to cast it because it is not type MapItem, but type HashTable
+ return (MapItem*) getItem(mapItem, keys); 
 }
+
+/**
+ * Returns the MapItem immediately below the given location.
+ */
 MapItem* get_south(int x, int y)
 {
-    
-}
-
-MapItem* get_east(int x, int y)
-{
-    
+ // coordinate to the one block south of the current block
+ int southCoordinate = y + 1;
+ // get the items in the active map
+ HashTable* mapItem = get_active_map()->items;
+ // get the keys to the respective coordinate, placed in a specific bucket
+ unsigned keys = XY_KEY(x, southCoordinate);  
+ // we need to cast it because it is not type MapItem, but type HashTable
+ return (MapItem*) getItem(mapItem, keys); 
 }
 
+
+/**
+ * Returns the MapItem immediately to the right of the given location.
+ */
+MapItem* get_east(int x, int y)
+{
+ // coordinate to the one block east of the current block
+ int eastCoordinate = x + 1;
+ // get the items in the active map
+ HashTable* mapItem = get_active_map()->items;
+ // get the keys to the respective coordinate, placed in a specific bucket
+ unsigned keys = XY_KEY(eastCoordinate, y);  
+ // we need to cast it because it is not type MapItem, but type HashTable
+ return (MapItem*) getItem(mapItem, keys); 
+}
+
+
+/**
+ * Returns the MapItem immediately to the left of  the given location.
+ */
 MapItem* get_west(int x, int y)
 {
-
+ // coordinate to the one block west of the current block
+ int westCoordinate = x - 1;
+ // get the items in the active map
+ HashTable* mapItem = get_active_map()->items;
+ // get the keys to the respective coordinate, placed in a specific bucket
+ unsigned keys = XY_KEY(westCoordinate, y);  
+ // we need to cast it because it is not type MapItem, but type HashTable
+ return (MapItem*) getItem(mapItem, keys); 
 }
 
+/**
+ * Returns the MapItem at the given location.
+ */
 MapItem* get_here(int x, int y)
 {
-
+ // get the items in the active map
+ HashTable* mapItem = get_active_map()->items;
+ // get the keys to the respective coordinate, placed in a specific bucket
+ unsigned keys = XY_KEY(x, y);  
+ // we need to cast it because it is not type MapItem, but type HashTable
+ return (MapItem*) getItem(mapItem, keys); 
 }
 
+
+/**
+ * If there is a MapItem at (x,y), remove it from the map.
+ */
 void map_erase(int x, int y)
 {
-
+    if (get_here(x, y) != NULL) {
+    return deleteItem(get_active_map()->items, XY_KEY(x, y));
+        }
+    return;
 }
 
 void add_wall(int x, int y, int dir, int len)
@@ -207,3 +302,58 @@
     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_shield(int x, int y)
+{
+    MapItem* w1 = (MapItem*) malloc(sizeof(MapItem));
+    w1->type = SHIELD;
+    w1->draw = draw_shield;
+    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_life(int x, int y)
+{
+    MapItem* w1 = (MapItem*) malloc(sizeof(MapItem));
+    w1->type = LIFE;
+    w1->draw = draw_life;
+    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_snowflake(int x, int y)
+{
+    MapItem* w1 = (MapItem*) malloc(sizeof(MapItem));
+    w1->type = SNOWFLAKE;
+    w1->draw = draw_snowflake;
+    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_sword(int x, int y)
+{
+    MapItem* w1 = (MapItem*) malloc(sizeof(MapItem));
+    w1->type = SWORD;
+    w1->draw = draw_sword;
+    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_nothing(int x, int y) 
+{
+    MapItem* w1 = (MapItem*) malloc(sizeof(MapItem));
+    w1->type = NOTHING;
+    w1->draw = draw_nothing;
+    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
+}