Changeset 3233

Timestamp:

01/23/10 01:38:16 (7 weeks ago)

Author:

ghoulsblade

Message:

dragdrop/stacking fixes and walk-config-params for pol, improved packet debugging utils

Location:

trunk/lua

Files:

• lib.proxy.lua (modified) (13 diffs)
• lib.uodragdrop.lua (modified) (3 diffs)
• net/net.tooltips.lua (modified) (1 diff)
• net/net.walk.lua (modified) (12 diffs)

trunk/lua/lib.proxy.lua

@@ -17 +17 @@
         gProxyHost = host
         gProxyPort = port
-        gProxyPort2 = port+1
+        gProxyPort2 = port
+        --~ gProxyPort2 = port+1
         
         gServerListenerTCP = UOProxyOpenListener(gProxyPort)
-        gServerListenerTCP2 = UOProxyOpenListener(gProxyPort2)
+        --~ gServerListenerTCP2 = UOProxyOpenListener(gProxyPort2)
         
         print("listen port opened....")
@@ -27 +28 @@
                 local listener = gServerListenerTCP
                 while true do
-                        local newcon = listener:PopAccepted()
+                        local newcon = listener:IsAlive() and listener:PopAccepted()
                         if (not newcon) then break end
                         print("###############################")
@@ -36 +37 @@
                         print("#### PROXY : connection ended")
                         print("###############################")
-                        listener = gServerListenerTCP2
+                        --~ listener = gServerListenerTCP2
                         --~ print("proxy end") return
                 end
@@ -111 +112 @@
 
 
+gLastPacketTBySender = {}
 -- returns false if packet incomplete
 function UOProxyHandlePacket    (fifo_in,fifo_out,bIsFromClient) 
@@ -121 +123 @@
         --~ if (bIsFromServer and gProxyServerHuffmanStarted) then bInterpret = false end -- huffman comp&decomp active now
         --~ if (bIsFromClient and gProxyServerHuffmanStarted) then bInterpret = false end -- not really needed but something seems bugged
-        if (gDisableProxyInterpretation) then bInterpret = false end
+        --~ if (gDisableProxyInterpretation) then bInterpret = false end
         local bScrambleTest = false
         local bClientBlockTest = true
+        local bShortDump = false
         
         if (bInterpret) then 
@@ -177 +180 @@
                                 fifo_in:PeekNetUint8(4) == 0x24) then
                                 --~ fifo_in:PokeNetUint8(5,math.random(0,255))
-                                print("+++++++++++++++++++++++++++++++++++++++++++++++")
-                                print("detected unknownSE")
-                                print("+++++++++++++++++++++++++++++++++++++++++++++++")
+                                if (not bShortDump) then
+                                        print("+++++++++++++++++++++++++++++++++++++++++++++++")
+                                        print("detected unknownSE")
+                                        print("+++++++++++++++++++++++++++++++++++++++++++++++")
+                                end
                                 if (bScrambleTest) then 
                                         fifo_in:PokeNetUint8(5,16)
@@ -205 +210 @@
         end
         
+        
+        function Pad (str,len)
+                str = tostring(str)
+                local add = len - #str 
+                if (add > 0) then return str..string.rep(" ",add) end 
+                return str
+        end
         if (bInterpret) then 
                 local iId = fifo_in:PeekNetUint8(0)
                 local iPacketSize = gPacketSizeByID[iId]
-                print("UOProxyHandlePacket",fromname,sprintf("0x%02x",iId),gPacketTypeId2Name[iId],iPacketSize,"t="..t_since_start)
-                assert(iPacketSize)
-                if (iPacketSize == 0 and fifo_in:Size() < 3) then print("incomplete packet dynsize? <3") return end -- packet incomplete
+                assert(iPacketSize,"unknown iPacketSize for id="..hex(iId))
+                if (iPacketSize == 0 and fifo_in:Size() < 3) then print("incomplete packet dynsize? <3",hex(iId)) return end -- packet incomplete
                 if (iPacketSize == 0) then iPacketSize = fifo_in:PeekNetUint16(1) end
