Thread: Bug Fix: Player Processing (Stop Mass clicking affecting your updating speeds!)

Purpose: To stop mass clicking completely, and give your server a steady processing time.

Description: This tutorial will show you how to fix a major bug I have recently discovered the cause of, in which mass clicking would affect the speed your server would process it's clients.
In simple english - Stop Mass clicking from affecting your 'timers'.

Difficulty: About 3.5, I don't think I explained it too well.

Assumed Knowledge: Opening Files, Copying and Pasting, Deleting.

Tested Server: Winterloves

Files/Classes Modified: PlayerHandler.java, Player.java, client.java

Procedure
Step 1 - Make sure your client.java can handle the updates to its method of processing:
Open up your client.java. Search for the following:

Code:

private boolean packetProcess()

If you DO have the above code:
• Replace the word private, with public .
• Scroll up a bit, until you see 'return packetProcess();'. Replace that with 'return false;'.
• Skip ahead to step 4.

If you DON'T have the above code, complete steps 2 and 3


Step 2 - Removing the old packet processing method:
Ok, so you don't have a seperate method for processing packets. Not to worry, I'll show you how to make one.

Search for:

Code:

void parseIncomingPackets()

A short while above that, you should see something like the following - in your process method.

Code:

        if(disconnected) return false;
        try {
            if(timeOutCounter++ > 20) {
                actionReset();
                disconnected = true;
                return false;  }
    
            if(in == null) return false;

            int avail = in.available();
            if(avail == 0) return false;
            if(packetType == -1) {
                packetType = in.read() & 0xff;
                if(inStreamDecryption != null)
                    packetType = packetType - inStreamDecryption.getNextKey() & 0xff;
                packetSize = packetSizes[packetType];
                avail--;  }
            if(packetSize == -1) {
                if(avail > 0) {
                    packetSize = in.read() & 0xff;
                    avail--; }
                else return false; }
            if(avail < packetSize) return false;
            fillInStream(packetSize);
            timeOutCounter = 0;

            parseIncomingPackets();    
            packetType = -1;
        } catch(java.lang.Exception __ex) {    __ex.printStackTrace();  disconnected = true;
                  System.out.println("UnScape Server [fatal] - exception"); }
        return true;

Delete all of that, from (and including)

Code:

        if(disconnected) return false;
        try {

until (and including)

Code:

return true;

In its place, add the following:

Code:

return false;

Note that the actual code will vary between servers, as boolean process is probably the most edited method by beginners.


Step 3 - Creating the new packet processing method:
Ok, so you didn't have a spearate packet processing method, and you have just deleted the packet processing method which was built into your boolean process.

Now, we need to create a new packet processing method.
Firstly, find the following again:

Code:

void parseIncomingPackets()

Add the following, above the line you just found.

Code:

    public boolean packetProcess() {
        try {
            if(timeOutCounter++ > 20) {
                misc.println("Disconnected "+playerName+", Data transfer timeout.");
                disconnected = true;
                return false;
            }
            if(in == null) return false;
            int avail = in.available();
            if(avail == 0) return false;

            if(packetType == -1) {
                packetType = in.read() & 0xff;
                if(inStreamDecryption != null)
                    packetType = packetType - inStreamDecryption.getNextKey() & 0xff;
                packetSize = packetSizes[packetType];
                avail--;
            }
            if(packetSize == -1) {
                if(avail > 0) {
                    packetSize = in.read() & 0xff;
                    avail--;
                }
                else return false;
            }
            if(avail < packetSize) return false;
            fillInStream(packetSize);
            timeOutCounter = 0;
            parseIncomingPackets();
            packetType = -1;
        } catch(java.lang.Exception __ex) {
            misc.println("Exception encountered while parsing incoming packets from "+playerName+".");
            __ex.printStackTrace(); 
            disconnected = true;
        }
        return true;
    }

Ok, now you should be ready to move on to the next steps.


Step 4 - Allowing Abstract access to the packetProcess Method:
Save and Close client.java, and open up Player.java.
Search for the following:

Code:

public abstract boolean process();

Below that, add this:

Code:

public abstract boolean packetProcess();

Save and close Player.java.


Step 5 - Changing the way clients are processed:
Ok, open up PlayerHandler.java and search for the following:

Code:

players[i].preProcessing();
while(players[i].process());
players.postProcessing();

Replace that with (Updated):

Code:

try { 
	players[ i ].preProcessing();
	players[ i ].process();
	int PacketLimit = 10;
	while(players[ i ].packetProcess() && PacketLimit-- >= 0);
	players[ i ].postProcessing();
} catch(Exception e) { players[ i ].disconnected = true; }

Save and close PlayerHandler, compile & restart your server, and you're done.


The Bug - Explained
Ok, I'll explain a little bit about this bug.
What happened was, every time the client sends data to the server to tell it what it is doing, the server would loop through all of the different packets and process the player aswell as the packet for each one received.
As most of you who program private servers add things to the client process, thinking the server processes it every half second, when infact it indeed processes it approximately every half second, but also when multiple packets are recieved. This causes certain scripts to be executed ahead of when you wanted them to be, and can be quite frustrating.
This tutorial replaces the old method of processing a player (continuously processing the player until all of the received packets have been parsed) with a new one, in which it first processes the player, and then loops through the recieved packets until they have all been parsed.



Credits: All credits to me (Unborn).

Note: This tutorial was created on this page, based on an edit made by myself to my server.
If any errors are encountered, please let me know.
I apologize for any parts of this tutorial which are not easily understandable.
Please post any comments you have on this tutorial, I would like to hear them all.