protected override void UpdateEntity(float dt, Entity entity)
 {
     var position = entity.Get<Position>();
     var prev = entity.Get<PreviousPosition>();
     position.X.CopyTo(prev.X, 0);
     position.Y.CopyTo(prev.Y, 0);
 }
Example #2
0
 public static void Assign(this UpdatePositionMsg msg, Entity entity)
 {
     msg.Id = entity.Id;
     msg.X = entity.Get<Pos>().X;
     msg.Y = entity.Get<Pos>().Y;
     msg.Dir = entity.Get<Motion>().Dir;
     msg.Speed = entity.Get<Motion>().Dir;
 }
Example #3
0
        public override void OnUpdate()
        {
            Tree.GUI.Interaction.Verbs.HighlightedVerb = (Verb.Equals(Verbs.Walk) ? null : Verb);

            if (Tree.GUI.Dialog.Menu.State != Dialog.DialogMenuState.Closed || (!World.Interactive && !DoUpdateLabel))
            {
                base.OnUpdate();

                return;
            }

            DoUpdateLabel = false;

            var Pick  = World.Get <STACK.Components.Mouse>().ObjectUnderMouse;
            var Label = Tree.GUI.Interaction.ActionTextLabel;

            Label.Color = Color.White;

            var CombinableComponent = Primary?.Get <Combinable>();
            var GivableComponent    = Primary?.Get <Givable>();
            var Combinable          = (null != CombinableComponent && CombinableComponent.IsCombinable);
            var Givable             = (null != GivableComponent && GivableComponent.IsGivable);

            var PickedScrollButton = (Pick == Tree.GUI.Interaction.ScrollDownButton || Pick == Tree.GUI.Interaction.ScrollUpButton);

            if (Pick is VerbButton && World.Interactive)
            {
                Label.ActionText = Pick.Get <Hotspot>().Caption;
                Tree.GUI.Interaction.Verbs.HighlightedVerb = ((VerbButton)Pick).Verb;
            }
            else if (Primary == null && !PickedScrollButton)
            {
                Label.ActionText = Verb.CreateActionString(Pick);
            }
            else if (Primary != null && (!Verb.Ditransitive || (!Combinable && Verb.Equals(Verbs.Use)) || (!Givable && Verb.Equals(Verbs.Give))))
            {
                // Action being executed
                Label.Color      = Color.Gray;
                Label.ActionText = Verb.CreateActionString(Primary, !Verb.Ditransitive);
            }
            else if (Primary != null && Secondary != null)
            {
                Label.Color      = Color.Gray;
                Label.ActionText = Verb.CreateActionString(Primary, true, Secondary);
            }
            else if (!PickedScrollButton)
            {
                Label.ActionText = Verb.CreateActionString(Primary, true, Pick);
            }
            else
            {
                Label.ActionText = Verb.CreateActionString(Primary, true);
            }

            base.OnUpdate();
        }
Example #4
0
        public static Body GetEffectiveBody(Entity e)
        {
            var body = e.Get(Body);
            if (body == null) {
                return null;
            }

            var position = e.Get(Located.Position);
            return body.Offset(position);
        }
Example #5
0
        protected override void UpdateEntity(float dt, Entity entity)
        {
            var position = entity.Get<Position>();
            var direction = entity.Get<Direction>();

            for (int i = 0; i < entity.Count(); ++i)
            {
                position.X[i] += direction.X[i] * dt;
                position.Y[i] += direction.Y[i] * dt;
            }
        }
Example #6
0
	public static void Attach(Entity result, Property<Matrix> property = null)
	{
		AkGameObjectTracker tracker = result.Get<AkGameObjectTracker>();
		if (tracker == null)
		{
			tracker = new AkGameObjectTracker();
			result.Add(tracker);
			if (property == null)
				property = result.Get<Transform>().Matrix;
			tracker.Add(new Binding<Matrix>(tracker.Matrix, property));
		}
	}
        public override void Update(GameTime gameTime)
        {
            var elapsedSeconds = gameTime.GetElapsedSeconds();

            foreach (var entity in ActiveEntities)
            {
                var transform = _transformMapper.Get(entity);
                var sprite    = _spriteMapper.Get(entity);

                if (_mainGame.KeyboardState.IsKeyDown(Keys.Left))
                {
                    transform.Position += new Vector2(-_playerSpeed, 0) * elapsedSeconds;
                    sprite.Effect       = SpriteEffects.FlipHorizontally;
                }

                if (_mainGame.KeyboardState.IsKeyDown(Keys.Right))
                {
                    transform.Position += new Vector2(_playerSpeed, 0) * elapsedSeconds;
                    sprite.Effect       = SpriteEffects.None;
                }

                if (_mainGame.KeyboardState.IsKeyDown(Keys.Up))
                {
                    transform.Position += new Vector2(0, -_playerSpeed) * elapsedSeconds;
                }

                if (_mainGame.KeyboardState.IsKeyDown(Keys.Down))
                {
                    transform.Position += new Vector2(0, _playerSpeed) * elapsedSeconds;
                }

                if (_previousKeyboardState.IsKeyUp(Keys.Space) && _mainGame.KeyboardState.IsKeyDown(Keys.Space))
                {
                    _spawningFireball = _entityFactory.SpawnFireball(transform.Position.X + 16, transform.Position.Y);
                }

                // Kinda hacky but it works for now.
                var spawningFireballBody = _spawningFireball?.Get <Body>();
                if (spawningFireballBody != null && _previousKeyboardState.IsKeyDown(Keys.Space) && _mainGame.KeyboardState.IsKeyUp(Keys.Space))
                {
                    spawningFireballBody.Velocity = new Vector2(200, 0);
                    _spawningFireball             = null;
                }

                var spawningFireballTransform = _spawningFireball?.Get <Transform2>();
                if (spawningFireballTransform != null)
                {
                    spawningFireballTransform.Position = new Vector2(transform.Position.X + 16, transform.Position.Y);
                }
            }

            _previousKeyboardState = _mainGame.KeyboardState;
        }
Example #8
0
        public static bool Kill(Entity zombie, Vector2? explosionVelocity)
        {
            const float LotsOfDamage = 1000 * 1000;
            zombie.Get<CHealth>().TakeDamage(LotsOfDamage);
            if (explosionVelocity.HasValue)
            {
                ZombieHelper.TriggerBloodExplosion(zombie.Transform, explosionVelocity.Value);
            }

            zombie.Get<CZombieInfo>().SetKillReason(KillReason.Instakill);
            return true;
        }
Example #9
0
File: Tick.cs Project: ktj007/mmo
        internal void OnTick(Entity entity, TickMessage tick)
        {
            // 로그아웃 한 상태에서 Tickable이 남아있는 유저는 Tick을 수행하지 않도록 한다.
            if (entity.Has<Player>() && !entity.Get<Player>().Logged)
            {
                entity.Detach<Tickable>();
                return;
            }

            if (entity.Has<Fightable>())
            {
                var fightable = entity.Get<Fightable>();
                if (fightable.IsAlive)
                {
                    if (++fightable.RecoveryCurrentTick >= fightable.RecoveryTickCount)
                    {
                        var recovery = DataCenter.Instance.GetDatum<InteractTemplate>((int)InteractTemplate.Ids.Recovery);
                        EffectSystem.Affect(entity, recovery);

                        fightable.RecoveryCurrentTick = 0;
                    }
                }
            }

            if (entity.Has<Eatable>())
            {
            }

            if (entity.Has<EntityGenerate>())
            {
                var entityGenerate = entity.Get<EntityGenerate>();
                if (entityGenerate.IsGeneratable)
                {
                    if (entityGenerate.Resource >= entityGenerate.NeededResourceToGen)
                    {
                        // generate!

                        entityGenerate.Resource -= entityGenerate.NeededResourceToGen;
                    }

                    entityGenerate.Resource += entityGenerate.IncResource;
                }
            }

            // 다음 Tick을 요청한다.
            if (entity.Has<Tickable>())
            {
                var nextMsg = new TickMessage {Id = entity.Id};
                nextMsg.ExecuteDelayed(entity, entity.Get<Tickable>().Interval);
            }
        }