-                if (fifo_in:Size() < iPacketSize) then print("incomplete packet ",fifo_in:Size(),iPacketSize) return end -- packet incomplete
-                
+                if (fifo_in:Size() < iPacketSize) then print("incomplete packet ",hex(iId),fifo_in:Size(),iPacketSize) return end -- packet incomplete
+                
+                local timediff = t_since_start - (gLastPacketTBySender[fromname] or t_since_start)
+                gLastPacketTBySender[fromname] = t_since_start
+                
+                local debuginfo
+                if (1 == 1) then -- generate some debug infos
+                        if (iId == kPacket_Generic_Command) then
+                                local iBFSubCmd = fifo_in:PeekNetUint16(3)
+                                debuginfo = sprintf("subcmd=%s[0x%02x]",gGenericSubCommandNamesByID[iBFSubCmd] or "???",iBFSubCmd)
+                        elseif (bIsFromClient and iId == kPacket_Request_Movement) then 
+                                debuginfo = sprintf("dir=%2x,seq=%3d,fc=%x",fifo_in:PeekNetUint8(1),fifo_in:PeekNetUint8(2),fifo_in:PeekNetUint32(3))
+                        elseif (iId == kPacket_Accept_Movement_Resync_Request) then 
+                                debuginfo = sprintf(fromname..":a=%3d,b=%3d",fifo_in:PeekNetUint8(1),fifo_in:PeekNetUint8(2))
+                        end
+                end
+                print("UOProxyHandlePacket",fromname,sprintf("0x%02x",iId),Pad(gPacketTypeId2Name[iId],40),Pad(iPacketSize,3),"dt="..Pad(timediff,4),debuginfo)
                 
                 if (bIsFromServer and iId == kPacket_Server_List) then -- 0xA8
@@ -241 +267 @@
                         fifo_in:PokeNetUint8(6,math.mod(iGameServerPort,256)) -- port
                         
-                        gProxyServerHuffmanStartedNextRound = true
+                        gProxyServerHuffmanStartedNextRound = true  -- only after 4 byte header?
+                        gDisableProxyInterpretation = true
                         print("+++++++++++++++++++++++++++++++++++++++++++++++")
                         print("+++++    adjusted kPacket_Server_Redirect")
                         print("+++++++++++++++++++++++++++++++++++++++++++++++")
-                        gDisableProxyInterpretation = true
                 end
                 
@@ -299 +325 @@
                 ]]--
                 
-                
-                print("recv:",fromname,"t_since_start=",t_since_start) 
-                print(HexDumpUOPacket(fifo_in,iPacketSize,bIsFromClient," proxy"))
+                if (not bShortDump) then 
+                        print("recv:",fromname,"t_since_start=",t_since_start) 
+                        print(HexDumpUOPacket(fifo_in,iPacketSize,bIsFromClient," proxy"))
+                end
                 --~ print(FIFOHexDump(fifo_in,0,iPacketSize))
                 fifo_out:PushFIFOPartRaw(fifo_in,0,iPacketSize) 
@@ -359 +386 @@
         gProxyClientSendCompFifo                = CreateFIFO()
         
+        local fHuffmanDummy_RawIn                       = CreateFIFO()
+        local fHuffmanDummy_RawOut                      = CreateFIFO()
+        local fHuffmanDummy_DecompIn            = CreateFIFO()
+        local fHuffmanDummy_DecompOut           = CreateFIFO()
+        
+        
         gPacketSizeByID[0xEF] = 21 -- protocol start... dummy here
         
@@ -364 +397 @@
         while bAlive do
                 -- send 
-                gProxyServerHuffmanStarted = false
-                if (gProxyServerHuffmanStarted) then
-                        HuffmanCompress(gProxyClientSendFifo,gProxyClientSendCompFifo) -- does NOT remove data from in-fifo. compression can always be completed.
-                        gProxyClientCon:Push(gProxyClientSendCompFifo)
-                        gProxyClientSendCompFifo:Clear()
-                        gProxyClientSendFifo:Clear()
-                else 
+                --~ if (gProxyServerHuffmanStarted) then
+                        --~ HuffmanCompress(gProxyClientSendFifo,gProxyClientSendCompFifo) -- does NOT remove data from in-fifo. compression can always be completed.
+                        --~ gProxyClientCon:Push(gProxyClientSendCompFifo)
+                        --~ gProxyClientSendCompFifo:Clear()
+                        --~ gProxyClientSendFifo:Clear()
+                --~ else 
                         gProxyClientCon:Push(gProxyClientSendFifo)
                         gProxyClientSendFifo:Clear()
-                end
+                --~ end
                 
                 gProxyServerCon:Push(gProxyServerSendFifo)
@@ -385 +417 @@
                 gProxyClientCon:Pop(gProxyClientRecvFifo)
                 
+                --~ if (gProxyServerHuffmanStarted) then 
+                        --~ gProxyServerCon:Pop(gProxyServerRecvCompFifo)
+                        --~ HuffmanDecompress(gProxyServerRecvCompFifo,gProxyServerRecvFifo) -- DOES remove data from gProxyServerRecvCompFifo, might not remove all if data for decompression is not yet complete
+                --~ else
+                        gProxyServerCon:Pop(gProxyServerRecvFifo)
+                --~ end
+                
+                -- handle packets
                 if (gProxyServerHuffmanStarted) then 
-                        gProxyServerCon:Pop(gProxyServerRecvCompFifo)
-                        HuffmanDecompress(gProxyServerRecvCompFifo,gProxyServerRecvFifo) -- DOES remove data from gProxyServerRecvCompFifo, might not remove all if data for decompression is not yet complete
+                        fHuffmanDummy_RawIn:PushFIFOPartRaw(gProxyServerRecvFifo)  -- copy from ServerRecv into huffRawIn
+                        HuffmanDecompress(fHuffmanDummy_RawIn,fHuffmanDummy_DecompIn)  -- decompress from huffRawIn to huffDecompIn
+                        
+                        while UOProxyHandlePacket(fHuffmanDummy_DecompIn,fHuffmanDummy_DecompOut,false) do end  -- pipe packets from huffDecompIn to huffDecompOut
+                        HuffmanCompress(fHuffmanDummy_DecompOut,fHuffmanDummy_RawOut) -- compress from huffDecompOut to huffRawOut ... does NOT remove data from in-fifo. compression can always be completed
+                        fHuffmanDummy_DecompOut:Clear() -- clear huffDecompOut, as it has been completely compressed
+                        
+                        local bHuffmanCompBugged = true
+                        if (bHuffmanCompBugged) then
+                                -- throw away modified/filtered output
+                                -- todo : show diff fHuffmanDummy_RawOut,gProxyServerRecvFifo ?   
+                                -- ServerRecv is what we originally got from the server, as long as nothing was modified in handle, it should be the same.   maybe incomplete packets,sizediff etc..
+                                fHuffmanDummy_RawOut:Clear()
+                                
+                                -- override
+                                gProxyClientSendFifo:PushFIFOPartRaw(gProxyServerRecvFifo) 
+                                gProxyServerRecvFifo:Clear()
+                        end
                 else
-                        gProxyServerCon:Pop(gProxyServerRecvFifo)
-                end
-                gProxyServerHuffmanStarted = false
-                
-                -- handle packets
-                while UOProxyHandlePacket(gProxyServerRecvFifo,gProxyClientSendFifo,false) do end
+                        while UOProxyHandlePacket(gProxyServerRecvFifo,gProxyClientSendFifo,false) do end
+                end
                 while UOProxyHandlePacket(gProxyClientRecvFifo,gProxyServerSendFifo,true) do end
                 
@@ -409 +461 @@
         gProxyServerRecvCompFifo:Destroy()
         gProxyClientSendCompFifo:Destroy()
+        
+        fHuffmanDummy_RawIn:Destroy()
+        fHuffmanDummy_RawOut:Destroy()
+        fHuffmanDummy_DecompIn:Destroy()
+        fHuffmanDummy_DecompOut:Destroy()
 end
 

trunk/lua/lib.uodragdrop.lua

@@ -374 +374 @@
                         x = 0xffff
                         y = 0xffff
