Example #1
0
        public void Create()
        {
            if (DisableAll)
            {
                return;
            }

            var entity = new Entity();

            entity.AddComponents(new EffectComponent {
                Update = dt => {
                    var x = 0.0f;

                    m_Time += dt;
                    if (Duration > 0.0f)
                    {
                        x = m_Time / Duration;
                    }

                    Update(x);
                }
            });

            Begin();

            if (Duration > 0.0f)
            {
                entity.AddComponent(new LifetimeComponent {
                    EndOfLife = End,
                    Lifetime  = Duration
                });
                Game.Inst.Scene.AddEntity(entity);
            }
        }
Example #2
0
        public static Entity GetNose(Color color, float angle = 0, float distFromParent = 8)
        {
            float radius = 5f;

            var noseEntity = new Entity("nose");

            var pos = distFromParent * new Vector2((float)Math.Cos(angle), (float)Math.Sin(angle));

            var transform = new TransformComponent(noseEntity)
            {
                LocalPosition = pos,
                LocalRotation = new Rotation(angle),
                LocalDepth    = 0.095f,
                Scale         = new Vector2(1, 1)
            };

            var graphics = new GraphicsComponent(noseEntity)
            {
                TexturePath = TextureAtlas.NosePath,
                Dimensions  = new Point((int)(radius * 2), (int)(radius * 2)),
                Color       = color
            };

            var noseComp = new NoseComponent(noseEntity)
            {
                NoseRange = 50,
            };

            noseEntity.AddComponents(transform, graphics, noseComp);

            return(noseEntity);
        }
Example #3
0
    public void AddSingletonComponent <T>(T singletonComponent, params EntityComponent[] entityComponents) where T : EntityMasterComponent
    {
        string singletonId = typeof(T).FullName;
        Entity entity      = CreateEntity(singletonId, singletonComponent);

        entity.AddComponents(entityComponents);
    }
        protected override void ApplicationStarted()
        {
            var componentNamespace = typeof(Component1).Namespace;

            _availableComponentTypes = _groupFactory.GetComponentTypes
                                       .Where(x => x.Namespace == componentNamespace)
                                       .ToArray();

            _availableComponents = _availableComponentTypes
                                   .Select(x => Activator.CreateInstance(x) as IComponent)
                                   .ToArray();

            var componentDatabase   = Container.Resolve <IComponentDatabase>();
            var componentTypeLookup = Container.Resolve <IComponentTypeLookup>();

            _entities = new List <IEntity>();
            for (var i = 0; i < EntityCount; i++)
            {
                var entity = new Entity(i, componentDatabase, componentTypeLookup);
                entity.AddComponents(_availableComponents);
                _entities.Add(entity);
            }

            var timeTaken = ProcessEntities();

            Console.WriteLine($"Finished In: {timeTaken.Milliseconds}ms");
        }
Example #5
0
        public static Entity GetMouth(Color color)
        {
            float radius = 10f;

            var mouthEntity = new Entity("mouth");

            var transform = new TransformComponent(mouthEntity)
            {
                LocalPosition = Vector2.Zero,
                LocalRotation = new Rotation(0),
                LocalDepth    = 0.09f,
                Scale         = new Vector2(1, 1)
            };

            var graphics = new GraphicsComponent(mouthEntity)
            {
                TexturePath = TextureAtlas.MouthPath,
                Dimensions  = new Point((int)(radius * 2), (int)(radius * 2)),
                Color       = color
            };

            var mouthComp = new MouthComponent(mouthEntity)
            {
            };

            var collider = new CircleColliderComponent(mouthEntity)
            {
                Radius = radius,
            };

            mouthEntity.AddComponents(transform, graphics, mouthComp, collider);

            return(mouthEntity);
        }
Example #6
0
        //TODO -> previously, we had this in awake to get around an issue where entities present in the scene that never had Awake() called
        //we not properly being disposed of -> OnDestroy + Disposer.Dispose() is not called
        //however, this made setup not so straightforward when instantiating entities from prefabs
        //need to work out a proper solution for both cases
        public override void Initialize(IEventSystem eventSystem)
        {
            base.Initialize(eventSystem);

            if (!Entity.HasComponent <ViewComponent>())
            {
                var viewComponent = new ViewComponent();
                AddTransformToView(viewComponent);
                Entity.AddComponent(viewComponent);
            }
            else
            {
                AddTransformToView(Entity.GetComponent <ViewComponent>());
            }

            foreach (var blueprint in Blueprints)
            {
                blueprint.Apply(this.Entity);
            }

            if (Components != null && Components.Length > 0)
            {
                Entity.AddComponents(Components.Select(c => c as object).Where(o => o != null).ToArray());
            }
            else
            {
                var monoBehaviours = GetComponents <Component>().Where(c => c != null && c.GetType() != typeof(Transform) && c.GetType() != typeof(EntityBehaviour)).ToArray();
                Entity.AddComponents(monoBehaviours);
            }
        }
Example #7
0
        public void should_add_components_in_parameter_order()
        {
            var fakeEntityId   = 1;
            var fakeComponents = new IComponent[] { new TestComponentOne(), new TestComponentTwo(), new TestComponentThree() };

            var componentDatabase = Substitute.For <IComponentDatabase>();

            componentDatabase.Allocate(Arg.Any <int>()).Returns(1);

            var componentTypeLookup = Substitute.For <IComponentTypeLookup>();

            componentTypeLookup.AllComponentTypeIds.Returns(new[] { 0, 1, 2 });
            componentTypeLookup.GetComponentType(fakeComponents[0].GetType()).Returns(0);
            componentTypeLookup.GetComponentType(fakeComponents[1].GetType()).Returns(1);
            componentTypeLookup.GetComponentType(fakeComponents[2].GetType()).Returns(2);

            var entity = new Entity(fakeEntityId, componentDatabase, componentTypeLookup);

            entity.AddComponents(fakeComponents);

            Received.InOrder(() => {
                componentDatabase.Allocate(0);
                componentDatabase.Set(0, 1, fakeComponents[0]);
                componentDatabase.Allocate(1);
                componentDatabase.Set(1, 1, fakeComponents[1]);
                componentDatabase.Allocate(2);
                componentDatabase.Set(2, 1, fakeComponents[2]);
            });
        }
Example #8
0
        public static Entity GetEye(Color color, float angle = 0, float fov = 60, float distFromParent = 8)
        {
            float radius = 5f;

            var eyeEntity = new Entity("eye");

            var pos = distFromParent * new Vector2(1, 0);

            var transform = new TransformComponent(eyeEntity)
            {
                LocalPosition = pos,
                LocalRotation = new Rotation(angle),
                LocalDepth    = 0.1f,
                Scale         = new Vector2(1, 1)
            };

            var graphics = new GraphicsComponent(eyeEntity)
            {
                TexturePath = TextureAtlas.EyePath,
                Dimensions  = new Point((int)(radius * 2), (int)(radius * 2)),
                Color       = color
            };

            var eyeComp = new EyeComponent(eyeEntity)
            {
                EyeRange = 150,
                Fov      = MathHelper.ToRadians(fov),
            };

            eyeEntity.AddComponents(transform, graphics, eyeComp);

            return(eyeEntity);
        }
Example #9
0
        public void AddMultipleComponentsToEntity()
        {
            componentList = new IComponent[2] {
                firstComponent, secondComponent
            };

            testEntity.AddComponents(true, componentList);
            Assert.AreEqual(2, testEntity.components.Count);
        }
Example #10
0
        public Entity addEntity(Component[] components)
        {
            var entity = new Entity();

            entity.id = entityId++;
            entity.AddComponents(components);
            Entities[entity.id] = entity;
            return(entity);
        }
Example #11
0
        public void IterationSetup()
        {
            _entities = new List <IEntity>();
            for (var i = 0; i < Entities; i++)
            {
                var entity = new Entity(i, _componentRepository);
                entity.AddComponents(_availableComponents);
                _entities.Add(entity);
            }

            _system = new EntityUpdateSystem();
        }
Example #12
0
        public void should_raise_event_when_adding_component()
        {
            var componentRepository = Substitute.For <IComponentRepository>();
            var entity         = new Entity(1, componentRepository);
            var dummyComponent = Substitute.For <IComponent>();

            var wasCalled = false;

            entity.ComponentsAdded.Subscribe(x => wasCalled = true);

            entity.AddComponents(dummyComponent);
            Assert.True(wasCalled);
        }
