internal static async Task <string> setAttack(State s, Attack attack)
{
//Regex r = new Regex("^car(?<car>[A-E]{1})_(?<key>[a-f0-9]{32})$");
Regex rex_Target = new Regex("^(?<target>[a-f0-9]{32})$");
//var m = r.Match(attack.car);
var m_Target = rex_Target.Match(attack.TargetOwner);
if (m_Target.Success)
{
var targetOwner = m_Target.Groups["target"].Value;
// Console.WriteLine($"正则匹配成功：{m.Groups["car"] }+{m.Groups["key"] }");
// if (m.Groups["key"].Value == s.Key)
{
var getPosition = new SetAttack()
{
c = "SetAttack",
Key = s.Key,
//car = "car" + m.Groups["car"].Value,
targetOwner = targetOwner,
target = attack.Target
};
var msg = Newtonsoft.Json.JsonConvert.SerializeObject(getPosition);
await Startup.sendInmationToUrlAndGetRes(Room.roomUrls[s.roomIndex], msg);
}
}
return("");
throw new NotImplementedException();
}
public bool conditionsOk(Command c, out string reason)
{
if (c.c == "SetAttack")
{
SetAttack sa = (SetAttack)c;
if (!(that._Players.ContainsKey(sa.targetOwner)))
{
reason = "";
return(false);
}
else if (that._Players[sa.targetOwner].StartFPIndex != sa.target)
{
reason = "";
return(false);
}
else if (sa.targetOwner == sa.Key)
{
#warning 这里要加日志，出现了自己攻击自己！！！
reason = "";
return(false);
}
else
{
reason = "";
return(true);
}
}
reason = "";
return(false);
}
private void SetAttackArrivalThread(int startT, Car car, SetAttack sa, List <Model.MapGo.nyrqPosition> returnPath)
{
Thread th = new Thread(() => setDebt(startT, new commandWithTime.debtOwner()
{
c = "debtOwner",
key = sa.Key,
car = sa.car,
returnPath = returnPath,
target = car.targetFpIndex,//新的起点
changeType = "Attack",
victim = sa.targetOwner
}));
th.Start();
}
internal void setDebtT(int startT, Car car, SetAttack sa, int goMile, RoomMainF.RoomMain.commandWithTime.ReturningOjb ro)
{
this.startNewThread(startT, new commandWithTime.debtOwner()
{
c = "debtOwner",
key = sa.Key,
// car = sa.car,
// returnPath = returnPath,
target = car.targetFpIndex,//新的起点
changeType = returnning.ChangeType.BeforeTax,
victim = sa.targetOwner,
costMile = goMile,
returningOjb = ro
}, this);
//Thread th = new Thread(() => setDebt(startT,);
//th.Start();
}
public void failedThenDo(Car car, RoleInGame player, Command c, ref List <string> notifyMsg)
{
if (c.c == "SetAttack")
{
SetAttack sa = (SetAttack)c;
this.carDoActionFailedThenMustReturn(car, player, ref notifyMsg);
if (car.state == CarState.waitAtBaseStation)
{
/*
* 在起始地点，攻击失败，说明最大里程内不能到达，故要重新换NPC.
*/
// if (player.playerType == RoleInGame.PlayerType.NPC)
// {
//#warning 这里要考虑是否直接提升玩家等级。
// ((NPC)player).SetBust(true, ref notifyMsg);
// }
}
//this.carsAttackFailedThenMustReturn(car, player, sa, ref notifyMsg);
}
}
private void MeetWithNPC(SetAttack sa)
{
// if (player.playerType == RoleInGame.PlayerType.player)
{
if (this._Players.ContainsKey(sa.targetOwner) && this._Players.ContainsKey(sa.Key))
{
if (this._Players[sa.targetOwner].playerType == RoleInGame.PlayerType.NPC &&
this._Players[sa.Key].playerType == RoleInGame.PlayerType.player)
{
var npc = ((NPC)this._Players[sa.targetOwner]);
if (npc.Enemies.Contains(sa.Key))
{
}
else
{
npc.Enemies.Add(sa.Key);
}
}
}
}
}
//private int GetFromWhenUpdateCollect(Player player, string cType, Car car)
//{
// switch (cType)
// {
// case "findWork":
// {
// switch (car.state)
// {
// case CarState.waitAtBaseStation:
// {
// if (car.targetFpIndex != -1)
// {
// //出现这种情况，应该是回了基站里没有初始
// throw new Exception("参数混乱");
// }
// else if (car.purpose == Purpose.@null)
// {
// return player.StartFPIndex;
// }
// else
// {
// //出现这种情况，应该是回了基站里没有初始
// throw new Exception("参数混乱");
// }
// };
// case CarState.waitForCollectOrAttack:
// {
// if (car.targetFpIndex == -1)
// {
// throw new Exception("参数混乱");
// }
// else if (car.purpose == Purpose.collect)
// {
// return car.targetFpIndex;
// }
// else
// {
// //出现这种情况，应该是回了基站里没有初始
// throw new Exception("参数混乱");
// }
// };
// case CarState.waitOnRoad:
// {
// if (car.targetFpIndex == -1)
// {
// throw new Exception("参数混乱");
// }
// else if (car.purpose == Purpose.collect || car.purpose == Purpose.@null)
// {
// return car.targetFpIndex;
// }
// else
// {
// //出现这种情况，应该是回了基站里没有初始
// throw new Exception("参数混乱");
// }
// }; break;
// };
// }; break;
// }
// throw new Exception("非法调用");
//}
private void carsAttackFailedThenMustReturn(Car car, Player player, SetAttack sc, ref List <string> notifyMsg)
{
// if (car.state == CarState.waitAtBaseStation)
{
//Console.Write($"现在剩余容量为{car.ability.leftVolume}，总容量为{car.ability.Volume}");
Console.WriteLine($"由于里程安排问题，必须返回！");
var from = getFromWhenAttack(this._Players[sc.Key], car);
int startT = 1;
//var carKey = $"{}_{}";
var returnPath_Record = this._Players[sc.Key].returningRecord[sc.car];
Thread th = new Thread(() => setReturn(startT, new commandWithTime.returnning()
{
c = "returnning",
key = sc.Key,
car = sc.car,
returnPath = returnPath_Record,
target = from,
changeType = AttackFailedReturn,
}));
th.Start();
}
}
public bool carAbilitConditionsOk(RoleInGame player, Car car, Command c)
{
if (c.c == "SetAttack")
{
if (car.ability.leftBusiness > 0)
{
SetAttack sa = (SetAttack)c;
var state = CheckTargetState(sa.targetOwner);
if (state == CarStateForBeAttacked.CanBeAttacked)
{
return(true);
// doAttack(player, car, sa, ref notifyMsg);
}
else if (state == CarStateForBeAttacked.HasBeenBust)
{
this.WebNotify(player, "攻击的对象已经破产！");
return(false);
}
else if (state == CarStateForBeAttacked.NotExisted)
{
this.WebNotify(player, "攻击的对象已经退出游戏！");
return(false);
}
else
{
throw new Exception($"{state.ToString()}未注册！");
}
}
else
{
this.WebNotify(player, "小车已经没有多余业务容量！");
return(false);
}
}
else
{
return(false);
}
}
private string SetNPCToDoSomeThing(NPC npc, NPCAction selectV)
{
switch (selectV)
{
case NPCAction.Bust:
{
/*
* 0代表破产
*/
var players = this.getGetAllPlayers();
string keyToSetBust;
if (SuitToSetBust(npc, players, out keyToSetBust))
{
/*
* 如果适合破产，将设置破产
*/
NpcDebugWrite($"{npc.PlayerName}({npc.Key})可以bust,其要对{this._Players[keyToSetBust].PlayerName}({keyToSetBust})进行破产清算！！！");
var sb = new SetBust()
{
c = "SetBust",
Key = npc.Key,
target = this._Players[keyToSetBust].StartFPIndex,
targetOwner = keyToSetBust
};
return(updateBust(sb));
}
else
{
NpcDebugWrite($"{npc.PlayerName}({npc.Key})不可以bust");
//执行攻击
return(SetNPCToDoSomeThing(npc, NPCAction.Attack));
}
};
case NPCAction.Attack:
{
// lock (this.PlayerLock)
{
npc.ClearEnemiesAndMolester(this._Players);
if (npc.SuitToAttack())
{
if (npc.Enemies.Count > 0)
{
string enemyKey = npc.Enemies[this.rm.Next(npc.Enemies.Count)];
NpcDebugWrite($"{npc.PlayerName}({npc.Key})可以Attack,其要对{this._Players[enemyKey].PlayerName}({enemyKey})进行攻击！！！");
var sa = new SetAttack()
{
c = "SetAttack",
Key = npc.Key,
target = this._Players[enemyKey].StartFPIndex,
targetOwner = enemyKey
};
return(updateAttack(sa));
}
else if (npc.Molester.Count > 0)
{
string molesterKey = npc.Molester[this.rm.Next(npc.Molester.Count)];
NpcDebugWrite($"{npc.PlayerName}({npc.Key})可以Attack,其要对{this._Players[molesterKey].PlayerName}({molesterKey})进行攻击！！！");
var sa = new SetAttack()
{
c = "SetAttack",
Key = npc.Key,
target = this._Players[molesterKey].StartFPIndex,
targetOwner = molesterKey
};
return(updateAttack(sa));
}
else
{
NpcDebugWrite($"{npc.PlayerName}({npc.Key})不可以Attack");
return(SetNPCToDoSomeThing(npc, NPCAction.Tax));
}
}
else
{
NpcDebugWrite($"{npc.PlayerName}({npc.Key})不可以Attack");
return(SetNPCToDoSomeThing(npc, NPCAction.Tax));
}
}
};
case NPCAction.Tax:
{
if (npc.SuitToCollectTax())
{
var taxInPositions = npc.TaxInPositionForeach();
var position = -1;
double minLength = double.MaxValue;
for (int indexOfTaxPosition = 0; indexOfTaxPosition < taxInPositions.Count; indexOfTaxPosition++)
{
var length = Distance(taxInPositions[indexOfTaxPosition], npc.StartFPIndex);
if (length < minLength)
{
minLength = length;
position = taxInPositions[indexOfTaxPosition];
}
}
if (position >= 0)
{
NpcDebugWrite($"{npc.PlayerName}({npc.Key})可以Tax,其要对{ Program.dt.GetFpByIndex(position).FastenPositionName}进行收取红包！！！");
var st = new SetTax()
{
c = "SetTax",
target = position,
Key = npc.Key
};
return(updateTax(st));
}
else
{
NpcDebugWrite($"{npc.PlayerName}({npc.Key})不可以Tax");
return(SetNPCToDoSomeThing(npc, NPCAction.Collect));
}
}
else
{
NpcDebugWrite($"{npc.PlayerName}({npc.Key})不可以Tax");
return(SetNPCToDoSomeThing(npc, NPCAction.Collect));
}
};
case NPCAction.Collect:
{
// lock (this.PlayerLock)
{
npc.ClearEnemiesAndMolester(this._Players);
if (npc.SuitToCollect())
{
// var collectInPositions = npc.TaxInPositionForeach();
var position = -1;
var collectIndex = -1;
double minLength = double.MaxValue;
foreach (var item in this._collectPosition)
{
if (item.Value >= 0)
{
var length = Distance(item.Value, npc.StartFPIndex);
if (length < minLength)
{
minLength = length;
position = item.Value;
collectIndex = item.Key;
}
}
}
if (collectIndex >= 0)
{
NpcDebugWrite($"{npc.PlayerName}({npc.Key})可以SetCollect");
var ut = new SetCollect()
{
c = "SetCollect",
collectIndex = collectIndex,
cType = "findWork",
fastenpositionID = Program.dt.GetFpByIndex(position).FastenPositionID,
Key = npc.Key
};
return(updateCollect(ut));
}
else
{
return(SetNPCToDoSomeThing(npc, NPCAction.Wait));
}
}
else
{
return(SetNPCToDoSomeThing(npc, NPCAction.Wait));
}
}
};
case NPCAction.Wait:
{
if (npc.getCar().state == Car.CarState.waitForCollectOrAttack)
{
var otr = new CommonClass.OrderToReturn()
{
c = "OrderToReturn",
Key = npc.Key
};
return(OrderToReturn(otr));
}
else if (npc.getCar().state == Car.CarState.waitForTaxOrAttack)
{
var otr = new CommonClass.OrderToReturn()
{
c = "OrderToReturn",
Key = npc.Key
};
return(OrderToReturn(otr));
}
else if (npc.getCar().state == Car.CarState.waitOnRoad)
{
var otr = new CommonClass.OrderToReturn()
{
c = "OrderToReturn",
Key = npc.Key
};
return(OrderToReturn(otr));
}
else
{
return("");
}
};
default:
{
return("");
}
}
}
private void EditCarStateWhenAttackStartOK(Player player, ref Car car, int to, Model.FastonPosition fp1, SetAttack sa, List <Model.MapGo.nyrqPosition> goPath, out int startT, ref List <string> notifyMsg)
{
car.targetFpIndex = to;//A.更改小车目标，在其他地方引用。
car.setPurpose(this._Players[sa.Key], ref notifyMsg, Purpose.attack);
// car.purpose = Purpose.attack;//B.更改小车目的，小车变为攻击状态！
// car.changeState++;//C.更改状态用去前台更新动画
/*
* D.更新小车动画参数
*/
var speed = car.ability.Speed;
startT = 0;
List <Data.PathResult> result;
if (car.state == CarState.waitAtBaseStation)
{
result = getStartPositon(fp1, sa.car, ref startT);
}
else if (car.state == CarState.waitForCollectOrAttack)
{
result = new List <Data.PathResult>();
}
else if (car.state == CarState.waitForTaxOrAttack)
{
result = new List <Data.PathResult>();
}
else if (car.state == CarState.waitOnRoad)
{
result = new List <Data.PathResult>();
}
else
{
throw new Exception("错误的汽车类型！！！");
}
car.setState(this._Players[sa.Key], ref notifyMsg, CarState.roadForAttack);
//car.state = CarState.roadForAttack;
// this.SendStateAndPurpose(this._Players[sa.Key], car, ref notifyMsg);
Program.dt.GetAFromBPoint(goPath, fp1, speed, ref result, ref startT);
result.RemoveAll(item => item.t0 == item.t1);
var animateData = new AnimateData()
{
animateData = result,
recordTime = DateTime.Now
};
car.setAnimateData(player, ref notifyMsg, animateData);
//car.animateData = new AnimateData()
//{
// animateData = result,
// recordTime = DateTime.Now
//};
}
public string updateAttack(SetAttack sa)
{
return(this.attackE.updateAttack(sa));
}
///// <summary>
/////
///// </summary>
///// <param name="player">玩家</param>
///// <param name="car">小车</param>
///// <param name="sa"></param>
///// <param name="notifyMsg"></param>
///// <param name="victimState">0，代表用户不存在了。1代表已经破产，2代表正常</param>
/// <summary>
/// 此函数，必须在this._Players.ContainsKey(sa.targetOwner)=true且this._Players[sa.targetOwner].Bust=false情况下运行。请提前进行判断！
/// </summary>
/// <param name="player">玩家</param>
/// <param name="car"></param>
/// <param name="sa"></param>
/// <param name="notifyMsg"></param>
/// <param name="victimState"></param>
/// <param name="reason"></param>
void attack(Player player, Car car, SetAttack sa, ref List <string> notifyMsg, out MileResultReason Mrr)
{
// if (this._Players.ContainsKey(sa.targetOwner))
{
//if (this._Players[sa.targetOwner].Bust)
if (car.ability.costBusiness + car.ability.costVolume > 0)
{
var from = this.getFromWhenAttack(player, car);
var to = sa.target;
var fp1 = Program.dt.GetFpByIndex(from);
var fp2 = Program.dt.GetFpByIndex(to);
var baseFp = Program.dt.GetFpByIndex(player.StartFPIndex);
// var goPath = Program.dt.GetAFromB(fp1, fp2.FastenPositionID);
//var goPath = Program.dt.GetAFromB(from, to);
var goPath = this.GetAFromB(from, to, player, ref notifyMsg);
//var returnPath = Program.dt.GetAFromB(fp2, baseFp.FastenPositionID);
//var returnPath = Program.dt.GetAFromB(to, player.StartFPIndex);
var returnPath = this.GetAFromB(to, player.StartFPIndex, player, ref notifyMsg);
var goMile = GetMile(goPath);
var returnMile = GetMile(returnPath);
//第一步，计算去程和回程。
if (car.ability.leftMile >= goMile + returnMile)
{
int startT;
EditCarStateWhenAttackStartOK(player, ref car, to, fp1, sa, goPath, out startT, ref notifyMsg);
SetAttackArrivalThread(startT, car, sa, returnPath);
// getAllCarInfomations(sa.Key, ref notifyMsg);
Mrr = MileResultReason.Abundant;
}
else if (car.ability.leftMile >= goMile)
{
//当攻击失败，必须返回
Console.Write($"去程{goMile}，回程{returnMile}");
Console.Write($"你去了回不来");
Mrr = MileResultReason.CanNotReturn;
}
else
{
#warning 这里要在web前台进行提示
//当攻击失败，必须返回
Console.Write($"去程{goMile}，回程{returnMile}");
Console.Write($"你去不了");
Mrr = MileResultReason.CanNotReach;
}
}
else
{
Mrr = MileResultReason.MoneyIsNotEnougt;
}
}
//else
//{
// throw new Exception("此方法，不该在此条件下运行");
//}
}
/*
* 攻击的目的是为了增加股份。
* A玩家，拿100块钱攻击B玩家，B玩家的债务增加100，使用金额都增加90
* 当第一股东不是B玩家时，是A玩家时。A玩家有权对B进行破产清算。
*/
internal async Task <string> updateAttack(SetAttack sa)
{
// Attack a = new Attack(sa, this);
//a.doAttack();
if (string.IsNullOrEmpty(sa.car))
{
return("");
}
else if (!(sa.car == "carA" || sa.car == "carB" || sa.car == "carC" || sa.car == "carD" || sa.car == "carE"))
{
return("");
}
else if (!(this._Players.ContainsKey(sa.targetOwner)))
{
return("");
}
else if (this._Players[sa.targetOwner].StartFPIndex != sa.target)
{
return("");
}
else if (sa.targetOwner == sa.Key)
{
#warning 这里要加日志，出现了自己攻击自己！！！
return("");
}
else
{
var carIndex = getCarIndex(sa.car);
List <string> notifyMsg = new List <string>();
lock (this.PlayerLock)
{
if (this._Players.ContainsKey(sa.Key))
{
if (this._Players[sa.Key].Bust)
{
}
else
{
// case "findWork":
{
var player = this._Players[sa.Key];
var car = this._Players[sa.Key].getCar(carIndex);
switch (car.state)
{
case CarState.waitAtBaseStation:
{
if (car.purpose == Purpose.@null)
{
var moneyIsEnoughToStart = giveMoneyFromPlayerToCarForAttack(player, car, ref notifyMsg);
if (moneyIsEnoughToStart)
{
var state = CheckTargetState(sa.targetOwner);
if (state == CarStateForBeAttacked.CanBeAttacked)
{
MileResultReason mrr;
attack(player, car, sa, ref notifyMsg, out mrr);
if (mrr == MileResultReason.Abundant)
{
}
else
{
if (mrr == MileResultReason.CanNotReach)
{
}
else if (mrr == MileResultReason.CanNotReturn)
{
}
else if (mrr == MileResultReason.MoneyIsNotEnougt)
{
}
giveMoneyFromCarToPlayer(player, car, ref notifyMsg);
}
// doAttack(player, car, sa, ref notifyMsg);
}
else if (state == CarStateForBeAttacked.HasBeenBust)
{
Console.WriteLine($"攻击对象已经破产！");
giveMoneyFromCarToPlayer(player, car, ref notifyMsg);
}
else if (state == CarStateForBeAttacked.NotExisted)
{
Console.WriteLine($"攻击对象已经退出了游戏！");
giveMoneyFromCarToPlayer(player, car, ref notifyMsg);
}
else
{
throw new Exception($"{state.ToString()}未注册！");
}
}
else
{
#warning 前端要提示
Console.WriteLine($"金钱不足以展开攻击！");
giveMoneyFromCarToPlayer(player, car, ref notifyMsg);
//carsAttackFailedThenMustReturn(car, player, sa, ref notifyMsg);
}
}
}; break;
case CarState.waitOnRoad:
{
/*
* 在接收到攻击指令时，如果小车在路上，说明，
* 其上一个任务是抢能力宝石，结果是没抢到。其
* 目的应该应该为purpose=null
*/
if (car.purpose == Purpose.@null)
{
var state = CheckTargetState(sa.targetOwner);
if (state == CarStateForBeAttacked.CanBeAttacked)
{
MileResultReason mrr;
attack(player, car, sa, ref notifyMsg, out mrr);
if (mrr == MileResultReason.Abundant)
{
}
else if (mrr == MileResultReason.CanNotReach)
{
carsAttackFailedThenMustReturn(car, player, sa, ref notifyMsg);
}
else if (mrr == MileResultReason.CanNotReturn)
{
carsAttackFailedThenMustReturn(car, player, sa, ref notifyMsg);
}
else if (mrr == MileResultReason.MoneyIsNotEnougt)
{
carsAttackFailedThenMustReturn(car, player, sa, ref notifyMsg);
}
// doAttack(player, car, sa, ref notifyMsg);
}
else if (state == CarStateForBeAttacked.HasBeenBust)
{
carsAttackFailedThenMustReturn(car, player, sa, ref notifyMsg);
Console.WriteLine($"攻击对象已经破产！");
}
else if (state == CarStateForBeAttacked.NotExisted)
{
carsAttackFailedThenMustReturn(car, player, sa, ref notifyMsg);
Console.WriteLine($"攻击对象已经退出了游戏！");
}
else
{
throw new Exception($"{state.ToString()}未注册！");
}
}
}; break;
case CarState.waitForTaxOrAttack:
{
if (car.purpose == Purpose.tax)
{
var state = CheckTargetState(sa.targetOwner);
if (state == CarStateForBeAttacked.CanBeAttacked)
{
MileResultReason mrr;
attack(player, car, sa, ref notifyMsg, out mrr);
if (mrr == MileResultReason.Abundant)
{
}
else if (mrr == MileResultReason.CanNotReach)
{
carsAttackFailedThenMustReturn(car, player, sa, ref notifyMsg);
}
else if (mrr == MileResultReason.CanNotReturn)
{
carsAttackFailedThenMustReturn(car, player, sa, ref notifyMsg);
}
else if (mrr == MileResultReason.MoneyIsNotEnougt)
{
carsAttackFailedThenMustReturn(car, player, sa, ref notifyMsg);
}
// doAttack(player, car, sa, ref notifyMsg);
}
else if (state == CarStateForBeAttacked.HasBeenBust)
{
Console.WriteLine($"攻击对象已经破产！");
carsAttackFailedThenMustReturn(car, player, sa, ref notifyMsg);
}
else if (state == CarStateForBeAttacked.NotExisted)
{
Console.WriteLine($"攻击对象已经退出了游戏！");
carsAttackFailedThenMustReturn(car, player, sa, ref notifyMsg);
}
else
{
throw new Exception($"{state.ToString()}未注册！");
}
}
}; break;
case CarState.waitForCollectOrAttack:
{
if (car.purpose == Purpose.collect)
{
var state = CheckTargetState(sa.targetOwner);
if (state == CarStateForBeAttacked.CanBeAttacked)
{
MileResultReason mrr;
attack(player, car, sa, ref notifyMsg, out mrr);
if (mrr == MileResultReason.Abundant)
{
}
else if (mrr == MileResultReason.CanNotReach)
{
carsAttackFailedThenMustReturn(car, player, sa, ref notifyMsg);
}
else if (mrr == MileResultReason.CanNotReturn)
{
carsAttackFailedThenMustReturn(car, player, sa, ref notifyMsg);
}
else if (mrr == MileResultReason.MoneyIsNotEnougt)
{
carsAttackFailedThenMustReturn(car, player, sa, ref notifyMsg);
}
}
else if (state == CarStateForBeAttacked.HasBeenBust)
{
Console.WriteLine($"攻击对象已经破产！");
carsAttackFailedThenMustReturn(car, player, sa, ref notifyMsg);
}
else if (state == CarStateForBeAttacked.NotExisted)
{
carsAttackFailedThenMustReturn(car, player, sa, ref notifyMsg);
Console.WriteLine($"攻击对象已经退出了游戏！");
}
else
{
throw new Exception($"{state.ToString()}未注册！");
}
}
}; break;
}
};
}
}
}
for (var i = 0; i < notifyMsg.Count; i += 2)
{
var url = notifyMsg[i];
var sendMsg = notifyMsg[i + 1];
Console.WriteLine($"url:{url}");
if (!string.IsNullOrEmpty(url))
{
await Startup.sendMsg(url, sendMsg);
}
}
return("");
}
}
public AttackObj(SetAttack sa, SetAttackArrivalThreadM setAttackArrivalThread)
{
this._sa = sa;
this._setAttackArrivalThread = setAttackArrivalThread;
}
private void SetAttackArrivalThread(int startT, int step, RoleInGame player, Car car, SetAttack sa, int goMile, Node goPath, commandWithTime.ReturningOjb ro)
{
System.Threading.Thread th = new System.Threading.Thread(() =>
{
if (step >= goPath.path.Count - 1)
{
that.debtE.setDebtT(startT, car, sa, goMile, ro);
}
//this.startNewThread(startT, new commandWithTime.defenseSet()
//{
// c = command,
// changeType = commandWithTime.returnning.ChangeType.BeforeTax,
// costMile = goMile,
// key = ms.Key,
// returningOjb = ro,
// target = car.targetFpIndex,
// beneficiary = ms.targetOwner
//}, this);
else
{
if (step == 0)
{
this.ThreadSleep(startT);
if (player.playerType == RoleInGame.PlayerType.NPC || player.Bust)
{
}
else
{
StartSelectThread(goPath.path[step].selections, goPath.path[step].selectionCenter, (Player)player);
}
List <string> notifyMsg = new List <string>();
int newStartT;
step++;
if (step < goPath.path.Count)
{
EditCarStateAfterSelect(step, player, ref car, goPath, ref notifyMsg, out newStartT);
}
else
{
newStartT = 0;
}
car.setState(player, ref notifyMsg, CarState.working);
this.sendMsg(notifyMsg);
//string command, int startT, int step, RoleInGame player, Car car, MagicSkill ms, int goMile, Node goPath, commandWithTime.ReturningOjb ro
SetAttackArrivalThread(newStartT, step, player, car, sa, goMile, goPath, ro);
}
else
{
this.ThreadSleep(startT);
if (player.playerType == RoleInGame.PlayerType.NPC || player.Bust)
{
}
else if (startT != 0)
{
StartSelectThread(goPath.path[step].selections, goPath.path[step].selectionCenter, (Player)player);
}
step++;
List <string> notifyMsg = new List <string>();
int newStartT;
if (step < goPath.path.Count)
{
EditCarStateAfterSelect(step, player, ref car, goPath, ref notifyMsg, out newStartT);
}
// else if(step==goPath.path.Count-1)
//EditCarStateAfterSelect(step,player,ref car,)
else
{
throw new Exception("这种情况不会出现");
}
//newStartT = 0;
car.setState(player, ref notifyMsg, CarState.working);
this.sendMsg(notifyMsg);
SetAttackArrivalThread(newStartT, step, player, car, sa, goMile, goPath, ro);
}
}
});
th.Start();
}
internal commandWithTime.ReturningOjb randomWhenConfused(RoleInGame player, RoleInGame boss, Car car, SetAttack sa, ref List <string> notifyMsg, out MileResultReason Mrr)
{
AttackObj ao = new AttackObj(sa,
(int startT, Car car, SetAttack sa, int goMile, Node goPath, commandWithTime.ReturningOjb ro) =>
{
//this.SetAttackArrivalThread()
List <string> notifyMsg = new List <string>();
car.setState(player, ref notifyMsg, CarState.working);
this.sendMsg(notifyMsg);
this.SetAttackArrivalThread(startT, 0, player, car, sa, goMile, goPath, ro);
}
);
return(this.randomWhenConfused(player, boss, car, ao, ref notifyMsg, out Mrr));
}
internal string updateAttack(SetAttack sa)
{
return(this.updateAction(this, sa, sa.Key));
}
