示例#1
0
 public void RPC_GetRoleGirdByType(byte itemType, byte page, RPC.RPCForwardInfo fwd)
 {
     RPC.PackageWriter pkg = new RPC.PackageWriter();
     H_RPCRoot.smInstance.HGet_ComServer(pkg).HGet_UserRoleManager(pkg).RPC_GetRoleGirdByType(pkg, PlayerData.RoleDetail.RoleId, itemType, page);
     pkg.WaitDoCommand(IPlanesServer.Instance.ComConnect, RPC.CommandTargetType.DefaultType, null).OnFarCallFinished = delegate(RPC.PackageProxy _io, bool isTimeOut)
     {
         if (isTimeOut)
         {
             return;
         }
         RPC.PackageWriter retPkg = new RPC.PackageWriter();
         retPkg.SetSinglePkg();
         sbyte result;
         _io.Read(out result);
         retPkg.Write(result);
         if (result == (sbyte)1)
         {
             int count = 0;
             _io.Read(out count);
             retPkg.Write(count);
             for (int i = 0; i < count; i++)
             {
                 CSCommon.Data.ConsignGridData data = new CSCommon.Data.ConsignGridData();
                 _io.Read(data);
                 pkg.Write(data);
             }
         }
         retPkg.DoReturnPlanes2Client(fwd);
     };
 }
示例#2
0
 public void RPC_GetMails(RPC.RPCForwardInfo fwd)
 {
     RPC.PackageWriter pkg = new RPC.PackageWriter();
     H_RPCRoot.smInstance.HGet_ComServer(pkg).HGet_UserRoleManager(pkg).RPC_GetMails(pkg, PlayerData.RoleDetail.RoleId);
     pkg.WaitDoCommand(IPlanesServer.Instance.ComConnect, RPC.CommandTargetType.DefaultType, null).OnFarCallFinished = delegate(RPC.PackageProxy _io, bool isTimeOut)
     {
         if (isTimeOut)
         {
             return;
         }
         RPC.PackageWriter retPkg = new RPC.PackageWriter();
         retPkg.SetSinglePkg();
         List <CSCommon.Data.MailData> mails = new List <CSCommon.Data.MailData>();
         int count = 0;
         _io.Read(out count);
         retPkg.Write(count);
         for (int i = 0; i < count; i++)
         {
             CSCommon.Data.MailData mail = new CSCommon.Data.MailData();
             _io.Read(mail);
             retPkg.Write(mail);
         }
         retPkg.DoReturnPlanes2Client(fwd);
     };
 }
示例#3
0
 public void RPC_GetTeamPlayers(RPC.RPCForwardInfo fwd)
 {
     RPC.PackageWriter pkg = new RPC.PackageWriter();
     H_RPCRoot.smInstance.HGet_ComServer(pkg).HGet_UserRoleManager(pkg).RPC_GetTeamPlayers(pkg, PlayerData.RoleDetail.RoleId);
     pkg.WaitDoCommand(IPlanesServer.Instance.ComConnect, RPC.CommandTargetType.DefaultType, null).OnFarCallFinished = delegate(RPC.PackageProxy _io, bool isTimeOut)
     {
         if (isTimeOut)
         {
             return;
         }
         RPC.PackageWriter retPkg = new RPC.PackageWriter();
         retPkg.SetSinglePkg();
         sbyte result = _io.ReadSByte();
         retPkg.Write(result);
         if (result == (sbyte)CSCommon.eRet_Team.Succeed)
         {
             byte count = _io.ReadByte();
             retPkg.Write(count);
             for (byte i = 0; i < count; i++)
             {
                 RoleCom data = new RoleCom();
                 _io.Read(data);
                 retPkg.Write(data);
             }
         }
         retPkg.DoReturnPlanes2Client(fwd);
     };
 }
示例#4
0
 public static void SendMsg2Client(PlayerInstance player, CSCommon.Data.Message msg)
 {
     RPC.PackageWriter pkg = new RPC.PackageWriter();
     pkg.SetSinglePkg();
     Wuxia.H_RpcRoot.smInstance.RPC_ReceiveMsg(pkg, msg);
     pkg.DoCommandPlanes2Client(player.Planes2GateConnect, player.ClientLinkId);
 }
