Event ID Marshaller [Event/Message ID Standard]

[maritnmine]

There will be a release tomorrow where we're gonna show you guys some code :)

- Martin

[Dissi]

Small update:
We will not be releasing it today.
There aren't enough object yet on the object bench to get a good head-start. It is, however, functional now

Update:
Added if-else to the packet builder
Added less than, bigger than, etc to the statements
It's now possible to actually integrate this into the server. in other words, it now generates Event structures.
All event structures are generated at startup of the marshaller, so no slow sending, its as fast as you would code your own packets

Pictures of progress:

Spoiler:

[The General]

This looks promising. Really nice development :)

[TheOleg]

Small update:
We will not be releasing it today.
There aren't enough object yet on the object bench to get a good head-start. It is, however, functional now

Update:
Added if-else to the packet builder
Added less than, bigger than, etc to the statements
It's now possible to actually integrate this into the server. in other words, it now generates Event structures.
All event structures are generated at startup of the marshaller, so no slow sending, its as fast as you would code your own packets

Good work, but if all emulators will use same packets structures and realization, won't they will be totally same?

[Zak©]

Good work, but if all emulators will use same packets structures and realization, won't they will be totally same?

All emulators are generic in packets because that's how Habbo works.

What makes emulators different is the code (The way it is programmed and such)

Maybe unique features such as commands, but all emulators are the same when it comes to packets because we are replicating Habbo, not developing our own game.

[Dissi]

All emulators are generic in packets because that's how Habbo works.

What makes emulators different is the code (The way it is programmed and such)

Maybe unique features such as commands, but all emulators are the same when it comes to packets because we are replicating Habbo, not developing our own game.

Exactly this.
There are currently a small set of problems when updating to a new version:

• event ID's are shuffled
• Packet structures are adapted

We're trying to overcome this problem by making an easy-to-use interface which will take away these difficulties.
The biggest problem im currently facing is covering all kinds of object the server needs to send through the client, from friendlist to navigator categories. It's coming along fine and is updateable, but if i forget one crucial part it might not even be able to send catalog purchases if you wanted to use this library

[dominic]

Why not try to do an auto-header updater?

[Dissi]

Why not try to do an auto-header updater?

please elaborate on what you mean with this

[TheOleg]

please elaborate on what you mean with this

There is couple ways, one of them:
Since packets are being call always in same classes(just different names) you can make some kind of main classes deobfuscator and get packet's new class names.
Example:

Game2CheckGameDirectoryStatusMessageComposer

is always called in

public function initGameDirectoryConnection():void{            this.send(new Game2CheckGameDirectoryStatusMessageComposer());
        }

which is always called in

private function _-1Vr(k:_-3kL):void{
            switch (_arg1._-5z)
            {
                case HabboToolbarIconEnum.GAMES:
                    if (this.gameCenterEnabled)
                    {
                        this.showGameCenterByGameName("showGameCenter.toolBarClick", this._-19Z);
                    }
                    else
                    {
                        this.initGameDirectoryConnection();
                        this.send(new _-4Vp());
                    };
                    return;
                case HabboToolbarIconEnum.RECEPTION:
                    this._-06S();
                    return;
            };
        }

So, app decompiles swf via RABCDASM, finds

"showGameCenter.toolBarClick"

reads else part and then initGameDirectoryConnection. Now you have Game2CheckGameDirectoryStatusMessageComposer and _-4Vp names.
It will take a lot of code, but it can't be patched

[Dissi]

So you mean,

