fix some stuff for disposal

Assets/Scripts/SS3D/Systems/Tile/Connections/AdjacencyMap.cs

@@ -106,7 +106,7 @@ public bool SetConnection(Direction direction, AdjacencyData data)
             return changed;
         }
 
-        private List<Direction> GetAdjacencies(bool cardinal)
+        public List<Direction> GetAdjacencies(bool cardinal)
         {
             //Are we getting adjacencies for cardinal or diagonal directions?
             List<int> directionIndexes = cardinal ?

Assets/Scripts/SS3D/Systems/Tile/Connections/DisposalPipeAdjacencyConnector.cs

@@ -35,6 +35,8 @@ public class DisposalPipeAdjacencyConnector : NetworkActor, IAdjacencyConnector
 
         protected TileObjectSpecificType _specificType;
 
+        private bool _isVertical = false;
+
 
         private void Setup()
         {
@@ -172,20 +174,37 @@ protected virtual void UpdateMeshAndDirection()
             var info = _pipeAdjacency.GetMeshAndDirection(_adjacencyMap, _verticalConnection);
             transform.localRotation = Quaternion.identity;
 
-            var pos = transform.position;
+            Vector3 pos = transform.position;
+            Quaternion localRotation = _filter.transform.localRotation;
+            Vector3 eulerRotation = localRotation.eulerAngles;
+            _filter.mesh = info.Mesh;
 
             if (info.Mesh == _pipeAdjacency.verticalMesh)
             {
+                _isVertical= true;
                 transform.position = new Vector3(pos.x, -0.67f, pos.z);
+                _filter.transform.localRotation = Quaternion.Euler(eulerRotation.x, TileHelper.GetRotationAngle(_placedObject.Direction), eulerRotation.z);
+
+                if (!_isVertical)
+                {
+                    var directions = TileHelper.AllDirections();
+                    directions.Remove(TileHelper.GetOpposite(_placedObject.Direction));
+                    SetBlockedDirection(directions, false);
+
+                }
+
+                return;
             }
             else if (_filter.mesh == _pipeAdjacency.verticalMesh)
             {
                 transform.position = new Vector3(pos.x, 0f, pos.z);
-                return;
             }
-            _filter.mesh = info.Mesh;
-            Quaternion localRotation = _filter.transform.localRotation;
-            Vector3 eulerRotation = localRotation.eulerAngles;
+
+            if (info.Mesh != _pipeAdjacency.verticalMesh)
+            {
+                _isVertical = false;
+            }
+
             localRotation = Quaternion.Euler(eulerRotation.x, info.Rotation, eulerRotation.z);
             _filter.transform.localRotation = localRotation;
         }
@@ -217,5 +236,19 @@ private void SyncVertical(bool oldValue, bool newValue, bool asServer)
                 UpdateMeshAndDirection();
             }
         }
+
+        /// <summary>
+        /// Sets a given direction blocked or unblocked. 
+        /// If blocked, this means that it will no longer be allowed to connect on that direction (until further update).
+        /// </summary>
+        private void SetBlockedDirection(List<Direction> directions, bool value)
+        {
+            foreach(var dir in directions)
+            {
+                _adjacencyMap.SetConnection(dir, new AdjacencyData(TileObjectGenericType.None, TileObjectSpecificType.None, value));  
+            }
+
+            UpdateMeshAndDirection();
+        }
     }
 }

Assets/Scripts/SS3D/Systems/Tile/PlacedObjects/PlacedTileObject.cs

@@ -123,6 +123,11 @@ public SavedPlacedTileObject Save()
             };
         }
 
+        public void SetDirection(Direction dir)
+        {
+            _dir = dir;
+        }
+
         /// <summary>
         /// Is this in front of the other object ?
         /// </summary>

Assets/Scripts/SS3D/Systems/Tile/TileHelper.cs

@@ -4,6 +4,7 @@
 using System.Collections.Generic;
 using System.Runtime.CompilerServices;
 using UnityEngine;
+using SS3D.Utils;
 
 namespace SS3D.Systems.Tile
 {
@@ -57,6 +58,12 @@ public static TileLayer[] GetTileLayers()
             return TileLayers;
         }
 
+        public static Tuple<Direction,Direction> GetAdjacentDirections(Direction dir)
+        {
+            return new Tuple<Direction, Direction>( (Direction) MathUtility.mod((int) dir + 1, 8),
+                (Direction)MathUtility.mod((int)dir - 1, 8) );
+        }
+
         /// <summary>
         /// Get the offset in coordinates in a given direction.
         /// </summary>
@@ -78,12 +85,10 @@ public static Vector3 GetClosestPosition(Vector3 worldPosition)
 
         /// <summary>
         /// Get the relative direction between two direction. 
-        /// E.g : to = North-East, from = South-West, return South.
-        /// TODO : maybe swith name of to and from, currently it feels it's the inverse way around.
         /// </summary>
-        public static Direction GetRelativeDirection(Direction to, Direction from)
+        public static Direction GetRelativeDirection(Direction from, Direction to)
         {
-            return (Direction)((((int)to - (int)from) + 8) % 8);
+            return (Direction)((((int)from - (int)to) + 8) % 8);
         }
 
         /// <summary>
@@ -94,6 +99,15 @@ public static List<Direction> CardinalDirections()
             return new List<Direction> { Direction.North, Direction.East, Direction.South, Direction.West };
         }
 
+        /// <summary>
+        /// Return a list of the cardinal directions.
+        /// </summary>
+        public static List<Direction> AllDirections()
+        {
+            return new List<Direction> { Direction.North, Direction.NorthEast, Direction.East, Direction.SouthEast,
+                Direction.South, Direction.SouthWest, Direction.West, Direction.NorthWest };
+        }
+
         /// <summary>
         /// Return a list of the diagonal directions.
         /// </summary>

Assets/Scripts/SS3D/Systems/Tile/TileMap.cs

@@ -108,7 +108,7 @@ public TileChunk GetChunk(Vector3 worldPosition)
             }
         }
 
-        private TileObject GetTileObject(TileLayer layer, Vector3 worldPosition)
+        public TileObject GetTileObject(TileLayer layer, Vector3 worldPosition)
         {
             TileChunk chunk = GetOrCreateChunk(worldPosition); // TODO: creates unnessary empty chunk when checking whether building can be done
             return chunk.GetTileObject(layer, worldPosition);