Пример #1
0
        public override void onRemoteMethodCall(UInt16 methodUtype, MemoryStream stream)
        {
            ScriptModule sm = EntityDef.moduledefs["Operation"];

            Method method = sm.idmethods[methodUtype];

            switch (method.methodUtype)
            {
            case 16:
                UInt64 onCreateSpaceResult_arg1 = stream.readUint64();
                onCreateSpaceResult(onCreateSpaceResult_arg1);
                break;

            case 18:
                Int32  onLoginOutSpaceResult_arg1 = stream.readInt32();
                UInt64 onLoginOutSpaceResult_arg2 = stream.readUint64();
                onLoginOutSpaceResult(onLoginOutSpaceResult_arg1, onLoginOutSpaceResult_arg2);
                break;

            case 17:
                UInt64 onLoginSpaceResult_arg1 = stream.readUint64();
                onLoginSpaceResult(onLoginSpaceResult_arg1);
                break;

            case 15:
                SPACE_LIST onReqSpaceList_arg1 = ((DATATYPE_SPACE_LIST)method.args[0]).createFromStreamEx(stream);
                onReqSpaceList(onReqSpaceList_arg1);
                break;

            default:
                break;
            }
            ;
        }
Пример #2
0
        public SYNCHRODATA createFromStreamEx(MemoryStream stream)
        {
            SYNCHRODATA datas = new SYNCHRODATA();

            datas.senderID = stream.readUint64();
            datas.recverID = stream.readUint64();
            return(datas);
        }
Пример #3
0
        public MAILDATA createFromStreamEx(MemoryStream stream)
        {
            MAILDATA datas = new MAILDATA();

            datas.senderID   = stream.readUint64();
            datas.senderName = stream.readUnicode();
            datas.recverID   = stream.readUint64();
            return(datas);
        }
Пример #4
0
        public CHESS_INFO createFromStreamEx(MemoryStream stream)
        {
            CHESS_INFO datas = new CHESS_INFO();

            datas.id    = stream.readUint64();
            datas.name  = stream.readUnicode();
            datas.level = stream.readUint64();
            return(datas);
        }
Пример #5
0
        public MAIL createFromStreamEx(MemoryStream stream)
        {
            MAIL datas = new MAIL();

            datas.senderDBID = stream.readUint64();
            datas.senderName = stream.readUnicode();
            datas.targetDBID = stream.readUint64();
            datas.targetName = stream.readUnicode();
            datas.lookOver   = stream.readUint8();
            datas.mailType   = stream.readUint8();
            datas.mailInfo   = stream.readUnicode();
            datas.mailID     = stream.readInt32();
            return(datas);
        }
