// void OnTriggerExit2D(Collider2D coll){
//// if (coll.transform.position.y > transform.position.y) {
//// sr.sortingOrder = originalSorting;
//// }
// }
SpriteRenderer GetSprite(GameObject other)
{
if (other.GetComponent<SpriteRenderer> () != null) {
return other.GetComponent<SpriteRenderer> ();
} else if (other.GetComponentInParent<SpriteRenderer> () != null) { // check the parent
return other.GetComponentInParent<SpriteRenderer> ();
} else {
return null;
}
}
void Start () {
//get this waypoint's marker
WaypointMarker = transform.Find ("WaypointMarker").gameObject;
GameObject p = GameObject.FindWithTag ("Player");
GameObject mc = GameObject.FindWithTag ("MainCamera");
if (p) {
PlayerController = p.GetComponent<CharacterController> () as CharacterController;
} else {
Debug.LogError("No GameObject with tag 'Player' exists. Make sure you have a Player GameComponent and it is tagged, 'Player'.");
}
if (mc) {
GazeCam = mc.GetComponent<Camera>() as Camera;
} else {
Debug.LogError("No GameObject with tag 'MainCamera' exists. Make sure you have a MainCamera GameComponent and it is tagged, 'MainCamera'.");
}
WPNavigator = PlayerController.GetComponent<WayPointNavigator>();
//set all child DetailPoints invisible
foreach(Transform child in transform){
if(child.CompareTag("DetailPoint")){
DetailPoints.Add(child.gameObject);
child.gameObject.SetActive(false);
}
}
//set-up click eventfor waypointMarker
EventTrigger trigger = WaypointMarker.GetComponentInParent<EventTrigger>();
EventTrigger.Entry entry = new EventTrigger.Entry();
entry.eventID = EventTriggerType.PointerClick;
entry.callback.AddListener( (eventData) => { HandleClick(eventData); } );
trigger.triggers.Add(entry);
}
int GetSortingOrder(GameObject other)
{
if (other.GetComponent<SpriteRenderer> () != null) {
return other.GetComponent<SpriteRenderer> ().sortingOrder;
} else if (other.GetComponentInParent<SpriteRenderer> () != null) { // check the parent
return other.GetComponentInParent<SpriteRenderer> ().sortingOrder;
} else {
return 0;
}
}
Person GetPerson(GameObject obj) {
var person = obj.GetComponentInParent<Person> ();
var proxy = obj.GetComponentInParent<PersonProxy> ();
if (!person && proxy && proxy.person) {
person = proxy.person;
}
return person;
}
void OnHitOccurs (GameObject attacker, GameObject defender) {
// TODO: 정리
var player = attacker.GetComponentInParent <Player> ();
if (player) {
dir = new Vector3 (player.Dir.x, player.Dir.y, 0f).normalized;
}
var ai = attacker.GetComponentInParent <AI> ();
if (ai) {
dir = new Vector3 (ai.Dir.x, ai.Dir.y, 0f).normalized;
}
}
public void SetFriendRoom(bool isFriend)
{
if (!isFriend)
{
roomIdObj?.GetComponentInParent <Image>()?.gameObject?.SetActive(false);
}
else
{
roomIdObj?.GetComponentInParent <Image>()?.gameObject?.SetActive(true);
}
}
private void DetectedCollider(GameObject gameObject)
{
var testExplosive = gameObject.GetComponentInParent<ExplosiveObject>();
//print(test);
if(testExplosive != null)
{
var getGroundMover = gameObject.GetComponentInParent<MovementChecker>();
_subscribedCollider = testExplosive;
_groundMover = getGroundMover;
_groundMover.X_PositionChanged += GroundMoverOnPositionChanged;
}
}
public void execute(GameObject player)
{
/*
if (!flag) {
GetComponent<Transform> ().Translate (-2, 0, 0);
} else {
GetComponent<Transform> ().Translate (2, 0, 0);
}
flag = !flag;
*/
player.GetComponentInParent<AudioSource> ().clip = voice;
player.GetComponentInParent<AudioSource> ().Play ();
}
public void OnBeginDrag(PointerEventData eventData)
{
itemBeingDraggedType = gameObject.GetComponent<ItemType>().itemType;
itemBeingDragged = gameObject;
Socket socket = itemBeingDragged.GetComponentInParent<Socket>();
Item i = itemBeingDragged.GetComponent<Item>();
if ( i != null ){
i.turnOffPower();
i.equipped = false;
}
startPosition = gameObject.transform.position;
startParent = gameObject.transform.parent;
gameObject.GetComponent<CanvasGroup>().blocksRaycasts = false;
gameObject.transform.SetParent(_Hover.transform);
// on picking up the item, trigger a circuit change
if ( socket != null && socket.parentCircuit != null ){
//Debug.Log (DateTime.Now.ToString("ssffff") + " IBeginDragHandler");
if ( itemBeingDragged.GetComponent<ItemType>().itemType != ItemTypes.PowerUnit ){
socket.parentCircuit.circuitChange();
}
}
}
private static void AddGNStringText(MenuCommand menuCommand)
{
GameObject go = new GameObject("Text");
GameObjectUtility.SetParentAndAlign(go, menuCommand.context as GameObject);
if(go.GetComponentInParent<Canvas>()== null)
{
var canvas = Object.FindObjectOfType<Canvas>();
if(canvas == null)
{
var goCanvas = new GameObject("Canvas");
canvas = goCanvas.AddComponent<Canvas>();
canvas.renderMode = RenderMode.ScreenSpaceOverlay;
goCanvas.AddComponent<UnityEngine.UI.CanvasScaler>();
goCanvas.AddComponent<UnityEngine.UI.GraphicRaycaster>();
}
go.transform.SetParent(canvas.transform);
go.transform.localPosition = Vector3.zero;
}
go.AddComponent<GNText>();
Undo.RegisterCreatedObjectUndo(go, "Create " + go.name);
Selection.activeObject = go;
if(GNStringManager.instance == null)
{
var sm = new GameObject("StringManager");
sm.AddComponent<GNStringManager>();
}
}
/// <summary>
/// This method conducts a swap
/// </summary>
/// <param name="s"></param>
void ClickShape(GameObject s)
{
if (firstShape == null)
firstShape = s;
else
{
secondShape = s;
GameObject p1 = firstShape.transform.parent.gameObject;
GameObject p2 = secondShape.transform.parent.gameObject;
c1 = firstShape.GetComponentInParent<Cell>();
c2 = secondShape.GetComponentInParent<Cell>();
if (c1.cellID - c2.cellID == 4 ||
c2.cellID - c1.cellID == 4 ||
c1.cellID - c2.cellID == 1 ||
c2.cellID - c1.cellID == 1)
{
firstShape.GetComponent<RectTransform>().SetParent(p2.transform);
secondShape.GetComponent<RectTransform>().SetParent(p1.transform);
c1.inPlace = false;
c1.currentShape = secondShape;
c2.inPlace = false;
c2.currentShape = firstShape;
checkMatch = true;
firstShape = null;
secondShape = null;
}
}
}
void OnParticleCollision(GameObject other)
{
//Die ();
BulletTester bullets = other.GetComponentInParent<BulletTester>();
if(bullets == null) return;
bullets.HitEnemy();
}
public void CmdHallucinateSpawn(GameObject target, float radius, int numMinions, Action<GameObject[], GameObject> completion)
{
List<Node> nodes = GridBehavior.Instance.getNodesNearPos(target.transform.position, radius, node => !node.hasLight && node.canWalk) as List<Node>;
nodes.Sort((a, b) => UnityEngine.Random.Range(-1, 2));
Vector3[] positions = new Vector3[numMinions];
for (int n = 0; n < numMinions; n++)
{
positions[n] = nodes[n].position;
}
GameObject[] minions = new GameObject[numMinions];
for (int n = 0; n < numMinions; n++)
{
var avatar = target.GetComponentInParent<AvatarController>();
Transform spawn = minionContainer;
minions[n] = Instantiate(EnemyPrefab[0], positions[n], Quaternion.identity) as GameObject;
minions[n].transform.SetParent(spawn);
minions[n].GetComponent<MinionController>().enabled = true;
minions[n].GetComponent<MinionController>().SetVisibility(avatar.gameObject);
NetworkServer.Spawn(minions[n]);
TextureRandomizer rnd = minions[n].GetComponent<TextureRandomizer>();
rnd.RandomizeTexture();
}
completion(minions, target);
StartCoroutine(SetGridDirty());
}
public void AbsorbPowerUp( GameObject go)
{
PowerUp pu = go.GetComponentInParent<PowerUp> ();
switch (pu.type) {
case WeaponType.shield:
shieldLevel++;
break;
default:
if( pu.type == weapons[0].type){
Weapon w = GetEmptyWeaponsSlot();
if(w != null)
w.SetType(pu.type);
} else {
ClearWeapons();
weapons[0].SetType(pu.type);
}
break;
}
pu.AbsorbedBy (this.gameObject);
}
protected virtual void CmdDealDamage(GameObject go)
{
var mortalScript = go.GetComponentInParent<MortalObjectScript>();
if (mortalScript != null)
mortalScript.ReceiveDamage (damage);
}
void ChangeEnemyVelocity(GameObject gam)
{
EnemySphere enSphere = gam.GetComponentInParent<EnemySphere>();
if (!gam.name.Contains("Black"))
enSphere.velocity += 5F;
}
void TriggerTeleport(GameObject aColliderGo)
{
PlayerStat playerStat = aColliderGo.GetComponentInParent<PlayerStat> ();
if (playerStat != null) {
OnTriggerTeleport(m_MapToTeleport, m_SpawnPointToTeleport);
}
}
static GameObject GetOrCreateCanvasGameObject()
{
GameObject selected = Selection.activeGameObject;
// Try to find a gameobject that is the selected GO or one if its parents.
Canvas canvas = selected?.GetComponentInParent <Canvas>();
if (IsValidCanvas(canvas))
{
return(selected);
}
// No canvas in selection or its parents? Then use any valid canvas.
// We have to find all loaded Canvases, not just the ones in main scenes.
Canvas[] canvasArray = StageUtility.GetCurrentStageHandle().FindComponentsOfType <Canvas>();
for (int i = 0; i < canvasArray.Length; i++)
{
if (IsValidCanvas(canvasArray[i]))
{
return(canvasArray[i].gameObject);
}
}
// No canvas in the scene at all? Then create a new one.
return(CreateNewUI());
}
public void InteractDoor(GameObject currentObject) {
if (currentObject.name == "Door") {
currentObject.GetComponentInParent<Animator>().SetTrigger ("mayOpen");
if (soundManager.GetComponent<SoundManager> ().myAudioSource [1].isPlaying == false) {
soundManager.GetComponent<SoundManager> ().OpenDoor ();
particleSpark.SetActive (true);
}
}
if (currentObject.name == "DoorBroken") {
currentObject.GetComponentInParent<Animator>().SetTrigger("broken");
particleSpark.SetActive (true);
if (soundManager.GetComponent<SoundManager> ().myAudioSource [1].isPlaying == false) {
soundManager.GetComponent<SoundManager> ().OpenBrokenDoor ();
}
}
}
Rigidbody FindRigidbody(GameObject obj)
{
var body = obj.GetComponent<Rigidbody>();
if (body == null)
body = obj.GetComponentInParent<Rigidbody>();
return body;
}
public void InvokeHitEvent (GameObject attacker, GameObject defender) {
if (OnHitOccurs != null) {
OnHitOccurs (attacker, defender);
}
if (attacker.GetComponentInParent <Player> () != null) {
GameSpeedManager.GetInstance.RequestTimeStop (0.05f, 0.5f, 0.2f);
}
}
public void OnHit(GameObject obj)
{
var other = obj.GetComponentInParent<Entity>();
if (other != null)
{
other.Damage(Damage, entity);
}
}
public void OnSkillOver(GameObject gobject)
{
onOver = true;
XmlReader xr = new XmlReader();
var name = gobject.GetComponentInParent<Skill>().name;
int item = int.Parse(gobject.name) - 1;
info = xr.Read(xr.LoadFile("SkillsDescription"), name, item);
}
string getMyParentCanvasName(GameObject panel)
{
Canvas canvasGO = panel.GetComponentInParent<Canvas> ();
if (canvasGO != null) {
return canvasGO.name;
} else {
return "";
}
}
// Use this for initialization
void Start()
{
tagCameraWithoutBreath = GameObject.FindWithTag("MainCamera");
dock = GameObject.FindObjectOfType<DockToAnimal>();
ssf = tagCameraWithoutBreath.GetComponentInParent<ScreenShakeFeeding>();
gc = GameObject.FindObjectOfType<GameController>();
eh = GameObject.FindObjectOfType<EnableHeat>();
bloodSucked = Shader.Find("Custom/ToonBasicAdjusted");
}
void OnEaten(GameObject eater)
{
CritterCtrl critter = eater.GetComponentInParent<CritterCtrl>();
if(critter != null)
{
critter.Feed(feedAmount);
gameObject.SetActive(false);
}
}
protected override string Usage(GameObject target, Vector3 clickWorldPos)
{
if (target.tag != "Player") return Name + " skill needs to target an explorer.";
var selfAc = target.GetComponent<AvatarNetworkBehavior>();
MinionSpawnManager.Instance.CmdHauntSpawn(HauntDuration, target.transform.position, MinionType.HauntMelee, target.GetComponentInParent<NetworkIdentity>().gameObject);
return null;
}
////////////////////Gathering Functions////////////////////
public void Gather(GameObject selectedObject){
target = selectedObject.transform;
if (target != null) {
targetTerrain = selectedObject.GetComponentInParent<Terrain>();
if (targetTerrain.HasReasource() == true) {
targetTerrain.Graze();
StartCoroutine(ActionMove());
}
}
}
public override void ShowToolTip(GameObject slot){
Slot tmpSlot = slot.GetComponent<Slot>();
if (!tmpSlot.IsEmpty && InventoryManager.Instance.HoverObject == null && !InventoryManager.Instance.selectStackSize.activeSelf && slot.GetComponentInParent<Inventory>().IsOpen){
InventoryManager.Instance.visualTextObject.text = tmpSlot.CurrentItem.GetToolTip(this);
InventoryManager.Instance.SizeTextObject.text = InventoryManager.Instance.visualTextObject.text;
InventoryManager.Instance.tooltipObject.SetActive(true);
float xPos = slot.transform.position.x + 1;
float yPos = slot.transform.position.y - slot.GetComponent<RectTransform>().sizeDelta.y + 42;
InventoryManager.Instance.tooltipObject.transform.position = new Vector2(xPos, yPos);
//InventoryManager.Instance.tooltipObject.transform.position = slot.transform.position;
}
}
void HitObject(GameObject theObject) {
// Do damage to the thing we hit, if possible
var theirDamage = theObject.GetComponentInParent<DamageTaking>();
if (theirDamage) {
theirDamage.TakeDamage(damage);
}
// Do damage to ourself, if possible
var ourDamage = this.GetComponentInParent<DamageTaking>();
if (ourDamage) {
ourDamage.TakeDamage(damageToSelf);
}
}
public void Interact(GameObject other)
{
if (target != null)
return;
// Check what we collided with and see if we are actually able to interact with it.
target = other;
if (other.tag == "RoomCamera") {
other.GetComponentInParent<RoomCamera>().turnedOn = false;
}
else if (other.tag == "RoomLight") {
other.GetComponentInParent<RoomLight>().turnedOn = false;
}
else if (other.layer == enemyLayer) {
other.GetComponent<EnemyBaseBehavior>().swarmed = true;
}
else if (other.tag == "KeypadTrigger") {
other.GetComponent<KeypadTrigger>().active = false;
GetComponent<Renderer>().enabled = false;
}
else {
target = null;
return;
}
// If we did interact, then set our parent and start our death timer.
if (target != null) {
InvokeRepeating("UpdateDisabledTimer", 0f, 1f);
targetOffset = transform.position - target.transform.position;
}
else
{
Debug.Assert(false);
}
// Camera control goes back to the scientist
GameObject.Find("MultipurposeCameraRig").GetComponent<AutoCam>().m_Target = scientistTrans;
Main.S.controlScientist = interacting = true;
}
public void TransferEnergy(GameObject target) {
if (target.tag == "Enemy") {
SoundManager.myInstance.Play("Gun_Shoot_Collectable3");
playerEnergy += energyTransferRate;
target.GetComponent<EnemyHealth>().curHealth -= energyTransferRate;
}
else if (target.tag == "ForceField") {
SoundManager.myInstance.Play("Gun_Shoot_Force_Field2");
playerEnergy -= 2 * energyTransferRate;
target.GetComponentInParent<Forcefield>().health -= 2 * energyTransferRate;
if (playerEnergy < 0) playerEnergy = 0;
}
}
private static bool Prefix(SinkholeEnvironmentalHazard __instance, GameObject player)
{
try
{
if (!NetworkServer.active)
{
return(false);
}
var component = player?.GetComponentInParent <PlayerEffectsController>();
if (component == null)
{
return(false);
}
var sinkholeeffect = component.GetEffect <CustomPlayerEffects.SinkHole>();
var synapseplayer = player.GetPlayer();
if (Vector3.Distance(player.transform.position, __instance.transform.position) <= __instance.DistanceToBeAffected)
{
var allow = true;
if (__instance.SCPImmune && synapseplayer.RealTeam == Team.SCP || synapseplayer.GodMode)
{
allow = false;
}
Synapse.Api.Events.EventHandler.Get.Player.InvokeSinkhole(synapseplayer, __instance, ref allow);
if (allow)
{
synapseplayer.GiveEffect(Api.Enum.Effect.SinkHole);
return(false);
}
}
synapseplayer.GiveEffect(Api.Enum.Effect.SinkHole, 0);
return(false);
}
catch (Exception e)
{
Logger.Get.Error($"Synapse-Event: PlayerWalkOnSinkholeEvent failed!!\n{e}\nStackTrace:\n{e.StackTrace}");
return(true);
}
}
private bool Pick()
{
// Do a raycast into the world based on the user's
// head position and orientation.
Vector3 origin = transform.position;
//Vector3 direction = transform.forward;
//if (transform.parent != null)
//{
// Vector3 offset = transform.parent.position - origin;
// if (Vector3.SqrMagnitude(offset) > float.Epsilon)
// {
// direction = offset.normalized;
// }
//}
RaycastHit hitInfo;
pickingRay = raycastingCamera.ScreenPointToRay(Input.mousePosition);
//bool hit = Physics.Raycast(transform.position, direction, out hitInfo, pickingDistance);
bool hit = Physics.Raycast(pickingRay, out hitInfo, pickingDistance);
if (hit)
{
HitPoint = hitInfo.point;
HitNormal = hitInfo.normal;
HitDistance = hitInfo.distance;
hitObject = hitInfo.collider.gameObject;
bearingSurfaceEntity = hitObject?.GetComponentInParent <EntityData>();
}
else
{
hitObject = null;
bearingSurfaceEntity = null;
}
return(hit);
}
//function to execute in stalk state, contains transitions, and code to maintain distance from player and attempt to avoid being cornered
void stalk()
{
posTimer = 30;
posTimer2 = 25;
if (AttackTimer > 0)
{
AttackTimer -= Time.deltaTime;
}
//print(AttackTimer);
//attack timer reachers 0 attack
if (AttackTimer <= 0)
{
State = InuState.Cornered;
return;
}
AnimState = InuAnim.Creep;
//rayDirection = playerTransform.position - transform.position;
//rayDirection.y = 0;
playerCloseToEnemy = Vector3.Distance(playerTransform.position, transform.position) < StalkDistance;
if (!playerCloseToEnemy)
{
beenTooClose = false;
seen = false;
seen = SeeObject(PlayerObject, LevelMask, home);
if (seen)
{
State = InuState.Chase;
return;
}
foundFootprint = SeeFootprint(allNodes, LevelMask, home);
if (foundFootprint != null)
{
State = InuState.Follow;
return;
}
else if (StartingNode != null)
{
State = InuState.Patrol;
return;
}
else
{
State = InuState.Idle;
return;
}
}
//check to see if player is close enough to trigger cornered state
playerTooCloseToEnemy = Vector3.Distance(playerTransform.position, transform.position) < StartCorneredDistance;
if (playerTooCloseToEnemy)
{
//signify the player is too close to the inu
//print("too close");
beenTooClose = true;
//get the distance from player to inu
newdir = transform.position - playerTransform.position;
//create containers for attempted destinations
destinationNode = null;
secondDestNode = null;
tertDestNode = null;
//get current node based on location
currentLocation = new Vector3(transform.position.x, home.y + 1.5F, transform.position.z);
fromNode = MazeGenerator.getNodeBasedOnLocation(currentLocation);
//print("current location " + new Vector3(transform.position.x, home.y + 1.5F, transform.position.z));
//print("from node " + new Vector3(fromNode.Col * 6 + 8, fromNode.Floor * 30, fromNode.Row * 6 + 8));
//get the player's current node
playerNode = MazeGenerator.getNodeBasedOnLocation(playerTransform.position);
//if the change in x is greater than the change in z try to move in the x direction first
if (Math.Abs(newdir.x) > Math.Abs(newdir.z))
{
//if the change in x is positive
if (newdir.x > 0)
{
//set primary destination to be the node with the next higher value in the x direction
destinationNode = MazeGenerator.getNodeBasedOnLocation(new Vector3((fromNode.Col + 1) * 6 + 8, fromNode.Floor * 30, fromNode.Row * 6 + 8));
//if change in z is positive
if (newdir.z > 0)
{
//set secondary destination to be the node with the next higher value in the z direction
secondDestNode = MazeGenerator.getNodeBasedOnLocation(new Vector3(fromNode.Col * 6 + 8, fromNode.Floor * 30, (fromNode.Row + 1) * 6 + 8));
}
if (newdir.z < 0)
{
secondDestNode = MazeGenerator.getNodeBasedOnLocation(new Vector3(fromNode.Col * 6 + 8, fromNode.Floor * 30, (fromNode.Row - 1) * 6 + 8));
}
}
if (newdir.x < 0)
{
destinationNode = MazeGenerator.getNodeBasedOnLocation(new Vector3((fromNode.Col - 1) * 6 + 8, fromNode.Floor * 30, fromNode.Row * 6 + 8));
if (newdir.z > 0)
{
secondDestNode = MazeGenerator.getNodeBasedOnLocation(new Vector3(fromNode.Col * 6 + 8, fromNode.Floor * 30, (fromNode.Row + 1) * 6 + 8));
}
if (newdir.z < 0)
{
secondDestNode = MazeGenerator.getNodeBasedOnLocation(new Vector3(fromNode.Col * 6 + 8, fromNode.Floor * 30, (fromNode.Row - 1) * 6 + 8));
}
}
}
//if the change in x is the same as the change in the z direction, used rand with two possible values
if (Math.Abs(newdir.x) == Math.Abs(newdir.z))
{
rand = UnityEngine.Random.Range(0, 1);
if (rand == 0)
{
if (newdir.x > 0)
{
destinationNode = MazeGenerator.getNodeBasedOnLocation(new Vector3((fromNode.Col + 1) * 6 + 8, fromNode.Floor * 30, fromNode.Row * 6 + 8));
if (newdir.z > 0)
{
secondDestNode = MazeGenerator.getNodeBasedOnLocation(new Vector3(fromNode.Col * 6 + 8, fromNode.Floor * 30, (fromNode.Row + 1) * 6 + 8));
}
if (newdir.z < 0)
{
secondDestNode = MazeGenerator.getNodeBasedOnLocation(new Vector3(fromNode.Col * 6 + 8, fromNode.Floor * 30, (fromNode.Row - 1) * 6 + 8));
}
}
if (newdir.x < 0)
{
destinationNode = MazeGenerator.getNodeBasedOnLocation(new Vector3((fromNode.Col - 1) * 6 + 8, fromNode.Floor * 30, fromNode.Row * 6 + 8));
if (newdir.z > 0)
{
secondDestNode = MazeGenerator.getNodeBasedOnLocation(new Vector3(fromNode.Col * 6 + 8, fromNode.Floor * 30, (fromNode.Row + 1) * 6 + 8));
}
if (newdir.z < 0)
{
secondDestNode = MazeGenerator.getNodeBasedOnLocation(new Vector3(fromNode.Col * 6 + 8, fromNode.Floor * 30, (fromNode.Row - 1) * 6 + 8));
}
}
}
if (rand == 1)
{
if (newdir.z > 0)
{
destinationNode = MazeGenerator.getNodeBasedOnLocation(new Vector3(fromNode.Col * 6 + 8, fromNode.Floor * 30, (fromNode.Row + 1) * 6 + 8));
if (newdir.x > 0)
{
secondDestNode = MazeGenerator.getNodeBasedOnLocation(new Vector3((fromNode.Col + 1) * 6 + 8, fromNode.Floor * 30, fromNode.Row * 6 + 8));
}
if (newdir.x < 0)
{
secondDestNode = MazeGenerator.getNodeBasedOnLocation(new Vector3((fromNode.Col - 1) * 6 + 8, fromNode.Floor * 30, fromNode.Row * 6 + 8));
}
}
if (newdir.z < 0)
{
destinationNode = MazeGenerator.getNodeBasedOnLocation(new Vector3(fromNode.Col * 6 + 8, fromNode.Floor * 30, (fromNode.Row - 1) * 6 + 8));
if (newdir.x > 0)
{
secondDestNode = MazeGenerator.getNodeBasedOnLocation(new Vector3((fromNode.Col + 1) * 6 + 8, fromNode.Floor * 30, fromNode.Row * 6 + 8));
}
if (newdir.x < 0)
{
secondDestNode = MazeGenerator.getNodeBasedOnLocation(new Vector3((fromNode.Col - 1) * 6 + 8, fromNode.Floor * 30, fromNode.Row * 6 + 8));
}
}
}
}
//if the change in x is less than the change in z try to move in the z direction first
if (Math.Abs(newdir.x) < Math.Abs(newdir.z))
{
if (newdir.z > 0)
{
destinationNode = MazeGenerator.getNodeBasedOnLocation(new Vector3(fromNode.Col * 6 + 8, fromNode.Floor * 30, (fromNode.Row + 1) * 6 + 8));
if (newdir.x > 0)
{
secondDestNode = MazeGenerator.getNodeBasedOnLocation(new Vector3((fromNode.Col + 1) * 6 + 8, fromNode.Floor * 30, fromNode.Row * 6 + 8));
}
if (newdir.x < 0)
{
secondDestNode = MazeGenerator.getNodeBasedOnLocation(new Vector3((fromNode.Col - 1) * 6 + 8, fromNode.Floor * 30, fromNode.Row * 6 + 8));
}
}
if (newdir.z < 0)
{
destinationNode = MazeGenerator.getNodeBasedOnLocation(new Vector3(fromNode.Col * 6 + 8, fromNode.Floor * 30, (fromNode.Row - 1) * 6 + 8));
if (newdir.x > 0)
{
secondDestNode = MazeGenerator.getNodeBasedOnLocation(new Vector3((fromNode.Col + 1) * 6 + 8, fromNode.Floor * 30, fromNode.Row * 6 + 8));
}
if (newdir.x < 0)
{
secondDestNode = MazeGenerator.getNodeBasedOnLocation(new Vector3((fromNode.Col - 1) * 6 + 8, fromNode.Floor * 30, fromNode.Row * 6 + 8));
}
}
}
//get the list of nodes adjacent to the inu's current node
adjacent = fromNode.GetAdjacentNodes();
for (int iter = 0; iter < adjacent.Count; iter++)
{
//if new node, it is recored as tertiary destination
if (adjacent[iter] != destinationNode && adjacent[iter] != secondDestNode && adjacent[iter] != playerNode)
{
tertDestNode = adjacent[iter];
//check to see if tertiary is behind player and thus not valid
inuToPlayer = playerTransform.position - transform.position;
inuToTert = new Vector3(tertDestNode.Col * 6 + 8, tertDestNode.Floor * 30, tertDestNode.Row * 6 + 8) - transform.position;
if (inuToPlayer.x > 0 && inuToTert.x > 0)
{
if (inuToPlayer.z > 0 && inuToTert.z > 0)
{
tertDestNode = null;
}
if (inuToPlayer.z < 0 && inuToTert.z < 0)
{
tertDestNode = null;
}
}
if (inuToPlayer.x < 0 && inuToTert.x < 0)
{
if (inuToPlayer.z > 0 && inuToTert.z > 0)
{
tertDestNode = null;
}
if (inuToPlayer.z < 0 && inuToTert.z < 0)
{
tertDestNode = null;
}
}
}
}
//check if primary and secondary are valid nodes
if (adjacent.Contains(destinationNode) == false)
{
if (destinationNode != null)
{
//print("primary not adjacent " + new Vector3(destinationNode.Col * 6 + 8, fromNode.Floor * 30, destinationNode.Row * 6 + 8));
destinationNode = null;
}
else
{
//print("no primary dest found");
}
}
if (adjacent.Contains(secondDestNode) == false)
{
if (secondDestNode != null)
{
//print("secondary not adjacent " + new Vector3(secondDestNode.Col * 6 + 8, fromNode.Floor * 30, secondDestNode.Row * 6 + 8));
secondDestNode = null;
}
else
{
//print("no secondary dest found");
}
}
//try nodes in order
if (destinationNode == null)
{
//print("primary not valid");
if (secondDestNode == null)
{
//print("secondary not valid");
if (tertDestNode == null)
{
//print("tertiary not valid");
//try to move backwards anyways
newdir.y = 0;
//normalize to get direction only
newdir.Normalize();
//create a scalar
scalar = (float)Math.Sqrt(15);
//scale direction vector to set distace to go
newdir.Scale(new Vector3(scalar, 1, scalar));
//set inu to go from current direction to scalar distance in normalized direction
goal = playerTransform.position + newdir;
wallDistance = newdir.magnitude;
ray = new Ray(playerTransform.position, newdir);
//if wall in the way transition to cornered
if (Physics.Raycast(ray, out rayHit, wallDistance, LevelMask))
{
State = InuState.Cornered;
return;
}
//else move backwards away from player
else
{
agent.ResetPath();
agent.SetDestination(goal);
retreating = true;
return;
}
}
//move to tertiary destination
else
{
//print("trying to go to tert " + new Vector3(tertDestNode.Col * 6 + 8, fromNode.Floor * 30, tertDestNode.Row * 6 + 8));
agent.ResetPath();
agent.SetDestination(new Vector3(tertDestNode.Col * 6 + 8, fromNode.Floor * 30, tertDestNode.Row * 6 + 8));
retreating = true;
return;
}
}
//move to secondary destination
else
{
//print("trying to go to second " + new Vector3(secondDestNode.Col * 6 + 8, fromNode.Floor * 30, secondDestNode.Row * 6 + 8));
agent.ResetPath();
agent.SetDestination(new Vector3(secondDestNode.Col * 6 + 8, fromNode.Floor * 30, secondDestNode.Row * 6 + 8));
retreating = true;
return;
}
}
//move to primary destination
else
{
print("trying to go to primary " + new Vector3(destinationNode.Col * 6 + 8, fromNode.Floor * 30, destinationNode.Row * 6 + 8));
agent.ResetPath();
agent.SetDestination(new Vector3(destinationNode.Col * 6 + 8, fromNode.Floor * 30, destinationNode.Row * 6 + 8));
retreating = true;
return;
}
}
//if player is not close enough for cornered
if (!playerTooCloseToEnemy && beenTooClose == true)
{
retreating = false;
beenTooClose = false;
}
//if not retrreating maintain distance from player
if (retreating != true)
{
agent.ResetPath();
dest = playerTransform.position;
if (Vector3.Distance(transform.position, dest) < 5)
{
agent.ResetPath();
agent.SetDestination(transform.position);
}
else
{
//print("stalking towards player");
agent.SetDestination(dest);
}
}
//if player has tripper kill them, trip not currently implemented
if (hasPlayerTripped())
{
if (UnityEngine.XR.XRDevice.isPresent)
{
player = PlayerObject.GetComponentInParent <Actor>();
GameManager.Instance.ActorKilled(actorID, player);
}
else
{
GameManager.Instance.ActorKilled(actorID, PlayerObject.GetComponent <Actor>());
}
GameManager.Instance.GameOver();
PlayerObject.SetActive(false);
print("GameOver");
}
}
static public void PlaceFurniture(GameObject component, GameObject target, TechType tech)
{
target = target?.GetComponentInParent <SubRoot>()?.gameObject;
Place(component, target, null, tech, true);
}
private IEnumerator PlayerJumpCoroutine()
{
yield return(new WaitForSeconds(0.2f));
player.GetComponentInParent <Rigidbody>().AddForce(Vector3.up * 200);
}
private IEnumerator fireAction()
{
// 更新AR環境碰撞體，等待3幀
SingleObj <DepthMeshColliderCus> .obj.ScanDepthCollider();
yield return(new WaitForSeconds(0.1f));
float timing = 0;
Vector2 raycastPose = getSightPosToScreen();
GameObject hitEnemy = null;
muzzleFire.gameObject.SetActive(true);
muzzleFire.Play();
impact.gameObject.SetActive(true);
fireAudio.Play();
sightAnime.SetBool(animeCtrlName, true);
Ray ray = FirstPersonCamera.ScreenPointToRay(new Vector3(raycastPose.x, raycastPose.y, 0));
while (bullet > 0)
{
raycastPose = getSightPosToScreen();
//Debug.Log(raycastPose);
ray = FirstPersonCamera.ScreenPointToRay(new Vector3(raycastPose.x, raycastPose.y, 0));
gameSceneFire(ray, shotDistance,
(hit) =>
{
impactPos.position = hit.point;
impactPos.LookAt(hit.point - hit.normal);
impactPos.transform.Translate(Vector3.back * 0.01f);
if (!impact.isPlaying)
{
impact.Play();
}
hitEnemy = hit.collider.gameObject;
colliderLog.text = hit.point.ToString();
},
() => { impact.Stop(); });
/*if(hitEnemy == null) //舊版作法，使用AR平面感測
* {
* arCoreFire(raycastPose, (hit) =>
* {
* spark.transform.position = hit.Pose.position;
* spark.transform.rotation = Quaternion.FromToRotation(Vector3.up, hit.Pose.position);
* spark.Play();
* });
* }*/
if (timing >= fireDelay)
{
timing = 0;
bullet--;
//刷新AR的虛擬環境碰撞體(深度感測)
SingleObj <DepthMeshColliderCus> .obj.ScanDepthCollider();
//對目標造成傷害
hitEnemy?.GetComponent <Enemy>()?.recvDamage(damage);
hitEnemy?.GetComponent <BoomBox>()?.recvDamage(damage);
if (Game.mode != Mode.PVE)
{
hitEnemy?.GetComponentInParent <NetworkPlayer>()?.recvDamage(damage);
}
//彈孔殘留效果，延遲5秒後消失(請參考ImpactShowDelay.cs)
if (hitEnemy?.tag == Constants.tagARCollider)
{
GameObject impactDelay = impactPool.getObj();
impactDelay.transform.position = impactPos.position;
impactDelay.transform.rotation = impactPos.rotation;
}
}
hitEnemy = null;
timing += Time.deltaTime;
yield return(0);
}
fireAudio.Stop();
muzzleFire.Stop();
impact.Stop();
muzzleFire.gameObject.SetActive(false);
impact.gameObject.SetActive(false);
sightAnime.SetBool(animeCtrlName, false);
}
/// <summary>
/// Checks whether the GameObject is a valid element
/// </summary>
/// <param name="pointer">Pointer used during determination</param>
/// <param name="obj">Object to check</param>
/// <returns>True if object is valid. False otherwise.</returns>
protected virtual bool ValidElement(UIPointer pointer, GameObject obj)
{
var canvasCheck = obj.GetComponentInParent <Canvas>();
return(pointer.IsValidElement(obj) && (canvasCheck && canvasCheck.enabled ? true : false));
}
public static PhotonView Get(GameObject gameObj)
{
return(gameObj.GetComponentInParent <PhotonView>());
}
public void SetTarget(GameObject activeGameObject)
{
CurrentAnimator = activeGameObject?.GetComponentInParent <Animator>();
}
void Update()
{
// Centre of the screen
PointerEventData pointer = new PointerEventData(EventSystem.current);
pointer.position = new Vector2(Screen.width / 2, Screen.height / 2);
pointer.button = PointerEventData.InputButton.Left;
List <RaycastResult> raycastResults = new List <RaycastResult>();
EventSystem.current.RaycastAll(pointer, raycastResults);
if (raycastResults.Count > 0)
{
// Target is being activating -> fade in anim
if (target == raycastResults[0].gameObject && target != lastActivatedTarget)
{
progress = Mathf.Lerp(1, 0, (endFocusTime - Time.time) / loadingTime);
indicatorFillRT.localScale = Vector3.Lerp(Vector3.zero, Vector3.one, curve.Evaluate(progress));
indicatorFillRawImage.color = Color.Lerp(Color.clear, activeColor, curve.Evaluate(progress));
centerRawImage.color = Color.Lerp(Color.black, Color.white, curve.Evaluate(progress));
if (target.GetComponent <Selectable>())
{
target.GetComponent <Selectable>().OnPointerEnter(pointer);
}
if (Time.time >= endFocusTime && target != lastActivatedTarget)
{
lastActivatedTarget = target;
if (target.GetComponent <ISubmitHandler>() != null)
{
target.GetComponent <ISubmitHandler>().OnSubmit(pointer);
}
else if (target.GetComponentInParent <ISubmitHandler>() != null)
{
target.GetComponentInParent <ISubmitHandler>().OnSubmit(pointer);
}
else if (target.GetComponentInParent <Slider>() != null)
{
lastActivatedTarget = null;
endFocusTime = Time.time + loadingTime;
if (target.GetComponentInParent <Slider>().normalizedValue < 1f - sliderIncrement)
{
target.GetComponentInParent <Slider>().normalizedValue += sliderIncrement;
}
else if (target.GetComponentInParent <Slider>().normalizedValue != 1)
{
target.GetComponentInParent <Slider>().normalizedValue = 1;
}
else
{
target.GetComponentInParent <Slider>().normalizedValue = 0;
}
}
}
}
// Target activated -> fade out anim
else
{
if (target && target.GetComponent <Selectable>())
{
target.GetComponent <Selectable>().OnPointerExit(pointer);
}
if (target != raycastResults[0].gameObject)
{
target = raycastResults[0].gameObject;
endFocusTime = Time.time + loadingTime;
}
progress = Mathf.Lerp(0, 1, (Time.time - endFocusTime) / loadingTime * 2);
indicatorFillRawImage.color = Color.Lerp(Color.white, Color.clear, curve.Evaluate(progress));
centerRawImage.color = Color.Lerp(activeColor, Color.gray, curve.Evaluate(progress));
}
}
// No target -> reset
else
{
lastActivatedTarget = null;
if (target && target.GetComponent <Selectable>())
{
target.GetComponent <Selectable>().OnPointerExit(pointer);
}
target = null;
indicatorFillRT.localScale = Vector3.zero;
centerRawImage.color = Color.gray;
endFocusTime = Time.time + loadingTime;
}
}
protected virtual bool ValidElement(GameObject obj)
{
VRTK_UICanvas canvasCheck = obj.GetComponentInParent <VRTK_UICanvas>();
return(canvasCheck != null && canvasCheck.enabled ? true : false);
}
private void OnDrawGizmosSelected()
{
mousePos = Event.current.mousePosition;
// Set color
switch (mode)
{
case DungeonCreatorMode.DEFAULT:
Gizmos.color = Color.gray;
break;
case DungeonCreatorMode.ADD:
Gizmos.color = Color.blue;
break;
case DungeonCreatorMode.REMOVE:
Gizmos.color = Color.red;
break;
}
bool newDoorHovered = false;
mouseHoverDoor = GetMouseOverlap(typeof(Door));
if (mouseHoverDoor)
{
Gizmos.DrawCube(mouseHoverDoor.GetComponent <Door>().SocketPoint.transform.position, new Vector3(0.5f, 0.5f, 0.5f));
if (lastMouseHoverDoor == null && mouseHoverDoor.GetComponentInParent <Room>().gameObject != ghostRoom)
{
lastMouseHoverDoor = mouseHoverDoor.GetComponent <Door>();
newDoorHovered = true;
}
else if (mouseHoverDoor != lastMouseHoverDoor.gameObject && mouseHoverDoor.GetComponentInParent <Room>().gameObject != ghostRoom)
{
lastMouseHoverDoor = mouseHoverDoor.GetComponent <Door>();
newDoorHovered = true;
}
}
// Actions
switch (mode)
{
case DungeonCreatorMode.DEFAULT:
break;
case DungeonCreatorMode.ADD:
// Spawn ghost if mouse hovered door
if (!ghostRoom && mouseHoverDoor && selectedRoomDoor && selectedRoomPrefab)
{
oldSelectedRoomDoorName = selectedRoomDoor.name;
InitGhostRoom(lastMouseHoverDoor);
}
if (ghostRoom && newDoorHovered && lastMouseHoverDoor && selectedRoomDoor && selectedRoomPrefab)
{
oldSelectedRoomDoorName = selectedRoomDoor.name;
RemoveGhostRoom();
InitGhostRoom(lastMouseHoverDoor);
}
break;
case DungeonCreatorMode.REMOVE:
GameObject currentHoverNode = GetMouseOverlap(typeof(Node));
GameObject currentHoverRoom = null;
if (currentHoverNode)
{
currentHoverRoom = currentHoverNode.GetComponentInParent <Room>().gameObject;
}
// We are selecting only if cursor on room, if no room - selection is hold. Also we can't remove start room
if (mouseHoverRoom != currentHoverRoom && currentHoverRoom != null && currentHoverRoom.GetComponent <Room>().Type != Room.RoomType.STARTROOM)
{
mouseHoverRoom = currentHoverRoom;
}
if (mouseHoverRoom)
{
Gizmos.DrawCube(mouseHoverRoom.transform.position, new Vector3(1f, 1f, 1f));
}
break;
}
}
void DeleteObj(GameObject hit)
{
GameObject Top = null;
GameObject Down = null;
GameObject Left = null;
GameObject Right = null;
GameObject LeftDown = null;
GameObject RightDown = null;
foreach (GameObject go in player.playerModules)
{
if (go.transform.position.x == hit.transform.position.x && go.transform.position.y == hit.transform.position.y + 1)
{
Top = go;
}
else if (go.transform.position.x == hit.transform.position.x && go.transform.position.y == hit.transform.position.y - 1)
{
Down = go;
}
else if (go.transform.position.x == hit.transform.position.x - GameManager.offsetX && go.transform.position.y == hit.transform.position.y + GameManager.offsetY)
{
Left = go;
}
else if (go.transform.position.x == hit.transform.position.x + GameManager.offsetX && go.transform.position.y == hit.transform.position.y + GameManager.offsetY)
{
Right = go;
}
else if (go.transform.position.x == hit.transform.position.x + GameManager.offsetX && go.transform.position.y == hit.transform.position.y - GameManager.offsetY)
{
RightDown = go;
}
else if (go.transform.position.x == hit.transform.position.x - GameManager.offsetX && go.transform.position.y == hit.transform.position.y - GameManager.offsetY)
{
LeftDown = go;
}
}
GameObject tempObj = hit.transform.gameObject;
RemoveModuleFromPlayer(hit.transform.gameObject);
player.CheckIfConnectedToCore();
bool legalDeletion = true;
if (Top != null)
{
if (Top.name != "coreModule")
{
if (Top.GetComponentInParent <Module>().hasCore == false)
{
legalDeletion = false;
}
}
}
if (Down != null)
{
if (Down.name != "coreModule")
{
if (Down.GetComponentInParent <Module>().hasCore == false)
{
if (legalDeletion == true)
{
legalDeletion = false;
}
}
}
}
if (Left != null)
{
if (Left.name != "coreModule")
{
if (Left.GetComponentInParent <Module>().hasCore == false)
{
if (legalDeletion == true)
{
legalDeletion = false;
}
}
}
}
if (Right != null)
{
if (Right.name != "coreModule")
{
if (Right.GetComponentInParent <Module>().hasCore == false)
{
if (legalDeletion == true)
{
legalDeletion = false;
}
}
}
}
if (RightDown != null)
{
if (RightDown.name != "coreModule")
{
if (RightDown.GetComponentInParent <Module>().hasCore == false)
{
if (legalDeletion == true)
{
legalDeletion = false;
}
}
}
}
if (LeftDown != null)
{
if (LeftDown.name != "coreModule")
{
if (LeftDown.GetComponentInParent <Module>().hasCore == false)
{
if (legalDeletion == true)
{
legalDeletion = false;
}
}
}
}
if (legalDeletion)
{
AddOrDeduceModuleFromPlayerInventory(hit.transform.gameObject.name, true);
RemoveModuleFromPlayer(hit.transform.gameObject);
tempObj.GetComponent <Animation>().clip = moduleBeingDeleted;
tempObj.GetComponent <Animation>().Play();
Destroy(tempObj, moduleBeingDeleted.length);
RegenerateBuildingSpots();
player.GetModules();
}
else
{
player.playerModules.Add(tempObj);
}
player.alreadyLooked.Clear();
foreach (GameObject go in GameObject.FindGameObjectsWithTag("Modules"))
{
if (go != null)
{
if (go.name != "coreModule")
{
go.GetComponentInParent <Module>().hasCore = false;
}
}
}
player.CalculateMovement();
}
protected virtual void Start()
{
_activable = _activableObject?.GetComponent <IActivable>() ?? _activableObject?.GetComponentInChildren <IActivable>() ?? _activableObject?.GetComponentInParent <IActivable>();
SetActiveColor(AccessGrant.None);
}
protected virtual void LateUpdate()
{
var points = raycaster.BreakPoints;
var pointCount = points.Count;
var result = raycaster.FirstRaycastResult();
if ((showOnHitOnly && !result.isValid) || pointCount <= 1)
{
reticleForDefaultRay.gameObject.SetActive(false);
reticleForCurvedRay.gameObject.SetActive(false);
return;
}
var isCurvedRay = raycaster.CurrentSegmentGenerator() != null;
if (reticleForDefaultRay != null)
{
reticleForDefaultRay.gameObject.SetActive(!isCurvedRay);
}
if (reticleForCurvedRay != null)
{
reticleForCurvedRay.gameObject.SetActive(isCurvedRay);
}
var targetReticle = isCurvedRay ? reticleForCurvedRay : reticleForDefaultRay;
if (result.isValid)
{
if (targetReticle != null)
{
targetReticle.position = result.worldPosition;
targetReticle.rotation = Quaternion.LookRotation(result.worldNormal, raycaster.transform.forward);
if (autoScaleReticle)
{
// Set the reticle size based on sizeInPixels, references:
// https://answers.unity.com/questions/268611/with-a-perspective-camera-distance-independent-siz.html
Vector3 a = Camera.main.WorldToScreenPoint(targetReticle.position);
Vector3 b = new Vector3(a.x, a.y + sizeInPixels, a.z);
Vector3 aa = Camera.main.ScreenToWorldPoint(a);
Vector3 bb = Camera.main.ScreenToWorldPoint(b);
targetReticle.localScale = Vector3.one * (aa - bb).magnitude;
}
}
hitTarget = result.gameObject;
hitDistance = result.distance;
}
else
{
if (targetReticle != null)
{
targetReticle.position = points[pointCount - 1];
targetReticle.rotation = Quaternion.LookRotation(points[pointCount - 1] - points[pointCount - 2], raycaster.transform.forward);
}
hitTarget = null;
hitDistance = 0f;
}
// Change reticle material according to IReticleMaterialChanger
var matChanger = hitTarget == null ? null : hitTarget.GetComponentInParent <IMaterialChanger>();
var newMat = matChanger == null ? null : matChanger.reticleMaterial;
if (m_matFromChanger != newMat)
{
m_matFromChanger = newMat;
if (newMat != null)
{
SetReticleMaterial(newMat);
}
else if (defaultReticleMaterial != null)
{
SetReticleMaterial(defaultReticleMaterial);
}
}
}
private bool ValidElement(GameObject obj)
{
var canvasCheck = obj.GetComponentInParent <VRTK_UICanvas>();
return(canvasCheck && canvasCheck.enabled ? true : false);
}
protected virtual bool ValidElement(GameObject obj)
{
var canvasCheck = obj.GetComponentInParent <Pvr_UICanvas>();
return(canvasCheck && canvasCheck.enabled ? true : false);
}
private void RotateParentObjectXAxis()
{
Rigidbody rigibody = character.GetComponentInParent <Rigidbody>();
rigibody.transform.localRotation = Quaternion.AngleAxis(mouseLook.x, character.transform.up);
}
private void PlaceTileAsObject(GameObject goTilemap, SuperTile tile, int cx, int cy, TileIdMath tileId, Vector3Int pos3)
{
Assert.IsNotNull(goTilemap.GetComponentInParent <SuperMap>());
Assert.IsNotNull(goTilemap.GetComponentInParent <SuperLayer>());
var superMap = goTilemap.GetComponentInParent <SuperMap>();
var superLayer = goTilemap.GetComponentInParent <SuperLayer>();
var color = new Color(1, 1, 1, superLayer.CalculateOpacity());
string tileName = string.Format("tile ({0}, {1})", cx, cy);
var goTRS = new GameObject(string.Format("{0} (TRS)", tileName));
goTilemap.AddChildWithUniqueName(goTRS);
// Create a faux SuperObject component to add to our placed tile
// We need this in case we have custom scripts that are looking for tile object via component
{
var tileObject = goTRS.AddComponent <SuperObject>();
tileObject.m_Id = m_ObjectIdCounter++;
tileObject.m_TiledName = string.Format("AsObject_{0}", tileObject.m_Id);
tileObject.m_X = pos3.x * superMap.m_TileWidth;
tileObject.m_Y = -pos3.y * superMap.m_TileHeight;
tileObject.m_Width = tile.m_Width;
tileObject.m_Height = tile.m_Height;
tileObject.m_TileId = (uint)tile.m_TileId;
tileObject.m_Visible = true;
// Does the tile have any properties?
if (!tile.m_CustomProperties.IsEmpty())
{
var component = tileObject.gameObject.AddComponent <SuperCustomProperties>();
component.m_Properties = new List <CustomProperty>();
component.m_Properties.CombineFromSource(tile.m_CustomProperties);
}
}
Vector3 translate, rotate, scale;
tile.GetTRS(tileId.FlipFlags, m_MapComponent.m_Orientation, out translate, out rotate, out scale);
var cellPos = superMap.CellPositionToLocalPosition(pos3.x, pos3.y);
translate.x += cellPos.x;
translate.y += cellPos.y;
if (m_MapComponent.m_Orientation == MapOrientation.Isometric || m_MapComponent.m_Orientation == MapOrientation.Staggered)
{
translate.x -= SuperImportContext.MakeScalar(m_MapComponent.m_TileWidth) * 0.5f;
}
else if (m_MapComponent.m_Orientation == MapOrientation.Hexagonal)
{
translate.x -= SuperImportContext.MakeScalar(m_MapComponent.m_TileWidth) * 0.5f;
translate.y -= SuperImportContext.MakeScalar(m_MapComponent.m_TileHeight) * 0.5f;
}
// Add the game object for the tile
goTRS.transform.localPosition = translate;
goTRS.transform.localRotation = Quaternion.Euler(rotate);
goTRS.transform.localScale = scale;
// Add the sprite renderer component
var renderer = goTRS.AddComponent <SpriteRenderer>();
renderer.sprite = tile.m_Sprite;
renderer.color = color;
AssignMaterial(renderer);
AssignSpriteSorting(renderer);
if (!tile.m_AnimationSprites.IsEmpty())
{
var tileAnimator = goTRS.AddComponent <TileObjectAnimator>();
tileAnimator.m_AnimationFramerate = SuperImportContext.Settings.AnimationFramerate;
tileAnimator.m_AnimationSprites = tile.m_AnimationSprites;
}
// Add any colliders that may be on the tile object
tile.AddCollidersForTileObject(goTRS, SuperImportContext);
}
private IEnumerator fireAction()
{
// 更新AR環境碰撞體，等待3幀
SingleObj <DepthMeshColliderCus> .obj.ScanDepthCollider();
yield return(new WaitForSeconds(0.1f));
Vector2 raycastPose = getSightPosToScreen();
GameObject hitEnemy = null;
muzzleFire.gameObject.SetActive(true);
muzzleFire.Play();
impact.gameObject.SetActive(true);
fireAudio.Play();
Ray ray = FirstPersonCamera.ScreenPointToRay(new Vector3(raycastPose.x, raycastPose.y, 0));
gameSceneFire(ray, shotDistance, (hit) =>
{
impactPos.position = hit.point;
impactPos.LookAt(hit.point - hit.normal);
impactPos.transform.Translate(Vector3.back * 0.01f);
if (!impact.isPlaying)
{
impact.Play();
}
hitEnemy = hit.collider.gameObject;
}, () => { impact.Stop(); });
/*if (hitEnemy == null)
* {
* arCoreFire(raycastPose, (hit) =>
* {
* impact.transform.position = hit.Pose.position;
* impact.transform.rotation = Quaternion.FromToRotation(Vector3.up, hit.Pose.position);
* impact.Play();
* });
* }*/
if (loaded)
{
hitEnemy?.GetComponent <Enemy>()?.recvDamage(damage * 1.5f);
hitEnemy?.GetComponent <BoomBox>()?.recvDamage(damage * 1.5f);
if (Game.mode != Mode.PVE)
{
hitEnemy?.GetComponentInParent <NetworkPlayer>()?.recvDamage(damage * 1.5f);
}
}
else
{
hitEnemy?.GetComponent <Enemy>()?.recvDamage(damage);
hitEnemy?.GetComponent <BoomBox>()?.recvDamage(damage);
if (Game.mode != Mode.PVE)
{
hitEnemy?.GetComponentInParent <NetworkPlayer>()?.recvDamage(damage);
}
}
//彈孔殘留效果，延遲5秒後消失(請參考ImpactShowDelay.cs)
if (hitEnemy?.tag == Constants.tagARCollider)
{
GameObject impactDelay = impactPool.getObj();
impactDelay.transform.position = impactPos.position;
impactDelay.transform.rotation = impactPos.rotation;
}
loaded = false;
sightAnime.SetBool(animeCtrlName, true);
yield return(new WaitForSeconds(0.3f));
//fireAudio.Stop();
muzzleFire.gameObject.SetActive(false);
impact.gameObject.SetActive(false);
sightAnime.SetBool(animeCtrlName, false);
}
void OnMouseOver()
{
angry.GetComponentInParent <Animator>().enabled = true;
resolving.GetComponent <Animator>().Play("ResolvingBigger");
}
public void respawnPellet(GameObject p)
{
p.GetComponentInParent <Transform>().position = tiles[Random.Range(0, tiles.Length)].pelletLocation;
}
protected virtual void Start()
{
_activable = _activableObject?.GetComponent <IActivable>() ?? _activableObject?.GetComponentInChildren <IActivable>() ?? _activableObject?.GetComponentInParent <IActivable>();
SetActiveColor(_active);
if (_triggerOnStart)
{
SetActive(_active);
}
}
private void PerformShift()
{
// the focus object must be moved
Debug.Assert(focusObject.GetComponentInParent <VtsObjectShiftingOriginBase>());
// compute the transformation change
double[] originalNavigationPoint = umap.UnityToVtsNavigation(zero3d);
double[] targetNavigationPoint = umap.UnityToVtsNavigation(VtsUtil.U2V3(focusObject.transform.position));
if (!VtsMapMakeLocal.MakeLocal(umap, targetNavigationPoint))
{
Debug.Assert(false, "failed shifting origin");
return;
}
Vector3 move = -focusObject.transform.position;
float Yrot = (float)(targetNavigationPoint[0] - originalNavigationPoint[0]) * Mathf.Sign((float)originalNavigationPoint[1]);
// find objects that will be transformed
var objs = new System.Collections.Generic.List <VtsObjectShiftingOriginBase>();
foreach (VtsObjectShiftingOriginBase obj in FindObjectsOfType <VtsObjectShiftingOriginBase>())
{
// ask if the object allows to be transformed by this map
if (obj.enabled && obj.OnBeforeOriginShift(this))
{
objs.Add(obj);
}
}
// actually transform the objects
foreach (VtsObjectShiftingOriginBase obj in objs)
{
// only transform object's topmost ancestor - its childs will inherit the change
// an object is shifted only once even if it has multiple VtsObjectShiftingOriginBase components
if (!obj.transform.parent || !obj.transform.parent.GetComponentInParent <VtsObjectShiftingOriginBase>() &&
obj == obj.GetComponents <VtsObjectShiftingOriginBase>()[0])
{
obj.transform.localPosition += move;
obj.transform.RotateAround(Vector3.zero, Vector3.up, Yrot);
}
}
// notify the object that it was transformed
foreach (VtsObjectShiftingOriginBase obj in objs)
{
obj.OnAfterOriginShift();
}
// force all objects cameras to recompute positions -> improves precision
foreach (VtsCameraBase cam in FindObjectsOfType <VtsCameraBase>())
{
cam.OriginShifted();
}
// force all collider probes to recompute positions -> improves precision
// warning: this has big performance impact!
if (updateColliders)
{
foreach (VtsColliderProbe col in FindObjectsOfType <VtsColliderProbe>())
{
col.OriginShifted();
}
}
}
protected virtual void LateUpdate()
{
var points = raycaster.BreakPoints;
var pointCount = points.Count;
var result = raycaster.FirstRaycastResult();
if ((showOnHitOnly && !result.isValid) || pointCount <= 1)
{
reticleForDefaultRay.gameObject.SetActive(false);
reticleForCurvedRay.gameObject.SetActive(false);
return;
}
var isCurvedRay = raycaster.CurrentSegmentGenerator() != null;
if (reticleForDefaultRay != null)
{
reticleForDefaultRay.gameObject.SetActive(!isCurvedRay);
}
if (reticleForCurvedRay != null)
{
reticleForCurvedRay.gameObject.SetActive(isCurvedRay);
}
var targetReticle = isCurvedRay ? reticleForCurvedRay : reticleForDefaultRay;
if (result.isValid)
{
if (targetReticle != null)
{
targetReticle.position = result.worldPosition;
targetReticle.rotation = Quaternion.LookRotation(result.worldNormal, raycaster.transform.forward);
}
hitTarget = result.gameObject;
hitDistance = result.distance;
#region
hitTarget.transform.SetParent(Righthand.transform);
hitTarget.transform.DOLocalMove(Vector3.zero + Vector3.forward * 0.1f, 2);
#endregion
}
else
{
if (targetReticle != null)
{
targetReticle.position = points[pointCount - 1];
targetReticle.rotation = Quaternion.LookRotation(points[pointCount - 1] - points[pointCount - 2], raycaster.transform.forward);
}
hitTarget = null;
hitDistance = 0f;
}
// Change reticle material according to IReticleMaterialChanger
var matChanger = hitTarget == null ? null : hitTarget.GetComponentInParent <IMaterialChanger>();
var newMat = matChanger == null ? null : matChanger.reticleMaterial;
if (m_matFromChanger != newMat)
{
m_matFromChanger = newMat;
if (newMat != null)
{
SetReticleMaterial(newMat);
}
else if (defaultReticleMaterial != null)
{
SetReticleMaterial(defaultReticleMaterial);
}
}
}
// Called regardless of if there are non-kinematic RigidBody's involved
private void ProcessCollision(GameObject otherGameObject)
{
if (otherGameObject.layer == LayerMask.NameToLayer("BaseLevel"))
{
}
else if (otherGameObject.layer == LayerMask.NameToLayer("Props"))
{
}
else if (otherGameObject.layer == LayerMask.NameToLayer("Enemies"))
{
DamageObject damageObj = otherGameObject.GetComponentInParent <DamageObject>();
if (damageObj != null)
{
if (GameCoordinator.Instance.Health > 0)
{
GameCoordinator.Instance.Health -= damageObj.Value;
if (GameCoordinator.Instance.Health <= 0)
{
GameCoordinator.Instance.Health = 0;
}
Debug.Log($"Took damage {damageObj.Value} from enemy {otherGameObject.name}");
CheckWinLossConditions();
}
}
}
else if (otherGameObject.layer == LayerMask.NameToLayer("Player"))
{
}
else if (otherGameObject.layer == LayerMask.NameToLayer("Collectables"))
{
if (!m_IsGameOver)
{
CollectableObject co = otherGameObject.GetComponentInParent <CollectableObject>();
if (co != null)
{
GameCoordinator.Instance.Health += co.RechargeValue;
GameCoordinator.Instance.Ammo += co.AmmoValue;
if (co.IsLevelToken)
{
m_LevelTokens.Add(otherGameObject.name);
}
}
Debug.Log("Collected " + otherGameObject.name);
Destroy(otherGameObject);
CheckWinLossConditions();
}
}
else if (otherGameObject.layer == LayerMask.NameToLayer("PlayerProjectiles"))
{
}
else if (otherGameObject.layer == LayerMask.NameToLayer("EnemyProjectiles"))
{
DamageObject damageObj = otherGameObject.GetComponentInParent <DamageObject>();
if (damageObj != null)
{
if (GameCoordinator.Instance.Health > 0)
{
GameCoordinator.Instance.Health -= damageObj.Value;
if (GameCoordinator.Instance.Health <= 0)
{
GameCoordinator.Instance.Health = 0;
}
Debug.Log($"Took damage {damageObj.Value} from projectile {otherGameObject.name}");
CheckWinLossConditions();
}
}
}
}
private int?GetPID(GameObject model)
{
DepNode parentNode = model.GetComponentInParent <DepNode>();
return(parentNode.NodeID);
}
public bool Check(GameObject go)
{
return(go.GetComponentInParent <CharacterController>() != null);
}
