private void tryTarget(Targetable target) { foreach (Unit unit in selectScript.selectedUnits) { unit.getTargeterScript().CmdSetTarget(target.gameObject); } }
public override int GetHashCode() { int hash = 1; if (ResourceName.Length != 0) { hash ^= ResourceName.GetHashCode(); } if (HasId) { hash ^= Id.GetHashCode(); } if (HasCode) { hash ^= Code.GetHashCode(); } if (HasName) { hash ^= Name.GetHashCode(); } if (HasTargetable) { hash ^= Targetable.GetHashCode(); } if (_unknownFields != null) { hash ^= _unknownFields.GetHashCode(); } return(hash); }
private void Update() { Targetable target = targeter.GetTarget(); if (target == null) { return; } if (!CanFireAtTarget()) { return; } Quaternion targetRot = Quaternion.LookRotation( target.transform.position - transform.position); transform.rotation = Quaternion.RotateTowards( transform.rotation, targetRot, rotSpeed * Time.deltaTime); if (Time.time > (1f / fireRate) + lastFireTime) { Quaternion projectileRot = Quaternion.LookRotation( target.GetAimAtPoint().position - projectileSpawnPoint.position); GameObject projectile = Instantiate( projectilePf, projectileSpawnPoint.position, projectileRot); NetworkServer.Spawn(projectile, connectionToClient); lastFireTime = Time.time; } }
void Hit(NodeBehaviour targetNode, Targetable pTarget) { Debug.Log("Target Node " + targetNode); Debug.Log("Targetable " + pTarget); if (pTarget.GetComponent <Pawn>() != null) { double hitChance = 1 - (1 - 0.5) * (Vector3.Distance(owner.transform.position, targetNode.transform.position) - 1) / (range - 1); if (RNG.NextDouble() < hitChance) { double accuracy = Vector3.Distance(targetNode.transform.position, pTarget.GetComponent <Pawn>().transform.position) / 200d; double tmpDamageMod = (1 - accuracy) * RNG.NextDouble() + accuracy; if (tmpDamageMod > 1d) { tmpDamageMod = 1d; } int tmpDamage = (int)System.Math.Round((double)damage * tmpDamageMod); if (tmpDamage < 1) { tmpDamage = 1; } Debug.Log(owner + " hit " + (pTarget.GetComponent <Pawn>()) + " and dealt " + tmpDamage + " damage."); pTarget.GetComponent <Health>().Damage(owner, tmpDamage); } } else if (pTarget.GetComponent <DestroyableProp>() != null) { pTarget.GetComponent <Health>().Damage(owner, 1); } }
private void Update() { Targetable currentTarget = targeter.GetTarget(); if (currentTarget != null) { if (Vector3.Distance(transform.position, currentTarget.transform.position) < chaseDistance) { agent.ResetPath(); return; } agent.SetDestination(currentTarget.transform.position); return; } if (!agent.hasPath) { return; } if (agent.remainingDistance > agent.stoppingDistance) { return; } agent.ResetPath(); }
private void Update() { Targetable target = targeter.GetTarget(); if (target == null) { return; } if (!CanFireAtTarget()) { return; } // if we are here, we are in range. Now we want to face Quaternion targetRotation = Quaternion.LookRotation(target.transform.position - transform.position); transform.rotation = Quaternion.RotateTowards(transform.rotation, targetRotation, rotationSpeed * Time.deltaTime); // using rotation speed * time.delta helps with lag if (Time.time > (1 / fireRate) + lastFireTime) { Quaternion projectileRotation = Quaternion.LookRotation(target.GetAimAtPoint().position - projectileSpawnPoint.position); GameObject projectileInstance = Instantiate(projectilePrefab, projectileSpawnPoint.position, projectileRotation); NetworkServer.Spawn(projectileInstance, connectionToClient); lastFireTime = Time.time; } }
private void Update() { Targetable target = targeter.GetTarget(); if (target == null) { return; } if (!CanFireAtTarget()) { return; } if (Time.time > (1 / fireRate) + lastFireTime && isEnabled) { Quaternion targetRotation = Quaternion.LookRotation(target.transform.position - transform.position); transform.rotation = Quaternion.RotateTowards( transform.rotation, targetRotation, rotationSpeed * Time.deltaTime); Quaternion projectileRotation = Quaternion.LookRotation( target.GetAimAtPoint().position - projectileSpawnPoint.position); GameObject swordInstance = Instantiate(swordPrefab, projectileSpawnPoint.transform); NetworkServer.Spawn(swordPrefab, connectionToClient); swordInstance.transform.parent = transform; lastFireTime = Time.time; } }
private void TryTarget(Targetable targetable) { foreach (UnitController unitController in _unitSelectionHandler.SelectionUnits) { unitController.Targeter.SetTarget(targetable.gameObject); } }
private void Update() { Targetable target = targeterScript.getTarget(); if (target != null) { if ((target.transform.position - transform.position).sqrMagnitude > chaceRange * chaceRange) { agent.SetDestination(target.transform.position); } else if (agent.hasPath) { agent.ResetPath(); } return; } if (agent.hasPath) { if (agent.remainingDistance < agent.stoppingDistance) { agent.ResetPath(); } } }
private void startHoverForTarget(Targetable target) { NodeData actionNode = selected.getNode(); float carryingEdgeExpected = selected.expectedVisibilityModifier(); EdgeData carryingEdge = null; if (target is NodeData) { if (graphUtility.getConnectedNodes(actionNode).Contains((NodeData)target)) { carryingEdge = graphUtility.getConnectingEdge(actionNode, (NodeData)target); carryingEdgeExpected += carryingEdge.getExpectedVisibilityIncrease(selected.CarryingEdgeVisibilityIncreaseScaleParameter, selected.CarryingEdgeMaxVisibilityIncrease, true); } } bool didCarryingEdge = false; graphUtility.VisitEdgesBetweenNodesWithVisibility(turnController.CurrentPlayer.StartingNode, actionNode, selected.PathVisibilityIncreaseScaleParameter, (edge, increaseScaleParameter) => { float expected = edge.getExpectedVisibilityIncrease(increaseScaleParameter, edge.getMaxEdgeVisibilityIncrease(selected.PathMaxVisibilityIncrease)); bool isCarryingEdge = edge != null && edge == carryingEdge; if (isCarryingEdge) { expected += carryingEdgeExpected; didCarryingEdge = true; } showEdgeText(edge, expected); } ); if (carryingEdge != null && !didCarryingEdge) { showEdgeText(carryingEdge, carryingEdgeExpected); } }
protected virtual void AttachTarget(Targetable target, RaycastHit targettingInfo) { if (HasTarget()) { ReleaseTarget(); } m_OwnTarget = target; if (null == target) { return; } var sourceTransform = GetTargettingSource(); m_TargetDistance = (target.transform.position - sourceTransform.position).magnitude; m_TargetRotation = target.gameObject.transform.rotation; m_SourceRotation = sourceTransform.rotation; m_TargettingHandle = (GameObject)Instantiate(TargettingHandleTemplate); m_TargettingHandle.transform.position = target.transform.position; m_TargettingHandle.transform.rotation = target.transform.rotation; Rigidbody handleRB = m_TargettingHandle.GetComponent <Rigidbody>(); if (null != handleRB && null != SourcePhysicsHandle) { SourcePhysicsHandle.connectedBody = handleRB; } target.AttachToTargettingSource(this); }
public virtual void InputUp() { if (CurrentTarget != null) { Targetable Temp = PlayerController.Instance.GetTargetableAtMousePosition(); if (Temp != CurrentTarget) { CurrentTarget = null; return; } if (CurrentTarget is Unit) { UIManager.Instance.OpenUnitScreen(CurrentTarget as Unit); Debug.Log("Unit selected"); } if (CurrentTarget is UnitSpawner) { UIManager.Instance.OpenBuildingScreen(CurrentTarget as UnitSpawner); Debug.Log("building selected"); } } CurrentTarget = null; }
override protected void doActivate(Targetable target) { NodeData otherNode = target.GetComponent <NodeData>(); NodeData thisNode = getNode(); EdgeData edge = graphUtility.getConnectingEdge(thisNode, otherNode); if (edge.direction == EdgeData.EdgeDirection.Unusable) { return; } bool isWin = gen.NextDouble() <= getProbabilityOfWin(target); // Take node if (isWin) { graphUtility.CaptureNode(otherNode, thisNode); } if (effect != null) { effect.additionalEffect(thisNode, target, isWin); } effect = null; }
public double getProbabilityOfWin(Targetable target) { NodeData otherNode = target.GetComponent <NodeData>(); NodeData thisNode = getNode(); bool isStrong = (otherNode.type == strongAgainst); // Find attacker attack score and defender defense score int defense = otherNode.power; int attack = thisNode.power; int minAttack = attack / 2; int maxAttack = attack * (isStrong ? 3 : 2); // Determine if node is captured double probability = 0; if (defense <= minAttack) { probability = 1; } else if (defense >= maxAttack) { probability = 0; } else { probability = ((double)(maxAttack - defense)) / ((double)(maxAttack - minAttack)); } return(probability); }
[ServerCallback] //Stops client from logging. private void Update() { Targetable target = targeter.GetTarget(); if (target != null) { //Done this way since its called in Update Every frame when target is not null. if ((target.transform.position - transform.position).sqrMagnitude > chaseRange * chaseRange) //Really Efficient way to check distance between unit and target { //Chase agent.SetDestination(target.transform.position); } else if (agent.hasPath) { //stop chasing agent.ResetPath(); } return; } //Once the units get to their spot it clears path so units stop. if (!agent.hasPath) { return; } if (agent.remainingDistance > agent.stoppingDistance) { return; } agent.ResetPath(); }
/// <summary> /// The delay configuration for the attacking /// </summary> /// <param name="origin"> /// The point the attack will be fired from /// </param> /// <param name="enemy"> /// The enemy to attack /// </param> public void AttackEnemy(Vector3 origin, Targetable enemy) { m_Enemy = enemy; m_Origin = origin; m_Timer.Reset(); m_PauseTimer = false; }
private void Update() { var forward = _trackedObj.transform.TransformDirection(Vector3.forward); if (_device.index == _rightControllerIndex) { var fwd = _trackedObj.transform.TransformDirection(Vector3.forward); if (Physics.Raycast(_trackedObj.transform.position, fwd, out _hit, 60)) { var target = _hit.transform.gameObject.GetComponent <Targetable>(); if (target != null) { _lastTarget = target; if (_device.GetPress(SteamVR_Controller.ButtonMask.Trigger)) { EmitEvent(InputEventsEnum.LeftClickOnTargetEvent, target); } } else { _lastTarget = null; } } } }
private void Awake() { foreach (var shootPoint in ShootPoints) { shootPoint.Initialize(WeaponPrefab.MuzzlePrefab); } _velocityReference = new VelocityReference(Vector3.zero); if (Targetable == null) { Targetable = GetComponent<Targetable>(); } _weaponInstance = Utility.InstantiateInParent(WeaponPrefab.gameObject, transform).GetComponent<Weapon>(); _weaponInstance.Initialize(gameObject, ShootPoints, _velocityReference, Targetable.Team); _recoilCooldowns = new List<float>(); _barrelOffsets = new List<Vector3>(); for (var i = 0; i < ShootPoints.Count; i++) { _recoilCooldowns.Add(RecoilTime); _barrelOffsets.Add(RecoilBarrels[i].localPosition); } _weaponInstance.OnShoot += (shootPointIndex) => { _recoilCooldowns[shootPointIndex] = RecoilTime; }; }
// Use this for initialization public void Start() { PauseController = GameObject.Find("PauseCanvas").GetComponent <PauseController>(); _timeAffected = GetComponent <TimeAffected> (); _timeAffected.ShadowBlinkHandler += OnShadowBlink; _timeAffected.PassPauseController(PauseController); _layeredController = GetComponent <LayeredController> (); _targetable = gameObject.GetComponent <Targetable> (); _targetable.DeathEventHandler += OnDeath; _camera = Camera.main.GetComponent <CameraController> (); _musicController = gameObject.GetComponent <MusicController> (); GetComponent <LayeredController> ().LayerChangedEventHandler += UpdateLayerTransparencyOnLayerChange; GetComponent <LayeredController> ().LayerChangedEventHandler += UpdateMusicOnLayerChange; _bigGearPrefab = (GameObject)Resources.Load("BigGear"); _smallGearPrefab = (GameObject)Resources.Load("SmallGear"); _bigGear = Instantiate(_bigGearPrefab).GetComponent <GearController> (); _bigGear.PassPauseController(PauseController); _smallGear = Instantiate(_smallGearPrefab).GetComponent <GearController> (); _smallGear.PassPauseController(PauseController); _bigGear.Player = this; _smallGear.Player = this; _bigGear.RotationSpeed = _bigGearDefaultRotationSpeed; _smallGear.RotationSpeed = _smallGearDefaultRotationSpeed; _bigGear.Damage = _bigGearDamage; _smallGear.Damage = _smallGearDamage; _layeredController.Initialize(); UpdateLayerTransparencyOnLayerChange(); SaveCheckpoint(); }
/// <summary> /// A delegate to compare distances of components /// </summary> /// <param name="first"></param> /// <param name="second"></param> protected virtual int ByDistance(Targetable first, Targetable second) { float firstSqrMagnitude = Vector3.SqrMagnitude(first.position - epicenter.position); float secondSqrMagnitude = Vector3.SqrMagnitude(second.position - epicenter.position); return(firstSqrMagnitude.CompareTo(secondSqrMagnitude)); }
public void CmdSetTarget(GameObject targetGameObj) { if (targetGameObj.TryGetComponent <Targetable>(out Targetable newTarget)) { target = newTarget; } }
override public void SetTarget(Targetable target) { if (!target) { Debug.Log($"Spell {name} has no target. Target probably has been destroyed."); return; } base.SetTarget(target); HP hp = target.GetComponent <HP>( ); hp.DoDamage(effectAmount, transform.position, targetFreezTime > 0); if (targetShockTime > 0 || targetFreezTime > 0) { Unit unit = target.GetComponent <Unit>( ); unit.Freez(targetShockTime, targetFreezTime); UnitVisuals unitVis = target.GetComponent <UnitVisuals>( ); unitVis.Shocked(targetShockTime); } if (shakeStrength > 0) { ScreenshakeManager.Instance.DoShake(shakeStrength); } }
/// <summary> /// Returns the nearest targetable within the currently tracked targetables /// </summary> /// <returns>The nearest targetable if there is one, null otherwise</returns> protected virtual Targetable GetNearestTargetable() { int length = m_TargetsInRange.Count; if (length == 0) { return(null); } Targetable nearest = null; float distance = float.MaxValue; for (int i = length - 1; i >= 0; i--) { Targetable targetable = m_TargetsInRange[i]; if (targetable == null || targetable.isDead) { m_TargetsInRange.RemoveAt(i); continue; } float currentDistance = Vector3.Distance(transform.position, targetable.position); if (currentDistance < distance) { distance = currentDistance; nearest = targetable; } } return(nearest); }
/// <summary> /// Fired by the agents died event or when the current target moves out of range, /// Fires the lostTarget event. /// </summary> void OnTargetRemoved(DamageableBehaviour target) { target.removed -= OnTargetRemoved; if (m_CurrrentTargetable != null && target.configuration == m_CurrrentTargetable.configuration) { if (lostTarget != null) { lostTarget(); } m_HadTarget = false; m_TargetsInRange.Remove(m_CurrrentTargetable); m_CurrrentTargetable = null; m_XRotationCorrectionTime = 0.0f; } else //wasnt the current target, find and remove from targets list { for (int i = 0; i < m_TargetsInRange.Count; i++) { if (m_TargetsInRange[i].configuration == target.configuration) { m_TargetsInRange.RemoveAt(i); break; } } } }
private void Update() { Targetable target = targeter.GetTarget(); if (targeter.GetTarget() != null) { if ((target.transform.position - transform.position).sqrMagnitude > chaseRange * chaseRange) //Vector3.Distance too slow { agent.SetDestination(target.transform.position); } else if (agent.hasPath) { agent.ResetPath(); } return; } if (!agent.hasPath) { return; } if (agent.remainingDistance > agent.stoppingDistance) { return; } agent.ResetPath(); }
public void EmitEvent(InputEventsEnum inputEvent, Targetable target = null) { Debug.Log(inputEvent); switch (inputEvent) { case InputEventsEnum.LeftClickEvent: if (LeftClickEvent != null) { LeftClickEvent(); } break; case InputEventsEnum.LeftClickReleaseEvent: if (LeftClickReleaseEvent != null) { LeftClickReleaseEvent(); } break; case InputEventsEnum.LeftClickOnTargetEvent: if (LeftClickOnTargetEvent != null) { LeftClickOnTargetEvent(target); } //Debug.Log(target+ " has been clicked."); break; } }
public static AttackTask Create(Targetable ship) { AttackTask task = CreateInstance<AttackTask>(); task.attackTarget = ship; task.attackShip = ship.GetComponent<Ship>(); return task; }
private void Update() { Targetable target = targeter.GetTarget(); if (!target) { return; } if (!CanFireAtTarget()) { return; } Quaternion targetRotation = Quaternion.LookRotation(target.transform.position - transform.position); transform.rotation = Quaternion.RotateTowards(transform.rotation, targetRotation, rotationSpeed * Time.deltaTime); if (Time.time <= (1 / fireRate) + lastFireTime) { return; } Quaternion projectileRotation = Quaternion.LookRotation(target.GetTargetPoint().position - spawnPoint.position); GameObject projectileInstance = Instantiate(projectilePrefab, spawnPoint.position, projectileRotation); NetworkServer.Spawn(projectileInstance, connectionToClient); lastFireTime = Time.time; }
/// <summary> /// Launches a single projectile at a single enemy from a single firing point /// </summary> /// <param name="enemy"> /// The enemy to target /// </param> /// <param name="projectile"> /// The projectile to attack /// </param> /// <param name="firingPoint"> /// The point to fire from /// </param> public override void Launch(Targetable enemy, GameObject projectile, Transform firingPoint) { Vector3 startPosition = firingPoint.position; var ballisticProjectile = projectile.GetComponent <BallisticProjectile>(); if (ballisticProjectile == null) { Debug.LogError("No ballistic projectile attached to projectile"); DestroyImmediate(projectile); return; } Vector3 targetPoint; if (ballisticProjectile.fireMode == BallisticFireMode.UseLaunchSpeed) { // use speed targetPoint = Ballistics.CalculateBallisticLeadingTargetPointWithSpeed( startPosition, enemy.position, enemy.velocity, ballisticProjectile.startSpeed, ballisticProjectile.arcPreference, Physics.gravity.y, 4); } else { // use angle targetPoint = Ballistics.CalculateBallisticLeadingTargetPointWithAngle( startPosition, enemy.position, enemy.velocity, ballisticProjectile.firingAngle, ballisticProjectile.arcPreference, Physics.gravity.y, 4); } ballisticProjectile.FireAtPoint(startPosition, targetPoint); ballisticProjectile.IgnoreCollision(LevelManager.instance.environmentColliders); PlayParticles(fireParticleSystem, startPosition, targetPoint); }
//Get Unit Targeter Script Set Into Targetable Object private void TryTarget(Targetable target) { foreach (Unit unit in unitSelectionHandler.SelectedUnits) { unit.GetTargeter().CmdSetTarget(target.gameObject); } }
void WeaponFiredHandler() { if (isReloading) { return; } shootAudioSource.clip = firingSound; if (isADS) { anim.Play("Aim Fire", 0, 0f); } else { muzzleFlash.Play(); anim.Play("Fire", 0, 0f); } shootAudioSource.Play(); rifleCurrentAmmo--; RaycastHit hit; if (Physics.Raycast(playerCam.transform.position, playerCam.transform.forward, out hit, Mathf.Infinity, ~(1 << 13))) { GameObject impactGameObject = Instantiate(impactEffect, hit.point, Quaternion.LookRotation(hit.normal)); Destroy(impactGameObject, 0.5f); Targetable target = hit.transform.GetComponent <Targetable>(); if (target != null) { target.isHit(); } } }
// Use this for initialization public void Start () { PauseController = GameObject.Find("PauseCanvas").GetComponent<PauseController>(); _timeAffected = GetComponent<TimeAffected> (); _timeAffected.ShadowBlinkHandler += OnShadowBlink; _timeAffected.PassPauseController (PauseController); _layeredController = GetComponent<LayeredController> (); _targetable = gameObject.GetComponent<Targetable> (); _targetable.DeathEventHandler += OnDeath; _camera = Camera.main.GetComponent<CameraController> (); _musicController = gameObject.GetComponent<MusicController> (); GetComponent<LayeredController> ().LayerChangedEventHandler += UpdateLayerTransparencyOnLayerChange; GetComponent<LayeredController> ().LayerChangedEventHandler += UpdateMusicOnLayerChange; _bigGearPrefab = (GameObject)Resources.Load ("BigGear"); _smallGearPrefab = (GameObject)Resources.Load ("SmallGear"); _bigGear = Instantiate (_bigGearPrefab).GetComponent<GearController> (); _bigGear.PassPauseController (PauseController); _smallGear = Instantiate (_smallGearPrefab).GetComponent<GearController> (); _smallGear.PassPauseController (PauseController); _bigGear.Player = this; _smallGear.Player = this; _bigGear.RotationSpeed = _bigGearDefaultRotationSpeed; _smallGear.RotationSpeed = _smallGearDefaultRotationSpeed; _bigGear.Damage = _bigGearDamage; _smallGear.Damage = _smallGearDamage; _layeredController.Initialize(); UpdateLayerTransparencyOnLayerChange(); SaveCheckpoint (); }
public void UnregisterTarget(Targetable oldTarget) { if (oldTarget && RegisteredTargets != null) { RegisteredTargets.Remove(oldTarget); } }
public virtual void SelectTarget(Targetable t) { Debug.Log("SelectTarget: " + t); if (selectedTarget != t) ClearTarget(); // 清理以前的目标 if (t == null) return; selectedTarget = t; selectedTarget.onDestroy += OnTargetedDestroyed; }
public static void DealDamage(Targetable sender, List<Targetable> receivers, int damageAmount, DamageType damageType) { foreach (Targetable receiver in receivers) { int damageModifiers = 0; if (damageDealtHandlers.Count != 0) { DamageHandler[] dummyDamageHandlers = new DamageHandler[damageDealtHandlers.Count]; damageDealtHandlers.CopyTo(dummyDamageHandlers); foreach (DamageHandler dmgHand in dummyDamageHandlers) { damageModifiers += dmgHand(sender, receiver, ref damageAmount, damageType); if (damageAmount == 0){ //meaning the user is immune damageModifiers = 0; //could add another pointer param for invincible in dmgHand break; } } } if (damageModifiers + damageAmount > receiver.maxHealth) receiver.lifeTotal = receiver.maxHealth; else receiver.lifeTotal -= damageModifiers + damageAmount; } /* if (heroes != null) { foreach (Hero hero in heroes) { hero.lifeTotal -= damageModifiers + damageAmount; Console.WriteLine(hero.lifeTotal); } } if (villain != null) { villain.lifeTotal -= damageModifiers + damageAmount; Console.WriteLine(villain.lifeTotal); } if (minions != null) { foreach (Minion minion in minions) { minion.lifeTotal -= damageModifiers + damageAmount; Console.WriteLine(minion.lifeTotal); } } */ }
public virtual void ClearTarget() { Debug.Log("ClearTarget: " + selectedTarget); if (selectedTarget == null) return; // 清除掉队列中的技能 // actor.ClearQueuedSkill(); // 停止交互 // StopInteract(); selectedTarget.onDestroy -= OnTargetedDestroyed; selectedTarget = null; }
public override Vector3? PredictTarget(Ship activator, int slot, Targetable target) { Vector3 speedDiff; var targetBody = target.GetComponent<Rigidbody>(); var activatorBody = activator.GetComponent<Rigidbody>(); if (bulletType.applyBaseVelocity) { if (targetBody && activatorBody) { speedDiff = targetBody.velocity - activatorBody.velocity; } else if (activatorBody) { speedDiff = -activatorBody.velocity; } else { speedDiff = Vector3.zero; } } else { if (targetBody) { speedDiff = targetBody.velocity; } else { speedDiff = Vector3.zero; } } float distToTarget = (target.transform.position - activator.transform.position).magnitude; float timeToHit = distToTarget / bulletType.velocity; speedDiff *= timeToHit; var targetPos = target.transform.position; targetPos += speedDiff; return targetPos; }
void Start () { _player = GameObject.Find ("Player").GetComponent<PlayerController> (); _timeAffected = GameObject.Find("Player").GetComponent<TimeAffected>(); _playerTargetable = _player.GetComponent<Targetable> (); _playerMovement = _player.GetComponent<PlayerMovement> (); _oilScreen = (Texture)Resources.Load ("OilScreen"); _shadowBlinkIcon = (Texture)Resources.Load ("ShadowBlinkIcon"); _layerJumpIcons[0] = (Texture)Resources.Load("LayerJumpIconToFront"); _layerJumpIcons[1] = (Texture)Resources.Load("LayerJumpIconToMiddle"); _layerJumpIcons[2] = (Texture)Resources.Load("LayerJumpIconToBack"); _layerJumpIcon = _layerJumpIcons[1]; _joyStickIcon = (Texture)Resources.Load ("JoyStick"); _joyStickPadIcon = (Texture)Resources.Load ("JoyStickPad"); _joyStickPadRect = new Rect (_joyStickOrigin.x - _joyStickPadSize / 2, _joyStickOrigin.y - _joyStickPadSize / 2, _joyStickPadSize, _joyStickPadSize); }
public Color GetBracketColor(Targetable bracketOwner, Targetable bracketTarget) { TargetRelationship relationship; if (!bracketOwner || !bracketTarget) { relationship = TargetRelationship.Neutral; } else { relationship = bracketOwner.RelationshipTo(bracketTarget); } switch (relationship) { case TargetRelationship.FleetMember: return FleetMemberColor; case TargetRelationship.Friendly: return FriendlyColor; case TargetRelationship.Hostile: return HostileColor; case TargetRelationship.Resource: return ResourceColor; default: return Color.white; } }
public bool turnForce(SingleSkill singleSkill/*Vector3 direction, float angle, float lookAtTime*/) { turning = true; turningForce = true; maxAngle = singleSkill.maxAngle; target = singleSkill.target; keepLookAtTime = singleSkill.keepLookAtTime; return turning; // // TODO 以下是老版本 // // newQuaternion = Quaternion.LookRotation(direction); // // float angle = Quaternion.Angle(transform.rotation, newQuaternion); // // Debug.LogError("angle XXXXXX : " + angle); // // // // // TODO 判断角度范围 // // if (angle > 5f) // // { // turning = true; // turningForce = true; // turningForceCost = lookAtTime; // // // if (angle < 30) // // { // // turningForceCost = 0.2f; // // } // // else if (angle > 90) // // { // // turningForceCost = 0.6f; // // } // // else // // { // // turningForceCost = 0.4f; // // } // // // turningForceCost = turningForceLast * angle; // // turningForceCost = turningForceCost < 0.2f ? 0.2f : (turningForceCost > 0.6f ? 0.6f : turningForceCost); // // } // // return turning; }
public TargetRelationship RelationshipTo(Targetable other) { if (ship && other.ship && ship.IsFleetMember(other.ship)) { return TargetRelationship.FleetMember; } if (other.faction == "resource") { return TargetRelationship.Resource; } if (string.IsNullOrEmpty(other.Faction) || string.IsNullOrEmpty(Faction)) { return TargetRelationship.Neutral; } bool sameFaction = Faction == other.Faction; return sameFaction ? TargetRelationship.Friendly : TargetRelationship.Hostile; }
public void Fire(Targetable target) { transform.LookAt(target.transform); }
public void Initialize() { _targetable = GetComponent<Targetable>(); if (PrimaryWeaponPrefab != null) SetPrimaryWeapon(PrimaryWeaponPrefab.gameObject); if (SecondaryWeaponPrefab != null) SetSecondaryWeapon(SecondaryWeaponPrefab.gameObject); if (ShieldPrefab != null) SetShield(ShieldPrefab.gameObject); if (EnginePrefab != null) SetEngine(EnginePrefab.gameObject); }
public DragCommand(Draggable source, Targetable destination) { Source = source; Destination = destination; }
public int ObsidianFieldHandler(Targetable sender, Targetable receiver, ref int damageAmount, DamageEffects.DamageType damageType) { return 1; }
public int GroundPound_DamageHandler(object sender, Targetable receiver, ref int damageAmount, DamageEffects.DamageType damageType) { bool senderIsNotHero= !typeof(Hero).IsAssignableFrom(sender.GetType()); if(senderIsNotHero) damageAmount = 0; return 0; }
public virtual Vector3? PredictTarget(Ship activator, int slot, Targetable target) { return null; }
private void TargetLocking() { var shootPointsCentre = GetShootPointCentre(); if (_lockingTarget != null) { var toLockingTarget = _lockingTarget.position - shootPointsCentre; if (toLockingTarget.sqrMagnitude > TargetLockingMaxDistance * TargetLockingMaxDistance) { ClearTargetLock(); } } else { ClearTargetLock(); } if (_lockedTarget != null) { var toLockedTarget = _lockedTarget.position - shootPointsCentre; if (toLockedTarget.sqrMagnitude > TargetLockingMaxDistance * TargetLockingMaxDistance) { ClearTargetLock(); } } else { ClearTargetLock(); } if (!_isLocked) { _lockingTarget = null; if (IsTriggered) { var targetLockingDir = _aimAt - shootPointsCentre; _lockingTarget = Targeting.FindFacingAngleTeam(_targetTeam, shootPointsCentre, targetLockingDir, TargetLockingMaxDistance); if (_lastLockingTarget == null) _lastLockingTarget = _lockingTarget; } else { _lastLockingTarget = null; } if (_lastLockingTarget != null && _lastLockingTarget == _lockingTarget) { _lockingCooldown -= Time.deltaTime; if (_lockingCooldown < 0f) { _lockedTarget = _lockingTarget; _isLocked = true; if (LockSound != null) { Utility.PlayOnTransform(LockSound, _owner.transform); } } } else { _lockingCooldown = TargetLockTime; } } else { if (!IsTriggered) { _lockedVehicle = _lockedTarget.GetComponent<Vehicle>(); if (_lockedVehicle != null) { // Rough Extrapolation SetAimAt(Utility.GetVehicleExtrapolatedPosition(_lockedVehicle, this, 0f)); } else { SetAimAt(_lockedTarget.position); } _targetable = _lockedTarget.GetComponent<Targetable>(); if (_targetable != null) { _targetable.LockedOnBy = _owner.transform; } SetAimAt(GetShootPointCentre() + _velocityReference.Value); _nextMissile = GetNextMissile(); _nextMissile.GetComponent<Missile>().SetTarget(_lockedTarget); FireMissile(_nextMissile); ClearTargetLock(); } } }
int HakaOfBattleDamageHandler(object sender, Targetable receiver, ref int damageAmount, DamageEffects.DamageType damageType) { if (sender.Equals(this)) { DamageEffects.damageDealtHandlers.Remove(HakaOfBattleDamageHandler); return GameBoard.discardedCardsThisTurn.Count; } return 0; }
void LeftMouseClicked() { //if not holding an object already if (!objectHeld) { //send a ray to check if capable of picking up and object if (Physics.Raycast(mainCam.transform.position, transform.forward, out hit, rayLength, pickUpObjects)) { //pick up object if found objectHeld = true; currentObject = hit.collider.gameObject.GetComponent<PickUpObject>(); currentObject.Clicked(); } else if (Physics.Raycast(mainCam.transform.position, transform.forward, out hit, rayLength, dynamicObjects)) { currentTarget = hit.collider.gameObject.GetComponent<Targetable>(); if (currentTarget != null) { currentTarget.Clicked(); } } } //if we are holding an object else { //release it currentActivityObject = null; currentObject.Release(); objectHeld = false; } }
private int EnduringIntercession_Damage_Handler(Targetable sender, Targetable receiver, ref int damageAmount, DamageEffects.DamageType damageType) { bool receiverIsNotHaka= !receiver.GetType().Equals(typeof(Haka)); if (receiverIsNotHaka) { if (typeof(GameEnvironment).IsAssignableFrom(sender.GetType()) || GameEngine.getEnvironment().getMinions().Contains(sender)) { DamageEffects.DealDamage(sender, new List<Targetable>() { this }, damageAmount, damageType); return (-1) * damageAmount;//balances out the amount that it deals to player that isn't haka } } return 0; }
private void Awake() { _screenCentre = new Vector3(0.5f * Screen.width, 0.5f * Screen.height); var boundaryPadding = 20f; _screenBounds = new Rect(boundaryPadding, boundaryPadding, Screen.width - 2f * boundaryPadding, Screen.height - 2f * boundaryPadding); _shieldBarTexture = Utility.ColouredTexture(48, 2, new Color(0.6f, 0.6f, 1f, 1f)); _healthBarTexture = Utility.ColouredTexture(48, 2, new Color(1f, 1f, 1f, 1f)); _healthBarBackgroundTexture = Utility.ColouredTexture(48, 2, new Color(1f, 1f, 1f, 0.05f)); _targetable = Targetable ?? GetComponent<Targetable>(); _killable = Killable ?? GetComponent<Killable>(); _maxDistanceSquared = MaxDistance*MaxDistance; _isLockedOn = false; }
private int PunishTheWeak_Damage_Handler(Targetable sender, Targetable receiver, ref int damageAmount, DamageEffects.DamageType damageType) { List<Targetable> sortedNonHeroes = getSortedNonHeroes(); if (receiver.Equals(sortedNonHeroes[0])) return 1; else return -1; }
void RightMouseClicked() { if (Physics.Raycast(mainCam.transform.position, transform.forward, out hit, rayLength, dynamicObjects)) { currentTarget = hit.collider.gameObject.GetComponent<Targetable>(); if (currentTarget != null) { currentTarget.Clicked(); } } }