示例#5
0
 public void AcceptTask()
 {
     //调用客户端接受任务了
     RPC.PackageWriter pkg = new RPC.PackageWriter();
     pkg.SetSinglePkg();
     Wuxia.H_RpcRoot.smInstance.RPC_AcceptTask(pkg, this.mCurTask.TaskData);
     pkg.DoCommandPlanes2Client(this.Planes2GateConnect, this.ClientLinkId);
 }
示例#6
0
        public void RPC_GetGuilds(ulong roleId, Iocp.NetConnection connect, RPC.RPCForwardInfo fwd)
        {
            RPC.PackageWriter retPkg = new RPC.PackageWriter();
            retPkg.SetSinglePkg();
            var role = GetRole(roleId);

            if (role == null)
            {
                retPkg.Write((sbyte)CSCommon.eRet_GetGuilds.NoRole);
                retPkg.DoReturnCommand2(connect, fwd.ReturnSerialId);
                return;
            }
            if (role.RoleData.GuildId == 0)//没有帮会,返回帮会列表信息
            {
                retPkg.Write((sbyte)CSCommon.eRet_GetGuilds.ReturnGuilds);
                List <CSCommon.Data.GuildCom> guilds = new List <CSCommon.Data.GuildCom>();
                foreach (var guild in GuildManager.Instance.Guilds)
                {
                    if (guild.Value.GuildData.PlanesId == role.RoleData.PlanesId && guild.Value.GuildData.Camp == role.RoleData.Camp)
                    {
                        guilds.Add(guild.Value.GuildData);
                    }
                }

                int count = guilds.Count;
                retPkg.Write(count);
                foreach (var i in guilds)
                {
                    retPkg.Write(i);
                }
            }
            else //有帮会,返回帮会成员信息
            {
                if (role.GuildInstance == null)
                {
                    Log.Log.Guild.Print("role.GuildInstance is null {0}", role.RoleData.GuildId);
                    retPkg.Write((sbyte)CSCommon.eRet_GetGuilds.NoGuild);
                    retPkg.DoReturnCommand2(connect, fwd.ReturnSerialId);
                    return;
                }
                else
                {
                    retPkg.Write((sbyte)CSCommon.eRet_GetGuilds.ReturnGuildMembers);
                    retPkg.Write(role.GuildInstance.GuildData);
                    retPkg.Write(role.GuildInstance.Members.Count);
                    foreach (var member in role.GuildInstance.Members)
                    {
                        retPkg.Write(member.Value.RoleData);
                    }
                }
            }
            retPkg.DoReturnCommand2(connect, fwd.ReturnSerialId);
        }
示例#7
0
        public bool AutoAddItem(Item item)
        {
            //先找能堆叠的
            for (UInt16 i = 0; i < mBagSize; i++)
            {
                if (mItems[i] != null && mItems[i].ItemTemplate == item.ItemTemplate)
                {
                    if (mItems[i].StackNum >= item.MaxStackNum)
                    {
                        continue;
                    }
                    int canPut = item.MaxStackNum - mItems[i].StackNum;
                    if (item.StackNum >= canPut)
                    {
                        item.StackNum     -= canPut;
                        mItems[i].StackNum = item.MaxStackNum;
                    }
                    else
                    {
                        mItems[i].StackNum += item.StackNum;
                        item.StackNum       = 0;
                    }

                    ItemStackNumChangedToClient(mItems[i].ItemData.ItemId, (byte)InventoryType, mItems[i].StackNum);

                    if (item.StackNum <= 0)
                    {
                        item.DestroyFromDB(mHostRole);
                        return(true);
                    }
                }
            }

            for (UInt16 i = 0; i < mBagSize; i++)
            {
                if (mItems[i] == null)
                {
                    this[i] = item;

                    var player = mHostRole as PlayerInstance;
                    if (player != null)
                    {
                        RPC.PackageWriter pkg = new RPC.PackageWriter();
                        pkg.SetSinglePkg();
                        Wuxia.H_RpcRoot.smInstance.RPC_ItemAdd2Bag(pkg, item.ItemData, (byte)InventoryType, i);
                        pkg.DoCommandPlanes2Client(player.Planes2GateConnect, player.ClientLinkId);
                    }
                    OnItemsChanged();
                    return(true);
                }
            }
            return(false);
        }
