Skip to content

Instantly share code, notes, and snippets.

Embed
What would you like to do?
Selection of a few scripts from Golden Loft. All of these scripts were written solely by myself
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
public class ClawGameController : MonoBehaviour
{
public bool shouldResetForTesting = false;
public bool isEnabled = true, hasCompletedLesson = false;
public float timeToReturnToStart = 5f;
public GameObject FinalHandle;
public AudioClip[] audioLessons;
private AudioSource lessonPlayer;
public AudioSource AmbientMusicPlayer;
public AudioClip[] introAndLoop;
public TextMeshProTweenColor[] displayArrays;
public TextMeshProTweenColor[] glowingSlideBarArray;
public TextMeshProTweenColor[] afterwardsDisplayArray;
public ParticleSystem turnedOnSparks;
public Transform LightHolder;
public GameObject LightObjectToClone;
[Tooltip("Valid values are 2, 3, 5, 6, 10, or 15")]
public int numLights = 5;
public float timePerEachLight = .25f;
private MovingLight[] lightArray;
private float clockTimer = 0;
private GameObject rewardHandle;
private SelectableObject button;
private Claw_Slider handle;
private Animator clawAnimationController;
private bool handleHasMoved = false;
private Controller masterT;
//
//
//This block of code is called when the scene starts
//
//
void Start()
{
shouldResetForTesting = false;
masterT = FindObjectOfType<Controller>();
button = GetComponentInChildren<SelectableObject>();
button.OnInteract += LeverTriggered;
StartCoroutine(LateStart());
}
IEnumerator LateStart()
{
yield return new WaitForSeconds(0.2f);
lessonPlayer = GetComponent<AudioSource>();
rewardHandle = GetComponentInChildren<PickUppableObject>().gameObject;
handle = GetComponentInChildren<Claw_Slider>();
clawAnimationController = GetComponent<Animator>();
button.disableTemporarily(true);
lightArray = new MovingLight[numLights];
for (int i = 0; i < numLights; i++)
{
GameObject g = Instantiate(LightObjectToClone, LightHolder.localPosition, Quaternion.identity, LightHolder);
MovingLight ml = g.GetComponent<MovingLight>();
ml.SetDimensionsEachSide();
ml.SetIndex(i * 30 / numLights);
lightArray[i] = ml;
g.SetActive(false);
}
turnedOnSparks.Stop();
}
//
//
//This block of code manages turning the machine on and off
//
//
public void StartUpEngine()
{
isEnabled = true;
button.disableTemporarily(false);
masterT.SetLesson(audioLessons[0]);
handle.hasPlayedLesson = false;
handle.GetComponent<AudioSource>().enabled = true;
foreach (MovingLight ml in lightArray)
{
ml.gameObject.SetActive(true);
}
foreach (TextMeshProTweenColor tmp in displayArrays)
{
tmp.gameObject.SetActive(true);
tmp.FadeIn();
}
AmbientMusicPlayer.clip = introAndLoop[0];
AmbientMusicPlayer.Play();
turnedOnSparks.Play();
}
public void ShutDownEngine()
{
//uncomment this code if you want the player to be able to replay lesson very easily
//handle.hasPlayedLesson = false;
//handle.GetComponent<AudioSource>().enabled = true;
foreach (MovingLight ml in lightArray)
{
ml.gameObject.SetActive(false);
}
foreach (TextMeshProTweenColor tmp in displayArrays)
{
tmp.FadeOut();
}
foreach (TextMeshProTweenColor tmp in glowingSlideBarArray)
{
tmp.FadeOut();
}
isEnabled = false;
hasCompletedLesson = true;
StartCoroutine(MusicFade());
}
//Fades the music over time
IEnumerator MusicFade()
{
float startTime = 0;
float currentVolume = AmbientMusicPlayer.volume;
while (startTime < 3)
{
yield return null;
startTime += Time.deltaTime;
AmbientMusicPlayer.volume = Mathf.Lerp(currentVolume, 0, startTime / 3);
}
AmbientMusicPlayer.Stop();
foreach (TextMeshProTweenColor tmp in afterwardsDisplayArray)
{
tmp.FadeIn();
}
turnedOnSparks.Stop();
masterT.incrementMainPathCompleted();
}
//
//
//This block of code manages how the lights move around
//
//
private void Update()
{
if (shouldResetForTesting)
{
shouldResetForTesting = false;
StartUpEngine();
}
if (isEnabled)
{
if (clockTimer >= timePerEachLight)
{
clockTimer = 0;
foreach (MovingLight ml in lightArray)
{
ml.IncrementIndex();
}
}
else
{
clockTimer += Time.deltaTime;
}
if (!AmbientMusicPlayer.isPlaying)
{
AmbientMusicPlayer.clip = introAndLoop[1];
AmbientMusicPlayer.Play();
}
}
}
//
//
//Scripts below here are called when the button is pushed
//
//
public void LeverTriggered(Controller t)
{
if(!t.isPlayingMainPathLesson() && isEnabled)
{
button.disableTemporarily(true);
button.GetComponent<AudioSource>().Play();
//
//If the value is correct, do the animation where the handle comes with
//
if (isEnabled && !masterT.isPlayingMainPathLesson())
{
if ((handle.value > 34 - 0.1 && handle.value < 34 + .1) && !handleHasMoved)
{
clawAnimationController.SetBool("CorrectValue", true);
StartCoroutine(WaitThenReturn(true));
//if the correct value has been inputted, don't play that animation again
handleHasMoved = true;
}
else
{
clawAnimationController.SetBool("CompleteMiss", true);
StartCoroutine(WaitThenReturn(false));
}
}
else
{
StartCoroutine(ButtonDownAndUp());
}
}
}
IEnumerator ButtonDownAndUp()
{
//Make the button go down then back up
Vector3 startPos = button.transform.localPosition;
Vector3 tempPos = startPos;
tempPos.y = 3.36f;
float timeSinceStart = 0;
float timeToDepress = 0.25f;
while (timeSinceStart < timeToDepress)
{
yield return null;
timeSinceStart += Time.deltaTime;
button.transform.localPosition = Vector3.Lerp(startPos, tempPos, timeSinceStart / timeToDepress);
}
timeSinceStart = 0;
while (timeSinceStart < timeToDepress)
{
yield return null;
timeSinceStart += Time.deltaTime;
button.transform.localPosition = Vector3.Lerp(tempPos, startPos, timeSinceStart / timeToDepress);
}
button.disableTemporarily(false);
}
IEnumerator WaitThenReturn(bool isCorrectValue)
{
Vector3 tempPos;
if (isCorrectValue)
{
masterT.SetLesson(audioLessons[2]);
}
rewardHandle.transform.parent.GetComponent<Animator>().enabled = false;
yield return StartCoroutine(ButtonDownAndUp());
button.disableTemporarily(true);
//
//Wait for the grabbing animation to be done
//
yield return new WaitForSeconds(1f);
while (clawAnimationController.GetCurrentAnimatorStateInfo(0).normalizedTime < 1 && !clawAnimationController.GetCurrentAnimatorStateInfo(0).IsName("Default"))
{
yield return null;
}
//
//Automatically push the handle back towards the starting position
//If you have the correct value, also pull the CabinetHandle back
//
Vector3 velocity = new Vector3((handle.defaultValue - handle.rightistValue) / 4, 0, 0);
while (handle.transform.localPosition.x > handle.defaultValue + .1f || handle.transform.localPosition.x < handle.defaultValue - .1f)
{
yield return null;
if (handle.transform.localPosition.x > handle.defaultValue)
{
handle.transform.localPosition -= velocity * Time.deltaTime;
if (isCorrectValue)
{
rewardHandle.transform.parent.transform.localPosition -= velocity * Time.deltaTime;
}
}
else if (handle.transform.localPosition.x < handle.defaultValue)
{
handle.transform.localPosition += velocity * Time.deltaTime;
if (isCorrectValue)
{
rewardHandle.transform.parent.transform.localPosition += velocity * Time.deltaTime;
}
}
}
handle.transform.localPosition = handle.startingPosition;
tempPos = rewardHandle.transform.localPosition;
yield return new WaitForSeconds(1f);
//Reset
clawAnimationController.SetBool("CompleteMiss", false);
clawAnimationController.SetBool("CorrectValue", false);
rewardHandle.transform.localPosition = tempPos;
while (handle.transform.GetChild(0).GetChild(0).GetComponent<MeshRenderer>().enabled)
{
yield return null;
}
//
//If correct value, make the handle fall (Animation Controlled)
//
if (isCorrectValue)
{
rewardHandle.transform.parent.GetComponent<Animator>().enabled = true;
rewardHandle.transform.parent.GetComponent<Animator>().SetBool("IsTimeToFall", true);
clawAnimationController.enabled = false;
ShutDownEngine();
}
button.disableTemporarily(false);
}
public void SetFinished()
{
handle.hasPlayedLesson = true;
handle.GetComponent<AudioSource>().enabled = false;
masterT.SetLesson(null);
AmbientMusicPlayer.Stop();
FinalHandle.SetActive(true);
foreach (MovingLight ml in lightArray)
{
ml.gameObject.SetActive(false);
}
foreach (TextMeshProTweenColor tmp in displayArrays)
{
tmp.FadeOut();
}
foreach (TextMeshProTweenColor tmp in glowingSlideBarArray)
{
tmp.FadeOut();
}
isEnabled = false;
hasCompletedLesson = true;
foreach (TextMeshProTweenColor tmp in afterwardsDisplayArray)
{
tmp.FadeIn();
}
turnedOnSparks.Stop();
}
}
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using TMPro;
public class Claw_Slider : InteractableHolder
{
public float OverallLengthForSlider = 55f;
public float speed = 1f;
//0 <= value <= 55
public float value = 0;
private float oldValue = 0;
public float timeToFinishSlide = .25f;
public float lockTime = 0.25f;
public int correctValue = 5;
public TMP_FontAsset CorrectValueMaterial;
private TMP_FontAsset DefaultMaterial;
public Transform bigOverSmall;
public TextMeshPro EqualSign;
public TextMeshPro answers;
public Transform overallOverBig;
public Transform[] leftBars;
public Transform[] rightBars;
public TextMeshProTweenColor helperText;
[HideInInspector] public float leftistValue;
[HideInInspector] public float rightistValue;
[HideInInspector] public float defaultValue;
[HideInInspector] public Vector3 startingPosition;
private float lengthPerSegment;
private ClawGameController masterController;
private Controller masterT;
private float initZ;
private float startFinishTime = 0;
private float currentLockTime = 0;
private float targetAngleToFinish;
private float tempValue;
private bool canPlaySFX = false, isLocked = false, canUpdate = false, canFadeHelperText = false;
private ShmancyLock parentLock;
private AudioSource SFX;
void Start()
{
StartCoroutine(LateStart());
}
IEnumerator LateStart()
{
yield return new WaitForSeconds(0.075f);
tempValue = value;
intensity = 0f;
initZ = transform.localPosition.x;
currentRenderer = GetComponent<Renderer>();
parentLock = GetComponentInParent<ShmancyLock>();
SFX = GetComponent<AudioSource>();
masterController = transform.parent.GetComponent<ClawGameController>();
startingPosition = transform.localPosition;
DefaultMaterial = EqualSign.font;
leftistValue = 62.26f;
rightistValue = -52.37f;
defaultValue = 49.68982f;
startingPosition.x = defaultValue;
transform.localPosition = startingPosition;
masterT = FindObjectOfType<Controller>();
lengthPerSegment = (leftistValue - rightistValue) / OverallLengthForSlider;
UpdateValues();
yield return StartCoroutine(Adjustment());
canUpdate = true;
}
override protected void Update()
{
if (canUpdate)
{
base.Update();
if (masterController.isEnabled)
{
if (!isLocked)
{
//Change the position based on intensity
Vector3 newLocation = transform.localPosition;
newLocation += new Vector3(speed * intensity * Time.deltaTime, 0, 0);
newLocation.x = Mathf.Clamp(newLocation.x, rightistValue, leftistValue);
transform.localPosition = newLocation;
float relativeChange = Mathf.Abs((initZ - transform.localPosition.x));
valChanged(relativeChange);
//
//Check to see if the handle should lock a little
//
if (value > 33.8f && oldValue < 33.8f ||
value < 34.2f && oldValue > 34.2f)
{
isLocked = true;
value = 34;
oldValue = 34;
//given a value of 34, calculate the correct position
float precisePercent = Mathf.InverseLerp(0, 55, value);
float precisePosition = Mathf.Lerp(leftistValue, rightistValue, precisePercent);
transform.localPosition = new Vector3(precisePosition, transform.localPosition.y, transform.localPosition.z);
}
if (isLocked)
{
currentLockTime = lockTime;
}
}
//
//Whether locked or not
//
if (currentLockTime <= 0f)
{
isLocked = false;
}
else
{
currentLockTime -= Time.deltaTime;
}
UpdateValues();
}
//
//If the machine is disabled, make helper text appear and disappear
//
else if (!masterController.hasCompletedLesson)
{
if (intensity != 0 && !canFadeHelperText)
{
canFadeHelperText = true;
helperText.FadeIn();
}
else if (intensity == 0 && canFadeHelperText)
{
canFadeHelperText = false;
helperText.FadeOut();
}
}
}
}
public void UpdateValues()
{
//total width is "55"
//current position divided by length of one segment is value
//total minus value is other segment
value = Mathf.Abs((transform.localPosition.x - leftistValue) / lengthPerSegment);
//update the displays
bigOverSmall.GetChild(0).GetComponent<TextMeshPro>().text = FormatNumber(value, 3);
bigOverSmall.GetChild(1).GetComponent<TextMeshPro>().text = FormatNumber(OverallLengthForSlider - value, 3);
overallOverBig.GetChild(0).GetComponent<TextMeshPro>().text = FormatNumber(OverallLengthForSlider, 3);
overallOverBig.GetChild(1).GetComponent<TextMeshPro>().text = FormatNumber(value, 3);
answers.text = "\t " + FormatNumber(value / (OverallLengthForSlider - value), 4) + "\t\t\t " + FormatNumber(OverallLengthForSlider / value, 4);
//Update the length of the colorful bars
//.915 is max length for displaybars
foreach (Transform t in leftBars)
{
t.localScale = new Vector3(0.915f * value / OverallLengthForSlider, .215f, 1);
}
foreach (Transform t in rightBars)
{
t.localScale = new Vector3(0.915f * (OverallLengthForSlider - value) / OverallLengthForSlider, .215f, 1);
}
//update oldvalue
if (Mathf.Abs(value - oldValue) > 0.05f)
{
oldValue = value;
}
//check to see if you should update the color of the equals sign
if (value > 34 - 0.001f && value < 34 + 0.001f)
{
EqualSign.font = CorrectValueMaterial;
EqualSign.color = Color.red;
}
else
{
EqualSign.font = DefaultMaterial;
EqualSign.color = Color.black;
}
}
//Truncates the numberToFormat to be a constanst number of digits
public string FormatNumber(float numberToFormat, int numPlaces)
{
//Return NaN when the number is effectively infinite
if (numberToFormat >= 1000000)
{
return "NaN";
}
float f = numberToFormat;
string formatText = "";
//If the number is more than 1000, transition to k -> 1.12k
if (f >= 1000)
{
return FormatNumber(f / 1000, numPlaces - 1) + "k";
}
else if (f > (34.0f / 21.0) - 0.001f && f < (34.0f / 21.0) + 0.001f)
{
return "1.618";
}
while (formatText.Length < numPlaces)
{
formatText += "0";
}
int decimalIndex = 0;
//Determine where the decimal should go
do
{
decimalIndex++;
f /= 10;
} while (f >= 1 - 0.001f);
formatText = formatText.Insert(decimalIndex, ".");
//return the formatted number
return numberToFormat.ToString(formatText);
}
public override void StartInteraction()
{
currentRenderer.material = MaterialHighlight;
SetHolding(true);
if (masterController.isEnabled && !hasPlayedLesson && lessonOnFirstGrab)
{
FindObjectOfType<Controller>().AddToAudioQueue(lessonOnFirstGrab);
hasPlayedLesson = true;
StartCoroutine(FadeInCorrectTime(masterController.glowingSlideBarArray));
}
}
IEnumerator FadeInCorrectTime(TextMeshProTweenColor[] arrayOfBars)
{
yield return new WaitForSeconds(.2f);
while(masterT.GetCurrentClip() != lessonOnFirstGrab)
{
yield return null;
}
//
//Equation Values are expected to be Numerator, Denominator, Quotient
//
float timeSinceStart = 0;
int childIndex = 0;
//ChildIndex 0 and 1 are the numbers, 2 is the answer number
float currentChildDrawTime = arrayOfBars[childIndex].drawTime;
float currentChildFadeInPoint = arrayOfBars[childIndex].timeToBeCompletelyVisible;
while (masterT.isPlayingMainPathLesson())
{
timeSinceStart += Time.deltaTime;
yield return null;
//If it is time to fade in the next object(s)
if (timeSinceStart > currentChildFadeInPoint - currentChildDrawTime)
{
arrayOfBars[childIndex].FadeIn();
childIndex++;
if (childIndex >= arrayOfBars.Length)
{
yield break;
}
currentChildDrawTime = arrayOfBars[childIndex].drawTime;
currentChildFadeInPoint = arrayOfBars[childIndex].timeToBeCompletelyVisible;
}
}
}
override public void EndInteraction()
{
base.EndInteraction();
intensity = 0;
//Adjust to closest whole value
if (masterController.isEnabled)
{
StartCoroutine(Adjustment());
}
}
//Moves the slider to the closest number
public IEnumerator Adjustment()
{
//Calculate needed position with goal value
//lerp between current pos and that pos over a certain amount of time
//Round the currentvalue to the nearest 0.1f
float goalValue = Mathf.Round(value);
Vector3 startPosition = transform.localPosition;
Vector3 goalPosition = startPosition;
goalPosition.x = leftistValue - (goalValue * lengthPerSegment);
float timeSinceStart = 0f;
while (timeSinceStart < timeToFinishSlide)
{
yield return null;
transform.localPosition = Vector3.Lerp(startPosition, goalPosition, timeSinceStart / timeToFinishSlide);
timeSinceStart += Time.deltaTime;
UpdateValues();
}
transform.localPosition = goalPosition;
UpdateValues();
}
}
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
public class HandleDropAnimationController : MonoBehaviour
{
public Animator dropclaw;
public AudioClip soundOnHit;
public PickUppableObject secretChildHandle;
private AudioSource SFXMaker;
// Start is called before the first frame update
void Start()
{
SFXMaker = GetComponent<AudioSource>();
}
public void StartSound()
{
SFXMaker.clip = soundOnHit;
SFXMaker.Play();
}
public void DoneSliding()
{
Vector3 tempPos = transform.GetChild(0).localPosition;
dropclaw.enabled = true;
transform.GetChild(0).gameObject.SetActive(false);
secretChildHandle.gameObject.SetActive(true);
secretChildHandle.disableTemporarily(false);
}
}
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
public class MovingLight : MonoBehaviour
{
public int index = 0;
private Vector3[] startDimensionsEachSide;
public void IncrementIndex()
{
index++;
if(index >= 30)
{
index -= 30;
}
UpdatePosition();
}
public void SetIndex(int newLocation)
{
index = newLocation;
UpdatePosition();
}
public void SetDimensionsEachSide()
{
startDimensionsEachSide = new Vector3[3];
startDimensionsEachSide[0] = new Vector3(76.23f, 80.34f, -31.771f);
startDimensionsEachSide[1] = new Vector3(71.86f, 80.34f, 26.93f);
startDimensionsEachSide[2] = new Vector3(-66.999f, 80.34f, 22.229f);
}
public void UpdatePosition()
{
Vector3 directionToMove;
if(index < 7)
{
directionToMove = new Vector3(0, 0, 9 * index);
transform.localRotation = Quaternion.Euler(0, 0, 0);
transform.localPosition = startDimensionsEachSide[0] + directionToMove;
}
else if(index < 23)
{
directionToMove = new Vector3(-9 * (index-7), 0, 0);
transform.localRotation = Quaternion.Euler(0, 270, 0);
transform.localPosition = startDimensionsEachSide[1] + directionToMove;
}
else
{
directionToMove = new Vector3(0, 0, -9 * (index-23));
transform.localRotation = Quaternion.Euler(0, 180, 0);
transform.localPosition = startDimensionsEachSide[2] + directionToMove;
}
}
}
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
public class PickUppableObject : BringObjectClose
{
public float timeToFadeIn = 1f;
public GameObject ObjectToClone;
public Vector3 positionInHand;
public Vector3 customRotationForKeys;
public GameObject ExtraObjectToHighlight;
public LockedObject thisKeyGoesToThisLock;
private Renderer extraObjectToRender;
public GameObject enabledObjectOnPickup;
private GameObject ClonedObject;
private Transform handPosition;
private bool canChangeOverlay = true;
private int overlayIndex = 0;
private float startFadeTime = 0;
private Controller theController;
private AudioSource minorLessonPlayer;
private int numKids;
private bool hasPlayedOneShotYet = false;
override protected void Start()
{
base.Start();
if (ExtraObjectToHighlight)
extraObjectToRender = ExtraObjectToHighlight.GetComponent<Renderer>();
OnInteract += Clone;
StartCoroutine(LateStart());
}
IEnumerator LateStart()
{
yield return new WaitForSeconds(.15f);
//Keys should be empty
if (!ObjectToClone)
{
ObjectToClone = this.gameObject;
}
//Keys in hand get disabled
else if (ObjectToClone.Equals(gameObject))
{
isDisabled = true;
}
//Other Pickups
else
{
ObjectToClone.SetActive(false);
}
numKids = ObjectToClone.transform.childCount;
minorLessonPlayer = FindObjectOfType<MinorObjectLessonPlayer>().gameObject.GetComponent<AudioSource>();
}
//
//Highlight manager
//
override protected void Update()
{
base.Update();
if (!isDisabled)
{
if (highlightOn && ExtraObjectToHighlight)
{
if(extraObjectToRender.sharedMaterial != MaterialHighlight)
{
extraObjectToRender.material = MaterialHighlight;
}
}
else if (ExtraObjectToHighlight)
{
if(extraObjectToRender.sharedMaterial != MaterialDefault)
{
extraObjectToRender.material = MaterialDefault;
}
}
highlightOn = false;
}
}
//
//
//Code that Runs on interaction
//
//
private void Clone(Controller t)
{
//if you don't have a hand position
//or
//active hand is not the same as hand position
//set hand position to the right look for remote
if (!handPosition ||
t.leftHandRemoteTracker.thisHandIsActive && handPosition.gameObject != t.leftHandRemoteTracker.gameObject ||
t.rightHandRemoteTracker.thisHandIsActive && handPosition.gameObject != t.rightHandRemoteTracker.gameObject)
{
if (t.leftHandRemoteTracker.thisHandIsActive)
{
handPosition = t.leftHandRemoteTracker.transform;
}
else if (t.rightHandRemoteTracker.thisHandIsActive)
{
handPosition = t.rightHandRemoteTracker.transform;
}
else
{
handPosition = t.NoHandDesloc.transform.GetComponentInChildren<LookForRemote>().transform;
}
}
//This is for the basic Image Pickup
if (this.gameObject.transform.childCount > 0)
{
ObjectToClone.SetActive(true);
GetComponent<AudioSource>().Play();
ObjectToClone.transform.SetParent(handPosition);
ObjectToClone.transform.localEulerAngles = new Vector3(0, 90, 60);
ObjectToClone.transform.localPosition = positionInHand;
if (lessonOnPickup && !gameObject.CompareTag("Shell"))
{
minorLessonPlayer.Stop();
minorLessonPlayer.clip = lessonOnPickup;
minorLessonPlayer.Play();
}
//Basic Image With Overlays
if (ObjectToClone.transform.childCount > 0)
{
overlayIndex = 0;
StopCoroutine(OverlayFadeMaster(t));
StartCoroutine(OverlayFadeMaster(t));
}
}
//Pick up for keys
else
{
disableTemporarily(true);
isDisabled = true;
currentRenderer.material = MaterialDisabled;
ObjectToClone = this.gameObject;
GameObject temp = Instantiate(ObjectToClone, handPosition.position, Quaternion.identity, handPosition);
temp.transform.localEulerAngles = customRotationForKeys;
temp.transform.localPosition = positionInHand;
MeshCollider clonedMeshCollider = temp.GetComponent<MeshCollider>();
BoxCollider clonedBoxCollider = temp.GetComponent<BoxCollider>();
if (clonedMeshCollider)
{
clonedMeshCollider.enabled = false;
}
else if (clonedBoxCollider)
{
clonedBoxCollider.enabled = false;
}
temp.GetComponent<Renderer>().material = MaterialDisabled;
ClonedObject = temp;
theController = t;
if (thisKeyGoesToThisLock)
{
thisKeyGoesToThisLock.disableTemporarily(false);
}
if (lessonOnPickup)
{
masterT.AddToAudioQueue(lessonOnPickup);
}
}
this.gameObject.GetComponent<MeshRenderer>().enabled = false;
//
//Extra behavior for weird cornercases
//
if (this.gameObject.CompareTag("PickUpBasic"))
{
}
else if (this.gameObject.CompareTag("Shell"))
{
if(overlayIndex == 0)
{
t.SetLesson(lessonOnPickup);
overlayIndex++;
}
//Make orbs appear
if(t.numAtticMainPathCompleted < 11)
{
t.incrementMainPathCompleted();
}
enabledObjectOnPickup.SetActive(true);
if(!hasPlayedOneShotYet)
{
hasPlayedOneShotYet = true;
minorLessonPlayer.GetComponent<MinorObjectLessonPlayer>().canUpdate = true;
}
}
else
{
if (gameObject.transform.localScale.x > 10)
{
ClonedObject.transform.localScale = new Vector3(0.9114001f, 0.9114001f, 0.9114001f);
}
else if (gameObject.transform.localScale.x > 1.001 && gameObject.transform.localScale.x < 1.05f)
{
ClonedObject.transform.localScale = new Vector3(0.01f, 0.01f, 0.01f);
}
ClonedObject.SetActive(true);
ClonedObject.GetComponent<PickUppableObject>().isDisabled = true;
}
}
//
//Pickup Items with overlays
//
IEnumerator OverlayFadeMaster(Controller t)
{
float startTime = 0f;
ObjectToClone.transform.GetChild(0).gameObject.SetActive(true);
TextMeshProTweenColor child = ObjectToClone.transform.GetChild(overlayIndex).GetComponent<TextMeshProTweenColor>();
while (startTime < minorLessonPlayer.clip.length && minorLessonPlayer.clip == lessonOnPickup)
{
startTime += Time.deltaTime;
yield return null;
if (overlayIndex < numKids && startTime >= child.timeToBeCompletelyVisible - child.drawTime)
{
if (overlayIndex > 0)
{
ObjectToClone.transform.GetChild(overlayIndex - 1).GetComponent<TextMeshProTweenColor>().FadeOut();
}
child.FadeIn();
overlayIndex++;
if (overlayIndex < numKids)
{
ObjectToClone.transform.GetChild(overlayIndex).gameObject.SetActive(true);
child = ObjectToClone.transform.GetChild(overlayIndex).GetComponent<TextMeshProTweenColor>();
}
}
}
foreach (Transform trans in ObjectToClone.transform)
{
trans.GetComponent<TextMeshProTweenColor>().FadeOut();
}
yield return new WaitForSeconds(child.drawTime);
disableTemporarily(false);
}
//
//
//When the player tries to put the item down
//
//
override public void StopHolding(Controller t)
{
base.StopHolding(t);
//Basic Image Putdown
if (this.gameObject.CompareTag("PickUpBasic"))
{
StopAllCoroutines();
if (ObjectToClone.transform.childCount > 0)
{
overlayIndex = 0;
foreach(Transform trans in ObjectToClone.transform)
{
trans.GetComponent<TextMeshProTweenColor>().SetZero();
}
}
ObjectToClone.SetActive(false);
ObjectToClone.transform.SetParent(this.gameObject.transform);
this.gameObject.GetComponent<MeshRenderer>().enabled = true;
minorLessonPlayer.Stop();
if (lessonOnPutDown)
{
minorLessonPlayer.clip = lessonOnPutDown;
minorLessonPlayer.Play();
}
}
else if (this.gameObject.CompareTag("Shell"))
{
StopAllCoroutines();
ObjectToClone.SetActive(false);
ObjectToClone.transform.SetParent(this.gameObject.transform);
this.gameObject.GetComponent<MeshRenderer>().enabled = true;
theController = t;
//Make orbs disappear
//enabledObjectOnPickup.SetActive(false);
}
//Stop Holding Keys
else
{
t.SetLesson(null);
Destroy(ClonedObject);
disableTemporarily(false);
if (thisKeyGoesToThisLock)
{
thisKeyGoesToThisLock.disableTemporarily(true);
}
this.gameObject.GetComponent<MeshRenderer>().enabled = true;
theController.SetLesson(null);
}
}
//Special edge case scenario
override public void StopHoldingNoBack()
{
base.StopHoldingNoBack();
theController.SetPickedObject(null);
theController.incrementMainPathCompleted();
Destroy(ClonedObject);
}
public void SetFinished(int shouldPlaySoundAtIndex)
{
theController = FindObjectOfType<Controller>();
this.gameObject.GetComponent<MeshRenderer>().enabled = false;
if(theController.numAtticMainPathCompleted == shouldPlaySoundAtIndex)
{
thisKeyGoesToThisLock.Unlock(theController);
theController.SetLesson(lessonOnPutDown);
}
else
{
thisKeyGoesToThisLock.Unlock(null);
}
this.gameObject.SetActive(false);
}
}
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment
You can’t perform that action at this time.