public override bool readFromBuff(ref NetInputBuffer buff)
        {
            int n = MacroDefine.INVALID_ID;

            if (buff.ReadInt(ref n) != sizeof(int))
            {
                return(false);
            }
            else
            {
                m_nCmdID = (ENUM_SCRIPT_COMMAND)n;
            }

            switch (m_nCmdID)
            {
            case ENUM_SCRIPT_COMMAND.SCRIPT_COMMAND_EVENT_LIST_RESPONSE:
            {
                ScriptParam = TempScriptParam_EventList;
                if (!TempScriptParam_EventList.Read(ref buff))
                {
                    return(false);
                }
                break;
            }

            case ENUM_SCRIPT_COMMAND.SCRIPT_COMMAND_MISSION_RESPONSE:
            {
                ScriptParam = TempScriptParam_MissionInfo;
                if (!TempScriptParam_MissionInfo.Read(ref buff))
                {
                    return(false);
                }
                break;
            }

            case ENUM_SCRIPT_COMMAND.SCRIPT_COMMAND_MISSION_REGIE:
            {
                ScriptParam = TempScriptParam_MissionRegie;
                if (!TempScriptParam_MissionRegie.Read(ref buff))
                {
                    return(false);
                }
                break;
            }

            case ENUM_SCRIPT_COMMAND.SCRIPT_COMMAND_MISSION_DEMAND_RESPONSE:
            {
                ScriptParam = TempScriptParam_MissionDemandInfo;
                if (!TempScriptParam_MissionDemandInfo.Read(ref buff))
                {
                    return(false);
                }
                break;
            }

            case ENUM_SCRIPT_COMMAND.SCRIPT_COMMAND_MISSION_CONTINUE_RESPONSE:
            {
                ScriptParam = TempScriptParam_MissionContinueInfo;
                if (!TempScriptParam_MissionContinueInfo.Read(ref buff))
                {
                    return(false);
                }
                break;
            }

            case ENUM_SCRIPT_COMMAND.SCRIPT_COMMAND_MISSION_TIPS:
            {
                ScriptParam = TempScriptParam_MissionTips;
                if (!TempScriptParam_MissionTips.Read(ref buff))
                {
                    return(false);
                }
                break;
            }

            case ENUM_SCRIPT_COMMAND.SCRIPT_COMMAND_TRADE:
            {
                ScriptParam = TempScriptParam_Trade;
                if (!TempScriptParam_Trade.Read(ref buff))
                {
                    return(false);
                }
                break;
            }

            case ENUM_SCRIPT_COMMAND.SCRIPT_COMMAND_SKILL_STUDY:
            {
                ScriptParam = TempScriptParam_SkillStudy;
                if (!TempScriptParam_SkillStudy.Read(ref buff))
                {
                    return(false);
                }
                break;
            }

            default:
                break;
            }
            return(true);
        }
        public override bool readFromBuff(ref NetInputBuffer buff)
        {
            buff.Read(ref szAccount, sizeof(byte) * NET_DEFINE.MAX_ACCOUNT);

            return(true);
        }
Example #3
0
 public bool readFromBuff(ref NetInputBuffer buff)
 {
     buff.ReadShort(ref m_Value);
     return(true);
 }
Example #4
0
 public override bool readFromBuff(ref NetInputBuffer buff)
 {
     buff.ReadUint(ref m_ObjID);
     return(true);
 }
