Example #1
0
 public Projectile(long id, double mass, double x, double y, double speedX, double speedY, double angle,
         double angularSpeed, double radius, long carId, long playerId, ProjectileType type)
         : base(id, mass, x, y, speedX, speedY, angle, angularSpeed, radius) {
     this.carId = carId;
     this.playerId = playerId;
     this.type = type;
 }
    public Projectile NewProjectile(ProjectileType pType)
    {
        Projectile newProjectile = null;

        switch(pType)
        {
            case ProjectileType.BlasterBolt:
                newProjectile = Instantiate(blasterBoltPrefab) as Projectile;
                break;
            case ProjectileType.RedBlasterBolt:
                newProjectile = Instantiate(redBlasterBoltPrefab) as Projectile;
                break;
            case ProjectileType.PurpleBlasterBolt:
                newProjectile = Instantiate(purpleBlasterBoltPrefab) as Projectile;
                break;
        }

        if (newProjectile)
        {
            newProjectile.transform.parent = transform;
            newProjectile.gameObject.SetActive(false);
            _projectiles[pType].Add(newProjectile);
        }

        return newProjectile;
    }
Example #3
0
 public void RefreshWeaponBox(ProjectileType type, int count, bool startReload = false, float duration = 0)
 {
     weaponBoxes[type].UpdateCount(count);
     if (startReload) {
         weaponBoxes[type].StartReload(duration);
     }
 }
 public static void Add(NetworkMessage message, Location fromLocation, Location toLocation, ProjectileType projectile)
 {
     message.AddByte((byte)ServerPacketType.Projectile);
     message.AddLocation(fromLocation);
     message.AddLocation(toLocation);
     message.AddByte((byte)projectile);
 }
Example #5
0
 void getStatsForType(ProjectileType type_)
 {
     switch (type_)
     {
         case ProjectileType.NORMAL_BULLET:
             damage = 2;
             speed = 200;
             break;
         case ProjectileType.NORMAL_BULLET_UPGRADE:
             damage = 3;
             speed = 200;
             break;
         case ProjectileType.DOUBLE_BULLET:
             damage = 3;
             speed = 200;
             break;
         case ProjectileType.NORMAL_MISSLE:
             damage = 4;
             speed = 150;
             break;
         case ProjectileType.DOUBLE_MISSLE:
             damage = 5;
             speed = 150;
             break;
     }
 }
    public void FireProjectile(Transform tar, float time, ProjectileType type, bool isHoming)
    {
        transform.localScale = new Vector3 (15, 15, 15);
        GameObject particle;
        particle = Instantiate (Resources.Load ("FireParticle") as GameObject, transform.position, transform.rotation) as GameObject;

        //Saved values i
        GameObject cloneTarget;
        cloneTarget = new GameObject ();
        cloneTarget.transform.position = tar.position;
        if (!isHoming)
            tar = cloneTarget.transform;
        orgin = transform.position;
        targetPositionAtFire = transform.position;
        target = tar;
        transitTime = time + 1;
        Destroy (particle, time);
        distanceCovered = 0;
        transform.LookAt(tar);
        //Calulate control point based on information given
        controlPoint = Vector3.Lerp(orgin, target.position, 0.5f);
        controlPoint += Vector3.up * (Vector3.Distance(orgin, tar.position) / 2);
        //Start the Event
        StartCoroutine (StartEvent (type));
        deathTimer = transitTime;
    }