Example #13
0
        public Entity Wall(int mX, int mY, string mLabelName = "fill", float mRotation = 0)
        {
            var result = new Entity(_manager);

            var cBody   = Body(new SSVector2I(mX, mY), 16.ToUnits(), 16.ToUnits(), true);
            var cRender = Render(cBody, Textures.Wall, Tilesets.Wall, mLabelName, mRotation);

            cBody.Body.AddGroups(Groups.Obstacle);

            result.AddComponents(cBody, cRender);
            result.AddTags(Tags.Wall, Tags.DestroysBullets);

            return(result);
        }
Example #14
0
        private Entity BulletBase(int mX, int mY, float mDegrees, int mSpeed, string mTextureName, bool mEnemy)
        {
            var result = new Entity(_manager);

            var cBody     = Body(new SSVector2I(mX, mY), 250, 250);
            var cMovement = Movement(cBody);
            var cRender   = Render(cBody, mTextureName);

            cBody.Body.AddGroupsToCheck(Groups.Obstacle, Groups.Character);
            cBody.Body.AddGroupsToIgnoreResolve(Groups.Obstacle, Groups.Character);
            cBody.OnCollision += (mCollisionInfo) =>
            {
                var entity  = (Entity)mCollisionInfo.UserData;
                var cHealth = entity.GetComponent <CHealth>();

                if (entity.HasTag(Tags.DamagedByAny))
                {
                    cHealth.Health--;
                    result.Destroy();
                }
                else if (result.HasTag(Tags.BulletFriendly) &&
                         entity.HasTag(Tags.DamagedByFriendly))
                {
                    cHealth.Health--;
                    result.Destroy();
                }
                else if (result.HasTag(Tags.BulletEnemy) &&
                         entity.HasTag(Tags.DamagedByEnemy))
                {
                    cHealth.Health--;
                    result.Destroy();
                }

                if (entity.HasTag(Tags.DestroysBullets))
                {
                    result.Destroy();
                }
            };

            cMovement.Angle = mDegrees;
            cMovement.Speed = mSpeed;

            cRender.Torque = 8;

            result.AddComponents(cBody, cMovement, cRender);
            result.AddTags(Tags.Bullet);

            return(result);
        }
Example #15
0
        public Entity Decoration(int mX, int mY, string mTextureName, string mTilesetName, string mLabelName,
                                 float mRotation = 0)
        {
            var result = new Entity(_manager);

            var cBody = Body(new SSVector2I(mX, mY), 1600, 1600, true);
            var cRender = Render(cBody, mTextureName, mTilesetName, mLabelName, mRotation);

            cBody.Body.AddGroups(Groups.Decoration);

            result.AddComponents(cBody, cRender);
            result.AddTags(Tags.Decoration);

            return result;
        }
Example #16
0
        public Entity Decoration(int mX, int mY, string mTextureName, string mTilesetName, string mLabelName,
                                 float mRotation = 0)
        {
            var result = new Entity(_manager);

            var cBody   = Body(new SSVector2I(mX, mY), 1600, 1600, true);
            var cRender = Render(cBody, mTextureName, mTilesetName, mLabelName, mRotation);

            cBody.Body.AddGroups(Groups.Decoration);

            result.AddComponents(cBody, cRender);
            result.AddTags(Tags.Decoration);

            return(result);
        }
Example #17
0
        public void should_add_components_in_parameter_order()
        {
            var fakeEntityId   = 1;
            var fakeComponents = new IComponent[] { new TestComponentOne(), new TestComponentTwo(), new TestComponentThree() };

            var componentRepository = Substitute.For <IComponentRepository>();
            var entity = new Entity(fakeEntityId, componentRepository);

            entity.AddComponents(fakeComponents);

            Received.InOrder(() => {
                componentRepository.Add(fakeEntityId, fakeComponents[0]);
                componentRepository.Add(fakeEntityId, fakeComponents[1]);
                componentRepository.Add(fakeEntityId, fakeComponents[2]);
            });
        }
        public void PushState(T stateIndex)
        {
            EntityState newState = StateLookup[stateIndex];

            if (TopState == null)
            {
                Entity.AddComponents(newState.components);
            }
            else
            {
                var oldState = States.Pop();
                UpdateComponents(oldState.components, newState.components);
            }

            States.Push(newState);
        }
Example #19
0
        public static Entity GetFoodPellet(Color color)
        {
            float radius = 10f;

            var foodEntity = new Entity("food");

            var transform = new TransformComponent(foodEntity)
            {
                LocalPosition = Vector2.Zero,
                LocalRotation = new Rotation(0),
                LocalDepth    = 0.09f,
                Scale         = new Vector2(1, 1)
            };

            var graphics = new GraphicsComponent(foodEntity)
            {
                TexturePath = TextureAtlas.SoupPath,
                Dimensions  = new Point((int)(radius * 2), (int)(radius * 2)),
                Color       = color
            };

            var colourComp = new VisibleColourComponent(foodEntity)
            {
                RealR = 0.9f,
                RealB = 0.05f,
                RealG = 0.05f,
            };

            var energy = new EnergyComponent(foodEntity)
            {
                Energy = 3
            };

            var edible = new EdibleComponent(foodEntity)
            {
            };


            var collider = new CircleColliderComponent(foodEntity)
            {
                Radius = radius,
            };

            foodEntity.AddComponents(transform, graphics, energy, edible, collider, colourComp);

            return(foodEntity);
        }
Example #20
0
        public static Entity BlueDoor(bool mIsOff = false)
        {
            var result = new Entity(Tile) {Layer = TDLLayers.Door};

            var cRender = TDLComponentFactory.Render(@"environment\door\blue\closed", "doortiles", "single");
            var cRecalculateSprites = new TDCRecalculateSprites(TDLTags.DoorClosed, TDLRecalculations.RecalculateDoorSprite);
            var cSwitch = TDLComponentFactory.SwitchTexture(cRender, mIsOff, @"environment\door\blue\open", @"environment\door\blue\closed");
            cSwitch.OnlyOffTags.Add(TDLTags.BlueDoorOpen);
            cSwitch.OnlyOnTags.AddRange(new[] {TDLTags.BlueDoorClosed, TDLTags.Solid, TDLTags.GroundPathmapObstacle});
            var cSwitchRecalculateTagAI = new TDCSwitchRecalculateTagAI(cSwitch, cRecalculateSprites, TDLTags.BlueDoorOpen, TDLTags.BlueDoorClosed);
            var cDoor = new TDCDoor(TDCDoor.DoorType.Blue, mIsOff, Game, cSwitch, cRecalculateSprites);

            result.AddTags(TDLTags.BlueDoor);
            result.AddComponents(cRender, cSwitch, cSwitchRecalculateTagAI, cRecalculateSprites, cDoor);

            return result;
        }
Example #21
0
        /// <summary>
        /// Add a new component with a transform
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void addChildEntityButton_Click(object sender, EventArgs e)
        {
            Entity def = new Entity();

            def.AddComponents(new TransformComponent(def));
            string newTagAttempt = "Entity";

            // Make sure user can't add a duplicate tag
            while (_target.Children.ContainsKey(newTagAttempt))
            {
                newTagAttempt += "New";
            }
            def.Tag = newTagAttempt;
            _target.AddChild(def);
            _target.OwnerPool.AddDeserializedEntity(def, _target);
            Invalidate();
        }
Example #22
0
        /// <summary>
        /// display dialog for adding a component
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void addComponentButton_Click(object sender, EventArgs e)
        {
            var chooseComponent = new ChooseComponentForm(ComponentCompatibility.GetCompatibleComponents(_target));

            chooseComponent.ShowDialog();

            if (chooseComponent.DialogResult != DialogResult.OK)
            {
                return;
            }

            var componentType = chooseComponent.Selected;
            var component     = Activator.CreateInstance(componentType, _target);

            _target.AddComponents((AbstractComponent)component);
            Invalidate();
        }
