/// <summary>判断是否大于最大值</summary>
private bool IsMax(tg_war_city model, int type, int count)
{
var result = false;
var cs = Variable.BASE_WARCITYSIZE.FirstOrDefault(m => m.id == model.size);
if (cs == null)
{
return(false);
}
var temp = 0;
switch (type)
{
case (int)WarResourseType.兵粮:
{
temp = model.res_foods + count;
result = temp <= cs.foods; break;
}
case (int)WarResourseType.马匹:
case (int)WarResourseType.铁炮:
case (int)WarResourseType.薙刀:
case (int)WarResourseType.苦无:
{
temp = model.res_horse + model.res_gun + model.res_razor + model.res_kuwu + count;
result = temp <= cs.goods; break;
}
}
return(result);
}
/// <summary>验证最大值</summary>
private tg_war_city CheckMax(int type, int total, int count, tg_war_city city)
{
int surplus;
switch (type)
{
case (int)WarResourseType.马匹:
surplus = total - city.res_kuwu - city.res_razor - city.res_gun;
city.res_horse += count;
city.res_horse = city.res_horse >= surplus ? surplus : city.res_horse;
break;
case (int)WarResourseType.铁炮:
surplus = total - city.res_kuwu - city.res_razor - city.res_horse;
city.res_gun += count;
city.res_gun = city.res_gun >= surplus ? surplus : city.res_gun;
break;
case (int)WarResourseType.薙刀:
surplus = total - city.res_kuwu - city.res_horse - city.res_gun;
city.res_razor += count;
city.res_razor = city.res_razor >= surplus ? surplus : city.res_razor;
break;
case (int)WarResourseType.苦无:
surplus = total - city.res_horse - city.res_razor - city.res_gun;
city.res_kuwu += count;
city.res_kuwu = city.res_kuwu >= surplus ? surplus : city.res_kuwu;
break;
}
return(city);
}
/// <summary>
/// 插入新的防守方案
/// </summary>
/// <param name="city">据点实体</param>
/// <param name="location">新防守方案位置（2、3）</param>
/// <returns></returns>
public tg_war_city_plan GetDefensePlanInsert(tg_war_city city, int location)
{
//插入阵表
var basefront = Variable.BASE_WAR_FRONT.FirstOrDefault(q => q.free == 1);
tg_war_formation.Insert(new tg_war_formation()
{
user_id = city.user_id, base_id = basefront.id
});
//插入防守方案表
var newplan = new tg_war_city_plan()
{
user_id = city.user_id, location = location, formation = basefront.id
};
newplan.Insert();
////关联防守武将表
//tg_war_city_defense.Insert(new tg_war_city_defense() { user_id = city.user_id, city_id = city.base_id, plan_id = newplan.id });
////关联防守地形表
//tg_war_plan_area.Insert((new tg_war_plan_area() { plan_id = newplan.id }));
//更新据点数据
switch (location)
{
//locatio: 0-2
case 1: { city.plan_2 = newplan.id; } break;
case 2: { city.plan_3 = newplan.id; } break;
}
newplan.Update();
return(newplan);
}
/// <summary>PlayerCity 实体转换</summary>
public static PlayerCity ToPlayerCity(tg_war_city model)
{
var city = new PlayerCity()
{
id = model.id,
baseid = model.base_id,
name = model.name,
res_foods = model.res_foods,
res_funds = model.res_funds,
res_soldier = model.res_soldier,
res_gun = model.res_gun,
res_horse = model.res_horse,
res_razor = model.res_razor,
res_kuwu = model.res_kuwu,
res_morale = model.res_morale,
peace = model.peace,
strong = model.strong,
boom = model.boom,
};
switch (model.size)
{
case 1: city.size = "村"; break;
case 2: city.size = "小城"; break;
case 3: city.size = "大城"; break;
case 4: city.size = "中城"; break;
case 5: city.size = "巨城"; break;
}
return(city);
}
/// <summary>
/// 验证消耗的军资金
/// </summary>
/// <returns></returns>
private bool CheckFunds(tg_war_city city)
{
var costfunds = Common.GetInstance().GetRule("32042");
if (city.res_funds < costfunds)
{
return(false);
}
city.res_funds -= costfunds;
city.Update();
Variable.WarCityAll.TryUpdate(city.base_id, city, city);
new Share.War().SendCity(city.base_id, city.user_id);
return(true);
}
/// <summary> 己方据点为发出点的情况 </summary>
/// <param name="city">除敌方外的据点信息</param>
/// <param name="userid">用户Id</param>
/// <param name="psList">盟友集合</param>
private WarEntity GetBuildWarEntity(tg_war_city city, Int64 userid, List <tg_war_partner> psList)
{
var cityid = city.base_id;
var olist = new List <int>(); //己方可操作的据点
var rlist = new List <int>(); //敌方可操作的据点
var map = new List <Core.Common.Util.Map>(); //构建的可操作的己方据点的图型集合
var _map = new List <Core.Common.Util.Map>(); //构建的可操作的敌方据点的图型集合
var time = (DateTime.Now.Ticks - 621355968000000000) / 10000;
if (city.guard_time < time)
{
_map = (new Share.War()).GetBattleMaps(cityid, psList, userid, new List <int>(), ref rlist);
}
map = (new Share.War()).GetMaps(cityid, psList, userid, new List <int>(), ref olist);
return(BuildWarEntity(0, 0, 0, 0, olist, rlist, map, _map));
}
/// <summary>资源设置</summary>
private tg_war_city SetResouce(tg_war_city model, int type, int count)
{
switch (type)
{
case (int)WarResourseType.兵粮: { model.res_foods += count; break; }
case (int)WarResourseType.马匹: { model.res_horse += count; break; }
case (int)WarResourseType.铁炮: { model.res_gun += count; break; }
case (int)WarResourseType.薙刀: { model.res_razor += count; break; }
case (int)WarResourseType.苦无: { model.res_kuwu += count; break; }
}
return(model);
}
/// <summary>
/// 获取防守方防守方案id集合
/// </summary>
/// <param name="city"></param>
/// <returns></returns>
private List <Int64> GetCityPlanIds(tg_war_city city)
{
var list = new List <Int64>();
if (city.plan_1 > 0)
{
list.Add(city.plan_1);
}
if (city.plan_2 > 0)
{
list.Add(city.plan_2);
}
if (city.plan_3 > 0)
{
list.Add(city.plan_3);
}
return(list);
}
///// <summary> 更新玩家铜币资源 </summary>
///// <param name="userid">用户id</param>
///// <param name="cost">花费铜币数量</param>
///// <param name="cmd">指令号</param>
///// <param name="ids">需要推送的其他类型 GoodsType</param>
///// <param name="flag">花费标识</param>
//public void UpdateCoin(Int64 userid, Int64 cost, int cmd, List<int> ids, string flag)
//{
// if (!Variable.OnlinePlayer.ContainsKey(userid)) return;
// var session = Variable.OnlinePlayer[userid] as TGGSession;
// if (session == null) return;
// var user = session.Player.User.CloneEntity();
// var coin = user.coin;
// user.coin = user.coin - cost;
// var logdata = string.Format("{0}_{1}_{2}_{3}", "Coin", coin, cost, user.coin);
// (new Log()).WriteLog(user.id, (int)LogType.Use, (int)ModuleNumber.USER, (int)UserCommand.OFFICIAL_UPGRADE, "用户", flag, "金钱", (int)GoodsType.TYPE_COIN, Convert.ToInt32(cost), user.coin, logdata);
// ids.Add((int)GoodsType.TYPE_COIN);
// user.Save();
// session.Player.User = user;
// (new User()).REWARDS_API(ids, session.Player.User);
//}
/// <summary>更新据点资源 </summary>
/// <param name="city"></param>
/// <param name="state">开发类型</param>
/// <param name="resource">资源</param>
/// <returns></returns>
public tg_war_city GetUpdateCity(tg_war_city city, int state, int resource)
{
switch (state)
{
case (int)WarRoleStateType.ASSART: city.res_foods += resource; break;
case (int)WarRoleStateType.BUILDING: city.boom += resource; break;
case (int)WarRoleStateType.BUILD_ADD: city.strong += resource; break;
case (int)WarRoleStateType.MINING: city.res_funds += resource; break;
case (int)WarRoleStateType.PEACE: city.peace += resource; break;
case (int)WarRoleStateType.LEVY:
{
city.res_soldier += resource;
var res = city.res_morale - ReduceMorale(resource); //徵兵扣除士气
city.res_morale = res <= 0 ? 0 : res;
}
break;
case (int)WarRoleStateType.TRAIN:
{
city.res_morale = city.res_morale + resource + GetCharacterMorale(city.user_id);
var basecity = Variable.BASE_WARCITYSIZE.FirstOrDefault(m => m.id == city.size);
if (basecity == null) //基表判断
{
return(null);
}
if (city.res_morale > basecity.morale)
{
city.res_morale = basecity.morale;
}
}
break;
}
return(city);
}
/// <summary>
/// 占有度足够城市资源结算
/// </summary>
/// <param name="city">城市实体</param>
/// <param name="userid">新占领的用户id</param>
private void CityWarResourse(tg_war_city city, Int64 userid)
{
city.boom *= 0.2;
city.strong *= 0.2;
city.peace *= 0.2;
city.res_foods = Convert.ToInt32(Math.Floor(city.res_foods * 0.5));
city.res_funds = Convert.ToInt32(Math.Floor(city.res_funds * 0.5));
city.res_horse = Convert.ToInt32(Math.Floor(city.res_horse * 0.5));
city.res_kuwu = Convert.ToInt32(Math.Floor(city.res_kuwu * 0.5));
city.res_razor = Convert.ToInt32(Math.Floor(city.res_razor * 0.5));
city.res_soldier = Convert.ToInt32(Math.Floor(city.res_soldier * 0.5));
city.res_morale = Convert.ToInt32(Math.Floor(city.res_morale * 0.5));
//计算城市新的规模
var newsize = Variable.BASE_WARCITYSIZE.FirstOrDefault(q => q.boom >= city.boom && q.strong >= city.strong && q.peace >= city.peace);
city.size = newsize != null ? newsize.id : Variable.BASE_WARCITYSIZE.FirstOrDefault().id;
city.user_id = userid;
city.plan_1 = 0;
city.plan_2 = 0;
city.plan_3 = 0;
city.type = (int)WarCityType.VICECITY;
city.guard_time = (DateTime.Now.AddDays(1).Ticks - 621355968000000000) / 10000;
//插入防守方案表
var newplan = new tg_war_city_plan()
{
user_id = userid, location = 0
};
newplan.Insert();
city.plan_1 = newplan.id;
city.Update();
Variable.WarCityAll.AddOrUpdate(city.base_id, city, (k, v) => city);
var view = view_war_city.GetEntityByBaseId(city.base_id);
new Share.War().SendCityBuild(view);
}
/// <summary>更新当前据点资源信息</summary>
private tg_war_city MaxNumber(int type, int count, tg_war_city city)
{
var info = Variable.BASE_WARCITYSIZE.FirstOrDefault(m => m.id == city.size);
if (info == null)
{
return(city);
}
switch (type)
{
case (int)WarResourseType.兵粮:
city.res_foods += count;
if (city.res_foods > info.foods)
{
city.res_foods = info.foods;
}
break;
case (int)WarResourseType.军资金:
city.res_funds += count;
if (city.res_funds > info.funds)
{
city.res_funds = info.funds;
}
break;
case (int)WarResourseType.足轻:
city.res_soldier += count;
if (city.res_soldier > info.soldier)
{
city.res_soldier = info.soldier;
}
break;
}
city = CheckMax(type, info.goods, count, city);
return(city);
}
private bool SavaData(List <Common.Resourse> resourses, tg_war_role role, Int32 baseid, Int32 count, tg_war_city city)
{
role.army_id = baseid;
role.army_soldier = count;
//更新城市资源和武将资源
foreach (var resourse in resourses)
{
switch (resourse.type)
{
case (int)WarResourseType.兵粮: { city.res_foods -= resourse.value * count; } break;
case (int)WarResourseType.军资金: { city.res_funds -= resourse.value * count; } break;
case (int)WarResourseType.苦无: { city.res_use_kuwu += resourse.value * count; role.army_kuwu = resourse.value * count; } break;
case (int)WarResourseType.薙刀: { city.res_use_razor += resourse.value * count; role.army_razor = resourse.value * count; } break;
case (int)WarResourseType.足轻: { city.res_use_soldier += resourse.value * count; role.army_soldier = resourse.value * count; } break;
case (int)WarResourseType.铁炮: { city.res_use_gun += resourse.value * count; role.army_gun = resourse.value * count; } break;
case (int)WarResourseType.马匹: { city.res_use_horse += resourse.value * count; role.army_horse = resourse.value * count; } break;
}
}
//保存数据
role.Update();
city.Update();
Variable.WarCityAll.TryUpdate(city.base_id, city, city);
//推送数据
var list = new[] { "armyBaseId", "armyCount" };
new Share.War().SendWarRole(role, list);
new Share.War().SendCity(city.base_id, role.user_id);
//tg_war_city.Update(string.Format("res_use_foods={0},res_use_funds={1},res_use_kuwu={2},res_use_razor={3}," +
// "res_use_soldier={4},res_use_gun={5},res_use_horse={6}"city.res_use_foods, city.res_use_funds))
return(true);
}
/// <summary>验证数据信息</summary>
private void CheckData(tg_war_city city, tg_war_role role)
{
var basesize = GetBase();
if (basesize == null)
{
return;
}
switch (role.state)
{
case (int)WarRoleStateType.ASSART: city.res_foods += role.resource; break;
case (int)WarRoleStateType.BUILDING:
{
city.boom += role.resource;
if (city.boom > basesize.boom)
{
city.boom = basesize.boom;
}
break;
}
case (int)WarRoleStateType.BUILD_ADD:
{
city.strong += role.resource;
if (city.strong > basesize.strong)
{
city.strong = basesize.strong;
}
break;
}
case (int)WarRoleStateType.MINING: city.res_funds += role.resource; break;
case (int)WarRoleStateType.PEACE:
{
city.peace += role.resource;
if (city.peace > basesize.peace)
{
city.peace = basesize.peace;
}
break;
}
case (int)WarRoleStateType.LEVY:
{
city.res_soldier += role.resource;
var res = city.res_morale - ReduceMorale(role.resource); //徵兵扣除士气
city.res_morale = res <= 0 ? 0 : res;
}
break;
case (int)WarRoleStateType.TRAIN:
{
city.res_morale = city.res_morale + role.resource + GetCharacterMorale(city.user_id);
var basecity = Variable.BASE_WARCITYSIZE.FirstOrDefault(m => m.id == city.size);
if (basecity == null) //基表判断
{
return;
}
if (city.res_morale > basecity.morale)
{
city.res_morale = basecity.morale;
}
}
break;
}
new Share.War().ReduceAdd(role, 0);
city.Update();
if (role.count == 0)
{
new Share.War().ReduceRes(role);
role.state = (int)WarRoleStateType.IDLE;
role.resource = 0;
role.total_count = 0;
role.state_end_time = 0;
RemoveTask(role.user_id, role.id); //移除CD时间
(new Share.War()).SendWarRole(role, "state");
}
else
{
//更新武将下一个半小时到达时间
role.count -= 1;
Int64 time = 30 * 60 * 1000;
# if DEBUG
time = 1 * 60 * 1000;
#endif
role.state_end_time = CurrentTime() + time;
RemoveTask(role.user_id, role.id); //移除CD时间
SpinWait.SpinUntil(() => false, 500);
TaskBegin(role.user_id, role.id, time); //重新开启线程
}
/// <summary>
/// 据点数据更改
/// </summary>
/// <param name="userid">防守据点用户id</param>
/// <param name="city">tg_war_city</param>
/// <param name="attackuserid">攻击者id</param>
private void GetCityChange(Int64 userid, tg_war_city city, Int64 attackuserid)
{
var list = new List <tg_war_role>();
var roles = tg_war_role.GetListByCityIdAndType(city.base_id, userid, (int)WarRoleType.PLAYER);
var npcroles = tg_war_role.GetListByCityIdAndType(city.base_id, userid, (int)WarRoleType.NPC);
tg_war_role.GetListDeleteByIds(npcroles); //备大将删除
//进攻玩家插入新的备大将
var newroles = tg_war_role.GetNpcRole(city.base_id, attackuserid);
newroles.Insert();
new Share.War().BreakTask(city.base_id); //关闭天守阁所有线程
new Share.War().CarryClose(city.base_id); //运输线程结束
var citycount = Variable.WarCityAll.Values.Count(q => q.user_id == userid);
if (citycount <= 0) //没有其他城市
{
//武将数据清零，状态改为空闲
foreach (var role in roles)
{
list.Add(new tg_war_role()
{
user_id = role.user_id,
id = role.id,
rid = role.rid,
state = (int)WarRoleStateType.IDLE,
});
new Share.War().RoleStopTask(role); //放火破坏等结束
}
tg_war_role.GetListUpdate(roles);
new Share.War().PushCityAssault(userid, attackuserid); //推送玩家最后一个城市被攻占
}
else //有占领其他城市
{
var maincity = Variable.WarCityAll.Values.FirstOrDefault(q => q.user_id == userid && q.type == (int)WarCityType.MAINCITY);
if (maincity == null) //没有本城
{
//最大的城市作为本城
var maxsizecity = Variable.WarCityAll.Values.OrderByDescending(q => q.size).FirstOrDefault(q => q.user_id == userid);
if (maxsizecity == null)
{
return;
}
maxsizecity.type = (int)WarCityType.MAINCITY;
maxsizecity.Update();
Variable.WarCityAll.TryUpdate(maxsizecity.base_id, maxsizecity, maxsizecity);
maincity = maxsizecity;
}
//武将回归本城
foreach (var role in roles)
{
var state = role.state;
if (state != (int)WarRoleStateType.DESTROY && state != (int)WarRoleStateType.FIRE &&
state != (int)WarRoleStateType.DIPLOMATIC_RELATIONS)
{
state = (int)WarRoleStateType.IDLE;
}
list.Add(new tg_war_role()
{
user_id = role.user_id,
id = role.id,
rid = role.rid,
state = state,
station = maincity.base_id,
});
}
tg_war_role.GetListUpdate(roles);
}
}
/// <summary> 武将集合配置的兵扣除对应城市的资源 </summary>
/// <param name="list">武将集合</param>
/// <param name="city">据点信息</param>
private tg_war_city ReduceWarCityRes(IEnumerable <tg_war_role> list, tg_war_city city)
{
return(list.Aggregate(city, (current, item) => ReduceWarCityRes(item, current)));
}
/// <summary>
/// 战斗结束
/// </summary>
/// <param name="player"></param>
/// <param name="cityinfo"></param>
/// <param name="defenseuserid"></param>
/// <param name="fightvo"></param>
/// <param name="bq"></param>
/// <returns></returns>
private bool GetFightEnd(Player player, tg_war_city cityinfo, Int64 defenseuserid, WarFightVo fightvo, tg_war_battle_queue bq)
{
var defenseuser = tg_user.FindByid(defenseuserid);
var own = Variable.BASE_OFFICE.FirstOrDefault(q => q.id == player.User.office); //占有度查询
if (own == null)
{
return(false);
}
var left = own.total_own - player.UserExtend.war_total_own;
var basesize = Variable.BASE_WARCITYSIZE.FirstOrDefault(q => q.id == cityinfo.size);
if (basesize == null)
{
return(false);
}
var defenseextend = tg_user_extend.GetByUserId(defenseuserid);
if (fightvo.result.isWin == 1) //出征成功,攻防胜利且占有度足够
{
//游戏战报
WarReportInsert(player.User.id, 100042, cityinfo.base_id, defenseuserid, player.User.player_name);
if (left >= basesize.own) //占有度足够
{
var rivalUserId = cityinfo.user_id;
var planlist = GetCityPlanIds(cityinfo);
tg_war_city_plan.GetListDelete(planlist); //删除所有的防守方案
player.UserExtend.war_total_own += basesize.own; //进攻玩家占有度使用增加
if (defenseextend.war_total_own >= basesize.own) //防守玩家占有度使用减少
{
defenseextend.war_total_own -= basesize.own;
}
//城市资源结算，城市改为进攻方
CityWarResourse(cityinfo, player.User.id);
player.UserExtend.Update();
player.User.merit += (int)Math.Floor(fightvo.result.rivalDieCount * 0.5);
GetCityChange(defenseuserid, cityinfo, player.User.id);
#region 除内政策略
var flag = Variable.WarCityAll.Values.Count(m => m.user_id == rivalUserId) > 0;
if (!flag)
{
var temp = tg_war_home_tactics.GetEntityByUserid(rivalUserId);
if (temp != null)
{
(new Share.War()).RemoveCD((new Share.War()).GetKey(temp.end_time, rivalUserId));
temp.Delete();
}
}
#endregion
}
else
{
CityWarResourse(cityinfo);
player.User.merit += (int)Math.Floor(fightvo.result.rivalDieCount * 0.5) + basesize.addMerit;
}
defenseuser.merit += (int)Math.Floor(fightvo.result.rivalDieCount * 0.1);
fightvo.result.reward.Add(new RewardVo()
{
goodsType = (int)GoodsType.TYPE_MERIT,
value = player.User.merit,
});
}
else
{
//游戏战报
WarReportInsert(player.User.id, 100043, cityinfo.base_id, defenseuserid, player.User.player_name);
player.User.merit += (int)Math.Floor(fightvo.result.rivalDieCount * 0.1);
defenseuser.merit += (int)Math.Floor(fightvo.result.rivalDieCount * 0.5);
fightvo.result.reward.Add(new RewardVo()
{
goodsType = (int)GoodsType.TYPE_MERIT,
value = player.User.merit,
});
// new Share.War().QueueResultCity(bq);
}
//进攻玩家发送协议
if (Variable.OnlinePlayer.ContainsKey(player.User.id))
{
player.User.Update();
player.UserExtend.Update();
var session = Variable.OnlinePlayer[player.User.id] as TGGSession;
session.Player = player;
(new Share.User()).REWARDS_API(player.User.id, fightvo.result.reward);
}
//防守玩家发送协议
if (Variable.OnlinePlayer.ContainsKey(defenseuserid))
{
defenseuser.Update();
var session = Variable.OnlinePlayer[defenseuserid] as TGGSession;
session.Player.User = defenseuser;
session.Player.UserExtend = defenseextend;
(new Share.User()).REWARDS_API(defenseuserid, fightvo.result.reward);
}
return(true);
}
/// <summary> 武将配置的兵扣除对应城市的资源 </summary>
/// <param name="temp">武将信息</param>
/// <param name="city">据点信息</param>
private tg_war_city ReduceWarCityRes(tg_war_role temp, tg_war_city city)
{
city.res_foods -= temp.army_foods;
city.res_use_foods -= temp.army_foods;
if (city.res_foods < 0)
{
city.res_foods = 0;
}
if (city.res_use_foods < 0)
{
city.res_use_foods = 0;
}
city.res_funds -= temp.army_funds;
city.res_use_funds -= temp.army_funds;
if (city.res_funds < 0)
{
city.res_funds = 0;
}
if (city.res_use_funds < 0)
{
city.res_use_funds = 0;
}
city.res_gun -= temp.army_gun;
city.res_use_gun -= temp.army_gun;
if (city.res_gun < 0)
{
city.res_gun = 0;
}
if (city.res_use_gun < 0)
{
city.res_use_gun = 0;
}
city.res_horse -= temp.army_horse;
city.res_use_horse -= temp.army_horse;
if (city.res_horse < 0)
{
city.res_horse = 0;
}
if (city.res_use_horse < 0)
{
city.res_use_horse = 0;
}
city.res_kuwu -= temp.army_kuwu;
city.res_use_kuwu -= temp.army_kuwu;
if (city.res_kuwu < 0)
{
city.res_kuwu = 0;
}
if (city.res_use_kuwu < 0)
{
city.res_use_kuwu = 0;
}
city.res_razor -= temp.army_razor;
city.res_use_razor -= temp.army_razor;
if (city.res_razor < 0)
{
city.res_razor = 0;
}
if (city.res_use_razor < 0)
{
city.res_use_razor = 0;
}
city.res_soldier -= temp.army_soldier;
city.res_use_soldier -= temp.army_soldier;
if (city.res_soldier < 0)
{
city.res_soldier = 0;
}
if (city.res_use_soldier < 0)
{
city.res_use_soldier = 0;
}
return(city);
}
/// <summary>资源更新后处理</summary>
private void ResourceData(tg_war_city city)
{
(new War()).SaveWarCityAll(city); //更新全局据点信息
(new War()).SendCity(city.base_id, city.user_id); //推送据点数据更新
}
/// <summary>检测资源 </summary>
private Tuple <bool, List <Common.Resourse> > CheckResourse(Int32 baseid, int count, tg_war_city city, tg_war_role role)
{
var listentity = new List <Common.Resourse>();
var add = Common.GetInstance().GetResourseString(role.army_id, 1);
if (add == null)
{
return(Tuple.Create(false, listentity));
}
var oldcount = role.army_soldier;
if (oldcount > 0)
{
foreach (var resourse in add)
{
switch (resourse.type)
{
//兵粮和军资金回归城市，不用锁定
case (int)WarResourseType.兵粮: { city.res_foods += resourse.value * oldcount; } break;
case (int)WarResourseType.军资金: { city.res_funds += resourse.value * oldcount; } break;
case (int)WarResourseType.苦无: { if (city.res_use_kuwu >= resourse.value * oldcount)
{
city.res_use_kuwu -= resourse.value * oldcount;
}
} break;
case (int)WarResourseType.薙刀: { if (city.res_use_razor >= resourse.value * oldcount)
{
city.res_use_razor -= resourse.value * oldcount;
}
} break;
case (int)WarResourseType.足轻: { if (city.res_use_soldier >= resourse.value * oldcount)
{
city.res_use_soldier -= resourse.value * oldcount;
}
} break;
case (int)WarResourseType.铁炮: { if (city.res_use_gun >= resourse.value * oldcount)
{
city.res_use_gun -= resourse.value * oldcount;
}
} break;
case (int)WarResourseType.马匹: { if (city.res_use_horse >= resourse.value * oldcount)
{
city.res_use_horse -= resourse.value * oldcount;
}
} break;
}
}
}
// listentity.AddRange(add);
var reduce = Common.GetInstance().GetResourseString(baseid, 1);
if (reduce == null)
{
return(Tuple.Create(false, listentity));
}
foreach (var resourse in reduce)
{
switch (resourse.type)
{
case (int)WarResourseType.兵粮: { if (resourse.value * count > city.res_foods)
{
return(Tuple.Create(false, listentity));
}
} break;
case (int)WarResourseType.军资金: { if (resourse.value * count > city.res_funds)
{
return(Tuple.Create(false, listentity));
}
} break;
case (int)WarResourseType.苦无: { if (resourse.value * count > city.res_kuwu - city.res_use_kuwu)
{
return(Tuple.Create(false, listentity));
}
} break;
case (int)WarResourseType.薙刀: { if (resourse.value * count > city.res_razor - city.res_use_razor)
{
return(Tuple.Create(false, listentity));
}
} break;
case (int)WarResourseType.足轻: { if (resourse.value * count > city.res_soldier - city.res_use_soldier)
{
return(Tuple.Create(false, listentity));
}
} break;
case (int)WarResourseType.铁炮: { if (resourse.value * count > city.res_gun - city.res_use_gun)
{
return(Tuple.Create(false, listentity));
}
} break;
case (int)WarResourseType.马匹: { if (resourse.value * count > city.res_horse - city.res_use_horse)
{
return(Tuple.Create(false, listentity));
}
} break;
}
}
listentity.AddRange(reduce);
return(Tuple.Create(true, listentity));
}
