Exemple #1
0
        internal static async Task <string> setBust(State s, Bust bust)
        {
            //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(bust.car);
            var m_Target = rex_Target.Match(bust.TargetOwner);

            if (m_Target.Success)
            {
                var targetOwner = m_Target.Groups["target"].Value;

                // Console.WriteLine($"正则匹配成功: {m.Groups["key"] }");
                //   if (m.Groups["key"].Value == s.Key)
                {
                    var getPosition = new SetBust()
                    {
                        c   = "SetBust",
                        Key = s.Key,
                        //  car = "car" + m.Groups["car"].Value,
                        targetOwner = targetOwner,
                        target      = bust.Target
                    };
                    var msg = Newtonsoft.Json.JsonConvert.SerializeObject(getPosition);
                    await Startup.sendInmationToUrlAndGetRes(Room.roomUrls[s.roomIndex], msg);
                }
            }
            return("");
        }
Exemple #2
0
        private void bust(Player player, Car car, SetBust sb, ref List <string> notifyMsg, out MileResultReason Mrr)
        {
            {
                //if (this._Players[sa.targetOwner].Bust)


                {
                    var from   = this.getFromWhenAttack(player, car);
                    var to     = sb.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 = this.GetAFromB(from, to, player, ref notifyMsg);
                    // var goPath = Program.dt.GetAFromB(from, to);
                    //var returnPath = Program.dt.GetAFromB(fp2, baseFp.FastenPositionID);
                    var returnPath = this.GetAFromB(to, player.StartFPIndex, player, ref notifyMsg);
                    //var returnPath = Program.dt.GetAFromB(to, player.StartFPIndex);

                    var goMile     = GetMile(goPath);
                    var returnMile = GetMile(returnPath);


                    //第一步,计算去程和回程。
                    if (car.ability.leftMile >= goMile + returnMile)
                    {
                        int startT;
                        EditCarStateWhenBustStartOK(player, ref car, to, fp1, sb, goPath, out startT, ref notifyMsg);
                        SetBustArrivalThread(startT, car, sb, 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;
                    }
                }
            }
        }
Exemple #3
0
        private void SetBustArrivalThread(int startT, Car car, SetBust sb, List <Model.MapGo.nyrqPosition> returnPath)
        {
            Thread th = new Thread(() => setBustF(startT, new commandWithTime.bustSet()
            {
                c          = "bustSet",
                key        = sb.Key,
                returnPath = returnPath,
                target     = car.targetFpIndex,//新的起点
                changeType = "Bust",
                victim     = sb.targetOwner
            }));

            th.Start();
        }
Exemple #4
0
        private void carsBustFailedThenMustReturn(Car car, Player player, SetBust sb, ref List <string> notifyMsg)
        {
            Console.WriteLine($"由于里程安排问题,必须返回!");
            var from   = getFromWhenAttack(this._Players[sb.Key], car);
            int startT = 1;
            //var carKey = $"{}_{}";
            var    returnPath_Record = this._Players[sb.Key].returningRecord[sb.car];
            Thread th = new Thread(() => setReturn(startT, new commandWithTime.returnning()
            {
                c          = "returnning",
                key        = sb.Key,
                car        = sb.car,
                returnPath = returnPath_Record,
                target     = from,
                changeType = AttackFailedReturn,
            }));

            th.Start();
        }
Exemple #5
0
        private void EditCarStateWhenBustStartOK(Player player, ref Car car, int to, Model.FastonPosition fp1, SetBust sb, List <Model.MapGo.nyrqPosition> goPath, out int startT, ref List <string> notifyMsg)
        {
            car.targetFpIndex = to;//A.更改小车目标,在其他地方引用。
            car.setPurpose(this._Players[sb.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, sb.car, ref startT);
            }
            else
            {
                throw new Exception("错误的汽车类型!!!");
            }
            car.setState(this._Players[sb.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);
        }
Exemple #6
0
        internal async Task <string> updateBust(SetBust sb)
        {
            if (string.IsNullOrEmpty(sb.car))
            {
                return("");
            }
            else if (!(sb.car == "carA" || sb.car == "carB" || sb.car == "carC" || sb.car == "carD" || sb.car == "carE"))
            {
                return("");
            }
            else if (!(this._Players.ContainsKey(sb.targetOwner)))
            {
                return("");
            }
            else if (this._Players[sb.targetOwner].StartFPIndex != sb.target)
            {
                return("");
            }
            else if (sb.targetOwner == sb.Key)
            {
#warning 这里要加日志,出现了自己破产自己!!!
                return("");
            }
            else
            {
                var           carIndex  = getCarIndex(sb.car);
                List <string> notifyMsg = new List <string>();
                lock (this.PlayerLock)
                {
                    if (this._Players.ContainsKey(sb.Key))
                    {
                        if (this._Players[sb.Key].Bust)
                        {
                        }
                        else
                        {
                            //  case "findWork":
                            {
                                var player = this._Players[sb.Key];
                                var car    = this._Players[sb.Key].getCar(carIndex);
                                switch (car.state)
                                {
                                case CarState.waitAtBaseStation:
                                {
                                    if (car.purpose == Purpose.@null)
                                    {
                                        {
                                            //var state = CheckTargetState(sa.targetOwner);
                                            if (this._Players[sb.targetOwner].TheLargestHolderKey == player.Key)
                                            {
                                                MileResultReason mrr;
                                                bust(player, car, sb, ref notifyMsg, out mrr);
                                                if (mrr == MileResultReason.Abundant)
                                                {
                                                }
                                                else
                                                {
                                                    if (mrr == MileResultReason.CanNotReach)
                                                    {
                                                    }
                                                    else if (mrr == MileResultReason.CanNotReturn)
                                                    {
                                                    }
                                                    giveMoneyFromCarToPlayer(player, car, ref notifyMsg);
                                                }
                                                // doAttack(player, car, sa, ref notifyMsg);
                                            }
                                            else
                                            {
                                                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($"金钱不足以展开攻击!");
                                        //                                                    //carsBustFailedThenMustReturn(car, player, sb, ref notifyMsg);
                                        //                                                    carsBustFailedThenMustReturn(car, player, sb, ref notifyMsg);
                                        //                                                }
                                    }
                                }; 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("");
            }
        }
Exemple #7
0
        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("");
            }
            }
        }