Example #23
0
        public Entity BreakableWall(int mX, int mY)
        {
            var result = new Entity(_manager);

            var cHealth = new CHealth(85);
            var cBody = Body(new SSVector2I(mX, mY), 16.ToUnits(), 16.ToUnits(), true);
            var cRender = Render(cBody, Textures.Wall, Tilesets.Wall, "breakable");

            cBody.Body.AddGroups(Groups.Obstacle);

            result.AddComponents(cHealth, cBody, cRender);
            result.AddTags(Tags.Wall, Tags.DamagedByAny);

            cRender.Sprite.Rotation = Utils.Random.Next(0, 4)*90;

            return result;
        }
Example #24
0
        public Entity BreakableWall(int mX, int mY)
        {
            var result = new Entity(_manager);

            var cHealth = new CHealth(85);
            var cBody   = Body(new SSVector2I(mX, mY), 16.ToUnits(), 16.ToUnits(), true);
            var cRender = Render(cBody, Textures.Wall, Tilesets.Wall, "breakable");

            cBody.Body.AddGroups(Groups.Obstacle);

            result.AddComponents(cHealth, cBody, cRender);
            result.AddTags(Tags.Wall, Tags.DamagedByAny);

            cRender.Sprite.Rotation = Utils.Random.Next(0, 4) * 90;

            return(result);
        }
Example #25
0
        public Entity Player(int mX, int mY)
        {
            var result = new Entity(_manager);

            var cStats    = new CStats(1, 1, 1, 50);
            var cHealth   = new CHealth(cStats);
            var cBody     = Body(new SSVector2I(mX, mY), 10.ToUnits(), 10.ToUnits());
            var cMovement = Movement(cBody);
            var cRender   = Render(cBody, Textures.CharPlayer, Tilesets.Char, "normal");
            var cControl  = Control(cBody, cStats, cMovement, cRender);
            var cShadower = new CShadower(_game, cBody, true, new Color(77, 77, 175, 255), 1);

            cBody.Body.AddGroups(Groups.Character, Groups.Friendly);
            cBody.Body.AddGroupsToCheck(Groups.Obstacle);

            result.AddComponents(cStats, cHealth, cBody, cMovement, cControl, cRender, cShadower);
            result.AddTags(Tags.Char, Tags.Friendly, Tags.DamagedByEnemy);

            return(result);
        }
Example #26
0
        public static Entity Arrow(int mDirection = 0, bool mIsOff = false, List<int> mIDs = default(List<int>))
        {
            var result = new Entity(Tile) {Layer = TDLLayers.Arrow, UpdateOrder = TDLOrders.Trapdoor};

            var cRender = TDLComponentFactory.Render(@"environment\arrow", "onoffdirtiles", "on_n");
            var cDirection = new TDCDirection(mDirection);
            var cSpecialSquare = new TDCSpecialSquare(TDLPriorities.Arrow);
            var cID = TDLComponentFactory.ID(mIDs);
            var cSwitch = new TDCSwitch(cRender, mIsOff);
            cSwitch.SetOffTextureRect(Assets.GetTileset("onoffdirtiles").GetTextureRect("off_" + cDirection.DirectionString));
            cSwitch.SetOnTextureRect(Assets.GetTileset("onoffdirtiles").GetTextureRect("on_" + cDirection.DirectionString));
            var cIDSwitchAI = new TDCIDSwitchAI(cSwitch, cID);
            var cArrow = new TDCArrow(cSpecialSquare, cDirection, cSwitch);

            cSwitch.OnlyOnTags.Add(TDLTags.GroundPathmapObstacle);

            result.AddTags(TDLTags.Arrow);
            result.AddComponents(cRender, cDirection, cSpecialSquare, cID, cSwitch, cIDSwitchAI, cArrow);

            return result;
        }
Example #27
0
        public Entity BigEnemy(int mX, int mY)
        {
            var result = new Entity(_manager);

            var cHealth = Health(12);
            var cBody = Body(new SSVector2I(mX, mY), 2000, 2000);
            var cMovement = Movement(cBody);
            var cTargeter = Targeter(cBody, Tags.Friendly);
            var cRender = Render(cBody, Textures.BigCharBlack, Tilesets.BigChar, "normal");
            var cAI = AI(cBody, cMovement, cTargeter, cRender, true);

            cBody.Body.AddGroups(Groups.Character, Groups.Enemy);
            cBody.Body.AddGroupsToCheck(Groups.Obstacle);

            result.AddComponents(cHealth, cBody, cMovement, cTargeter, cRender, cAI);
            result.AddTags(Tags.Char, Tags.Enemy, Tags.DamagedByWhite);

            Aura(result, mX, mY, true);

            return result;
        }
Example #28
0
        public void should_return_all_components_allocated_to_the_entity()
        {
            var fakeEntityId      = 1;
            var components        = new IComponent[] { new TestComponentOne(), new TestComponentTwo(), new TestComponentThree() };
            var componentDatabase = Substitute.For <IComponentDatabase>();

            componentDatabase.Allocate(Arg.Any <int>()).Returns(0);
            componentDatabase.Get <IComponent>(Arg.Any <int>(), Arg.Any <int>()).Returns(info => components[info.ArgAt <int>(0)]);

            var componentTypeLookup = Substitute.For <IComponentTypeLookup>();

            componentTypeLookup.AllComponentTypeIds.Returns(new[] { 0, 1, 2 });
            componentTypeLookup.GetComponentType(components[0].GetType()).Returns(0);
            componentTypeLookup.GetComponentType(components[1].GetType()).Returns(1);
            componentTypeLookup.GetComponentType(components[2].GetType()).Returns(2);

            var entity = new Entity(fakeEntityId, componentDatabase, componentTypeLookup);

            entity.AddComponents(components);
            Assert.Equal(components, entity.Components);
        }
Example #29
0
        protected override void Initialize()
        {
            Console.Initialise();
            CoroutineManager.Initialise();

            Graphics.PreferredBackBufferWidth  = GAME_WIDTH * 3;
            Graphics.PreferredBackBufferHeight = GAME_HEIGHT * 3;
            Graphics.ApplyChanges();
            UpdateScaleViewport();

            entityManager = new EntityManager(this);
            Audio         = new AudioManager(this);
            Input         = new InputManager(this);

            KeyInput = new TextInput(this);

            Player = new Entity(entityManager, "player");
            Player.AddComponents(new List <Component>()
            {
                new InputTransformComponent(),
                new PositionComponent(),
                new PlayerComponent(),
                new CollisionComponent(new Resolve.RectangleF(-6, -20, 12, 24))
            });

            Camera = new Camera(this);
            Camera.SetTarget(Player);
            MapManager = new MapManager(this, Player);

            ScriptingManager = new ScriptingManager(this);
            Transition       = new TransitionManager(this);

            renderTarget1 = new RenderTarget2D(this.GraphicsDevice, GAME_WIDTH, GAME_HEIGHT);
            renderTarget2 = new RenderTarget2D(this.GraphicsDevice, GAME_WIDTH, GAME_HEIGHT);

            //IEnumerator t = Test();
            //CoroutineManager.StartCoroutine(t);

            base.Initialize();
        }
Example #30
0
        public static Entity GetWeapon(Color color)
        {
            float radius = 8f;

            var weaponEntity = new Entity("weapon");

            var transform = new TransformComponent(weaponEntity)
            {
                LocalPosition = Vector2.Zero,
                LocalRotation = new Rotation(0),
                LocalDepth    = 0.09f,
                Scale         = new Vector2(1, 1)
            };

            var graphics = new GraphicsComponent(weaponEntity)
            {
                TexturePath = TextureAtlas.BoxingGloveRetractedPath,
                Dimensions  = new Point((int)(radius * 2), (int)(radius * 2)),
                Color       = color
            };

            var collider = new CircleColliderComponent(weaponEntity)
            {
                Radius = radius,
            };

            var weaponComp = new WeaponComponent(weaponEntity)
            {
                ActivateThreshold   = 0.75f,
                AttackCost          = 0.1f,
                AttackTimeSeconds   = 0.1f,
                CooldownTimeSeconds = 1.2f,
                Damage = 34f
            };

            weaponEntity.AddComponents(transform, graphics, weaponComp, collider);

            return(weaponEntity);
        }