Пример #6
0
        public override void onRemoteMethodCall(Method method, MemoryStream stream)
        {
            switch (method.methodUtype)
            {
            case 21:
                UInt64 onEnterHall_arg1 = stream.readUint64();
                onEnterHall(onEnterHall_arg1);
                break;

            case 20:
                string onEnterSetName_arg1 = stream.readUnicode();
                onEnterSetName(onEnterSetName_arg1);
                break;

            case 29:
                Int64 onReqExitRoom_arg1 = stream.readInt64();
                onReqExitRoom(onReqExitRoom_arg1);
                break;

            case 25:
                UInt16 onReqJoinRoomFailed_arg1 = stream.readUint16();
                onReqJoinRoomFailed(onReqJoinRoomFailed_arg1);
                break;

            case 26:
                UInt16 onReqJoinRoomSuccess_arg1 = stream.readUint16();
                onReqJoinRoomSuccess(onReqJoinRoomSuccess_arg1);
                break;

            case 28:
                SEATS_INFO onReqPlayersInfo_arg1 = ((DATATYPE_SEATS_INFO)method.args[0]).createFromStreamEx(stream);
                onReqPlayersInfo(onReqPlayersInfo_arg1);
                break;

            case 27:
                string onReqRoomPassword_arg1 = stream.readUnicode();
                onReqRoomPassword(onReqRoomPassword_arg1);
                break;

            case 24:
                ROOM_INFOS_LIST onReqRoomsByParams_arg1 = ((DATATYPE_ROOM_INFOS_LIST)method.args[0]).createFromStreamEx(stream);
                onReqRoomsByParams(onReqRoomsByParams_arg1);
                break;

            case 22:
                UInt16 onSetNameFailed_arg1 = stream.readUint16();
                string onSetNameFailed_arg2 = stream.readUnicode();
                onSetNameFailed(onSetNameFailed_arg1, onSetNameFailed_arg2);
                break;

            case 23:
                string onSetNameSuccessfully_arg1 = stream.readUnicode();
                onSetNameSuccessfully(onSetNameSuccessfully_arg1);
                break;

            default:
                break;
            }
            ;
        }
        public override void onRemoteMethodCall(MemoryStream stream)
        {
            ScriptModule sm = EntityDef.moduledefs["Account"];

            UInt16 methodUtype            = 0;
            UInt16 componentPropertyUType = 0;

            if (sm.useMethodDescrAlias)
            {
                componentPropertyUType = stream.readUint8();
                methodUtype            = stream.readUint8();
            }
            else
            {
                componentPropertyUType = stream.readUint16();
                methodUtype            = stream.readUint16();
            }

            Method method = null;

            if (componentPropertyUType == 0)
            {
                method = sm.idmethods[methodUtype];
            }
            else
            {
                Property pComponentPropertyDescription = sm.idpropertys[componentPropertyUType];
                switch (pComponentPropertyDescription.properUtype)
                {
                default:
                    break;
                }

                return;
            }

            switch (method.methodUtype)
            {
            case 10005:
                Byte         onCreateAvatarResult_arg1 = stream.readUint8();
                AVATAR_INFOS onCreateAvatarResult_arg2 = ((DATATYPE_AVATAR_INFOS)method.args[1]).createFromStreamEx(stream);
                onCreateAvatarResult(onCreateAvatarResult_arg1, onCreateAvatarResult_arg2);
                break;

            case 3:
                UInt64 onRemoveAvatar_arg1 = stream.readUint64();
                onRemoveAvatar(onRemoveAvatar_arg1);
                break;

            case 10003:
                AVATAR_INFOS_LIST onReqAvatarList_arg1 = ((DATATYPE_AVATAR_INFOS_LIST)method.args[0]).createFromStreamEx(stream);
                onReqAvatarList(onReqAvatarList_arg1);
                break;

            default:
                break;
            }
            ;
        }
Пример #8
0
        public CARD_INFO createFromStreamEx(MemoryStream stream)
        {
            CARD_INFO datas = new CARD_INFO();

            datas.CardID  = stream.readUint64();
            datas.CardNum = stream.readUint8();
            return(datas);
        }
Пример #9
0
        public CITY_SELL_GOODS_INFO createFromStreamEx(MemoryStream stream)
        {
            CITY_SELL_GOODS_INFO datas = new CITY_SELL_GOODS_INFO();

            datas.GoodsID      = stream.readUint64();
            datas.GoodsBaseNum = stream.readUint16();
            return(datas);
        }
Пример #10
0
        public override void onRemoteMethodCall(MemoryStream stream)
        {
            ScriptModule sm = EntityDef.moduledefs["Avatar"];

            UInt16 methodUtype            = 0;
            UInt16 componentPropertyUType = 0;

            if (sm.useMethodDescrAlias)
            {
                componentPropertyUType = stream.readUint8();
                methodUtype            = stream.readUint8();
            }
            else
            {
                componentPropertyUType = stream.readUint16();
                methodUtype            = stream.readUint16();
            }

            Method method = null;

            if (componentPropertyUType == 0)
            {
                method = sm.idmethods[methodUtype];
            }
            else
            {
                Property pComponentPropertyDescription = sm.idpropertys[componentPropertyUType];
                switch (pComponentPropertyDescription.properUtype)
                {
                case 6:
                    component1.onRemoteMethodCall(methodUtype, stream);
                    break;

                default:
                    break;
                }

                return;
            }

            switch (method.methodUtype)
            {
            case 5:
                UInt64 onGameBegine_arg1 = stream.readUint64();
                onGameBegine(onGameBegine_arg1);
                break;

            case 4:
                FRAME_DATA onRspFrameMessage_arg1 = ((DATATYPE_FRAME_DATA)method.args[0]).createFromStreamEx(stream);
                onRspFrameMessage(onRspFrameMessage_arg1);
                break;

            default:
                break;
            }
            ;
        }
