Exemplo n.º 1
0
        public ITEM_INFO_LIST createFromStreamEx(MemoryStream stream)
        {
            ITEM_INFO_LIST datas = new ITEM_INFO_LIST();

            datas.values = values_DataType.createFromStreamEx(stream);
            return(datas);
        }
Exemplo n.º 2
0
        public override void onReqItemList(ITEM_INFO_LIST infos, ITEM_INFO_LIST equipInfos)
        {
            itemDict.Clear();
            List <ITEM_INFO> listinfos = infos.values;

            for (int i = 0; i < listinfos.Count; i++)
            {
                ITEM_INFO info = listinfos[i];
                itemDict.Add(info.UUID, info);
                itemIndex2Uids[info.itemIndex] = info.UUID;
            }
            equipItemDict.Clear();
            List <ITEM_INFO> elistinfos = equipInfos.values;

            for (int i = 0; i < elistinfos.Count; i++)
            {
                ITEM_INFO info = elistinfos[i];
                equipItemDict.Add(info.UUID, info);
                equipIndex2Uids[info.itemIndex] = info.UUID;
            }
            // ui event
            Event.fireOut("onReqItemList", new object[] { itemDict, equipItemDict });
        }
Exemplo n.º 3
0
 public virtual void onItemListChanged(ITEM_INFO_LIST oldValue)
 {
 }