Example #10
0
        public static bool TakeDamage(Entity zombie, float damage, Vector2? explosionVelocity)
        {
            CHealth health = zombie.Get<CHealth>();
            if (!health.IsAlive)
            {
                return true;
            }

            IBoosterState boosterState = zombie.EntityWorld.Services.Get<IBoosterState>();
            bool killed = health.TakeDamage(damage * BoosterHelper.GetZombieDamageRedcutionMultiplier(boosterState));
            if (explosionVelocity.HasValue)
            {
                if (killed)
                {
                    ZombieHelper.TriggerBloodExplosion(zombie.Transform, explosionVelocity.Value);
                }
                else
                {
                    ZombieHelper.TriggerBloodSplatter(zombie.Transform, Vector2.Zero);
                }
            }

            if (killed)
            {
                zombie.Get<CZombieInfo>().SetKillReason(KillReason.Normal);
            }

            return killed;
        }
Example #11
0
        public override void Start()
        {
            base.Start();

            var virtualResolution = new Vector3(GraphicsDevice.Presenter.BackBuffer.Width, GraphicsDevice.Presenter.BackBuffer.Height, 1);

            spriteBatch = new SpriteBatch(GraphicsDevice)
            {
                VirtualResolution = virtualResolution
            };

            GetSceneRendererCollection()?.Children.Add(delegateRenderer = new DelegateSceneRenderer(Draw));

            DebugCameraController  = DebugCameraController ?? Camera?.Get <DebugCameraController>();
            FollowCameraController = FollowCameraController ?? Camera?.Get <FollowCamera>();
        }
Example #12
0
        public static void HoldableOnPipeExit(Entity entity, MarioClearPipeInteraction interaction)
        {
            Holdable holdable = entity?.Get <Holdable>();

            if (holdable != null && entity.Scene != null && !holdable.IsHeld)
            {
                Vector2 speed = Vector2.Zero;

                switch (interaction.Direction)
                {
                case Direction.Left:
                    speed = new Vector2(-1.0f, 0.1f);
                    break;

                case Direction.Right:
                    speed = new Vector2(1.0f, -0.1f);
                    break;

                case Direction.Up:
                    speed = new Vector2(0, -1.0f);
                    break;

                case Direction.Down:
                    speed = new Vector2(0, 1.0f);
                    break;

                default:
                    break;
                }

                holdable.Release(speed);
            }
        }
Example #13
0
 public override void OnEntityAdded(Entity entity)
 {
     if (entity.ComponentTypes.Contains(typeof(InputComponent)))
     {
         _inputComponent = entity.Get<InputComponent>();
     }
 }
Example #14
0
        public static bool HoldableCanEnterPipe(Entity entity, Direction direction)
        {
            Holdable holdable = entity?.Get <Holdable>();

            if (holdable != null && !holdable.IsHeld)
            {
                Vector2 speed = holdable?.SpeedGetter() ?? Vector2.Zero;

                switch (direction)
                {
                case Direction.Left:
                    return(speed.X > 0);

                case Direction.Right:
                    return(speed.X < 0);

                case Direction.Up:
                    return(speed.Y > 0);

                case Direction.Down:
                    return(speed.Y < 0);

                default:
                    return(false);
                }
            }

            return(false);
        }
Example #15
0
 public static void Assign(this SpawnMsg msg, Entity entity)
 {
     msg.Id = entity.Id;
     msg.Name = entity.Get<Nameplate>().Name;
     Assign(msg.CharacterResource, entity);
     Assign(msg.UpdatePosition, entity);
 }
Example #16
0
        public override void Initialize()
        {
            this.RegisterSystems();

            FPSCamera camera = new FPSCamera(new Vector3(0f, 0f, 0f), Vector3.Zero,
                Blackboard.Get<GraphicsDevice>("GraphicsDevice").Viewport.AspectRatio, 0.05f, 100f);

            Entity fpscounter = new Entity();
            fpscounter.AddComponent(new Transform2DComponent() { Position = new Vector2(5, 150) });
            fpscounter.AddComponent(new FPSCounterComponent());
            fpscounter.AddComponent(new GUITextComponent());

            Entity pos = new Entity();
            pos.AddComponent(new PositionalTrackingComponent() { Target = camera.Get<Transform3DComponent>() });
            pos.AddComponent(new GUITextComponent());
            pos.AddComponent(new Transform2DComponent() { Position = new Vector2(5, 180) });

            Entity model = new Entity();
            model.AddComponent(new Transform3DComponent(new Vector3(0f, -1f, 2f)));
            model.Get<Transform3DComponent>().Rotation = new Vector3(0f, MathHelper.PiOver2, 3f*MathHelper.PiOver2);
            Model m = Blackboard.Get<ContentManager>("ContentManager").Load<Model>("dragon");
            model.AddComponent(new ModelComponent() { Model = m });

            this.AddEntity(model);
            this.AddEntity(pos);
            this.AddEntity(fpscounter);
            this.AddEntity(camera);
        }
Example #17
0
        protected override void UpdateEntity(float dt, Entity entity)
        {
            if (entity.Count() == 0)
            {
                return;
            }
            var direction = entity.Get<Direction>();
            var position = entity.Get<Position>();
            var input = entity.Get<InputComponent>();
            var hotspots = entity.Get<Hotspots>();

            float accel = dt * 0.8f;
            if (input.Right)
            {
                direction.X[0] = direction.X[0] + accel * (24.0f - direction.X[0]);
            }
            if (input.Left)
            {
                direction.X[0] = direction.X[0] + accel * (-24.0f - direction.X[0]);
            }
            if (!(input.Left || input.Right))
            {
                if (hotspots.BottomHit[0])
                {
                    direction.X[0] = direction.X[0] + dt * (0 - direction.X[0]);
                }
                else
                {
                    direction.X[0] = direction.X[0] + dt * .1f * (0 - direction.X[0]);
                }
            }
            if (input.Jump && hotspots.BottomHit[0])
            {
                if (input.Down)
                {
                    direction.Y[0] = 1.5f;
                    entity.Transform(0, input.DroppingPlayer);
                    input.DroppingPlayer.Get<TypeChanger>().Transformation = entity;
                    input.DroppingPlayer.Get<TypeChanger>().TTL = 0.8f;
                }
                else
                {
                    direction.Y[0] = -32.0f;
                }
            }
        }
 public override void Update()
 {
     if(Game.IsRunning && Entity.Components.Get<UIComponent>(UIComponent.Key).Enabled)
     {
         castle = (from entities in SceneSystem.SceneInstance where entities.Name == "Castle" select entities).FirstOrDefault();
         ((TextBlock)Entity.Components.Get<UIComponent>(UIComponent.Key).RootElement.VisualChildren.ElementAt(4)).Text = "Złoto: " + ((CastleController)castle.Get<ScriptComponent>(ScriptComponent.Key).Scripts[0]).gold.ToString();
         ((TextBlock)Entity.Components.Get<UIComponent>(UIComponent.Key).RootElement.VisualChildren.ElementAt(5)).Text = "Zdrowie: " + ((CastleController)castle.Get<ScriptComponent>(ScriptComponent.Key).Scripts[0]).health.ToString();
         ((TextBlock)Entity.Components.Get<UIComponent>(UIComponent.Key).RootElement.VisualChildren.ElementAt(6)).Text = "Jednostki: " + ((CastleController)castle.Get<ScriptComponent>(ScriptComponent.Key).Scripts[0]).units.ToString();
         ((TextBlock)Entity.Components.Get<UIComponent>(UIComponent.Key).RootElement.VisualChildren.ElementAt(7)).Text = "Kilofy: " + ((CastleController)castle.Get<ScriptComponent>(ScriptComponent.Key).Scripts[0]).pickaxes.ToString();
         ((TextBlock)Entity.Components.Get<UIComponent>(UIComponent.Key).RootElement.VisualChildren.ElementAt(8)).Text = "Miecze: " + ((CastleController)castle.Get<ScriptComponent>(ScriptComponent.Key).Scripts[0]).swords.ToString();
         ((TextBlock)Entity.Components.Get<UIComponent>(UIComponent.Key).RootElement.VisualChildren.ElementAt(9)).Text = "Łuki: " + ((CastleController)castle.Get<ScriptComponent>(ScriptComponent.Key).Scripts[0]).bowArrows.ToString();
         ((TextBlock)Entity.Components.Get<UIComponent>(UIComponent.Key).RootElement.VisualChildren.ElementAt(10)).Text = "Różdżki " + ((CastleController)castle.Get<ScriptComponent>(ScriptComponent.Key).Scripts[0]).wands.ToString();
         //Keyboard Input
         if(Input.IsKeyReleased(Keys.Escape))
         {
             ((Game)Game).Exit();
         }
         if(Input.IsKeyReleased(Keys.K))
         {
             ProduceUnit("KILOF");
         }
         if(Input.IsKeyReleased(Keys.M))
         {
             ProduceUnit("MIECZ");
         }
         if(Input.IsKeyReleased(Keys.L))
         {
             ProduceUnit("ŁUK");
         }
         if(Input.IsKeyReleased(Keys.R))
         {
             ProduceUnit("RÓŻDŻKA");
         }
     }
 }