Example #7
0
        public Projectile(Vector2 Location, Vector2 Direction, float Speed, Texture2D Texture, int Damage, Boolean IsPlayer, Vector2 Target, 
                            ProjectileType ProjectileType = ProjectileType.Cannon, float RateOfTurn = 0f, float FlightTime = 3f, int Health = 10)
        {
            v2Location = Location;
            v2Target = Target;
            Direction.Normalize();
            v2Direction = Direction;
            fSpeed = Speed;
            fRateOfTurn = RateOfTurn;

            ptType = ProjectileType;

            t2dTexture = Texture;
            rectHitBox.Width = Texture.Width;
            rectHitBox.Height = Texture.Height;

            if (ProjectileType == ProjectileType.Cannon)
                fFlightTime = FlightTime * 3f;
            else
                fFlightTime = FlightTime;

            iDamage = Damage;
            iHealth = Health;
            bActive = true;
            bPlayer = IsPlayer;

            CurrentAngle = (float)Math.Atan2((double)v2Direction.Y, (double)v2Direction.X);

            SetHitbox();
        }
Example #8
0
        public bool CheckHit(Vector2 pos, Vector2 speed, ProjectileType type, bool grenade)
        {
            //if (!Active) return false;
            if (HP <= 0) return false;

            bool isHit = false;

            if ((pos - CenterPosition).Length() <= (type!= ProjectileType.Grenade?(15 * scale):(20*scale)))
            {

                isHit = true;

                HP -= (!grenade?0.2f:0.1f);
                GameManager.ParticleController.AddMetalDebris(pos, speed*0.2f);
                if(!grenade)
                    AudioController.PlaySFX("metalhit" + (randomNumber.Next(4) +1), 0.5f, 0f, 0.3f, Position);
                if(randomNumber.Next(20)==1)
                    AudioController.PlaySFX("ricochet", 0.4f, 0f, 0.3f, Position);

                if (HP <= 0) Die();

            }

            return isHit;
        }
 public static bool Defeats(ProjectileType type1, ProjectileType type2)
 {
     return type2 == ProjectileType.Fragile ||
         type1 == ProjectileType.Fire && type2 == ProjectileType.Ice ||
         type1 == ProjectileType.Ice && type2 == ProjectileType.Water ||
         type1 == ProjectileType.Water && type2 == ProjectileType.Fire ||
         type1 == ProjectileType.Fire && type2 == ProjectileType.Tree;
 }
Example #10
0
 public AProjectile(Projectile proj)
 {
     Type = proj.Type;
     X = proj.X;
     Y = proj.Y;
     Speed = new Point(proj.SpeedX, proj.SpeedY);
     Radius = proj.Radius;
 }
Example #11
0
 public static bool Send(Objects.Client client, Objects.Location fromLocation, Objects.Location toLocation, ProjectileType effect)
 {
     ProjectilePacket p = new ProjectilePacket(client);
     p.FromPosition = fromLocation;
     p.ToPosition = toLocation;
     p.Effect = effect;
     return p.Send();
 }
Example #12
0
 public override void CreateProjectile(ProjectileType type, Vector2 startPosition, Vector2 startVelocity)
 {
     switch (type)
     {
         case ProjectileType.Bullet:
             projectiles.Add(new Bullet(this.content, startPosition, startVelocity));
             return;
         default: return;
     }
 }
Example #13
0
 /// <summary>
 ///  Constructs a projectile with the given y velocity
 /// </summary>
 /// <param name="type">the projectile type</param>
 /// <param name="sprite">the sprite for the projectile</param>
 /// <param name="x">the x location of the center of the projectile</param>
 /// <param name="y">the y location of the center of the projectile</param>
 /// <param name="yVelocity">the y velocity for the projectile</param>
 public Projectile(ProjectileType type, Texture2D sprite, int x, int y, 
     float yVelocity)
 {
     this.type = type;
     this.sprite = sprite;
     this.yVelocity = yVelocity;
     drawRectangle = new Rectangle(x - sprite.Width / 2,
         y - sprite.Height / 2, sprite.Width,
         sprite.Height);
 }
Example #14
0
 public CannonBase(Rang rang, float damage, float attackSpeed,
                   ProjectileType projectileType, float projectileSpeed,
                   CannonBaseType cannonBaseType)
 {
     Rang            = rang;
     Damage          = damage;
     AttackSpeed     = attackSpeed;
     ProjectileType  = projectileType;
     ProjectileSpeed = projectileSpeed;
     CannonBaseType  = cannonBaseType;
 }
