EQEmulator Forums

I've seen several people asking about this, so I figured I'd take a look into it.

Player Movement only stores coordinates to /rewind if they were significant, yet not a very large movement update. This prevents someone from intra-zone gating, then /rewind to get back to a spawn, etc.

One thing, when doing the diff, be sure that you update patch_Titanium.conf and move it into your server's folder, since this patch updates it (if you don't, then OP_Rewind won't get identified, and the rest of the patch won't do anything).

Here ya go, let me know what you think:

This was diffed against 0.7.0-1106:

Code:

diff  C:/eqemu-source-diff/EQEmu-0.7.0-1106/zone/zoning.cpp C:/eqemu-source-diff/daxum/zone/zoning.cpp

236c236

<                 if(Admin() < minStatusToIgnoreZoneFlags && !HasZoneFlag(target_zone_id)) {

---

>                 if(Admin() < minStatusToIgnoreZoneFlags && !HasZoneFlag(target_zone_id)) {

420a421,424

>                 case Rewind:

>                         Message(15, "Rewinding to previous location.");

>                         ZonePC(zoneID, x, y, z, heading, ignorerestrictions, zm);

>                         break;

437,478c441,482

<         switch(zm) {

<                 case EvacToSafeCoords:

<                 case ZoneToSafeCoords:

<                         x = zone->safe_x();

<                         y = zone->safe_y();

<                         z = zone->safe_z();

<                         heading = heading;

<                         break;

<                 case GMSummon:

<                         zonesummon_x = x_pos = x;

<                         zonesummon_y = y_pos = y;

<                         zonesummon_z = z_pos = z;

<                         heading = heading;

<                         

<                         zonesummon_id = zoneID;

<                         zonesummon_ignorerestrictions = 1;

<                         break;

<                 case ZoneSolicited:

<                         zonesummon_x = x;

<                         zonesummon_y = y;

<                         zonesummon_z = z;

<                         heading = heading;

<                         

<                         zonesummon_id = zoneID;

<                         zonesummon_ignorerestrictions = ignorerestrictions;

<                         break;

<                 case GateToBindPoint:

<                         x = x_pos = m_pp.binds[0].x;

<                         y = y_pos = m_pp.binds[0].y;

<                         z = z_pos = m_pp.binds[0].z;

<                         heading = m_pp.binds[0].heading;

<                         break;

<                 case ZoneToBindPoint:

<                         x = x_pos = m_pp.binds[0].x;

<                         y = y_pos = m_pp.binds[0].y;

<                         z = z_pos = m_pp.binds[0].z;

<                         heading = m_pp.binds[0].heading;

<                         

<                         zonesummon_ignorerestrictions = 1;

<                         LogFile->write(EQEMuLog::Debug, "Player %s has died and will be zoned to bind point in zone: %s at LOC x=%f, y=%f, z=%f, heading=%f", GetName(), pZoneName, m_pp.binds[0].x, m_pp.binds[0].y, m_pp.binds[0].z, m_pp.binds[0].heading);

<                         break;

<                 case SummonPC:

---

>         switch(zm) {

>                 case EvacToSafeCoords:

>                 case ZoneToSafeCoords:

>                         x = zone->safe_x();

>                         y = zone->safe_y();

>                         z = zone->safe_z();

>                         heading = heading;

>                         break;

>                 case GMSummon:

>                         zonesummon_x = x_pos = x;

>                         zonesummon_y = y_pos = y;

>                         zonesummon_z = z_pos = z;

>                         heading = heading;

>                         

>                         zonesummon_id = zoneID;

>                         zonesummon_ignorerestrictions = 1;

>                         break;

>                 case ZoneSolicited:

>                         zonesummon_x = x;

>                         zonesummon_y = y;

>                         zonesummon_z = z;

>                         heading = heading;

>                         

>                         zonesummon_id = zoneID;

>                         zonesummon_ignorerestrictions = ignorerestrictions;

>                         break;

>                 case GateToBindPoint:

>                         x = x_pos = m_pp.binds[0].x;

>                         y = y_pos = m_pp.binds[0].y;

>                         z = z_pos = m_pp.binds[0].z;

>                         heading = m_pp.binds[0].heading;

>                         break;

>                 case ZoneToBindPoint:

>                         x = x_pos = m_pp.binds[0].x;

>                         y = y_pos = m_pp.binds[0].y;

>                         z = z_pos = m_pp.binds[0].z;

>                         heading = m_pp.binds[0].heading;

>                         

>                         zonesummon_ignorerestrictions = 1;

>                         LogFile->write(EQEMuLog::Debug, "Player %s has died and will be zoned to bind point in zone: %s at LOC x=%f, y=%f, z=%f, heading=%f", GetName(), pZoneName, m_pp.binds[0].x, m_pp.binds[0].y, m_pp.binds[0].z, m_pp.binds[0].heading);

>                         break;

>                 case SummonPC:

483,487c487,498

<                         break;

<                 default:

<                         LogFile->write(EQEMuLog::Error, "Client::ZonePC() received a reguest to perform an unsupported client zone operation.");

<                         ReadyToZone = false;

<                         break;

---

>                         break;

>                 case Rewind:

>                         LogFile->write(EQEMuLog::Debug, "%s has requested a /rewind from %f, %f, %f, to %f, %f, %f in %s", GetName(), x_pos, y_pos, z_pos, rewind_x, rewind_y, rewind_z, zone->GetShortName());

>                         zonesummon_x = x_pos = x;

>                         zonesummon_y = y_pos = y;

>                         zonesummon_z = z_pos = z;

>                         heading = heading;

>                         break;

>                 default:

>                         LogFile->write(EQEMuLog::Error, "Client::ZonePC() received a reguest to perform an unsupported client zone operation.");

>                         ReadyToZone = false;

>                         break;

diff  C:/eqemu-source-diff/EQEmu-0.7.0-1106/zone/mob.cpp C:/eqemu-source-diff/daxum/zone/mob.cpp

102a103

>                 rewind_timer(30000), //Lieka:  Timer used for determining amount of time between actual player position updates for /rewind.

104c105

<                 bardsong_timer(6000),

---

>                 bardsong_timer(6000),

124c125,127

< 

---

>         rewind_x = 0;                //Lieka: Stored x_pos for /rewind

>         rewind_y = 0;                //Lieka: Stored y_pos for /rewind

>         rewind_z = 0;                //Lieka: Stored z_pos for /rewind

diff  C:/eqemu-source-diff/EQEmu-0.7.0-1106/zone/client_packet.cpp C:/eqemu-source-diff/daxum/zone/client_packet.cpp

316a317,318

>         ConnectedOpcodes[OP_Rewind] = &Client::Handle_OP_Rewind;

> 

808c810,838

<         

---

> 

>         //Lieka:  Check to see if PPU should trigger an update to the rewind position.

>         float rewind_x_diff = 0;

>         float rewind_y_diff = 0;

>         float rewind_z_diff = 0;

> 

>         rewind_x_diff = ppu->x_pos - rewind_x;

>         rewind_x_diff *= rewind_x_diff;

>         rewind_y_diff = ppu->y_pos - rewind_y;

>         rewind_y_diff *= rewind_y_diff;

> 

>         //Lieka:  We only need to store updated values if the player has moved.

>         //If the player has moved more than  units for x or y, then we'll store

>         //his pre-PPU x and y for /rewind, in case he gets stuck.

>         if ((rewind_x_diff > 750) || (rewind_y_diff > 750)) { 

>                 rewind_x = x_pos;

>                 rewind_y = y_pos;

>                 rewind_z = z_pos;        

>         }

> 

>         //Lieka:  If the PPU was a large jump, such as a cross zone gate or Call of Hero, 

>         //just update rewind coords to the new ppu coords.  This will prevent exploitation.

> 

>         if ((rewind_x_diff > 5000) || (rewind_y_diff > 5000)) { 

>                 rewind_x = ppu->x_pos;

>                 rewind_y = ppu->y_pos;

>                 rewind_z = ppu->z_pos;        

>         }

> 

816,822c846,852

<         if(

<                 ( (heading != ppu->heading) && !((int)heading % 3) ) ||        // turning

<                 ( (x_pos != ppu->x_pos) && !((int)x_pos % 6) )                                        // moving

<         )

<         {

<                 CheckIncreaseSkill(SENSE_HEADING, -20);

<         }

---

>         if(

>                 ( (heading != ppu->heading) && !((int)heading % 3) ) ||        // turning

>                 ( (x_pos != ppu->x_pos) && !((int)x_pos % 6) )                                        // moving

>         )

>         {

>                 CheckIncreaseSkill(SENSE_HEADING, -20);

>         }

876a907

>                         rewind_timer.Start(30000, true);

3156c3187

<         }

---

>         }

6827a6859,6868

> }

> 

> void Client::Handle_OP_Rewind(const EQApplicationPacket *app)

> {

>         if ((rewind_timer.GetRemainingTime() > 1 && rewind_timer.Enabled())) {

>                 Message_StringID(MT_System, 4059); //You must wait a bit longer before using the rewind command again. 

>         } else {

>                 CastToClient()->MovePC(zone->GetZoneID(), rewind_x, rewind_y, rewind_z, 0, 2, Rewind);        

>                 rewind_timer.Start(30000, true);

>         }

diff  C:/eqemu-source-diff/EQEmu-0.7.0-1106/zone/client.h C:/eqemu-source-diff/daxum/zone/client.h

151a152

>         Rewind,                                        // Lieka:  Summon to /rewind location.

153a155

> 

diff  C:/eqemu-source-diff/EQEmu-0.7.0-1106/zone/client_packet.h C:/eqemu-source-diff/daxum/zone/client_packet.h

214a215

>         void Handle_OP_Rewind(const EQApplicationPacket *app);

diff  C:/eqemu-source-diff/EQEmu-0.7.0-1106/zone/mob.h C:/eqemu-source-diff/daxum/zone/mob.h

788a789,792

>         float rewind_x; //Lieka:  Used for storing /rewind values

>         float rewind_y; //Lieka:  Used for storing /rewind values

>         float rewind_z; //Lieka:  Used for storing /rewind values

>         Timer rewind_timer; //Lieka:  Used for measuring how long a player stays in one spot

diff  C:/eqemu-source-diff/EQEmu-0.7.0-1106/utils/patch_Titanium.conf C:/eqemu-source-diff/daxum/utils/patch_Titanium.conf

267a268

> OP_Rewind=0x4cfa                        # Lieka 4/20/08: /rewind command

diff  C:/eqemu-source-diff/EQEmu-0.7.0-1106/common/emu_oplist.h C:/eqemu-source-diff/daxum/common/emu_oplist.h

401a402

> N(OP_Rewind),

<3,
Dax

I didn't think about the fact that many people aren't running the stock eqemu source, and that generated patch diffs might not be the best way for them to update their sources. With that said, here's a manual context diff. Just go through and add the red lines into your source, and you should be good to go.

Also, to clarify, this update gives functionality to the client /rewind feature. This command / feature was added to the client by Sony due to the collision issues (i.e. players getting stuck on trees and ladders, etc). This will allow players to "unstick" themselves if they are trapped in geometry without the need for GM assistance.

Without further delay, here is the code (note: this is the same code as my previous post - just in an easier to read format, for ServerOps that want to manually update their source):

patch_Titanium.conf (in your eqemu directory)

Code:

OP_LDoNButton=0x0000

OP_MoveCoin=0x7657

OP_ReloadUI=0x0000

OP_ZonePlayerToBind=0x385e                # FNW Discovered on Feb 9, 2007

OP_Rewind=0x4cfa                                # Lieka: /rewind command



#bazaar trader stuff stuff:

#become and buy from

./common/emu_oplist.h

Code:

N(OP_Command),

N(OP_MailboxHeader),

N(OP_MailHeader),

N(OP_MailBody),

N(OP_NewMail),

N(OP_SentConfirm),

N(OP_ZonePlayerToBind),

N(OP_AutoFire),

N(OP_Rewind),

./zone/mob.h

Code:

        bool DivineAura() const;

    bool SpecAttacks[SPECATK_MAXNUM];

        Shielders_Struct shielder[MAX_SHIELDERS];

        Trade* trade;

        

        //temporary:

        bool fix_pathing;

        float rewind_x; //Lieka:  Used for storing /rewind values

        float rewind_y; //Lieka:  Used for storing /rewind values

        float rewind_z; //Lieka:  Used for storing /rewind values

        Timer rewind_timer; //Lieka:  Used for measuring how long a player stays in one spot

        inline float GetCWPX() const { return(cur_wp_x); }

        inline float GetCWPY() const { return(cur_wp_y); }

        inline float GetCWPZ() const { return(cur_wp_z); }

        inline float GetCWPP() const { return(cur_wp_pause); }

        inline int GetCWP() const { return(cur_wp); }

        virtual FACTION_VALUE GetReverseFactionCon(Mob* iOther) { return FACTION_INDIFFERENT; }

./zone/client_packet.h

Code:

        void Handle_OP_PurchaseLeadershipAA(const EQApplicationPacket *app);

        void Handle_OP_Ignore(const EQApplicationPacket *app);

        void Handle_OP_LoadSpellSet(const EQApplicationPacket *app);

        void Handle_OP_AutoFire(const EQApplicationPacket *app);

        void Handle_OP_Rewind(const EQApplicationPacket *app);

./zone/client.h

Code:

typedef enum {

        ZoneToSafeCoords,                // Always send ZonePlayerToBind_Struct to client: Succor/Evac

        GMSummon,                                // Always send ZonePlayerToBind_Struct to client: Only a GM Summon

        ZoneToBindPoint,                // Always send ZonePlayerToBind_Struct to client: Death Only

        ZoneSolicited,                        // Always send ZonePlayerToBind_Struct to client: Portal, Translocate, Evac spells that have a x y z coord in the spell data

        ZoneUnsolicited,

        GateToBindPoint,                // Always send RequestClientZoneChange_Struct to client: Gate spell or Translocate To Bind Point spell

        SummonPC,                                // In-zone GMMove() always: Call of the Hero spell or some other type of in zone only summons

        Rewind,                                        // Lieka:  Summon to /rewind location.

        EvacToSafeCoords

} ZoneMode;

./zone/zoning.cpp

Code:

                case ZoneToBindPoint:

                        ZonePC(zoneID, x, y, z, heading, ignorerestrictions, zm);

                        break;

                case ZoneSolicited:

                        ZonePC(zoneID, x, y, z, heading, ignorerestrictions, zm);

                        break;

                case SummonPC:

                        Message(15, "You have been summoned!");

                        ZonePC(zoneID, x, y, z, heading, ignorerestrictions, zm);

                        break;

                case Rewind:

                        Message(15, "Rewinding to previous location.");

                        ZonePC(zoneID, x, y, z, heading, ignorerestrictions, zm);

                        break;

                default:

                        LogFile->write(EQEMuLog::Error, "Client::ProcessMovePC received a reguest to perform an unsupported client zone operation.");

                        break;

        }

}

