Esempio n. 1
0
    public static JobComponent ScheduleJobControllerInWorld(
        WorldComponent worldComponent, Job job)
    {
        GameObject   entityObject    = new GameObject();
        JobComponent entityComponent = entityObject.AddComponent <JobComponent>();

        entityObject.transform.SetParent(worldComponent.transform);

        IndicatorBar bar = IndicatorBar.Instantiate(entityObject);

        bar.GetSizeCallback = new IndicatorBar.GetSize(
            () => { return(job.CurrentStage().CurrentProgress()); }
            );

        entityObject.name   = job.id + "_indicator";
        entityComponent.job = job;

        PolygonCollider2D collider = entityObject.AddComponent <PolygonCollider2D>();

        collider.points = new Vector2[] {
            new Vector2(-0.5f, -0.5f),
            new Vector2(-0.5f, 0.5f),
            new Vector2(0.5f, 0.5f),
            new Vector2(0.5f, -0.5f)
        };

        entityComponent.spriteRenderer        = entityObject.AddComponent <SpriteRenderer>();
        entityComponent.spriteRenderer.sprite = SpriteLoader.GetSprite("test");

        return(entityComponent);
    }
Esempio n. 2
0
 public void BlockChange(Player p, BlockChangeEventArgs args)
 {
     p.OnPlayerBlockChange.Normal -= BlockChange;
     WorldComponent.GenerateTree(p, args.X, args.Z, args.Y, (TreeType)p.ExtraData["TreeType"], ServerSettings.GetSettingBoolean("TreesGoThrough"));
     args.Cancel();
     p.ExtraData.Remove("TreeType");
 }
Esempio n. 3
0
        public void Run()
        {
            WorldComponent world = _world.Components1[0];

            foreach (int i in _stoppedGhosts)
            {
                int ghostEntity = _stoppedGhosts.Entities[i];
                _ecsWorld
                .AddComponent <ChangeDirectionComponent>(ghostEntity)
                .NewDirection = Random.NextEnum <Directions>();
            }

            foreach (int i in _ghosts)
            {
                Vector2Int currentPosition = _ghosts.Components1[i].Position;
                foreach (int entity in world.WorldField[currentPosition.x][currentPosition.y])
                {
                    var player = _ecsWorld.GetComponent <PlayerComponent>(entity);
                    var isDead = _ecsWorld.GetComponent <PlayerIsDeadEvent>(entity);
                    if (player != null && isDead == null)
                    {
                        _ecsWorld.AddComponent <PlayerIsDeadEvent>(entity);
                    }
                }
            }
        }
Esempio n. 4
0
        /// <summary>
        /// Returns a populated world grid for testing.
        /// </summary>
        /// <returns></returns>
        private WorldGrid GetPopulatedWorldGrid()
        {
            WorldGrid grid = new WorldGrid(800, 800, 200, 200);

            // Populate
            float[] posX = new float[]
            {
                250, 450, 650, 750,
                210, 450,
                500,
                50, 250, 750
            };
            float[] posY = new float[]
            {
                50, 50, 50, 150,
                300, 300,
                500,
                700, 700, 700
            };
            for (int i = 0; i < posX.Length; i++)
            {
                WorldComponent comp = new WorldComponent();
                comp.Entity                     = new Entity(i);
                comp.PositionComponent          = new PositionComponent();
                comp.PositionComponent.Position =
                    new Vector2(posX[i], posY[i]);

                grid.Add(comp);
            }

            return(grid);
        }
Esempio n. 5
0
    private EnemyHealth GetClosest()
    {
        var stacks = COMPONENT_DATABASE.RetrieveComponents <EnemyHealth>();

        if (stacks.Count == 0)
        {
            return(null);
        }

        WorldComponent closest     = null;
        float          closestDist = float.MaxValue;

        foreach (var stack in stacks)
        {
            float dist = (stack.gameObject.transform.position - transform.position).magnitude;

            if (dist < closestDist)
            {
                closest     = stack;
                closestDist = dist;
            }
        }

        return((EnemyHealth)closest);
    }