Example #19
0
        public override bool OnBulletHitCallback(UpdateContext updateContext, CBullet bullet, Entity entityHit)
        {
            if (entityHit.Get<CHealth>().IsAlive && ZombieHelper.TakeDamage(entityHit, updateContext.DeltaSeconds * 10f, null))
            {
                ZombieHelper.TriggerBloodExplosion(entityHit.Transform, Vector2.Zero);
            }

            return false;
        }
Example #20
0
        public static void HoldableOnPipeUpdate(Entity entity, MarioClearPipeInteraction interaction)
        {
            Holdable holdable = entity?.Get <Holdable>();

            if (holdable != null && holdable.IsHeld)
            {
                interaction.ExitEarly = true;
            }
        }
Example #21
0
        static void Main(string[] args)
        {
            ReplaceInFile("C:\\Users\\Javier\\Desktop\\hola.txt", "C:\\Users\\Javier\\Desktop\\hola3.txt", "las personas","el mundo");
            ///////////////////////////
            //Se prueba objeto entity
            ///////////////////////////

            //Método Set (no case sensitive)
            Entity e = new Entity();
            e.Set("Nombre", "Javier");
            e.Set("Nombre", "Alonso");
            e.Set("Apellido", "Alvarez");
            e.Set("edad", 20);
            e.Set("fecha_nacimiento", new DateTime(1992,2,2));

            //Método Get (no case sensitive)
            Console.WriteLine("Información de Javier:");
            Console.WriteLine("Nombre: " + (string)e.Get("Nombre"));
            Console.WriteLine("Apellido: " + (string)e.Get("apellido"));
            Console.WriteLine("Edad: " + (int)e.Get("edad"));
            Console.WriteLine("Fecha de Nacimiento: " + (DateTime)e.Get("fecha_nacimiento"));

            ///////////////////////////
            ///////////////////////////

            ManejadorBaseDatos.Instancia.EjecutarScript("AYA");
            ///////////////////////////
            //Se prueba DA
            ///////////////////////////

            // Prueba Carga XML con DA
            Entities sp = new XMLLoader().loadXML("C://Users//Javier//.netbeans//7.1.2//config//GF3//domain1//tmsite//da//da.xml");

            // Prueba Ejecutar SP con objeto entity
            Entity parametros = new Entity();
            parametros.Set("pID", 1);
            parametros.Set("pCarro","Toyota");
            parametros.Set("pNombre","Javier");

            ///////////////////////////
            ///////////////////////////

            Console.ReadKey();
        }
Example #22
0
        public static void HoldableOnPipeEnter(Entity entity, MarioClearPipeInteraction interaction)
        {
            Holdable holdable = entity?.Get <Holdable>();

            if (holdable != null)
            {
                // Reset speeds and remove holder
                holdable.Release(Vector2.Zero);
            }
        }
Example #23
0
	public static void Attach(Entity result, Property<Vector3> property)
	{
		AkGameObjectTracker tracker = result.Get<AkGameObjectTracker>();
		if (tracker == null)
		{
			tracker = new AkGameObjectTracker();
			result.Add(tracker);
			tracker.Add(new Binding<Matrix, Vector3>(tracker.Matrix, x => Microsoft.Xna.Framework.Matrix.CreateTranslation(x), property));
		}
	}
Example #24
0
 public void Emit(Entity e)
 {
     var weaponConfig = e.Get(WeaponConfiguration);
     if (weaponConfig != null) {
         foreach (var weapon in weaponConfig) {
             weapon.ForEach<IBulletEmitter>((c) => {
                 c.Emit(weapon, e);
             });
         }
     }
 }
Example #25
0
 protected override void UpdateEntity(float dt, Entity entity)
 {
     var tc = entity.Get<TypeChanger>();
     if ((tc.TTL -= dt) <= 0)
     {
         for (int i = 0; i < entity.Count(); ++i)
         {
             entity.Transform(i, tc.Transformation);
         }
     }
 }
Example #26
0
        // Use this if you have one or two vr controllers (usually one for each hand)
        private void UpdateVrController()
        {
            var vrController = Hand == HandSide.Left ? vrDeviceSystem.Device?.LeftHand : vrDeviceSystem.Device?.RightHand;

            if (vrController == null)
            {
                return;
            }

            if (vrController.State == DeviceState.Invalid)
            {
                return;
            }

            Head.Transform.UpdateWorldMatrix();
            Entity.Transform.Parent.UpdateWorldMatrix();
            var parentWorldInv = Entity.Transform.Parent.WorldMatrix;

            parentWorldInv.Invert();

            var handPose = Matrix.RotationQuaternion(vrController.Rotation) * Matrix.Translation(vrController.Position);

            var        mat = handPose * Head.Transform.WorldMatrix * parentWorldInv;
            Vector3    pos, scale;
            Quaternion rot;

            mat.Decompose(out scale, out rot, out pos);
            Entity.Transform.Position = pos;
            Entity.Transform.Rotation = rot;

            if (vrController.Trigger > 0.5f)
            {
                if (animation != null)
                {
                    animation.TimeFactor = 1.0f;
                }

                GrabNewEntity();
            }
            else
            {
                if (animation != null)
                {
                    animation.TimeFactor = -1.0f;
                }

                var rb = grabbedEntity?.Get <RigidbodyComponent>();

                ReleaseGrabbedEntity();

                rb?.ApplyImpulse(vrController.LinearVelocity);
                rb?.ApplyTorqueImpulse(vrController.AngularVelocity / 5.0f);
            }
        }
        protected override void Initialize()
        {
            _player = this.EntityWorld.FindEntityByName(EntityNames.Player);
            _playerInfo = _player.Get<CPlayerInfo>();

            this.EntityWorld.SubscribeToMessage<ZombieKilledMessage>(this.OnZombieKilled);
            _passiveStats = this.EntityWorld.Services.Get<IPlayerPassiveStats>();
            if (_passiveStats.SpawnWithThreeLives)
            {
                _playerInfo.AddLife();
            }
        }
Example #28
0
        public Section AddBackgroundEntity(Entity backgroundEntity)
        {
            // Attach  it in ModelEntity
            RootEntity.AddChild(backgroundEntity);

            // Get length via its bounding box
            var modelComponent = backgroundEntity.Get<ModelComponent>().Model;
            var boundingBox = modelComponent.BoundingBox;

            Length += boundingBox.Maximum.Z - boundingBox.Minimum.Z;

            return this;
        }
Example #29
0
        private void ChangeMaterial(Material material)
        {
            var modelComponent = Entity?.Get <ModelComponent>();

            if (modelComponent != null)
            {
                var materialCount = modelComponent.Materials.Count;
                modelComponent.Materials.Clear();
                for (int i = 0; i < materialCount; i++)
                {
                    modelComponent.Materials.Add(i, material);
                }
            }
        }
        /// <summary>
        /// Factory method to create Section from a given BackgroundEntity
        /// </summary>
        /// <param name="backgroundEnt"></param>
        /// <param name="maxObstacleOverride">The maximum number of obstacle in the block level</param>
        /// <returns></returns>
        private Section CreateLevelBlock(Entity backgroundEnt, int? maxObstacleOverride = null)
        {
            // Reset position
            backgroundEnt.Transform.Position = Vector3.Zero;

            var levelBlock = new Section();
            var backgroundInfo = backgroundEnt.Get<BackgroundInfo>();
            levelBlock.AddBackgroundEntity(backgroundEnt).AddHoleRange(backgroundInfo.Holes);

            var len = levelBlock.Length;
            RandomAddObstacles(levelBlock, len, maxObstacleOverride ?? backgroundInfo.MaxNbObstacles);

            return levelBlock;
        }
