Adds weapons (#48)

* Adds weapons

- Adds melee weapons
- Adds projectile weapons
- Adds hitscan weapons (like lasers)

* Adds a separate sprite for projectile weapons

Content.Server/GameObjects/Components/Projectiles/ProjectileComponent.cs

@@ -0,0 +1,61 @@
+using SS14.Shared.GameObjects;
+using SS14.Shared.Interfaces.GameObjects;
+using SS14.Shared.Interfaces.Physics;
+using SS14.Shared.Interfaces.GameObjects.Components;
+using System;
+using System.Collections.Generic;
+using YamlDotNet.RepresentationModel;
+using SS14.Shared.Utility;
+
+namespace Content.Server.GameObjects.Components.Projectiles
+{
+    public class ProjectileComponent : Component, ICollideSpecial, ICollideBehavior
+    {
+        public override string Name => "Projectile";
+
+        public bool IgnoreShooter = true;
+
+        private EntityUid Shooter = EntityUid.Invalid;
+
+        public Dictionary<DamageType, int> damages = new Dictionary<DamageType, int>();
+
+        /// <summary>
+        /// Function that makes the collision of this object ignore a specific entity so we don't collide with ourselves
+        /// </summary>
+        /// <param name="shooter"></param>
+        public void IgnoreEntity(IEntity shooter)
+        {
+            Shooter = shooter.Uid;
+        }
+
+        /// <summary>
+        /// Special collision override, can be used to give custom behaviors deciding when to collide
+        /// </summary>
+        /// <param name="collidedwith"></param>
+        /// <returns></returns>
+        bool ICollideSpecial.PreventCollide(ICollidable collidedwith)
+        {
+            if (IgnoreShooter && collidedwith.Owner.Uid == Shooter)
+                return true;
+            return false;
+        }
+
+        /// <summary>
+        /// Applys the damage when our projectile collides with its victim
+        /// </summary>
+        /// <param name="collidedwith"></param>
+        void ICollideBehavior.CollideWith(List<IEntity> collidedwith)
+        {
+            foreach(var entity in collidedwith)
+            {
+                if(entity.TryGetComponent(out DamageableComponent damage))
+                {
+                    damage.TakeDamage(DamageType.Brute, 10);
+                }
+            }
+
+            if (collidedwith.Count > 0)
+                Owner.Delete();
+        }
+    }
+}

Content.Server/GameObjects/Components/Weapon/Melee/MeleeWeaponComponent.cs

@@ -0,0 +1,52 @@
+using System;
+using SS14.Shared.GameObjects;
+using SS14.Shared.GameObjects.Serialization;
+using Content.Server.GameObjects.EntitySystems;
+using SS14.Shared.Interfaces.GameObjects;
+using SS14.Shared.Map;
+using SS14.Shared.IoC;
+using SS14.Server.GameObjects;
+using SS14.Shared.Maths;
+using SS14.Server.Interfaces.GameObjects;
+using SS14.Shared.Interfaces.Timing;
+using SS14.Shared.GameObjects.EntitySystemMessages;
+
+namespace Content.Server.GameObjects.Components.Weapon.Melee
+{
+    public class MeleeWeaponComponent : Component, IAfterAttack
+    {
+        public override string Name => "MeleeWeapon";
+
+        public int Damage = 1;
+        public float Range = 1;
+        public float ArcWidth = 90;
+
+        public override void ExposeData(EntitySerializer serializer)
+        {
+            base.ExposeData(serializer);
+
+            serializer.DataField(ref Damage, "damage", 5);
+            serializer.DataField(ref Range, "damage", 1);
+            serializer.DataField(ref ArcWidth, "damage", 90);
+
+        }
+
+        void IAfterAttack.Afterattack(IEntity user, LocalCoordinates clicklocation)
+        {
+            var location = user.GetComponent<TransformComponent>().LocalPosition;
+            var angle = new Angle(clicklocation.ToWorld().Position - location.ToWorld().Position);
+            var entities = IoCManager.Resolve<IServerEntityManager>().GetEntitiesInArc(user.GetComponent<TransformComponent>().LocalPosition, Range, angle, ArcWidth);
+
+            foreach(var entity in entities)
+            {
+                if (!entity.GetComponent<TransformComponent>().IsMapTransform || entity == user)
+                    continue;
+                
+                if(entity.TryGetComponent(out DamageableComponent damagecomponent))
+                {
+                    damagecomponent.TakeDamage(DamageType.Brute, Damage);
+                }
+            }
+        }
+    }
+}

Content.Server/GameObjects/Components/Weapon/Ranged/Hitscan/HitscanWeaponComponent.cs

@@ -0,0 +1,61 @@
+using SS14.Server.GameObjects;
+using SS14.Server.GameObjects.EntitySystems;
+using SS14.Shared.GameObjects;
+using SS14.Shared.GameObjects.EntitySystemMessages;
+using SS14.Shared.Interfaces.GameObjects;
+using SS14.Shared.Interfaces.Physics;
+using SS14.Shared.Interfaces.Timing;
+using SS14.Shared.IoC;
+using SS14.Shared.Map;
+using SS14.Shared.Maths;
+using SS14.Shared.Physics;
+using System;
+
+namespace Content.Server.GameObjects.Components.Weapon.Ranged.Hitscan
+{
+    public class HitscanWeaponComponent : RangedWeaponComponent
+    {
+        public override string Name => "HitscanWeapon";
+
+        string spritename = "laser";
+        
+        protected override void Fire(IEntity user, LocalCoordinates clicklocation)
+        {
+            var userposition = user.GetComponent<TransformComponent>().WorldPosition; //Remember world positions are ephemeral and can only be used instantaneously
+            var angle = new Angle(clicklocation.Position - userposition);
+            var theta = angle.Theta;
+            
+            var ray = new Ray(userposition, angle.ToVec());
+            var raycastresults = IoCManager.Resolve<ICollisionManager>().IntersectRay(ray, 20, Owner.GetComponent<TransformComponent>().GetMapTransform().Owner);
+
+            Hit(raycastresults);
+            AfterEffects(user, raycastresults, theta);
+        }
+
+        protected virtual void Hit(RayCastResults ray)
+        {
+            if(ray.HitEntity != null && ray.HitEntity.TryGetComponent(out DamageableComponent damage))
+            {
+                damage.TakeDamage(DamageType.Heat, 10);
+            }
+        }
+        
+        protected virtual void AfterEffects(IEntity user, RayCastResults ray, double theta)
+        {
+            var time = IoCManager.Resolve<IGameTiming>().CurTime;
+            EffectSystemMessage message = new EffectSystemMessage
+            {
+                EffectSprite = spritename,
+                Born = time,
+                DeathTime = time + TimeSpan.FromSeconds(1),
+                Size = new Vector2(ray.Distance, 1f),
+                Coordinates = user.GetComponent<TransformComponent>().LocalPosition,
+                //Rotated from east facing
+                Rotation = (float)theta,
+                ColorDelta = new Vector4(0, 0, 0, -1500f),
+                Color = new Vector4(255,255,255,750)
+            };
+            IoCManager.Resolve<IEntitySystemManager>().GetEntitySystem<EffectSystem>().CreateParticle(message);
+        }
+    }
+}

Content.Server/GameObjects/Components/Weapon/Ranged/Projectile/ProjectileWeapon.cs

@@ -0,0 +1,40 @@
+using Content.Server.GameObjects.Components.Projectiles;
+using SS14.Server.GameObjects;
+using SS14.Server.Interfaces.GameObjects;
+using SS14.Shared.Interfaces.GameObjects;
+using SS14.Shared.IoC;
+using SS14.Shared.Map;
+using SS14.Shared.Maths;
+
+namespace Content.Server.GameObjects.Components.Weapon.Ranged.Projectile
+{
+    public class ProjectileWeaponComponent : RangedWeaponComponent
+    {
+        public override string Name => "ProjectileWeapon";
+
+        private string _ProjectilePrototype = "ProjectileBullet";
+
+        private float _velocity = 20f;
+
+        protected override void Fire(IEntity user, LocalCoordinates clicklocation)
+        {
+            var userposition = user.GetComponent<TransformComponent>().LocalPosition; //Remember world positions are ephemeral and can only be used instantaneously
+            var angle = new Angle(clicklocation.Position - userposition.Position);
+
+            var theta = angle.Theta;
+
+
+            //Spawn the projectileprototype
+            IEntity projectile = IoCManager.Resolve<IServerEntityManager>().ForceSpawnEntityAt(_ProjectilePrototype, userposition);
+
+            //Give it the velocity we fire from this weapon, and make sure it doesn't shoot our character
+            projectile.GetComponent<ProjectileComponent>().IgnoreEntity(user);
+
+            //Give it the velocity this weapon gives to things it fires from itself
+            projectile.GetComponent<PhysicsComponent>().LinearVelocity = angle.ToVec() * _velocity;
+
+            //Rotate the bullets sprite to the correct direction, from north facing I guess
+            projectile.GetComponent<TransformComponent>().LocalRotation = angle.Theta;
+        }
+    }
+}

Content.Server/GameObjects/Components/Weapon/Ranged/RangedWeapon.cs

@@ -0,0 +1,35 @@
+using SS14.Shared.GameObjects;
+using Content.Server.GameObjects.EntitySystems;
+using SS14.Shared.Interfaces.GameObjects;
+using SS14.Shared.Map;
+
+namespace Content.Server.GameObjects.Components.Weapon.Ranged
+{
+    public class RangedWeaponComponent : Component, IAfterAttack
+    {
+        public override string Name => "RangedWeapon";
+
+        void IAfterAttack.Afterattack(IEntity user, LocalCoordinates clicklocation)
+        {
+            if(UserCanFire(user) && WeaponCanFire())
+            {
+                Fire(user, clicklocation);
+            }
+        }
+
+        protected virtual bool WeaponCanFire()
+        {
+            return true;
+        }
+
+        protected virtual bool UserCanFire(IEntity user)
+        {
+            return true;
+        }
+
+        protected virtual void Fire(IEntity user, LocalCoordinates clicklocation)
+        {
+            return;
+        }
+    }
+}