Esempio n. 6
0
        public OctoGame() : base()
        {
            graphics = new GraphicsDeviceManager(this);
            Content.RootDirectory = "Content";
            this.Window.Title     = "OctoAwesome";

            graphics.PreferredBackBufferWidth  = 1280;
            graphics.PreferredBackBufferHeight = 720;
            this.IsMouseVisible = true;

            input             = new InputComponent(this);
            input.UpdateOrder = 1;
            Components.Add(input);

            world             = new WorldComponent(this, input);
            world.UpdateOrder = 2;
            Components.Add(world);

            //camera = new CameraComponent(this, world, input);
            //camera.UpdateOrder = 3;
            //Components.Add(camera);

            camera3d             = new Camera3DComponent(this, world);
            camera3d.UpdateOrder = 3;
            Components.Add(camera3d);

            render3d           = new Render3DComponent(this, world, camera3d);
            render3d.DrawOrder = 1;
            Components.Add(render3d);
        }
        private static bool GetManagerForPrefix(Pawn pawn, bool createIfMissing, WorldComponent __instance, ref object __result)
        {
            if (MP.IsInMultiplayer || !createIfMissing)
            {
                return(true);                                        // We don't care and let the method run, we only care if we might need to creat a VerbManager
            }
            var table      = mvcfManagersTableField.GetValue(__instance);
            var parameters = new object[] { pawn, null };

            if ((bool)conditionalWeakTableTryGetValueMethod.Invoke(table, parameters))
            {
                // Might as well give the result back instead of continuing the normal execution of the method,
                // as it would just do the same stuff as we do here again
                __result = parameters[1];
            }
            else
            {
                // We basically setup an empty reference, but we'll initialize it in the synced method.
                // We just return the reference for it so other objects can use it now. The data they
                // have will be updated after the sync, so the gizmos related to verbs might not be
                // shown immediately for players who selected specific pawns.
                __result = CreateAndAddVerbManagerToCollections(pawn, __instance, table: table);
            }

            // Ensure VerbManager is initialized for all players, as it might not be
            SyncedInitVerbManager(pawn);

            return(false);
        }
Esempio n. 8
0
        private void Body_OnCollision(Fixture fixtureA, Fixture fixtureB, VelcroPhysics.Collision.ContactSystem.Contact contact)
        {
            WorldComponent ground = (fixtureB.Body.UserData as WorldComponent);

            if (ground != null)
            {
                RectangleFloat bounds     = ground.Bounds;
                RectangleFloat heroBounds = Platman.Bounds;

                var bottom = Math.Abs(heroBounds.Bottom - bounds.Top);
                var top    = Math.Abs(heroBounds.Top - bounds.Bottom);
                var left   = Math.Abs(heroBounds.Left - bounds.Right);
                var right  = Math.Abs(heroBounds.Right - bounds.Left);

                float[] values = new float[] { bottom, top, left, right };

                Array.Sort(values);

                float edge = values[0];

                bool b = false;

                if (World.Gravity == VelocityValues.Instance.GravityDown)
                {
                    if (heroBounds.Bottom <= bounds.Top && bottom == edge)
                    {
                        b = true;
                    }
                }
                else if (World.Gravity == VelocityValues.Instance.GravityUp)
                {
                    if (heroBounds.Top > bounds.Bottom && top == edge)
                    {
                        b = true;
                    }
                }
                else if (World.Gravity == VelocityValues.Instance.GravityRight)
                {
                    if (heroBounds.Right <= bounds.Left && right == edge)
                    {
                        b = true;
                    }
                }
                else if (World.Gravity == VelocityValues.Instance.GravityLeft)
                {
                    if (heroBounds.Left > bounds.Right && left == edge)
                    {
                        b = true;
                    }
                }

                if (b)
                {
                    isOverGround = true;
                    overGround   = ground;
                    ApplyFallColisionImpulse();
                }
            }
        }
Esempio n. 9
0
 public BlueprintDamage(BlueprintDamageType type, short tileX, short tileY, sbyte level, WorldComponent component)
 {
     this.Type      = type;
     this.TileX     = tileX;
     this.TileY     = tileY;
     this.Level     = level;
     this.Component = component;
 }