Example #15
0
 public Projectile(ProjectileType type_, Texture2D texture, Vector2 pos, Vector2 direct, float ang)
 {
     type = type_;
     sprite = texture;
     position = pos;
     getStatsForType(type);
     direct.Normalize();
     velocity = direct * speed * -1;
     angle = ang;
     base.Initialize();
 }
Example #16
0
    public void UpdateBufferData(int index, ProjectileType projectileType, ProjectileData data)
    {
        if (projectileType.Index != LastAccessedProjectileTypeIndex)
        {
            LastAccessedProjectileTypeIndex = projectileType.Index;
            LastAccessedRenderer            = IndirectRenderers[LastAccessedProjectileTypeIndex];
        }

        LastAccessedRenderer.UpdateBufferData(projectileType.BufferIndex, data);
        projectileType.BufferIndex++;
    }
 public void popAmmo()
 {
     if (ammoCount > 0)
     {
         ammoCount--;
     }
     else
     {
         currentType = ProjectileType.None;
     }
 }
Example #18
0
 public void Add(Vector2 loc, Vector2 speed, double life, bool ownerhero, ProjectileType type)
 {
     foreach (Projectile p in Projectiles)
     {
         if (!p.Active)
         {
             p.Spawn(loc, speed, life, ownerhero, type);
             break;
         }
     }
 }
Example #19
0
    public BaseProjectile CreateProjectile(ProjectileType type, bool _isEnemy, int _damage, Vector3 _startPos, BaseObject _attacker, Vector3 _endPos, BaseObject _target)
    {
        BaseProjectile projectile = PrefabsManager.SpawnProjectile(type);

        projectile.Init(type, _isEnemy, _damage);
        projectile.InitPosition(_startPos, _endPos);
        projectile.InitObjects(_attacker, _target);

        projectileList.Add(projectile);
        return(projectile);
    }
        public Projectile(Texture2D texture, Vector2 position, int width, Color color, float rotation, 
            float scale, float drawLayer, int frames, ProjectileType type, Vector2 direction, float speed, ProjectileOwner owner)
            : base(texture, position, width, color, rotation, scale, drawLayer, frames)
        {
            this.Type = type;
            this.Owner = owner;
            this.Direction = direction;
            this.Speed = speed;

            this.IsActive = true;
        }
Example #21
0
        public override void CreateProjectile(ProjectileType type, Vector2 startPosition, Vector2 startVelocity)
        {
            switch (type)
            {
            case ProjectileType.Bullet:
                projectiles.Add(new Bullet(this.content, startPosition, startVelocity));
                return;

            default: return;
            }
        }
    public ProjectileParameters(ProjectileType _type, float _fuse, float _speed, float _detonateForce, float _radius, int _damage)
    {
        type            = _type;
        fuse            = _fuse;
        speed           = _speed;
        detonationForce = _detonateForce;
        radius          = _radius;
        damage          = _damage;

        ImportProjectileDefaults();
    }
Example #23
0
        public Projectile(TextureHandler t, HumptyDumpty humptyDumpty)
        {
            setDestination(humptyDumpty.Position);
            hitbox = new Rectangle((int)position.X, (int)position.Y, 10, 10);
            trajectory = new Rectangle((int)position.X, (int)position.Y, 2, 100);
            this.humptyDumpty = humptyDumpty;

            Random r = new Random();
            projectileType = (ProjectileType)r.Next(7);
            texture = t.getProjectile(projectileType);
        }
        protected Projectile()
        {
            mMuzzleSpeed = 5.0f;
            mVelocity    = Vector3.zero;
            mPlayerId    = 0;
            SetScale(GetScale() * 0.25f);
            SetCollisionRadius(0.125f);

            mCreateTime    = Timing.sInstance.GetFrameStartTime();
            projectileType = ProjectileType.SphericalLinear;
        }
    public void Start()
    {
        Camera = Camera.main;

        Interval = INTERVAL;

        // If projectile type is not set, use default
        if (ProjectileType == null)
        {
            ProjectileType = ProjectileManager.Instance.GetProjectileType(0);
        }
    }