Example #31
0
        public Entity Enemy(int mX, int mY)
        {
            var result = new Entity(_manager);

            var cStats       = new CStats(1, 1, 1, 75);
            var cHealth      = new CHealth(cStats);
            var cBody        = Body(new SSVector2I(mX, mY), 10.ToUnits(), 10.ToUnits());
            var cMovement    = Movement(cBody);
            var cRender      = Render(cBody, Textures.CharEnemy, Tilesets.Char, "normal");
            var cShadower    = new CShadower(_game, cBody, false, new Color(125, 255, 125, 125));
            var cLineOfSight = new CLineOfSight(_game, cBody, cShadower)
            {
                TargetTag = Tags.Friendly, Angle = 90, Amplitude = 65
            };
            var cAI = AI(cStats, cBody, cMovement, cRender, cLineOfSight);

            cBody.Body.AddGroups(Groups.Character, Groups.Enemy);
            cBody.Body.AddGroupsToCheck(Groups.Obstacle);

            result.AddComponents(cHealth, cBody, cMovement, cRender, cShadower, cLineOfSight, cAI);
            result.AddTags(Tags.Char, Tags.Enemy, Tags.DamagedByFriendly);

            return(result);
        }
Example #32
0
        public void should_raise_event_when_adding_components()
        {
            var componentDatabase   = Substitute.For <IComponentDatabase>();
            var componentTypeLookup = Substitute.For <IComponentTypeLookup>();

            componentTypeLookup.AllComponentTypeIds.Returns(new [] { 0, 1 });
            componentTypeLookup.GetComponentType(Arg.Any <Type>()).Returns(1);

            var entity         = new Entity(1, componentDatabase, componentTypeLookup);
            var dummyComponent = Substitute.For <IComponent>();

            var wasCalled = false;

            int[] eventData = null;
            entity.ComponentsAdded.Subscribe(x =>
            {
                eventData = x;
                wasCalled = true;
            });

            entity.AddComponents(dummyComponent);
            Assert.True(wasCalled);
            Assert.Equal(new [] { 1 }, eventData);
        }
Example #33
0
        public static Entity Guard(int mDirection = 0)
        {
            var result = new Entity(Tile) {Layer = TDLLayers.Roach, UpdateOrder = TDLOrders.Guard};

            var outline1 = new TDCRenderSpriteOutline("humanoidtiles", @"humanoid\body\red", "n");
            var outline2 = new TDCRenderSpriteOutline("humanoidtiles", @"humanoid\hands\pink", "n");
            var outline3 = new TDCRenderSpriteOutline("humanoidtiles", @"humanoid\head\pink", "n");

            var cRender = new TDCRender(outline1, outline2, outline3) {IsLerped = true};
            var cDirection = new TDCDirection(mDirection);
            var cTarget = new TDCTarget(TDLTags.MonsterTargetTags);
            var cHitByWeapon = new TDCHitByWeapon(TDCHitByWeapon.HitActions.Kill);
            var cMovement = new TDCMovement(TDCMovement.MovementType.FlexibleNormal, TDLTags.GroundAllowedTags, TDLTags.GroundObstacleTags, TDLTags.GroundExceptionTags);
            var cRenderDirectionAI = new TDCRenderDirectionAI(cRender, cDirection, "humanoidtiles");
            var cWielder = new TDCWielder(cMovement, cDirection);
            var cWielderTargetAI = new TDCWielderTargetAI(cTarget, cMovement, cDirection, cWielder);
            var cMovementTargetAI = new TDCMovementTargetAI(Instance, cMovement, cTarget, cDirection, TDLPathmaps.SideGood, false, true);
            var cPathmapper = new TDCPathmapper(Instance, TDLPathmaps.SideBad);
            var cWielderRenderAI = new TDCWielderRenderAI(cWielder, cRender, cRenderDirectionAI);

            result.AddTags(TDLTags.Solid, TDLTags.Humanoid, TDLTags.SideBad, TDLTags.HitByWeapon,
                           TDLTags.WeightLow, TDLTags.BoosterUser, TDLTags.RequiredKill, TDLTags.Guard);
            result.AddComponents(cRender, cDirection, cTarget, cHitByWeapon,
                                 cWielderTargetAI, cMovementTargetAI, cMovement, cRenderDirectionAI, cWielder, cPathmapper,
                                 cWielderRenderAI);

            cWielder.SetWeapon(WoodenSword());

            return result;
        }
Example #34
0
        public static Entity Orb(List<int> mTargetIDs = default(List<int>), List<int> mTargetEffects = default(List<int>), bool mIsBroken = false, int mHealth = 2)
        {
            var result = new Entity(Tile) {Layer = TDLLayers.Orb};

            var cRender = TDLComponentFactory.Render(@"elements\orb", "orbtiles", "on");
            var cIDCaller = new TDCIDCaller(mTargetIDs, mTargetEffects);
            var cOrb = new TDCOrb(mIsBroken, mHealth, cRender, cIDCaller);
            var cHitByWeapon = new TDCHitByWeapon(cOrb.Struck);

            if (mIsBroken) TDLMethods.AttachCrackedOverlay(cRender, mHealth >= 2 ? 0 : 1);

            result.AddTags(TDLTags.Solid, TDLTags.HitByWeapon, TDLTags.GroundPathmapObstacle);
            result.AddComponents(cRender, cHitByWeapon, cIDCaller, cOrb);

            return result;
        }
Example #35
0
        public static Entity HotTile(int mTurnsToBurn = 2)
        {
            var result = new Entity(Tile) {UpdateOrder = TDLOrders.Trapdoor, Layer = TDLLayers.Trapdoor};

            var cRender = TDLComponentFactory.Render(@"environment\hottile", "doortiles", "single");
            var cRecalculateSprites = new TDCRecalculateSprites(TDLTags.HotTile, TDLRecalculations.RecalculateDoorSprite);
            var cSpecialSquare = new TDCSpecialSquare(TDLPriorities.Trapdoor);
            var cHotTile = new TDCHotTile(cSpecialSquare, mTurnsToBurn);

            result.AddTags(TDLTags.HotTile);
            result.AddComponents(cRender, cSpecialSquare, cRecalculateSprites, cHotTile);

            return result;
        }
Example #36
0
        private Entity SporeBase(int mX, int mY, float mDegrees, int mSpeed, string mTextureName, bool mEnemy)
        {
            var result = new Entity(_manager);

            var cBody = Body(new SSVector2I(mX, mY), 250, 250);
            var cMovement = Movement(cBody);
            var cRender = Render(cBody, mTextureName);

            cBody.Body.AddGroupsToCheck(Groups.Obstacle, Groups.Character);
            cBody.Body.AddGroupsToIgnoreResolve(Groups.Obstacle, Groups.Character);
            cBody.OnCollision += (mCollisionInfo) =>
                                 {
                                     var entity = (Entity)mCollisionInfo.UserData;

                                     var cHealth = entity.GetComponent<CHealth>();

                                     if (result.HasTag(Tags.SporeBlack) && entity.HasTag(Tags.DamagedByWhite))
                                     {
                                         cHealth++;
                                         result.Destroy();
                                     }
                                     else if (result.HasTag(Tags.SporeWhite) && entity.HasTag(Tags.DamagedByBlack))
                                     {
                                         cHealth++;
                                         result.Destroy();
                                     }

                                     if (entity.HasTag(Tags.DestroysBullets)) result.Destroy();
                                 };

            cMovement.Angle = mDegrees;
            cMovement.Speed = mSpeed;
            cMovement.Acceleration = -0.1f;

            cRender.Torque = 8;

            result.AddComponents(cBody, cMovement, cRender);
            result.AddTags(Tags.Spore);

            cRender.Sprite.Color = new Color(255, 255, 255, 125);

            return result;
        }
Example #37
0
        public static Entity RoachEgg()
        {
            var result = new Entity(Tile) {Layer = TDLLayers.Roach, UpdateOrder = TDLOrders.Roach};

            var cRender = TDLComponentFactory.Render(@"monster\roachegg", "roachtiles", "n", true);
            var cHitByWeapon = new TDCHitByWeapon(TDCHitByWeapon.HitActions.Kill);
            var cEgg = new TDCEgg(cRender, 4);
            var cPathmapper = new TDCPathmapper(Instance, TDLPathmaps.SideBad);

            result.AddTags(TDLTags.Solid, TDLTags.SideBad, TDLTags.HitByWeapon, TDLTags.RequiredKill);
            result.AddComponents(cRender, cHitByWeapon, cEgg, cPathmapper);

            return result;
        }