Esempio n. 10
0
        private void Body_OnSeparation(Fixture fixtureA, Fixture fixtureB, VelcroPhysics.Collision.ContactSystem.Contact contact)
        {
            WorldComponent ground = (fixtureB.Body.UserData as WorldComponent);

            if (overGround == ground)
            {
                isOverGround = false;
            }
        }
Esempio n. 11
0
        public static Viewport GetCurrentViewport(GraphicsDevice graphicsDevice)
        {
            ComponentManager cm     = ComponentManager.GetInstance();
            WorldComponent   world  = (from w in cm.GetComponentsOfType <WorldComponent>().Values select w).First() as WorldComponent;
            Rectangle        bounds = new Rectangle(0, 0, graphicsDevice.Viewport.Width, graphicsDevice.Viewport.Height);

            bounds.Offset(world.Center - new Point(graphicsDevice.Viewport.Width / 2, graphicsDevice.Viewport.Height / 2));

            return(new Viewport(bounds));
        }
Esempio n. 12
0
        public Player()
        {
            _spritePoint = Point.Zero;
            //Position = Vector2.Zero;
            Position = new Vector2(16 * 16, 8 * 16);
            _world   = ComponentManager.Instance.GetInstance <WorldComponent>();

            RegisterEvents();

            _animation = new IdleAnimation();
        }
Esempio n. 13
0
 // PRIVATE MODIFIERS
 private void UpdateListenArea()
 {
     Collider2D[] col = Physics2D.OverlapCircleAll(transform.position, god.max_radius * listen_percent);
     //Debug.Log(col.Length);
     for (int i = 0; i < col.Length; ++i)
     {
         WorldComponent wc = col[i].gameObject.GetComponent <WorldComponent>();
         if (wc != null)
         {
             wc.TurnOn();
         }
     }
 }
Esempio n. 14
0
        public void Initialize()
        {
            worldEntity        = _world.CreateEntityWith <WorldComponent>();
            worldEntity.Width  = 320;
            worldEntity.Height = 240;

            LoadMap(Resources.Birb);



            var ballEntity = MakeBall();

            BuildWalls();
            BuildPaddle();
        }
Esempio n. 15
0
        public override float GetScore(Tile tile, int tileID)
        {
            // return 0f;

            if (!AlphaBiomes_Settings.AB_SpawnTarPits)
            {
                return(-100f);
            }
            if (tile.WaterCovered)
            {
                return(-100f);
            }
            if (tile.hilliness != Hilliness.Flat)
            {
                return(-100f);
            }
            if (tile.temperature < 0f)
            {
                return(0f);
            }
            if (tile.rainfall < 100f || tile.rainfall >= 600f)
            {
                return(0f);
            }
            Vector3 tileCenter = Find.WorldGrid.GetTileCenter(tileID);

            if (Find.World.GetComponent <WorldComponentExtender>() == null)
            {
                WorldComponent item = (WorldComponent)Activator.CreateInstance(typeof(WorldComponentExtender), new object[]
                {
                    Find.World
                });
                Find.World.components.Add(item);
            }

            float tileWeirdness = Find.World.GetComponent <WorldComponentExtender>().noiseWeirdness.GetValue(tileCenter);

            //Log.Message(tileWeirdness.ToString());
            if (tileWeirdness > 0.7f)
            {
                return(100f);
            }
            else
            {
                return(0f);
            }
        }
