void basicFireTowardsMouse() { tutText.pushToMin(2); fireSound.Play(); Vector2 mousePos = Camera.main.ScreenToWorldPoint(Input.mousePosition); Vector2 velDirection = mousePos - new Vector2(playerTransform.position.x, playerTransform.position.y); velDirection.Normalize(); bulletInstance = Instantiate(bullet, playerTransform.position, playerTransform.rotation); switch (bulletPowerup) { case PowerupType.MASSIVE_BULLET: bulletInstance.transform.localScale *= 5; bulletInstance.GetComponent <Collider2D>().enabled = false; bulletPowerup = PowerupType.NONE; break; default: bulletPowerup = PowerupType.NONE; break; } bulletCam.SetActive(true); bulletCam.SendMessage("SetBullet", bulletInstance); bulletInstance.GetComponent <Rigidbody2D>().velocity = velDirection * bulletSpeed; }
void bigFireTowardsMouse(float intensity) { tutText.pushToMin(7); shotChargeSound.Stop(); fireSound.Play(); Vector2 mousePos = Camera.main.ScreenToWorldPoint(Input.mousePosition); Vector2 velDirection = mousePos - new Vector2(playerTransform.position.x, playerTransform.position.y); velDirection.Normalize(); bulletInstance = Instantiate(bullet, playerTransform.position, playerTransform.rotation); GameObject bulletHaloInstance = Instantiate(bulletHalo, playerTransform.position, playerTransform.rotation); bulletHaloInstance.transform.SetParent(bulletInstance.transform); bulletHaloInstance.transform.localScale *= 1 + 5 * intensity; bulletInstance.transform.position += new Vector3(0, 0, 1);//behind switch (bulletPowerup) { case PowerupType.MASSIVE_BULLET: bulletInstance.transform.localScale *= 5; bulletInstance.GetComponent <Collider2D>().enabled = false; bulletPowerup = PowerupType.NONE; break; default: bulletPowerup = PowerupType.NONE; break; } bulletCam.SetActive(true); bulletCam.SendMessage("SetBullet", bulletInstance); bulletInstance.GetComponent <CircleCollider2D>().enabled = false; bulletInstance.GetComponent <Rigidbody2D>().velocity = velDirection * bulletSpeed; bulletInstance.BroadcastMessage("SetDamage", intensity * 5); GetComponent <Rigidbody2D>().AddForce(intensity * (-velDirection) * recoilAmount); }
override protected Powerup createPowerup(float x, float y, PowerupType type) { RenderedPowerup rendered = new RenderedPowerup(this, x, y, type, resourceScript); powerups.Add(rendered as Powerup); return(rendered); }
public void SetPowerup(Powerup powerup) { this.powerup = powerup; GetComponent <Animator>().runtimeAnimatorController = powerup.animator; name = powerup.name; type = powerup.type; }
public Powerup(PowerupScript script) { Type = script.Type; Amount = script.Amount; Duration = script.Duration; Lifetime = script.Lifetime; }
void UpdateType(PowerupType powerup_type) { if (current) { Destroy(current.gameObject); } Transform prefab = null; switch (powerup_type) { case PowerupType.ExtraJump: prefab = powerupExtraJumpPrefab; break; case PowerupType.Gun: prefab = powerupGunPrefab; break; case PowerupType.Transparency: prefab = powerupTransparencyPrefab; break; } if (prefab != null) { current = (Instantiate(prefab, transform.position, transform.rotation) as Transform); } }
public static void Create(Vector3 pos, PowerupType type) { GameObject p; if (Player.Instance == null) { return; } type = Player.Instance.PickValidPowerup(type); if (type == PowerupType.FrontCannon) { p = new GameObject(GameRes.Data.Prefabs.Powerups.FrontCannon_Prefab); } else if (type == PowerupType.DiagonalCannon) { p = new GameObject(GameRes.Data.Prefabs.Powerups.DiagonalCannon_Prefab); } else if (type == PowerupType.SideCannon) { p = new GameObject(GameRes.Data.Prefabs.Powerups.SideCannon_Prefab); } else if (type == PowerupType.KillAll) { p = new GameObject(GameRes.Data.Prefabs.Powerups.KillAll_Prefab); } else { return; } p.Transform.Pos = pos; p.Transform.Vel = new Vector3(MathF.Rnd.NextVector2(1.0f)); Scene.Current.RegisterObj(p); }
/// <summary> /// A helper function that will remove the Blade powerup and restore defaults. /// </summary> void unApplyBlades() { this.PowerupType = this.PowerupType ^= PowerupType.Blades; this.velocity /= 2; bladesPowerupTimer = 0; //TO DO: make Player vulerable again, since not implemented yet. }
internal EquipmentBlockBase(BinaryReader binaryReader) : base(binaryReader) { this.powerupType = (PowerupType)binaryReader.ReadInt16(); this.grenadeType = (GrenadeType)binaryReader.ReadInt16(); this.powerupTimeSeconds = binaryReader.ReadSingle(); this.pickupSound = binaryReader.ReadTagReference(); }
public void SpawnPowerUp(PowerupType powerupType, Cell thisCell, float horizontalCell, float verticalCell) { switch (powerupType) { case PowerupType.Invulnerability: powerUpToCreate = m_InvulnerablePowerup; break; case PowerupType.Range: powerUpToCreate = m_RangePowerup; break; case PowerupType.Shake: powerUpToCreate = m_ShakePowerup; break; case PowerupType.Speed: powerUpToCreate = m_SpeedPowerup; break; case PowerupType.Trick: powerUpToCreate = m_TrickPowerup; break; } Debug.Log("SPAWNING POWERUP: " + powerupType + " CellX: " + horizontalCell + " Vertical Cell: " + verticalCell); // Spawn a powerup then destroy the game object Vector3 powerupPos = new Vector3(GetHorizontalPos(horizontalCell), GetVerticalPos(verticalCell), powerUpToCreate.transform.position.z); GameObject powerupInstance = Instantiate(powerUpToCreate, powerupPos, transform.rotation) as GameObject; thisCell.CellGameObject = powerupInstance; }
private void OnPowerupChanged(PowerupType newType, PowerupType oldType) { if (destroyPowerupButton.targetGraphic != null) { destroyPowerupButton.targetGraphic.color = newType == PowerupType.DestroyCell ? powerupButtonHighlightColor : powerupButtonNormalColor; } if (swapPowerupButton.targetGraphic != null) { swapPowerupButton.targetGraphic.color = newType == PowerupType.SwapCells ? powerupButtonHighlightColor : powerupButtonNormalColor; } if (scramblePowerupButton.targetGraphic != null) { scramblePowerupButton.targetGraphic.color = newType == PowerupType.Scramble ? powerupButtonHighlightColor : powerupButtonNormalColor; } }
public GameObject GenerateAsteroid(AsteroidType type) { GameObject result = null; if (type == AsteroidType.Small) { PowerupType p = Player.Instance != null?Player.Instance.PickValidPowerup(PowerupType.Random) : PowerupType.None; result = new GameObject(p == PowerupType.Blue ? GameRes.Data.Prefabs.AsteroidSmallBlue_Prefab : GameRes.Data.Prefabs.AsteroidSmall_Prefab); } else if (type == AsteroidType.Medium) { PowerupType p = Player.Instance != null?Player.Instance.PickValidPowerup(PowerupType.Random) : PowerupType.None; result = new GameObject(p == PowerupType.Blue ? GameRes.Data.Prefabs.AsteroidMediumBlue_Prefab : GameRes.Data.Prefabs.AsteroidMedium_Prefab); } else if (type == AsteroidType.Big) { int rnd = MathF.Rnd.Next(3); result = new GameObject(rnd == 0 ? GameRes.Data.Prefabs.AsteroidBig1_Prefab : (rnd == 1 ? GameRes.Data.Prefabs.AsteroidBig2_Prefab : GameRes.Data.Prefabs.AsteroidBig3_Prefab)); } result.Transform.Pos = this.FindValidAsteroidPos(250); Scene.Current.RegisterObj(result); return(result); }
public void Start() { // choose a new powerup currentPowerupType = (PowerupType)UnityEngine.Random.Range(0, System.Enum.GetNames(typeof(PowerupType)).Length); mats = GetComponent <MeshRenderer>().materials; // Change material switch (currentPowerupType) { case PowerupType.powerupHealth: { name = "Health Powerup"; mats[0] = healthMat; break; } case PowerupType.powerupSpeed: { name = "Speed Powerup"; mats[0] = speedMat; break; } case PowerupType.firerate: { name = "Fire Rate"; mats[0] = fireRateMat; break; } } GetComponent <MeshRenderer>().materials = mats; }
public static Color GetColor(PowerupType type) { //if our color is magenta, that means we didnt find the color Color c = Color.magenta; switch (type) { case (PowerupType.Health): c = HealthColor; break; case (PowerupType.HealthRegen): c = HealthColor; break; case (PowerupType.Stamina): c = StaminaColor; break; case (PowerupType.StaminaRegen): c = StaminaColor; break; case (PowerupType.Experience): c = ExperienceColor; break; case (PowerupType.MovementSpeed): c = MovementSpeedColor; break; } return c; }
public void Start() { // choose a new powerup currentPowerupType = (PowerupType)UnityEngine.Random.Range(0, System.Enum.GetNames(typeof(PowerupType)).Length); mats = GetComponent <MeshRenderer>().materials; // Change material switch (currentPowerupType) { case PowerupType.powerupHealth: { name = "Health Powerup"; mats[0] = healthIcon; break; } case PowerupType.powerupSpeed: { name = "Speed Powerup"; mats[0] = speedIcon; break; } case PowerupType.powerupMissileCDReduction: { name = "Missile CD Powerup"; mats[0] = missileCDIcon; break; } } GetComponent <MeshRenderer>().materials = mats; }
public PowerupType PickValidPowerup(PowerupType type) { int powerupCount = 1 + instance.powerDiagonal + instance.powerFront + instance.powerSide + Powerup.Instances.Count() + Asteroid.Instances.Count(a => a.ContainedPowerup != PowerupType.None); float timeSinceLast = Time.GameTimer - lastPowerupTime; if (type == PowerupType.Blue) { if (this.powerFront + this.powerDiagonal + this.powerSide < 13) { type = MathF.Rnd.WeightedNext( new[] { PowerupType.FrontCannon, PowerupType.DiagonalCannon, PowerupType.SideCannon }, new[] { this.powerFront < 5 ? 1.5f : 0.0f, this.powerDiagonal < 4 ? 1.25f : 0.0f, this.powerSide < 4 ? 1.0f : 0.0f }); } else { type = PowerupType.None; } } else if (type == PowerupType.Green) { type = PowerupType.KillAll; } else if (type == PowerupType.Random) { if (timeSinceLast >= 10000.0f) { float noneWeight = 2.0f * MathF.Pow(powerupCount, 1.5f); if (this.powerFront + this.powerDiagonal + this.powerSide < 13) { type = MathF.Rnd.WeightedNext( new[] { PowerupType.None, PowerupType.Blue, PowerupType.Green }, new[] { 1.0f + noneWeight, 1.0f, 2.0f }); } else { type = MathF.Rnd.WeightedNext( new[] { PowerupType.None, PowerupType.Green }, new[] { 1.0f + noneWeight, 3.0f }); } } else { type = PowerupType.None; } if (type != PowerupType.None) { lastPowerupTime = Time.GameTimer; } } return(type); }
//collisions with obstacles and ground private void OnTriggerEnter2D(Collider2D collider) { //if it hits an obstacle, quit if (collider.gameObject.tag == "Obstacle") { isDead = true; randomC.clips = deathClips; randomC.PlaySound(true); GameControl.GetComponent <GameControl>().GameOver(); transform.position = new Vector3(transform.position.x, OriginalPosition.y, transform.position.z); } //if collided with ground, its running if (collider.gameObject.tag == "Ground") { isGrounded = true; gameObject.GetComponent <Rigidbody2D>().velocity = Vector3.zero; } //if collided with a powerup, change appropriate stat and destroy powerup if (collider.gameObject.tag == "Powerup") { isPoweredUp = true; PowerupType type = collider.gameObject.GetComponent <PowerUp>().type; Destroy(collider.gameObject); //TODO: add more types switch (type) { case PowerupType.IncreaseJumpHeight: maxJumpHeight = 1.5f; break; } } }
public Powerup(int x, int y, PowerupType powerupType) : base("Sprites", x, y, new Rectangle(96 + 32 * (int)powerupType, 144, 32, 32), 0.4f) { _type = powerupType; color.A = 0; visibleTimer = 0; }
public Powerup(PowerupType type, float amount, float duration, float lifetime) { Type = type; Amount = amount; Duration = duration; Lifetime = lifetime; }
public Powerup(int x, int y, int width, int height, Player player, PowerupType effectType, int effectAmount, Color effectColor, int effectDuration, Weapon weapon) { this.bounds = new Rectangle(x, y, width, height); this.player = player; this.effectAmount = effectAmount; this.effectColor = effectColor; this.effectType = effectType; this.effectDuration = effectDuration; switch (effectType) { case PowerupType.FireRateBoost: srcRect = new Rectangle(0, 0, 16, 16); break; case PowerupType.HealthBoost: srcRect = new Rectangle(32, 0, 16, 16); break; case PowerupType.SpeedBoost: srcRect = new Rectangle(16, 0, 16, 16); break; case PowerupType.Shotgun: srcRect = new Rectangle(48, 0, 16, 16); break; } this.weapon = weapon; }
public static IEnumerable <KeyValuePair <Point, PowerupType> > GenerateMapPowerups(Map map) { foreach (var item in map.tiles) { if (item.Object is Block) { Random rand = new Random(item.GetHashCode()); int randValue = rand.Next(0, 100); if (randValue < 50) { PowerupType newPowerUp = 0; if (randValue < 20) { (item.Object as Block).HiddenItem = new BombRangePowerup(0); newPowerUp = PowerupType.ExtraPower; } else if (randValue < 40) { (item.Object as Block).HiddenItem = new ExtraBombPowerup(0); newPowerUp = PowerupType.ExtraBomb; } else { (item.Object as Block).HiddenItem = new KickAbilityPowerup(0); newPowerUp = PowerupType.KickAbility; } yield return(new KeyValuePair <Point, PowerupType>(item.MapCoordinate, newPowerUp)); } } } yield break; }
public void AddPowerup(PowerupType type, float time, Sprite powerupIcon) { if (type == PowerupType.HealthPack) { playerController.AddHealth(20); } audioSource.PlayOneShot(powerupAudioClip); if (time == 0) { return; } GameObject powerupIconGameObject = Instantiate(powerupItemPrefab); powerupIconGameObject.GetComponent <Image>().sprite = powerupIcon; powerupIconGameObject.transform.SetParent(powerupUiRoot.transform, false); if (!powerupQueue.ContainsKey(type)) { powerupQueue[type] = new Queue <PowerupHandle>(); } powerupQueue[type].Enqueue(new PowerupHandle(type, time, powerupIconGameObject)); }
public void CreateDebris(AsteroidType t, PowerupType p) { GameObject debris; if (t == AsteroidType.Medium) { if (p == PowerupType.Blue) debris = new GameObject(GameRes.Data.Prefabs.AsteroidMediumBlue_Prefab); else if (p == PowerupType.Green) debris = new GameObject(GameRes.Data.Prefabs.AsteroidMediumGreen_Prefab); else debris = new GameObject(GameRes.Data.Prefabs.AsteroidMedium_Prefab); } else { if (p == PowerupType.Blue) debris = new GameObject(GameRes.Data.Prefabs.AsteroidSmallBlue_Prefab); else if (p == PowerupType.Green) debris = new GameObject(GameRes.Data.Prefabs.AsteroidSmallGreen_Prefab); else debris = new GameObject(GameRes.Data.Prefabs.AsteroidSmall_Prefab); } debris.Transform.Pos = this.GameObj.Transform.Pos; debris.Transform.Vel += this.GameObj.Transform.Vel; Scene.Current.RegisterObj(debris); }
/// <summary> /// Adds to the current powerup progress. /// </summary> /// <param name="amount">How much? (you get a powerup at 100)</param> public void AddPowerupProgress(float amount) { if (!GameManager.ShouldUpdate()) { return; } playerObject.powerupProgress += amount * CharacterAbilityManager.powerupProgressMod[playerNum]; if (playerObject.powerupProgress >= 100) { // Powerup time! currChoice = 0; var choices = PowerupInfo.Choose2RandomPowerups(playerObject.playerNum); type1 = choices[0]; type2 = choices[1]; choice1.text = PowerupInfo.Name(type1); choice1.color = Color.white; choice2.text = PowerupInfo.Name(type2); choice2.color = Color.white; GameManager.gameState = GameState.ChoosePowerup; choice1.GetComponent<Button>().interactable = true; choice2.GetComponent<Button>().interactable = true; } }
/// <summary> /// Applies the specified powerup to the ship /// </summary> /// <param name="powerup">the indicated powerup</param> public void ApplyPowerup(PowerupType powerup) { //Meteor triggers on pickup, no need to store it. //Alternatively, it could be stored and triggered on a custom key //Another alternative - Store it as a once-per-press powerup, and remove it after the first press if ((powerup & PowerupType.MeteorPowerup) > 0) { TriggerMeteor(); return; } // Store the new powerup in the PowerupType bitmask this.PowerupType |= powerup; //Apply special logic for powerups here switch (powerup) { case PowerupType.Blades: ApplyBlades(); break; case PowerupType.EightBallShield: TriggerEightBallShield(); break; case PowerupType.TriShield: ApplyTriShield(); break; case PowerupType.Ale: GetDrunk(); break; } }
public RenderedPowerup(RenderedWorld parent, float x, float y, PowerupType type, Game resourceScript) : base(parent, x, y, type) { // Create the unity object GameObject cloneSource = null; switch (type) { case PowerupType.Bombs: cloneSource = resourceScript.Protobombs; break; case PowerupType.Gravity: cloneSource = resourceScript.Protogravity; break; case PowerupType.Lightning: cloneSource = resourceScript.Protolightnings; break; case PowerupType.Minions: cloneSource = resourceScript.Protominions; break; case PowerupType.Rockets: cloneSource = resourceScript.Protorockets; break; case PowerupType.Speed: cloneSource = resourceScript.Protospeed; break; } ObjectTransform = Object.Instantiate(cloneSource.transform); ObjectTransform.position = new Vector3(x, y); }
// Powerup creation/deletion virtual protected Powerup createPowerup(float x, float y, PowerupType type) { Powerup powerup = new Powerup(this, x, y, type); powerups.Add(powerup); return(powerup); }
public void ActivatePowerup(PowerupType powerup_type, float duration) { switch (powerup_type) { case PowerupType.DOUBLEJUMP: lightning.LightningPlay(duration); StopCoroutine("DoubleJump"); StartCoroutine("DoubleJump", duration); break; case PowerupType.DOUBLESPEED: flames.FlamePlay(duration); StopCoroutine("SpeedUp"); StartCoroutine("SpeedUp", duration); break; case PowerupType.HEALTH: health += 10; if (health > 100) { health = 100; } break; } }
public void spawn(PowerupType powerupType) { CreatePowerup(powerupType); //Vector3 velocityChange = Quaternion.Euler(0.0F, 0.0F, angle) * (BulletSpeed * direction); this.rb.velocity = new Vector3(0.0F, 1.0F, 0.0F); }
public Powerup(GameManager gameManager, Point location, float maximumSpeed, PowerupType powerupType) : base(gameManager, new Rect(location, GameSprite.PowerupSize), CollisionLayer.Powerup, maximumSpeed) { this.powerupType = powerupType; SetSpriteSource(); velocity.Y = maximumSpeed; }
private void Awake() { // Set Type and Sprite int random = Random.Range(0, (int)Enum.GetValues(typeof(PowerupType)).Cast <PowerupType>().Max() + 1); type = (PowerupType)random; image.sprite = sprites[random]; }
public void PickupPowerupCoroutine(PowerupType typeOfPowerup) { foreach (PlayerStats ps in AllPlayerStats) { IEnumerator pickupPowerupCoroutine = ps.OnPowerupPickup(typeOfPowerup); StartCoroutine(pickupPowerupCoroutine); } }
public void TriggerAmmoPickup(GunType gunType, PowerupType powerupType) { EventLogger.PrintToLog("Player Gains Ammo Powerup: " + gunType); Assert.IsTrue(_guns.ContainsKey(gunType)); _guns[gunType].PickupAmmo(); _statsManagerScript.PickupPowerupCoroutine(powerupType); }
public Powerup Create(PowerupType type) { var powerup = _container.InstantiatePrefabForComponent <Powerup>(_projectSettings.Prefabs.Powerup); powerup.Type = type; return(powerup); }
public void ReplaceHiddenPowerup(PowerupType newValue) { var index = GameComponentsLookup.HiddenPowerup; var component = (HiddenPowerupComponent)CreateComponent(index, typeof(HiddenPowerupComponent)); component.value = newValue; ReplaceComponent(index, component); }
public Powerup(Texture2D texture, PowerupType type) { this.Texture = texture; Position = new Vector2(TOBamGame.Random.Next(0, ScreenManager.Width), -texture.Height + 1); Velocity.Y = 1.2f; Size = new Vector2(Texture.Width, Texture.Height); Power = type; }
public Powerup(int x, int y, PowerupType type) { ShouldBeRemoved = false; Type = type; X = x; Y = y; Time = 0; }
// Called when a player with a powerup just hit the ball void DoFriendlyHit(PowerupType powerup) { switch (powerup) { case PowerupType.Fireball: // ACTIVATE FIREBALL ballHandle.flamin = true; break; } }
public void AddPowerup(PowerupType newValue) { var index = GameComponentsLookup.Powerup; var component = (PowerupComponent)CreateComponent(index, typeof(PowerupComponent)); component.value = newValue; AddComponent(index, component); }
float waitTime; // time to wait until respawn #endregion Fields #region Constructors // (zero when powerup is pickable) /// <summary> /// Create a new powerup /// </summary> public Powerup( PowerupType type, Matrix transform, Model model) { powerupType = type; this.transform = transform; this.model = model; }
public Powerup(PowerupType type, Vector3 position) { this.Type = type; this.Position = position; this.Model = null; this.Activated = false; this.Collected = false; this.Timer = 10; this.BoundingSphere = new BoundingSphere(); this.World = Matrix.Identity; }
public Powerup(TileObjectManager manager, int tilePosX, int tilePosY, PowerupType pType, Texture2D tex, SoundEffectInstance powerupSound) : base(manager, tilePosX, tilePosY) { this.pType = pType; this.powerupTex = tex; this.powerupSoundInstance = powerupSound; Solid = false; //Hook to destroy when burnt OnFireSpread += Destroy; OnPlayerCollision += PlayerCollect; }
// Called when a powerup is over and done void EndPowerup(PowerupType powerup, PaddleObject player) { switch(powerup) { case PowerupType.Magnet: player.magnetized = false; break; case PowerupType.Iceball: player.icy = false; break; case PowerupType.Ghost: player.ghostly = false; break; } }
// Base Constructor public Powerup(PowerupType powerupType, Vector2 position, Texture2D texture, bool isTilePosition, bool isBouncy) : base(position, texture) { this.powerupType = powerupType; if (isTilePosition) this.position = new Vector2(position.X * Tile.Width, position.Y * Tile.Height); else this.position = position; this.isBouncy = isBouncy; this.isBouncy = true; this.bounce = 0.0f; }
public void PickedUpPowerup(PowerupType powerUpType) { if (powerUpType == PowerupType.Health) { _health = maxHealth; healthBar.ShowPercentage((float)_health / maxHealth); } else { type = powerUpType.ToCharacterType(); SetupLook(); } AudioSource.PlayClipAtPoint(powerupSound, Vector3.zero); }
public void receievePowerup(PowerupType type) { //TODO: Add the powerup to our list of powerups /*switch (pu.type) { case "shotspeedup": break; case "health": break; default: Debug.Log(String.Format("%s is not a valid powerup type!", type)); return; } */ }
public Powerup(GraphicsDeviceManager gdm, SpriteBatch sb, ContentManager cm, Vector2 position) { this.position = position; Random rng = new Random(); double rand = rng.NextDouble(); if (rand < 0.9) { powerupTexture = cm.Load<Texture2D>("Images/health-powerup"); type = PowerupType.Health; } else { powerupTexture = cm.Load<Texture2D>("Images/charge-powerup"); type = PowerupType.Charge; } }
public Powerup(PowerupType type, double amount, Vector position) : base(Sorting.Group, "Powerups", 3) { BodyShape = new RectangleShape(); BodyShape.Size = new Vector2f(BodyRadius, BodyRadius); BodyShape.Origin = BodyShape.Size * 0.5f; BodyShape.FillColor = BodyColor; Type = type; Amount = amount; Position = position; Game.Sounds.Prepare(ref SFX_Create, "Blip2", 10, 1.0f); Game.Sounds.Prepare(ref SFX_Pickup, "Powerup1", 10, 1.0f); SFX_Create.Play(); }
public void ActivatePowerup(PowerupType type) { if (currentPowerup != PowerupType.Normal) { EndPowerup(); } currentPowerup = type; PlayerBallControl pbc = player.GetComponent<PlayerBallControl> (); Color particleColor = Color.white; switch (currentPowerup) { case PowerupType.SuperJump: pbc.jumpForce = superJumpBoost; powerupTime = superJumpTime; particleColor = superJumpColor; break; case PowerupType.Spiderball: this.GetComponent<Spiderball>().enabled = true; powerupTime = spiderballTime; particleColor = spiderBallColor; break; case PowerupType.Gliding: this.GetComponent<Parachuter>().enabled = true; powerupTime = glidingTime; particleColor = glidingColor; break; case PowerupType.Balloon: this.GetComponent<Ballonist>().enabled = true; powerupTime = balloonTime; particleColor = balloonColor; break; } particleObj = Instantiate (particlePrefab, transform.position, Quaternion.identity) as Transform; particleObj.particleSystem.startColor = particleColor; powerupTimer = 0f; if (timeObj != null) { timeObj.GetComponent<PowerUpTime>().StartTimer(powerupTime, particleColor); } }
public Powerup(Game1 game, Vector3 pos, PowerupType powerupType) : base(game, pos) { Type = GameObjectType.Powerup; initModel(MODELNAME); Velocity = VELOCITY; Acceleration = ACCELERATION; RotationVelocity = ROTATION_VELOCITY; SightRange = SIGHT_RANGE; Scale = SCALE; transformation = TRANSFORM; isCollidable = false; // Type of powerup this.powerupType = powerupType; // Powerup travels in random direction when spawned this.vel.X = Velocity; this.vel.Y = Velocity * (float)game.random.NextDouble(); }
private void CreatePowerup(PowerupType powerupType) { Type = powerupType; /* float mass; switch (powerupType) { case PowerupType.HEALTHPACK: mass = 2.0F; break; case PowerupType.SHOTSPEED: mass = 4.0F; break; default: Debug.LogWarning("This isn't right"); mass = 2.0F; break; } */ //this.Mass = mass; }
public static void Create(Vector3 pos, PowerupType type) { GameObject p; if (Player.Instance == null) return; type = Player.Instance.PickValidPowerup(type); if (type == PowerupType.FrontCannon) p = new GameObject(GameRes.Data.Prefabs.Powerups.FrontCannon_Prefab); else if (type == PowerupType.DiagonalCannon) p = new GameObject(GameRes.Data.Prefabs.Powerups.DiagonalCannon_Prefab); else if (type == PowerupType.SideCannon) p = new GameObject(GameRes.Data.Prefabs.Powerups.SideCannon_Prefab); else if (type == PowerupType.KillAll) p = new GameObject(GameRes.Data.Prefabs.Powerups.KillAll_Prefab); else return; p.Transform.Pos = pos; p.Transform.Vel = new Vector3(MathF.Rnd.NextVector2(1.0f)); Scene.Current.RegisterObj(p); }
public Powerup CreatePowerup(TileObjectManager manager, int tilePosX, int tilePosY, PowerupType pType) { if (!loaded) return null; Texture2D pTex; switch (pType) { case PowerupType.BOMB_UP: pTex = powerupTex[0]; break; case PowerupType.FIRE_UP: pTex = powerupTex[1]; break; case PowerupType.SPEED_UP: pTex = powerupTex[2]; break; default: pTex = powerupTex[0]; break; } return new Powerup(manager, tilePosX, tilePosY, pType, pTex, powerupSoundInstance); }
public void SpawnPowerUp(PowerupType powerupType, Cell thisCell, float horizontalCell, float verticalCell) { switch (powerupType) { case PowerupType.Invulnerability: powerUpToCreate = m_InvulnerablePowerup; break; case PowerupType.Range: powerUpToCreate = m_RangePowerup; break; case PowerupType.Shake: powerUpToCreate = m_ShakePowerup; break; case PowerupType.Speed: powerUpToCreate = m_SpeedPowerup; break; case PowerupType.Trick: powerUpToCreate = m_TrickPowerup; break; } Debug.Log("SPAWNING POWERUP: "+powerupType + " CellX: "+horizontalCell + " Vertical Cell: "+verticalCell); // Spawn a powerup then destroy the game object Vector3 powerupPos = new Vector3(GetHorizontalPos(horizontalCell), GetVerticalPos(verticalCell), powerUpToCreate.transform.position.z); GameObject powerupInstance = Instantiate(powerUpToCreate, powerupPos, transform.rotation) as GameObject; thisCell.CellGameObject = powerupInstance; }
/// <summary> /// A helper function that will remove the Blade powerup and restore defaults. /// </summary> void unApplyBlades() { this.PowerupType = this.PowerupType ^= PowerupType.Blades; this.velocity /= 2; bladesPowerupTimer = 0; //TO DO: make player vulerable again, since not implemented yet. }
//Clear the powerups public void ClearPowerups() { PowerupType = PowerupType.None; }
/// <summary> /// Applies the specified powerup to the ship /// </summary> /// <param name="powerup">the indicated powerup</param> public void ApplyPowerup(PowerupType powerup) { //Meteor triggers on pickup, no need to store it. //Alternatively, it could be stored and triggered on a custom key //Another alternative - Store it as a once-per-press powerup, and remove it after the first press if ((powerup & PowerupType.MeteorPowerup) > 0) { TriggerMeteor(); return; } //This will level us up if we hit another homing missile if ((powerup & PowerupType.HomingMissiles) > 0) { HomingMissileLevel = (short)MathHelper.Min(HomingMissileLevel + 1, 3); } // Store the new powerup in the PowerupType bitmask this.PowerupType = powerup | PowerupType; //Apply special logic for powerups here switch (powerup) { case PowerupType.Blades: ApplyBlades(); break; case PowerupType.EightBallShield: TriggerEightBallShield(); break; case PowerupType.TriShield: ApplyTriShield(); break; case PowerupType.Ale: GetDrunk(); break; case PowerupType.EnergyBlast: energyBlastLevel++; break; case PowerupType.BubbleBeam: BubbleBullet.POWER_LEVEL++; break; } }
/// <summary> /// Applies the specified powerup to the ship /// </summary> /// <param name="powerup">the indicated powerup</param> public void ApplyPowerup(PowerupType powerup) { // Store the new powerup in the PowerupType bitmask this.PowerupType |= powerup; }
/// <summary> /// Factory method for spawning a projectile /// </summary> /// <param name="projectileType">The type of projectile to create</param> /// <param name="position">The position of the projectile in the game world</param> /// <returns>The game object id of the projectile</returns> public Powerup CreatePowerup(PowerupType powerupType, Vector2 position) { Powerup powerup; uint id = NextID(); switch (powerupType) { case PowerupType.Fireball: powerup = new FireballPowerup(id, content, position); break; case PowerupType.Frostball: powerup = new FrostballPowerup(id, content, position); break; case PowerupType.BubbleBeam: powerup = new BubbleBeamPowerup(id, content, position); break; case PowerupType.Freezewave: powerup = new FreezewavePowerup(id, content, position); break; case PowerupType.Blades: powerup = new BladesPowerup(id, content, position); break; case PowerupType.EightBallShield: //added EightBallShield powerup = new EightBallShieldPowerup(id, content, position); break; case PowerupType.TriShield: powerup = new TriShieldPowerup(id, content, position); break; case PowerupType.DroneWave: powerup = new DroneWavePowerup(id, content, position); break; case PowerupType.Birdcrap: powerup = new BirdcrapPowerup(id, content, position); break; case PowerupType.EnergyBlast: powerup = new EnergyBlastPowerup(id, content, position); break; case PowerupType.Bomb: powerup = new BombPowerUp(id, content, position); break; case PowerupType.Ale: powerup = new AlePowerup(id, content, position); break; case PowerupType.ShotgunPowerup: powerup = new ShotgunPowerup(id, content, position); break; case PowerupType.MeteorPowerup: powerup = new MeteorPowerup(id, content, position); break; case PowerupType.Railgun: powerup = new Railgun(id, content, position); break; case PowerupType.HomingMissiles: powerup = new HomingMissilesPowerup(id, content, position); break; default: throw new NotImplementedException("The powerup type " + Enum.GetName(typeof(ProjectileType), powerupType) + " is not supported"); } powerup.ObjectType = ObjectType.Powerup; QueueGameObjectForCreation(powerup); return powerup; }