[SOURCE] Real NostaleSDK - Other Information / Sources

[atom0s]

Hello everyone, this is for those that wish to develop bots and other hacks for Nostale but skids that want to act like they know everything will not share stuff.

This thread will contain various information for Nostale for those that wish to make all the similar crap you see on this forum that is paid for. I will not go into detail on how to piece things together to make that 'ultimate bot' that you ever so want, but instead here is the building blocks for what is needed.

I've quit playing Nostale and do not care what people do to the game in terms of killing it with exploits/bots or so on. Want to ruin the game, go for it.

This post contains a real SDK, not some garbage that prints out two functions.

Other posts in this thread will contain more info as well.

/**
 * NostaleSDK - Copyright (c) 2016 atom0s []
 *
 * This work is licensed under the Creative Commons Attribution-NonCommercial-NoDerivatives 4.0 International License.
 * To view a copy of this license, visit http://creativecommons.org/licenses/by-nc-nd/4.0/ or send a letter to
 * Creative Commons, PO Box 1866, Mountain View, CA 94042, USA.
 *
 * By using NostaleSDK, you agree to the above license and its terms.
 *
 *      Attribution - You must give appropriate credit, provide a link to the license and indicate if changes were
 *                    made. You must do so in any reasonable manner, but not in any way that suggests the licensor
 *                    endorses you or your use.
 *
 *   Non-Commercial - You may not use the material (NostaleSDK) for commercial purposes.
 *
 *   No-Derivatives - If you remix, transform, or build upon the material (NostaleSDK), you may not distribute the
 *                    modified material. You are, however, allowed to submit the modified works back to the original
 *                    NostaleSDK project in attempt to have it added to the original project.
 *
 * You may not apply legal terms or technological measures that legally restrict others
 * from doing anything the license permits.
 *
 * No warranties are given.
 */

#ifndef __NOSTALESDK_H_INCLUDED__
#define __NOSTALESDK_H_INCLUDED__

#if defined (_MSC_VER) && (_MSC_VER >= 1020)
#pragma once
#endif

#include <Windows.h>
#include <algorithm>
#include <functional>
#include <map>
#include <string>

/**
 * TMapObjBase
 *
 * Structure definition of a base map object. All entities inherit from this.
 */
struct TMapObjBase
{
    uint32_t        VTablePointer;              // TMapObjBase VTable Pointer
    uint8_t         ObjectType;                 // The object type id. [0x01 = Player, 0x02 = Monster, 0x03 = NPC, 0x04 = Item]
    uint8_t         Unknown0000[3];             // Unknown (unused; padding)
    uint32_t        Id;                         // The objects id.
    uint16_t        MapX;                       // The objects map x coord.
    uint16_t        MapY;                       // The objects map y coord.
    uint32_t        SyncCount;                  // Must stay in sync with another pointer or you get kicked from game. (Movement syncing?)
    uint32_t        Unknown0001;                // Unknown (Seems like a string based on what reads from it.)
    uint32_t        Unknown0002;                // Unknown (Seems like a string based on what reads from it.)
    uint32_t        Unknown0003;                // Unknown (Usually -1 0xFFFFFFFF)
    uint32_t        Unknown0004;                // Unknown (Usually -1 0xFFFFFFFF)
    uint32_t        Unknown0005;                // Pointer to TSmallIntList object. (Used with the last two unknowns.)
    uint32_t        Unknown0006;                // Pointer to TSmallIntList object. (Used with the last two unknowns.)
    uint32_t        ColorMask;                  // BGRA color of the object. Typically 0xFFFFFFFF to allow normal color of the object.
    uint8_t         ColorMaskOpacity;           // 0-255 opacity that is used for the above color mask. Setting this will set the alpha channel in the above color.
    uint8_t         Unknown0007;                // Unknown (unused; padding)
    uint8_t         Unknown0008;                // Unknown (unused; padding)
    uint8_t         Unknown0009;                // Unknown (unused; padding)
    float           Unknown0010;                // Unknown (Changes rapidly while moving.)
    float           Unknown0011;                // Unknown (Usually 1, if changed it is the max value of the above unknown.)
    uint8_t         Unknown0012;                // Unknown (Usually 1, seems to be some sort of 'loaded' flag.)
    uint8_t         Unknown0013;                // Unknown (unused; padding)
    uint8_t         Unknown0014;                // Unknown (unused; padding)
    uint8_t         Unknown0015;                // Unknown (unused; padding)
    uint32_t        Unknown0016;                // Pointer to TMapObjTextureCache (Affects the objects model if edited.)
    float           ModelSize;                  // The size of the objects model.
    float           HitboxRadius;               // The radius of the objects hitbox from its center. (0 = max radius, higher number makes radius smaller and smaller.)
    float           Unknown0018;                // Unknown (Usually 1, only set when spawning/zoning.)
    float           Unknown0019;                // Unknown (Usually 1, only set when spawning/zoning.)
    float           X;                          // The objects X coord. (Where the model is rendered at.)
    float           Z;                          // The objects Z coord. (Where the model is rendered at.)
    float           Y;                          // The objects Y coord. (Where the model is rendered at.)
    float           X2;                         // The objects X coord. (Where the game assumes you are doing things from.)
    float           Z2;                         // The objects Z coord. (Where the game assumes you are doing things from.)
    float           Y2;                         // The objects Y coord. (Where the game assumes you are doing things from.)
    float           XAxisOffset;                // The objects offset on the X coord from 'center' screen. (Visual only, if you move it will reset to normal.)
    float           ZAxisOffset;                // The objects offset on the Z coord from 'center' screen. (Visual only, if you move it will reset to normal.)
    float           YAxisOffset;                // The objects offset on the Y coord from 'center' screen. (Visual only, if you move it will reset to normal.)
    float           XAxisOffset2;               // The objects offset on the X coord from 'center' screen. (If set this will be used constantly.)
    float           ZAxisOffset2;               // The objects offset on the Z coord from 'center' screen. (If set this will be used constantly.)
    float           YAxisOffset2;               // The objects offset on the Y coord from 'center' screen. (If set this will be used constantly.)
    uint32_t        Unknown0020;                // Relates to sync count. Set when you load/zone. Used to calculate your frame.
    float           Unknown0021;                // Relates to the models size/pitch?
    uint8_t         Unknown0022;                // Unknown (Used in the walk packet, 'walk x y ? speed', flips between 0 and 1.)
    uint8_t         Unknown0023;                // Unknown (unused; padding)
    uint8_t         Unknown0024;                // Unknown (unused; padding)
    uint8_t         Unknown0025;                // Unknown (unused; padding)
    uint32_t        Unknown0028;                // Unknown (set while zoning, usually -1)
    uint8_t         Unknown0029;                // Flag the enables reading of the Unknown0033 value. 
    uint8_t         Unknown0030;                // Unknown (unused; padding)
    uint8_t         Unknown0031;                // Unknown (unused; padding)
    uint8_t         Unknown0032;                // Unknown (unused; padding)
    uint32_t        Unknown0033;                // Offset 0x98
};