Example #5
0
 //公用继承接口
 public override bool readFromBuff(ref NetInputBuffer buff)
 {
     m_Relation.readFromBuff(ref buff);
     return(true);
 }
        public override bool readFromBuff(ref NetInputBuffer buff)
        {
            int n = -1;

            // LogManager.Log("Read LCRetCharList");

            if (buff.ReadInt(ref n) != 4)
            {
                return(false);
            }
            result = (NET_RESULT_DEFINE.ASKCHARLIST_RESULT)n;

            if (Result == NET_RESULT_DEFINE.ASKCHARLIST_RESULT.ASKCHARLIST_SUCCESS)
            {
                buff.Read(ref szAccount, sizeof(byte) * NET_DEFINE.MAX_ACCOUNT);
                buff.ReadByte(ref uCharNumber);
                if (uCharNumber > NET_DEFINE.DB_CHAR_NUMBER)
                {
                    uCharNumber = (byte)NET_DEFINE.DB_CHAR_NUMBER;
                }
                if (CharList == null)
                {
                    CharList = new DB_CHAR_BASE_INFO[uCharNumber];
                }

                for (int i = 0; i < uCharNumber; i++)
                {
                    //int size = Marshal.SizeOf(typeof(DB_CHAR_BASE_INFO));
                    //byte[] bytes = new byte[size];
                    //buff.Read(ref bytes, size);
                    //CharList[i] = (DB_CHAR_BASE_INFO)NET_DEFINE.BytesToStruct(bytes, typeof(DB_CHAR_BASE_INFO));


                    CharList[i].readFromBuff(ref buff);

                    //CharList[i] = (DB_CHAR_BASE_INFO)buff.ReadStruct(typeof(DB_CHAR_BASE_INFO) );

                    //LogManager.Log("DBINFO size=" + size);

//                    LogManager.Log(" m_GUID:"+BitConverter.ToString( BitConverter.GetBytes(CharList[i].m_GUID) )
//                              +" ,m_Sex:"+BitConverter.ToString( BitConverter.GetBytes(CharList[i].m_Sex) )
//                              );
//
//					string temp = string.Empty;
//					for(int j=0; j< CharList[i].m_Name.Length ;j++ ){
//
//						temp += BitConverter.ToString( BitConverter.GetBytes( CharList[i].m_Name[j] ) );
//					}
                    //					LogManager.Log(" ,name:"+ temp );
                    //                    LogManager.Log("m_Level:"+BitConverter.ToString( BitConverter.GetBytes( CharList[i].m_Level ) )
                    //					          +",m_Ambit"+BitConverter.ToString( BitConverter.GetBytes( CharList[i].m_Ambit ) )
                    //					          +",m_HairColor"+BitConverter.ToString( BitConverter.GetBytes( CharList[i].m_HairColor ) )
                    //					          +",m_FaceColor"+BitConverter.ToString( BitConverter.GetBytes( CharList[i].m_FaceColor ) )
                    //					          +",m_HairModel"+BitConverter.ToString( BitConverter.GetBytes( CharList[i].m_HairModel ) )
                    //					          +",m_FaceModel"+BitConverter.ToString( BitConverter.GetBytes( CharList[i].m_FaceModel ) )
                    //					          +" ,m_StartScene:"+BitConverter.ToString( BitConverter.GetBytes( CharList[i].m_StartScene ) )
                    //					          +",m_nClientResID"+BitConverter.ToString( BitConverter.GetBytes( CharList[i].m_nClientResID ) )
                    //					          +",m_Menpai"+BitConverter.ToString( BitConverter.GetBytes( CharList[i].m_Menpai ) )
                    //					          +",m_HeadID"+BitConverter.ToString( BitConverter.GetBytes( CharList[i].m_HeadID ) )
                    //                              +" ,m_Camp:"+BitConverter.ToString( BitConverter.GetBytes( CharList[i].m_Camp ) )
                    //					          );
//
                    //LogManager.Log(" m_GUID:" + CharList[i].m_GUID
                    //          + " ,m_Sex:" + CharList[i].m_Sex
                    //          + " ,name:" + Encoding.ASCII.GetString(CharList[i].m_Name)
                    //          );
                    //LogManager.Log("m_Level:" + CharList[i].m_Level
                    //          + ",m_Ambit" + CharList[i].m_Ambit
                    //          + ",m_HairColor" + CharList[i].m_HairColor
                    //          + ",m_FaceColor" + CharList[i].m_FaceColor
                    //          + ",m_HairModel" + CharList[i].m_HairModel
                    //          + ",m_FaceModel" + CharList[i].m_FaceModel
                    //          + " ,m_StartScene:" + CharList[i].m_StartScene
                    //          + ",m_nClientResID" + CharList[i].m_nClientResID
                    //          + ",m_Menpai" + CharList[i].m_Menpai
                    //          + ",m_HeadID" + CharList[i].m_HeadID
                    //          + " ,m_Camp:" + CharList[i].m_Camp
                    //          );
                }
            }

            return(true);
        }
Example #7
0
 public override bool readFromBuff(ref NetInputBuffer buff)
 {
     // 包内容
     m_GUID.readFromBuff(ref buff);
     return(true);
 }
Example #8
0
    // 将byte流转换为包内容
    public bool readFromBuff(ref NetInputBuffer buff)
    {
        if (buff.ReadInt(ref m_GUID) != sizeof(int))
        {
            return(false);
        }
        if (buff.ReadByte(ref m_Sex) != sizeof(byte))
        {
            return(false);
        }
        if (m_Name == null)
        {
            m_Name = new byte[NET_DEFINE.MAX_CHARACTER_NAME];
        }
        if (buff.Read(ref m_Name, NET_DEFINE.MAX_CHARACTER_NAME) != NET_DEFINE.MAX_CHARACTER_NAME)
        {
            return(false);
        }
        //temp code 去除服务器发送的无用字节
        int zeroIndex = -1;

        for (int i = 0; i < NET_DEFINE.MAX_CHARACTER_NAME; ++i)
        {
            if (m_Name[i] == 0)
            {
                zeroIndex = i;
                break;
            }
        }
        for (int i = zeroIndex; i < NET_DEFINE.MAX_CHARACTER_NAME; ++i)
        {
            m_Name[i] = 0;
        }        //end temp code

        if (buff.ReadInt(ref m_Level) != sizeof(int))
        {
            return(false);
        }
        if (buff.ReadByte(ref m_Ambit) != sizeof(byte))
        {
            return(false);
        }
        int n = 0;

        if (buff.ReadInt(ref n) != sizeof(int))
        {
            return(false);
        }
        m_HairColor = (uint)n;
        if (buff.ReadByte(ref m_FaceColor) != sizeof(byte))
        {
            return(false);
        }
        if (buff.ReadByte(ref m_HairModel) != sizeof(byte))
        {
            return(false);
        }
        if (buff.ReadByte(ref m_FaceModel) != sizeof(byte))
        {
            return(false);
        }
        if (buff.ReadShort(ref m_StartScene) != sizeof(short))
        {
            return(false);
        }
        if (buff.ReadShort(ref m_nClientResID) != sizeof(short))
        {
            return(false);
        }
        if (buff.ReadInt(ref m_Menpai) != sizeof(int))
        {
            return(false);
        }
        if (buff.ReadInt(ref m_HeadID) != sizeof(int))
        {
            return(false);
        }
        if (buff.ReadShort(ref m_Camp) != sizeof(short))
        {
            return(false);
        }

        if (m_EquipList == null)
        {
            m_EquipList = new uint[(int)HUMAN_EQUIP.HEQUIP_NUMBER];
        }
        for (int i = 0; i < (int)HUMAN_EQUIP.HEQUIP_NUMBER; i++)
        {
            if (buff.ReadInt(ref n) != sizeof(int))
            {
                return(false);
            }
            m_EquipList[i] = (uint)n;
        }

        return(true);
    }
