Exemple #1
0
        //0表示男女,1男2女
        //type 1表示物品,2表示金币,3表示点券,4表示经验,5表示功勋,6表示BUFF
        public static bool AddDailyAward(GamePlayer player)
        {
            if (DateTime.Now.Date == player.PlayerCharacter.LastAward.Date)
            {
                return(false);
            }

            //if (player.PlayerCharacter.DayLoginCount > 0)
            //    return false;

            player.PlayerCharacter.DayLoginCount++;
            player.PlayerCharacter.LastAward = DateTime.Now;
            DailyAwardInfo[] infos = GetAllAwardInfo();
            StringBuilder    msg   = new StringBuilder();
            string           full  = string.Empty;
            bool             has   = false;

            foreach (DailyAwardInfo info in infos)
            {
                if (info.Sex != 0 && (player.PlayerCharacter.Sex ? 1 : 2) != info.Sex)
                {
                    continue;
                }

                has = true;
                switch (info.Type)
                {
                case 1:
                    ItemTemplateInfo itemTemplateInfo = Bussiness.Managers.ItemMgr.FindItemTemplate(info.TemplateID);
                    if (itemTemplateInfo != null)
                    {
                        int itemCount = info.Count;
                        for (int len = 0; len < itemCount; len += itemTemplateInfo.MaxCount)
                        {
                            int      count = len + itemTemplateInfo.MaxCount > itemCount ? itemCount - len : itemTemplateInfo.MaxCount;
                            ItemInfo item  = ItemInfo.CreateFromTemplate(itemTemplateInfo, count, (int)ItemAddType.DailyAward);
                            item.ValidDate = info.ValidDate;
                            item.IsBinds   = info.IsBinds;

                            //if (player.AddItem(item, Game.Server.Statics.ItemAddType.DailyAward, item.GetBagType()) == -1)
                            if (!player.AddTemplate(item, item.Template.BagType, item.Count))
                            {
                                using (PlayerBussiness db = new PlayerBussiness())
                                {
                                    item.UserID = 0;
                                    db.AddGoods(item);

                                    MailInfo message = new MailInfo();
                                    message.Annex1     = item.ItemID.ToString();
                                    message.Content    = LanguageMgr.GetTranslation("AwardMgr.AddDailyAward.Content", item.Template.Name);
                                    message.Gold       = 0;
                                    message.Money      = 0;
                                    message.Receiver   = player.PlayerCharacter.NickName;
                                    message.ReceiverID = player.PlayerCharacter.ID;
                                    message.Sender     = message.Receiver;
                                    message.SenderID   = message.ReceiverID;
                                    message.Title      = LanguageMgr.GetTranslation("AwardMgr.AddDailyAward.Title", item.Template.Name);
                                    message.Type       = (int)eMailType.DailyAward;
                                    db.SendMail(message);

                                    full = LanguageMgr.GetTranslation("AwardMgr.AddDailyAward.Mail");
                                }
                            }
                        }
                    }
                    break;

                case 2:
                    player.AddGold(info.Count);
                    break;

                case 3:
                    player.AddMoney(info.Count);
                    LogMgr.LogMoneyAdd(LogMoneyType.Award, LogMoneyType.Award_Daily, player.PlayerCharacter.ID, info.Count, player.PlayerCharacter.Money, 0, 0, 0, 0, "", "", "");
                    break;

                case 4:
                    player.AddGP(info.Count);
                    break;

                case 5:
                    player.AddOffer(info.Count, false);
                    break;

                case 6:
                    ItemTemplateInfo template = Bussiness.Managers.ItemMgr.FindItemTemplate(info.TemplateID);
                    if (template != null)
                    {
                        AbstractBuffer buffer = BufferList.CreateBufferHour(template, info.ValidDate);
                        buffer.Start(player);
                    }
                    break;
                }
            }


            if (has)
            {
                //player.Out.SendMessage(eMessageType.DailyAward, full + msg.ToString());

                if (!string.IsNullOrEmpty(full))
                {
                    player.Out.SendMailResponse(player.PlayerCharacter.ID, eMailRespose.Receiver);
                }
            }

            return(true);
        }
 public WebSocketPackageInfo Filter(BufferList data, out int rest)
 {
     rest = 0;
     return(null);
 }
 public override TestProtobasePackageInfo Filter(BufferList data, out int rest)
 {
     return(base.Filter(data, out rest));
 }