Esempio n. 16
0
        public override float GetScore(Tile tile, int tileID)
        {
            if (!AlphaBiomes_Settings.AB_SpawnOcularForest)
            {
                return(-100f);
            }
            float result;

            if (tile.WaterCovered)
            {
                result = -100f;
            }
            else if (tile.temperature < 15f)
            {
                result = 0f;
            }
            else if (tile.rainfall < 2000f)
            {
                result = 0f;
            }
            else
            {
                Vector3 tileCenter = Find.WorldGrid.GetTileCenter(tileID);
                if (Find.World.GetComponent <WorldComponentExtender>() == null)
                {
                    WorldComponent item = (WorldComponent)Activator.CreateInstance(typeof(WorldComponentExtender), new object[]
                    {
                        Find.World
                    });
                    Find.World.components.Add(item);
                }

                float tileWeirdness = Find.World.GetComponent <WorldComponentExtender>().noiseWeirdness.GetValue(tileCenter);
                //Log.Message(tileWeirdness.ToString());
                if (tileWeirdness < 0.15f)
                {
                    result = 100f;
                }
                else
                {
                    result = 0f;
                }
            }
            return(result);
        }
        // Helper method for creating an empty verb manager for a pawn
        private static object CreateAndAddVerbManagerToCollections(Pawn pawn, WorldComponent worldComponent, object list = null, object table = null)
        {
            var verbManager = mvcfVerbManagerCtor.Invoke(Array.Empty <object>());

            if (list == null)
            {
                list = mvcfAllManagersListField.GetValue(worldComponent);
            }
            if (table == null)
            {
                table = mvcfManagersTableField.GetValue(worldComponent);
            }

            conditionalWeakTableAddMethod.Invoke(table, new object[] { pawn, verbManager });
            ((IList)list).Add(weakReferenceCtor.Invoke(new object[] { verbManager }));

            return(verbManager);
        }
Esempio n. 18
0
        void RenderTiles(RenderHelper renderHelper)
        {
            ComponentManager cm             = ComponentManager.GetInstance();
            WorldComponent   world          = (from w in cm.GetComponentsOfType <WorldComponent>().Values select w).First() as WorldComponent;
            Viewport         viewport       = Extensions.GetCurrentViewport(renderHelper.graphicsDevice);
            Rectangle        viewportBounds = viewport.Bounds;

            foreach (var tile in world.Tiles)
            {
                Point     point      = new Point(tile.Key.X * tile.Value.Width, tile.Key.Y * tile.Value.Height);
                Rectangle tileBounds = new Rectangle(point.X, point.Y, tile.Value.Width, tile.Value.Height);

                if (viewportBounds.Intersects(tileBounds))
                {
                    renderHelper.spriteBatch.Draw(tile.Value, point.WorldToScreen(ref viewport).ToVector2(), null, Color.White, 0f, Vector2.Zero, 1f, SpriteEffects.None, (float)RenderLayer.Tiles);
                }
            }
        }
Esempio n. 19
0
    public bool AwareOfObject(WorldComponent obj)
    {
        RaycastHit2D hit = Physics2D.Linecast(transform.position, obj.transform.position);

        float dist = Vector2.Distance(transform.position, obj.transform.position);

        //Debug.Log("hit dist " + hit.distance);
        //Debug.Log("vision radius " + god.max_radius * listen_percent);

        if (hit != null)
        {
            float vision_radius = god.max_radius * listen_percent;
            if (vision_radius >= dist)
            {
                return(true);
            }
        }
        return(false);
    }
Esempio n. 20
0
    private void UpdateHypotheticalListenArea()
    {
        if (this != god.GetActiveNPC())
        {
            return;
        }

        Collider2D[] col = Physics2D.OverlapCircleAll(transform.position, god.GetHypotheticalPercent() * god.max_radius);
        //Debug.Log(col.Length);
        for (int i = 0; i < col.Length; ++i)
        {
            WorldComponent wc = col[i].gameObject.GetComponent <WorldComponent>();
            if (wc != null)
            {
                wc.TurnOn();
                wc.SetColored(true);
            }
        }
    }
    // Use this for initialization
    void Start()
    {
        PreInit();

        World = new World(200, 200);
        world.SetRegistry();

        GameObject       worldObject      = new GameObject();
        WorldComponent   worldComponent   = worldObject.AddComponent <WorldComponent>();
        GameObject       overlayObject    = new GameObject();
        OverlayComponent overlayComponent = overlayObject.AddComponent <OverlayComponent>();

        world.Connect(worldComponent);
        world.Connect(overlayComponent);

        world.Generate();

        cameraController.Center();
    }