Exemplo n.º 4
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)
                    {
                    default:
                        break;
                    }

                    return;
                }

                switch (prop.properUtype)
                {
                case 47001:
                    Int32 oldval_HP = HP;
                    HP = stream.readInt32();

                    if (prop.isBase())
                    {
                        if (inited)
                        {
                            onHPChanged(oldval_HP);
                        }
                    }
                    else
                    {
                        if (inWorld)
                        {
                            onHPChanged(oldval_HP);
                        }
                    }

                    break;

                case 47002:
                    Int32 oldval_HP_Max = HP_Max;
                    HP_Max = stream.readInt32();

                    if (prop.isBase())
                    {
                        if (inited)
                        {
                            onHP_MaxChanged(oldval_HP_Max);
                        }
                    }
                    else
                    {
                        if (inWorld)
                        {
                            onHP_MaxChanged(oldval_HP_Max);
                        }
                    }

                    break;

                case 47003:
                    Int32 oldval_MP = MP;
                    MP = stream.readInt32();

                    if (prop.isBase())
                    {
                        if (inited)
                        {
                            onMPChanged(oldval_MP);
                        }
                    }
                    else
                    {
                        if (inWorld)
                        {
                            onMPChanged(oldval_MP);
                        }
                    }

                    break;

                case 47004:
                    Int32 oldval_MP_Max = MP_Max;
                    MP_Max = stream.readInt32();

                    if (prop.isBase())
                    {
                        if (inited)
                        {
                            onMP_MaxChanged(oldval_MP_Max);
                        }
                    }
                    else
                    {
                        if (inWorld)
                        {
                            onMP_MaxChanged(oldval_MP_Max);
                        }
                    }

                    break;

                case 17:
                    Int32 oldval_attack_Max = attack_Max;
                    attack_Max = stream.readInt32();

                    if (prop.isBase())
                    {
                        if (inited)
                        {
                            onAttack_MaxChanged(oldval_attack_Max);
                        }
                    }
                    else
                    {
                        if (inWorld)
                        {
                            onAttack_MaxChanged(oldval_attack_Max);
                        }
                    }

                    break;

                case 18:
                    Int32 oldval_attack_Min = attack_Min;
                    attack_Min = stream.readInt32();

                    if (prop.isBase())
                    {
                        if (inited)
                        {
                            onAttack_MinChanged(oldval_attack_Min);
                        }
                    }
                    else
                    {
                        if (inWorld)
                        {
                            onAttack_MinChanged(oldval_attack_Min);
                        }
                    }

                    break;

                case 19:
                    Int32 oldval_defence = defence;
                    defence = stream.readInt32();

                    if (prop.isBase())
                    {
                        if (inited)
                        {
                            onDefenceChanged(oldval_defence);
                        }
                    }
                    else
                    {
                        if (inWorld)
                        {
                            onDefenceChanged(oldval_defence);
                        }
                    }

                    break;

                case 25:
                    Int32 oldval_dexterity = dexterity;
                    dexterity = stream.readInt32();

                    if (prop.isBase())
                    {
                        if (inited)
                        {
                            onDexterityChanged(oldval_dexterity);
                        }
                    }
                    else
                    {
                        if (inWorld)
                        {
                            onDexterityChanged(oldval_dexterity);
                        }
                    }

                    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 21:
                    Int32 oldval_dodge = dodge;
                    dodge = stream.readInt32();

                    if (prop.isBase())
                    {
                        if (inited)
                        {
                            onDodgeChanged(oldval_dodge);
                        }
                    }
                    else
                    {
                        if (inWorld)
                        {
                            onDodgeChanged(oldval_dodge);
                        }
                    }

                    break;

                case 7:
                    ITEM_INFO_LIST oldval_equipItemList = equipItemList;
                    equipItemList = ((DATATYPE_ITEM_INFO_LIST)EntityDef.id2datatypes[28]).createFromStreamEx(stream);

                    if (prop.isBase())
                    {
                        if (inited)
                        {
                            onEquipItemListChanged(oldval_equipItemList);
                        }
                    }
                    else
                    {
                        if (inWorld)
                        {
                            onEquipItemListChanged(oldval_equipItemList);
                        }
                    }

                    break;

                case 8:
                    Int32 oldval_equipWeapon = equipWeapon;
                    equipWeapon = stream.readInt32();

                    if (prop.isBase())
                    {
                        if (inited)
                        {
                            onEquipWeaponChanged(oldval_equipWeapon);
                        }
                    }
                    else
                    {
                        if (inWorld)
                        {
                            onEquipWeaponChanged(oldval_equipWeapon);
                        }
                    }

                    break;

                case 23:
                    UInt64 oldval_exp = exp;
                    exp = stream.readUint64();

                    if (prop.isBase())
                    {
                        if (inited)
                        {
                            onExpChanged(oldval_exp);
                        }
                    }
                    else
                    {
                        if (inWorld)
                        {
                            onExpChanged(oldval_exp);
                        }
                    }

                    break;

                case 47005:
                    Int32 oldval_forbids = forbids;
                    forbids = stream.readInt32();

                    if (prop.isBase())
                    {
                        if (inited)
                        {
                            onForbidsChanged(oldval_forbids);
                        }
                    }
                    else
                    {
                        if (inWorld)
                        {
                            onForbidsChanged(oldval_forbids);
                        }
                    }

                    break;

                case 6:
                    ITEM_INFO_LIST oldval_itemList = itemList;
                    itemList = ((DATATYPE_ITEM_INFO_LIST)EntityDef.id2datatypes[28]).createFromStreamEx(stream);

                    if (prop.isBase())
                    {
                        if (inited)
                        {
                            onItemListChanged(oldval_itemList);
                        }
                    }
                    else
                    {
                        if (inWorld)
                        {
                            onItemListChanged(oldval_itemList);
                        }
                    }

                    break;

                case 5:
                    UInt16 oldval_level = level;
                    level = stream.readUint16();

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

                    break;

                case 41006:
                    UInt32 oldval_modelID = modelID;
                    modelID = stream.readUint32();

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

                    break;

                case 41007:
                    Byte oldval_modelScale = modelScale;
                    modelScale = stream.readUint8();

                    if (prop.isBase())
                    {
                        if (inited)
                        {
                            onModelScaleChanged(oldval_modelScale);
                        }
                    }
                    else
                    {
                        if (inWorld)
                        {
                            onModelScaleChanged(oldval_modelScale);
                        }
                    }

                    break;

                case 22:
                    UInt64 oldval_money = money;
                    money = stream.readUint64();

                    if (prop.isBase())
                    {
                        if (inited)
                        {
                            onMoneyChanged(oldval_money);
                        }
                    }
                    else
                    {
                        if (inWorld)
                        {
                            onMoneyChanged(oldval_money);
                        }
                    }

                    break;

                case 12:
                    Byte oldval_moveSpeed = moveSpeed;
                    moveSpeed = stream.readUint8();

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

                    break;

                case 41003:
                    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 20:
                    Int32 oldval_rating = rating;
                    rating = stream.readInt32();

                    if (prop.isBase())
                    {
                        if (inited)
                        {
                            onRatingChanged(oldval_rating);
                        }
                    }
                    else
                    {
                        if (inWorld)
                        {
                            onRatingChanged(oldval_rating);
                        }
                    }

                    break;

                case 4:
                    Byte oldval_roleTypeCell = roleTypeCell;
                    roleTypeCell = stream.readUint8();

                    if (prop.isBase())
                    {
                        if (inited)
                        {
                            onRoleTypeCellChanged(oldval_roleTypeCell);
                        }
                    }
                    else
                    {
                        if (inWorld)
                        {
                            onRoleTypeCellChanged(oldval_roleTypeCell);
                        }
                    }

                    break;

                case 40002:
                    stream.readUint32();
                    break;

                case 41001:
                    UInt32 oldval_spaceUType = spaceUType;
                    spaceUType = stream.readUint32();

                    if (prop.isBase())
                    {
                        if (inited)
                        {
                            onSpaceUTypeChanged(oldval_spaceUType);
                        }
                    }
                    else
                    {
                        if (inWorld)
                        {
                            onSpaceUTypeChanged(oldval_spaceUType);
                        }
                    }

                    break;

                case 26:
                    Int32 oldval_stamina = stamina;
                    stamina = stream.readInt32();

                    if (prop.isBase())
                    {
                        if (inited)
                        {
                            onStaminaChanged(oldval_stamina);
                        }
                    }
                    else
                    {
                        if (inWorld)
                        {
                            onStaminaChanged(oldval_stamina);
                        }
                    }

                    break;

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

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

                    break;

                case 24:
                    Int32 oldval_strength = strength;
                    strength = stream.readInt32();

                    if (prop.isBase())
                    {
                        if (inited)
                        {
                            onStrengthChanged(oldval_strength);
                        }
                    }
                    else
                    {
                        if (inWorld)
                        {
                            onStrengthChanged(oldval_strength);
                        }
                    }

                    break;

                case 47007:
                    Byte oldval_subState = subState;
                    subState = stream.readUint8();

                    if (prop.isBase())
                    {
                        if (inited)
                        {
                            onSubStateChanged(oldval_subState);
                        }
                    }
                    else
                    {
                        if (inWorld)
                        {
                            onSubStateChanged(oldval_subState);
                        }
                    }

                    break;

                case 41004:
                    UInt32 oldval_uid = uid;
                    uid = stream.readUint32();

                    if (prop.isBase())
                    {
                        if (inited)
                        {
                            onUidChanged(oldval_uid);
                        }
                    }
                    else
                    {
                        if (inWorld)
                        {
                            onUidChanged(oldval_uid);
                        }
                    }

                    break;

                case 41005:
                    UInt32 oldval_utype = utype;
                    utype = stream.readUint32();

                    if (prop.isBase())
                    {
                        if (inited)
                        {
                            onUtypeChanged(oldval_utype);
                        }
                    }
                    else
                    {
                        if (inWorld)
                        {
                            onUtypeChanged(oldval_utype);
                        }
                    }

                    break;

                default:
                    break;
                }
                ;
            }
        }