Example #31
0
        public void Update(Entity e, KeyboardState s)
        {
            var v = Vector2.Zero;
            if (s.IsKeyDown(Keys.Left )) { v.X -= 1; }
            if (s.IsKeyDown(Keys.Right)) { v.X += 1; }
            if (s.IsKeyDown(Keys.Down )) { v.Y += 1; }
            if (s.IsKeyDown(Keys.Up   )) { v.Y -= 1; }

            if (v != Vector2.Zero) {
                v.Normalize();
            }

            e.Set(Located.Velocity, v * e.Get(MovementSpeed));
        }
Example #32
0
        public void Use(Entity itemEntity, ProgramData data, int?targetX = null, int?targetY = null)
        {
            var item = itemEntity?.Get <ItemComponent>();

            if (item == null)
            {
                return;
            }

            if (item.ItemFunction == null)
            {
                if (itemEntity.Get <EquippableComponent>() != null)
                {
                    data.Events.Add(new ToggleEquipEvent(itemEntity));
                }
                else
                {
                    data.GameData.MessageLog.AddMessage($"The {itemEntity.Name} cannot be used", Color.Yellow);
                }
            }
            else
            {
                if (item.Targeting && (targetX == null || targetY == null))
                {
                    data.Events.Add(new TargetingStartEvent(itemEntity));
                }
                else
                {
                    item.ItemFunction.Target     = Owner;
                    item.ItemFunction.Entities   = data.GameData.Entities;
                    item.ItemFunction.DungeonMap = data.GameData.DungeonLevel.Map;
                    item.ItemFunction.TargetX    = targetX;
                    item.ItemFunction.TargetY    = targetY;

                    var events = item.ItemFunction.Execute(data);

                    foreach (var @event in events)
                    {
                        if (@event is ItemConsumedEvent)
                        {
                            Items.Remove(itemEntity);
                        }

                        data.Events.Add(@event);
                    }
                }
            }
        }
Example #33
0
        private Vector2 GeneratePosition()
        {
            Entity?player    = _world.Entities.With <Player>().FirstOrDefault();
            var    transform = player?.Get <Transform>();

            Vector2 position;

            do
            {
                position = new Vector2(
                    (float)_world.Random.NextDouble() * _world.Width,
                    (float)_world.Random.NextDouble() * _world.Height
                    );
            } while (transform != null && (transform.Position - position).Length() < SafeDistance);

            return(position);
        }
Example #34
0
        public static string GetDocumentGuidFromExtensibleStorage(Document document)
        {
            Schema guidSchema = GetRegularDocumentGUIDSchema();

            // Retrieving and testing all DataStorage objects in the document against our DocumentGuid schema.
            List <DataStorage> allDataStorage = new FilteredElementCollector(document).OfClass(typeof(DataStorage)).OfType <DataStorage>().ToList();

            if (allDataStorage.Count < 1)
            {
                return(null);
            }

            // Returning the document RuleGuid if the schema is employed, otherwise null
            DataStorage documentGuidDataStorage = allDataStorage.FirstOrDefault(x => x.GetEntity(guidSchema).IsValid());
            Entity      documentGuidEntity      = documentGuidDataStorage?.GetEntity(guidSchema);
            string      documentGuid            = documentGuidEntity?.Get <string>("RegularDocumentGUID");

            return(documentGuid);
        }
Example #35
0
        /// <summary>
        /// Chaining method for adding an obstacle to this Section.
        /// It initializes bounding boxes and stores in Collidable Obstacles.
        /// </summary>
        /// <param name="obstacleEntity">The entity containing the obstacle</param>
        /// <param name="useSubBoundingBoxes">true to use the bounding boxes of the sub-meshes</param>
        /// <returns></returns>
        public Section AddObstacleEntity(Entity obstacleEntity, bool useSubBoundingBoxes)
        {
            // Attach it in ModelEntity
            RootEntity.AddChild(obstacleEntity);

            // Get and add bb to CollidableObstacles
            var modelComponent = obstacleEntity.Get<ModelComponent>();

            var collidableObstacle = new Obstacle { Entity = obstacleEntity };

            if (useSubBoundingBoxes)
            {
                // Use bounding boxes from parts of the obstacle.
                foreach (var mesh in modelComponent.Model.Meshes)
                {
                    var boundingBox = mesh.BoundingBox;
                    var nodeIndex = mesh.NodeIndex;
                    while (nodeIndex >= 0)
                    {
                        var node = modelComponent.Model.Skeleton.Nodes[nodeIndex];
                        var transform = node.Transform;
                        var matrix = Matrix.Transformation(Vector3.Zero, Quaternion.Identity, transform.Scale, Vector3.Zero, transform.Rotation, transform.Position);

                        Vector3.TransformNormal(ref boundingBox.Minimum, ref matrix, out boundingBox.Minimum);
                        Vector3.TransformNormal(ref boundingBox.Maximum, ref matrix, out boundingBox.Maximum);

                        nodeIndex = node.ParentIndex;
                    }

                    collidableObstacle.BoundingBoxes.Add(boundingBox);
                }
            }
            else
            {
                // Use bounding box of the whole model
                collidableObstacle.BoundingBoxes.Add(modelComponent.Model.BoundingBox); 
            }

            CollidableObstacles.Add(collidableObstacle);

            return this;
        }
 public void Draw(GameTime gameTime)
 {
     int width = World.Width;
     int height = World.Height;
     
     Entity? player = World.Entities.With<Player>().FirstOrDefault();
     Vector2 playerPosition = player?.Get<Transform>().Position ?? _oldPlayerPosition;
     _oldPlayerPosition = playerPosition;
     Vector2 playerToCenter = playerPosition - new Vector2(width / 2f, height / 2f);
     Vector2 absPlayerToCenter = new Vector2(MathF.Abs(playerToCenter.X), MathF.Abs(playerToCenter.Y)) / new Vector2(width, height);
     Vector2 parallaxShift = new Vector2(MathF.Cos(absPlayerToCenter.X), MathF.Sin(absPlayerToCenter.Y)) * ParallaxMaxShift;
     
     _spriteBatch.Begin();
     
     for (var i = 0; i < width; i += _firstLayer.Width)
     for (var j = 0; j < height; j += _firstLayer.Height)
     {
         _spriteBatch.Draw(
             _firstLayer,
             new Vector2(i, j),
             null,
             Color.White,
             0,
             Vector2.Zero,
             1f,
             SpriteEffects.None,
             0f
         );
         _spriteBatch.Draw(
             _secondLayer,
             new Vector2(i, j) - parallaxShift,
             null,
             Color.White,
             0,
             Vector2.Zero,
             1f,
             SpriteEffects.None,
             1f
         );
     }
     _spriteBatch.End();
 }
        private bool ShouldEscape(Entity zombie, CGoldenGoblinAI goldenGoblinAI)
        {
            // is player too close?
            const float DistanceToStartEscape = SkypieaConstants.PixelsPerMeter * 3;
            if (Vector2.Distance(_playerTransform.Position, zombie.Transform.Position) < DistanceToStartEscape)
            {
                return true;
            }

            // is at last waypoint
            if (goldenGoblinAI.CurrentWaypointIndex >= goldenGoblinAI.Waypoints.Count)
            {
                return true;
            }

            // has golden goblin been hit too much?
            const float EscapeLifeBoundary = 0.6f; // awful name.. basically how much life must be taken (in %) for the goblin to start escaping?
            CHealth health = zombie.Get<CHealth>();
            return health.CurrentHealth < health.MaximumHealth * EscapeLifeBoundary;
        }
        /// <summary>
        /// Called on every frame update
        /// </summary>
        public override void Update()
        {
            var camForward   = Entity.Transform.WorldMatrix.Forward * 2;
            var holdPosition = Entity.GetParent().Transform.Position + Vector3.UnitY * 3 + camForward;

            if (Input.IsKeyPressed(Keys.E))
            {
                if (cooldownRemaining == 0)
                {
                    pullRemainingDuration = PullDuration;
                    cooldownRemaining     = Cooldown;

                    var raycastStart = Entity.Transform.WorldMatrix.TranslationVector;
                    var forward      = Entity.Transform.WorldMatrix.Forward;
                    var raycastEnd   = raycastStart + forward * MaxPullDistance;

                    var result = this.GetSimulation().Raycast(raycastStart, raycastEnd);


                    if (result.Succeeded && result.Collider != null)
                    {
                        if (result.Collider is RigidbodyComponent rigidBody)
                        {
                            onHold = Entity.Scene.Entities.First(e => e.Get <RigidbodyComponent>() == rigidBody);
                        }
                    }
                }
            }
            if (pullRemainingDuration > 0)
            {
                var direction = (holdPosition - onHold.Transform.Position) * (float)ForceDirection;
                direction.Normalize();
                onHold?.Get <RigidbodyComponent>()?.ApplyImpulse(direction * (float)Game.UpdateTime.Elapsed.TotalSeconds * PullImpulse);
                pullRemainingDuration = (pullRemainingDuration - (float)Game.UpdateTime.Elapsed.TotalSeconds >= 0) ? pullRemainingDuration - (float)Game.UpdateTime.Elapsed.TotalSeconds : 0;
            }
            if (pullRemainingDuration == 0 && cooldownRemaining > 0)
            {
                cooldownRemaining = (cooldownRemaining - (float)Game.UpdateTime.Elapsed.TotalSeconds >= 0) ? cooldownRemaining - (float)Game.UpdateTime.Elapsed.TotalSeconds : 0;
            }
        }
 protected override void Draw(GraphicsContext graphicsContext, Entity entity)
 {
     this.DrawThumbStick(graphicsContext, entity.Get<CVirtualThumbstick>());
 }