Esempio n. 22
0
        public override float GetScore(Tile tile, int tileID)
        {
            if (!AlphaBiomes_Settings.AB_SpawnGelatinousSuperorganism)
            {
                return(-100f);
            }
            if (tile.WaterCovered)
            {
                return(-100f);
            }
            if (tile.temperature < -10f)
            {
                return(0f);
            }
            if (tile.rainfall < 600f)
            {
                return(0f);
            }

            Vector3 tileCenter = Find.WorldGrid.GetTileCenter(tileID);

            if (Find.World.GetComponent <WorldComponentExtender>() == null)
            {
                WorldComponent item = (WorldComponent)Activator.CreateInstance(typeof(WorldComponentExtender), new object[]
                {
                    Find.World
                });
                Find.World.components.Add(item);
            }

            float tileWeirdness = Find.World.GetComponent <WorldComponentExtender>().noiseWeirdness.GetValue(tileCenter);

            //Log.Message(tileWeirdness.ToString());
            if (tileWeirdness > 0.75f)
            {
                return(100f);
            }
            else
            {
                return(0f);
            }
            //return 15f + (tile.temperature - 7f) + (tile.rainfall - 600f) / 180f + tile.swampiness * 10f;
        }
Esempio n. 23
0
        public override float GetScore(Tile tile, int tileID)
        {
            if (!AlphaBiomes_Settings.AB_SpawnMechanoidIntrusion)
            {
                return(-100f);
            }
            if (tile.WaterCovered)
            {
                return(-100f);
            }
            if ((tile.temperature < 17f) || (tile.temperature > 25f))
            {
                return(0f);
            }
            if (tile.rainfall < 600f)
            {
                return(0f);
            }
            Vector3 tileCenter = Find.WorldGrid.GetTileCenter(tileID);

            if (Find.World.GetComponent <WorldComponentExtender>() == null)
            {
                WorldComponent item = (WorldComponent)Activator.CreateInstance(typeof(WorldComponentExtender), new object[]
                {
                    Find.World
                });
                Find.World.components.Add(item);
            }

            float tileRadiation = Find.World.GetComponent <WorldComponentExtender>().noiseRadiation.GetValue(tileCenter);

            // Log.Message(tileRadiation.ToString());
            if (tileRadiation > 0.75f)
            {
                return(101f);
            }
            else
            {
                return(0f);
            }
            //return 16f + (tile.temperature - 7f) + (tile.rainfall - 600f) / 180f;
        }
Esempio n. 24
0
        public void Run()
        {
            WorldComponent world = _world.Components1[0];

            foreach (int i in _moveableObjects)
            {
                Vector2Int newPosition   = _moveableObjects.Components1[i].NewPosition;
                int        movableEntity = _moveableObjects.Entities[i];

                foreach (int entity in world.WorldField[newPosition.x][newPosition.y])
                {
                    var portal = _ecsWorld.GetComponent <PortalComponent>(entity);
                    if (portal == null || portal.EstimateReloadTime > 0)
                    {
                        continue;
                    }

                    int otherPortalEntity = portal.OtherPortalEntity;
                    var otherPortal       = _ecsWorld.GetComponent <PortalComponent>(otherPortalEntity);

                    Vector2Int otherPortalPosition = _ecsWorld
                                                     .GetComponent <PositionComponent>(otherPortalEntity)
                                                     .Position;
                    _ecsWorld.AddComponent <TeleportingComponent>(movableEntity).NewPosition = otherPortalPosition;

                    portal.EstimateReloadTime      = PORTAL_RELOAD_TIME;
                    otherPortal.EstimateReloadTime = PORTAL_RELOAD_TIME;
                }
            }

            foreach (int i in _portals)
            {
                PortalComponent portalComponent = _portals.Components1[i];
                if (portalComponent.EstimateReloadTime > 0)
                {
                    portalComponent.EstimateReloadTime -= Time.deltaTime;
                }
            }
        }