Code:

                case ZoneToBindPoint:

                        x = x_pos = m_pp.binds[0].x;

                        y = y_pos = m_pp.binds[0].y;

                        z = z_pos = m_pp.binds[0].z;

                        heading = m_pp.binds[0].heading;

                        

                        zonesummon_ignorerestrictions = 1;

                        LogFile->write(EQEMuLog::Debug, "Player %s has died and will be zoned to bind point in zone: %s at LOC x=%f, y=%f, z=%f, heading=%f", GetName(), pZoneName, m_pp.binds[0].x, m_pp.binds[0].y, m_pp.binds[0].z, m_pp.binds[0].heading);

                        break;

                case SummonPC:

                        this->cheat_timer.Start(2500,false);

                        zonesummon_x = x_pos = x;

                        zonesummon_y = y_pos = y;

                        zonesummon_z = z_pos = z;

                        heading = heading;

                        break;

                case Rewind:

                        LogFile->write(EQEMuLog::Debug, "%s has requested a /rewind from %f, %f, %f, to %f, %f, %f in %s", GetName(), x_pos, y_pos, z_pos, rewind_x, rewind_y, rewind_z, zone->GetShortName());

                        zonesummon_x = x_pos = x;

                        zonesummon_y = y_pos = y;

                        zonesummon_z = z_pos = z;

                        heading = heading;

                        break;

                default:

                        LogFile->write(EQEMuLog::Error, "Client::ZonePC() received a reguest to perform an unsupported client zone operation.");

                        ReadyToZone = false;

                        break;

        }

