public int CalculateDiceNumber(UnitScript attacker, UnitScript defender, bool badRangeShooting)
{
int diceNumber = attacker.DiceNumber;
/*if (attacker.CurrentHP * 2 <= attacker.MaxHP)
* {
* diceNumber--;
* }
* if (defender.CurrentHP * 2 <= defender.MaxHP)
* {
* diceNumber++;
* }*/
if ((attacker.GetComponent <HeroScript>() != null || attacker.isSpecial) && defender.unitType == UnitType.Cannonmeat)
{
diceNumber++;
}
if ((defender.GetComponent <HeroScript>() != null || defender.isSpecial) && attacker.unitType == UnitType.Cannonmeat)
{
diceNumber--;
}
if (badRangeShooting)
{
diceNumber--;
}
if (diceNumber < 1)
{
diceNumber = 1;
}
return(diceNumber);
}
//public int count
//{
// get
// {
// return myPhases.Length;
// }
//}
public void Activate()
{
if (myWait <= 0f)
{
myWait = myDuration;
HealthScript health = myUnit.GetComponent <HealthScript>();
if (health.isAlive)
{
if (myTarget)
{
myDistance = (myTarget.transform.position - myUnit.transform.position).magnitude;
if (myDistance < myRange)
{
myEffect.Affect(new Message(myUnit.ToTerm(), myTarget.ToTerm()), 0f);
}
}
}
}
else
{
myWait -= Time.deltaTime;
}
}
protected override Queue <UnitScript> GetPossibleUnits()
{
if (GetUnitsWithPriority() == null)
{
GameStateManager.NextPhase();
return(null);
}
Queue <UnitScript> myUnitsToMove = new Queue <UnitScript>(GetUnitsWithPriority());
UnitScript firstUnit = myUnitsToMove.Peek();
while (unitsSkippingTurn.Contains(firstUnit) == true || firstUnit.GetComponent <UnitMovement>().CanMove == false)
{
myUnitsToMove.Dequeue();
if (myUnitsToMove.Count == 0)
{
if (GetUnitsWithPriority() == null)
{
GameStateManager.NextPhase();
}
return(null);
}
else
{
firstUnit = myUnitsToMove.Peek();
}
}
return(myUnitsToMove);
}
public override float EvaluateAsATarget(UnitScript currentUnit, Tile startingTile, Tile enemyTile)
{
// here our unit makes a decision of where to attack at. He will:
// 1. Want to prio units who cannot counterattack
// 2. Want to hit guys, who will give him more points
// 3. Want to hit guys, who he has bigger chance to actually damage.
UnitScript target = enemyTile.myUnit;
float Evaluation = 0f;
// Debug.Log("Evaluating a shot by: " + currentUnit + " at: " + target);
// 1.
if (target.CanCurrentlyRetaliate == false)
{
Evaluation += 0.2f;
}
// 2.
Evaluation += target.Value * 0.1f;
if (target.GetComponent <HeroScript>() != null)
{
Evaluation += 0.75f;
// Thats just my ruff estimate of "value" of a hero here, lol.
}
// Debug.Log("Evaluation increased by: " + target.Value * 0.1f + " because of arget's value");
// NOTE - this might want to get changed to "AI Value" when we add AIData scripts for units.
// 3.
float temp = ChancesToHit(currentUnit, target);
Evaluation += temp;
// Debug.Log("Evaluation increased by: " + temp + " for chances to hit");
return(Evaluation);
}
public bool IsUsableNowBase()
{
return
(IsUsableNow() &&
(UsesLeft > 0 || LimitedUses == false) &&
myEnergy.IsEnoughEnergyFor(this) &&
TurnManager.Instance.PlayerHavingTurn == myUnit.PlayerID &&
AlreadyUsedThisTurn == false &&
GameStateManager.Instance.IsItPreGame() == false &&
LegalInPhases.Contains(TurnManager.Instance.CurrentPhase) &&
(!OnlyInCombat || (OnlyInCombat && myUnit.CheckIfIsInCombat())) &&
(!UnavailableInCombat || (UnavailableInCombat && !myUnit.CheckIfIsInCombat())) &&
(!RequiresCanMove || (RequiresCanMove && myUnit.GetComponent <UnitMovement>().CanMove)) &&
(!RequiresShootingAbility || (RequiresShootingAbility && myUnit.GetComponent <ShootingScript>().IsAbleToShoot())) &&
(!IsAttack || (IsAttack && myUnit.hasAttacked == false)));
}
public void Attack(UnitScript Attacker, UnitScript Defender, bool retaliatable, int damage, int hits)
{
if (Attacker.GetComponent <ShootingScript>() != null)
{
Attacker.GetComponent <ShootingScript>().myTarget = Defender.transform.position;
// this is mostly done HERE for melee attacks of Ravens...
}
if (AttackEvent != null)
{
AttackEvent(Attacker, Defender, damage);
}
AttackingUnit = Attacker;
AttackTarget = Defender;
DamageCalculator dc = new DamageCalculator();
dc.DealDamage(Attacker, Defender, damage, Attacker.isPoisonous, retaliatable, hits);
CheckIfLastAttacker();
}
void MeleeAttackObstacle(UnitScript Attacker, DestructibleScript target)
{
Debug.Log("Melee attacking obstacle - debugging fencer bug");
Attacker.GetComponent <UnitMovement>().LookAtTheTarget(target.transform.position, Attacker.GetComponentInChildren <BodyTrigger>().RotationInAttack);
Attacker.GetComponentInChildren <AnimController>().AnimateAttack();
target.GetDamaged(Attacker.CurrentAttack + 1);
Attacker.hasAttacked = true;
CheckIfLastAttacker();
target.GetComponentInChildren <ObjectHP>().SwitchTrigger();
}
void FinishQC(bool didDie, int unitX, int unitZ)
{
if (didDie == false)
{
UnitScript QCUnit = Map.Board[unitX, unitZ].myUnit;
QCUnit.isQuittingCombat = true;
UnitMovement uMovement = QCUnit.GetComponent <UnitMovement>();
uMovement.CanMove = true;
MovementSystem.Instance.DoMovement(uMovement);
if (QCUnit.GetComponent <ShootingScript>() != null)
{
QCUnit.GetComponent <ShootingScript>().hasAlreadyShot = true;
}
uMovement.CanMove = true;
FinalTile = null;
}
PlayerChoosesWhetherToQC = false;
}
void Update()
{
if (myWaves > 0)
{
if (myWait <= 0f)
{
myWait = 10f;
Debug.Log("Wait done");
bool ready = true;
foreach (UnitScript unit in myBugs)
{
if (unit && unit.GetComponent <HealthScript>().isAlive)
{
ready = false;
break;
}
}
if (ready)
{
Debug.Log("All Clear");
foreach (GameObject spawn in mySpawns)
{
for (int i = 0; i < 2; i++)
{
UnitScript unit = Instantiate(myUnit).GetComponent <UnitScript>();
unit.transform.position = spawn.transform.position;
AggroScript aggro = unit.GetComponent <AggroScript>();
aggro.myRange = 9999f;
myBugs.Add(unit);
}
}
if (1 == myWaves)
{
Debug.Log("Boss Wave");
AggroScript aggro = myBoss.GetComponent <AggroScript>();
aggro.myRange = 9999f;
}
myWaves--;
}
}
else
{
myWait -= Time.deltaTime;
}
}
}
bool CanQuitCombat(UnitScript unit)
{
if (
unit.CheckIfIsInCombat() &&
IsItTimeToMove(unit) &&
unit.GetComponent <UnitMovement>().CanMove&&
IsThisTileLegal(MouseManager.Instance.mouseoveredTile, unit.GetComponent <UnitMovement>(), true)
)
{
return(true);
}
else
{
/*Debug.Log("inCombat: " + unit.CheckIfIsInCombat());
* Debug.Log("timetoMove: " + IsItTimeToMove(unit));
* Debug.Log("canMove: " + unit.GetComponent<UnitMovement>().canMove);
* Debug.Log("LegalTile: " + IsItALegalTileForQC(unit, MouseManager.Instance.mouseoveredTile));*/
return(false);
}
}
public bool CanMove(UnitScript unit, Tile target, bool isAffectedByCombat)
{
if (
IsThisTileLegal(target, unit.GetComponent <UnitMovement>(), isAffectedByCombat) &&
IsItTimeToMove(unit) &&
CanUnitMoveAtAll(unit.GetComponent <UnitMovement>())
)
{
return(true);
}
else
{
/* Debug.Log("Legal: " + IsThisTileLegal(target, unit.GetComponent<UnitMovement>(), isAffectedByCombat));
* Debug.Log("TimeToMove: " + IsItTimeToMove(unit));
* Debug.Log("HaveMovement: " + CanUnitMoveAtAll(unit.GetComponent<UnitMovement>()));
* Debug.Log("LastTIleIsSafe: " + IsTheLastTileSafe());
* Debug.Log("UnitNotInCombat: " + !unit.CheckIfIsInCombat());*/
return(false);
}
}
////////////////////////////////////////////////
////////////////////////////////////////////////
public static void MakeActiveUnitMove_CLIENT()
{
UnitScript activeUnit = UnitsManager.ActiveUnit;
if (activeUnit)
{
if (_movePath != null)
{
activeUnit.GetComponent <MovementScript>().MoveUnit(_movePath);
//PlayerManager.NetworkAgent.CmdTellServerToMoveUnit(PlayerManager.PlayerAgent.NetworkInstanceID, _activeUnit.NetID, pathInts);
}
}
}
public bool WouldTileBeLegal(Tile tile, UnitScript unit, int speed)
{
int i = Mathf.RoundToInt(tile.transform.position.x);
int j = Mathf.RoundToInt(tile.transform.position.z);
return
(Distances[i, j] <= speed &&
Distances[i, j] != -1 &&
Map.Board[i, j].isWalkable == true &&
Map.Board[i, j].hasObstacle == false &&
Map.Board[i, j].myUnit == null &&
Map.Board[i, j] != unit.GetComponent <UnitScript>().myTile);
}
public static void SetNewPosition(int startPosX, int startPosZ, int endPosX, int endPosZ)
{
Vector3 oldPos = Map.Board[startPosX, startPosZ].transform.position;
Vector3 newPos = Map.Board[endPosX, endPosZ].transform.position;
Unit unit = Map.Board[startPosX, startPosZ].myUnit.unitUnit;
UnitScript me = Map.Board[startPosX, startPosZ].myUnit;
if (me.PlayerID == 0)
{
if (NewGameScript.PlayerOneArmy.ContainsKey(oldPos))
{
NewGameScript.PlayerOneArmy.Remove(oldPos);
}
NewGameScript.PlayerOneArmy.Add(newPos, unit);
}
else
{
if (NewGameScript.PlayerTwoArmy.ContainsKey(oldPos))
{
NewGameScript.PlayerTwoArmy.Remove(oldPos);
}
NewGameScript.PlayerTwoArmy.Add(newPos, unit);
}
Tile tile = Map.Board[endPosX, endPosZ];
Quaternion q = me.transform.rotation;
me.transform.position = tile.transform.position;
me.transform.rotation = q;
me.GetComponent <UnitMovement>().TeleportTo(tile);
if (tile.myUnit != null)
{
tile.myUnit.DeathEvent -= tile.OnMyUnitDied;
}
tile.myUnit = me.GetComponent <UnitScript>();
tile.myUnit.DeathEvent += tile.OnMyUnitDied;
}
public void UnitInstantiated(UnitScript unit)
{
if (battleFase)
{
// comprueba si el cliente local es dueño de la unidad instanciada
ConnectionManager.instance.CmdCheckUnitOwner(unit.GetComponent <NetworkIdentity>());
}
else
{
deployUnitList.Add(unit);
unit.transform.SetParent(map.allyUnitContainer);
unit.gameObject.SetActive(false);
}
}
public void Shoot(UnitScript Attacker, UnitScript Defender, bool badRange, bool AOE)
{
SendCommandToAttack(Attacker, Defender, badRange, false);
if (AOE)
{
foreach (Tile tile in Defender.myTile.GetNeighbours())
{
if (tile.myUnit != null)
{
SendCommandToAttack(Attacker, tile.myUnit, badRange, false);
}
}
}
SendCommandToLaunchProjectile(Attacker.GetComponent <ShootingScript>(), Defender.transform.position);
}
/** Note will not reposition the transfering unit if any*/
public bool transferUnit(HexTile fromTile, HexTile toTile)
{
if (fromTile != null && toTile != null)
{
if (fromTile.getOccupyingUnit() != null)
{
UnitScript occupyingUnit = fromTile.getOccupyingUnit();
UnitScript oScript = (UnitScript)occupyingUnit.GetComponent(typeof(UnitScript));
oScript.setOccupyingHex(toTile);
toTile.setOccupyingUnit(occupyingUnit);
fromTile.setOccupyingUnit(null);
return(true);
}
}
return(false);
}
void RPCDoMovement(int startX, int startZ, int endX, int endZ)
{
Tile startTile = Map.Board[startX, startZ];
UnitScript unit = startTile.myUnit;
if (unit == null)
{
Debug.LogError("NoUnit!");
Log.SpawnLog("NO UNIT TO MOVE!");
return;
}
Tile destination = Map.Board[endX, endZ];
PathCreator.Instance.AddSteps(unit.myTile, destination);
DoMovement(unit.GetComponent <UnitMovement>());
}
private void CheckForAssassin()
{
AssassinStatModifier modifier = myUnit.GetComponent <AssassinStatModifier>();
bool active = modifier != null;
Assassin.SetActive(active);
if (active)
{
AssassinValue.text = modifier.AttackModifierVersusUnitType.ToString();
}
}
private IEnumerator QCAIRoutine(Tile destination)
{
UnitScript unit = MouseManager.Instance.SelectedUnit;
StartCoroutine(CheckForBackstabsInCoroutine());
yield return(new WaitForSeconds(1f));
if (unit != null && unit.CurrentHP > 0)
{
PathCreator.Instance.AddSteps(unit.myTile, destination);
MovementSystem.Instance.SendCommandToMove(unit.GetComponent <UnitMovement>());
}
else
{
yield return(null);
}
}
internal override void Animate()
{
if (faceMovingDirection)
{
direction = UNIT.GetComponent <Movability>().MovingDirection;
}
else if (faceOtherTransform)
{
direction = TransformToFace.position - this.gameObject.transform.position;
}
else if (faceCamera)
{
direction = qamDirection;
}
if (direction != Vector3.zero)
{
switch (forwardIs)
{
case EnumProvider.DIRECTION.forward:
gameObject.transform.forward = direction;
break;
case EnumProvider.DIRECTION.right:
gameObject.transform.right = direction;
break;
case EnumProvider.DIRECTION.up:
gameObject.transform.up = direction;
break;
case EnumProvider.DIRECTION.backward:
gameObject.transform.forward = -direction;
break;
case EnumProvider.DIRECTION.left:
gameObject.transform.right = -direction;
break;
case EnumProvider.DIRECTION.down:
gameObject.transform.up = -direction;
break;
}
}
}