Exemple #4
0
 public UserInfo()
 {
     BuffManger = new BufferList(RConfig.ReadInt("MaxBufferSize"));
 }
 protected virtual void AfterPrint()
 {
     BufferList.Add(PrinterCmdUtils.NextLine(2));
     BufferList.Add(PrinterCmdUtils.FeedPaperCutAll());
 }
Exemple #6
0
        void ProcessPackageWithSessionID(Socket listenSocket, IPEndPoint remoteEndPoint, ArraySegment <byte> receivedData)
        {
            TPackageInfo requestInfo;

            string sessionID;

            int rest;

            try
            {
                var receiveData = new BufferList();
                receiveData.Add(receivedData);

                requestInfo = this.m_UdpRequestFilter.Filter(receiveData, out rest);
            }
            catch (Exception exc)
            {
                if (AppServer.Logger.IsErrorEnabled)
                {
                    AppServer.Logger.Error("Failed to parse UDP package!", exc);
                }
                return;
            }

            var udpRequestInfo = requestInfo as IUdpPackageInfo;

            if (rest > 0)
            {
                if (AppServer.Logger.IsErrorEnabled)
                {
                    AppServer.Logger.Error("The output parameter rest must be zero in this case!");
                }
                return;
            }

            if (udpRequestInfo == null)
            {
                if (AppServer.Logger.IsErrorEnabled)
                {
                    AppServer.Logger.Error("Invalid UDP package format!");
                }
                return;
            }

            if (string.IsNullOrEmpty(udpRequestInfo.SessionID))
            {
                if (AppServer.Logger.IsErrorEnabled)
                {
                    AppServer.Logger.Error("Failed to get session key from UDP package!");
                }
                return;
            }

            sessionID = udpRequestInfo.SessionID;

            var appSession = AppServer.GetSessionByID(sessionID);

            if (appSession == null)
            {
                if (!DetectConnectionNumber(remoteEndPoint))
                {
                    return;
                }

                var socketSession = new UdpSocketSession(listenSocket, remoteEndPoint, sessionID);
                appSession = AppServer.CreateAppSession(socketSession);

                if (appSession == null)
                {
                    return;
                }

                if (!DetectConnectionNumber(remoteEndPoint))
                {
                    return;
                }

                if (!AppServer.RegisterSession(appSession))
                {
                    return;
                }

                Interlocked.Increment(ref m_ConnectionCount);

                socketSession.Closed += OnSocketSessionClosed;
                socketSession.Start();
            }
            else
            {
                var socketSession = appSession.SocketSession as UdpSocketSession;
                //Client remote endpoint may change, so update session to ensure the server can find client correctly
                socketSession.UpdateRemoteEndPoint(remoteEndPoint);
            }

            m_RequestHandler.ExecuteCommand(appSession, requestInfo);
        }
        /// <summary>
        /// Filters the received data.
        /// </summary>
        /// <param name="data">The received data.</param>
        /// <param name="rest">The length of the rest data after filtering.</param>
        /// <returns>the received packageInfo instance</returns>
        public virtual TPackageInfo Filter(BufferList data, out int rest)
        {
            rest = 0;

            int searchEndMarkOffset;
            int searchEndMarkLength;

            var currentSegment = data.Last;
            var readBuffer     = currentSegment.Array;
            var offset         = currentSegment.Offset;
            var length         = currentSegment.Count;

            int totalParsed = 0;

            if (!m_FoundBegin)
            {
                int pos = readBuffer.SearchMark(offset, length, m_BeginSearchState, out totalParsed);

                if (pos < 0)
                {
                    //All received data is part of the begin mark
                    if (m_BeginSearchState.Matched > 0 && data.Total == m_BeginSearchState.Matched)
                    {
                        return(default(TPackageInfo));
                    }

                    //Invalid data, contains invalid data before the regular begin mark
                    State = FilterState.Error;
                    return(default(TPackageInfo));
                }

                //Found the matched begin mark
                if (pos != offset)//But not at the beginning, contains invalid data before the regular begin mark
                {
                    State = FilterState.Error;
                    return(default(TPackageInfo));
                }

                //Found start mark, then search end mark
                m_FoundBegin = true;

                searchEndMarkOffset = offset + totalParsed;

                //Reach end
                if (offset + length <= searchEndMarkOffset)
                {
                    return(default(TPackageInfo));
                }

                searchEndMarkLength = offset + length - searchEndMarkOffset;
            }
            else//Already found begin mark
            {
                searchEndMarkOffset = offset;
                searchEndMarkLength = length;
            }

            while (true)
            {
                int parsedLength;
                var endPos = readBuffer.SearchMark(searchEndMarkOffset, searchEndMarkLength, m_EndSearchState, out parsedLength);

                //Haven't found end mark
                if (endPos < 0)
                {
                    return(default(TPackageInfo));
                }

                totalParsed += parsedLength; //include begin mark if the mark is found in this round receiving
                rest         = length - totalParsed;

                data.SetLastItemLength(totalParsed);

                var packageInfo = ResolvePackage(this.GetBufferStream(data));

                if (!ReferenceEquals(packageInfo, default(TPackageInfo)))
                {
                    Reset();
                    return(packageInfo);
                }

                if (rest > 0)
                {
                    searchEndMarkOffset = endPos + m_EndSearchState.Mark.Length;
                    searchEndMarkLength = rest;
                    continue;
                }

                //Not found end mark
                return(default(TPackageInfo));
            }
        }
        public int HandlePacket(GameClient client, GSPacketIn packet)
        {
            int    bagType           = packet.ReadInt();
            int    num               = packet.ReadInt();
            string translateId       = null;
            List <ShopItemInfo> list = new List <ShopItemInfo>();

            if (client.Player.PlayerCharacter.HasBagPassword && client.Player.PlayerCharacter.IsLocked)
            {
                client.Out.SendMessage(eMessageType.Normal, LanguageMgr.GetTranslation("Bag.Locked", new object[0]));
                return(0);
            }
            ItemInfo itemInfo;

            if (num == -1)
            {
                int num2 = packet.ReadInt();
                int num3 = packet.ReadInt();
                int num4 = 0;
                int num5 = 0;
                ItemTemplateInfo goods = ItemMgr.FindItemTemplate(num2);
                itemInfo = ItemInfo.CreateFromTemplate(goods, 1, 102);
                list     = ShopMgr.FindShopbyTemplatID(num2);
                for (int i = 0; i < list.Count; i++)
                {
                    if (list[i].APrice1 == -1 && list[i].AValue1 != 0)
                    {
                        num5 = list[i].AValue1;
                        itemInfo.ValidDate = list[i].AUnit;
                    }
                }
                if (itemInfo != null)
                {
                    if (num4 <= client.Player.PlayerCharacter.Gold && num5 <= client.Player.PlayerCharacter.Money)
                    {
                        client.Player.RemoveMoney(num5);
                        client.Player.RemoveGold(num4);
                        LogMgr.LogMoneyAdd(LogMoneyType.Shop, LogMoneyType.Shop_Card, client.Player.PlayerCharacter.ID, num5, client.Player.PlayerCharacter.Money, num4, 0, 0, 0, "牌子编号", itemInfo.TemplateID.ToString(), num3.ToString());
                        translateId = "CardUseHandler.Success";
                    }
                    else
                    {
                        itemInfo = null;
                    }
                }
            }
            else
            {
                itemInfo    = client.Player.PropBag.GetItemAt(num);
                translateId = "CardUseHandler.Success";
            }
            if (itemInfo != null)
            {
                string translateId2 = string.Empty;
                if (itemInfo.Template.Property1 != 21)
                {
                    AbstractBuffer abstractBuffer = BufferList.CreateBuffer(itemInfo.Template, itemInfo.ValidDate);
                    if (abstractBuffer != null)
                    {
                        abstractBuffer.Start(client.Player);
                        if (num != -1)
                        {
                            client.Player.PropBag.RemoveCountFromStack(itemInfo, 1);
                        }
                    }
                    client.Out.SendMessage(eMessageType.Normal, LanguageMgr.GetTranslation(translateId, new object[0]));
                }
                else
                {
                    if (itemInfo.IsValidItem())
                    {
                        client.Player.PlayerCharacter.GP += client.Player.AddGP(itemInfo.Template.Property2 * itemInfo.Count);//fix add nuoc kinh nghiem
                        if (itemInfo.Template.CanDelete)
                        {
                            client.Player.RemoveAt((eBageType)bagType, num);
                            translateId2 = "GPDanUser.Success";
                        }
                    }
                    client.Out.SendMessage(eMessageType.Normal, LanguageMgr.GetTranslation(translateId2, new object[]
                    {
                        itemInfo.Template.Property2 *itemInfo.Count
                    }));
                }
            }
            return(0);
        }