Example #9
0
 public bool readFromBuff(ref NetInputBuffer buff)
 {
     buff.ReadUint(ref idTable);
     buff.ReadByte(ref byNumber);
     return(true);
 }
Example #10
0
 public bool readFromBuff(ref NetInputBuffer buff)
 {
     m_Attr.readFromBuff(ref buff);
     buff.ReadUint(ref m_nPrice);
     return(true);
 }
Example #11
0
 public bool readFromBuff(ref NetInputBuffer buff)
 {
     buff.ReadShort(ref m_Level);
     buff.ReadShort(ref m_Exp);
     return(true);
 }
Example #12
0
 public bool readFromBuff(ref NetInputBuffer buff)
 {
     buff.ReadUint(ref m_GemType);
     return(true);
 }
Example #13
0
 public bool readFromBuff(ref NetInputBuffer buff)
 {
     buff.ReadByte(ref m_AttrType);
     m_Value.readFromBuff(ref buff);
     return(true);
 }
Example #14
0
    public bool readFromBuff(ref NetInputBuffer buff)
    {
        m_ItemGUID.readFromBuff(ref buff);
        buff.ReadUint(ref m_ItemIndex);
        buff.ReadByte(ref m_RulerID);
        buff.ReadByte(ref m_nsBind);
        buff.Read(ref m_Param, ItemDefine.MAX_ITEM_PARAM * sizeof(int));

        if (GetCreatorVar())
        {
            buff.Read(ref m_Creator, ItemDefine.MAX_ITEM_CREATOR_NAME);
        }
        if ((ITEM_CLASS)ItemClass() == ITEM_CLASS.ICLASS_EQUIP)
        {
            if (m_Equip == null)
            {
                m_Equip = new EQUIP_INFO();
            }
            buff.ReadByte(ref m_Equip.m_CurDurPoint);
            buff.ReadByte(ref m_Equip.m_CurSoulType);
            short damage = 0;
            buff.ReadShort(ref damage);
            m_Equip.m_CurDamagePoint = (ushort)damage;
            buff.ReadByte(ref m_Equip.m_MaxDurPoint);
            buff.ReadUint(ref m_Equip.m_BasePrice);
            buff.ReadByte(ref m_Equip.m_EquipPoint);
            buff.ReadByte(ref m_Equip.m_AttrCount);
            buff.ReadShort(ref m_Equip.m_SetNum);
            buff.ReadByte(ref m_Equip.m_MaxNum);
            if (m_Equip.m_AttrCount > GAMEDEFINE.MAX_ITEM_ATTR)
            {
                m_Equip.m_AttrCount = GAMEDEFINE.MAX_ITEM_ATTR;
            }

            for (int j = 0; j < m_Equip.m_AttrCount; j++)
            {
                m_Equip.m_pAttr[j].readFromBuff(ref buff);
            }
            buff.ReadByte(ref m_Equip.m_StoneCount);
            if (m_Equip.m_StoneCount > GAMEDEFINE.MAX_ITEM_GEM)
            {
                m_Equip.m_StoneCount = GAMEDEFINE.MAX_ITEM_GEM;
            }


            //镶嵌系统修改,必须接收MAX_ITEM_GEM个 [2011-9-28] by: cfp+
            for (int j = 0; j < GAMEDEFINE.MAX_ITEM_GEM; j++)
            {
                m_Equip.m_pGemInfo[j].readFromBuff(ref buff);
            }

            buff.ReadByte(ref m_Equip.m_NeedLevel);
            buff.ReadByte(ref m_Equip.m_GemMax);
            buff.ReadByte(ref m_Equip.m_nDangCi);
            buff.ReadInt(ref m_Equip.m_nNextDangCiItemSN);
            buff.ReadByte(ref m_Equip.m_FaileTimes);
            buff.ReadByte(ref m_Equip.m_EquipEnhanceLevel);
        }
        else if ((ITEM_CLASS)ItemClass() == ITEM_CLASS.ICLASS_GEM)
        {
            if (m_Gem == null)
            {
                m_Gem = new GEM_INFO();
            }
            m_Gem.readFromBuff(ref buff);
        }
        else if ((ITEM_CLASS)ItemClass() == ITEM_CLASS.ICLASS_COMITEM)
        {
            if (m_Medic == null)
            {
                m_Medic = new MEDIC_INFO();
            }
            m_Medic.readFromBuff(ref buff);
        }
        else if ((ITEM_CLASS)ItemClass() == ITEM_CLASS.ICLASS_MATERIAL)
        {
            if (m_Medic == null)
            {
                m_Medic = new MEDIC_INFO();
            }
            m_Medic.readFromBuff(ref buff);
        }
        else if ((ITEM_CLASS)ItemClass() == ITEM_CLASS.ICLASS_TASKITEM)
        {
            if (m_Medic == null)
            {
                m_Medic = new MEDIC_INFO();
            }
            m_Medic.readFromBuff(ref buff);
        }
        else if ((ITEM_CLASS)ItemClass() == ITEM_CLASS.ICLASS_STOREMAP)
        {
            //iStream.Read((CHAR*)(GetStoreMapData()),sizeof(STORE_MAP_INFO));
        }
        else if ((ITEM_CLASS)ItemClass() == ITEM_CLASS.ICLASS_TALISMAN)
        {
            if (m_Talisman == null)
            {
                m_Talisman = new TALISMAN_INFO();
            }
            m_Talisman.readFromBuff(ref buff);
        }
        else if ((ITEM_CLASS)ItemClass() == ITEM_CLASS.ICLASS_SYMBOLITEM)
        {
            if (m_Charm == null)
            {
                m_Charm = new CHARM_INFO();
            }
            m_Charm.readFromBuff(ref buff);
        }
        return(true);
    }
 //公用继承接口
 public override bool readFromBuff(ref NetInputBuffer buff)
 {
     return(m_UplevelInfo.readFromBuff(ref buff));
 }
