public static List <TilePosition> GetInflateOneBorder(IObstacleInfo obstacle, bool isActor)
{
if (obstacle is IBuildingInfo)
{
IBuildingInfo building = obstacle as IBuildingInfo;
if (!s_BuildingInflateOneBorderDict.ContainsKey(building.BuildingType))
{
List <TilePosition> inflateOneObstacleList = Inflate(obstacle, isActor);
List <TilePosition> border = FindBorder(inflateOneObstacleList);
s_BuildingInflateOneBorderDict.Add(building.BuildingType, border);
}
return(s_BuildingInflateOneBorderDict[building.BuildingType]);
}
else
{
IRemovableObjectInfo removableObject = obstacle as IRemovableObjectInfo;
if (!s_RemovableObjectInflateOneBorderDict.ContainsKey(removableObject.ObjectType))
{
List <TilePosition> inflateOneObstacleList = Inflate(obstacle, isActor);
List <TilePosition> border = FindBorder(inflateOneObstacleList);
s_RemovableObjectInflateOneBorderDict.Add(removableObject.ObjectType, border);
}
return(s_RemovableObjectInflateOneBorderDict[removableObject.ObjectType]);
}
}
public static TilePosition FindValidInflateOneBorderPoint(IObstacleInfo obstacleInfo, bool isActor)
{
List <TilePosition> borders = GetInflateOneBorder(obstacleInfo, isActor);
int index = Random.Range(0, borders.Count);
TilePosition result = isActor ? obstacleInfo.ActorPosition + borders[index] :
obstacleInfo.BuildingPosition + borders[index];
if (isActor)
{
while (!result.IsValidActorTilePosition())
{
index = Random.Range(0, borders.Count);
result = obstacleInfo.ActorPosition + borders[index];
}
}
else
{
while (!result.IsValidBuildingTilePosition())
{
index = Random.Range(0, borders.Count);
result = obstacleInfo.BuildingPosition + borders[index];
}
}
//Debug.Log(result.Row + " , " + result.Column);
return(result);
}
public BuilderBuildState(NewAI aiBehavior, IObstacleInfo targetInfo, IMapData mapData, TilePosition buildPosition) : base(aiBehavior)
{
this.m_TargetInfo = targetInfo;
this.m_TargetPosition = this.m_TargetInfo.BuildingPosition;
this.m_BuildPosition = buildPosition;
this.m_MapData = mapData;
}
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);
}
public BuilderBuildHoverState(IObstacleInfo targetInfo, IMapData mapData, TilePosition targetPosition, NewAI aiBehavior)
: base(mapData, targetPosition, aiBehavior, targetInfo)
{
ActorConfig config = ActorPrefabConfig.Instance.GetComponent <ActorConfig>();
this.WalkVelocity = config.BuilderMoveVelocity;
}
protected override void CalculateLightPositions(GameObject target, int targetRow, int targetColumn)
{
base.CalculateLightPositions(target, targetRow, targetColumn);
IObstacleInfo property = this.m_MapData.GetObstacleInfoFormActorObstacleMap(targetRow, targetColumn);
int radius = Mathf.FloorToInt(m_AttackScope /
Mathf.Min(ClientSystemConstants.ACTOR_TILE_MAP_TILE_SIZE.width,
ClientSystemConstants.ACTOR_TILE_MAP_TILE_SIZE.height));
radius = Mathf.Max(0, radius - 1);
foreach (TilePosition offset in property.ActorObstacleList)
{
TilePosition targetPosition = property.ActorPosition + offset;
List <TilePosition> destinationTiles = RoundHelper.FillCircle(targetPosition.Column, targetPosition.Row, radius);
foreach (TilePosition lightPosition in destinationTiles)
{
if (lightPosition.IsValidActorTilePosition())
{
if (!this.m_PreviousTargetLightPositions.Contains(lightPosition.Column + (lightPosition.Row << 16)))
{
this.m_PreviousTargetLightPositions.Add(lightPosition.Column + (lightPosition.Row << 16));
}
}
}
}
}
private static List <TilePosition> FindBorder(IObstacleInfo obstacleInfo)
{
ObstacleConfigData data = null;
if (obstacleInfo is IBuildingInfo)
{
data = ConfigInterface.Instance.BuildingConfigHelper.GetBuildingData(((IBuildingInfo)obstacleInfo).BuildingType, 0);
}
else
{
data = ConfigInterface.Instance.RemovableConfigHelper.GetRemovableObjectData(((IRemovableObjectInfo)obstacleInfo).ObjectType);
}
List <TilePosition> obstacleList = new List <TilePosition>();
int minRow = 255;
int maxRow = -255;
int minColumn = 255;
int maxColumn = -255;
foreach (ConfigUtilities.Structs.TilePoint obstacle in data.ActorObstacleList)
{
minRow = Mathf.Min(minRow, obstacle.row);
maxRow = Mathf.Max(maxRow, obstacle.row);
minColumn = Mathf.Min(minColumn, obstacle.column);
maxColumn = Mathf.Max(maxColumn, obstacle.column);
obstacleList.Add(obstacle.ConvertToTilePosition());
}
return(FindBorder(obstacleList, minRow, maxRow, minColumn, maxColumn));
}
public void SendBuilder(int builderNO, IObstacleInfo targetInfo)
{
BuildingLogicData builderHutData = LogicController.Instance.GetBuildingObject(
new BuildingIdentity(ConfigUtilities.Enums.BuildingType.BuilderHut, builderNO));
int builderLevel = builderHutData.Level;
BuildingSceneDirector.Instance.SendBuilderToBuild(builderNO, builderLevel, builderHutData.BuildingPosition,
targetInfo, SceneManager.Instance);
this.AddBusyBuilder(builderNO, targetInfo);
}
protected virtual int GetWeightAccordingToObstacle(IObstacleInfo obstacle)
{
if (obstacle is IRemovableObjectInfo)
{
return(1000);
}
else
{
return(20);
}
}
protected override int GetWeightAccordingToObstacle(IObstacleInfo obstacle)
{
if (obstacle is IBuildingInfo)
{
if (((IBuildingInfo)obstacle).BuildingType == BuildingType.Wall)
{
return(10);
}
}
return(base.GetWeightAccordingToObstacle(obstacle));
}
public static bool IsBuildingHover(this IObstacleInfo buildingInfo, IMapData mapData)
{
if(Application.loadedLevelName != ClientStringConstants.BUILDING_SCENE_LEVEL_NAME)
{
return false;
}
else
{
TilePosition buildingPosition = buildingInfo.GetBuildingFirstBuildingPosition();
return mapData.GetBuildingObjectFromBuildingObstacleMap(buildingPosition.Row, buildingPosition.Column) == null;
}
}
public Nullable <bool> FindNeighourWallNotNull(BuildingObstacleDirection wallDirection, int index)
{
TilePosition tilePosition = null;
BuildingLogicData buildingLogicData = null;
switch (wallDirection)
{
case BuildingObstacleDirection.Top:
tilePosition = new TilePosition(this.BuildingLogicData.BuildingPosition.Column, this.BuildingLogicData.BuildingPosition.Row + index);
break;
case BuildingObstacleDirection.Bottom:
tilePosition = new TilePosition(this.BuildingLogicData.BuildingPosition.Column, this.BuildingLogicData.BuildingPosition.Row - index);
break;
case BuildingObstacleDirection.Left:
tilePosition = new TilePosition(this.BuildingLogicData.BuildingPosition.Column - index, this.BuildingLogicData.BuildingPosition.Row);
break;
case BuildingObstacleDirection.Right:
tilePosition = new TilePosition(this.BuildingLogicData.BuildingPosition.Column + index, this.BuildingLogicData.BuildingPosition.Row);
break;
}
IObstacleInfo obstacleInfo = SceneManager.Instance.GetBuildingInfoFormBuildingObstacleMap(tilePosition.Row, tilePosition.Column);
if (obstacleInfo == null)
{
return(null);
}
else
{
buildingLogicData = obstacleInfo as BuildingLogicData;
if (buildingLogicData != null)
{
if (buildingLogicData.BuildingIdentity.buildingType == BuildingType.Wall)
{
return(true);
}
else
{
return(null);
}
}
return(null);
}
}
protected override void CalculateLightPositions (GameObject target, int targetRow, int targetColumn)
{
base.CalculateLightPositions (target, targetRow, targetColumn);
IObstacleInfo obstacleInfo = this.m_MapData.GetObstacleInfoFormActorObstacleMap(this.m_SourceRow, this.m_SourceColumn);
if(obstacleInfo != null)
{
TilePosition position = obstacleInfo.ActorPosition;
foreach(TilePosition offset in obstacleInfo.ActorObstacleList)
{
TilePosition lightPosition = position + offset;
this.m_PreviousTargetLightPositions.Add(lightPosition.GetIndexInt());
}
}
}
public int GetWeight(int row, int column, int destinationRow, int destinationColumn)
{
GameObject target = this.m_MapData.GetBuildingObjectFromBuildingObstacleMap(destinationRow, destinationColumn);
if (!this.m_MapData.ActorCanPass(destinationRow, destinationColumn))
{
if (target != this.m_PreviousCalculateTarget)
{
this.CalculateLightPositions(target);
this.m_PreviousCalculateTarget = target;
}
if (this.IsInLightArray(row, column))
{
return(1);
}
}
IObstacleInfo obstacleInfo = this.m_MapData.GetObstacleInfoFormActorObstacleMap(row, column);
int weight = obstacleInfo == null ? 1 : this.GetWeightAccordingToObstacle(obstacleInfo);
return(weight);
}
protected override bool IsInLightArray(int row, int column)
{
GameObject relatedObject = this.m_MapData.GetBulidingObjectFromActorObstacleMap(row, column);
if (relatedObject == null)
{
return(false);
}
IObstacleInfo property = this.m_MapData.GetObstacleInfoFormActorObstacleMap(row, column);
TilePosition buildingPosition = property.ActorPosition;
foreach (TilePosition offset in property.ActorObstacleList)
{
TilePosition position = buildingPosition + offset;
if (position.IsValidActorTilePosition() &&
!this.m_PreviousTargetLightPositions.Contains(position.Column + (position.Row << 16)))
{
return(false);
}
}
return(true);
}
public void SendBuilderToBuild(int builderNO, int builderLevel, TilePosition builderHutPosition,
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);
builder.transform.position = PositionConvertor.GetWorldPositionFromBuildingTileIndex(builderHutPosition);
}
BuilderAI builderAI = builder.GetComponent <BuilderAI>();
builderAI.MapData = mapData;
builderAI.BuilderNO = builderNO;
builderAI.Build(targetInfo);
}
public MovableTargetWalkState(IMapData mapData, TilePosition targetPosition, NewAI aiBehavior, IObstacleInfo targetInfo)
: base(mapData, targetPosition, aiBehavior)
{
this.m_TargetInfo = targetInfo;
this.m_TargetObjectPosition = targetInfo.ActorPosition;
}
public void AddBusyBuilder(int builderNO, IObstacleInfo targetInfo)
{
this.Builders[builderNO].Build(targetInfo);
this.m_BusyBuilderNumber++;
}
public static TilePosition GetBuildingFirstActorPosition(this IObstacleInfo buildingInfo)
{
return buildingInfo.ActorPosition + buildingInfo.ActorObstacleList[0];
}
public void Build(IObstacleInfo target)
{
this.m_Data.CurrentWorkTarget = target;
}
public void Build(IObstacleInfo targetInfo)
{
BuilderWalkState walkState = new BuilderWalkState(targetInfo, this.MapData, targetInfo.ActorPosition, this); //targetData, targetData.BuildingPosition, this);
this.ChangeState(walkState);
}
private static List <TilePosition> Inflate(IObstacleInfo obstacleInfo, bool isActor)
{
ObstacleConfigData data = null;
if (obstacleInfo is IBuildingInfo)
{
data = ConfigInterface.Instance.BuildingConfigHelper.GetBuildingData(((IBuildingInfo)obstacleInfo).BuildingType, 0);
}
else
{
data = ConfigInterface.Instance.RemovableConfigHelper.GetRemovableObjectData(((IRemovableObjectInfo)obstacleInfo).ObjectType);
}
List <TilePosition> obstacleList = new List <TilePosition>();
if (isActor)
{
foreach (ConfigUtilities.Structs.TilePoint obstacle in data.ActorObstacleList)
{
obstacleList.Add(obstacle.ConvertToTilePosition());
}
}
else
{
foreach (ConfigUtilities.Structs.TilePoint obstacle in data.BuildingObstacleList)
{
obstacleList.Add(obstacle.ConvertToTilePosition());
}
}
List <TilePosition> inflateList = new List <TilePosition>();
foreach (TilePosition obstacle in obstacleList)
{
TilePosition up = new TilePosition(obstacle.Column, obstacle.Row - 1);
TilePosition down = new TilePosition(obstacle.Column, obstacle.Row + 1);
TilePosition left = new TilePosition(obstacle.Column - 1, obstacle.Row);
TilePosition right = new TilePosition(obstacle.Column + 1, obstacle.Row);
TilePosition leftUp = new TilePosition(obstacle.Column - 1, obstacle.Row - 1);
TilePosition rightUp = new TilePosition(obstacle.Column + 1, obstacle.Row - 1);
TilePosition leftDown = new TilePosition(obstacle.Column - 1, obstacle.Row + 1);
TilePosition rightDown = new TilePosition(obstacle.Column + 1, obstacle.Row + 1);
if (!obstacleList.Contains(up) && !inflateList.Contains(up))
{
inflateList.Add(up);
}
if (!obstacleList.Contains(down) && !inflateList.Contains(down))
{
inflateList.Add(down);
}
if (!obstacleList.Contains(left) && !inflateList.Contains(left))
{
inflateList.Add(left);
}
if (!obstacleList.Contains(right) && !inflateList.Contains(right))
{
inflateList.Add(right);
}
if (!obstacleList.Contains(leftUp) && !inflateList.Contains(leftUp))
{
inflateList.Add(leftUp);
}
if (!obstacleList.Contains(rightUp) && !inflateList.Contains(rightUp))
{
inflateList.Add(rightUp);
}
if (!obstacleList.Contains(leftDown) && !inflateList.Contains(leftDown))
{
inflateList.Add(leftDown);
}
if (!obstacleList.Contains(rightDown) && !inflateList.Contains(rightDown))
{
inflateList.Add(rightDown);
}
}
List <TilePosition> result = new List <TilePosition>();
result.AddRange(obstacleList);
result.AddRange(inflateList);
return(result);
}
public void Build(IObstacleInfo targetInfo, TilePosition buildPosition)
{
BuilderBuildState buildState = new BuilderBuildState(this, targetInfo, this.MapData, buildPosition);
this.ChangeState(buildState);
}
public static List <TilePosition> GetInflateOneBorder(IObstacleInfo obstacle)
{
return(GetInflateOneBorder(obstacle, true));
}
public static TilePosition FindValidInflateOneBorderPoint(IObstacleInfo obstacleInfo)
{
return(FindValidInflateOneBorderPoint(obstacleInfo, true));
}
protected virtual int GetWeightAccordingToObstacle(IObstacleInfo obstacle)
{
return(4);
}
