Added diagonal ramps

src/rpg/entity/entity.c

@@ -84,8 +84,30 @@ void entityWalk(entity_t *entity, const entitydir_t direction) {
   // Are we walking up a ramp?
   if(
     tileIsRamp(tileCurrent) &&
-    (direction+TILE_SHAPE_RAMP_SOUTH) == tileCurrent &&
-    newPos.z < (MAP_CHUNK_DEPTH - 1)
+    (
+      // Can only walk UP the direction the ramp faces.
+      (direction+TILE_SHAPE_RAMP_SOUTH) == tileCurrent ||
+      // If diagonal ramp, can go up one of two ways only.
+      (
+        (
+          tileCurrent == TILE_SHAPE_RAMP_SOUTHEAST &&
+          (direction == ENTITY_DIR_SOUTH || direction == ENTITY_DIR_EAST)
+        ) ||
+        (
+          tileCurrent == TILE_SHAPE_RAMP_SOUTHWEST &&
+          (direction == ENTITY_DIR_SOUTH || direction == ENTITY_DIR_WEST)
+        ) ||
+        (
+          tileCurrent == TILE_SHAPE_RAMP_NORTHEAST &&
+          (direction == ENTITY_DIR_NORTH || direction == ENTITY_DIR_EAST)
+        ) ||
+        (
+          tileCurrent == TILE_SHAPE_RAMP_NORTHWEST &&
+          (direction == ENTITY_DIR_NORTH || direction == ENTITY_DIR_WEST)
+        )
+      )
+    // Must be able to walk up.
+    ) && newPos.z < (MAP_CHUNK_DEPTH - 1)
   ) {
     tileNew = TILE_SHAPE_NULL;// Force check for ramp above.
     worldpos_t abovePos = newPos;
@@ -104,7 +126,29 @@ void entityWalk(entity_t *entity, const entitydir_t direction) {
     if(
       tileBelow != TILE_SHAPE_NULL &&
       tileIsRamp(tileBelow) &&
-      (entityDirGetOpposite(direction)+TILE_SHAPE_RAMP_SOUTH) == tileBelow
+      (
+        // This handles regular cardinal ramps
+        (entityDirGetOpposite(direction)+TILE_SHAPE_RAMP_SOUTH) == tileBelow ||
+        // This handles diagonal ramps
+        (
+          (
+            tileBelow == TILE_SHAPE_RAMP_SOUTHEAST &&
+            (direction == ENTITY_DIR_NORTH || direction == ENTITY_DIR_WEST)
+          ) ||
+          (
+            tileBelow == TILE_SHAPE_RAMP_SOUTHWEST &&
+            (direction == ENTITY_DIR_NORTH || direction == ENTITY_DIR_EAST)
+          ) ||
+          (
+            tileBelow == TILE_SHAPE_RAMP_NORTHEAST &&
+            (direction == ENTITY_DIR_SOUTH || direction == ENTITY_DIR_WEST)
+          ) ||
+          (
+            tileBelow == TILE_SHAPE_RAMP_NORTHWEST &&
+            (direction == ENTITY_DIR_SOUTH || direction == ENTITY_DIR_EAST)
+          )
+        )
+      )
     ) {
       // We will fall to this tile.
       fall = true;

src/rpg/world/map.c

@@ -127,6 +127,7 @@ void mapDispose() {
 
 void mapChunkUnload(chunk_t* chunk) {
   for(uint8_t i = 0; i < chunk->meshCount; i++) {
+    if(chunk->meshes[i].vertexCount == 0) continue;
     meshDispose(&chunk->meshes[i]);
   }
 }
@@ -135,6 +136,7 @@ errorret_t mapChunkLoad(chunk_t* chunk) {
   char_t buffer[64];
 
   chunk->meshCount = 0;
+  memoryZero(chunk->meshes, sizeof(chunk->meshes));
 
   snprintf(buffer, sizeof(buffer), "map/map/%d_%d_%d.dcf",
     chunk->position.x,

src/rpg/world/tile.c

@@ -9,15 +9,11 @@
 
 bool_t tileIsWalkable(const tile_t tile) {
   switch(tile) {
-    case TILE_SHAPE_FLOOR:
-    case TILE_SHAPE_RAMP_NORTH:
-    case TILE_SHAPE_RAMP_SOUTH:
-    case TILE_SHAPE_RAMP_EAST:
-    case TILE_SHAPE_RAMP_WEST:
-      return true;
+    case TILE_SHAPE_NULL:
+      return false;
 
     default:
-      return false;
+      return true;
   }
 }
 
@@ -27,6 +23,10 @@ bool_t tileIsRamp(const tile_t tile) {
     case TILE_SHAPE_RAMP_SOUTH:
     case TILE_SHAPE_RAMP_EAST:
     case TILE_SHAPE_RAMP_WEST:
+    case TILE_SHAPE_RAMP_NORTHEAST:
+    case TILE_SHAPE_RAMP_NORTHWEST:
+    case TILE_SHAPE_RAMP_SOUTHEAST:
+    case TILE_SHAPE_RAMP_SOUTHWEST:
       return true;
 
     default: