Ejemplo n.º 1
0
        public MirrorPlayer(GameController game)
            : base(game)
        {
            this.game = game;

            // Model
            this.colorDefault = Constants.noColor;
            this.color = colorDefault;
            this.texturename = null;
            this.modelname = Constants.model_fish;
            getSizeRatioAndTransformation();
            this.type = GameObjectType.MirrorPlayer;

            // Stats
            hp = game.player.hp;
            mass = hp / size_ratio;
            maxAttackDelay = 0;
            maxHitDelay = 0;
            maxRotationSpeed = Constants.playerRotationSpeed;
            attackingAngle = Constants.attackingAngle;
            timeInBetweenShots = 100;

            this.pos = game.player.pos;
            this.movementSpeed = game.player.movementSpeed;
            this.acceleration = game.player.acceleration;
            this.accX = acceleration * ((float)Math.Cos(game.player.rotationAngle));
            this.accY = acceleration * ((float)Math.Sin(game.player.rotationAngle));
            this.pos_offset_x = ((float)game.random.NextDouble() * this.mass * 10 - this.mass*5);
            this.pos_offset_y = ((float)game.random.NextDouble() * this.mass * 10 - this.mass * 5);
            this.pos.X = game.player.pos.X + pos_offset_x;
            this.pos.Y = game.player.pos.Y + pos_offset_y;
            this.damage = game.player.damage/2;

            // Gamelogic
            isCollidable = false;

            refreshModel(color);

            // Follow a target
            target = null;

            game.Add(this);
        }
Ejemplo n.º 2
0
        // Handle a collision with a specific object
        public void rebound(float timeDelta, GameObject obj)
        {
            if (!this.colossal)
            {
                float vtx = accX * timeDelta * Constants.bounciness;
                float vty = accY * timeDelta * Constants.bounciness;

                this.velX -= vtx * obj.mass / (this.mass + obj.mass) * Constants.elasticModulus;
                this.velY -= vty * obj.mass / (this.mass + obj.mass) * Constants.elasticModulus;
            }
        }
Ejemplo n.º 3
0
        // Check if a specific object is within attack region
        public bool isFacing(GameObject obj)
        {
            // Get the angle between the two objects
            float angle = Methods.getAngle(this.pos, obj.pos);
            float[] diff = new float[2];

            diff[0] = Methods.absDiff(angle, this.rotationAngle);
            diff[1] = Methods.absDiff(angle + (float)Math.PI * 2, this.rotationAngle);

            if (diff[0] < attackingAngle || diff[1] < attackingAngle)
            {
                return true;
            }
            else
            {
                return false;
            }
        }
Ejemplo n.º 4
0
        // Calculate the squared distance from a specific object
        public float getCollisionDistanceSquared(GameObject obj)
        {
            float this_weighted_radius = this.mass / 2f * this.size_ratio / Constants.size_ratio_cube;
            float obj_weighted_radius = obj.mass / 2f * obj.size_ratio / Constants.size_ratio_cube;

            float sumRadiusSquared = (this_weighted_radius + obj_weighted_radius) * (this_weighted_radius + obj_weighted_radius);
            float collisionDistance = Methods.lengthSquared3(this.pos, obj.pos) - sumRadiusSquared;

            return collisionDistance;
        }
Ejemplo n.º 5
0
        // Check collision with a specific object and update the collision state
        public void checkCollision(GameObject obj, float timeDelta)
        {
            float collisionDistance = getCollisionDistanceSquared(obj);
            //float mag = Math.Min(Methods.magnitudeSquared(velX * timeDelta, velY * timeDelta), Methods.magnitudeSquared(obj.velX * timeDelta, obj.velY * timeDelta));

            if (collisionDistance < 0)
            {
                collisionState = CollisionState.Overlapping;
            }
            //else if (collisionDistance < mag)
            //{
            //    collisionState = CollisionState.Touching;
            //}
            else
            {
                collisionState = CollisionState.None;
            }
        }
