xiaoou/hjha-server
0
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat: initial commit - HJHA game server full source

Browse Source 
6 major server modules (PdkFriendServer/GlobalSever/ServerCore/GameModule/GameNetModule) +
game logic (GameFix/GameDAL/ServerData) +
network layer (NetWorkMessage) +
data layer (ObjectModel) +
utilities (MrWu/Core/Config/CloudAPI/dll) +
adapters (zyxAdapter/base)

.NET 8.0 C# solution, 16 projects, 958 source files
This commit is contained in:
xiaoou
2026-07-07 12:02:15 +08:00
commit e9616125ce
958 changed files with 158203 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

76
NetWorkMessage/GameData/Club/ClubBlockPlayerInfo.cs Normal file
View File

@ -0,0 +1,76 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace GameData.Club
{
/// <summary>
/// 封禁玩家信息 xu add
/// </summary>
public class ClubBlockPlayerInfo
{
/// <summary>
/// 玩家Id
/// </summary>
public int UserId;
/// <summary>
/// 玩家性别 --暂时没有赋值
/// </summary>
public int Sex;
/// <summary>
/// 玩家昵称
/// </summary>
public string NickName;
/// <summary>
/// 是否允许进入游戏, 1为允许,非1为不允许
/// 保存统一，方便以后其他状态的扩展
/// </summary>
public int InGame;
/// <summary>
/// 加入时间
/// </summary>
public DateTime JoinClubDateTime;
/// <summary>
/// 加入方式 --暂时获取不到
/// </summary>
public int JoinStyle;
/// <summary>
/// 如果是邀请方式，该字段存储邀请人姓名。如果是会长邀请的该值就是 “会长”
/// --暂时获取不到
/// </summary>
public string InvitationName;
/// <summary>
/// 构造
/// </summary>
public ClubBlockPlayerInfo(){ }
}
/// <summary>
///
/// </summary>
public class LeagueClubBlockPlayerInfo : ClubBlockPlayerInfo
{
/// <summary>
///
/// </summary>
public string ClubName;
/// <summary>
///
/// </summary>
public int ClubId;
/// <summary>
///
/// </summary>
public LeagueClubBlockPlayerInfo() { }
}
}

783
NetWorkMessage/GameData/Club/ClubMatchPack.cs Normal file
View File

@ -0,0 +1,783 @@
using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using GameMessage;
namespace GameData.Club
{
/// <summary>
/// 创建比赛请求参数
/// </summary>
public class CreateClubMatchPack
{
#region 客户端赋值
/// <summary>
/// 所属竞技比赛
/// </summary>
public int ClubId;
/// <summary>
/// 比赛开始时间--只取客户端小时和分钟部分
/// </summary>
public DateTime MatchStartTime;
/// <summary>
/// 比赛名称 可以为空。
/// </summary>
public string ClubMatchName;
/// <summary>
/// 比赛结束时间
/// </summary>
public DateTime MatchEndTime;
/// <summary>
/// 比赛频率 天为单位
/// </summary>
public int MatchRate;
/// <summary>
/// 比赛淘汰分值
/// </summary>
public int DieOutNum;
/// <summary>
/// 是否自动开启下一场比赛
/// </summary>
public bool AutoOpen;
/// <summary>
/// --前多少名正数玩家自动进入下一轮比赛
/// 该值表示是否是联赛，小于0是联赛，该值存储了联赛的ClubId
/// </summary>
public int HowTopUser;
/// <summary>
/// 比赛关联的玩法 数据库这个字段用string存储 MatchPlayWayId，用逗号分隔。
/// </summary>
public List<MatchPlayWayPack> MatchPlayWays;
/// <summary>
/// 普通成员显示的桌子数量
/// </summary>
public int VisibleDesk;
/// <summary>
/// 是否只显示自己俱乐部的桌子--只有联赛才会能体现出这个设置
/// 1不是 0是显示自己俱乐部的桌子
/// </summary>
public byte isOnlyVisibleMyClub;
/// <summary>
/// 是否显示淘汰分 1显示 0不显示(默认)
/// </summary>
public byte isVisibleScoreBak;
/// <summary>
/// 每轮比赛开始积分是否清零 1请零 0不清零(默认)
/// </summary>
public byte isScoreReset;
#endregion
/// <summary>
/// 服务器返回消息，空是成功，其他是失败
/// </summary>
public string msg;
/// <summary>
/// 联赛账号，只用于展示和进入联赛时用。其他获取比赛数据不能使用
/// </summary>
public int LeagueUserNameNumber;
/// <summary>
///
/// </summary>
public CreateClubMatchPack() { }
/// <summary>
/// 校验请求
/// </summary>
/// <returns></returns>
public bool CheckData()
{
if (ClubId <= 0 || MatchStartTime == default(DateTime) || MatchRate <= 0 || MatchPlayWays == null || MatchPlayWays.Count < 1)
{
return false;
}
foreach (var item in MatchPlayWays)
{
if (!item.CheckData())
{
return false;
}
}
return true;
}
}
/// <summary>
/// 比赛玩法
/// </summary>
public class MatchPlayWayPack
{
#region 客户端赋值
/// <summary>
/// 玩法的唯一码
/// </summary>
public string weiyima;
/// <summary>
/// 最低分数限制
/// </summary>
public int MinScore;
/// <summary>
/// 桌费数值，每人消耗 AA
/// </summary>
public int DeskCost;
/// <summary>
/// 消耗方式 1AA 2大赢家
/// </summary>
public int TypeMode;
/// <summary>
/// 最低分值免收桌费，大赢家低于免消耗 AA
/// </summary>
public int MinFreeDeskCostNum;
/// <summary>
/// 是否第一局结束前解散不计房费 true是不计 false 否计算
/// </summary>
public bool IsFirstCalcDeskCost;
/// <summary>
/// 小局低于多少分解散桌子
/// </summary>
public int BuresMinScore;
/// <summary>
/// 是否开启小局低于多少分解散房间
/// </summary>
public bool IsBuresMin;
/// <summary>
/// 是否开启 解散房间按实际局数计算比赛消耗
/// </summary>
public bool IsRealCalcScore;
/// <summary>
/// 大赢家消耗规则
/// </summary>
public List<MaxWinnerScoreRange> MaxWinnerScoreRanges;
/// <summary>
/// 每次比赛联赛活跃积分,联赛使用 联盟长可以设置，群主只能看，成员不可见
/// </summary>
public decimal LeagueDeskScore;
#endregion
/// <summary>
///
/// </summary>
public MatchPlayWayPack() { }
/// <summary>
/// 校验数据
/// </summary>
/// <returns></returns>
public bool CheckData()
{
if (string.IsNullOrEmpty(weiyima) || TypeMode <= 0)
{
return false;
}
return true;
}
}
/// <summary>
/// 大赢家规则
/// </summary>
public class MaxWinnerScoreRange
{
/// <summary>
/// 主键
/// </summary>
[JsonIgnore]
public int MaxWinnerScoreRangeId;
/// <summary>
/// 玩法ID
/// </summary>
[JsonIgnore]
public int MatchPlayWayId;
#region 客户端赋值
/// <summary>
/// 大赢家积分低于多少积分，0是大赢家积分在其他区间时
/// </summary>
public int MaxWinnerMinScore;
/// <summary>
/// 消耗多少积分
/// </summary>
public int DeskScore;
#endregion
/// <summary>
///
/// </summary>
public MaxWinnerScoreRange() { }
}
/// <summary>
/// 获取俱乐部比赛玩家积分
/// </summary>
public class GetClubMatchUserScoresRequest
{
#region 客户端赋值
/// <summary>
/// 比赛Id
/// </summary>
public int ClubId;
/// <summary>
/// 比赛ID 0当前比赛
/// </summary>
public int ClubMatchId;
/// <summary>
/// 获取第几页的内容0表示首页 -1表示尾页 0表示第一页 1表示第二页
/// </summary>
public int PageIndex;
/// <summary>
/// 一页展示多少人,客户端赋值
/// </summary>
public int PageSize;
#endregion
/// <summary>
/// 最大多少页
/// </summary>
public int MaxPage;
/// <summary>
/// 玩家总数
/// </summary>
public int TotalCount;
/// <summary>
/// 玩家的分数
/// </summary>
public List<ClubMatchUserScoreResponse> Users;
/// <summary>
///
/// </summary>
public GetClubMatchUserScoresRequest() { }
}
/// <summary>
///
/// </summary>
public class ClubMatchUserScoreResponse : UserInfoUIBase
{
/// <summary>
/// 比赛分
/// </summary>
public double Score;
/// <summary>
/// 玩家提供的桌费 竞技赛活跃积分 房费/人数
/// 退赛列表界面该字段无效
/// </summary>
public double DeskScore;
/// <summary>
/// 比赛分备注
/// </summary>
public int ScoreMemo;
/// <summary>
///
/// </summary>
public ClubMatchUserScoreResponse() { }
}
/// <summary>
/// 玩家基本信息
/// </summary>
public class UserInfoUIBase
{
/// <summary>
/// 玩家Id
/// </summary>
public int UserId;
/// <summary>
/// 名字
/// </summary>
public string NickName;
/// <summary>
/// 备注
/// </summary>
public string Remark;
/// <summary>
/// 性别
/// </summary>
public int Sex;
/// <summary>
///
/// </summary>
public UserInfoUIBase() { }
}
/// <summary>
/// 个人日志，群主和玩家都要查询
/// </summary>
public class GetClubMatchScoreNotesByUserPack
{
#region 客户端赋值
/// <summary>
/// 比赛Id
/// </summary>
public int ClubId;
/// <summary>
/// 比赛ID
/// </summary>
public int ClubMatchId;
/// <summary>
/// 看谁的日志
/// </summary>
public int UserId;
#endregion
/// <summary>
/// 日志记录
/// </summary>
public List<UserScoreLog> Logs;
/// <summary>
///
/// </summary>
public GetClubMatchScoreNotesByUserPack() { }
}
/// <summary>
///
/// </summary>
public class UserScoreLog
{
/// <summary>
///
/// </summary>
public UserScoreLog() { }
/// <summary>
/// 创建时间
/// </summary>
public DateTime CreateTime;
/// <summary>
/// 类型 1游戏结算 2群主调整比赛积分 3比赛重置 4比赛结束
/// </summary>
public int TypeId;
/// <summary>
/// 输赢分
/// </summary>
public double Score;
/// <summary>
/// 这把玩家扣除的桌费--这个字段只有群主自己展示
/// </summary>
public double DeskScore;
/// <summary>
/// 积分状态
/// </summary>
public double ScoreUI;
/// <summary>
/// 获取类型字符串
/// </summary>
/// <returns></returns>
public string GetTypeMsg() {
switch (TypeId) {
case 1:
return "游戏结算";
case 2:
return "调整比赛积分";
case 3:
return "比赛重置";
case 4:
return "比赛结束";
case 5:
return "调整淘汰分";
}
return "";
}
}
/// <summary>
/// 获取比赛日志
/// </summary>
public class ClubMatchNotesPack
{
/// <summary>
///
/// </summary>
public ClubMatchNotesPack() { }
#region 客户端赋值
/// <summary>
/// 俱乐部ID
/// </summary>
public int ClubId;
/// <summary>
/// 比赛ID
/// </summary>
public int ClubMatchId;
#endregion
/// <summary>
/// 日志
/// </summary>
public List<ClubMatchNotesLog> Logs;
}
/// <summary>
/// 获取比赛日志
/// </summary>
public class ClubMatchNotesByTypePack : ClubMatchNotesPack
{
/// <summary>
/// 日志类型
/// </summary>
public MatchNotesEnum TypeId;
}
/// <summary>
///
/// </summary>
public class ClubMatchNotesLog
{
/// <summary>
///
/// </summary>
public ClubMatchNotesLog() { }
/// <summary>
/// 日志类型
/// </summary>
public MatchNotesEnum TypeId;
/// <summary>
/// 产生时间
/// </summary>
public DateTime CreateTime;
/// <summary>
/// 内容
/// </summary>
public string Content;
}
/// <summary>
/// 设置玩家比赛的分数 只有会长才有权利
/// </summary>
public class SetClubMatchUserScorePack
{
#region 客户端赋值
/// <summary>
/// 俱乐部Id 不用比赛Id，设置只能设置当前的比赛
/// </summary>
public int ClubId;
/// <summary>
/// 要修改的玩家，单个就一个值。多个就赋值多个
/// </summary>
public List<UserScorePack> userScores;
#endregion
/// <summary>
/// 空是成功，有值就是失败
/// </summary>
public string Msg;
/// <summary>
///
/// </summary>
public SetClubMatchUserScorePack() { }
}
#if Server
/// <summary>
/// 获取自己的比赛信息
/// </summary>
public class GetMyMatchScorePack
{
/// <summary>
///
/// </summary>
public GetMyMatchScorePack() { }
#region 客户端赋值
/// <summary>
/// 玩家Id
/// </summary>
public int UserId;
/// <summary>
/// 俱乐部Id
/// </summary>
public int ClubId;
#endregion
/// <summary>
/// 是否在比赛 true在比赛，，false未比赛
/// </summary>
public bool IsOpenMatch;
/// <summary>
/// 比赛积分。开始了才有值
/// </summary>
public double Score;
/// <summary>
/// 淘汰分
/// </summary>
public double ScoreBak;
/// <summary>
/// 0是联赛，有值是联赛的俱乐部Id
/// </summary>
public int LeagueClubId;
/// <summary>
/// 比赛结束时间
/// </summary>
public DateTime MatchEndTime;
/// <summary>
/// 是否显示淘汰分 1显示 0不显示(默认)
/// </summary>
public byte isVisibleScoreBak;
}
#endif
/// <summary>
/// 申请退赛
/// </summary>
public class ExitMatchPack
{
#region 客户端赋值
/// <summary>
/// 玩家Id
/// </summary>
public int UserId;
/// <summary>
/// 俱乐部Id
/// </summary>
public int ClubId;
#endregion
/// <summary>
///
/// </summary>
public ExitMatchPack() { }
}
/// <summary>
/// 获取退赛列表 --群主才有权利
/// </summary>
public class GetExitMatchUserListPack
{
#region 客户端赋值
/// <summary>
/// 俱乐部Id
/// </summary>
public int ClubId;
#endregion
/// <summary>
/// 玩家的分数
/// </summary>
public List<ClubMatchUserScoreResponse> Users;
}
/// <summary>
/// 处理退赛
/// </summary>
public class DealWithExitMatchPack : SetClubMatchUserScorePack
{
#region 客户端赋值 注意继承关系
/// <summary>
/// 是否同意退赛，True同意并要把分数设置。false取消不用设置分数
/// </summary>
public bool IsAgree;
/// <summary>
/// 是否清空淘汰分
/// </summary>
public bool IsResetScoreBak;
#endregion
/// <summary>
///
/// </summary>
public DealWithExitMatchPack() { }
}
/// <summary>
/// 关闭比赛
/// </summary>
public class CloseClubMatchPack
{
/// <summary>
///
/// </summary>
public CloseClubMatchPack() { }
#region 客户端赋值
/// <summary>
/// 俱乐部Id --只关闭当前正在比赛的比赛，不需要比赛Id
/// </summary>
public int ClubId;
#endregion
/// <summary>
/// 空是成功，有值就是失败
/// </summary>
public string Msg;
}
#if Server
/// <summary>
/// 获取比赛列表
/// </summary>
public class GetClubMathcListPack
{
#region 客户端赋值
/// <summary>
/// 俱乐部Id
/// </summary>
public int ClubId;
#endregion
/// <summary>
/// 比赛列表，只有近3天的数据
/// </summary>
public List<ClubMatchInfo> ClubMatchInfos;
}
/// <summary>
///
/// </summary>
public class ClubMatchInfo
{
/// <summary>
///
/// </summary>
public ClubMatchInfo() { }
/// <summary>
/// 比赛Id，关于比赛的参数用这个跟服务器交互
/// </summary>
public int ClubMatchId;
/// <summary>
/// 俱乐部Id
/// </summary>
public int ClubId;
/// <summary>
/// 比赛名字
/// </summary>
public string ClubMatchName;
/// <summary>
/// 比赛开始时间-
/// </summary>
public DateTime MatchStartTime;
/// <summary>
/// 比赛结束时间
/// </summary>
public DateTime MatchEndTime;
/// <summary>
/// 比赛状态1进行中 2比赛结束
/// </summary>
public int StatusFlag;
}
#endif
/// <summary>
/// 修改比赛中的玩法设置
/// </summary>
public class EditClubMatchPlayWayPack:MatchPlayWayPack
{
#region 客户端赋值
/// <summary>
/// 所属竞技比赛 组合索引I_MatchPlayWay_ClubIdClubMatchId 1
/// </summary>
public int ClubId;
#endregion
/// <summary>
/// 空成功 其他失败
/// </summary>
public string Msg;
/// <summary>
///
/// </summary>
public EditClubMatchPlayWayPack() { }
}
/// <summary>
/// 群主记录类型
/// </summary>
public enum MatchNotesEnum
{
/// <summary>
/// 基础设置变更
/// </summary>
BasicSetting = 1,
/// <summary>
/// 重赛审核
/// </summary>
CompetitionReview = 2,
/// <summary>
/// 比赛卷发放
/// </summary>
MatchScoreEdit = 3,
/// <summary>
/// 操作桌子
/// </summary>
EditDesk = 4,
/// <summary>
/// 玩法修改
/// </summary>
EditPlayWay = 5,
/// <summary>
/// 生成任务
/// </summary>
LiveTask = 6
}
}

211
NetWorkMessage/GameData/Club/ConstData.cs Normal file
View File

@ -0,0 +1,211 @@
/*
* 作者:吴隆健
* 日期: 2019-04-12
* 时间: 17:43
*
*/
using System;
using System.Collections.Generic;
namespace GameData.Club
{
/// <summary>
/// 竞技比赛常量数据
/// </summary>
public class ConstData
{
/// <summary>
/// 名称
/// </summary>
public const string CLUB_NAME = "公会";
/// <summary>
/// 竞技比赛名称最小字符数
/// </summary>
public const int minClubNameLength = 3;
/// <summary>
/// 竞技比赛名称最大字符数
/// </summary>
public const int maxClubNameLength = 8;
/// <summary>
/// 竞技比赛最大成员数量
/// </summary>
public const int maxMemNum = 1000;
/// <summary>
/// 竞技比赛最大玩法数量
/// </summary>
public const int maxplaywayNum = 100;
/// <summary>
/// 一场游戏的最大人数
/// </summary>
public const int maxGamePlayerCount = 8;
/// <summary>
/// 最大竞技比赛数量
/// </summary>
public const int maxClubNumCnt = 10;
/// <summary>
/// 我的竞技比赛最大数量
/// </summary>
public const int maxMyClubNumCnt = 5;
/// <summary>
/// 我加入的竞技比赛最大数量
/// </summary>
public const int maxJoinClubNumCnt = 5;
/// <summary>
/// 一个玩家所能获得的最大记录数量
/// </summary>
public const int maxPlayerFightRecordCount = 50;
/// <summary>
/// 创建竞技比赛所需的房卡数量
/// </summary>
public const int minRoomCardForCreateClub = 200;
/// <summary>
/// 创建竞技比赛所需的道具数量
/// </summary>
public const int minPropForCreateClub = 1;
/// <summary>
/// 最多显示消息数量
/// </summary>
public const int maxMessageCnt = 20;
/// <summary>
/// 最多显示记录的数量
/// </summary>
public const int maxrecordCnt = 20;
/// <summary>
/// 如果是重置比赛积分的比赛设置，重置比赛时候的AwardId标记
/// </summary>
public const int AwardId_CloseMatchWithResetScore = 101;
/// <summary>
/// 颁奖的时候，无需要颁奖汇总显示的标记
/// </summary>
public const int AwardId_AwardNoInHistory = 100;
/// <summary>
/// ID 小于 100 认为是要在历史汇总中显示的
/// 当前默认的需要汇总的ID
/// </summary>
public const int AwardId_Default = 99;
/// <summary>
/// 需要显示在历史中的汇总记录
/// </summary>
public const int AwardId_InHistoryCloseMatchWithResetScore = 98;
/// <summary>
///
/// </summary>
public ConstData()
{
}
}
/// <summary>
/// 俱乐部设置
/// </summary>
public static class ClubSettingConst
{
public static int JoinDeskMode_JoinDesk = 0;
public static int JoinDeskMode_CreateDesk = 1;
}
public static class ClubPlayerPositionType
{
public const int President = 0; // 会长
public const int PlaceHolder = 1; // 占位
public const int Manager = 2; // 管理员
public const int Partner = 3; // 合伙人
/// <summary>
/// 可以管理俱乐部部分功能
/// </summary>
public static bool IsManageClub(int position)
{
return position == President
|| position == Manager
|| position == Partner;
}
}
public static class ClubReadyTimeOutConfig
{
public static int DefaultReadyTimeOutSeconds = 30;
public enum KickOption
{
SystemDefault, // 系统默认
NeverKick, // 不踢出
Sec10, // 10s
Sec20, // 20s
Sec30, // 30s
Min1, // 1分钟
Min2, // 2分钟
Min3, // 3分钟
Min5 // 5分钟
}
public class KickConfig
{
public KickOption Option { get; set; }
public string Label { get; set; } // 界面显示的文字
public int TimeoutSeconds { get; set; } // 倒计时秒数（统一单位）
public KickConfig(KickOption option, string label, int timeoutSeconds)
{
Option = option;
Label = label;
TimeoutSeconds = timeoutSeconds;
}
}
// 核心映射字典
public static readonly List<KickConfig> KickSettings = new()
{
{ new KickConfig(KickOption.SystemDefault, "系统默认", 30) },
// { KickOption.NeverKick, new KickConfig("不踢出", false, false, -1) },
{ new KickConfig(KickOption.Sec10, "10s", 10) },
{ new KickConfig(KickOption.Sec20, "20s", 20) },
{ new KickConfig(KickOption.Sec30, "30s", 30) },
{ new KickConfig(KickOption.Min1, "1分钟", 60) },
{ new KickConfig(KickOption.Min2, "2分钟", 120) },
{ new KickConfig(KickOption.Min3, "3分钟", 180) },
{ new KickConfig(KickOption.Min5, "5分钟", 300) }
};
}
/// <summary>
/// 服务器客户端公用方法
/// </summary>
public static class ClubSCFunc
{
public static string GetPositionName(int position)
{
switch (position)
{
case 0:
return "会长";
case 1:
case 2:
return "管理员";
case 3:
return "合伙人";
default:
return "会员";
}
}
}
}

22
NetWorkMessage/GameData/Club/JoinDeskResult.cs Normal file
View File

@ -0,0 +1,22 @@
#if Server
namespace GameData.Club
{
public class JoinDeskResult
{
/// <summary>
/// 处理ID
/// </summary>
public long Id;
/// <summary>
/// 处理结果
/// </summary>
public int ResultCode;
/// <summary>
/// 要进入的游戏
/// </summary>
public int GameSerId;
}
}
#endif

89
NetWorkMessage/GameData/Club/PlayWay.cs Normal file
View File

@ -0,0 +1,89 @@
/*
* 作者:吴隆健
* 日期: 2019-04-11
* 时间: 11:16
*
*/
using System;
namespace GameData.Club
{
/// <summary>
/// 玩法
/// </summary>
public class PlayWay
{
/// <summary>
/// 客户端不管，服务器使用的 -没有启动的情况，叫玩家稍后再试
/// </summary>
public int enable;
/// <summary>
/// 玩法的唯一码
/// </summary>
public string weiyima;
/// <summary>
/// 所属竞技比赛
/// </summary>
public int Clubid;
/// <summary>
/// 对应的客户端游戏版本
/// </summary>
public int ver;
/// <summary>
/// 服务器gameid
/// </summary>
public int sergameid;
/// <summary>
/// 桌子规则
/// </summary>
public DeskRule dskrule;
/// <summary>
/// 修改时间
/// </summary>
public DateTime editorTime;
/// <summary>
///
/// </summary>
public PlayWay()
{
}
public PlayWay(int clubId)
{
this.Clubid = clubId;
}
public PlayWay CopyFrom(PlayWay src)
{
this.enable = src.enable;
this.weiyima = src.weiyima;
this.ver = src.ver;
this.sergameid = src.sergameid;
this.dskrule = src.dskrule;
this.editorTime = src.editorTime;
return this;
}
/// <summary>
///
/// </summary>
/// <returns></returns>
public override string ToString()
{
return string.Empty;
//return string.Format("[PlayWay Weiyima={0}, Ver={1}, Sergameid={2}, Deskcnt={3}, PlayerCnt={4}, Clubid={5}, Dskrule={6}]", weiyima, ver, sergameid, deskcnt, playerCnt, Clubid, dskrule);
}
}
}

63
NetWorkMessage/GameData/Common/AwardInfoPack.cs Normal file
View File

@ -0,0 +1,63 @@
using System;
namespace GameData
{
/// <summary>
/// 比赛的奖励信息
/// </summary>
[Serializable]
public class AwardInfoPack
{
/// <summary>
/// 奖励的游戏币 大于0的显示
/// </summary>
public int Money;
/// <summary>
/// 奖励的筹码 大于0的显示
/// </summary>
public int Coupon;
/// <summary>
/// 奖励的房卡，大于0的显示
/// </summary>
public int CarNum;
/// <summary>
/// 红包数字 大于0的显示
/// </summary>
public int RedEnvelopes;
/// <summary>
/// 参赛卷 大于0的显示
/// </summary>
public int CanSaiJuan;
/// <summary>
/// 抢位资格 大于0的显示
/// </summary>
public int SeatTv;
/// <summary>
/// 都市放心购电子券 --值是放心购卡的面值。比如20 就是放心购20元的电子券
/// </summary>
public int DSFXGVoucherNum;
/// <summary>
/// 复活卡
/// </summary>
public int FuHuoKa;
/// <summary>
/// 实物黄金
/// </summary>
public float RealGold;
/// <summary>
///
/// </summary>
public AwardInfoPack() { }
}
}

17
NetWorkMessage/GameData/Common/BindSocket.cs Normal file
View File

@ -0,0 +1,17 @@
namespace GameData
{
public class BindSocket
{
public string SeesionUUID;
/// <summary>
/// 设备信息ID
/// </summary>
public string DeviceInfoId;
/// <summary>
/// 商店类型
/// </summary>
public string StoreType;
}
}

89
NetWorkMessage/GameData/Common/CastleConfig.cs Normal file
View File

@ -0,0 +1,89 @@
#if Server
/*
* 由SharpDevelop创建。
* 用户： Administrator
* 日期: 2018-10-20
* 时间: 13:48
*
* 要改变这种模板请点击 工具|选项|代码编写|编辑标准头文件
*/
using System;
using System.Xml;
using System.Text;
using System.Collections;
using System.Collections.Generic;
namespace GameData
{
/// <summary>
/// 城堡配置 用来控制赔率
/// </summary>
public class CastleConfig
{
/// <summary>
/// 所拥有的厅id
/// </summary>
public int[] tingids;
/// <summary>
/// 房间的赔率
/// </summary>
public int peilv;
/// <summary>
/// 0金币 1比赛 2朋友
/// </summary>
public int roomMode;
/// <summary>
/// 房间的税收
/// </summary>
public int tax;
/// <summary>
/// 房间打一局获得的经验
/// </summary>
public int exp;
/// <summary>
/// 最小可进入城堡的游戏币金额
/// </summary>
public int minMoney;
/// <summary>
/// 最大可进入城堡的游戏币金额
/// </summary>
public int maxMoney;
/// <summary>
///
/// </summary>
public CastleConfig() { }
/// <summary>
///
/// </summary>
/// <returns></returns>
public override string ToString()
{
StringBuilder sb = new StringBuilder();
sb.Append("赔率:");
sb.Append(this.peilv);
sb.Append(Environment.NewLine);
sb.Append("税收:");
sb.Append(this.tax);
sb.Append(Environment.NewLine);
sb.Append("经验加成:");
sb.Append(this.exp);
sb.Append(Environment.NewLine);
sb.Append("最小可进游戏币:");
sb.Append(this.minMoney);
sb.Append(Environment.NewLine);
sb.Append("最大可进游戏币:");
sb.Append(this.maxMoney);
sb.Append(Environment.NewLine);
return base.ToString();
}
}
}
#endif

83
NetWorkMessage/GameData/Common/ChatPack.cs Normal file
View File

@ -0,0 +1,83 @@
/********************************
*
* 作者:吴隆健
* 创建时间: 2019/7/19 10:17:00
*
********************************/
using System;
namespace GameData {
/// <summary>
/// 聊天包
/// </summary>
public class ChatPack {
/// <summary>
/// 消息类型 0公聊 1私聊 100系统消息
/// </summary>
public int lx;
/// <summary>
/// 发送者的明细
/// </summary>
public string sendName;
/// <summary>
/// 消息内容
/// </summary>
public string body;
/// <summary>
///
/// </summary>
public ChatPack() { }
}
/// <summary>
/// 道具包
/// </summary>
public class PropsPack {
/// <summary>
/// 发送者userid
/// </summary>
public int sendId;
/// <summary>
/// 发送的位置，绝对位置 seat
/// </summary>
public int SendSeat;
/// <summary>
/// 接收的位置 seat
/// </summary>
public int ReciveSeat;
/// <summary>
/// 接收人的userid，userid小于0 是机器人
/// </summary>
public int ReciveUserId;
/// <summary>
/// 道具id
/// </summary>
public int PropsId;
/// <summary>
/// 几个
/// </summary>
public int Count;
/// <summary>
/// 构造
/// </summary>
public PropsPack() {
}
}
}

197
NetWorkMessage/GameData/Common/ClubBalanceConfig.cs Normal file
View File

@ -0,0 +1,197 @@
using System.Collections.Generic;
namespace GameData
{
public class ClubBalanceConfig
{
/// <summary>
/// 倍率
/// </summary>
public float BeiLv;
/// <summary>
/// 局数
/// </summary>
public int FightCnt;
/// <summary>
/// 平衡值
/// </summary>
public int BalanceValue;
}
public class ClubBalancePlayerConfig
{
public ClubBalanceConfig Config;
public int Userid;
public int Score;
}
public class AddClubBalanceConfigPack
{
public ClubBalanceConfig Config;
/// <summary>
/// 密码
/// </summary>
public string Pwd;
/// <summary>
/// 处理结果
/// </summary>
public int Result;
}
public class RemoveClubBalanceConfigPack
{
public ClubBalanceConfig Config;
public string Pwd;
public int Result;
}
public class EditorClubBalanceConfigPack
{
public ClubBalanceConfig Config;
public string Pwd;
public int Result;
}
public class GetClubBalanceConfigPack
{
public ClubBalanceConfig Config;
public string Pwd;
public List<ClubBalanceConfig> Configs;
}
public class AddBalancePlayerConfigPack
{
public int Userid;
public string Pwd;
public int Result;
}
public class RemoveBalancePlayerConfigPack
{
public int Userid;
public string Pwd;
public int Result;
}
public class EditorBalancePlayerConfigPack
{
public ClubBalanceConfig Config;
public int Userid;
public string Pwd;
public int Score;
public int Result;
}
public class GetBalancePlayerConfigPack
{
public int Userid;
public string Pwd;
public List<ClubBalancePlayerConfig> Configs;
}
public class BalanceRoomRateConfig
{
public float BeiLv;
public int FightCnt;
public int ModeType;
}
public class BalanceRoomRateItemConfig
{
/// <summary>
/// 最小值
/// </summary>
public int MinScore;
/// <summary>
/// 最大值
/// </summary>
public int MaxScore;
/// <summary>
/// 房费
/// </summary>
public int Rate;
}
public class AddRoomRateRuleConfigPack
{
public BalanceRoomRateConfig Config;
public string Pwd;
public int Result;
}
public class RemoveRoomRateRuleConfigPack
{
public BalanceRoomRateConfig Config;
public string Pwd;
public int Result;
}
public class AddRoomRateItemRuleConfigPack
{
public BalanceRoomRateConfig Config;
public int MinScore;
public int MaxScore;
public int RoomRate;
public string Pwd;
public int Result;
}
public class RemoveRoomRateItemRuleConfigPack
{
public BalanceRoomRateConfig Config;
public int MinScore;
public int MaxScore;
public int RoomRate;
public string Pwd;
public int Result;
}
public class GetRoomRateConfigPack
{
public BalanceRoomRateConfig Config;
public List<BalanceRoomRateItemConfig> Items;
public string Pwd;
}
}

37
NetWorkMessage/GameData/Common/CreateRoomPack.cs Normal file
View File

@ -0,0 +1,37 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using GameMessage;
namespace GameData
{
/// <summary>
/// 创建房间包
/// </summary>
public class CreateRoomPack
{
/// <summary>
/// 设备信息
/// </summary>
public DeviceInfo deviceInfo;
/// <summary>
/// 桌子信息
/// </summary>
public DeskInfo deskinfo;
/// <summary>
/// 是否是自动的
/// </summary>
public int isAuto;
public int ClubId;
public double Score;
public bool IsTestPack;
public long TaskId;
}
}

709
NetWorkMessage/GameData/Common/DeskInfo.cs Normal file
View File

@ -0,0 +1,709 @@
using System;
using System.Collections.Generic;
using System.Diagnostics;
using Newtonsoft.Json;
namespace GameData
{
// 如果房间半个小时未开战,如果房间开战12小时未打完,自动解散
/// <summary>
/// 房间数据
/// </summary>
public class DeskInfo
{
/// <summary>
/// 唯一码 其他模块应持有这个
/// </summary>
public string weiyima;
/// <summary>
/// 房间号 不是唯一的,同一时间运算的是唯一的 6为数房间码
/// </summary>
public string roomNum;
/// <summary>
/// 房间规则
/// </summary>
public DeskRule rule;
/// <summary>
/// 当前数量的场数 1开始
/// </summary>
public int nowCnt;
/// <summary>
/// 结束的数量
/// </summary>
public int overCnt;
/// <summary>
/// 游戏服务器的版本
/// </summary>
public int serverVer;
/// <summary>
/// 创建房间的类型 0普通开 1代开房间 5竞技比赛创建房间
/// </summary>
public int creatStyle;
/// <summary>
/// 创建房间的id 如果是普通创建的房间 则此id为玩家的userid 竞技比赛创建则为竞技比赛id
/// </summary>
public int creatUserid;
/// <summary>
/// 玩法的id
/// </summary>
public string wayid;
/// <summary>
/// 创建房间的房卡数量
/// </summary>
public int fangka;
/// <summary>
/// 玩家数据
/// </summary>
public PlayerData[] pls;
/// <summary>
/// 当前的玩家数量
/// </summary>
public int nowPlayerCnt
{
get
{
if (pls == null)
return 0;
int cnt = 0;
int len = pls.Length;
for (int i = 0; i < len; i++)
{
if (pls[i] != null)
cnt++;
}
return cnt;
}
}
/// <summary>
/// 请求解散的次数 可以补存数据库，因为不是很重要
/// </summary>
public int RequestDissolveCnt;
/// <summary>
/// 玩家座位 当前的座位编号 --里面存储的座位
/// </summary>
public int[] seat;
/// <summary>
/// 是否请求解散中
/// </summary>
public bool isDising = false;
/// <summary>
/// 解散超时时间
/// </summary>
public const int DisTimeOut = 60;
/// <summary>
/// 解散倒计时
/// </summary>
public int DisCount;
/// <summary>
/// 0表示没投票 1表示同意 -1表示拒绝->与pls 顺序一致
/// </summary>
public int[] plsDis;
/// <summary>
/// 立即开战
/// </summary>
public int[] OnceFight;
/// <summary>
/// 用来存储额外的内容
/// </summary>
public int[] Ex;
/// <summary>
/// 每局明细
/// </summary>
public List<Bureau> burs = new List<Bureau>();
/// <summary>
/// 一局打完总的结算，如果有封顶的话，里面计算好了封顶之后的分值
/// </summary>
public List<SummaryBureau> SumBurs = new List<SummaryBureau>();
/// <summary>
/// 创建时间
/// </summary>
public DateTime CreateTime;
/// <summary>
/// 是否关闭
/// </summary>
public int isClose;
/// <summary>
/// 关闭时间
/// </summary>
public DateTime closeTime;
/// <summary>
/// 解散的ID
/// </summary>
public int DisUserId = 0;
/// <summary>
/// 子游戏服务器使用,服务器数据! --此处可优化,发给客户端的数据中，可以不带此数据
/// </summary>
[JsonIgnore] public string otherdata;
/// <summary>
/// 是否未开战过
/// </summary>
public bool noWar
{
get { return overCnt == 0 && nowCnt == 0; }
}
/// <summary>
/// 是不是所有的场次都结束了
/// </summary>
public bool isAllOver
{
get
{
if (rule == null)
{
return true;
}
return rule.warCnt <= overCnt;
}
}
/// <summary>
///
/// </summary>
public DeskInfo()
{
}
/// <summary>
///
/// </summary>
/// <param name="maxCnt"></param>
public DeskInfo(int maxCnt)
{
this.rule = new DeskRule(maxCnt);
}
/// <summary>
/// 房间信息初始化创建时调用
/// </summary>s
public void Init(int ver)
{
nowCnt = 0;
overCnt = 0;
serverVer = ver;
pls = new PlayerData[rule.maxCnt];
seat = new int[rule.maxCnt];
plsDis = new int[rule.maxCnt];
OnceFight = new int[rule.maxCnt];
for (int i = 0; i < rule.maxCnt; i++)
{
seat[i] = -1;
}
CreateTime = DateTime.Now;
isClose = 0;
//年月日时分秒毫秒房间号
int rmNum = int.Parse(roomNum);
string str = "000000" + rmNum;
int len = str.Length;
str = str.Substring(len - 6);
weiyima = CreateTime.ToString("yyyyMMddHHmmssffff") + str;
}
/// <summary>
/// 开战-未战斗完毕的时间
/// </summary>
public DateTime wartimeOutDis;
/// <summary>
/// 为开战超时时间
/// </summary>
public DateTime jointimeOutDis;
#if UNITY_5_3_OR_NEWER
[JsonIgnore]
public string roomNumStr
{
get { return GetFullRoomNum(roomNum); }
}
public static string GetFullRoomNum(string roomNum)
{
if (roomNum == null)
{
roomNum = string.Empty;
}
string str = "000000" + roomNum;
return str.Substring(str.Length - 6);
}
#endif
/// <summary>
/// 检查是否需要自动解散
/// </summary>
/// <returns></returns>
public int CheckDisBank()
{
DateTime time = DateTime.Now;
if (time > wartimeOutDis)
{
//最多保留24小时
return 1; //超时未打完
}
if (noWar && time > jointimeOutDis)
{
//未开战超时
return 2; //超时未满员
}
return 0;
}
/// <summary>
/// 添加玩家
/// </summary>
/// <param name="pl"></param>
public int AddPlayer(playerData pl)
{
bool isManager = creatUserid == pl.userid && (creatStyle == 0 || creatStyle == 1);
PlayerData rpl = new PlayerData(pl, isManager);
int len = pls.Length;
for (int i = 0; i < len; i++)
{
if (pls[pl.seat] == null)
{
pls[pl.seat] = rpl;
seat[pl.seat] = pl.seat;
OnceFight[pl.seat] = 0;
return pl.seat;
}
}
for (int i = 0; i < len; i++)
{
OnceFight[i] = 0;
}
return -1;
}
/// <summary>
/// 移除玩家
/// </summary>
/// <param name="userid">userid</param>
/// <param name="pl">用户</param>
public int RemovePlayer(int userid, ref PlayerData pl)
{
int len = pls.Length;
int result = -1;
//这个len 不能改
for (int i = 0; i < len; i++)
{
if (pls[i] != null && pls[i].userid == userid)
{
//Debug.Log("移除玩家 fangzhu:" + pls[i].fangzhu);
if (pls[i].fangzhu == 0)
{
pls[i] = null;
seat[i] = -1;
pl = pls[i];
result = i;
break;
}
}
}
if (result > -1)
{
for (int i = 0; i < OnceFight.Length; i++)
{
OnceFight[i] = 0;
}
}
return result;
}
public long GetTotalScore(int seat)
{
long totalScore = 0;
foreach (var bur in burs)
{
if (bur.seat == null || bur.playScore == null) return totalScore;
for (int i = 0; i < bur.seat.Length; i++)
{
if (seat == bur.seat[i])
{
totalScore += bur.playScore[i];
}
}
}
return totalScore;
}
/// <summary>
/// 获取朋友房打完玩家最终成绩,如果有封顶，则该结果已经计算完了封顶逻辑
/// </summary>
/// <param name="seat"></param>
/// <returns></returns>
public decimal GetOverScore(int seat)
{
//Log.Debug("朋友房:" + SumBurs.Count);
if (SumBurs == null || SumBurs.Count <= 0) return 0;
var ps = SumBurs.Find(x => x.seat == seat);
if (ps == null) return 0;
return ps.Score;
}
/// <summary>
/// 创建局明细
/// </summary>
/// <returns></returns>
public Bureau CreateBureau(int idx)
{
return new Bureau(idx, new long[rule.maxCnt], seat);
}
/// <summary>
/// 压缩人数
/// </summary>
public bool CompressionPlayer()
{
int nowplcnt = nowPlayerCnt;
if (nowplcnt < 1 || nowplcnt >= rule.maxCnt)
return false;
rule.minCnt = nowplcnt;
rule.maxCnt = nowplcnt;
var oldpls = pls;
pls = new PlayerData[nowplcnt];
plsDis = new int[nowplcnt];
seat = new int[nowplcnt];
OnceFight = new int[nowplcnt];
//这里座位重新编排 数据库没有重新编排
for (int i = 0; i < nowplcnt; i++)
{
for (int j = 0; j < oldpls.Length; j++)
{
if (oldpls[j] != null)
{
pls[i] = oldpls[j];
seat[i] = i;
oldpls[j] = null;
break;
}
}
}
return true;
}
/// <summary>
///
/// </summary>
/// <returns></returns>
public override string ToString()
{
string str = "";
str += "唯一吗:" + weiyima + Environment.NewLine;
str += "房间号:" + roomNum + Environment.NewLine;
str += "服务器版本:" + serverVer + Environment.NewLine;
str += "创建类型:" + creatStyle + Environment.NewLine;
str += "创建者id:" + creatUserid + Environment.NewLine;
str += "房卡:" + fangka + Environment.NewLine;
str += "创建时间:" + CreateTime + Environment.NewLine;
str += "房间规则:" + Environment.NewLine;
str += rule.ToString() + Environment.NewLine;
int len = 0;
if (seat != null)
{
str += "玩家座位:";
len = seat.Length;
for (int i = 0; i < len; i++)
{
str += string.Format("{0}:{1} ", i, seat[i]);
}
}
str += Environment.NewLine;
len = pls.Length;
for (int i = 0; i < len; i++)
{
str += "玩家:" + i + Environment.NewLine;
if (pls[i] == null)
{
str += "该位置没有人!" + Environment.NewLine;
continue;
}
str += Environment.NewLine;
if (pls == null) continue;
str += pls[i].ToString();
}
if (burs != null && burs.Count > 0)
{
len = burs.Count;
for (int i = 0; i < len; i++)
{
str += Environment.NewLine;
str += "局数详情" + i + ":" + Environment.NewLine;
str += burs[i].ToString();
}
}
return str;
}
/// <summary>
/// 查找玩家所在的位置
/// </summary>
/// <param name="userid"></param>
/// <returns></returns>
public int FindPlayer(int userid)
{
int seat = -1;
int len = pls.Length;
for (int i = 0; i < len; i++)
{
if (pls[i] != null && pls[i].userid == userid)
{
seat = this.seat[i];
break;
}
}
return seat;
}
/// <summary>
/// 朋友房中的玩家
/// </summary>
public class PlayerData
{
/// <summary>
/// 玩家的userid
/// </summary>
public int userid;
/// <summary>
/// 玩家的昵称
/// </summary>
public string nickName;
/// <summary>
/// 玩家的性别
/// </summary>
public int sex;
/// <summary>
/// 玩家的头像
/// </summary>
public string photo;
/// <summary>
/// 玩家是否是房主
/// </summary>
public int fangzhu;
/// <summary>
/// ip
/// </summary>
public string ip;
/// <summary>
/// 玩家在哪个俱乐部，联赛用
/// </summary>
public int ClubId;
/// <summary>
///
/// </summary>
public PlayerData()
{
}
/// <summary>
///
/// </summary>
/// <param name="pl"></param>
/// <param name="isManager"></param>
public PlayerData(GameData.playerData pl, bool isManager)
{
userid = pl.userid;
nickName = pl.nickname;
sex = pl.sex;
fangzhu = isManager ? 1 : 0;
ip = pl.ip;
ClubId = pl.ClubId;
}
/// <summary>
///
/// </summary>
/// <returns></returns>
public override string ToString()
{
string str = "";
str += "玩家userid:" + userid + Environment.NewLine;
str += "昵称:" + nickName + Environment.NewLine;
str += "玩家性别:" + sex + Environment.NewLine;
str += "是否是房主:" + fangzhu + Environment.NewLine;
str += "玩家ip:" + ip + Environment.NewLine;
return str;
}
}
/// <summary>
/// 朋友房的总结算
/// </summary>
public class SummaryBureau
{
public int seat;
public decimal Score;
}
/// <summary>
/// 局明细
/// </summary>
public class Bureau
{
/// <summary>
/// 当前局
/// </summary>
public int id;
/// <summary>
/// 玩家分数
/// </summary>
public long[] playScore;
/// <summary>
/// 玩家的座位
/// </summary>
public int[] seat;
/// <summary>
///
/// </summary>
/// <param name="id">当前局的id 索引</param>
/// <param name="playScore">这一局玩家的分数</param>
/// <param name="seat">玩家的座位</param>
public Bureau(int id, long[] playScore, int[] seat)
{
this.id = id;
this.playScore = playScore;
this.seat = seat;
}
/// <summary>
///
/// </summary>
public Bureau()
{
}
/// <summary>
///
/// </summary>
/// <returns></returns>
public override string ToString()
{
string str = "";
str += "id:" + id + Environment.NewLine;
str += "score:";
int len = playScore.Length;
for (int i = 0; i < len; i++)
{
str += playScore[i] + ",";
}
str += Environment.NewLine;
str += "seat:";
for (int i = 0; i < len; i++)
{
str += seat[i] + ",";
}
return str;
}
}
/// <summary>
/// 根据解散类型获取解散备注
/// </summary>
/// <param name="style">解散类型</param>
/// <returns></returns>
public static string GetDisBankMemo(int style)
{
if(style >= 100000)
{
return "玩家解散";
}
switch (style)
{
case 0: //正常打完
return "正常打完结束";
case 1: //正常打完
return "全部打完结束";
//下面都是异常
case 2:
return "玩家解散";
case 3:
return "超时解散";
case 4:
return "超时解散";
case 5:
return "房主解散";
case 6:
return "玩法删除解散";
case 7:
return "管理员解散";
case 8:
return "积分不够解散";
case 9:
return "托管解散";
default:
return string.Empty;
}
}
}
}

101
NetWorkMessage/GameData/Common/DeskPack.cs Normal file
View File

@ -0,0 +1,101 @@
using System;
namespace GameData {
/// <summary>
/// 桌上玩家数据包
/// </summary>
public class DeskPlayerData<T> where T : playerData {
/// <summary>
/// 类型 0添加 1移除 2所有玩家数据
/// </summary>
public int style;
/// <summary>
/// 添加移除时有效
/// </summary>
public int index;
/// <summary>
/// 玩家数据 当style = 2 所有值有效 当style = 1 全部无效 当 style = 0 第一个datas[0] 有效
/// </summary>
public playerData[] datas;
/// <summary>
/// json序列化使用
/// </summary>
public DeskPlayerData() {}
}
/// <summary>
/// 玩家状态信息变化包
/// </summary>
public class PlayerStateChangePack {
/// <summary>
/// 变化的玩家座位
/// </summary>
public int seat;
/// <summary>
/// 玩家状态__DeskPlayerState
/// </summary>
public int state;
/// <summary>
///
/// </summary>
public PlayerStateChangePack() { }
/// <summary>
///
/// </summary>
/// <param name="seat">座位</param>
/// <param name="state">状态</param>
public PlayerStateChangePack(int seat,int state) {
this.seat = seat;
this.state = state;
}
}
/// <summary>
/// 托管变化包
/// </summary>
public class PlayerDePositChange
{
public int seat;
public bool isDePosit;
/// <summary>
///
/// </summary>
/// <param name="seat">座位</param>
/// <param name="isDePosit">托管状态</param>
public PlayerDePositChange(int seat,bool isDePosit) {
this.seat = seat;
this.isDePosit = isDePosit;
}
}
/// <summary>
/// 离线变化包
/// </summary>
public class OutLineChangePack
{
public int seat;
public int state;
public OutLineChangePack(int seat, int state)
{
this.seat = seat;
this.state = state;
}
public OutLineChangePack()
{
}
}
}

46
NetWorkMessage/GameData/Common/DeskPlayerState.cs Normal file
View File

@ -0,0 +1,46 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace GameData {
/// <summary>
/// 桌上玩家状态 界面刷新用,逻辑使用应该使用PlayerState 与 OutLine
/// </summary>
public enum DeskPlayerState {
/// <summary>
/// 无状态 ，不在桌上
/// </summary>
None = 0,
/// <summary>
/// 在桌上
/// </summary>
Desk = 1,
/// <summary>
/// 准备好了
/// </summary>
Ready = 2,
/// <summary>
/// 开战中
/// </summary>
War = 3,
/// <summary>
/// 托管
/// </summary>
DePosit = 4,
/// <summary>
/// 网络不稳定
/// </summary>
astable = 5,
/// <summary>
/// 离线
/// </summary>
OutLine = 6,
}
}

211
NetWorkMessage/GameData/Common/DeskRule.cs Normal file
View File

@ -0,0 +1,211 @@
using System;
using System.Diagnostics;
using System.Text;
using GameMessage;
using Newtonsoft.Json;
namespace GameData
{
/// <summary>
/// 桌子规则
/// </summary>
public class DeskRule
{
/// <summary>
/// 密码
/// </summary>
public string pwd;
/// <summary>
/// 最大玩家数量
/// </summary>
public int maxCnt;
/// <summary>
/// 最小玩家数量
/// </summary>
public int minCnt;
/// <summary>
/// 战斗场次
/// </summary>
public int warCnt;
/// <summary>
/// 游戏的服务器id
/// </summary>
public int game_serid;
/// <summary>
/// 是否拦截ip
/// </summary>
public int interceptIp;
/// <summary>
/// 地理位置拦截
/// </summary>
public int interceptpos;
/// <summary>
/// 是否拦截不是微信的账号
/// </summary>
public int interceptWeChat;
/// <summary>
/// 检查设备唯一码是否相同
/// </summary>
public int interecptimei;
/// <summary>
/// 防外挂
/// </summary>
public int fanG;
/// <summary>
/// 是否开启语音
/// </summary>
public int yuying;
/// <summary>
/// 防作弊变化是否提醒
/// </summary>
public int warn;
/// <summary>
/// 客户端拓展，只保存,服务器不处理
/// </summary>
public string[] ex;
/// <summary>
/// 是否需要换座位
/// </summary>
public bool isNeedSwapSeat;
/// <summary>
/// 赔率
/// </summary>
public float peilv;
/// <summary>
/// 房间规则
/// </summary>
public string roomrule;
/// <summary>
/// 多少数封顶，总结算的封顶（子乘倍率的,就是最后封顶输多少钱） 等于0的值就是有封顶，要不就没有封顶
/// </summary>
public int Capping;
/// <summary>
/// 玩法备注
/// </summary>
public string Remarks;
/// <summary>
/// 规则拓展
/// </summary>
public DeskRuleEx RuleEx;
[JsonIgnore]
public string RuleExStr
{
get
{
if (RuleEx == null)
{
return string.Empty;
}
return JsonPack.GetJson(RuleEx);
}
}
/// <summary>
///
/// </summary>
public DeskRule()
{
//SetCappingAndPeiLv(ex);
}
/// <summary>
///
/// </summary>
/// <param name="maxCnt"></param>
public DeskRule(int maxCnt)
{
this.maxCnt = maxCnt;
//SetCappingAndPeiLv(ex);
}
/// <summary>
/// 获取创建房间所需要的房卡
/// 一般在客户端显示的时候需要传递参数。
/// 服务器在创建房间的时候是不用填写参数，直接使用类里面的内存技术即可
/// </summary>
/// <param name="_warCnt">局数</param>
/// <param name="_maxCnt">人数</param>
/// <param name="clacCreateRoomCardNum">计算房卡的委托，自己计算</param>
/// <returns>返回所需要的房卡数量</returns>
/// <exception cref="Exception"></exception>
[Obsolete("方法作废，客户端自己计算使用了多少房卡，服务器取规则里面的房卡数量", true)]
public int GetCreateRoomCardNum(int _warCnt = 0, int _maxCnt = 0,Func<int,int,int> clacCreateRoomCardNum=null)
{
if (clacCreateRoomCardNum != null) {
return clacCreateRoomCardNum(_warCnt,_maxCnt);
}
var num = _warCnt > 0 ? _warCnt : warCnt;
var renshu = _maxCnt > 0 ? _maxCnt : maxCnt;
int result = 0;
switch (game_serid)//游戏的服务器id
{
case 42: //跑得快朋友房
case 41: //上饶打炸
result = num / 4;
break;
case 26: //窝龙
result = num / 4;
if (renshu > 4)
{
result = result * 2;
}
break;
case 45:
break;
default:
#if !Server
throw new Exception("游戏未实现创建房间需要多少张房卡" + game_serid);
#endif
break;
}
return result;
}
/// <summary>
///
/// </summary>
/// <returns></returns>
public override string ToString()
{
StringBuilder sb = new StringBuilder();
sb.AppendLine("密码" + pwd);
sb.AppendLine("最大开战人数:" + maxCnt);
sb.AppendLine("最小开战人数:" + minCnt);
sb.AppendLine("总局数:" + warCnt);
sb.AppendLine("游戏id:" + game_serid);
sb.AppendLine("是否拦截ip:" + interceptIp);
sb.AppendLine("是否拦截电脑账号:" + interceptWeChat);
sb.AppendLine("是否拦截定位:" + interceptpos);
sb.AppendLine("是否拦截设备唯一标识:" + interecptimei);
sb.AppendLine("规则:" + roomrule);
return sb.ToString();
}
}
}

229
NetWorkMessage/GameData/Common/DeskinfoPack.cs Normal file
View File

@ -0,0 +1,229 @@
/*
* 由SharpDevelop创建。
* 用户： Administrator
* 日期: 2019-03-21
* 时间: 17:26
*
* 要改变这种模板请点击 工具|选项|代码编写|编辑标准头文件
*/
using System;
using System.Collections.Generic;
namespace GameData {
/// <summary>
/// 朋友房解散信息包
/// </summary>
public class DisInfo {
/// <summary>
/// 1请求解散 2同意解散 3拒绝解散
/// </summary>
public int style;
/// <summary>
/// 谁
/// </summary>
public int userid;
/// <summary>
/// 玩家名称
/// </summary>
public string nickname;
/// <summary>
/// 自动解散剩余时间
/// </summary>
public int count;
/// <summary>
/// 是否在解散中的信息
/// </summary>
public bool isDising;
/// <summary>
/// 请求解散的次数
/// </summary>
public int requestCnt;
/// <summary>
///
/// </summary>
public DisInfo() { }
}
/// <summary>
/// 朋友房详情信息
/// </summary>
public class BurInfo {
/// <summary>
/// 0是全部信息 1是跟新信息 收到全部信息直接替换, 收到更新信息发现本地没有则添加,有则替换响应的详情信息
/// </summary>
public int style;
/// <summary>
///
/// </summary>
public BurInfo() { }
/// <summary>
/// 详情信息
/// </summary>
public List<DeskInfo.Bureau> burs = new List<DeskInfo.Bureau>();
}
/// <summary>
/// 朋友房玩家信息包 收到此包更新玩家数据
/// </summary>
public class FriendPlayersInfo {
/// <summary>
/// 0表示不提示 1表示有人离开 2表示有人加入 3座位跟换包->离开到本地拿玩家数据提示,加入拿本包数据信息提示
/// </summary>
public int style;
/// <summary>
/// 谁
/// </summary>
public int userid;
/// <summary>
/// 哪个玩家-提示用
/// </summary>
public string nickname;
/// <summary>
/// 玩家数据
/// </summary>
public DeskInfo.PlayerData[] players;
/// <summary>
/// 玩家的桌位信息
/// </summary>
public int[] seat;
/// <summary>
/// 请求解散投票数据
/// </summary>
public int[] plsDis;
/// <summary>
/// 是否立即开战
/// </summary>
public int[] onceFight;
/// <summary>
///
/// </summary>
public FriendPlayersInfo(){ }
/// <summary>
/// 获取玩家数据
/// </summary>
/// <param name="userid"></param>
/// <returns></returns>
public DeskInfo.PlayerData GetPlayer(int userid) {
if (players == null)
return null;
int len = players.Length;
for (int i = 0; i < len; i++) {
if (players[i] != null && players[i].userid == userid)
return players[i];
}
return null;
}
}
/// <summary>
/// 战斗记录数据
/// </summary>
public class FightRecordData {
/// <summary>
/// 唯一码
/// </summary>
public string weiyima;
/// <summary>
/// 第几局
/// </summary>
public int index;
/// <summary>
/// 战斗数据 回放用
/// </summary>
public FightData data;
/// <summary>
///
/// </summary>
public FightRecordData() { }
}
public class FightRecordDataNew : FightRecordData {
/// <summary>
/// 游戏服务器id
/// </summary>
public int game_serid;
/// <summary>
/// zha
/// </summary>
public DateTime Time;
public FightRecordDataNew() { }
}
/// <summary>
/// 俱乐部回放数据
/// </summary>
public class ClubFriendFightdataReponse: FightRecordData
{
/// <summary>
///
/// </summary>
public ClubFriendFightdataReponse() { }
/// <summary>
///
/// </summary>
/// <param name="data_"></param>
public ClubFriendFightdataReponse(FightRecordData data_)
{
weiyima = data_.weiyima;
index = data_.index;
data = data_.data;
}
/// <summary>
///
/// </summary>
public DeskInfo deskInfo;
}
public class ClubFriendFightdataReponseNew : FightRecordDataNew
{
/// <summary>
///
/// </summary>
public ClubFriendFightdataReponseNew() { }
/// <summary>
///
/// </summary>
/// <param name="data_"></param>
public ClubFriendFightdataReponseNew(FightRecordDataNew data_)
{
weiyima = data_.weiyima;
index = data_.index;
data = data_.data;
game_serid = data_.game_serid;
Time = data_.Time;
}
/// <summary>
///
/// </summary>
public DeskInfo deskInfo;
}
}

167
NetWorkMessage/GameData/Common/ErrorInfo.cs Normal file
View File

@ -0,0 +1,167 @@
/*
* 由SharpDevelop创建。
* 用户： Administrator
* 日期: 2019-01-25
* 时间: 15:38
*
* 要改变这种模板请点击 工具|选项|代码编写|编辑标准头文件
*/
using System;
namespace GameData
{
/// <summary>
/// 游戏信息包
/// </summary>
public class TipInfo
{
//包编号
//GamePackAgreement.pack_error
/// <summary>
/// 错误编码信息
/// </summary>
public static string[] tipInfos = new string[]{
string.Empty, //0不启用
"服务器维护中，请稍后再试!",
"请求超时！请稍后再试!",
"服务器爆满！请稍后再试!",
"房间号错误,无此房间!",
/*5*/
"进入失败!密码错误!",
"房间已开战,进入失败!",
"房间已满员,进入失败!",
"检测到相同ip账号,进入失败!",
"未获取到您的ip,进入失败!",
/*10*/
"进入失败,必须微信登录或者微信绑定才能进入此房间!",
"进入失败,必须是微信绑定的账号才能进入此房间!",
"房卡不足，创建失败!",
"数据错误,请重新登录!",
"登录过期,请重新登录!",
/*15*/
"用户名或密码为空!",
"用户名或密码错误!",
"对方不在线!",
"您在朋友房中，不能重复创建!",
"您已经在朋友房中了!",
/*20*/
"朋友房规则错误!",
"房卡不足创建失败!",
"竞技比赛名称必须是3-8个字符串组成!",
"竞技比赛名称非法!",
"创建失败!请稍后再试!",
/*25*/
"创建的竞技比赛已达上限!",
"竞技比赛公告过长!",
"竞技比赛公告包含特殊字符!",
"竞技比赛名称已被使用!",
"网络异常!",
/*30*/
"您不在此竞技比赛中!",
"您的权限不足!",
"修改失败,公告过长或有特殊字符！",
"房卡不足，充值失败!",
"充值失败！",
/*35*/
"由于管理员设置,您无法加入该游戏!",
"房卡不足加入失败！",
"发生未知错误!",
"竞技比赛房间，无法手动加入!",
"您在游戏中，无法进入仓库!",
/*40*/
"仓库密码错误!",
"您在游戏中无法进行存取金币操作",
"金币操作数额过大。",
"您的金币不足，取出失败!",
"您的游戏币超过限额，无法取出!",
/*45*/
"您的游戏币不足，存入失败!",
"您的金币不足，赠送失败!",
"操作失败,请稍后重新发起!",
"赠送的金币必须大于1！",
"金币不足，购买失败!",
/*50*/
"操作失败,请稍后再试!",
"卖出失败!",
"不能卖出身上的物品!",
"保存失败!",
"玩法已被修改或者删除！",
/*55*/
"防作弊检查,加入房间失败!",
"创建失败,未检测到ip地址!",
"暂时微信用户才可创建房间,绑定后再试!",
"防作弊房间需开启定位才可创建!",
"未获取到设备信息,请稍后再试!",
/*60*/
"超时未准备,您已被踢出房间!",
"您在别处登录游戏!",
"等级不满6级不能使用该功能!",
"密码修改失败!",
"旧密码错误!",
/*65*/
"验证码不正确",
"参数不正确，必须包含联系方式、登录名、登录密码及预留的联系信息",
"新密码格式不对!",
"房卡不足，充值失败",
"没有这个玩家，赠送失败!",
/*70*/
"没有这个用户，请检查手机号是否输入正确!",
"没有这个用户,请检查用户名是否正确！",
"该用户未绑定手机，请联系客服修改密码！",
"加入失败!",
"不存在这个房间!",
/*75*/
"解散成功!",
"已存在相同名称的战队！",
"金币不足，创建战队失败！",
"不存在该战队！",
"超时未准备，您已被踢出房间!",
/*80*/
"您当前已经在房间!",
"状态错误，操作失败!"
};
/// <summary>
/// 提示类型 0弹窗 1飞字 2飘字
/// </summary>
public int style;
/// <summary>
/// 错误编号
/// </summary>
public int infoCode;
/// <summary>
///
/// </summary>
public TipInfo(){}
/// <summary>
/// 构造函数
/// </summary>
/// <param name="style">提示类型0弹窗 1飞字 2飘字</param>
/// <param name="errCode">错误编号</param>
public TipInfo(int style,int errCode){
this.style = style;
this.infoCode = errCode;
}
/// <summary>
///
/// </summary>
/// <returns></returns>
public override string ToString()
{
string msg = null;
if (infoCode <= 0 || infoCode >= tipInfos.Length)
{
msg = "null msg";
}
else {
msg = tipInfos[infoCode];
}
return msg;
}
}
}

40
NetWorkMessage/GameData/Common/EventTrackerType.cs Normal file
View File

@ -0,0 +1,40 @@
using System.ComponentModel;
namespace GameData
{
/// <summary>
/// 事件类型
/// </summary>
public enum EventTrackerType
{
[Description("数值类型")]
Number,
[Description("字符串类型")]
String,
[Description("参数类型")]
Param
}
/// <summary>
/// 事件分类
/// </summary>
public enum EventTrackerCategory
{
[Description("客户端")]
Client,
[Description("服务器")]
Server,
}
/// <summary>
/// 事件状态
/// </summary>
public enum EventTrackerStatus
{
[Description("未激活")]
Inactive,
[Description("激活")]
Active,
}
}

121
NetWorkMessage/GameData/Common/FightData.cs Normal file
View File

@ -0,0 +1,121 @@
/*
* 由SharpDevelop创建。
* 用户： Administrator
* 日期: 2019-01-22
* 时间: 16:00
*
* 要改变这种模板请点击 工具|选项|代码编写|编辑标准头文件
*/
using System;
using System.Collections.Generic;
namespace GameData
{
/// <summary>
/// 战斗数据
/// </summary>
public class FightData
{
/// <summary>
///
/// </summary>
public FightData() { }
/// <summary>
/// 所有的战斗包 触发hand逻辑变化
/// </summary>
public List<fightdataone> fightPack = new List<fightdataone>();
}
/// <summary>
/// 一次战斗数据
/// </summary>
public class fightdataone
{
/// <summary>
/// 类型
/// </summary>
public int lx;
/// <summary>
/// 数据
/// </summary>
public string data;
}
/// <summary>
/// 房间战绩数据
/// </summary>
public class RoomFightData
{
/// <summary>
/// 玩家分数
/// </summary>
public long[] playScore;
/// <summary>
/// 玩家的座位
/// </summary>
public int[] seat;
/// <summary>
/// 战斗数据
/// </summary>
public FightData data;
/// <summary>
/// 结束类型
/// </summary>
public int style;
public RoomFightData() { }
}
public static class GetOssPath
{
/// <summary>
/// 桶名
/// </summary>
public const string BucketName8880666s = "8880666s";
/// <summary>
/// oss桶里面保存的文件夹
/// </summary>
public const string FilePaht = "RoomFight";
/// <summary>
/// 根据文件返回OSS的完整路径
/// </summary>
/// <param name="fileName">文件名</param>
/// <param name="serId">游戏服务器Id</param>
/// <param name="data">要获取哪一天的数据</param>
/// <returns></returns>
public static string GetKey(string fileName, int serId,DateTime data)
{
return $"{FilePaht}/{data.ToString("yyyyMMdd")}/{serId}/{fileName}";
}
/// <summary>
/// 获取战斗数据的文件名
/// </summary>
/// <param name="weiyima">唯一码</param>
/// <param name="idx">第几局</param>
/// <returns></returns>
public static string GetFileName(string weiyima, int idx)
{
return $"{weiyima}_{idx}.txt";
}
/// <summary>
/// 客户端获取回放战绩OSS Http地址
/// </summary>
/// <param name="weiyima">战绩唯一码</param>
/// <param name="idx">第几局</param>
/// <param name="gameServerId">服务器Id</param>
/// <param name="data">要获取哪一天的数据</param>
/// <returns></returns>
public static string GetFileHttpUrl(string weiyima, int idx, int gameServerId, DateTime data)
{
return $"https://{BucketName8880666s}.oss-cn-hangzhou.aliyuncs.com/{GetKey(GetFileName(weiyima, idx), gameServerId, data)}";
}
}
}

158
NetWorkMessage/GameData/Common/FightScore.cs Normal file
View File

@ -0,0 +1,158 @@
/*
* 作者:吴隆健
* 日期: 2019-04-22
* 时间: 16:54
*
*/
using Newtonsoft.Json;
using System;
using System.Collections.Generic;
namespace GameData
{
/// <summary>
/// 分值
/// </summary>
public class FightScore : ICloneable
{
/// <summary>
/// 数据库的id
/// </summary>
public int id;
/// <summary>
/// 竞技比赛id
/// </summary>
public int clubid;
/// <summary>
/// 玩法id
/// 从int 改为string 之前也没有使用上。
/// </summary>
public string wayid;
/// <summary>
/// 朋友房唯一码
/// </summary>
public string weiyima;
/// <summary>
/// 游戏的服务器id
/// </summary>
public int game_serid;
/// <summary>
/// 房间号
/// </summary>
public int roomnum;
/// <summary>
/// 开始时间
/// </summary>
public DateTime startTime;
/// <summary>
/// 结束时间
/// </summary>
public DateTime endTime;
/// <summary>
/// 开战次数
/// </summary>
public int warCnt;
/// <summary>
/// 打完多少盘
/// </summary>
public int overCnt;
/// <summary>
/// 耗卡数量 --xu add
/// </summary>
public int CardNum;
/// <summary>
/// 解散原因
/// </summary>
public int Style;
/// <summary>
/// 解散玩家ID
/// </summary>
public int DisUserId;
/// <summary>
/// 分值
/// </summary>
public Player[] scores;
/// <summary>
///
/// </summary>
public FightScore() { }
/// <summary>
/// 浅克隆
/// </summary>
/// <returns></returns>
public object Clone()
{
return this.MemberwiseClone();
}
/// <summary>
/// 玩家
/// </summary>
public class Player
{
/// <summary>
/// 用户唯一id
/// </summary>
public int userid;
/// <summary>
/// 名称
/// </summary>
public string name;
/// <summary>
/// 分值
/// </summary>
public decimal score;
/// <summary>
/// 玩家头像
/// </summary>
public string photo;
/// <summary>
/// 俱乐部id
/// </summary>
public int clubId;
/// <summary>
/// 俱乐部名字
/// </summary>
public string clubName;
/// <summary>
///
/// </summary>
public Player() { }
/// <summary>
///
/// </summary>
/// <param name="userid"></param>
/// <param name="name"></param>
/// <param name="score"></param>
public Player(int userid, string name, decimal score)
{
this.userid = userid;
this.name = name;
this.score = score;
}
}
}
}

170
NetWorkMessage/GameData/Common/GameConfig.cs Normal file
View File

@ -0,0 +1,170 @@
#if Server
/*
* 由SharpDevelop创建。
* 用户： Administrator
* 日期: 2018-10-20
* 时间: 16:17
*
* 要改变这种模板请点击 工具|选项|代码编写|编辑标准头文件
*/
using Newtonsoft.Json;
using System;
using System.Text;
using System.Xml;
namespace GameData
{
/// <summary>
/// Description of GameConfig.
/// </summary>
public class GameConfig
{
/// <summary>
/// 游戏的gameid
/// </summary>
public int gameid;
/// <summary>
/// 服务器版本
/// </summary>
public int serverVer;
/// <summary>
/// 客户端id
/// </summary>
public int gameClientId;
/// <summary>
/// 游戏名称
/// </summary>
public string gameName;
/// <summary>
/// 最大的玩家数量
/// </summary>
public int maxPlayer;
/// <summary>
/// 是否打开朋友房
/// </summary>
public int OpenFriendRoom;
/// <summary>
/// 是否开启金币模式
/// </summary>
public int OpenGlod;
/// <summary>
/// 城堡配置 没城堡表示没有金币场
/// </summary>
public CastleConfig[] castles;
/// <summary>
/// 厅配置
/// </summary>
public TingConfig[] tings;
/// <summary>
/// 游戏模式 0普通模式 1百家乐模式 2休闲模式
/// </summary>
public int gameMode;
/// <summary>
/// 游戏规则-游戏通用规则,长度为50
/// </summary>
public string gameGz;
/// <summary>
/// 游戏类型 0是牌类 1是麻将类
/// </summary>
public int style;
/// <summary>
/// 开放平台 0表示所有 1表示pc 2表示手机
/// </summary>
public int plat;
/// <summary>
/// 排序数字
/// </summary>
public int sortNum;
/// <summary>
/// 游戏图片
/// </summary>
public int imgNum;
/// <summary>
/// 活动状态
/// </summary>
public int activezt;
/// <summary>
/// 游戏配置
/// </summary>
public GameConfig() { }
/// <summary>
///
/// </summary>
/// <returns></returns>
public override string ToString()
{
StringBuilder sb = new StringBuilder();
sb.AppendLine("gameid:" + this.gameid);
sb.AppendLine("gameClientId:" + this.gameClientId);
sb.AppendLine("gameName:" + this.gameName);
sb.AppendLine("maxPlayer:" + this.maxPlayer);
sb.AppendLine("OpenFriendRoom:" + this.OpenFriendRoom);
sb.AppendLine("OpenGlod:" + OpenGlod);
if (castles == null)
sb.AppendLine("castles is null");
else
{
int len = castles.Length;
for (int i = 0; i < len; i++)
{
sb.Append("castles " + i + ":" + System.Environment.NewLine + "," + castles[i].ToString());
}
}
if (tings == null)
{
sb.AppendLine("tings is null");
}
else
{
int len = tings.Length;
for (int i = 0; i < len; i++)
{
sb.Append("tings " + i + ":" + System.Environment.NewLine + "," + tings[i].ToString());
}
}
sb.AppendLine("gameMode:" + gameMode);
sb.AppendLine("style:" + style);
sb.AppendLine("gameGz:" + gameGz);
sb.AppendLine("plat:" + plat);
sb.AppendLine("sortNum:" + sortNum);
sb.AppendLine("imgNum:" + imgNum);
sb.AppendLine("activezt:" + activezt);
return sb.ToString();
}
}
}
#endif

70
NetWorkMessage/GameData/Common/GameLoginPack.cs Normal file
View File

@ -0,0 +1,70 @@
/*
* 由SharpDevelop创建。
* 用户： Administrator
* 日期: 2019-01-27
* 时间: 14:03
*
* 要改变这种模板请点击 工具|选项|代码编写|编辑标准头文件
*/
using System;
using System.Text;
namespace GameData
{
/// <summary>
/// 进入桌子包
/// </summary>
public class InDeskPack{
/// <summary>
/// 进入的房间编号
/// </summary>
public int roomid;
/// <summary>
/// 进入的厅编号
/// </summary>
public int tingid;
/// <summary>
/// 进入的桌子编号 >=0 表示进入指定房间
/// </summary>
public int deskid;
/// <summary>
///
/// </summary>
public InDeskPack(){}
/// <summary>
///
/// </summary>
/// <param name="roomid"></param>
/// <param name="tingid"></param>
/// <param name="deskid"></param>
public InDeskPack(int roomid,int tingid,int deskid){
this.roomid = roomid;
this.tingid = tingid;
this.deskid = deskid;
}
/// <summary>
///
/// </summary>
/// <returns></returns>
public override string ToString()
{
StringBuilder sb = new StringBuilder();
sb.Append("roomid:");
sb.Append(roomid);
sb.Append(Environment.NewLine);
sb.Append("tingid:");
sb.Append(tingid);
sb.Append(Environment.NewLine);
sb.Append("deskid:");
sb.Append(deskid);
sb.Append(Environment.NewLine);
return sb.ToString();
}
}
}

79
NetWorkMessage/GameData/Common/GameNode.cs Normal file
View File

@ -0,0 +1,79 @@
/********************************
*
* 作者:吴隆健
* 创建时间: 2019/7/8 13:26:08
*
********************************/
using System;
namespace GameData {
/// <summary>
/// 服务器节点
/// </summary>
//[ProtoBuf.ProtoContract]
#pragma warning disable CS0659 // 类型重写 Object.Equals(object o)，但不重写 Object.GetHashCode()
public class ServerNode {
#pragma warning restore CS0659 // 类型重写 Object.Equals(object o)，但不重写 Object.GetHashCode()
/// <summary>
/// 模块id 大系统的编号
/// </summary>
//[ProtoBuf.ProtoMember(1)]
public int id;
/// <summary>
/// 节点编号 集群中的编号
/// </summary>
//[ProtoBuf.ProtoMember(2)]
public int nodeNum;
/// <summary>
/// 是否暂停
/// </summary>
//[ProtoBuf.ProtoMember(3)]
public bool ispause = false;
/// <summary>
///
/// </summary>
public ServerNode() {
}
/// <summary>
///
/// </summary>
/// <param name="moduleId"></param>
/// <param name="nodeNum"></param>
public ServerNode(int moduleId, int nodeNum) {
this.id = moduleId;
this.nodeNum = nodeNum;
}
/// <summary>
/// 比较数据是否相同
/// </summary>
/// <param name="obj"></param>
/// <returns></returns>
public override bool Equals(object obj) {
if (obj == null)
return false;
ServerNode node = obj as ServerNode;
if (node == null)
return false;
return node.id == this.id && node.nodeNum == this.nodeNum&&node.ispause ==this.ispause;
}
/// <summary>
///
/// </summary>
/// <returns></returns>
public override string ToString() {
if (ispause)
return "id:" + id + ",nodeNum:" + nodeNum + ",暂停";
else
return "id:" + id + ",nodeNum:" + nodeNum;
}
}
}

41
NetWorkMessage/GameData/Common/JoinRoom.cs Normal file
View File

@ -0,0 +1,41 @@
using GameMessage;
namespace GameData
{
/// <summary>
/// 进入房间包
/// </summary>
public class JoinRoom {
/// <summary>
/// 房间号
/// </summary>
public string roomNum;
/// <summary>
/// 密码
/// </summary>
public string pwd;
/// <summary>
/// 设备信息
/// </summary>
public DeviceInfo deviceinfo;
/// <summary>
///
/// </summary>
public JoinRoom() {
}
/// <summary>
///
/// </summary>
/// <param name="roomNum"></param>
/// <param name="pwd"></param>
public JoinRoom(string roomNum, string pwd) {
this.roomNum = roomNum;
this.pwd = pwd;
}
}
}

402
NetWorkMessage/GameData/Common/JsonPack.cs Normal file
View File

@ -0,0 +1,402 @@
/*
* 由SharpDevelop创建。
* 用户： 吴隆健
* 日期: 2018-04-02
* 时间: 10:55
*
* 要改变这种模板请点击 工具|选项|代码编写|编辑标准头文件
*/
using System;
using Newtonsoft.Json;
using System.Text;
using System.Security.Cryptography;
namespace GameData
{
/// <summary>
/// Description of JsonPack.
/// </summary>
public static class JsonPack
{
/// <summary>
/// 秘钥
/// </summary>
public const string key = "asnfkjahsfjabnslkd";
/// <summary>
/// JSon 序列化是否包含默认值
/// </summary>
public static bool IsHaveDefault = true;
/// <summary>
/// MD5加密
/// </summary>
/// <param name="text"></param>
/// <returns></returns>
public static string ENCRYMD5(string text)
{
byte[] data = Encoding.UTF8.GetBytes(text);
MD5 md5 = new MD5CryptoServiceProvider();
byte[] output = md5.ComputeHash(data);
return BitConverter.ToString(output).Replace("-", "");
}
/// <summary>
/// 获取Json数据
/// </summary>
/// <param name="data"></param>
/// <returns></returns>
public static string GetJson(Object data)
{
JsonSerializerSettings jsonset = new JsonSerializerSettings();
jsonset.DefaultValueHandling = DefaultValueHandling.Ignore;
return IsHaveDefault ? JsonConvert.SerializeObject(data, jsonset) : JsonConvert.SerializeObject(data);
}
/// <summary>
/// 获取Json数据
/// </summary>
/// <param name="data"></param>
/// <param name="jsonSet"></param>
/// <returns></returns>
public static string GetJson(Object data, JsonSerializerSettings jsonSet)
{
return IsHaveDefault ? JsonConvert.SerializeObject(data, jsonSet) : JsonConvert.SerializeObject(data);
}
public static string GetJsonNoIgnore(Object data) {
return JsonConvert.SerializeObject(data);
}
/// <summary>
/// 获取数据
/// </summary>
/// <param name="jsonData"></param>
/// <returns></returns>
public static T GetData<T>(string jsonData)
{
// JsonSerializerSettings jsonset = new JsonSerializerSettings();
// jsonset.DefaultValueHandling = DefaultValueHandling.IgnoreAndPopulate;
#pragma warning disable CS0168 // 声明了变量，但从未使用过
try
{
return JsonConvert.DeserializeObject<T>(jsonData);
}
catch (Exception e)
{
return default(T);
}
#pragma warning restore CS0168 // 声明了变量，但从未使用过
}
public static T GetData<T>(string jsonData, JsonSerializerSettings jsonSet)
{
#pragma warning disable CS0168 // 声明了变量，但从未使用过
try
{
return JsonConvert.DeserializeObject<T>(jsonData, jsonSet);
}
catch (Exception e)
{
return default(T);
}
#pragma warning restore CS0168 // 声明了变量，但从未使用过
}
/// <summary>
/// 获取包裹的json数据
/// </summary>
/// <param name="head">包头</param>
/// <param name="data">数据</param>
/// <param name="md5">md5</param>
/// <returns></returns>
public static string GetJsonByPack<T>(T head, System.Object data, bool md5 = false) where T : PackHead
{
string jsonHead = string.Empty, jsondata = string.Empty;
if (head != null)
jsonHead = GetJson(head);
if (data != null)
jsondata = GetJson(data);
string msg = jsonHead + jsondata;
int headlen = jsonHead.Length;
int datalen = jsondata.Length;
if (md5)
{
string encryStr = msg;
if (head.clientVer > 1)
encryStr = encryStr + key;
if (msg != null)
msg += ENCRYMD5(encryStr);
datalen += 32;
}
return IntToStr16(jsonHead.Length) + IntToStr16(jsondata.Length) + msg;
}
/// <summary>
/// 获取包裹的json数据
/// </summary>
/// <param name="head">包头</param>
/// <param name="messagedata">数据</param>
/// <param name="md5">md5</param>
/// <returns></returns>
public static string GetJsonByPack_head<T>(T head, string messagedata, bool md5 = false) where T : PackHead
{
string jsonHead = string.Empty;
string jsondata = messagedata;
if (head != null)
jsonHead = GetJson(head);
if (jsondata == null)
jsondata = string.Empty;
string msg = jsonHead + jsondata;
int headlen = jsonHead.Length;
int datalen = jsondata.Length;
if (md5)
{
string encryStr = msg;
if (head.clientVer > 1)
encryStr = encryStr + key;
if (msg != null)
msg += ENCRYMD5(encryStr);
datalen += 32;
}
return IntToStr16(jsonHead.Length) + IntToStr16(jsondata.Length) + msg;
}
/// <summary>
/// 获取包裹的json数据base64字符串类型
/// </summary>
/// <param name="head">包头数据</param>
/// <param name="data">包数据</param>
/// <param name="md5">md5加签</param>
/// <returns></returns>
public static string GetJsonByPackBase64<T>(T head, System.Object data, bool md5 = false) where T : PackHead
{
string str = GetJsonByPack(head, data, md5);
return GetBase64(str);
}
/// <summary>
/// 获取报复哦的json数据base64字符串类型
/// </summary>
/// <param name="head">包头数据</param>
/// <param name="messagedata">包数据</param>
/// <param name="md5">md5加签</param>
/// <returns></returns>
public static string GetJsonByPackBase64_head<T>(T head, string messagedata, bool md5 = false) where T : PackHead
{
string str = GetJsonByPack_head(head, messagedata, md5);
return GetBase64(str);
}
/// <summary>
/// 转换成base64
/// </summary>
/// <param name="jsonpack"></param>
/// <returns></returns>
public static string GetBase64(string jsonpack)
{
byte[] data = System.Text.Encoding.UTF8.GetBytes(jsonpack);
return Convert.ToBase64String(data);
}
/// <summary>
/// 把base64转换成普通字符串
/// </summary>
/// <param name="jsonpack64"></param>
/// <returns></returns>
public static string GetStringByBase64(string jsonpack64)
{
byte[] data = Convert.FromBase64String(jsonpack64);
return System.Text.Encoding.UTF8.GetString(data);
}
private static bool CheckMD5(string jsondata, bool isCheck)
{
if (!isCheck)
return true;
if (jsondata == null || jsondata.Length < 48)
return false;
int len = jsondata.Length;
int idx = len - 32;
string md5str = jsondata.Substring(idx);
string datastr = jsondata.Substring(0, len - 32);
datastr = datastr.Substring(16);
if (md5str == null)
return false;
datastr += key;
string newmd5str = ENCRYMD5(datastr).ToLower();
return md5str.ToLower() == newmd5str;
}
/// <summary>
/// 获取json的包数据
/// </summary>
/// <param name="jsonstring">json字符串</param>
/// <param name="head">包头数据</param>
/// <param name="data">包数据</param>
/// <param name="md5">是否md5验证</param>
/// <returns>是否验证通过</returns>
public static bool GetPackByJson<T, K>(string jsonstring, out K head, out T data, bool md5 = false) where K : PackHead
{
int startIdx = 0;
int len = 8;
string len1 = jsonstring.Substring(startIdx, len);//包头长度
startIdx += len;
string len2 = jsonstring.Substring(startIdx, len);//包数据长度
startIdx += len;
len = Str16ToInt(len1);
head = GetData<K>(jsonstring.Substring(startIdx, len));
startIdx += len;
len = Str16ToInt(len2);
data = GetData<T>(jsonstring.Substring(startIdx, len));
startIdx += len;
if (md5)
{
return CheckMD5(jsonstring, head.clientVer > 1);
}
return true;
}
/// <summary>
/// 获取json数据包
/// </summary>
/// <param name="jsonstring">base64json字符创</param>
/// <param name="head">包头</param>
/// <param name="data">包数据</param>
/// <param name="md5">是否md5验证</param>
public static bool GetPackByJsonBase64<T, K>(string jsonstring, out K head, out T data, bool md5 = false) where K : PackHead
{
jsonstring = GetStringByBase64(jsonstring);
return GetPackByJson<T, K>(jsonstring, out head, out data, md5);
}
/// <summary>
/// 获取包数据
/// </summary>
/// <returns>包数据</returns>
/// <param name="jsonstring">json字符串</param>
/// <typeparam name="T">获取的包数据类型</typeparam>
public static T GetPackData<T>(string jsonstring)
{
return GetData<T>(jsonstring);
}
/// <summary>
/// 字符转Ushort数据
/// </summary>
/// <param name="strs"></param>
/// <returns></returns>
public static int Str16ToInt(string strs)
{
return Convert.ToInt32(strs, 16);
}
/// <summary>
/// 把int转成16进制字符串
/// </summary>
/// <returns></returns>
public static string IntToStr16(int num)
{
string str16 = Convert.ToString(num, 16);
string tmp = "";
for (int i = str16.Length; i < 8; i++)
{
tmp += "0";
}
return tmp + str16;
}
/// <summary>
/// 获取包头
/// </summary>
/// <param name="jsonpack">包体</param>
/// <param name="head">包头</param>
/// <param name="md5">是否md5验证</param>
public static string GetPackBase64Head<T>(string jsonpack, out T head, bool md5 = false) where T : PackHead
{
jsonpack = GetStringByBase64(jsonpack);
int startIdx = 0;
int len = 8;
string len1 = jsonpack.Substring(startIdx, len);//包头长度
startIdx += len;
string len2 = jsonpack.Substring(startIdx, len);//包数据长度
startIdx += len;
len = Str16ToInt(len1);
head = GetData<T>(jsonpack.Substring(startIdx, len));
startIdx += len;
len = Str16ToInt(len2);
if (md5)
{
if (!CheckMD5(jsonpack, head.clientVer > 1))
return null;
}
return jsonpack.Substring(startIdx, len);
}
/// <summary>
/// 获取包头
/// </summary>
/// <param name="jsonpack"></param>
/// <param name="head"></param>
/// <param name="md5"></param>
/// <returns></returns>
public static string GetPackHead<T>(string jsonpack, out T head, bool md5 = false) where T : PackHead
{
int startIdx = 0;
int len = 8;
string len1 = jsonpack.Substring(startIdx, len);//包头长度
startIdx += len;
string len2 = jsonpack.Substring(startIdx, len);//包数据长度
startIdx += len;
len = Str16ToInt(len1);
head = GetData<T>(jsonpack.Substring(startIdx, len));
startIdx += len;
len = Str16ToInt(len2);
if (md5)
{
if (!CheckMD5(jsonpack, head.clientVer > 1))
return null;
}
return jsonpack.Substring(startIdx, len);
}
}
}

84
NetWorkMessage/GameData/Common/MessageData.cs Normal file
View File

@ -0,0 +1,84 @@
using System;
using System.Text;
namespace GameData{
/// <summary>
/// 消息数据
/// </summary>
public class MessageData {
/// <summary>
/// 0 全服喊话 1单游喊话 2全桌喊话 3全竞技比赛喊话(clubid) 4私聊(userid)
/// </summary>
public int msgStyle;
/// <summary>
/// 当是竞技比赛喊话时 是竞技比赛id 当是私聊时 是玩家userid
/// </summary>
public int serverid;
/// <summary>
/// 文本内容
/// </summary>
public string context;
/// <summary>
/// 发送者userid
/// </summary>
public int receiveId;
/// <summary>
/// 发送者昵称
/// </summary>
public string receiveNickName;
/// <summary>
/// 发送者经验
/// </summary>
public int receiveExp;
/// <summary>
///
/// </summary>
public MessageData() { }
/// <summary>
///
/// </summary>
/// <param name="msgStyle"></param>
/// <param name="context"></param>
/// <param name="serverid"></param>
public MessageData(int msgStyle,string context,int serverid) {
this.msgStyle = msgStyle;
this.context = context;
this.serverid = serverid;
}
/// <summary>
///
/// </summary>
/// <returns></returns>
public override string ToString() {
StringBuilder sb = new StringBuilder();
sb.Append("msgSty: ");
sb.Append(msgStyle);
sb.Append(Environment.NewLine);
sb.Append("context:");
sb.Append(context);
sb.Append(Environment.NewLine);
sb.Append("serverid:");
sb.Append(serverid);
sb.Append(Environment.NewLine);
sb.Append("receiveId:");
sb.Append(receiveId);
sb.Append(Environment.NewLine);
sb.Append("receiveNickName:");
sb.Append(receiveNickName);
sb.Append(Environment.NewLine);
sb.Append("receiveExp:");
sb.Append(receiveExp);
return sb.ToString();
}
}
}

2236
NetWorkMessage/GameData/Common/PackAgreement.cs Normal file
View File

@ -0,0 +1,2236 @@
/*
* 由SharpDevelop创建。
* 用户： Administrator
* 日期: 2018-09-18
* 时间: 13:38
*
* 要改变这种模板请点击 工具|选项|代码编写|编辑标准头文件
*/
using System;
using System.Runtime.CompilerServices;
using System.Security.Policy;
namespace GameData
{
/// <summary>
/// 包裹协议常量 小于0 是内部消息 0-9999是发送给客户端(注意别与子游戏重叠了) 小于10000 万位以上表示模块号 发送给那个模块
/// </summary>
public class GamePackAgreement
{
/// <summary>
/// 错误提示包
/// </summary>
public const int pack_error = 1;
/// <summary>
/// 进入游戏信息 玩家收到此包就去自动登录
/// </summary>
public const int InGameInfo = 2;
/// <summary>
/// 场景切换
/// </summary>
public const int SceneChange = 3;
/// <summary>
/// 玩家信息包
/// </summary>
public const int playerInfo = 4;
/// <summary>
/// 游戏断开包
/// </summary>
public const int GameDisConnection = 5;
/// <summary>
/// 游戏币超过上限
/// </summary>
public const int MoneyUpper = 6;
/// <summary>
/// 文字型消息提示
/// </summary>
public const int autoTipInfo = 7;
/// <summary>
/// 升级提示
/// </summary>
public const int MandatoryUpdate = 8;
/// <summary>
/// ping 包
/// </summary>
public const int SocketPing = 9;
/// <summary>
/// 叫玩家去重连游戏,当玩家没在游戏中时
/// </summary>
public const int ReConnection = 10;
/// <summary>
///
/// </summary>
public const int UpdateSocketCryptKey = 11;
#region TestModule 2
/// <summary>
///
/// </summary>
//public const int serverinfo = 20001;
#endregion
#region SocketModule 3
/// <summary>
/// socket注册
/// </summary>
public const int registeredSocket = 30001;
/// <summary>
/// 玩家离线包
/// </summary>
public const int closeSocket = 30002;
/// <summary>
/// 如果有人在线，强行登陆挤对方下线
/// </summary>
public const int PushLogin = 30003;
/// <summary>
/// 强制下线
/// </summary>
//public const int ForceOffLine = 30004;
/// <summary>
/// 继续登陆
/// </summary>
//public const int GoLogin = 30005;
/// <summary>
/// 心跳包
/// </summary>
public const int Heartbeat = 30006;
/// <summary>
/// 连接Socket成功通知玩家
/// </summary>
public const int connecOk = 30007;
#pragma warning disable CS1587 // XML 注释没有放在有效语言元素上
/// <summary>
/// 断开链接通知其他模块
/// </summary>
//public const int DisConnection = 30008;
/// <summary>
/// 中转包
/// </summary>
public const int TransFerPack = 30009;
#pragma warning restore CS1587 // XML 注释没有放在有效语言元素上
// <summary>
// 发送给任意游戏模块处理
// </summary>
//public const int EveryGame = 30010;
/// <summary>
/// 处理玩家之间的消息转发
/// </summary>
public const int DoMessgae = 30011;
/// <summary>
/// 获取玩家所在游戏的信息
/// </summary>
public const int GetPlayerGameInfo = 30012;
#endregion
#if Server
#region HttpMpdule 4
/// <summary>
/// 中转包
/// </summary>
public const int TransFerHttp = 40001;
/// <summary>
/// get方法
/// </summary>
public const int getforHttp = 40002;
/// <summary>
/// 检查身份
/// </summary>
public const int CheckIdentity = 40003;
/// <summary>
/// 上传游戏配置
/// </summary>
public const int UploadGameConfig = 40004;
#endregion
#region LoginModule 5
/// <summary>
/// 游戏登录包
/// </summary>
public const int gameLogin = 50001;
/// <summary>
/// 用户注册包
/// </summary>
//public const int userRegistered = 50002;
/// <summary>
/// 用户名检测包
/// </summary>
public const int userNickName = 50003;
/// <summary>
/// 游戏登录成功
/// </summary>
public const int gameLoginOk = 50004;
/// <summary>
/// http测试
/// </summary>
public const int httpTest = 50005;
/// <summary>
/// 获取用户信息...测试用
/// </summary>
public const int GetUserInfo = 50006;
/// <summary>
/// 修改密码
/// </summary>
public const int EditorPwd = 50007;
/// <summary>
/// 更新玩家信息
/// </summary>
public const int UpdatePlayerInfo = 50008;
/// <summary>
/// 登陆慢
/// </summary>
public const int loginslow = 50009;
/// <summary>
/// 绑定玩家手机号码 过时
/// </summary>
//public const int BindPlayerPhone = 50010;
/// <summary>
/// 检查是否绑定过手机号码
/// </summary>
//public const int IsBindPlayerPhone = 50011;
/// <summary>
/// 新版微信登录，登录带unionId
/// </summary>
//public const int xcxGameLogin = 50012;
/// <summary>
/// 登录包
/// </summary>
public const int LoginVer1 = 50013;
/// <summary>
/// 绑定玩家联系方式
/// </summary>
public const int BindPlayerContactInfo = 50020;
/// <summary>
/// 玩家获取验证码 过时
/// </summary>
//public const int GetPlayerVerifyCode = 50021;
/// <summary>
/// 玩家获取验证码后重置密码 过时
/// </summary>
//public const int ResetPlayerPasswordByVerifyCode = 50022;
/// <summary>
/// 手机号登陆
/// </summary>
//public const int PhoneLogin = 50023;
/// <summary>
/// 重置密码
/// </summary>
//public const int ResetPlayerPasswordByVerifyCodeNew = 50024;
/// <summary>
/// 获取验证码新方式
/// </summary>
//public const int GetPlayerVerifyCodeNew = 50025;
/// <summary>
/// 绑定手机号
/// </summary>
//public const int BindPlayerPhoneNew = 50026;
/// <summary>
/// 防沉迷认证
/// </summary>
public const int AntiAddictionCertification = 50027;
/// <summary>
/// 获取防沉迷验证码
/// </summary>
//public const int GetVerifyCodeByAntiAddiction = 50028;
/// <summary>
/// 设置微信unionid 和userid 的关系
/// </summary>
public const int SetUnionIdAndUserId = 50029;
/// <summary>
/// 获取微信小游戏Token
/// </summary>
public const int GetMiniGameToken = 50030;
/// <summary>
/// 申请注销
/// </summary>
public const int RequestLogout = 50031;
//ServerDashboardPackAgreement.cs 中已定义 50100 至 50200
#endregion
#endif
#region ConfigManager
/// <summary>
/// 所有的服务器信息
/// </summary>
public const int AllServerInfo = 60001;
///// <summary>
///// Socket链接信息
///// </summary>
//public const int SocketConnecInfo = 60002;
///// <summary>
///// 获取游戏信息
///// </summary>
//public const int GameConfigInfo = 60003;
/// <summary>
/// 获取pc版本号
/// </summary>
public const int GET_PC_VERSION = 60004;
/// <summary>
/// 获取pc版本测试号
/// </summary>
public const int GET_PC_VERSION_CE = 60005;
/// <summary>
/// 获取自定义版本信息
/// </summary>
public const int GetCustomizeVer = 60006;
/// <summary>
/// 兑换码兑换
/// </summary>
public const int HotDuiHuang = 60007;
/// <summary>
/// 兑换码
/// </summary>
public const int duihuanHot = 60008;
/// <summary>
/// 获取玩家地址
/// </summary>
public const int getplayerAddress = 60009;
/// <summary>
/// 获取商品信息
/// </summary>
public const int getcommdity = 60010;
/// <summary>
/// 获取兑换记录
/// </summary>
public const int GETMALLRECORD = 60011;
/// <summary>
/// 购买商品
/// </summary>
public const int MALLCOMMDITY = 60012;
/// <summary>
/// 获取一个兑换记录
/// </summary>
public const int ONEMALLRECORD = 60013;
/// <summary>
/// 保存玩家地址
/// </summary>
public const int SAVEPLAYERADDRESS = 60014;
/// <summary>
/// 获取商品数量
/// </summary>
public const int MALLCOUNT = 60015;
/// <summary>
/// 获取购买记录数量
/// </summary>
public const int RecordCount = 60016;
/// <summary>
/// 领取救济金
/// </summary>
public const int Dole = 60017;
/// <summary>
/// 每日签到
/// </summary>
public const int SignDay = 60018;
/// <summary>
/// 每日分享
/// </summary>
public const int shareDay = 60019;
/// <summary>
/// 领取红包
/// </summary>
//public const int GetReadPack = 60020;
/// <summary>
/// 进入游戏标记
/// </summary>
public const int DoGame = 60021;
/// <summary>
/// 获取未读邮件的数量
/// </summary>
public const int unreadEmlCount = 60022;
/// <summary>
/// 获取所有的邮件
/// </summary>
public const int GetEmls = 60023;
/// <summary>
/// 读取邮件
/// </summary>
public const int ReadEml = 60024;
/// <summary>
/// 登录数据
/// </summary>
public const int LoginData = 60025;
/// <summary>
/// 刷新金钱
/// </summary>
//public const int RefreshMoney = 60026;
/// <summary>
/// 获取代理值
/// </summary>
//public const int GetDailiValue = 60027;
/// <summary>
/// 二七王结算错误提交
/// </summary>
//public const int submitAccountError = 60028;
/// <summary>
/// 获取系统消息
/// </summary>
//public const int GetSystemMessage = 60029;
/// <summary>
/// 根据moduleid 来获取游戏名称
/// </summary>
public const int GetGameName_ByModuleId = 60030;
/// <summary>
/// 测试，设置玩家游戏币..
/// </summary>
public const int SetGold = 60031;
/// <summary>
/// 比赛所有的配置
/// </summary>
public const int bisaiallconfigs = 60032;
/// <summary>
/// 获取比赛的数据
/// </summary>
//public const int bisaiData = 60033;
/// <summary>
/// 获取服务器时间
/// </summary>
public const int getServerTime = 60035;
/// <summary>
/// 反馈数据
/// </summary>
public const int feedbackData = 60037;
/// <summary>
/// 反馈数据
/// </summary>
public const int setDeBugtext = 60038;
/// <summary>
/// 获取玩家所在的游戏信息
/// </summary>
public const int GetGameInfo = 60039;
/// <summary>
/// 普通账户绑定微信
/// </summary>
public const int BindUser = 60040;
/// <summary>
/// 微信绑定普通账户
/// </summary>
public const int BindAccount = 60041;
/// <summary>
/// 客户端http包错误或缓慢
/// </summary>
public const int httperrorinfo = 60042;
/// <summary>
/// 拒绝更新
/// </summary>
public const int RefusedToUpdate = 60043;
/// <summary>
/// 安卓更新错误
/// </summary>
public const int AndroidUpdateError = 60044;
/// <summary>
/// 实物卡充值
/// </summary>
//public const int CardCharge = 60045;
/// <summary>
/// 获取tv_pc版本信息
/// </summary>
public const int GET_TCPV_VERSION = 60046;
/// <summary>
/// 获取注册的数据
/// </summary>
public const int GetReginData = 60047;
/// <summary>
/// 获取充值数据
/// </summary>
public const int GetRechargeData = 60048;
/// <summary>
/// 获取平台管理
/// </summary>
public const int GetPlatAdmin = 60049;
/// <summary>
/// 获取游戏排行总榜
/// </summary>
public const int GetGameRankList = 60050;
/// <summary>
/// 获取子游戏榜
/// </summary>
public const int GetSubGameRankList = 60051;
/// <summary>
/// 获取即时榜数据
/// </summary>
public const int GetRealDayRankList = 60052;
/// <summary>
/// 查询某游戏中某玩家自己的积分
/// </summary>
public const int GetPlayerRealDayRankScore = 60053;
/// <summary>
/// 获取玩家的昵称
/// </summary>
public const int GetPlayerNickName = 60054;
/// <summary>
/// 获取代理下的玩家信息
/// </summary>
public const int GetReginPlayerList = 60055; ///// <summary>
///// 为代理下的玩家加房卡
///// </summary>
//public const int ReginAddFangKa = 60056;
/// <summary>
///
/// </summary>
public const int GetGameRankListForRegin = 60057;
/// <summary>
/// 测试包
/// </summary>
public const int PackTest = 60058;
/// <summary>
/// 检查用户名及手机号是否存在
/// </summary>
public const int GetPlayerNameandPhone = 60059;
/// <summary>
/// 检查验证码是否正确
/// </summary>
//public const int CheckVerificationCode = 60060;
/// <summary>
/// 获取抢位比赛回放数据
/// </summary>
public const int GetEqwMatchFightData = 60061;
/// <summary>
/// 转盘抽奖
/// </summary>
public const int TurntableLottery = 60062;
/// <summary>
/// 年终积分榜 --大厅以前总榜单协议号：60050
/// </summary>
public const int YearScoreboard = 60063;
/// <summary>
/// 获取定局比赛战斗数据RPC
/// </summary>
public const int GetFixedMatchDataRPC = 60064;
/// <summary>
/// 更新玩家名字和头像
/// </summary>
public const int UpdateUserInfo = 60065;
/// <summary>
/// 获取充值商城的物品
/// </summary>
public const int GetCZShangPing = 60066;
/// <summary>
/// 兑换道具或者商品
/// </summary>
public const int DuiHuanShangPing = 60067;
/// <summary>
/// 获取连续签到礼包
/// </summary>
public const int GetSignInPack = 60068;
/// <summary>
/// 获取小程序安卓订单号、应用宝
/// </summary>
public const int GetAndroidPayOrderId = 60069;
/// <summary>
/// 获取资产明细
/// </summary>
public const int GetZiChanMingXi = 60070;
/// <summary>
/// 获取玩家道具
/// </summary>
public const int GetUserDaoJu = 60071;
/// <summary>
/// 金币存取操作
/// </summary>
public const int DoGoldChange = 60072;
/// <summary>
/// 获取红包金额
/// </summary>
public const int GetRedMoney = 60073;
/// <summary>
/// 获取自身的5倍福利
/// </summary>
public const int GetFuli5Bei = 60074;
/// <summary>
/// 获取所有游戏的榜单
/// </summary>
public const int GetAllGamesRankList = 60075;
/// <summary>
/// 获取IPTV桌子的战斗数据
/// </summary>
public const int GetIPtvMatchWarData = 60076;
/// <summary>
/// 玩家获取定局积分比赛记录
/// </summary>
public const int GetFixedMatchDataById = 60077;
/// <summary>
/// 获取回放数据
/// </summary>
public const int GetWarPlayBackData = 60078;
/// <summary>
/// 获取玩家的举报信息
/// </summary>
public const int GetReportInfo = 60079;
/// <summary>
/// 举报玩家
/// </summary>
public const int ReportPlayer = 60080;
/// <summary>
/// 获取这个比赛是否有举报信息
/// </summary>
public const int GetReportByMatchKey = 60081;
/// <summary>
/// 获取摇钱树抽奖信息
/// </summary>
public const int CashCowActive = 60082;
/// <summary>
/// 获取广告金币礼包
/// </summary>
public const int GetAdGift = 60083;
/// <summary>
/// 获取我的奖励
/// </summary>
public const int GetMyRewards = 60084;
/// <summary>
/// 激活推广
/// </summary>
public const int ActivatePromotion = 60085;
/// <summary>
/// 获取推广状态
/// </summary>
public const int GetPromotionState = 60086;
/// <summary>
/// 保存玩家头像和性别
/// </summary>
public const int SaveSexHead = 60087;
/// <summary>
/// 获取朋友房信息
/// </summary>
public const int GetFriendRoomInfo = 60088;
/// <summary>
/// 获取过年活动比赛配置
/// </summary>
//public const int GetYearMatchInfo = 60089;
/// <summary>
/// 领取广告礼包
/// </summary>
public const int GetAdGiftVer1 = 60091;
/// <summary>
/// 领取救济金
/// </summary>
public const int DoleVer1 = 60092;
/// <summary>
/// AppStore支付 票据校验
/// </summary>
public const int AppStorePayVerify = 60093;
/// <summary>
/// 获取玩家信息
/// </summary>
public const int GetPlayerInfo = 60094;
/// <summary>
/// 钻石兑换房卡
/// </summary>
public const int DiamondExchangeCard = 60095;
/// <summary>
/// 玩家祈福
/// </summary>
public const int PlayerPray = 60096;
#endregion
//ServerDashboardPackAgreement.cs 中已定义 60250 至 61000 #endregion
#region ClubManager
/// <summary>
/// 创建竞技比赛 过时
/// </summary>
public const int CreateClub = 70001;
/// <summary>
/// 解散竞技比赛
/// </summary>
public const int DismissClub = 70002;
/// <summary>
/// 添加玩法
/// </summary>
public const int EditorPlayWay = 70003;
/// <summary>
/// 获取玩法
/// </summary>
public const int GetPlayWay = 70004;
/// <summary>
/// 获取与我相关的所有竞技比赛基本信息
/// </summary>
public const int AllClubBaseInfo = 70005;
/// <summary>
/// 修改基本信息
/// </summary>
public const int EditorBasicInfo = 70006;
/// <summary>
/// 房卡转换
/// </summary>
public const int PayUpCard = 70007;
/// <summary>
/// 进入某玩法
/// </summary>
public const int JoinWay = 70008;
/// <summary>
/// 获取战绩统计
/// </summary>
public const int Statistics = 70009;
/// <summary>
/// 获取玩家自己的战绩
/// </summary>
public const int GetMyFightRecode = 70010;
/// <summary>
/// 申请加入竞技比赛
/// </summary>
public const int ApplyJoinClub = 70011;
/// <summary>
/// 退出竞技比赛
/// </summary>
public const int QuitClub = 70012;
// <summary>
// 踢出成员
// </summary>
//public const int DeleteMember = 70013;
/// <summary>
/// 修改成员信息
/// </summary>
public const int EditorPlayer = 70014;
/// <summary>
/// 获取玩家信息
/// </summary>
public const int GetPlayersInfo = 70015;
/// <summary>
/// 获取竞技比赛玩家信息
/// </summary>
public const int GetClubPlayers = 70016;
/// <summary>
/// 获取消息
/// </summary>
public const int GetClubMeeage = 70017;
/// <summary>
/// 处理消息
/// </summary>
public const int DoClubMessage = 70018;
/// <summary>
/// 删除消息
/// </summary>
public const int DeleteMessage = 70019;
/// <summary>
/// 获取战斗记录
/// </summary>
public const int GetFrigtRecord = 70020;
/// <summary>
/// 获取大赢家 分页处理
/// </summary>
public const int GetBigWinner = 70021;
/// <summary>
/// 添加战斗记录
/// </summary>
public const int AddFightRecord = 70022;
/// <summary>
/// 获取某时间内的所有大赢家
/// </summary>
public const int GetBigWinner1 = 70023;
/// <summary>
/// 获取竞技比赛的所有版本信息
/// </summary>
public const int GetClubVer = 70024;
/// <summary>
/// 获取服务器信息
/// </summary>
public const int GetSers = 70025;
/// <summary>
/// 获取竞技比赛信息
/// </summary>
public const int GetClubInfo = 70026;
/// <summary>
/// 登录信号
/// </summary>
public const int cnt_userid = 70027;
/// <summary>
/// RPC_检查玩家是否可加入玩法
/// </summary>
public const int CheckUserJoinWanfa = 70028;
/// <summary>
/// 写竞技比赛消息
/// </summary>
public const int WriteClubMsg = 70029;
/// <summary>
/// 获取竞技比赛消息
/// </summary>
public const int GetClubMsg = 70030;
/// <summary>
/// 获取竞技比赛玩家信息
/// </summary>
public const int GetClubPlayerInfo = 70031;
/// <summary>
/// 赠送房卡给用户
/// </summary>
public const int CardToPlayer = 70032;
/// <summary>
/// 获取个人消息
/// </summary>
public const int PersonMessage = 70033;
/// <summary>
/// WayDeskChange
/// </summary>
public const int WayDeskChange = 70034;
/// <summary>
/// GetClubDesks
/// </summary>
public const int GetClubDesks = 70035;
/// <summary>
/// 设置玩家为管理员
/// </summary>
public const int SetPersonMgr = 70036;
/// <summary>
/// 设置权限
/// </summary>
public const int SetPower = 70037;
/// <summary>
/// 设置禁止同桌!
/// </summary>
public const int SetBanGroup = 70038;
/// <summary>
/// 获取禁止同桌数据
/// </summary>
public const int GetBanGroups = 70039;
/// <summary>
/// 封禁竞技比赛玩家
/// </summary>
public const int ClubBlockPlayer = 70040;
/// <summary>
/// 解散竞技比赛的桌子
/// </summary>
public const int DismissClubDesk = 70041;
/// <summary>
/// 获取转入房卡记录，会长和管理员有权限 客户端获取和服务器发送可以用一个类型
/// </summary>
public const int GetClubPayCard = 70042;
/// <summary>
/// 获取竞技比赛小黑屋玩家
/// </summary>
public const int GetClubBlockPlayerList = 70043;
/// <summary>
/// 通过昵称或者备注查询竞技比赛玩家
/// </summary>
public const int FindClubPlayerByName = 70044;
/// <summary>
/// 获取战绩数据--使用场景：我的战绩
/// </summary>
public const int GetPlayRecordData = 70045;
/// <summary>
/// 获取竞技比赛统计数据--战绩统计里面的总把数/耗卡数
/// </summary>
public const int GetClubStatisticsData = 70046;
/// <summary>
/// 获取竞技比赛时间段的大赢家
/// </summary>
public const int GetClubCountOfBest = 70047;
/// <summary>
/// 获取竞技比赛时间段的房主
/// </summary>
public const int GetClubCountOfRoomOwner = 70048;
/// <summary>
/// 获取竞技比赛参与人次
/// </summary>
public const int GetClubCountOfRound = 70049;
/// <summary>
/// 创建玩法桌子
/// </summary>
public const int CreateWayDesk = 70050;
/// <summary>
/// 加入玩法的桌子
/// </summary>
public const int JoinWayDesk = 70051;
/// <summary>
/// 俱乐部回放
/// </summary>
public const int ClubFriendFightdata = 70052;
#region 俱乐部合伙人
/// <summary>
/// 获取俱乐部的合伙人列表
/// </summary>
public const int GetPartnerListOfClub = 70060;
/// <summary>
/// 获取俱乐部的合伙人列表
/// </summary>
public const int GetMembersOfPartnerClub = 70061;
/// <summary>
/// 为俱乐部玩家增加合伙人角色
/// </summary>
public const int AddPartnerRoleForPlayerClub = 70062;
/// <summary>
/// 从俱乐部玩家移除合伙人角色
/// </summary>
public const int RemovePartnerRoleForClubPlayer = 70063;
/// <summary>
/// 加组员给俱乐部合伙人
/// </summary>
public const int AddPlayersToClubPartner = 70064;
/// <summary>
/// 从俱乐部合伙人移除组员
/// </summary>
public const int RemovePlayerFromPartnerClub = 70065;
/// <summary>
/// 搜索无合伙人的俱乐部玩家
/// </summary>
public const int SearchPlayerOfNoPartnerClub = 70066;
/// <summary>
/// 获取俱乐部合伙人统计汇总信息
/// </summary>
public const int GetStatisticsOfPartnerClub = 70068;
/// <summary>
/// 会长将合伙人组员转移至其他合伙人
/// </summary>
public const int TransferMemberOfPartnerClub = 70067;
/// <summary>
/// 申请成功为合伙人的组员
/// </summary>
public const int ApplyMemberOfPartnerClub = 70069;
/// <summary>
/// 创建比赛
/// </summary>
public const int CreateClubMatch = 70070;
/// <summary>
/// 获取比赛信息
/// </summary>
public const int GetClubMatchInfo = 70071;
/// <summary>
/// 获取比赛玩家积分--群主使用
/// </summary>
public const int GetClubMatchUserScores = 70072;
/// <summary>
/// 获取玩家积分日志 群主和玩家都要使用
/// </summary>
public const int GetClubMatchScoreNotesByUser = 70073;
/// <summary>
/// 获取比赛日志
/// </summary>
public const int GetClubMatchNotes = 70074;
/// <summary>
/// 设置当前比赛玩家的比赛积分
/// </summary>
public const int SetClubMatchUserScore = 70075;
/// <summary>
/// 获取自己的比赛信息
/// </summary>
public const int GetMyMatchInfo = 70076;
/// <summary>
/// 玩家退赛申请
/// </summary>
public const int UserAskExitMatch = 70077;
/// <summary>
/// 获取玩家退赛列表
/// </summary>
public const int GetExitMatchUserList = 70078;
/// <summary>
/// 群主处理重赛
/// </summary>
public const int DoDealWithExitMatch = 70079;
/// <summary>
/// 关闭比赛
/// </summary>
public const int CloseClubMatch = 70080;
/// <summary>
/// 获取比赛列表
/// </summary>
public const int GetClubMatchList = 70081;
/// <summary>
/// 修改比赛中的玩法设置
/// </summary>
public const int EditClubMatchPlayWay = 70082;
/// <summary>
/// 获取俱乐部是否有联赛权限
/// </summary>
public const int GetClubLeaguePower = 70083;
/// <summary>
/// 创建俱乐部联赛
/// </summary>
public const int CreateClubLeagueMatch = 70084;
/// <summary>
/// 加入联赛
/// </summary>
public const int DoJoinClubLeagueMatch = 70085;
/// <summary>
/// 返回加入联赛的俱乐部列表
/// </summary>
public const int GetJoinLeagueMatchClubList = 70086;
/// <summary>
/// 请求加入联赛
/// </summary>
public const int AskJoinClubLeagueMatch = 70087;
/// <summary>
/// 获取申请加入联赛的列表--联盟长用
/// </summary>
public const int GetAskJoinClubLeagueMatchList = 70088;
/// <summary>
/// 获取竞猜联赛管理列表
/// </summary>
public const int GetJoinClubLists = 70089;
/// <summary>
/// 联盟长限制玩家不能玩游戏
/// </summary>
public const int LeagueClubBlockPlayer = 70090;
/// <summary>
/// 踢出联赛
/// </summary>
public const int DismissClubLeagueMatch = 70091;
/// <summary>
/// 联赛禁桌
/// </summary>
public const int LeagueClubBanDesk = 70092;
/// <summary>
/// 获取联赛排行榜
/// </summary>
public const int GetLeagueClubRanking = 70093;
/// <summary>
/// 盟主颁奖
/// </summary>
public const int DoAward = 70094;
/// <summary>
/// 获取颁奖记录
/// </summary>
public const int GetAwardRecord = 70095;
/// <summary>
/// 发布生存任务
/// </summary>
public const int LeaguePublishTask = 70096;
/// <summary>
/// 获取生存任务列表
/// </summary>
public const int GetLeaguePublishTaskList = 70097;
/// <summary>
/// 获取俱乐部禁桌的数据
/// </summary>
public const int GetClubBanDesk = 70098;
/// <summary>
/// 关闭联赛
/// </summary>
public const int CloseLeagueMathc = 70099;
/// <summary>
/// 获取俱乐部列表
/// </summary>
public const int GetClubList = 70100;
/// <summary>
/// 设置禁止同桌 联盟用
/// </summary>
public const int SetBanGroupByLeague = 70101;
/// <summary>
/// 获取禁止同桌的数据 联盟用
/// </summary>
public const int GetBanGroupsByLeague = 70102;
/// <summary>
/// 获取小黑屋玩家，--联盟俱乐部
/// </summary>
public const int GetLeagueClubBlockPlayerList = 70103;
/// <summary>
/// 俱乐部通过玩家Id查找玩家
/// </summary>
public const int ClubFindPlayById = 70104;
/// <summary>
/// 添加玩家到俱乐部
/// </summary>
public const int AddPlayerInClub = 70105;
/// <summary>
/// 获取合伙人的桌费列表
/// </summary>
public const int GetPartnerDeskScore = 70106;
/// <summary>
/// 踢出玩家
/// </summary>
public const int OutPlayer = 70107;
/// <summary>
/// 获取俱乐部玩家信息
/// </summary>
public const int GetClubPlayInfo = 70108;
/// <summary>
/// 获取俱乐部的战绩数据
/// </summary>
public const int GetClubFightRecord = 70109;
/// <summary>
/// 获取盟主下面的俱乐部列表
/// </summary>
public const int GetLeagueClubs = 70120;
/// <summary>
/// 获取玩家比赛积分
/// </summary>
public const int GetPlayMatchScore = 70121;
///// <summary>
///// 查找战绩玩家在哪个俱乐部打的
///// </summary>
//public const int GetPlayerFightRecordInClub = 70122;
/// <summary>
/// 群主设置某些玩法隐藏
/// </summary>
public const int SetWayHide = 70123;
/// <summary>
/// 限制某些玩家某些玩法不能玩
/// </summary>
public const int SetWayHideToPlayer = 70124;
/// <summary>
/// 设置比赛积分备注
/// </summary>
public const int SetMatchSocreMemo = 70125;
/// <summary>
/// 修改比赛设置
/// </summary>
public const int SetMatchSet = 70126;
/// <summary>
/// 获取比赛设置
/// </summary>
public const int GetMatchSet = 70127;
/// <summary>
/// 获取自己的俱乐部是不是联赛管理员
/// </summary>
public const int GetMyClubIsAdmin = 70128;
/// <summary>
/// 设置联赛管理员
/// </summary>
public const int SetLeagueAdminClubs = 70129;
/// <summary>
/// 获取一个俱乐部管理名下的俱乐部信息 --联赛使用
/// </summary>
public const int GetClubOfManager = 70130;
/// <summary>
/// 根据类型获取比赛日志
/// </summary>
public const int GetClubMatchNotesByType = 70131;
/// <summary>
/// 修改俱乐部密码
/// </summary>
public const int EditClubPassWord = 70132;
/// <summary>
/// 玩家主动退出俱乐部
/// </summary>
public const int PlayExitClub = 70133;
/// <summary>
/// 俱乐部回放 --新版
/// </summary>
public const int ClubFriendFightdataNew = 70134;
#endregion
#endregion
#if Server
#region ServerManager 10
/// <summary>
/// 选举包
/// </summary>
public const int election = 100001;
/// <summary>
/// 选举结果
/// </summary>
public const int electionResult = 100002;
/// <summary>
/// 心跳包
/// </summary>
public const int heartBeatpack = 100003;
/// <summary>
/// 服务器管理的集群信息
/// </summary>
public const int serverMainclusterInfo = 100004;
#endregion
#region DataCenter 21
/// <summary>
/// 读取玩家数据
/// </summary>
public const int ReadPlayerData = 210001;
/// <summary>
/// 写玩家数据
/// </summary>
public const int WritePlayerData = 210002;
/// <summary>
/// 保存玩家数据
/// </summary>
public const int SavePlayerData = 210003;
#endregion
#endif
#region bisaiServer
/// <summary>
/// 比赛包
/// </summary>
//public const int biSaiPack = 320001;
#endregion
#region ChatServer 36
/// <summary>
/// 一条信息
/// </summary>
//public const int AMessage = 360001;
/// <summary>
/// 创建竞技比赛聊天室
/// </summary>
//public const int CreateChatRoom = 360002;
/// <summary>
/// 销毁聊天室
/// </summary>
//public const int DestroyChatRoom = 360003;
/// <summary>
/// 对聊天室发送消息
/// </summary>
//public const int SendMessage = 360004;
/// <summary>
/// 心跳包
/// </summary>
// public const int ChatHeart = 360005;
#endregion
#if Server
#region TeamManager 44
/// <summary>
/// 获取我的战队
/// </summary>
public const int GetMyTeam = 440001;
/// <summary>
/// 获取所有战队信息
/// </summary>
public const int GetAllTeamList = 440002;
/// <summary>
/// 创建战队
/// </summary>
public const int CreateTeam = 440003;
/// <summary>
/// 获取战队排行榜
/// </summary>
public const int GetTeamRankList = 440004;
/// <summary>
/// 获取战队成员列表
/// </summary>
public const int GetMemberList = 440005;
/// <summary>
/// 申请加入战队
/// </summary>
public const int JoinTeamRequest = 440006;
/// <summary>
/// 离开战队
/// </summary>
public const int QuitTeam = 440007;
/// <summary>
/// 修改战队信息
/// </summary>
public const int EditorTeamInfo = 440008;
/// <summary>
/// 获取战队详细信息
/// </summary>
public const int GetTeamDetailInfo = 440009;
/// <summary>
/// 编辑战队密码
/// </summary>
public const int EditorTeamPassword = 440010;
/// <summary>
/// 获取申请加入战队的列表
/// </summary>
public const int GetApplyJoinList = 440011;
/// <summary>
/// 获取战队中自身的信息
/// </summary>
public const int GetTeamMyInfo = 440012;
/// <summary>
/// 审核玩家加入战队
/// </summary>
public const int CheckUserJoinTeam = 440013;
/// <summary>
/// 获取邀请玩家的信息
/// </summary>
public const int GetInvitePlayer = 440014;
/// <summary>
/// 邀请玩家加入战队
/// </summary>
public const int InvitePlayer = 440015;
/// <summary>
/// 获取战队的详细玩家信息
/// </summary>
public const int GetTeamDetailPlayer = 440016;
/// <summary>
/// 获取玩家个人的信息，如邀请加入战队
/// </summary>
public const int GetPersonMessage = 440017;
/// <summary>
/// 邀请结果
/// </summary>
public const int InviteResult = 440018;
/// <summary>
/// 创建战队自建比赛
/// </summary>
public const int CreateTeamRace = 440100;
#endregion
#endif
}
/// <summary>
/// 游戏包裹协议
/// </summary>
public static class GameSeverAgreement
{
/*
* 服务器通用包
* */
/// <summary>
/// 玩家登录包
/// </summary>
public const int Login = 5000;
/// <summary>
/// 金币场进入桌子包
/// </summary>
public const int InDesk = 5001;
/// <summary>
/// 服务器配置信息
/// </summary>
public const int gameConfig = 5002;
/// <summary>
/// 返回、后退包
/// </summary>
public const int comBack = 5003;
/// <summary>
/// 子游戏包
/// </summary>
public const int zyxPack = 5004;
/// <summary>
/// 桌上玩家信息
/// </summary>
public const int deskPlayerInfo = 5005;
// <summary>
// 退出房间
// </summary>
//public const int quitRoom = 5006;
/// <summary>
/// 准备包裹
/// </summary>
public const int readyPk = 5007;
/// <summary>
/// 开战
/// </summary>
public const int startWar = 5008;
/// <summary>
/// 战斗结束信号
/// </summary>
public const int warOver = 5009;
/// <summary>
/// 玩家状态变化事件
/// </summary>
public const int playerStateChange = 5010;
/// <summary>
/// 个人创建朋友房包
/// </summary>
public const int createFriendRoom = 5011;
/// <summary>
/// 解散房间命令
/// </summary>
public const int dissFriendRoomCmd = 5012;
/// <summary>
/// 进入房间
/// </summary>
public const int joinFriendRoom = 5013;
/// <summary>
/// 请求解散房间
/// </summary>
public const int placedissRoom = 5014;
/// <summary>
/// 解散回复,同意或拒绝
/// </summary>
public const int disreponse = 5015;
/// <summary>
/// 朋友房信息包
/// </summary>
public const int friendroominfo = 5016;
/// <summary>
/// 朋友房玩家信息包
/// </summary>
public const int friendroomplayers = 5017;
/// <summary>
/// 朋友房详情包-对战信息
/// </summary>
public const int friendroombrus = 5018;
/// <summary>
/// 朋友房解散信息包
/// </summary>
public const int disbankinfo = 5019;
/// <summary>
/// 朋友房上几场信息
/// </summary>
public const int friendlastInfo = 5020;
/// <summary>
/// 获取战斗数据回放包
/// </summary>
public const int friendfightdata = 5021;
/// <summary>
/// 加入玩法
/// </summary>
public const int joinWay = 5022;
/// <summary>
/// 测试
/// </summary>
public const int Test = 5023;
/// <summary>
/// 某局结束通知
/// </summary>
public const int over_paiju = 5024;
/// <summary>
/// 打完所有局
/// </summary>
public const int over_All = 5025;
/// <summary>
/// 开战过，局数没到被解散
/// </summary>
public const int over_jiesan = 5026;
/// <summary>
/// 超时被解散_24小时还没打完
/// </summary>
public const int over_timeout = 5027;
/// <summary>
/// 房主解散
/// </summary>
public const int over_fangzhu = 5028;
/// <summary>
/// 进入到朋友房_拿开战局数以及房间人数可以判断_创建房间_加入房间_玩家重连
/// </summary>
public const int accesstoFriendRoom = 5029;
/// <summary>
/// 桌上聊天包
/// </summary>
public const int chatDesk = 5030;
/// <summary>
/// 离线挂机包
/// </summary>
public const int outlineGuji = 5031;
/// <summary>
/// 朋友房重连提示包
/// </summary>
public const int friendReconn = 5032;
/// <summary>
/// 朋友房离线提示包
/// </summary>
public const int friendLeave = 5033;
/// <summary>
/// 超时未满员
/// </summary>
public const int over_timeout_nowar = 5034;
/// <summary>
/// 返还房卡提示
/// </summary>
public const int returnCard = 5035;
/// <summary>
/// 没有成功进入房间的提示
/// </summary>
public const int notJoinFriendRoom = 5036;
/// <summary>
/// 设备信息包 客户端发给服务端
/// </summary>
public const int DeviceInfoPack = 5037;
/// <summary>
/// 设备信息变化包 服务端发给客户端
/// </summary>
public const int DeviceInfoChange = 5038;
/// <summary>
/// 语音包
/// </summary>
public const int voiceData = 5039;
/// <summary>
/// 玩家数据包
/// </summary>
public const int getPlayerData_Test = 5040;
/// <summary>
/// 请求立即开战
/// </summary>
public const int questOnceFight = 5041;
/// <summary>
/// 桌子信息发生变化
/// </summary>
public const int DeskInfoChange = 5042;
/// <summary>
/// 发送道具包
/// </summary>
public const int Props = 5043;
/// <summary>
/// 玩法被删除了
/// </summary>
public const int wayDel = 5044;
/// <summary>
/// 竞技比赛桌子解散指令
/// </summary>
public const int ClubDisBankCmd = 5045;
/// <summary>
/// 加入竞技比赛房间
/// </summary>
public const int JoinClubDesk = 5046;
/// <summary>
/// 创建竞技比赛房间
/// </summary>
public const int CreateClubDesk = 5047;
/// <summary>
/// 赠送道具
/// </summary>
public const int GiveProps = 5048;
/// <summary>
/// 玩家托管
/// </summary>
public const int PlayerDePosit = 5049;
/// <summary>
/// 少人开始
/// </summary>
public const int LessOpen = 5050;
/// <summary>
/// 切换俱乐部房间
/// </summary>
public const int SwitchClubRoom = 5051;
/// <summary>
/// 离线变化包
/// </summary>
public const int OutLineChange = 5052;
/// <summary>
/// 俱乐部再来一局
/// </summary>
//public const int ClubAgainGameSuccess = 5053;
/// <summary>
/// 玩家托管变化包
/// </summary>
public const int PlayerDepositChange = 5054;
/// <summary>
/// 开战倒计时包
/// </summary>
public const int StartWarCountdown = 5055;
/// <summary>
/// 用户观战包
/// </summary>
public const int PlayerLookOn = 5056;
/// <summary>
/// 用户换座位包
/// </summary>
public const int PlayerChangeDeskSeat = 5057;
#region xu添加电视比赛包协议
/// <summary>
/// 发送比赛服务器信息
/// </summary>
public const int TVRaceInfo = 6000;
/// <summary>
/// 抢位置包
/// </summary>
public const int TVSeat = 6001;
/// <summary>
/// 观战包
/// </summary>
public const int TVLook = 6002;
/// <summary>
/// 竞猜包
/// </summary>
public const int TVGuess = 6003;
/// <summary>
/// 客户端获取竞猜数据
/// </summary>
public const int TVGetGuess = 6004;
/// <summary>
/// 更新玩家数据
/// </summary>
public const int UpdatePlayerInfo = 6005;
/// <summary>
/// 获取历史下注结果
/// </summary>
public const int GetHistoryGameResult = 6006;
/// <summary>
/// 返还竞猜游戏币
/// </summary>
public const int BackGuessMoney = 6007;
/// <summary>
/// 获取游戏排行榜
/// </summary>
public const int GetGameRankingList = 6008;
/// <summary>
/// 发送公告
/// </summary>
public const int SendNoticeMessage = 6009;
/// <summary>
/// 更新玩家钱
/// </summary>
public const int UpdateUserMoney = 6010;
/// <summary>
/// 获取竞猜结束结果信息
/// </summary>
public const int GetGuessGameOverInfo = 6011;
/// <summary>
/// 俱乐部比赛因小局分不够解散桌子
/// </summary>
public const int ClubMatchDisBankDeskByBurs = 6012;
/// <summary>
/// 因托管自动解散
/// </summary>
public const int DepositAutoDissolve = 6013;
#endregion
#region 积分竞技比赛包协议
/// <summary>
/// 报名
/// </summary>
public const int DoEnlist = 6013;
/// <summary>
/// 发送比赛信息
/// </summary>
public const int MatchInfo = 6014;
/// <summary>
/// 比赛排行榜信息，有淘汰竞技数据
/// </summary>
public const int MatchRank = 6015;
/// <summary>
/// 获取比赛报名人数
/// </summary>
public const int GetMatchPlayerCount = 6016;
/// <summary>
/// 玩家的比赛信息
/// </summary>
public const int MatchPlayerInfo = 6017;
/// <summary>
/// 获取比赛进行中的信息
/// </summary>
public const int GetMatchPlayInfo = 6018;
/// <summary>
/// 发送比赛进行到哪一轮的信息
/// </summary>
public const int MatchLunInfo = 6019;
/// <summary>
/// 积分报名
/// </summary>
public const int ScoreEnroll = 6020; //
/// <summary>
/// 比赛卷兑换奖券
/// </summary>
public const int MatchRollExchange = 6021;
#endregion
#region 新版本比赛包协议 打立出局 定局积分
/// <summary>
/// 获取新的比赛配置
/// </summary>
public const int GetNewMatchConfig = 6022;
/// <summary>
/// 新的比赛报名
/// </summary>
public const int NewMatchEnlist = 6023;
/// <summary>
/// 获取报名人数
/// </summary>
public const int GetEnlistPeopleCountPack = 6024;
/// <summary>
/// 获取实时赛况列表
/// </summary>
public const int GetRealTimeOuts = 6025;
/// <summary>
/// 获取比赛详细信息
/// </summary>
public const int GetMatchInfo = 6026;
/// <summary>
/// 获取自己是否报名
/// </summary>
public const int GetMyIsEnlist = 6027; //
/// <summary>
/// 获取报名玩家
/// </summary>
public const int GetEnlistPlayer = 6028; //
/// <summary>
/// 退费
/// </summary>
public const int ExitMatchMoney = 6029;
/// <summary>
/// 一轮打完发包
/// </summary>
public const int LunGameOver = 6030;
/// <summary>
/// 一轮开始告诉玩家淘汰还是晋级
/// </summary>
public const int LunGameResult = 6031;
/// <summary>
/// 玩家比赛中的信息
/// </summary>
public const int PlayerMatching = 6032;
/// <summary>
/// 获取定时赛时间列表
/// </summary>
public const int GetFixedTimeMatch = 6034;
/// <summary>
/// 比赛退赛
/// </summary>
public const int ExitMatch = 6035;
/// <summary>
/// 新的比赛报名-C#用
/// </summary>
public const int GetEnlistPeopleCountPackNET = 6036;
/// <summary>
/// 新的比赛报名-C#用 6038已经被使用
/// </summary>
public const int NewMatchEnlistNET = 6037;
/// <summary>
/// 获取定局积分排行榜
/// </summary>
public const int SendIntegral = 6038;
/// <summary>
/// 获取比赛详细信息，通过Key Str
/// </summary>
public const int GetMatchByKeyStr = 6039;
/// <summary>
/// 获取玩家道具
/// </summary>
public const int GetUserDaoJu = 6040;
/// <summary>
/// 获取定局积分排行榜 因为6038被占用
/// </summary>
public const int GetFixedScoreRankListNew = 6041;
/// <summary>
/// IPTV 海选报名
/// </summary>
public const int IPTVMatchEnlist = 6042;
/// <summary>
/// 发送IPTV奖励信息包
/// </summary>
public const int IPTVMatchRewardPack = 6043;
/// <summary>
/// 获取积分日榜
/// </summary>
public const int GetScoreRankListByDay = 6044;
/// <summary>
/// 发送晋级消息
/// </summary>
public const int SendAdvancement = 6045;
/// <summary>
/// IPTV 海选赛
/// </summary>
public const int IPTVHaiXuanMatch = 6046;
/// <summary>
/// 获取IPTV比赛桌子信息
/// </summary>
public const int GetIPTVMatchDesk = 6047;
/// <summary>
/// 获取IPTV报名选手名单
/// </summary>
public const int GetIPTVEnlistPlayer = 6048;
/// <summary>
/// 是否使用复活卡
/// </summary>
public const int IsUserRevive = 6049;
/// <summary>
/// 获取冠军列表
/// </summary>
public const int GetChampionList = 6050;
/// <summary>
/// 发包给客户端同步数据
/// </summary>
public const int AddZiChanToPlayer = 6051;
/// <summary>
/// 游戏开始发送玩家比赛信息，同6032是一样的包内容。只是发送的时间不一样
/// </summary>
public const int SetPlayMathcInfo = 6052;
#endregion
/// <summary>
/// 竞技比赛踢出玩家协议
/// </summary>
public const int ClubOutPlayer = 6053;
/// <summary>
/// 添加平衡配置
/// </summary>
public const int AddBalanceConfig = 6054;
/// <summary>
/// 删除平衡配置
/// </summary>
public const int RemoveBalanceConfig = 6055;
/// <summary>
/// 获取平衡配置
/// </summary>
public const int GetBalanceConfigs = 6056;
/// <summary>
/// 编辑平衡配置
/// </summary>
public const int EditorBalanceConfig = 6057;
/// <summary>
/// 添加玩家平衡配置
/// </summary>
public const int AddBalancePlayerConfig = 6058;
/// <summary>
/// 移除玩家平衡配置
/// </summary>
public const int RemoveBalancePlayerConfig = 6059;
/// <summary>
/// 编辑玩家平衡配置
/// </summary>
public const int EditorBalancePlayerConfig = 6060;
/// <summary>
/// 获取玩家平衡配置
/// </summary>
public const int GetBalancePlayerConfig = 6061;
public const int AddRoomRateRule = 6062;
public const int RemoveRoomRateRule = 6063;
public const int AddRoomRateRuleItem = 6064;
public const int RemoveRoomRateRuleItem = 6065;
public const int GetRoomRateRuleItem = 6066;
/// <summary>
/// 更新活动道具数据
/// </summary>
public const int UpdateActivityPropData = 6067;
/// <summary>
/// 房间奖励
/// </summary>
public const int CastleRewardData = 6068;
/// <summary>
/// 玩家替补比赛
/// </summary>
public const int PlayerSubstituteRace = 6069;
/// <summary>
/// 获取自己的比赛报名费用包
/// </summary>
public const int GetSelfRaceEnlistFeePack = 6070;
/// <summary>
/// 获取二七王周赛配置
/// </summary>
public const int GetEqwWeakRaceConfig = 6071;
/// <summary>
/// 桌子的其他数据
/// </summary>
public const int DeskOtherData = 6072;
/// <summary>
/// 使用记牌器
/// </summary>
public const int UsingHandTracker = 6073;
}
}

14
NetWorkMessage/GameData/Common/Pay/ApplePayAppBody.cs Normal file
View File

@ -0,0 +1,14 @@
using System;
namespace GameData
{
/// <summary>
/// 支付之后返回给客户端得数据结构
/// </summary>
[Serializable]
public class ApplePayAppBody
{
public string AppleProductionId { get; set; }
public string Uuid { get; set; }
}
}

11
NetWorkMessage/GameData/Common/Pay/CMBMiniPayBody.cs Normal file
View File

@ -0,0 +1,11 @@
using System;
namespace GameData
{
[Serializable]
public class CMBMiniPayBody
{
public string UserName;
public string Path;
}
}

41
NetWorkMessage/GameData/Common/Pay/HuaweiPayAppBody.cs Normal file
View File

@ -0,0 +1,41 @@
using System;
namespace GameData
{
/// <summary>
/// 支付之后返回给客户端得数据结构
/// </summary>
[Serializable]
public class HuaweiPayAppBody
{
public string HuaweiProductionId { get; set; }
public string DeveloperPayload { get; set; }
}
/// <summary>
/// 客户端支付成功之后通知给服务器得数据结构
/// </summary>
[Serializable]
public class HuaweiPayAppC2SNotifyBody
{
/// <summary>
/// 购买详情
/// </summary>
public string inAppPurchaseData;
/// <summary>
/// 签名字符串
/// </summary>
public string inAppPurchaseDataSignature;
/// <summary>
/// 给服务器使用的商品ID
/// </summary>
public string productId;
/// <summary>
/// 给服务使用的商品token
/// </summary>
public string purchaseToken;
}
}

11
NetWorkMessage/GameData/Common/Pay/LakalaMiniPayBody.cs Normal file
View File

@ -0,0 +1,11 @@
using System;
namespace GameData
{
[Serializable]
public class LakalaMiniPayBody
{
public string UserName;
public string Path;
}
}

65
NetWorkMessage/GameData/Common/Pay/VivoPayBody.cs Normal file
View File

@ -0,0 +1,65 @@
using System;
namespace GameData
{
[Serializable]
public class VivoPayBody
{
/**
* 商户订单号
*/
public string OrderId;
/**
* 商品名称
*/
public string ProductName;
/**
* 商品描述
*/
public string ProductDesc;
/**
* 价格 单位分
*/
public int Amount;
/**
* 用户的OpenId
*/
public string OpenId;
/**
* 回调通知URL
*/
public string NotifyUrl;
/**
* 订单过期时间 可选 格式为 yyyyMMddHHmmss 不传，不知道是什么时间
*/
public string ExpireTime;
/**
* 用户等级 可选
*/
public int Level;
/**
* VIP等级 可选
*/
public int Vip;
/**
* 角色ID 可选
*/
public int RoleId;
/**
* 扩展参数 可选
*/
public string ExtInfo;
}
}

37
NetWorkMessage/GameData/Common/Pay/WechatMiniGamePayBody.cs Normal file
View File

@ -0,0 +1,37 @@
using System;
namespace GameData
{
[Serializable]
public class WechatMiniGamePayBody
{
/// <summary>
/// 币种
/// CNY: 人民币
/// </summary>
public string CurrencyType { get; set; }
/// <summary>
/// 环境配置
/// 0 米大师正式环境
/// 1 米大师沙箱环境
/// </summary>
public int Env { get; set; }
/// <summary>
/// 支付的类型，不同的支付类型有各自额外要传的附加参数。
/// game: 购买游戏币
/// </summary>
public string Mode { get; set; }
/// <summary>
/// 在米大师侧申请的应用 id
/// </summary>
public string OfferId { get; set; }
/// <summary>
/// 购买数量。mode=game 时必填。购买数量
/// </summary>
public int BuyQuantity { get; set; }
/// <summary>
/// 分区 ID
/// </summary>
public string ZoneId { get; set; }
}
}

42
NetWorkMessage/GameData/Common/Pay/WechatPayAppBody.cs Normal file
View File

@ -0,0 +1,42 @@
using System;
namespace GameData
{
/// <summary>
/// 支付之后返回给客户端得数据结构
/// </summary>
[Serializable]
public class WechatPayAppBody
{
/// <summary>
/// 填写下单时传入的【应用ID】appid。
/// </summary>
public string AppId;
/// <summary>
/// 填写下单时传入的【商户号】mchid。
/// </summary>
public string PartnerId;
/// <summary>
/// 预支付交易会话标识。APP下单接口返回的prepay_id，该值有效期为2小时，超过有效期需要重新请求APP下单接口以获取新的prepay_id。
/// </summary>
public string PrepayId;
/// <summary>
/// 随机字符串，不长于32位。该值建议使用随机数算法生成。
/// </summary>
public string NonceStr;
/// <summary>
/// 填写固定值Sign=WXPay
/// 注意：如果是ios则请求参数为“package”
/// </summary>
public string Package;
/// <summary>
/// Unix时间戳，是从1970年1月1日（UTC/GMT的午夜）开始所经过的秒数。
/// 注意：常见时间戳为秒级或毫秒级，该处必需传秒级时间戳。
/// </summary>
public string Timestamp;
/// <summary>
/// 签名，使用字段appId、timeStamp、nonceStr、prepayId以及商户API证书私钥生成的RSA签名值，详细参考APP调起支付签名。
/// </summary>
public string Sign;
}
}

494
NetWorkMessage/GameData/Common/PlayerData.cs Normal file
View File

@ -0,0 +1,494 @@
/*
* 由SharpDevelop创建。
* 用户： Administrator
* 日期: 2018-10-19
* 时间: 9:17
*
* 要改变这种模板请点击 工具|选项|代码编写|编辑标准头文件
*/
using System;
using System.ComponentModel;
using System.Text;
using GameMessage;
using Newtonsoft.Json;
#if Server
using MrWu.Debug;
#endif
namespace GameData
{
/// <summary>
///
/// </summary>
public class playerData
{
/// <summary>
/// 可携带的最大游戏币数量 -读取检查 - 写库(所有写库)检查 -牛牛打完检查 -上桌检查
/// </summary>
public const int MaxMoney = 2000000000;
#if Server
/// <summary>
/// 读取的时候是否超过上限!
/// </summary>
[JsonIgnore]
public int isUpper = 0;
#endif
/// <summary>
/// 内存id
/// </summary>
[DefaultValue(-1)] public int id = -1;
/// <summary>
/// userid
/// </summary>
public int userid;
/// <summary>
/// 性别 0男 1女
/// </summary>
public int sex;
/// <summary>
/// 地区
/// </summary>
public string area;
/// <summary>
/// 用户名
/// </summary>
public string UserName;
/// <summary>
/// 昵称
/// </summary>
public string nickname;
/// <summary>
/// 游戏币
/// </summary>
public long money;
/// <summary>
/// 金币
/// </summary>
public int gold;
/// <summary>
/// 奖券
/// </summary>
public int coupon;
/// <summary>
/// 玩家的ip地址 --发包可忽略
/// </summary>
public string ip;
/// <summary>
/// 经验
/// </summary>
public int exp;
/// <summary>
/// 玩家状态
/// </summary>
/// <see cref="Game.Data.PlayerState"/>
public int state;
/// <summary>
/// 玩家是否离线 0在线 1离线
/// </summary>
public int outline;
/// <summary>
/// 房卡
/// </summary>
public int fangka;
/// <summary>
/// 用户类型 0普通玩家 110微信绑定用户 100微信登陆用户 200QQ 300苹果 400华为
/// </summary>
public int userType;
/// <summary>
/// 玩家所在游戏
/// </summary>
[DefaultValue(-1)] public int gameid = -1;
/// <summary>
/// 玩家的所在的城堡
/// </summary>
[DefaultValue(-1)] public int roomid = -1;
/// <summary>
/// 玩家所在的厅id
/// </summary>
[DefaultValue(-1)] public int tingid = -1;
/// <summary>
/// 桌子id
/// </summary>
[DefaultValue(-1)] public int deskid = -1;
/// <summary>
/// 玩家的桌位号
/// </summary>
[DefaultValue(-1)] public int seat = -1;
/// <summary>
/// 准备倒计时 小于0将被扔出桌子 -暂时只有客户端用 -朋友房中, 未开战满人后 30秒不准备就踢出桌子!
/// </summary>
//[DefaultValue(-1)]
public int readCtDown = -1;
/// <summary>
/// 头像
/// </summary>
public string avatar;
/// <summary>
/// 是否挂机
/// </summary>
public bool isGuaji;
/// <summary>
/// 是否托管 不能设置值，设置要使用方法
/// </summary>
//[JsonIgnore] //忽略此属性
public bool isDePosit
{
get;
#if Server
private
#endif
set;
}
/// <summary>
/// 是否网络不稳定
/// </summary>
[JsonIgnore] public bool isastable;
/// <summary>
/// 桌上状态
/// </summary>
[JsonIgnore] public DeskPlayerState dskState;
/// <summary>
/// 朋友房房间号
/// </summary>
public int friendRoomNum;
/// <summary>
/// 朋友房唯一码
/// </summary>
[JsonIgnore] public string friendWeiYiMa;
/// <summary>
/// 玩家性格
/// </summary>
public int mettle = 0;
/// <summary>
/// 是否是代理
/// </summary>
public int daili = 0;
/// <summary>
/// 玩家魅力
/// </summary>
public int Charm = 0;
/// <summary>
/// 防沉迷用户认证标识
/// </summary>
public string pi;
/// <summary>
/// 2023年4月20日15:09:09 改成钻石，新的充值货币
/// </summary>
public int MatchRoll = 0;
/// <summary>
/// 注册时间
/// </summary>
public DateTime RegTime;
/// <summary>
/// 推广标识
/// </summary>
[JsonIgnore] public string platTag = null;
/// <summary>
/// 头像类型
/// </summary>
public int HeadType = 0;
/// <summary>
/// 玩家的设备信息
/// </summary>
public DeviceInfo device = new DeviceInfo();
/// <summary>
/// 是否参加比赛
/// </summary>
public bool IsJoinMatch;
/// <summary>
/// 平台类型
/// </summary>
///<see cref="Game.Pack.PlatEnum"/>
public int PlatEnum;
/// <summary>
/// 玩家在俱乐部哪个 ------联赛使用
/// </summary>
//[JsonIgnore]
public int ClubId;
#if Server
/// <summary>
/// 玩家俱乐部的分数
/// </summary>
public double ClubScore = int.MaxValue;
#else
/// <summary>
/// 玩家俱乐部的分数
/// </summary>
public double ClubScore;
#endif
/// <summary>
/// 比赛倍率
/// </summary>
public int RaceBeiLv;
/// <summary>
/// 更新设备的信息
/// </summary>
/// <param name="info"></param>
/// <returns>返回更新设备信息等级 0表示无关 1表示低级 2表示中等 3表示高级</returns>
public void UpdateDeviceInfo(DeviceInfo info)
{
device.plat = info.plat;
device.wmsty = info.wmsty;
device.loginsty = info.loginsty;
device.wifimac = info.wifimac;
device.wifissd = info.wifissd;
device.ip = info.ip;
device.phone_imei = info.phone_imei;
device.weidu = info.weidu;
device.jingdu = info.jingdu;
device.city = info.city;
device.province = info.province;
device.district = info.district;
device.address = info.address;
}
/// <summary>
/// 更新玩家状态_自动运算
/// </summary>
public virtual void UpdatePlayerState()
{
if (state == (int)PlayerState.Ready)
{
//准备
dskState = DeskPlayerState.Ready;
}
else if (state == (int)PlayerState.Desk)
{
//在桌上
dskState = DeskPlayerState.Desk;
}
else if (state == (int)PlayerState.War)
{
if (outline == 1)
{
//离线
dskState = DeskPlayerState.OutLine;
}
// else if (isDePosit)
// {
// //托管
// dskState = DeskPlayerState.DePosit;
// }
else if (isastable)
{
//网络不稳定
dskState = DeskPlayerState.astable;
}
else
dskState = DeskPlayerState.War;
}
else
{
//没在桌上
dskState = DeskPlayerState.None;
}
}
/// <summary>
///
/// </summary>
public playerData()
{
id = -1;
gameid = -1;
roomid = -1;
tingid = -1;
deskid = -1;
seat = -1;
readCtDown = -1;
dskState = DeskPlayerState.None;
setMettle();
}
/// <summary>
/// 设置玩家性格
/// </summary>
private void setMettle()
{
Random random = new Random();
int r = random.Next(0, 100);
int a, b, c, d;
if (r < 18)
a = 1;
else if (r < 36)
a = 2;
else if (r < 68)
a = 3;
else
a = 4;
r = random.Next(0, 100);
if (r <= 80)
b = 10;
else if (r <= 90)
b = 20;
else
b = 30;
c = (random.Next(2) + 1) * 100;
r = random.Next(0, 100);
if (r < 80)
d = 1000;
else
d = 2000;
mettle = a + b + c + d;
}
/// <summary>
/// 获取状态字符串信息
/// </summary>
/// <returns></returns>
public string StateToString()
{
switch (state)
{
case 0:
return "不在游戏中";
case 1:
return "进入游戏";
case 2:
return "在桌上";
case 3:
return "准备好了";
case 4:
return "开战中";
}
return "Error State : " + state;
}
/// <summary>
/// 获取用户类型字符串信息
/// </summary>
/// <returns></returns>
public string UserTypeToString()
{
switch (userType)
{
case 0:
return "普通用户";
case 100:
return "微信登录用户";
case 110:
return "微信绑定用户";
case 200:
return "QQ登录用户";
case 300:
return "苹果登录用户";
case 400:
return "华为登录用户";
}
return "Error UserType : " + userType;
}
/// <summary>
///
/// </summary>
/// <returns></returns>
public override string ToString()
{
StringBuilder sbl = new StringBuilder();
sbl.Append("id:" + id + "\r\n");
sbl.Append("userid:" + userid + "\r\n");
sbl.Append("sex:" + sex + "\r\n");
sbl.Append("地区:" + area + "\r\n");
sbl.Append("昵称:" + nickname + "\r\n");
sbl.Append("游戏币:" + money + "\r\n");
sbl.Append("金币:" + gold + "\r\n");
sbl.Append("奖券:" + coupon + "\r\n");
sbl.Append("经验:" + exp + "\r\n");
sbl.Append("是否离线:" + outline + Environment.NewLine);
sbl.Append("玩家状态:" + StateToString() + "\r\n");
sbl.Append("房卡:" + fangka + "\r\n");
sbl.Append("魅力:" + Charm + "\r\n");
sbl.Append("玩家所在游戏:" + gameid + "\r\n");
sbl.Append("玩家的房间号:" + roomid + "\r\n");
sbl.Append("玩家所在的厅:" + tingid + "\r\n");
sbl.Append("玩家所在的桌子:" + deskid + "\r\n");
sbl.Append("玩家的座位号:" + seat + "\r\n");
//sbl.Append("剩余准备时间:" + readCtDown + "\r\n");
sbl.Append("用户类型:" + UserTypeToString() + "\r\n");
sbl.Append("代理:" + daili + "\r\n");
sbl.Append("钻石：" + MatchRoll + "\r\n");
sbl.Append("pi:" + pi + "\r\n");
sbl.Append("注册时间:" + RegTime + "\r\n");
sbl.Append("是否比赛中:" + IsJoinMatch + "\r\n");
return sbl.ToString();
}
/// <summary>
/// 玩家托管状态变化事件
/// </summary>
[JsonIgnore]
public Action<playerData> DepositChange;
#if Server
public void SetDeposit(bool value)
{
if (isDePosit != value)
{
isDePosit = value;
try
{
DepositChange?.Invoke(this);
}
catch (Exception e)
{
Debug.Error($"托管状态改变出错:{e.Message}");
}
}
}
#endif
}
}

57
NetWorkMessage/GameData/Common/PlayerGameInfo.cs Normal file
View File

@ -0,0 +1,57 @@
using System;
namespace GameData {
/// <summary>
/// 玩家的游戏信息
/// </summary>
public class PlayerGameInfo {
/// <summary>
/// 玩家所在游戏的服务器id 小于等于0表示未在任何游戏中
/// </summary>
public int game_serid;
/// <summary>
/// 是否是在朋友房 小于等0 表示未在朋友房
/// </summary>
public int isFriendRoom;
/// <summary>
/// 玩家点击的游戏_game_serid;
/// </summary>
public int clickGame;
/// <summary>
/// 1表示提示玩家 2让客户端立即进入
/// </summary>
public int style;
/// <summary>
///
/// </summary>
public PlayerGameInfo(){ }
/// <summary>
///
/// </summary>
/// <param name="game_serid">game_serid</param>
/// <param name="isFriendRoom">所在朋友房房间号</param>
/// <param name="style">类型1表示提示玩家 2表示让客户端立即进入</param>
/// <param name="clickGame">点击的游戏</param>
public PlayerGameInfo(int game_serid,int isFriendRoom,int style,int clickGame) {
this.game_serid = game_serid;
this.isFriendRoom = isFriendRoom;
this.style = style;
this.clickGame = clickGame;
}
/// <summary>
///
/// </summary>
/// <returns></returns>
public override string ToString() {
return "game_serid: " + game_serid + ",FriendRoom:" + isFriendRoom + ",clickGame:" + clickGame;
}
}
}

47
NetWorkMessage/GameData/Common/PlayerState.cs Normal file
View File

@ -0,0 +1,47 @@
/*
* 由SharpDevelop创建。
* 用户： Administrator
* 日期: 2018-10-19
* 时间: 9:16
*
* 要改变这种模板请点击 工具|选项|代码编写|编辑标准头文件
*/
using System;
namespace GameData
{
/// <summary>
/// 玩家状态
/// </summary>
public enum PlayerState{
/// <summary>
/// 不在游戏中
/// </summary>
NOGame = 0,
/// <summary>
/// 进入游戏
/// </summary>
INGame = 1,
/// <summary>
/// 在桌上
/// </summary>
Desk = 2,
/// <summary>
/// 准备好了
/// </summary>
Ready = 3,
/// <summary>
/// 开战中
/// </summary>
War = 4,
/// <summary>
/// 观战
/// </summary>
LookOn=5
}
}

88
NetWorkMessage/GameData/Common/Prize.cs Normal file
View File

@ -0,0 +1,88 @@
#if Server
using System;
namespace GameData
{
/// <summary>
/// 奖品
/// </summary>
[Serializable]
public class Prize
{
/// <summary>
/// 名次
/// </summary>
public int Index;
/// <summary>
/// 奖励的游戏币
/// </summary>
public int Winmoney;
/// <summary>
/// 奖励的礼券
/// </summary>
public int Wincoupon;
/// <summary>
/// 房卡
/// </summary>
public int CarNum;
/// <summary>
/// 红包积分--1积分等于1分
/// </summary>
public int RedEnvelopes;
/// <summary>
/// 参赛券
/// </summary>
public int CanSaiJuan;
/// <summary>
/// 都市放心购电子券，值是放心购卡的面值。比如20，就是放心购20元的电子券
/// </summary>
public int DSFXGVoucherNum;
/// <summary>
/// 复活卡
/// </summary>
public int FuHuoKa;
/// <summary>
/// 实物黄金
/// </summary>
public float RealGlod;
public AwardInfoPack GetAward()
{
return new AwardInfoPack()
{
Money = this.Winmoney,
CarNum = this.CarNum,
Coupon = this.Wincoupon,
RedEnvelopes = this.RedEnvelopes,
CanSaiJuan = this.CanSaiJuan,
DSFXGVoucherNum = this.DSFXGVoucherNum,
FuHuoKa = this.FuHuoKa,
RealGold = this.RealGlod,
};
}
public Prize Clone() {
return new Prize
{
Index=this.Index,
Winmoney=this.Winmoney,
Wincoupon=this.Wincoupon,
CarNum = this.CarNum,
RedEnvelopes =this.RedEnvelopes,
CanSaiJuan =this.CanSaiJuan,
DSFXGVoucherNum = this.DSFXGVoucherNum,
FuHuoKa = this.FuHuoKa,
RealGlod = this.RealGlod,
};
}
}
}
#endif

48
NetWorkMessage/GameData/Common/PropsConfig.cs Normal file
View File

@ -0,0 +1,48 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace GameData
{
/// <summary>
/// 道具配置
/// </summary>
public class PropsConfig
{
/// <summary>
///
/// </summary>
public static List<PropsInformation> list = new List<PropsInformation> {
new PropsInformation{ PropsId=1,Money=1000,Name="鲜花",Charm=1} ,
new PropsInformation{ PropsId=2,Money=1000,Name="砖头",Charm=-1}
};
}
/// <summary>
/// 道具信息
/// </summary>
public class PropsInformation
{
/// <summary>
/// 道具Id
/// </summary>
public int PropsId;
/// <summary>
/// 钱
/// </summary>
public int Money;
/// <summary>
/// 道具名称
/// </summary>
public string Name;
/// <summary>
/// 道具的魅力值
/// </summary>
public int Charm;
}
}

12
NetWorkMessage/GameData/Common/Race/DeskPlayScore.cs Normal file
View File

@ -0,0 +1,12 @@
using System;
namespace GameData.Race
{
[Serializable]
public class DeskPlayScore
{
public int UserId;
public int Score;//分数
public byte ju;
}
}

11
NetWorkMessage/GameData/Common/Race/DeskPlayer.cs Normal file
View File

@ -0,0 +1,11 @@
namespace GameData.Race
{
public class DeskPlayer
{
public int UserId;
public int Seat;
public int Score;
public int sex;
public string Name;
}
}

62
NetWorkMessage/GameData/Common/Race/LunGameResultPack.cs Normal file
View File

@ -0,0 +1,62 @@
using System;
namespace GameData.Race
{
/// <summary>
/// 告诉玩家淘汰还是晋级
/// </summary>
[Serializable]
public class LunGameResultPack
{
/// <summary>
/// 1晋级 2淘汰 3轮空晋级
/// </summary>
public byte IsOver;
/// <summary>
/// 第几轮
/// </summary>
public int CurrentLun;
/// <summary>
/// 总轮数
/// </summary>
public int LunCount;
#if Server
/// <summary>
/// 比赛内存
/// </summary>
public Object Match;
#else
/// <summary>
/// 比赛内存
/// </summary>
public FixedMatchMemroy Match;
#endif
/// <summary>
/// 总人数
/// </summary>
public int PeopleCount;
/// <summary>
/// 标题
/// </summary>
public string Title;
/// <summary>
/// 名次
/// </summary>
public int Index;
/// <summary>
/// 奖励信息，为空就是没有奖励
/// </summary>
public AwardInfoPack AwardInfo;
/// <summary>
/// 比赛是否结束
/// </summary>
public bool IsMatchOver;
}
}

54
NetWorkMessage/GameData/Common/Race/UserRevivePack.cs Normal file
View File

@ -0,0 +1,54 @@
using System;
namespace GameData.Race
{
[Serializable]
public class UserRevivePack
{
#region 这些是服务器赋值发给客户端，客户端不用修改。直接原封不动的发给服务器回来
/// <summary>
/// 玩家Id
/// </summary>
public int UserId;
/// <summary>
/// 比赛key
/// </summary>
public long MatchKey;
/// <summary>
/// 第几轮，从0开始
/// </summary>
public int LunCount;
/// <summary>
/// true淘汰 false未淘汰（不淘汰的不发复活包）
/// </summary>
public bool IsOver;
/// <summary>
/// 当前名次
/// </summary>
public byte Index;
//界面显示的需要使用几张复活卡和等待几秒 客户端自己从轮配置里面取。
#endregion
/// <summary>
/// 是否使用复活卡 true使用 false不使用 --客户端需要修改该值
/// </summary>
public bool IsUser;
/// <summary>
/// 校验数据是否合法
/// </summary>
/// <returns></returns>
public bool CheckData()
{
if (UserId <= 0 || MatchKey <= 0 || LunCount < 0) return false;
return true;
}
}
}

84
NetWorkMessage/GameData/Common/ResName.cs Normal file
View File

@ -0,0 +1,84 @@
namespace GameData
{
/// <summary>
/// 资源名称
/// </summary>
public static class ResName
{
/// <summary>
/// 房卡
/// </summary>
public const int RoomCard = 10001;
/// <summary>
/// 钻石
/// </summary>
public const int Diamond = 10002;
/// <summary>
/// 金币
/// </summary>
public const int Gold = 10003;
/// <summary>
/// 复活卡
/// </summary>
public const int ReviveCard = 10004;
/// <summary>
/// 公会令
/// </summary>
public const int ClubToken = 10005;
/// <summary>
/// 总公会令
/// </summary>
public const int ClubSuperToken = 10006;
/// <summary>
/// 参赛券
/// </summary>
public const int MatchCard = 10007;
/// <summary>
/// 门票
/// </summary>
public const int Ticket = 10008;
/// <summary>
/// 礼券
/// </summary>
public const int Wincoupon = 10009;
/// <summary>
/// 红卡
/// </summary>
public const int RedMoney = 10010;
/// <summary>
/// 记牌器
/// </summary>
public const int HandTracker = 200000;
}
public static class ResFunc
{
public static int GetEmailNewResId(int orgId)
{
if (orgId > 10) return orgId;
switch (orgId)
{
case 0: return ResName.Gold;
case 1: return ResName.RoomCard;
case 2: return ResName.Wincoupon;
case 3: return ResName.Diamond;
case 4: return ResName.ReviveCard;
case 5: return ResName.MatchCard;
case 7: return ResName.Ticket;
}
return orgId;
}
}
}

81
NetWorkMessage/GameData/Common/SceneManager.cs Normal file
View File

@ -0,0 +1,81 @@
/*
* 由SharpDevelop创建。
* 用户： Administrator
* 日期: 2019-01-26
* 时间: 16:13
*
* 要改变这种模板请点击 工具|选项|代码编写|编辑标准头文件
*/
using System;
namespace GameData
{
/// <summary>
/// 场景类型
/// </summary>
public enum SceneType
{
/// <summary>
/// 登录 特殊情况
/// </summary>
Login = -1,
/// <summary>
/// 主界面 还没进入子游戏
/// </summary>
Main = 0,
/// <summary>
/// 进入子游戏
/// </summary>
InGame = 1,
/// <summary>
/// 在子游戏桌子上
/// </summary>
Desk = 2,
/// <summary>
/// 在竞技比赛中
/// </summary>
Club = 3,
}
/// <summary>
/// 场景变化包裹
/// </summary>
public class ChangeScenePack{
/// <summary>
/// 当前应该在的场景
/// </summary>
public int scene;
/// <summary>
/// 玩家数据
/// </summary>
public playerData data;
/// <summary>
///
/// </summary>
public ChangeScenePack(){}
/// <summary>
///
/// </summary>
/// <param name="scene"></param>
/// <param name="data">玩家数据</param>
public ChangeScenePack(int scene,playerData data) {
this.scene = scene;
this.data = data;
}
/// <summary>
///
/// </summary>
/// <param name="type"></param>
public ChangeScenePack(SceneType type){
this.scene = (int)type;
}
}
}

82
NetWorkMessage/GameData/Common/SocketRegResult.cs Normal file
View File

@ -0,0 +1,82 @@
using System;
using System.Text;
namespace GameData
{
/// <summary>
/// socket注册结果包
/// </summary>
public class SocketRegResult
{
/// <summary>
/// 1成功! -1玩家登录太久了，请重新登录 -2提示账号在线,询问是否要挤下玩家 -3数据异常 -4您在别处登录
/// </summary>
public int result;
/// <summary>
///
/// </summary>
public string rltStr;
/// <summary>
/// 玩家数据
/// </summary>
public playerData pldata;
/// <summary>
///
/// </summary>
public SocketRegResult()
{
}
/// <summary>
///
/// </summary>
/// <param name="style"></param>
/// <returns></returns>
public static SocketRegResult GetSocketRegResult(int style)
{
SocketRegResult result = new SocketRegResult();
result.result = style;
switch (style)
{
case -1:
result.rltStr = "登录过期，请重新登录!";
break;
case -2:
result.rltStr = "您的账号在别处登录，是否继续!";
break;
case -3:
result.rltStr = "登录失败,请稍后再试!";
break;
case -4:
result.rltStr = "您在别处登录!";
break;
case 1:
result.rltStr = "登录成功!";
break;
}
return result;
}
/// <summary>
///
/// </summary>
/// <returns></returns>
public override string ToString()
{
StringBuilder sb = new StringBuilder();
sb.Append("result:");
sb.Append(result);
sb.Append(Environment.NewLine);
sb.Append("结果字符:");
sb.Append(rltStr);
sb.Append(Environment.NewLine);
sb.Append("玩家数据:");
sb.Append(pldata.ToString());
return sb.ToString();
}
}
}

50
NetWorkMessage/GameData/Common/TingConfig.cs Normal file
View File

@ -0,0 +1,50 @@
#if Server
/*
* 由SharpDevelop创建。
* 用户： Administrator
* 日期: 2018-10-20
* 时间: 13:49
*
* 要改变这种模板请点击 工具|选项|代码编写|编辑标准头文件
*/
using System;
using System.Xml;
using System.Text;
namespace GameData {
/// <summary>
/// 厅配置
/// </summary>
public class TingConfig {
/// <summary>
/// 厅的id
/// </summary>
public int id;
/// <summary>
/// 桌子数量 小于等于0表示自动创建房间 >0表示预先好创建房间
/// </summary>
public int deskCnt;
/// <summary>
/// 最小开战人数
/// </summary>
public int warCnt;
/// <summary>
/// 最大开战人数
/// </summary>
public int maxCnt;
/// <summary>
/// 厅规则 长度为50;
/// </summary>
public string tingGz;
/// <summary>
///
/// </summary>
public TingConfig() { }
}
}
#endif

18
NetWorkMessage/Message/Base/MessageAttribute.cs Normal file
View File

@ -0,0 +1,18 @@
using System;
namespace GameMessage
{
[AttributeUsage(AttributeTargets.Class)]
public class MessageAttribute : Attribute
{
public int Opcode
{
get;
}
public MessageAttribute(int opcode)
{
this.Opcode = opcode;
}
}
}

599
NetWorkMessage/Message/Base/MessageCode.Club.cs Normal file
View File

@ -0,0 +1,599 @@
namespace GameMessage
{
public static partial class MessageCode
{
#region GameClubMsgId 70000 - 79999
/// <summary>
/// 心跳包
/// </summary>
public const int GameClubHeart = 70000;
/// <summary>
/// 俱乐部游戏数据版本请求
/// </summary>
public const int ClubDataVerRequest = 70001;
/// <summary>
/// 俱乐部游戏数据版本响应
/// </summary>
public const int ClubDataVerResponse = 70002;
/// <summary>
/// 俱乐部玩法数据请求
/// </summary>
public const int ClubDataPlayWayRequest = 70003;
/// <summary>
/// 俱乐部玩法数据响应
/// </summary>
public const int ClubDataPlayWayResponse = 70004;
/// <summary>
/// 俱乐部桌子数据请求
/// </summary>
public const int ClubDataAllDeskInfoRequest = 70005;
/// <summary>
/// 俱乐部桌子数据响应
/// </summary>
public const int ClubDataAllDeskInfoResponse = 70006;
/// <summary>
/// 俱乐部比赛数据请求
/// </summary>
public const int ClubMatchScoreRequest = 70007;
/// <summary>
/// 俱乐部比赛数据响应
/// </summary>
public const int ClubMatchScoreResponse = 70008;
/// <summary>
/// 获取联赛权限请求
/// </summary>
public const int ClubLeaguePowerRequest = 70009;
/// <summary>
/// 获取联赛权限响应
/// </summary>
public const int ClubLeaguePowerResponse = 70010;
/// <summary>
/// 修改玩家俱乐部积分请求
/// </summary>
public const int EditorClubMatchScoreRequest = 70011;
/// <summary>
/// 修改玩家俱乐部积分响应
/// </summary>
public const int EditorClubMatchScoreResponse = 70012;
/// <summary>
/// 俱乐部隐藏玩法请求
/// </summary>
public const int ClubHideWaysRequest = 70013;
/// <summary>
/// 俱乐部隐藏玩法响应
/// </summary>
public const int ClubHideWaysResponse = 70014;
/// <summary>
/// 获取俱乐部比赛设置请求
/// </summary>
public const int ClubMatchSettingRequest = 70015;
/// <summary>
/// 获取俱乐部比赛设置响应
/// </summary>
public const int ClubMatchSettingResponse = 70016;
/// <summary>
/// 玩家比赛积分请求
/// </summary>
public const int PlayerMatchScoreRequest = 70017;
/// <summary>
/// 玩家比赛积分响应
/// </summary>
public const int PlayerMatchScoreResponse = 70018;
/// <summary>
/// 设置俱乐部管理权限请求
/// </summary>
public const int ClubManagerPowerRequest = 70019;
/// <summary>
/// 设置俱乐部管理权限响应
/// </summary>
public const int ClubManagerPowerResponse = 70020;
/// <summary>
/// 俱乐部管理员玩家设置
/// </summary>
public const int ClubManagerPersonRequest = 70021;
/// <summary>
/// 俱乐部管理员玩家设置响应
/// </summary>
public const int ClubManagerPersonResponse = 70022;
/// <summary>
/// 俱乐部玩家退出/踢出请求
/// </summary>
public const int ClubQuitRequest = 70023;
/// <summary>
/// 俱乐部玩家退出/踢出响应
/// </summary>
public const int ClubQuitResponse = 70024;
/// <summary>
/// 俱乐部玩家正常请求
/// </summary>
public const int ClubNormalQuitRequest = 70025;
/// <summary>
/// 俱乐部玩家正常响应
/// </summary>
public const int ClubNormalQuitResponse = 70026;
/// <summary>
/// 重赛审核，退赛处理请求
/// </summary>
public const int ClubMatchQuitDealRequest = 70027;
/// <summary>
/// 重赛审核，退赛处理响应
/// </summary>
public const int ClubMatchQuitDealResponse = 70028;
/// <summary>
/// 俱乐部消息处理请求
/// </summary>
public const int ClubDoMessageRequest = 70029;
/// <summary>
/// 俱乐部消息处理响应
/// </summary>
public const int ClubDoMessageResponse = 70030;
/// <summary>
/// 俱乐部玩家自身请求
/// </summary>
public const int ClubPlayerSelfRequest = 70031;
/// <summary>
/// 俱乐部玩家自身响应
/// </summary>
public const int ClubPlayerSelfResponse = 70032;
/// <summary>
/// 联赛俱乐部信息请求
/// </summary>
public const int LeagueClubsInfoRequest = 70033;
/// <summary>
/// 联赛俱乐部信息响应
/// </summary>
public const int LeagueClubsInfoResponse = 70034;
/// <summary>
/// 联赛颁奖
/// </summary>
public const int LeagueAwardRequest = 70035;
/// <summary>
/// 联赛颁奖响应
/// </summary>
public const int LeagueAwardResponse = 70036;
/// <summary>
/// 俱乐部基本信息请求
/// </summary>
public const int AllClubBasicInfoRequest = 70037;
/// <summary>
/// 俱乐部基本信息响应
/// </summary>
public const int AllClubBasicInfoResponse = 70038;
/// <summary>
/// 俱乐部比赛信息请求
/// </summary>
public const int ClubMatchInfoRequest = 70039;
/// <summary>
/// 俱乐部比赛信息响应
/// </summary>
public const int ClubMatchInfoResponse = 70040;
/// <summary>
/// 俱乐部战斗记录请求
/// </summary>
public const int ClubFightRecordRequest = 70041;
/// <summary>
/// 俱乐部战斗记录响应
/// </summary>
public const int ClubFightRecordResponse = 70042;
/// <summary>
/// 俱乐部战斗记录统计请求
/// </summary>
public const int ClubFightRecordStatisticsRequest = 70043;
/// <summary>
/// 俱乐部战斗记录统计响应
/// </summary>
public const int ClubFightRecordStatisticsResponse = 70044;
/// <summary>
/// 俱乐部创建请求
/// </summary>
public const int ClubCreateRequest = 70045;
/// <summary>
/// 俱乐部创建响应
/// </summary>
public const int ClubCreateResponse = 70046;
/// <summary>
/// 俱乐部编辑基本信息请求
/// </summary>
public const int ClubEditorBasicInfoRequest = 70047;
/// <summary>
/// 俱乐部编辑基本信息响应
/// </summary>
public const int ClubEditorBasicInfoResponse = 70048;
/// <summary>
/// 俱乐部卡牌转换请求
/// </summary>
public const int ClubCardTransferInRequest = 70049;
/// <summary>
/// 俱乐部卡牌转换响应
/// </summary>
public const int ClubCardTransferInResponse = 70050;
/// <summary>
/// 俱乐部加入申请请求
/// </summary>
public const int ClubJoinApplyRequest = 70051;
/// <summary>
/// 俱乐部加入申请响应
/// </summary>
public const int ClubJoinApplyResponse = 70052;
/// <summary>
/// 俱乐部玩家编辑请求
/// </summary>
public const int ClubPlayerEditorRequest = 70053;
/// <summary>
/// 俱乐部玩家编辑响应
/// </summary>
public const int ClubPlayerEditorResponse = 70054;
/// <summary>
/// 俱乐部消息请求
/// </summary>
public const int ClubMsgRequest = 70055;
/// <summary>
/// 俱乐部消息响应
/// </summary>
public const int ClubMsgResponse = 70056;
/// <summary>
/// 俱乐部群组封禁编辑请求
/// </summary>
public const int ClubBanGroupEditorRequest = 70057;
/// <summary>
/// 俱乐部群组封禁编辑响应
/// </summary>
public const int ClubBanGroupEditorResponse = 70058;
/// <summary>
/// 俱乐部群组封禁获取请求
/// </summary>
public const int ClubBanGroupGetRequest = 70059;
/// <summary>
/// 俱乐部群组封禁获取响应
/// </summary>
public const int ClubBanGroupGetResponse = 70060;
/// <summary>
/// 俱乐部解散桌子请求
/// </summary>
public const int ClubDisbandDeskRequest = 70061;
/// <summary>
/// 俱乐部解散桌子响应
/// </summary>
public const int ClubDisbandDeskResponse = 70062;
/// <summary>
/// 俱乐部卡牌转换记录请求
/// </summary>
public const int ClubCardTransferRecordRequest = 70063;
/// <summary>
/// 俱乐部卡牌转换记录响应
/// </summary>
public const int ClubCardTransferRecordResponse = 70064;
/// <summary>
/// 俱乐部黑名单房间获取请求
/// </summary>
public const int ClubBlackRoomGetRequest = 70065;
/// <summary>
/// 俱乐部黑名单房间获取响应
/// </summary>
public const int ClubBlackRoomGetResponse = 70066;
/// <summary>
/// 俱乐部获取我的记录数据请求
/// </summary>
public const int ClubGetMyRecordDataRequest = 70067;
/// <summary>
/// 俱乐部获取我的记录数据响应
/// </summary>
public const int ClubGetMyRecordDataResponse = 70068;
/// <summary>
/// 俱乐部统计请求
/// </summary>
public const int ClubStatisticsRequest = 70069;
/// <summary>
/// 俱乐部统计响应
/// </summary>
public const int ClubStatisticsResponse = 70070;
/// <summary>
/// 俱乐部玩家战斗统计请求
/// </summary>
public const int ClubPlayerFightStatisticsRequest = 70071;
/// <summary>
/// 俱乐部玩家战斗统计响应
/// </summary>
public const int ClubPlayerFightStatisticsResponse = 70072;
/// <summary>
/// 俱乐部合伙人编辑请求
/// </summary>
public const int ClubPartnerEditorRequest = 70073;
/// <summary>
/// 俱乐部合伙人编辑响应
/// </summary>
public const int ClubPartnerEditorResponse = 70074;
/// <summary>
/// 俱乐部录像数据请求
/// </summary>
public const int ClubReplayDataRequest = 70075;
/// <summary>
/// 俱乐部录像数据响应
/// </summary>
public const int ClubReplayDataResponse = 70076;
/// <summary>
/// 俱乐部合伙人成员请求
/// </summary>
public const int ClubPartnerMembersRequest = 70077;
/// <summary>
/// 俱乐部合伙人成员响应
/// </summary>
public const int ClubPartnerMembersResponse = 70078;
/// <summary>
/// 俱乐部非合伙人搜索请求
/// </summary>
public const int ClubNotPartnerSearchRequest = 70079;
/// <summary>
/// 俱乐部非合伙人搜索响应
/// </summary>
public const int ClubNotPartnerSearchResponse = 70080;
/// <summary>
/// 俱乐部合伙人列表获取请求
/// </summary>
public const int ClubPartnerListGetRequest = 70081;
/// <summary>
/// 俱乐部合伙人列表获取响应
/// </summary>
public const int ClubPartnerListGetResponse = 70082;
/// <summary>
/// 俱乐部合伙人统计请求
/// </summary>
public const int ClubPartnerStatisticsRequest = 70083;
/// <summary>
/// 俱乐部合伙人统计响应
/// </summary>
public const int ClubPartnerStatisticsResponse = 70084;
/// <summary>
/// 俱乐部合伙人编辑用户请求
/// </summary>
public const int ClubPartnerEditorUserRequest = 70085;
/// <summary>
/// 俱乐部合伙人编辑用户响应
/// </summary>
public const int ClubPartnerEditorUserResponse = 70086;
/// <summary>
/// 俱乐部合伙人加入申请请求
/// </summary>
public const int ClubPartnerJoinApplyRequest = 70087;
/// <summary>
/// 俱乐部合伙人加入申请响应
/// </summary>
public const int ClubPartnerJoinApplyResponse = 70088;
/// <summary>
/// 申请加入联赛请求
/// </summary>
public const int ClubLeagueJoinApplyRequest = 70089;
/// <summary>
/// 申请加入联赛响应
/// </summary>
public const int ClubLeagueJoinApplyResponse = 70090;
/// <summary>
/// 俱乐部加入桌子请求
/// </summary>
public const int ClubJoinDeskRequest = 70091;
/// <summary>
/// 俱乐部加入桌子响应
/// </summary>
public const int ClubJoinDeskResponse = 70092;
/// <summary>
/// 更新俱乐部基础信息
/// </summary>
public const int UpdateClubBasicInfoResponse = 70093;
/// <summary>
/// 获取俱乐部普通信息请求
/// </summary>
public const int GetClubNormalInfoRequest = 70094;
public const int GetClubNormalInfoResponse = 70095;
/// <summary>
/// 搜索俱乐部玩家请求
/// </summary>
public const int SearchClubPlayerRequest = 70096;
public const int SearchClubPlayerResponse = 70097;
/// <summary>
/// 搜索游戏玩家请求
/// </summary>
public const int SearchGamePlayerRequest = 70098;
public const int SearchGamePlayerResponse = 70099;
/// <summary>
/// 踢出桌上玩家请求
/// </summary>
public const int KickOutPlayerOfDeskRequest = 70100;
public const int KickOutPlayerOfDeskResponse = 70101;
/// <summary>
/// 俱乐部执行回放请求
/// </summary>
public const int ClubDoFightRecordRequest = 70102;
public const int ClubDoFightRecordResponse = 70103;
/// <summary>
/// 注销俱乐部请求
/// </summary>
public const int ClubDeleteRequest = 70104;
public const int ClubDeleteResponse = 70105;
/// <summary>
/// 比赛排行，用户积分日志
/// </summary>
public const int ClubMatchUserScoreNotesRequest = 70106;
public const int ClubMatchUserScoreNotesResponse = 70107;
/// <summary>
/// 获取比赛玩家积分
/// </summary>
public const int ClubMatchUserScoresRequest = 70108;
public const int ClubMatchUserScoresResponse = 70109;
/// <summary>
/// 获取比赛玩家积分搜索
/// </summary>
public const int ClubMatchUserScoreSearchRequest = 70110;
public const int ClubMatchUserScoreSearchResponse = 70111;
/// <summary>
/// 更新俱乐部设置
/// </summary>
public const int ClubUpdateSettingRequest = 70112;
public const int ClubUpdateSettingResponse = 70113;
/// <summary>
/// 解锁联赛权限
/// </summary>
public const int ClubLeagueUnlockPowerRequest = 70141;
public const int ClubLeagueUnlockPowerResponse = 70142;
/// <summary>
/// 俱乐部联赛设置
/// </summary>
public const int ClubLeagueSetMatchSetRequest = 70143;
public const int ClubLeagueSetMatchSetResponse = 70144;
/// <summary>
/// 生存积分列表
/// </summary>
public const int ClubLeagueGetLifeTasksRequest = 70145;
public const int ClubLeagueGetLifeTasksResponse = 70146;
/// <summary>
/// 发布生存任务
/// </summary>
public const int ClubLeaguePublishLiveTaskRequest = 70147;
public const int ClubLeaguePublishLiveTaskResponse = 70148;
/// <summary>
/// 重置俱乐部最终积分 （解禁）
/// </summary>
public const int ClubLeagueResetFinScoreRequest = 70149;
public const int ClubLeagueResetFinScoreResponse = 70150;
/// <summary>
/// 俱乐部排行榜
/// </summary>
public const int ClubLeagueMatchRankListRequest = 70151;
public const int ClubLeagueMatchRankListResponse = 70152;
/// <summary>
/// 俱乐部比赛列表
/// </summary>
public const int ClubMatchListRequest = 70153;
public const int ClubMatchListResponse = 70154;
/// <summary>
/// 俱乐部颁奖记录
/// </summary>
public const int ClubMatchAwardLogRequest = 70155;
public const int ClubMatchAwardLogResponse = 70156;
/// <summary>
/// 俱乐部颁奖记录详情（包涵了解禁之类的数据）
/// </summary>
public const int ClubMatchAwardDetailLogRequest = 70157;
public const int ClubMatchAwardDetailLogResponse = 70158;
/// <summary>
/// 俱乐部退赛请求
/// </summary>
public const int ClubMatchQuitRequest = 70159;
public const int ClubMatchQuitResponse = 70160;
#endregion GameClubMsgId
}
}

24
NetWorkMessage/Message/Base/MessageCode.Game.cs Normal file
View File

@ -0,0 +1,24 @@
namespace GameMessage
{
public partial class MessageCode
{
#region Game通用包协议号 10000 - 19999
/// <summary>
/// 绑定会话
/// </summary>
public const int BindSession = 10000;
/// <summary>
/// 客户端包裹请求
/// </summary>
public const int ClientPackRequest = 10001;
/// <summary>
/// 客户端包裹响应
/// </summary>
public const int ClientPackResponse = 10002;
#endregion
}
}

910
NetWorkMessage/Message/Base/MessageCode.GameCenter.cs Normal file
View File

@ -0,0 +1,910 @@
namespace GameMessage
{
public static partial class MessageCode
{
#region GameCenterMsgId 360000 - 369999
/// <summary>
/// 获取登录验证码
/// </summary>
public const int LoginVerificationRequest = 36106;
public const int LoginVerificationResponse = 36107;
/// <summary>
/// 微信扫码登录请求
/// </summary>
public const int LoginWxCodeRequest = 36108;
public const int LoginWxCodeResponse = 36109;
/// <summary>
/// 获取验证码
/// </summary>
public const int PhoneVerifyCodeRequest = 36110;
public const int PhoneVerifyCodeResponse = 36111;
/// <summary>
/// 自动登录协议
/// </summary>
public const int AutoLoginRequest = 36112;
public const int AutoLoginResponse = 36113;
/// <summary>
/// 账号绑定-绑定三方账号
/// </summary>
public const int AccountBindRequest = 36114;
public const int AccountBindResponse = 36115;
/// <summary>
/// 账号安全信息获取
/// </summary>
public const int AccountPrivateInfoRequest = 36116;
public const int AccountPrivateInfoResponse = 36117;
/// <summary>
/// 奖励通知
/// </summary>
public const int PlayerAwardNotify = 36118;
/// <summary>
/// 心跳包
/// </summary>
public const int GameCenterHeart = 360000;
/// <summary>
/// 游戏登录请求
/// </summary>
public const int LoginRequest = 360001;
/// <summary>
/// 游戏登录响应
/// </summary>
public const int LoginResponse = 360002;
/// <summary>
/// 小游戏token请求
/// </summary>
public const int MiniGameTokenRequest = 360003;
/// <summary>
/// 小游戏token响应
/// </summary>
public const int MiniGameTokenResponse = 360004;
/// <summary>
/// 道具数据请求 过时
/// </summary>
public const int PropDataRequest = 360005;
/// <summary>
/// 道具数据响应 过时
/// </summary>
public const int PropDataResponse = 360006;
/// <summary>
/// 邮件未读数量请求
/// </summary>
public const int EmlUnReadCntRequest = 360007;
/// <summary>
/// 邮件未读数量响应
/// </summary>
public const int EmlUnReadCntResponse = 360008;
/// <summary>
/// 所有未读邮件请求
/// </summary>
public const int EmlsUnReadRequest = 360009;
/// <summary>
/// 所有未读邮件响应
/// </summary>
public const int EmlsUnReadResponse = 360010;
/// <summary>
/// 读取邮件请求
/// </summary>
public const int ReadEmlRequest = 360011;
/// <summary>
/// 读取邮件响应
/// </summary>
public const int ReadEmlResponse = 360012;
/// <summary>
/// 我的游戏信息请求
/// </summary>
public const int MyGameInfoRequest = 360013;
/// <summary>
/// 我的游戏信息响应
/// </summary>
public const int MyGameInfoResponse = 360014;
/// <summary>
/// 玩家的基础信息请求
/// </summary>
public const int PlayerBasicInfoRequest = 360015;
/// <summary>
/// 玩家的基础信息响应
/// </summary>
public const int PlayerBasicInfoResponse = 360016;
/// <summary>
/// 服务器配置请求
/// </summary>
public const int ServerConfigRequest = 360017;
/// <summary>
/// 服务器配置响应
/// </summary>
public const int ServerConfigResponse = 360018;
/// <summary>
/// bug提交请求
/// </summary>
public const int BugReportRequest = 360019;
/// <summary>
/// bug提交响应
/// </summary>
public const int BugReportResponse = 360020;
/// <summary>
/// 用户名检测请求
/// </summary>
public const int UserNameCheckRequest = 360021;
/// <summary>
/// 用户名检测响应
/// </summary>
public const int UserNameCheckResponse = 360022;
/// <summary>
/// 用户注册请求
/// </summary>
public const int UserRegisterRequest = 360023;
/// <summary>
/// 用户注册响应
/// </summary>
public const int UserRegisterResponse = 360024;
/// <summary>
/// 实名认证请求
/// </summary>
public const int RealNameAuthRequest = 360025;
/// <summary>
/// 实名认证响应
/// </summary>
public const int RealNameAuthResponse = 360026;
/// <summary>
/// 注销请求
/// </summary>
public const int LogOutRequest = 360027;
/// <summary>
/// 注销响应
/// </summary>
public const int LogOutResponse = 360028;
/// <summary>
/// 商品数据请求
/// </summary>
public const int CommodityRequest = 360029;
/// <summary>
/// 商品数据响应
/// </summary>
public const int CommodityResponse = 360030;
/// <summary>
/// 实体商品请求
/// </summary>
public const int EntityCommodityRequest = 360031;
/// <summary>
/// 实体商品响应
/// </summary>
public const int EntityCommodityResponse = 360032;
/// <summary>
/// 兑换实体商品请求
/// </summary>
public const int ExChangeEntityCommodityRequest = 360033;
/// <summary>
/// 兑换实体商品响应
/// </summary>
public const int ExChangeEntityCommodityResponse = 360034;
/// <summary>
/// 兑换实体商品记录请求
/// </summary>
public const int ExChangeEntityRecordRequest = 360035;
/// <summary>
/// 兑换实体商品记录响应
/// </summary>
public const int ExChangeEntityRecordResponse = 360036;
/// <summary>
/// 兑换商品请求
/// </summary>
public const int ExchangeCommodityRequest = 360037;
/// <summary>
/// 兑换商品响应
/// </summary>
public const int ExchangeCommodityResponse = 360038;
/// <summary>
/// 红包券请求
/// </summary>
public const int HongBaoJuanRequest = 360039;
/// <summary>
/// 红包券响应
/// </summary>
public const int HongBaoJuanResponse = 360040;
/// <summary>
/// 玩家资产细节请求
/// </summary>
public const int AssetDetailRequest = 360041;
/// <summary>
/// 玩家资产细节响应
/// </summary>
public const int AssetDetailResponse = 360042;
/// <summary>
/// 福利数据请求
/// </summary>
public const int WelfareDataRequest = 360043;
/// <summary>
/// 福利数据响应
/// </summary>
public const int WelfareDataResponse = 360044;
/// <summary>
/// 保险箱操作请求
/// </summary>
public const int SafeBoxOperationRequest = 360045;
/// <summary>
/// 保险箱操作响应
/// </summary>
public const int SafeBoxOperationResponse = 360046;
/// <summary>
/// 救济金请求
/// </summary>
public const int ReliefRequest = 360047;
/// <summary>
/// 救济金响应
/// </summary>
public const int ReliefResponse = 360048;
/// <summary>
/// 转盘请求
/// </summary>
public const int TurnTableRequest = 360049;
/// <summary>
/// 转盘响应
/// </summary>
public const int TurnTableResponse = 360050;
/// <summary>
/// 签到宝箱领取请求
/// </summary>
public const int SignBoxRequest = 360051;
/// <summary>
/// 签到宝箱领取响应
/// </summary>
public const int SignBoxResponse = 360052;
/// <summary>
/// 广告礼包领取请求
/// </summary>
public const int AdGiftRequest = 360053;
/// <summary>
/// 广告礼包领取响应
/// </summary>
public const int AdGiftResponse = 360054;
/// <summary>
/// 加入房间请求
/// </summary>
public const int JoinRoomRequest = 360055;
/// <summary>
/// 加入房间响应
/// </summary>
public const int JoinRoomResponse = 360056;
/// <summary>
/// 摇树请求
/// </summary>
public const int ShakeTreeRequest = 360057;
/// <summary>
/// 摇树响应
/// </summary>
public const int ShakeTreeResponse = 360058;
/// <summary>
/// 激活推广请求
/// </summary>
public const int ActivatePromotionRequest = 360059;
/// <summary>
/// 激活推广响应
/// </summary>
public const int ActivatePromotionResponse = 360060;
/// <summary>
/// 获取推广信息请求
/// </summary>
public const int GetUserIsPromotionRequest = 360061;
/// <summary>
/// 获取推广信息响应
/// </summary>
public const int GetUserIsPromotionResponse = 360062;
/// <summary>
/// 获取推广员奖励请求
/// </summary>
public const int GetPromotionRewardDataRequest = 360063;
/// <summary>
/// 获取推广员奖励响应
/// </summary>
public const int GetPromotionRewardDataResponse = 360064;
/// <summary>
/// 获取排行榜请求
/// </summary>
public const int GetGameRankingRequest = 360065;
/// <summary>
/// 获取排行榜响应
/// </summary>
public const int GetGameRankingResponse = 360066;
/// <summary>
/// 获取定时赛数据积分比赛记录请求
/// </summary>
public const int GetFixedMatchDataByIdRequest = 360067;
/// <summary>
/// 获取定时赛数据积分比赛记录响应
/// </summary>
public const int GetFixedMatchDataByIdResponse = 360068;
/// <summary>
/// 获取回放数据请求
/// </summary>
public const int GetWarPlayerBackDataRequest = 360069;
/// <summary>
/// 获取回放数据响应
/// </summary>
public const int GetWarPlayerBackDataResponse = 360070;
/// <summary>
/// 钻石兑换房卡请求
/// </summary>
public const int DiamondExChangeFangKaRequest = 360071;
/// <summary>
/// 钻石兑换房卡响应
/// </summary>
public const int DiamondExChangeFangKaResponse = 360072;
/// <summary>
/// AppStore 票据核销请求
/// </summary>
public const int AppStorePayVerifyRequest = 360073;
/// <summary>
/// AppStore 票据核销响应
/// </summary>
public const int AppStorePayVerifyResponse = 360074;
/// <summary>
/// 祈福请求
/// </summary>
public const int PrayRequest = 360075;
/// <summary>
/// 祈福响应
/// </summary>
public const int PrayResponse = 360076;
/// <summary>
/// 黑名单上报请求
/// </summary>
public const int BlackListReportRequest = 360077;
/// <summary>
/// 黑名单上报响应
/// </summary>
public const int BlackListReportResponse = 360078;
/// <summary>
/// 实名信息请求
/// </summary>
public const int RealNameInfoRequest = 360079;
/// <summary>
/// 实名信息响应
/// </summary>
public const int RealNameInfoResponse = 360080;
/// <summary>
/// 编辑玩家性别或头像请求
/// </summary>
public const int EditorPlayerSexOrPhotoRequest = 360081;
/// <summary>
/// 编辑玩家性别或头像响应
/// </summary>
public const int EditorPlayerSexOrPhotoResponse = 360082;
/// <summary>
/// 玩家UserId 登录
/// </summary>
public const int UserIdLoginRequest = 360083;
/// <summary>
/// 游戏测试任务ID请求
/// </summary>
public const int GameTestTaskIdRequest = 360084;
/// <summary>
/// 游戏测试任务ID响应
/// </summary>
public const int GameTestTaskIdResponse = 360085;
/// <summary>
/// 更新维护通知响应
/// </summary>
public const int UpdateNotifierResponse = 360086;
/// <summary>
/// 服务器配置请求 版本2
/// </summary>
public const int ServerConfigRequestV2 = 360087;
/// <summary>
/// 服务器配置响应 版本2
/// </summary>
public const int ServerConfigResponseV2 = 360088;
/// <summary>
/// 华为购买请求
/// </summary>
public const int HuaWeiPayRequest = 360089;
/// <summary>
/// 华为购买响应
/// </summary>
public const int HuaWeiPayResponse = 360090;
/// <summary>
/// 搜索玩家信息请求
/// </summary>
public const int SearchPlayerInfoRequest = 360091;
/// <summary>
/// 搜索玩家信息响应
/// </summary>
public const int SearchPlayerInfoResponse = 360092;
/// <summary>
/// 推广员信息
/// </summary>
public const int PromoterInfoRequest = 360093;
public const int PromoterInfoResponse = 360094;
/// <summary>
/// 推广员下线注册信息
/// </summary>
public const int PromoterRegistrationRequest = 360095;
public const int PromoterRegistrationResponse = 360096;
/// <summary>
/// 推广员下线充值信息
/// </summary>
public const int PromoterCostRequest = 360097;
public const int PromoterCostResponse = 360098;
/// <summary>
/// 测试请求
/// </summary>
public const int GameCenter_TestRequest = 360100;
/// <summary>
/// 测试回复
/// </summary>
public const int GameCenter_TestResponse = 360101;
/// <summary>
/// 赠送道具
/// </summary>
public const int PropDataGiveRequest = 360102;
/// <summary>
/// 赠送道具
/// </summary>
public const int PropDataGiveResponse = 360103;
/// <summary>
/// 资产变更
/// </summary>
public const int PlayerPropertyRequest = 360104;
public const int PlayerPropertyResponse = 360105;
/// <summary>
/// 拉起支付
/// </summary>
public const int PayPrepareRequest = 360106;
public const int PayPrepareResponse = 360107;
/// <summary>
/// 支持成功通知
/// </summary>
public const int PayC2SNotifyRequest = 360108;
public const int PayC2SNotifyResponse = 360109;
/// <summary>
/// 获取账号信息，修改密码的Token
/// </summary>
public const int GetAccountInfoRequest = 360110;
public const int GetAccountInfoResponse = 360111;
/// <summary>
/// 修改密码处理
/// </summary>
public const int ResetPasswordRequest = 360112;
public const int ResetPasswordResponse = 360113;
/// <summary>
/// 设置账号密码
/// </summary>
public const int EditorUserPwdRequest = 360114;
public const int EditorUserPwdResponse = 360115;
/// <summary>
/// 道具数据请求 过时
/// </summary>
public const int PropDataRequestV2 = 360116;
/// <summary>
/// 道具数据响应 过时
/// </summary>
public const int PropDataResponseV2 = 360117;
/// <summary>
/// 获取朋友房记录请求
/// </summary>
public const int GetFriendRoomRecordListRequest = 360501;
/// <summary>
/// 获取朋友房记录响应
/// </summary>
public const int GetFriendRoomRecordListResponse = 360502;
/// <summary>
/// 获取朋友房战绩数据请求
/// </summary>
public const int GetFriendRoomFightDataRequest = 360503;
/// <summary>
/// 获取朋友房战绩数据响应
/// </summary>
public const int GetFriendRoomFightDataResponse = 360504;
/// <summary>
/// 获取金币场记录列表请求
/// </summary>
public const int GetCoinRecordListRequest = 360505;
/// <summary>
/// 获取金币场记录列表响应
/// </summary>
public const int GetCoinRecordListResponse = 360506;
/// <summary>
/// 获取游戏记录日志请求
/// </summary>
public const int GetGameGoldRecordLogRequest = 360507;
/// <summary>
/// 获取游戏记录日志响应
/// </summary>
public const int GetGameGoldRecordLogResponse = 360508;
/// <summary>
/// 测试消息
/// </summary>
public const int TestMessageRequest = 360509;
public const int TestMessageResponse = 360510;
/// <summary>
/// 获取年度 Match 信息请求
/// </summary>
public const int GetYearMatchInfoRequest = 360511;
/// <summary>
/// 获取年度 Match 信息响应
/// </summary>
public const int GetYearMatchInfoResponse = 360512;
/// <summary>
/// 请求微信授权
/// </summary>
public const int GetWxMiniLoginCodeRequest = 360513;
/// <summary>
/// 微信授权响应
/// </summary>
public const int GetWxMiniLoginCodeResponse = 360514;
/// <summary>
/// 更新用户信息 头像和昵称
/// </summary>
public const int UpdateUserInfoRequest = 360515;
public const int UpdateUserInfoResponse = 360516;
/// <summary>
/// 获取积分奖励列表请求
/// </summary>
public const int GetScoreRewardListRequest = 360517;
public const int GetScoreRewardListResponse = 360518;
/// <summary>
/// 领取积分奖励
/// </summary>
public const int ReceiveScoreRewardRequest = 360519;
public const int ReceiveScoreRewardResponse = 360520;
/// <summary>
/// 获取救助金领取次数
/// </summary>
public const int SubsidyCntRequest = 360521;
public const int SubsidyCntResponse = 360522;
/// <summary>
/// 救助金领取
/// </summary>
public const int SubsidyReceiveRequest = 360523;
public const int SubsidyReceiveResponse = 360524;
/// <summary>
/// 签到数据请求
/// </summary>
public const int SignDataRequest = 360525;
public const int SignDataResponse = 360526;
/// <summary>
/// 签到领取请求
/// </summary>
public const int SignReceiveRequest = 360527;
public const int SignReceiveResponse = 360528;
/// <summary>
/// 转盘数据请求
/// </summary>
public const int PrizeWheelDataRequest = 360529;
public const int PrizeWheelDataResponse = 360530;
/// <summary>
/// 转盘领取请求
/// </summary>
public const int PrizeWheelRewardRequest = 360531;
public const int PrizeWheelRewardResponse = 360532;
/// <summary>
/// 通用广告礼包数据
/// </summary>
public const int GeneralAdGiftDataRequest = 360533;
public const int GeneralAdGiftDataResponse = 360534;
/// <summary>
/// 通用广告礼包
/// </summary>
public const int GeneralAdGiftRequest = 360535;
public const int GeneralAdGiftResponse = 360536;
/// <summary>
/// 随机广告礼包数据
/// </summary>
public const int AdGiftRandomDataRequest = 360537;
public const int AdGiftRandomDataResponse = 360538;
/// <summary>
/// 随机广告礼包
/// </summary>
public const int AdGiftRandomRequest = 360539;
public const int AdGiftRandomResponse = 360540;
/// <summary>
/// 钻石商城数据
/// </summary>
public const int DiamondMallDataRequest = 360541;
public const int DiamondMallDataResponse = 360542;
/// <summary>
/// 兑换商城数据
/// </summary>
public const int ExchangeMallDataRequest = 360543;
public const int ExchangeMallDataResponse = 360544;
/// <summary>
/// 兑换商城兑换
/// </summary>
public const int ExchangeMallRequest = 360545;
public const int ExchangeMallResponse = 360546;
/// <summary>
/// 道具日志
/// </summary>
public const int PropLogRequest = 360547;
public const int PropLogResponse = 360548;
/// <summary>
/// 玩家地址列表请求
/// </summary>
public const int UserAddressListRequest = 360549;
public const int UserAddressListResponse = 360550;
/// <summary>
/// 编辑玩家地址请求
/// </summary>
public const int EditorUserAddressListRequest = 360551;
public const int EditorUserAddressListResponse = 360552;
/// <summary>
/// 删除玩家地址请求
/// </summary>
public const int DeleteUserAddressListRequest = 360553;
public const int DeleteUserAddressListResponse = 360554;
/// <summary>
/// 设置默认地址请求
/// </summary>
public const int UserAddressSetDefaultRequest = 360555;
public const int UserAddressSetDefaultResponse = 360556;
/// <summary>
/// 获取默认地址请求
/// </summary>
public const int UserAddressGetDefaultRequest = 360557;
public const int UserAddressGetDefaultResponse = 360558;
/// <summary>
/// 获取实体兑换商城数据
/// </summary>
public const int EntityMallDataRequest = 360559;
public const int EntityMallDataResponse = 360560;
/// <summary>
/// 实体商城兑换
/// </summary>
public const int EntityMallExchangeRequest = 360561;
public const int EntityMallExchangeResponse = 360562;
/// <summary>
/// 用户订单列表
/// </summary>
public const int EntityMallOrderListRequest = 360563;
public const int EntityMallOrderListResponse = 360564;
/// <summary>
/// 小米用户登录Session校验
/// </summary>
public const int XiaoMiLoginVerificationRequest = 360565;
public const int XiaoMiLoginVerificationResponse = 360566;
#region 建材比赛消息 360600 - 360650
/// <summary>
/// 比赛报名请求
/// </summary>
public const int JianCaiRaceCompetitionRequest = 360600;
/// <summary>
/// 比赛报名响应
/// </summary>
public const int JianCaiRaceCompetitionResponse = 360601;
/// <summary>
/// 报名信息查询请求
/// </summary>
public const int JianCaiRaceCompetitionInfoRequest = 360602;
/// <summary>
/// 报名信息查询响应
/// </summary>
public const int JianCaiRaceCompetitionInfoResponse = 360603;
/// <summary>
/// 建材比赛报名信息查询请求
/// </summary>
public const int JianCaiRaceCompetitionInfoByPhoneRequest = 360604;
/// <summary>
/// 建材报名信息查询响应
/// </summary>
public const int JianCaiRaceCompetitionInfoByPhoneResponse = 360605;
/// <summary>
/// 建材比赛用户加白请求
/// </summary>
public const int RegisterJianCaiBiSaiRequest = 360606;
/// <summary>
/// 建材比赛用户加白响应
/// </summary>
public const int RegisterJianCaiBiSaiResponse = 360607;
/// <summary>
/// 建材比赛报名信息
/// </summary>
public const int JianCaiRaceCompetitionInfoByRaceIdRequest = 360608;
public const int JianCaiRaceCompetitionInfoByRaceIdResponse = 360609;
/// <summary>
/// 成为队友请求
/// </summary>
public const int JianCaiGetTeammateApplyRequest = 360610;
public const int JianCaiGetTeammateApplyResponse = 360611;
/// <summary>
/// 解除队友绑定
/// </summary>
public const int UnbindTeammateRequest = 360612;
public const int UnbindTeammateResponse = 360613;
/// <summary>
/// 建材比赛轮次信息
/// </summary>
public const int JianCaiRoundInfosRequest = 360614;
public const int JianCaiRoundInfosResponse = 360615;
/// <summary>
/// 抽签
/// </summary>
public const int JianCaiRoundChouQianRequest = 36016;
public const int JianCaiRoundChouQianResponse = 36017;
/// <summary>
/// 对阵信息
/// </summary>
public const int JianCaiDuiZhenInfosRequest = 36018;
public const int JianCaiDuiZhenInfosResponse = 36019;
/// <summary>
/// 比赛分数导入
/// </summary>
public const int JianCaiBiSaiScoreImportRequest = 36020;
public const int JianCaiBiSaiScoreImportResponse = 36021;
#endregion 建材比赛消息
#endregion GameCenterMsgId
}
}

99
NetWorkMessage/Message/Base/MessageCode.cs Normal file
View File

@ -0,0 +1,99 @@
using System.ComponentModel;
using System.Runtime.InteropServices;
namespace GameMessage
{
public static partial class MessageCode
{
#region Common 0000 - 9999
/// <summary>
/// 注册会话请求
/// </summary>
public const int RegisterSessionRequest = 1;
/// <summary>
/// 注册会话响应
/// </summary>
public const int RegisterSessionResponse = 2;
/// <summary>
/// 更新会话过期时间
/// </summary>
public const int UpdateSessionExpireTime = 3;
/// <summary>
/// 获取活动道具数据请求
/// </summary>
public const int ActivityPropDataGetRequest = 4;
/// <summary>
/// 获取活动道具数据响应
/// </summary>
public const int ActivityPropDataGetResponse = 5;
/// <summary>
/// 活动道具数据变更数据推送
/// </summary>
public const int ActivityPropDataChange = 6;
/// <summary>
/// 连接请求
/// </summary>
public const int ConnectSYN = 7;
/// <summary>
/// 连接响应
/// </summary>
public const int ConnectACK = 8;
/// <summary>
/// 连接断开请求
/// </summary>
public const int ConnectFin = 9;
//public const int ConnectFinAck = 10;
/// <summary>
/// 路由心跳请求
/// </summary>
public const int RouterHeartRequest = 11;
/// <summary>
/// 路由心跳响应
/// </summary>
public const int RouterHeartResponse = 12;
/// <summary>
/// 链接验证码
/// </summary>
public const int ConnectAuthCode = 13;
/// <summary>
/// 游戏测试包
/// </summary>
public const int GamePackTestRequest = 14;
/// <summary>
/// 游戏测试响应包
/// </summary>
public const int GamePackTestResponse = 15;
/// <summary>
/// 服务器断开包
/// </summary>
public const int ServerFin = 16;
/// <summary>
/// 游戏主动断开玩家
/// </summary>
public const int GameFinPlayer = 20;
/// <summary>
/// 提示码
/// </summary>
public const int TipCode = 100;
#endregion Common
}
}

41
NetWorkMessage/Message/Base/MessageData.cs Normal file
View File

@ -0,0 +1,41 @@
using MessagePack;
#if Server
using Server.Core;
#else
using GameFramework;
#endif
namespace GameMessage
{
/// <summary>
/// 消息对象
/// </summary>
public abstract class MessageData
: IReference
{
#if Server
[IgnoreMember]
public bool IsFromPool
{
get;
set;
}
[IgnoreMember]
public long ReferenceId
{
get;
set;
}
public virtual void Dispose()
{
}
#else
public virtual void Clear()
{
}
#endif
}
}

68
NetWorkMessage/Message/Base/MessageManager.cs Normal file
View File

@ -0,0 +1,68 @@
using System;
using System.Collections.Generic;
namespace GameMessage
{
public static class MessageManager
{
private static Dictionary<int, Type> messageTypeDic = new Dictionary<int, Type>();
private static Dictionary<Type, int> opcodeDic = new Dictionary<Type, int>();
/// <summary>
/// 注册
/// </summary>
public static void Register()
{
if (messageTypeDic.Count > 0)
{
return;
}
Type messageType = typeof(MessageAttribute);
Type[] types = typeof(MessageManager).Assembly.GetTypes();
foreach (var type in types)
{
object[] att = type.GetCustomAttributes(messageType, false);
if (att.Length == 0)
{
continue;
}
MessageAttribute messageAttribute = att[0] as MessageAttribute;
if (messageAttribute == null)
continue;
int opcode = messageAttribute.Opcode;
if (opcode != 0)
{
messageTypeDic.Add(opcode, type);
opcodeDic.Add(type,opcode);
//Log.Debug("添加消息:" + opcode + "," + type);
}
}
}
public static Type GetType(int opcode)
{
if (!messageTypeDic.TryGetValue(opcode, out var type))
{
throw new Exception($"OpcodeType not found type: {opcode}");
}
return type;
}
public static int GetOpcode(Type type)
{
if (!opcodeDic.TryGetValue(type,out var opcode))
{
throw new Exception($"OpcodeType not found opcode: {type}");
}
return opcode;
}
}
}

30
NetWorkMessage/Message/MessageData/Common/ActivityPropData.cs Normal file
View File

@ -0,0 +1,30 @@
using MessagePack;
namespace GameMessage
{
/// <summary>
/// 活动道具数据
/// </summary>
[MessagePackObject]
public class ActivityPropData
{
/// <summary>
/// 活动道具ID
/// </summary>
[Key(0)]
public int Id;
/// <summary>
/// 活动道具名称
/// </summary>
[Key(1)]
public string PropName;
/// <summary>
/// 活动道具数量
/// </summary>
[Key(2)]
public long Count;
}
}

57
NetWorkMessage/Message/MessageData/Common/ActivityPropDataMessage.cs Normal file
View File

@ -0,0 +1,57 @@
using System.Collections.Generic;
using MessagePack;
#if GameClient
using GameFramework;
#endif
namespace GameMessage
{
[Message(MessageCode.ActivityPropDataGetRequest)]
[MessagePackObject]
public class ActivityPropDataGetRequest : MessageData
{
/// <summary>
/// 0 表示 获取所有道具数据 大于0 表示获取指定道具数据
/// </summary>
[Key(0)]
public int PropType;
#if GameClient
public static ActivityPropDataGetRequest Create(int propType)
{
ActivityPropDataGetRequest request = ReferencePool.Acquire<ActivityPropDataGetRequest>();
request.PropType = propType;
return request;
}
#endif
}
[Message(MessageCode.ActivityPropDataGetResponse)]
[MessagePackObject]
public class ActivityPropDataGetResponse : MessageData
{
/// <summary>
/// 0 表示 获取所有道具数据 大于0 表示获取指定道具数据
/// </summary>
[Key(0)]
public int PropType;
/// <summary>
/// 道具数据
/// </summary>
[Key(1)]
public List<ActivityPropData> Datas;
}
[Message(MessageCode.ActivityPropDataChange)]
[MessagePackObject]
public class ActivityPropDataChangeMessage : MessageData
{
/// <summary>
/// 道具数据
/// </summary>
[Key(0)]
public List<ActivityPropData> ChangeDatas;
}
}

17
NetWorkMessage/Message/MessageData/Common/CommonDeskData.cs Normal file
View File

@ -0,0 +1,17 @@
using MessagePack;
namespace GameMessage
{
/// <summary>
/// 通用桌子数据
/// </summary>
[MessagePackObject]
public class CommonDeskData
{
/// <summary>
/// 是否使用记牌器
/// </summary>
[Key(0)]
public bool[] IsUsingHandTacker;
}
}

246
NetWorkMessage/Message/MessageData/Common/ConnectMessage.cs Normal file
View File

@ -0,0 +1,246 @@
using System.Collections.Generic;
using MessagePack;
#if Server
using Server.Core;
#else
using GameFramework;
#endif
namespace GameMessage
{
[Message(MessageCode.ConnectAuthCode)]
[MessagePackObject]
public class ConnectAuthCode : MessageData
{
/// <summary>
/// 验证码
/// </summary>
[Key(0)] public byte[] AuthCode;
#if Server
public static ConnectAuthCode Create(byte[] authCode)
{
ConnectAuthCode connectAuthCode = ReferencePool.Fetch<ConnectAuthCode>();
connectAuthCode.AuthCode = authCode;
return connectAuthCode;
}
public override void Dispose()
{
this.AuthCode = null;
ReferencePool.Recycle(this);
}
#endif
}
[Message(MessageCode.ConnectSYN)]
[MessagePackObject]
public class ConnectSyn : MessageData
{
/// <summary>
/// 验证码
/// </summary>
[Key(0)] public byte[] AuthCode;
#if GameClient
public static ConnectSyn Create(byte[] authCode)
{
ConnectSyn connectSyn = ReferencePool.Acquire<ConnectSyn>();
connectSyn.AuthCode = authCode;
return connectSyn;
}
public override void Clear()
{
AuthCode = null;
}
#endif
}
[Message(MessageCode.ConnectACK)]
[MessagePackObject]
public class ConnectAck : MessageData
{
/// <summary>
/// 链接结果
/// </summary>
[Key(0)] public bool Result;
#if Server
public static ConnectAck Create(bool result)
{
ConnectAck connectAck = ReferencePool.Fetch<ConnectAck>();
connectAck.Result = result;
return connectAck;
}
public override void Dispose()
{
ReferencePool.Recycle(this);
}
#endif
}
[Message(MessageCode.ConnectFin)]
[MessagePackObject]
public class ConnectFin : MessageData
{
#if GameClient
public static ConnectFin Create()
{
return ReferencePool.Acquire<ConnectFin>();
}
#endif
}
[Message(MessageCode.ServerFin)]
[MessagePackObject]
public class ServerFin : MessageData
{
/// <summary>
/// 正常断开
/// </summary>
public const int FinCode_Normal = 0;
/// <summary>
/// 别处登录
/// </summary>
public const int FinCode_RemoteLogin = 1;
[Key(0)] public int FinCode;
#if Server
public static ServerFin Create(int finCode)
{
ServerFin serverFin = ReferencePool.Fetch<ServerFin>();
serverFin.FinCode = finCode;
return serverFin;
}
public override void Dispose()
{
ReferencePool.Recycle(this);
}
#endif
}
/// <summary>
/// 心跳包
/// </summary>
[Message(MessageCode.RouterHeartRequest)]
[MessagePackObject]
public class RouterHeartRequest : MessageData
{
/// <summary>
/// 发送时间
/// </summary>
[Key(0)] public long SendTime;
#if GameClient
public static RouterHeartRequest Create(long sendTime)
{
RouterHeartRequest request = ReferencePool.Acquire<RouterHeartRequest>();
request.SendTime = sendTime;
return request;
}
#endif
}
[Message(MessageCode.RouterHeartResponse)]
[MessagePackObject]
public class RouterHeartResponse : MessageData
{
/// <summary>
/// 发送时间
/// </summary>
[Key(0)] public long SendTime;
/// <summary>
/// 服务器链接信息
/// </summary>
[Key(1)] public List<ServerConnectInfo> ServerInfos;
#if Server
public static RouterHeartResponse Create()
{
RouterHeartResponse routerHeartResponse = ReferencePool.Fetch<RouterHeartResponse>();
return routerHeartResponse;
}
public override void Dispose()
{
//if (IsFromPool)
{
if (ServerInfos != null)
{
foreach (var info in ServerInfos)
{
info.Dispose();
}
}
ServerInfos = null;
}
ReferencePool.Recycle(this);
}
#endif
}
/// <summary>
/// 服务器链接信息
/// </summary>
[MessagePackObject]
public class ServerConnectInfo
#if Server
: IReference
#endif
{
[IgnoreMember] public bool IsFromPool { get; set; }
[IgnoreMember] public long ReferenceId { get; set; }
/// <summary>
/// 模块Id
/// </summary>
[Key(0)] public byte ModuleId;
/// <summary>
/// 模块数量
/// </summary>
[Key(1)] public byte NodeNum;
/// <summary>
/// 模块状态
/// </summary>
[Key(2)] public byte State;
/// <summary>
/// 链接中
/// </summary>
public const byte Connecting = 0;
/// <summary>
/// 连上了
/// </summary>
public const byte Open = 1;
/// <summary>
/// 链接已关闭
/// </summary>
public const byte Close = 2;
#if Server
public static ServerConnectInfo Create()
{
return ReferencePool.Fetch<ServerConnectInfo>();
}
public void Dispose()
{
ReferencePool.Recycle(this);
}
#endif
}
}

24
NetWorkMessage/Message/MessageData/Common/DataPageMessage.cs Normal file
View File

@ -0,0 +1,24 @@
using MessagePack;
namespace GameMessage
{
/// <summary>
/// 分页的数据
/// </summary>
[MessagePackObject]
public class DataPage
{
[IgnoreMember]
public static DataPage Default => new DataPage { PageId = 1, PageSize = 20 };
/// <summary>
/// 第几页 (从1开始)
/// </summary>
[Key(0)]public int PageId = 1;
/// <summary>
/// 一页的数量
/// </summary>
[Key(1)]public int PageSize = 20;
}
}

80
NetWorkMessage/Message/MessageData/Common/DeskOtherDataMessage.cs Normal file
View File

@ -0,0 +1,80 @@
using MessagePack;
#if Server
using Server.Core;
#endif
#if GameClient
using GameFramework;
#endif
namespace GameMessage
{
[MessagePackObject]
public class DeskOtherDataResponse : MessageData
{
/// <summary>
/// 桌子其他数据信息
/// </summary>
[Key(0)] public CommonDeskData CommonDeskData;
#if Server
public static DeskOtherDataResponse Create(CommonDeskData commonDeskData)
{
DeskOtherDataResponse self = ReferencePool.Fetch<DeskOtherDataResponse>();
self.CommonDeskData = commonDeskData;
return self;
}
public override void Dispose()
{
ReferencePool.Recycle(this);
}
#endif
}
/// <summary>
/// 使用记牌器数据
/// </summary>
[MessagePackObject]
public class UsingHandTrackerData : MessageData
{
/// <summary>
/// 消耗类型 1 记牌器 2 钻石
/// </summary>
[Key(0)] public int ConsumeType;
/// <summary>
/// 消耗数量
/// </summary>
[Key(1)] public int ConsumeValue;
#if Server
public static UsingHandTrackerData Create(int consumeType,int consumeValue)
{
UsingHandTrackerData self = ReferencePool.Fetch<UsingHandTrackerData>();
self.ConsumeType = consumeType;
self.ConsumeValue = consumeValue;
return self;
}
public override void Dispose()
{
ReferencePool.Recycle(this);
}
#endif
#if GameClient
public static UsingHandTrackerData Create(int consumeType)
{
UsingHandTrackerData self = ReferencePool.Acquire<UsingHandTrackerData>();
self.ConsumeType = consumeType;
return self;
}
public override void Clear()
{
}
#endif
}
}

144
NetWorkMessage/Message/MessageData/Common/DeskRuleV1.cs Normal file
View File

@ -0,0 +1,144 @@
using MessagePack;
namespace GameMessage
{
[MessagePackObject()]
public class ClubDeskRule
{
/// <summary>
/// 密码
/// </summary>
[Key(0)]
public string Pwd;
/// <summary>
/// 最大玩家数量
/// </summary>
[Key(1)]
public int MaxCnt;
/// <summary>
/// 最小玩家数量
/// </summary>
[Key(2)]
public int MinCnt;
/// <summary>
/// 倍率
/// </summary>
[Key(3)]
public float BeiLv;
/// <summary>
/// 游戏的房间规则
/// </summary>
[Key(4)]
public string RoomRule;
/// <summary>
/// 总封顶
/// </summary>
[Key(5)]
public int Capping;
/// <summary>
/// 玩法备注
/// </summary>
[Key(6)]
public string Remarks;
/// <summary>
/// 规则扩展
/// </summary>
[Key(7)]
public DeskRuleEx RuleEx;
/// <summary>
/// 游戏服务Id
/// </summary>
[Key(8)]
public int GameSerId;
/// <summary>
/// 地理位置拦截
/// </summary>
[Key(9)]
public int InterceptPos;
/// <summary>
/// 是否拦截不是微信的账号
/// </summary>
[Key(10)]
public int InterceptWeChat;
/// <summary>
/// 战局数
/// </summary>
[Key(11)]
public int WarCnt;
}
[MessagePackObject()]
public class DeskRuleEx
{
/// <summary>
/// 县级游戏id
/// </summary>
[Key(0)]
public int ZyxIdx;
/// <summary>
/// 是否自动托管 0 表示不托管 大于0表示多少秒进入自动托管
/// </summary>
[Key(1)]
public int AutoDeposit;
/// <summary>
/// 托管自动解散
/// </summary>
[Key(2)]
public bool DepositAutoDissolve;
/// <summary>
/// 可以请求解散的次数 -1 表示不可申请 0 表示无限次 大于0 表示具体次数
/// </summary>
[Key(3)]
public int CanRequestDissolveCnt;
/// <summary>
/// 创建房间消耗的房卡数量
/// </summary>
[Key(4)]
public int CreateRoomCardNum;
/// <summary>
/// 开战后自动准备的时间 小于0表示不自动准备 等于0表示使用默认值5 大于0表示具体时间
/// </summary>
[Key(5)]
public int AutoReadTime;
/// <summary>
/// 是否禁止发送道具
/// </summary>
[Key(6)]
public bool RefuseProp;
/// <summary>
/// 进入随机位置
/// </summary>
[Key(7)]
public bool JoinRandomSeat;
/// <summary>
/// 离线罚分
/// </summary>
[Key(8)]
public int OutLinePenaltyPoint;
/// <summary>
/// 未准备超时踢出
/// </summary>
[Key(9)]
public int ReadyTimeout;
}
}

246
NetWorkMessage/Message/MessageData/Common/DeviceInfo.cs Normal file
View File

@ -0,0 +1,246 @@
using System;
using System.Text;
using MessagePack;
namespace GameMessage
{
/// <summary>
/// 设备信息
/// </summary>
[MessagePackObject]
public class DeviceInfo
{
/// <summary>
/// 玩家所在的平台 0pc 1安卓 2IOS 3miniGame 4webgl
/// </summary>
[Key(0)]
public int plat;
/// <summary>
/// 玩家类型 0正常 1虚拟机
/// </summary>
[Key(1)]
public int wmsty;
/// <summary>
/// 登录类型 -1未知 0普通 1微信 2QQ
/// </summary>
[Key(2)]
public int loginsty;
/// <summary>
/// 维度
/// </summary>
[Key(3)]
public double weidu;
/// <summary>
/// 经度
/// </summary>
[Key(4)]
public double jingdu;
/// <summary>
/// wifi 名称
/// </summary>
[Key(5)]
public string wifissd;
/// <summary>
/// wifi mac 地址
/// </summary>
[Key(6)]
public string wifimac;
/// <summary>
/// 手机的IMEI
/// </summary>
[Key(7)]
public string phone_imei;
/// <summary>
/// ip地址
/// </summary>
[Key(8)]
public string ip;
/// <summary>
/// 省
/// </summary>
[Key(9)]
public string province;
/// <summary>
/// 市
/// </summary>
[Key(10)]
public string city;
/// <summary>
/// 区
/// </summary>
[Key(11)]
public string district;
/// <summary>
/// 地址名称
/// </summary>
[Key(12)]
public string address;
/// <summary>
/// 作弊程度 0"正常", 1 "无法定位", 2"低", 3"中", 4"高"
/// </summary>
[Key(13)]
public int zuobichengdu;
/// <summary>
///
/// </summary>
public DeviceInfo()
{
}
/// <summary>
/// 无定位信息
/// </summary>
[IgnoreMember]
public bool isEmpty
{
get { return Math.Abs(jingdu) < 0.01f && Math.Abs(weidu) < 0.01; }
}
/// <summary>
///
/// </summary>
/// <returns></returns>
public override string ToString()
{
StringBuilder sb = new StringBuilder();
sb.AppendLine("plat:" + plat);
sb.AppendLine("wmsty:" + wmsty);
sb.AppendLine("loginsty:" + loginsty);
sb.AppendLine("weidu:" + weidu);
sb.AppendLine("jingdu" + jingdu);
sb.AppendLine("wifissd:" + wifissd);
sb.AppendLine("wifimac:" + wifimac);
sb.AppendLine("phone_imei:" + phone_imei);
sb.AppendLine("ip:" + ip);
sb.AppendLine("province:" + province);
sb.AppendLine("city:" + city);
sb.AppendLine("district:" + district);
sb.AppendLine("address:" + address);
return sb.ToString();
}
/// <summary>
/// 获取用户坐标
/// </summary>
/// <returns></returns>
public WorldPosition GetPosition()
{
return new WorldPosition() { weidu = weidu, jingdu = jingdu };
}
}
/// <summary>
/// 定位信息
/// </summary>
public struct WorldPosition
{
/// <summary>
/// 经度
/// </summary>
public double jingdu;
/// <summary>
/// 纬度
/// </summary>
public double weidu;
/// <summary>
/// 无定位信息
/// </summary>
public bool isEmpty {
get {
return Math.Abs(jingdu) < 0.01f && Math.Abs(weidu) < 0.01;
}
}
/// <summary>
/// 是否属于安全距离
/// </summary>
/// <param name="pos0"></param>
/// <param name="pos1"></param>
/// <param name="sefeDistance">安全距离</param>
/// <returns></returns>
public static bool CheckSafeDistance(WorldPosition pos0, WorldPosition pos1, int sefeDistance) {
if (pos0.isEmpty || pos1.isEmpty)
return false;
double safeSegment = sefeDistance / 100000f;
double latbetween = Math.Abs(pos0.weidu - pos1.weidu);
double lngbetween = Math.Abs(pos0.jingdu - pos1.jingdu);
if (latbetween + lngbetween > safeSegment)
return true;
var dis = GetDistance(pos0, pos1);
return dis > sefeDistance;
}
/// <summary>
/// 获取两个位置的坐标距离
/// </summary>
/// <param name="pos0">坐标0</param>
/// <param name="pos1">坐标1</param>
/// <returns>坐标距离</returns>
public static double GetDistance(WorldPosition pos0, WorldPosition pos1) {
if (pos0.isEmpty || pos1.isEmpty)
return 0;
return GetDistance(pos0.jingdu, pos0.weidu, pos1.jingdu, pos1.weidu);
}
/// <summary>
/// 计算地球上两点之间的距离_单位是米
/// 经纬度相差一个单位大约是 10000米 如果是比较两点是否小于 2000米 应该使用估算方法 只要两个点 经各经度 纬度 之间的差值 之后大于0.5应该就不需要计算了,肯定是大于2000米 减小运算 运算费时
/// </summary>
/// <param name="lng1">第一点的经度</param>
/// <param name="lat1">第一点的纬度</param>
/// <param name="lng2">第二点的经度</param>
/// <param name="lat2">第二点的维度</param>
/// <returns></returns>
public static double GetDistance(double lng1, double lat1, double lng2, double lat2)
{
double ralat1 = Rad(lat1);
double ralng1 = Rad(lng1);
double ralat2 = Rad(lat2);
double ralng2 = Rad(lng2);
double a = ralat1 - ralat2;
double b = ralng1 - ralng2;
double result = 2 * Math.Asin(Math.Sqrt(Math.Pow(Math.Sin(a / 2), 2) + Math.Cos(ralat1) * Math.Cos(ralat2) * Math.Pow(Math.Sin(b / 2), 2))) * Earth_Radius;
return result;
}
/// <summary>
/// 地球的半径
/// </summary>
public const double Earth_Radius = 6378137;
/// <summary>
/// 经纬度转弧度
/// </summary>
/// <returns>弧度</returns>
public static double Rad(double d)
{
return (double)d * Math.PI / 180d;
}
}
}

72
NetWorkMessage/Message/MessageData/Common/GameCommonMessage.cs Normal file
View File

@ -0,0 +1,72 @@
using MessagePack;
#if Server
using Server.Core;
#else
using GameFramework;
#endif
namespace GameMessage
{
[Message(MessageCode.ClientPackRequest)]
[MessagePackObject]
public class ClientPackRequest : MessageData
{
/// <summary>
/// 包头
/// </summary>
[Key(0)] public byte[] Head;
/// <summary>
/// 包数据
/// </summary>
[Key(1)] public byte[] Data;
#if GameClient
public static ClientPackRequest Create(byte[] head, byte[] data)
{
ClientPackRequest request = ReferencePool.Acquire<ClientPackRequest>();
request.Head = head;
request.Data = data;
return request;
}
public override void Clear()
{
Head = null;
Data = null;
}
#endif
}
[Message(MessageCode.ClientPackResponse)]
[MessagePackObject]
public class ClientPackResponse : MessageData
{
/// <summary>
/// 包头
/// </summary>
[Key(0)] public byte[] Head;
/// <summary>
/// 包数据
/// </summary>
[Key(1)] public byte[] Data;
#if Server
public static ClientPackResponse Create(byte[] head, byte[] data)
{
ClientPackResponse response = ReferencePool.Fetch<ClientPackResponse>();
response.Head = head;
response.Data = data;
return response;
}
public override void Dispose()
{
Head = null;
Data = null;
ReferencePool.Recycle(this);
}
#endif
}
}

234
NetWorkMessage/Message/MessageData/Common/GameDesk.cs Normal file
View File

@ -0,0 +1,234 @@
using System;
using System.Collections.Generic;
using GameData;
using MessagePack;
namespace GameMessage
{
/// <summary>
/// 游戏内的桌子信息
/// </summary>
[MessagePackObject]
public class GameDeskInfo
{
/// <summary>
/// 位置信息
/// </summary>
[Key(0)] public int[] Seat;
}
[MessagePackObject]
public class DeskRulePack
{
/// <summary>
/// 最大玩家数量
/// </summary>
[Key(0)]public int MaxCnt;
/// <summary>
/// 最小玩家数量
/// </summary>
[Key(1)]public int MinCnt;
/// <summary>
/// 战斗场次
/// </summary>
[Key(2)]public int WarCnt;
/// <summary>
/// 游戏的服务器id
/// </summary>
[Key(3)]public int GameSerId;
/// <summary>
/// 是否拦截ip
/// </summary>
[Key(4)]public int InterceptIp;
/// <summary>
/// 地理位置拦截
/// </summary>
[Key(5)]public int InterceptPos;
/// <summary>
/// 是否拦截不是微信的账号
/// </summary>
[Key(6)]public int InterceptWeChat;
/// <summary>
/// 客户端拓展，只保存,服务器不处理
/// </summary>
[Key(7)]public List<string> Ex;
/// <summary>
/// 赔率
/// </summary>
[Key(8)]public float Peilv;
/// <summary>
/// 房间规则
/// </summary>
[Key(9)]public string Roomrule;
/// <summary>
/// 多少数封顶，总结算的封顶（子乘倍率的,就是最后封顶输多少钱） 等于0的值就是有封顶，要不就没有封顶
/// </summary>
[Key(10)]public int Capping;
/// <summary>
/// 玩法备注
/// </summary>
[Key(11)]public string Remarks;
/// <summary>
/// 规则拓展
/// </summary>
[Key(12)]public DeskRuleEx RuleEx;
}
[MessagePackObject]
public class DeskPlayerDataPack
{
/// <summary>
/// 玩家ID
/// </summary>
[Key(0)]
public int UserId;
/// <summary>
/// 玩家昵称
/// </summary>
[Key(1)]
public string NickName;
/// <summary>
/// 玩家性别
/// </summary>
[Key(2)]
public int Sex;
/// <summary>
/// 是否房主
/// </summary>
[Key(3)]
public int FangZhu;
/// <summary>
/// 客户端IP地址
/// </summary>
[Key(4)]
public string ClientIp;
/// <summary>
/// 玩家所属俱乐部ID
/// </summary>
[Key(5)]
public int ClubId;
}
[MessagePackObject]
public class DeskBureauPack
{
/// <summary>
/// 当前局
/// </summary>
[Key(0)]public int Id;
/// <summary>
/// 玩家分数
/// </summary>
[Key(1)]public List<long> PlayScore;
/// <summary>
/// 玩家的座位
/// </summary>
[Key(2)]public List<int> Seat;
}
[MessagePackObject]
public class DeskSummaryBureauPack
{
[Key(0)]public int Seat;
[Key(1)]public decimal Score;
}
[MessagePackObject]
public class DeskInfoPack
{
/// <summary>
/// 唯一码 其他模块应持有这个
/// </summary>
[Key(0)]public string Weiyima;
/// <summary>
/// 房间号 不是唯一的,同一时间运算的是唯一的 6为数房间码
/// </summary>
[Key(1)]public string RoomNum;
/// <summary>
/// 房间规则
/// </summary>
[Key(2)]public DeskRulePack Rule;
/// <summary>
/// 当前数量的场数 1开始
/// </summary>
[Key(3)]public int NowCnt;
/// <summary>
/// 结束的数量
/// </summary>
[Key(4)]public int OverCnt;
/// <summary>
/// 游戏服务器的版本
/// </summary>
[Key(5)]public int ServerVer;
/// <summary>
/// 创建房间的类型 0普通开 1代开房间 5竞技比赛创建房间
/// </summary>
[Key(6)]public int CreatStyle;
/// <summary>
/// 创建房间的id 如果是普通创建的房间 则此id为玩家的userid 竞技比赛创建则为竞技比赛id
/// </summary>
[Key(7)]public int CreatUserid;
/// <summary>
/// 创建房间的房卡数量
/// </summary>
[Key(8)]public int Fangka;
/// <summary>
/// 玩家数据
/// </summary>
[Key(9)]public List<DeskPlayerDataPack> Pls;
/// <summary>
/// 玩家座位 当前的座位编号 --里面存储的座位
/// </summary>
[Key(10)]public List<int> Seat;
/// <summary>
/// 每局明细
/// </summary>
[Key(11)]public List<DeskBureauPack> Burs;
/// <summary>
/// 一局打完总的结算，如果有封顶的话，里面计算好了封顶之后的分值
/// </summary>
[Key(12)]public List<DeskSummaryBureauPack> SumBurs;
/// <summary>
/// 创建时间
/// </summary>
[Key(13)]public DateTime CreateTime;
/// <summary>
/// 关闭时间
/// </summary>
[Key(14)]public DateTime CloseTime;
}
}

33
NetWorkMessage/Message/MessageData/Common/GameFinMessage.cs Normal file
View File

@ -0,0 +1,33 @@
using GameMessage;
using MessagePack;
#if Server
using Server.Core;
#else
#endif
namespace UnityGame
{
[Message(MessageCode.GameFinPlayer)]
[MessagePackObject]
public class GameFinMessage : MessageData
{
[Key(0)]
public int FinCode;
#if Server
public static GameFinMessage Create(int finCode)
{
GameFinMessage gameFinMessage = ReferencePool.Fetch<GameFinMessage>();
gameFinMessage.FinCode = finCode;
return gameFinMessage;
}
public override void Dispose()
{
ReferencePool.Recycle(this);
}
#endif
}
}

47
NetWorkMessage/Message/MessageData/Common/GamePackTest.cs Normal file
View File

@ -0,0 +1,47 @@
#if GameClient
using GameFramework;
#endif
using MessagePack;
namespace GameMessage
{
[Message(MessageCode.GamePackTestRequest)]
[MessagePackObject]
public class GamePackTestRequest : MessageData
{
[Key(0)]
public int Id;
[Key(1)]
public byte[] Data;
#if GameClient
public static GamePackTestRequest Create(int id,byte[] data = null)
{
GamePackTestRequest request = ReferencePool.Acquire<GamePackTestRequest>();
request.Id = id;
request.Data = data;
return request;
}
public override void Clear()
{
this.Data = null;
}
#endif
}
[Message(MessageCode.GamePackTestResponse)]
[MessagePackObject]
public class GamePackTestResponse : MessageData
{
/// <summary>
/// 响应ID
/// </summary>
[Key(0)]
public int Id;
[Key(1)]
public byte[] Data;
}
}

13
NetWorkMessage/Message/MessageData/Common/IgnoreMessage.cs Normal file
View File

@ -0,0 +1,13 @@
using MessagePack;
namespace UnityGame
{
// [MessagePackObject()]
// public class IgnoreMessage
// {
// [Key(0)] public int a;
//
// [IgnoreMember]
// public int b;
// }
}

23
NetWorkMessage/Message/MessageData/Common/MessageErrCode.PayMsg.cs Normal file
View File

@ -0,0 +1,23 @@
using System.Collections.Generic;
namespace GameMessage
{
public static partial class MessageErrCode
{
private static Dictionary<int, string> _payErrorMsg = new Dictionary<int, string>()
{
{ PayErrorAmount, "支付金额错误" },
{ PayIsPaying, "订单支付中" },
{ PayErrorReceiveRole, "充值对象不存在" },
{ PayErrorPayRole, "付款对象不存在" },
{ PayErrorRpc, "调用支付失败" },
{ PayErrorOrderNotExist, "订单不存在" },
{ PayErrorConfigNotExist, "商品不存在" },
};
public static string GetPayErrorMsg(int code)
{
return _payErrorMsg.TryGetValue(code, out string msg) ? msg : "";
}
}
}

1934
NetWorkMessage/Message/MessageData/Common/MessageErrCode.cs Normal file
View File

@ -0,0 +1,1934 @@
using System.Dynamic;
using System.Runtime.InteropServices;
namespace GameMessage
{
/// <summary>
/// 错误码
/// </summary>
public static partial class MessageErrCode
{
/// <summary>
/// 成功
/// </summary>
public const int Success = -1;
/// <summary>
/// 客户端版本过低
/// </summary>
public const int ClientLow = 1;
/// <summary>
/// 服务器内部错误
/// </summary>
public const int InternalServerError = 2;
/// <summary>
/// 用户客户端数据错误
/// </summary>
public const int UserClientDataError = 3;
/// <summary>
/// 活动已经取消
/// </summary>
public const int ActivityCancel = 4;
#region 登录 10001 ~ 10050
/// <summary>
/// 昵称或密码为空
/// </summary>
public const int Login_NameOrPsdIsEmpty = 10001;
/// <summary>
/// 登录失败
/// </summary>
public const int Login_Fail = 10002;
/// <summary>
/// 登录失败，参数错误
/// </summary>
public const int Login_ParamError = 10003;
/// <summary>
/// 用户名或密码错误
/// </summary>
public const int Login_NameOrPsdError = 10004;
/// <summary>
/// 账号被禁止登录
/// </summary>
public const int Login_AstrictLogin = 10005;
/// <summary>
/// 未知错误
/// </summary>
public const int Login_UnknowError = 10006;
/// <summary>
/// 服务器错误
/// </summary>
public const int Login_ServerError = 10007;
/// <summary>
/// 登录失败，玩家账号在注销中
/// </summary>
public const int Login_Logout = 10008;
/// <summary>
/// 不支持的登录类型
/// </summary>
public const int Login_TypeError = 10009;
/// <summary>
/// 微信扫码认证失败
/// </summary>
public const int Login_WxQrAuthError = 10010;
/// <summary>
/// 验证码错误
/// </summary>
public const int Login_PhoneVerifyCodeError = 10011;
/// <summary>
/// Token错误
/// </summary>
public const int LoginAuto_TokenError = 10012;
/// <summary>
/// Token超时
/// </summary>
public const int LoginAuto_TokenExpiration = 10013;
/// <summary>
/// 校验第三方Token失败
/// </summary>
public const int LoginAuto_AuthTokenFail = 10014;
#endregion
#region 广告礼包 10051 ~ 10099
/// <summary>
/// 广告礼包今日领取次数达到上限
/// </summary>
public const int AdGiftCntLimit = 10051;
/// <summary>
/// 广告礼包领取失败
/// </summary>
public const int AdGiftFail = 10052;
#endregion
#region 救济金 10100 ~ 10149
/// <summary>
/// 救济金领取失败 版本过低
/// </summary>
public const int EmergencyGold_VerFail = 10100;
/// <summary>
/// 救济金领取失败，未达到领取条件
/// </summary>
public const int EmergencyGold_NotMeet = 10101;
/// <summary>
/// 救济金领取失败，领取次数达到上限
/// </summary>
public const int EmergencyGold_CntLimit = 10102;
#endregion
#region 上传配置服配置 10150 ~ 10199
/// <summary>
/// 上传配置失败，秘钥错误
/// </summary>
public const int UploadConfig_KeyError = 10150;
/// <summary>
/// 上传配置失败
/// </summary>
public const int UploadConfig_Fail = 10151;
#endregion
#region 注册Session 10200 ~ 10249
/// <summary>
/// 会话过期
/// </summary>
public const int SessionUuidExpired = 10200;
/// <summary>
/// 用户Userid 错误
/// </summary>
public const int UseridFail = 10201;
#endregion
#region BUG提交 10250 ~ 10299
/// <summary>
/// 提交已达上限
/// </summary>
public const int BugReportLimit = 10250;
/// <summary>
/// 提交过于频繁
/// </summary>
public const int BugReportFrequently = 10251;
#endregion
#region 用户名检测 10300 ~ 10349
/// <summary>
/// 用户名不能为空
/// </summary>
public const int UserNameEmpty = 10300;
/// <summary>
/// 用户名长度错误
/// </summary>
public const int UserNameLengthError = 10301;
/// <summary>
/// 用户名非法
/// </summary>
public const int UserNameFail = 10302;
/// <summary>
/// 用户名只能使用英文、数字
/// </summary>
public const int UserNameRuleError = 10303;
/// <summary>
/// 用户名存在
/// </summary>
public const int UserNameExists = 10304;
/// <summary>
/// 发生报错
/// </summary>
public const int UserNameException = 10305;
#endregion
#region 用户注册 10350 ~ 10399
/// <summary>
/// 用户名不能为空
/// </summary>
public const int RegisterUserNameEmpty = 10350;
/// <summary>
/// 用户名长度错误
/// </summary>
public const int RegisterUserNameLengthError = 10351;
/// <summary>
/// 用户名非法
/// </summary>
public const int RegisterUserNameFail = 10352;
/// <summary>
/// 用户名只能使用英文、数字
/// </summary>
public const int RegisterUserNameRuleError = 10353;
/// <summary>
/// 昵称不能为空
/// </summary>
public const int RegisterNickNameEmpty = 10354;
/// <summary>
/// 昵称长度错误
/// </summary>
public const int RegisterNickNameLengthError = 10355;
/// <summary>
/// 昵称包含特殊字符
/// </summary>
public const int RegisterNickNameSpeChar = 10356;
/// <summary>
/// 昵称非法
/// </summary>
public const int RegisterNickNameFail = 10357;
/// <summary>
/// 密码为空
/// </summary>
public const int RegisterPassWordEmpty = 10358;
/// <summary>
/// 密码长度错误
/// </summary>
public const int RegisterPassWordLengthError = 10359;
/// <summary>
/// 用户名只能使用英文、数字
/// </summary>
public const int RegisterPassWordRuleError = 10360;
/// <summary>
/// 性别数据错误
/// </summary>
public const int RegisterSexError = 10361;
/// <summary>
/// 注册失败, 通常是用户名已存在
/// </summary>
public const int RegisterFail = 10362;
/// <summary>
/// 注册发生错误
/// </summary>
public const int RegisterException = 10363;
#endregion
#region 实名认证 10400 ~ 10449
/// <summary>
/// 实名认证信息错误
/// </summary>
public const int RealNameAuthInfoError = 10400;
/// <summary>
/// 实名认证的账号已达上限
/// </summary>
public const int RealNameAuthAccountLimit = 10401;
/// <summary>
/// 实名认证失败
/// </summary>
public const int RealNameAuthFail = 10402;
/// <summary>
/// 实名认证中，请稍后再试
/// </summary>
public const int RealNameAuthing = 10403;
/// <summary>
/// 数据错误，请重新登录
/// </summary>
public const int RealNameAuthDataError = 10404;
/// <summary>
/// 已经认证过了
/// </summary>
public const int AccountIsAuthSuccess = 10405;
#endregion
#region 注销账号 10450 ~ 10499
/// <summary>
/// 注销失败
/// </summary>
public const int LogOutFail = 10450;
#endregion
#region 兑换实体商品 10500 ~ 10549
/// <summary>
/// 兑换失败 没有这么多钱
/// </summary>
public const int ExChangeEntityNotValue = 10500;
/// <summary>
/// 兑换失败，没有库存
/// </summary>
public const int ExChangeEntityNoStock = 10501;
/// <summary>
/// 兑换失败，没有商品
/// </summary>
public const int ExChangeEntityNoCommodity = 10502;
/// <summary>
/// 兑换失败，其他错误
/// </summary>
public const int ExChangeEntityOther = 10503;
#endregion
#region 兑换商品 10550 ~ 10599
/// <summary>
/// 兑换失败，没有这么多钱
/// </summary>
public const int ExChangeCommodityNotValue = 10550;
/// <summary>
/// 兑换失败，没有这个商品
/// </summary>
public const int ExchangeCommodityNotId = 10551;
/// <summary>
/// 兑换失败，其他错误
/// </summary>
public const int ExChangeCommodityOther = 10552;
/// <summary>
/// 兑换失败，需要购买
/// </summary>
public const int ExChangeCommodityBuy = 10553;
#endregion
#region 兑换商城V2 10554 ~ 10559
/// <summary>
/// 兑换商城兑换失败，商品不存在
/// </summary>
public const int ExchangeMallNoProduct = 10554;
/// <summary>
/// 兑换商城兑换失败，资产不足
/// </summary>
public const int ExchangeMallNotEnough = 10555;
/// <summary>
/// 兑换商城兑换失败，其他错误
/// </summary>
public const int ExchangeMallOther = 10556;
#endregion
#region 保险箱操作 10600 ~ 10649
/// <summary>
/// 玩家在游戏中
/// </summary>
public const int SafeBoxPlayerInGame = 10600;
/// <summary>
/// 玩家钱不够，存失败
/// </summary>
public const int SafeBoxDepositMoneyDef = 10601;
/// <summary>
/// 玩家钱不够，取失败
/// </summary>
public const int SafeBoxWithdrawMoneyDef = 10602;
#endregion
#region 转盘签到 10650 ~ 10699
/// <summary>
/// 转盘今日已领取
/// </summary>
public const int TurnTableTodayReward = 10650;
#endregion
#region 签到宝箱 10700 ~ 10749
/// <summary>
/// 已经领取过了
/// </summary>
public const int SignBoxIsReward = 10700;
/// <summary>
/// 未满足领取条件
/// </summary>
public const int SignBoxNotCondition = 10701;
#endregion
#region 摇钱树 10750 ~ 10799
/// <summary>
/// 参与金额不足
/// </summary>
public const int ShakeTreeMoneyNotHave = 10750;
/// <summary>
/// 玩家在游戏中，参与失败
/// </summary>
public const int ShakeTreeInGame = 10751;
#endregion
#region 钻石兑换房卡 10800 ~ 10849
/// <summary>
/// 兑换失败 钻石数量不足
/// </summary>
public const int DiamondExchangeCardFail = 10800;
#endregion
#region 祈福 10850 ~ 10899
/// <summary>
/// 祈福失败，钻石不足
/// </summary>
public const int PrayFail = 10850;
#endregion
#region 修改俱乐部玩家积分 10900 ~ 10949
/// <summary>
/// 修改俱乐部玩家积分权限不足
/// </summary>
public const int EditorClubMatchScorePermissionDenied = 10900;
/// <summary>
/// 修改俱乐部玩家积分，玩家没有积分
/// </summary>
public const int EditorClubMatchScorePlayerNoScore = 10901;
/// <summary>
/// 修改俱乐部玩家积分，玩家在游戏中
/// </summary>
public const int EditorClubMatchScorePlayerInGame = 10902;
/// <summary>
/// 修改俱乐部积分出错
/// </summary>
public const int EditorClubMatchScoreError = 10903;
/// <summary>
/// 修改俱乐部玩家积分 比赛未开始
/// </summary>
public const int EditorClubMatchScoreNotOpen = 10904;
#endregion
#region 俱乐部隐藏玩法请求 10950 ~ 10999
/// <summary>
/// 俱乐部隐藏玩法权限不足
/// </summary>
public const int ClubHideWaysPermissionDenied = 10950;
/// <summary>
/// 俱乐部隐藏玩法失败
/// </summary>
public const int ClubHideWaysFail = 10951;
#endregion
#region 俱乐部设置管理员 11000 ~ 11049
/// <summary>
/// 管理员设置失败
/// </summary>
public const int ClubManagerSetFail = 11000;
#endregion
#region 俱乐部成员退出 11050 ~ 11099
/// <summary>
/// 没找到俱乐部
/// </summary>
public const int QuitNotFoundClub = 11050;
/// <summary>
/// 玩家没在俱乐部中
/// </summary>
public const int QuitMyNotExistsClub = 11051;
/// <summary>
/// 没找到目标玩家
/// </summary>
public const int QuitTargetPlayerNotFound = 11052;
/// <summary>
/// 目标玩家没在俱乐部中
/// </summary>
public const int QuitTargetNotExistsClub = 11053;
/// <summary>
/// 踢出权限不足
/// </summary>
public const int QuitNotPermission = 11054;
/// <summary>
/// 不能踢出自己
/// </summary>
public const int QuitNotKickOutSelf = 11055;
/// <summary>
/// 不能踢出合伙人
/// </summary>
public const int QuitNotKickOutPartner = 11056;
/// <summary>
/// 会长不能退出
/// </summary>
public const int QuitLeaderCannot = 11057;
/// <summary>
/// 合伙人不能退出
/// </summary>
public const int QuitPartnerCannot = 11058;
/// <summary>
/// 退出重复提交
/// </summary>
public const int QuitRepeated = 11059;
/// <summary>
/// 退出处理失败
/// </summary>
public const int QuitFail = 11060;
#endregion
#region 俱乐部退赛处理 11100 ~ 11149
/// <summary>
/// 没找到这个用户
/// </summary>
public const int QuitMatchNotFoundPlayer = 11100;
/// <summary>
/// 退赛处理权限不足
/// </summary>
public const int QuitMatchNotPermission = 11101;
/// <summary>
/// 退赛处理失败
/// </summary>
public const int QuitMatchFail = 11102;
/// <summary>
/// 退赛不同意
/// </summary>
public const int QuitMatchNotAgree = 11103;
#endregion
#region 俱乐部消息处理 11150 ~ 11199
/// <summary>
/// 消息已经处理过
/// </summary>
public const int ClubMsgAlreadyHandled = 11150;
/// <summary>
/// 不存在这个俱乐部
/// </summary>
public const int ClubMsgNotExitsClub = 11151;
/// <summary>
/// 俱乐部消息处理失败
/// </summary>
public const int ClubMsgHandleFail = 11152;
/// <summary>
/// 处理人不在俱乐部中
/// </summary>
public const int ClubMsgPlayerNotExistsClub = 11153;
/// <summary>
/// 这个消息必须会长处理
/// </summary>
public const int ClubMsgNeedLeaderHandle = 11154;
/// <summary>
/// 权限不足处理失败
/// </summary>
public const int ClubMsgNotPermission = 11155;
/// <summary>
/// 俱乐部已达上限
/// </summary>
public const int ClubMsgClubLimit = 11156;
/// <summary>
/// 玩家已经在俱乐部中
/// </summary>
public const int ClubMsgPlayerIsExists = 11157;
#endregion
#region 俱乐部创建 11200 ~ 11249
/// <summary>
/// 俱乐部名称长度非法
/// </summary>
public const int CreateClubNameLengthIllegal = 11200;
/// <summary>
/// 俱乐部名称非法
/// </summary>
public const int CreateClubNameIllegal = 11201;
/// <summary>
/// 俱乐部公告长度非法
/// </summary>
public const int CreateClubNoticeLengthIllegal = 11202;
/// <summary>
/// 俱乐部公告非法
/// </summary>
public const int CreateClubNoticeIllegal = 11203;
/// <summary>
/// 创建俱乐部失败，没找到这个玩家
/// </summary>
public const int CreateClubNotFindPlayer = 11204;
/// <summary>
/// 俱乐部已达上限
/// </summary>
public const int CreateClubLimit = 11205;
/// <summary>
/// 创建俱乐部失败，卡牌不足
/// </summary>
public const int CreateClubCardDeficiency = 10206;
/// <summary>
/// 创建俱乐部失败，生成器ID错误
/// </summary>
public const int CreateClubGeneratorIdFail = 11207;
/// <summary>
/// 创建俱乐部失败
/// </summary>
public const int CreateClubFail = 11208;
/// <summary>
/// 俱乐部名称已存在
/// </summary>
public const int CreateClubNameExists = 11209;
#endregion
#region 俱乐部修改基本信息 11250 ~ 11299
/// <summary>
/// 修改基本信息失败，没在俱乐部中
/// </summary>
public const int EditorClubBasicInfoNotInClub = 11250;
/// <summary>
/// 修改基本信息失败，权限不足
/// </summary>
public const int EditorClubBasicInfoPermission = 11251;
/// <summary>
/// 修改基本信息失败，内容非法
/// </summary>
public const int EditorClubBasicInfoFail = 11252;
#endregion
#region 俱乐部房卡转换 11300 ~ 11349
/// <summary>
/// 转换失败，没找到这个玩家
/// </summary>
public const int ClubCardTransferNotFindPlayer = 11300;
/// <summary>
/// 转换失败，玩家不在俱乐部中
/// </summary>
public const int ClubCardTransferNotInClub = 11301;
/// <summary>
/// 俱乐部房卡转换失败，权限不足
/// </summary>
public const int ClubCardTransferPermission = 11302;
/// <summary>
/// 俱乐部房卡转换失败，卡牌不足
/// </summary>
public const int ClubCardTransferCardEnough = 11303;
/// <summary>
/// 俱乐部房卡转换失败
/// </summary>
public const int ClubCardTransferFail = 11304;
#endregion
#region 俱乐部申请加入请求 11350 ~ 11399
/// <summary>
/// 申请加入俱乐部失败，没找到这个俱乐部
/// </summary>
public const int ClubJoinApplyNotExistsClub = 11350;
/// <summary>
/// 申请加入俱乐部失败，加入的俱乐部已达上限
/// </summary>
public const int ClubJoinApplyClubLimit = 11351;
/// <summary>
/// 申请加入俱乐部失败，玩家已经在俱乐部中
/// </summary>
public const int ClubJoinApplyClubPlayerIsExists = 11352;
/// <summary>
/// 申请加入俱乐部失败，玩家在联赛的其他俱乐部中
/// </summary>
public const int ClubJoinApplyLeagueClubPlayerIsExists = 11353;
/// <summary>
/// 申请加入俱乐部失败，没找到推荐人
/// </summary>
public const int ClubJoinApplyNotFindPartnerId = 11354;
/// <summary>
/// 申请加入俱乐部失败，推荐人权限不足（不是合伙人）
/// </summary>
public const int ClubJoinApplyPartnerIdPermission = 11355;
/// <summary>
/// 申请加入俱乐部失败，已经申请，请勿重复申请
/// </summary>
public const int ClubJoinApplyExistsApply = 11356;
/// <summary>
/// 申请加入俱乐部失败
/// </summary>
public const int ClubJoinApplyFail = 11357;
#endregion
#region 俱乐部玩家信息修改 11400 ~ 11449
/// <summary>
/// 修改玩家信息失败，自己不在俱乐部中
/// </summary>
public const int ClubPlayerEditorSelfNotInClub = 11400;
/// <summary>
/// 修改玩家信息失败，别人不在俱乐部中
/// </summary>
public const int ClubPlayerEditorOtherNotInClub = 11401;
/// <summary>
/// 修改玩家信息失败，权限不足
/// </summary>
public const int ClubPlayerEditorPermission = 11402;
/// <summary>
/// 修改玩家信息失败，备注非法
/// </summary>
public const int ClubPlayerEditorRemarkIllegal = 11403;
#endregion
#region 俱乐部禁止同桌设置 11450 ~ 11499
/// <summary>
/// 禁止同桌设置失败，权限不足
/// </summary>
public const int ClubBanGroupPermission = 11450;
/// <summary>
/// 禁止同桌设置失败，没找到这个俱乐部
/// </summary>
public const int ClubBanGroupClubNotExists = 11451;
/// <summary>
/// 禁止同桌设置失败，禁止同桌分组已达上限
/// </summary>
public const int ClubBanGroupAddLimit = 11452;
/// <summary>
/// 禁止同桌设置失败
/// </summary>
public const int ClubBanGroupFail = 11453;
#endregion
#region 俱乐部禁止同桌获取 11500 ~ 11549
/// <summary>
/// 获取同桌设置失败，权限不足
/// </summary>
public const int ClubBanGroupGetPermission = 11500;
#endregion
#region 解散桌子 11550 ~ 11599
/// <summary>
/// 解散桌子失败，没找到这个俱乐部
/// </summary>
public const int ClubDisbandNotFindClub = 11550;
/// <summary>
/// 解散桌子失败，权限不足
/// </summary>
public const int ClubDisbandPermission = 11551;
/// <summary>
/// 解散桌子失败，没找到这个桌子
/// </summary>
public const int ClubDisbandNotFindDesk = 11552;
/// <summary>
/// 解散桌子失败，游戏正在维护
/// </summary>
public const int ClubDisbandGameMaintenance = 11553;
#endregion
#region 获取房卡充值记录 11600 ~ 11649
/// <summary>
/// 获取房卡充值记录失败，没找到这个俱乐部
/// </summary>
public const int ClubCardTransferRecordNotFindClub = 11600;
/// <summary>
/// 获取房卡充值记录失败，权限不足
/// </summary>
public const int ClubCardTransferRecordPermission = 11601;
#endregion
#region 合伙人编辑 11650 ~ 11699
/// <summary>
/// 编辑合伙人失败
/// </summary>
public const int ClubPartnerEditorFail = 11650;
/// <summary>
/// 编辑合伙人失败，权限不足
/// </summary>
public const int ClubPartnerEditorPermission = 11651;
#endregion
#region 合伙人用户编辑 11700 ~ 11749
/// <summary>
/// 合伙人转入与转出不能是同一个人
/// </summary>
public const int ClubPartnerUserEditorFromToNotSame = 11700;
/// <summary>
/// 合伙人转入转出失败，没找到这个用户
/// </summary>
public const int ClubPartnerUserEditorNotFindUser = 11701;
/// <summary>
/// 编辑合伙人用户失败，参数错误
/// </summary>
public const int ClubPartnerUserEditorParam = 11702;
/// <summary>
/// 编辑合伙人用户失败，权限不足
/// </summary>
public const int ClubPartnerUserEditorPermission = 11703;
/// <summary>
/// 编辑合伙人用户失败
/// </summary>
public const int ClubPartnerUserEditorFail = 11704;
#endregion
#region 申请成为合伙人的组员 11750 ~ 11799
/// <summary>
/// 申请成为合伙人的组员失败，没找到这个俱乐部
/// </summary>
public const int ClubPartnerJoinApplyNotFindClub = 11750;
/// <summary>
/// 申请成为合伙人的组员失败
/// </summary>
public const int ClubPartnerJoinApplyFail = 11751;
/// <summary>
/// 申请成为合伙人的组员失败，你是会长
/// </summary>
public const int ClubPartnerJoinApplyUserIsLeader = 11752;
/// <summary>
/// 申请成为合伙人的组员失败， partnerId非法
/// </summary>
public const int ClubPartnerJoinApplyInvalidPartnerId = 11753;
/// <summary>
/// 申请成为合伙人的组员失败，没找到这个合伙人
/// </summary>
public const int ClubPartnerJoinApplyNotFindPartner = 11754;
/// <summary>
/// 申请成为合伙人的组员失败，这个用户已经是这个俱乐部的成员
/// </summary>
public const int ClubPartnerJoinApplyExistsUser = 11755;
/// <summary>
/// 申请成为合伙人的组员失败，这个用户不属于合伙人
/// </summary>
public const int ClubPartnerJoinApplyIsNotPartner = 11756;
/// <summary>
/// 申请成为合伙人的组员失败，这个用户已经申请
/// </summary>
public const int ClubPartnerJoinApplyIsExists = 11757;
#endregion
#region 申请加入联赛 11800 ~ 11849
/// <summary>
/// 申请加入联赛失败，没找到这个联赛
/// </summary>
public const int ClubLeagueJoinApplyNotFindLeague = 11800;
/// <summary>
/// 申请加入联赛失败，没找到这个俱乐部
/// </summary>
public const int ClubLeagueJoinApplyNotFindClub = 11801;
/// <summary>
/// 申请加入联赛失败，当前俱乐部已经是联赛
/// </summary>
public const int ClubLeagueJoinApplyClubIsLeague = 11802;
/// <summary>
/// 申请加入联赛失败，没有加入权限
/// </summary>
public const int ClubLeagueJoinApplyNotJoinPermission = 11803;
/// <summary>
/// 申请加入联赛失败，已经加入了联赛
/// </summary>
public const int ClubLeagueJoinApplyIsJoin = 11804;
/// <summary>
/// 申请加入联赛失败，没找到这个用户
/// </summary>
public const int ClubLeagueJoinApplyNotFindPlayer = 11805;
/// <summary>
/// 申请加入联赛失败，权限不足
/// </summary>
public const int ClubLeagueJoinApplyPermission = 11806;
/// <summary>
/// 申请加入联赛失败，这个俱乐部已经加入
/// </summary>
public const int ClubLeagueJoinApplyIsExistsClub = 11807;
/// <summary>
/// 申请加入联赛失败
/// </summary>
public const int ClubLeagueJoinApplyFail = 11808;
#endregion
#region 加入俱乐部桌子 11850 ~ 11899
/// <summary>
/// 加入桌子失败，操作频繁，请稍后再试
/// </summary>
public const int ClubJoinDeskFrequent = 11850;
/// <summary>
/// 加入桌子失败，没找到这个俱乐部
/// </summary>
public const int ClubJoinDeskClubNotFind = 11851;
/// <summary>
/// 加入桌子失败，未知错误
/// </summary>
public const int ClubJoinDeskUnknow = 11852;
/// <summary>
/// 加入桌子失败，还在某个游戏中
/// </summary>
public const int ClubJoinDeskLockGame = 11853;
/// <summary>
/// 加入桌子失败，比赛正在开启下一轮
/// </summary>
public const int ClubJoinDeskClubMatchOpening = 11854;
/// <summary>
/// 加入桌子失败，上一局还未结算完成
/// </summary>
public const int ClubJoinDeskNotSettle = 11855;
/// <summary>
/// 加入桌子失败，正在退赛中
/// </summary>
public const int ClubJoinDeskIsExitMatch = 11856;
/// <summary>
/// 加入桌子失败，房卡不够
/// </summary>
public const int ClubJoinDeskCardNotEnough = 11857;
/// <summary>
/// 加入桌子失败，没有找到这个玩家
/// </summary>
public const int ClubJoinDeskNotFindPlayer = 11858;
/// <summary>
/// 加入桌子失败，由于管理员设置不能加入该玩法
/// </summary>
public const int ClubJoinDeskNotJoinWay = 11859;
/// <summary>
/// 加入桌子失败，您在小黑屋中
/// </summary>
public const int ClubJoinDeskInBlackRoom = 11860;
/// <summary>
/// 加入桌子失败，您在联赛的小黑屋中
/// </summary>
public const int ClubJoinDeskInLeagueBlackRoom = 11861;
/// <summary>
/// 加入桌子失败，没有找到这个玩法
/// </summary>
public const int ClubJoinDeskNotFindWay = 11862;
/// <summary>
/// 加入桌子失败，竞技赛场已经被禁止上桌
/// </summary>
public const int ClubJoinDeskClubBan = 11863;
/// <summary>
/// 加入桌子失败，竞技赛场的生存任务失败
/// </summary>
public const int ClubJoinDeskClubLiveTaskFail = 11864;
/// <summary>
/// 加入桌子失败，积分不够
/// </summary>
public const int ClubJoinDeskScoreNotEnough = 11865;
/// <summary>
/// 加入桌子失败，没有指定游戏
/// </summary>
public const int ClubJoinDeskNotGame = 11866;
/// <summary>
/// 加入桌子失败，该游戏不在线
/// </summary>
public const int ClubJoinDeskGameOffLine = 11867;
/// <summary>
/// 加入桌子失败，请求超时
/// </summary>
public const int ClubJoinDeskTimeOut = 11868;
/// <summary>
/// 加入桌子失败，游戏没有开放朋友房
/// </summary>
public const int ClubJoinDeskNotOpenFriend = 11869;
/// <summary>
/// 加入桌子失败，没有设备信息
/// </summary>
public const int ClubJoinDeskNotDeviceInfo = 11870;
/// <summary>
/// 加入桌子失败，没有获取到IP信息
/// </summary>
public const int ClubJoinDeskNotIp = 11871;
/// <summary>
/// 加入桌子失败，正在处理中
/// </summary>
public const int ClubJoinDeskDoing = 11872;
/// <summary>
/// 加入桌子失败，参数错误
/// </summary>
public const int ClubJoinDeskParamError = 11873;
/// <summary>
/// 加入桌子失败，玩法规则错误
/// </summary>
public const int ClubJoinDeskWayRuleError = 11874;
/// <summary>
/// 加入桌子失败，正在其他游戏
/// </summary>
public const int ClubJoinDeskInOtherGame = 11875;
/// <summary>
/// 加入桌子失败，你已经有其他桌子
/// </summary>
public const int ClubJoinDeskHasRoom = 11876;
/// <summary>
/// 加入桌子失败，没有这个桌子
/// </summary>
public const int ClubJoinDeskNotDesk = 11877;
/// <summary>
/// 加入桌子失败，密码错误
/// </summary>
public const int ClubJoinDeskPwdError= 11878;
/// <summary>
/// 加入桌子失败，桌子失效
/// </summary>
public const int ClubJoinDeskInValid = 11879;
/// <summary>
/// 加入桌子失败，桌子已满
/// </summary>
public const int ClubJoinDeskFull = 11880;
/// <summary>
/// 加入桌子失败，同一个IP不能加入
/// </summary>
public const int ClubJoinDeskSameIp = 11881;
/// <summary>
/// 加入桌子失败，IP不能为空
/// </summary>
public const int ClubJoinDeskIpEmpty = 11882;
/// <summary>
/// 加入桌子失败，IMEI不能为空
/// </summary>
public const int ClubJoinDeskImeiEmpty = 11883;
/// <summary>
/// 加入桌子失败，同一个IMEI不能加入
/// </summary>
public const int ClubJoinDeskSameImei = 11884;
/// <summary>
/// 加入桌子失败，需要微信账号才能加入
/// </summary>
public const int ClubJoinDeskNotWeChatAccount = 11885;
/// <summary>
/// 加入桌子失败，没有定位信息
/// </summary>
public const int ClubJoinDeskNotPosition = 11886;
/// <summary>
/// 加入桌子失败，不在安全距离内
/// </summary>
public const int ClubJoinDeskNotSafeDistance = 11887;
/// <summary>
/// 加入桌子失败，加入失败
/// </summary>
public const int ClubJoinDeskJoinFail = 11888;
/// <summary>
/// 加入桌子失败，房间号错误!
/// </summary>
public const int ClubJoinDeskNumError = 11889;
/// <summary>
/// 加入桌子失败，与桌子上的玩家禁止加入同一桌
/// </summary>
public const int ClubJoinDeskNotAllowed = 11890;
#endregion
#region 道具 11900 ~ 11949
/// <summary>
/// 道具没有足够数量
/// </summary>
public const int PropDataGiveNoEnough = 11900;
/// <summary>
/// 该道具不能赠送
/// </summary>
public const int PropDataGiveNotSend = 11901;
/// <summary>
/// 赠送用户不存在
/// </summary>
public const int PropDataGiveNotReceiveUser = 11902;
/// <summary>
/// 保存到数据库失败
/// </summary>
public const int PropDataGiveSaveDbError = 11903;
#endregion
#region 支付11950 ~ 11999
/// <summary>
/// 支付金额错误
/// </summary>
public const int PayErrorAmount = 11950;
/// <summary>
/// 订单支付中
/// </summary>
public const int PayIsPaying = 11951;
/// <summary>
/// 充值对象不存在
/// </summary>
public const int PayErrorReceiveRole = 11952;
/// <summary>
/// 付款对象不存在
/// </summary>
public const int PayErrorPayRole = 11953;
/// <summary>
/// 内部RPC调用支付失败
/// </summary>
public const int PayErrorRpc = 11954;
/// <summary>
/// 订单不存在
/// </summary>
public const int PayErrorOrderNotExist = 11955;
/// <summary>
/// 商品不存在
/// </summary>
public const int PayErrorConfigNotExist = 11956;
/// <summary>
/// 客户端通知支付验证失败
/// </summary>
public const int PayC2SVerifyError = 11957;
/// <summary>
/// 客户端通知支付验证服务器报错
/// </summary>
public const int PayC2SVerifyServerError = 11958;
#endregion
#region 短信验证码 12000 ~ 12049
/// <summary>
/// 时间冷却
/// </summary>
public const int PhoneVerifyCodeTimeLimit = 12000;
/// <summary>
/// 次数限制
/// </summary>
public const int PhoneVerifyCodeCountLimit = 12001;
/// <summary>
/// 没有验证码模板
/// </summary>
public const int PhoneVerifyCodeTemplateNotExist = 12002;
/// <summary>
/// 发送服务错误
/// </summary>
public const int PhoneVerifyCodeSendServiceError = 12003;
/// <summary>
/// 手机号格式错误
/// </summary>
public const int PhoneNumberError = 12004;
#endregion
#region 俱乐部比赛列表 12050 ~ 12099
/// <summary>
/// 未找到俱乐部
/// </summary>
public const int ClubMatchListNotFindClub = 12050;
/// <summary>
/// 俱乐部比赛列表错误 服务器报错
/// </summary>
public const int ClubMatchListError = 12051;
#endregion
#region 账号信息 12100 ~ 12149
/// <summary>
/// 绑定失败-验证失败
/// </summary>
public const int AccountBind_VeriyFail = 12100;
/// <summary>
/// 绑定失败-手机号错误
/// </summary>
public const int AccountBind_PhoneNumberError = 12101;
/// <summary>
/// 绑定失败-未知错误
/// </summary>
public const int AccountBind_Unknow = 12102;
/// <summary>
/// 绑定失败-手机绑定修改已达上限
/// </summary>
public const int AccountBind_PhoneBindLimit = 12103;
/// <summary>
/// 绑定失败-手机已绑定其他用户
/// </summary>
public const int AccountBind_PhoneExist = 12104;
/// <summary>
/// 账户安全信息获取失败
/// </summary>
public const int AccountPrivateInfo_GetError = 12105;
#endregion
#region 获取账号信息重置密码用 12150 ~ 12199
/// <summary>
/// 获取账号信息验证码错误
/// </summary>
public const int GetAccountInfoVerifyCodeError = 12150;
/// <summary>
/// 获取账号信息内部错误
/// </summary>
public const int GetAccountInfoVerifyCodeFail = 12151;
/// <summary>
/// 获取账号信息失败，没有绑定这个手机的账户
/// </summary>
public const int GetAccountInfoNotFind = 12152;
/// <summary>
/// 没有账号密码登录的功能
/// </summary>
public const int GetAccountInfoNotUserName = 12153;
#endregion
#region 重置密码 12200 ~ 12249
/// <summary>
/// 新密码是空
/// </summary>
public const int ResetPasswordIsEmpty = 12200;
/// <summary>
/// 长度不对
/// </summary>
public const int ResetPasswordLengthError = 12201;
/// <summary>
/// 重置失败
/// </summary>
public const int ResetPasswordFail = 12202;
/// <summary>
/// Token失效，请重新验证
/// </summary>
public const int ResetPasswordTokenError = 12203;
#endregion
#region 设置密码 12250 ~ 12299
/// <summary>
/// 玩家ID错误
/// </summary>
public const int EditorUserPwdUserIdError = 12250;
/// <summary>
/// 非游客账号不可设置
/// </summary>
public const int EditorUserPwdNotGuest = 12251;
/// <summary>
/// 用户名为空
/// </summary>
public const int EditorUserPwdUserNameEmpty = 12252;
/// <summary>
/// 用户名长度错误
/// </summary>
public const int EditorUserPwdUserNameLengthError = 12253;
/// <summary>
/// 用户名非法
/// </summary>
public const int EditorUserPwdUserNameFail = 12254;
/// <summary>
/// 用户名规则错误
/// </summary>
public const int EditorUserPwdUserNameRuleError = 12255;
/// <summary>
/// 用户名已存在
/// </summary>
public const int EditorUserPwdUserNameExists = 12256;
/// <summary>
/// 密码为空
/// </summary>
public const int EditorUserPwdPasswordEmpty = 12257;
/// <summary>
/// 密码长度错误
/// </summary>
public const int EditorUserPwdPasswordLengthError = 12258;
/// <summary>
/// 设置账号密码失败
/// </summary>
public const int EditorUserPwdUpdateFail = 12259;
/// <summary>
/// 设置账号密码异常
/// </summary>
public const int EditorUserPwdException = 12260;
#endregion
#region 公会退赛请求 12300 ~ 12349
/// <summary>
/// 没找到俱乐部
/// </summary>
public const int ClubMatchQuitNotFindClub = 12300;
/// <summary>
/// 俱乐部没有比赛
/// </summary>
public const int ClubMatchQuitClubNotMatch = 12301;
/// <summary>
/// 没有比赛积分
/// </summary>
public const int ClubMatchQuitNotScore = 12302;
/// <summary>
/// 正在退赛中
/// </summary>
public const int ClubMatchQuitIsExiting = 12303;
/// <summary>
/// 玩家退赛请求出错
/// </summary>
public const int ClubMatchQuitRequestError = 12304;
#endregion
#region 俱乐部踢出桌子 12350 ~ 12399
/// <summary>
/// 桌子不存在
/// </summary>
public const int KickOutPlayerOfDesk_NoDesk = 12350;
/// <summary>
/// 游戏维护中
/// </summary>
public const int KickOutPlayerOfDesk_GameMaintain = 12351;
/// <summary>
/// 桌子已开战
/// </summary>
public const int KickOutPlayerOfDesk_GameInWar = 12352;
#endregion
#region 俱乐部注销 12400 ~ 12449
/// <summary>
/// 俱乐部正在比赛中
/// </summary>
public const int ClubDeleteClubInMatch = 12400;
/// <summary>
/// 不是俱乐部会长
/// </summary>
public const int ClubDeleteClubNoLeader = 12401;
/// <summary>
/// 俱乐部不存在
/// </summary>
public const int ClubDeleteClubNotExist = 12402;
/// <summary>
/// 俱乐部注销失败
/// </summary>
public const int ClubDeleteFail = 12403;
/// <summary>
/// 俱乐部注销失败，导出的俱乐部不存在
/// </summary>
public const int ClubDeleteClubExportClubNotExist = 12404;
/// <summary>
/// 俱乐部注销失败，导出的俱乐部不是全新的
/// </summary>
public const int ClubDeleteClubExportClubNotNew = 12405;
/// <summary>
/// 俱乐部注销失败，不允许导出
/// </summary>
public const int ClubDeleteClubExportClubNotAllow = 12406;
/// <summary>
/// 俱乐部正在注销
/// </summary>
public const int ClubDeleteClubIsDeleting = 12407;
#endregion
#region 救济金领取V2 12450 ~ 12499
/// <summary>
/// 救济金领取出错
/// </summary>
public const int SubsidyReceiveError = 12450;
/// <summary>
/// 救济金领取次数限制
/// </summary>
public const int SubsidyReceiveLimit = 12451;
#endregion
#region 签到处理V2 12500 ~ 12549
/// <summary>
/// 签到处理错误
/// </summary>
public const int SignInProcessError = 12500;
/// <summary>
/// 签到数据错误
/// </summary>
public const int SignInDataError = 12501;
/// <summary>
/// 已经签到完成
/// </summary>
public const int SignInOver = 12502;
/// <summary>
/// 还没到时间签到
/// </summary>
public const int SignInNotStart = 12503;
/// <summary>
/// 没满足领取宝箱的条件
/// </summary>
public const int SignGiftBoxNotEnough = 12504;
/// <summary>
/// 不存在这个礼包
/// </summary>
public const int SignGiftBoxNotExists = 12505;
/// <summary>
/// 已经领取过这个礼包
/// </summary>
public const int SignGiftBoxOver = 12506;
#endregion
#region 转盘处理 12550 ~ 12599
/// <summary>
/// 转盘处理出错
/// </summary>
public const int PrizeWheelProcessError = 12550;
/// <summary>
/// 转盘今日免费次数已达上限
/// </summary>
public const int PrizeWheelFreeLimit = 12551;
/// <summary>
/// 转盘今日次数已达上限
/// </summary>
public const int PrizeWheelLimit = 12552;
/// <summary>
/// 转盘参数有误
/// </summary>
public const int PrizeWheelParamError = 12553;
#endregion
#region 用户地址 12600 ~ 12649
/// <summary>
/// 参数错误
/// </summary>
public const int AddressParamError = 12600;
/// <summary>
/// 操作失败
/// </summary>
public const int OperationFailed = 12601;
/// <summary>
/// 地址不存在
/// </summary>
public const int AddressNotFound = 12602;
/// <summary>
/// 地址数量已达上限
/// </summary>
public const int AddressLimitExceeded = 12603;
#endregion
#region 实体商城兑换 12650 ~ 12699
/// <summary>
/// 商品不存在
/// </summary>
public const int EntityMallProductNotFound = 12650;
/// <summary>
/// 商品已下架
/// </summary>
public const int EntityMallProductNotShelved = 12651;
/// <summary>
/// 兑换数量无效
/// </summary>
public const int EntityMallCountInvalid = 12652;
/// <summary>
/// 实物商品需要地址
/// </summary>
public const int EntityMallNeedAddress = 12653;
/// <summary>
/// 虚拟商品需要账号
/// </summary>
public const int EntityMallNeedAccount = 12654;
/// <summary>
/// 账号格式错误（需要手机号）
/// </summary>
public const int EntityMallAccountFormatError = 12655;
/// <summary>
/// 地址不存在或不属于用户
/// </summary>
public const int EntityMallAddressNotValid = 12656;
/// <summary>
/// 全服兑换次数已达上限
/// </summary>
public const int EntityMallServerLimitExceeded = 12657;
/// <summary>
/// 用户兑换次数已达上限
/// </summary>
public const int EntityMallUserLimitExceeded = 12658;
/// <summary>
/// 红卡数量不足
/// </summary>
public const int EntityMallRedMoneyNotEnough = 12659;
/// <summary>
/// 兑换失败
/// </summary>
public const int EntityMallExchangeFail = 12660;
#endregion
#region 小米授权登录，Session校验 12700 ~ 12749
/// <summary>
/// 参数错误
/// </summary>
public const int XiaoMiVerificationParamError = 12700;
/// <summary>
/// 服务器错误
/// </summary>
public const int XiaMiVerificationServerError = 12701;
#endregion
#region 建材比赛相关错误码 12750 ~ 12799
/// <summary>
/// 验证码错误
/// </summary>
public const int JianCaiErrorVerify = 12750;
/// <summary>
/// 参数错误
/// </summary>
public const int JianCaiErrorParam = 12751;
/// <summary>
/// 名字是空
/// </summary>
public const int JianCaiErrorNameEmpty = 12752;
/// <summary>
/// 建材名字是空
/// </summary>
public const int JianCaiErrorNameTooLong = 12753;
/// <summary>
/// 建材公司名字是空
/// </summary>
public const int JianCaiErrorCompanyEmpty = 12754;
/// <summary>
/// 建材公司名字过长
/// </summary>
public const int JianCaiErrorCompanyTooLong = 12755;
/// <summary>
/// 手机号
/// </summary>
public const int JianCaiErrorPhoneEmpty = 12756;
/// <summary>
/// 手机号格式错误
/// </summary>
public const int JianCaiErrorPhoneFormat = 12757;
/// <summary>
/// 职位校验
/// </summary>
public const int JianCaiErrorPositionTooLong = 12758;
/// <summary>
/// 手机号已经报名
/// </summary>
public const int JianCaiErrorPhoneAlreadyRegistered = 12759;
/// <summary>
/// 该用户已经报名
/// </summary>
public const int JianCaiErrorUserAlreadyRegistered = 12760;
/// <summary>
/// 报名失败
/// </summary>
public const int JianCaiErrorRegisterFailed = 12761;
/// <summary>
/// 玩家未报名
/// </summary>
public const int JianCaiErrorNotRegistered = 12762;
/// <summary>
/// 玩家信息查询失败
/// </summary>
public const int JianCaiErrorQueryFailed = 12763;
/// <summary>
/// 不能申请和自己成为队友
/// </summary>
public const int JianCaiErrorCannotApplySelf = 12764;
/// <summary>
/// 自己已经有队友
/// </summary>
public const int JianCaiErrorAlreadyHasTeammate = 12765;
/// <summary>
/// 已经提交了申请，对方还未处理
/// </summary>
public const int JianCaiErrorHasPendingApply = 12766;
/// <summary>
/// 对方未报名
/// </summary>
public const int JianCaiErrorTargetNotRegistered = 12767;
/// <summary>
/// 对方已经有队友
/// </summary>
public const int JianCaiErrorTargetHasTeammate = 12768;
/// <summary>
/// 申请成为队友失败！
/// </summary>
public const int JianCaiErrorApplyFailed = 12769;
/// <summary>
/// 没有这个申请ID
/// </summary>
public const int JianCaiErrorApplyNotFound = 12770;
/// <summary>
/// 该申请不属于当前用户
/// </summary>
public const int JianCaiErrorApplyNotOwned = 12771;
/// <summary>
/// 该申请已经处理过了
/// </summary>
public const int JianCaiErrorApplyNotPending = 12772;
/// <summary>
/// 撤销申请失败
/// </summary>
public const int JianCaiErrorCancelFailed = 12773;
/// <summary>
/// 申请结果处理异常
/// </summary>
public const int JianCaiErrorHandleApplyFailed = 12774;
/// <summary>
/// 百名单已经注册过了
/// </summary>
public const int JianCaiBiSaiRegisterExists = 12775;
/// <summary>
/// 白名单注册失败
/// </summary>
public const int JianCaiBiSaiRegisterFailed = 12776;
/// <summary>
/// 您没有队友
/// </summary>
public const int JianCaiErrorNoTeammate = 12777;
/// <summary>
/// 解除绑定失败!
/// </summary>
public const int JianCaiErrorUnbindFailed = 12778;
/// <summary>
/// 对方的 队友不是我
/// </summary>
public const int JianCaiErrorTeammateIsNotMe = 12779;
/// <summary>
/// 报名已截止
/// </summary>
public const int JianCaiErrorENROLLMENT_ENDED = 12780;
/// <summary>
/// 轮次状态错误
/// </summary>
public const int JianCaiErrorRoundNotStarted = 12781;
/// <summary>
/// 建材数据保存失败
/// </summary>
public const int JianCaiErrorSaveFailed = 12782;
#endregion
}
}

28
NetWorkMessage/Message/MessageData/Common/MessageTipCode.cs Normal file
View File

@ -0,0 +1,28 @@
using System.Collections.Generic;
namespace ObjectMessage
{
/// <summary>
/// 用做提示的状态码定义
/// </summary>
public static class MessageTipCode
{
public const int Error_WrongData = 1;
public const int Error_NoPermission = 2;
public const int Error_Argument = 3;
public const int Error_Server = 4;
public const int Error_DB = 5;
}
public static class MessageTip
{
public static Dictionary<int, string> Tips = new Dictionary<int, string>()
{
{ MessageTipCode.Error_WrongData, "数据错误!" },
{ MessageTipCode.Error_NoPermission, "您的权限不足!" },
{ MessageTipCode.Error_Argument, "参数错误!" },
{ MessageTipCode.Error_Server, "服务器错误，操作失败!" },
{ MessageTipCode.Error_DB, "数据库错误，操作失败!" },
};
}
}

255
NetWorkMessage/Message/MessageData/Common/PackHead.cs Normal file
View File

@ -0,0 +1,255 @@
/*
* 由SharpDevelop创建。
* 用户： Administrator
* 日期: 2018-04-02
* 时间: 21:11
*
* 要改变这种模板请点击 工具|选项|代码编写|编辑标准头文件
*/
using System;
using System.ComponentModel;
using MessagePack;
using Newtonsoft.Json;
#if Server
using Server.Core;
#else
using GameFramework;
#endif
namespace GameData
{
/// <summary>
/// 包头协议 描述
/// </summary>
[MessagePackObject]
public class PackHead
: IReference
{
/// <summary>
/// 包类型
/// </summary>
[Key(0)] public int packlx;
/// <summary>
/// userid
/// </summary>
[Key(1)] public int userid;
/// <summary>
/// 平台0PC 1Android 2Ios 3MiniGame 4WebGl
/// </summary>
[Key(2)] public string plat;
/// <summary>
/// 平台 整数值 后续把上面的plat移除
/// </summary>
[Key(3)] public int platValue;
/// <summary>
/// 客户端版本
/// </summary>
[Key(4)] public int clientVer;
/// <summary>
/// 其他int参数
/// </summary>
[Key(5)] public int[] otherInt;
/// <summary>
/// 其他字符串参数
/// </summary>
[Key(6)] public string[] otherString;
/// <summary>
/// 客户端的标识，每个客户端都是唯一的
/// </summary>
[Key(7)] public string clientSign;
/// <summary>
/// 会话ID
/// </summary>
[IgnoreMember] public string SessionUUID;
#if Server
/// <summary>
/// 中转包类型
/// </summary>
[IgnoreMember] public int transfer;
[IgnoreMember] [JsonIgnore] public bool IsFromPool { get; set; }
[IgnoreMember] [JsonIgnore] public long ReferenceId { get; set; }
/// <summary>
/// http 请求ID
/// </summary>
[DefaultValue(-1)] [IgnoreMember] public int requestId = -1;
/// <summary>
/// 时间验证
/// </summary>
[DefaultValue(-1)] [IgnoreMember] public long doid = -1;
/// <summary>
/// 发送的模块
/// </summary>
[IgnoreMember] public ModuleUtile sendutil;
/// <summary>
/// 通讯模块
/// </summary>
[IgnoreMember] public ServerNode Util;
/// <summary>
/// IP地址
/// </summary>
[IgnoreMember] public string ip;
/// <summary>
/// 游戏节点
/// </summary>
//[ProtoBuf.ProtoMember(14)]
[IgnoreMember] public ServerNode gameNode;
[IgnoreMember] public ServerNode[] utils;
/// <summary>
/// 添加模块
/// </summary>
/// <param name="util">添加的模块</param>
public bool AddModule(ModuleUtile util)
{
if (utils == null)
{
utils = new ModuleUtile[] { util };
return true;
}
int len = utils.Length;
if (len > 0)
{
return false;
}
for (int i = 0; i < len; i++)
{
if (util.id == utils[i].id)
return false;
}
ModuleUtile[] temp = new ModuleUtile[len + 1];
temp[len] = util;
Array.Copy(utils, 0, temp, 0, len);
utils = temp;
return true;
}
public ServerNode GetUtil()
{
if (Util != null)
{
return Util;
}
if (utils != null && utils.Length > 0)
{
return utils[0];
}
return null;
}
#endif
/// <summary>
/// Dispose
/// </summary>
public void Dispose()
{
plat = null;
otherInt = null;
otherString = null;
clientSign = null;
#if Server
Util = null;
sendutil = null;
ip = null;
ReferencePool.Recycle(this);
#endif
}
#if Server
public static PackHead Create()
{
PackHead head = ReferencePool.Fetch<PackHead>();
return head;
}
public static PackHead Create(int packLx)
{
PackHead head = ReferencePool.Fetch<PackHead>();
head.packlx = packLx;
return head;
}
#else
/// <summary>
///
/// </summary>
public PackHead()
{
}
public PackHead(int packLx)
{
this.packlx = packLx;
}
public static PackHead Create(int packLx)
{
PackHead head = ReferencePool.Acquire<PackHead>();
head.packlx = packLx;
return head;
}
public void Clear()
{
Dispose();
}
#endif
}
#if Server
/// <summary>
/// 平台枚举
/// </summary>
public enum PlatEnum
{
/// <summary>
/// 桌面模式
/// </summary>
Window = 0,
/// <summary>
/// 安卓平台
/// </summary>
Android = 1,
/// <summary>
/// 苹果平台
/// </summary>
Ios = 2,
/// <summary>
/// 小游戏
/// </summary>
MiniGame = 3,
/// <summary>
/// WebGl
/// </summary>
WebGL = 4,
}
#endif
}

105
NetWorkMessage/Message/MessageData/Common/RegisterSession.cs Normal file
View File

@ -0,0 +1,105 @@
using MessagePack;
#if GameClient
using GameFramework;
#endif
namespace GameMessage
{
/// <summary>
/// 注册Session
/// </summary>
[Message(MessageCode.RegisterSessionRequest)]
[MessagePackObject]
public class RegisterSessionRequest : MessageData
{
/// <summary>
/// 用户Userid
/// </summary>
[Key(0)] public int Userid;
/// <summary>
/// 会话SessionUUID
/// </summary>
[Key(1)] public string SessionUUID;
/// <summary>
/// 客户端版本
/// </summary>
[Key(2)] public int ClientVer;
[Key(3)] public long SeqId;
[Key(4)]
public int Plat;
/// <summary>
/// 设备信息
/// </summary>
[Key(5)]
public string DeviceInfo;
/// <summary>
/// 商店类型
/// </summary>
[Key(6)]
public string StoreType;
#if GameClient
public static RegisterSessionRequest Create()
{
return ReferencePool.Acquire<RegisterSessionRequest>();
}
public override void Clear()
{
Userid = 0;
SessionUUID = null;
ClientVer = 0;
SeqId = 0;
Plat = 0;
DeviceInfo = null;
}
#endif
}
/// <summary>
/// 注册Session 响应
/// </summary>
[Message(MessageCode.RegisterSessionResponse)]
[MessagePackObject]
public class RegisterSessionResponse : MessageData
{
/// <summary>
/// 处理结果
/// </summary>
[Key(0)] public int ResultCode;
[Key(1)] public long SeqId;
}
/// <summary>
/// 更新Session过期时间
/// </summary>
[Message(MessageCode.UpdateSessionExpireTime)]
[MessagePackObject]
public class SessionUpdateExpireTime : MessageData
{
#if GameClient
public static SessionUpdateExpireTime Create()
{
return ReferencePool.Acquire<SessionUpdateExpireTime>();
}
#endif
}
// /// <summary>
// /// 链接成功
// /// </summary>
// [Message(MessageCode.ConnectSuccess)]
// [MessagePackObject]
// public class ConnectSuccessMsg : MessageData
// {
//
// }
}

50
NetWorkMessage/Message/MessageData/Common/ResData.cs Normal file
View File

@ -0,0 +1,50 @@
using MessagePack;
#if GameClient
using GameFramework;
#endif
namespace GameMessage
{
/// <summary>
/// 游戏资源奖励资源 历史遗留问题，后续不用了可以删除
/// </summary>
[MessagePackObject]
public class GameRewardResData
{
[Key(0)]
public int Id;
[Key(1)]
public int Count;
}
/// <summary>
/// 资源数据
/// </summary>
[MessagePackObject]
public class ResData
#if GameClient
: IReference
#endif
{
[Key(0)] public int Id;
[Key(1)] public long Count;
#if GameClient
public static ResData Create(int id, long count)
{
ResData resData = ReferencePool.Acquire<ResData>();
resData.Id = id;
resData.Count = count;
return resData;
}
public void Clear()
{
}
#endif
}
}

16
NetWorkMessage/Message/MessageData/Common/TipCodeMessageEx.cs Normal file
View File

@ -0,0 +1,16 @@
using GameMessage;
namespace ObjectMessage
{
public static class TipCodeMessageEx
{
public static void SetCode(this TipCodeResponse resp, int code)
{
resp.Code = code;
if (MessageTip.Tips.TryGetValue(code, out var tip))
{
resp.Message = tip;
}
}
}
}

21
NetWorkMessage/Message/MessageData/Common/TipCodeResponse.cs Normal file
View File

@ -0,0 +1,21 @@
using MessagePack;
namespace GameMessage
{
[Message(MessageCode.TipCode)]
[MessagePackObject]
public class TipCodeResponse : MessageData
{
/// <summary>
/// 错误码
/// </summary>
[Key(0)]
public int Code;
/// <summary>
/// 错误码信息
/// </summary>
[Key(1)]
public string Message;
}
}

46
NetWorkMessage/Message/MessageData/Common/UserRegistrationMessage.cs Normal file
View File

@ -0,0 +1,46 @@
using System;
using MessagePack;
namespace GameMessage
{
[MessagePackObject]
public class UserRegistrationData
{
public const string UserIdName = nameof(UserId);
public const string InviteIdName = nameof(InviteId);
public const string RegisterChannelName = nameof(RegisterChannel);
public const string AccountTypeName = nameof(AccountType);
public const string RegisterTimeName = nameof(RegisterTime);
public const string RemarkName = nameof(Remark);
/// <summary>
/// 用户Id
/// </summary>
[Key(0)] public int UserId { get; set; }
/// <summary>
/// 邀请人
/// </summary>
[Key(1)] public string InviteId { get; set; }
/// <summary>
/// 注册平台 (PlatType)
/// </summary>
[Key(2)] public int RegisterChannel { get; set; }
/// <summary>
/// 账号类型 （普通账号、微信、QQ、、、） (LoginType)
/// </summary>
[Key(3)] public int AccountType { get; set; }
/// <summary>
/// 注册时间
/// </summary>
[Key(4)] public DateTime RegisterTime { get; set; }
/// <summary>
/// 注册备注
/// </summary>
[Key(5)] public string Remark { get; set; }
}
}

40
NetWorkMessage/Message/MessageData/Common/WarFriendItemData.cs Normal file
View File

@ -0,0 +1,40 @@
using MessagePack;
namespace GameMessage
{
[MessagePackObject]
public class WarFriendItemData
{
public const string UserIdName = nameof(UserId);
public const string GameIdName = nameof(GameId);
public const string WeiYiMaName = nameof(WeiYiMa);
public const string ContentName = nameof(Content);
/// <summary>
/// 玩家UserId
/// </summary>
[Key(0)]
public int UserId;
/// <summary>
/// 客户端ID
/// </summary>
[Key(1)]
public int GameId;
/// <summary>
/// 桌子唯一码
/// </summary>
[Key(2)]
public string WeiYiMa;
/// <summary>
/// 战绩内容
/// </summary>
[Key(3)]
public string Content;
}
}

99
NetWorkMessage/Message/MessageData/Common/WarGoldRecordItemData.cs Normal file
View File

@ -0,0 +1,99 @@
using System;
using System.Collections.Generic;
using MessagePack;
namespace GameMessage
{
[MessagePackObject]
public class WarGoldRecordItemData
{
public const string UserIdName = nameof(UserId);
public const string ScoreName = nameof(Score);
public const string ContentName = nameof(Content);
public const string GameIdName = nameof(GameId);
public const string BeiLvName = nameof(BeiLv);
public const string TaxName = nameof(Tax);
public const string RoomIdName = nameof(RoomId);
public const string EndTimeName = nameof(EndTime);
public const string DescriptionName = nameof(Description);
/// <summary>
/// 玩家
/// </summary>
[Key(0)]
public int UserId;
/// <summary>
/// 这一局得分数
/// </summary>
[Key(1)]
public double Score;
/// <summary>
/// 这一局得玩家信息
/// </summary>
[Key(2)]
public List<WarRecordPlayerData> Content;
/// <summary>
/// 游戏ID
/// </summary>
[Key(3)]
public int GameId;
/// <summary>
/// 倍率
/// </summary>
[Key(4)]
public float BeiLv;
/// <summary>
/// 手续费
/// </summary>
[Key(5)]
public int Tax;
/// <summary>
/// 房间号
/// </summary>
[Key(6)]
public string RoomId;
/// <summary>
/// 结束时间
/// </summary>
[Key(7)]
public string EndTime;
/// <summary>
/// 用于填一下描述信息 （如玩法、游戏名称）
/// </summary>
[Key(8)]
public string Description;
}
[Serializable]
[MessagePackObject]
public class WarRecordPlayerData
{
/// <summary>
/// 用户ID
/// </summary>
[Key(0)]
public int UserId;
/// <summary>
/// 战绩分数
/// </summary>
[Key(1)]
public double Score;
}
}

149
NetWorkMessage/Message/MessageData/Const/PayConst.cs Normal file
View File

@ -0,0 +1,149 @@
using System.ComponentModel;
namespace GameMessage.Const
{
/// <summary>
/// 角色
/// </summary>
public enum OrderRoleType
{
[Description("未知")]
Unknow = 0,
[Description("用户")]
User = 1, // 用户
[Description("公会")]
Club = 2, // 公会
}
/// <summary>
/// 订单状态
/// </summary>
public enum OrderState
{
Open = 1, // 打开状态
Paying = 2, // 支付中
Completed = 3, // 支付完成
Refunding = 4, // 退款中
Refunded = 5, // 已退款
Authing = 6, // 支付授权中
Exception = 99, // 异常订单
}
/// <summary>
/// 业务相关支付渠道
/// </summary>
public enum PaymentChannel
{
Unknow = 0,
Alipay_H5Web = 1, // 支付宝手机网站支付
WeChat_JSAPI = 2, // 微信内手机网站支付
Agent_H5Web = 3, // 代付手机网站支付
AliPay_App = 4, // 支付宝app支付
WeChat_App = 5, // 微信app支付
Huawei_App = 6, // 华为app支付
Apple_App = 7, // 苹果app支付
QR_PC = 8, // PC扫码支付
WeChat_MiniGame = 9, // 微信小游戏支付
ZG_WeChat_JSAPI = 10, // 中钢微信支付支付 (作废)
Lakala_Cashier = 11, // 拉卡拉聚合支付
ZG_QR_App = 12, // 中钢App扫码支付 （作废）
Lakala_Mini = 13, // 拉卡拉小程序
CMB_Wechat_App = 14, // 招行-微信app
CMB_Wechat_JSAPI = 15, // 招行-微信JsApi
CMB_CloudPay = 16, // 招行-云闪付
CMB_ZFBWap = 17, // 招行-支付宝手机网站支付
CMB_ZFBApp = 18, // 招行-支付宝app支付
CMB_QRCode = 19, // 招行-收款码
CMB_Wechat_MiniApp = 20, // 招行-小程序
HM_JSAPI = 21, // 河马付 - JsApi
Lakala_QFW_Mini = 22, // 拉卡拉全方位平台小程序
Lakala_QFW_Cashier = 23, // 拉卡拉全方位聚合支付
XiaoMi = 24, //小米支付
Vivo = 25, //Vivo支付
}
/// <summary>
/// 支付渠道类型
/// </summary>
public enum ChannelType
{
Alipay = 1,
WeChat = 2,
Huawei = 3,
Apple = 4,
ZG = 5, // 中钢
Lakala = 6, // 拉卡拉
MiniGame = 7, // 小游戏
CMB = 8, // 招行
HM = 9, // 河马支付
XiaoMi = 10, //小米支付
SandBox = 99, // 沙盒
}
/// <summary>
/// 支付来源类型
/// </summary>
public enum ChannelOriginType
{
Unknown = 0,
WxService = 1, // 微信服务号
PC = 2, // PC端
Android = 3, // 安卓
IOS = 4, // Apple
WebGL = 5, // WebGL
MiniGame = 6, // 微信小游戏
}
public class PayNameMapUtil
{
public static string GetChannelOriginTypeName(ChannelOriginType type)
{
switch (type)
{
case ChannelOriginType.WxService:
return "微信服务号";
case ChannelOriginType.PC:
return "PC端";
case ChannelOriginType.Android:
return "安卓";
case ChannelOriginType.IOS:
return "苹果";
case ChannelOriginType.WebGL:
return "WebGL";
case ChannelOriginType.MiniGame:
return "微信小游戏";
default:
return "未知";
}
}
public static string GetChannelTypeName(ChannelType channel)
{
switch (channel)
{
case ChannelType.Alipay:
return "支付宝";
case ChannelType.WeChat:
return "微信";
case ChannelType.MiniGame:
return "微信小游戏";
case ChannelType.Huawei:
return "华为";
case ChannelType.Apple:
return "苹果";
case ChannelType.Lakala:
return "拉卡拉";
case ChannelType.CMB:
return "招行";
case ChannelType.HM:
return "河马付";
case ChannelType.SandBox:
return "沙盒";
default:
return "未知";
}
}
}
}

156
NetWorkMessage/Message/MessageData/Convert/DeskInfoConvert.cs Normal file
View File

@ -0,0 +1,156 @@
using System;
using System.Collections.Generic;
using System.Linq;
using GameData;
namespace GameMessage
{
public static class DeskInfoConvert
{
#region Pack To Data
public static DeskInfo ConvertDeskInfo(DeskInfoPack pack)
{
DeskInfo info = new DeskInfo();
info.weiyima = pack.Weiyima;
info.roomNum = pack.RoomNum;
info.rule = ConvertDeskRule(pack.Rule);
info.nowCnt = pack.NowCnt;
info.overCnt = pack.OverCnt;
info.serverVer = pack.ServerVer;
info.creatStyle = pack.CreatStyle;
info.creatUserid = pack.CreatUserid;
info.fangka = pack.Fangka;
info.pls = pack.Pls.Select(ConvertDeskPlayer).ToArray();
info.seat = pack.Seat?.ToArray() ?? Array.Empty<int>();
info.burs = pack.Burs.Select(ConvertDeskBureau).ToList();
info.SumBurs = pack.SumBurs.Select(ConvertDeskSummaryBureau).ToList();
info.CreateTime = pack.CreateTime;
info.closeTime = pack.CloseTime;
return info;
}
public static DeskRule ConvertDeskRule(DeskRulePack pack)
{
DeskRule data = new DeskRule();
data.maxCnt = pack.MaxCnt;
data.minCnt = pack.MinCnt;
data.warCnt = pack.WarCnt;
data.game_serid = pack.GameSerId;
data.interceptIp = pack.InterceptIp;
data.interceptpos = pack.InterceptPos;
data.interceptWeChat = pack.InterceptWeChat;
data.ex = pack.Ex?.ToArray() ?? Array.Empty<string>();
data.peilv = pack.Peilv;
data.roomrule = pack.Roomrule;
data.Capping = pack.Capping;
data.Remarks = pack.Remarks;
data.RuleEx = pack.RuleEx;
return data;
}
public static DeskInfo.PlayerData ConvertDeskPlayer(DeskPlayerDataPack pack)
{
DeskInfo.PlayerData data = new DeskInfo.PlayerData();
data.userid = pack.UserId;
data.nickName = pack.NickName;
data.sex = pack.Sex;
data.fangzhu = pack.FangZhu;
data.ip = pack.ClientIp;
data.ClubId = pack.ClubId;
return data;
}
public static DeskInfo.Bureau ConvertDeskBureau(DeskBureauPack pack)
{
DeskInfo.Bureau data = new DeskInfo.Bureau();
data.id = pack.Id;
data.playScore = pack.PlayScore?.ToArray() ?? Array.Empty<long>();
data.seat = pack.Seat?.ToArray() ?? Array.Empty<int>();
return data;
}
public static DeskInfo.SummaryBureau ConvertDeskSummaryBureau(DeskSummaryBureauPack pack)
{
DeskInfo.SummaryBureau data = new DeskInfo.SummaryBureau();
data.seat = pack.Seat;
data.Score = pack.Score;
return data;
}
#endregion
#region Data To Pack
public static DeskInfoPack ConvertDeskInfoPack(DeskInfo data)
{
DeskInfoPack pack = new DeskInfoPack();
pack.Weiyima = data.weiyima;
pack.RoomNum = data.roomNum;
pack.Rule = ConvertDeskRulePack(data.rule);
pack.NowCnt = data.nowCnt;
pack.OverCnt = data.overCnt;
pack.ServerVer = data.serverVer;
pack.CreatStyle = data.creatStyle;
pack.CreatUserid = data.creatUserid;
pack.Fangka = data.fangka;
pack.Pls = data.pls.Select(ConvertDeskPlayerPack).ToList();
pack.Seat = new List<int>(data.seat ?? Array.Empty<int>());
pack.Burs = data.burs.Select(ConvertDeskBureauPack).ToList();
pack.SumBurs = data.SumBurs.Select(ConvertDeskSummaryBureauPack).ToList();
pack.CreateTime = data.CreateTime;
pack.CloseTime = data.closeTime;
return pack;
}
public static DeskRulePack ConvertDeskRulePack(DeskRule data)
{
DeskRulePack pack = new DeskRulePack();
pack.MaxCnt = data.maxCnt;
pack.MinCnt = data.minCnt;
pack.WarCnt = data.warCnt;
pack.GameSerId = data.game_serid;
pack.InterceptIp = data.interceptIp;
pack.InterceptPos = data.interceptpos;
pack.InterceptWeChat = data.interceptWeChat;
pack.Ex = new List<string>(data.ex ?? Array.Empty<string>());
pack.Peilv = data.peilv;
pack.Roomrule = data.roomrule;
pack.Capping = data.Capping;
pack.Remarks = data.Remarks;
pack.RuleEx = data.RuleEx;
return pack;
}
public static DeskPlayerDataPack ConvertDeskPlayerPack(DeskInfo.PlayerData data)
{
DeskPlayerDataPack pack = new DeskPlayerDataPack();
pack.UserId = data.userid;
pack.NickName = data.nickName;
pack.Sex = data.sex;
pack.FangZhu = data.fangzhu;
pack.ClientIp = data.ip;
pack.ClubId = data.ClubId;
return pack;
}
public static DeskBureauPack ConvertDeskBureauPack(DeskInfo.Bureau data)
{
DeskBureauPack pack = new DeskBureauPack();
pack.Id = data.id;
pack.PlayScore = new List<long>(data.playScore ?? Array.Empty<long>());
pack.Seat = new List<int>(data.seat ?? Array.Empty<int>());
return pack;
}
public static DeskSummaryBureauPack ConvertDeskSummaryBureauPack(DeskInfo.SummaryBureau data)
{
DeskSummaryBureauPack pack = new DeskSummaryBureauPack();
pack.Seat = data.seat;
pack.Score = data.Score;
return pack;
}
#endregion
}
}

66
NetWorkMessage/Message/MessageData/GameCenter/AccountInfoMessage.cs Normal file
View File

@ -0,0 +1,66 @@
using MessagePack;
namespace GameMessage
{
[Message(MessageCode.AccountPrivateInfoRequest)]
[MessagePackObject]
public class AccountPrivateInfoRequest : MessageData
{
#if GameClient
public static AccountPrivateInfoRequest Create()
{
return GameFramework.ReferencePool.Acquire<AccountPrivateInfoRequest>();
}
#endif
}
[Message(MessageCode.AccountPrivateInfoResponse)]
[MessagePackObject]
public class AccountPrivateInfoResponse : MessageData
{
[Key(0)]public int ResultCode;
[Key(1)]public string PhoneNumber;
}
[Message(MessageCode.AccountBindRequest)]
[MessagePackObject]
public class AccountBindRequest : MessageData
{
/// <summary>
/// 绑定类型
/// </summary>
[Key(0)]public AccountBindType BindType;
/// <summary>
/// 绑定的账号
/// </summary>
[Key(1)]public string BindAccount;
/// <summary>
/// 绑定账号验证凭证
/// </summary>
[Key(2)]public string BindVerifyCode;
#if GameClient
public static AccountBindRequest Create()
{
return GameFramework.ReferencePool.Acquire<AccountBindRequest>();
}
#endif
}
[Message(MessageCode.AccountBindResponse)]
[MessagePackObject]
public class AccountBindResponse : MessageData
{
[Key(0)]public int ResultCode;
}
/// <summary>
/// 账号绑定类型
/// </summary>
public enum AccountBindType
{
None = 0,
Phone = 1, // 手机绑定
}
}

292
NetWorkMessage/Message/MessageData/GameCenter/ActivityMessage.cs Normal file
View File

@ -0,0 +1,292 @@
#if GameClient
using GameFramework;
#endif
using System;
using MessagePack;
namespace GameMessage
{
/// <summary>
/// 福利数据请求
/// </summary>
[Message(MessageCode.WelfareDataRequest)]
[MessagePackObject()]
[Obsolete("版本50以上过时")]
public class WelfareDataRequest : MessageData
{
#if GameClient
public static WelfareDataRequest Create()
{
return ReferencePool.Acquire<WelfareDataRequest>();
}
#endif
}
/// <summary>
/// 福利数据响应
/// </summary>
[Message(MessageCode.WelfareDataResponse)]
[MessagePackObject()]
[Obsolete("版本50以上过时")]
public class WelfareDataResponse : MessageData
{
/// <summary>
/// 上次签到的时间
/// </summary>
[Key(0)] public string LastSignTimeStr;
/// <summary>
/// 连续签到次数
/// </summary>
[Key(1)] public int LastSignCnt;
}
/// <summary>
/// 救济金请求
/// </summary>
[Message(MessageCode.ReliefRequest)]
[MessagePackObject()]
[Obsolete("版本50以上过时")]
public class ReliefRequest : MessageData
{
/// <summary>
/// 可领救济金的条件
/// </summary>
[Key(0)] public int Poor;
/// <summary>
/// 救济金的金额
/// </summary>
[Key(1)] public int Relief;
/// <summary>
/// 是否看广告
/// </summary>
[Key(2)] public bool IsAd;
#if GameClient
public static ReliefRequest Create()
{
return ReferencePool.Acquire<ReliefRequest>();
}
public override void Clear()
{
Poor = 0;
Relief = 0;
IsAd = false;
}
#endif
}
/// <summary>
/// 救济金响应
/// </summary>
[Message(MessageCode.ReliefResponse)]
[MessagePackObject()]
[Obsolete("版本50以上过时")]
public class ReliefResponse : MessageData
{
/// <summary>
/// 领取到的金额
/// </summary>
[Key(0)] public int Money;
/// <summary>
/// 领取次数
/// </summary>
[Key(1)] public int DoleCnt;
/// <summary>
/// 领取结果
/// </summary>
[Key(2)] public int ResultCode;
}
/// <summary>
/// 转盘请求
/// </summary>
[Message(MessageCode.TurnTableRequest)]
[MessagePackObject()]
[Obsolete("版本50以上过时")]
public class TurnTableRequest : MessageData
{
/// <summary>
/// 是否活动
/// </summary>
[Key(0)] public bool IsActivity;
}
/// <summary>
/// 转盘响应
/// </summary>
[Message(MessageCode.TurnTableResponse)]
[MessagePackObject()]
[Obsolete("版本50以上过时")]
public class TurnTableResponse : MessageData
{
/*
1 100W金币 50%
2 80礼券 40%
3 1参赛卷 3%
4 1复活卡 3%
5 300万金币 1%
6 240礼券 1%
7 3参赛卷 1%
8 3张复活卡 1% */
/// <summary>
/// 奖励类型
/// </summary>
[Key(0)] public int RewardType;
/// <summary>
/// 连续领取的次数
/// </summary>
[Key(1)] public int ContinuousDoleCnt;
/// <summary>
/// 是否活动
/// </summary>
[Key(2)] public bool IsActivity;
/// <summary>
/// 结果
/// </summary>
[Key(3)] public int ResultCode;
}
/// <summary>
/// 签到宝箱领取请求
/// </summary>
[Message(MessageCode.SignBoxRequest)]
[MessagePackObject()]
[Obsolete("版本50以上过时")]
public class SignBoxRequest : MessageData
{
/// <summary>
/// 宝箱索引
/// </summary>
[Key(0)] public int BoxIndex;
#if GameClient
public static SignBoxRequest Create(int boxIndex)
{
SignBoxRequest request = ReferencePool.Acquire<SignBoxRequest>();
request.BoxIndex = boxIndex;
return request;
}
#endif
}
/// <summary>
/// 签到宝箱领取响应
/// </summary>
[Message(MessageCode.SignBoxResponse)]
[MessagePackObject()]
[Obsolete("版本50以上过时")]
public class SignBoxResponse : MessageData
{
/// <summary>
/// 宝箱索引
/// </summary>
[Key(0)] public int BoxIndex;
/// <summary>
/// 领取结果
/// </summary>
[Key(1)] public int ResultCode;
}
/// <summary>
/// 广告礼包请求
/// </summary>
[Message(MessageCode.AdGiftRequest)]
[MessagePackObject()]
[Obsolete("版本50以上过时")]
public class AdGiftRequest : MessageData
{
#if GameClient
public static AdGiftRequest Create()
{
return ReferencePool.Acquire<AdGiftRequest>();
}
#endif
}
/// <summary>
/// 广告礼包响应
/// </summary>
[Message(MessageCode.AdGiftResponse)]
[MessagePackObject()]
[Obsolete("版本50以上过时")]
public class AdGiftResponse : MessageData
{
/// <summary>
/// 领取的金额
/// </summary>
[Key(0)] public int Money;
/// <summary>
/// 领取的次数
/// </summary>
[Key(1)] public int AdGiftCnt;
/// <summary>
/// 领取结果
/// </summary>
[Key(2)] public int ResultCode;
}
/// <summary>
/// 摇钱树请求
/// </summary>
[Message(MessageCode.ShakeTreeRequest)]
[MessagePackObject()]
public class ShakeTreeRequest : MessageData
{
/// <summary>
/// 摇树次数
/// </summary>
[Key(0)] public int Cnt;
#if GameClient
public static ShakeTreeRequest Create(int cnt)
{
ShakeTreeRequest request = ReferencePool.Acquire<ShakeTreeRequest>();
request.Cnt = cnt;
return request;
}
#endif
}
/// <summary>
/// 摇钱树响应
/// </summary>
[Message(MessageCode.ShakeTreeResponse)]
[MessagePackObject()]
public class ShakeTreeResponse : MessageData
{
/// <summary>
/// 消耗的游戏币
/// </summary>
[Key(0)] public long ExpendMoney;
/// <summary>
/// 参赛券数量
/// </summary>
[Key(1)] public int CanSaiJuanNum;
/// <summary>
/// 礼券数量
/// </summary>
[Key(2)] public int LiQuanNum;
/// <summary>
/// 摇树结果
/// </summary>
[Key(3)] public int ResultCode;
}
}

87
NetWorkMessage/Message/MessageData/GameCenter/AdGiftRandomMessage.cs Normal file
View File

@ -0,0 +1,87 @@
using GameMessage;
using MessagePack;
#if Server
using Server.Core;
#else
using GameFramework;
#endif
namespace UnityGame
{
[Message(MessageCode.AdGiftRandomDataRequest)]
[MessagePackObject]
public class AdGiftRandomDataRequest : MessageData
{
}
[Message(MessageCode.AdGiftRandomDataResponse)]
[MessagePackObject]
public class AdGiftRandomDataResponse : MessageData
{
[Key(0)] public int DayReceiveCnt;
#if Server
public static AdGiftRandomDataResponse Create(int receiveCnt)
{
AdGiftRandomDataResponse response = ReferencePool.Fetch<AdGiftRandomDataResponse>();
response.DayReceiveCnt = receiveCnt;
return response;
}
public override void Dispose()
{
ReferencePool.Recycle(this);
}
#endif
}
[Message(MessageCode.AdGiftRandomRequest)]
[MessagePackObject]
public class AdGiftRandomRequest : MessageData
{
/// <summary>
/// 奖励数额
/// </summary>
[Key(0)] public int Reward;
#if GameClient
public static AdGiftRandomRequest Create(int reward)
{
AdGiftRandomRequest self = ReferencePool.Acquire<AdGiftRandomRequest>();
self.Reward = reward;
return self;
}
#endif
}
[Message(MessageCode.AdGiftRandomResponse)]
[MessagePackObject]
public class AdGiftRandomResponse : MessageData
{
/// <summary>
/// 今日领取次数
/// </summary>
[Key(0)] public int DayReceiveCnt;
/// <summary>
/// 奖励
/// </summary>
[Key(1)] public int Reward;
#if Server
public static AdGiftRandomResponse Create(int receiveCnt, int reward)
{
AdGiftRandomResponse response = ReferencePool.Fetch<AdGiftRandomResponse>();
response.DayReceiveCnt = receiveCnt;
response.Reward = reward;
return response;
}
public override void Dispose()
{
ReferencePool.Recycle(this);
}
#endif
}
}

79
NetWorkMessage/Message/MessageData/GameCenter/AssetDetailMessage.cs Normal file
View File

@ -0,0 +1,79 @@
using MessagePack;
#if GameClient
using GameFramework;
#endif
namespace GameMessage
{
/// <summary>
/// 资产明细请求
/// </summary>
[Message(MessageCode.AssetDetailRequest)]
[MessagePackObject()]
public class AssetDetailRequest : MessageData
{
/// <summary>
/// 资产Id
/// </summary>
[Key(0)]
public int AssetId;
#if GameClient
public static AssetDetailRequest Create(int assetId)
{
AssetDetailRequest request = ReferencePool.Acquire<AssetDetailRequest>();
request.AssetId = assetId;
return request;
}
#endif
}
/// <summary>
/// 资产明细响应
/// </summary>
[Message(MessageCode.AssetDetailResponse)]
[MessagePackObject()]
public class AssetDetailResponse : MessageData
{
[Key(0)]
public int AssetId;
[Key(1)]
public AssetDetailValue[] Values;
}
[MessagePackObject()]
public class AssetDetailValue
{
/// <summary>
/// 资源Id
/// </summary>
[Key(0)]
public int ResId;
/// <summary>
/// 资源类型
/// </summary>
[Key(1)]
public int ResType;
/// <summary>
/// 变化时间
/// </summary>
[Key(2)]
public long ChangeTime;
/// <summary>
/// 变化值
/// </summary>
[Key(3)]
public long ChangeValue;
/// <summary>
/// 余额
/// </summary>
[Key(4)]
public long NowValue;
}
}

69
NetWorkMessage/Message/MessageData/GameCenter/BlacklistMessage.cs Normal file
View File

@ -0,0 +1,69 @@
using MessagePack;
#if GameClient
using GameFramework;
#endif
namespace GameMessage
{
/// <summary>
/// 黑名单请求
/// </summary>
[Message(MessageCode.BlackListReportRequest)]
[MessagePackObject]
public class BlackListReportRequest : MessageData
{
/// <summary>
/// 所属平台
/// </summary>
[Key(0)] public int Plat;
/// <summary>
/// ip地址
/// </summary>
[Key(1)] public string Ip;
/// <summary>
/// 商店类型
/// </summary>
[Key(2)] public string StoreType;
/// <summary>
/// 设备码
/// </summary>
[Key(3)] public string DeviceId;
/// <summary>
/// 地址信息
/// </summary>
[Key(4)] public string AddressInfo;
#if GameClient
public static BlackListReportRequest Create()
{
return ReferencePool.Acquire<BlackListReportRequest>();
}
public override void Clear()
{
Plat = 0;
Ip = null;
StoreType = null;
DeviceId = null;
AddressInfo = null;
}
#endif
}
/// <summary>
/// 黑名单响应
/// </summary>
[Message(MessageCode.BlackListReportResponse)]
[MessagePackObject]
public class BlackListReportResponse : MessageData
{
/// <summary>
/// 是否需要退出
/// </summary>
[Key(0)] public bool CanQuit;
}
}

116
NetWorkMessage/Message/MessageData/GameCenter/BugReportMessage.cs Normal file
View File

@ -0,0 +1,116 @@
using GameMessage;
using MessagePack;
#if GameClient
using GameFramework;
#endif
namespace GameMessage
{
[Message(MessageCode.BugReportRequest)]
[MessagePackObject()]
public class BugReportRequest : MessageData
{
/// <summary>
/// 联系方式
/// </summary>
[Key(0)] public string Phone;
/// <summary>
/// bug描述
/// </summary>
[Key(1)] public string Description;
/// <summary>
/// 当前游戏的状态
/// </summary>
[Key(2)] public string GameState;
/// <summary>
/// 当前所在的游戏名称
/// </summary>
[Key(3)] public string GameName;
/// <summary>
/// 当前所在的游戏页面
/// </summary>
[Key(4)] public string GamePage;
/// <summary>
/// App版本
/// </summary>
[Key(5)] public string AppVer;
/// <summary>
/// 版本描述
/// </summary>
[Key(6)] public string VerCode;
/// <summary>
/// 资源版本
/// </summary>
[Key(7)] public string ResVer;
/// <summary>
/// 平台名称
/// </summary>
[Key(8)] public string PlatName;
/// <summary>
/// 设备系统
/// </summary>
[Key(9)] public string DeviceSystem;
/// <summary>
/// 是否是测试模式
/// </summary>
[Key(10)] public bool IsTestModel;
/// <summary>
/// 商店类型
/// </summary>
[Key(11)] public string StoreType;
#if GameClient
public static BugReportRequest Create()
{
return ReferencePool.Acquire<BugReportRequest>();
}
public override void Clear()
{
Phone = null;
Description = null;
GameState = null;
GameName = null;
GamePage = null;
AppVer = null;
VerCode = null;
ResVer = null;
PlatName = null;
DeviceSystem = null;
IsTestModel = false;
StoreType = null;
}
#endif
}
[Message(MessageCode.BugReportResponse)]
[MessagePackObject()]
public class BugReportResponse : MessageData
{
/// <summary>
/// 结果类型
/// </summary>
[Key(0)] public int ResultCode;
/// <summary>
/// 日志提交的地址
/// </summary>
[Key(1)] public string ReportUrl;
/// <summary>
/// 提交的日志长度
/// </summary>
[Key(2)] public int LogLength;
}
}

57
NetWorkMessage/Message/MessageData/GameCenter/EditorUserPwdMessage.cs Normal file
View File

@ -0,0 +1,57 @@
using MessagePack;
#if GameClient
using GameFramework;
#endif
namespace GameMessage
{
[Message(MessageCode.EditorUserPwdRequest)]
[MessagePackObject]
public class EditorUserPwdRequest : MessageData
{
/// <summary>
/// 用户名
/// /// </summary>
[Key(0)]
public string UserName;
/// <summary>
/// 密码
/// </summary>
[Key(1)]
public string Pwd;
#if GameClient
public static EditorUserPwdRequest Create(string userName, string pwd)
{
EditorUserPwdRequest request = ReferencePool.Acquire<EditorUserPwdRequest>();
request.UserName = userName;
request.Pwd = pwd;
return request;
}
public override void Clear()
{
UserName = null;
Pwd = null;
}
#endif
}
[Message(MessageCode.EditorUserPwdResponse)]
[MessagePackObject]
public class EditorUserPwdResponse : MessageData
{
/// <summary>
/// 结果
/// </summary>
[Key(0)]
public int ResultCode;
/// <summary>
/// 用户名
/// </summary>
[Key(1)]
public string UserName;
}
}

311
NetWorkMessage/Message/MessageData/GameCenter/EmlMessage.cs Normal file
View File

@ -0,0 +1,311 @@
using MessagePack;
#if GameClient
using GameFramework;
#endif
namespace GameMessage
{
/// <summary>
/// 请求邮件未读数量
/// </summary>
[Message(MessageCode.EmlUnReadCntRequest)]
[MessagePackObject()]
public class EmlUnReadCntRequest : MessageData
{
/// <summary>
/// 是否删除过期的邮件
/// </summary>
[Key(0)] public int DelExpiredEml;
/// <summary>
/// 邮件类型
/// 0系统邮件
/// 1用户邮件
/// 2竞技比赛邮件
/// </summary>
[Key(1)] public int EmlType;
#if GameClient
public static EmlUnReadCntRequest Create()
{
return ReferencePool.Acquire<EmlUnReadCntRequest>();
}
public override void Clear()
{
DelExpiredEml = 0;
EmlType = 0;
}
#endif
}
/// <summary>
/// 响应邮件未读数量
/// </summary>
[Message(MessageCode.EmlUnReadCntResponse)]
[MessagePackObject()]
public class EmlUnReadCntResponse : MessageData
{
[Key(0)] public int Userid;
[Key(1)] public int UnReadEmlCnt;
}
/// <summary>
/// 请求所有未读邮件
/// </summary>
[Message(MessageCode.EmlsUnReadRequest)]
[MessagePackObject()]
public class EmlsUnReadRequest : MessageData
{
/// <summary>
/// 邮件类型
/// 0系统邮件
/// 1用户邮件
/// 2竞技比赛邮件
/// </summary>
[Key(0)] public int EmlType;
#if GameClient
public static EmlsUnReadRequest Create(int emlType)
{
EmlsUnReadRequest request = ReferencePool.Acquire<EmlsUnReadRequest>();
request.EmlType = emlType;
return request;
}
public override void Clear()
{
}
#endif
}
/// <summary>
/// 响应所有未读邮件
/// </summary>
[Message(MessageCode.EmlsUnReadResponse)]
[MessagePackObject()]
public class EmlsUnReadResponse : MessageData
{
[Key(0)] public int Userid;
[Key(1)] public MailContent[] Emls;
}
/// <summary>
/// 请求读取邮件
/// </summary>
[Message(MessageCode.ReadEmlRequest)]
[MessagePackObject()]
public class ReadEmlRequest : MessageData
{
/// <summary>
/// 接收人的Userid
/// </summary>
[Key(0)] public int ReceiveId;
/// <summary>
/// 邮件类型
/// 0系统邮件
/// 1用户邮件
/// 2竞技比赛邮件
/// </summary>
[Key(1)] public int EmlType;
/// <summary>
/// 1读取 2领取 3读取或领取 并删除
/// </summary>
[Key((2))] public int DoWhat;
/// <summary>
/// 唯一码
/// </summary>
[Key(3)] public string Weiyima;
#if GameClient
public static ReadEmlRequest Create()
{
return ReferencePool.Acquire<ReadEmlRequest>();
}
public override void Clear()
{
ReceiveId = 0;
EmlType = 0;
DoWhat = 0;
Weiyima = null;
}
#endif
}
/// <summary>
/// 响应读取邮件
/// </summary>
[Message(MessageCode.ReadEmlResponse)]
[MessagePackObject()]
public class ReadEmlResponse : MessageData
{
/// <summary>
/// 响应结果码
/// 1成功
/// 2未知
/// -1 邮件已被删除
/// -2 邮件已被领取
/// -3 携带的游戏币已达上限
/// </summary>
[Key(0)] public int ResultCode;
/// <summary>
/// 唯一码
/// </summary>
[Key(1)] public string Weiyima;
}
/// <summary>
/// 邮件
/// </summary>
[MessagePackObject()]
public class MailContent
{
/**
* 1.邮件领取类型领取自动删除
* 2.邮件只保留30天
**/
/// <summary>
/// 唯一码
/// </summary>
[Key(0)] public string weiyima;
/// <summary>
/// 收件人id
/// </summary>
[Key(1)] public int receive_id;
/// <summary>
/// 收件人类型 0系统 1普通用户 2竞技比赛
/// </summary>
[Key(2)] public int receive_type;
/// <summary>
/// 发件人id
/// </summary>
[Key(3)] public int send_id;
/// <summary>
/// 发送者名称
/// </summary>
[Key(4)] public string send_name;
/// <summary>
/// 发件人类型 0系统 1普通用户 2竞技比赛
/// </summary>
[Key(5)] public int send_type;
/// <summary>
/// 邮件标题
/// </summary>
[Key(6)] public string mailTitle;
/// <summary>
/// 邮件正文
/// </summary>
[Key(7)] public string strContent;
/// <summary>
/// 邮件资源
/// </summary>
[Key(8)] public GameRes[] mailres;
/// <summary>
/// 发送时间
/// </summary>
[Key(9)] public string sendTime;
/// <summary>
/// 邮件状态 0未读 1已读未领取 2已读
/// </summary>
[Key(10)] public int mailState;
/// <summary>
/// 邮件读取时间
/// </summary>
[Key(11)] public string readTime;
// /// <summary>
// /// 剩余时间
// /// </summary>
// [DefaultValue(-1)] [IgnoreMember] private int m_sur_time = -1;
//
// /// <summary>
// /// 获取剩余时间
// /// </summary>
// public int sur_time
// {
// get
// {
// if (m_sur_time < 0)
// {
// DateTime dt = DateTime.Parse(sendTime);
// dt = dt.AddDays(30);
// TimeSpan ts = dt.Subtract(DateTime.Now);
// m_sur_time = ts.Days;
// if (m_sur_time < 0)
// m_sur_time = 0;
// }
//
// return m_sur_time;
// }
// }
/// <summary>
///
/// </summary>
public MailContent()
{
}
/// <summary>
///
/// </summary>
/// <returns></returns>
public override string ToString()
{
string str = "";
str += "收件人:" + receive_id;
str += "收件人类型:" + receive_type;
str += "发件人:" + send_id;
str += "发件人类型:" + send_type;
str += "邮件标题:" + mailTitle;
str += "邮件正文:" + strContent;
str += "邮件资源:" + mailres;
str += "发送时间:" + sendTime;
str += "邮件状态:" + mailState;
str += "邮件读取时间:" + readTime;
return str;
}
}
/// <summary>
///
/// </summary>
[MessagePackObject()]
public class GameRes
{
/// <summary>
/// 游戏资源类型 0金币 1房卡 2礼券 3钻石 4复活卡 5参赛券 7门票 8红包券
/// </summary>
[Key(0)] public int org;
/// <summary>
/// 资源数量
/// </summary>
[Key(1)] public int count;
/// <summary>
///
/// </summary>
public GameRes()
{
}
}
}

698
NetWorkMessage/Message/MessageData/GameCenter/EntityMallMessage.cs Normal file
View File

@ -0,0 +1,698 @@
using System.Collections.Generic;
using MessagePack;
#if GameClient
using GameFramework;
#else
using Server.Core;
#endif
namespace GameMessage
{
/// <summary>
/// 玩家地址列表请求
/// </summary>
[Message(MessageCode.UserAddressListRequest)]
[MessagePackObject]
public class UserAddressListRequest : MessageData
{
#if GameClient
public static UserAddressListRequest Create()
{
UserAddressListRequest self = ReferencePool.Acquire<UserAddressListRequest>();
return self;
}
public override void Clear()
{
}
#endif
}
/// <summary>
/// 玩家地址列表响应
/// </summary>
[Message(MessageCode.UserAddressListResponse)]
[MessagePackObject]
public class UserAddressListResponse : MessageData
{
/// <summary>
/// 地址列表
/// </summary>
[Key(0)]
public List<UserAddressEntity> AddressList;
#if Server
public static UserAddressListResponse Create()
{
UserAddressListResponse self = ReferencePool.Fetch<UserAddressListResponse>();
return self;
}
public override void Dispose()
{
AddressList = null;
ReferencePool.Recycle(this);
}
#endif
}
/// <summary>
/// 编辑玩家地址请求（新增/修改）
/// </summary>
[Message(MessageCode.EditorUserAddressListRequest)]
[MessagePackObject]
public class EditorUserAddressListRequest : MessageData
{
/// <summary>
/// 编辑类型：0 新增，1 修改
/// </summary>
[Key(0)]
public int EditorType;
/// <summary>
/// 地址数据
/// </summary>
[Key(1)]
public UserAddressEntity Address;
#if GameClient
public static EditorUserAddressListRequest Create(int editorType, UserAddressEntity address)
{
EditorUserAddressListRequest self = ReferencePool.Acquire<EditorUserAddressListRequest>();
self.EditorType = editorType;
self.Address = address;
return self;
}
public override void Clear()
{
EditorType = 0;
Address = null;
}
#endif
}
/// <summary>
/// 编辑玩家地址响应
/// </summary>
[Message(MessageCode.EditorUserAddressListResponse)]
[MessagePackObject]
public class EditorUserAddressListResponse : MessageData
{
/// <summary>
/// 结果码：0 成功
/// </summary>
[Key(0)]
public int ResultCode;
/// <summary>
/// 编辑类型：0 新增，1 修改
/// </summary>
[Key(1)]
public int EditorType;
/// <summary>
/// 编辑后的地址数据
/// </summary>
[Key(2)]
public UserAddressEntity Address;
#if Server
public static EditorUserAddressListResponse Create(int resultCode, int editorType, UserAddressEntity address)
{
EditorUserAddressListResponse self = ReferencePool.Fetch<EditorUserAddressListResponse>();
self.ResultCode = resultCode;
self.EditorType = editorType;
self.Address = address;
return self;
}
public override void Dispose()
{
Address = null;
ReferencePool.Recycle(this);
}
#endif
}
/// <summary>
/// 删除玩家地址请求
/// </summary>
[Message(MessageCode.DeleteUserAddressListRequest)]
[MessagePackObject]
public class DeleteUserAddressListRequest : MessageData
{
/// <summary>
/// 要删除的地址ID
/// </summary>
[Key(0)]
public int UserAddressId;
#if GameClient
public static DeleteUserAddressListRequest Create(int userAddressId)
{
DeleteUserAddressListRequest self = ReferencePool.Acquire<DeleteUserAddressListRequest>();
self.UserAddressId = userAddressId;
return self;
}
public override void Clear()
{
UserAddressId = 0;
}
#endif
}
/// <summary>
/// 删除玩家地址响应
/// </summary>
[Message(MessageCode.DeleteUserAddressListResponse)]
[MessagePackObject]
public class DeleteUserAddressListResponse : MessageData
{
/// <summary>
/// 结果码：0 成功
/// </summary>
[Key(0)]
public int ResultCode;
/// <summary>
/// 已删除的地址ID
/// </summary>
[Key(1)]
public int UserAddressId;
#if Server
public static DeleteUserAddressListResponse Create(int resultCode, int userAddressId)
{
DeleteUserAddressListResponse self = ReferencePool.Fetch<DeleteUserAddressListResponse>();
self.ResultCode = resultCode;
self.UserAddressId = userAddressId;
return self;
}
public override void Dispose()
{
ReferencePool.Recycle(this);
}
#endif
}
/// <summary>
/// 设置默认地址请求
/// </summary>
[Message(MessageCode.UserAddressSetDefaultRequest)]
[MessagePackObject]
public class UserAddressSetDefaultRequest : MessageData
{
/// <summary>
/// 要设为默认的地址ID
/// </summary>
[Key(0)]
public int UserAddressId;
#if GameClient
public static UserAddressSetDefaultRequest Create(int userAddressId)
{
UserAddressSetDefaultRequest self = ReferencePool.Acquire<UserAddressSetDefaultRequest>();
self.UserAddressId = userAddressId;
return self;
}
public override void Clear()
{
UserAddressId = 0;
}
#endif
}
/// <summary>
/// 设置默认地址响应
/// </summary>
[Message(MessageCode.UserAddressSetDefaultResponse)]
[MessagePackObject]
public class UserAddressSetDefaultResponse : MessageData
{
/// <summary>
/// 结果码：0 成功
/// </summary>
[Key(0)]
public int ResultCode;
/// <summary>
/// 已设为默认的地址ID
/// </summary>
[Key(1)]
public int UserAddressId;
#if Server
public static UserAddressSetDefaultResponse Create(int resultCode, int userAddressId)
{
UserAddressSetDefaultResponse self = ReferencePool.Fetch<UserAddressSetDefaultResponse>();
self.ResultCode = resultCode;
self.UserAddressId = userAddressId;
return self;
}
public override void Dispose()
{
ReferencePool.Recycle(this);
}
#endif
}
/// <summary>
/// 获取默认地址请求
/// </summary>
[Message(MessageCode.UserAddressGetDefaultRequest)]
[MessagePackObject]
public class UserAddressGetDefaultRequest : MessageData
{
#if GameClient
public static UserAddressGetDefaultRequest Create()
{
UserAddressGetDefaultRequest self = ReferencePool.Acquire<UserAddressGetDefaultRequest>();
return self;
}
public override void Clear()
{
}
#endif
}
/// <summary>
/// 获取默认地址响应
/// </summary>
[Message(MessageCode.UserAddressGetDefaultResponse)]
[MessagePackObject]
public class UserAddressGetDefaultResponse : MessageData
{
/// <summary>
/// 默认地址数据（若无默认地址则为null）
/// </summary>
[Key(0)]
public UserAddressEntity UserAddress;
#if Server
public static UserAddressGetDefaultResponse Create(UserAddressEntity userAddress)
{
UserAddressGetDefaultResponse self = ReferencePool.Fetch<UserAddressGetDefaultResponse>();
self.UserAddress = userAddress;
return self;
}
public override void Dispose()
{
UserAddress = null;
ReferencePool.Recycle(this);
}
#endif
}
/// <summary>
/// 玩家地址实体
/// </summary>
[MessagePackObject]
public class UserAddressEntity
{
/// <summary>
/// 地址ID
/// </summary>
[Key(0)]
public int Id;
/// <summary>
/// 玩家UserId
/// </summary>
[Key(1)]
public int UserId;
/// <summary>
/// 收货人姓名
/// </summary>
[Key(2)]
public string ReceiverName;
/// <summary>
/// 收货人手机号码
/// </summary>
[Key(3)]
public string Phone;
/// <summary>
/// 省
/// </summary>
[Key(4)]
public string Province;
/// <summary>
/// 市
/// </summary>
[Key(5)]
public string City;
/// <summary>
/// 区/县
/// </summary>
[Key(6)]
public string District;
/// <summary>
/// 详细地址
/// </summary>
[Key(7)]
public string DetailAddress;
/// <summary>
/// 是否是默认地址
/// </summary>
[Key(8)]
public bool IsDefault;
}
[Message(MessageCode.EntityMallDataRequest)]
[MessagePackObject]
public class EntityMallDataRequest : MessageData
{
/// <summary>
/// 版本
/// </summary>
[Key(0)]
public long Ver;
#if GameClient
public static EntityMallDataRequest Create(long ver)
{
EntityMallDataRequest self = ReferencePool.Acquire<EntityMallDataRequest>();
self.Ver = ver;
return self;
}
public override void Clear()
{
Ver = 0;
}
#endif
}
[Message(MessageCode.EntityMallDataResponse)]
[MessagePackObject]
public class EntityMallDataResponse : MessageData
{
[Key(0)]
public EntityMallProductsData Products;
/// <summary>
/// 全服兑换数据
/// </summary>
[Key(1)]
public Dictionary<int, int> ServerExchangeData;
/// <summary>
/// 用户兑换数据
/// </summary>
[Key(2)]
public Dictionary<int, int> UserExchangeData;
#if Server
public static EntityMallDataResponse Create(EntityMallProductsData products, Dictionary<int, int> serverExchangeData, Dictionary<int, int> userExchangeData)
{
EntityMallDataResponse self = ReferencePool.Fetch<EntityMallDataResponse>();
self.Products = products;
self.ServerExchangeData = serverExchangeData;
self.UserExchangeData = userExchangeData;
return self;
}
public override void Dispose()
{
Products = null;
ServerExchangeData = null;
UserExchangeData = null;
ReferencePool.Recycle(this);
}
#endif
}
/// <summary>
/// 所有商品数据
/// </summary>
[MessagePackObject]
public class EntityMallProductsData
{
/// <summary>
/// 版本
/// </summary>
[Key(0)]
public long Ver;
/// <summary>
/// 所有商品
/// </summary>
[Key(1)]
public List<EntityMallProductData> Products;
}
[MessagePackObject]
public class EntityMallProductData
{
[Key(0)]
public int Id;
[Key(1)]
public string Name;
[Key(2)]
public int RedMoney;
[Key(3)]
public int ProductType;
[Key(4)]
public int MallType;
[Key(5)]
public int DayLimit;
[Key(6)]
public int UserDayLimit;
[Key(7)]
public int Sort;
[Key(8)]
public string Desc;
}
/// <summary>
/// 实体商城兑换请求
/// </summary>
[Message(MessageCode.EntityMallExchangeRequest)]
[MessagePackObject]
public class EntityMallExchangeRequest : MessageData
{
/// <summary>
/// 商品Id
/// </summary>
[Key(0)]
public int ProductId;
/// <summary>
/// 地址Id（实物商品需要）
/// </summary>
[Key(1)]
public int AddressId;
/// <summary>
/// 账号（虚拟商品需要，必须是手机号）
/// </summary>
[Key(2)]
public string Account;
#if GameClient
public static EntityMallExchangeRequest Create(int productId, int addressId, string account)
{
EntityMallExchangeRequest self = ReferencePool.Acquire<EntityMallExchangeRequest>();
self.ProductId = productId;
self.AddressId = addressId;
self.Account = account;
return self;
}
public override void Clear()
{
ProductId = 0;
AddressId = 0;
Account = null;
}
#endif
}
/// <summary>
/// 实体商城兑换响应
/// </summary>
[Message(MessageCode.EntityMallExchangeResponse)]
[MessagePackObject]
public class EntityMallExchangeResponse : MessageData
{
/// <summary>
/// 商品Id
/// </summary>
[Key(0)]
public int ProductId;
/// <summary>
/// 结果码
/// </summary>
[Key(1)]
public int ResultCode;
#if Server
public static EntityMallExchangeResponse Create(int productId, int resultCode)
{
EntityMallExchangeResponse self = ReferencePool.Fetch<EntityMallExchangeResponse>();
self.ProductId = productId;
self.ResultCode = resultCode;
return self;
}
public override void Dispose()
{
ReferencePool.Recycle(this);
}
#endif
}
/// <summary>
/// 用户订单列表请求
/// </summary>
[Message(MessageCode.EntityMallOrderListRequest)]
[MessagePackObject]
public class EntityMallOrderListRequest : MessageData
{
#if GameClient
public static EntityMallOrderListRequest Create()
{
EntityMallOrderListRequest self = ReferencePool.Acquire<EntityMallOrderListRequest>();
return self;
}
public override void Clear()
{
}
#endif
}
/// <summary>
/// 用户订单列表响应
/// </summary>
[Message(MessageCode.EntityMallOrderListResponse)]
[MessagePackObject]
public class EntityMallOrderListResponse : MessageData
{
/// <summary>
/// 订单列表
/// </summary>
[Key(0)]
public List<EntityMallOrderData> OrderList;
#if Server
public static EntityMallOrderListResponse Create(List<EntityMallOrderData> orderList)
{
EntityMallOrderListResponse self = ReferencePool.Fetch<EntityMallOrderListResponse>();
self.OrderList = orderList;
return self;
}
public override void Dispose()
{
OrderList = null;
ReferencePool.Recycle(this);
}
#endif
}
/// <summary>
/// 订单数据
/// </summary>
[MessagePackObject]
public class EntityMallOrderData
{
/// <summary>
/// 订单ID
/// </summary>
[Key(0)]
public int Id;
/// <summary>
/// 商品ID
/// </summary>
[Key(1)]
public int ProductId;
/// <summary>
/// 商品名称
/// </summary>
[Key(2)]
public string ProductName;
/// <summary>
/// 商品描述
/// </summary>
[Key(3)]
public string ProductDesc;
/// <summary>
/// 商品类型：1实物商品，2虚拟商品
/// </summary>
[Key(4)]
public int ProductType;
/// <summary>
/// 兑换数量
/// </summary>
[Key(5)]
public int ExchangeCount;
/// <summary>
/// 兑换时间
/// </summary>
[Key(6)]
public long ExchangeTime;
/// <summary>
/// 账号（虚拟商品）
/// </summary>
[Key(7)]
public string Account;
/// <summary>
/// 收货地址（实物商品，完整地址信息）
/// </summary>
[Key(8)]
public string Address;
/// <summary>
/// 订单状态：0已提交，1已发货
/// </summary>
[Key(9)]
public int OrderStatus;
/// <summary>
/// 发货时间
/// </summary>
[Key(10)]
public long ShipTime;
/// <summary>
/// 备注
/// </summary>
[Key(11)]
public string Remark;
}
}

202
NetWorkMessage/Message/MessageData/GameCenter/FriendRoomMessage.cs Normal file
View File

@ -0,0 +1,202 @@
using MessagePack;
using System.Collections.Generic;
using System;
#if GameClient
using GameFramework;
#endif
namespace GameMessage
{
[Message(MessageCode.JoinRoomRequest)]
[MessagePackObject()]
public class JoinRoomRequest : MessageData
{
/// <summary>
/// 房间号
/// </summary>
[Key(0)] public int RoomId;
#if GameClient
public static JoinRoomRequest Create(int roomId)
{
JoinRoomRequest request = ReferencePool.Acquire<JoinRoomRequest>();
request.RoomId = roomId;
return request;
}
#endif
}
[Message(MessageCode.JoinRoomResponse)]
[MessagePackObject()]
public class JoinRoomResponse : MessageData
{
/// <summary>
/// 房间号
/// </summary>
[Key(0)] public int RoomId;
/// <summary>
/// 房间所属模块Id
/// </summary>
[Key(1)] public int ModuleId;
}
[MessagePackObject]
public class FriendRoomRecordInfo
{
/// <summary>
/// ID
/// </summary>
[Key(0)] public int Id;
/// <summary>
/// 创建人Id
/// </summary>
[Key(1)] public int CreateUserId;
/// <summary>
/// 玩法id
/// 从int 改为string 之前也没有使用上。
/// </summary>
[Key(2)] public string WayId;
/// <summary>
/// 朋友房唯一码
/// </summary>
[Key(3)] public string WeiYiMa;
/// <summary>
/// 游戏的服务器id
/// </summary>
[Key(4)] public int GameSerId;
/// <summary>
/// 房间号
/// </summary>
[Key(5)] public int RoomNum;
/// <summary>
/// 开始时间
/// </summary>
[Key(6)] public long StartTime;
/// <summary>
/// 结束时间
/// </summary>
[Key(7)] public long EndTime;
/// <summary>
/// 开战次数
/// </summary>
[Key(8)] public int WarCnt;
/// <summary>
/// 打完多少盘
/// </summary>
[Key(9)] public int OverCnt;
/// <summary>
/// 耗卡数量 --xu add
/// </summary>
[Key(10)] public int CardNum;
/// <summary>
/// 解散原因
/// </summary>
[Key(11)] public int DisBankStyle;
/// <summary>
/// 分值
/// </summary>
[Key(12)] public List<PlayerFightData> Players;
/// <summary>
/// 解散玩家id
/// </summary>
[Key(13)] public int DisUserId;
}
[Message(MessageCode.GetFriendRoomRecordListRequest)]
[MessagePackObject()]
public class GetFriendRoomRecordListRequest : MessageData
{
/// <summary>
/// 页码索引
/// </summary>
[Key(0)] public int PageIndex;
/// <summary>
/// 页码大小
/// </summary>
[Key(1)] public int PageSize;
#if GameClient
public static GetFriendRoomRecordListRequest Create(int pageIndex,int pageSize)
{
GetFriendRoomRecordListRequest request = ReferencePool.Acquire<GetFriendRoomRecordListRequest>();
request.PageIndex = pageIndex;
request.PageSize = pageSize;
return request;
}
#endif
}
[Message(MessageCode.GetFriendRoomRecordListResponse)]
[MessagePackObject()]
public class GetFriendRoomRecordListResponse : MessageData
{
/// <summary>
/// 战绩列表数据
/// </summary>
[Key(0)] public List<WarFriendItemData> Datas;
}
[Message(MessageCode.GetFriendRoomFightDataRequest)]
[MessagePackObject()]
public class GetFriendRoomFightDataRequest : MessageData
{
/// <summary>
/// 战绩唯一码
/// </summary>
[Key(0)] public string WeiYiMa;
/// <summary>
/// 第几局
/// </summary>
[Key(1)] public int Index;
/// <summary>
/// 服务器ID
/// </summary>
[Key(2)] public int GameSerId;
/// <summary>
/// 回放数据时间
/// </summary>
[Key(3)] public DateTime Time;
#if GameClient
public static GetFriendRoomFightDataRequest Create()
{
return ReferencePool.Acquire<GetFriendRoomFightDataRequest>();
}
public override void Clear()
{
WeiYiMa = null;
Index = 0;
GameSerId = 0;
}
#endif
}
[Message(MessageCode.GetFriendRoomFightDataResponse)]
[MessagePackObject()]
public class GetFriendRoomFightDataResponse : MessageData
{
/// <summary>
/// 战绩回放数据
/// </summary>
[Key(0)] public string JsonPack;
}
}

235
NetWorkMessage/Message/MessageData/GameCenter/GameRankingMessage.cs Normal file
View File

@ -0,0 +1,235 @@
using System.Collections.Generic;
using MessagePack;
#if GameClient
using GameFramework;
#endif
namespace GameMessage
{
/// <summary>
/// 获取游戏排行榜请求
/// </summary>
[Message(MessageCode.GetGameRankingRequest)]
[MessagePackObject()]
public class GetGameRankingRequest : MessageData
{
/// <summary>
/// 天 -如果请求年和月的数据，这个字段不用赋值
/// </summary>
[Key(0)]
public int Day;
/// <summary>
/// 月 -如果请求年的数据，这个字段不用赋值
/// </summary>
[Key(1)]
public int Month;
/// <summary>
/// 年
/// </summary>
[Key(2)]
public int Year;
/// <summary>
/// 获取第几周的时间
/// </summary>
[Key(3)]
public int WeekDay;
/// <summary>
/// 请求排行榜的类型 游戏ID
/// </summary>
[Key(4)]
public int Type;
#if GameClient
public static GetGameRankingRequest Create()
{
GetGameRankingRequest request = ReferencePool.Acquire<GetGameRankingRequest>();
return request;
}
public override void Clear()
{
Day = 0;
Month = 0;
Year = 0;
WeekDay = 0;
Type = 0;
}
#endif
}
/// <summary>
/// 获取游戏排行榜响应
/// </summary>
[Message(MessageCode.GetGameRankingResponse)]
[MessagePackObject()]
public class GetGameRankingResponse : MessageData
{
/// <summary>
/// 排行榜的类型 游戏ID
/// </summary>
[Key(0)]
public int Type;
/// <summary>
/// 榜单
/// </summary>
[Key(1)]
public List<PlayerInfoOfRanking> List;
}
[MessagePackObject()]
public class PlayerInfoOfRanking
{
/// <summary>
/// 名次
/// </summary>
[Key(0)]
public int Index;
/// <summary>
/// 昵称
/// </summary>
[Key(1)]
public string NickName;
/// <summary>
/// 数值
/// </summary>
[Key(2)]
public long Number;
[Key(3)]
public int Sex;
[Key(4)]
public int userid;
/// <summary>
/// CTOR
/// </summary>
public PlayerInfoOfRanking()
{
}
}
/// <summary>
/// 获取积分奖励列表请求
/// </summary>
[Message(MessageCode.GetScoreRewardListRequest)]
[MessagePackObject]
public class GetScoreRewardListRequest : MessageData
{
[Key(0)]
public int GameId;
#if GameClient
public static GetScoreRewardListRequest Create()
{
GetScoreRewardListRequest request = ReferencePool.Acquire<GetScoreRewardListRequest>();
return request;
}
public override void Clear()
{
}
#endif
}
/// <summary>
/// 获取积分奖励列表响应
/// </summary>
[Message(MessageCode.GetScoreRewardListResponse)]
[MessagePackObject]
public class GetScoreRewardListResponse : MessageData
{
/// <summary>
/// 积分奖励列表
/// </summary>
[Key(0)]
public List<RewardOfScore> RewardList;
}
[MessagePackObject()]
public class RewardOfScore
{
/// <summary>
/// 积分
/// </summary>
[Key(0)]
public int Score;
/// <summary>
/// 奖励物品
/// </summary>
[Key(1)]
public Dictionary<int, long> RewardItems;
/// <summary>
/// 奖励索引
/// </summary>
[Key(2)]
public int RewardIndex;
/// <summary>
/// CTOR
/// </summary>
public RewardOfScore()
{
}
}
/// <summary>
/// 领取积分奖励请求
/// </summary>
[Message(MessageCode.ReceiveScoreRewardRequest)]
[MessagePackObject]
public class ReceiveScoreRewardRequest : MessageData
{
[Key(0)]
public int UserId;
[Key(1)]
public int RewardIndex;
[Key(2)]
public int RequiredScore;
[Key(3)]
public int GameId;
#if GameClient
public static ReceiveScoreRewardRequest Create()
{
ReceiveScoreRewardRequest request = ReferencePool.Acquire<ReceiveScoreRewardRequest>();
return request;
}
public override void Clear()
{
UserId = 0;
RewardIndex = 0;
RequiredScore = 0;
}
#endif
}
/// <summary>
/// 领取积分奖励响应
/// </summary>
[Message(MessageCode.ReceiveScoreRewardResponse)]
[MessagePackObject]
public class ReceiveScoreRewardResponse : MessageData
{
}
}

58
NetWorkMessage/Message/MessageData/GameCenter/GameRecordLogMessage.cs Normal file
View File

@ -0,0 +1,58 @@
using System.Collections.Generic;
using MessagePack;
#if GameClient
using GameFramework;
#endif
namespace GameMessage
{
[Message(MessageCode.GetGameGoldRecordLogRequest)]
[MessagePackObject]
public class GetGameGoldRecordLogRequest : MessageData
{
/// <summary>
/// 查最近几天的
/// </summary>
[Key(0)] public int Day;
/// <summary>
/// 那个游戏 -1 表示全部游戏
/// </summary>
[Key(1)] public int GameClientId;
/// <summary>
/// 第几页
/// </summary>
[Key(2)] public int Page;
/// <summary>
/// 一页显示多少条
/// </summary>
[Key(3)] public int PageSize;
#if GameClient
public static GetGameGoldRecordLogRequest Create()
{
return ReferencePool.Acquire<GetGameGoldRecordLogRequest>();
}
public override void Clear()
{
Day = 0;
GameClientId = 0;
Page = 0;
PageSize = 0;
}
#endif
}
[Message(MessageCode.GetGameGoldRecordLogResponse)]
[MessagePackObject]
public class GetGameGoldRecordLogResponse : MessageData
{
/// <summary>
/// 数据
/// </summary>
[Key(0)] public List<WarGoldRecordItemData> Datas;
}
}

93
NetWorkMessage/Message/MessageData/GameCenter/GeneralAdGiftMessage.cs Normal file
View File

@ -0,0 +1,93 @@
using GameMessage;
using MessagePack;
#if Server
using Server.Core;
#else
using GameFramework;
#endif
namespace UnityGame
{
[Message(MessageCode.GeneralAdGiftDataRequest)]
[MessagePackObject]
public class GeneralAdGiftDataRequest : MessageData
{
}
[Message(MessageCode.GeneralAdGiftDataResponse)]
[MessagePackObject]
public class GeneralAdGiftDataResponse : MessageData
{
[Key(0)] public int DayReceiveCnt;
#if Server
public static GeneralAdGiftDataResponse Create(int receiveCnt)
{
GeneralAdGiftDataResponse response = ReferencePool.Fetch<GeneralAdGiftDataResponse>();
response.DayReceiveCnt = receiveCnt;
return response;
}
public override void Dispose()
{
ReferencePool.Recycle(this);
}
#endif
}
[Message(MessageCode.GeneralAdGiftRequest)]
[MessagePackObject]
public class GeneralAdGiftRequest : MessageData
{
/// <summary>
/// 奖励数额
/// </summary>
[Key(0)] public int Reward;
/// <summary>
/// 领取类型
/// </summary>
[Key(1)] public int ReceiveType;
#if GameClient
public static GeneralAdGiftRequest Create(int reward, int receiveType)
{
GeneralAdGiftRequest self = ReferencePool.Acquire<GeneralAdGiftRequest>();
self.Reward = reward;
self.ReceiveType = receiveType;
return self;
}
#endif
}
[Message(MessageCode.GeneralAdGiftResponse)]
[MessagePackObject]
public class GeneralAdGiftResponse : MessageData
{
/// <summary>
/// 今日领取次数
/// </summary>
[Key(0)] public int DayReceiveCnt;
/// <summary>
/// 奖励
/// </summary>
[Key(1)] public int Reward;
#if Server
public static GeneralAdGiftResponse Create(int receiveCnt, int reward)
{
GeneralAdGiftResponse response = ReferencePool.Fetch<GeneralAdGiftResponse>();
response.DayReceiveCnt = receiveCnt;
response.Reward = reward;
return response;
}
public override void Dispose()
{
ReferencePool.Recycle(this);
}
#endif
}
}

14
NetWorkMessage/Message/MessageData/GameCenter/HeartMessage.cs Normal file
View File

@ -0,0 +1,14 @@
using MessagePack;
namespace GameMessage
{
/// <summary>
/// 心跳包
/// </summary>
[Message(MessageCode.GameCenterHeart)]
[MessagePackObject]
public class HeartMessage : MessageData
{
[Key(0)] public long HeartId;
}
}

89
NetWorkMessage/Message/MessageData/GameCenter/HuaWeiPayRequest.cs Normal file
View File

@ -0,0 +1,89 @@
using MessagePack;
#if GameClient
using GameFramework;
#endif
namespace GameMessage
{
[Message(MessageCode.HuaWeiPayRequest)]
[MessagePackObject]
public class HuaWeiPayRequest : MessageData
{
/// <summary>
/// 给服务器使用的商品ID
/// </summary>
[Key(0)] public string ProductId;
/// <summary>
/// 给服务使用的商品token
/// </summary>
[Key(1)] public string PurchaseToken;
/// <summary>
/// 购买详情
/// </summary>
[Key(2)] public string InAppPurchaseData;
/// <summary>
/// 签名字符串
/// </summary>
[Key(3)] public string InAppPurchaseDataSignature;
#if GameClient
public static HuaWeiPayRequest Create()
{
return ReferencePool.Acquire<HuaWeiPayRequest>();
}
public override void Clear()
{
ProductId = null;
PurchaseToken = null;
InAppPurchaseData = null;
InAppPurchaseDataSignature = null;
}
#endif
}
[Message(MessageCode.HuaWeiPayResponse)]
[MessagePackObject]
public class HuaWeiPayReponse : MessageData
{
/// <summary>
/// 给服务器使用的商品ID
/// </summary>
[Key(0)] public string ProductId;
/// <summary>
/// 给服务使用的商品token
/// </summary>
[Key(1)] public string PurchaseToken;
/// <summary>
/// 购买详情
/// </summary>
[Key(2)] public string InAppPurchaseData;
/// <summary>
/// 签名字符串
/// </summary>
[Key(3)] public string InAppPurchaseDataSignature;
/// <summary>
/// 状态 1成功 其他失败
/// </summary>
[Key(4)] public int State;
/// <summary>
/// 加的道具类型
/// 1钻石 2礼券 3参赛卷 4门票 5复活卡 6金币 7红包券
/// </summary>
[Key(5)] public int Type;
/// <summary>
/// 需要加的数值
/// </summary>
[Key(6)] public int Value;
}
}

642
NetWorkMessage/Message/MessageData/GameCenter/JianCaiBiSaiMessage.cs Normal file
View File

@ -0,0 +1,642 @@
using System;
using System.Collections.Generic;
using MessagePack;
#if GameClient
using GameFramework;
#endif
#if Server
using Server.Core;
#endif
namespace GameMessage
{
/// <summary>
/// 比赛报名请求
/// </summary>
[Message(MessageCode.JianCaiRaceCompetitionRequest)]
[MessagePackObject]
public class JianCaiRaceCompetitionRequest : MessageData
{
/// <summary>
/// 报名信息
/// </summary>
[Key(0)] public JianCaiRaceCompetitionInfo CompetitionInfo;
/// <summary>
/// 验证码
/// </summary>
[Key(1)] public string VerifyCode;
#if GameClient
public static JianCaiRaceCompetitionRequest Create()
{
return ReferencePool.Acquire<JianCaiRaceCompetitionRequest>();
}
public override void Clear()
{
CompetitionInfo = null;
VerifyCode = null;
}
#endif
}
/// <summary>
/// 报名结果响应
/// </summary>
[Message(MessageCode.JianCaiRaceCompetitionResponse)]
[MessagePackObject]
public class JianCaiRaceCompetitionResponse : MessageData
{
/// <summary>
/// 报名结果错误码
/// </summary>
[Key(0)] public int ResultCode;
/// <summary>
/// 报名信息
/// </summary>
[Key(1)] public JianCaiRaceCompetitionInfo CompetitionInfo;
/// <summary>
/// 奖励
/// </summary>
[Key(2)] public ResData[] Reward;
#if Server
public static JianCaiRaceCompetitionResponse Create()
{
JianCaiRaceCompetitionResponse self = ReferencePool.Fetch<JianCaiRaceCompetitionResponse>();
self.ResultCode = 0;
self.Reward = null;
return self;
}
public override void Dispose()
{
ResultCode = 0;
CompetitionInfo = null;
Reward = null;
ReferencePool.Recycle(this);
}
#endif
}
/// <summary>
/// 报名信息查询请求
/// </summary>
[Message(MessageCode.JianCaiRaceCompetitionInfoRequest)]
[MessagePackObject]
public class JianCaiRaceCompetitionInfoRequest : MessageData
{
/// <summary>
/// 查询的用户UserId，查询自己填0
/// </summary>
[Key(0)] public int UserId;
#if GameClient
public static JianCaiRaceCompetitionInfoRequest Create()
{
return ReferencePool.Acquire<JianCaiRaceCompetitionInfoRequest>();
}
public override void Clear()
{
UserId = 0;
}
#endif
}
/// <summary>
/// 报名信息查询响应
/// </summary>
[Message(MessageCode.JianCaiRaceCompetitionInfoResponse)]
[MessagePackObject]
public class JianCaiRaceCompetitionInfoResponse : MessageData
{
/// <summary>
/// 查询的用户UserId
/// </summary>
[Key(0)] public int UserId;
[Key(1)] public int ResultCode;
/// <summary>
/// 自己的报名信息
/// </summary>
[Key(2)] public JianCaiRaceCompetitionInfo Self;
/// <summary>
/// 队友的报名信息
/// </summary>
[Key(3)] public JianCaiRaceCompetitionInfo Friend;
/// <summary>
/// 队友的游戏信息
/// </summary>
[Key(4)] public RaceGameInfo FriendGameInfo;
#if Server
public static JianCaiRaceCompetitionInfoResponse Create(int userId)
{
JianCaiRaceCompetitionInfoResponse self = ReferencePool.Fetch<JianCaiRaceCompetitionInfoResponse>();
self.ResultCode = 0;
self.UserId = userId;
return self;
}
public override void Dispose()
{
UserId = 0;
Self = null;
Friend = null;
FriendGameInfo = null;
ReferencePool.Recycle(this);
}
#endif
}
[Message(MessageCode.JianCaiRaceCompetitionInfoByRaceIdRequest)]
[MessagePackObject]
public class JianCaiRaceCompetitionInfoByRaceIdRequest : MessageData
{
[Key(0)] public string Tag;
[Key(1)] public int RaceId;
#if GameClient
public static JianCaiRaceCompetitionInfoByRaceIdRequest Create(string tag, int raceId)
{
JianCaiRaceCompetitionInfoByRaceIdRequest self =
ReferencePool.Acquire<JianCaiRaceCompetitionInfoByRaceIdRequest>();
self.Tag = tag;
self.RaceId = raceId;
return self;
}
public override void Clear()
{
}
#endif
}
[Message(MessageCode.JianCaiRaceCompetitionInfoByRaceIdResponse)]
[MessagePackObject]
public class JianCaiRaceCompetitionInfoByRaceIdResponse : MessageData
{
[Key(0)] public string Tag;
/// <summary>
/// 自己的报名信息
/// </summary>
[Key(1)] public JianCaiRaceCompetitionInfo info;
[Key(2)] public int UserId;
#if Server
public static JianCaiRaceCompetitionInfoByRaceIdResponse Create(string tag)
{
JianCaiRaceCompetitionInfoByRaceIdResponse self =
ReferencePool.Fetch<JianCaiRaceCompetitionInfoByRaceIdResponse>();
self.Tag = tag;
self.info = null;
self.UserId = 0;
return self;
}
public override void Dispose()
{
Tag = null;
info = null;
ReferencePool.Recycle(this);
}
#endif
}
/// <summary>
/// 建材比赛报名信息查询
/// </summary>
[Message(MessageCode.JianCaiRaceCompetitionInfoByPhoneRequest)]
[MessagePackObject]
public class JianCaiRaceCompetitionInfoByPhoneRequest : MessageData
{
/// <summary>
/// 手机号
/// </summary>
[Key(0)] public string PhoneNumber;
}
[Message(MessageCode.JianCaiRaceCompetitionInfoByPhoneResponse)]
[MessagePackObject]
public class JianCaiRaceCompetitionInfoByPhoneResponse : MessageData
{
[Key(0)] public int ResultCode;
/// <summary>
/// 自己的报名信息
/// </summary>
[Key(1)] public JianCaiRaceCompetitionInfo Self;
/// <summary>
/// 队友的游戏信息
/// </summary>
[Key(2)] public RaceGameInfo FriendGameInfo;
#if Server
public static JianCaiRaceCompetitionInfoByPhoneResponse Create()
{
JianCaiRaceCompetitionInfoByPhoneResponse self =
ReferencePool.Fetch<JianCaiRaceCompetitionInfoByPhoneResponse>();
self.ResultCode = 0;
return self;
}
public override void Dispose()
{
this.Self = null;
this.FriendGameInfo = null;
ReferencePool.Recycle(this);
}
#endif
}
/// <summary>
/// 注册成为建材比赛的用户
/// </summary>
[Message(MessageCode.RegisterJianCaiBiSaiRequest)]
[MessagePackObject]
public class RegisterJianCaiBiSaiRequest : MessageData
{
#if GameClient
public static RegisterJianCaiBiSaiRequest Create()
{
RegisterJianCaiBiSaiRequest self = ReferencePool.Acquire<RegisterJianCaiBiSaiRequest>();
return self;
}
public override void Clear()
{
}
#endif
}
/// <summary>
/// 注册成为建材比赛用户的响应
/// </summary>
[Message(MessageCode.RegisterJianCaiBiSaiResponse)]
[MessagePackObject]
public class RegisterJianCaiBiSaiResponse : MessageData
{
/// <summary>
/// 注册结果
/// </summary>
[Key(0)] public int ResultCode;
/// <summary>
/// 是否是注册
/// </summary>
[Key(1)] public bool IsRegister;
#if Server
public static RegisterJianCaiBiSaiResponse Create()
{
RegisterJianCaiBiSaiResponse self = ReferencePool.Fetch<RegisterJianCaiBiSaiResponse>();
self.IsRegister = false;
return self;
}
public override void Dispose()
{
ReferencePool.Recycle(this);
}
#endif
}
[Message(MessageCode.JianCaiGetTeammateApplyRequest)]
[MessagePackObject]
public class JianCaiGetTeammateApplyRequest : MessageData
{
/// <summary>
/// 队友的比赛ID
/// </summary>
[Key(0)] public int FriendRaceId;
#if GameClient
public static JianCaiGetTeammateApplyRequest Create(int friendRaceId)
{
JianCaiGetTeammateApplyRequest self = ReferencePool.Acquire<JianCaiGetTeammateApplyRequest>();
self.FriendRaceId = friendRaceId;
return self;
}
#endif
}
[Message(MessageCode.JianCaiGetTeammateApplyResponse)]
[MessagePackObject]
public class JianCaiGetTeammateApplyResponse : MessageData
{
/// <summary>
/// 成为队友信息结果
/// </summary>
[Key(0)] public int ResultCode;
/// <summary>
/// 队友的报名信息
/// </summary>
[Key(1)] public JianCaiRaceCompetitionInfo Friend;
/// <summary>
/// 队友的游戏信息
/// </summary>
[Key(2)] public RaceGameInfo FriendGameInfo;
#if Server
public static JianCaiGetTeammateApplyResponse Create()
{
JianCaiGetTeammateApplyResponse self = ReferencePool.Fetch<JianCaiGetTeammateApplyResponse>();
return self;
}
public override void Dispose()
{
Friend = null;
FriendGameInfo = null;
ReferencePool.Recycle(this);
}
#endif
}
[Message(MessageCode.UnbindTeammateRequest)]
[MessagePackObject]
public class UnbindTeammateRequest : MessageData
{
}
[Message(MessageCode.UnbindTeammateResponse)]
[MessagePackObject]
public class UnbindTeammateResponse : MessageData
{
/// <summary>
/// 解除队友绑定
/// </summary>
[Key(0)] public int ResultCode;
#if Server
public static UnbindTeammateResponse Create()
{
UnbindTeammateResponse self = ReferencePool.Fetch<UnbindTeammateResponse>();
self.ResultCode = 0;
return self;
}
public override void Dispose()
{
ReferencePool.Recycle(this);
}
#endif
}
/// <summary>
/// 建材比赛所有轮的信息
/// </summary>
[MessagePackObject]
[Message(MessageCode.JianCaiRoundInfosRequest)]
public class JianCaiRoundInfosRequest : MessageData
{
}
[MessagePackObject]
[Message(MessageCode.JianCaiRoundInfosResponse)]
public class JianCaiRoundInfosResponse : MessageData
{
/// <summary>
/// 轮次信息
/// </summary>
[Key(0)] public JianCaiRoundInfo[] RoundInfos;
}
[MessagePackObject]
[Message(MessageCode.JianCaiRoundChouQianRequest)]
public class JianCaiRoundChouQianRequest : MessageData
{
/// <summary>
/// 抽签的轮次
/// </summary>
[Key(0)] public int RoundNumber;
}
[MessagePackObject]
[Message(MessageCode.JianCaiRoundChouQianResponse)]
public class JianCaiRoundChouQianResponse : MessageData
{
}
[MessagePackObject]
[Message(MessageCode.JianCaiDuiZhenInfosRequest)]
public class JianCaiDuiZhenInfosRequest : MessageData
{
/// <summary>
/// 对阵信息 大于0指定轮次获取 小于0获取当前轮信息(如果没有当前轮次，则获取所有轮次信息)
/// </summary>
[Key(0)] public int RoundNumber;
}
[MessagePackObject]
[Message(MessageCode.JianCaiDuiZhenInfosResponse)]
public class JianCaiDuiZhenInfosResponse : MessageData
{
/// <summary>
/// 轮次信息
/// </summary>
[Key(0)] public JianCaiRoundInfo RoundInfo;
/// <summary>
/// 参赛者信息
/// </summary>
[Key(1)] public JianCaiPlayerInfo[] PlayerInfos;
/// <summary>
/// 队伍信息
/// </summary>
[Key(2)] public JianCaiTeamInfo[] TeamInfos;
/// <summary>
/// 桌子信息
/// </summary>
[Key(3)] public List<JianCaiTableInfo> TableInfos;
#if Server
public static JianCaiDuiZhenInfosResponse Create()
{
JianCaiDuiZhenInfosResponse self = ReferencePool.Fetch<JianCaiDuiZhenInfosResponse>();
return self;
}
public override void Dispose()
{
RoundInfo = null;
PlayerInfos = null;
TeamInfos = null;
TableInfos = null;
ReferencePool.Recycle(this);
}
#endif
}
[Message(MessageCode.JianCaiBiSaiScoreImportRequest)]
[MessagePackObject]
public class JianCaiBiSaiScoreImportRequest : MessageData
{
[Key(0)]
public int RoundNumber;
[Key(1)]
public TeamScoreInfo[] TeamInfos;
}
[Message(MessageCode.JianCaiBiSaiScoreImportResponse)]
[MessagePackObject]
public class JianCaiBiSaiScoreImportResponse : MessageData
{
[Key(0)]
public int ResultCode;
}
/// <summary>
/// 建材比赛信息
/// </summary>
[MessagePackObject]
public class JianCaiRoundInfo
{
[Key(0)] public int RoundId;
[Key(1)] public int RoundNumber;
[Key(2)] // 0-未开始, 1-进行中, 2-已结束
public int Status;
[Key(3)] public long CreateTime;
[Key(4)] public long StartTime;
[Key(5)] public long EndTime;
}
/// <summary>
/// 建材比赛参赛者信息
/// </summary>
[MessagePackObject]
public class JianCaiPlayerInfo
{
[Key(0)] public int Id;
[Key(1)] public int PlayerId;
[Key(2)] public string Name;
[Key(3)] public string Phone;
[Key(4)] public int UserId;
[Key(5)] public string Company;
[Key(6)] public string Position;
[Key(7)] public int TeamId;
}
[MessagePackObject]
public class JianCaiTeamInfo
{
[Key(0)] public int TeamId;
[Key(1)] public string TeamName;
[Key(2)] public int Member1Id;
[Key(3)] public int Member2Id;
[Key(4)] public int TotalScore;
}
[MessagePackObject]
public class JianCaiTableInfo
{
[Key(0)] public int TableId;
[Key(1)] public int TableNumber;
[Key(2)] public int RoundId;
[Key(3)] public int Team1Id;
[Key(4)] public int Team2Id;
[Key(5)] public int Team1Score;
[Key(6)] public int Team2Score;
}
/// <summary>
/// 报名信息
/// </summary>
[MessagePackObject]
public class JianCaiRaceCompetitionInfo
{
/// <summary>
/// 参赛ID
/// </summary>
[Key(0)] public int RaceId;
/// <summary>
/// 姓名
/// </summary>
[Key(1)] public string RealName;
/// <summary>
/// 手机号
/// </summary>
[Key(2)] public string PhoneNumber;
/// <summary>
/// 公司
/// </summary>
[Key(3)] public string Company;
/// <summary>
/// 职位
/// </summary>
[Key(4)] public string Position;
}
/// <summary>
/// 游戏信息
/// </summary>
[MessagePackObject]
public class RaceGameInfo
{
/// <summary>
/// 用户ID
/// </summary>
[Key(0)] public int UserId;
}
/// <summary>
/// 队伍的分数
/// </summary>
[MessagePackObject]
public class TeamScoreInfo
{
[Key(0)]
public string TeamName;
[Key(1)]
public int Score;
}
}

33
NetWorkMessage/Message/MessageData/GameCenter/LogOutMessage.cs Normal file
View File

@ -0,0 +1,33 @@
using MessagePack;
#if GameClient
using GameFramework;
#endif
namespace GameMessage
{
/// <summary>
/// 注销请求
/// </summary>
[Message(MessageCode.LogOutRequest)]
[MessagePackObject()]
public class LogOutRequest : MessageData
{
#if GameClient
public static LogOutRequest Create()
{
return ReferencePool.Acquire<LogOutRequest>();
}
#endif
}
/// <summary>
/// 注销响应
/// </summary>
[Message(MessageCode.LogOutResponse)]
[MessagePackObject()]
public class LogOutResponse : MessageData
{
[Key(0)]
public int ResultCode;
}
}

482
NetWorkMessage/Message/MessageData/GameCenter/LoginMessage.cs Normal file
View File

@ -0,0 +1,482 @@
using System;
using MessagePack;
#if GameClient
using GameFramework;
#endif
namespace GameMessage
{
/// <summary>
/// 用户登录包
/// </summary>
[Message(MessageCode.LoginRequest)]
[MessagePackObject]
public class LoginRequest : MessageData
{
/// <summary>
/// 用户名
/// </summary>
[Key(0)] public String UserName;
/// <summary>
/// 密码
/// </summary>
[Key(1)] public string PassWord;
/// <summary>
/// 第三方登录 昵称
/// </summary>
[Key(2)] public string NickName;
/// <summary>
/// 性别
/// </summary>
[Key(3)] public int Sex;
/// <summary>
/// 登录类型 0 账号密码登录 1 微信登录 2 qq登录 3 苹果登录 4华为登录
/// </summary>
[Key(4)] public int LoginType;
// 现在登录的第三方标志
/// <summary>
/// 登录用的第三方标志
/// </summary>
[Key(5)] public string UserOpenId;
// 后续账号转移使用
/// <summary>
/// 微信的用户唯一标志
/// </summary>
[Key(6)] public string WxUnionId;
/// <summary>
/// 第三方头像地址
/// </summary>
[Key(7)] public string PhotoUrl;
/// <summary>
/// 邀请人标记
/// </summary>
[Key(8)] public string Inviter;
/// <summary>
/// 是否取消注销
/// </summary>
[Key(9)] public int CancelLogOut;
/// <summary>
/// 客户端版本
/// </summary>
[Key(10)] public int ClientVer;
/// <summary>
/// 所属平台 0桌面模式 1安卓平台 2苹果平台 3小游戏 4WebGl
/// </summary>
[Key(11)] public int Plat;
/// <summary>
/// 设备唯一标识
/// </summary>
[Key(12)] public string DeviceId;
/// <summary>
/// 验证码
/// </summary>
[Key(13)] public string VerificationCode;
/// <summary>
/// 手机号
/// </summary>
[Key(14)] public string PhoneNumber;
/// <summary>
/// 手机验证码
/// </summary>
[Key(15)] public string PhoneVerifyCode;
/// <summary>
/// 商店或者说是渠道类型
/// </summary>
[Key(16)]
public string StoreType;
/// <summary>
/// 账户校验Token
/// </summary>
[Key(17)]
public string AuthToken;
#if GameClient
public static LoginRequest Create()
{
return new LoginRequest();
}
public override void Clear()
{
Log.Debug("Clear LoginRequest");
UserName = null;
PassWord = null;
NickName = null;
Sex = 0;
LoginType = 0;
UserOpenId = null;
WxUnionId = null;
PhotoUrl = null;
Inviter = null;
CancelLogOut = 0;
ClientVer = 0;
Plat = 0;
DeviceId = null;
VerificationCode = null;
PhoneNumber = null;
PhoneVerifyCode = null;
}
#endif
}
public class LoginUserInfoVer1 : LoginRequest
{
/// <summary>
/// 用户UserId
/// </summary>
public int UserId;
/// <summary>
/// 手机号
/// </summary>
public string Phone;
/// <summary>
/// 登录Token - 手机登录使用
/// </summary>
public string Token;
}
/// <summary>
/// 登录响应包
/// </summary>
[Message(MessageCode.LoginResponse)]
[MessagePackObject]
public class LoginResponse : MessageData
{
/// <summary>
/// 玩家数据
/// </summary>
[Key(0)] public string PlayerData;
/// <summary>
/// 所有服务器配置
/// </summary>
[Key(1)] public string AllServerConfig;
/// <summary>
/// 登录时间
/// </summary>
[Key(2)] public long LoginTime;
/// <summary>
/// 玩家的活动数据
/// </summary>
[Key(3)] public PlayerActivityData ActivityData;
/// <summary>
/// 注销信息
/// </summary>
[Key(4)] public LogOutInfo LogoutInfo;
/// <summary>
/// 处理结果
/// </summary>
[Key(5)] public int ResultCode;
/// <summary>
/// SessionUUID
/// </summary>
[Key(6)] public string SessionUUID;
/// <summary>
/// 是否是新注册
/// </summary>
[Key(7)] public bool IsRegister;
/// <summary>
/// 登录后返回的Token
/// </summary>
[Key(8)] public string LoginToken;
/// <summary>
/// AuthToken校验错误码
/// </summary>
[Key(9)]
public int AuthTokenCode;
}
/// <summary>
/// Userid 登录包
/// </summary>
[Message(MessageCode.UserIdLoginRequest)]
[MessagePackObject]
public class UserIdLoginRequest : MessageData
{
/// <summary>
/// 玩家UserId
/// </summary>
[Key(0)] public int UserId;
/// <summary>
/// Token
/// </summary>
[Key(1)] public string Token;
/// <summary>
/// 客户端版本
/// </summary>
[Key(2)] public int ClientVer;
#if GameClient
public static UserIdLoginRequest Create()
{
return ReferencePool.Acquire<UserIdLoginRequest>();
}
public override void Clear()
{
UserId = 0;
Token = null;
ClientVer = 0;
}
#endif
}
/// <summary>
/// 注销信息
/// </summary>
[MessagePackObject]
public class LogOutInfo
{
/// <summary>
/// UserId
/// </summary>
[Key(0)] public int UserId;
/// <summary>
/// 注销的时间
/// </summary>
[Key(1)] public long LogoutTime;
}
/// <summary>
/// 玩家活动数据
/// </summary>
[MessagePackObject]
public class PlayerActivityData
{
/// <summary>
/// 领取的广告礼包数据
/// </summary>
[Key(0)] public int adGiftCnt;
/// <summary>
/// 上次领取广告礼包时间
/// </summary>
[Key(1)] public long lastadGiftTime;
/// <summary>
/// 领取救济金的次数
/// </summary>
[Key(2)] public int doleCnt;
/// <summary>
/// 上次领取救济金的时间
/// </summary>
[Key(3)] public long lastDoleTime;
}
/// <summary>
/// 请求
/// </summary>
[Message(MessageCode.LoginVerificationRequest)]
[MessagePackObject]
public class LoginVerificationRequest : MessageData
{
}
/// <summary>
/// 响应
/// </summary>
[Message(MessageCode.LoginVerificationResponse)]
[MessagePackObject]
public class LoginVerificationResponse : MessageData
{
/// <summary>
/// 验证码
/// </summary>
[Key(0)] public string VerificationCode;
}
/// <summary>
/// 通过WxCode登录
/// </summary>
[Message(MessageCode.LoginWxCodeRequest)]
[MessagePackObject]
public class LoginWxCodeRequest : MessageData
{
[Key(0)]
public string Code;
#if GameClient
public static LoginWxCodeRequest Create()
{
return GameFramework.ReferencePool.Acquire<LoginWxCodeRequest>();
}
#endif
}
[Message(MessageCode.LoginWxCodeResponse)]
[MessagePackObject]
public class LoginWxCodeResponse : MessageData
{
[Key(0)]
public int ErrCode;
[Key(1)]
public WxLoginUserInfo UserInfo;
}
[MessagePackObject]
public class WxLoginUserInfo
{
[Key(0)]public string OpenId;
[Key(1)]public string Nickname;
[Key(2)]public int Sex;
[Key(3)]public string Language;
[Key(4)]public string City;
[Key(5)]public string Province;
[Key(6)]public string Country;
[Key(7)]public string Headimgurl;
[Key(8)]public string Unionid;
}
[Message(MessageCode.AutoLoginRequest)]
[MessagePackObject]
public class AutoLoginRequest : MessageData
{
/// <summary>
/// 一键登录Token
/// </summary>
[Key(0)]public string Token;
/// <summary>
/// 设备唯一标识码
/// </summary>
[Key(1)] public string DeviceId;
/// <summary>
/// 版本信息
/// </summary>
[Key(2)] public int ClientVer;
/// <summary>
/// 所属平台
/// </summary>
[Key(3)] public int Plat;
/// <summary>
/// 商店类型
/// </summary>
[Key(4)]
public string StoreType;
#if GameClient
public static AutoLoginRequest Create()
{
return GameFramework.ReferencePool.Acquire<AutoLoginRequest>();
}
#endif
}
[Message(MessageCode.AutoLoginResponse)]
[MessagePackObject]
public class AutoLoginResponse : MessageData
{
[Key(0)]public int ResultCode;
}
/// <summary>
/// 登录类型
/// </summary>
public enum LoginType
{
/// <summary>
/// 账号密码
/// </summary>
ACCOUNT = 0,
/// <summary>
/// 微信登录
/// </summary>
WECHAT = 100,
/// <summary>
/// QQ登录
/// </summary>
QQ = 200,
/// <summary>
/// 苹果登录
/// </summary>
APPLE = 300,
/// <summary>
/// 华为登录
/// </summary>
HuaWei = 400,
/// <summary>
/// 手机号登录
/// </summary>
Phone = 500,
/// <summary>
/// 小米登录
/// </summary>
XiaoMi = 600,
/// <summary>
/// Vivo登录
/// </summary>
Vivo = 700,
}
/// <summary>
/// 平台类型
/// </summary>
public enum PlatType
{
/// <summary>
/// 桌面模式
/// </summary>
PC = 0,
/// <summary>
/// 安卓
/// </summary>
Android = 1,
/// <summary>
/// 苹果
/// </summary>
Apple = 2,
/// <summary>
/// 小游戏
/// </summary>
MiniGame = 3,
/// <summary>
/// Web
/// </summary>
WebGL = 4,
}
}

595
NetWorkMessage/Message/MessageData/GameCenter/MallMessage.cs Normal file
View File

@ -0,0 +1,595 @@
using System;
using MessagePack;
#if GameClient
using GameFramework;
#endif
namespace GameMessage
{
/// <summary>
/// 商品请求
/// </summary>
[Message(MessageCode.CommodityRequest)]
[MessagePackObject()]
[Obsolete("版本50以上过时")]
public class CommodityRequest : MessageData
{
/// <summary>
/// 数据版本
/// </summary>
[Key(0)] public long Ver;
/// <summary>
/// 商品类型
/// </summary>
[Key(1)] public int MallType;
/// <summary>
/// 商店类型
/// </summary>
[Key(2)] public int StoreType;
#if GameClient
public static CommodityRequest Create()
{
return ReferencePool.Acquire<CommodityRequest>();
}
public override void Clear()
{
Ver = 0;
MallType = 0;
StoreType = 0;
}
#endif
}
/// <summary>
/// 商品响应
/// </summary>
[Message(MessageCode.CommodityResponse)]
[MessagePackObject()]
[Obsolete("版本50以上过时")]
public class CommodityResponse : MessageData
{
/// <summary>
/// 商品类型
/// </summary>
[Key(0)] public int MallType;
/// <summary>
/// 数据版本
/// </summary>
[Key(1)] public long Ver;
/// <summary>
/// 商品数据
/// </summary>
[Key(2)] public CommodityData[] CommodityDatas;
}
/// <summary>
/// 请求实体商品列表
/// </summary>
[Message(MessageCode.EntityCommodityRequest)]
[MessagePackObject()]
[Obsolete("版本50以上过时")]
public class EntityCommodityRequest : MessageData
{
[Key(0)] public long Ver;
#if GameClient
public static EntityCommodityRequest Create()
{
return ReferencePool.Acquire<EntityCommodityRequest>();
}
public override void Clear()
{
Ver = 0;
}
#endif
}
/// <summary>
/// 请求实体商品响应
/// </summary>
[Message(MessageCode.EntityCommodityResponse)]
[MessagePackObject()]
[Obsolete("版本50以上过时")]
public class EntityCommodityResponse : MessageData
{
/// <summary>
/// 版本
/// </summary>
[Key(0)] public long Ver;
[Key(1)] public EntityCommodityData[] CommodityDatas;
}
/// <summary>
/// 兑换实体商品请求
/// </summary>
[Message(MessageCode.ExChangeEntityCommodityRequest)]
[MessagePackObject()]
[Obsolete("版本50以上过时")]
public class ExChangeEntityCommodityRequest : MessageData
{
/// <summary>
/// 要兑换的实体商品ID
/// </summary>
[Key(0)] public int Id;
#if GameClient
public static ExChangeEntityCommodityRequest Create(int id)
{
ExChangeEntityCommodityRequest request = ReferencePool.Acquire<ExChangeEntityCommodityRequest>();
request.Id = id;
return request;
}
#endif
}
/// <summary>
/// 兑换实体商品响应
/// </summary>
[Message(MessageCode.ExChangeEntityCommodityResponse)]
[MessagePackObject()]
[Obsolete("版本50以上过时")]
public class ExChangeEntityCommodityResponse : MessageData
{
/// <summary>
/// 兑换的实体商品ID
/// </summary>
[Key(0)] public int Id;
/// <summary>
/// 兑换结果
/// </summary>
[Key(1)] public int ResultCode;
}
/// <summary>
/// 兑换实体商品记录请求
/// </summary>
[Message(MessageCode.ExChangeEntityRecordRequest)]
[MessagePackObject()]
[Obsolete("版本50以上过时")]
public class ExChangeEntityRecordRequest : MessageData
{
#if GameClient
public static ExChangeEntityRecordRequest Create()
{
return ReferencePool.Acquire<ExChangeEntityRecordRequest>();
}
#endif
}
/// <summary>
/// 兑换实体商品记录响应
/// </summary>
[Message(MessageCode.ExChangeEntityRecordResponse)]
[MessagePackObject()]
[Obsolete("版本50以上过时")]
public class ExChangeEntityRecordResponse : MessageData
{
[Key(0)] public ExChangeEntityRecord[] Records;
}
/// <summary>
/// 兑换商品请求
/// </summary>
[Message(MessageCode.ExchangeCommodityRequest)]
[MessagePackObject()]
[Obsolete("版本50以上过时")]
public class ExchangeCommodityRequest : MessageData
{
/// <summary>
/// 兑换的商品ID
/// </summary>
[Key(0)] public int Id;
#if GameClient
public static ExchangeCommodityRequest Create(int id)
{
ExchangeCommodityRequest request = ReferencePool.Acquire<ExchangeCommodityRequest>();
request.Id = id;
return request;
}
#endif
}
/// <summary>
/// 兑换商品响应
/// </summary>
[Message(MessageCode.ExchangeCommodityResponse)]
[MessagePackObject()]
[Obsolete("版本50以上过时")]
public class ExchangeCommodityResponse : MessageData
{
/// <summary>
/// 兑换的商品ID
/// </summary>
[Key(0)] public int Id;
/// <summary>
/// 兑换结果
/// </summary>
[Key(1)] public int ResultCode;
}
/// <summary>
/// AppStore 票据核销请求
/// </summary>
[Message(MessageCode.AppStorePayVerifyRequest)]
[MessagePackObject()]
public class AppStorePayVerifyRequest : MessageData
{
/// <summary>
/// 票据字符串
/// </summary>
[Key(0)] public string ReceiptStr;
#if GameClient
public static AppStorePayVerifyRequest Create(string receiptStr)
{
AppStorePayVerifyRequest request = ReferencePool.Acquire<AppStorePayVerifyRequest>();
request.ReceiptStr = receiptStr;
return request;
}
public override void Clear()
{
ReceiptStr = null;
}
#endif
}
/// <summary>
/// AppStore 票据核销响应
/// </summary>
[Message(MessageCode.AppStorePayVerifyResponse)]
[MessagePackObject()]
public class AppStorePayVerifyResponse : MessageData
{
/// <summary>
/// 核销状态
/// </summary>
[Key(0)] public int Statue;
/// <summary>
/// 票据字符串
/// </summary>
[Key(1)] public string ReceiptStr;
[Key(2)] public AppStoreProductBuyData[] Data;
}
[MessagePackObject()]
public class AppStoreProductBuyData
{
/// <summary>
/// 商品Id
/// </summary>
[Key(0)] public string ProductId;
/// <summary>
/// 价格
/// </summary>
[Key(1)] public int Price;
/// <summary>
/// 钻石数量
/// </summary>
[Key(2)] public int DiamondNum;
}
[MessagePackObject()]
public class CommodityData
{
/// <summary>
/// 商品Id
/// </summary>
[Key(0)] public int Id;
/// <summary>
/// 标题
/// </summary>
[Key(1)] public string Title;
/// <summary>
/// 价值
/// </summary>
[Key(2)] public int Cost;
/// <summary>
/// 可获得金币的数量
/// </summary>
[Key(3)] public long CoinNum;
/// <summary>
/// 可获得参赛券的数量
/// </summary>
[Key(4)] public int CanSaiJuanNum;
/// <summary>
/// 获得复活卡的数量
/// </summary>
[Key(5)] public int FuHuoKaNum;
/// <summary>
/// 钻石数量
/// </summary>
[Key(6)] public int DiamondNum;
/// <summary>
/// 可获得VIP天数
/// </summary>
[Key(7)] public int VipDays;
/// <summary>
/// 可获得房卡的数量
/// </summary>
[Key(8)] public int FangKaNum;
/// <summary>
/// 需要支付的钻石数量
/// </summary>
[Key(9)] public int PayDiamond;
/// <summary>
/// 需要支付的礼券数量
/// </summary>
[Key(10)] public int PayLiJuan;
/// <summary>
/// 需要支付的人民币数量
/// </summary>
[Key(11)] public int PayRMB;
/// <summary>
/// 需要支付的红包券数量
/// </summary>
[Key(12)] public int PayHonBaoJuan;
/// <summary>
/// 是否是实物
/// </summary>
[Key(13)] public bool IsEntity;
/// <summary>
/// 商品新Id 对于ProductionConfig
/// </summary>
[Key(14)] public int NewId;
}
public enum MallType
{
/// <summary>
/// 默认 推荐
/// </summary>
Default = 1,
/// <summary>
/// 默认 钻石
/// </summary>
Diamond = 2,
/// <summary>
/// 金币
/// </summary>
Coin = 3,
/// <summary>
/// 道具
/// </summary>
Prop = 4,
/// <summary>
/// 兑换
/// </summary>
Item = 5,
/// <summary>
/// 实物
/// </summary>
Entity = 6,
/// <summary>
/// 房卡
/// </summary>
FangKa = 7
}
public static class MallStoreType
{
/// <summary>
/// 微信小程序
/// </summary>
public const int WXMiniGame = 1;
/// <summary>
/// 应用宝
/// </summary>
public const int YingYongBao = 2;
/// <summary>
/// AppStore
/// </summary>
public const int AppStore = 3;
/// <summary>
/// 默认的
/// </summary>
public const int Default = 4;
/// <summary>
/// 华为
/// </summary>
public const int Huawei = 5;
/// <summary>
/// 公众号
/// </summary>
public const int OfficialAccount = 6;
/// <summary>
/// 小米
/// </summary>
public const int XiaoMi = 7;
/// <summary>
/// Vivo
/// </summary>
public const int Vivo = 8;
}
[MessagePackObject()]
public class EntityCommodityData
{
/// <summary>
/// 商品ID
/// </summary>
[Key(0)] public int Id;
/// <summary>
/// 商品类型 0游戏币 2房卡 3比赛卷 5都市放心购电子卷 20实物 4都市放心购电子卷 小程序使用.........
/// </summary>
[Key(1)] public int Sty;
/// <summary>
/// 单价
/// </summary>
[Key(2)] public int Money;
/// <summary>
/// 商品名称
/// </summary>
[Key(3)] public string Title;
/// <summary>
/// 价值 如果是游戏 内的物体表示的是游戏内物品的数量
/// </summary>
[Key(4)] public int Cost;
/// <summary>
/// 商品描述
/// </summary>
[Key(5)] public string Node;
/// <summary>
/// 商品状态
/// </summary>
[Key(6)] public int State;
/// <summary>
/// 商品图片数量
/// </summary>
[Key(7)] public int ImgCount;
/// <summary>
/// 商品库存
/// </summary>
[Key(8)] public int Quantity;
/// <summary>
/// 商品其他描述 key_keyValue 配套使用
/// </summary>
[Key(9)] public string[] Key;
[Key(10)] public string[] KeyValue;
}
[MessagePackObject()]
public class ExChangeEntityRecord
{
/// <summary>
/// 玩家userid
/// </summary>
[Key(0)] public int UserId;
/// <summary>
/// 商品数量
/// </summary>
[Key(1)] public int MallCount;
/// <summary>
/// 购买时间
/// </summary>
[Key(2)] public string ShipTime;
/// <summary>
/// 收货信息
/// </summary>
[Key(3)] public ShippingAddress Address;
/// <summary>
/// 数量
/// </summary>
[Key(4)] public int Count;
/// <summary>
/// 商品Id
/// </summary>
[Key(5)] public int CommodityId;
/// <summary>
/// 商品名称
/// </summary>
[Key(6)] public string CommodityName;
/// <summary>
/// 商品类型
/// </summary>
[Key(7)] public int Sty;
/// <summary>
/// 商品价值
/// </summary>
[Key(8)] public int Cost;
/// <summary>
/// 商品单价
/// </summary>
[Key(9)] public int Money;
/// <summary>
/// 商品描述
/// </summary>
[Key(10)] public string Desc;
/// <summary>
/// 状态 1表示等待发货 2表示发货中 3表示交易完成
/// </summary>
[Key(11)] public int State;
/// <summary>
/// 邮件单号
/// </summary>
[Key(12)] public string EmlCode;
}
[MessagePackObject()]
public class ShippingAddress
{
/// <summary>
/// 电话
/// </summary>
[Key(0)] public string Phone;
/// <summary>
/// 收货人名字
/// </summary>
[Key(1)] public string Name;
/// <summary>
/// 邮政编码
/// </summary>
[Key(2)] public string Postalcode;
/// <summary>
/// 用户地址
/// </summary>
[Key(3)] public string Address;
}
}

252
NetWorkMessage/Message/MessageData/GameCenter/MallMessageV2.cs Normal file
View File

@ -0,0 +1,252 @@
using System;
using System.Collections.Generic;
using MessagePack;
#if GameClient
using GameFramework;
#else
using Server.Core;
#endif
namespace GameMessage
{
[Message(MessageCode.DiamondMallDataRequest)]
[MessagePackObject]
public class DiamondMallDataRequest : MessageData
{
/// <summary>
/// 数据版本
/// </summary>
[Key(0)] public long Ver;
/// <summary>
/// 商城类型 默认0
/// </summary>
[Key(1)] public int MallType;
/// <summary>
/// App商城类型
/// </summary>
[Key(2)] public int AppStoreType;
#if GameClient
public static DiamondMallDataRequest Create(long ver,int appStoreType)
{
DiamondMallDataRequest self = ReferencePool.Acquire<DiamondMallDataRequest>();
self.Ver = ver;
self.AppStoreType = appStoreType;
return self;
}
public override void Clear()
{
}
#endif
}
[Message(MessageCode.DiamondMallDataResponse)]
[MessagePackObject]
public class DiamondMallDataResponse : MessageData
{
[Key(0)] public long Ver;
[Key(1)] public List<DiamondProduct> Products;
}
/// <summary>
/// 钻石商品 - 需要充值获得
/// </summary>
[MessagePackObject]
public class DiamondProduct
{
/// <summary>
/// 商品id
/// </summary>
[Key(0)] public int Id;
/// <summary>
/// 平台的商品id
/// </summary>
[Key(1)] public string PlatProductId;
/// <summary>
/// 商品名称
/// </summary>
[Key(2)] public string Name;
/// <summary>
/// 商品价格
/// </summary>
[Key(3)] public int Price;
/// <summary>
/// 获得的主体资源
/// </summary>
[Key(4)] public ResData[] Packages;
/// <summary>
/// 赠送的资源
/// </summary>
[Key(5)] public ResData[] Gift;
/// <summary>
/// 描述
/// </summary>
[Key(6)] public string Desc;
}
[Message(MessageCode.ExchangeMallDataRequest)]
[MessagePackObject]
public class ExchangeMallDataRequest : MessageData
{
/// <summary>
/// 数据版本
/// </summary>
[Key(0)] public long Ver;
/// <summary>
/// 商城类型 0全部 1金币 2道具 3活动
/// </summary>
[Key(1)] public int MallType;
/// <summary>
/// App商城类型
/// </summary>
[Key(2)] public int AppStoreType;
#if GameClient
public static ExchangeMallDataRequest Create(long ver, int mallType,int appStoreType)
{
ExchangeMallDataRequest self = ReferencePool.Acquire<ExchangeMallDataRequest>();
self.Ver = ver;
self.MallType = mallType;
self.AppStoreType = appStoreType;
return self;
}
public override void Clear()
{
}
#endif
}
[Message(MessageCode.ExchangeMallDataResponse)]
[MessagePackObject]
public class ExchangeMallDataResponse : MessageData
{
[Key(0)] public long Ver;
[Key(1)] public List<ExchangeProduct> Products;
}
/// <summary>
/// 兑换商品 - 使用物品兑换获得
/// </summary>
[MessagePackObject]
public class ExchangeProduct
{
/// <summary>
/// 商品id
/// </summary>
[Key(0)] public int Id;
/// <summary>
/// 商品名称
/// </summary>
[Key(1)] public string Name;
/// <summary>
/// 商城类型 1金币 2道具 3活动（用于区分商品所属类型）
/// </summary>
[Key(2)] public int MallType;
/// <summary>
/// 需要消耗的物品列表
/// </summary>
[Key(3)] public ResData[] SourceItems;
/// <summary>
/// 兑换获得的物品列表
/// </summary>
[Key(4)] public ResData[] TargetItems;
/// <summary>
/// 描述
/// </summary>
[Key(5)] public string Desc;
}
/// <summary>
/// 兑换商城兑换请求
/// </summary>
[Message(MessageCode.ExchangeMallRequest)]
[MessagePackObject]
public class ExchangeMallRequest : MessageData
{
/// <summary>
/// 兑换商品Id
/// </summary>
[Key(0)] public int ProductId;
/// <summary>
/// 兑换数量
/// </summary>
[Key(1)] public int Count;
#if GameClient
public static ExchangeMallRequest Create(int productId,int count = 1)
{
ExchangeMallRequest self = ReferencePool.Acquire<ExchangeMallRequest>();
self.ProductId = productId;
self.Count = count;
return self;
}
public override void Clear()
{
}
#endif
}
/// <summary>
/// 兑换商城兑换响应
/// </summary>
[Message(MessageCode.ExchangeMallResponse)]
[MessagePackObject]
public class ExchangeMallResponse : MessageData
{
/// <summary>
/// 兑换商品Id
/// </summary>
[Key(0)] public int ProductId;
/// <summary>
/// 兑换数量
/// </summary>
[Key(1)]
public int Count;
/// <summary>
/// 结果码 0成功
/// </summary>
[Key(2)] public int ResultCode;
#if Server
public static ExchangeMallResponse Create(int productId,int count)
{
ExchangeMallResponse self = ReferencePool.Fetch<ExchangeMallResponse>();
self.ProductId = productId;
self.Count = count;
return self;
}
public override void Dispose()
{
ReferencePool.Recycle(this);
}
#endif
}
}

Some files were not shown because too many files have changed in this diff Show More