-                        z = 0
+                        x = gMousePickFoundHit.item.xloc or 0xffff
+                        y = gMousePickFoundHit.item.yloc or 0xffff
+                        z = gMousePickFoundHit.item.zloc or 0
+                        print("###############################")
+                        print("#### drop on other item in container : ",x,y,z)
+                        print("###############################")
                         target = gMousePickFoundHit.item.serial 
                         --[[
@@ -408 +413 @@
         elseif (dialog_under_mouse and dialog_under_mouse.dropOnMobileSerial) then
                 -- support drop of stuff onto dialogs
+                local mobile = GetMobile(dialog_under_mouse.dropOnMobileSerial)
+                if (mobile) then 
+                        x = 0xffff
+                        y = 0xffff
+                        z = 0
+                end
+                print("###############################")
+                print("#### drop on mobile via dialog : ",x,y,z,mobile)
+                print("###############################")
                 Send_Drop_Object(item.serial,x,y,z,dialog_under_mouse.dropOnMobileSerial)
         elseif (dialog_under_mouse and dialog_under_mouse.uoSecureTrade) then
@@ -469 +483 @@
                                 if (TestBit(flags,kTileDataFlag_Surface)) then iSerial = nil end   --  or kTileDataFlag_Background ?
                                 if (ItemIsMulti(dynamic)) then iSerial = nil end
+                                if (iSerial) then 
+                                        -- pol fix?
+                                        x = dynamic.xloc 
+                                        y = dynamic.yloc 
+                                        z = dynamic.zloc 
+                                        print("###############################")
+                                        print("#### drop on other item in world : ",x,y,z)
+                                        print("###############################")
+                                end
+                        end
+                        local mobile = GetMobile(iSerial)
+                        if (mobile) then 
+                                x = 0xffff
+                                y = 0xffff
+                                z = 0
+                                print("###############################")
+                                print("#### drop on mobile in world : ",x,y,z,mobile)
+                                print("###############################")
                         end
                 end

trunk/lua/net/net.tooltips.lua

@@ -19 +19 @@
 --endloop       - Item Info
 function Send_AosToolTipRequest(objserial)
+        if (gClientDisable_kPacket_Mega_Cliloc) then return end
         local out = GetSendFIFO()
         out:PushNetUint8(kPacket_Mega_Cliloc) -- 0xD6 runuo : BatchQueryProperties

trunk/lua/net/net.walk.lua

@@ -46 +46 @@
 
 gWalkRequestAntiStuckTimeout = 0 -- Client_GetTicks()
+gWalkRequestAntiStuckTimeoutDelay = 2000
 gNextWalkRequestTime = 0
 gNextWalkSequenceNumber = 0
@@ -57 +58 @@
 gWalkTimeout_MountRunningSpeed = 95
 gWalkTimeout_DirectionChange = 60
+gMaxWalkQueueEntries = 3
+
+
 
 
@@ -78 +82 @@
         WalkLog("FastWalk_Init end") 
 end
-function FastWalk_PushKey       (key)           WalkLog("FastWalk_PushKey",key) table.insert(gFastwalkStack,key) gFastWalkKeysUsed = true end
+function FastWalk_PushKey       (key)           
+        WalkLog("FastWalk_PushKey",key) 
+        table.insert(gFastwalkStack,key) 
+        gFastWalkKeysUsed = true 
+end
 function FastWalk_PopKey        ()
         local res = FastWalk_HasKey() and table.remove(gFastwalkStack) or 0
@@ -84 +92 @@
         return res 
 end 
-function FastWalk_Ok    ()                      return FastWalk_HasKey() or (not gFastWalkKeysUsed) end 
+function FastWalk_Ok            ()                      return FastWalk_HasKey() or (not gFastWalkKeysUsed) end 
 function FastWalk_HasKey        ()                      return notempty(gFastwalkStack) end 
 function FastWalk_CountKeys     ()                      return table.getn(gFastwalkStack) end
@@ -188 +196 @@
 -- returns false if the walk queue is full and the next request should wait
 function WalkQueueOkForNextSend ()
-        return countarr(gWalkRequests) <= 3
+        return countarr(gWalkRequests) <= gMaxWalkQueueEntries
 end
         
@@ -203 +211 @@
                 if (not WalkQueueOkForNextSend()) then
                         if (Client_GetTicks() > gWalkRequestAntiStuckTimeout) then
-                                print("walk:walk-request-timeout,sending resync-request")
+                                print("++++++++++++++++++++++++++++++ walk:walk-request-timeout,sending resync-request")
                                 Send_Movement_Resync_Request()
                         else
@@ -212 +220 @@
         end
         gProfiler_Walk:Section("ExecWalk:TimeCalc")
-        gWalkRequestAntiStuckTimeout = Client_GetTicks() + 2000 -- might need resync
+        gWalkRequestAntiStuckTimeout = Client_GetTicks() + gWalkRequestAntiStuckTimeoutDelay -- might need resync
         iDir = DirWrap(iDir)
         local iFullDir = BitwiseOR(iDir,bRunFlag and kWalkFlag_Run or 0) -- includes runflag
@@ -275 +283 @@
         out:PushNetUint32(iFastKey)
         out:SendPacket()
-        --~ print("walk:request",sprintf("0x%04x",iFullDir),iSeqNum)
+        print("++++++++++++++++++++++++++++++ walk:request",sprintf("0x%04x",iFullDir),iSeqNum,WalkGetInterval(TestBit(iFullDir,kWalkFlag_Run)))
 end
 
@@ -284 +292 @@
         local id = input:PopNetUint8()
         local iSeqNum = input:PopNetUint8()
-        --~ print("walk:accept",iSeqNum)
+        print("++++++++++++++++++++++++++++++ walk:accept",iSeqNum)
         local player_notoriety = input:PopNetUint8()
         local playermobile = GetPlayerMobile()
@@ -309 +317 @@
 function ResetWalkQueue ()
         --~ WalkLog("ResetWalkQueue start")
+        print("ResetWalkQueue,gNextWalkSequenceNumber=0")
+        print(_TRACEBACK())
         gNextWalkSequenceNumber = 0
         gWalkRequests = {}
@@ -358 +368 @@
         out:PushNetUint8(hex2num("0x00"))
         out:SendPacket()
+        print("++++++++++++++++++++++++++++++ Send_Accept_Block_Movement",seqnumber)
 end
 
@@ -376 +387 @@
         out:PushNetUint8(0)
         out:SendPacket()
+        print("++++++++++++++++++++++++++++++ Send_Movement_Resync_Request,0,0")
 end