public void GetShouldReturnAllDoors()
{
//Arrange
var _doorrepo = new Mock <IEntityBaseRepository <Door> >();
_doorrepo.Setup(x => x.GetAll()).Returns(doors.AsQueryable());
var _errorrepo = new Mock <IEntityBaseRepository <Error> >();
var _uow = new Mock <IUnitOfWork>();
var AutoMapperMock = new Mock <IMapper>();
var config = new HttpConfiguration();
var request = new HttpRequestMessage(HttpMethod.Get, "http://localhost/api/door");
var route = config.Routes.MapHttpRoute("DefaultApi", "api/{controller}/{id}");
var routeData = new HttpRouteData(route, new HttpRouteValueDictionary {
{ "controller", "door" }
});
var controller = new DoorController(_doorrepo.Object, _errorrepo.Object, _uow.Object);
controller.ControllerContext = new HttpControllerContext(config, routeData, request);
controller.Request = request;
controller.Request.Properties[HttpPropertyKeys.HttpConfigurationKey] = config;
//Act
var _response = controller.Get(request);
// Assert
var responseResult = JsonConvert.DeserializeObject <List <DoorDTO> >(_response.Content.ReadAsStringAsync().Result).ToArray();
Assert.AreEqual(_response.StatusCode, HttpStatusCode.OK);
Assert.AreEqual(responseResult.Any(), true);
Assert.AreEqual(responseResult.Length, 2);
}
public void PutShouldInsertItemAndReturnCorrectStatus()
{
//Arrange
var _doorrepo = new Mock <IEntityBaseRepository <Door> >();
_doorrepo.Setup(x => x.GetAll()).Returns(doors.AsQueryable());
var _errorrepo = new Mock <IEntityBaseRepository <Error> >();
var _uow = new Mock <IUnitOfWork>();
var AutoMapperMock = new Mock <IMapper>();
var config = new HttpConfiguration();
var request = new HttpRequestMessage(HttpMethod.Get, "http://localhost/api/door/");
var route = config.Routes.MapHttpRoute("DefaultApi", "api/{controller}/{id}");
var routeData = new HttpRouteData(route, new HttpRouteValueDictionary {
{ "controller", "door" }
});
var controller = new DoorController(_doorrepo.Object, _errorrepo.Object, _uow.Object);
controller.ControllerContext = new HttpControllerContext(config, routeData, request);
controller.Request = request;
controller.Request.Properties[HttpPropertyKeys.HttpConfigurationKey] = config;
DoorDTO newDoor = new DoorDTO {
Id = 2, Make = "NewDoor"
};
//Act
var _response = controller.Put(request, newDoor);
// Assert
Assert.AreEqual(_response.StatusCode, HttpStatusCode.Created);
}
private void InteractDoor(Vector3 currentPosition, Vector3 direction)
{
// Make sure there is a door controller
Vector3Int position = Vector3Int.RoundToInt(currentPosition + direction);
DoorController doorController = matrix.GetFirst <DoorController>(position);
if (!doorController)
{
doorController = matrix.GetFirst <DoorController>(Vector3Int.RoundToInt(currentPosition));
if (doorController)
{
RegisterDoor registerDoor = doorController.GetComponent <RegisterDoor>();
if (registerDoor.IsPassable(position))
{
doorController = null;
}
}
}
// Attempt to open door
if (doorController != null && allowInput)
{
pna.CmdCheckDoorPermissions(doorController.gameObject, gameObject);
allowInput = false;
StartCoroutine(DoorInputCoolDown());
}
}
public void Setup()
{
_door = Substitute.For <IDoor>();
_entry = Substitute.For <IEntryNotification>();
_validation = Substitute.For <IUserValidation>();
_uut = new DoorController(_door, _validation, _entry);
}
private void OnTriggerEnter(Collider other)
{
if (other.tag == "Door" && !hasDoorBeenTriggered)
{
// Stores a cached reference to the door that we are interacting with
doorInteractingWith = other.GetComponent <DoorController>();
// Sets a bool so that we know that the agent is already interacting with a door
hasDoorBeenTriggered = true;
// Takes user input control away
hasControl = false;
// Saves the final destination position that the agent is trying to reach
targetPosition = myNavmeshAgent.destination;
// Gets the position the player should move to while waiting for the door to open
Vector3 waitPosition = doorInteractingWith.GetWaitPosition(transform.position);
// Gets the length of the door open animation so we know how long to wait
doorOpenDelay = doorInteractingWith.animationDuration;
// Tell the agent to move to the position where he should wait for the door open animation
SetDestination(waitPosition);
// Starts the coroutine that will carry out the sequence of waiting and opening the door
StartCoroutine(DelayCoroutine());
}
}
void MakeInstance()
{
if (instance == null)
{
instance = this;
}
}
public void RemoveDoor(DoorController cont)
{
if (currentDoors.Contains(cont))
{
currentDoors.Remove(cont);
}
}
private void GenerateDoorsAndWalls()
{
m_spawnedDoors = new List <DoorController>();
m_spawnedWalls = new List <GameObject>();
List <int> proccessedConnectors = new List <int>();
foreach (RoomModule module in m_spawnedModules)
{
foreach (ModuleConnector connector in module.GetConnectors())
{
if (connector.linkedModule == null)
{
// Spawn wall
GameObject wall = Instantiate(wallPrefab, connector.transformPoint.position, connector.transformPoint.rotation, module.transform);
proccessedConnectors.Add(connector.UniqueId);
m_spawnedWalls.Add(wall);
}
else
{
if (proccessedConnectors.Contains(connector.LinkedUniqueId) == false)
{
// Spawn door
if (Random.Range(0f, 1f) >= 0.5f)
{
DoorController cont = Instantiate(doorPrefab, connector.transformPoint.position, connector.transformPoint.rotation, module.transform).GetComponent <DoorController>();
m_spawnedDoors.Add(cont);
}
proccessedConnectors.Add(connector.UniqueId);
proccessedConnectors.Add(connector.LinkedUniqueId);
}
}
}
}
}
public void Attach(GameplayController gameplayController, CardController cardController, DoorController doorController, Camera mainCamera)
{
this.gameplayController = gameplayController;
this.cardController = cardController;
this.doorController = doorController;
this.mainCamera = mainCamera;
}
// code that is executed when something collides with lock
void OnTriggerEnter2D(Collider2D collider)
{
// ignore any collision with non-player game objects
if (collider.CompareTag("Player") == false)
{
return;
}
// get the player's script who entered the square
PlayerController p = collider.gameObject.GetComponent <PlayerController>();
DoorController d = (DoorController)door.GetComponent(typeof(DoorController));
// set unlock to true if player has keys and matches color
if (p.checkKey() && p.colorPower.Contains(color))
{
// play sound effect once so it doesn't play on exit
if (sound)
{
keyUnlock.Play();
sound = false;
}
// set variable and check door
unlock = true;
d.CheckDoor();
}
}
// Esta funcao e chamada a cada frame
void Update()
{
if (alive)
{
if (curHealth <= 0)
{
// O boss morreu
movementScript.canMove = false; // O boss nao pode mais se mexer
attackScript.canAttack = false; // O boss nao pode mais atacar
animator.SetTrigger("Died"); // Avisa ao Animator que ele morreu
oldCollider.enabled = false;
newCollider.enabled = true;
if (healthBar != null)
{
Destroy(healthBar.gameObject, 0.5f); // Desativa sua barra de vida apos um certo tempo
}
Destroy(gameObject, 4f); // Destroi ele apos um certo tempo
// Abre todas as portas para o jogador
foreach (GameObject obj in doors)
{
DoorController contr = obj.GetComponent <DoorController>();
contr.CanBeOpened(true);
}
alive = false;
attackScript.IsAlive(false);
}
// Atualiza a barra de vida
healthBar.SetValueWithoutNotify(curHealth / health);
}
}
DoorController findBestDoorAux(List <DoorController> lista_door, int playerLvl, int old_lvl)
{
bool flag_aux = true;
DoorController best_door = new DoorController();
int max, max_aux = 100;
//print(lista_door.Count);
foreach (DoorController door in lista_door)
{
if (door.nextLevel != old_lvl)
{
if (flag_aux)
{
max_aux = Mathf.Abs(playerLvl - door.nextLevel); // door.nextlevel mais proximo do playerlvl;
flag_aux = false;
}
max = Mathf.Abs(playerLvl - door.nextLevel);
if (Mathf.Abs(playerLvl - door.nextLevel) <= max_aux)
{
max_aux = max;
best_door = door;
// Debug.Log("in");
}
}
}
//Debug.Break();
return(best_door);
}
/// Cross-matrix now! uses world positions
private void InteractDoor(Vector3Int currentPos, Vector3Int targetPos)
{
// Make sure there is a door controller
DoorController doorController = MatrixManager.Instance.GetFirst <DoorController>(targetPos);
if (!doorController)
{
doorController = MatrixManager.Instance.GetFirst <DoorController>(Vector3Int.RoundToInt(currentPos));
if (doorController)
{
RegisterDoor registerDoor = doorController.GetComponent <RegisterDoor>();
Vector3Int localPos = MatrixManager.Instance.WorldToLocalInt(targetPos, matrix);
if (registerDoor.IsPassable(localPos))
{
doorController = null;
}
}
}
// Attempt to open door
if (doorController != null && allowInput)
{
pna.CmdCheckDoorPermissions(doorController.gameObject, gameObject);
allowInput = false;
StartCoroutine(DoorInputCoolDown());
}
}
Vector3 ChooseDoor()
{
DoorController closestDoor = null;
float maxDistance = 100;
foreach (DoorController door in currentRoom.doors)
{
if (currentRoom.doors.Count > 1)
{
if (door.locked)
{
float newDistance = Vector3.Distance(transform.position, door.transform.position);
if (newDistance < maxDistance)
{
maxDistance = newDistance;
closestDoor = door;
}
}
}
else
{
closestDoor = door;
}
}
targetDoor = closestDoor;
return(closestDoor.transform.position);
}
public static int RegisterDoor( DoorController doorController )
{
if( instance )
return instance.internalRegisterDoor( doorController );
return -1;
}
protected void InitializeControllers()
{
_doorController = new DoorController(_doorServo, _openEndStopSwitch, _closeEndStopSwitch);
_doorController.DoorOpened += (s, e) => {
Debug.Print("Door opened.");
_menu.UpdateItemValue("toggle", "Close");
};
_doorController.DoorClosed += (s, e) => {
Debug.Print("Door closed.");
_menu.UpdateItemValue("toggle", "Open");
};
_tempController = new TemperatureController(_heatLampRelay, _tempSensor);
switch (_doorController.State)
{
case DoorStateType.Closed:
_menu.UpdateItemValue("toggle", "Open");
break;
case DoorStateType.Open:
_menu.UpdateItemValue("toggle", "Close");
break;
}
Debug.Print("Controllers initialized.");
}
void OnLoadCallback(Scene scene, LoadSceneMode scenemode)
{
//if we have changed scenes from a room then move our player to the door they came from
if (PreviousSceneName != null && PreviousSceneName != "Menu" && !"Menu".Equals(scene.name))
{
//finds all of our doors. we will use this to set the player position
DoorController[] doors = FindObjectsOfType <DoorController>();
PlayerController player = FindObjectOfType <PlayerController>();
//start by finding the door that leads to the other level that we came from, this is the transform we want
DoorController fromDoor = Array.Find(doors, door => PreviousSceneName.Equals(door.transitionToLabel));
//modify the player transform, by combining the door transform and the transform modifiers
Transform newPos = fromDoor.gameObject.transform;
player.gameObject.transform.position = new Vector3(
newPos.position.x + fromDoor.xSpawn,
newPos.position.y + fromDoor.ySpawn,
-1//fix the player position to not spawn at 0 on the axis
);
player.Spawn(new Vector2(
newPos.position.x + fromDoor.xSpawn,
newPos.position.y + fromDoor.ySpawn
), fromDoor.xSpawn, fromDoor.ySpawn);
}
//set the previous scene to be this scene (should always happen)
PreviousSceneName = scene.name;
}
protected void Move(Vector3Int dirToMove)
{
var dest = mobTile.LocalPositionServer + dirToMove;
if (mobTile.customNetTransform.Push(dirToMove.To2Int(), context: gameObject) == false)
{
//New doors
DoorMasterController tryGetDoorMaster = mobTile.Matrix.GetFirst <DoorMasterController>(dest, true);
if (tryGetDoorMaster)
{
tryGetDoorMaster.Bump(gameObject);
}
//Old doors
DoorController tryGetDoor = mobTile.Matrix.GetFirst <DoorController>(dest, true);
if (tryGetDoor)
{
tryGetDoor.MobTryOpen(gameObject);
}
}
if (rotatable != null)
{
rotatable.SetFaceDirectionLocalVictor(dirToMove.To2Int());
}
}
//move in direction input
public void MoveInDirection(Vector2 direction)
{
nextTile.x = (int)(Mathf.Round(transform.position.x) + direction.x);
nextTile.y = (int)(Mathf.Round(transform.position.y) + direction.y);
if (Matrix.Matrix.At(nextTile.x, nextTile.y).IsPassable())
{
lerpA = false;
moveDirection = direction;
isMoving = true;
if (direction == Vector2.right || direction == Vector2.left)
{
clampPos = Mathf.Round(transform.position.y);
}
if (direction == Vector2.down || direction == Vector2.up)
{
clampPos = Mathf.Round(transform.position.x);
}
}
else
{
//Check why it is not passable (doors etc)
DoorController getDoor = Matrix.Matrix.At(nextTile.x, nextTile.y).GetDoor();
if (getDoor != null && !tryOpenDoor)
{
tryOpenDoor = true;
StartCoroutine("OpenCoolDown");
// getDoor.CmdTryOpen();
}
}
}
// Use this for initialization
void Start()
{
gameController = GameObject.Find("Controller").GetComponent("GameController") as GameController;
introFlowController = this.GetComponent("IntroFlowController") as IntroFlowController;
introFlowController.enabled = false;
level1FlowController = this.GetComponent("Level1FlowController") as Level1FlowController;
level1FlowController.enabled = false;
level2FlowController = this.GetComponent("Level2FlowController") as Level2FlowController;
level2FlowController.enabled = false;
EndController = GetComponent("GameEndsController") as GameEndsController;
doorController = GameObject.Find("Door2").GetComponent("DoorController") as DoorController;
introFlowController.FinishedEvent += introFlowControllerListener;
level1FlowController.FinishedEvent += level1FlowControllerListener;
level2FlowController.FinishedEvent += level2FlowControllerListener;
if (!gameController.isCheating())
{
if (gameController.startingLevel() == 0)
{
startStory();
}
else if (gameController.startingLevel() == 1)
{
introFlowControllerListener(null);
}
else if (gameController.startingLevel() == 2)
{
level1FlowControllerListener(null);
}
}
}
private void Awake()
{
_switches = GameObject.FindObjectsOfType <SwitchController>();
_door = GameObject.FindObjectOfType <DoorController>();
_camera = GameObject.FindObjectOfType <CameraController>();
_enemyManager = GameObject.FindObjectOfType <EnemyManager>();
}
private void Awake()
{
_particleSystem = GetComponent <ParticleSystem>();
_renderer = GetComponent <MeshRenderer>();
_doorController = FindObjectOfType <DoorController>();
_particleSystem.Stop();
}
bool IsNearDoor()
{
Vector3 pos = Snap(m_Transform.position);
if (Vector3.Distance(pos, m_Transform.position) > senseRadius)
{
return(false);
}
Vector2[] options = { Vector2.up, Vector2.down, Vector2.left, Vector2.right };
foreach (var option in options)
{
var hit = Physics2D.Raycast(pos, option, 1.0f);
if (hit.collider == null)
{
continue;
}
door = hit.collider.GetComponent <DoorController>();
if (door == null)
{
continue;
}
// Hit door
m_CircleCollider.enabled = false;
m_Transform.position = pos;
return(true);
}
return(false);
}
private void CheckDoorAccess(IDCard cardID, DoorController doorController)
{
if (cardID.accessSyncList.Contains((int)doorController.restriction))
{
// has access
allowInput = false;
//Server only here but it is a cmd for the input trigger (opening with mouse click from client)
if (CustomNetworkManager.Instance._isServer)
{
doorController.CmdTryOpen(gameObject);
}
StartCoroutine(DoorInputCoolDown());
}
else
{
// does not have access
allowInput = false;
StartCoroutine(DoorInputCoolDown());
//Server only here but it is a cmd for the input trigger (opening with mouse click from client)
if (CustomNetworkManager.Instance._isServer)
{
doorController.CmdTryDenied();
}
}
}
// Use this for initialization
void Start()
{
gameController = GameObject.Find("Controller").GetComponent("GameController") as GameController;
introFlowController = this.GetComponent("IntroFlowController") as IntroFlowController;
introFlowController.enabled = false;
level1FlowController = this.GetComponent("Level1FlowController") as Level1FlowController;
level1FlowController.enabled = false;
level2FlowController = this.GetComponent("Level2FlowController") as Level2FlowController;
level2FlowController.enabled = false;
EndController = GetComponent("GameEndsController") as GameEndsController;
doorController = GameObject.Find("Door2").GetComponent("DoorController") as DoorController;
introFlowController.FinishedEvent += introFlowControllerListener;
level1FlowController.FinishedEvent += level1FlowControllerListener;
level2FlowController.FinishedEvent += level2FlowControllerListener;
if( !gameController.isCheating() ){
if( gameController.startingLevel() == 0){
startStory();
} else if( gameController.startingLevel() == 1){
introFlowControllerListener(null);
} else if( gameController.startingLevel() == 2){
level1FlowControllerListener(null);
}
}
}
private void OnTriggerExit2D(Collider2D other)
{
if (other.GetComponent <DoorController>() != null)
{
door = null;
}
}
private void HandleDoorAreaInteraction(Collider2D doorInteractiveArea)
{
DoorController doorController = doorInteractiveArea.gameObject.GetComponentInParent <DoorController>();
if (doorController.openWithKeyName != "")
{
PickUp requiredKey = FindInInventory(PickUpConstants.TYPE_KEY, doorController.openWithKeyName);
if (requiredKey != null)
{
doorController.ToggleState();
bool result = RemoveFromInventory(requiredKey);
if (!result)
{
Debug.Log("There was an error trying to remove the required key from inventory.");
}
}
else
{
Debug.Log("Doesn't have the right key!");
}
}
else
{
Debug.Log("The door doesn't use a key!");
}
}
void atDoor(DoorController dc)
{
if (doorUpdate[0] == null)
{
doorUpdate[0] = dc;
doorUpdate[0].activateRooms(true);
return;
}
if (doorUpdate[1] == null)
{
if (doorUpdate[0] == dc)
{
return;
}
else
{
doorUpdate[1] = dc;
doorUpdate[0].activateRooms(false);
doorUpdate[1].activateRooms(true);
}
}
if (doorUpdate[1] == dc)
{
return;
}
else
{
doorUpdate[0] = doorUpdate[1];
doorUpdate[1] = dc;
doorUpdate[0].activateRooms(false);
doorUpdate[1].activateRooms(true);
}
}
// Use this for initialization
void Start()
{
score = LevelManager.instance.scoreInOneScene;
scoreText.text = "Score:" + score;
gameLife = LevelManager.instance.playerHealth;
heartCount_Player = LevelManager.instance.heartCount_Player;
heartCount_Dof = LevelManager.instance.heartCount_Dof;
levelText.text = "Màn chơi cuối";
////Display the player's life
//for (int i = heartCount_Player - 1; i < gameLife - 1; i++)
//{
// heart_Player[i + 1].gameObject.SetActive(false);
//}
for (int i = 0; i < heartCount_Player; i++)
{
heart_Player[i].gameObject.SetActive(true);
}
for (int i = heartCount_Dof - 1; i < 2; i++)
{
heart_Dof[i + 1].gameObject.SetActive(false);
}
doorController = LevelManager.instance.doors[LevelManager.instance.indexDoor];
//Debug.Log(LevelManager.indexDoor);
//Debug.Log(doorController.QASetList[0].question);
FinalMCManager.instance.BeginConversation(doorController);
}
public int AddDoor(DoorController cont, out DoorController.DoorType newOrientation)
{
newOrientation = cont.DoorLocation;
if (newOrientation == DoorController.DoorType.East ||
newOrientation == DoorController.DoorType.West)
{
if (cont.gameObject.transform.position.x - transform.position.x > 0)
{
newOrientation = DoorController.DoorType.East;
}
else
{
newOrientation = DoorController.DoorType.West;
}
}
else if (newOrientation == DoorController.DoorType.North ||
newOrientation == DoorController.DoorType.South)
{
if (cont.gameObject.transform.position.x - transform.position.x > 0)
{
newOrientation = DoorController.DoorType.South;
}
else
{
newOrientation = DoorController.DoorType.North;
}
}
currentDoors.Add(cont);
return(currentDoors.Count);
}
public void DecreaseMonsterCountAtRoom(int col, int row)
{
sessionArray[row, col].movingEnemyCount--;
if (sessionArray[row, col].movingEnemyCount <= 0)
{
if (sessionArray[row, col].roomType == RoomType.boss)
{
HeroController.S.isClearSession = true;
}
else
{
sessionArray[row, col].movingEnemyCount = 0;
sessionArray[row, col].monsterList.Clear();
DoorController tempDoorController = null;
foreach (var door in sessionArray[row, col].doorsInRoomDic)
{
tempDoorController = door.Value.transform.Find("Door").GetComponent <DoorController>();
if (tempDoorController != null)
{
tempDoorController.DoorOpen();
}
}
}
}
}
void Start()
{
intObj.interactMethod = UseKeypad;
uiKeypadInput = uiKeypad.GetComponent <TMP_InputField>();
uiKeypadInput.characterLimit = characterLimit;
connectedDoorController = connectedDoor.GetComponent <DoorController>();
}
void Start()
{
this.cameraControler = this.gameObject.AddComponent<CameraControler> ();
this.doorController = this.gameObject.AddComponent<DoorController> ();
this.inventory = this.gameObject.AddComponent<Inventory> ();
this.lightManager = this.gameObject.AddComponent<LightManager> ();
this.playerController = this.gameObject.AddComponent<PlayerController> ();
this.cameraControler.lightManager = this.lightManager;
this.gameObject.name = "Player";
}
//This script unlocks a door when called by an NPC...
void OnEnable()
{
if(!alreadyEnabledOnce){
alreadyEnabledOnce = true;
doorController = GetComponent<DoorController> ();
doorController.UnlockDoor ();
//if there is a chained action...
if(targetGO){
(targetGO.GetComponent(scriptNameToEnable) as MonoBehaviour).enabled = true;
}
}
}
void OnTriggerEnter(Collider other)
{
if (other.gameObject.tag == Tags.player) {
if(!targetEnabled && targetGO != null){
doorController = targetGO.GetComponent<DoorController>();
doorController.LockDoor();
(targetGO.GetComponent(scriptNameToEnable) as MonoBehaviour).enabled = true;
targetEnabled = true;
if(destroyGO){
Destroy (gameObject);
}
}
}
}
public void Close()
{
_opener = null;
ActionState = DoorState.Idle;
}
public void WalkThrough(DoorController opener)
{
_opener = opener;
ActionState = DoorState.Ghost;
}
// Initialization
void Start()
{
// If the player is the seeker, tag their player object as "Hunter" and
// send a message to all clients that this object is the Hunter object
if (isServer && isLocalPlayer) {
this.tag = "Hunter";
SendPropMessageTag ();
}
// Setup camera based on player role
string whichCamera;
if (isServer) {
whichCamera = "FirstPerson";
UIText = firstPersonText;
} else {
whichCamera = "ThirdPerson";
UIText = thirdPersonText;
}
// hide and lock the cursor
Cursor.visible = false;
Cursor.lockState = CursorLockMode.Locked;
// Get Audio Source
playerAudio = GetComponent<AudioSource>();
// get necessary references
graphics = transform.Find("Graphics").gameObject;
playerModel = graphics.transform.Find("Player Model").gameObject;
cam = transform.Find(whichCamera).gameObject;
myCamera = cam.GetComponent<Camera>();
rigidBody = GetComponent<Rigidbody>();
doorController = GetComponent<DoorController>();
timer = GameObject.Find("Timer").GetComponent<Timer>();
// life status
health = MaxHealth;
dead = false;
// record the spawn place, used to respawn
spawnPosition = transform.position;
spawnRotation = transform.rotation;
// disable UI for other players
if (!isLocalPlayer) {
cam.transform.Find("Canvas").gameObject.SetActive(false);
}
// ignore local player model to avoid clipping with first person camera
if (isLocalPlayer && isServer) {
playerModel.GetComponent<MeshRenderer>().enabled = false;
}
// setup handlers for messages
if (isServer) {
NetworkServer.RegisterHandler(PropMessage.TypeId, OnPropMessageServer);
}
if (isLocalPlayer) {
NetworkClient.allClients[0].RegisterHandler(PropMessage.TypeId, OnPropMessageClient);
}
// TEMPORARY SOLUTION: the server is the hunter permanantly
if (isServer) {
if (isLocalPlayer) {
isActive = false;
}
else {
isActive = true;
}
}
}
public void Open(DoorController opener)
{
_opener = opener;
ActionState = DoorState.Open;
}
// Use this for initialization
void Start()
{
doorController = GameObject.Find(whichDoor).GetComponent("DoorController") as DoorController;
}
void Awake()
{
nearestDoor = FindObjectOfType<DoorController>();
//nearestDoor.AddToTargetList(gameObject);
}
// Use this for initialization
void Start()
{
// If the player is the host and the object in the scene is the localplayer's character, initialize the Steam controller
if (isServer && isLocalPlayer) {
rightTrackedObject = this.transform.Find("[CameraRig]").Find("Controller (right)").GetComponent<SteamVR_TrackedObject>();
}
// Determining the camera based on if the person is a seeker or hider
string whichCamera;
if (isServer && isLocalPlayer) {
whichCamera = "FirstPerson";
UIText = firstPersonText;
} else {
whichCamera = "ThirdPerson";
UIText = thirdPersonText;
}
myCamera = transform.Find(whichCamera).GetComponent<Camera>();
doorController = GetComponent<DoorController>();
timer = GameObject.Find("Timer").GetComponent<Timer>();
// record the spawn place, used to respawn
spawnPosition = transform.position;
spawnRotation = transform.rotation;
rigidBody = GetComponent<Rigidbody>();
// TEMPORARY solution: the server is the hunter
if (isServer) {
if (isLocalPlayer) {
isActive = true;
this.transform.Find ("[CameraRig]").gameObject.SetActive (true);
}
else {
isActive = false;
}
}
// wait at the beginning of the game
if (isActive) {
waiting = true;
GetComponent<myViveController>().enabled = false;
}
}
private int internalRegisterDoor( DoorController doorController )
{
if( doorController.getUniqueID() == -1 )
{
int uniqueID = IDIndex;
IDIndex++;
doorsById.Add( uniqueID, doorController );
return uniqueID;
}
return doorController.getUniqueID();
}
// Use this for initialization
void Start()
{
doorAnim = door.GetComponent<Animator> ();
doorScript = door.GetComponent<DoorController> ();
anim = gameObject.GetComponent<Animator> ();
}
void Awake()
{
doorController = GetComponentInParent<DoorController> ();
}