void Update()
{
if (!this.m_IsLoadSceneFromDisk)
{
Hashtable map = MapReader.Instance.LoadMap();
if (map != null)
{
FindRivalResponseParameter param = DataConvertor.ConvertJSONToParameter(map);
foreach (var building in param.Buildings)
{
EditorFactory.Instance.ConstructBuilding(building.BuildingType, building.Level,
new TilePosition(building.PositionColumn, building.PositionRow));
}
foreach (var removableObject in param.Objects)
{
EditorFactory.Instance.ConstructRemovableObject(removableObject.ObjectType,
new TilePosition(removableObject.PositionColumn, removableObject.PositionRow));
}
foreach (var achievementBuilding in param.AchievementBuildings)
{
EditorFactory.Instance.ConstructAchievementBuilding(achievementBuilding.AchievementBuildingType,
new TilePosition(achievementBuilding.PositionColumn, achievementBuilding.PositionRow));
}
foreach (var defenseObject in param.DefenseObjects)
{
EditorFactory.Instance.ConstructDefenseObject(defenseObject.PropsType,
new TilePosition(defenseObject.PositionColumn, defenseObject.PositionRow));
}
}
this.m_IsLoadSceneFromDisk = true;
}
}
public void ConstructScene(FindRivalResponseParameter rival)
{
this.m_CameraInitializer.Reset();
this.m_MatchObserveStartTick = TimeTickRecorder.Instance.CurrentTimeTick;
//this.CurrentRivalAge = CommonHelper.GetAgeFromPlayerLevel(rival.RivalLevel);
this.m_IsBattleObserve = true;
this.m_CurrentRivalID = rival.RivalID;
this.m_CurrentRivalName = rival.RivalName;
this.m_CurrentRivalLevel = rival.RivalLevel;
this.m_CurrentRivalHonour = rival.RivalHonour;
this.m_CurrentRivalPropsType = rival.RivalPropsType;
this.m_SceneHelper.ClearObject();
this.m_GridFactory.Clear();
this.m_SceneDirector.ClearAllActors();
Resources.UnloadUnusedAssets();
this.m_BuildingFactory.ConstructBuilding(rival);
this.m_Map.SetMap(this.CurrentRivalAge);
BattleMapData.Instance.ConstructGridArray();
this.m_GridFactory.ConstructGird();
this.m_SceneDirector.GenerateActors();
if (BattleData.RivalInformation != null)
{
this.m_NextButton.HideButton();
}
}
private void NotifyConstructScene(FindRivalResponseParameter rival)
{
this.m_Director.ConstructScene(rival);
this.m_CurrentRivalID = rival.RivalID;
if (BattleData.RivalInformation == null)
{
this.m_NextButton.DisplayButton();
}
this.m_NextButton.ProcessFinish();
this.StartCoroutine("Wait");
this.m_TimeTips.ShowTime();
}
private void RivalFound(Hashtable rival)
{
this.m_ActivityView.SetActive(false);
if (rival.Count == 0)
{
this.m_NotFound.Show();
}
else
{
Hashtable rivalData = rival;
FindRivalResponseParameter parameter = new FindRivalResponseParameter();
parameter.InitialParameterObjectFromHashtable(rivalData);
print(parameter.RivalName);
LogicController.Instance.FindMatch();
this.NotifyConstructScene(parameter);
}
}
public void ConstructBuilding(FindRivalResponseParameter response)
{
foreach (BattleRemovableObjectParameter removableObject in response.Objects)
{
this.ConstructRemovableObject(removableObject);
}
foreach (BattleDefenseObjectParameter defenseObject in response.DefenseObjects)
{
this.ConstructDefenseObject(defenseObject);
}
if (response.Buffs != null)
{
BuildingBuffSystem.Instance.ClearBuff();
BuildingBuffSystem.Instance.InitialBuff(response.Buffs);
}
bool isReplay = Application.loadedLevelName == ClientStringConstants.BATTLE_REPLAY_LEVEL_NAME;
Dictionary <BuildingType, int> NOGenerater = new Dictionary <BuildingType, int>();
if (isReplay)
{
for (int i = 0; i < (int)BuildingType.Length; i++)
{
NOGenerater.Add((BuildingType)i, 0);
}
}
Age age = Age.Prehistoric;
bool isInitialAge = false;
List <BuildingSurfaceBehavior> notInitialSurfaces = new List <BuildingSurfaceBehavior>();
foreach (BattleBuildingParameter building in response.Buildings)
{
BuildingConfigData configData = ConfigInterface.Instance.BuildingConfigHelper.GetBuildingData(building.BuildingType, building.Level);
string prefabName = string.Format("{0}{1}{2}", ClientStringConstants.BATTLE_SCENE_RESOURCE_PREFAB_PREFIX_NAME,
ClientStringConstants.BUILDING_OBJECT_PREFAB_PREFIX_NAME, configData.BuildingPrefabName);
GameObject buildingPrefab = Resources.Load(prefabName) as GameObject;
GameObject buildingObject = GameObject.Instantiate(buildingPrefab) as GameObject;
buildingObject.transform.position = PositionConvertor.GetWorldPositionFromBuildingTileIndex
(new TilePosition(building.PositionColumn, building.PositionRow));
buildingObject.transform.parent = this.m_ParentNode;
BuildingPropertyBehavior property = buildingObject.GetComponent <BuildingPropertyBehavior>();
property.BuildingType = building.BuildingType;
if (building.BuildingType == BuildingType.CityHall)
{
this.m_CurrentRivalCityHallLevel = building.Level;
age = CommonUtilities.CommonUtilities.GetAgeFromCityHallLevel(building.Level);
isInitialAge = true;
}
if (isReplay)
{
property.BuildingNO = NOGenerater[building.BuildingType];
NOGenerater[building.BuildingType]++;
}
else
{
property.BuildingNO = building.BuildingNO;
}
property.BuildingCategory = (BuildingCategory)configData.Category;
property.Level = building.Level;
property.BuildingPosition = new TilePosition(building.PositionColumn, building.PositionRow);
property.BuildingObstacleList = new List <TilePosition>();
property.ActorObstacleList = new List <TilePosition>();
foreach (TilePoint buildingObstacle in configData.BuildingObstacleList)
{
property.BuildingObstacleList.Add(buildingObstacle.ConvertToTilePosition());
}
foreach (TilePoint actorObstacle in configData.ActorObstacleList)
{
property.ActorObstacleList.Add(actorObstacle.ConvertToTilePosition());
}
//propert
property.PlunderRate = configData.PlunderRate;
property.GoldCapacity = configData.StoreGoldCapacity;
property.FoodCapacity = configData.StoreFoodCapacity;
property.OilCapacity = configData.StoreOilCapacity;
property.Buffs = BuildingBuffSystem.Instance.GetBuffs(property.BuildingCategory);
if (building.CurrentGold.HasValue || building.CurrentFood.HasValue || building.CurrentOil.HasValue)
{
property.Gold = building.CurrentGold.HasValue ? building.CurrentGold.Value : 0;
property.Food = building.CurrentFood.HasValue ? building.CurrentFood.Value : 0;
property.Oil = building.CurrentOil.HasValue ? building.CurrentOil.Value : 0;
property.Gold = Mathf.RoundToInt(property.Gold * property.PlunderRate);
property.Food = Mathf.RoundToInt(property.Food * property.PlunderRate);
property.Oil = Mathf.RoundToInt(property.Oil * property.PlunderRate);
property.OriginalGold = property.Gold;
property.OriginalFood = property.Food;
property.OriginalOil = property.Oil;
this.m_SceneHelper.AddProduceResourceBuilding(property);
}
else
{
if ((configData.CanStoreGold && !configData.CanProduceGold && building.Level != 0) ||
(configData.CanStoreFood && !configData.CanProduceFood && building.Level != 0) ||
(configData.CanStoreOil && !configData.CanProduceOil && building.Level != 0))
{
this.m_SceneHelper.AddResourceBuilding(buildingObject,
new CapacityConfigData()
{
GoldCapacity = configData.StoreGoldCapacity,
FoodCapacity = configData.StoreFoodCapacity, OilCapacity = configData.StoreOilCapacity
});
}
}
BuildingHPBehavior hp = buildingObject.GetComponent <BuildingHPBehavior>();
hp.TotalHP = Mathf.Max(1, configData.MaxHP + property.BuffHPEffect);
hp.SceneHelper = this.m_SceneHelper;
hp.ArmorCategory = configData.ArmorCategory;
if (building.BuilderLevel.HasValue)
{
BattleObstacleUpgradingInfo info = new BattleObstacleUpgradingInfo()
{
AttachedBuilderLevel = building.BuilderLevel.Value, ObstacleProperty = property
};
this.m_SceneHelper.AddUpgradingObstacle(info);
}
if (building.IsUpgrading)
{
this.ConstructFacility(buildingObject, property);
}
BuildingSurfaceBehavior surface = buildingObject.GetComponent <BuildingSurfaceBehavior>();
if (surface != null)
{
if (isInitialAge)
{
surface.SetSurface(age, building.BuildingType);
}
else
{
notInitialSurfaces.Add(surface);
}
}
BuildingAI buildingAI = buildingObject.GetComponent <BuildingAI>();
if (configData.CanAttack && !building.IsUpgrading)
{
buildingAI.enabled = false;
AttackBehavior attackBehavior = null;
if (configData.ApMinScope > 0)
{
attackBehavior = buildingObject.AddComponent <RingAttackBehavior>();
((RingAttackBehavior)attackBehavior).BlindScope = configData.ApMinScope;
}
else
{
attackBehavior = buildingObject.AddComponent <AttackBehavior>();
}
int cd = Mathf.FloorToInt(configData.AttackCD * ClientConfigConstants.Instance.TicksPerSecond);
attackBehavior.AttackCD = Mathf.Max(1, cd - property.BuffAttackSpeedEffect);
attackBehavior.AttackScope = configData.ApMaxScope;
attackBehavior.AttackValue = Mathf.Max(1, configData.AttackValue + property.BuffAttackValueEffect);
attackBehavior.BulletFlySpeed = configData.AttackMiddleSpeed;
attackBehavior.AttackType = (AttackType)configData.AttackType;
attackBehavior.AttackCategory = configData.AttackCategory;
attackBehavior.TargetType = (TargetType)configData.TargetType;
attackBehavior.DamageScope = configData.DamageScope;
attackBehavior.PushTicks = configData.DamagePushTicks;
attackBehavior.PushVelocity = configData.DamagePushVelocity;
attackBehavior.BulletParent = this.m_BulletParent;
buildingAI.AttackBehavior = attackBehavior;
BuildingIdleState idleState = new BuildingIdleState(buildingAI, true);
buildingAI.ChangeState(idleState);
buildingAI.SceneHelper = BattleSceneHelper.Instance;
}
else
{
buildingAI.DetachSelf();
}
this.m_SceneHelper.ConstructBuilding(buildingObject);
}
foreach (BuildingSurfaceBehavior surface in notInitialSurfaces)
{
surface.SetSurface(age, surface.GetComponent <BuildingPropertyBehavior>().BuildingType);
}
this.m_SceneHelper.DistributeResource(response.TotalGold, response.TotalFood, response.TotalOil);
foreach (BattleAchievementBuildingParameter achievementBuilding in response.AchievementBuildings)
{
this.ConstructAchievementBuilding(achievementBuilding, age);
}
}
public static FindRivalResponseParameter ConvertJSONToParameter(Hashtable map)
{
FindRivalResponseParameter result = new FindRivalResponseParameter();
result.Objects = new List <BattleRemovableObjectParameter>();
result.Buildings = new List <BattleBuildingParameter>();
result.AchievementBuildings = new List <BattleAchievementBuildingParameter>();
result.DefenseObjects = new List <BattleDefenseObjectParameter>();
result.RivalHonour = 10000;
result.RivalID = -100;
result.RivalLevel = -100;
result.RivalName = "电脑";
result.TotalFood = 0;
result.TotalGold = 0;
result.TotalOil = 0;
if (map.ContainsKey(EditorConfigInterface.Instance.MapBuildingKey))
{
var buildings = (ArrayList)map[EditorConfigInterface.Instance.MapBuildingKey];
foreach (var b in buildings)
{
Hashtable building = (Hashtable)b;
BattleBuildingParameter param = new BattleBuildingParameter();
param.BuildingNO = Convert.ToInt32(building[EditorConfigInterface.Instance.MapBuildingNoKey]);
param.BuildingType = (BuildingType)(Convert.ToInt32(building[EditorConfigInterface.Instance.MapBuildingTypeKey]));
param.IsUpgrading = false;
param.Level = Convert.ToInt32(building[EditorConfigInterface.Instance.MapBuildingLevelKey]);
param.PositionColumn = Convert.ToInt32(building[EditorConfigInterface.Instance.MapBuildingColumnKey]);
param.PositionRow = Convert.ToInt32(building[EditorConfigInterface.Instance.MapBuildingRowKey]);
BuildingConfigData configData = ConfigInterface.Instance.BuildingConfigHelper.GetBuildingData(param.BuildingType, param.Level);
if (configData.StoreGoldCapacity > 0)
{
if (configData.CanProduceGold)
{
param.CurrentGold = configData.StoreGoldCapacity;
}
else
{
result.TotalGold += configData.StoreGoldCapacity;
}
}
if (configData.StoreFoodCapacity > 0)
{
if (configData.CanProduceFood)
{
param.CurrentFood = configData.StoreFoodCapacity;
}
else
{
result.TotalFood += configData.StoreFoodCapacity;
}
}
if (configData.StoreOilCapacity > 0)
{
if (configData.CanProduceOil)
{
param.CurrentOil = configData.StoreOilCapacity;
}
else
{
result.TotalOil += configData.StoreOilCapacity;
}
}
result.Buildings.Add(param);
}
}
if (map.ContainsKey(EditorConfigInterface.Instance.MapRemovableObjectKey))
{
var objects = (ArrayList)map[EditorConfigInterface.Instance.MapRemovableObjectKey];
foreach (var o in objects)
{
Hashtable removableObject = (Hashtable)o;
BattleRemovableObjectParameter param = new BattleRemovableObjectParameter();
param.ObjectType = (RemovableObjectType)(Convert.ToInt32(removableObject[EditorConfigInterface.Instance.MapRemovableObjectTypeKey]));
param.PositionRow = Convert.ToInt32(removableObject[EditorConfigInterface.Instance.MapBuildingRowKey]);
param.PositionColumn = Convert.ToInt32(removableObject[EditorConfigInterface.Instance.MapBuildingColumnKey]);
result.Objects.Add(param);
}
}
if (map.ContainsKey(EditorConfigInterface.Instance.MapAchievementBuildingKey))
{
var achievementBuildings = (ArrayList)map[EditorConfigInterface.Instance.MapAchievementBuildingKey];
int buildingNo = 0;
foreach (var a in achievementBuildings)
{
Hashtable achievementBuilding = (Hashtable)a;
BattleAchievementBuildingParameter param = new BattleAchievementBuildingParameter();
param.AchievementBuildingNo = ++buildingNo;
param.AchievementBuildingType = (AchievementBuildingType)(Convert.ToInt32(achievementBuilding[EditorConfigInterface.Instance.MapAchievementBuildingTypeKey]));
param.IsDropProps = false;
param.PositionRow = Convert.ToInt32(achievementBuilding[EditorConfigInterface.Instance.MapAchievementBuildingRowKey]);
param.PositionColumn = Convert.ToInt32(achievementBuilding[EditorConfigInterface.Instance.MapAchievementBuildingColumnKey]);
result.AchievementBuildings.Add(param);
}
}
if (map.ContainsKey(EditorConfigInterface.Instance.MapDefenseObjectKey))
{
var defenseObjects = (ArrayList)map[EditorConfigInterface.Instance.MapDefenseObjectKey];
long objectID = 0;
foreach (var d in defenseObjects)
{
Hashtable defenseObject = (Hashtable)d;
BattleDefenseObjectParameter param = new BattleDefenseObjectParameter();
param.DefenseObjectID = objectID++;
param.PropsType = (PropsType)(Convert.ToInt32(defenseObject[EditorConfigInterface.Instance.MapDefenseObjectTypeKey]));
param.PositionRow = Convert.ToInt32(defenseObject[EditorConfigInterface.Instance.MapDefenseObjectRowKey]);
param.PositionColumn = Convert.ToInt32(defenseObject[EditorConfigInterface.Instance.MapDefenseObjectColumnKey]);
result.DefenseObjects.Add(param);
}
}
return(result);
}