Пример #11
0
        public override object createFromStream(MemoryStream stream)
        {
            UInt64 cid   = stream.readUint64();
            Int32  id    = stream.readInt32();
            UInt16 type  = stream.readUint16();
            UInt16 utype = stream.readUint16();

            return(new byte[0]);
        }
Пример #12
0
        public ROOM_INFO createFromStreamEx(MemoryStream stream)
        {
            ROOM_INFO datas = new ROOM_INFO();

            datas.room_key     = stream.readUint64();
            datas.player_count = stream.readUint8();
            datas.room_state   = stream.readInt8();
            datas.room_creater = stream.readInt32();
            return(datas);
        }
Пример #13
0
        public ENTITYDATA createFromStreamEx(MemoryStream stream)
        {
            ENTITYDATA datas = new ENTITYDATA();

            datas.playerName = stream.readUnicode();
            datas.playerBean = stream.readInt32();
            datas.roomIndex  = stream.readUint8();
            datas.playerID   = stream.readUint64();
            return(datas);
        }
Пример #14
0
        public PLAYRE_DATA createFromStreamEx(MemoryStream stream)
        {
            PLAYRE_DATA datas = new PLAYRE_DATA();

            datas.playerName = stream.readUnicode();
            datas.playerDBID = stream.readUint64();
            datas.playerGold = stream.readUint32();
            datas.isOnLine   = stream.readUint8();
            return(datas);
        }
Пример #15
0
        public AVATAR_INFO createFromStreamEx(MemoryStream stream)
        {
            AVATAR_INFO datas = new AVATAR_INFO();

            datas.dbid     = stream.readUint64();
            datas.name     = stream.readUnicode();
            datas.roleType = stream.readUint8();
            datas.level    = stream.readUint16();
            return(datas);
        }
Пример #16
0
        public SPACE_INFO createFromStreamEx(MemoryStream stream)
        {
            SPACE_INFO datas = new SPACE_INFO();

            datas.space_key     = stream.readUint64();
            datas.player_count  = stream.readUint8();
            datas.space_state   = stream.readInt8();
            datas.space_creater = stream.readInt32();
            return(datas);
        }
Пример #17
0
        public AVATAR_INFOS createFromStreamEx(MemoryStream stream)
        {
            AVATAR_INFOS datas = new AVATAR_INFOS();

            datas.dbid     = stream.readUint64();
            datas.name     = stream.readUnicode();
            datas.roleType = stream.readUint8();
            datas.weaponId = stream.readInt32();
            return(datas);
        }
Пример #18
0
        public D_MATCH_REQUEST createFromStreamEx(MemoryStream stream)
        {
            D_MATCH_REQUEST datas = new D_MATCH_REQUEST();

            datas.utype   = stream.readUint32();
            datas.matchID = stream.readUint64();
            datas.passwd  = stream.readUint32();
            datas.teamID  = stream.readInt8();
            return(datas);
        }
Пример #19
0
        public ITEM_INFO createFromStreamEx(MemoryStream stream)
        {
            ITEM_INFO datas = new ITEM_INFO();

            datas.UUID      = stream.readUint64();
            datas.itemId    = stream.readInt32();
            datas.itemCount = stream.readUint32();
            datas.itemIndex = stream.readInt32();
            return(datas);
        }
Пример #20
0
        public FRIENDDATA createFromStreamEx(MemoryStream stream)
        {
            FRIENDDATA datas = new FRIENDDATA();

            datas.status       = stream.readUint8();
            datas.playerID     = stream.readUint64();
            datas.playerName   = stream.readUnicode();
            datas.playerBean   = stream.readInt32();
            datas.playerEntity = stream.readEntitycall();
            return(datas);
        }
Пример #21
0
        public FRIEND_INFO createFromStreamEx(MemoryStream stream)
        {
            FRIEND_INFO datas = new FRIEND_INFO();

            datas.dbid   = stream.readUint64();
            datas.name   = stream.readUnicode();
            datas.level  = stream.readUint16();
            datas.status = stream.readUint16();
            datas.icon   = stream.readUint16();
            return(datas);
        }