示例#8
0
        protected override void OnPutItem(UInt16 index, Item item)
        {
            this[index] = item;
            var player = mHostRole as PlayerInstance;

            if (player != null)
            {
                RPC.PackageWriter pkg = new RPC.PackageWriter();
                pkg.SetSinglePkg();
                Wuxia.H_RpcRoot.smInstance.RPC_ItemAdd2Bag(pkg, item.ItemData, (byte)InventoryType, index);
                pkg.DoCommandPlanes2Client(player.Planes2GateConnect, player.ClientLinkId);
            }
        }
示例#9
0
 public void RPC_GetGuilds(RPC.RPCForwardInfo fwd)
 {
     RPC.PackageWriter pkg = new RPC.PackageWriter();
     H_RPCRoot.smInstance.HGet_ComServer(pkg).HGet_UserRoleManager(pkg).RPC_GetGuilds(pkg, PlayerData.RoleDetail.RoleId);
     pkg.WaitDoCommand(IPlanesServer.Instance.ComConnect, RPC.CommandTargetType.DefaultType, null).OnFarCallFinished = delegate(RPC.PackageProxy _io, bool isTimeOut)
     {
         if (isTimeOut)
         {
             return;
         }
         RPC.PackageWriter retPkg = new RPC.PackageWriter();
         retPkg.SetSinglePkg();
         sbyte success;
         _io.Read(out success);
         retPkg.Write(success);
         if (success == (sbyte)CSCommon.eRet_GetGuilds.ReturnGuilds)
         {
             int guildcount = 0;
             _io.Read(out guildcount);
             retPkg.Write(guildcount);
             for (int i = 0; i < guildcount; i++)
             {
                 CSCommon.Data.GuildCom guild = new CSCommon.Data.GuildCom();
                 _io.Read(guild);
                 retPkg.Write(guild);
             }
         }
         else if (success == (sbyte)CSCommon.eRet_GetGuilds.ReturnGuildMembers)
         {
             CSCommon.Data.GuildCom ownguild = new CSCommon.Data.GuildCom();
             _io.Read(ownguild);
             retPkg.Write(ownguild);
             int membercount = 0;
             _io.Read(out membercount);
             retPkg.Write(membercount);
             for (int j = 0; j < membercount; j++)
             {
                 RoleCom roleData = new RoleCom();
                 _io.Read(roleData);
                 retPkg.Write(roleData);
             }
         }
         retPkg.DoReturnPlanes2Client(fwd);
     };
 }
示例#10
0
        public void RPC_FetchCity(RPC.RPCForwardInfo fwd)
        {
            RPC.PackageWriter retPkg = new RPC.PackageWriter();
            retPkg.SetSinglePkg();
            byte succeed = 1;

            retPkg.Write(succeed);
            retPkg.Write((UInt16)1);
            for (int i = 0; i < 1; i++)
            {
                CSCommon.Data.CampForceData data = new CSCommon.Data.CampForceData();
                data.CityId  = 1;
                data.Camp    = 1;
                data.MyForce = 500;
                retPkg.Write(data);
            }
            retPkg.DoReturnPlanes2Client(fwd);
        }
示例#11
0
        public bool AddItem2Position(UInt16 pos, Item item)
        {
            if (mItems[pos] != null)
            {
                return(false);
            }
            else
            {
                this[pos] = item;

                var player = mHostRole as PlayerInstance;
                if (player != null)
                {
                    RPC.PackageWriter pkg = new RPC.PackageWriter();
                    pkg.SetSinglePkg();
                    Wuxia.H_RpcRoot.smInstance.RPC_ItemAdd2Bag(pkg, item.ItemData, (byte)InventoryType, pos);
                    pkg.DoCommandPlanes2Client(player.Planes2GateConnect, player.ClientLinkId);
                }
            }
            OnItemsChanged();
            return(true);
        }