Ejemplo n.º 6
0
        // Attack a specific object, amount is the percentage damage dealt (1 = 100%)
        public void attack(GameObject obj, float amount)
        {
            if (this == game.player) game.scoreController.addToScore(Constants.score_attacks);

            //game.soundController.PlaySound("hit1.wav", 0.7);

            float addedHp;

            // Will need to recreate models since hp has changed
            modelNeedsRefresh = true;
            obj.modelNeedsRefresh = true;

            // Update attack delay and hit delay counters
            attackDelayCounter = maxAttackDelay;
            obj.hitDelayCounter = obj.maxHitDelay;

            if (obj.hp - (damage * amount) <= 0)       // Remove victim if its hp reaches 0
            {
                addedHp = obj.hp;           // Add victim's remaining hp to attacker
                obj.hp = 0;
                obj.kill();
            }
            else
            {
                addedHp = damage * amount;           // Otherwise add hp to attacker equal to attacker's damage
                obj.hp -= addedHp;           // Remove HP from victim
                obj.damage -= addedHp * Constants.added_damage_ratio;       // decrease victim's damage
            }

            // HP and Damage addition is not applicable for survival units or projectiles
            if (this.type != GameObjectType.EnemySurvival &&
                this.type != GameObjectType.ProjectilePlayer &&
                this.type != GameObjectType.ProjectileEnemy &&
                this.type != GameObjectType.FieldPlayer)
            {
                hp += addedHp * Constants.added_hp_ratio;                   // Update hp, survival units can't gain hp
                damage += addedHp * Constants.added_damage_ratio;           // Increase attack's damage
            }

            // Limit how low a unit's damage can go
            if (obj.damage < Constants.minimumDamage) obj.damage = Constants.minimumDamage;
        }
Ejemplo n.º 7
0
        public void applyVortex(GameObject target, float range)
        {
            accX = 0;
            accY = 0;

            if (target.isAlive)
            {
                float diffX = pos.X - target.pos.X;
                float diffY = pos.Y - target.pos.Y;

                if (diffX < range + target.mass && diffY < range + target.mass)
                {
                    if (diffX >= 0) accX = -Constants.vortexAccel;
                    else accX = Constants.vortexAccel;

                    if (diffY >= 0) accY = -Constants.vortexAccel;
                    else accY = Constants.vortexAccel;
                }
            }
        }
Ejemplo n.º 8
0
        public Projectile(GameObject obj, GameController game, float variance, Vector4 color, float damage, bool randomDirection, bool homing)
            : base(game)
        {
            this.pos = obj.pos;
            this.game = game;

            if (obj.type == GameObjectType.Player || obj.type == GameObjectType.MirrorPlayer)
            {
                this.type = GameObjectType.ProjectilePlayer;
            }
            else
            {
                this.type = GameObjectType.ProjectileEnemy;
            }

            // Model
            // projectile color - default blue, otherwise copies the shooter's color
            if (obj.colorDefault == Constants.noColor) this.colorDefault = Constants.blue;
            else this.colorDefault = obj.colorDefault;

            // Init values
            this.colorDefault = color;
            this.color = colorDefault;
            this.texturename = null;
            this.modelname = Constants.model_projectile;
            getSizeRatioAndTransformation();
            this.showLighting = false;

            // Stats
            hp = Constants.projectile_base_size + obj.hp/10;   // Here HP and MASS just determines size of the projectile
            mass = hp / size_ratio;
            this.damage = damage;
            this.maxRotationSpeed = Constants.projectileRotationSpeed;

            // Set base speed and accel
            this.movementSpeed = Constants.projectile_speed;
            this.acceleration = Constants.projectile_accel;

            // Initial accel and velocity is in the direction of the shooter
            this.accX = acceleration * ((float)Math.Cos(obj.rotationAngle));
            this.accY = acceleration * ((float)Math.Sin(obj.rotationAngle));
            this.velX = obj.velX;
            this.velY = obj.velY;

            // Random projectile direction if applicable
            if (randomDirection)
            {
                accX = accX + ((float)game.random.NextDouble() * variance * 2 - variance);
                accY = accY + ((float)game.random.NextDouble() * variance * 2 - variance);
            }

            this.pos.X += ((float)Math.Cos(obj.rotationAngle)) * obj.mass / 2f;
            this.pos.Y += ((float)Math.Sin(obj.rotationAngle)) * obj.mass / 2f;

            // Gamelogic
            isCollidable = false;
            isAffectedByVortex = false;
            this.homing = homing;

            if (homing) lifeTime = Constants.projectile_lifetime + 400;
            else lifeTime = Constants.projectile_lifetime;

            refreshModel(color);

            game.Add(this);
        }