Пример #22
0
        public ROOM_INFOS createFromStreamEx(MemoryStream stream)
        {
            ROOM_INFOS datas = new ROOM_INFOS();

            datas.roomKey     = stream.readUint64();
            datas.name        = stream.readUnicode();
            datas.intro       = stream.readUnicode();
            datas.playerCount = stream.readUint8();
            datas.isPlaying   = stream.readUint8();
            datas.hasPassword = stream.readUint8();
            return(datas);
        }
Пример #23
0
        public AVATAR_INFOS createFromStreamEx(MemoryStream stream)
        {
            AVATAR_INFOS datas = new AVATAR_INFOS();

            datas.dbid     = stream.readUint64();
            datas.Name     = stream.readUnicode();
            datas.RoleType = stream.readUint8();
            datas.Country  = stream.readUint8();
            datas.Sex      = stream.readUint8();
            datas.Level    = stream.readInt16();
            datas.Gold     = stream.readInt32();
            return(datas);
        }
Пример #24
0
        public OPEN_PACK_RUL createFromStreamEx(MemoryStream stream)
        {
            UInt32        size  = stream.readUint32();
            OPEN_PACK_RUL datas = new OPEN_PACK_RUL();

            while (size > 0)
            {
                --size;
                datas.Add(stream.readUint64());
            }
            ;

            return(datas);
        }
Пример #25
0
        public FRIENDS_LIST createFromStreamEx(MemoryStream stream)
        {
            UInt32       size  = stream.readUint32();
            FRIENDS_LIST datas = new FRIENDS_LIST();

            while (size > 0)
            {
                --size;
                datas.Add(stream.readUint64());
            }
            ;

            return(datas);
        }
Пример #26
0
 static int readUint64(IntPtr L)
 {
     try
     {
         ToLua.CheckArgsCount(L, 1);
         KBEngine.MemoryStream obj = (KBEngine.MemoryStream)ToLua.CheckObject <KBEngine.MemoryStream>(L, 1);
         ulong o = obj.readUint64();
         LuaDLL.tolua_pushuint64(L, o);
         return(1);
     }
     catch (Exception e)
     {
         return(LuaDLL.toluaL_exception(L, e));
     }
 }
Пример #27
0
        public override void onUpdatePropertys(MemoryStream stream)
        {
            ScriptModule sm = EntityDef.moduledefs["Account"];
            Dictionary <UInt16, Property> pdatas = sm.idpropertys;

            while (stream.length() > 0)
            {
                UInt16 _t_utype       = 0;
                UInt16 _t_child_utype = 0;

                {
                    if (sm.usePropertyDescrAlias)
                    {
                        _t_utype       = stream.readUint8();
                        _t_child_utype = stream.readUint8();
                    }
                    else
                    {
                        _t_utype       = stream.readUint16();
                        _t_child_utype = stream.readUint16();
                    }
                }

                Property prop = null;

                if (_t_utype == 0)
                {
                    prop = pdatas[_t_child_utype];
                }
                else
                {
                    Property pComponentPropertyDescription = pdatas[_t_utype];
                    switch (pComponentPropertyDescription.properUtype)
                    {
                    default:
                        break;
                    }

                    return;
                }

                switch (prop.properUtype)
                {
                case 40001:
                    Vector3 oldval_direction = direction;
                    direction = stream.readVector3();

                    if (prop.isBase())
                    {
                        if (inited)
                        {
                            onDirectionChanged(oldval_direction);
                        }
                    }
                    else
                    {
                        if (inWorld)
                        {
                            onDirectionChanged(oldval_direction);
                        }
                    }

                    break;

                case 2:
                    UInt64 oldval_lastSelCharacter = lastSelCharacter;
                    lastSelCharacter = stream.readUint64();

                    if (prop.isBase())
                    {
                        if (inited)
                        {
                            onLastSelCharacterChanged(oldval_lastSelCharacter);
                        }
                    }
                    else
                    {
                        if (inWorld)
                        {
                            onLastSelCharacterChanged(oldval_lastSelCharacter);
                        }
                    }

                    break;

                case 40000:
                    Vector3 oldval_position = position;
                    position = stream.readVector3();

                    if (prop.isBase())
                    {
                        if (inited)
                        {
                            onPositionChanged(oldval_position);
                        }
                    }
                    else
                    {
                        if (inWorld)
                        {
                            onPositionChanged(oldval_position);
                        }
                    }

                    break;

                case 40002:
                    stream.readUint32();
                    break;

                default:
                    break;
                }
                ;
            }
        }
