W.I.P. correct direction diagonal

diff --git a/Automap/Renderers/StandardRenderer.cs b/Automap/Renderers/StandardRenderer.cs
index 433f411..6ed2a1b 100644 (file)
--- a/Automap/Renderers/StandardRenderer.cs
+++ b/Automap/Renderers/StandardRenderer.cs
@@ -51,54 +51,53 @@ namespace Automap
                }
 
                // Prefetch map chunks, in pattern              
-               var corner_pos = new Vec2i(chunkPos.X - 1, chunkPos.Y - 1);
+               var corner_pos = new Vec2i(chunkPos.X - 1, chunkPos.Y + 1);
                var west_pos = new Vec2i(chunkPos.X - 1, chunkPos.Y);
-               var south_pos = new Vec2i(chunkPos.X, chunkPos.Y - 1);
-                                       
+               var north_pos = new Vec2i(chunkPos.X, chunkPos.Y + 1);                                  
 
-               ColumnMeta south, southWest, west;
+               ColumnMeta north, northWest, west;
                /* 
                  "Overlap" Heightmap for Slope (height) values; covers 1 whole + 2 chunk edges, and corner block,
                   substitute ZERO with Average Height....better than nothing even if its wrong?
                */
                var overlapHeightmap = new ushort[chunkSize + 1, chunkSize + 1];
 
-               //Ofset copy of Heightmap...
+               //Ofset copy of Heightmap...copied to Bottom, Rightmost
                for (int copyX = 0; copyX < chunkSize; copyX++)
                {
                        for (int copyY = 0; copyY < chunkSize; copyY++) {
-                               overlapHeightmap[copyX + 1, copyY] = targetColMeta.HeightMap[copyX, copyY];
+                               overlapHeightmap[copyX + 1, copyY + 1] = targetColMeta.HeightMap[copyX, copyY];
                        }                       
                }
 
 
 
                if (allCols.Contains(corner_pos) && allCols[corner_pos].HeightMap != null) {
-               southWest = allCols[corner_pos];
-               overlapHeightmap[0, 32] = southWest.HeightMap[0, chunkSize - 1];
+               northWest = allCols[corner_pos];
+               overlapHeightmap[0, 0] = northWest.HeightMap[chunkSize - 1, chunkSize - 1];
                }
                else {
                var cornerMC = ClientAPI.World.BlockAccessor.GetMapChunk(corner_pos);
                if (cornerMC != null && cornerMC.RainHeightMap != null) 
                        {
-                       overlapHeightmap[0, 32] = cornerMC.RainHeight2DMap(0, (chunkSize - 1) );
+                       overlapHeightmap[0, 0] = cornerMC.RainHeight2DMap(chunkSize - 1, (chunkSize - 1) );
                        }
                }
                
-               if (allCols.Contains(south_pos) && allCols[south_pos].HeightMap != null) {
-               south = allCols[south_pos];
+               if (allCols.Contains(north_pos) && allCols[north_pos].HeightMap != null) {
+               north = allCols[north_pos];
 
-                       for (int southEdgeIndex = 0; southEdgeIndex < chunkSize; southEdgeIndex++) 
+                       for (int northEdgeIndex = 0; northEdgeIndex < chunkSize; northEdgeIndex++) 
                        {
-                       overlapHeightmap[32, southEdgeIndex + 1] = south.HeightMap[0, southEdgeIndex];                  
+                       overlapHeightmap[1, northEdgeIndex + 1 ] = north.HeightMap[ (chunkSize - 1), northEdgeIndex];                   
                        }
                }               
                else {
-                       var southMC = ClientAPI.World.BlockAccessor.GetMapChunk(south_pos);
-                       if (southMC != null && southMC.RainHeightMap != null) {
-                               for (int southEdgeIndex = 0; southEdgeIndex < chunkSize; southEdgeIndex++) 
+                       var northMC = ClientAPI.World.BlockAccessor.GetMapChunk(north_pos);
+                       if (northMC != null && northMC.RainHeightMap != null) {
+                               for (int northEdgeIndex = 0; northEdgeIndex < chunkSize; northEdgeIndex++) 
                                {
-                               overlapHeightmap[32, southEdgeIndex] = southMC.RainHeight2DMap(0, southEdgeIndex);
+                               overlapHeightmap[1, northEdgeIndex + 1] = northMC.RainHeight2DMap((chunkSize - 1), northEdgeIndex);
                                }
                        }
                }
@@ -108,14 +107,14 @@ namespace Automap
 
                        for (int westEdgeIndex = 0; westEdgeIndex < chunkSize; westEdgeIndex++) 
                        {
-                       overlapHeightmap[westEdgeIndex, 0] = west.HeightMap[westEdgeIndex, chunkSize - 1];
+                       overlapHeightmap[westEdgeIndex + 1, 0] = west.HeightMap[westEdgeIndex, chunkSize - 1];
                        }
                }               
                else {
-               var westMC = ClientAPI.World.BlockAccessor.GetMapChunk(south_pos);
+               var westMC = ClientAPI.World.BlockAccessor.GetMapChunk(west_pos);
                if (westMC != null && westMC.RainHeightMap != null) {
                        for (int westEdgeIndex = 0; westEdgeIndex < chunkSize; westEdgeIndex++) {
-                       overlapHeightmap[westEdgeIndex, 0] = westMC.RainHeight2DMap(westEdgeIndex, chunkSize - 1);
+                       overlapHeightmap[westEdgeIndex + 1, 0] = westMC.RainHeight2DMap(westEdgeIndex, chunkSize - 1);
                        }
                }
                }
@@ -152,17 +151,17 @@ namespace Automap
                float slopeBoost = 1f;
                int leftTop, rightTop, leftBot;                                         
 
-               int topX = localX;
-               int botX = localX + 1;
-               int leftZ = localZ + 1;
-               int rightZ = localZ;            
-
-               topX  = GameMath.Mod(topX, chunkSize + 1);
-               leftZ = GameMath.Mod(leftZ, chunkSize + 1);
+               int up_X = localX;
+               int low_X = localX + 1;
+               int left_Z = localZ;
+               int right_Z = localZ + 1;                               
                
-               leftTop  = Math.Sign(localY - overlapHeightmap[topX, leftZ]);
-               rightTop = Math.Sign(localY - overlapHeightmap[topX, rightZ]);
-               leftBot  = Math.Sign(localY - overlapHeightmap[botX, leftZ]);
+               //topX = GameMath.Mod(topX, chunkSize + 1);
+               //leftZ = GameMath.Mod(leftZ, chunkSize + 1);
+
+               leftTop  = Math.Sign(localY - overlapHeightmap[up_X, left_Z]);
+               rightTop = Math.Sign(localY - overlapHeightmap[up_X, right_Z]);
+               leftBot  = Math.Sign(localY - overlapHeightmap[low_X, left_Z]);
 
                float slopeness = (leftTop + rightTop + leftBot);