/**
 * TMapMoveObjBase
 *
 * Structure definition of a base movable map object.
 */
struct TMapMoveObjBase : TMapObjBase
{
    uint8_t         Direction;                  // The objects current facing direction. (0 = North, 1 = East, 2 = South, 3 = West, etc.)
    uint8_t         Status;                     // The objects current status. (0 = Normal, 1 = Resting, 8 = Running, 9 = Yawning (Animation))
    uint8_t         Speed;                      // The objects current speed. (Editing randomly causes disconnects.)
    uint8_t         BoundsCheck;                // The objects bounds checking status. (Normally 1, if set otherwise will let you attempt to walk through walls.)
    uint8_t         AttackedFlag;               // Toggles between 0 and 1 while being hit by something.
    uint8_t         Unknown0031;                // Unknown (unused; padding)
    uint8_t         Unknown0032;                // Unknown (unused; padding)
    uint8_t         Unknown0033;                // Unknown (unused; padding)
    uint32_t        AnimationCounter;           // The objects animation counter. (Set to 1 and you force-yawn.)
    float           AnimationStepCounter1;      // The objects animation step counter. (If frozen, you will teleport around instead of walking.)
    float           AnimationStepCounter2;      // The objects animation step counter. (If frozen and set to a high value, you will teleport instead of walk.)
    uint32_t        MovementDirectionList;      // Pointer to TByteList object holding the movement directions of the players current movement.
    uint32_t        MovementFrequency;          // The objects movement frequency limiter. (Freeze to 0 to speed hack in a 'legit' manner. You send valid walk walk packets but much faster.)
    uint32_t        Unknown0035;                // Pointer to TMapObjFxList object. (Holds a TNTFairy entry.)
    uint8_t         HealthPercent;              // The objects health percent. (Shown on the bar above their head.)
    uint8_t         ManaPercent;                // The objects mana percent. (Shown on the bar above their head.)
    uint8_t         Unknown0036;                // Unknown (unused; padding)
    uint8_t         Unknown0037;                // Unknown (unused; padding)
    uint32_t        Unknown0038;                // Unknown (unused)
    uint8_t         FamilyNameColor;            // The objects family name color.
    uint8_t         Unknown0039[3];             // Unknown (unused; padding)
    uint32_t        Unknown0040;                // Pointer to TSmallIntList object.
    uint32_t        Unknown0041;                // Pointer to TSmallIntList object.
    uint32_t        LastWaitAnimationTick;      // The last tick the object did a wait animation. (Stretch/yawn, foot tap etc.)
    uint16_t        Unknown0042;                // Unknown (Setting to 1 makes the scene half-disappear.)
    uint16_t        Unknown0043;                // Unknown (Used with the above unknown in some manner.)
    uint32_t        Unknown0044;                // Unknown (unused)
    uint32_t        Unknown0045;                // Unknown (Seems to always be -1)
    uint32_t        Unknown0046;                // Unknown (Seems to only be set when zoning.)
    uint32_t        Unknown0047;                // Unknown (Seems to only be set when zoning.)
    uint32_t        Unknown0048;                // Unknown (Seems to only be set when zoning.)
    uint32_t        Unknown0049;                // Unknown (Seems to only be set when zoning.)
    uint32_t        Unknown0050;                // Unknown (Seems to only be set when zoning.)
    uint32_t        Unknown0051;                // Unknown (Seems to only be set when zoning.)
    uint32_t        Unknown0052;                // Unknown (Compared against 0, if not 0 will lock you from moving.)
    uint8_t         Unknown0053;                // Unknown (unused)
    uint8_t         Unknown0054;                // The objects locked animation. (Sitting, knockback, death, etc.)
    uint8_t         Unknown0055;                // An offset used for a float lookup.
    uint8_t         Unknown0056;                // Unknown (unused)
    float           Unknown0057;                // Unknown (Timer that increments while locked animation is active.)
    float           Unknown0058;                // Unknown (Timer that increments while locked animation is active.)
    uint32_t        Unknown0059;                // Unknown (Seems to only be set when zoning.)
    uint32_t        Unknown0060;                // Unknown (Seems to only be set when zoning.)
    uint32_t        Unknown0061;                // Unknown (Seems to only be set when zoning.)
    uint8_t         Unknown0062;                // Unknown (Sets between 0 and 1 based on the objects status. If Status != 4, set to 1, otherwise 0.)
    uint8_t         Unknown0063;                // Unknown (unused; padding)
    uint8_t         Unknown0064;                // Unknown (unused; padding)
    uint8_t         Unknown0065;                // Unknown (unused; padding)
    uint32_t        Unknown0066;                // Unknown (Seems to only be set when zoning.)
    float           Unknown0067;                // Unknown (Seems to only be set when zoning.)
    uint8_t         Unknown0068;                // Flag used while object is animated.
    uint8_t         Unknown0069;                // Flag used while object is animated.
    uint8_t         Unknown0070;                // Unknown (unused; padding)
    uint8_t         Unknown0071;                // Unknown (unused; padding)
    uint32_t        Unknown0072;                // Unknown (Indexed array of pointers.)
    uint32_t        Unknown0073;                // Unknown (Indexed array of pointers.)
    uint32_t        Unknown0074;                // Unknown (Indexed array of pointers.)
    uint32_t        Unknown0075;                // Unknown (Indexed array of pointers.)
    uint32_t        Unknown0076;                // Unknown (Indexed array of pointers.)
    uint32_t        Unknown0077;                // Unknown (Indexed array of pointers.)
    uint32_t        Unknown0078;                // Unknown (Indexed array of pointers.)
    uint32_t        Unknown0079;                // Unknown (Indexed array of pointers.)
    uint16_t        Level;                      // The objects level.
    uint16_t        WingType;                   // The objects wing type shown when targeting them. (Based on their good/evil status?)
    uint16_t        Unknown0081;                // Unknown (Seems to always be 0 for players. Has a value for objects players spawn like mailboxes, mini-house telepots, etc.)
    uint8_t         ShadowVisible;              // -1 if hidden, anything else is visible.
    uint8_t         XSelectionVisible;          // Determines if the objects 'X' selection mark under it is visible.
    uint8_t         SelectionRingColor;         // The ring around the objects feet on the ground. (0 = Orange, 1 = Green)
    uint8_t         Unknown0083;                // Unknown (Seems to always be 0.)
    uint8_t         Unknown0084;                // Unknown (Seems to always be -1.)
    uint8_t         Unknown0085;                // Unknown (Seems to always be 0.)
    uint32_t        OwnerId;                    // The object id that owns this object. (Used for pets.)
    uint8_t         AboveHeadShopBackground;    // -1 if disabled, otherwise displays the shop background over the objects head.
    uint8_t         OpenWindowId;               // The window id to open when the objects shop is used (or dialog is opened). (This does not match normal window ids. It has some sort of offset.)
    uint16_t        Unknown0087;                // Unknown (unused; padding)
    uint32_t        AboveHeadShopText;          // Pointer to the shops text.
    float           Unknown0088;                // Unknown
    uint32_t        IsInPartyFlag;              // Set to -1 if not in party, 14 if in party.
    uint32_t        FamilyId;                   // The id of the objects family.
    uint32_t        Unknown0091;                // Unknown (Seems to always be -1.)
    uint32_t        Unknown0092;                // Unknown (Seems to always be -1.)
    uint32_t        Unknown0093;                // Unknown (Seems to always be -1.)
    uint32_t        Unknown0094;                // Unknown (Seems to always be -1.)
    uint8_t         Unknown0095;                // Setting this and moving alters the players animation.
    uint8_t         NameVisibleFlag;            // 0x02 when name is hidden. (Can be used to tell if something is invisible.)
    uint8_t         AboveHeadIcon;              // The icon displayed over the players head. (Checkmark, Exclamation, etc.)
    uint8_t         Unknown0096;                // Unknown (unused; padding)
    uint8_t         AutorunHitboxRange;         // The amount of space before the player will stop running to this object when auto-running. (0 means to run right up to the object.)
    uint8_t         Unknown0097;                // Unknown (unused; padding)
    uint8_t         Unknown0098;                // Unknown (unused; padding)
    uint8_t         Unknown0099;                // Unknown (unused; padding)
};