./zone/mob.cpp

Code:

                tic_timer(6000),

                mana_timer(2000),

                spellend_timer(0),

                rewind_timer(30000), //Lieka:  Timer used for determining amount of time between actual player position updates for /rewind.

                stunned_timer(0),

                bardsong_timer(6000),

#ifdef FLEE_HP_RATIO

                flee_timer(FLEE_CHECK_TIMER),

#endif

                bindwound_timer(10000)

Code:

        tarx=0;

        tary=0;

        tarz=0;

        AI_Init();

        SetMoving(false);

        moved=false;

        rewind_x = 0;

        rewind_y = 0;

        rewind_z = 0;

        _egnode = NULL;

        adverrorinfo = 0;

        name[0]=0;

        clean_name[0]=0;

        lastname[0]=0;

./zone/client_packet.cpp

Code:

        ConnectedOpcodes[OP_FloatListThing] = &Client::Handle_OP_Ignore;

        ConnectedOpcodes[OP_WorldUnknown001] = &Client::Handle_OP_Ignore;

        ConnectedOpcodes[OP_LoadSpellSet] = &Client::Handle_OP_LoadSpellSet;

        ConnectedOpcodes[OP_AutoFire] = &Client::Handle_OP_AutoFire;

        ConnectedOpcodes[OP_Rewind] = &Client::Handle_OP_Rewind;



        

}

