public void Equals_EqualVec3Objects_True()
        {
            Vec3 v1 = new Vec3(1, 2, 3);
            Vec3 v2 = new Vec3(1, 2, 3);

            Assert.IsTrue(v1.Equals(v2));
        }

        protected override void OnFire(Vec3 firePos)
        {
            var muzzleFlash = ParticleEffect.Get("weapon_fx.tank.tank125.muzzle_flash.muzzle_flash");
            muzzleFlash.Spawn(firePos, Attachment.Rotation.Column1, 0.5f);

            Owner.Physics.AddImpulse(-Attachment.Rotation.Column1 * impulseStrength);
        }

        public void Launch(Vec3 velocity)
        {
            ReceiveUpdates = true;
            state = BoidState.Launched;

            Physics.AddImpulse(velocity);
            OnLaunched(velocity);
        }

        public void NetSpawn(EntityId targetId, Vec3 pos)
        {
            var tank = Entity.Get<Tank>(targetId);

            tank.Position = pos;

            tank.OnRevive();
        }

        public void Vec3()
        {
            Vec3 vec3 = UnusedMarker.Vec3;
            Assert.True(UnusedMarker.IsUnused(vec3));

            vec3 = new Vec3(0, 250, 3);
            Assert.False(UnusedMarker.IsUnused(vec3));
        }

        public override void OnRevive(EntityId actorId, Vec3 pos, Vec3 rot, int teamId)
        {
            var player = Actor.Get<Player>(actorId);

            if(player == null)
            {
                Debug.Log("[SinglePlayer.OnRevive] Failed to get the player. Check the log for errors.");
                return;
            }
        }

        protected override void OnCollision(EntityId targetEntityId, Vec3 hitPos, Vec3 dir, short materialId, Vec3 contactNormal)
        {
            if(Velocity.Length > VelocityToKill)
            {
                var particle = ParticleEffect.Get("explosions.barrel.explode");
                particle.Spawn(hitPos);

                Entity.Remove(Id);
            }
        }

 protected override void OnCollision(EntityId targetEntityId, Vec3 hitPos, Vec3 dir, short materialId, Vec3 contactNormal)
 {
     // Hit something, reset last event time.
     if(state == BoidState.Launched)
     {
         if(postFire == null)
             postFire = new DelayedFunc(OnStoppedMoving, 4000);
         else
             postFire.Reset();
     }
 }

        public override void OnRevive(EntityId actorId, Vec3 pos, Vec3 rot, int teamId)
        {
            var cameraProxy = Actor.Get(actorId) as PlayerCamera;
            if(cameraProxy == null)
            {
                Debug.Log("[SinglePlayer.OnRevive] Failed to get the player proxy. Check the log for errors.");
                return;
            }

            cameraProxy.Init();
        }

        protected override void OnCollision(EntityId targetEntityId, Vec3 hitPos, Vec3 dir, short materialId, Vec3 contactNormal)
        {
            if (!Destroyed && targetEntityId!=0)
            {
                var breakageParams = new BreakageParameters();
                breakageParams.type = BreakageType.Destroy;
                breakageParams.fParticleLifeTime = 7.0f;
                breakageParams.bMaterialEffects = true;
                breakageParams.nGenericCount = 0;
                breakageParams.bForceEntity = false;
                breakageParams.bOnlyHelperPieces = false;

                breakageParams.fExplodeImpulse = 10.0f;
                breakageParams.vHitImpulse = dir;
                breakageParams.vHitPoint = hitPos;

                Physics.Break(breakageParams);

                SetSlotFlags(GetSlotFlags() | EntitySlotFlags.Render);

                Destroyed = true;
            }
        }

 public void SetRotationAA(float c, float s, Vec3 axis, Vec3 t = default(Vec3))
 {
     this = new Matrix34(Matrix33.CreateRotationAA(c, s, axis));
     M03 = t.X; M13 = t.Y; M23 = t.Z;
 }

 /// <summary>
 /// Sent on entity collision.
 /// </summary>
 protected virtual void OnCollision(ColliderInfo source, ColliderInfo target, Vec3 hitPos, Vec3 contactNormal, float penetration, float radius)
 {
 }

 /// <summary>
 /// apply scaling to matrix.
 /// </summary>
 /// <returns></returns>
 void Scale(Vec3 s)
 {
     M00 *= s.X; M01 *= s.Y; M02 *= s.Z;
     M10 *= s.X; M11 *= s.Y; M12 *= s.Z;
     M20 *= s.X; M21 *= s.Y; M22 *= s.Z;
 }

 /// <summary>
 /// transforms a vector. the translation is not beeing considered
 /// </summary>
 /// <param name="p"></param>
 /// <returns></returns>
 public Vec3 TransformVector(Vec3 p)
 {
     return new Vec3(M00 * p.X + M01 * p.Y + M02 * p.Z + M03, M10 * p.X + M11 * p.Y + M12 * p.Z + M13, M20 * p.X + M21 * p.Y + M22 * p.Z + M23);
 }

 public QuatT(Vec3 t, Quat q)
 {
     Q = q;
     T = t;
 }

        public void SetRotationXYZ(Vec3 rad, Vec3? trans = null)
        {
            Q.SetRotationXYZ(rad);

            T = trans.GetValueOrDefault();
        }

 public void SetFromVectors(Vec3 vx, Vec3 vy, Vec3 vz, Vec3 pos)
 {
     var m34 = new Matrix34();
     m34.M00 = vx.X; m34.M01 = vy.X; m34.M02 = vz.X; m34.M03 = pos.X;
     m34.M10 = vx.Y; m34.M11 = vy.Y; m34.M12 = vz.Y; m34.M13 = pos.Y;
     m34.M20 = vx.Z; m34.M21 = vy.Z; m34.M22 = vz.Z; m34.M23 = pos.Z;
     this = new QuatT(m34);
 }

        public void Length_NormalizedVec3_True()
        {
            Vec3 v = new Vec3(1, 0, 0);

            Assert.IsTrue(v.Length == 1);
        }

 public void Normalize_Vec3_LengthIsEqualToOne()
 {
     Vec3 v = new Vec3(26, 23, 135);
     v.Normalize();
     Assert.IsTrue(v.Length == 1);
 }

        /*!
        * Create rotation-matrix about Z axis using an angle.
        * The angle is assumed to be in radians.
        * The translation-vector is set to zero.
        *
        *  Example:
        *        Matrix34 m34;
        *        m34.SetRotationZ(0.5f);
        */
        public void SetRotationZ(float rad, Vec3 t = default(Vec3))
        {
            this = new Matrix34(Matrix33.CreateRotationZ(rad));

            SetTranslation(t);
        }