private static Dictionary <Axial, Vector2> CreateNewField(Axial center)
 {
     return(new Dictionary <Axial, Vector2>()
     {
         { center, Vector2.zero },
     });
 }
        public VectorField(Axial center, Dictionary <Axial, Vector2> field)
        {
            creationTime = Time.time;

            this.center = center;
            this.field  = field;
        }
 private static Dictionary <Axial, Node> CreateClosedCollection(Axial center)
 {
     return(new Dictionary <Axial, Node>()
     {
         { center, new Node(center, 0) }
     });
 }
    /// <summary>
    /// Will try to get the farthest position in <paramref name="direction"/> starting from <paramref name="start"/>
    /// </summary>
    /// <returns>World-Space Position</returns>
    public static Vector2 GetFarthestWalkablePositionInDirection(Vector2 startingPosition, Vector2 direction, float maxDistance)
    {
        Vector2 positionOffsetPerStep    = ScaleToOrthographicVector(direction);
        Vector2 positionToCheck          = startingPosition + positionOffsetPerStep;
        Vector2 farthestWalkablePosition = startingPosition;

        while (true)
        {
            if (OrthographicDistance(startingPosition, positionToCheck) > maxDistance)
            {
                break;
            }

            Axial nearestAxialPosition = WorldToAxialPosition(positionToCheck);

            if (IsAxialPositionWalkable(nearestAxialPosition))
            {
                farthestWalkablePosition = positionToCheck;
            }

            positionToCheck += positionOffsetPerStep;
        }

        return(farthestWalkablePosition);
    }
 protected override void DoRightClick(Axial position, RoomData room)
 {
     if (room.Prefabs.ContainsKey(position))
     {
         room.Prefabs.Remove(position);
     }
 }
    void cannonFacing(Axial currentAxis)
    {
        Axial      axis = currentAxis;
        Quaternion actualRotation;

        actualRotation = transform.rotation;

        switch (axis)
        {
        case Axial.RIGHT:
            transform.rotation = Quaternion.Lerp(actualRotation, Quaternion.Euler(0, 0, (float)Axial.RIGHT), 10f * Time.deltaTime);
            break;

        case Axial.LEFT:
            transform.rotation = Quaternion.Lerp(actualRotation, Quaternion.Euler(0, 0, (float)Axial.LEFT), 10f * Time.deltaTime);
            break;

        case Axial.UP:
            transform.rotation = Quaternion.Lerp(actualRotation, Quaternion.Euler(0, 0, (float)Axial.UP), 10f * Time.deltaTime);
            break;

        case Axial.DOWN:
            transform.rotation = Quaternion.Lerp(actualRotation, Quaternion.Euler(0, 0, (float)Axial.DOWN), 10f * Time.deltaTime);
            break;
        }
    }
 /// <summary>
 /// Enumerates over 6 adjacent axial positions to <paramref name="center"/>
 /// </summary>
 public static void AdjacentHexagons(Axial center, System.Action <Axial> callback)
 {
     for (int i = 0; i < 6; i++)
     {
         callback(center + AxialDirection.AllDirections[i]);
     }
 }
示例#8
0
 /// <inheritdoc/>
 public override void RunCombination(int combinationIndex, Combination combination, CalculationContext context)
 {
     Shear.Run(context);
     Moment.Run(context);
     Axial.Run(context);
     Deflection.Run(context);
 }
        public Node(Axial position, float cost, float heuristic, Node parent)
        {
            Parent = parent;

            this.Position  = position;
            this.Cost      = cost;
            this.Heuristic = heuristic;
        }
 public Node(Axial target, int steps)
 {
     Target = new NodePosition()
     {
         Position = target,
         Steps    = steps,
     };
 }
    private static void HandleException(Axial current, Dictionary <Axial, Node> closed)
    {
#if UNITY_EDITOR
        HandleExceptionInEditor(current, closed);
#else
        Debug.LogError("Exception thrown when building vector field");
#endif
    }
示例#12
0
    public static Vector3 AxialToCube(Axial hex)
    {
        float x = hex.q;
        float z = hex.r;
        float y = -x - z;

        return(new Vector3(x, y, z));
    }
        public bool ShouldUpdate(Axial currentPosition)
        {
            if (Time.time - creationTime >= MaxBuildInterval)
            {
                return(center != currentPosition);
            }

            return(false);
        }
        protected override void DoLeftClick(Axial position, RoomData room)
        {
#if UNITY_EDITOR
            if (Selection.activeGameObject != null)
            {
                room.Prefabs.Overwrite(position, Selection.activeGameObject);
            }
#endif
        }
    public void AddPrefab(Axial position, GameObject prefab)
    {
        if (Prefabs.ContainsKey(position))
        {
            Debug.LogError($"Attempted to overwrite prefab at position {position}");
        }

        Prefabs.Add(position, prefab);
    }
    private static bool FieldShouldBeRebuilt(GameObject target, Axial targetPosition)
    {
        if (!TargetHasField(target))
        {
            throw new System.NullReferenceException($"{target} doesn't have a field!");
        }

        return(fields[target].ShouldUpdate(targetPosition));
    }
    public void AddTile(Axial position, TileData tile)
    {
        if (Tiles.ContainsKey(position))
        {
            Debug.LogError($"Attempted to overwrite tile at position {position}");
        }

        Tiles.Add(position, tile);
    }