示例#12
0
        public void RPC_GetSocialList(ulong roleId, byte type, Iocp.NetConnection connect, RPC.RPCForwardInfo fwd)
        {
            RPC.PackageWriter pkg = new RPC.PackageWriter();
            pkg.SetSinglePkg();
            var role = this.GetRole(roleId);

            if (role == null)
            {
                Log.Log.Social.Print("role is null , {0}", roleId);
                pkg.Write((sbyte)-1);
                pkg.DoReturnCommand2(connect, fwd.ReturnSerialId);
                return;
            }
            UpdateSocialInfoList((CSCommon.eSocialType)type, role);
            pkg.Write((sbyte)1);
            pkg.Write(role.mSocialInfoList.Count);
            foreach (var s in role.mSocialInfoList.Values)
            {
                pkg.Write(s);
                pkg.Write(s.socialData);
            }
            pkg.DoReturnCommand2(connect, fwd.ReturnSerialId);
        }
示例#13
0
        public void RPC_GetSocialList(byte type, RPC.RPCForwardInfo fwd)
        {
            RPC.PackageWriter pkg = new RPC.PackageWriter();
            H_RPCRoot.smInstance.HGet_ComServer(pkg).HGet_UserRoleManager(pkg).RPC_GetSocialList(pkg, this.PlayerData.RoleDetail.RoleId, type);
            pkg.WaitDoCommand(IPlanesServer.Instance.ComConnect, RPC.CommandTargetType.DefaultType, null).OnFarCallFinished = delegate(RPC.PackageProxy _io, bool bTimeOut)
            {
                RPC.PackageWriter retPkg = new RPC.PackageWriter();
                retPkg.SetSinglePkg();
                sbyte result = -1;
                _io.Read(out result);

                int count;
                if (result == -1)
                {
                    count = 0;
                    retPkg.Write(count);
                    retPkg.DoReturnPlanes2Client(fwd);
                    return;
                }
                else if (result == 1)
                {
                    _io.Read(out count);
                    retPkg.Write(count);

                    for (int i = 0; i < count; i++)
                    {
                        CSCommon.Data.SocialRoleInfo s = new CSCommon.Data.SocialRoleInfo();
                        _io.Read(s);
                        _io.Read(s.socialData);
                        retPkg.Write(s);
                        retPkg.Write(s.socialData);
                    }
                    retPkg.DoReturnPlanes2Client(fwd);
                    return;
                }
            };
        }