Example #38
0
        public static Entity Scroll(string mText = "")
        {
            var result = new Entity(Tile) {Layer = TDLLayers.Arrow, UpdateOrder = TDLOrders.Trapdoor};

            var cRender = TDLComponentFactory.Render(@"elements\scroll");
            var cScroll = new TDCScroll(Game, mText);

            result.AddComponents(cRender, cScroll);

            return result;
        }
Example #39
0
        public Entity Wall(int mX, int mY, string mLabelName = "fill", float mRotation = 0)
        {
            var result = new Entity(_manager);

            var cBody = Body(new SSVector2I(mX, mY), 16.ToUnits(), 16.ToUnits(), true);
            var cRender = Render(cBody, Textures.Wall, Tilesets.Wall, mLabelName, mRotation);

            cBody.Body.AddGroups(Groups.Obstacle);

            result.AddComponents(cBody, cRender);
            result.AddTags(Tags.Wall, Tags.DestroysBullets);

            return result;
        }
Example #40
0
        public static Entity WeaponSlot(bool mIsOff = false, List<int> mIDs = default(List<int>), string mWeapon = "")
        {
            var result = new Entity(Tile) {Layer = TDLLayers.Arrow, UpdateOrder = TDLOrders.Trapdoor};

            var cRender = TDLComponentFactory.Render(@"elements\weaponslot", "onofftiles", "on");
            var cSpecialSquare = new TDCSpecialSquare(TDLPriorities.Trapdoor);
            var cID = TDLComponentFactory.ID(mIDs);
            var cSwitch = TDLComponentFactory.Switch(cRender, mIsOff);
            var cIDSwitchAI = new TDCIDSwitchAI(cSwitch, cID);
            var cWeaponSlot = new TDCWeaponSlot(cSpecialSquare, cRender);

            cRender.AddBlankSprite();

            if (mWeapon == "reallybigsword") cWeaponSlot.Weapon = ReallyBigSword();
            else if (mWeapon == "shortsword") cWeaponSlot.Weapon = ShortSword();
            else if (mWeapon == "woodensword") cWeaponSlot.Weapon = WoodenSword();

            if (cWeaponSlot.Weapon != null) cWeaponSlot.Weapon.IsOutOfField = true;
            cWeaponSlot.RecalculateWeaponSprite();

            result.AddTags(TDLTags.WeaponSlot);
            result.AddComponents(cRender, cSpecialSquare, cID, cSwitch, cIDSwitchAI, cWeaponSlot);

            return result;
        }
Example #41
0
        public static Entity Brain()
        {
            var result = new Entity(Tile) {Layer = TDLLayers.Roach, UpdateOrder = TDLOrders.Roach};

            var cRender = TDLComponentFactory.Render(@"monster\brain", true);
            var cHitByWeapon = new TDCHitByWeapon(TDCHitByWeapon.HitActions.KillBrain);
            var cPathmapper = new TDCPathmapper(Instance, TDLPathmaps.SideBad);

            result.AddTags(TDLTags.Solid, TDLTags.SideBad, TDLTags.HitByWeapon,
                           TDLTags.RequiredKill, TDLTags.WeightLow, TDLTags.Brain);
            result.AddComponents(cRender, cHitByWeapon, cPathmapper);

            result.Field.TurnActions[TDLTurnActions.StartBrainCheck] += () => TDLMethods.CheckForBrains(result.Field);

            return result;
        }
Example #42
0
        public static Entity Wall(bool mIsBroken = false)
        {
            var result = new Entity(Tile) {Layer = TDLLayers.Wall};

            var cRender = TDLComponentFactory.Render(@"environment\wall\purple", "walltiles", "single");
            var cHitByWeapon = new TDCHitByWeapon(TDCHitByWeapon.HitActions.Break);
            var cRecalculateSprites = new TDCRecalculateSprites(TDLTags.Wall, TDLRecalculations.RecalculateWallSprite);

            result.AddTags(TDLTags.Solid, TDLTags.Wall, TDLTags.HitByWeapon, TDLTags.GroundPathmapObstacle);
            result.AddComponents(cRender, cRecalculateSprites);
            if (mIsBroken)
            {
                TDLMethods.AttachBrokenOverlay(cRender);
                result.AddComponents(cHitByWeapon);
            }

            return result;
        }
Example #43
0
        public static Entity Water()
        {
            var result = new Entity(Tile) {Layer = TDLLayers.Pit};

            var cRender = TDLComponentFactory.Render(@"environment\water", "doortiles", "single");
            var cRecalculateSprites = new TDCRecalculateSprites(TDLTags.Water, TDLRecalculations.RecalculateDoorSprite);

            result.AddTags(TDLTags.Solid, TDLTags.Water, TDLTags.GroundPathmapObstacle);
            result.AddComponents(cRender, cRecalculateSprites);

            return result;
        }
Example #44
0
        public static Entity Tunnel(int mDirection = 0)
        {
            var result = new Entity(Tile) {Layer = TDLLayers.Arrow};

            var cRender = TDLComponentFactory.Render(@"elements\tunnel");
            var cDirection = new TDCDirection(mDirection);
            var cSpecialSquare = new TDCSpecialSquare(TDLPriorities.Trapdoor);
            var cTunnel = new TDCTunnel(cRender, cDirection, cSpecialSquare);

            result.AddTags(TDLTags.Tunnel, TDLTags.GroundPathmapObstacle);
            result.AddComponents(cRender, cSpecialSquare, cDirection, cTunnel);

            return result;
        }
Example #45
0
        public static Entity Trapdoor(bool mIsOff = false, List<int> mIDs = default(List<int>), bool mIsOnWater = false, bool mIsBroken = false)
        {
            var result = new Entity(Tile) {Layer = TDLLayers.Trapdoor, UpdateOrder = TDLOrders.Trapdoor};

            var trapdoorTexture = @"environment\trapdoor";
            if (mIsOnWater) trapdoorTexture = @"environment\watertrapdoor";

            var cRender = TDLComponentFactory.Render(trapdoorTexture, "onofftiles", "on");
            var cID = TDLComponentFactory.ID(mIDs);
            var cSwitch = TDLComponentFactory.Switch(cRender, mIsOff);
            var cIDSwitchAI = new TDCIDSwitchAI(cSwitch, cID);
            var cSpecialSquare = new TDCSpecialSquare(TDLPriorities.Trapdoor);
            var cTrapdoor = new TDCTrapdoor(mIsOnWater, mIsBroken, cSpecialSquare, cSwitch);

            if (mIsBroken) TDLMethods.AttachCrackedOverlay(cRender, 0);

            result.AddTags(TDLTags.GroundWalkable, TDLTags.Trapdoor);
            result.AddComponents(cRender, cID, cSwitch, cIDSwitchAI, cSpecialSquare, cTrapdoor);

            return result;
        }