Example #16
0
        public override bool readFromBuff(ref NetInputBuffer buff)
        {
            buff.ReadByte(ref m_IsSellOk);

            return(true);
        }
Example #17
0
        //公用继承接口
        public override bool readFromBuff(ref NetInputBuffer buff)
        {
            if (buff.ReadInt(ref m_ObjID) != sizeof(int))
            {
                return(false);
            }
            int n = 0;

            if (buff.ReadInt(ref n) != sizeof(int))
            {
                return(false);
            }
            m_uFlags = (uint)n;


            if ((m_uFlags & (1 << (int)ENUM_UPDATE_CHAR_ATT.UPDATE_CHAR_ATT_DATA_ID)) != 0)
            {
                if (buff.ReadShort(ref m_wDataID) != sizeof(short))
                {
                    return(false);
                }
            }

            if ((m_uFlags & (1 << (int)ENUM_UPDATE_CHAR_ATT.UPDATE_CHAR_ATT_NAME)) != 0)
            {
                if (buff.ReadByte(ref m_byNameSize) != sizeof(byte))
                {
                    return(false);
                }
                if (buff.Read(ref m_szName, sizeof(byte) * m_byNameSize) != m_byNameSize)
                {
                    return(false);
                }
                m_szName[m_byNameSize] = 0;
            }

            if ((m_uFlags & (1 << (int)ENUM_UPDATE_CHAR_ATT.UPDATE_CHAR_ATT_TITLE)) != 0)
            {
                if (buff.ReadByte(ref m_TitleType) != sizeof(byte))
                {
                    return(false);
                }
                if (buff.ReadByte(ref m_byTitleSize) != sizeof(byte))
                {
                    return(false);
                }
                if (buff.Read(ref m_szTitle, m_byTitleSize) != m_byTitleSize)
                {
                    return(false);
                }
                m_szTitle[m_byTitleSize] = 0;
            }

            if ((m_uFlags & (1 << (int)ENUM_UPDATE_CHAR_ATT.UPDATE_CHAR_ATT_LEVEL)) != 0)
            {
                if (buff.ReadByte(ref m_Level) != sizeof(byte))
                {
                    return(false);
                }
            }

            if ((m_uFlags & (1 << (int)ENUM_UPDATE_CHAR_ATT.UPDATE_CHAR_ATT_HP_PERCENT)) != 0)
            {
                if (buff.ReadByte(ref m_HPPercent) != sizeof(byte))
                {
                    return(false);
                }
            }

            if ((m_uFlags & (1 << (int)ENUM_UPDATE_CHAR_ATT.UPDATE_CHAR_ATT_MP_PERCENT)) != 0)
            {
                if (buff.ReadByte(ref m_MPPercent) != sizeof(byte))
                {
                    return(false);
                }
            }

            if ((m_uFlags & (1 << (int)ENUM_UPDATE_CHAR_ATT.UPDATE_CHAR_ATT_RAGE)) != 0)
            {
                if (buff.ReadInt(ref m_nRage) != sizeof(int))
                {
                    return(false);
                }
            }

            if ((m_uFlags & (1 << (int)ENUM_UPDATE_CHAR_ATT.UPDATE_CHAR_ATT_STEALTH_LEVEL)) != 0)
            {
                if (buff.ReadInt(ref m_nStealthLevel) != sizeof(int))
                {
                    return(false);
                }
            }

            if ((m_uFlags & (1 << (int)ENUM_UPDATE_CHAR_ATT.UPDATE_CHAR_ATT_SIT)) != 0)
            {
                if (buff.ReadByte(ref m_cMoodState) != sizeof(byte))
                {
                    return(false);
                }
            }

            if ((m_uFlags & (1 << (int)ENUM_UPDATE_CHAR_ATT.UPDATE_CHAR_ATT_MOVE_SPEED)) != 0)
            {
                buff.ReadFloat(ref m_fMoveSpeed);
            }

            if ((m_uFlags & (1 << (int)ENUM_UPDATE_CHAR_ATT.UPDATE_CHAR_ATT_ATTACK_SPEED)) != 0)
            {
                buff.ReadFloat(ref m_fAttackSpeed);
            }

            if ((m_uFlags & (1 << (int)ENUM_UPDATE_CHAR_ATT.UPDATE_CHAR_ATT_CAMP_ID)) != 0)
            {
//                 int size = Marshal.SizeOf(m_CampData);
//                 byte[] bytes = new byte[size];
//                 if (buff.Read(ref bytes, size) != size) return false;
//                 m_CampData = (_CAMP_DATA)NET_DEFINE.BytesToStruct(bytes, typeof(_CAMP_DATA));
//                 LogManager.Log("CharBase: obj=" + m_ObjID + " Flag=" + m_uFlags + " size=" + size);

                //object camp = buff.ReadStruct(typeof(_CAMP_DATA));
                //if (camp == null) return false;
                //m_CampData = (_CAMP_DATA)camp;
                m_CampData.readFromBuff(ref buff);
            }



            if ((m_uFlags & (1 << (int)ENUM_UPDATE_CHAR_ATT.UPDATE_CHAR_ATT_PORTRAIT_ID)) != 0)
            {
                if (buff.ReadInt(ref m_nPortraitID) != sizeof(int))
                {
                    return(false);
                }
            }


            if ((m_uFlags & (1 << (int)ENUM_UPDATE_CHAR_ATT.UPDATE_CHAR_ATT_MODEL_ID)) != 0)
            {
                if (buff.ReadInt(ref m_nModelID) != sizeof(int))
                {
                    return(false);
                }
            }

            if ((m_uFlags & (1 << (int)ENUM_UPDATE_CHAR_ATT.UPDATE_CHAR_ATT_MOUNT_ID)) != 0)
            {
                if (buff.ReadInt(ref m_nMountID) != sizeof(int))
                {
                    return(false);
                }
            }

            if ((m_uFlags & (1 << (int)ENUM_UPDATE_CHAR_ATT.UPDATE_CHAR_ATT_AITYPE)) != 0)
            {
                if (buff.ReadInt(ref m_nAIType) != sizeof(int))
                {
                    return(false);
                }
            }

            if ((m_uFlags & (1 << (int)ENUM_UPDATE_CHAR_ATT.UPDATE_CHAR_ATT_PLAYER_DATA)) != 0)
            {
                if (buff.ReadInt(ref m_uPlayerData) != sizeof(int))
                {
                    return(false);
                }
                if (buff.ReadUint(ref m_HairColor) != sizeof(int))
                {
                    return(false);
                }
            }

            if ((m_uFlags & (1 << (int)ENUM_UPDATE_CHAR_ATT.UPDATE_CHAR_IS_IN_STALL)) != 0)
            {
                if (buff.ReadByte(ref m_bStallIsOpen) != sizeof(byte))
                {
                    return(false);
                }
            }

            if ((m_uFlags & (1 << (int)ENUM_UPDATE_CHAR_ATT.UPDATE_CHAR_STALL_NAME)) != 0)
            {
                if (buff.ReadByte(ref m_nStallNameSize) != sizeof(byte))
                {
                    return(false);
                }
                //Assert(m_nStallNameSize < MAX_STALL_NAME);
                if (buff.Read(ref m_szStallName, m_nStallNameSize) != m_nStallNameSize)
                {
                    return(false);
                }
                m_szStallName[m_nStallNameSize] = 0;
            }

            if ((m_uFlags & (1 << (int)ENUM_UPDATE_CHAR_ATT.UPDATE_CHAR_OCCUPANT)) != 0)
            {
                if (buff.ReadInt(ref m_OccupantGUID) != sizeof(int))
                {
                    return(false);
                }
            }

            if ((m_uFlags & (1 << (int)ENUM_UPDATE_CHAR_ATT.UPDATE_CHAR_OWNER)) != 0)
            {
                if (buff.ReadInt(ref m_OwnerID) != sizeof(int))
                {
                    return(false);
                }
            }

            if ((m_uFlags & (1 << (int)ENUM_UPDATE_CHAR_ATT.UPDATE_CHAR_ISNPC)) != 0)
            {
                if (buff.ReadByte(ref m_IsNPC) != sizeof(byte))
                {
                    return(false);
                }
            }

            return(true);
        }
