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();
}
}
}
