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 override void AICalculate()
{
float distanceSqr = Vector2.SqrMagnitude((Vector2)PositionConvertor.GetWorldPositionFromActorTileIndex
(this.m_TargetPosition) - (Vector2)this.m_AIBehavior.transform.position);
if (this.m_Target == null)
{
InvaderIdleState idleState = new InvaderIdleState(this.m_AIBehavior, false);
this.m_AIBehavior.ChangeState(idleState);
}
else
{
if (distanceSqr <= this.CharacterAI.AttackBehavior.AttackScopeSqr)
{
BuildingBasePropertyBehavior property = this.m_Target.GetComponent <BuildingBasePropertyBehavior>();
AttackState attackState;
if (property == null)
{
attackState = new InvaderAttackState(this.m_AIBehavior, new AITargetObject(this.m_Target, this.m_Target.transform.position), this.CharacterAI.AttackBehavior);
}
else
{
attackState = new InvaderAttackState(this.m_AIBehavior,
new AITargetObject(this.m_Target, (Vector2)(PositionConvertor.GetWorldPositionFromActorTileIndex(this.m_TargetPosition))), this.CharacterAI.AttackBehavior);
}
this.m_AIBehavior.ChangeState(attackState);
}
else
{
base.AICalculate();
}
}
}
public void SendBuilderBuild(int builderNO, int builderLevel, IObstacleInfo targetInfo, IMapData mapData)
{
GameObject builder = null;
if (this.m_Builders.ContainsKey(builderNO))
{
builder = this.m_Builders[builderNO];
builder.SetActive(true);
}
else
{
builder = this.GenerateBuilder(builderNO, builderLevel);
this.m_Builders.Add(builderNO, builder);
}
TilePosition buildPoint = BorderPointHelper.FindValidInflateOneBorderPoint(targetInfo);
builder.transform.position = PositionConvertor.GetWorldPositionFromActorTileIndex(buildPoint);
BuilderAI builderAI = builder.GetComponent <BuilderAI>();
builderAI.MapData = mapData;
builderAI.BuilderNO = builderNO;
builderAI.Build(targetInfo, buildPoint);
}
private void Appear()
{
List <IBuildingInfo> buildings = ((VillagerAI)this.m_AIBehavior).SceneHelper.GetBuildingsOfTypes(this.m_AppearBuildings);
int index = Random.Range(0, buildings.Count);
IBuildingInfo appearBuilding = buildings[index];
while (appearBuilding.IsBuildingHover(((VillagerAI)this.m_AIBehavior).MapData))
{
index = Random.Range(0, buildings.Count);
appearBuilding = buildings[index];
}
List <TilePosition> borders = BorderPointHelper.GetBorder(appearBuilding);
index = Random.Range(0, borders.Count);
TilePosition appearPoint = appearBuilding.ActorPosition + borders[index];
while (!appearPoint.IsValidActorTilePosition())
{
index = Random.Range(0, borders.Count);
appearPoint = appearBuilding.BuildingPosition + borders[index];
}
this.m_AIBehavior.transform.position = PositionConvertor.GetWorldPositionFromActorTileIndex(appearPoint);
this.m_AnimationController.SetVisible();
}
public void FindTargetObject(IBuildingInfo buildingInfo, TilePosition startPosition)
{
List <IBuildingInfo> buildings = this.SceneHelper.GetAllBuildings();
int index = Random.Range(0, buildings.Count);
IBuildingInfo targetBuildingInfo = buildings[index];
if (buildingInfo != null)
{
while (buildingInfo == targetBuildingInfo)
{
index = Random.Range(0, buildings.Count);
targetBuildingInfo = buildings[index];
}
}
TilePosition targetPoint = BorderPointHelper.FindValidInflateOneBorderPoint(targetBuildingInfo);
if (startPosition != null)
{
this.transform.position = PositionConvertor.GetWorldPositionFromActorTileIndex(startPosition);
}
VillagerWalkState walkState = new VillagerWalkState(this.MapData, targetPoint, this, targetBuildingInfo);
this.ChangeState(walkState);
}
public override void AICalculate()
{
if (this.m_Target == null)
{
BombermanIdleState idleState = new BombermanIdleState(this.m_AIBehavior, false);
this.m_AIBehavior.ChangeState(idleState);
}
else
{
float distanceSqr = Vector2.SqrMagnitude((Vector2)PositionConvertor.GetWorldPositionFromActorTileIndex
(this.m_TargetPosition) - (Vector2)this.m_AIBehavior.transform.position);
if (distanceSqr <= this.CharacterAI.AttackBehavior.AttackScopeSqr)
{
this.m_HPBehavior.Bomb();
List <GameObject> relatedBuildings = new List <GameObject>();
if (this.CharacterAI.AttackBehavior.DamageScope > 0)
{
relatedBuildings = BattleSceneHelper.Instance.GetNearByBuilding(this.m_AIBehavior.transform.position, this.CharacterAI.AttackBehavior.DamageScope);
}
else
{
relatedBuildings.Add(this.m_Target);
}
foreach (GameObject building in relatedBuildings)
{
BuildingHPBehavior targetHP = building.GetComponent <BuildingHPBehavior>();
targetHP.DecreaseHP(this.CharacterAI.AttackBehavior.AttackValue, this.CharacterAI.AttackBehavior.AttackCategory);
}
}
else
{
base.AICalculate();
}
}
}
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);
}
protected override void FindPath()
{
List <TilePosition> aStarPath;
List <TilePosition> linePath = AStarPathFinder.CalculatePathTile(this.FindPathStrategy, this.CharacterAI.BattleMapData.ActorObstacleArray,
this.m_PreviousPosition, this.m_TargetPosition, out aStarPath);
//this.CharacterAI.DrawPath(aStarPath);
/*
* Debug.Log("AStar Path Length is:" + aStarPath.Count);
* foreach(TilePosition at in aStarPath)
* {
* Debug.Log("row:" + at.Row + " ,column:" + at.Column);
* }
* Debug.Log("Line Path Length is:" + linePath.Count);
* foreach (TilePosition lt in linePath)
* {
* Debug.Log("row:" + lt.Row + " ,column:" + lt.Column);
* }
*/
this.SetPath(linePath);
if (linePath.Count == 0)
{
this.OnTargetReached();
}
else
{
TilePosition targetTilePosition = linePath[linePath.Count - 1];
if (this.m_MapData.GetBulidingObjectFromActorObstacleMap(targetTilePosition.Row, targetTilePosition.Column) !=
this.m_Target)
{
Vector2 reachablePosition = (Vector2)PositionConvertor.GetWorldPositionFromActorTileIndex(linePath[linePath.Count - 2]);
TilePosition targetTile = aStarPath[aStarPath.Count - 1];
for (int i = 1; i < aStarPath.Count; i++)
{
if (this.m_MapData.GetBulidingObjectFromActorObstacleMap(aStarPath[i].Row, aStarPath[i].Column) == this.m_Target)
{
targetTile = aStarPath[i];
break;
}
}
Vector2 targetPosition = (Vector2)PositionConvertor.GetWorldPositionFromActorTileIndex(targetTile);
if (Vector2.SqrMagnitude(targetPosition - reachablePosition) <= this.CharacterAI.AttackBehavior.AttackScopeSqr)
{
this.m_TargetPosition = targetTile;
this.ShowTarget();
return;
}
}
this.m_TargetPosition = targetTilePosition;
this.m_Target = this.CharacterAI.BattleMapData.GetBulidingObjectFromActorObstacleMap
(this.m_TargetPosition.Row, this.m_TargetPosition.Column);
this.ShowTarget();
}
}
public void GenerateArmyInCamp(IBuildingInfo campInfo)
{
this.transform.position = PositionConvertor.GetWorldPositionFromActorTileIndex(
this.FindCampStandablePoint(campInfo)) + new Vector3(Random.Range(-ClientSystemConstants.ACTOR_TILE_MAP_TILE_SIZE.width / 2, ClientSystemConstants.ACTOR_TILE_MAP_TILE_SIZE.height / 2),
Random.Range(-ClientSystemConstants.ACTOR_TILE_MAP_TILE_SIZE.width / 2, ClientSystemConstants.ACTOR_TILE_MAP_TILE_SIZE.height / 2), 0);
ArmyIdleState idleState = new ArmyIdleState(this, campInfo);
this.ChangeState(idleState);
}
public void SendMercenaryToCamp(MercenaryType mercenaryType, IBuildingInfo campInfo, IBuildingInfo factoryInfo)
{
GameObject mercenary = this.GenerateMercenary(mercenaryType);
TilePosition initialPoint = BorderPointHelper.FindValidInflateOneBorderPoint(factoryInfo);
mercenary.transform.position = PositionConvertor.GetWorldPositionFromActorTileIndex(initialPoint);
ArmyAI ai = mercenary.GetComponent <ArmyAI>();
ai.SendArmyToCamp(campInfo);
}
public void SendArmyToCamp(ArmyType armyType, int level, IBuildingInfo campInfo, IBuildingInfo factoryInfo)
{
GameObject army = this.GenerateArmy(armyType, level);
TilePosition initialPoint = BorderPointHelper.FindValidInflateOneBorderPoint(factoryInfo);
army.transform.position = PositionConvertor.GetWorldPositionFromActorTileIndex(initialPoint);
ArmyAI ai = army.GetComponent <ArmyAI>();
ai.SendArmyToCamp(campInfo);
}
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_Target == null)
{
KodoIdleState idleState = new KodoIdleState(this.m_AIBehavior, false);
this.m_AIBehavior.ChangeState(idleState);
}
else
{
float distanceSqr = Vector2.SqrMagnitude((Vector2)PositionConvertor.GetWorldPositionFromActorTileIndex
(this.m_TargetPosition) - (Vector2)this.m_AIBehavior.transform.position);
if(distanceSqr <= this.CharacterAI.AttackBehavior.AttackScopeSqr)
{
this.m_HPBehavior.Bomb();
BuildingHPBehavior targetHP = this.m_Target.transform.GetComponent<BuildingHPBehavior>();
targetHP.DecreaseHP(this.CharacterAI.AttackBehavior.AttackValue, this.CharacterAI.AttackBehavior.AttackCategory);
}
else
{
base.AICalculate();
}
}
}
public override void Initial()
{
ActorConfig config = ActorPrefabConfig.Instance.GetComponent <ActorConfig>();
this.m_CurrentFrame = config.BuildAnimationFrame;
if (SceneManager.Instance != null)
{
GameObject go = SceneManager.Instance.GetBuildingObjectFromBuildingObstacleMap(this.m_TargetInfo.BuildingPosition.Row,
this.m_TargetInfo.BuildingPosition.Column);
if (go != null)
{
Transform anchorPosition = go.transform.FindChild(ClientStringConstants.BUILDING_ANCHOR_OBJECT_NAME);
if (anchorPosition != null)
{
this.m_AnimationController.PlayBuildAnimation(anchorPosition.position);
}
else
{
this.m_AnimationController.PlayBuildAnimation(PositionConvertor.GetWorldPositionFromActorTileIndex(this.m_TargetInfo.ActorPosition));
}
}
}
else
{
BuildingBasePropertyBehavior property = this.m_TargetInfo as BuildingBasePropertyBehavior;
if (property != null)
{
this.m_AnimationController.PlayBuildAnimation(property.AnchorTransform.position);
}
else
{
this.m_AnimationController.PlayBuildAnimation(PositionConvertor.GetWorldPositionFromActorTileIndex(this.m_TargetInfo.ActorPosition));
}
}
}
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);
}
}
