Пример #1
0
        public Entity CreateGold(EntityCommandBuffer ecb, int2 xy, float3 pos)
        {
            Entity entity = ecb.CreateEntity(Gold);

            Sprite2DRenderer s = new Sprite2DRenderer();
            Translation      t = new Translation();
            WorldCoord       c = new WorldCoord();
            LayerSorting     l = new LayerSorting();

            t.Value = pos;

            c.x = xy.x;
            c.y = xy.y;

            // Only tint sprites if ascii
            s.color = GlobalGraphicsSettings.ascii
                ? new Unity.Tiny.Core2D.Color(0.964f, 0.749f, 0.192f)
                : Color.Default;
            if (GlobalGraphicsSettings.ascii)
            {
                s.color.a = 0;
            }

            s.sprite = SpriteSystem.IndexSprites[SpriteSystem.ConvertToGraphics((char)236)];
            l.layer  = 1;

            ecb.SetComponent(entity, s);
            ecb.SetComponent(entity, t);
            ecb.SetComponent(entity, c);
            ecb.SetComponent(entity, l);

            return(entity);
        }
Пример #2
0
        public void ResetPlayer(EntityCommandBuffer cb, Entity player, WorldCoord worldCoord, Translation translation)
        {
            CreatureDescription descr = CreatureDescriptions[(int)ECreatureId.Player];

            Creature c = new Creature {
                id = (int)ECreatureId.Player
            };
            HealthPoints hp = new HealthPoints {
                max = descr.health, now = descr.health
            };
            AttackStat att = new AttackStat {
                range = descr.attackRange
            };
            Level lvl = new Level {
                level = 1
            };
            ExperiencePoints exp = new ExperiencePoints {
                now = 0, next = LevelSystem.GetXPRequiredForLevel(1)
            };
            GoldCount gp = new GoldCount {
                count = 0
            };
            Mobile mobile = new Mobile {
                Destination = new float3(0, 0, 0), Initial = new float3(0, 0, 0), MoveTime = 0, Moving = false
            };
            Animated animated = new Animated {
                Id = descr.spriteId, Direction = Direction.Right, Action = Action.None, AnimationTime = 0, AnimationTrigger = false
            };
            Sight sight = new Sight {
                SightRadius = 4
            };
            TurnPriorityComponent tp = new TurnPriorityComponent {
                Value = -1
            };

            // Only tint sprites if ascii
            Sprite2DRenderer s = new Sprite2DRenderer();
            LayerSorting     l = new LayerSorting {
                order = 2
            };

            s.color  = GlobalGraphicsSettings.ascii ? descr.asciiColor : Color.Default;
            s.sprite = SpriteSystem.IndexSprites[SpriteSystem.ConvertToGraphics(descr.ascii)];
            l.layer  = 2;

            cb.SetComponent(player, s);
            cb.SetComponent(player, c);
            cb.SetComponent(player, l);
            cb.SetComponent(player, hp);
            cb.SetComponent(player, att);
            cb.SetComponent(player, lvl);
            cb.SetComponent(player, exp);
            cb.SetComponent(player, gp);
            cb.SetComponent(player, mobile);
            cb.SetComponent(player, animated);
            cb.SetComponent(player, sight);
            cb.SetComponent(player, worldCoord);
            cb.SetComponent(player, translation);
            cb.SetComponent(player, tp);
        }
Пример #3
0
        public Entity CreateSpearTrap(EntityCommandBuffer ecb, int2 xy, float3 pos)
        {
            Entity entity = ecb.CreateEntity(SpearTrap);

            Sprite2DRenderer s = new Sprite2DRenderer();
            Translation      t = new Translation();
            WorldCoord       c = new WorldCoord();
            LayerSorting     l = new LayerSorting();

            t.Value = pos;

            c.x = xy.x;
            c.y = xy.y;

            // Only tint sprites if ascii
            s.color = TinyRogueConstants.DefaultColor;
            if (GlobalGraphicsSettings.ascii)
            {
                s.color.a = 0;
            }
            s.sprite = SpriteSystem.IndexSprites[SpriteSystem.ConvertToGraphics('^')];
            l.order  = 1;

            ecb.SetComponent(entity, s);
            ecb.SetComponent(entity, t);
            ecb.SetComponent(entity, c);
            ecb.SetComponent(entity, l);

            return(entity);
        }