示例#14
0
        public void RPC_OnClientEnterMapOver(RPC.RPCForwardInfo fwd)
        {
            var retPkg = new RPC.PackageWriter();

            retPkg.SetSinglePkg();

            // 通知客户端周围玩家及NPC
            if (!mHostMap.IsNullMap)
            {
                retPkg.Write((sbyte)1);
                mHostMap.OnClientEnterMapOver(this);
                var loc = GetPosition();
                List <RoleActor> roleList = new List <RoleActor>();

                // 先同步NPC(todo: 如果同步压力过大则区分功能NPC和其他NPC进行同步,以便减小同步压力)
                //RPC.DataWriter sceneDW = new RPC.DataWriter();
                UInt32 actorTypes = (1 << (Int32)eActorGameType.Npc);// | (1<<(Int32)CSCommon.Component.EActorGameType.Player);
                mHostMap.TourRoles(ref loc, RPC.RPCNetworkMgr.Sync2ClientRange, actorTypes, this.OnTellClientNPC, roleList);
                Byte npcCount = (Byte)(roleList.Count);
                retPkg.Write(npcCount);
                foreach (NPCInstance npc in roleList)
                {
                    retPkg.Write(npc.NPCData);
                }

                // 同步玩家镜像
                roleList.Clear();
                actorTypes = (1 << (Int32)eActorGameType.PlayerImage);
                mHostMap.TourRoles(ref loc, RPC.RPCNetworkMgr.Sync2ClientRange, actorTypes, this.OnTellClientPlayer, roleList);
                Byte imageCount = (Byte)(roleList.Count);
                retPkg.Write(imageCount);
                foreach (var image in roleList)
                {
                    CSCommon.Data.RoleSyncInfo info = new CSCommon.Data.RoleSyncInfo((PlayerImage)image);
                    retPkg.Write(info);
                }

                // 再同步玩家
                roleList.Clear();
                actorTypes = (1 << (Int32)eActorGameType.Player);
                mHostMap.TourRoles(ref loc, RPC.RPCNetworkMgr.Sync2ClientRange, actorTypes, this.OnTellClientPlayer, roleList);
                Byte playerCount = (Byte)(roleList.Count - 1);//需要去掉自己
                if (playerCount < 0)
                {
                    Log.Log.Server.Error("怎么可能!至少有自己吧!");
                }
                retPkg.Write(playerCount);
                foreach (var player in roleList)
                {
                    if (player.Id == this.Id)
                    {
                        continue;
                    }

                    CSCommon.Data.RoleSyncInfo info = new CSCommon.Data.RoleSyncInfo((PlayerInstance)player);
                    retPkg.Write(info);
                }

                //RPC.DataWriter stateParamDW = new RPC.DataWriter();
                //stateParamDW.Write(this.CurrentState.Parameter, true);
            }
            else
            {
                retPkg.Write((sbyte)0);
            }


            retPkg.DoReturnPlanes2Client(fwd);
        }
示例#15
0
        public void RPC_GetRoleCreateInfo(ulong id, RPC.RPCForwardInfo fwd)
        {
            var map = this.HostMap;

            if (map == null)
            {
                return;
            }

            RPC.PackageWriter retPkg = new RPC.PackageWriter();
            retPkg.SetSinglePkg();
            var roleActor = map.GetRole(id);

            if (roleActor == null)
            {
                retPkg.Write((sbyte)eRet_GetRoleCreateInfo.NotFindActor);//找不到角色
                retPkg.DoReturnPlanes2Client(fwd);
                return;
            }
            else if (roleActor.GameType == eActorGameType.Npc)
            {
                float fdistSq = SlimDX.Vector3.DistanceSquared(this.GetPosition(), roleActor.GetPosition());
                if (fdistSq > RPC.RPCNetworkMgr.Sync2ClientRangeSq)
                {
                    retPkg.Write((sbyte)eRet_GetRoleCreateInfo.OverDistance);//距离太远
                    retPkg.DoReturnPlanes2Client(fwd);
                    return;
                }
                //这里后面还需要判断是否已经死亡,是否对玩家可见
                else
                {
                    retPkg.Write((sbyte)eRet_GetRoleCreateInfo.OK_NPC);//距离太远
                    var npc = roleActor as NPCInstance;
                    retPkg.Write(npc.NPCData);
                    retPkg.DoReturnPlanes2Client(fwd);
                    return;
                }
            }
            else if (roleActor.GameType == eActorGameType.Player)
            {
                float fdistSq = SlimDX.Vector3.DistanceSquared(this.GetPosition(), roleActor.GetPosition());
                if (fdistSq > RPC.RPCNetworkMgr.Sync2ClientRangeSq)
                {
                    retPkg.Write((sbyte)eRet_GetRoleCreateInfo.OverDistance);//距离太远
                    retPkg.DoReturnPlanes2Client(fwd);
                    return;
                }
                //这里后面还需要判断是否已经死亡,是否对玩家可见
                else
                {
                    retPkg.Write((sbyte)eRet_GetRoleCreateInfo.OK_Player);//距离太远
                    var player = roleActor as PlayerInstance;
                    CSCommon.Data.RoleSyncInfo info = new CSCommon.Data.RoleSyncInfo(player);
                    retPkg.Write(info);
                    retPkg.DoReturnPlanes2Client(fwd);
                    return;
                }
            }
            else if (roleActor.GameType == eActorGameType.PlayerImage)
            {
                retPkg.Write((sbyte)eRet_GetRoleCreateInfo.OK_PlayerImage);
                var image = roleActor as PlayerImage;
                CSCommon.Data.RoleSyncInfo info = new CSCommon.Data.RoleSyncInfo(image);
                retPkg.Write(info);
                retPkg.DoReturnPlanes2Client(fwd);
            }
        }