/**
 * TMapPlayerObj
 *
 * Structure definition of a player object.
 */
struct TMapPlayerObj : TMapMoveObjBase
{

    uint16_t        Visuals0000;                // Contains the players current costume id. (Lower end bits hold the sex of the outfit.)
    uint16_t        Unknown0000;                // Unknown (unused)
    uint8_t         IsMounted;                  // Flag that determines if the player is in a mounted costume / state.
    uint8_t         Unknown0001;                // Unknown (unused)
    uint8_t         Unknown0002;                // Unknown (unused)
    uint8_t         Unknown0003;                // Unknown (unused)
    uint32_t        HairColorPointer;           // Pointer to the players hair color. (0xAARRGGBB format.)
    uint32_t        HairColor;                  // The players hair color. (0xAARRGGBB format.) (Updates from the pointer value above.)
    uint32_t        HatColor;                   // The players hat color. (0xAARRGGBB format.)
    uint32_t        FaceMaskColor;              // The players face mask color. (0xAARRGGBB format.)
    uint8_t         Unknown0005;                // Unknown (Flag that is checked against 0.)
    uint8_t         Unknown0006;                // Unknown (unused)
    uint8_t         Unknown0007;                // Unknown (unused)
    uint8_t         Unknown0008;                // Unknown (unused)
    float           GlowEffectDistance;         // The distance a glowing effect pulses from the player. (Such as a weapon on their back.)
    uint8_t         WeaponGlowEffect;           // The players weapon glow effect.
    uint32_t        WeaponGlowColor;            // The players weapon glow color. (0xAARRGGBB format.)
    float           WeaponGlowSize;             // The players weapon glow size.
    uint8_t         WeaponGlowInnerEffect;      // The players weapon glow inner effect.
    uint32_t        Unknown0009;                // Unknown function pointer.
    uint8_t         Unknown0010;                // Unknown (Passed as a parameter to the above unknown function.)
    uint8_t         Unknown0011;                // Unknown (Passed as a parameter to the above unknown function.)
    uint32_t        LastSparkleTick;            // The players last time they sparkled.
    uint16_t        Unknown0012;                // Unknown (Affects the players sparkle effect.)
    uint16_t        Unknown0013;                // Unknown (unused)
    uint8_t         ClassId;                    // The players class id. (0x80 = Adventurer, 0x81 = Swordsman, 0x82 = Archer, 0x83 = Mage)
    uint8_t         JobId;                      // The players job id.
    uint8_t         ShirtStyle;                 // The players shirt style.
    uint8_t         HairStyle;                  // The players hair style.
    uint8_t         HatId;                      // The players hat id.
    uint8_t         FaceMask;                   // The players face mask id.
    uint8_t         Unknown0014;                // Unknown;
    uint8_t         ClassWeapon;                // The players weapon id. (Based on their class.)
    char*           Name;                       // Pointer to the players name.
    uint32_t        Family;                     // Pointer to the players family name and information.
    uint32_t        Fairy;                      // Pointer to the players TNTFairy object.
    uint16_t        NameFlag;                   // Bit array that handles the players name tags. (GM = 0x02)
    uint16_t        Unknown0015;                // Unknown
    uint32_t        NameIcon;                   // Bit array that handles the icon shown next to the players name.
};

/**
 * TMonsterName
 *
 * Structure definition of a monsters name information.
 */
struct TMonsterName
{
    uint32_t        Length;                     // The length of the monsters name.
    char*           MonsterName;                // Pointer to the monsters name.
};

/**
 * TMapMonsterObj
 *
 * Structure definition of a monster object.
 */
struct TMapMonsterObj : TMapMoveObjBase
{
    uint8_t         Unknown0000;                // Deals with the outlining of the monster when moused over.
    uint8_t         Unknown0001;                // Unknown (unused; padding)
    uint8_t         Unknown0002;                // Unknown (unused; padding)
    uint8_t         Unknown0003;                // Unknown (unused; padding)
    uint32_t        Unknown0004;                // Unknown (If not 0, all entities are hidden on screen.)
    uint16_t        ModelId;                    // The monster model id to load for the entity.
    uint16_t        Unknown0006;                // Alters the shadow of the entity. Not sure what exactly it is for though.
    TMonsterName*   NamePointer;                // Pointer to a TMonsterName structure holding the monsters name info.
    uint8_t         SpecialEffect;              // Additional effect placed on the entity.
    uint8_t         Unknown0008;                // Unknown (unused; padding)
    uint8_t         Unknown0009;                // Unknown (unused; padding)
    uint8_t         Unknown0010;                // Unknown (unused; padding)
    float           SpecialEffectMultiplier;    // Multiplies the amount of the special effect that is activated.
    uint8_t         EffectColorB;               // The blue color of the effect. (SpecialEffect 1 for this to work.)
    uint8_t         EffectColorG;               // The green color of the effect. (SpecialEffect 1 for this to work.)
    uint8_t         EffectColorR;               // The red color of the effect. (SpecialEffect 1 for this to work.)
    uint8_t         Unknown0011;                // Unknown (unused; padding)
    uint8_t         EffectPulseType;            // The special effect pulse type when the effect is set to 2.
};