Пример #28
0
 public override object createFromStream(MemoryStream stream)
 {
     return(stream.readUint64());
 }
        public override void onUpdatePropertys(MemoryStream stream)
        {
            ScriptModule sm = EntityDef.moduledefs["Room"];
            Dictionary <UInt16, Property> pdatas = sm.idpropertys;

            while (stream.length() > 0)
            {
                UInt16 _t_utype       = 0;
                UInt16 _t_child_utype = 0;

                {
                    if (sm.usePropertyDescrAlias)
                    {
                        _t_utype       = stream.readUint8();
                        _t_child_utype = stream.readUint8();
                    }
                    else
                    {
                        _t_utype       = stream.readUint16();
                        _t_child_utype = stream.readUint16();
                    }
                }

                Property prop = null;

                if (_t_utype == 0)
                {
                    prop = pdatas[_t_child_utype];
                }
                else
                {
                    Property pComponentPropertyDescription = pdatas[_t_utype];
                    switch (pComponentPropertyDescription.properUtype)
                    {
                    default:
                        break;
                    }

                    return;
                }

                switch (prop.properUtype)
                {
                case 19:
                    Byte oldval_RoomType = RoomType;
                    RoomType = stream.readUint8();

                    if (prop.isBase())
                    {
                        if (inited)
                        {
                            onRoomTypeChanged(oldval_RoomType);
                        }
                    }
                    else
                    {
                        if (inWorld)
                        {
                            onRoomTypeChanged(oldval_RoomType);
                        }
                    }

                    break;

                case 24:
                    Byte oldval_cur_turn = cur_turn;
                    cur_turn = stream.readUint8();

                    if (prop.isBase())
                    {
                        if (inited)
                        {
                            onCur_turnChanged(oldval_cur_turn);
                        }
                    }
                    else
                    {
                        if (inWorld)
                        {
                            onCur_turnChanged(oldval_cur_turn);
                        }
                    }

                    break;

                case 40001:
                    Vector3 oldval_direction = direction;
                    direction = stream.readVector3();

                    if (prop.isBase())
                    {
                        if (inited)
                        {
                            onDirectionChanged(oldval_direction);
                        }
                    }
                    else
                    {
                        if (inWorld)
                        {
                            onDirectionChanged(oldval_direction);
                        }
                    }

                    break;

                case 22:
                    Byte oldval_numOfMJ = numOfMJ;
                    numOfMJ = stream.readUint8();

                    if (prop.isBase())
                    {
                        if (inited)
                        {
                            onNumOfMJChanged(oldval_numOfMJ);
                        }
                    }
                    else
                    {
                        if (inWorld)
                        {
                            onNumOfMJChanged(oldval_numOfMJ);
                        }
                    }

                    break;

                case 21:
                    Byte oldval_playerMaxCount = playerMaxCount;
                    playerMaxCount = stream.readUint8();

                    if (prop.isBase())
                    {
                        if (inited)
                        {
                            onPlayerMaxCountChanged(oldval_playerMaxCount);
                        }
                    }
                    else
                    {
                        if (inWorld)
                        {
                            onPlayerMaxCountChanged(oldval_playerMaxCount);
                        }
                    }

                    break;

                case 40000:
                    Vector3 oldval_position = position;
                    position = stream.readVector3();

                    if (prop.isBase())
                    {
                        if (inited)
                        {
                            onPositionChanged(oldval_position);
                        }
                    }
                    else
                    {
                        if (inWorld)
                        {
                            onPositionChanged(oldval_position);
                        }
                    }

                    break;

                case 23:
                    ROOM_PUBLIC_INFO oldval_public_roomInfo = public_roomInfo;
                    public_roomInfo = ((DATATYPE_ROOM_PUBLIC_INFO)EntityDef.id2datatypes[31]).createFromStreamEx(stream);

                    if (prop.isBase())
                    {
                        if (inited)
                        {
                            onPublic_roomInfoChanged(oldval_public_roomInfo);
                        }
                    }
                    else
                    {
                        if (inWorld)
                        {
                            onPublic_roomInfoChanged(oldval_public_roomInfo);
                        }
                    }

                    break;

                case 18:
                    UInt64 oldval_roomKey = roomKey;
                    roomKey = stream.readUint64();

                    if (prop.isBase())
                    {
                        if (inited)
                        {
                            onRoomKeyChanged(oldval_roomKey);
                        }
                    }
                    else
                    {
                        if (inWorld)
                        {
                            onRoomKeyChanged(oldval_roomKey);
                        }
                    }

                    break;

                case 40002:
                    stream.readUint32();
                    break;

                default:
                    break;
                }
                ;
            }
        }