Example #46
0
        public static Entity Player(int mDirection = 0)
        {
            var result = new Entity(Tile) {Layer = TDLLayers.Roach, UpdateOrder = TDLOrders.Player};

            var outline1 = new TDCRenderSpriteOutline("humanoidtiles", @"humanoid\body\yellow", "n");
            var outline2 = new TDCRenderSpriteOutline("humanoidtiles", @"humanoid\hands\pink", "n");
            var outline3 = new TDCRenderSpriteOutline("humanoidtiles", @"humanoid\head\pink", "n");

            var cRender = new TDCRender(outline1, outline2, outline3) {IsLerped = true};
            var cDirection = new TDCDirection(mDirection);
            var cTarget = new TDCTarget();
            var cHitByWeapon = new TDCHitByWeapon(TDCHitByWeapon.HitActions.Kill);
            var cMovement = new TDCMovement(TDCMovement.MovementType.Direct, TDLTags.GroundAllowedTags, TDLTags.GroundObstacleTags, TDLTags.GroundExceptionTags);
            var cRenderDirectionAI = new TDCRenderDirectionAI(cRender, cDirection, "humanoidtiles");
            var cWielder = new TDCWielder(cMovement, cDirection);
            var cPathmapper = new TDCPathmapper(Instance, TDLPathmaps.SideGood);
            var cPlayer = new TDCPlayer(Game, cMovement, cDirection, cWielder);
            var cRoomSwitch = new TDCRoomSwitch(Game, cMovement);
            var cWielderRenderAI = new TDCWielderRenderAI(cWielder, cRender, cRenderDirectionAI);

            result.AddTags(TDLTags.Solid, TDLTags.Humanoid, TDLTags.SideGood, TDLTags.HitByWeapon,
                           TDLTags.Player, TDLTags.TunnelUser, TDLTags.WeightLow, TDLTags.BoosterUser);
            result.AddComponents(cRender, cDirection, cTarget, cHitByWeapon, cPlayer, cMovement, cRenderDirectionAI,
                                 cWielder, cPathmapper, cRoomSwitch, cWielderRenderAI);

            cWielder.SetWeapon(ReallyBigSword());

            /*cMovement.OnMovementFail += () =>
                                        {
                                            // This is only to prevent wall bump sounds if using a tunnel or a booster
                                            var x = cMovement.TargetX;
                                            var y = cMovement.TargetY;

                                            if (result.Field.HasEntityByTag(result.X, result.Y, TDLTags.Tunnel)) return;
                                            if (result.Field.HasEntityByTag(result.X, result.Y, TDLTags.Booster)) return;

                                            if (result.Field.HasEntityByTag(x, y, TDLTags.Wall)) TDLSounds.Play("SoundWallBump");
                                            else if (result.Field.HasEntityByTag(x, y, TDLTags.Pit)) TDLSounds.Play("SoundPitBump");
                                        };*/

            return result;
        }
Example #47
0
        public static Entity Door(bool mIsBroken = false, bool mIsOff = false, List<int> mIDs = default(List<int>))
        {
            var result = new Entity(Tile) {Layer = TDLLayers.Door};

            var cRender = TDLComponentFactory.Render(@"environment\door\yellow\closed", "doortiles", "single");
            var cSwitch = TDLComponentFactory.SwitchTexture(cRender, mIsOff, @"environment\door\yellow\open", @"environment\door\yellow\closed");
            cSwitch.OnlyOffTags.Add(TDLTags.DoorOpen);
            cSwitch.OnlyOnTags.AddRange(new[] {TDLTags.DoorClosed, TDLTags.Solid, TDLTags.GroundPathmapObstacle});
            var cHitByWeapon = new TDCHitByWeapon(TDCHitByWeapon.HitActions.BreakIfOff);
            var cID = TDLComponentFactory.ID(mIDs);
            var cRecalculateSprites = new TDCRecalculateSprites(TDLTags.DoorClosed, TDLRecalculations.RecalculateDoorSprite, cID.SameIDsCondition);
            var cIDSwitchAI = new TDCIDSwitchAI(cSwitch, cID);
            var cSwitchRecalculateTagAI = new TDCSwitchRecalculateTagAI(cSwitch, cRecalculateSprites, TDLTags.DoorOpen, TDLTags.DoorClosed);
            var cDoor = new TDCDoor(TDCDoor.DoorType.Yellow, mIsOff, Game, cSwitch, cRecalculateSprites);

            result.AddTags(TDLTags.Door, TDLTags.HitByWeapon);
            result.AddComponents(cRender, cID, cSwitch, cSwitchRecalculateTagAI, cRecalculateSprites,
                                 cIDSwitchAI, cDoor);
            if (mIsBroken)
            {
                result.AddComponents(cHitByWeapon);
                TDLMethods.AttachBrokenOverlay(cRender);
            }

            return result;
        }
Example #48
0
        public Entity Enemy(int mX, int mY)
        {
            var result = new Entity(_manager);

            var cStats = new CStats(1, 1, 1, 75);
            var cHealth = new CHealth(cStats);
            var cBody = Body(new SSVector2I(mX, mY), 10.ToUnits(), 10.ToUnits());
            var cMovement = Movement(cBody);
            var cRender = Render(cBody, Textures.CharEnemy, Tilesets.Char, "normal");
            var cShadower = new CShadower(_game, cBody, false, new Color(125, 255, 125, 125));
            var cLineOfSight = new CLineOfSight(_game, cBody, cShadower) {TargetTag = Tags.Friendly, Angle = 90, Amplitude = 65};
            var cAI = AI(cStats, cBody, cMovement, cRender, cLineOfSight);

            cBody.Body.AddGroups(Groups.Character, Groups.Enemy);
            cBody.Body.AddGroupsToCheck(Groups.Obstacle);

            result.AddComponents(cHealth, cBody, cMovement, cRender, cShadower, cLineOfSight, cAI);
            result.AddTags(Tags.Char, Tags.Enemy, Tags.DamagedByFriendly);

            return result;
        }
Example #49
0
        public static Entity WoodenSword()
        {
            var result = new Entity(Tile) {Layer = TDLLayers.Weapon};

            var cRender = TDLComponentFactory.Render(@"weapon\woodensword", "dirtiles", "n", true);
            var cDirection = new TDCDirection(0);
            var cWeapon = new TDCWeapon();
            var cRenderDirectionAI = new TDCRenderDirectionAI(cRender, cDirection, "dirtiles");

            result.AddTags(TDLTags.Solid, TDLTags.Weapon, TDLTags.DoesNotTriggerPlate);
            result.AddComponents(cRender, cDirection, cWeapon, cRenderDirectionAI);

            Instance.AddEntity(result);
            return result;
        }
Example #50
0
        public static Entity RoachQueen(int mDirection = 0, int mSpawnTurns = 30)
        {
            var result = new Entity(Tile) {Layer = TDLLayers.Roach, UpdateOrder = TDLOrders.Roach};

            var cRender = TDLComponentFactory.Render(@"monster\roachqueen", "roachtiles", "n", true);
            var cDirection = new TDCDirection(mDirection);
            var cTarget = new TDCTarget(TDLTags.MonsterTargetTags);
            var cHitByWeapon = new TDCHitByWeapon(TDCHitByWeapon.HitActions.Kill);
            var cMovement = new TDCMovement(TDCMovement.MovementType.BeelineNormal, TDLTags.GroundAllowedTags, TDLTags.GroundObstacleTags, TDLTags.GroundExceptionTags) {IsReverse = true};
            var cMovementTargetAI = new TDCMovementTargetAI(Instance, cMovement, cTarget, cDirection, TDLPathmaps.SideGood);
            var cRenderDirectionAI = new TDCRenderDirectionAI(cRender, cDirection, "roachtiles");
            var cPathmapper = new TDCPathmapper(Instance, TDLPathmaps.SideBad);
            var cRoachQueen = new TDCRoachQueen(false, mSpawnTurns);

            result.AddTags(TDLTags.Solid, TDLTags.SideBad, TDLTags.HitByWeapon,
                           TDLTags.RequiredKill, TDLTags.BoosterUser, TDLTags.WeightLow, TDLTags.AffectedByBrain);
            result.AddComponents(cRender, cDirection, cTarget, cHitByWeapon,
                                 cMovementTargetAI, cMovement, cRenderDirectionAI, cPathmapper, cRoachQueen);

            return result;
        }