Example #40
0
 public void Draw(Entity e, SpriteBatch b)
 {
     b.DrawString(e.Get(Font), e.Get(Text), e.Get(Located.Position), Color.White);
 }
Example #41
0
        public EatResponse OnEvent(EventId id, object cookie)
        {
            if (id <= EventId.ChampionStartedRepairing)
            {
                switch (id)
                {
                case EventId.BuildingViewReady:
                {
                    EntityViewParams entityViewParams = (EntityViewParams)cookie;
                    Entity           entity           = entityViewParams.Entity;
                    if (this.waitingForView.Contains(entity))
                    {
                        this.waitingForView.Remove(entity);
                        GameObjectViewComponent view = entity.Get <GameObjectViewComponent>();
                        List <ScaffoldingData>  list = this.viewObjects[entity];
                        int i     = 0;
                        int count = list.Count;
                        while (i < count)
                        {
                            GameObject gameObj = list[i].GameObj;
                            gameObj.SetActive(true);
                            this.AttachToView(gameObj, view);
                            i++;
                        }
                        return(EatResponse.NotEaten);
                    }
                    return(EatResponse.NotEaten);
                }

                case EventId.BuildingViewFailed:
                    return(EatResponse.NotEaten);

                case EventId.BuildingCancelled:
                    this.HideScaffold(((ContractEventData)cookie).Entity);
                    return(EatResponse.NotEaten);

                case EventId.TroopCancelled:
                    break;

                default:
                    if (id == EventId.ViewObjectsPurged)
                    {
                        this.HideScaffold((Entity)cookie);
                        return(EatResponse.NotEaten);
                    }
                    if (id != EventId.ChampionStartedRepairing)
                    {
                        return(EatResponse.NotEaten);
                    }
                    goto IL_E2;
                }
            }
            else if (id <= EventId.BuildingConstructed)
            {
                if (id != EventId.ChampionRepaired)
                {
                    switch (id)
                    {
                    case EventId.BuildingLevelUpgraded:
                    case EventId.BuildingSwapped:
                    case EventId.BuildingConstructed:
                    {
                        ContractEventData contractEventData = (ContractEventData)cookie;
                        this.HideScaffold(contractEventData.Entity);
                        return(EatResponse.NotEaten);
                    }

                    default:
                        return(EatResponse.NotEaten);
                    }
                }
            }
            else if (id != EventId.ContractStarted)
            {
                if (id != EventId.ShowScaffolding)
                {
                    return(EatResponse.NotEaten);
                }
                goto IL_E2;
            }
            else
            {
                ContractEventData contractEventData2 = (ContractEventData)cookie;
                switch (contractEventData2.Contract.DeliveryType)
                {
                case DeliveryType.Building:
                case DeliveryType.UpgradeBuilding:
                case DeliveryType.SwapBuilding:
                    this.ShowScaffold(contractEventData2.Entity);
                    return(EatResponse.NotEaten);

                default:
                    return(EatResponse.NotEaten);
                }
            }
            ContractEventData contractEventData3 = cookie as ContractEventData;
            SmartEntity       smartEntity        = (SmartEntity)contractEventData3.Entity;

            if (smartEntity.BuildingComp.BuildingType.Type == BuildingType.ChampionPlatform)
            {
                this.HideScaffold(contractEventData3.Entity);
                return(EatResponse.NotEaten);
            }
            return(EatResponse.NotEaten);

IL_E2:
            this.ShowScaffold((Entity)cookie);
            return(EatResponse.NotEaten);
        }
Example #42
0
 private void ShowScaffold(Entity building)
 {
     if (!this.viewObjects.ContainsKey(building))
     {
         BuildingComponent buildingComponent = building.Get <BuildingComponent>();
         if (buildingComponent == null)
         {
             return;
         }
         BuildingTypeVO buildingType = buildingComponent.BuildingType;
         FactionType    faction      = buildingType.Faction;
         string         text;
         if (faction != FactionType.Empire)
         {
             text = "rbl";
         }
         else
         {
             text = "emp";
         }
         if (text != null)
         {
             List <string>      list  = new List <string>();
             List <object>      list2 = new List <object>();
             List <AssetHandle> list3 = new List <AssetHandle>();
             int num = Math.Min(buildingType.SizeY, 6);
             for (int i = 2; i <= num; i++)
             {
                 string item = string.Format("scaffold_{0}-mod_{1}", new object[]
                 {
                     text,
                     i
                 });
                 list.Add(item);
                 list2.Add(new ScaffoldingData(building, num - i, false));
                 list3.Add(AssetHandle.Invalid);
             }
             int num2 = Math.Min(buildingType.SizeX, 6);
             for (int j = 2; j <= num2; j++)
             {
                 string item2 = string.Format("scaffold_{0}-mod_{1}", new object[]
                 {
                     text,
                     j
                 });
                 list.Add(item2);
                 list2.Add(new ScaffoldingData(building, num2 - j, true));
                 list3.Add(AssetHandle.Invalid);
             }
             if (list.Count > 0)
             {
                 Service.Get <AssetManager>().MultiLoad(list3, list, new AssetSuccessDelegate(this.OnAssetSuccess), new AssetFailureDelegate(this.OnAssetFailure), list2, null, null);
                 int k     = 0;
                 int count = list2.Count;
                 while (k < count)
                 {
                     ScaffoldingData scaffoldingData = (ScaffoldingData)list2[k];
                     scaffoldingData.Handle = list3[k];
                     k++;
                 }
                 List <ScaffoldingData> value = new List <ScaffoldingData>();
                 this.viewObjects.Add(building, value);
             }
         }
     }
 }
Example #43
0
        protected override async Task LoadContent()
        {
            await base.LoadContent();

            // create pipeline
            CreatePipeline();

            // setup the scene
            var material = Asset.Load <Material>("BasicMaterial");

            teapotEntity = new Entity()
            {
                new ModelComponent()
                {
                    Model = new Model()
                    {
                        material,
                        new Mesh()
                        {
                            Draw          = GeometricPrimitive.Teapot.New(GraphicsDevice).ToMeshDraw(),
                            MaterialIndex = 0,
                        }
                    }
                }
            };
            Entities.Add(teapotEntity);

            var textureCube         = Asset.Load <Texture>("uv_cube");
            var staticCubemapEntity = new Entity()
            {
                new CubemapSourceComponent(textureCube)
                {
                    InfluenceRadius = 2f, IsDynamic = false
                },
                new TransformationComponent()
                {
                    Translation = Vector3.UnitZ
                }
            };

            Entities.Add(staticCubemapEntity);

            dynamicCubemapEntity = new Entity()
            {
                new CubemapSourceComponent(textureCube)
                {
                    InfluenceRadius = 0.5f, IsDynamic = false
                },
                new TransformationComponent()
                {
                    Translation = Vector3.Zero
                }
            };
            Entities.Add(dynamicCubemapEntity);

            var mainCamera = new Entity()
            {
                new CameraComponent
                {
                    AspectRatio         = 8 / 4.8f,
                    FarPlane            = 20,
                    NearPlane           = 1,
                    VerticalFieldOfView = 0.6f,
                    Target   = teapotEntity,
                    TargetUp = Vector3.UnitY,
                },
                new TransformationComponent
                {
                    Translation = new Vector3(4, 3, 0)
                }
            };

            Entities.Add(mainCamera);

            RenderSystem.Pipeline.SetCamera(mainCamera.Get <CameraComponent>());

            Script.Add(GameScript1);
        }