Exemplo n.º 5
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)
                {
                default:
                    break;
                }

                return;
            }

            switch (method.methodUtype)
            {
            case 21:
                string ReceiveChatMessage_arg1 = stream.readUnicode();
                ReceiveChatMessage(ReceiveChatMessage_arg1);
                break;

            case 10104:
                dialog_close();
                break;

            case 10101:
                Int32         dialog_setContent_arg1 = stream.readInt32();
                List <UInt32> dialog_setContent_arg2 = ((DATATYPE_AnonymousArray_31)method.args[1]).createFromStreamEx(stream);
                List <string> dialog_setContent_arg3 = ((DATATYPE_AnonymousArray_32)method.args[2]).createFromStreamEx(stream);
                string        dialog_setContent_arg4 = stream.readUnicode();
                string        dialog_setContent_arg5 = stream.readUnicode();
                string        dialog_setContent_arg6 = stream.readUnicode();
                dialog_setContent(dialog_setContent_arg1, dialog_setContent_arg2, dialog_setContent_arg3, dialog_setContent_arg4, dialog_setContent_arg5, dialog_setContent_arg6);
                break;

            case 24:
                Int32  dropItem_re_arg1 = stream.readInt32();
                UInt64 dropItem_re_arg2 = stream.readUint64();
                dropItem_re(dropItem_re_arg1, dropItem_re_arg2);
                break;

            case 25:
                ITEM_INFO equipItemRequest_re_arg1 = ((DATATYPE_ITEM_INFO)method.args[0]).createFromStreamEx(stream);
                ITEM_INFO equipItemRequest_re_arg2 = ((DATATYPE_ITEM_INFO)method.args[1]).createFromStreamEx(stream);
                equipItemRequest_re(equipItemRequest_re_arg1, equipItemRequest_re_arg2);
                break;

            case 26:
                Int32 errorInfo_arg1 = stream.readInt32();
                errorInfo(errorInfo_arg1);
                break;

            case 31:
                Int32 onAddSkill_arg1 = stream.readInt32();
                onAddSkill(onAddSkill_arg1);
                break;

            case 32:
                Int32 onRemoveSkill_arg1 = stream.readInt32();
                onRemoveSkill(onRemoveSkill_arg1);
                break;

            case 22:
                ITEM_INFO_LIST onReqItemList_arg1 = ((DATATYPE_ITEM_INFO_LIST)method.args[0]).createFromStreamEx(stream);
                ITEM_INFO_LIST onReqItemList_arg2 = ((DATATYPE_ITEM_INFO_LIST)method.args[1]).createFromStreamEx(stream);
                onReqItemList(onReqItemList_arg1, onReqItemList_arg2);
                break;

            case 23:
                ITEM_INFO pickUp_re_arg1 = ((DATATYPE_ITEM_INFO)method.args[0]).createFromStreamEx(stream);
                pickUp_re(pickUp_re_arg1);
                break;

            case 35:
                Int32 recvDamage_arg1 = stream.readInt32();
                Int32 recvDamage_arg2 = stream.readInt32();
                Int32 recvDamage_arg3 = stream.readInt32();
                Int32 recvDamage_arg4 = stream.readInt32();
                recvDamage(recvDamage_arg1, recvDamage_arg2, recvDamage_arg3, recvDamage_arg4);
                break;

            default:
                break;
            }
            ;
        }