Example #18
0
 public bool readFromBuff(ref NetInputBuffer buff)
 {
     buff.ReadShort(ref m_GuildGUID);
     buff.ReadByte(ref m_Type);
     return(true);
 }
Example #19
0
 public override bool readFromBuff(ref NetInputBuffer buff)
 {
     buff.ReadInt(ref m_nResult);
     return(true);
 }
Example #20
0
 public bool readFromBuff(ref NetInputBuffer buff)
 {
     buff.ReadUint(ref m_GuildUserGUID);
     return(true);
 }
        public override bool readFromBuff(ref NetInputBuffer buff)
        {
            m_StudeResult.readFromBuff(ref buff);

            return(true);
        }
Example #22
0
 public bool readFromBuff(ref NetInputBuffer buff)
 {
     buff.ReadUint(ref m_MoneyAmount);
     return(true);
 }
Example #23
0
 public override bool readFromBuff(ref NetInputBuffer buff)
 {
     buff.ReadUint(ref m_Prescription);
     buff.ReadInt(ref m_LearnOrAbandon);
     return(true);
 }
Example #24
0
        public override bool readFromBuff(ref NetInputBuffer buff)
        {
            m_GUID.readFromBuff(ref buff);
            buff.ReadInt(ref m_nTradeIndex);
            buff.ReadUint(ref m_uLowFlags);
            buff.ReadUint(ref m_uHighFlags);

            if (IsSetBit(ENUM_PET_DETAIL_ATTR.PET_DETAIL_ATTR_OBJ_ID))
            {
                buff.ReadUint(ref m_ObjID);
            }
            if (IsSetBit(ENUM_PET_DETAIL_ATTR.PET_DETAIL_ATTR_DATA_ID))
            {
                buff.ReadInt(ref m_nDataID);
            }
            if (IsSetBit(ENUM_PET_DETAIL_ATTR.PET_DETAIL_ATTR_NAME))
            {
                buff.ReadByte(ref m_byNameSize);
                buff.Read(ref m_szName, m_byNameSize);
            }
            if (IsSetBit(ENUM_PET_DETAIL_ATTR.PET_DETAIL_ATTR_AI_TYPE))
            {
                buff.ReadInt(ref m_nAIType);
            }
            if (IsSetBit(ENUM_PET_DETAIL_ATTR.PET_DETAIL_ATTR_SPOUSE_GUID))
            {
                m_SpouseGUID.readFromBuff(ref buff);
            }
            if (IsSetBit(ENUM_PET_DETAIL_ATTR.PET_DETAIL_ATTR_LEVEL))
            {
                buff.ReadInt(ref m_nLevel);
            }
            if (IsSetBit(ENUM_PET_DETAIL_ATTR.PET_DETAIL_ATTR_EXP))
            {
                buff.ReadInt(ref m_nExp);
            }
            if (IsSetBit(ENUM_PET_DETAIL_ATTR.PET_DETAIL_ATTR_HP))
            {
                buff.ReadInt(ref m_nHP);
            }
            if (IsSetBit(ENUM_PET_DETAIL_ATTR.PET_DETAIL_ATTR_HPMAX))
            {
                buff.ReadInt(ref m_nHPMax);
            }

            if (IsSetBit(ENUM_PET_DETAIL_ATTR.PET_DETAIL_ATTR_LIFE))
            {
                buff.ReadInt(ref m_nLife);
            }
            if (IsSetBit(ENUM_PET_DETAIL_ATTR.PET_DETAIL_ATTR_GENERATION))
            {
                buff.ReadByte(ref m_byGeneration);
            }
            if (IsSetBit(ENUM_PET_DETAIL_ATTR.PET_DETAIL_ATTR_HAPPINESS))
            {
                buff.ReadByte(ref m_byHappiness);
            }

            if (IsSetBit(ENUM_PET_DETAIL_ATTR.PET_DETAIL_ATTR_ATT_PHYSICS))
            {
                buff.ReadInt(ref m_nAtt_Physics);
            }
            if (IsSetBit(ENUM_PET_DETAIL_ATTR.PET_DETAIL_ATTR_ATT_MAGIC))
            {
                buff.ReadInt(ref m_nAtt_Magic);
            }
            if (IsSetBit(ENUM_PET_DETAIL_ATTR.PET_DETAIL_ATTR_DEF_PHYSICS))
            {
                buff.ReadInt(ref m_nDef_Physics);
            }
            if (IsSetBit(ENUM_PET_DETAIL_ATTR.PET_DETAIL_ATTR_DEF_MAGIC))
            {
                buff.ReadInt(ref m_nDef_Magic);
            }

            if (IsSetBit(ENUM_PET_DETAIL_ATTR.PET_DETAIL_ATTR_HIT))
            {
                buff.ReadInt(ref m_nHit);
            }
            if (IsSetBit(ENUM_PET_DETAIL_ATTR.PET_DETAIL_ATTR_MISS))
            {
                buff.ReadInt(ref m_nMiss);
            }
            if (IsSetBit(ENUM_PET_DETAIL_ATTR.PET_DETAIL_ATTR_CRITICAL))
            {
                buff.ReadInt(ref m_nCritical);
            }
            if (IsSetBit(ENUM_PET_DETAIL_ATTR.PET_DETAIL_ATTR_DEF_CRITICAL))
            {
                buff.ReadInt(ref m_nDefCritical);
            }

            if (IsSetBit(ENUM_PET_DETAIL_ATTR.PET_DETAIL_ATTR_MODELID))
            {
                buff.ReadInt(ref m_nModelID);
            }
            if (IsSetBit(ENUM_PET_DETAIL_ATTR.PET_DETAIL_ATTR_MOUNTID))
            {
                buff.ReadInt(ref m_nMountID);
            }

            if (IsSetBit(ENUM_PET_DETAIL_ATTR.PET_DETAIL_ATTR_STRPERCEPTION))
            {
                buff.ReadInt(ref m_StrPerception);
            }
            if (IsSetBit(ENUM_PET_DETAIL_ATTR.PET_DETAIL_ATTR_CONPERCEPTION))
            {
                buff.ReadInt(ref m_ConPerception);
            }
            if (IsSetBit(ENUM_PET_DETAIL_ATTR.PET_DETAIL_ATTR_DEXPERCEPTION))
            {
                buff.ReadInt(ref m_DexPerception);
            }
            if (IsSetBit(ENUM_PET_DETAIL_ATTR.PET_DETAIL_ATTR_SPRPERCEPTION))
            {
                buff.ReadInt(ref m_SprPerception);
            }
            if (IsSetBit(ENUM_PET_DETAIL_ATTR.PET_DETAIL_ATTR_INTPERCEPTION))
            {
                buff.ReadInt(ref m_IntPerception);
            }

            if (IsSetBit(ENUM_PET_DETAIL_ATTR.PET_DETAIL_ATTR_STR))
            {
                buff.ReadInt(ref m_Str);
            }
            if (IsSetBit(ENUM_PET_DETAIL_ATTR.PET_DETAIL_ATTR_CON))
            {
                buff.ReadInt(ref m_Con);
            }
            if (IsSetBit(ENUM_PET_DETAIL_ATTR.PET_DETAIL_ATTR_DEX))
            {
                buff.ReadInt(ref m_Dex);
            }
            if (IsSetBit(ENUM_PET_DETAIL_ATTR.PET_DETAIL_ATTR_SPR))
            {
                buff.ReadInt(ref m_Spr);
            }
            if (IsSetBit(ENUM_PET_DETAIL_ATTR.PET_DETAIL_ATTR_INT))
            {
                buff.ReadInt(ref m_Int);
            }
            if (IsSetBit(ENUM_PET_DETAIL_ATTR.PET_DETAIL_ATTR_GENGU))
            {
                buff.ReadInt(ref m_GenGu);
            }

            if (IsSetBit(ENUM_PET_DETAIL_ATTR.PET_DETAIL_ATTR_RANDOM_STR))
            {
                buff.ReadInt(ref m_StrBring);                                                   // 力量
            }
            if (IsSetBit(ENUM_PET_DETAIL_ATTR.PET_DETAIL_ATTR_RANDOM_CON))
            {
                buff.ReadInt(ref m_ConBring);                                                   // 体力
            }
            if (IsSetBit(ENUM_PET_DETAIL_ATTR.PET_DETAIL_ATTR_RANDOM_DEX))
            {
                buff.ReadInt(ref m_DexBring);                                                   // 身法
            }
            if (IsSetBit(ENUM_PET_DETAIL_ATTR.PET_DETAIL_ATTR_RANDOM_SPR))
            {
                buff.ReadInt(ref m_SprBring);                                                   // 灵气
            }
            if (IsSetBit(ENUM_PET_DETAIL_ATTR.PET_DETAIL_ATTR_RANDOM_INT))
            {
                buff.ReadInt(ref m_IntBring);                                                   // 定力
            }
            if (IsSetBit(ENUM_PET_DETAIL_ATTR.PET_DETAIL_ATTR_POINT_REMAIN))
            {
                buff.ReadInt(ref m_nRemainPoint);
            }

            if (IsSetBit(ENUM_PET_DETAIL_ATTR.PET_DETAIL_ATTR_SKILL_0))
            {
                m_aSkill[0].readFromBuff(ref buff);
            }


            if (IsSetBit(ENUM_PET_DETAIL_ATTR.PET_DETAIL_ATTR_SKILL_1))
            {
                m_aSkill[1].readFromBuff(ref buff);
            }

            if (IsSetBit(ENUM_PET_DETAIL_ATTR.PET_DETAIL_ATTR_SKILL_2))
            {
                m_aSkill[2].readFromBuff(ref buff);
            }

            if (IsSetBit(ENUM_PET_DETAIL_ATTR.PET_DETAIL_ATTR_SKILL_3))
            {
                m_aSkill[3].readFromBuff(ref buff);
            }

            if (IsSetBit(ENUM_PET_DETAIL_ATTR.PET_DETAIL_ATTR_SKILL_4))
            {
                m_aSkill[4].readFromBuff(ref buff);
            }

            if (IsSetBit(ENUM_PET_DETAIL_ATTR.PET_DETAIL_ATTR_SKILL_5))
            {
                m_aSkill[5].readFromBuff(ref buff);
            }

            buff.ReadByte(ref m_ExtraInfoLength);
            buff.Read(ref m_ExtraInfoData, m_ExtraInfoLength);
            return(true);
        }