示例#16
0
        public void RPC_AddSocial(ulong roleId, string otherName, byte type, Iocp.NetConnection connect, RPC.RPCForwardInfo fwd)
        {
            RPC.PackageWriter pkg = new RPC.PackageWriter();
            pkg.SetSinglePkg();
            var role = this.GetRole(roleId);

            if (role == null)
            {
                Log.Log.Social.Print("role is null , {0}", roleId);
                pkg.Write((sbyte)CSCommon.eRet_AddSocial.NoRole);
                pkg.DoReturnCommand2(connect, fwd.ReturnSerialId);
                return;
            }
            var other = this.GetRole(otherName);

            if (other == null)
            {
                pkg.Write((sbyte)CSCommon.eRet_AddSocial.NoOther);
                pkg.DoReturnCommand2(connect, fwd.ReturnSerialId);
                return;
            }
            if (roleId == other.RoleData.RoleId)
            {
                pkg.Write((sbyte)CSCommon.eRet_AddSocial.RoleIsOther);
                pkg.DoReturnCommand2(connect, fwd.ReturnSerialId);
                return;
            }
            if (role.SocialManager.IsSocial(other.RoleData.RoleId, (CSCommon.eSocialType)type))
            {
                pkg.Write((sbyte)CSCommon.eRet_AddSocial.IsSocial);  //已经是这种关系
                pkg.DoReturnCommand2(connect, fwd.ReturnSerialId);
                return;
            }
            if (role.SocialManager.IsCoupleType((CSCommon.eSocialType)type))
            {
                if (false == role.SocialManager.IsSocial(other.RoleData.RoleId, CSCommon.eSocialType.Friend))
                {
                    pkg.Write((sbyte)CSCommon.eRet_AddSocial.NotFriend);//不是好友
                    pkg.DoReturnCommand2(connect, fwd.ReturnSerialId);
                    return;
                }
                //发送邀请
                CSCommon.Data.Message msg = CreateMessage(CSCommon.eMessageFrom.Social, _GetSocialMsgType((CSCommon.eSocialType)type), role.RoleData.Name, other.RoleData.RoleId);
                msg.ShowInfo = string.Format("玩家{0}请求与你成为{1}关系", role.RoleData.Name, _GetStrSocial((CSCommon.eSocialType)type));
                SendMessageToOther(other, msg);
                pkg.Write((sbyte)CSCommon.eRet_AddSocial.AskSucceed);
            }
            else
            {
                CSCommon.Data.SocialData sd = role.SocialManager.AddSocial(other.RoleData.RoleId, (CSCommon.eSocialType)type);
                if (sd == null)
                {
                    pkg.Write((sbyte)CSCommon.eRet_AddSocial.IsSocial);   //已经是这种关系
                    pkg.DoReturnCommand2(connect, fwd.ReturnSerialId);
                    return;
                }
                var info = CreateSocialRoleInfo(sd, other);
                pkg.Write((sbyte)CSCommon.eRet_AddSocial.AddSucceed);
                pkg.Write(info);
                pkg.Write(sd);

                if ((CSCommon.eSocialType)type == CSCommon.eSocialType.Friend)
                {
                    //发送消息
                    CSCommon.Data.Message msg = CreateMessage(CSCommon.eMessageFrom.Social, _GetSocialMsgType((CSCommon.eSocialType)type), role.RoleData.Name, other.RoleData.RoleId);
                    msg.ShowInfo = string.Format("玩家{0}把你加为好友", role.RoleData.Name);
                    SendMessageToOther(other, msg);
                }
            }
            pkg.DoReturnCommand2(connect, fwd.ReturnSerialId);
        }