// Use this for initialization
void Start()
{
sailSound.volume = 0f;
cannon1.GetComponent <Cannon> ().enemyRaft = otherRaftScript.gameObject;
cannon2.GetComponent <Cannon> ().enemyRaft = otherRaftScript.gameObject;
grapple1.GetComponent <Grapple> ().enemyRaft = otherRaftScript.gameObject;
grapple2.GetComponent <Grapple> ().enemyRaft = otherRaftScript.gameObject;
grapple1.GetComponent <Grapple> ().thisRaft = this.gameObject;
grapple2.GetComponent <Grapple> ().thisRaft = this.gameObject;
power1 = power2 = PowerUp.PowerUpType.None;
winnerExists = false;
lCool = rCool = spinFrameCounter = 0;
noControl = false;
left = "joystick " + player1 + " button 0";
right = "joystick " + player2 + " button 0";
backLeft = "joystick " + player1 + " button 1";
backRight = "joystick " + player2 + " button 1";
fireLeft = "joystick " + player1 + " button 2";
fireRight = "joystick " + player2 + " button 2";
fireTriggerLeft = "Player" + player1 + "_RightTrigger";
fireTriggerRight = "Player" + player2 + "_RightTrigger";
leftAxisH = "Player" + player1 + "_axisX";
rightAxisH = "Player" + player2 + "_axisX";
leftAxisV = "Player" + player1 + "_axisY";
rightAxisV = "Player" + player2 + "_axisY";
raft.maxAngularVelocity = 4f;
}
void DealWithPowerup(PowerUp powerUp)
{
PowerUp.PowerUpType powerUpType = powerUp.Type;
//TODO shine in powerups color instead of custom
switch (powerUpType)
{
case PowerUp.PowerUpType.WEAPON:
if (playerWeaponSystem.WeaponCanBeUpgraded())
{
playerWeaponSystem.UpgradeWeapon();
powerUp.ReturnToPool();
}
break;
case PowerUp.PowerUpType.RELOAD:
if (playerWeaponSystem.SpecialWeaponCanBeReloaded())
{
playerWeaponSystem.ReloadSpecialWeapon();
powerUp.ReturnToPool();
}
break;
case PowerUp.PowerUpType.REPAIR:
if (playerHealthSystem.CanBeHealed())
{
playerHealthSystem.Heal();
powerUp.ReturnToPool();
}
break;
default:
throw new UnityException("Unknown PowerUp-Type \"" + powerUpType.ToString() + "\"");
}
}
public void ApplyPowerUp(PowerUp.PowerUpType poweUpType)
{
switch (poweUpType)
{
case PowerUp.PowerUpType.BombCount:
BombCount += 1;
UIScript.ChangeText(1, BombCount.ToString());
break;
case PowerUp.PowerUpType.Speed:
PlayerSpeed = 4;
UIScript.ChangeText(0, PlayerSpeed.ToString());
// trail.SetActive(true);
break;
case PowerUp.PowerUpType.BombDistance:
BombDamageDistance += 1;
UIScript.ChangeText(2, BombDamageDistance.ToString());
break;
case PowerUp.PowerUpType.WallWalking:
WallWalking = true;
UIScript.ChangeText(3, "");
boardManager.ChangeCollapsingWallTransparency();
break;
default:
throw new ArgumentOutOfRangeException(nameof(poweUpType), poweUpType, null);
}
}
public void GetPowerUp(PowerUp.PowerUpType type)
{
switch (type)
{
case PowerUp.PowerUpType.TripleShot:
_currentWeapon = _tripleShot;
StartCoroutine(ResetWeapon());
break;
case PowerUp.PowerUpType.Speed:
_currentSpeed = _baseSpeed * 1.5f;
StartCoroutine(ResetSpeed());
break;
case PowerUp.PowerUpType.Shield:
if (_shieldStrength == _maxShieldStrength)
{
AddToScore(_bonusShieldScore);
}
else
{
_shieldStrength = _maxShieldStrength;
SetShieldColorByStrength(_shieldStrength);
_playerShield.SetActive(true);
}
break;
case PowerUp.PowerUpType.Ammo:
_currentAmmo += _ammoPowerUpAmount;
_uiManager.UpdateAmmo(_currentAmmo);
break;
case PowerUp.PowerUpType.Life:
if (_lives >= 3)
{
AddToScore(_bonusLifeScore);
}
else
{
_lives++;
_uiManager.UpdateLives(_lives);
}
break;
case PowerUp.PowerUpType.Beam:
_hasBeam = true;
StartCoroutine(ResetWeapon());
break;
default:
break;
}
}
public void CollectPowerUp(PowerUp.PowerUpType type)
{
if (type == PowerUp.PowerUpType.Speed)
{
maxSpeed = speedBoostSpeed;
usingSpeedBoost = true;
audioSource.PlayOneShot(speedSound);
}
else if (type == PowerUp.PowerUpType.Time)
{
Time.timeScale = 0.1f;
}
}
public PowerUp GetPowerUp(PowerUp.PowerUpType type)
{
for (int i = 0; i < powerUps.Count; i++)
{
if (powerUps[i].myType == type)
{
PowerUp temp = powerUps[i];
powerUps.RemoveAt(i);
return(temp);
}
}
return(null);
}
public Ball GetBall(PowerUp.PowerUpType type)
{
for (int i = 0; i < balls.Count; i++)
{
if (balls[i].myType == type)
{
Ball temp = balls[i];
balls.RemoveAt(i);
return(temp);
}
}
return(null);
}
public List <PowerUp> GetPowerUpsOfType(PowerUp.PowerUpType powerUpType)
{
List <PowerUp> foundPowerUps = new List <PowerUp>();
foreach (PowerUp powerUp in powerUps)
{
if (powerUp.GetPowerUpType() == powerUpType)
{
foundPowerUps.Add(powerUp);
}
}
return(foundPowerUps);
}
IEnumerator PowerUpRoutine(float effectDuration, PowerUp.PowerUpType type)
{
yield return(new WaitForSeconds(effectDuration));
if (type == PowerUp.PowerUpType.RapidShot)
{
_fireMultiplier = 1;
}
else if (type == PowerUp.PowerUpType.Shield)
{
_hasShield = false;
shield.RequestActivateObject(false);
}
}
public void PowerUpPicked(float effectDuration, PowerUp.PowerUpType type)
{
if (type == PowerUp.PowerUpType.RapidShot)
{
_fireMultiplier = 0.4f;
StartCoroutine(PowerUpRoutine(effectDuration, type));
}
else if (type == PowerUp.PowerUpType.Shield)
{
_hasShield = true;
shield.RequestActivateObject(true);
StartCoroutine(PowerUpRoutine(effectDuration, type));
}
}
//allow the players to grab powerups, but don't overwrite old ones!
void getPowerUps(PowerUp.PowerUpType incoming)
{
cannon1line.SetActive(true);
cannon2line.SetActive(true);
grapple1line.SetActive(true);
grapple2line.SetActive(true);
powerupGrab.Play();
if (power1 == PowerUp.PowerUpType.None)
{
power1 = incoming;
}
if (power2 == PowerUp.PowerUpType.None)
{
power2 = incoming;
}
}
public static Color PowerUpThree(PowerUp.PowerUpType type)
{
switch (type)
{
case PowerUp.PowerUpType.PaddleSizeUp:
return(Color.DarkGoldenrod);
case PowerUp.PowerUpType.PaddleSizeDown:
return(Color.DarkGreen);
case PowerUp.PowerUpType.BallSizeUp:
return(Color.DarkOrange);
//case PowerUp.PowerUpType.BallSizeDown:
// return Color.DarkViolet;
case PowerUp.PowerUpType.SplitBalls:
return(Color.DarkRed);
case PowerUp.PowerUpType.BallSpeedUp:
return(Color.DarkBlue);
//case PowerUp.PowerUpType.BallSpeedDown:
// return Color.DeepPink;
case PowerUp.PowerUpType.PaddleSpeedUp:
return(Color.DarkCyan);
case PowerUp.PowerUpType.PaddleSpeedDown:
return(Color.DarkMagenta);
//case PowerUp.PowerUpType.StickyPaddle:
// return Color.Black;
case PowerUp.PowerUpType.ExtraBall:
return(Color.White);
case PowerUp.PowerUpType.ExtraLife:
return(Color.Brown);
case PowerUp.PowerUpType.TemporaryGun:
return(Color.Black);
default:
return(Color.Brown);
}
}
public static Color PowerUpOne(PowerUp.PowerUpType type)
{
switch (type)
{
case PowerUp.PowerUpType.PaddleSizeUp:
return(Color.LightYellow);
case PowerUp.PowerUpType.PaddleSizeDown:
return(Color.LightGreen);
case PowerUp.PowerUpType.BallSizeUp:
return(Color.LightSalmon);
//case PowerUp.PowerUpType.BallSizeDown:
// return Color.MediumPurple;
case PowerUp.PowerUpType.SplitBalls:
return(Color.PaleVioletRed);
case PowerUp.PowerUpType.BallSpeedUp:
return(Color.LightBlue);
//case PowerUp.PowerUpType.BallSpeedDown:
// return Color.LightPink;
case PowerUp.PowerUpType.PaddleSpeedUp:
return(Color.LightCyan);
case PowerUp.PowerUpType.PaddleSpeedDown:
return(Color.FloralWhite);
//case PowerUp.PowerUpType.StickyPaddle:
// return Color.LightGray;
case PowerUp.PowerUpType.ExtraBall:
return(Color.White);
case PowerUp.PowerUpType.ExtraLife:
return(Color.Beige);
case PowerUp.PowerUpType.TemporaryGun:
return(Color.LightGray);
default:
return(Color.Brown);
}
}
public static Color PowerUpTwo(PowerUp.PowerUpType type)
{
switch (type)
{
case PowerUp.PowerUpType.PaddleSizeUp:
return(Color.Yellow);
case PowerUp.PowerUpType.PaddleSizeDown:
return(Color.Green);
case PowerUp.PowerUpType.BallSizeUp:
return(Color.Orange);
//case PowerUp.PowerUpType.BallSizeDown:
// return Color.Purple;
case PowerUp.PowerUpType.SplitBalls:
return(Color.Red);
case PowerUp.PowerUpType.BallSpeedUp:
return(Color.Blue);
//case PowerUp.PowerUpType.BallSpeedDown:
// return Color.HotPink;
case PowerUp.PowerUpType.PaddleSpeedUp:
return(Color.Cyan);
case PowerUp.PowerUpType.PaddleSpeedDown:
return(Color.Magenta);
//case PowerUp.PowerUpType.StickyPaddle:
// return Color.DarkGray;
case PowerUp.PowerUpType.ExtraBall:
return(Color.White);
case PowerUp.PowerUpType.ExtraLife:
return(Color.SandyBrown);
case PowerUp.PowerUpType.TemporaryGun:
return(Color.DarkGray);
default:
return(Color.Brown);
}
}
public void PickedUpPowerUp(PowerUp.PowerUpType type, Vector3 position)
{
if (dead)
{
return;
}
if (type == PowerUp.PowerUpType.FUEL)
{
fuel += 50;
if (fuel > 100)
{
fuel = 100;
}
fuelAlarm.StopAlarm();
UpdateFuelBar();
lowFuelText.HideText();
ship.PickedUpFuel();
Transform powerUpMessageTrans = (Transform)Instantiate(powerUpMessagePrefab);
powerUpMessageTrans.GetComponent <PowerUpMessage>().Initialize("+fuel", position);
}
else if (type == PowerUp.PowerUpType.SPEED)
{
boosterActivated = true;
boosterTimer = boosterDuration;
ship.BoosterActive(true);
ship.PickedUpBooster();
Transform powerUpMessageTrans = (Transform)Instantiate(powerUpMessagePrefab);
powerUpMessageTrans.GetComponent <PowerUpMessage>().Initialize("+boost", position);
}
}
public void PowerUpBall(GameObject player, PowerUp.PowerUpType typeToChangeTo, PowerUp powerUp)
{
projectiles.powerUps.Add(powerUp); powerUp.transform.position = new Vector2(10000, 10000);
foreach (GameObject ball in player.GetComponent <PlayerBallController>().balls)
{
if (ball.GetComponent <Ball>().myType == PowerUp.PowerUpType.Basic)
{
//if there is a basic ball to replace
player.GetComponent <PlayerBallController>().balls.Remove(ball);
Destroy(ball);
GameObject newBall = projectiles.GetBall(typeToChangeTo).gameObject;
newBall.transform.position = player.transform.position;
newBall.GetComponent <Ball>().players[0] = players[0].gameObject;
newBall.GetComponent <Ball>().players[1] = players[1].gameObject;
newBall.SetActive(true);
player.GetComponent <PlayerBallController>().balls.Add(newBall);
return;
}
}
UI.OpenBallSwitching(player.GetComponent <PlayerBallController>(), projectiles.GetBall(typeToChangeTo));
}
public void NewPowerUp(Vector3 position, PowerUp.PowerUpType type)
{
Rigidbody powerUpRB;
if (!TryTakeRBFromInactivePool(out powerUpRB))
{
powerUpCount++;
GameObject powerUpObject = Instantiate(powerupPrefab) as GameObject;
powerUpObject.transform.parent = this.transform;
powerUpObject.name = "powerup " + powerUpCount;
powerUpRB = powerUpObject.GetComponent <Rigidbody>();
}
PowerUp powerUp = powerUpRB.gameObject.GetComponent <PowerUp>();
powerUp.Initialize(type, this);
powerUpRB.gameObject.SetActive(true);
powerUpRB.transform.position = position;
// powerUpRB.transform.localRotation = Quaternion.LookRotation(direction);
// powerUpRB.velocity = direction * bulletSpeed;
activeRBs.Add(powerUpRB);
}
public int ScoreValue(PowerUp.PowerUpType type)
{
switch (type)
{
case PowerUp.PowerUpType.WIDE_PADDLE: return(1);
case PowerUp.PowerUpType.STICKY_BALL: return(1);
case PowerUp.PowerUpType.SLOW_BALL: return(1);;
case PowerUp.PowerUpType.BIG_BALL: return(1);
//non timed ones
case PowerUp.PowerUpType.HEAVY_BALL: return(1);
case PowerUp.PowerUpType.EXTRA_LIFE: return(1);
case PowerUp.PowerUpType.TRIPLE_BALLS: return(1);
case PowerUp.PowerUpType.RESET_SPEED: return(1);
case PowerUp.PowerUpType.BULLETS: return(1);
//power downs timed
case PowerUp.PowerUpType.NARROW_PADDLE: return(10);
case PowerUp.PowerUpType.INVERT_CONTROLS: return(20);
case PowerUp.PowerUpType.RANDOM_BOUNCE: return(5);
case PowerUp.PowerUpType.CURVE_BALL: return(25);
//non timed
case PowerUp.PowerUpType.INCREASE_SPEED: return(10);
}
return(0);
}
public void PowerUpCollected(PowerUp.PowerUpType type)
{
//do the collection code here
switch (type)
{
case PowerUp.PowerUpType.WIDE_PADDLE: WidePaddleCollected(); break;
case PowerUp.PowerUpType.STICKY_BALL: StickyBallCollected(); break;
case PowerUp.PowerUpType.SLOW_BALL: SlowBallCollected(); break;
case PowerUp.PowerUpType.BIG_BALL: BigBallCollected(); break;
//non timed ones
case PowerUp.PowerUpType.HEAVY_BALL: HeavyBallCollected(); break;
case PowerUp.PowerUpType.EXTRA_LIFE: ExtraLifeCollected(); break;
case PowerUp.PowerUpType.TRIPLE_BALLS: TrippleBallsCollected(); break;
case PowerUp.PowerUpType.RESET_SPEED: ResetSpeedCollected(); break;
case PowerUp.PowerUpType.BULLETS: BulletsCollected(); break;
//power downs timed
case PowerUp.PowerUpType.NARROW_PADDLE: NarrowPaddlesCollected(); break;
case PowerUp.PowerUpType.INVERT_CONTROLS: InvertControlsCollected(); break;
case PowerUp.PowerUpType.RANDOM_BOUNCE: RandomBounceCollected(); break;
case PowerUp.PowerUpType.CURVE_BALL: CurveBallCollected(); break;
//non timed
case PowerUp.PowerUpType.INCREASE_SPEED: IncreaseSpeedCollected(); break;
}
}
public void SetPowerUp(PowerUp.PowerUpType powerUp)
{
hasPowerUp = true;
powerUpItem = powerUp;
}
public override void Update(GameTime gameTime)
{
isBoss = MobSpawner.bossSpawn;
startDelayTimer += (float)gameTime.ElapsedGameTime.TotalMilliseconds;
gameDuration += gameTime.ElapsedGameTime.Milliseconds;
if (gameDuration > 5 * 1000 && barrierBufferMax > 100 && isBoss == false)
{
swap = 0;
if (justSwitchedBoss == true)
{
barrierBufferMax = barrierBufferMem;
gameDuration = 0;
justSwitchedBoss = false;
}
else if (justSwitchedBoss == false)
{
barrierBufferMax -= ((difficulty + 1) * 25);
gameDuration = 0;
}
}
else if (isBoss == true)
{
if (swap == 0)
{
barrierBufferMem = barrierBufferMax;
barrierBufferMax = 100;
swap = 1;
}
}
if (startDelayTimer < Game1.PLAY_START_DELAY)
{
player.Update(gameTime);
return;
}
player.Update(gameTime);
if (isFrozen == false && isBreaking == false)
{
currentTimer = null;
}
if (player.isHit == true && clearAmount < clearInterval)
{
clearAmount += gameTime.ElapsedGameTime.Milliseconds;
}
if (isFrozen == false)
{
barrierBuffer += gameTime.ElapsedGameTime.Milliseconds;
freezeTimer = 4;
freezeLabel = null;
}
powerUpBuffer += gameTime.ElapsedGameTime.Milliseconds;
if (isFrozen == true)
{
freezeDuration += gameTime.ElapsedGameTime.Milliseconds;
currentTimer = new Component(timers[freezeTimer - 1], new Vector2(625, 25));
freezeLabel = new Component(freezeLabelTexture, new Vector2(475, 15));
if (freezeDuration == 992 || freezeDuration == 2000 || freezeDuration == 3008)
{
freezeTimer -= 1;
}
}
if (isBreaking == true)
{
breakingDuration += gameTime.ElapsedGameTime.Milliseconds;
currentTimer = new Component(timers[breakingTimer - 1], new Vector2(625, 25));
smashLabel = new Component(smashLabelTexture, new Vector2(475, 15));
if (breakingDuration == 992 || breakingDuration == 2000 || breakingDuration == 3008 || breakingDuration == 400 ||
breakingDuration == 5008 || breakingDuration == 6000 || breakingDuration == 7008)
{
breakingTimer -= 1;
}
}
else
{
breakingTimer = 8;
smashLabel = null;
}
if (freezeDuration > 4000)
{
freezeDuration = 0;
isFrozen = false;
foreach (LeftBarrier b in barriers)
{
b.setBarrierSpeed(barrierSpeed);
}
}
if (breakingDuration > 8000)
{
breakingDuration = 0;
isBreaking = false;
}
if (barrierBuffer >= barrierBufferMax && clearAmount > clearInterval)
{
barriers.Add(new LeftBarrier(barrierTexture, new Vector2(0, 0), barrierSpeed, columnAmt));
barrierBuffer = 0;
}
for (int i = 0; i < barriers.Count; i++)
{
barriers[i].Update(gameTime);
if (player.hitStatus() == false && player.getRectangle().Intersects(barriers[i].getRectangle()))
{
if (isBreaking == true)
{
barriers.Remove(barriers[i]);
breakSound.Play(Game1.Volume, 0f, 0f);
}
else
{
clearAmount = 0;
barriers.Clear();
player.setHit(true);
player.Hit(1);
}
}
}
if (powerUpBuffer >= 8000)
{
int type = powerUpDecider.Next(0, 2);
switch (type)
{
case 0:
powerUp = new PowerUp(freezeTexture, new Vector2(0, 0), PowerUp.PowerUpType.freezeBarriers);
break;
case 1:
powerUp = new PowerUp(breakTexture, new Vector2(0, 0), PowerUp.PowerUpType.breakBarriers);
break;
}
powerUpBuffer = 0;
}
for (int i = 0; i < barriers.Count; i++)
{
if (barriers[i].position.Y > 900)
{
barriers.Remove(barriers[i]);
}
}
if (powerUp != null && player.getRectangle().Intersects(powerUp.getRectangle()))
{
powerUpType = powerUp.getPowerUpType();
powerUp = null;
switch (powerUpType)
{
case PowerUp.PowerUpType.freezeBarriers:
isFrozen = true;
freezeCollectSound.Play(Game1.Volume, 0f, 0f);
foreach (LeftBarrier b in barriers)
{
b.setBarrierSpeed(0);
}
break;
case PowerUp.PowerUpType.breakBarriers:
smashCollectSound.Play(Game1.Volume, 0f, 0f);
isBreaking = true;
break;
}
}
if (powerUp != null)
{
powerUp.Update(gameTime);
if (powerUp.position.Y > 900)
{
powerUp = null;
}
}
}
/// <summary>
/// Indicates whether or not the given powerUpType is active.
/// </summary>
/// <param name="powerUpType">The power up type to test.</param>
/// <returns>true if the given power up type is currently active.</returns>
private bool isPowerUpActive(PowerUp.PowerUpType powerUpType)
{
return(activePowerUps.Contains(powerUpType));
}
/// <summary>
/// Apply the given power up type, but only after a certain amount has elapsed, then power down.
/// </summary>
/// <returns></returns>
private IEnumerator delayPowerUp(PowerUp.PowerUpType powerUpType)
{
yield return(new WaitForSeconds(5.0f));
activePowerUps.Remove(powerUpType);
}
// Update is called once per frame
void Update()
{
//rotate the paddles appropriately!
float lAnglePercent = (float)lCool / (float)paddleFrames; //this is what percentage of a full paddle we've done!
float rAnglePercent = (float)rCool / (float)paddleFrames;
if (lAnglePercent < .2f && leftPrompt.sprite == aButton)
{
lAnglePercent = 1f - (5f * lAnglePercent);
}
if (rAnglePercent < .2f && rightPrompt.sprite == aButton)
{
rAnglePercent = 1f - (5f * rAnglePercent);
}
if (leftPrompt.sprite == bButton)
{
lAnglePercent = 1f - lAnglePercent; //paddling backwards!
}
if (rightPrompt.sprite == bButton)
{
rAnglePercent = 1f - rAnglePercent;
}
float angleToRotateLeftPaddle = lAnglePercent * 90f;
float angleToRotateRightPaddle = rAnglePercent * 90f;
Vector3 paddle1Angle = paddle1.transform.localEulerAngles;
paddle1Angle.z = 80f - angleToRotateLeftPaddle;
//print (paddle1Angle.z);
paddle1.transform.localEulerAngles = paddle1Angle;
Vector3 paddle2Angle = paddle2.transform.localEulerAngles;
paddle2Angle.z = -80f + angleToRotateRightPaddle;
//print (paddle1Angle.z);
paddle2.transform.localEulerAngles = paddle2Angle;
tutorialActive = TutorialGORef.GetComponent <RaftingTutorial>().tutorial.enabled;
if (tutorialActive)
{
return;
}
//allow paddling!
if ((Input.GetKeyDown(left) || Input.GetKeyDown(keyLeft) || Input.GetKeyDown(backLeft) || Input.GetKeyDown(keyBackLeft)) && lCool <= 0)
{
lCool = cooldownFrames;
forwardPaddleSound.Play();
}
if (Input.GetKeyDown(right) || Input.GetKeyDown(keyRight) || Input.GetKeyDown(backRight) || Input.GetKeyDown(keyBackRight) && rCool <= 0)
{
rCool = cooldownFrames;
forwardPaddleSound.Play();
//rightPaddle.AddForce (rightPaddle.transform.up * paddleForce);
}
if (winnerExists && Time.time - victoryTime > victoryDelay)
{
ScoreKeeper.DisplayResultsScreen(); //leave the minigame
}
//Time to deal with powerups
if (power1 == PowerUp.PowerUpType.None)
{
powerImage1.enabled = false;
}
if (power2 == PowerUp.PowerUpType.None)
{
powerImage2.enabled = false;
}
//Handle Cannon powerup
if (power1 == PowerUp.PowerUpType.Cannon)
{
powerImage1.enabled = true;
powerImage1.sprite = cannonSprite;
cannon1.SetActive(true);
//rotate the cannon to match the control stick
float controlStickAngle = Mathf.Rad2Deg * Mathf.Atan2(Input.GetAxis(leftAxisH), Input.GetAxis(leftAxisV));
cannon1.transform.eulerAngles = new Vector3(0, 0, 180f - controlStickAngle);
if (Mathf.Abs(Input.GetAxis(leftAxisH)) + Mathf.Abs(Input.GetAxis(leftAxisV)) < .1f)
{
cannon1.transform.localEulerAngles = new Vector3(0, 0, 180);
//cannon1line.SetActive(false);
}
else
{
//cannon1line.SetActive(true);
}
}
else
{
cannon1.SetActive(false);
}
if (power2 == PowerUp.PowerUpType.Cannon)
{
powerImage2.enabled = true;
powerImage2.sprite = cannonSprite;
cannon2.SetActive(true);
//rotate the cannon to match the control stick
float controlStickAngle = Mathf.Rad2Deg * Mathf.Atan2(Input.GetAxis(rightAxisH), Input.GetAxis(rightAxisV));
cannon2.transform.eulerAngles = new Vector3(0, 0, 180f - controlStickAngle);
if (Mathf.Abs(Input.GetAxis(rightAxisH)) + Mathf.Abs(Input.GetAxis(rightAxisV)) < .2f)
{
cannon2.transform.eulerAngles = this.transform.eulerAngles;
//cannon2line.SetActive(false);
}
else
{
//cannon2line.SetActive(true);
}
}
else
{
cannon2.SetActive(false);
}
//allow player to fire powerups
if (Input.GetKeyDown(fireLeft) || Input.GetKeyDown(keyFireLeft) ||
Input.GetAxis(fireTriggerLeft) >= 0.9f)
{
if (power1 == PowerUp.PowerUpType.Cannon)
{
power1 = PowerUp.PowerUpType.None;
cannon1.GetComponent <Cannon> ().fire();
cannon1line.SetActive(false);
cannonFire.Play();
}
if (power1 == PowerUp.PowerUpType.Grapple)
{
power1 = PowerUp.PowerUpType.None;
grapple1.GetComponent <Grapple> ().fire();
grapple1line.SetActive(false);
grappleLaunch.Play();
}
if (power1 == PowerUp.PowerUpType.Sail)
{
power1 = PowerUp.PowerUpType.None;
sailPole1.SetActive(false);
StartCoroutine(Boost(sail1, sailPole1));
}
}
if (Input.GetKeyDown(fireRight) || Input.GetKeyDown(keyFireRight) ||
Input.GetAxis(fireTriggerRight) >= 0.9f)
{
if (power2 == PowerUp.PowerUpType.Cannon)
{
power2 = PowerUp.PowerUpType.None;
cannon2.GetComponent <Cannon> ().fire();
cannon2line.SetActive(false);
cannonFire.Play();
}
if (power2 == PowerUp.PowerUpType.Grapple)
{
power2 = PowerUp.PowerUpType.None;
grapple2.GetComponent <Grapple> ().fire();
grapple2line.SetActive(false);
grappleLaunch.Play();
}
if (power2 == PowerUp.PowerUpType.Sail)
{
power2 = PowerUp.PowerUpType.None;
sailPole2.SetActive(false);
StartCoroutine(Boost(sail2, sailPole2));
}
}
//Handle Grapple powerup stuff
if (power1 == PowerUp.PowerUpType.Grapple)
{
grapple1.SetActive(true);
powerImage1.enabled = true;
powerImage1.sprite = grappleSprite;
currentScaling = .1f; //for some reason having an active grapple makes you go way faster, so I manually nerfed it this way
//rotate the grapple to match the control stick
float controlStickAngle = Mathf.Rad2Deg * Mathf.Atan2(Input.GetAxis(leftAxisH), Input.GetAxis(leftAxisV));
grapple1.transform.eulerAngles = new Vector3(0, 0, 180f - controlStickAngle);
if (Mathf.Abs(Input.GetAxis(leftAxisH)) + Mathf.Abs(Input.GetAxis(leftAxisV)) < .1f)
{
grapple1.transform.localEulerAngles = new Vector3(0, 0, 180);
}
}
else
{
currentScaling = 1f; //un-nerf water speed
}
if (power2 == PowerUp.PowerUpType.Grapple)
{
grapple2.SetActive(true);
powerImage2.enabled = true;
powerImage2.sprite = grappleSprite;
currentScaling = .1f; //for some reason grapple makes you flow way faster, so I had to manually nerf the current
//rotate the cannon to match the control stick
float controlStickAngle = Mathf.Rad2Deg * Mathf.Atan2(Input.GetAxis(rightAxisH), Input.GetAxis(rightAxisV));
grapple2.transform.eulerAngles = new Vector3(0, 0, 180f - controlStickAngle);
if (Mathf.Abs(Input.GetAxis(rightAxisH)) + Mathf.Abs(Input.GetAxis(rightAxisV)) < .1f)
{
grapple2.transform.localEulerAngles = new Vector3(0, 0, 0);
}
}
else
{
currentScaling = 1f; //un-nerf when you don't have a grapple anymore
}
//Handle Sail powerup stuff
if (power1 == PowerUp.PowerUpType.Sail)
{
powerImage1.enabled = true;
powerImage1.sprite = sailSprite;
sailPole1.SetActive(true);
}
if (power2 == PowerUp.PowerUpType.Sail)
{
powerImage2.enabled = true;
powerImage2.sprite = sailSprite;
sailPole2.SetActive(true);
}
}
/// <summary>
/// Enables the triple shot power up for a certain amount of time.
/// </summary>
public void powerUpOccurred(PowerUp.PowerUpType powerUpType)
{
activePowerUps.Add(powerUpType);
StartCoroutine(delayPowerUp(powerUpType));
}