First find AND parse this bit:

   public class HabboMessages implements _-3hW 
    {


        private static const _-lq:Map = new _-2R1();
        private static const _-3lD:Map = new _-2R1();


        {
            _-3lD[1023] = _-1G2;
            _-3lD[1025] = _-1KI;
            _-3lD[1032] = _-2tP;
            _-3lD[1033] = _-0Zi;
            _-3lD[1035] = _-39p;
            _-3lD[1047] = _-4W6;

etc....
            _-lq[1010] = Game2AccountGameStatusMessageEvent;
            _-lq[103] = _-Zj;
            _-lq[1064] = _-1cj;
            _-lq[1112] = _-iK;
            _-lq[1113] = _-1FM;
            _-lq[1118] = _-1-2;
            _-lq[1125] = _-4KH;

etc...
        public function get events():Map
        {
            return (_-lq);
        }
        public function get _-4kT():Map
        {
            return (_-3lD);
        }

And than find related classes:
[somenumber] = _-1G2

than I find _-1G2, map that to some named string we got , for example "MessengerInitEvent"

That can be done, but i will require assistance with this, as it's very hard to do this on your own.
Also, loading 10 MB of text into the app and searching it might get REALLY slow if more than 400 packets need to be mapped
example:

Load script from file: loading 10 mb, thats fast
FULL match operation on 10 MB string x 400 , slow
Some logic to check if X is some class, could be fast, might not be fast, don't know for sure about that

I will need a lot of time to analyze all these classes, and if one off-set changes that specific packet will fail to map to the new ID, so it's not as easy as it sounds.

I think it's CURRENTLY better to just map from x/y manually. If lots of people help with this it will be quite fast using this program, as the ID's can be stored online in some central database

Regards,
Dissi

[TheOleg]

text

Nah,
1. Find SnowWarEngine.IncomingMessages
2. Parse first class
3. done

public function IncomingMessages(k:SnowWarEngine){
            this._-1JD = _arg1;
            var k:_-4mB = this._-1JD.communication;
            k.addHabboConnectionMessageEvent(new _-4z4(this._-46x));
            k.addHabboConnectionMessageEvent(new _-OV(this._-4ga));
            k.addHabboConnectionMessageEvent(new Game2GameDirectoryStatusMessageEvent(this._-031));
            k.addHabboConnectionMessageEvent(new Game2GameCreatedMessageEvent(this._-F5));
            k.addHabboConnectionMessageEvent(new Game2GameStartedMessageEvent(this._-1iE));
            k.addHabboConnectionMessageEvent(new Game2GameCancelledMessageEvent(this._-5Al));
            k.addHabboConnectionMessageEvent(new Game2InArenaQueueMessageEvent(this._-28W));
            k.addHabboConnectionMessageEvent(new Game2UserJoinedGameMessageEvent(this._-29u));
            k.addHabboConnectionMessageEvent(new Game2UserLeftGameMessageEvent(this._-44n));
            k.addHabboConnectionMessageEvent(new Game2StartCounterMessageEvent(this._-2h5));
            k.addHabboConnectionMessageEvent(new Game2StopCounterMessageEvent(this._-0Ul));
            k.addHabboConnectionMessageEvent(new Game2GameLongDataMessageEvent(this._-0Kt));
            k.addHabboConnectionMessageEvent(new Game2AccountGameStatusMessageEvent(this._-1wM));
            k.addHabboConnectionMessageEvent(new Game2JoiningGameFailedMessageEvent(this._-3a0));
            k.addHabboConnectionMessageEvent(new Game2StartingGameFailedMessageEvent(this._-0xH));
            k.addHabboConnectionMessageEvent(new Game2UserBlockedMessageEvent(this._-1Fd));
            k.addHabboConnectionMessageEvent(new Game2EnterArenaMessageEvent(this._-0QD));
            k.addHabboConnectionMessageEvent(new Game2ArenaEnteredMessageEvent(this._-1Mn));
            k.addHabboConnectionMessageEvent(new Game2StageLoadMessageEvent(this._-0k3));
            k.addHabboConnectionMessageEvent(new Game2StageStillLoadingMessageEvent(this._-3fp));
            k.addHabboConnectionMessageEvent(new Game2StageStartingMessageEvent(this._-4OZ));
            k.addHabboConnectionMessageEvent(new Game2StageRunningMessageEvent(this._-20J));
            k.addHabboConnectionMessageEvent(new Game2StageEndingMessageEvent(this._-0eR));
            k.addHabboConnectionMessageEvent(new Game2GameEndingMessageEvent(this._-0d2));
            k.addHabboConnectionMessageEvent(new Game2PlayerExitedGameArenaMessageEvent(this._-aU));
            k.addHabboConnectionMessageEvent(new Game2GameRejoinMessageEvent(this._-3d0));
            k.addHabboConnectionMessageEvent(new Game2PlayerRematchesMessageEvent(this._-2Gi));
            k.addHabboConnectionMessageEvent(new Game2GameChatFromPlayerMessageEvent(this._-0wx));
            k.addHabboConnectionMessageEvent(new Game2EnterArenaFailedMessageEvent(this._-2jQ));
            k.addHabboConnectionMessageEvent(new Game2FullGameStatusMessageEvent(this._-nU));
            k.addHabboConnectionMessageEvent(new Game2GameStatusMessageEvent(this._-0p2));
            k.addHabboConnectionMessageEvent(new Game2TotalLeaderboardEvent(this._-0));
            k.addHabboConnectionMessageEvent(new Game2FriendsLeaderboardEvent(this._-3Nm));
            k.addHabboConnectionMessageEvent(new Game2WeeklyLeaderboardEvent(this._-1-n));
            k.addHabboConnectionMessageEvent(new Game2WeeklyFriendsLeaderboardEvent(this._-Qv));
        }

Then find RoomEngine.IncomingMessages, etc.
This way you can find all server->client messages.
Client->server will be quite harder, but similar strategy.

[Dissi]

If you can come up with a proof of concept I will gladly incorporate this into the project

[Dissi]

Project update:

Added support for calls to objects on objects in a loop (In other words, when you got a loop over roomuser, and you request his/her group, you can now get it)

Was a big undertaking but it works now ^^

Spoiler:

[Dissi]

Added more data to the object bench.
We're going to test the calls of the speed now.
The calls to get the data from the interface are about 1.3 times slower than direct calls to an object, but the amount of overhead is greatly reduced. (The writing to the Event is slower)

It takes about 1,7 ticks to make 1 call using the interface and it takes about 1,3 ticks for a direct call (as comparison)

Spoiler:

[Leon]

Any news?