Esempio n. 1
0
 public void ConsumeTurn(Dungeon.Dungeon dungeon)
 {
     if (_character != null)
     {
         _character.TickTurn_Status();
         _character.Tick_StatRegen();
     }
 }
Esempio n. 2
0
        protected MoveResult Move(Dungeon.Dungeon dungeon, MoveDirection dir, bool isPlayer)
        {
            if (_character == null)
            {
                return(MoveResult.None);
            }

            var move = DirectionToVec(dir);

            return(Character.Move(move, isPlayer));
        }
Esempio n. 3
0
        private void TickTargetPosition(Dungeon.Dungeon dungeon)
        {
            if (_itemPendingUseFromTargetPosition == null)
            {
                _mode = InputMode.Character;
                //_targetGameObject?.SetActive(false);
                if (_targetGameObject != null)
                {
                    GameObject.Destroy(_targetGameObject);
                }
                return;
            }

            if (Input.GetKeyDown(KeyCode.Escape))
            {
                _mode = InputMode.Character;
                _itemPendingUseFromTargetPosition = null;
                //_targetGameObject?.SetActive(false);
                if (_targetGameObject != null)
                {
                    GameObject.Destroy(_targetGameObject);
                }
                return;
            }

            if (Input.GetKeyDown(KeyCode.E))
            {
                _mode = InputMode.Character;
                if (Character.TryCastSpell(_itemPendingUseFromTargetPosition, _targetPosition))
                {
                    SpendTurn(dungeon);
                }

                _itemPendingUseFromTargetPosition = null;
                //_targetGameObject?.SetActive(false);
                if (_targetGameObject != null)
                {
                    GameObject.Destroy(_targetGameObject);
                }
                return;
            }

            MoveResult    result = MoveResult.None;
            MoveDirection dir    = CheckMoveInput();
            var           move   = DirectionToVec(dir);

            _targetPosition += move;
            if (_targetGameObject != null)
            {
                _targetGameObject.transform.position = new Vector3(_targetPosition.x, _targetPosition.y, 0);
            }
        }
Esempio n. 4
0
        public override void Tick(Dungeon.Dungeon dungeon)
        {
            switch (_mode)
            {
            case InputMode.Character:
                TickCharacter(dungeon);
                break;

            case InputMode.TargetPosition:
                TickTargetPosition(dungeon);
                break;
            }
        }
Esempio n. 5
0
        public void UpdateVisibility(Dungeon.Dungeon dungeon)
        {
            if (Character != null)
            {
                foreach (var tile in dungeon.Tiles)
                {
                    if (Character.Context.FieldOfView.ContainsKey(tile.Key))
                    {
                        tile.Value.Visibility(true);
                    }
                    else
                    {
                        tile.Value.Visibility(false);
                    }
                }

                foreach (var character in dungeon.Characters)
                {
                    if (character == Character)
                    {
                        continue;
                    }

                    if (Character.Context.FieldOfView.ContainsKey(character.Position))
                    {
                        character.Visibility(true);
                    }
                    else
                    {
                        character.Visibility(false);
                    }
                }

                foreach (var item in dungeon.WorldItems)
                {
                    if (Character.Context.FieldOfView.ContainsKey(item.WorldPosition))
                    {
                        item.Visibility(true);
                    }
                    else
                    {
                        item.Visibility(false);
                    }
                }
            }
        }
Esempio n. 6
0
        private void SpendTurn(Dungeon.Dungeon dungeon)
        {
            // We tick the AI first, so that we're not updating status effects until NPCs have had the chance to add new ones.
            dungeon.TickAI();

            if (Character == null || Character.IsDead)
            {
                return;
            }

            ConsumeTurn(dungeon);
            Character.TickTurn_Sensors();

            UpdateVisibility(dungeon);

            UpdateMap();
            UpdateInventory();
            UpdateScraps();
            UpdateStatuses();
        }