Example #26
0
 public void Set(bool alive, byte health, byte movementSpeed, ProjectileType weapontype,
                 Point posCenter, Point target, byte spawning = spawnTime)
 {
     this.alive         = (byte)(alive ? 2 : 0);
     Health             = health;
     this.movementSpeed = movementSpeed;
     Position.Offset(posCenter - Position.Center);
     this.target   = target;
     reattackTime  = GetMaxCooldown();
     WeaponType    = weapontype;
     this.spawning = spawning;
 }
Example #27
0
        public Projectile(TextureHandler t, HumptyDumpty humptyDumpty)
        {
            setDestination(humptyDumpty.Position);
            hitbox            = new Rectangle((int)position.X, (int)position.Y, 10, 10);
            trajectory        = new Rectangle((int)position.X, (int)position.Y, 2, 100);
            this.humptyDumpty = humptyDumpty;

            Random r = new Random();

            projectileType = (ProjectileType)r.Next(7);
            texture        = t.getProjectile(projectileType);
        }
Example #28
0
    private int GetTypeIndex(ProjectileType type)
    {
        for (int i = 0; i < typeCount; i++)
        {
            if (type == types[i])
            {
                return(i);
            }
        }

        return(-1);
    }
Example #29
0
 public void RemoveProjectile(ProjectileType proj)
 {
     for (int i = 0; i < ProjectileInventory.Count; i++)
     {
         if (ProjectileInventory[i] == proj)
         {
             ProjectileInventory.RemoveAt(i);
             // Make sure we only remove one projectile
             return;
         }
     }
 }
 public void addAmmo(ProjectileType type)
 {
     if (type == currentType)
     {
         ammoCount++;
     }
     else
     {
         currentType = type;
         ammoCount   = 1;
     }
 }
