public void ConstructDefender()
{
GameObject defender = GameObject.Instantiate(this.m_DefenderPrefab) as GameObject;
defender.transform.position = transform.position;
defender.transform.parent = this.m_ParentNode;
/*
* DefenderBehavior behavior = defender.GetComponent<DefenderBehavior>();
* behavior.MapData = this.m_MapData;
*
*
* ArmyWeightDataCalculator weightCalculator = defender.GetComponent<ArmyWeightDataCalculator>();
* weightCalculator.MapData = this.m_MapData;
*
* CharacterWalk walk = defender.GetComponent<CharacterWalk>();
* walk.MapData = this.m_MapData;
*/
//CharacterHPBehavior hpBehavior = defender.GetComponent<CharacterHPBehavior>();
CharacterPropertyBehavior property = defender.GetComponent <CharacterPropertyBehavior>();
property.CharacterType = CharacterType.Defender;
BattleSceneHelper.Instance.ConstructActor
(defender, PositionConvertor.GetActorTileIndexFromWorldPosition(defender.transform.position));
}
protected override void Calculate()
{
TilePosition affectPosition = PositionConvertor.GetActorTileIndexFromWorldPosition(this.DestinationObject.GetDestinationPosition(this.transform.position));
List <TilePosition> affectedTiles = RoundHelper.FillCircle
(affectPosition.Column, affectPosition.Row, Mathf.CeilToInt(this.DamageScope /
(float)Mathf.Min(ClientSystemConstants.ACTOR_TILE_MAP_TILE_SIZE.height,
ClientSystemConstants.ACTOR_TILE_MAP_TILE_SIZE.width)));
foreach (TilePosition tile in affectedTiles)
{
if (tile.IsValidActorTilePosition())
{
List <GameObject> characters = BattleMapData.Instance.ActorArray[tile.Row, tile.Column];
foreach (GameObject character in characters)
{
CharacterPropertyBehavior property = character.GetComponent <CharacterPropertyBehavior>();
if (property.CharacterType == CharacterType.Invader)
{
//float distance = Vector2.Distance((Vector2)this.transform.position, (Vector2)character.transform.position);
//float percentage = (1 - distance) / this.m_GroupDamageScope;
//percentage = Mathf.Max(percentage, 0);
CharacterHPBehavior hpBehavior = character.GetComponent <CharacterHPBehavior>();
hpBehavior.DecreaseHP(this.Damage, this.AttackCategory);
this.PushCharacter(character);
}
}
}
}
}
public override void Initial()
{
this.m_PushVelocity = this.m_Velocity * this.m_Direction;
this.m_PreviousPosition = PositionConvertor.GetActorTileIndexFromWorldPosition(this.m_AIBehavior.transform.position);
this.m_AnimationController.PlayIdleAnimation();
}
public override void AICalculate()
{
CharacterAI characterAI = (CharacterAI)this.m_AIBehavior;
if (this.m_Ticks++ == this.m_PushTicks)
{
characterAI.SetIdle(false);
}
else
{
this.m_PushVelocity *= this.m_PushAttenuateFactor;
Vector2 v = this.m_PushVelocity * this.m_PushFactor;
Vector2 newPosition = (Vector2)this.m_AIBehavior.transform.position + v;
newPosition = PositionConvertor.ClampWorldPositionOfActorTile(newPosition);
TilePosition currentTile = PositionConvertor.GetActorTileIndexFromWorldPosition(this.m_AIBehavior.transform.position);
TilePosition newTile = PositionConvertor.GetActorTileIndexFromWorldPosition(new Vector3(newPosition.x, newPosition.y));
if (BattleMapData.Instance.ActorCanPass(newTile.Row, newTile.Column) && BattleMapData.Instance.ActorCanPass(currentTile.Row, currentTile.Column))
{
this.m_AIBehavior.transform.position = new Vector3(newPosition.x, newPosition.y, this.m_AIBehavior.transform.position.z);
if (newTile != this.m_PreviousPosition)
{
BattleMapData.Instance.RefreshInformationWithMoveActor(this.m_AIBehavior.gameObject, this.m_PreviousPosition, newTile);
this.m_PreviousPosition = newTile;
if (characterAI.BattleMapData.ActorCanPass(newTile.Row, newTile.Column))
{
characterAI.PreviousValidPosition = newTile;
}
}
}
}
}
private void Effect()
{
List <BuildingAI> affectedBuildings = new List <BuildingAI>();
int distanceSqrt = this.Scope * this.Scope;
Vector2 targetPosition = (Vector2)this.transform.position;
TilePosition targetTile = PositionConvertor.GetActorTileIndexFromWorldPosition(this.transform.position);
int radius = Mathf.CeilToInt(this.Scope / (float)Mathf.Min(ClientSystemConstants.ACTOR_TILE_MAP_TILE_SIZE.width,
ClientSystemConstants.ACTOR_TILE_MAP_TILE_SIZE.height));
List <TilePosition> affectedTiles = RoundHelper.FillCircle(targetTile.Column, targetTile.Row, radius);
foreach (TilePosition tile in affectedTiles)
{
if (tile.IsValidActorTilePosition())
{
Vector2 p = (Vector2)PositionConvertor.GetWorldPositionFromActorTileIndex(tile);
Vector2 dis = p - targetPosition;
if (dis.sqrMagnitude <= distanceSqrt)
{
GameObject building = BattleMapData.Instance.GetBulidingObjectFromActorObstacleMap(tile.Row, tile.Column);
if (building != null)
{
BuildingAI ai = building.GetComponent <BuildingAI>();
if (ai != null && !affectedBuildings.Contains(ai))
{
affectedBuildings.Add(ai);
ai.SetTarget(this.gameObject, (Vector2)this.transform.position);
}
}
}
}
}
}
public List <GameObject> GetNearByBuilding(Vector3 position, int scope)
{
List <GameObject> result = new List <GameObject>();
int distanceSqrt = scope * scope;
TilePosition tilePosition = PositionConvertor.GetActorTileIndexFromWorldPosition(position);
int radius = Mathf.CeilToInt(scope / (float)Mathf.Min(ClientSystemConstants.ACTOR_TILE_MAP_TILE_SIZE.width,
ClientSystemConstants.ACTOR_TILE_MAP_TILE_SIZE.height));
List <TilePosition> affectedTiles = RoundHelper.FillCircle(tilePosition.Column, tilePosition.Row, radius);
foreach (TilePosition tile in affectedTiles)
{
if (tile.IsValidActorTilePosition())
{
Vector2 p = (Vector2)PositionConvertor.GetWorldPositionFromActorTileIndex(tile);
Vector2 dis = p - (Vector2)position;
if (dis.sqrMagnitude <= distanceSqrt)
{
GameObject building = BattleMapData.Instance.GetBulidingObjectFromActorObstacleMap(tile.Row, tile.Column);
if (building != null && !result.Contains(building) && building.GetComponent <BuildingHPBehavior>() != null)
{
result.Add(building);
}
}
}
}
return(result);
}
private List <TilePosition> GetTilePositionList(int scope)
{
TilePosition actorPosition = PositionConvertor.GetActorTileIndexFromWorldPosition
(this.m_Property.AnchorTransform.position);
int radius = Mathf.CeilToInt(scope / (float)Mathf.Min(ClientSystemConstants.ACTOR_TILE_MAP_TILE_SIZE.width,
ClientSystemConstants.ACTOR_TILE_MAP_TILE_SIZE.height));
return(RoundHelper.FillCircle(actorPosition.Column, actorPosition.Row, radius));
}
public virtual void SetPush(int pushTicks, int pushVelocity, Vector3 pushSource)
{
TilePosition currentPosition = PositionConvertor.GetActorTileIndexFromWorldPosition(this.transform.position);
if (BattleMapData.Instance.ActorCanPass(currentPosition.Row, currentPosition.Column))
{
PushState pushState = new PushState(this, pushTicks, pushVelocity, this.transform.position - pushSource);
this.ChangeState(pushState);
}
}
public override void Initial()
{
this.m_PreviousPosition = PositionConvertor.GetActorTileIndexFromWorldPosition
(this.m_AIBehavior.gameObject.transform.position);
if (this.m_LinePath == null || this.m_LinePath.Count == 0)
{
this.FindPath();
}
}
private void ConstructCharacter(GameObject characterPrefab, Vector3 position, BuildingCategory favoriteCategory,
int hp, int armorCategory, float moveVelocity, TargetType type, float attackCD, int attackValue, float attackScope,
int damageScope, float middleSpeed, int attackCategory, TargetType targetType, float pushFactor, float pushAttenuateFactor)
{
GameObject army = GameObject.Instantiate(characterPrefab) as GameObject;
army.transform.position = position;
army.transform.parent = this.m_ParentNode;
CharacterAI ai = army.GetComponent <CharacterAI>();
ai.BattleMapData = BattleMapData.Instance;
ai.BattleSceneHelper = this.m_SceneHelper;
ai.FavoriteCategory = favoriteCategory;
ai.PushFactor = pushFactor;
ai.PushAttenuateFactor = pushAttenuateFactor;
ai.SetIdle(true);
CharacterHPBehavior hpBehavior = army.GetComponent <CharacterHPBehavior>();
hpBehavior.TotalHP = hp;
hpBehavior.ArmorCategory = armorCategory;
if (hpBehavior is KodoHPBehavior)
{
KodoHPBehavior kodoHP = hpBehavior as KodoHPBehavior;
kodoHP.Factory = this;
}
CharacterPropertyBehavior property = army.GetComponent <CharacterPropertyBehavior>();
property.CharacterType = CharacterType.Invader;
property.MoveVelocity = moveVelocity;
property.Type = type;
AttackBehavior attackBehavior = army.GetComponent <AttackBehavior>();
attackBehavior.BulletParent = this.m_BulletParent;
attackBehavior.AttackCD = Mathf.FloorToInt(attackCD * ClientConfigConstants.Instance.TicksPerSecond);
attackBehavior.AttackValue = attackValue;
attackBehavior.AttackScope = attackScope;
attackBehavior.DamageScope = damageScope;
attackBehavior.BulletFlySpeed = middleSpeed;
attackBehavior.AttackCategory = attackCategory;
attackBehavior.TargetType = targetType;
BattleSceneHelper.Instance.ConstructActor
(army, PositionConvertor.GetActorTileIndexFromWorldPosition(army.transform.position));
}
IEnumerator CharacterDestroy()
{
for (int i = this.m_InvaderList.Count - 1; i >= 0; i--)
{
GameObject invader = this.m_InvaderList[i];
if (invader != null)
{
CharacterHPBehavior hpBehavior = invader.GetComponent <CharacterHPBehavior>();
BattleMapData.Instance.RefreshInformationWithDestroyActor(invader,
PositionConvertor.GetActorTileIndexFromWorldPosition(invader.transform.position));
hpBehavior.SetDead();
yield return(new WaitForSeconds(0.2f));
}
}
this.m_InvaderList.Clear();
}
protected void ClearActor()
{
TilePosition currentPosition = PositionConvertor.GetActorTileIndexFromWorldPosition(this.transform.position);
BattleSceneHelper.Instance.DestroyActor(gameObject, currentPosition);
if (Application.loadedLevelName == ClientStringConstants.BATTLE_SCENE_LEVEL_NAME)
{
CharacterPropertyBehavior property = this.GetComponent <CharacterPropertyBehavior>();
if (property.CharacterType == CharacterType.Invader)
{
if (BattleSceneHelper.Instance.TotalInvaderCount == 0 &&
BattleRecorder.Instance.DropArmyCount == ArmyMenuPopulator.Instance.TotalArmyCount &&
BattleRecorder.Instance.DropMercenaryCount == ArmyMenuPopulator.Instance.TotalMercenaryCount)
{
BattleDirector.Instance.EndMatch();
}
}
}
}
private void FindTarget()
{
TilePosition currentPosition = PositionConvertor.GetActorTileIndexFromWorldPosition(this.m_AIBehavior.transform.position);
if (!this.FindDefender(currentPosition))
{
GameObject target = null;
target = this.CharacterAI.BattleSceneHelper.GetNearestBuildingOfCategory(this.m_AIBehavior.transform.position, this.CharacterAI.FavoriteCategory);
if (target != null)
{
BuildingBasePropertyBehavior property = target.GetComponent <BuildingBasePropertyBehavior>();
int rID = BattleRandomer.Instance.GetRandomNumber(0, property.ActorObstacleList.Count);
TilePosition tp = property.ActorPosition + property.ActorObstacleList[rID];
InvaderWalkState invaderWalkState = new InvaderWalkState(this.CharacterAI.BattleMapData,
tp, this.m_AIBehavior, target);
this.m_AIBehavior.ChangeState(invaderWalkState);
}
}
}
public void DestroyAllInvaders()
{
if (BattleDirector.Instance == null)
{
foreach (GameObject invader in this.m_InvaderList)
{
CharacterHPBehavior hpBehavior = invader.GetComponent <CharacterHPBehavior>();
BattleMapData.Instance.RefreshInformationWithDestroyActor(invader,
PositionConvertor.GetActorTileIndexFromWorldPosition(invader.transform.position));
hpBehavior.SetDead();
}
this.m_InvaderList.Clear();
}
else
{
foreach (GameObject invader in this.m_InvaderList)
{
invader.GetComponent <NewAI>().enabled = false;
}
this.StartCoroutine("CharacterDestroy");
}
}
public override void AICalculate()
{
if (this.m_IsFindInstantly || this.m_AIBehavior.CanTakeResponse)
{
CharacterAI ai = (CharacterAI)this.m_AIBehavior;
TilePosition currentPosition = PositionConvertor.GetActorTileIndexFromWorldPosition(this.m_AIBehavior.transform.position);
if (!BattleMapData.Instance.ActorCanPass(currentPosition.Row, currentPosition.Column))
{
GameObject go = BattleMapData.Instance.GetBulidingObjectFromActorObstacleMap(currentPosition.Row, currentPosition.Column);
BuildingHPBehavior targetHP = go.GetComponent <BuildingHPBehavior>();
if (targetHP != null)
{
CharacterAttack attack = ai.AttackBehavior;
targetHP.DecreaseHP(attack.AttackValue, attack.AttackCategory);
}
KodoHPBehavior hp = this.m_AIBehavior.GetComponent <KodoHPBehavior>();
hp.Bomb();
}
else
{
List <GameObject> targets = BattleSceneHelper.Instance.GetBuildingsOfCategory(ai.FavoriteCategory);
if (targets.Count > 0)
{
int i = BattleRandomer.Instance.GetRandomNumber(0, targets.Count);
GameObject targetGo = targets[i];
BuildingBasePropertyBehavior targetProperty = targetGo.GetComponent <BuildingBasePropertyBehavior>();
i = BattleRandomer.Instance.GetRandomNumber(0, targetProperty.ActorObstacleList.Count);
TilePosition targetTile = targetProperty.ActorPosition + targetProperty.ActorObstacleList[i];
Vector2 targetPosition = PositionConvertor.GetWorldPositionFromActorTileIndex(targetTile);
CrazyKodoWalkState walkState = new CrazyKodoWalkState(this.m_AIBehavior, targetGo, targetPosition);
this.m_AIBehavior.ChangeState(walkState);
}
}
}
}
public override void AICalculate()
{
if (this.m_AttackScopeList == null)
{
if (this.BuildingAI.AttackBehavior.AttackScopeArray.Count > 0)
{
this.m_AttackScopeList = new List <TilePosition>();
TilePosition actorPosition = PositionConvertor.GetActorTileIndexFromWorldPosition(
this.BuildingAI.Property.AnchorTransform.position);
foreach (TilePosition offset in this.BuildingAI.AttackBehavior.AttackScopeArray)
{
this.m_AttackScopeList.Add(actorPosition + offset);
}
}
}
if (this.m_AttackScopeList != null)
{
if (this.m_IsFindInstantly || this.m_AIBehavior.CanTakeResponse)
{
this.FindTarget();
}
}
}
private void NotifyNearbyInvader()
{
Vector3 anchorPosition = this.m_BaseProperty.AnchorTransform.position;
TilePosition center = PositionConvertor.GetActorTileIndexFromWorldPosition(anchorPosition);
int tileRadius = Mathf.CeilToInt(this.m_NotifyRadius /
Mathf.Min(ClientSystemConstants.ACTOR_TILE_MAP_TILE_SIZE.width, ClientSystemConstants.ACTOR_TILE_MAP_TILE_SIZE.height));
List <TilePosition> points = RoundHelper.FillCircle(center.Column, center.Row, tileRadius);
List <GameObject> actors = this.SceneHelper.GetActors(points, TargetType.Ground);
foreach (GameObject actor in actors)
{
CharacterPropertyBehavior property = actor.GetComponent <CharacterPropertyBehavior>();
if (property.CharacterType == CharacterType.Invader)
{
Vector2 dist = (Vector2)(anchorPosition - actor.transform.position);
if (this.m_NotifyRadiusSqr >= Vector2.SqrMagnitude(dist))
{
actor.GetComponent <CharacterAI>().SetIdle(false);
}
}
}
}
public CharacterIdleState(NewAI aiBehavior, bool isFindInstantly) : base(aiBehavior)
{
this.m_IsFindInstantly = isFindInstantly;
this.m_CurrentPosition = PositionConvertor.GetActorTileIndexFromWorldPosition(this.m_AIBehavior.transform.position);
}
public override void AICalculate()
{
if (this.m_LinePath.Count == 0)
{
this.OnTargetReached();
}
else
{
Vector2 sourcePosition = this.m_AIBehavior.transform.position;
Vector2 destinationPosition = (Vector2)PositionConvertor.GetWorldPositionFromActorTileIndex(this.m_LinePath.Peek());
if (this.m_LinePath.Count == 1)
{
destinationPosition += this.m_TargetOffset;
}
float move = this.WalkVelocity;
float distance = Vector2.Distance(sourcePosition, destinationPosition);
Vector2 result = Vector2.zero;
Vector2 deltaVector = destinationPosition - sourcePosition;
while (distance <= move)
{
this.m_LinePath.Dequeue();
result += deltaVector;
move -= distance;
sourcePosition = destinationPosition;
if (this.m_LinePath.Count == 0)
{
distance = 0;
break;
}
destinationPosition = (Vector2)PositionConvertor.GetWorldPositionFromActorTileIndex(this.m_LinePath.Peek());
if (this.m_LinePath.Count == 1)
{
destinationPosition += this.m_TargetOffset;
}
distance = Vector2.Distance(sourcePosition, destinationPosition);
deltaVector = destinationPosition - sourcePosition;
}
if (distance.IsZero())
{
result = deltaVector;
}
else
{
float percentage = move / distance;
result += deltaVector * percentage;
}
this.m_MoveVector = result;
this.m_AIBehavior.transform.position += new Vector3(result.x, result.y, 0);
TilePosition currentPosition = PositionConvertor.GetActorTileIndexFromWorldPosition(this.m_AIBehavior.transform.position);
if (!currentPosition.Equals(this.m_PreviousPosition))
{
this.OnPositionTileChanged(this.m_PreviousPosition, currentPosition);
this.m_PreviousPosition = currentPosition;
}
this.m_AnimationController.PlayWalkAnimation(this.m_MoveVector);
}
}
public override void Initial()
{
this.m_AnimationController.PlayWalkAnimation(this.m_MoveVector);
this.ShowTarget();
this.m_PreviousPosition = PositionConvertor.GetActorTileIndexFromWorldPosition(this.m_AIBehavior.transform.position);
}
public override void AICalculate()
{
/*
* if(this.m_TargetBuilding != null)
* {
* if(++this.m_MoveTicks == this.m_TotalTicks)
* {
* this.m_AIBehavior.transform.position = new Vector3(this.m_TargetPosition.x, this.m_TargetPosition.y, this.m_TargetPosition.y);
* TilePosition currentPosition = PositionConvertor.GetActorTileIndexFromWorldPosition(this.m_AIBehavior.transform.position);
* if(this.m_PreviousPosition != currentPosition)
* {
* BattleMapData.Instance.RefreshInformationWithMoveActor(this.m_AIBehavior.gameObject, this.m_PreviousPosition, currentPosition);
* }
* this.Bomb(this.m_TargetBuilding);
* }
* else
* {
*/
this.m_AIBehavior.transform.position = new Vector3(this.m_AIBehavior.transform.position.x + this.m_MoveVector.x,
this.m_AIBehavior.transform.position.y + this.m_MoveVector.y,
this.m_AIBehavior.transform.position.y + this.m_MoveVector.y);
TilePosition currentPosition = PositionConvertor.GetActorTileIndexFromWorldPosition(this.m_AIBehavior.transform.position);
if (this.m_PreviousPosition != currentPosition)
{
if (currentPosition.IsValidActorTilePosition())
{
BattleMapData.Instance.RefreshInformationWithMoveActor(this.m_AIBehavior.gameObject, this.m_PreviousPosition, currentPosition);
if (!BattleMapData.Instance.ActorCanPass(currentPosition.Row, currentPosition.Column))
{
this.Bomb(BattleMapData.Instance.GetBulidingObjectFromActorObstacleMap(currentPosition.Row, currentPosition.Column));
}
}
else
{
BattleSceneHelper.Instance.DestroyActor(this.m_AIBehavior.gameObject, this.m_PreviousPosition);
GameObject.Destroy(this.m_AIBehavior.gameObject);
if (Application.loadedLevelName == ClientStringConstants.BATTLE_SCENE_LEVEL_NAME)
{
CharacterPropertyBehavior property = this.CharacterAI.PropertyBehavior;
if (property.CharacterType == CharacterType.Invader)
{
if (BattleSceneHelper.Instance.TotalInvaderCount == 0 &&
BattleRecorder.Instance.DropArmyCount == ArmyMenuPopulator.Instance.TotalArmyCount &&
BattleRecorder.Instance.DropMercenaryCount == ArmyMenuPopulator.Instance.TotalMercenaryCount)
{
BattleDirector.Instance.EndMatch();
}
}
}
}
}
this.m_PreviousPosition = currentPosition;
/*
* }
* }
* else
* {
* this.CharacterAI.SetIdle(false);
* }
*/
}