Esempio n. 7
0
        public override void Tick(Dungeon.Dungeon dungeon)
        {
            if (Character == null || Character.IsDead)
            {
                return;
            }

            Character.TickTurn_Sensors();

            if (_brain != null)
            {
                int steps = 0;
                Character.Context.SetState(CharacterWorldState.HasConsumedTurn, false, EffectType.Permanent);
                while (Character.Context.HasState(CharacterWorldState.HasConsumedTurn) == false)
                {
                    steps++;
                    _brainHandler.Tick(_brain, Character.Context);
                    if (steps > 10)
                    {
                        break;
                    }
                }

                if (Character.Context.LogDecomposition)
                {
                    UnityEngine.Debug.Log("---------------------- DECOMP LOG --------------------------");
                    while (Character.Context.DecompositionLog?.Count > 0)
                    {
                        var entry = Character.Context.DecompositionLog.Dequeue();
                        var depth = FluidHTN.Debug.Debug.DepthToString(entry.Depth);
                        //Console.ForegroundColor = entry.Color;
                        var color = ColorUtility.ToHtmlStringRGB(FromColor(entry.Color));
                        UnityEngine.Debug.Log($"<color={color}>{depth}{entry.Name}: {entry.Description}</color>");
                    }
                    //Console.ResetColor();
                    UnityEngine.Debug.Log("-------------------------------------------------------------");
                }
            }

            ConsumeTurn(dungeon);
        }
Esempio n. 8
0
        public static bool IsConnected(Dungeon dungeon, DungeonTheme theme, int2 start, int2 end)
        {
            List <int2> closed = new List <int2>();

            return(Floodfill(dungeon, theme, start, end, closed));
        }
Esempio n. 9
0
        private void AddCaveFeatures(Dungeon dungeon, bool leftToRight, bool upToDown, int maxModifications)
        {
            if (maxModifications <= 0)
            {
                return;
            }

            var halfWidth  = _meta.Width / 2;
            var halfHeight = _meta.Height / 2;

            int modifications = 0;
            var startIndexW   = leftToRight ? -halfWidth : halfWidth;
            var endIndexW     = leftToRight ? halfWidth : -halfWidth;
            var incrementW    = leftToRight ? 1 : -1;
            var startIndexH   = upToDown ? -halfHeight : halfHeight;
            var endIndexH     = upToDown ? halfHeight : -halfHeight;
            var incrementH    = upToDown ? 1 : -1;

            for (var dx = startIndexW; dx <= endIndexW; dx += incrementW)
            {
                for (var dy = startIndexH; dy <= endIndexH; dy += incrementH)
                {
                    var x   = _meta.CenterX + dx;
                    var y   = _meta.CenterY + dy;
                    var key = new int2(x, y);

                    if (dungeon.ValueMap.ContainsKey(key) == false)
                    {
                        continue;
                    }

                    var value = dungeon.ValueMap[key];
                    if (value.Room != this)
                    {
                        continue;
                    }

                    if (value.Index == DungeonTile.Index.Wall)
                    {
                        if (GetAdjacentIndex(dungeon, key, BuilderDirection.East) == DungeonTile.Index.Wall &&
                            GetAdjacentIndex(dungeon, key, BuilderDirection.West) == DungeonTile.Index.Floor)
                        {
                            if (TryConvertIndexAtoB(dungeon, key, BuilderDirection.West, DungeonTile.Index.Floor,
                                                    DungeonTile.Index.Wall, 10))
                            {
                                modifications++;
                            }
                        }
                        else if (GetAdjacentIndex(dungeon, key, BuilderDirection.East) == DungeonTile.Index.Floor &&
                                 GetAdjacentIndex(dungeon, key, BuilderDirection.West) == DungeonTile.Index.Wall)
                        {
                            if (TryConvertIndexAtoB(dungeon, key, BuilderDirection.East, DungeonTile.Index.Floor,
                                                    DungeonTile.Index.Wall, 10))
                            {
                                modifications++;
                            }
                        }

                        if (GetAdjacentIndex(dungeon, key, BuilderDirection.North) == DungeonTile.Index.Wall &&
                            GetAdjacentIndex(dungeon, key, BuilderDirection.South) == DungeonTile.Index.Floor)
                        {
                            if (TryConvertIndexAtoB(dungeon, key, BuilderDirection.South, DungeonTile.Index.Floor,
                                                    DungeonTile.Index.Wall, 10))
                            {
                                modifications++;
                            }
                        }
                        else if (GetAdjacentIndex(dungeon, key, BuilderDirection.North) == DungeonTile.Index.Floor &&
                                 GetAdjacentIndex(dungeon, key, BuilderDirection.South) == DungeonTile.Index.Wall)
                        {
                            if (TryConvertIndexAtoB(dungeon, key, BuilderDirection.North, DungeonTile.Index.Floor,
                                                    DungeonTile.Index.Wall, 10))
                            {
                                modifications++;
                            }
                        }
                    }

                    if (modifications >= maxModifications)
                    {
                        return;
                    }
                }
            }
        }
