Example #1
0
        public override void onUpdatePropertys(MemoryStream stream)
        {
            ScriptModule sm = EntityDef.moduledefs["Avatar"];
            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)
                    {
                    case 15:
                        componentFrameSync.onUpdatePropertys(_t_child_utype, stream, -1);
                        break;

                    default:
                        break;
                    }

                    return;
                }

                switch (prop.properUtype)
                {
                case 15:
                    componentFrameSync.createFromStream(stream);
                    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 11:
                    SByte oldval_gameStateC = gameStateC;
                    gameStateC = stream.readInt8();

                    if (prop.isBase())
                    {
                        if (inited)
                        {
                            onGameStateCChanged(oldval_gameStateC);
                        }
                    }
                    else
                    {
                        if (inWorld)
                        {
                            onGameStateCChanged(oldval_gameStateC);
                        }
                    }

                    break;

                case 13:
                    Byte oldval_modelID = modelID;
                    modelID = stream.readUint8();

                    if (prop.isBase())
                    {
                        if (inited)
                        {
                            onModelIDChanged(oldval_modelID);
                        }
                    }
                    else
                    {
                        if (inWorld)
                        {
                            onModelIDChanged(oldval_modelID);
                        }
                    }

                    break;

                case 8:
                    float oldval_moveSpeed = moveSpeed;
                    moveSpeed = stream.readFloat();

                    if (prop.isBase())
                    {
                        if (inited)
                        {
                            onMoveSpeedChanged(oldval_moveSpeed);
                        }
                    }
                    else
                    {
                        if (inWorld)
                        {
                            onMoveSpeedChanged(oldval_moveSpeed);
                        }
                    }

                    break;

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

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

                    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 4:
                    Byte oldval_roleType = roleType;
                    roleType = stream.readUint8();

                    if (prop.isBase())
                    {
                        if (inited)
                        {
                            onRoleTypeChanged(oldval_roleType);
                        }
                    }
                    else
                    {
                        if (inWorld)
                        {
                            onRoleTypeChanged(oldval_roleType);
                        }
                    }

                    break;

                case 40002:
                    stream.readUint32();
                    break;

                case 9:
                    SByte oldval_state = state;
                    state = stream.readInt8();

                    if (prop.isBase())
                    {
                        if (inited)
                        {
                            onStateChanged(oldval_state);
                        }
                    }
                    else
                    {
                        if (inWorld)
                        {
                            onStateChanged(oldval_state);
                        }
                    }

                    break;

                case 6:
                    Byte oldval_teamID = teamID;
                    teamID = stream.readUint8();

                    if (prop.isBase())
                    {
                        if (inited)
                        {
                            onTeamIDChanged(oldval_teamID);
                        }
                    }
                    else
                    {
                        if (inWorld)
                        {
                            onTeamIDChanged(oldval_teamID);
                        }
                    }

                    break;

                case 5:
                    Int32 oldval_weaponID = weaponID;
                    weaponID = stream.readInt32();

                    if (prop.isBase())
                    {
                        if (inited)
                        {
                            onWeaponIDChanged(oldval_weaponID);
                        }
                    }
                    else
                    {
                        if (inWorld)
                        {
                            onWeaponIDChanged(oldval_weaponID);
                        }
                    }

                    break;

                default:
                    break;
                }
                ;
            }
        }