Exemple #9
0
        public int HandlePacket(GameClient client, GSPacketIn packet)
        {
            int    bagType = packet.ReadInt();
            int    place   = packet.ReadInt();
            string msg1    = null;

            ItemInfo            item     = null;
            List <ShopItemInfo> ShopItem = new List <ShopItemInfo>();

            if (client.Player.PlayerCharacter.HasBagPassword && client.Player.PlayerCharacter.IsLocked)
            {
                client.Out.SendMessage(eMessageType.Normal, LanguageMgr.GetTranslation("Bag.Locked"));
                return(0);
            }
            if (place == -1)
            {
                int templateID = packet.ReadInt();
                int type       = packet.ReadInt();
                int gold       = 0;
                int money      = 0;



                ItemTemplateInfo template = Bussiness.Managers.ItemMgr.FindItemTemplate(templateID);
                item     = ItemInfo.CreateFromTemplate(template, 1, (int)ItemAddType.Buy);
                ShopItem = Bussiness.Managers.ShopMgr.FindShopbyTemplatID(templateID);
                for (int i = 0; i < ShopItem.Count; i++)
                {
                    if (ShopItem[i].APrice1 == -1 && ShopItem[i].AValue1 != 0)
                    {
                        money          = ShopItem[i].AValue1;
                        item.ValidDate = ShopItem[i].AUnit;
                    }
                }

                if (item != null)
                {
                    // item = ItemInfo.SetItemType(item, type, ref gold, ref money, ref offer);
                    if (gold <= client.Player.PlayerCharacter.Gold && money <= client.Player.PlayerCharacter.Money)
                    {
                        client.Player.RemoveMoney(money);
                        client.Player.RemoveGold(gold);
                        LogMgr.LogMoneyAdd(LogMoneyType.Shop, LogMoneyType.Shop_Card, client.Player.PlayerCharacter.ID, money, client.Player.PlayerCharacter.Money, gold, 0, 0, "牌子编号", item.TemplateID.ToString(), type.ToString());
                        msg1 = "CardUseHandler.Success";
                    }
                    else
                    {
                        item = null;
                    }
                }
            }
            else
            {
                item = client.Player.PropBag.GetItemAt(place);
                msg1 = "CardUseHandler.Success";
            }

            if (item != null)
            {
                string msg = string.Empty;
                if (item.Template.Property1 != 21)
                {
                    AbstractBuffer buffer = BufferList.CreateBuffer(item.Template, item.ValidDate);
                    if (buffer != null)
                    {
                        buffer.Start(client.Player);
                        if (place != -1)
                        {
                            client.Player.PropBag.RemoveItem(item);
                        }
                    }
                    client.Out.SendMessage(eMessageType.Normal, LanguageMgr.GetTranslation(msg1));
                }
                else
                {
                    if (item.IsValidItem())
                    {
                        //client.Player.PlayerCharacter.GP += item.Template.Property1;
                        client.Player.AddGP(item.Template.Property2);

                        if (item.Template.CanDelete)
                        {
                            client.Player.RemoveItem(item);
                            msg = "GPDanUser.Success";
                        }
                    }
                    client.Out.SendMessage(eMessageType.Normal, LanguageMgr.GetTranslation(msg, item.Template.Property2));
                }
            }

            return(0);
        }