Example #51
0
        public EntityEditWidget CreateEditWidget(Entity target)
        {
            var widget = new EntityEditWidget(target, this);

            widget._removeComponentButton.Click += (s, a) =>
            {
                if (target.Components.Count <= 0)
                {
                    return;
                }
                Grid grid = new Grid();

                // Make list of all components that are removable
                ListBox box = new ListBox();
                box.Width          = 200;
                box.GridColumn     = 0;
                box.GridRow        = 0;
                box.GridColumnSpan = 2;
                foreach ((int id, AbstractComponent comp) in target.Components)
                {
                    // Logic for removing components
                    if (!(comp is TransformComponent))
                    {
                        var item = new ListItem(comp.GetType().Name, Color.White, comp.GetType());
                        box.Items.Add(item);
                    }
                }
                box.SelectedIndex = 0;

                grid.Widgets.Add(box);

                Dialog removeComponentWindow = new Dialog()
                {
                    Content = grid,
                    Title   = "Select Component To Remove",
                    Left    = 676,
                    Top     = 205,
                    Id      = "_removeComponent",
                };

                removeComponentWindow.Closed += (s, a) =>
                {
                    if (!removeComponentWindow.Result)
                    {
                        // Dialog was either closed or "Cancel" clicked
                        return;
                    }

                    // "Ok" was clicked or Enter key pressed
                    // Remove item from list
                    target.RemoveComponent((Type)box.SelectedItem.Tag);
                    RebuildTree();
                };

                removeComponentWindow.ShowModal(Desktop);
            };

            widget._deleteEntityButton.Click += (s, a) =>
            {
                var dialogue = Dialog.CreateMessageBox("Delete Entity", $"Are you sure you would like to delete entity {target.Tag}?");
                dialogue.Closed += (s, a) =>
                {
                    if (!dialogue.Result)
                    {
                        // Escape or "Cancel"
                        return;
                    }
                    ;
                    target.Parent.Children.Remove(target.Tag);
                    _simulation.Manager.DestroyEntity(target);
                    RebuildTree();
                };
                dialogue.ShowModal(Desktop);
            };

            widget._addChildButton.Click += (s, a) =>
            {
                Grid grid = new Grid();

                Dialog dialog = new Dialog
                {
                    Title = "New Entity"
                };

                var stackPanel = new HorizontalStackPanel
                {
                    Spacing = 8
                };
                stackPanel.Proportions.Add(new Proportion
                {
                    Type = ProportionType.Auto,
                });
                stackPanel.Proportions.Add(new Proportion
                {
                    Type = ProportionType.Fill,
                });

                var label1 = new Label
                {
                    Text = "Tag:"
                };
                stackPanel.Widgets.Add(label1);

                var textBox1 = new TextBox();
                stackPanel.Widgets.Add(textBox1);

                dialog.Content = stackPanel;

                dialog.Closed += (s, a) => {
                    if (!dialog.Result)
                    {
                        // Dialog was either closed or "Cancel" clicked
                        return;
                    }

                    if (!EntityPool.IsValidTag(textBox1.Text))
                    {
                        Dialog.CreateMessageBox("Error", "Invalid tag.").ShowModal(Desktop);
                        return;
                    }
                    if (target.Children.ContainsKey(textBox1.Text))
                    {
                        Dialog.CreateMessageBox("Error", $"Already a child with tag {textBox1.Text}").ShowModal(Desktop);
                        return;
                    }
                    // "Ok" was clicked or Enter key pressed
                    Entity newChild = new Entity(textBox1.Text);
                    newChild.AddComponents(new TransformComponent(newChild));
                    target.AddChild(newChild);
                };

                dialog.ShowModal(Desktop);
            };

            widget._addComponentButton.Click += (s, a) =>
            {
                Grid grid = new Grid();

                // Make list of all components that are removable
                ListBox box = new ListBox();
                box.Width          = 200;
                box.GridColumn     = 0;
                box.GridRow        = 0;
                box.GridColumnSpan = 2;
                foreach (Type component in _addableComponentTypes)
                {
                    if (target.HasComponent(component))
                    {
                        continue;
                    }
                    var item = new ListItem(component.Name, Color.White, component);
                    box.Items.Add(item);
                }
                if (box.Items.Count > 0)
                {
                    box.SelectedIndex = 0;
                }

                grid.Widgets.Add(box);

                Dialog addComponentWindow = new Dialog()
                {
                    Content = grid,
                    Title   = "Select component to add...",
                    Left    = 676,
                    Top     = 205,
                    Id      = "_selectAddComponent",
                };

                addComponentWindow.Closed += (s, a) =>
                {
                    if (!addComponentWindow.Result)
                    {
                        // Dialog was either closed or "Cancel" clicked
                        return;
                    }
                    if (box.SelectedItem is null)
                    {
                        // No more types of component to add.
                        return;
                    }
                    // "Ok" was clicked or Enter key pressed
                    // Add selected component if exists.
                    var componentType = (Type)box.SelectedItem.Tag;
                    // Create a new component instance using the tagged type.
                    var component = Activator.CreateInstance(componentType, target);
                    target.AddComponents((AbstractComponent)component);
                    RebuildTree();
                };

                addComponentWindow.ShowModal(Desktop);
            };

            return(widget);
        }
Example #52
0
        public static Entity Booster(int mDirection = 0, bool mIsOff = false, List<int> mIDs = default(List<int>))
        {
            var result = new Entity(Tile) {Layer = TDLLayers.Arrow};

            var cRender = TDLComponentFactory.Render(@"elements\booster", "onoffdirtiles", "on_n");
            var cDirection = new TDCDirection(mDirection);
            var cSpecialSquare = new TDCSpecialSquare(TDLPriorities.Trapdoor);
            var cID = TDLComponentFactory.ID(mIDs);
            var cSwitch = new TDCSwitch(cRender, mIsOff);
            cSwitch.SetOffTextureRect(Assets.GetTileset("onoffdirtiles").GetTextureRect("off_" + cDirection.DirectionString));
            cSwitch.SetOnTextureRect(Assets.GetTileset("onoffdirtiles").GetTextureRect("on_" + cDirection.DirectionString));
            var cIDSwitchAI = new TDCIDSwitchAI(cSwitch, cID);
            var cBooster = new TDCBooster(cDirection, cSwitch, cSpecialSquare);

            result.AddTags(TDLTags.Booster);
            result.AddComponents(cRender, cSpecialSquare, cDirection, cID, cSwitch, cIDSwitchAI, cBooster);

            return result;
        }
Example #53
0
        private Entity BulletBase(int mX, int mY, float mDegrees, int mSpeed, string mTextureName, bool mEnemy)
        {
            var result = new Entity(_manager);

            var cBody = Body(new SSVector2I(mX, mY), 250, 250);
            var cMovement = Movement(cBody);
            var cRender = Render(cBody, mTextureName);

            cBody.Body.AddGroupsToCheck(Groups.Obstacle, Groups.Character);
            cBody.Body.AddGroupsToIgnoreResolve(Groups.Obstacle, Groups.Character);
            cBody.OnCollision += (mCollisionInfo) =>
                                 {
                                     var entity = (Entity) mCollisionInfo.UserData;
                                     var cHealth = entity.GetComponent<CHealth>();

                                     if (entity.HasTag(Tags.DamagedByAny))
                                     {
                                         cHealth.Health--;
                                         result.Destroy();
                                     }
                                     else if (result.HasTag(Tags.BulletFriendly) &&
                                              entity.HasTag(Tags.DamagedByFriendly))
                                     {
                                         cHealth.Health--;
                                         result.Destroy();
                                     }
                                     else if (result.HasTag(Tags.BulletEnemy) &&
                                              entity.HasTag(Tags.DamagedByEnemy))
                                     {
                                         cHealth.Health--;
                                         result.Destroy();
                                     }

                                     if (entity.HasTag(Tags.DestroysBullets)) result.Destroy();
                                 };

            cMovement.Angle = mDegrees;
            cMovement.Speed = mSpeed;

            cRender.Torque = 8;

            result.AddComponents(cBody, cMovement, cRender);
            result.AddTags(Tags.Bullet);

            return result;
        }
Example #54
0
        public static Entity OrthogonalSquare(bool mIsOff = false, List<int> mIDs = default(List<int>))
        {
            var result = new Entity(Tile) {Layer = TDLLayers.Arrow, UpdateOrder = TDLOrders.Trapdoor};

            var cRender = TDLComponentFactory.Render(@"environment\orthogonalsquare", "onofftiles", "on");
            var cSpecialSquare = new TDCSpecialSquare(TDLPriorities.Arrow);
            var cID = TDLComponentFactory.ID(mIDs);
            var cSwitch = TDLComponentFactory.Switch(cRender, mIsOff);
            var cIDSwitchAI = new TDCIDSwitchAI(cSwitch, cID);
            var cOrthogonalSquare = new TDCOrthogonalSquare(cSpecialSquare, cSwitch);

            result.AddTags(TDLTags.OrthogonalSquare);
            result.AddComponents(cRender, cSpecialSquare, cID, cSwitch, cIDSwitchAI, cOrthogonalSquare);

            return result;
        }