/**
 * TMapNpcObj
 *
 * Structure definition of an npc object.
 */
struct TMapNpcObj : TMapMonsterObj
{
    char*           NpcName;
};

/**
 * TMapItemInfo
 *
 * Structure definition of an items information.
 */
struct TMapItemInfo
{
    uint8_t         Unknown0000[0x38];
    uint32_t        ItemName;
    uint8_t         Unknown0001[0x0E];
    uint16_t        ItemId;
};

/**
 * TMapItemObj
 *
 * Structure definition of an item object.
 */
struct TMapItemObj : TMapObjBase
{
    uint32_t        Unknown0000;                // Unknown (set to 0 when item is spawned)
    uint32_t        Unknown0001;                // Unknown (set to 0 when item is spawned)
    uint32_t        Unknown0002;                // Unknown (set to 0 when item is spawned)
    uint32_t        Unknown0003;                // Unknown (set to 0 when item is spawned)
    uint8_t         Unknown0004;                // If set to 1 the item will disappear on screen like someone picked it up.
    uint8_t         Unknown0005;                // Unknown (set to 0 when item is spawned)
    uint8_t         Unknown0006;                // Unknown (set to 0 when item is spawned)
    uint8_t         Unknown0007;                // Unknown (set to 0 when item is spawned)
    uint32_t        Unknown0008;                // Unknown (set to 0 when item is spawned)
    uint32_t        Unknown0009;                // Unknown (set to 0 when item is spawned)
    uint32_t        Unknown0010;                // Unknown (set to 0 when item is spawned)
    uint16_t        ItemId;                     // The items id.
    uint16_t        ItemId2;                    // The items id. (Copied from [ItemInfoPointer]+0x4A's value.)
    TMapItemInfo*   ItemInfoPointer;            // Pointer to information about this item. (+0x4A from this holds the item id.)
    uint32_t        ItemCount;                  // The amount of items in the single stack.
    uint32_t        ItemOwnerId;                // The server id of the owner of the item. (-1 if its free for all.)
    uint8_t         ItemFlags;                  // Bit array holding information about the item. (Such as if it is a quest item etc.)
    uint8_t         Unknown0011;                // Unknown (unused; padding)
    uint8_t         Unknown0012;                // Unknown (unused; padding)
    uint8_t         Unknown0013;                // Unknown (unused; padding)
};

/**
 * TPlayerObjManager
 *
 * Structure definition of the games internal TPlayerObjManager object.
 */
struct TPlayerObjManager
{
    uint32_t        VTablePointer;              // TPlayerObjManager VTable Pointer
    uint16_t        CurrentMapX;                // The players current map x position.
    uint16_t        CurrentMapY;                // The players curremt map y position.
    uint16_t        DestinationMapX;            // The players destination map x position.
    uint16_t        DestinationMapY;            // The players destination map y position.
    uint32_t        Unknown0002;                // Incrementing timer used while auto-attacking.
    uint32_t        Unknown0003;                // Unknown (unused)
    uint8_t         CombatStatus;               // The players combat status. 0 = None, 2 = Attacking / Casting, 3 = Using Slingshot, etc.
    uint8_t         Unknown0004;                // Unknown (0 is written to this each time you exit combat.)
    uint16_t        Unknown0005;                // Unknown (unused)
    uint32_t        Unknown0006;                // Pointer to a TByteList object.
    uint8_t         Unknown0007;                // Unknown (set to 0 usually, deals with the list object before this if set to 1.)
    uint8_t         Unknown0008;                // Unknown (unused)
    uint8_t         Unknown0009;                // Unknown (unused)
    uint8_t         Unknown0010;                // Unknown (unused) 
    TMapPlayerObj*  PlayerObject;               // Pointer to the current players object. 
    uint32_t        PlayerId;                   // The current players server id.
    uint8_t         CanUseEmotes;               // Determines if the player is able to emote. (Possibly a flag to determine if the player is loaded.) 
    uint8_t         Unknown0011;                // Unknown (unused) 
    uint8_t         Unknown0012;                // Unknown (unused) 
    uint8_t         Unknown0013;                // Unknown (unused) 
    TMapObjBase*    AutoAttackingMobPointer;    // Pointer to an entity object that the player has double-clicked to auto-follow / auto-attack.
    uint32_t        Unknown0014;                // Pointer to a TList object.
    uint32_t        Unknown0015;                // Pointer to a wide string. Unsure what uses it currently. 
    uint32_t        Unknown0016;                // Unknown (set to 0 when logging out.)
    uint32_t        Unknown0017;                // Unknown (set to 0 when logging out.)
    uint32_t        Unknown0018;                // Unknown (set to 1800000 when the manager is created.)
    TMapObjBase*    LastClickedObject;          // Pointer to the last clicked object. (0 if floor was clicked.)
};

/**
 * TSceneManager
 *
 * Structure definition of the games internal TSceneManager object.
 */
