// Use this for initialization
public void Start()
{
activable = target.GetComponent <Activable> ();
if (activable == null)
{
Debug.Log("Need Activable");
}
}
// Use this for initialization
void Start()
{
rend = gameObject.GetComponent <Renderer> ();
index = Random.Range(0, materialsList.Length);
rend.materials [materialIndex].CopyPropertiesFromMaterial(materialsList [index]);
activable = gameObject.GetComponent <Activable> ();
}
void Update()
{
// Timer du Loader
if (isTimingforObjet)
{
timerObjet = timerObjet + Time.deltaTime;
}
else
{
timerObjet = 0;
}
RaycastHit hit;
// Définition de la longueur du rayonCurseur
curseurRayon.localScale = new Vector3(curseurRayon.localScale.x, activeDistance * 2, curseurRayon.localScale.z);
// L'axe des Z mis dans la variable profondeur
Vector3 profondeur = transform.forward;
//Met à jour la position de curseurRayon à chaque frame
curseurRayon.position = transform.position;
curseurRayon.up = profondeur;
if (Physics.Raycast(transform.position, profondeur, out hit, activeDistance))
{
if (Activable.isActivable(hit.transform.tag) && hit.collider.gameObject.CompareTag("Bouche_Aeration"))
{
isTimingforObjet = true;
if (timerObjet > loadingTime)
{
pictoMsg = Activable.picto;
loading = false;
showPicto = true;
}
else
{
loading = true;
showPicto = false;
}
}
else
{
isTimingforObjet = false;
loading = false;
showPicto = false;
}
}
}
public void OnSceneGUI()
{
Activable o = (Activable)target;
Vector3 start = o.transform.position;
Vector3 end = start + o.transform.right * o.range;
float size = HandleUtility.GetHandleSize(start) * 0.1f;
Handles.DrawLine(start, end);
Handles.SphereHandleCap(0, end, Quaternion.identity, size, EventType.Repaint);
}
// Use this for initialization
void Start()
{
activable = gameObject.GetComponent <Activable> ();
if (activable == null)
{
Debug.Log("Need Activable Script!");
}
isEnable = activable.isOpened();
prev_state = isEnable;
}
private void OnTriggerExit(Collider other)
{
//change the color of an illuminable object to the default(red in this case)
if (other.transform.gameObject.tag == "illuminable" && mLigth.isActiveAndEnabled)
{
Activable activator = other.gameObject.GetComponent <Activable>();
if (activator != null)
{
activator.exitLight();
}
}
}
// Use this for initialization
void Start()
{
activable = gameObject.GetComponent <Activable> ();
timeActual = timeBeforeNextAction;
if (activable == null)
{
Debug.Log("ChangeCamera script need Activable script!");
}
_camera = GameObject.Find("LobbyCamera");
}
// Use this for initialization
void Start()
{
Position = transform.position;
for (int i = 0; i < transform.childCount; i++)
{
if (transform.GetChild(i).name == "Position")
{
Position = transform.GetChild(i).transform.position;
Destroy(transform.GetChild(i).gameObject);
break;
}
}
locker = hiddingPlace.GetComponent <Locker> ();
activable = hiddingPlace.GetComponent <Activable> ();
}
/// <summary>
/// Try to use a consumable on an activable, if it work, the consumable is removed from the inventory
/// </summary>
/// <param name="objectToActive">object to active</param>
public void TryToUse(Activable objectToActive)
{
for (var i = _consumables.Count - 1; i >= 0; i--)
{
var consumable = _consumables[i];
if (!objectToActive.Active(consumable))
{
continue;
}
DestroyConsumable(consumable);
if (objectToActive.Actived)
{
return;
}
}
}
IEnumerator ActivateActivables()
{
if (_board != null)
{
Activable activable = _board.FindActivableAt(_board.PlayerNode);
if (activable != null)
{
yield return(StartCoroutine(activable.Activate()));
}
}
else
{
Debug.LogWarning("PLAYERMANAGER ActivateActivables Error: _board is null");
}
yield return(new WaitForSeconds(0f));
}
// Called from UI
public void LoadState()
{
save.rawSave = JsonUtility.FromJson <SaveContent.RawSave>(currentContent);
for (int i = 0; i < f_coins.Count && i < save.rawSave.coinsState.Count; i++)
{
GameObjectManager.setGameObjectState(f_coins.getAt(i), save.rawSave.coinsState[i]);
f_coins.getAt(i).GetComponent <Renderer>().enabled = save.rawSave.coinsState[i];
}
for (int i = 0; i < f_doors.Count && i < save.rawSave.doorsState.Count; i++)
{
GameObjectManager.setGameObjectState(f_doors.getAt(i), save.rawSave.doorsState[i]);
f_doors.getAt(i).GetComponent <Renderer>().enabled = save.rawSave.doorsState[i];
}
for (int i = 0; i < f_directions.Count && i < save.rawSave.directions.Count; i++)
{
f_directions.getAt(i).GetComponent <Direction>().direction = save.rawSave.directions[i];
}
for (int i = 0; i < f_positions.Count && i < save.rawSave.positions.Count; i++)
{
Position pos = f_positions.getAt(i).GetComponent <Position>();
pos.x = save.rawSave.positions[i].x;
pos.z = save.rawSave.positions[i].z;
}
for (int i = 0; i < f_activables.Count && i < save.rawSave.activables.Count; i++)
{
Activable act = f_activables.getAt(i).GetComponent <Activable>();
act.isActivated = save.rawSave.activables[i].isActivated;
act.isFullyActivated = save.rawSave.activables[i].isFullyActivated;
act.side = save.rawSave.activables[i].side;
act.slotID = save.rawSave.activables[i].slotID;
}
foreach (GameObject go in f_currentActions)
{
if (go.GetComponent <CurrentAction>().agent.CompareTag("Drone"))
{
GameObjectManager.removeComponent <CurrentAction>(go);
}
}
foreach (SaveContent.RawCurrentAction act in save.rawSave.currentDroneActions)
{
GameObjectManager.addComponent <CurrentAction>(act.action, new{ agent = act.agent });
}
}
void OnTriggerStay(Collider other)
{
Activable activator = other.gameObject.GetComponent <Activable>();
if (activator != null && !activator.InLight)
{
RaycastHit hit;
Vector3 direction = other.transform.position - mLigth.transform.position;
Ray lightRay = new Ray(mLigth.transform.position, direction);
Debug.DrawRay(lightRay.origin, lightRay.direction * 10);
if (Physics.Raycast(lightRay, out hit, mLigth.range) && mLigth.isActiveAndEnabled)
{
//if the ray hits the same object the have enter in the trigger and it's illuminable, we change it's color
if (other.gameObject.GetInstanceID() == hit.transform.gameObject.GetInstanceID())
{
activator.enterInLight();
}
}
}
}
protected void action()
{
GameObject target = GameObject.Find("Pointer").GetComponent <PointerManager> ().targetedObject;
if (target != null && target.GetComponent <Activable>() != null)
{
if (target.GetComponent <SimpleAgent>() != null)
{
if (Vector3.Distance(target.transform.position, this.transform.position) <= FIGHTING_DISTANCE)
{
Activable a = target.GetComponent <Activable> ();
a.action();
}
}
else
{
Activable a = target.GetComponent <Activable> ();
a.action();
}
}
}
// Update is called once per frame
void Update()
{
if (grabTentacle.grab && Input.GetAxisRaw("Jump") > 0)
{
grabTentacle.grab.transform.position = HeadTentacle.transform.position;
}
if (grabTentacle.activable && Input.GetAxisRaw("Jump") > 0 && resetActive)
{
Activable activeObject = grabTentacle.activable.GetComponent <Activable>();
Debug.Log(activeObject);
if (activeObject)
{
activeObject.activate();
}
resetActive = false;
}
if (Input.GetAxisRaw("Jump") == 0)
{
resetActive = true;
}
}
public static void ActivateHighlightedActivableObject()
{
if (Application.isPlaying)
{
try
{
GameObject obj = Selection.activeGameObject;
Activable actObj = obj.GetComponent <Activable>();
if (actObj != null)
{
actObj.SwitchState(null);
}
}
catch
{
Debug.Log("No object selected!");
}
}
else
{
Debug.LogError("Not in play mode.");
}
}
// Update is called once per frame
void Update()
{
RaycastHit hit = new RaycastHit();
Ray ray = Camera.main.ScreenPointToRay(Input.mousePosition);
if (Physics.Raycast(ray, out hit, rayCastInteractionRange))
{
GameObject obj = hit.transform.gameObject;
if ((obj.gameObject.layer == LayerMask.NameToLayer("UI")) && (currentObj != obj))
{
ApplyShader(obj, "Outlined/Silhouetted Diffuse");
if (currentObj != null)
{
ApplyShader(currentObj, "Diffuse");
}
currentObj = obj;
}
}
else if (currentObj != null)
{
ApplyShader(currentObj, "Diffuse");
currentObj = null;
}
if (currentObj != null)
{
// FIRE1 = Pick up/Release
if (Input.GetButtonDown("Fire1"))
{
if (itemPicked != null)
{
// itemPicked.transform.SetParent(null);
((Rigidbody)itemPicked.GetComponent <Rigidbody> ()).isKinematic = false;
itemPicked = null;
}
else if (currentObj.tag == "PickUp")
{
itemPicked = currentObj;
((Rigidbody)itemPicked.GetComponent <Rigidbody> ()).isKinematic = true;
screenPoint = Camera.main.WorldToScreenPoint(itemPicked.transform.position);
offset = itemPicked.transform.position - Camera.main.ScreenToWorldPoint(new Vector3(Input.mousePosition.x, Input.mousePosition.y, screenPoint.z));
// itemPicked.transform.SetParent(transform.parent);
}
}
// FIRE2 = Activate/Desactivate
if (Input.GetButtonDown("Fire2"))
{
Activable activable = currentObj.GetComponent <Activable>();
if (activable != null)
{
activable.Activate();
}
}
//FIRE3 = Rotate
if (Input.GetButtonDown("Fire3"))
{
}
}
if (itemPicked != null)
{
MoveItem();
}
}
// Update is called once per frame
void Update()
{
if (!gameObject.GetComponent <Camera> ().enabled)
{
return;
}
bool stop = false;
if (Input.GetKeyDown(KeyCode.E) || Input.GetKeyDown(KeyCode.Joystick1Button2))
{
Vector3 fwd = transform.TransformDirection(Vector3.forward);
RaycastHit[] hits = Physics.RaycastAll(transform.position, fwd, length);
for (int i = 0; i < hits.Length; i++)
{
RaycastHit hit = hits[i];
// Si on rencontre une porte
if (hit.collider != null && hit.collider.gameObject.CompareTag("Tag_Door"))
{
Doors d = hit.collider.gameObject.GetComponent <Doors> ();
if (d != null)
{
d.Action(gameObject);
}
else
{
if (hit.collider.gameObject.transform.childCount > 0)
{
d = hit.collider.gameObject.transform.GetChild(0).gameObject.GetComponent <Doors> ();
if (d != null)
{
d.Action(gameObject);
}
}
}
}
// Si on rencontre un objet activable
if (hit.collider != null)
{
GameObject go = hit.collider.gameObject;
Activable a = go.GetComponent <Activable> ();
if (!a && go.transform.parent != null)
{
go = go.transform.parent.gameObject;
a = go.GetComponent <Activable> ();
}
if (a)
{
a.Action(gameObject);
stop = a.blockRaycast;
}
}
if (stop)
{
break;
}
}
}
}
private void Awake()
{
m_activableScript = GetComponent <Activable>();
TryGetComponent(out m_renderer);
}
public void Unregister(Activable a)
{
onActivate.RemoveListener(a.Activate);
whileActive.RemoveListener(a.WhileActive);
onDeactivate.RemoveListener(a.Deactivate);
}
public void Register(Activable a)
{
onActivate.AddListener(a.Activate);
whileActive.AddListener(a.WhileActive);
onDeactivate.AddListener(a.Deactivate);
}
// Start is called before the first frame update
void Start()
{
act = GetComponent<Activable>();
StartCoroutine(AnimLight());
}
void ApplyDeactivate(Activable control)
{
control.deactivate();
}
void ApplyActivate(Activable control)
{
control.activate();
}
