Example #1
0
 private void OnTrigger(CollisionTag tag, Entity otherEntity)
 {
     if (tag == CollisionTag.Bullet)
     {
         _health.ChangeHealth(-1);
     }
 }
Example #2
0
        public Collidable(Image image, CollisionTag tag) : base(image)
        {
            PositionComponent origin = GetComponent(typeof(PositionComponent)) as PositionComponent;
            RenderComponent   render = GetComponent(typeof(RenderComponent)) as RenderComponent;
            double            width  = origin.Position.x + render.sprite.Width;
            double            height = origin.Position.y + render.sprite.Height;

            AddComponent(new HitBoxComponent(this, tag, origin.Position, width, height));
        }
Example #3
0
 /// <summary>
 /// Returns a list of entities that collide with the given Collider and posess the Tag.
 /// </summary>
 public IEnumerable <Entity> Collide(CircleCollider Collider, CollisionTag Tag)
 {
     foreach (var possibleCollider in Colliders)
     {
         if (possibleCollider.Tag == Tag && possibleCollider.Entity != Collider.Entity && possibleCollider.CollidesWith(Collider))
         {
             yield return(possibleCollider.Entity);
         }
     }
 }
Example #4
0
        private void OnTrigger(CollisionTag tag, Entity otherEntity)
        {
            if (tag == CollisionTag.Bullet)
            {
                var bullet = otherEntity.GetModule <BulletModule>(ModuleType.Bullet);
                if (bullet != null && bullet.Team != _team)
                {
                    _health.ChangeHealth(-1);
                }

                otherEntity.Destroy();
            }
        }
Example #5
0
 private void OnTrigger(CollisionTag tag, Entity otherEntity)
 {
     // we are destroyed if we hit anything
     // TODO: VFX?
     this.entity?.Destroy();
 }
 private void SetTruthTableComponent(CollisionTag tag1, CollisionTag tag2, bool result)
 {
     TruthTableCollision[(int)tag1, (int)tag2] = result;
     TruthTableCollision[(int)tag2, (int)tag1] = result;
 }
 private bool CanCollide(CollisionTag tag1, CollisionTag tag2)
 {
     return(TruthTableCollision[(int)tag1, (int)tag2]);
 }
Example #8
0
 public CircleCollider(Vector2 Offset, float Radius, CollisionTag Tag)
 {
     this.Radius = Radius;
     this.Tag    = Tag;
     this.Offset = Offset;
 }
        public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
        {
            string              objname      = string.Empty;
            Vector3             worldpos     = Vector3.Zero;
            Vector2             spriteorigin = Vector2.Zero;
            SpriteSheetRectName tiletype     = SpriteSheetRectName.None;

            Humper.Base.RectangleF boundingbox  = Humper.Base.RectangleF.Empty;
            CollisionTag           collisionTag = CollisionTag.None;
            string onactivate   = string.Empty;
            string ondeactivate = string.Empty;
            object metadata     = null;

            while (reader.Read())
            {
                if (reader.TokenType != JsonToken.PropertyName)
                {
                    break;
                }

                string propertyName = (string)reader.Value;
                if (!reader.Read())
                {
                    continue;
                }

                switch (propertyName)
                {
                case "Name":
                    objname = serializer.Deserialize <string>(reader);
                    break;

                case "WorldPos":
                    worldpos = serializer.Deserialize <Vector3>(reader);
                    break;

                case "SpriteOrigin":
                    spriteorigin = serializer.Deserialize <Vector2>(reader);
                    break;

                case "TiltType":
                    tiletype = (SpriteSheetRectName)serializer.Deserialize <int>(reader);
                    break;

                case "BoundingBox":
                    boundingbox = serializer.Deserialize <Humper.Base.RectangleF>(reader);
                    break;

                case "CollisionTag":
                    collisionTag = (CollisionTag)serializer.Deserialize <int>(reader);
                    break;

                case "OnActivate":
                    onactivate = serializer.Deserialize <string>(reader);
                    break;

                case "OnDeactivate":
                    ondeactivate = serializer.Deserialize <string>(reader);
                    break;

                case "Metadata":
                    metadata = serializer.Deserialize <object>(reader);
                    break;
                }
            }

            return(new Object()
            {
                Name = objname,
                WorldPos = worldpos,
                SpriteOrigin = spriteorigin,
                TileType = tiletype,
                BoundingBox = boundingbox,
                CollisionTag = collisionTag,
                OnActivate = onactivate,
                OnDeactivate = ondeactivate,
                Memory = new Stack <string>(),
                MetaData = metadata
            });
        }