Пример #4
0
        public Entity CreateTile(EntityManager entityManager, int2 xy, float3 pos, Entity parent)
        {
            Entity           entity = entityManager.CreateEntity(Tile);
            Sprite2DRenderer s      = new Sprite2DRenderer();
            Translation      t      = new Translation();
            Parent           p      = new Parent();
            WorldCoord       c      = new WorldCoord(); // ViewCoord?

            p.Value = parent;
            t.Value = pos;

            c.x = xy.x;
            c.y = xy.y;

            // Only tint sprites if ascii
            s.color = TinyRogueConstants.DefaultColor;
            if (GlobalGraphicsSettings.ascii)
            {
                s.color.a = 0;
            }

            s.sprite = SpriteSystem.IndexSprites[SpriteSystem.ConvertToGraphics(' ')];

            entityManager.SetComponentData(entity, s);
            entityManager.SetComponentData(entity, t);
            entityManager.SetComponentData(entity, p);
            entityManager.SetComponentData(entity, c);

            return(entity);
        }
Пример #5
0
        public void LogItemsAt(WorldCoord playerCoord)
        {
            int2 playerPos = new int2(playerCoord.x, playerCoord.y);

            Entities.WithAll <Collectible>().ForEach(
                (Entity item, ref WorldCoord itemCoord, ref CanBePickedUp pickable) =>
            {
                if (playerPos.x == itemCoord.x && playerPos.y == itemCoord.y)
                {
                    logSystem.AddLog($"You found a {pickable.name}");
                }
            });
        }
Пример #6
0
        public void AddActionRequest(Action a, Entity e, WorldCoord loc, Direction direction, int priority)
        {
            if (!_actionQueue.IsCreated)
            {
                _actionQueue = new NativeQueue <ActionRequest>(Allocator.TempJob);
            }
            ActionRequest ar;

            ar.Act      = a;
            ar.Ent      = e;
            ar.Loc      = new uint2((uint)loc.x, (uint)loc.y);
            ar.Dir      = direction;
            ar.Priority = priority;
            _actionQueue.Enqueue(ar);
        }
Пример #7
0
        public void CollectItemsAt(EntityCommandBuffer ecb, WorldCoord playerCoord)
        {
            int2 playerPos = new int2(playerCoord.x, playerCoord.y);

            Entities.WithAll <Collectible>().ForEach(
                (Entity item, ref WorldCoord itemCoord, ref CanBePickedUp pickable) =>
            {
                if (playerPos.x == itemCoord.x && playerPos.y == itemCoord.y)
                {
                    logSystem.AddLog($"You picked up a {pickable.name}");
                    AddItem(pickable);

                    ecb.DestroyEntity(item);
                }
            });
        }
Пример #8
0
        public void CreateCollectible(EntityCommandBuffer ecb, int2 xy, float3 pos)
        {
            Entity entity = ecb.CreateEntity(Collectible);

            Sprite2DRenderer s  = new Sprite2DRenderer();
            Translation      t  = new Translation();
            WorldCoord       c  = new WorldCoord();
            LayerSorting     l  = new LayerSorting();
            CanBePickedUp    p  = new CanBePickedUp();
            HealthBonus      hb = new HealthBonus();

            t.Value = pos;

            c.x = xy.x;
            c.y = xy.y;

            // Only tint sprites if ascii
            s.color = GlobalGraphicsSettings.ascii
                ? new Unity.Tiny.Core2D.Color(1, 1, 1)
                : Color.Default;
            if (GlobalGraphicsSettings.ascii)
            {
                s.color.a = 0;
            }

            l.layer = 1;

            p.appearance.color  = s.color;
            p.appearance.sprite = SpriteSystem.IndexSprites[SpriteSystem.ConvertToGraphics('S')];   //defaults

            p.name        = new NativeString64("unknown pickup");
            p.description = new NativeString64("Check collectible gen");

            var collectibleGenSystem = World.Active.GetOrCreateSystem <CollectibleGenSystem>();

            collectibleGenSystem.GetRandomCollectible(ecb, entity, p, hb);
            s.sprite = p.appearance.sprite;

            ecb.SetComponent(entity, s);
            ecb.SetComponent(entity, t);
            ecb.SetComponent(entity, c);
            ecb.SetComponent(entity, l);
            ecb.SetComponent(entity, p);
        }
Пример #9
0
 private void PlacePlayer(bool reset)
 {
     // Place the player
     Entities.WithAll <PlayerInput>().ForEach((Entity player) =>
     {
         int2 randomStartPosition = GetPlayerStartPosition();
         WorldCoord worldCoord    = new WorldCoord {
             x = randomStartPosition.x, y = randomStartPosition.y
         };
         Translation translation = new Translation {
             Value = _view.ViewCoordToWorldPos(randomStartPosition)
         };
         if (reset)
         {
             _creatureLibrary.ResetPlayer(_ecb, player, worldCoord, translation);
         }
         else
         {
             _ecb.SetComponent(player, worldCoord);
             _ecb.SetComponent(player, translation);
         }
     });
 }