Ejemplo n.º 9
0
        public void seekTarget()
        {
            accX = 0;
            accY = 0;

            float diffX = 10000;
            float diffY = 10000;

            if (target == null)
            {

                foreach (var obj in game.gameObjects)
                {
                    if (type == GameObjectType.ProjectilePlayer)
                    {
                        if (obj.type == GameObjectType.Enemy || obj.type == GameObjectType.Boss || obj.type == GameObjectType.EnemySurvival)
                        {
                            float x = pos.X - obj.pos.X;
                            float y = pos.Y - obj.pos.Y;

                            if (Math.Abs(diffX) > Math.Abs(x)) { diffX = x; target = obj; }
                            if (Math.Abs(diffY) > Math.Abs(y)) { diffY = y; target = obj; }
                        }
                    }
                    else
                    {
                        if (obj.type == GameObjectType.Player || obj.type == GameObjectType.MirrorPlayer)
                        {
                            float x = pos.X - obj.pos.X;
                            float y = pos.Y - obj.pos.Y;

                            if (Math.Abs(diffX) > Math.Abs(x)) { diffX = x; target = obj; }
                            if (Math.Abs(diffY) > Math.Abs(y)) { diffY = y; target = obj; }
                        }
                    }
                }
            }
            else
            {
                diffX = pos.X - target.pos.X;
                diffY = pos.Y - target.pos.Y;
            }

            if (diffX >= 0) accX = -acceleration;
            else accX = acceleration;

            if (diffY <= 0) accY = acceleration;
            else accY = -acceleration;
        }
Ejemplo n.º 10
0
        public void keepNearPlayer()
        {
            float diffX = pos.X - game.player.pos.X;
               float diffY = pos.Y - game.player.pos.Y;

               if (Math.Abs(diffX) > 5 && Math.Abs(diffY) > 5)
               {
                   target = game.player;
               }
               else
               {
                   if (target == game.player) target = null;
               }
        }
Ejemplo n.º 11
0
        public void moveTowardsEnemy()
        {
            accX = 0;
            accY = 0;

            float diffX = 10000;
            float diffY = 10000;

            if (target == null)
            {

                foreach (var obj in game.gameObjects)
                {
                    if (obj.type == GameObjectType.Enemy || obj.type == GameObjectType.Boss)
                    {
                        float x = pos.X - obj.pos.X;
                        float y = pos.Y - obj.pos.Y;

                        if (Math.Abs(diffX) > Math.Abs(x)) { diffX = x; target = obj; }
                        if (Math.Abs(diffY) > Math.Abs(y)) { diffY = y; target = obj; }
                    }
                }
            }
            else
            {
                diffX = pos.X - target.pos.X;
                diffY = pos.Y - target.pos.Y;
            }

                if (Math.Abs(diffX) < Constants.mirrorImageRange && Math.Abs(diffY) < Constants.mirrorImageRange)
                {
                    if (diffX >= 0) accX = -acceleration;
                    else accX = acceleration;

                    if (diffY <= 0) accY = acceleration;
                    else accY = -acceleration;
                }
        }