Example #25
0
 public override bool readFromBuff(ref NetInputBuffer buff)
 {
     throw new NotImplementedException();
 }
Example #26
0
        public override bool readFromBuff(ref NetInputBuffer buff)
        {
            buff.ReadUint(ref m_GUID);
            buff.ReadInt(ref m_Flags);
            if (IsUpdateAttrib((int)ENUM_TEAM_MEMBER_ATT.TEAM_MEMBER_ATT_FAMILY))
            {
                buff.ReadUint(ref m_uFamily);
            }

            if (IsUpdateAttrib((int)ENUM_TEAM_MEMBER_ATT.TEAM_MEMBER_ATT_LEVEL))
            {
                buff.ReadUint(ref m_uLevel);
            }

            if (IsUpdateAttrib((int)ENUM_TEAM_MEMBER_ATT.TEAM_MEMBER_ATT_POSITION))
            {
                m_WorldPos.readFromBuff(ref buff);
            }

            if (IsUpdateAttrib((int)ENUM_TEAM_MEMBER_ATT.TEAM_MEMBER_ATT_HP))
            {
                buff.ReadInt(ref m_nHP);
            }

            if (IsUpdateAttrib((int)ENUM_TEAM_MEMBER_ATT.TEAM_MEMBER_ATT_MAX_HP))
            {
                buff.ReadUint(ref m_uMaxHP);
            }

            if (IsUpdateAttrib((int)ENUM_TEAM_MEMBER_ATT.TEAM_MEMBER_ATT_MP))
            {
                buff.ReadInt(ref m_nMP);
            }

            if (IsUpdateAttrib((int)ENUM_TEAM_MEMBER_ATT.TEAM_MEMBER_ATT_MAX_MP))
            {
                buff.ReadUint(ref m_uMaxMP);
            }

            if (IsUpdateAttrib((int)ENUM_TEAM_MEMBER_ATT.TEAM_MEMBER_ATT_ANGER))
            {
                buff.ReadInt(ref m_nAnger);
            }

            if (IsUpdateAttrib((int)ENUM_TEAM_MEMBER_ATT.TEAM_MEMBER_ATT_WEAPON))
            {
                buff.ReadUint(ref m_WeaponID);
            }

            if (IsUpdateAttrib((int)ENUM_TEAM_MEMBER_ATT.TEAM_MEMBER_ATT_CAP))
            {
                buff.ReadUint(ref m_CapID);
            }

            if (IsUpdateAttrib((int)ENUM_TEAM_MEMBER_ATT.TEAM_MEMBER_ATT_ARMOR))
            {
                buff.ReadUint(ref m_ArmourID);
            }

            if (IsUpdateAttrib((int)ENUM_TEAM_MEMBER_ATT.TEAM_MEMBER_ATT_CUFF))
            {
                buff.ReadUint(ref m_CuffID);
            }

            if (IsUpdateAttrib((int)ENUM_TEAM_MEMBER_ATT.TEAM_MEMBER_ATT_BOOT))
            {
                buff.ReadUint(ref m_FootID);
            }


            /*
             *  if( IsUpdateAttrib(TEAM_MEMBER_ATT_BUFF) )
             *  {
             *  }
             */

            if (IsUpdateAttrib((int)ENUM_TEAM_MEMBER_ATT.TEAM_MEMBER_ATT_DEADLINK))
            {
                buff.ReadByte(ref m_DeadLinkFlag);
            }

            if (IsUpdateAttrib((int)ENUM_TEAM_MEMBER_ATT.TEAM_MEMBER_ATT_DEAD))
            {
                buff.ReadByte(ref m_DeadFlag);
            }

            if (IsUpdateAttrib((int)ENUM_TEAM_MEMBER_ATT.TEAM_MEMBER_ATT_FACEMESH))
            {
                buff.ReadUint(ref m_uFaceMeshID);
            }

            if (IsUpdateAttrib((int)ENUM_TEAM_MEMBER_ATT.TEAM_MEMBER_ATT_HAIRMESH))
            {
                buff.ReadUint(ref m_uHairMeshID);
            }

            if (IsUpdateAttrib((int)ENUM_TEAM_MEMBER_ATT.TEAM_MEMBER_ATT_HAIRCOLOR))
            {
                buff.ReadUint(ref m_uHairColor);
            }

            // 增加背饰 [12/14/2010 ivan edit]
            if (IsUpdateAttrib((int)ENUM_TEAM_MEMBER_ATT.TEAM_MEMBER_ATT_BACK))
            {
                buff.ReadUint(ref m_BackID);
            }

            return(true);
        }
 //公用继承接口
 public override bool readFromBuff(ref NetInputBuffer buff)
 {
     return(true);
 }