Exemple #10
0
    public IEnumerator RefreshAsync()
    {
        ColliderCell colliderCell = null;
        int          num;
        IEnumerator  enumerator;

        colliderCell.interrupt = false;
        BufferList <ColliderGroup> values = colliderCell.batches.Values;

        for (int i = 0; i < values.Count; i++)
        {
            ColliderGroup item = values[i];
            if (item.Count > 0)
            {
                item.Start();
            }
        }
        for (num = 0; num < values.Count && !colliderCell.interrupt; num++)
        {
            ColliderGroup colliderGroup = values[num];
            if (colliderGroup.Processing)
            {
                if (!Batching.collider_threading)
                {
                    colliderGroup.UpdateData();
                    if (colliderCell.grid.NeedsTimeout)
                    {
                        yield return(CoroutineEx.waitForEndOfFrame);

                        colliderCell.grid.ResetTimeout();
                    }
                }
                else
                {
                    enumerator = colliderGroup.UpdateDataAsync();
                    while (enumerator.MoveNext())
                    {
                        yield return(enumerator.Current);
                    }
                    colliderCell.grid.ResetTimeout();
                    enumerator = null;
                }
            }
        }
        for (num = 0; num < values.Count && !colliderCell.interrupt; num++)
        {
            ColliderGroup item1 = values[num];
            if (item1.Processing)
            {
                item1.CreateBatches();
                if (colliderCell.grid.NeedsTimeout)
                {
                    yield return(CoroutineEx.waitForEndOfFrame);

                    colliderCell.grid.ResetTimeout();
                }
            }
        }
        for (num = 0; num < values.Count && !colliderCell.interrupt; num++)
        {
            ColliderGroup colliderGroup1 = values[num];
            if (colliderGroup1.Processing)
            {
                if (!Batching.collider_threading)
                {
                    colliderGroup1.RefreshBatches();
                    if (colliderCell.grid.NeedsTimeout)
                    {
                        yield return(CoroutineEx.waitForEndOfFrame);

                        colliderCell.grid.ResetTimeout();
                    }
                }
                else
                {
                    enumerator = colliderGroup1.RefreshBatchesAsync();
                    while (enumerator.MoveNext())
                    {
                        yield return(enumerator.Current);
                    }
                    colliderCell.grid.ResetTimeout();
                    enumerator = null;
                }
            }
        }
        for (num = 0; num < values.Count && !colliderCell.interrupt; num++)
        {
            ColliderGroup item2 = values[num];
            if (item2.Processing)
            {
                for (int k = 0; k < item2.TempBatches.Count && !colliderCell.interrupt; k++)
                {
                    item2.TempBatches[k].Apply();
                    if (colliderCell.grid.NeedsTimeout)
                    {
                        yield return(CoroutineEx.waitForEndOfFrame);

                        colliderCell.grid.ResetTimeout();
                    }
                }
            }
            item2 = null;
        }
        for (int l = 0; l < values.Count && !colliderCell.interrupt; l++)
        {
            ColliderGroup colliderGroup2 = values[l];
            if (colliderGroup2.Processing)
            {
                colliderGroup2.DisplayBatches();
            }
        }
        for (int m = 0; m < values.Count; m++)
        {
            ColliderGroup item3 = values[m];
            if (item3.Processing || item3.Preserving)
            {
                item3.End();
            }
            else if (item3.Count == 0 && !colliderCell.interrupt)
            {
                item3.Clear();
                colliderCell.DestroyColliderGroup(ref item3);
                int num1 = m;
                m = num1 - 1;
                colliderCell.batches.RemoveAt(num1);
            }
        }
    }