Code:

printf("%s: Large position change: %f units\n", GetName(), sqrtf(dist));

                printf("Coords: (%.4f, %.4f, %.4f) -> (%.4f, %.4f, %.4f)\n",

                        x_pos, y_pos, z_pos, ppu->x_pos, ppu->y_pos, ppu->z_pos);

                printf("Deltas: (%.2f, %.2f, %.2f) -> (%.2f, %.2f, %.2f)\n",

                        delta_x, delta_y, delta_z, ppu->delta_x, ppu->delta_y, ppu->delta_z);

        }



        //Lieka:  Check to see if PPU should trigger an update to the rewind position.

        float rewind_x_diff = 0;

        float rewind_y_diff = 0;

        float rewind_z_diff = 0;



        rewind_x_diff = ppu->x_pos - rewind_x;

        rewind_x_diff *= rewind_x_diff;

        rewind_y_diff = ppu->y_pos - rewind_y;

        rewind_y_diff *= rewind_y_diff;



        //Lieka:  We only need to store updated values if the player has moved.

        //If the player has moved more than  units for x or y, then we'll store

        //his pre-PPU x and y for /rewind, in case he gets stuck.

        if ((rewind_x_diff > 750) || (rewind_y_diff > 750)) { 

                rewind_x = x_pos;

                rewind_y = y_pos;

                rewind_z = z_pos;        

        }



        //Lieka:  If the PPU was a large jump, such as a cross zone gate or Call of Hero, 

        //just update rewind coords to the new ppu coords.  This will prevent exploitation.



        if ((rewind_x_diff > 5000) || (rewind_y_diff > 5000)) { 

                rewind_x = ppu->x_pos;

                rewind_y = ppu->y_pos;

                rewind_z = ppu->z_pos;        

        }



        // solar: a very low chance to improve at sense heading, since