struct TSceneManager
{
    uint32_t        VTablePointer;              // TSceneManager VTable Pointer
    uint32_t        TEventCtrlPointer;          // Pointer to a TEventCtrl object.
    uint32_t        UnknownTMapMoveObjBaseList; // Pointer to a TMapMoveObjBase object.
    uint32_t        PlayerListPointer;          // Pointer to a TMapObjBaseList -> TMapPlayerObj object holding the current maps players.
    uint32_t        MonsterListPointer;         // Pointer to a TMapObjBaseList -> TMapMonsterObj object holding the curremt maps monsters.
    uint32_t        NpcListPointer;             // Pointer to a TMapObjBaseList -> TMapNpcObj object holding the curremt maps npcs.
    uint32_t        ItemListPointer;            // Pointer to a TMapObjBaseList -> TMapItemObj object holding the curremt maps items.
    uint32_t        UnknownTLBSBkFxListPointer; // Pointer to a TLBSBkFxList object.
    uint32_t        Unknown0000;                // Pointer to structure holding information about the mouse movement.
    uint32_t        TotalFrameCounter;          // Incrementing timer that signifies the total frame count. (Value is copied from another location. This copy is used for movement.)
    uint8_t         IsPlayerLoaded;             // Flag to determine if the player is loaded and the camera is snapped onto the player. (Set to zero while loading, reset to 1 after c_info and mapout packets are handled.)
    uint8_t         Unknown0002;                // Unknown (unused)
    uint8_t         Unknown0003;                // Unknown (unused)
    uint8_t         Unknown0004;                // Unknown (unused)
    uint32_t        PlayerId;                   // The local players current server id. (Referred to as session id by others.)
    uint32_t        PlayerObjectPointer;        // Pointer to the local players TMapPlayerObj object.
    uint32_t        MouseOverObjectPointer1;    // Pointer to the TMapObjBase object that the mouse is currently hovering over. (Valid when the mouse is over an object and the name is visible.)
    uint32_t        MouseOverObjectPointer2;    // Pointer to the TMapObjBase object that the mouse is currently hovering over. (Valid when the mouse is within an objects hitbox.)
    float           Unknown0005;                // Unknown (Deals with the mouse while its within the maps clickable area. Adjusts differently when mouse is held down.)
    float           Unknown0006;                // Unknown (Deals with the mouse while its within the maps clickable area. Adjusts differently when mouse is held down.)
    uint32_t        Unknown0007;                // Unknown (Deals with the mouse.)
    uint32_t        AutoAttackObjectPointer;    // Pointer to a TMapObjBase object that the player is targeting to attack. (When you double-click an enemy this is set to the enemies pointer.)
    uint16_t        MousePositionX;             // The mouses current x axis position, relative to the top-left corner of the game window.
    uint16_t        MousePositionY;             // The mouses current y axis position, relative to the top-left corner of the game window.
    uint16_t        WindowWidth;                // The window width that the mouse is usable within.
    uint16_t        WindowHeight;               // The window height that the mouse is usable within.
    uint32_t        Unknown0008;                // Unknown (usused, always 0)
    uint8_t         Unknown0009;                // Unknown (seems to always be 1, compared against 0 in several instructions. Deals with the mouse.)
    uint8_t         Unknown0010;                // Unknown (unused)
    uint8_t         Unknown0011;                // Unknown (unused)
    uint8_t         Unknown0012;                // Unknown (unused)
    float           MouseMapX;                  // The mouses current x axis position as a float. Can be used to edit where the mouse will click.
    float           MouseMapZ;                  // The mouses current z axis position as a float. Can be used to edit where the mouse will click. (Depth.)
    float           MouseMapY;                  // The mouses current y axis position as a float. Can be used to edit where the mouse will click.
    uint32_t        Unknown0013;                // Pointer to a TCellBlockTexture object.
    uint32_t        CameraPointer;              // Pointer to a TLBSCamera object that handles the game camera.
    uint32_t        Unknown0014;                // Pointer to a TList object. (List holds TLBSBaseGmItem objects.)
    uint32_t        Unknown0015;                // Pointer to a TList object. (List holds TLBSFixtGmItem objects.)
    uint32_t        Unknown0016;                // Pointer to a TList object. (List holds TLBSFixtGmItem objects.)
    uint32_t        Unknown0017;                // Pointer to a TList object. (List holds TLBSEffectGmItem objects.)
    uint32_t        Unknown0018;                // Pointer to a TList object. (List holds various objects, TMapMonsterObj, TMapPlayerObj etc. Changes sizes and objects rapidly while moving around.)
    uint32_t        Unknown0019;                // Pointer to a TList object. (List holds TLBSMapFxItem objects.)
    uint32_t        ZoneTimeSnapshot;           // The timer count set when zoning. (Pulls the timer from TotalFrameCounter's value at the time of zoning.)
    uint8_t         Unknown0020;                // Unknown (set when logging in, always 0)
    uint8_t         Unknown0021;                // Unknown (set when zoning, always 0)
    uint8_t         Unknown0022;                // Unknown (unused)
    uint8_t         Unknown0023;                // Unknown (unused)
    uint32_t        Unknown0024;                // Unknown (set when zoning, always 0)
    uint32_t        Unknown0025;                // Unknown (set when getting attacked,  changes each time you are attacked) TObjAtkTimeArr object.
    uint8_t         Unknown0026;                // Unknown (set to 255 (-1) by force if changed, used within the pulse packet handler somewhere)
    uint8_t         Unknown0027;                // Unknown (unused)
    uint8_t         Unknown0028;                // Unknown (unused)
    uint8_t         Unknown0029;                // Unknown (unused)
    uint32_t        Unknown0030;                // Unknown (read when zoning) /* End of TSceneManager based on decompiler output. */
};

#endif // __NOSTALESDK_H_INCLUDED__

The file attached to this post is my personal SDK I wrote for some of my public and private tools that involved various information about the current player, other players/mobs/entities etc on the map and so on. I have not played/updated this since around August so no idea if the structures are fully working still. But for those that know what they are doing you should be able to get things realigned in no time.

Unknowns are typically non-important information. The vital things are marked and used in the various managers in the SDK.

Have questions, feel free to ask.

More info can be found on my personal site:



Wont be posting much on here anymore, so if you want anything else check my personal site.

[atom0s]

TMiniMap

Pattern: 8B128942??8BCBB201A1????????E8????????A3????????8BCBB201
Offset: +0x14

Data Offsets (booleans):
 + 0xC4 = Show local player.
 + 0xC5 = Show party members.
 + 0xC6 = Show current target.
 + 0xC8 = Show npcs (1).
 + 0xC9 = Show portals.
 + 0xCA = Show timespaces.
 + 0xCC = Show players.
 + 0xCD = Show npcs (2).
 + 0xCE = Show monsters.
 + 0xCF = Show items.

void NosHacks::ApplyMinimapHack(uint32_t offset, bool value)
{
    // Ensure the minimap pointer is valid..
    if (this->m_PtrMinimap == 0)
        return;

    // Read into the pointer..
    auto pointer = *(uintptr_t*)this->m_PtrMinimap;
    if (pointer == 0) return;
    pointer = *(uintptr_t*)(pointer + 0x00);
    if (pointer == 0) return;
    pointer = *(uintptr_t*)(pointer + 0xA8);
    if (pointer == 0) return;

    // Write the value..
    *(bool*)(pointer + offset) = value;
}

Camera Zoom