Example #44
0
        private void GrabNewEntity()
        {
            if (grabbedEntity != null)
            {
                return;
            }

            var collisions = Entity.Get <PhysicsComponent>().Collisions;

            if (collisions.Count == 0)
            {
                return;
            }

            var enumerator = collisions.GetEnumerator();

            while (enumerator.MoveNext())
            {
                var collision = enumerator.Current;
                var entityA   = collision?.ColliderA?.Entity;
                var entityB   = collision?.ColliderB?.Entity;

                var otherEntity = (entityA == Entity) ? entityB : entityA;

                var otherRigidBody = otherEntity?.Get <RigidbodyComponent>();
                if (otherRigidBody == null || otherRigidBody.IsKinematic ||
                    otherRigidBody.CollisionGroup == CollisionFilterGroups.CharacterFilter)
                {
                    continue;
                }

                grabbedEntity = otherEntity;
                break;
            }

            if (grabbedEntity == null)
            {
                return;
            }

            var rigidBody = grabbedEntity?.Get <RigidbodyComponent>();

            rigidBody.IsKinematic = true;
            rigidBody.CanSleep    = false;

            Vector3    posObject, posParent;
            Vector3    sclObject, sclParent;
            Quaternion rotObject, rotParent;

            // Make sure old positions are up to date
            grabbedEntity.Transform.UpdateWorldMatrix();
            grabbedEntity.Transform.WorldMatrix.Decompose(out sclObject, out rotObject, out posObject);
            var parentEntity = Entity.GetChild(0);

            parentEntity.Transform.WorldMatrix.Decompose(out sclParent, out rotParent, out posParent);

            // Calculate relative transformations
            posObject -= posParent;
            posObject /= sclParent;
            rotParent.Conjugate();
            rotParent.Rotate(ref posObject);
            rotObject = rotParent * rotObject;

            // Attach the object to the parent
            var transformLink = grabbedEntity.Get <ModelNodeLinkComponent>();

            if (transformLink != null)
            {
                transformLink.Target = parentEntity.Get <ModelComponent>();
            }
            else
            {
                transformLink        = new ModelNodeLinkComponent();
                transformLink.Target = parentEntity.Get <ModelComponent>();
                grabbedEntity.Add(transformLink);
            }

            grabbedEntity.Transform.UseTRS   = true;
            grabbedEntity.Transform.Position = posObject;
            grabbedEntity.Transform.Rotation = rotObject;
        }
        public void CloneRefsWithBaseDefinition()
        {
            var x = DateTime.Now.ToUniversalTime().ToString("yyyyMMddHHmmss");

            #region Arrange

            // Types
            var userResource     = Entity.Get <EntityType>(new EntityRef("core", "userResource"));
            var myBaseDefinition = new Definition {
                Name = "clonebasedefinition" + x, Inherits = new EntityCollection <EntityType>(userResource.ToEnumerable())
            };
            myBaseDefinition.Save();

            var myRelatedDefinition = new Definition {
                Name = "clonerelateddefinition" + x, Inherits = new EntityCollection <EntityType>(userResource.ToEnumerable())
            };
            myRelatedDefinition.Save();

            var myBaseType    = Entity.Get <EntityType>(myBaseDefinition);
            var myRelatedType = Entity.Get <EntityType>(myRelatedDefinition);
            var myBaseToRelatedRelationship = new Relationship
            {
                FromType                = myBaseType,
                ToType                  = myRelatedType,
                Name                    = "clonebaserelationship" + x,
                Description             = "Clone With Base Definition",
                Cardinality             = Entity.Get <CardinalityEnum>(new EntityRef("core", "manyToMany")),
                CascadeDelete           = false,
                CascadeDeleteTo         = false,
                CloneAction_Enum        = CloneActionEnum_Enumeration.CloneReferences,
                ReverseCloneAction_Enum = CloneActionEnum_Enumeration.CloneReferences
            };
            myBaseToRelatedRelationship.Save();

            var myDefinitionA = new Definition {
                Name = "clonedefinitionA" + x, Inherits = new EntityCollection <EntityType>(myBaseType.ToEnumerable())
            };
            myDefinitionA.Save();

            var myDefinitionB = new Definition {
                Name = "clonedefinitionB" + x, Inherits = new EntityCollection <EntityType>(myBaseType.ToEnumerable())
            };
            myDefinitionB.Save();

            // Instances
            var rOne = new Entity(myRelatedDefinition);
            rOne.SetField(new EntityRef("core", "name"), "Related 1." + x);
            rOne.Save();

            var rTwo = new Entity(myRelatedDefinition);
            rTwo.SetField(new EntityRef("core", "name"), "Related 2." + x);
            rTwo.Save();

            var rCollection = new EntityRelationshipCollection <IEntity>();
            rCollection.Add(rOne);
            rCollection.Add(rTwo);

            var cA = new Entity(myDefinitionA);
            cA.SetField(new EntityRef("core", "name"), "Clone Me A." + x);
            cA.SetRelationships(myBaseToRelatedRelationship, rCollection);
            cA.Save();

            // Workflow Setup
            var cloneActivity = new CloneActivity();
            cloneActivity.Save();

            var nextActivity = (CloneImplementation)cloneActivity.As <WfActivity>().CreateWindowsActivity();
            var inputs       = new Dictionary <string, object>
            {
                { "Record", cA },
                { "Object", myDefinitionB } // core:newDefinitionCloneArgument
            };

            ToDelete.Add(cloneActivity.Id);
            ToDelete.Add(cA.Id);
            ToDelete.Add(myDefinitionA.Id);
            ToDelete.Add(myDefinitionB.Id);
            ToDelete.Add(myRelatedDefinition.Id);
            ToDelete.Add(myBaseDefinition.Id);

            #endregion

            var result   = RunActivity(nextActivity, inputs);
            var clone    = ((IEntity)result["Record"]);
            var original = Entity.Get(cA.Id);

            clone.Id.Should().NotBe(original.Id);

            ToDelete.Add(clone.Id);

            var rid = myBaseToRelatedRelationship.Id;

            var cloneRels = clone.GetRelationships(rid, Direction.Forward).ToList();
            cloneRels.Count.Should().Be(2);
            foreach (var cloneRel in cloneRels)
            {
                var revs = cloneRel.GetRelationships(rid, Direction.Reverse);
                revs.Select(r => r.Id).Should().Contain(new [] { original.Id, clone.Id });
            }

            var originalRels = original.GetRelationships(rid, Direction.Forward).ToList();

            originalRels.Count.Should().Be(2);
            originalRels.Select(o => o.Id).Should().BeEquivalentTo(cloneRels.Select(c => c.Id));
        }