Пример #30
0
 /*
     登录baseapp成功了
 */
 public void Client_onReLoginBaseappSuccessfully(MemoryStream stream)
 {
     entity_uuid = stream.readUint64();
     Dbg.DEBUG_MSG("KBEngine::Client_onReLoginBaseappSuccessfully: name(" + username + ")!");
     Event.fireAll("onReLoginBaseappSuccessfully", new object[]{});
 }
Пример #31
0
        public override void onUpdatePropertys(Property prop, MemoryStream stream)
        {
            switch (prop.properUtype)
            {
            case 40001:
                Vector3 oldval_direction = direction;
                direction = stream.readVector3();

                if (prop.isBase())
                {
                    if (inited)
                    {
                        onDirectionChanged(oldval_direction);
                    }
                }
                else
                {
                    if (inWorld)
                    {
                        onDirectionChanged(oldval_direction);
                    }
                }

                break;

            case 23:
                List <Int32> oldval_hiddenCards = hiddenCards;
                hiddenCards = ((DATATYPE_AnonymousArray_31)EntityDef.id2datatypes[31]).createFromStreamEx(stream);

                if (prop.isBase())
                {
                    if (inited)
                    {
                        onHiddenCardsChanged(oldval_hiddenCards);
                    }
                }
                else
                {
                    if (inWorld)
                    {
                        onHiddenCardsChanged(oldval_hiddenCards);
                    }
                }

                break;

            case 24:
                List <Int32> oldval_hiddenCardsOpen = hiddenCardsOpen;
                hiddenCardsOpen = ((DATATYPE_AnonymousArray_32)EntityDef.id2datatypes[32]).createFromStreamEx(stream);

                if (prop.isBase())
                {
                    if (inited)
                    {
                        onHiddenCardsOpenChanged(oldval_hiddenCardsOpen);
                    }
                }
                else
                {
                    if (inWorld)
                    {
                        onHiddenCardsOpenChanged(oldval_hiddenCardsOpen);
                    }
                }

                break;

            case 25:
                Int16 oldval_highestPoint = highestPoint;
                highestPoint = stream.readInt16();

                if (prop.isBase())
                {
                    if (inited)
                    {
                        onHighestPointChanged(oldval_highestPoint);
                    }
                }
                else
                {
                    if (inWorld)
                    {
                        onHighestPointChanged(oldval_highestPoint);
                    }
                }

                break;

            case 18:
                string oldval_intro = intro;
                intro = stream.readUnicode();

                if (prop.isBase())
                {
                    if (inited)
                    {
                        onIntroChanged(oldval_intro);
                    }
                }
                else
                {
                    if (inWorld)
                    {
                        onIntroChanged(oldval_intro);
                    }
                }

                break;

            case 30:
                Int16 oldval_isGameOver = isGameOver;
                isGameOver = stream.readInt16();

                if (prop.isBase())
                {
                    if (inited)
                    {
                        onIsGameOverChanged(oldval_isGameOver);
                    }
                }
                else
                {
                    if (inWorld)
                    {
                        onIsGameOverChanged(oldval_isGameOver);
                    }
                }

                break;

            case 19:
                Int16 oldval_isPlaying = isPlaying;
                isPlaying = stream.readInt16();

                if (prop.isBase())
                {
                    if (inited)
                    {
                        onIsPlayingChanged(oldval_isPlaying);
                    }
                }
                else
                {
                    if (inWorld)
                    {
                        onIsPlayingChanged(oldval_isPlaying);
                    }
                }

                break;

            case 26:
                Int16 oldval_landlordIndex = landlordIndex;
                landlordIndex = stream.readInt16();

                if (prop.isBase())
                {
                    if (inited)
                    {
                        onLandlordIndexChanged(oldval_landlordIndex);
                    }
                }
                else
                {
                    if (inWorld)
                    {
                        onLandlordIndexChanged(oldval_landlordIndex);
                    }
                }

                break;

            case 29:
                List <Int32> oldval_lastPlayCards = lastPlayCards;
                lastPlayCards = ((DATATYPE_AnonymousArray_33)EntityDef.id2datatypes[33]).createFromStreamEx(stream);

                if (prop.isBase())
                {
                    if (inited)
                    {
                        onLastPlayCardsChanged(oldval_lastPlayCards);
                    }
                }
                else
                {
                    if (inWorld)
                    {
                        onLastPlayCardsChanged(oldval_lastPlayCards);
                    }
                }

                break;

            case 28:
                Int16 oldval_lastPlayIndex = lastPlayIndex;
                lastPlayIndex = stream.readInt16();

                if (prop.isBase())
                {
                    if (inited)
                    {
                        onLastPlayIndexChanged(oldval_lastPlayIndex);
                    }
                }
                else
                {
                    if (inWorld)
                    {
                        onLastPlayIndexChanged(oldval_lastPlayIndex);
                    }
                }

                break;

            case 17:
                string oldval_name = name;
                name = stream.readUnicode();

                if (prop.isBase())
                {
                    if (inited)
                    {
                        onNameChanged(oldval_name);
                    }
                }
                else
                {
                    if (inWorld)
                    {
                        onNameChanged(oldval_name);
                    }
                }

                break;

            case 21:
                Int16 oldval_openCard = openCard;
                openCard = stream.readInt16();

                if (prop.isBase())
                {
                    if (inited)
                    {
                        onOpenCardChanged(oldval_openCard);
                    }
                }
                else
                {
                    if (inWorld)
                    {
                        onOpenCardChanged(oldval_openCard);
                    }
                }

                break;

            case 27:
                Int16 oldval_playIndex = playIndex;
                playIndex = stream.readInt16();

                if (prop.isBase())
                {
                    if (inited)
                    {
                        onPlayIndexChanged(oldval_playIndex);
                    }
                }
                else
                {
                    if (inWorld)
                    {
                        onPlayIndexChanged(oldval_playIndex);
                    }
                }

                break;

            case 40000:
                Vector3 oldval_position = position;
                position = stream.readVector3();

                if (prop.isBase())
                {
                    if (inited)
                    {
                        onPositionChanged(oldval_position);
                    }
                }
                else
                {
                    if (inWorld)
                    {
                        onPositionChanged(oldval_position);
                    }
                }

                break;

            case 22:
                Int32 oldval_raiseIndex = raiseIndex;
                raiseIndex = stream.readInt32();

                if (prop.isBase())
                {
                    if (inited)
                    {
                        onRaiseIndexChanged(oldval_raiseIndex);
                    }
                }
                else
                {
                    if (inWorld)
                    {
                        onRaiseIndexChanged(oldval_raiseIndex);
                    }
                }

                break;

            case 16:
                UInt64 oldval_roomKey = roomKey;
                roomKey = stream.readUint64();

                if (prop.isBase())
                {
                    if (inited)
                    {
                        onRoomKeyChanged(oldval_roomKey);
                    }
                }
                else
                {
                    if (inWorld)
                    {
                        onRoomKeyChanged(oldval_roomKey);
                    }
                }

                break;

            case 20:
                SEATS_INFO oldval_seatsData = seatsData;
                seatsData = ((DATATYPE_SEATS_INFO)EntityDef.id2datatypes[23]).createFromStreamEx(stream);

                if (prop.isBase())
                {
                    if (inited)
                    {
                        onSeatsDataChanged(oldval_seatsData);
                    }
                }
                else
                {
                    if (inWorld)
                    {
                        onSeatsDataChanged(oldval_seatsData);
                    }
                }

                break;

            case 40002:
                stream.readUint32();
                break;

            default:
                break;
            }
            ;
        }
Пример #32
0
		public override object createFromStream(MemoryStream stream)
		{
			return stream.readUint64();
		}