Example #10
0
 public MissileAbs(Vecteur2D origin, Image img, CollisionTag tag) : base(img, tag)
 {
     NbPixelToDestroy = 14;
     PositionComponent startPos = GetComponent(typeof(PositionComponent)) as PositionComponent;
     VelocityComponent velocity = GetComponent(typeof(VelocityComponent)) as VelocityComponent;
 }
 /// <summary>
 /// Constructeur
 /// </summary>
 /// <param name="e">L'entité du composant</param>
 /// <param name="tag">Le tag de collision</param>
 /// <param name="x">La coordonnée du point x de l'origine de la hitbox</param>
 /// <param name="y">La coordonnée du point y de l'origine de la hitbox></param>
 ///<param name="width">la largeur de la hitbox</param>
 /// <param name="height">la hauteur de la hitbox</param>
 public HitBoxComponent(Entity e, CollisionTag tag, double x, double y, double width, double height) : base(e)
 {
     HitBox   = new Box(x, y, width, height);
     this.tag = tag;
 }
 /// <summary>
 /// Constructeur
 /// </summary>
 /// <param name="e">L'entité du composant</param>
 /// <param name="tag">Le tag de collision</param>
 /// <param name="origin">Le vecteur 2D permettant de connaitre le point d'origine de la hitbox </param>
 /// <param name="width">la largeur de la hitbox</param>
 /// <param name="height">la hauteur de la hitbox</param>
 public HitBoxComponent(Entity e, CollisionTag tag, Vecteur2D origin, double width, double height) : base(e)
 {
     HitBox = new Box(origin, width, height);
     //Console.WriteLine(HitBox.ToString());
     this.tag = tag;
 }
 /// <summary>
 /// Constructeur
 /// </summary>
 /// <param name="e">L'entité du composant</param>
 /// <param name="tag">Le tag de collision</param>
 public HitBoxComponent(Entity e, CollisionTag tag) : base(e)
 {
     this.HitBox = new Box();
     this.tag    = tag;
 }
        private static Humper.Base.RectangleF GetCollsionBox(Vector2 pos, SpriteSheetRectName spriteSheetRectName)
        {
            var          result       = new Humper.Base.RectangleF();
            CollisionTag collisionTag = spriteSheetRectName.GetCollisionTag();
            var          dir          = spriteSheetRectName.GetSpriteDirection();

            switch (collisionTag)
            {
            case CollisionTag.DoorClosed:
            case CollisionTag.DoorOpened:
            case CollisionTag.Wall:

                switch (dir)
                {
                case Direction.up:
                    result.X      = pos.X - 0.3f;
                    result.Y      = pos.Y - 0.3f;
                    result.Width  = 1;
                    result.Height = 0.3f;
                    break;

                case Direction.left:
                    result.X      = pos.X - 0.3f;
                    result.Y      = pos.Y - 0.3f;
                    result.Width  = 0.3f;
                    result.Height = 1;
                    break;

                case Direction.down:
                    result.X      = pos.X - 0.3f;
                    result.Y      = pos.Y + 0.4f;
                    result.Width  = 1;
                    result.Height = 0.3f;
                    break;

                case Direction.right:
                    result.X      = pos.X + 0.4f;
                    result.Y      = pos.Y - 0.3f;
                    result.Width  = 0.3f;
                    result.Height = 1;
                    break;
                }
                break;

            case CollisionTag.Block:
                result.X      = pos.X - 0.3f;
                result.Y      = pos.Y - 0.3f;
                result.Width  = 1;
                result.Height = 1;
                break;

            case CollisionTag.PushableBlock:
                result.X      = pos.X;
                result.Y      = pos.Y;
                result.Width  = 0.3f;
                result.Height = 0.3f;
                break;

            case CollisionTag.FloorSwitch:
                result.X      = pos.X - 0.1f;
                result.Y      = pos.Y - 0.1f;
                result.Width  = 0.5f;
                result.Height = 0.5f;
                break;

            case CollisionTag.Lever:
                result.X      = pos.X - 0.1f;
                result.Y      = pos.Y - 0.1f;
                result.Width  = 0.5f;
                result.Height = 0.5f;
                break;

            case CollisionTag.Slab:
                break;

            case CollisionTag.None:
                result.X      = pos.X - 0.3f;
                result.Y      = pos.Y - 0.3f;
                result.Width  = 1;
                result.Height = 1;
                break;

            case CollisionTag.EndPoint:
                result.X      = pos.X - 0.3f;
                result.Y      = pos.Y - 0.3f;
                result.Width  = 1;
                result.Height = 1;
                break;

            case CollisionTag.Portal:
                switch (dir)
                {
                case Direction.up:
                    result.X      = pos.X - 0.1f;
                    result.Y      = pos.Y - 0.15f;
                    result.Width  = 0.5f;
                    result.Height = 0.1f;
                    break;

                case Direction.left:
                    result.X      = pos.X - 0.15f;
                    result.Y      = pos.Y - 0.1f;
                    result.Width  = 0.1f;
                    result.Height = 0.5f;
                    break;

                case Direction.down:
                    result.X      = pos.X - 0.1f;
                    result.Y      = pos.Y + 0.45f;
                    result.Width  = 0.5f;
                    result.Height = 0.1f;
                    break;

                case Direction.right:
                    result.X      = pos.X + 0.45f;
                    result.Y      = pos.Y - 0.1f;
                    result.Width  = 0.1f;
                    result.Height = 0.5f;
                    break;
                }
                break;

            case CollisionTag.PistonRetracted:
                switch (dir)
                {
                case Direction.up:
                    result.X      = pos.X - 0.35f;
                    result.Y      = pos.Y - 0.1f;
                    result.Width  = 0.75f;
                    result.Height = 0.2f;
                    break;

                case Direction.left:
                    result.X      = pos.X - 0.1f;
                    result.Y      = pos.Y - 0.35f;
                    result.Width  = 0.2f;
                    result.Height = 0.75f;
                    break;

                case Direction.down:
                    result.X      = pos.X - 0.2f;
                    result.Y      = pos.Y + 0.1f;
                    result.Width  = 0.75f;
                    result.Height = 0.2f;
                    break;

                case Direction.right:
                    result.X      = pos.X + 0.1f;
                    result.Y      = pos.Y - 0.2f;
                    result.Width  = 0.2f;
                    result.Height = 0.75f;
                    break;
                }
                break;

            case CollisionTag.PistonExtended:
                switch (dir)
                {
                case Direction.up:
                    result.X      = pos.X - 0.45f;
                    result.Y      = pos.Y + 0.35f;
                    result.Width  = 0.75f;
                    result.Height = 0.2f;
                    break;

                case Direction.left:
                    result.X      = pos.X + 0.35f;
                    result.Y      = pos.Y - 0.45f;
                    result.Width  = 0.2f;
                    result.Height = 0.75f;
                    break;

                case Direction.down:
                    result.X      = pos.X - 0.25f;
                    result.Y      = pos.Y - 0.55f;
                    result.Width  = 0.75f;
                    result.Height = 0.2f;
                    break;

                case Direction.right:
                    result.X      = pos.X - 0.55f;
                    result.Y      = pos.Y - 0.25f;
                    result.Width  = 0.2f;
                    result.Height = 0.75f;
                    break;
                }
                break;
            }

            return(result);
        }