Code:

                        sa_out->type = 0x03;

                        sa_out->parameter = 0;

                        entity_list.QueueClients(this, outapp, true);

                        safe_delete(outapp);

                        rewind_timer.Start(30000, true);

                }

        }

Code:

void Client::Handle_OP_BankerChange(const EQApplicationPacket *app)

{

        if(app->size != sizeof(BankerChange_Struct) && app->size!=4) // cb: Titanium only sends 4 Bytes for this

        {



                LogFile->write(EQEMuLog::Debug, "Size mismatch in OP_BankerChange expected %i got %i", sizeof(BankerChange_Struct), app->size);

                DumpPacket(app);

                return;

        }

        

        EQApplicationPacket *outapp=new EQApplicationPacket(OP_BankerChange,NULL,sizeof(BankerChange_Struct));

        BankerChange_Struct *bc=(BankerChange_Struct *)outapp->pBuffer;

        uint32 cp=m_pp.copper+(m_pp.silver*10)+(m_pp.gold*100)+(m_pp.platinum*1000);

        m_pp.copper=cp%10;

        cp/=10;

        m_pp.silver=cp%10;

        cp/=10;

        m_pp.gold=cp%10;

        cp/=10;

        m_pp.platinum=cp;



        cp=m_pp.copper_bank+(m_pp.silver_bank*10)+(m_pp.gold_bank*100)+(m_pp.platinum_bank*1000);

        m_pp.copper_bank=cp%10;

        cp/=10;

        m_pp.silver_bank=cp%10;

        cp/=10;

        m_pp.gold_bank=cp%10;

        cp/=10;

        m_pp.platinum_bank=cp;



        bc->copper=m_pp.copper;

        bc->silver=m_pp.silver;

        bc->gold=m_pp.gold;

        bc->platinum=m_pp.platinum;



        bc->copper_bank=m_pp.copper_bank;

        bc->silver_bank=m_pp.silver_bank;

        bc->gold_bank=m_pp.gold_bank;

        bc->platinum_bank=m_pp.platinum_bank;



        FastQueuePacket(&outapp);



        return;

}



void Client::Handle_OP_AutoFire(const EQApplicationPacket *app)

{

        if(app->size != sizeof(bool)) {

                LogFile->write(EQEMuLog::Debug, "Size mismatch in OP_AutoFire expected %i got %i", sizeof(bool), app->size);

                DumpPacket(app);

                return;

        }

        bool *af = (bool*)app->pBuffer;

        auto_fire = *af;

        SetAttackTimer();

}



void Client::Handle_OP_Rewind(const EQApplicationPacket *app)

{

        if ((rewind_timer.GetRemainingTime() > 1 && rewind_timer.Enabled())) {

                        Message_StringID(MT_System, 4059); //You must wait a bit longer before using the rewind command again. 

        } else {

                CastToClient()->MovePC(zone->GetZoneID(), rewind_x, rewind_y, rewind_z, 0, 2, Rewind);        

                rewind_timer.Start(30000, true);

        }

}