Esempio n. 10
0
 public abstract void Tick(Dungeon.Dungeon dungeon);
Esempio n. 11
0
        private void TickCharacter(Dungeon.Dungeon dungeon)
        {
            if (Character == null || Character.IsDead)
            {
                return;
            }

            // Cheats
            if (Input.GetKey(KeyCode.LeftShift) && Input.GetKeyDown(KeyCode.Alpha1))
            {
                Character.AddTimedStatus(CharacterStatusType.Stunned, 2);
                Debug.Log($"{Character.name} got stunned!");
                return;
            }
            else if (Input.GetKey(KeyCode.LeftShift) && Input.GetKeyDown(KeyCode.Alpha2))
            {
                Character.GodMode = !Character.GodMode;
                return;
            }

            // Logic

            if (Input.GetKeyDown(KeyCode.E))
            {
                var item = dungeon.GetItemAt(Character.Position);
                if (item == null)
                {
                    item = dungeon.GetItemAt(Character.Position + _lastMoveDir);
                    if (item == null)
                    {
                        return;
                    }
                }

                if (Character.TryInteract(item) == false)
                {
                    return;
                }
            }
            else if (GetInventoryKeyDown(out var index))
            {
                if (index >= Character.Inventory.Count)
                {
                    return;
                }

                var item = Character.Inventory[index];
                if (item.Meta.Type == ItemType.Weapon && Character.PrimaryWeapon != item)
                {
                    Character.SetPrimaryWeapon(item);
                }
                else if (item.Meta.Type == ItemType.Spell)
                {
                    if (Character.CanCastSpell(item) == false)
                    {
                        return;
                    }

                    _itemPendingUseFromTargetPosition = item;
                    _mode           = InputMode.TargetPosition;
                    _targetPosition = Character.FindDefaultTargetPosition(item, _lastMoveDir);

                    _targetGameObject = GameObject.Instantiate(_targetGameObjectPrefab);
                    _targetGameObject.SetActive(false);
                    _targetGameObject.transform.position = new Vector3(_targetPosition.x, _targetPosition.y, 0);

                    var shape  = item.GetAbilityShape(Character.Context);
                    var radius = item.GetLocalImpactRadius(Character.Context);

                    if (radius > 0)
                    {
                        var sqRad = radius * radius;
                        for (var y = -radius; y <= radius; y++)
                        {
                            for (var x = -radius; x <= radius; x++)
                            {
                                if (x == 0 && y == 0)
                                {
                                    continue;
                                }

                                var p = new int2(x, y);
                                if (shape == AbilityShape.FilledCircle)
                                {
                                    var sqDist = math.distancesq(p, int2.zero);
                                    if (sqDist > sqRad)
                                    {
                                        continue;
                                    }
                                }

                                var childTarget = new GameObject("T").AddComponent <SpriteRenderer>();
                                childTarget.sprite = _targetGameObject.GetComponent <SpriteRenderer>().sprite;
                                childTarget.transform.SetParent(_targetGameObject.transform, false);
                                childTarget.transform.localPosition = new Vector3(x, y, 0);
                            }
                        }
                    }

                    _targetGameObject?.SetActive(true);
                    return;
                }
                else
                {
                    return;
                }
            }
            else
            {
                MoveResult    result = MoveResult.None;
                MoveDirection dir    = CheckMoveInput();

                if (dir != MoveDirection.None)
                {
                    result       = Move(dungeon, dir, true);
                    _lastMoveDir = DirectionToVec(dir);
                }

                // We did not consume a turn
                if (result == MoveResult.None)
                {
                    return;
                }

                if (result == MoveResult.Collided)
                {
                    _forceKeyDown = true;
                    return;
                }

                if (result == MoveResult.Bump)
                {
                    if (Character.Context.CurrentBumpTarget != null)
                    {
                        if (Character.Context.CurrentBumpTarget is Character.Character c)
                        {
                            Character.Melee(c);
                        }

                        _forceKeyDown = true;
                    }
                    else
                    {
                        Debug.LogError("This should never happen");
                    }
                }
            }

            SpendTurn(dungeon);
        }