Esempio n. 25
0
        public void Run()
        {
            WorldComponent world = _world.Components1[0];

            foreach (int i in _players)
            {
                Vector2Int newPosition  = _players.Components1[i].NewPosition;
                int        playerEntity = _players.Entities[i];

                foreach (int entity in world.WorldField[newPosition.x][newPosition.y])
                {
                    var item = _ecsWorld.GetComponent <ItemComponent>(entity);
                    if (item == null)
                    {
                        continue;
                    }

                    _ecsWorld.AddComponent <TakenItemComponent>(entity).PlayerEntity = playerEntity;
                    _ecsWorld.AddComponent <DestroyedWorldObjectComponent>(entity);
                }
            }
        }
Esempio n. 26
0
        public void Run()
        {
            WorldComponent world = _world.Components1[0];

            foreach (int i in _createEvents)
            {
                Transform newObject = _createEvents.Components1[i].Transform;
                int       entity    = _createEvents.Entities[i];

                Vector2Int position = newObject.position.ToVector2Int();
                world.WorldField[position.x][position.y].Add(entity);
                _ecsWorld.AddComponent <PositionComponent>(entity).Position     = position;
                _ecsWorld.AddComponent <WorldObjectComponent>(entity).Transform = newObject;
            }

            foreach (int i in _movedObjects)
            {
                PositionComponent positionComponent = _movedObjects.Components1[i];
                Vector2Int        oldPosition       = positionComponent.Position;
                Vector2Int        newPosition       = _movedObjects.Components2[i].NewPosition;
                int entity = _movedObjects.Entities[i];

                world.WorldField[oldPosition.x][oldPosition.y].Remove(entity);
                world.WorldField[newPosition.x][newPosition.y].Add(entity);

                positionComponent.Position = newPosition;
            }

            foreach (int i in _destroyedObjects)
            {
                Transform  objectToDestroy = _destroyedObjects.Components1[i].Transform;
                Vector2Int position        = _destroyedObjects.Components2[i].Position;
                int        entity          = _destroyedObjects.Entities[i];

                world.WorldField[position.x][position.y].Remove(entity);
                objectToDestroy.gameObject.SetActive(false);
                _ecsWorld.RemoveEntity(entity);
            }
        }
 public static void WorldComponentListTick()
 {
     while (true)
     {
         int index = Interlocked.Decrement(ref worldComponentTicks);
         if (index < 0)
         {
             return;
         }
         WorldComponent worldComponent = worldComponents[index];
         if (null != worldComponent) //TODO: is null-check and lock necessary?
         {
             try
             {
                 worldComponent.WorldComponentTick();
             }
             catch (Exception ex)
             {
                 Log.Error("Exception ticking World Component: " + worldComponent.ToStringSafe() + ex);
             }
         }
     }
 }
        private static object InitVerbManager(Pawn pawn, WorldComponent comp = null, object list = null, object table = null)
        {
            if (comp == null)
            {
                comp = (WorldComponent)mvcfGetWorldCompMethod.Invoke(null, Array.Empty <object>());
            }
            if (comp == null)
            {
                return(null);
            }
            if (table == null)
            {
                table = mvcfManagersTableField.GetValue(comp);
            }
            var    parameters = new object[] { pawn, null };
            object verbManager;

            // Try to find the verb manager first, as it might exist (and it will definitely exist for at least one player)
            if ((bool)conditionalWeakTableTryGetValueMethod.Invoke(table, parameters))
            {
                verbManager = parameters[1];
                // If the manager has the pawn assigned, it means it's initialized, if it's not - we initialize it
                if (mvcfPawnGetter.Invoke(verbManager, Array.Empty <object>()) == null)
                {
                    mvcfInitializeManagerMethod.Invoke(verbManager, new object[] { pawn });
                }
            }
            // If the verb manager doesn't exist, we create an empty one here and add it to the verb manager list and table, and then initialize it
            else
            {
                verbManager = CreateAndAddVerbManagerToCollections(pawn, comp, list, table);
                mvcfInitializeManagerMethod.Invoke(verbManager, new object[] { pawn });
            }

            return(verbManager);
        }