Пример #10
0
        public Entity CreateHealingItem(EntityCommandBuffer ecb, int2 xy, float3 pos, int healAmount)
        {
            Entity entity = ecb.CreateEntity(HealingPotion);

            HealItem         heal = new HealItem();
            Sprite2DRenderer s    = new Sprite2DRenderer();
            Translation      t    = new Translation();
            WorldCoord       c    = new WorldCoord();
            LayerSorting     l    = new LayerSorting();

            t.Value = pos;

            c.x = xy.x;
            c.y = xy.y;

            // Only tint sprites if ascii
            s.color = GlobalGraphicsSettings.ascii
                ? new Unity.Tiny.Core2D.Color(1.0f, 0.26f, 0.23f)
                : Color.Default;
            if (GlobalGraphicsSettings.ascii)
            {
                s.color.a = 0;
            }

            s.sprite = SpriteSystem.IndexSprites[SpriteSystem.ConvertToGraphics((char)235)];
            l.layer  = 1;

            heal.HealAmount = healAmount;

            ecb.SetComponent(entity, s);
            ecb.SetComponent(entity, t);
            ecb.SetComponent(entity, c);
            ecb.SetComponent(entity, l);
            ecb.SetComponent(entity, heal);

            return(entity);
        }
Пример #11
0
        public Entity CreateDoorway(EntityCommandBuffer ecb, int2 xy, float3 pos, bool horizontal)
        {
            Entity entity = ecb.CreateEntity(Doorway);

            Sprite2DRenderer s = new Sprite2DRenderer();
            Translation      t = new Translation();
            WorldCoord       c = new WorldCoord();
            LayerSorting     l = new LayerSorting();
            Door             d = new Door();

            d.Horizontal = horizontal;
            t.Value      = pos;

            c.x = xy.x;
            c.y = xy.y;

            // Only tint sprites if ascii
            s.color = GlobalGraphicsSettings.ascii
                ? new Unity.Tiny.Core2D.Color(18 / 255.0f, 222 / 255.0f, 23.0f / 255.0f)
                : Color.Default;
            if (GlobalGraphicsSettings.ascii)
            {
                s.color.a = 0;
            }

            s.sprite = SpriteSystem.IndexSprites[SpriteSystem.ConvertToGraphics(horizontal ? '\\' : '/')];
            // Have to draw above character in graphical
            l.layer = (short)(GlobalGraphicsSettings.ascii ? 1 : 3);

            ecb.SetComponent(entity, s);
            ecb.SetComponent(entity, t);
            ecb.SetComponent(entity, c);
            ecb.SetComponent(entity, l);
            ecb.SetComponent(entity, d);

            return(entity);
        }
Пример #12
0
 public void AddPlayerActionRequest(Action a, Entity e, WorldCoord loc, Direction direction, int priority)
 {
     AddActionRequest(a, e, loc, direction, priority);
     NeedToTickTurn    = true;
     NeedToTickDisplay = true;
 }
