IEnumerator LoadRoomIntern(DoorTrigger destination)
{
Debug.Log("loading new room");
player2D.LockMovement();
blackOverlay.CrossFadeAlpha(1, .5f, false);
yield return(new WaitForSeconds(.5f));
LoadRoom(destination.room);
foreach (Transform childTransform in activeRoom.transform)
{
DoorTrigger childDoorComponent = childTransform.gameObject.GetComponent <DoorTrigger>();
if (childDoorComponent != null && destination.name == childDoorComponent.name)
{
childDoorComponent.isEntering = true;
childDoorComponent.OpenDoor();
}
}
player.transform.position = destination.gameObject.transform.position;
Debug.Log("new player position: " + destination.gameObject.transform.position);
UpdateCamera(destination.gameObject.transform);
blackOverlay.CrossFadeAlpha(0, .5f, false);
yield return(new WaitForSeconds(.5f));
player2D.UnlockMovement();
}
public override void ExitLevel(DoorTrigger door)
{
if (rogue)
{
rogue.SetActive(false);
}
}
// Use this for initialization
void Start()
{
if (PullSpeed == 0f)
{
PullSpeed = 18.0f;
}
IsPulling = false;
if (Door == null)
{
Door = transform.root.gameObject;
DoorTrigger = Door.GetComponent <DoorTrigger>();
}
if (TargetPointBehindDoor == null)
{
TargetPointBehindDoor = transform.Find("TargetPointBehindDoor").gameObject;
}
TargetPosBehindDoor = TargetPointBehindDoor.transform.position;
if (DoorTrigger.DoorType == "Exit")
{
IsExit = true;
}
}
bool CheckTriggers()
{
bool state = false;
SphereCollider collider = GetComponent <SphereCollider>();
GameObject[] magicObjects = GameObject.FindGameObjectsWithTag("MagicObject");
foreach (GameObject obj in magicObjects)
{
if (collider.bounds.Contains(obj.transform.position))
{
if (sigils.Contains(Sigil.Fire))
{
FlameObject flameScript = obj.GetComponent <FlameObject>();
if (flameScript != null && flameScript.IsLit == false)
{
flameScript.IsLit = true;
state = true;
}
}
if (sigils.Contains(Sigil.Earth))
{
DoorTrigger doorScript = obj.GetComponent <DoorTrigger>();
if (doorScript != null)
{
doorScript.Trigger();
}
}
}
}
return(state);
}
void Start()
{
app = AppController.instance;
if (moveCam == jumpToCam)
{
DebugConsole.LogError("You can't jump to and move a cam at the same time.");
}
box_X = (Screen.width / 2) - (width / 2);
box_Y = (Screen.height / 2) - (height / 2); //+ boxHeightOffset;
button_X = (width / 2) - (buttonWidth / 2);
//button_Y = box_Y - buttonHeight - 5;
infoWindow = new Rect(box_X, box_Y, width, height);
allInfos = GameObject.FindObjectsOfType <Information>();
doorTrigger = gameObject.GetComponent <DoorTrigger> ();
if (null != XRayMenuObject)
{
xRayMenu = XRayMenuObject.GetComponent <XRayMachineMenu> ();
}
}
void Start()
{
doorTrigger = transform.Find("OpenDoorTrigger").gameObject;
DoorTrigger trigger = doorTrigger.GetComponent <DoorTrigger>();
trigger.doorRef = this;
}
void Awake()
{
codeButtons = GameObject.Find("Code Buttons");
doorTrigger = FindObjectOfType <DoorTrigger>();
teleporter = GameObject.Find("Teleporter");
teleporter.SetActive(false);
}
public override void ExitLevel(DoorTrigger door)
{
if (flameLord)
{
flameLord.SetActive(false);
}
}
/// Cross-matrix now! uses world positions
private void InteractDoor(Vector3Int currentPos, Vector3Int targetPos)
{
// Make sure there is a door controller
DoorTrigger door = MatrixManager.Instance.GetFirst <DoorTrigger>(targetPos);
if (!door)
{
door = MatrixManager.Instance.GetFirst <DoorTrigger>(Vector3Int.RoundToInt(currentPos));
if (door)
{
RegisterDoor registerDoor = door.GetComponent <RegisterDoor>();
Vector3Int localPos = MatrixManager.Instance.WorldToLocalInt(targetPos, matrix);
if (registerDoor.IsPassable(localPos))
{
door = null;
}
}
}
// Attempt to open door
if (door != null && allowInput)
{
door.Interact(gameObject, TransformState.HiddenPos);
}
}
public bool AnyEmptyFields()
{
DoorTrigger doortrigger = target as DoorTrigger;
if (doortrigger.HasName && doortrigger.playerName == "")
{
return(true);
}
else if (doortrigger.IsLookingAt && doortrigger.lookObject == null)
{
return(true);
}
else if (doortrigger.HasPressed && doortrigger.character == "")
{
return(true);
}
else if (doortrigger.HasScript && doortrigger.script.script.Name == "")
{
return(true);
}
else if (doortrigger.IsGameObject && doortrigger.isObject == null)
{
return(true);
}
else
{
return(false);
}
}
public override void ExitLevel(DoorTrigger door)
{
if (door == doorTo12)
{
levelPassed = true;
LevelManager.Instance.SetLevelPassed(levelPassed, ID);
}
}
public override void ExitLevel(DoorTrigger door)
{
if (door == doorTo6)
{
levelPassed = true;
SentImportantObjectsPositionsToLevelManager();
LevelManager.Instance.SetLevelPassed(levelPassed, ID);
}
}
private void OnTriggerStay2D(Collider2D other)
{
// Picking Item
// Debug.Log("the Name is: " + other.name);
m_TargetItem = other.gameObject.GetComponent <Item>();
// Door Trigger
m_DoorTrigger = other.gameObject.GetComponent <DoorTrigger>();
}
public virtual void EnterLevel(DoorTrigger door)
{
if (levelPassed)
{
EnterPassedLevel();
}
else
{
EnterNotPassedLevel();
}
}
/// <summary>
/// Interact with a door at the specified position if there is a closed door there.
/// </summary>
/// <param name="currentPos">current world position </param>
/// <param name="targetPos">position to interact with</param>
private void InteractDoor(Vector3Int currentPos, Vector3Int targetPos)
{
// Make sure there is a door which can be interacted with
DoorTrigger door = MatrixManager.GetClosedDoorAt(currentPos, targetPos);
// Attempt to open door
if (door != null)
{
door.Interact(gameObject, TransformState.HiddenPos);
}
}
public void OnRiddleRequest(DoorTrigger doorTrigger)
{
if (this._riddleCurrentlyRunning)
{
return;
}
this._currentDoor = doorTrigger;
StartRiddle();
this._gooCam.enabled = true;
}
void Start()
{
doorTrigger = GetComponent <Cupboards.DoorTrigger>();
lockLight = transform.GetComponentInChildren <LockLightController>();
items = transform.FindChild("Items").gameObject;
if (PhotonNetwork.connectedAndReady)
{
//Has been instantiated at runtime and you received instantiate of this object from photon on room join
StartSync();
}
}
public override void ExitLevel(DoorTrigger door)
{
if (door == doorTo3)
{
levelPassed = true;
LevelManager.Instance.SetLevelPassed(levelPassed, ID);
}
if (BBEG)
{
BBEG.SetActive(false);
}
}
public static bool IsItUnlocked(DoorTrigger dt)
{
Doors thisDoorIs = BriansEngine.FindDoorType(dt);
for (int i = 0; i < BriansEngine.openable.Count; i++)
{
if (thisDoorIs.Equals(BriansEngine.openable[i].doorType))
{
return(!BriansEngine.openable[i].doorState);
}
}
throw new UnityException("Not implemented");
}
private void OnTriggerEnter(Collider hit)
{
if (hit.gameObject.CompareTag("Player"))
{
Destroy(gameObject);
DoorTrigger unlock1 = GameObject.FindGameObjectWithTag("Lock1").GetComponent <DoorTrigger>();
unlock1.Unlock();
DoorTrigger1 unlock2 = GameObject.FindGameObjectWithTag("Lock2").GetComponent <DoorTrigger1>();
unlock2.Unlock();
DoorTrigger2 unlock3 = GameObject.FindGameObjectWithTag("Lock3").GetComponent <DoorTrigger2>();
unlock3.Unlock();
DoorTrigger3 unlock4 = GameObject.FindGameObjectWithTag("Lock4").GetComponent <DoorTrigger3>();
unlock4.Unlock();
}
}
protected override void Awake()
{
doorCollider = GetComponent <Collider2D>();
trigger = GetComponent <DoorTrigger>();
base.Awake();
if (proximityDoorPuzzle)
{
SetProximityLamps();
}
else
{
SetNormalLamps();
}
lampless = (lamps.Length == 0);
}
/// <summary>
/// Called when player presses the use key
/// </summary>
private void useAction()
{
RaycastHit useHit;
if (Physics.Raycast(_playerCamera.transform.position, _playerCamera.transform.forward, out useHit, _useRange))
{
Transform target = useHit.transform;
if (target.CompareTag("Door"))
{
DoorTrigger door = target.GetComponent <DoorTrigger>();
if (door != null)
{
door.Use();
}
}
if (target.CompareTag("Message Switch"))
{
MessageSwitch mSwitch = target.GetComponent <MessageSwitch>();
if (mSwitch != null)
{
mSwitch.Use();
}
}
if (target.CompareTag("Platform Switch"))
{
PlatformSwitch pSwitch = target.GetComponent <PlatformSwitch>();
if (pSwitch != null)
{
pSwitch.Use();
}
}
if (target.CompareTag("Turret"))
{
TurretHealth turretHealth = target.GetComponent <TurretHealth>();
if (turretHealth != null)
{
turretHealth.Die();
}
}
}
}
public static Doors FindDoorType(DoorTrigger doorTrigger)
{
MeshFilter mf = doorTrigger.animator.GetComponent <MeshFilter>();
if (mf.name.Equals(MAINDOOR))
{
return(Doors.Main);
}
else if (mf.name.Equals(ROOM1))
{
return(Doors.Room1);
}
else if (mf.name.Equals(ROOM2))
{
return(Doors.Room2);
}
else if (mf.name.Equals(ROOM3))
{
return(Doors.Room3);
}
else if (mf.name.Equals(BATHROOM))
{
return(Doors.Bathroom);
}
else if (mf.name.Equals(BACKDOOR))
{
return(Doors.Back);
}
else if (mf.name.Equals(GLASSDOOR))
{
return(Doors.GlassDoor1);
}
else if (mf.name.Equals(GLASSDOOR2))
{
return(Doors.GlassDoor2);
}
else if (mf.name.Equals(GARAGEDOOR))
{
return(Doors.GarageDoor);
}
else
{
} throw new UnityException("Unknown return type, mesh filter name provided in BriansEngine doesn't match");
}
void DoorOpened(bool TruthDoor)
{
DoorTrigger doorSound = GetComponent <DoorTrigger>();
if (doorSound != null)
{
doorSound.TriggerSound();
}
Debug.Log("DoorOpenedCallback");
if (!TruthDoor)
{
AkSoundEngine.SetRTPCValue("Dare", 1.0f);
SpawnSpikes();
PlayerTransform.gameObject.GetComponent <PlayerController>().TriggerCameraShake();
}
else
{
DestroySpikes();
AkSoundEngine.SetRTPCValue("Dare", 0.0f);
}
}
/// <summary>
/// Gets the closest door to worldOrigin on the path from worldOrigin to targetPos (if there is one)
/// Assumes that
/// </summary>
/// <param name="worldOrigin">Origin World position to check from. This is required because e.g. Windoors may not appear closed from certain positions.</param>
/// <param name="targetPos">target world position to check</param>
/// <returns>The DoorTrigger of the closed door object specified in the summary, null if no such object
/// exists at that location</returns>
public static DoorTrigger GetClosedDoorAt(Vector3Int worldOrigin, Vector3Int targetPos, bool isServer)
{
// Check door on the local tile first
Vector3Int localTarget = Instance.WorldToLocalInt(targetPos, AtPoint(targetPos, isServer).Matrix);
DoorTrigger originDoor = Instance.GetFirst <DoorTrigger>(worldOrigin, isServer);
if (originDoor && !originDoor.GetComponent <RegisterDoor>().IsPassableTo(localTarget, isServer))
{
return(originDoor);
}
// No closed door on local tile, check target tile
Vector3Int localOrigin = Instance.WorldToLocalInt(worldOrigin, AtPoint(worldOrigin, isServer).Matrix);
DoorTrigger targetDoor = Instance.GetFirst <DoorTrigger>(targetPos, isServer);
if (targetDoor && !targetDoor.GetComponent <RegisterDoor>().IsPassable(localOrigin, isServer))
{
return(targetDoor);
}
// No closed doors on either tile
return(null);
}
public override void OnInspectorGUI()
{
thisTarget = (DoorTrigger)target;
thisTarget.doorType = (DoorTypeState)EditorGUILayout.EnumPopup("Door Type", thisTarget.doorType);
switch (thisTarget.doorType)
{
case DoorTypeState.None:
thisTarget.gameObject.GetComponent <BasicTrigger>().RemoveObject();
break;
case DoorTypeState.TestDoor:
if (thisTarget.door == null)
{
thisTarget.door = (GameObject)PrefabUtility.InstantiatePrefab(
AssetDatabase.LoadAssetAtPath <GameObject>("Assets/Assets/Prefabs/TestDoor.prefab"));
thisTarget.door.transform.parent = thisTarget.gameObject.transform;
thisTarget.door.transform.localPosition = Vector3.zero;
thisTarget.door.transform.localScale = new Vector3(.5f, 3, 3);
}
break;
}
//thisTarget.door = (GameObject)EditorGUILayout.ObjectField("Door Game Object", thisTarget.door, typeof(Object), true);
thisTarget.pull = EditorGUILayout.Toggle("Pull/Push", thisTarget.pull);
thisTarget.randomAngleToggle = EditorGUILayout.Toggle("Random Angle", thisTarget.randomAngleToggle);
if (thisTarget.randomAngleToggle)
{
thisTarget.randomAngleMin = EditorGUILayout.FloatField("between", thisTarget.randomAngleMin);
thisTarget.randomAngleMax = EditorGUILayout.FloatField("and", thisTarget.randomAngleMax);
thisTarget.rotationSpeed = EditorGUILayout.Slider("Speed", thisTarget.rotationSpeed, 0, 90);
}
else
{
thisTarget.angle = EditorGUILayout.Slider("Angle", thisTarget.angle, 0, 90);
thisTarget.rotationSpeed = EditorGUILayout.Slider("Speed", thisTarget.rotationSpeed, 0, 90);
}
}
// Use this for initialization
void Awake()
{
DoorTrigger = GetComponentInChildren <DoorTrigger>();
isOpen = true;
}
void resetLevel()
{
//==============================================//
// Change for each to for loop to reduce GC //
//==============================================//
sendBack = true;
// Get all the objects from the scene using tag (Might have performance impact, if have time find a better solution)
allEnemies = GameObject.FindGameObjectsWithTag("Enemy");
allHunters = GameObject.FindGameObjectsWithTag("HuntingDog");
allKeys = GameObject.FindGameObjectsWithTag("Key");
allDoors = GameObject.FindGameObjectsWithTag("Door");
allDestructibles = GameObject.FindGameObjectsWithTag("Destructible");
allBottles = GameObject.FindGameObjectsWithTag ("Bottle");
allBones = GameObject.FindGameObjectsWithTag("Bone");
allFatDogs = GameObject.FindGameObjectsWithTag("FatDog");
allSpheres = GameObject.FindGameObjectsWithTag("SoundSphere");
allClosets = GameObject.FindGameObjectsWithTag ("Closet");
//resets BGM.
chaseTransScript.resetChaseTrans();
// foreach(GameObject hunter in allHunters)
// {
// hunterScript = (huntingDog)hunter.GetComponent<huntingDog>();
// hunterScript.selfDestruct();
// //Destroy(hunter);
// }
// foreach(GameObject fatDog in allFatDogs)
// {
// fatDogScript = (fatDogAi)fatDog.GetComponent<fatDogAi>();
//// fatDogScript.agent.Stop();
//// fatDogScript.agent.velocity = Vector3.zero;
//// fatDogScript.GetComponent<Rigidbody>().velocity = Vector3.zero;
//// fatDogScript.GetComponent<Rigidbody>().angularVelocity = Vector3.zero;
//// if (fatDogScript.respawnPosition != null)
//// {
//// fatDogScript.transform.position = fatDogScript.respawnPosition;
//// }
//// fatDogScript.stateManager(4);
// // Reset func contains everything above
// fatDogScript.Reset ();
// }
int i = 0;
// if (allDestructibles.Length > 0)
// {
// for (i = 0; i < allDestructibles.Length; i++)
// {
// destructibleSpawner = allDestructibles[i].GetComponent<instantiateDestructible> ();
// destructibleSpawner.checkpoint ();
// }
// }
if (allDestructibles.Length > 0)
{
for (i = 0; i < allDestructibles.Length; i++)
{
destructibleSpawner = allDestructibles[i].GetComponent<instantiateDestructible> ();
destructibleSpawner.checkpoint ();
}
}
for (i = 0; i < allBottles.Length; i++)
{
if (allBottles[i].GetComponent<breakableObject>() == null)
{
Debug.Log (allBottles[i]);
}
}
if (allBottles.Length > 0)
{
for (i = 0; i < allBottles.Length; i++)
{
// if (allBottles[i].GetComponent<breakableObject>() == null)
// {
// Debug.Log (allBottles[i]);
// }
// bo = allBottles[i].GetComponent<breakableObject>();
// bo.brokenPieces.SetActive(false);
// bo.originalObject.SetActive(true);
// bo.GetComponent<CapsuleCollider>().enabled = true;
allBottles[i].GetComponent<breakableObject>().Reset();
}
}
if (allSpheres.Length > 0)
{
for (i = 0; i < allSpheres.Length; i++)
{
allSpheres[i].SetActive(false);
}
}
if (allBones.Length > 0)
{
for (i = 0; i < allBones.Length; i++)
{
player.GetComponent<TemporaryMovement> ().reduceBonePlacedNumber ();
Destroy (allBones[i]);
}
}
if (allHunters.Length > 0)
{
for (i = 0; i < allHunters.Length; i++)
{
hunterScript = allHunters [i].GetComponent<huntingDog> ();
hunterScript.selfDestruct ();
}
}
if (allFatDogs.Length > 0)
{
for (i = 0; i < allFatDogs.Length; i++)
{
fatDogScript = allFatDogs [i].GetComponent<fatDogAi> ();
fatDogScript.Reset ();
}
}
if (allEnemies.Length > 0)
{
for (i = 0; i < allEnemies.Length; i++)
{
script = (enemyPathfinding)allEnemies[i].GetComponent<enemyPathfinding> ();
script.agent.Stop ();
script.agent.velocity = Vector3.zero;
script.GetComponent<Rigidbody> ().velocity = Vector3.zero;
script.GetComponent<Rigidbody> ().angularVelocity = Vector3.zero;
if (script.respawnPosition != null) {
script.transform.position = script.respawnPosition;
}
script.currentTarget = script.firstTarget;
script.targetCounter = 0;
script.agent.speed = script.patrolSpeed;
script.stateManager (1);
script.agent.SetDestination (script.currentTarget.position);
script.newTargetTimer = script.defaultNewTargetTimer;
}
}
if (allKeys.Length > 0)
{
for (i = 0; i < allKeys.Length; i++)
{
keySpawner = allKeys[i].GetComponent<instantiateKey> ();
keySpawner.checkpoint ();
}
}
if (allDoors.Length > 0)
{
for (i = 0; i < allDoors.Length; i++)
{
door = allDoors[i].GetComponent<DoorTrigger> ();
door.checkpoint ();
}
}
if (allClosets.Length > 0)
{
for (i = 0; i < allClosets.Length; i++)
{
closet = allClosets[i].GetComponent<hidingThirdPerson>();
closet.ResetCloset ();
}
}
playerScript.resetCharacter();
StopAllCoroutines ();
sendBack = false;
}
void Awake()
{
Instance = this;
}
// Use this for initialization
void Start()
{
trigger = GetComponent <DoorTrigger>();
lastTriggerState = trigger.GetTriggerState();
}
public void OnDoorExit(DoorTrigger door)
{
//Debug.Log("OnDoorExit");
this.nearbyDoors.Remove(door);
//Debug.Log($"Nearby Doors {nearbyDoors.Count}");
}
public void OnDoorEnter(DoorTrigger door)
{
//Debug.Log("OnDoorEnter");
this.nearbyDoors.Add(door);
//Debug.Log($"Nearby Doors {nearbyDoors.Count}");
}