Pattern: ????8B43??A3????????EB??D905????????D85B
Offset: +0x00

    if (this->m_MiscCameraZoom)
    {
        DWORD oldProtect = 0;
        ::VirtualProtect((LPVOID)this->m_PtrCameraZoom, 0xFF, PAGE_EXECUTE_READWRITE, &oldProtect);
        *(uint8_t*)(this->m_PtrCameraZoom + 0x00) = 0xEB;
        *(uint8_t*)(this->m_PtrCameraZoom + 0x18) = 0xEB;
    }
    else
    {
        DWORD oldProtect = 0;
        ::VirtualProtect((LPVOID)this->m_PtrCameraZoom, 0xFF, PAGE_EXECUTE_READWRITE, &oldProtect);
        *(uint8_t*)(this->m_PtrCameraZoom + 0x00) = 0x73;
        *(uint8_t*)(this->m_PtrCameraZoom + 0x18) = 0x76;
    }

Ghost Camera

Pattern: C683C000000000A1????????8B0089583C
Offset: +0x08

    if (this->m_MiscGhostCamera)
    {
        auto pointer = *(uintptr_t*)this->m_PtrGhostCamera;
        pointer = *(uintptr_t*)pointer;
        pointer = *(uintptr_t*)pointer;
        *(uint8_t*)(pointer + 0x18) = 1;
    }
    else
    {
        auto pointer = *(uintptr_t*)this->m_PtrGhostCamera;
        pointer = *(uintptr_t*)pointer;
        pointer = *(uintptr_t*)pointer;
        *(uint8_t*)(pointer + 0x18) = 0;
    }

Hide Entities

Pattern: 803D????????00????????????837F3000????????????8B476C
Offset: +0x02

    if (this->m_MiscHideEntities)
    {
        auto pointer = *(uintptr_t*)this->m_PtrHideEntities;
        *(uint8_t*)pointer = 0x00;
    }
    else
    {
        auto pointer = *(uintptr_t*)this->m_PtrHideEntities;
        *(uint8_t*)pointer = 0x01;
    }

Send Packets via Chat

Pattern: 833D????????00????????????8D45AC508B45F4
Offset: +0x02

    if (this->m_MiscSendPacketsChat)
    {
        auto pointer = *(uintptr_t*)this->m_PtrSendPacketsChat;
        *(uint8_t*)pointer = 1;
    }
    else
    {
        auto pointer = *(uintptr_t*)this->m_PtrSendPacketsChat;
        *(uint8_t*)pointer = 0;
    }

Target Info Spy

Pattern: A3????????A1????????33D28950608BCBB201A1
Offset: +0x01

    if (this->m_MiscTargetInfoSpy)
    {
        {
            auto hppointer = *(uintptr_t*)this->m_PtrTargetInfoSpy;
            hppointer = *(uintptr_t*)(hppointer + 0x00);
            hppointer = *(uintptr_t*)(hppointer + 0x20);
            hppointer = *(uintptr_t*)(hppointer + 0x04);
            hppointer = *(uintptr_t*)(hppointer + 0x0C);
            hppointer = *(uintptr_t*)(hppointer + 0x20);
            hppointer = *(uintptr_t*)(hppointer + 0x04);
            hppointer = *(uintptr_t*)(hppointer + 0x14);
            *(uint8_t*)(hppointer + 0x84) = 1;
        }
        {
            auto mppointer = *(uintptr_t*)this->m_PtrTargetInfoSpy;
            mppointer = *(uintptr_t*)(mppointer + 0x00);
            mppointer = *(uintptr_t*)(mppointer + 0x20);
            mppointer = *(uintptr_t*)(mppointer + 0x04);
            mppointer = *(uintptr_t*)(mppointer + 0x10);
            mppointer = *(uintptr_t*)(mppointer + 0x20);
            mppointer = *(uintptr_t*)(mppointer + 0x04);
            mppointer = *(uintptr_t*)(mppointer + 0x14);
            *(uint8_t*)(mppointer + 0x84) = 1;
        }
    }
    else
    {
        {
            auto hppointer = *(uintptr_t*)this->m_PtrTargetInfoSpy;
            hppointer = *(uintptr_t*)(hppointer + 0x00);
            hppointer = *(uintptr_t*)(hppointer + 0x20);
            hppointer = *(uintptr_t*)(hppointer + 0x04);
            hppointer = *(uintptr_t*)(hppointer + 0x0C);
            hppointer = *(uintptr_t*)(hppointer + 0x20);
            hppointer = *(uintptr_t*)(hppointer + 0x04);
            hppointer = *(uintptr_t*)(hppointer + 0x14);
            *(uint8_t*)(hppointer + 0x84) = 0;
        }
        {
            auto mppointer = *(uintptr_t*)this->m_PtrTargetInfoSpy;
            mppointer = *(uintptr_t*)(mppointer + 0x00);
            mppointer = *(uintptr_t*)(mppointer + 0x20);
            mppointer = *(uintptr_t*)(mppointer + 0x04);
            mppointer = *(uintptr_t*)(mppointer + 0x10);
            mppointer = *(uintptr_t*)(mppointer + 0x20);
            mppointer = *(uintptr_t*)(mppointer + 0x04);
            mppointer = *(uintptr_t*)(mppointer + 0x14);
            *(uint8_t*)(mppointer + 0x84) = 0;
        }
    }

NPC Talk Anywhere (Longchat)

Pattern: 8B57??668B4D??8B460CE8????????84C0????8BC5
Offset: +0x11

    if (this->m_MiscNpcTalkAnywhere)
    {
        DWORD oldProtect = 0;
        ::VirtualProtect((LPVOID)this->m_PtrNpcTalkAnywhere, 0xFF, PAGE_EXECUTE_READWRITE, &oldProtect);
        *(uint8_t*)(this->m_PtrNpcTalkAnywhere + 0x00) = 0x90;
        *(uint8_t*)(this->m_PtrNpcTalkAnywhere + 0x01) = 0x90;
    }
    else
    {
        DWORD oldProtect = 0;
        ::VirtualProtect((LPVOID)this->m_PtrNpcTalkAnywhere, 0xFF, PAGE_EXECUTE_READWRITE, &oldProtect);
        *(uint8_t*)(this->m_PtrNpcTalkAnywhere + 0x00) = 0x74;
        *(uint8_t*)(this->m_PtrNpcTalkAnywhere + 0x01) = 0x27;
    }

No Stun / No Delay