示例#18
0
        private Axial GetFromPan(Panel pan)
        {
            var res = new Axial();
            var rw  = pan.Name.Split('_');

            int.TryParse(rw[1], out res.Q);
            int.TryParse(rw[2], out res.R);
            return(res);
        }
    /// <summary>
    /// Can an entity walk at the given position?
    /// </summary>
    public static bool IsAxialPositionWalkable(Dictionary <Axial, TileData> tiles, Axial position)
    {
        if (tiles.ContainsKey(position))
        {
            return(tiles[position].IsWalkable);
        }

        return(false);
    }
    private static void DrawVector(Axial start, Vector2 end)
    {
        Vector2 startWorldPos     = Utility.AxialToWorldPosition(start);
        Vector2 delta             = end - startWorldPos;
        Vector2 direction         = delta.normalized;
        float   orthographicScale = Utility.ScaleToOrthographicVector(direction).magnitude;

        Debug.DrawRay(startWorldPos, direction * (DirectionLength * orthographicScale), Color.cyan, 5, false);
    }
    /// <summary>
    /// Converts an axial position to world coordinates
    /// </summary>
    public static Vector2 AxialToWorldPosition(Axial axial)
    {
        Vector2 axialVector = axial;

        return(new Vector2()
        {
            x = (axialVector.x - axialVector.y * (Utility.HexelWidth / 2)) * OrthographicScale.x,
            y = (axialVector.y /= Utility.HexelHeightMultiplier) * OrthographicScale.y,
        });
    }
 public TileData this[Axial index]
 {
     get
     {
         return(Tiles[index]);
     }
     set
     {
         Tiles[index] = value;
     }
 }
    private static void DrawNeighborsOfCurrentPosition(Axial current)
    {
        Vector2 currentWorldPos = Utility.AxialToWorldPosition(current);

        for (int i = 0; i < AxialDirection.AllDirections.Length; i++)
        {
            Vector2 end = currentWorldPos + Utility.AxialToWorldPosition(AxialDirection.AllDirections[i]);

            Debug.DrawLine(currentWorldPos, end, Color.red, 5);
        }
    }
    public Vector2 GetNextPosition(Vector2 currentPosition)
    {
        Axial currentAxial       = Utility.WorldToAxialPosition(currentPosition);
        Axial firstPathNodeAxial = Utility.WorldToAxialPosition(rawPath.First.Value);

        if (currentAxial == firstPathNodeAxial)
        {
            rawPath.RemoveFirst();
        }

        return(rawPath.First.Value);
    }
    private static void EnqueueNeighbors(Axial center, Dictionary <Axial, Node> closed, Queue <Axial> open)
    {
        for (int i = 0; i < AxialDirection.AllDirections.Length; i++)
        {
            Axial neighbor = center + AxialDirection.AllDirections[i];

            if (IsValidPoint(neighbor) && !closed.ContainsKey(neighbor) && !open.Contains(neighbor))
            {
                open.Enqueue(neighbor);
            }
        }
    }
示例#26
0
    private static void SpawnEnemiesAtPosition(Axial center, EntityCollection collection)
    {
        List <Axial> spawnablePositions = GetSpawnablePositions(center, collection.Count);

        foreach (Entity prefab in collection)
        {
            Axial position = spawnablePositions.Random();
            spawnablePositions.Remove(position);

            Entity instance = Entity.Instantiate(prefab);
            instance.transform.position = Utility.AxialToWorldPosition(position);
        }
    }
    /// <summary>
    /// Calculates a bitmask based on the surroundings of a tile
    /// </summary>
    /// <param name="center">The tile whose bitmask we're calculating. Hexagonal coordinate</param>
    /// <param name="allTiles">All tiles in hexagonal coordinates</param>
    /// <returns>The bitmask of <paramref name="center"/></returns>
    public static byte GetBitmask(Axial center, HashSet <Axial> allTiles)
    {
        byte bitmask = 0;

        foreach (AxialDirection direction in AxialDirection.AllDirections)
        {
            if (allTiles.Contains(center + direction))
            {
                bitmask |= direction;
            }
        }

        return(bitmask);
    }
    private bool IsPositionValidConnetionPoint(Axial point)
    {
        bool isValid = false;

        Utility.AdjacentHexagons(point, x =>
        {
            if (!Tiles.ContainsKey(x))
            {
                isValid = true;
            }
        });

        return(isValid);
    }
    private void PlaceOnLevel(LevelBuildData levelData, Axial offset)
    {
        Position = offset;

        foreach (var pair in Tiles)
        {
            levelData.AddTile(pair.Key + offset, pair.Value);
        }

        foreach (var pair in Prefabs)
        {
            levelData.AddPrefab(pair.Key + offset, pair.Value);
        }
    }
示例#30
0
    private static void ShouldSpawn(Axial position, LevelBuildData data, Theme theme)
    {
        int adjacentCount = 0;

        Utility.AdjacentHexagons(position, w =>
        {
            if (data.Tiles.ContainsKey(w))
            {
                adjacentCount++;
            }
        });

        if (adjacentCount >= SpawnFloorCount)
        {
            data.Tiles.Add(position, theme.FloorTile);
        }
    }
示例#31
0
文件: HexMath.cs 项目: tory37/HexGame
    public static Vector2 AxialToWorld(Axial axial, float pointRadius, OffsetType type)
    {
        float x;
        float y;

        if (type == OffsetType.EvenR || type == OffsetType.OddR)
        {
            x = pointRadius * Mathf.Sqrt( 3 ) * (axial.q + axial.r / 2);
            y = pointRadius * 3 / 2 * axial.r;
        }
        else
        {
            x = pointRadius * 3 / 2 * axial.q;
            y = pointRadius * Mathf.Sqrt( 3 ) * (axial.r + axial.q / 2);
        }

        return new Vector2( x, y );
    }