Example #31
0
 public Weapon(int id, string title, string slug, int burstCount, ProjectileType typeOfProjectile, int rateOfFire,
               int inaccuracy)
 {
     ID               = id;
     Title            = title;
     Slug             = slug;
     Sprite           = new ContentRef <Texture>(null, @"Data\Sprites & Spritesheets\Weapons\" + slug + @".Texture.res");
     BurstCount       = burstCount;
     TypeOfProjectile = typeOfProjectile;
     RateOfFire       = rateOfFire;
     Inaccuracy       = inaccuracy;
 }
Example #32
0
        public void SendProjectile(Location from, Location to, ProjectileType projectile)
        {
            NetworkMessage outMessage = new NetworkMessage();

            ProjectilePacket.Add(
                outMessage,
                from,
                to,
                projectile
                );
            Send(outMessage);
        }
    public Projectile CreateProjectile(ProjectileType pType, Vector3 pos, Vector3 target, Quaternion rot, float speed)
    {
        Projectile projectile = CreateObject(pType, pos, rot, ProjectileManager.Instance.projParent);

        projectile.Initialize();
        ProjectileManager.Instance.managingSet.Add(projectile);
        projectile.projType = pType;
        projectile.speed    = speed;
        projectile.target   = target;

        return(projectile);
    }
Example #34
0
        public void Spawn(Vector2 pos, Vector2 speed, double life, bool heroowner, ProjectileType type)
        {
            Active = true;
            Position = pos;
            Speed = speed;
            Life = life;
            OwnedByHero = heroowner;
            Type = type;

            alpha = 1f;
            rot = Helper.V2ToAngle(Speed);
        }
Example #35
0
 /// <summary>
 /// Gets the projectile sprite for the given projectile type
 /// </summary>
 /// <param name="type">the projectile type</param>
 /// <returns>the projectile sprite for the type</returns>
 public static Texture2D GetProjectileSprite(ProjectileType type)
 {
     // replace with code to return correct projectile sprite based on projectile type
     if (type == ProjectileType.FrenchFries)
     {
         return(frenchFriesSprite);
     }
     else
     {
         return(teddyBearProjectileSprite);
     }
 }
Example #36
0
 public override void OnItemLoaded(Item item)
 {
     base.OnItemLoaded(item);
     selectedType = (ProjectileType)weaponTypeEnums.GetValue(projectileType);
     if (selectedType.Equals(ProjectileType.Pierce))
     {
         item.gameObject.AddComponent <ItemSimpleProjectile>();
     }
     // TODO: Add additional projectile types in future versions
     //else if (selectedType.Equals(ProjectileType.Explosive)) item.gameObject.AddComponent<Weapons.SimpleExplosive>();
     //else if (selectedType.Equals(ProjectileType.Energy)) item.gameObject.AddComponent<Weapons.PlasmaBolt>();
 }
Example #37
0
 public Player(Window window)
 {
     _Bitmap          = new Bitmap("player", "IsopodPlayer.png");
     _HealthBarBitmap = new Bitmap("healthBar", "healthBarEmpty.png");
     _HealthBitmap    = new Bitmap("health", "healthVial.png");
     X          = (window.Width - Width) / 2;
     Y          = (window.Height - Height) / 2;
     _Health    = 100;
     _AliveTime = new Timer("Alive Time");
     _AliveTime.Start();
     _ProjectileType = ProjectileType.bullet;
 }
Example #38
0
    public void Init(float _damage, float _speed, float _travelDist, Vector2 _direction, ProjectileType _projectileType = ProjectileType.Normal, AttackType _attackType = AttackType.Basic)
    {
        m_initialized = true;
        m_damage      = _damage;
        m_speed       = _speed;
        m_travelDist  = _travelDist;
        m_direction   = _direction;
        m_startPos    = transform.position;

        m_projectileType = _projectileType;
        m_attackType     = _attackType;
    }
Example #39
0
        /// <summary>
        /// Gets the projectile sprite for the given projectile type
        /// </summary>
        /// <param name="type">the projectile type</param>
        /// <returns>the projectile sprite for the type</returns>
        public static Texture2D GetProjectileSprite(ProjectileType type)
        {
            // replace with code to return correct projectile sprite based on projectile type
            switch (type)
            {
            case ProjectileType.FrenchFries:
                return(frenchFriesSprite);

            case ProjectileType.TeddyBear:
                return(teddyBearProjectileSprite);
            }
            return(null);
        }
Example #40
0
 public ProjectileFactory CreateFactory(ProjectileType type, int instability)
 {
     foreach (ProjectileFactory fact in factories)
     {
         if (fact.type == type)
         {
             ProjectileFactory copy = fact.Copy();
             copy.instability = instability;
             return(copy);
         }
     }
     return(null);
 }
Example #41
0
 public Projectile(ProjectileType type, int position, int bottom, Directions direction, int speed, int damage, ConsoleColor color, Background background)
 {
     Type            = type;
     Speed           = speed;
     Damage          = damage;
     Position        = position;
     Bottom          = bottom;
     Direction       = direction;
     frames          = 0;
     this.background = background;
     distance        = type == ProjectileType.PELLET ? 12 : 100;
     TextColor       = color;
 }
Example #42
0
    IEnumerator agasFireball(GameObject target, ProjectileType pt = ProjectileType.Linear,
                             ProjectileSpeed ps = ProjectileSpeed.Fast, float degreeModifier = 3f)
    {
        attacking = true;

        GameObject temp = Instantiate(ghostball, agas.transform.position, Quaternion.identity);

        yield return(null);

        temp.GetComponent <Projectile>().Configure(target, pt, ps, degreeModifier);

        attacking = false;
    }
Example #43
0
 /// <summary>
 ///
 /// </summary>
 /// <param name="level">Current level.</param>
 /// <param name="projectileType">Type of the projectile to shoot.</param>
 /// <param name="sourceOffset">Offset of the source of projectiles from the Entity Node.</param>
 /// <param name="rateOfFire">Number of projectiles to shoot per minute.</param>
 protected Shooter(ILevelManager level,
                   ProjectileType projectileType,
                   Vector3 sourceOffset,
                   float rateOfFire)
     : base(level)
 {
     this.projectileType = projectileType;
     this.SourceOffset   = sourceOffset;
     this.RateOfFire     = rateOfFire;
     this.shotDelay      = 60 / RateOfFire;
     this.searchDelay    = 0;
     ReceiveSceneUpdates = true;
 }
Example #44
0
 // Use this for initialization
 void Start()
 {
     audioSource          = GetComponent <AudioSource> ();
     rb                   = GetComponent <Rigidbody2D> ();
     spriteRenderer       = GetComponent <SpriteRenderer> ();
     CurrentProjectile    = ProjectileType.Std;
     state                = TankState.alive;
     alphaLevel           = 1.0f;
     tFire                = 0.0f;
     angle                = Mathf.Deg2Rad * transform.rotation.eulerAngles.z;
     spriteRenderer.color = new Color(colour.r, colour.g, colour.b, alphaLevel);
     SetFireDelay();
 }
Example #45
0
 protected FireProjectileAction(
     string actorId,
     ProjectileType projectileType,
     int power,
     Func <EncounterPosition, EncounterPath> pathFunction,
     int speed
     ) : base(actorId, ActionType.FIRE_PROJECTILE)
 {
     this.ProjectileType = projectileType;
     this.Power          = power;
     this.PathFunction   = pathFunction;
     this.Speed          = speed;
 }
Example #46
0
 public virtual void Shoot(Vector2 shotVel, Vector2 shotPos, Vector2 shotDir, ProjectileType type)
 {
     if (type == ProjectileType.VOLCANO)
     {
         VolcanoProjectile shot = new VolcanoProjectile(m_world, shotPos, m_ProjectileSpriteSize, m_ProjectileSprite, shotVel, shotDir, MovableType.Projectile, type, this);
         this.m_world.Add(shot);
     }
     else
     {
         Projectile shot = new Projectile(m_world, shotPos, m_ProjectileSpriteSize, m_ProjectileSprite, shotVel, shotDir, MovableType.Projectile, type, this);
         this.m_world.Add(shot);
     }
 }
 public void PlaybackGammaHit()
 {
     isNewBeta = true;
     Destroy(graphic.gameObject);
     ptype          = ProjectileType.E;
     graphic        = (Instantiate(particlePrefabsSmall[(int)ptype], transform.position, transform.rotation) as GameObject).transform;
     graphic.parent = transform;
     theSpeed       = speeds[(int)ptype] * 0.9f;
     curEnergy      = energies[(int)ptype];
     energyLossPerDensityPerUnit = energyLosses[(int)ptype] * (SelectZoomLevelGUI.selectedButton == 2?macroGammaBetaFudge : 1);
     originalEnergy     = curEnergy;
     transform.rotation = Quaternion.LookRotation(MacroModeGUI.bounceDir);
 }
 public void AddAmmoType(string name, ProjectileType type)
 {
     if (freeAmmoID.Count > 0)
     {
         ammoDatabase.Add(new Ammo(freeAmmoID.Dequeue(), name, type));
     }
     else
     {
         ammoDatabase.Add(new Ammo(maxID, name, type));
         maxID++;
     }
     EditorUtility.SetDirty(this);
 }
Example #49
0
 public Projectile(GameWorld pGameWorld, uint pTeam, ProjectileType pType, float pXPos, float pYPos, float pRotation, ProjectileKit pProjKit, Ship pTarget = null, Ship pOwner = null)
 {
     mXPos = pXPos;
     mYPos = pYPos;
     mType = pType;
     aaGameWorld = pGameWorld;
     mTeam = pTeam;
     SetProjType();
     mRotation = pRotation;
     mProjKit = pProjKit;
     mTarget = pTarget;
     mOwner = pOwner;
     mDispObject = new DisplayObject(aaGameWorld.aaDisplay, mAssetKit.ASSET_NAME, mXPos, mYPos, (int)mAssetKit.ORIGIN.X, (int)mAssetKit.ORIGIN.Y, Constants.LAYER_PROJECTILE_DEPTH, mAssetKit.SRC_RECTX, mAssetKit.SRC_RECTY, mAssetKit.SRC_RECTWIDTH, mAssetKit.SRC_RECTHEIGHT, mRotation, false);
 }
Example #50
0
 public Projectile(Projectile p)
 {
     position = new Vertex(p.position);
     type = p.type;
     lifeTime = p.lifeTime;
     exploded = p.exploded;
     playerProjectile = p.playerProjectile;
     if(p.srcMonster != null)
         srcMonsterId = p.srcMonster.id;
     missileTarget = p.missileTarget;
     stopped = p.stopped;
     exploding = p.exploding;
     explodeTime = p.explodeTime;
     laserDepth = p.laserDepth;
 }
Example #51
0
 void Start()
 {
     player = GameObject.FindGameObjectWithTag("Player").GetComponent<Controller2D>();
     sprite = GetComponent<SpriteRenderer>();
     animationController = GetComponent<Animator>();
     projectileCollider = GetComponent<Collider2D>();
     initalXOffset = projectileCollider.offset.x;
     initalYOffset = projectileCollider.offset.y;
     hit = false;
     decaying = false;
     projectileType = (GameControl.gameControl.playerClass == 3) ? ProjectileType.Arrow : ProjectileType.MagicMissle;
     weaponType = (GameControl.gameControl.playerClass == 3) ? "Bow" : "Staff";
     projectileNumber = EquipmentDatabase.equipmentDatabase.equipment[GameControl.gameControl.profile1Weapon].equipmentTier;
     UpdateDirection();
 }
Example #52
0
 public void Spawn(float d, ProjectileType t, Vector2 v, Controller.Owner o, float m, bool hacked)
 {
     StopAllCoroutines();
     if (hacked)
         StartCoroutine(enableCollisions());
     despawnTimer = 0;
     rigid = GetComponent<Rigidbody2D>();
     damage = d;
     projectileType = t;
     setDamage();
     owner = o;
     rigid.velocity = v;
     setLayer();
     procChance = m;
 }
Example #53
0
        public void Spawn(Vector2 pos, float landingheight, Vector2 speed, double life, bool heroowner, ProjectileType type, float pow, Color tint)
        {
            Active = true;
            Position = pos;
            Speed = speed;
            Life = life;
            OwnedByHero = heroowner;
            Type = type;
            Power = pow;
            Tint = tint;
            landingHeight = landingheight;

            alpha = 1f;
            rot = Helper.V2ToAngle(Speed);
        }
Example #54
0
        /// <summary>
        /// Creates a new projectile for the level based on its type.  It's position is updated and then added to the list of projectiles in the game.
        /// </summary>
        /// <param name="type"></param>
        /// <param name="position"></param>
        /// <returns></returns>
        public void CreateProjectile(ProjectileType type, Vector2 spawnPosition, Game game, ProjectileAlignment alignment)
        {
            Projectile newProjectile = null;
            switch (type)
            {
                case ProjectileType.BasicLaser:
                    newProjectile = new BasicLaser(game, alignment);
                    break;
                case ProjectileType.ChargedLaser:
                    newProjectile = new ChargedLaser(game, alignment);
                    break;
            }
            newProjectile.Position = spawnPosition;

            ProjectileList.Add(newProjectile);
        }
        public ProjectileController(IGameObject owner, Vector2 position, Vector2 velocity, ProjectileType type, int damage, String texturePath)
        {
            Rectangle bounds = new Rectangle((int)position.X - 1, (int)position.Y - 1, 3, 3);
            m_collider = new Collider(this, bounds, ColliderType.Projectile);

            Owner = owner;
            Velocity = velocity;
            Damage = damage;
            Tint = Color.White;
            Freezes = false;

            m_position = position;
            m_type = type;

            m_texture = new GameTexture(texturePath);
        }
Example #56
0
    public void Init(Vector2 goalPos, ProjectileType type, float speed)
    {
        this.goalPos = goalPos;
        this.type = type;

        GetComponent<SpriteRenderer>().sprite = SpriteLibrary.I.GetProjectileSprite(type);

        //Set velocity
        Vector2 dir = (goalPos - (Vector2)transform.position).normalized;
        Vector2 vel = dir * speed;
        rb.AddForce(vel, ForceMode2D.Impulse);

        //Set rotation

        transform.rotation = Tools.DirectionToQuaternion(dir);
    }
Example #57
0
        public override bool ParseMessage(NetworkMessage msg, PacketDestination destination)
        {
            int position = msg.Position;

            if (msg.GetByte() != (byte)IncomingPacketType.Projectile)
                return false;

            Destination = destination;
            Type = IncomingPacketType.Projectile;

            FromPosition = msg.GetLocation();
            ToPosition = msg.GetLocation();
            Effect = (ProjectileType)msg.GetByte();

            return true;
        }
Example #58
0
 public static Projectile Create(ProjectileType type)
 {
     var result = new Projectile();
     switch (type)
     {
         case ProjectileType.Torpedo:
             break;
         case ProjectileType.Skattershot:
             break;
         case ProjectileType.Hardshell:
             break;
         case ProjectileType.Nuke:
             break;
         case ProjectileType.Knockshot:
             break;
     }
     return result;
 }
Example #59
0
        //-----------------------------------------------------------------------------
        // Constructors
        //-----------------------------------------------------------------------------
        public Projectile()
        {
            EnablePhysics(PhysicsFlags.Flying);

            syncAnimationWithAngle		= false;
            syncAnimationWithDirection	= false;

            owner			= null;
            eventCollision	= null;
            eventLand		= null;
            angle			= 0;
            direction		= 0;

            crashAnimation	= null;
            bounceOnCrash	= false;

            projectileType = ProjectileType.Physical;
        }
    IEnumerator StartEvent(ProjectileType type)
    {
        //While traveling towards the target
        while (Vector3.Distance(transform.position, target.position) >= .25f)
        {
            //If its a missle type
            if (type == ProjectileType.Missle)
            {
                distanceCovered += Time.deltaTime;
                float fracJour = distanceCovered / transitTime;
                transform.position = Vector3.Lerp(orgin, target.position, fracJour);
                yield return null;
            }
            //If its a bomb type
            else if (type == ProjectileType.Bomb)
            {
                distanceCovered += Time.deltaTime;
                float fracJour = distanceCovered / transitTime;
                transform.position = BezierVec3(orgin, controlPoint, target.position, fracJour);
                yield return null;
            }
            //Or if its not yet programmed, destory the object
            else
            {
                print("Projectile type has not algorithm.");
                Destroy(this.gameObject);
            }

            deathTimer -= Time.deltaTime;
            if (deathTimer <= 0)
            {
                print("Projectile has lived too long.");
                Destroy(this.gameObject);
            }

            if(Vector3.Dot(transform.forward, target.position - transform.position) < 0)
            {
                print("Projectile passed its target");
                Destroy(this.gameObject);
            }
        }
        ResolveProjectile();
    }