Пример #13
0
        protected override JobHandle OnUpdate(JobHandle inputDependencies)
        {
            if (_cachedMapSize.x != _gss.View.Width || _cachedMapSize.y != _gss.View.Height)
            {
                ResizeMaps(_gss.View.Width, _gss.View.Height);
            }

            var clearJob = new ClearMapsJob()
            {
                FlagsMap  = _flagMap,
                EntityMap = _entityMap
            };

            var clearJobHandle = clearJob.Schedule(inputDependencies);

            var fillJob = new FillMapsJob()
            {
                MapSize             = _cachedMapSize,
                FlagsMap            = _flagMap,
                EntityMap           = _entityMap,
                EntityType          = GetArchetypeChunkEntityType(),
                WorldCoordType      = GetArchetypeChunkComponentType <WorldCoord>(true),
                BlockedMovementType = GetArchetypeChunkComponentType <BlockMovement>(true),
                DoorType            = GetArchetypeChunkComponentType <Door>(true),
                HostileType         = GetArchetypeChunkComponentType <tag_Attackable>(true),
                PlayerType          = GetArchetypeChunkComponentType <Player>(true)
            };
            var fillJobHandle = fillJob.Schedule(_mapFillQuery, clearJobHandle);

            var pendingMoves        = new NativeQueue <PendingMove>(Allocator.TempJob);
            var pendingWaits        = new NativeQueue <PendingWait>(Allocator.TempJob);
            var pendingAttacks      = new NativeQueue <PendingAttack>(Allocator.TempJob);
            var pendingOpens        = new NativeQueue <PendingDoorOpen>(Allocator.TempJob);
            var pendingInteractions = new NativeQueue <PendingInteractions>(Allocator.TempJob);

            var actionJob = new ConsumeActionsJob()
            {
                MapSize             = _cachedMapSize,
                ActionQueue         = _tms.ActionQueue,
                FlagsMap            = _flagMap,
                EntityMap           = _entityMap,
                PendingMoves        = pendingMoves,
                PendingWaits        = pendingWaits,
                PendingAttacks      = pendingAttacks,
                PendingOpens        = pendingOpens,
                PendingInteractions = pendingInteractions
            };
            var actionJobHandle = actionJob.Schedule(fillJobHandle);

            actionJobHandle.Complete();

            // TODO: Jobify?
            var         log = EntityManager.World.GetExistingSystem <LogSystem>();
            PendingMove pm;

            while (pendingMoves.TryDequeue(out pm))
            {
                var trans = _gss.View.ViewCoordToWorldPos(new int2(pm.Wc.x, pm.Wc.y));
                if (GlobalGraphicsSettings.ascii)
                {
                    EntityManager.SetComponentData(pm.Ent, new Translation {
                        Value = trans
                    });
                }
                else
                {
                    var anim   = EntityManager.World.GetExistingSystem <AnimationSystem>();
                    var mobile = EntityManager.GetComponentData <Mobile>(pm.Ent);
                    mobile.Initial     = EntityManager.GetComponentData <Translation>(pm.Ent).Value;
                    mobile.Destination = trans;
                    EntityManager.SetComponentData(pm.Ent, mobile);
                    anim.StartAnimation(pm.Ent, Action.Move, pm.Dir);
                    _inv.LogItemsAt(pm.Wc);
                }
                EntityManager.SetComponentData(pm.Ent, pm.Wc);
            }

            PendingWait pw;

            while (pendingWaits.TryDequeue(out pw))
            {
                if (EntityManager.HasComponent <Player>(pw.Ent))
                {
                    log.AddLog(pw.Ouch ? "You bumped into a wall. Ouch." : "You wait a turn.");
                }

                var anim = EntityManager.World.GetExistingSystem <AnimationSystem>();
                anim.StartAnimation(pw.Ent, pw.Ouch ? Action.Bump : Action.Wait, pw.Dir);
            }

            int pendingAttackCount = pendingAttacks.Count;

            if (pendingAttackCount > 0)
            {
                NativeArray <PendingAttack> sortedPendingAttacks =
                    new NativeArray <PendingAttack>(pendingAttackCount, Allocator.Temp);
                for (int i = 0; i < pendingAttackCount; i++)
                {
                    sortedPendingAttacks[i] = pendingAttacks.Dequeue();
                }

                sortedPendingAttacks.Sort(new PendingAttackComparer());
                for (int i = 0; i < pendingAttackCount; i++)
                {
                    PendingAttack pa         = sortedPendingAttacks[i];
                    AttackStat    att        = EntityManager.GetComponentData <AttackStat>(pa.Attacker);
                    Creature      attacker   = EntityManager.GetComponentData <Creature>(pa.Attacker);
                    HealthPoints  hp         = EntityManager.GetComponentData <HealthPoints>(pa.Defender);
                    Creature      defender   = EntityManager.GetComponentData <Creature>(pa.Defender);
                    HealthPoints  attackerHp = EntityManager.GetComponentData <HealthPoints>(pa.Attacker);
                    ArmorClass    defAC      = EntityManager.GetComponentData <ArmorClass>(pa.Defender);

                    if (attackerHp.now <= 0) // don't let the dead attack, is this hack? Maybe.
                    {
                        continue;
                    }
                    string attackerName = CreatureLibrary.CreatureDescriptions[attacker.id].name;
                    string defenderName = CreatureLibrary.CreatureDescriptions[defender.id].name;

                    // Play animation even if the creature misses
                    var anim = EntityManager.World.GetExistingSystem <AnimationSystem>();
                    anim.StartAnimation(pa.Attacker, Action.Attack, pa.AttackerDir);

                    if (DiceRoller.Roll(1, 20, 0) >= defAC.AC)
                    {
                        int  dmg      = RandomRogue.Next(att.range.x, att.range.y);
                        bool firstHit = hp.now == hp.max;

                        hp.now -= dmg;

                        bool playerAttack = attackerName == "Player";
                        bool killHit      = hp.now <= 0;

                        string logStr;

                        if (playerAttack && killHit && firstHit)
                        {
                            logStr = string.Concat("You destroy the ", defenderName);
                            logStr = string.Concat(logStr, ".");
                            ExperiencePoints xp = EntityManager.GetComponentData <ExperiencePoints>(pa.Attacker);
                            xp.now += hp.max; //XP awarded equals the defenders max hp
                            EntityManager.SetComponentData(pa.Attacker, xp);
                        }
                        else if (playerAttack)
                        {
                            logStr = string.Concat(string.Concat(string.Concat(string.Concat(
                                                                                   "You hit the ",
                                                                                   defenderName),
                                                                               " for "),
                                                                 dmg.ToString()),
                                                   " damage!");

                            if (killHit)
                            {
                                logStr = string.Concat(logStr, " Killing it.");
                                ExperiencePoints xp = EntityManager.GetComponentData <ExperiencePoints>(pa.Attacker);
                                xp.now += hp.max; //XP awarded equals the defenders max hp
                                EntityManager.SetComponentData(pa.Attacker, xp);
                            }
                        }
                        else
                        {
                            bool playerHit = false;
                            if (defenderName == "Player")
                            {
                                defenderName = "you";
                                playerHit    = true;
                            }

                            logStr = string.Concat(string.Concat(string.Concat(string.Concat(string.Concat(
                                                                                                 attackerName,
                                                                                                 " hits "),
                                                                                             defenderName),
                                                                               " for "),
                                                                 dmg.ToString()),
                                                   " damage!");

                            if (playerHit)
                            {
                                _gss.LastPlayerHurtLog = logStr;
                            }
                        }

                        log.AddLog(logStr);

                        EntityManager.SetComponentData(pa.Defender, hp);
                    }
                    else
                    {
                        string logStr = attackerName;
                        logStr = string.Concat(logStr, " swings at ");
                        logStr = string.Concat(logStr, defenderName);
                        logStr = string.Concat(logStr, ".  But missed!");

                        log.AddLog(logStr);
                    }
                }

                sortedPendingAttacks.Dispose();
            }

            PendingDoorOpen pd;

            while (pendingOpens.TryDequeue(out pd))
            {
                if (EntityManager.HasComponent <Player>(pd.OpeningEntity))
                {
                    log.AddLog("You opened a door.");
                }
                Sprite2DRenderer s = EntityManager.GetComponentData <Sprite2DRenderer>(pd.DoorEnt);
                var door           = EntityManager.GetComponentData <Door>(pd.DoorEnt);
                door.Locked = false;
                door.Opened = true;
                EntityManager.RemoveComponent(pd.DoorEnt, typeof(BlockMovement));
                EntityManager.SetComponentData(pd.DoorEnt, door);
                EntityManager.SetComponentData(pd.DoorEnt, s);
            }

            PendingInteractions pi;

            while (pendingInteractions.TryDequeue(out pi))
            {
                using (var entities = EntityManager.GetAllEntities(Allocator.TempJob))
                {
                    foreach (Entity e in entities)
                    {
                        if (EntityManager.HasComponent(e, typeof(WorldCoord)) &&
                            EntityManager.HasComponent(e, typeof(Collectible)))
                        {
                            WorldCoord coord = EntityManager.GetComponentData <WorldCoord>(e);
                            int2       ePos  = new int2(coord.x, coord.y);

                            if (pi.InteractPos.x == ePos.x && pi.InteractPos.y == ePos.y)
                            {
                                _inv.CollectItemsAt(new EntityCommandBuffer(Allocator.TempJob), coord);
                            }
                        }

                        if (EntityManager.HasComponent(e, typeof(WorldCoord)) &&
                            EntityManager.HasComponent(e, typeof(Stairway)))
                        {
                            WorldCoord coord = EntityManager.GetComponentData <WorldCoord>(e);
                            int2       ePos  = new int2(coord.x, coord.y);

                            if (pi.InteractPos.x == ePos.x && pi.InteractPos.y == ePos.y)
                            {
                                if (EntityManager.HasComponent(e, typeof(Stairway)))
                                {
                                    _gss.MoveToNextLevel(new EntityCommandBuffer(Allocator.TempJob));
                                }
                            }
                        }
                    }
                }
            }

            // Cleanup
            pendingMoves.Dispose();
            pendingAttacks.Dispose();
            pendingWaits.Dispose();
            pendingOpens.Dispose();
            pendingInteractions.Dispose();

            return(actionJobHandle);
        }