Example #46
0
        internal void ChangeSlotInternal(EquiPlayerAttachmentComponent.Slot slot, float randSeed)
        {
            this.GetLogger().Debug($"Changing slot for {Entity} to {slot?.Controllable?.Entity}#{slot?.Definition.Name}");
            var old = _controlledSlot;

            _controlledSlot = slot;

            var oldAnimData = old?.Definition.ByIndex(_saveData.AnimationId);

            EquiPlayerAttachmentComponentDefinition.AnimationDesc?newAnimData = null;
            if (slot != null && _saveData.ControlledSlot == slot.Definition.Name)
            {
                newAnimData = slot.Definition.ByIndex(_saveData.AnimationId);
            }
            if (!newAnimData.HasValue)
            {
                newAnimData = slot?.Definition.SelectAnimation(Entity.DefinitionId ?? default(MyDefinitionId), randSeed, out _saveData.AnimationId);
            }

            // Handles animation controller switching
            var animController = Entity.Components.Get <MyAnimationControllerComponent>();

            if (animController != null)
            {
                if (oldAnimData.HasValue)
                {
                    animController.TriggerAction(oldAnimData.Value.Stop);
                }
                if (newAnimData.HasValue)
                {
                    AddScheduledCallback(CommitAnimationStart);
                }
            }

            // Handle restoring character's position
            if (slot == null && old?.Controllable?.Entity != null && old.Controllable.Entity.InScene)
            {
                var relMatrix = _saveData.RelativeOrientation.GetMatrix();
                if (relMatrix.Scale.AbsMax() < 1)
                {
                    relMatrix = MatrixD.Identity;
                }
                var outPos         = relMatrix * old.AttachMatrix;
                var gravity        = Vector3.Normalize(MyGravityProviderSystem.CalculateTotalGravityInPoint(outPos.Translation));
                var rightCandidate = Vector3.Cross(gravity, (Vector3)outPos.Forward);
                if (rightCandidate.LengthSquared() < 0.5f)
                {
                    rightCandidate = MyUtils.GetRandomVector3();
                }
                var correctedForward = Vector3.Normalize(Vector3.Cross(rightCandidate, gravity));
                outPos = MatrixD.CreateWorld(outPos.Translation, correctedForward, -gravity);
                var transformedCenter   = Vector3.TransformNormal(Entity.PositionComp.LocalAABB.Center, outPos);
                var orientation         = Quaternion.CreateFromRotationMatrix(outPos);
                var originalHalfExtents = Entity.PositionComp.LocalAABB.HalfExtents;
                var halfExtents         = new Vector3(originalHalfExtents.X * 0.8f, originalHalfExtents.Y, originalHalfExtents.Z * 0.8f);

                const int maxUpwardShifts = 4;
                var       shiftDistance   = 0f;
                for (var i = 0; i <= maxUpwardShifts; i++)
                {
                    shiftDistance = (float)Math.Pow(i, 1.5f);
                    var outPosCenter = outPos.Translation + transformedCenter - gravity * shiftDistance;
                    if (i < maxUpwardShifts)
                    {
                        var translate = FindFreePlaceImproved(outPosCenter, orientation, halfExtents, gravity);
                        if (!translate.HasValue)
                        {
                            continue;
                        }
                        outPos.Translation = translate.Value - transformedCenter;
                        break;
                    }
                    else
                    {
                        var translate = MyEntities.FindFreePlace(outPosCenter, orientation, halfExtents,
                                                                 1000, 50, 0.1f,
                                                                 /* on the last try push to the surface */ true);
                        if (translate.HasValue)
                        {
                            outPos.Translation = translate.Value - transformedCenter;
                        }
                        else
                        {
                            outPos.Translation = old.AttachMatrix.Translation;
                        }
                        break;
                    }
                }

                // Final clean up with minor shift to get out of overlapping any surfaces
                var finalShift = MyEntities.FindFreePlace(outPos.Translation + transformedCenter, orientation,
                                                          originalHalfExtents * 1.05f, 250, 50, 0.025f, false);
                if (finalShift.HasValue)
                {
                    outPos.Translation = finalShift.Value - transformedCenter;
                }

                if (MyAPIGateway.Physics.CastRay(outPos.Translation - gravity, outPos.Translation + (1 + shiftDistance) * gravity, out var hit))
                {
                    outPos.Translation = hit.Position;
                }
                Entity.PositionComp.SetWorldMatrix(outPos, Entity.Parent, true);

                // Give the player 5 seconds of health immunity when they leave a chair to prevent collisions from killing them if we couldn't
                // find a free space
                Entity?.Get <MyCharacterDamageComponent>()?.AddTemporaryHealthImmunity(2);
            }

            // Handles storing the character's position when attaching
            if (slot != null)
            {
                _saveData.RelativeOrientation = new MyPositionAndOrientation(MatrixD.Normalize(Entity.WorldMatrix * MatrixD.Invert(slot.AttachMatrix)));
            }


            // Handle keeping the physics in check
            if (Entity.Physics != null)
            {
                var wantsPhysicsEnabled = slot == null;
                if (wantsPhysicsEnabled && !Entity.Physics.Enabled)
                {
                    Entity.Physics.Activate();
                }
                else if (!wantsPhysicsEnabled && Entity.Physics.Enabled)
                {
                    Entity.Physics.Deactivate();
                }
                if (slot == null)
                {
                    var oldPhys = old?.Controllable?.Entity.ParentedPhysics();
                    if (oldPhys != null)
                    {
                        Entity.Physics.LinearVelocity = oldPhys.GetVelocityAtPoint(old.Controllable.Entity.WorldMatrix.Translation);
                    }
                }
            }

            _saveData.ControlledEntity = slot?.Controllable.Entity.EntityId ?? 0;
            _saveData.ControlledSlot   = slot?.Definition.Name;
            if (slot == null)
            {
                _tracker.Unlink(Entity.EntityId);
            }
            else
            {
                _tracker.Link(Entity.EntityId, new ControlledId(slot));
            }

            if (old?.Controllable != null)
            {
                RemoveFixedUpdate(FixPosition);
            }

            if (slot?.Controllable != null)
            {
                AddFixedUpdate(FixPosition, PriorityOverride);
            }

            FixPosition();

            if (old != null)
            {
                old.AttachedCharacter = null;
            }
            if (slot != null)
            {
                slot.AttachedCharacter = Entity;
            }
            ControlledChanged?.Invoke(this, old, slot);
            _tracker.RaiseControlledChange(this, old, slot);
        }
Example #47
0
        protected override async Task LoadContent()
        {
            await base.LoadContent();

            Window.AllowUserResizing = true;

            await base.LoadContent();

            Window.AllowUserResizing = true;

            arial16 = Content.Load<SpriteFont>("DynamicFonts/Arial16");

            // Instantiate a scene with a single entity and model component
            var scene = new Scene();

            // Fixed size
            scene.Entities.Add(GetUIEntity(arial16, true, new Vector3(0, 0, 4)));
            scene.Entities.Add(GetUIEntity(arial16, true, new Vector3(-2, 1, 0)));
            scene.Entities.Add(GetUIEntity(arial16, true, new Vector3(2, 2, -2)));
            scene.Entities.Add(GetUIEntity(arial16, true, new Vector3(0, 1, 0)));
            scene.Entities.Add(GetUIEntity(arial16, true, new Vector3(0, 2, -2)));

            scene.Entities.Add(GetUIEntity(arial16, false, new Vector3(0, -0.3f, 4)));
            scene.Entities.Add(GetUIEntity(arial16, false, new Vector3(-2, 0, 0)));
            scene.Entities.Add(GetUIEntity(arial16, false, new Vector3(2, 1, -2)));


            // Create a camera entity and add it to the scene
            var cameraEntity = new Entity { new CameraComponent() };
            cameraEntity.Transform.Position = new Vector3(0, 0, 5);
            scene.Entities.Add(cameraEntity);

            // Create a graphics compositor
            var compositor = new SceneGraphicsCompositorLayers();

            bool isLDR = true;
            if (isLDR)
            {
                compositor.Master.Renderers.Add(new ClearRenderFrameRenderer());
                compositor.Master.Renderers.Add(new SceneCameraRenderer() { });
            }
            else
            {
                var layer = new SceneGraphicsLayer();
                var renderHDROutput = new LocalRenderFrameProvider { Descriptor = { Format = RenderFrameFormat.HDR, DepthFormat = RenderFrameDepthFormat.Shared } };
                layer.Output = renderHDROutput;
                layer.Renderers.Add(new ClearRenderFrameRenderer());
                layer.Renderers.Add(new SceneCameraRenderer());
                compositor.Layers.Add(layer);
                compositor.Master.Renderers.Add(new SceneEffectRenderer()
                {
                    Effect = new PostProcessingEffects()
                });
            }
            compositor.Cameras.Add(cameraEntity.Get<CameraComponent>());

            // Use this graphics compositor
            scene.Settings.GraphicsCompositor = compositor;

            // Create a scene instance
            SceneSystem.SceneInstance = new SceneInstance(Services, scene);
        }
 private static string GetText(Entity entity)
 {
     return "Hold mouse still for " + entity.Get<MouseHoverTrigger>().Elapsed + " seconds.";
 }