Exemplo n.º 6
0
 public abstract void onReqItemList(ITEM_INFO_LIST arg1, ITEM_INFO_LIST arg2);
Exemplo n.º 7
0
        public override void callPropertysSetMethods()
        {
            ScriptModule sm = EntityDef.moduledefs["Avatar"];
            Dictionary <UInt16, Property> pdatas = sm.idpropertys;

            Int32    oldval_HP = HP;
            Property prop_HP   = pdatas[4];

            if (prop_HP.isBase())
            {
                if (inited && !inWorld)
                {
                    onHPChanged(oldval_HP);
                }
            }
            else
            {
                if (inWorld)
                {
                    if (prop_HP.isOwnerOnly() && !isPlayer())
                    {
                    }
                    else
                    {
                        onHPChanged(oldval_HP);
                    }
                }
            }

            Int32    oldval_HP_Max = HP_Max;
            Property prop_HP_Max   = pdatas[5];

            if (prop_HP_Max.isBase())
            {
                if (inited && !inWorld)
                {
                    onHP_MaxChanged(oldval_HP_Max);
                }
            }
            else
            {
                if (inWorld)
                {
                    if (prop_HP_Max.isOwnerOnly() && !isPlayer())
                    {
                    }
                    else
                    {
                        onHP_MaxChanged(oldval_HP_Max);
                    }
                }
            }

            Int32    oldval_MP = MP;
            Property prop_MP   = pdatas[6];

            if (prop_MP.isBase())
            {
                if (inited && !inWorld)
                {
                    onMPChanged(oldval_MP);
                }
            }
            else
            {
                if (inWorld)
                {
                    if (prop_MP.isOwnerOnly() && !isPlayer())
                    {
                    }
                    else
                    {
                        onMPChanged(oldval_MP);
                    }
                }
            }

            Int32    oldval_MP_Max = MP_Max;
            Property prop_MP_Max   = pdatas[7];

            if (prop_MP_Max.isBase())
            {
                if (inited && !inWorld)
                {
                    onMP_MaxChanged(oldval_MP_Max);
                }
            }
            else
            {
                if (inWorld)
                {
                    if (prop_MP_Max.isOwnerOnly() && !isPlayer())
                    {
                    }
                    else
                    {
                        onMP_MaxChanged(oldval_MP_Max);
                    }
                }
            }

            Int32    oldval_attack_Max = attack_Max;
            Property prop_attack_Max   = pdatas[8];

            if (prop_attack_Max.isBase())
            {
                if (inited && !inWorld)
                {
                    onAttack_MaxChanged(oldval_attack_Max);
                }
            }
            else
            {
                if (inWorld)
                {
                    if (prop_attack_Max.isOwnerOnly() && !isPlayer())
                    {
                    }
                    else
                    {
                        onAttack_MaxChanged(oldval_attack_Max);
                    }
                }
            }

            Int32    oldval_attack_Min = attack_Min;
            Property prop_attack_Min   = pdatas[9];

            if (prop_attack_Min.isBase())
            {
                if (inited && !inWorld)
                {
                    onAttack_MinChanged(oldval_attack_Min);
                }
            }
            else
            {
                if (inWorld)
                {
                    if (prop_attack_Min.isOwnerOnly() && !isPlayer())
                    {
                    }
                    else
                    {
                        onAttack_MinChanged(oldval_attack_Min);
                    }
                }
            }

            Int32    oldval_defence = defence;
            Property prop_defence   = pdatas[10];

            if (prop_defence.isBase())
            {
                if (inited && !inWorld)
                {
                    onDefenceChanged(oldval_defence);
                }
            }
            else
            {
                if (inWorld)
                {
                    if (prop_defence.isOwnerOnly() && !isPlayer())
                    {
                    }
                    else
                    {
                        onDefenceChanged(oldval_defence);
                    }
                }
            }

            Int32    oldval_dexterity = dexterity;
            Property prop_dexterity   = pdatas[11];

            if (prop_dexterity.isBase())
            {
                if (inited && !inWorld)
                {
                    onDexterityChanged(oldval_dexterity);
                }
            }
            else
            {
                if (inWorld)
                {
                    if (prop_dexterity.isOwnerOnly() && !isPlayer())
                    {
                    }
                    else
                    {
                        onDexterityChanged(oldval_dexterity);
                    }
                }
            }

            Vector3  oldval_direction = direction;
            Property prop_direction   = pdatas[2];

            if (prop_direction.isBase())
            {
                if (inited && !inWorld)
                {
                    onDirectionChanged(oldval_direction);
                }
            }
            else
            {
                if (inWorld)
                {
                    if (prop_direction.isOwnerOnly() && !isPlayer())
                    {
                    }
                    else
                    {
                        onDirectionChanged(oldval_direction);
                    }
                }
            }

            Int32    oldval_dodge = dodge;
            Property prop_dodge   = pdatas[12];

            if (prop_dodge.isBase())
            {
                if (inited && !inWorld)
                {
                    onDodgeChanged(oldval_dodge);
                }
            }
            else
            {
                if (inWorld)
                {
                    if (prop_dodge.isOwnerOnly() && !isPlayer())
                    {
                    }
                    else
                    {
                        onDodgeChanged(oldval_dodge);
                    }
                }
            }

            ITEM_INFO_LIST oldval_equipItemList = equipItemList;
            Property       prop_equipItemList   = pdatas[13];

            if (prop_equipItemList.isBase())
            {
                if (inited && !inWorld)
                {
                    onEquipItemListChanged(oldval_equipItemList);
                }
            }
            else
            {
                if (inWorld)
                {
                    if (prop_equipItemList.isOwnerOnly() && !isPlayer())
                    {
                    }
                    else
                    {
                        onEquipItemListChanged(oldval_equipItemList);
                    }
                }
            }

            Int32    oldval_equipWeapon = equipWeapon;
            Property prop_equipWeapon   = pdatas[14];

            if (prop_equipWeapon.isBase())
            {
                if (inited && !inWorld)
                {
                    onEquipWeaponChanged(oldval_equipWeapon);
                }
            }
            else
            {
                if (inWorld)
                {
                    if (prop_equipWeapon.isOwnerOnly() && !isPlayer())
                    {
                    }
                    else
                    {
                        onEquipWeaponChanged(oldval_equipWeapon);
                    }
                }
            }

            UInt64   oldval_exp = exp;
            Property prop_exp   = pdatas[15];

            if (prop_exp.isBase())
            {
                if (inited && !inWorld)
                {
                    onExpChanged(oldval_exp);
                }
            }
            else
            {
                if (inWorld)
                {
                    if (prop_exp.isOwnerOnly() && !isPlayer())
                    {
                    }
                    else
                    {
                        onExpChanged(oldval_exp);
                    }
                }
            }

            Int32    oldval_forbids = forbids;
            Property prop_forbids   = pdatas[16];

            if (prop_forbids.isBase())
            {
                if (inited && !inWorld)
                {
                    onForbidsChanged(oldval_forbids);
                }
            }
            else
            {
                if (inWorld)
                {
                    if (prop_forbids.isOwnerOnly() && !isPlayer())
                    {
                    }
                    else
                    {
                        onForbidsChanged(oldval_forbids);
                    }
                }
            }

            ITEM_INFO_LIST oldval_itemList = itemList;
            Property       prop_itemList   = pdatas[17];

            if (prop_itemList.isBase())
            {
                if (inited && !inWorld)
                {
                    onItemListChanged(oldval_itemList);
                }
            }
            else
            {
                if (inWorld)
                {
                    if (prop_itemList.isOwnerOnly() && !isPlayer())
                    {
                    }
                    else
                    {
                        onItemListChanged(oldval_itemList);
                    }
                }
            }

            UInt16   oldval_level = level;
            Property prop_level   = pdatas[18];

            if (prop_level.isBase())
            {
                if (inited && !inWorld)
                {
                    onLevelChanged(oldval_level);
                }
            }
            else
            {
                if (inWorld)
                {
                    if (prop_level.isOwnerOnly() && !isPlayer())
                    {
                    }
                    else
                    {
                        onLevelChanged(oldval_level);
                    }
                }
            }

            UInt32   oldval_modelID = modelID;
            Property prop_modelID   = pdatas[19];

            if (prop_modelID.isBase())
            {
                if (inited && !inWorld)
                {
                    onModelIDChanged(oldval_modelID);
                }
            }
            else
            {
                if (inWorld)
                {
                    if (prop_modelID.isOwnerOnly() && !isPlayer())
                    {
                    }
                    else
                    {
                        onModelIDChanged(oldval_modelID);
                    }
                }
            }

            Byte     oldval_modelScale = modelScale;
            Property prop_modelScale   = pdatas[20];

            if (prop_modelScale.isBase())
            {
                if (inited && !inWorld)
                {
                    onModelScaleChanged(oldval_modelScale);
                }
            }
            else
            {
                if (inWorld)
                {
                    if (prop_modelScale.isOwnerOnly() && !isPlayer())
                    {
                    }
                    else
                    {
                        onModelScaleChanged(oldval_modelScale);
                    }
                }
            }

            UInt64   oldval_money = money;
            Property prop_money   = pdatas[21];

            if (prop_money.isBase())
            {
                if (inited && !inWorld)
                {
                    onMoneyChanged(oldval_money);
                }
            }
            else
            {
                if (inWorld)
                {
                    if (prop_money.isOwnerOnly() && !isPlayer())
                    {
                    }
                    else
                    {
                        onMoneyChanged(oldval_money);
                    }
                }
            }

            Byte     oldval_moveSpeed = moveSpeed;
            Property prop_moveSpeed   = pdatas[22];

            if (prop_moveSpeed.isBase())
            {
                if (inited && !inWorld)
                {
                    onMoveSpeedChanged(oldval_moveSpeed);
                }
            }
            else
            {
                if (inWorld)
                {
                    if (prop_moveSpeed.isOwnerOnly() && !isPlayer())
                    {
                    }
                    else
                    {
                        onMoveSpeedChanged(oldval_moveSpeed);
                    }
                }
            }

            string   oldval_name = name;
            Property prop_name   = pdatas[23];

            if (prop_name.isBase())
            {
                if (inited && !inWorld)
                {
                    onNameChanged(oldval_name);
                }
            }
            else
            {
                if (inWorld)
                {
                    if (prop_name.isOwnerOnly() && !isPlayer())
                    {
                    }
                    else
                    {
                        onNameChanged(oldval_name);
                    }
                }
            }

            Vector3  oldval_position = position;
            Property prop_position   = pdatas[1];

            if (prop_position.isBase())
            {
                if (inited && !inWorld)
                {
                    onPositionChanged(oldval_position);
                }
            }
            else
            {
                if (inWorld)
                {
                    if (prop_position.isOwnerOnly() && !isPlayer())
                    {
                    }
                    else
                    {
                        onPositionChanged(oldval_position);
                    }
                }
            }

            Int32    oldval_rating = rating;
            Property prop_rating   = pdatas[24];

            if (prop_rating.isBase())
            {
                if (inited && !inWorld)
                {
                    onRatingChanged(oldval_rating);
                }
            }
            else
            {
                if (inWorld)
                {
                    if (prop_rating.isOwnerOnly() && !isPlayer())
                    {
                    }
                    else
                    {
                        onRatingChanged(oldval_rating);
                    }
                }
            }

            Byte     oldval_roleTypeCell = roleTypeCell;
            Property prop_roleTypeCell   = pdatas[25];

            if (prop_roleTypeCell.isBase())
            {
                if (inited && !inWorld)
                {
                    onRoleTypeCellChanged(oldval_roleTypeCell);
                }
            }
            else
            {
                if (inWorld)
                {
                    if (prop_roleTypeCell.isOwnerOnly() && !isPlayer())
                    {
                    }
                    else
                    {
                        onRoleTypeCellChanged(oldval_roleTypeCell);
                    }
                }
            }

            UInt32   oldval_spaceUType = spaceUType;
            Property prop_spaceUType   = pdatas[26];

            if (prop_spaceUType.isBase())
            {
                if (inited && !inWorld)
                {
                    onSpaceUTypeChanged(oldval_spaceUType);
                }
            }
            else
            {
                if (inWorld)
                {
                    if (prop_spaceUType.isOwnerOnly() && !isPlayer())
                    {
                    }
                    else
                    {
                        onSpaceUTypeChanged(oldval_spaceUType);
                    }
                }
            }

            Int32    oldval_stamina = stamina;
            Property prop_stamina   = pdatas[27];

            if (prop_stamina.isBase())
            {
                if (inited && !inWorld)
                {
                    onStaminaChanged(oldval_stamina);
                }
            }
            else
            {
                if (inWorld)
                {
                    if (prop_stamina.isOwnerOnly() && !isPlayer())
                    {
                    }
                    else
                    {
                        onStaminaChanged(oldval_stamina);
                    }
                }
            }

            SByte    oldval_state = state;
            Property prop_state   = pdatas[28];

            if (prop_state.isBase())
            {
                if (inited && !inWorld)
                {
                    onStateChanged(oldval_state);
                }
            }
            else
            {
                if (inWorld)
                {
                    if (prop_state.isOwnerOnly() && !isPlayer())
                    {
                    }
                    else
                    {
                        onStateChanged(oldval_state);
                    }
                }
            }

            Int32    oldval_strength = strength;
            Property prop_strength   = pdatas[29];

            if (prop_strength.isBase())
            {
                if (inited && !inWorld)
                {
                    onStrengthChanged(oldval_strength);
                }
            }
            else
            {
                if (inWorld)
                {
                    if (prop_strength.isOwnerOnly() && !isPlayer())
                    {
                    }
                    else
                    {
                        onStrengthChanged(oldval_strength);
                    }
                }
            }

            Byte     oldval_subState = subState;
            Property prop_subState   = pdatas[30];

            if (prop_subState.isBase())
            {
                if (inited && !inWorld)
                {
                    onSubStateChanged(oldval_subState);
                }
            }
            else
            {
                if (inWorld)
                {
                    if (prop_subState.isOwnerOnly() && !isPlayer())
                    {
                    }
                    else
                    {
                        onSubStateChanged(oldval_subState);
                    }
                }
            }

            UInt32   oldval_uid = uid;
            Property prop_uid   = pdatas[31];

            if (prop_uid.isBase())
            {
                if (inited && !inWorld)
                {
                    onUidChanged(oldval_uid);
                }
            }
            else
            {
                if (inWorld)
                {
                    if (prop_uid.isOwnerOnly() && !isPlayer())
                    {
                    }
                    else
                    {
                        onUidChanged(oldval_uid);
                    }
                }
            }

            UInt32   oldval_utype = utype;
            Property prop_utype   = pdatas[32];

            if (prop_utype.isBase())
            {
                if (inited && !inWorld)
                {
                    onUtypeChanged(oldval_utype);
                }
            }
            else
            {
                if (inWorld)
                {
                    if (prop_utype.isOwnerOnly() && !isPlayer())
                    {
                    }
                    else
                    {
                        onUtypeChanged(oldval_utype);
                    }
                }
            }
        }
Exemplo n.º 8
0
 public void addToStreamEx(Bundle stream, ITEM_INFO_LIST v)
 {
     values_DataType.addToStreamEx(stream, v.values);
 }