Example #55
0
        public Entity Player(int mX, int mY)
        {
            var result = new Entity(_manager);

            var cStats = new CStats(1, 1, 1, 50);
            var cHealth = new CHealth(cStats);
            var cBody = Body(new SSVector2I(mX, mY), 10.ToUnits(), 10.ToUnits());
            var cMovement = Movement(cBody);
            var cRender = Render(cBody, Textures.CharPlayer, Tilesets.Char, "normal");
            var cControl = Control(cBody, cStats, cMovement, cRender);
            var cShadower = new CShadower(_game, cBody, true, new Color(77, 77, 175, 255), 1);

            cBody.Body.AddGroups(Groups.Character, Groups.Friendly);
            cBody.Body.AddGroupsToCheck(Groups.Obstacle);

            result.AddComponents(cStats, cHealth, cBody, cMovement, cControl, cRender, cShadower);
            result.AddTags(Tags.Char, Tags.Friendly, Tags.DamagedByEnemy);

            return result;
        }
Example #56
0
        public static Entity Oremites()
        {
            var result = new Entity(Tile) {Layer = TDLLayers.Trapdoor};

            var cRender = TDLComponentFactory.Render(@"environment\oremites", "doortiles", "single");
            var cRecalculateSprites = new TDCRecalculateSprites(TDLTags.Oremites, TDLRecalculations.RecalculateDoorSprite);
            var cSpecialSquare = new TDCSpecialSquare(TDLPriorities.Oremites);
            var cOremites = new TDCOremites(cSpecialSquare);

            result.AddTags(TDLTags.Oremites);
            result.AddComponents(cRender, cSpecialSquare, cOremites, cRecalculateSprites);

            return result;
        }
Example #57
0
        public static Entity PressurePlateSingleUse(List<int> mTargetIDs = default(List<int>), List<int> mTargetEffects = default(List<int>))
        {
            var result = new Entity(Tile) {Layer = TDLLayers.Floor, UpdateOrder = TDLOrders.Trapdoor};

            var cRender = TDLComponentFactory.Render(@"environment\pressureplate", "pressureplatetiles", "single");
            var cSpecialSquare = new TDCSpecialSquare(TDLPriorities.Trapdoor);
            var cIDCaller = new TDCIDCaller(mTargetIDs, mTargetEffects);
            var cFloodFiller = new TDCFloodFiller(TDLTags.PressurePlateSingleUse);
            var cPressurePlate = new TDCPressurePlate(TDCPressurePlate.PressurePlateType.Single, cRender, cFloodFiller, cIDCaller, cSpecialSquare, "triggered_single", "single");

            result.AddTags(TDLTags.PressurePlateSingleUse);
            result.AddComponents(cRender, cPressurePlate, cSpecialSquare, cIDCaller, cFloodFiller);

            return result;
        }
Example #58
0
        /*--------------------------------------
         * PUBLIC METHODS
         *------------------------------------*/

        /// <summary>Performs initialization logic.</summary>
        public override void Init()
        {
            AddSubsystems(new      BodySubsystem(),
                          new  ControlsSubsystem(),
                          new     InputSubsystem(),
                          new     LogicSubsystem(),
                          new RenderingSubsystem());

            var chopper = new Entity();

            var model = Game1.Inst.Content.Load <Model>("Models/Chopper");

            // TODO: This is crap.
            CModel modmod;
            var    cntrls = new CControls {
            };
            var controls  = cntrls.Controls;

            chopper.AddComponents(
                new CBody {
                Velocity = new Vector3(0f, 0f, 1.0f)
            },
                modmod = new CModel {
                Model = model
            },

                cntrls,

                new CInput {
                KeyMap =
                {
                    { Keys.Up,    () => {
                          controls["Up"] = 1.0f;
                      } },
                    { Keys.Down,  () => {
                          controls["Up"] = -1.0f;
                      } },
                    { Keys.Left,  () => {
                          controls["Turn"] = -1.0f;
                      } },
                    { Keys.Right, () => {
                          controls["Turn"] = 1.0f;
                      } },
                    { Keys.Q,     () => {
                          controls["Pitch"] = -1.0f;
                      } },
                    { Keys.A,     () => {
                          controls["Pitch"] = 1.0f;
                      } }
                },
                ResetControls = () => {
                    controls["Up"]    = 0.0f;
                    controls["Turn"]  = 0.0f;
                    controls["Pitch"] = 0.0f;
                }
            },

                new CLogic {
                UpdateFunc = (t, dt) => {
                    // TODO: Spin propellah
                    //System.Console.WriteLine("LOL", t);
                }
            });

            AddEntity(chopper);

            LoadHeightmap();

            base.Init();
        }
Example #59
0
        // WEAPONS
        public static Entity ReallyBigSword()
        {
            var result = new Entity(Tile) {Layer = TDLLayers.Weapon};

            var cRender = TDLComponentFactory.Render(@"weapon\reallybigsword", "dirtiles", "n", true);
            var cDirection = new TDCDirection(0);
            var cWeapon = new TDCWeapon();
            var cRenderDirectionAI = new TDCRenderDirectionAI(cRender, cDirection, "dirtiles");

            cWeapon.OnEquip += mWielder => mWielder.Entity.AddTags(TDLTags.WeightHigh);
            cWeapon.OnUnEquip += mWielder => mWielder.Entity.RemoveTags(TDLTags.WeightHigh);

            result.AddTags(TDLTags.Solid, TDLTags.Weapon, TDLTags.DoesNotTriggerPlate, TDLTags.AffectedByOremites);
            result.AddComponents(cRender, cDirection, cWeapon, cRenderDirectionAI);

            Instance.AddEntity(result);
            return result;
        }
Example #60
0
        private void LoadHeightmap()
        {
            var heightmap = Game1.Inst.Content.Load <Texture2D>("Textures/US_Canyon");

            var pixels = new Color[heightmap.Width * heightmap.Height];

            heightmap.GetData <Color>(pixels);

            var indices  = new List <int>();
            var vertices = new List <VertexPositionNormalTexture>();

            var k = (int)0;
            var q = 2;

            for (var j = 0; j < heightmap.Height / q; j++)
            {
                for (var i = 0; i < heightmap.Width / q; i++)
                {
                    // skapa triangel med index 0, 1, 2
                    var v0 = CreateHeightmapVertex(pixels, heightmap.Width, heightmap.Height, i * q, j * q);
                    vertices.Add(v0);
                }
            }

            for (var j = 0; j < heightmap.Height / q - 1; j++)
            {
                for (var i = 0; i < heightmap.Width / q - 1; i++)
                {
                    var a = i + j * (heightmap.Width / q);
                    var b = (i + 1) + j * (heightmap.Width / q);
                    var c = (i + 1) + (j + 1) * (heightmap.Width / q);
                    var d = i + (j + 1) * (heightmap.Width / q);

                    indices.Add(a);
                    indices.Add(b);
                    indices.Add(c);
                    indices.Add(a);
                    indices.Add(c);
                    indices.Add(d);
                }
            }

            var v = vertices.ToArray();

            for (int i = 0; i < indices.Count - 2; i += 3)
            {
                var a = indices[i];
                var b = indices[i + 1];
                var c = indices[i + 2];
                var N = Vector3.Cross(v[b].Position - v[a].Position, v[c].Position - v[a].Position);

                //N.Normalize();

                v[a].Normal -= N;
                v[b].Normal -= N;
                v[c].Normal -= N;
            }

            for (int i = 0; i < vertices.Count; i++)
            {
                v[i].Normal.Normalize();
            }

            VertexBuffer vb = new VertexBuffer(Game1.Inst.GraphicsDevice, typeof(VertexPositionNormalTexture), v.Length, BufferUsage.WriteOnly);

            vb.SetData <VertexPositionNormalTexture>(v);
            IndexBuffer ib = new IndexBuffer(Game1.Inst.GraphicsDevice, typeof(int), indices.Count, BufferUsage.WriteOnly);

            ib.SetData(indices.ToArray());

            heightmap.Dispose();

            var cmp = new CHeightmap {
                VertexBuffer = vb,
                IndexBuffer  = ib,
                NumVertices  = vertices.Count,
                NumTriangles = indices.Count
            };

            var e = new Entity();

            e.AddComponents(cmp);

            AddEntity(e);
        }