Example #49
0
 public static bool IsPlayer(Entity entity)
 {
     return(entity?.Get <CharacterComponent>() != null);
 }
Example #50
0
 private void FormEllipsePoints(Entity entity)
 {
     ellipsePoints = entity.Get<List<Vector2D>>();
     ellipsePoints.Clear();
     ellipsePoints.Add(center);
     for (int i = 0; i < pointsCount; i++)
         FormRotatedEllipsePoint(i);
     entity.Set(ellipsePoints);
 }
Example #51
0
 public static MarioClearPipeInteraction GetClearPipeInteraction(Entity entity)
 {
     return(entity?.Get <MarioClearPipeInteraction>());
 }
Example #52
0
        protected override async Task LoadContent()
        {
            await base.LoadContent();

            Window.AllowUserResizing = true;

            // Instantiate a scene with a single entity and model component
            var scene = new Scene();

            // Create a cube entity
            cubeEntity = new Entity();

            // Create a procedural model with a diffuse material
            var model = new Model();
            var material = Material.New(GraphicsDevice, new MaterialDescriptor
            {
                Attributes =
                {
                    Diffuse = new MaterialDiffuseMapFeature(new ComputeColor(Color.White)),
                    DiffuseModel = new MaterialDiffuseLambertModelFeature()
                }
            });
            model.Materials.Add(material);
            cubeEntity.Add(new ModelComponent(model));

            var modelDescriptor = new ProceduralModelDescriptor(new CubeProceduralModel());
            modelDescriptor.GenerateModel(Services, model);

            // Add the cube to the scene
            scene.Entities.Add(cubeEntity);

            // Create a camera entity and add it to the scene
            var cameraEntity = new Entity { new CameraComponent() };
            cameraEntity.Transform.Position = new Vector3(0, 0, 5);
            scene.Entities.Add(cameraEntity);

            // Create a light
            var lightEntity = new Entity()
            {
                new LightComponent()
            };

            lightEntity.Transform.Position = new Vector3(0, 0, 1);
            lightEntity.Transform.Rotation = Quaternion.RotationY(MathUtil.DegreesToRadians(45));
            scene.Entities.Add(lightEntity);

            // Create a graphics compositor
            var compositor = new SceneGraphicsCompositorLayers();

            bool isLDR = false;
            if (isLDR)
            {
                compositor.Master.Renderers.Add(new ClearRenderFrameRenderer());
                compositor.Master.Renderers.Add(new SceneCameraRenderer() {});
            }
            else
            {
                var layer = new SceneGraphicsLayer();
                var renderHDROutput = new LocalRenderFrameProvider { Descriptor = { Format = RenderFrameFormat.HDR, DepthFormat = RenderFrameDepthFormat.Shared} };
                layer.Output = renderHDROutput;
                layer.Renderers.Add(new ClearRenderFrameRenderer());
                layer.Renderers.Add(new SceneCameraRenderer());
                compositor.Layers.Add(layer);
                compositor.Master.Renderers.Add(new SceneEffectRenderer()
                {
                    Effect = new PostProcessingEffects()
                });
            }
            compositor.Cameras.Add(cameraEntity.Get<CameraComponent>());

            SceneSystem.SceneInstance = new SceneInstance(Services, scene);

            // Use this graphics compositor
            scene.Settings.GraphicsCompositor = compositor;

            // Create a scene instance
            SceneSystem.SceneInstance = new SceneInstance(Services, scene);
        }
Example #53
0
        protected override void LoadScene()
        {
            // Allow user to resize the window with the mouse.
            Game.Window.AllowUserResizing = true;

            // Create and initialize "Xenko Samples" Text
            var xenkoSampleTextBlock = new ContentDecorator
            {
                BackgroundImage = SpriteFromSheet.Create(SplashScreenImages, "xenko_sample_text_bg"),
                Content         = new TextBlock
                {
                    Font      = WesternFont,
                    TextSize  = 60,
                    Text      = "Xenko UI Particles",
                    TextColor = Color.White,
                },
                Padding             = new Thickness(35, 15, 35, 25),
                HorizontalAlignment = HorizontalAlignment.Center
            };

            xenkoSampleTextBlock.SetPanelZIndex(1);


            //*********************************
            // Confetti button
            var buttonImage = SpriteFromSheet.Create(SplashScreenImages, "button_long");

            var xenkoButtonConfetti = new Button
            {
                NotPressedImage = buttonImage,
                PressedImage    = buttonImage,
                MouseOverImage  = buttonImage,

                Content = new TextBlock
                {
                    Font      = WesternFont,
                    TextColor = Color.White,
                    Text      = "Click here to start the game over",
                    TextSize  = 24
                },

                HorizontalAlignment = HorizontalAlignment.Right,
                Padding             = new Thickness(90, 22, 25, 35),
//                BackgroundColor = Color.DarkOrchid
            };

            xenkoButtonConfetti.SetPanelZIndex(1);
            xenkoButtonConfetti.SetGridRow(1);

            xenkoButtonConfetti.Click += delegate
            {
                fusePercentage = 1f;
                desiredState   = GameState.NewGame;
                var effectOffset = new Vector3(45 - xenkoButtonConfetti.RenderSize.X / 2, -5, 0);
                SpawnParticles(xenkoButtonConfetti.WorldMatrix.TranslationVector + effectOffset, Prefab, 2f);
            };
            //*********************************

            //*********************************
            // Stars button
            var buttonStars = SpriteFromSheet.Create(SplashScreenImages, "button_short");

            var xenkoButtonStars = new Button
            {
                NotPressedImage = buttonStars,
                PressedImage    = buttonStars,
                MouseOverImage  = buttonStars,

                Content = new TextBlock
                {
                    Font      = WesternFont,
                    TextColor = Color.White,
                    Text      = "Congratulations",
                    TextSize  = 24
                },

                HorizontalAlignment = HorizontalAlignment.Right,
                Padding             = new Thickness(90, 22, 25, 35),
//                BackgroundColor = Color.DarkOrchid
            };

            xenkoButtonStars.SetPanelZIndex(1);
            xenkoButtonStars.SetGridRow(4);

            xenkoButtonStars.Click += delegate
            {
                desiredState = GameState.EndGame;
                var effectOffset = new Vector3(45 - xenkoButtonStars.RenderSize.X / 2, -5, 0);
                SpawnParticles(xenkoButtonStars.WorldMatrix.TranslationVector + effectOffset, Prefab, 2f);
            };
            //*********************************

            var bottomBar = CreateBottomBar();

            bottomBar.SetPanelZIndex(1);
            bottomBar.SetGridRow(6);

            var grid = new Grid
            {
                MaximumWidth        = virtualWidth,
                MaximumHeight       = virtualHeight,
                VerticalAlignment   = VerticalAlignment.Center,
                HorizontalAlignment = HorizontalAlignment.Center,
            };

            grid.RowDefinitions.Add(new StripDefinition(StripType.Auto));       // 0
            grid.RowDefinitions.Add(new StripDefinition(StripType.Auto));       // 1
            grid.RowDefinitions.Add(new StripDefinition(StripType.Auto));       // 2
            grid.RowDefinitions.Add(new StripDefinition(StripType.Auto));       // 3
            grid.RowDefinitions.Add(new StripDefinition(StripType.Auto));       // 4
            grid.RowDefinitions.Add(new StripDefinition(StripType.Fixed, 100)); // 5
            grid.RowDefinitions.Add(new StripDefinition(StripType.Fixed, 50));  // 5
            grid.ColumnDefinitions.Add(new StripDefinition());
            grid.LayerDefinitions.Add(new StripDefinition());

            grid.Children.Add(xenkoSampleTextBlock);
            grid.Children.Add(xenkoButtonConfetti);
            grid.Children.Add(xenkoButtonStars);
            grid.Children.Add(bottomBar);

            // Add the background
            var background = new ImageElement {
                Source = SpriteFromSheet.Create(SplashScreenImages, "background_uiimage"), StretchType = StretchType.Fill
            };

            background.SetPanelZIndex(-1);

            Entity.Get <UIComponent>().Page = new UIPage {
                RootElement = new UniformGrid {
                    Children = { background, grid }
                }
            };
        }