Esempio n. 29
0
    public static EntityComponent SpawnEntityControllerInWorld(
        WorldComponent worldComponent, Entity entity,
        Vector2 coord)
    {
        GameObject      entityObject    = new GameObject();
        EntityComponent entityComponent = entityObject.AddComponent <EntityComponent>();

        entityObject.transform.SetParent(worldComponent.transform);
        //entityComponent.SetPosition(coord);

        PolygonCollider2D collider = entityObject.AddComponent <PolygonCollider2D>();

        collider.points = new Vector2[] {
            new Vector2(-0.5f, -0.5f),
            new Vector2(-0.5f, 0.5f),
            new Vector2(0.5f, 0.5f),
            new Vector2(0.5f, -0.5f)
        };

        entityComponent.spriteRenderer        = entityObject.AddComponent <SpriteRenderer>();
        entityComponent.spriteRenderer.sprite = SpriteLoader.GetSprite("test");

        return(entityComponent);
    }
Esempio n. 30
0
 public BlueprintDamage(BlueprintDamageType type, short tileX, short tileY, sbyte level, WorldComponent component)
 {
     this.Type = type;
     this.TileX = tileX;
     this.TileY = tileY;
     this.Level = level;
     this.Component = component;
 }
Esempio n. 31
0
        public void Run()
        {
            GhostConfigComponent ghostConfig = _ghostConfig.Components1[0];
            WorldComponent       world       = _world.Components1[0];

            if (_enableEvents.EntitiesCount > 0)
            {
                foreach (int i in _ghosts)
                {
                    GameObject ghost       = _ghosts.Components2[i].Transform.gameObject;
                    int        ghostEntity = _ghosts.Entities[i];

                    bool isNew;
                    _ecsWorld
                    .EnsureComponent <GhostInFearStateComponent>(ghostEntity, out isNew)
                    .EstimateTime = ghostConfig.FearStateInSec;

                    if (isNew)
                    {
                        ghost.GetComponent <MeshRenderer>().material.color = ghostConfig.FearState;
                    }
                }
            }

            foreach (int i in _fearStateGhosts)
            {
                GhostComponent            ghostComponent = _fearStateGhosts.Components1[i];
                GhostInFearStateComponent fearState      = _fearStateGhosts.Components2[i];
                GameObject ghost       = _fearStateGhosts.Components3[i].Transform.gameObject;
                int        ghostEntity = _fearStateGhosts.Entities[i];

                fearState.EstimateTime -= Time.deltaTime;
                if (fearState.EstimateTime <= 0)
                {
                    _ecsWorld.RemoveComponent <GhostInFearStateComponent>(ghostEntity);

                    var material = ghost.GetComponent <MeshRenderer>().material;
                    switch (ghostComponent.GhostType)
                    {
                    case GhostTypes.BLINKY:
                        material.color = ghostConfig.Blinky;
                        break;

                    case GhostTypes.PINKY:
                        material.color = ghostConfig.Pinky;
                        break;

                    case GhostTypes.INKY:
                        material.color = ghostConfig.Inky;
                        break;

                    case GhostTypes.CLYDE:
                        material.color = ghostConfig.Clyde;
                        break;

                    default:
                        throw new ArgumentOutOfRangeException();
                    }

                    return;
                }

                Vector2Int currentPosition = _ecsWorld.GetComponent <PositionComponent>(ghostEntity).Position;
                foreach (int entity in world.WorldField[currentPosition.x][currentPosition.y])
                {
                    var player = _ecsWorld.GetComponent <PlayerComponent>(entity);
                    if (player == null)
                    {
                        continue;
                    }

                    player.Scores += ghostConfig.ScoresPerGhost;
                    _ecsWorld.CreateEntityWith <UpdateScoreTableEvent>();
                    _ecsWorld.AddComponent <DestroyedWorldObjectComponent>(ghostEntity);
                }
            }
        }
Esempio n. 32
0
 public void ApplyCamera(BasicEffect effect, WorldComponent component)
 {
     effect.View = State.Camera.View;
     effect.Projection = State.Camera.Projection;
     effect.World = component.World;
 }