Pattern: 83BF9A00000000????B3018BC7
Offset: +0x07
Pattern: 53????????8B45F4508D4DE8
Offset: +0x01

    // No Stun
    if (this->m_MiscNoStun)
    {
        DWORD oldProtect = 0;
        ::VirtualProtect((LPVOID)this->m_PtrNoStun, 0xFF, PAGE_EXECUTE_READWRITE, &oldProtect);
        *(uint8_t*)(this->m_PtrNoStun + 0x00) = 0xEB;
    }
    else
    {
        DWORD oldProtect = 0;
        ::VirtualProtect((LPVOID)this->m_PtrNoStun, 0xFF, PAGE_EXECUTE_READWRITE, &oldProtect);
        *(uint8_t*)(this->m_PtrNoStun + 0x00) = 0x76;
    }

    // No Delay
    if (this->m_MiscNoDelay)
    {
        DWORD oldProtect = 0;
        ::VirtualProtect((LPVOID)this->m_PtrNoDelay, 0xFF, PAGE_EXECUTE_READWRITE, &oldProtect);
        unsigned char patch[] = { 0x6A, 0x00, 0x90, 0x90 };
        memcpy((LPVOID)this->m_PtrNoDelay, &patch, 4);
    }
    else
    {
        DWORD oldProtect = 0;
        ::VirtualProtect((LPVOID)this->m_PtrNoDelay, 0xFF, PAGE_EXECUTE_READWRITE, &oldProtect);
        unsigned char patch[] = { 0x8B, 0x45, 0xFC, 0x50 };
        memcpy((LPVOID)this->m_PtrNoDelay, &patch, 4);
    }

Open Game Windows

Pattern: 558BEC83C4D8535633C9894D??894D??894D??8BF28BD833C055
Offset: +0x00

        auto func = this->m_PtrOpenWindow;
        __asm
        {
            xor ecx, ecx;
            xor edx, edx;
            xor eax, eax;
            mov al, windowId;
            call[func];
        }

Common Window Ids:
  - +Resistence: 0x0F
  - Bet Rare: 0x0E
  - Card Upgrade (SP): 0x13
  - Examine Relics: 0x1D
  - Item Upgrade: 0x05
  - NosBazaar: 0x20

Speed Hack

Pattern: 33C0????????????8B0485????????890424E8????????8944240833C08944240CDF6C2408D8A3
Offset: +0x02

        if (this->m_MiscUseSpeedHack)
        {
            unsigned char buffer[] = { 0xB0, 0x0B, 0x90, 0x90, 0x90, 0x90 };
            DWORD oldProtect = 0;
            VirtualProtect((LPVOID)this->m_PtrSpeedHack, 0x06, PAGE_EXECUTE_READWRITE, &oldProtect);
            memcpy((LPVOID)this->m_PtrSpeedHack, &buffer, 0x06);
        }
        else
        {
            unsigned char buffer[] = { 0x8A, 0x83, 0x9E, 0x00, 0x00, 0x00 };
            DWORD oldProtect = 0;
            VirtualProtect((LPVOID)this->m_PtrSpeedHack, 0x06, PAGE_EXECUTE_READWRITE, &oldProtect);
            memcpy((LPVOID)this->m_PtrSpeedHack, &buffer, 0x06);
        }

        // Writes the speed amount to the new modded instructions..
        *(uint8_t*)(this->m_PtrSpeedHack + 0x01) = (uint8_t)this->m_MiscSpeedHackAmount;

Teleporting
Doing these requires sending packets.

Act I
    NosVille - n_run 0 0 1
    NosCamp Cave - script 1 204
    Fernon Outpost - script 1 203

Act II
    Mount Krem - n_run 16 1 1
    Land of Death - n_run 150 0 1

Act IV
    Port Alveus - n_run 16 2 1
    Glacernon - n_run 5005 0 1
    Act IV Ship - n_run 5001 0 1

Act V
    Mortaz Desert Port - n_run 26 0 1
    Act V City 1 - n_run 26 2 1
    Act V City 2 - n_run 26 1 1
    Act V Shop - n_run 5011 0 1

Misc Teleports
    Secret Chicken Farm - n_run 2002 2110 1
    Pajama Stone (Yellow) - n_run 2002 2107 1
    SP 1 (Red) - n_run 2002 2108 1
    SP 2 (Blue) - n_run 2002 2109 1
    SP 3 (Golden) - n_run 2002 2111 1
    SP 4 (Grey) - n_run 2002 2112 1

Some of these require appending your current player id to the end of the packet info. (script commands do not require this, only the n_run ones do.)

Packet Functions

Packet 'this' class pointer:
    Pattern: 6A64A1????????8B008B4DF8BA????????E8????????33C05A5959
    Offset: +0x03

Packet Send Function:
    Pattern: 53568BF28BD8EB??EB??3919
    Offset: +0x00

Packet Receive Function:
    Pattern: 558BEC83C4F453565733C9894DF48955FC8BD88B45FC
    Offset: +0x00

Here are the hooks to invoke these from my project NosHook. This uses Detours (3.0.1) to hook and use the functions:

void PacketManager::SendPacket(const char* packet)
{
    if (Real_SendPacket == nullptr)
        return;

    // Convert the packet to a Nostale valid string..
    NostaleStringA nstr(packet);

    // Send the packet..
    auto pointer = this->m_PacketThis;
    auto pstr = nstr.get();

    __asm
    {
        mov eax, dword ptr ds : [pointer];  // Read the pointer for SendPacket..
        mov eax, dword ptr ds : [eax];      // Read the pointer for SendPacket..
        mov eax, dword ptr ds : [eax];      // Read the pointer for SendPacket..
        mov eax, dword ptr ds : [eax];      // Read the pointer for SendPacket..
        mov edx, pstr;                      // Set the packet string..
        call[Real_SendPacket];              // Send the packet..
    }
}

void PacketManager::RecvPacket(const char* packet)
{
    if (Real_RecvPacket == nullptr)
        return;

    // Convert the packet to a Nostale valid string..
    NostaleStringA nstr(packet);

    // Send the packet..
    auto pointer = this->m_PacketThis;
    auto pstr = nstr.get();

    __asm
    {
        mov eax, dword ptr ds : [pointer];  // Read the pointer for RecvPacket..
        mov eax, dword ptr ds : [eax];      // Read the pointer for RecvPacket..
        mov eax, dword ptr ds : [eax];      // Read the pointer for RecvPacket..
        mov eax, dword ptr ds : [eax];      // Read the pointer for RecvPacket..
        mov eax, dword ptr ds : [eax + 34h];// Read the pointer for RecvPacket..
        mov edx, pstr;                      // Set the packet string..
        call[Real_RecvPacket];              // Send the packet..
    }
}

NostaleString Classes (Ascii and Unicode)
Nostale uses Delphi which handles strings in a specific manner, these are two simple wrappers to use strings in that similar manner:

struct NostaleStringA
{
    char*   m_Buffer;
    size_t  m_Length;

    NostaleStringA(void)
        : m_Buffer(nullptr)
        , m_Length(0)
    { }
    NostaleStringA(const char* str)
        : m_Buffer(nullptr)
        , m_Length(0)
    {
        this->set(str);
    }
    ~NostaleStringA(void)
    {
        if (this->m_Buffer != nullptr)
            delete[] this->m_Buffer;
        this->m_Buffer = nullptr;
    }

    // Returns the size of the string.
    size_t len(void)
    {
        return (this->m_Buffer != nullptr) ? this->m_Length : 0;
    }

    // Returns the string within the buffer.
    char* get(void)
    {
        return (this->m_Buffer != nullptr) ? (char*)(this->m_Buffer + 0x08) : nullptr;
    }

    // Sets the string buffer.
    void set(const char* str)
    {
        if (this->m_Buffer != nullptr)
            delete[] this->m_Buffer;

        this->m_Length = strlen(str);
        this->m_Buffer = new char[this->m_Length + 8 + 1];

        *(unsigned int*)(this->m_Buffer + 0x00) = 1; // Reference Count
        *(unsigned int*)(this->m_Buffer + 0x04) = this->m_Length; // Length
        memcpy(this->m_Buffer + 0x08, str, this->m_Length);
        this->m_Buffer[this->m_Length + 0x08] = '\0';
    }
};

struct NostaleStringW
{
    wchar_t*    m_Buffer;
    size_t      m_Length;

    NostaleStringW(void)
        : m_Buffer(nullptr)
        , m_Length(0)
    { }
    NostaleStringW(const wchar_t* str)
        : m_Buffer(nullptr)
        , m_Length(0)
    {
        this->set(str);
    }
    ~NostaleStringW(void)
    {
        if (this->m_Buffer != nullptr)
            delete[] this->m_Buffer;
        this->m_Buffer = nullptr;
    }

    // Returns the size of the string.
    size_t len(void)
    {
        return (this->m_Buffer != nullptr) ? this->m_Length : 0;
    }

    // Returns the string within the buffer.
    wchar_t* get(void)
    {
        return (this->m_Buffer != nullptr) ? (wchar_t*)((char*)this->m_Buffer + 0x08) : nullptr;
    }

    // Sets the string buffer.
    void set(const wchar_t* str)
    {
        if (this->m_Buffer != nullptr)
            delete[] this->m_Buffer;

        this->m_Length = wcslen(str) * 2;
        this->m_Buffer = new wchar_t[this->m_Length + 8 + 1];

        *(unsigned int*)((char*)this->m_Buffer + 0x00) = 1; // Reference Count
        *(unsigned int*)((char*)this->m_Buffer + 0x04) = this->m_Length; // Length
        memcpy((char*)this->m_Buffer + 0x08, str, this->m_Length);
        *(wchar_t*)((char*)this->m_Buffer + this->m_Length + 0x08) = L'\0';
    }
};

Chat Related Functions

Chat 'this' class pointer:
    Pattern: 8B4DFCA1????????8B80B8000000
    Offset +0x04

Add To Chat Function:
    Pattern: 8BF98BF28BD88BCC33C08A83????????8B8483????????8D50??8BC6
    Offset: -0x06

Using the 'add to chat' function, this lets you write things to the chat log directly.

void ChatManager::Write(int chatMode, const char* msg)
{
    if (this->m_ChatThis == 0 || this->m_AddToChat == 0)
    {
        if (!this->Update())
            return;
    }

    // Convert to widechar..
    std::string str(msg);
    std::wstring wstr(str.begin(), str.end());

    NostaleStringW m(wstr.c_str());
    auto msgPtr = m.get();

    auto thisPointer = this->m_ChatThis;
    auto callPointer = this->m_AddToChat;

    __asm
    {
        mov eax, dword ptr ds : [thisPointer];
        mov eax, dword ptr ds : [eax];
        mov eax, dword ptr ds : [eax + 0xB8];
        mov edx, chatMode;
        mov ecx, msgPtr;
        call[callPointer];
    }
}

[Wulung]

Can you help me to make SDK for SF2 SEA?

[Valerius1992]

Hay, i need help for understand the "no n_run handler implementing for xxxx"
can u help me?

[_RowLegend_]

Can anybody explain me why this Code:


returns me an adress where the unicode is stored. But after that it immediately
clear the unicode which stored at that adress?

[Pumba98]

Originally Posted by _RowLegend_

Can anybody explain me why this Code:


returns me an adress where the unicode is stored. But after that it immediately
clear the unicode which stored at that adress?

maybe "m" gets out of scope & destructed?

[_RowLegend_]

thanks mate, removing

 ~NostaleStringW(void)
    {
        if (this->m_Buffer != nullptr)
            delete[] this->m_Buffer;
        this->m_Buffer = nullptr;
    }

was the solution

[imXeno]

That is actually not a solution. It just leaks memory. You should simply keep the NostaleStringW in scope.

[UserBlack]

Bonjour tout le monde, je cherche a décoder les Packet sniffer de nostale mais je cherche le type de cryptage utilisé par le jeu ,quelqu un a une idée comment nostale crypt ses packets puisque je reçoit des réponse de type b'x9f/......' de cette forme

[Apourtartt]

[UserBlack]

Merci pour votre réponse mais ce decodeur n a pas fonctionné jsp pourquoi

[Apourtartt]

Did you use Client or Server cryptography?
Did you retrieve the encryption key from the first packet sent to the server to decode other packets?

(You have to speak in english btw)

[FI0w]

Originally Posted by UserBlack

Merci pour votre réponse mais ce decodeur n a pas fonctionné jsp pourquoi

Write English. Your Current Messages are against Rules.

[Fizo55]

Originally Posted by UserBlack

Bonjour tout le monde, je cherche a décoder les Packet sniffer de nostale mais je cherche le type de cryptage utilisé par le jeu ,quelqu un a une idée comment nostale crypt ses packets puisque je reçoit des réponse de type b'x9f/......' de cette forme

Here's an example of how you could use it using the librairy Apourtartt mentionned :

[UserBlack]

hey again sorry for speaking french so i used the client cryptography and for " retrieve the encryption key from the first packet sent to the server to decode other packets?" i don't know how to do it in the first time , so basically i used a sniffer so i got some response "b'pZ\x9e\x94d\....."and when i tried the Client.worldDecrypt the response wa "b'\xa5ak\x9b%CWY\...." like this so i think i didn't work any advice ?