Example #28
0
    public bool readFromBuff(ref NetInputBuffer buff)
    {
        m_szName = new byte[GAMEDEFINE.MAX_CHARACTER_NAME];
        m_aSkill = new _OWN_SKILL[GAMEDEFINE.MAX_PET_SKILL_COUNT];
        if (!m_GUID.readFromBuff(ref buff))
        {
            return(false);
        }
        if (buff.ReadInt(ref m_ObjID) != sizeof(int))
        {
            return(false);
        }
        if (buff.ReadInt(ref m_nDataID) != sizeof(int))
        {
            return(false);
        }
        if (buff.Read(ref m_szName, GAMEDEFINE.MAX_CHARACTER_NAME) != GAMEDEFINE.MAX_CHARACTER_NAME)
        {
            return(false);
        }
        if (buff.ReadInt(ref m_nAIType) != sizeof(int))
        {
            return(false);
        }
        if (!m_SpouseGUID.readFromBuff(ref buff))
        {
            return(false);
        }
        if (buff.ReadInt(ref m_nLevel) != sizeof(int))
        {
            return(false);                                                                              // 等级
        }
        if (buff.ReadInt(ref m_nExp) != sizeof(int))
        {
            return(false);                                                                                              // 经验
        }
        if (buff.ReadInt(ref m_nHP) != sizeof(int))
        {
            return(false);                                                                                              // 血当前值
        }
        if (buff.ReadInt(ref m_nHPMax) != sizeof(int))
        {
            return(false);
        }
        if (buff.ReadInt(ref m_nLife) != sizeof(int))
        {
            return(false);
        }
        if (buff.ReadByte(ref m_byGeneration) != sizeof(byte))
        {
            return(false);
        }
        if (buff.ReadByte(ref m_byHappiness) != sizeof(byte))
        {
            return(false);
        }
        if (buff.ReadInt(ref m_nAtt_Physics) != sizeof(int))
        {
            return(false);
        }
        if (buff.ReadInt(ref m_nAtt_Magic) != sizeof(int))
        {
            return(false);
        }
        if (buff.ReadInt(ref m_nDef_Physics) != sizeof(int))
        {
            return(false);
        }
        if (buff.ReadInt(ref m_nDef_Magic) != sizeof(int))
        {
            return(false);
        }

        if (buff.ReadInt(ref m_nHit) != sizeof(int))
        {
            return(false);
        }
        if (buff.ReadInt(ref m_nMiss) != sizeof(int))
        {
            return(false);
        }
        if (buff.ReadInt(ref m_nCritical) != sizeof(int))
        {
            return(false);
        }

        if (buff.ReadInt(ref m_nModelID) != sizeof(int))
        {
            return(false);
        }
        if (buff.ReadInt(ref m_nMountID) != sizeof(int))
        {
            return(false);
        }

        if (buff.ReadInt(ref m_StrPerception) != sizeof(int))
        {
            return(false);
        }
        if (buff.ReadInt(ref m_ConPerception) != sizeof(int))
        {
            return(false);
        }
        if (buff.ReadInt(ref m_DexPerception) != sizeof(int))
        {
            return(false);
        }
        if (buff.ReadInt(ref m_SprPerception) != sizeof(int))
        {
            return(false);
        }
        if (buff.ReadInt(ref m_IntPerception) != sizeof(int))
        {
            return(false);
        }

        if (buff.ReadInt(ref m_Str) != sizeof(int))
        {
            return(false);
        }
        if (buff.ReadInt(ref m_Con) != sizeof(int))
        {
            return(false);
        }
        if (buff.ReadInt(ref m_Dex) != sizeof(int))
        {
            return(false);
        }
        if (buff.ReadInt(ref m_Spr) != sizeof(int))
        {
            return(false);
        }
        if (buff.ReadInt(ref m_Int) != sizeof(int))
        {
            return(false);
        }
        if (buff.ReadInt(ref m_GenGu) != sizeof(int))
        {
            return(false);
        }
        if (buff.ReadInt(ref m_nRemainPoint) != sizeof(int))
        {
            return(false);
        }
        for (int i = 0; i < GAMEDEFINE.MAX_PET_SKILL_COUNT; i++)
        {
            if (!m_aSkill[i].readFromBuff(ref buff))
            {
                return(false);
            }
        }
        return(true);
    }