Example #2
0
        public override void onUpdatePropertys(MemoryStream stream)
        {
            ScriptModule sm = EntityDef.moduledefs["Avatar"];
            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)
                    {
                    case 17:
                        compMatchAvatar.onUpdatePropertys(_t_child_utype, stream, -1);
                        break;

                    case 8:
                        component1.onUpdatePropertys(_t_child_utype, stream, -1);
                        break;

                    case 11:
                        component2.onUpdatePropertys(_t_child_utype, stream, -1);
                        break;

                    case 15:
                        component3.onUpdatePropertys(_t_child_utype, stream, -1);
                        break;

                    default:
                        break;
                    }

                    return;
                }

                switch (prop.properUtype)
                {
                case 17:
                    compMatchAvatar.createFromStream(stream);
                    break;

                case 8:
                    component1.createFromStream(stream);
                    break;

                case 11:
                    component2.createFromStream(stream);
                    break;

                case 15:
                    component3.createFromStream(stream);
                    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 4:
                    string oldval_name = name;
                    name = stream.readUnicode();

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

                    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;

                case 7:
                    SByte oldval_teamID = teamID;
                    teamID = stream.readInt8();

                    if (prop.isBase())
                    {
                        if (inited)
                        {
                            onTeamIDChanged(oldval_teamID);
                        }
                    }
                    else
                    {
                        if (inWorld)
                        {
                            onTeamIDChanged(oldval_teamID);
                        }
                    }

                    break;

                default:
                    break;
                }
                ;
            }
        }
        public override void onUpdatePropertys(MemoryStream stream)
        {
            ScriptModule sm = EntityDef.moduledefs["Avatar"];
            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)
                    {
                    case 17:
                        componentFrameSync.onUpdatePropertys(_t_child_utype, stream, -1);
                        break;

                    default:
                        break;
                    }

                    return;
                }

                switch (prop.properUtype)
                {
                case 17:
                    componentFrameSync.createFromStream(stream);
                    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 13:
                    SByte oldval_gameStateC = gameStateC;
                    gameStateC = stream.readInt8();

                    if (prop.isBase())
                    {
                        if (inited)
                        {
                            onGameStateCChanged(oldval_gameStateC);
                        }
                    }
                    else
                    {
                        if (inWorld)
                        {
                            onGameStateCChanged(oldval_gameStateC);
                        }
                    }

                    break;

                case 5:
                    Int32 oldval_heroId = heroId;
                    heroId = stream.readInt32();

                    if (prop.isBase())
                    {
                        if (inited)
                        {
                            onHeroIdChanged(oldval_heroId);
                        }
                    }
                    else
                    {
                        if (inWorld)
                        {
                            onHeroIdChanged(oldval_heroId);
                        }
                    }

                    break;

                case 15:
                    SByte oldval_level = level;
                    level = stream.readInt8();

                    if (prop.isBase())
                    {
                        if (inited)
                        {
                            onLevelChanged(oldval_level);
                        }
                    }
                    else
                    {
                        if (inWorld)
                        {
                            onLevelChanged(oldval_level);
                        }
                    }

                    break;

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

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

                    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 12:
                    SByte oldval_roundCount = roundCount;
                    roundCount = stream.readInt8();

                    if (prop.isBase())
                    {
                        if (inited)
                        {
                            onRoundCountChanged(oldval_roundCount);
                        }
                    }
                    else
                    {
                        if (inWorld)
                        {
                            onRoundCountChanged(oldval_roundCount);
                        }
                    }

                    break;

                case 14:
                    SByte oldval_seatNo = seatNo;
                    seatNo = stream.readInt8();

                    if (prop.isBase())
                    {
                        if (inited)
                        {
                            onSeatNoChanged(oldval_seatNo);
                        }
                    }
                    else
                    {
                        if (inWorld)
                        {
                            onSeatNoChanged(oldval_seatNo);
                        }
                    }

                    break;

                case 40002:
                    stream.readUint32();
                    break;

                case 9:
                    Int32 oldval_teamId = teamId;
                    teamId = stream.readInt32();

                    if (prop.isBase())
                    {
                        if (inited)
                        {
                            onTeamIdChanged(oldval_teamId);
                        }
                    }
                    else
                    {
                        if (inWorld)
                        {
                            onTeamIdChanged(oldval_teamId);
                        }
                    }

                    break;

                case 11:
                    SByte oldval_winRate = winRate;
                    winRate = stream.readInt8();

                    if (prop.isBase())
                    {
                        if (inited)
                        {
                            onWinRateChanged(oldval_winRate);
                        }
                    }
                    else
                    {
                        if (inWorld)
                        {
                            onWinRateChanged(oldval_winRate);
                        }
                    }

                    break;

                default:
                    break;
                }
                ;
            }
        }