private void Start()
{
// Set UI panels to be hidden or visible at the start
gameOver.SetActive(false);
blurPanel.SetActive(true);
controlPanel.SetActive(true);
// Reset rounded score for audio event
roundScore = 0;
blendingScoreRTPC.SetGlobalValue(roundScore);
// Acquire the progress arrow's position from startup
arrowPos = progArrow.transform.position;
// Set target score to a quarter of the total score for each round (1/4 so every minigame adds up to total)
targetScore = MinigameScores.ScoreTarget / 4;
// Set the initial position and rotation of the particle emitter to make sure particles shoot towards camera
particlePosition = new Vector3(blender.transform.position.x - 3, blender.transform.position.y + 3, 1.0f);
particleRotation = new Quaternion(Quaternion.identity.x + 180, Quaternion.identity.y, Quaternion.identity.z, Quaternion.identity.w);
// Get the animator for the blender and wheel
wheelAnimator = wheel.GetComponent <Animator>();
goblinAnimator = goblin.GetComponent <Animator>();
blenderAnimator = blender.GetComponent <Animator>();
// Get the height of the progress bar
progBarTotalHeight = progBar.GetComponent <Renderer>().bounds.size.y;
// Play audio
blendMinigameStart.Post(gameObject);
}
public void EnableMagic()
{
SpellChargeLevel.SetGlobalValue(0f);
SpellChargeStart.Post(gameObject);
InputManager.OnUseDown += OnCharge;
InputManager.OnUseUp += OffCharge;
}
public void SetRTPC(float value)
{
if (Menu.isOpen)
{
RTPC.SetGlobalValue(value);
}
}
public override void ProcessFrame(Playable playable, FrameData info, object playerData)
{
if (!m_OverrideTrackObject)
{
// At this point, m_RTPCObject will have been set to the timeline owner object in AkRTPCPlayable::CreatePlayable().
// If the track object is null, we keep using the timeline owner object. Otherwise, we swap it for the track object.
GameObject obj = playerData as GameObject;
if (obj != null)
{
m_RTPCObject = obj;
}
}//If we are overriding the track object, the m_RTPCObject will have been resolved in AkRTPCPlayable::CreatePlayable().
if (m_Parameter != null)
{
if (m_SetRTPCGlobally || m_RTPCObject == null)
{
m_Parameter.SetGlobalValue(RTPCValue);
}
else
{
m_Parameter.SetValue(m_RTPCObject, RTPCValue);
}
}
}
// Update is called once per frame
void Update()
{
TimeOfDayRTPC.SetGlobalValue(time);
if (!started)
{
return;
}
Vector3 position = transform.position;
position.y += speed;
transform.position = position;
time = position.y;
if (time >= nightTimeEnd)
{
nightTime = false;
}
if (time >= nightTimeStart)
{
nightTime = true;
}
if (time >= resetTime)
{
position.y = 0f;
transform.position = position;
time = 0f;
nightTime = true;
}
}
// Update is called once per frame
void Update()
{
currentPower = Mathf.MoveTowards(currentPower, targetPower, powerDelta);
if (EnginePowerRTPC != null)
{
EnginePowerRTPC.SetGlobalValue(currentPower);
}
}
// Use this for initialization
void Start()
{
cam = transform.parent.GetComponentInChildren <Camera>();
background = GameObject.FindGameObjectWithTag("Background");
boundsX = background.GetComponentInChildren <BoxCollider2D>().bounds.size.x;
boundsY = background.GetComponentInChildren <BoxCollider2D>().bounds.size.y;
camWidth = 18.0f;
camHeight = 5.0f;
camPosition = new Vector3(0.0f, 0.0f, -10.0f);
bulletSpeed = 20.0f;
currentBulletSpeed = bulletSpeed;
bulletOffsetX = 0.2f;
bulletDist = new Vector3(bulletOffsetX, 0, 0);
maxAmmo = 8;
currentAmmo = 0;
maxPollution = 10;
currentPollution = 0;
pollutionPerAmmo = 1;
pollutionToNextAmmo = pollutionPerAmmo;
speedIncrease = 15.7f;
scale = 0.4f;
maxSpeed = 24.0f;
velocity = new Vector3(0, 0, 0);
isJumping = false;
scaleVector = new Vector3(scale, scale, 1);
playerHeight = transform.position.y + 40.0f;
playerHeight = Mathf.Lerp(0.0f, 100.0f, playerHeight);
heightRTPC.SetGlobalValue(playerHeight);
score = 0;
stopped = 0;
controller = GameObject.FindObjectOfType <GameController>();
//bulletPosition = new Vector3(-bulletDist, 0, 0) + transform.position;
}
IEnumerator AkHealthStatus()
{
while (true)
{
HealthLevel.SetGlobalValue(Mathf.Min(HealthOfPlayer, 100));
yield return(new WaitForSeconds(0.1f));
}
}
public void ToggleMenu()
{
if (isOpen || !DialogueManager.DialogueActive)
{
menuOpen = !menuOpen;
isOpen = menuOpen;
if (menuOpen)
{
source.clip = Open;
source.Play(0);
MenuOpenSound.Post(gameObject);
MenuRTPC.SetGlobalValue(100f);
GameManager.Instance.gameSpeedHandler.PauseGameSpeed(gameObject.GetInstanceID());
GameManager.Instance.BlurCam();
QuestBox.EnableObject(0.5f);
#if UNITY_STANDALONE
PlayerManager.Instance.cameraScript.FreezeAndShowCursor(true, gameObject);
ControlsBox.EnableObject(0.5f);
#endif
}
else
{
source.clip = Close;
source.Play(0);
MenuCloseSound.Post(gameObject);
MenuRTPC.SetGlobalValue(0f);
GameManager.Instance.gameSpeedHandler.UnPauseGameSpeed(gameObject.GetInstanceID());
GameManager.Instance.UnBlurCam();
QuestBox.DisableObject(0.25f);
#if UNITY_STANDALONE
PlayerManager.Instance.cameraScript.FreezeAndShowCursor(false, gameObject);
ControlsBox.DisableObject(0.25f);
#endif
}
if (OnMenuStateChange != null)
{
OnMenuStateChange(menuOpen);
}
OnMenuDown.Invoke(menuOpen);
}
}
private void LateUpdate()
{
runAmount = Mathf.Lerp(runAmount, playerBody.velocity.magnitude / 7.1f, Time.deltaTime * 10f); //TODO: Fix these hard-coded number.
//Update the movementSpeed parameter in the animator
animator.SetFloat(movementSpeedHash, runAmount);
float RTPCValue = runAmount * 100f;
MovementSpeed.SetGlobalValue(RTPCValue);
}
// Only handle controls changing speed or velocity here
// If changing velocity, put it inside a variable and have
// FixedUpdate add that velocity on top of the current velocity
// and then have it reset that variable
void Update()
{
if (speedChange != 0 && !(movementSpeed + speedChange <= 0))
{
movementSpeed += speedChange * changeSpeedSpeed;
}
waterSpeed = movementSpeed;
speedOfWaterRTPC.SetGlobalValue(MetaballManager.waterSpeed);
}
void Update()
{
mood = (CalculateMood() <= 1f) ? CalculateMood() : 1f;
if (Input.GetKeyDown(KeyCode.Escape))
{
Application.Quit();
}
hpRTPC.SetGlobalValue(hp);
}
IEnumerator Regen()
{
Health.Post(this.gameObject);
StartCoroutine(AkHealthStatus());
while (true)
{
if (isAlive)
{
if (isRegenerating)
{
if (regenSpeed < 1f)
{
regenSpeed += Time.deltaTime / maxRegenerationSpeed;
}
if (HealthOfPlayer < 100f)
{
RegenerationLevel.SetGlobalValue(RegenerationCurve.Evaluate(regenSpeed) * 100f);
HealthOfPlayer += RegenerationCurve.Evaluate(regenSpeed);
}
else
{
RegenerationLevel.SetGlobalValue(0f);
}
}
else
{
regenerationCooldown += Time.deltaTime / timeBeforeRegen;
if (regenerationCooldown > 1f)
{
isRegenerating = true;
}
}
}
else
{
HealthOfPlayer = 100f;
}
yield return(null);
}
}
private void Start()
{
if (global)
{
RTPC.SetGlobalValue(value);
}
else
{
RTPC.SetValue(ObjectReference != null ? ObjectReference : gameObject, value);
}
}
private void Update()
{
//bkGndSatSldrValue = bkGndSatSldr.value;
if (bkGndSatSldrValue != bkGndSatSldr.value)
{
MGPV.RPC("UpdateSaturation", RpcTarget.AllBufferedViaServer, bkGndSatSldr.value);
}
masterLFO.SetGlobalValue(bkGndSatSldrValue * 100);
CreateShape();
UpdateMesh();
}
private void Update()
{
throttle = Movement.Throttle;
ThrusterVolume = 0;
for (int i = 0; i < 3; i++) //use the largest throttle value for the sound
{
throttle[i] = Mathf.Abs(throttle[i]);
if (ThrusterVolume < throttle[i])
{
ThrusterVolume = throttle[i];
}
}
// Debug.Log(ThrusterVolume);
ThrusterImpulseRTPC.SetGlobalValue(ThrusterVolume);
}
void FixedUpdate()
{
//Move the character
if ((rb.position.x >= PostWwiseEvent.mapRight) && (this.movement.x == 1))
{
this.movement.x = 0;
}
if ((rb.position.x <= PostWwiseEvent.mapLeft) && (this.movement.x == -1))
{
this.movement.x = 0;
}
if ((rb.position.y >= PostWwiseEvent.mapTop) && (this.movement.y == 1))
{
this.movement.y = 0;
}
if ((rb.position.y <= PostWwiseEvent.mapBottom) && (this.movement.y == -1))
{
this.movement.y = 0;
}
rb.MovePosition(rb.position + movement * speed * Time.fixedDeltaTime);
charXPos.SetGlobalValue(100 * (rb.position.x - PostWwiseEvent.mapLeft) / PostWwiseEvent.mapHorizontalDist);
}
IEnumerator DistanceToEnemies()
{
while (true)
{
float combatLevel = Enemies.Count;
if (!overrideEnemyRTPCs)
{
EvilHeadValue = EvilCrawlerValue = EvilSpitPlantValue = 1f;
if (Enemies.Count > 0)
{
Transform playerTransform = PlayerManager.Instance.playerTransform;
if (Enemies.Count > 2)
{
Enemies.Sort((Creature a, Creature b) => Vector3.SqrMagnitude(playerTransform.position - a.transform.position).CompareTo(Vector3.SqrMagnitude(playerTransform.position - b.transform.position)));
}
Creature closestEvilHead = Enemies.FirstOrDefault(x => x.AttackType == WeaponTypes.EvilHead);
Creature closestEvilSpitPlant = Enemies.FirstOrDefault(x => x.AttackType == WeaponTypes.EvilSpitPlant);
Creature closestEvilCrawler = Enemies.FirstOrDefault(x => x.AttackType == WeaponTypes.EvilCrawler);
EvilHeadValue = Mathf.Clamp01(closestEvilHead != null ? (Vector3.SqrMagnitude(closestEvilHead.transform.position - playerTransform.position) / (proximityThreshold * proximityThreshold)) : 1f);
EvilSpitPlantValue = Mathf.Clamp01(closestEvilSpitPlant != null ? (Vector3.SqrMagnitude(closestEvilSpitPlant.transform.position - playerTransform.position) / (proximityThreshold * proximityThreshold)) : 1f);
EvilCrawlerValue = Mathf.Clamp01(closestEvilCrawler != null ? (Vector3.SqrMagnitude(closestEvilCrawler.transform.position - playerTransform.position) / (proximityThreshold * proximityThreshold)) : 1f);
}
}
EvilHeadRTPC.SetGlobalValue(EvilHeadValue * 100f);
EvilCrawlerRTPC.SetGlobalValue(EvilCrawlerValue * 100f);
EvilSpitPlantRTPC.SetGlobalValue(EvilSpitPlantValue * 100f);
CombatLevelRTPC.SetGlobalValue(combatLevel);
yield return(new WaitForSeconds(0.1f));
}
}
// Update is called once per frame
void Update()
{
WaterSpeedRPTC.SetGlobalValue(MetaballManager.waterSpeed);
}
// Update is called once per frame.
void Update()
{
float distance = Vector3.Distance(OtherTransform.position, transform.position);
GameParameter.SetGlobalValue(distance);
}
private void Update()
{
timescale.SetGlobalValue(Time.timeScale);
}
// Update is called once per frame
void Update()
{
if (Input.GetKeyDown(KeyCode.J))
{
if (photonView.ViewID == myControl)
{
Color.RGBToHSV(head.color, out value, out ignore, out ignore);
headVal = value;
Color.RGBToHSV(torso.color, out value, out ignore, out ignore);
torsoVal = value;
Color.RGBToHSV(leftArm.color, out value, out ignore, out ignore);
armVal = value;
Color.RGBToHSV(leftLeg.color, out value, out ignore, out ignore);
legVal = value;
snap = true;
}
}
if (photonView.CreatorActorNr == GameController.actorNumber)
{
if ((Input.GetKeyUp("a")) || (Input.GetKeyUp("d")))
{
this.movement.x = 0;
}
if ((Input.GetKeyUp("w")) || (Input.GetKeyUp("s")))
{
this.movement.y = 0;
}
if (Input.GetKeyDown("a"))
{
if (rb.position.x >= PostWwiseEvent.mapLeft)
{
this.movement.x = -1;
}
else
{
this.movement.x = 0;
}
}
else if (Input.GetKeyDown("d"))
{
if (rb.position.x <= PostWwiseEvent.mapRight)
{
this.movement.x = 1;
}
}
if (Input.GetKeyDown("w"))
{
if (rb.position.y <= PostWwiseEvent.mapTop)
{
this.movement.y = 1;
}
}
else if (Input.GetKeyDown("s"))
{
if (rb.position.y >= PostWwiseEvent.mapBottom)
{
this.movement.y = -1;
}
}
Color.RGBToHSV(head.color, out value, out ignore, out ignore);
melodyHead.SetGlobalValue(value * 90);
Color.RGBToHSV(torso.color, out value, out ignore, out ignore);
melodyTorso.SetGlobalValue(value * 90);
Color.RGBToHSV(leftArm.color, out value, out ignore, out ignore);
melodyArms.SetGlobalValue(value * 90);
Color.RGBToHSV(leftLeg.color, out value, out ignore, out ignore);
melodyLegs.SetGlobalValue(value * 90);
}
if (photonView.ViewID == control)
{
Controls();
}
}
void Update()
{
#region Jump
if (PlayerInput.Gameplay.Jump.triggered && !IsJumping && Energy > EnergyLossCoefficient)
{
IsJumping = true;
AnimationController.SetTrigger("Fly");
AkSoundEngine.PostEvent("Pajaro_Aletea", gameObject);
}
if (PlayerInput.Gameplay.Horizontal.enabled)
{
FrameRotation.z = -PlayerInput.Gameplay.Horizontal.ReadValue <float>();
}
if (PlayerInput.Gameplay.Vertical.enabled)
{
if (GameManager.Instance.InvertedY)
{
FrameRotation.x = PlayerInput.Gameplay.Vertical.ReadValue <float>();
}
else
{
FrameRotation.x = -PlayerInput.Gameplay.Vertical.ReadValue <float>();
}
}
if (IsJumping)
{
JumpGravity = JumpSpeed * JumpCurve.Evaluate(JumpTimer);
JumpTimer = Mathf.Clamp01(JumpTimer += Time.deltaTime);
if (JumpTimer >= 0.9f)
{
IsJumping = false;
}
JumpEnergyLoss = JumpGravity / 2;
}
else
{
JumpTimer = 0;
JumpGravity = 0f;
JumpEnergyLoss = 1f;
}
#endregion
#region Rotation
if (OffLeftLimit)
{
FrameRotation.z -= OffLimitsRotationMultiplier * Time.deltaTime;
}
else if (OffRightLimit)
{
FrameRotation.z += OffLimitsRotationMultiplier * Time.deltaTime;
}
if (EndedLevel)
{
FrameRotation.x = -2;
}
Rotation.x += FrameRotation.x * RotationSpeed * Time.deltaTime;
Rotation.z += FrameRotation.z * RotationSpeed * Time.deltaTime;
Rotation.x = Mathf.Clamp(Rotation.x, MinRotation.x, MaxRotation.x);
Rotation.z = Mathf.Clamp(Rotation.z, MinRotation.z, MaxRotation.z);
if (Rotation.z >= MaxRotation.z && OffRightLimit)
{
PlayerInput.Gameplay.Horizontal.Enable();
//OffRightLimit = false;
}
else if (Rotation.z <= MinRotation.z && OffLeftLimit)
{
PlayerInput.Gameplay.Horizontal.Enable();
//OffLeftLimit = false;
}
DestRotation = Quaternion.Euler(Rotation.x, 0f, Rotation.z);
#endregion
#region MovementCalculations
if (Rotation.x < 4f && Energy > 0)
{
RotationCoefficient = DownRotationCoefficient;
if (Rotation.x > 0)
{
RotationCoefficient = MiddleRotationCoefficient;
}
AnimationController.SetBool("GoingDown", false);
}
else
{
RotationCoefficient = UpRotationCoefficient;
if (Rotation.x >= 4f)
{
AnimationController.SetBool("GoingDown", true);
}
else
{
AnimationController.SetBool("GoingDown", false);
}
}
SpeedMultiplier += (SpeedMultiplier * RotationCoefficient * Rotation.x) * Time.deltaTime;
SpeedMultiplier = Mathf.Clamp(SpeedMultiplier, MinSpeedMultiplier, MaxSpeedMultiplier);
Gravity = BaseGravity / SpeedMultiplier + JumpGravity;
#endregion
#region EnergyCalculation
Energy -= EnergyLossCoefficient * JumpEnergyLoss * Time.deltaTime;
Energy = Mathf.Clamp(Energy, 0, MaxEnergy);
EnergyFilter.color = new Vector4(0.1f, 0, 0, 0.9f - Energy / 100);
#endregion
#region LevelDistance
RaycastHit hit;
string layerHitted;
if (Physics.Raycast(transform.position, Vector3.forward, out hit, LevelRayDistance, LevelRaycastLayer))
{
layerHitted = LayerMask.LayerToName(hit.transform.gameObject.layer);
if (layerHitted == "Finish")
{
LevelDistanceLeft = hit.distance;
LevelDistancePorc = LevelDistanceLeft / LevelDistance;
}
}
#endregion
#region FOVModify
float speedPorc = Rigi.velocity.magnitude / MaxSpeed;
if (OnPlayerMovingAction != null)
{
OnPlayerMovingAction(speedPorc);
}
#endregion
#region Altitude
if (Physics.Raycast(transform.position, Vector3.down, out hit, LevelRayDistance, AltitudeRaycastLayer))
{
layerHitted = LayerMask.LayerToName(hit.transform.gameObject.layer);
if (layerHitted == "Floor")
{
PlayerAltitude = hit.distance;
AltitudePorc = PlayerAltitude / MaxAltitude;
}
}
#endregion
#region RTPC
EnergyRTPCParameter.SetGlobalValue(Energy / 100);
SpeedRTPCParameter.SetGlobalValue(speedPorc);
DistanceRTPCParameter.SetGlobalValue(LevelDistancePorc);
AltitudeRTPCParameter.SetGlobalValue(AltitudePorc);
#endregion
UpdateBlobShadowPosition();
}
public void SetValue(bool active)
{
RTPCToSet.SetGlobalValue(active ? OnValue : OffValue);
}
public void SetVolume(float volume)
{
//save change in SO and change volume in wwise
optionsVariables.volume = volume;
volumeRTPC.SetGlobalValue(volume);
}
void FixedUpdate()
{
_rigidbody.mass = 1f + Remaining() / 1000f;
FuelRTPC.SetGlobalValue(_fuelAmount);
}
// Update is called once per frame
void Update()
{
/*if (!characterFound)
* {
*
* }*/
if (!ShapeManager.deleteSqDone)
{
deleteDone = false;
}
else if (!ShapeManager.deleteCirDone)
{
deleteDone = false;
}
else
{
deleteDone = true;
}
if (deleteDone)
{
//Press J to play a note
PlayNote();
squareList = ShapeManager.squareList;
circleList = ShapeManager.circleList;
//triangleList = ShapeManager.triangleList;
//Shape distance from player affects different audio filters
for (int i = 0; i <= ShapeManager.sqIdx; i++)
{
percRTPCs[i].SetGlobalValue(posFactor * Vector3.Distance(Movement.playerPos.position, squareList[i].transform.position));
spriteRenderer = squareList[i].GetComponent <SpriteRenderer>();
Color.RGBToHSV(spriteRenderer.color, out hue, out saturation, out value);
percVolumes[i].SetGlobalValue(value * 100);
}
for (int i = 0; i <= ShapeManager.cirIdx; i++)
{
bkGndDelay[i].SetGlobalValue(posFactor * Vector3.Distance(Movement.playerPos.position, circleList[i].transform.position));
spriteRenderer = circleList[i].GetComponent <SpriteRenderer>();
Color.RGBToHSV(spriteRenderer.color, out hue, out saturation, out value);
bkGndBright[i].SetGlobalValue(value * 100);
}
playSpeed.SetGlobalValue(scootDistance * 50f);
if (!clockStart)
{
if (squareList.Count + circleList.Count > 0)
{
clockEvent.Post(gameObject, (uint)AkCallbackType.AK_MusicSyncUserCue, ClockCallback);
clockStart = true;
clockBeginning = true;
}
}
if (clockStart)
{
if (squareList.Count + circleList.Count <= 0)
{
stopClock.Post(gameObject, (uint)AkCallbackType.AK_MusicSyncUserCue, ClockCallback);
clockStart = false;
clockBeginning = false;
Debug.Log(clockStart);
}
}
//Only add in a new track if the loop is at the beginning
if (clockBeginning)
{
PlayPercInstrument(squareList, percSwitches, percPlaying);
PlayBackgrounds(circleList, bkGndSwitches, bkGndPlaying);
clockBeginning = false;
}
//Talks to shapemanager script to know if
if ((ShapeManager.deleteSqCalled) && (squareList.Count > 0))
{
ShapeManager.deleteSqDone = false;
ShapeManager.deleteSqCalled = false;
//percStopped = false;
int temp = ShapeManager.sqIdx;
aipv.RPC("StopPerc", RpcTarget.AllBufferedViaServer, temp);
//percCall = false;
ShapeManager.deleteSquare();
}
if ((ShapeManager.deleteCirCalled) && (circleList.Count > 0))
{
ShapeManager.deleteCirDone = false;
ShapeManager.deleteCirCalled = false;
//bkGndStopped = false;
int temp = ShapeManager.cirIdx;
aipv.RPC("StopBkGnd", RpcTarget.AllBufferedViaServer, temp);
ShapeManager.deleteCircle();
}
}
}
// Update is called once per frame
void Update()
{
AmountOfWater.SetGlobalValue(MetaballManager.GetMetaballs().Count);
}
public void UpdateRTPC()
{
float percentage = ((float)mainQuestProgress / (float)AmountOfQuests) * 100f;
QuestProgressRTPC.SetGlobalValue(percentage);
}
// Update is called once per frame
void Update()
{
// hide tutorial panel
if (Input.GetMouseButtonDown(0) && !gameStarted)
{
blurPanel.SetActive(false);
tutorialPanel.SetActive(false);
gameStarted = true;
return;
}
// if game finished or game not started
if (scoreAdded || !gameStarted)
{
return;
}
// colour indicator, highlights old goblin art when target and pointer overlap to tell you when to tap, not visible in game currently
if (pointer.GetComponent <BoxCollider2D>().IsTouching(target.GetComponent <BoxCollider2D>()) && targetScript.colourState != 0) // tap when the pointer is on the target
{
indicator.GetComponent <SpriteRenderer>().color = Color.green;
}
else
{
indicator.GetComponent <SpriteRenderer>().color = Color.white;
}
// scale score to 0-100 value for oven volume
float ovenVolume = (hits / targetScore) * 100.0f;
// oven sound based on score clamped 0-100
Oven_Minigame.SetGlobalValue(Mathf.Clamp(ovenVolume, 0, 100));
// if the game is not finished
if (!gameFailed && !gameWon)
{
// if the player has touched the screen
if (Input.GetMouseButtonDown(0))
{
if (pointer.GetComponent <BoxCollider2D>().IsTouching(target.GetComponent <BoxCollider2D>())) // tap when the pointer is on the target
{
// result of tap depends on current colour of target
// 1 and 5 orange, 2 and 4 yellow, 3 green, 0 red
if (targetScript.colourState == 1 || targetScript.colourState == 5)
{
// increase score
hits += scoreOnOrange;
// if over max score clamp it back
if (hits > targetScore)
{
hits = targetScore;
}
// update score displayed on UI
scoreText.text = "Score: " + hits;
// spawn breath prefab
Instantiate(breathParticles);
// play breath sound
hitSound.Post(gameObject);
}
else if (targetScript.colourState == 2 || targetScript.colourState == 4)
{
hits += scoreOnYellow;
if (hits > targetScore)
{
hits = targetScore;
}
scoreText.text = "Score: " + hits;
Instantiate(breathParticles);
hitSound.Post(gameObject);
}
else if (targetScript.colourState == 3)
{
hits += scoreOnGreen;
if (hits > targetScore)
{
hits = targetScore;
}
scoreText.text = "Score: " + hits;
Instantiate(breathParticles);
hitSound.Post(gameObject);
}
else if (targetScript.colourState == 0) // if bar is red then hitting it is a failure
{
gameFailed = true;
Instantiate(fartParticles);
fartSound.Post(gameObject);
}
}
else // if the player missed the target bar
{
gameFailed = true;
Instantiate(fartParticles);
fartSound.Post(gameObject);
}
}
}
// if the score is equal to or over the target score
if (hits >= targetScore)
{
// you win
rat.GetComponent <SpriteRenderer>().sprite = cookedRat; // change rat sprite to cooked version, not visible in final build
gameWon = true; // set game won
Victory();
}
if (gameFailed)
{
Failure();
}
}
