public void DropArmy(ArmyIdentity id)
{
ArmyLogicData armyData = LogicController.Instance.GetArmyObjectData(id);
this.m_Buildings[armyData.CampID.buildingType][armyData.CampID.buildingNO].DropArmy(id);
this.AssignArmies();
}
public void ProduceArmy(ArmyIdentity armyID, BuildingIdentity factoryID)
{
BuildingLogicObject factory = this.m_Buildings[factoryID.buildingType][factoryID.buildingNO];
factory.ProduceArmy(armyID);
this.ReCalculateResource();
}
public void DropArmy(ArmyIdentity id)
{
this.m_Armies[id.armyType].Remove(id.armyNO);
if (this.m_Armies[id.armyType].Count == 0)
{
this.m_Armies.Remove(id.armyType);
}
}
public void SendCancelProduceArmyRequest(ArmyIdentity armyID)
{
ArmyProduceCancelReqeustParameter request = new ArmyProduceCancelReqeustParameter();
request.ArmyType = armyID.armyType;
request.ArmyNO = armyID.armyNO;
request.OperateTick = LogicTimer.Instance.GetServerTick();
CommunicationUtility.Instance.CancelArmyProduce(request);
}
public void SendFinishProduceArmyRequest(ArmyIdentity armyID, BuildingIdentity campID, float remainingSecond)
{
ArmyProduceSuccessRequestParameter request = new ArmyProduceSuccessRequestParameter();
request.ArmyType = armyID.armyType;
request.ArmyNO = armyID.armyNO;
request.OwnerBuildingType = campID.buildingType;
request.OwnerBuildingNO = campID.buildingNO;
request.OperateTick = LogicTimer.Instance.GetServerTick(remainingSecond);
CommunicationUtility.Instance.FinishArmyProduce(request);
}
public void SendProduceArmyRequest(BuildingIdentity factoryID, ArmyIdentity armyID, int order)
{
ArmyProduceRequestParameter request = new ArmyProduceRequestParameter();
request.FactoryBuildingType = factoryID.buildingType;
request.FactoryBuildingNO = factoryID.buildingNO;
request.ArmyType = armyID.armyType;
request.ArmyNO = armyID.armyNO;
request.ProduceOrder = order;
request.OperateTick = LogicTimer.Instance.GetServerTick();
CommunicationUtility.Instance.ProduceArmy(request);
}
public void AssignHeadArmyProduct()
{
ArmyIdentity army = this.m_Data.ProduceArmy[0].Value[0];
ArmyLogicData armyObject = LogicController.Instance.GetArmyObjectData(army);
this.m_Data.ProduceArmy[0].Value.RemoveAt(0);
if (this.m_Data.ProduceArmy[0].Value.Count == 0)
{
this.m_Data.ProduceArmy.RemoveAt(0);
}
this.m_AlreadyProduceArmyCapacity -= armyObject.CapacityCost;
}
public void DropArmy(ArmyIdentity army)
{
foreach (ArmyIdentity armyID in this.m_Data.AvailableArmy)
{
if (army == armyID)
{
ArmyLogicData armyData = LogicController.Instance.GetArmyObjectData(armyID);
this.m_Data.AvailableArmy.Remove(army);
this.m_AlreadyArmyCapacity -= armyData.CapacityCost;
break;
}
}
}
public ArmyIdentity ProduceArmy(ArmyType type, BuildingIdentity factoryID)
{
CostConfigData cost = ConfigInterface.Instance.ArmyConfigHelper.GetProduceCostData(type, this.PlayerData.GetArmyLevel(type));
this.m_PlayerModule.Consume(cost.CostGold, cost.CostFood, cost.CostOil, cost.CostGem);
int armyLevel = this.m_PlayerModule.Data.GetArmyLevel(type);
int armyNO = this.m_PlayerModule.Data.GetArmyStartNO(type);
this.m_PlayerModule.AddArmy(type);
ArmyIdentity result = this.m_ArmyModule.ProduceArmy(type, armyLevel, armyNO);
this.m_BuildingModule.ProduceArmy(result, factoryID);
return(result);
}
public void SendFinishProduceArmyInstantlyRequest(List <ArmyIdentity> armies, List <BuildingIdentity> destinations, int gem)
{
ArmyProduceFinishInstantlyRequestParameter parameter = new ArmyProduceFinishInstantlyRequestParameter();
parameter.Destinations = new List <ArmyProduceSuccessRequestParameter>();
for (int i = 0; i < armies.Count; i++)
{
ArmyIdentity armyID = armies[i];
BuildingIdentity campID = destinations[i];
ArmyProduceSuccessRequestParameter param = new ArmyProduceSuccessRequestParameter();
param.OwnerBuildingType = campID.buildingType;
param.OwnerBuildingNO = campID.buildingNO;
param.ArmyType = armyID.armyType;
param.ArmyNO = armyID.armyNO;
parameter.Destinations.Add(param);
}
parameter.GemCost = gem;
parameter.OperateTick = LogicTimer.Instance.GetServerTick();
CommunicationUtility.Instance.FinishArmyProduceInstantly(parameter);
}
public void AddArmyToCamp(ArmyIdentity army, BuildingIdentity factoryID)
{
if (this.m_Data.AvailableArmy == null)
{
this.m_Data.AvailableArmy = new List <ArmyIdentity>();
}
this.m_Data.AvailableArmy.Add(army);
ArmyLogicObject armyObject = LogicController.Instance.GetArmyObject(army);
this.m_AlreadyArmyCapacity += armyObject.ArmyLogicData.CapacityCost;
armyObject.AddArmyToCamp(this.m_Data.BuildingID);
if (Application.loadedLevelName == ClientStringConstants.BUILDING_SCENE_LEVEL_NAME)
{
BuildingSceneDirector.Instance.SendArmyToCamp(army.armyType, LogicController.Instance.GetArmyLevel(army.armyType),
this.m_BuildingLogicData, LogicController.Instance.GetBuildingObject(factoryID));
AudioController.Play("TrainingFinished");
}
}
public void ProduceArmy(ArmyIdentity id)
{
bool alreadyHaveThisType = false;
int order = 0;
if (this.m_Data.ProduceArmy == null)
{
this.m_Data.ProduceArmy = new List <KeyValuePair <ArmyType, List <ArmyIdentity> > >();
}
else
{
foreach (KeyValuePair <ArmyType, List <ArmyIdentity> > productList in this.m_Data.ProduceArmy)
{
order += productList.Value.Count;
if (productList.Key == id.armyType)
{
alreadyHaveThisType = true;
productList.Value.Add(id);
break;
}
}
}
if (!alreadyHaveThisType)
{
List <ArmyIdentity> newList = new List <ArmyIdentity>()
{
id
};
this.m_Data.ProduceArmy.Add(new KeyValuePair <ArmyType, List <ArmyIdentity> >(id.armyType, newList));
}
ArmyLogicData army = LogicController.Instance.GetArmyObjectData(id);
this.m_AlreadyProduceArmyCapacity += army.CapacityCost;
this.m_CommunicationHelper.SendProduceArmyRequest(this.m_Data.BuildingID, id, order);
}
public ArmyLogicObject GetArmyObject(ArmyIdentity id)
{
return(this.m_Armies[id.armyType][id.armyNO]);
}
public ArmyLogicObject GetArmyObject(ArmyIdentity id)
{
return(this.m_ArmyModule.GetArmyObject(id));
}
public void InitialWithResponseData(FriendResponseParameter parameter, string friendName)
{
UserData userData = new UserData();
userData.Name = friendName;
userData.Honour = parameter.Honour;
userData.Level = parameter.Level;
userData.CurrentStoreGold = parameter.PlayerGold;
userData.CurrentStoreFood = parameter.PlayerFood;
userData.CurrentStoreOil = parameter.PlayerOil;
userData.ConfigData = ConfigInterface.Instance.PlayerConfigHelper.GetPlayerData(parameter.Level);
this.m_FriendData = new PlayerLogicData(userData);
this.m_LogicObjects = new Dictionary <BuildingType, Dictionary <int, BuildingLogicObject> >();
this.m_ArmyObjects = new Dictionary <ArmyType, Dictionary <int, FriendArmyParameter> >();
this.m_Mercenaries = new Dictionary <MercenaryType, int>();
this.m_ItemObjects = new Dictionary <ItemType, Dictionary <int, FriendItemParameter> >();
this.m_AchievementBuildings = new Dictionary <int, AchievementBuildingLogicData>();
this.m_Buffs = new List <BuffLogicData>();
this.m_Props = new List <PropsLogicData>();
this.m_ResourceManager = new ResourceManager();
this.m_ArmyLevels = new Dictionary <ArmyType, int>();
Dictionary <BuildingType, Dictionary <int, BuildingData> > datas =
new Dictionary <BuildingType, Dictionary <int, BuildingData> >();
this.m_RemovableObjects = new Dictionary <long, RemovableObjectLogicData>();
int objectID = 0;
foreach (FriendObjectParameter param in parameter.Objects)
{
RemovableObjectData data = new RemovableObjectData();
data.BuilderBuildingNO = param.BuilderBuildingNO;
data.Position = new TilePosition(param.PositionColumn, param.PositionRow);
if (param.IsRemoving)
{
if (param.BuilderBuildingNO.HasValue)
{
data.RemainingWorkload = 0;
}
else
{
data.RemainingWorkload = 1;
}
}
data.RemovableObjectNo = objectID;
data.RemovableObjectType = param.ObjectType;
data.ConfigData = ConfigInterface.Instance.RemovableConfigHelper.GetRemovableObjectData(param.ObjectType);
this.m_RemovableObjects.Add(objectID, new RemovableObjectLogicData(data));
objectID++;
}
int buildingNo = 0;
foreach (FriendAchievementBuildingParameter param in parameter.AchievementBuildings)
{
AchievementBuildingData data = new AchievementBuildingData();
data.AchievementBuildingType = param.AchievementBuildingType;
data.BuildingNo = buildingNo++;
data.BuildingPosition = new TilePosition(param.PositionColumn, param.PositionRow);
data.Life = param.Life;
data.ConfigData = ConfigInterface.Instance.AchievementBuildingConfigHelper.GetAchievementBuildingData(param.AchievementBuildingType);
this.m_AchievementBuildings.Add(data.BuildingNo, new AchievementBuildingLogicData(data));
}
foreach (FriendBuffParameter buff in parameter.Buffs)
{
BuffData b = new BuffData();
b.RelatedPropsType = buff.PropsType;
b.RemainingCD = 10;
b.BuffConfigData = ConfigInterface.Instance.PropsConfigHelper.GetPropsData(buff.PropsType).FunctionConfigData as PropsBuffConfigData;
BuffLogicData data = new BuffLogicData(b);
this.m_Buffs.Add(data);
}
int tempPropsID = 0;
foreach (FriendPropsParameter props in parameter.Props)
{
PropsData p = new PropsData();
PropsConfigData propsConfigData = ConfigInterface.Instance.PropsConfigHelper.GetPropsData(props.PropsType);
p.PropsConfigData = propsConfigData;
p.PropsNo = tempPropsID++;
p.PropsType = props.PropsType;
p.RemainingCD = 10;
p.RemainingUseTime = propsConfigData.MaxUseTimes;
PropsLogicData data = new PropsLogicData(p);
this.m_Props.Add(data);
}
foreach (FriendBuildingParameter param in parameter.Buildings)
{
BuildingConfigData configData = ConfigInterface.Instance.BuildingConfigHelper.GetBuildingData(param.BuildingTypeID, param.Level);
BuildingData data = new BuildingData();
data.BuilderBuildingNO = param.BuilderBuildingNO;
data.BuildingID = new BuildingIdentity(param.BuildingTypeID, param.BuildingNO);
data.BuildingPosition = new TilePosition(param.PositionColumn, param.PositionRow);
data.Level = param.Level;
if (param.IsUpgrading)
{
if (param.BuilderBuildingNO.HasValue)
{
data.UpgradeRemainingWorkload = 1;
}
else
{
data.UpgradeRemainingWorkload = 0;
}
}
if (param.IsResourceAccelerate)
{
data.RemainResourceAccelerateTime = 1;
}
if (param.IsArmyAccelerate)
{
data.RemainArmyAccelerateTime = 1;
}
if (param.IsItemAccelerate)
{
data.RemainItemAccelerateTime = 1;
}
data.ConfigData = configData;
if (param.CurrentStoreGold.HasValue)
{
data.CurrentStoreGold = param.CurrentStoreGold.Value;
}
else if (configData.CanStoreGold)
{
this.m_ResourceManager.AddStorage(ResourceType.Gold, data.BuildingID, configData.StoreGoldCapacity);
}
if (param.CurrentStoreFood.HasValue)
{
data.CurrentStoreFood = param.CurrentStoreFood.Value;
}
else if (configData.CanStoreFood)
{
this.m_ResourceManager.AddStorage(ResourceType.Food, data.BuildingID, configData.StoreFoodCapacity);
}
if (param.CurrentStoreOil.HasValue)
{
data.CurrentStoreOil = param.CurrentStoreOil.Value;
}
else if (configData.CanStoreOil)
{
this.m_ResourceManager.AddStorage(ResourceType.Oil, data.BuildingID, configData.StoreOilCapacity);
}
if (!this.m_LogicObjects.ContainsKey(param.BuildingTypeID))
{
this.m_LogicObjects.Add(param.BuildingTypeID, new Dictionary <int, BuildingLogicObject>());
}
if (!datas.ContainsKey(param.BuildingTypeID))
{
datas.Add(param.BuildingTypeID, new Dictionary <int, BuildingData>());
}
this.m_LogicObjects[param.BuildingTypeID].Add(param.BuildingNO,
new BuildingLogicObject(data, (int)BuildingFunction.ProduceResource, false));
datas[param.BuildingTypeID].Add(param.BuildingNO, data);
data.AvailableMercenary = new List <MercenaryIdentity>();
if (param.Mercenaries != null)
{
foreach (KeyValuePair <MercenaryType, int> mercenary in param.Mercenaries)
{
MercenaryConfigData mercenaryConfigData = ConfigInterface.Instance.MercenaryConfigHelper.GetMercenaryData(mercenary.Key);
this.m_AlreadyArmyCapacity += mercenaryConfigData.CapcityCost * mercenary.Value;
for (int i = 0; i < mercenary.Value; i++)
{
data.AvailableMercenary.Add(new MercenaryIdentity(mercenary.Key, i));
if (!this.m_Mercenaries.ContainsKey(mercenary.Key))
{
this.m_Mercenaries.Add(mercenary.Key, 0);
}
this.m_Mercenaries[mercenary.Key]++;
}
}
}
data.AvailableArmy = new List <ArmyIdentity>();
if (param.Armies != null)
{
foreach (FriendArmyParameter army in param.Armies)
{
if (!this.m_ArmyLevels.ContainsKey(army.ArmyType))
{
this.m_ArmyLevels.Add(army.ArmyType, army.ArmyLevel);
}
ArmyType type = army.ArmyType;
ArmyConfigData armyConfigData = ConfigInterface.Instance.ArmyConfigHelper.GetArmyData(army.ArmyType, army.ArmyLevel);
this.m_AlreadyArmyCapacity += armyConfigData.CapcityCost;
if (!this.m_ArmyObjects.ContainsKey(type))
{
this.m_ArmyObjects.Add(type, new Dictionary <int, FriendArmyParameter>());
}
ArmyIdentity armyID = new ArmyIdentity(type, this.m_ArmyObjects[type].Count);
data.AvailableArmy.Add(armyID);
this.m_ArmyObjects[type].Add(armyID.armyNO, army);
}
}
data.AvailableItem = new List <ItemIdentity>();
if (param.Items != null)
{
foreach (FriendItemParameter item in param.Items)
{
ItemType type = item.ItemType;
if (!this.m_ItemObjects.ContainsKey(type))
{
this.m_ItemObjects.Add(type, new Dictionary <int, FriendItemParameter>());
}
ItemIdentity itemID = new ItemIdentity(type, this.m_ItemObjects[type].Count);
data.AvailableItem.Add(itemID);
this.m_ItemObjects[type].Add(itemID.itemNO, item);
}
}
this.m_TotalCampCapacity += configData.ArmyCapacity;
}
Dictionary <ResourceType, Dictionary <BuildingIdentity, int> > result = this.m_ResourceManager.CalculateStorage
(userData.CurrentStoreGold, userData.CurrentStoreFood, userData.CurrentStoreOil);
foreach (KeyValuePair <ResourceType, Dictionary <BuildingIdentity, int> > resource in result)
{
foreach (KeyValuePair <BuildingIdentity, int> r in resource.Value)
{
switch (resource.Key)
{
case ResourceType.Gold:
{
datas[r.Key.buildingType][r.Key.buildingNO].CurrentStoreGold = r.Value;
}
break;
case ResourceType.Food:
{
datas[r.Key.buildingType][r.Key.buildingNO].CurrentStoreFood = r.Value;
}
break;
case ResourceType.Oil:
{
datas[r.Key.buildingType][r.Key.buildingNO].CurrentStoreOil = r.Value;
}
break;
}
}
}
}
public ArmyLogicData GetArmyObjectData(ArmyIdentity id)
{
return(this.m_Armies[id.armyType][id.armyNO].ArmyLogicData);
}
public FriendArmyParameter GetArmy(ArmyIdentity id)
{
return(this.m_ArmyObjects[id.armyType][id.armyNO]);
}
protected virtual void ShowProgress()
{
if (!this.BuildingBehavior.Created)
{
return;
}
if (SceneManager.Instance.SceneMode == SceneMode.SceneVisit)
{
if (this.BuildingLogicData.CurrentBuilidngState != BuildingEditorState.Normal)
{
this.ActiveFacility(true);
}
else
{
this.ActiveFacility(false);
}
return;
}
if (this.BuildingLogicData.CurrentBuilidngState == BuildingEditorState.Update)
{
this.ActiveFacility(true);
foreach (KeyValuePair <int, ProgressBarBehavior> pb in m_ProgressBarBehaviorDictionary)
{
if (pb.Key == 4)
{
pb.Value.gameObject.SetActive(true);
pb.Value.SetProgressPosition(0);
pb.Value.SetProgressBar((this.BuildingLogicData.UpgradeWorkload - this.BuildingLogicData.UpgradeRemainingWorkload) / this.BuildingLogicData.UpgradeWorkload, this.BuildingLogicData.UpgradeRemainingWorkload / this.BuildingLogicData.AttachedBuilderEfficiency, false, string.Empty);
}
else
{
pb.Value.gameObject.SetActive(false);
}
}
}
else
{
this.ActiveFacility(false);
m_ProgressBarBehaviorDictionary[4].gameObject.SetActive(false);
if (this.BuildingLogicData.CurrentBuilidngState == BuildingEditorState.Normal)
{
int order = 0;
foreach (KeyValuePair <int, ProgressBarBehavior> pb in m_ProgressBarBehaviorDictionary)
{
switch (pb.Key)
{
case 0: //0 = UpgradeSpell
if (this.BuildingLogicData.ItemUpgrade.HasValue)
{
pb.Value.gameObject.SetActive(true);
pb.Value.SetProgressPosition(order);
float remainingTime = this.BuildingLogicData.ItemUpgradeRemainingTime;
float progress = (this.BuildingLogicData.ItemUpgradeTotalWorkload - this.BuildingLogicData.ItemUpgradeRemainingWorkload) / (float)this.BuildingLogicData.ItemUpgradeTotalWorkload;
pb.Value.SetProgressBar(progress, remainingTime, true, ClientSystemConstants.Spell_ICON_COMMON_DICTIONARY[this.BuildingLogicData.ItemUpgrade.Value]);
order++;
}
else
{
pb.Value.gameObject.SetActive(false);
}
break;
case 1: //ProduceSpell
if (this.BuildingLogicData.ItemProducts != null)
{
if (this.BuildingLogicData.ItemProducts.Count > 0)
{
pb.Value.gameObject.SetActive(true);
pb.Value.SetProgressPosition(order);
ItemIdentity itemIdentity = this.BuildingLogicData.ItemProducts[0].Value[0];
ItemLogicObject itemLogicObject = LogicController.Instance.GetItemObject(itemIdentity);
float remainingTime = (float)itemLogicObject.ProduceRemainingWorkload / ConfigInterface.Instance.SystemConfig.ProduceItemEfficiency;
float progress = (itemLogicObject.ProduceTotalWorkload - itemLogicObject.ProduceRemainingWorkload) / (float)itemLogicObject.ProduceTotalWorkload;
pb.Value.SetProgressBar(progress, remainingTime, true, ClientSystemConstants.Spell_ICON_COMMON_DICTIONARY[itemIdentity.itemType]);
order++;
}
else
{
pb.Value.gameObject.SetActive(false);
}
}
break;
case 2: //2 = UpgradeArmy
if (this.BuildingLogicData.ArmyUpgrade.HasValue)
{
if (this.BuildingLogicData.IsArmyProduceBlock && !this.BuildingBehavior.IsClick)
{
order++;
}
pb.Value.gameObject.SetActive(true);
pb.Value.SetProgressPosition(order);
float remainingTime = this.BuildingLogicData.ArmyUpgradeRemainingTime; // (float)this.BuildingLogicData.ArmyUpgradeRemainWorkload / this.BuildingLogicData.ArmyUpgradeEfficiency;
float progress = (this.BuildingLogicData.ArmyUpgradeTotalWorkload - this.BuildingLogicData.ArmyUpgradeRemainWorkload) / (float)this.BuildingLogicData.ArmyUpgradeTotalWorkload;
pb.Value.SetProgressBar(progress, remainingTime, true, ClientSystemConstants.ARMY_UPGRADE_ICON_COMMON_DICTIONARY[this.BuildingLogicData.ArmyUpgrade.Value]);
order++;
}
else
{
pb.Value.gameObject.SetActive(false);
}
break;
case 3: //ProduceArmy
if (this.BuildingLogicData.ArmyProducts != null && !this.BuildingLogicData.IsArmyProduceBlock)
{
if (this.BuildingLogicData.ArmyProducts.Count > 0)
{
pb.Value.gameObject.SetActive(true);
pb.Value.SetProgressPosition(order);
ArmyIdentity armyIdentity = this.BuildingLogicData.ArmyProducts[0].Value[0];
ArmyLogicData armyLogicData = LogicController.Instance.GetArmyObjectData(armyIdentity);
float remainingTime = (float)armyLogicData.ProduceRemainingWorkload / ConfigInterface.Instance.SystemConfig.ProduceArmyEfficiency;
float progress = (armyLogicData.ProduceTotalWorkload - armyLogicData.ProduceRemainingWorkload) / (float)armyLogicData.ProduceTotalWorkload;
pb.Value.SetProgressBar(progress, remainingTime, true, ClientSystemConstants.ARMY_ICON_COMMON_DICTIONARY[armyIdentity.armyType]);
order++;
}
else
{
pb.Value.gameObject.SetActive(false);
}
}
else
{
pb.Value.gameObject.SetActive(false);
}
break;
}
}
}
}
}
public void Construct(Vector2 position)
{
TilePosition mousePosition = PositionConvertor.GetBuildingTileIndexFromScreenPosition(position);
mousePosition.Row = Mathf.Clamp(mousePosition.Row, 0, ClientSystemConstants.BUILDING_TILE_MAP_SIZE.height - 1);
mousePosition.Column = Mathf.Clamp(mousePosition.Column, 0, ClientSystemConstants.BUILDING_TILE_MAP_SIZE.width - 1);
UICheckbox check = null;
UICheckbox[] checks = this.m_SelectionGroup.GetComponentsInChildren <UICheckbox>();
foreach (UICheckbox c in checks)
{
if (c.isChecked)
{
check = c;
break;
}
}
PropsButtonInformation propsInfo = check.transform.parent.GetComponent <PropsButtonInformation>();
bool isUseProps = propsInfo != null &&
!(ConfigInterface.Instance.PropsConfigHelper.GetPropsData(propsInfo.Type).FunctionConfigData is PropsArmyConfigData) &&
!(ConfigInterface.Instance.PropsConfigHelper.GetPropsData(propsInfo.Type).FunctionConfigData is PropsMercenaryConfigData);
bool isValidPosition = true;
if (mousePosition.IsEdgeBuildingTilePosition())
{
isValidPosition = true;
}
else if (!mousePosition.IsValidBuildingTilePosition())
{
this.m_GridFactory.DisplayGrid();
isValidPosition = false;
}
else if (BattleMapData.Instance.CharacterForbiddenArray[mousePosition.Row, mousePosition.Column] &&
!isUseProps)
{
this.m_GridFactory.DisplayGrid();
isValidPosition = false;
}
if (isValidPosition && (BattleDirector.Instance == null || !BattleDirector.Instance.IsBattleFinished))
{
ArmyButtonInformation armyInfo = check.transform.parent.GetComponent <ArmyButtonInformation>();
MercenaryButtonInformation mercenaryInfo = check.transform.parent.GetComponent <MercenaryButtonInformation>();
if (armyInfo != null)
{
if (armyInfo.Dropable)
{
Vector3 worldPosition = CameraManager.Instance.MainCamera.ScreenToWorldPoint(new Vector3(position.x, position.y, 0));
worldPosition = PositionConvertor.ClampWorldPositionOfBuildingTile(worldPosition);
ArmyIdentity id = armyInfo.DropArmy();
this.m_ConstructArmyList.Add(new ConstructArmyCommand()
{
Position = worldPosition,
Identity = id, Level = armyInfo.ArmyLevel
});
}
else
{
UIErrorMessage.Instance.ErrorMessage(ClientStringConstants.NO_ARMY_TO_DROP_WARNING_MESSAGE);
}
}
else if (mercenaryInfo != null)
{
if (mercenaryInfo.Dropable)
{
Vector3 worldPosition = CameraManager.Instance.MainCamera.ScreenToWorldPoint(new Vector3(position.x, position.y, 0));
worldPosition = PositionConvertor.ClampWorldPositionOfBuildingTile(worldPosition);
MercenaryIdentity id = mercenaryInfo.DropArmy();
this.m_ConstructMercenaryList.Add(new UserCommand <MercenaryIdentity>()
{
Position = worldPosition,
Identity = id
});
}
else
{
UIErrorMessage.Instance.ErrorMessage(ClientStringConstants.NO_ARMY_TO_DROP_WARNING_MESSAGE);
}
}
else if (propsInfo != null)
{
if (propsInfo.Dropable)
{
Vector3 worldPosition = CameraManager.Instance.MainCamera.ScreenToWorldPoint(new Vector3(position.x, position.y, 0));
worldPosition = PositionConvertor.ClampWorldPositionOfBuildingTile(worldPosition);
int no = propsInfo.DropArmy();
this.m_UsePropsList.Add(new UsePropsCommand()
{
Position = worldPosition,
Identity = no, PropsType = propsInfo.Type
});
}
else
{
UIErrorMessage.Instance.ErrorMessage(ClientStringConstants.NO_PROPS_TO_DROP_WARNING_MESSAGE);
}
}
}
else
{
if (isUseProps)
{
UIErrorMessage.Instance.ErrorMessage(ClientStringConstants.CAN_NOT_USE_PROPS_WARNING_MESSAGE);
}
else
{
UIErrorMessage.Instance.ErrorMessage(ClientStringConstants.CAN_NOT_DROP_ARMY_WARNING_MESSAGE);
}
}
}
public void DropArmy(ArmyIdentity id)
{
this.m_BuildingModule.DropArmy(id);
this.m_ArmyModule.DropArmy(id);
}
public ArmyLogicData GetArmyObjectData(ArmyIdentity id)
{
return(this.m_ArmyModule.GetArmyObjectData(id));
}
