PureBasic Forums - English

Code: Select all

;/-------------------\
;| GameFixer Plugin  |
;| Memory Fix        |
;|                   |
;| Version 0.01      |
;| Date: 30.04.2012  |
;| PureBasic 4.60    |
;|                   |
;| by Thorium        |
;\-------------------/

EnableExplicit

;Import all what we need from the GameFixer core.
Import "GameFixer Core.lib"
  UninstallStdProcHook(HookId.i)
  GetOrigStdProcAddr.i(HookId.i)
  InstallWin32ApiHook.i(DllName.s, ProcName.s, HookProcAddr.i)
EndImport

;We need this prototype to call GlobalMemoryStatus after we hooked it.
Prototype Proto_GlobalMemoryStatus(*lpBuffer.MEMORYSTATUS)
Global GlobalMemoryStatus.Proto_GlobalMemoryStatus

;Variable for the hook ID of the GlobalMemoryStatus hook.
Global GlobalMemoryStatusHookId.i

;Variables to hold the values we want to change inside the MEMORYSTATUS
;structure returned by GlobalMemoryStatus.
;-1 means dont change it.
Global MemoryLoad.i    = -1
Global TotalPhys.i     = -1
Global AvailPhys.i     = -1
Global TotalPageFile.i = -1
Global AvailPageFile.i = -1
Global TotalVirtual.i  = -1
Global AvailVirtual.i  = -1

;This procedure is called if the plugin DLL is first loaded.
ProcedureDLL AttachProcess(Instance.i)
  
  ;We do nothing here.
  ;It's not needed to include this procedure.
  
EndProcedure

;This procedure is called if the plugin DLL unloads.
ProcedureDLL DetachProcess(Instance.i)
  
  ;If our plugin unloads we need to uninstall the hook on GlobalMemoryStatus,
  ;or the game will crash if it calls it again.
  UninstallStdProcHook(GlobalMemoryStatusHookId)
  
EndProcedure

;We redirect all calls to GlobalMemoryStatus to this procedure.
Procedure GlobalMemoryStatusHook(*lpBuffer.MEMORYSTATUS)
  
  ;We call the original GlobalMemoryStatus procedure,
  ;to get the real values of the members in the MEMORYSTATUS structure.
  GlobalMemoryStatus(*lpBuffer)
  
  ;Change them if the user wants to.
  
  If MemoryLoad <> -1
    *lpBuffer\dwMemoryLoad = MemoryLoad
  EndIf
  
  If TotalPhys <> -1
    *lpBuffer\dwTotalPhys = TotalPhys
  EndIf
  
  If AvailPhys <> -1
    *lpBuffer\dwAvailPhys = AvailPhys
  EndIf
  
  If TotalPageFile <> -1
    *lpBuffer\dwTotalPageFile = TotalPageFile
  EndIf
  
  If AvailPageFile <> -1
    *lpBuffer\dwAvailPageFile = AvailPageFile
  EndIf
  
  If TotalVirtual <> -1
    *lpBuffer\dwTotalVirtual = TotalVirtual
  EndIf
  
  If AvailVirtual <> -1
    *lpBuffer\dwAvailVirtual = AvailVirtual
  EndIf
  
  ;The GlobalMemoryStatus function does not return anything,
  ;so we dont need to also.
  
EndProcedure

;This procedure is called by the GameFixer core to configure the plugin.
ProcedureDLL.i Config(Config.s)
  
  Protected i.i
  Protected Setting.s
  Protected Value.i
  
  ;We are parsing the config line in Config.s
  ;to know what members of the MEMORYSTATUS structure
  ;the user wants to change and to what values.
  
  For i = 1 To 100
    
    Setting = StringField(Config, i, " ")
    If Setting = ""
      Break
    EndIf
    
    Value = Val(StringField(Setting, 2, "="))

    Select LCase(StringField(Setting, 1, "="))
        
      Case "memoryload", "ml"
        MemoryLoad = Value
        
      Case "totalphys", "tp"
        TotalPhys = Value
        
      Case "availphys", "ap"
        AvailPhys = Value
        
      Case "totalpagefile", "tpf"
        TotalPageFile = Value
        
      Case "availpagefile", "apf"
        AvailPageFile = Value
        
      Case "totalvirtual", "tv"
        TotalVirtual = Value
        
      Case "availvirtual", "av"
        AvailVirtual = Value
        
    EndSelect

  Next
  
  ;Now we are installing a hook on GlobalMemoryStatus,
  ;so we can change the values of the MEMORYSTATUS
  ;every time the game calls GlobalMemoryStatus.
  ;The hook will redirect every call from GlobalMemoryStatus
  ;to our own procedure: GlobalMemoryStatusHook

  GlobalMemoryStatusHookId = InstallWin32ApiHook("Kernel32.dll", "GlobalMemoryStatus", @GlobalMemoryStatusHook())
  If GlobalMemoryStatusHookId = 0
    ;The hooking failed, so we tell the GameFixer core that our plugin failed by returning #False.
    ProcedureReturn #False
  EndIf
  
  ;We need to get a new address to call the original GlobalMemoryStatus procedure,
  ;without getting redirected to GlobalMemoryStatusHook.
  ;For easy calling later, we use a prototype here.
  GlobalMemoryStatus = GetOrigStdProcAddr(GlobalMemoryStatusHookId)
  
  ;We return #True to tell the GameFixer core that all wend fine.
  ProcedureReturn #True
  
EndProcedure

Code: Select all

;/-------------------\
;| GameFixer Plugin  |
;| MaxFPS            |
;|                   |
;| Version 0.01      |
;| Date: 29.06.2012  |
;| PureBasic 4.60    |
;|                   |
;| by Thorium        |
;\-------------------/

EnableExplicit

;Contains constants we need for the DirectDraw hooking.
XIncludeFile "GameFixer DirectDraw Hook.pbi"

;Import all what we need from the GameFixer core.
Import "GameFixer Core.lib"
  UninstallStdProcHook(HookId.i)
  GetOrigStdProcAddr.i(HookId.i)
  InstallDDrawHook.i(*Callback)
  UninstallDDrawHook(DDrawHookId.i)
  InstallDDrawProcHook(*Object, MethodeIndex.i, HookProcAddr.i)
EndImport

;We want to hook the Flip procedure and need a prototype
;to call the original procedure after it is hooked.
Prototype Proto_Flip(*this, *lpDDSurfaceTargetOverride, dwFlags.i)
Global Flip.Proto_Flip

;Holds the hook ID of the DirectDraw hook.
Global DDrawHookId.i

;Holds the hook ID of the Flip procedure hook.
Global FlipHookId.i

;Holds the FPS limit.
Global MaxFps.i

;Needed for delay calculation to limit the FPS.
Global FpsTimerDuration
Global StartTime.i

;We redirect all calls to Flip to this procedure.
;The Flip procedure swaps two surfaces (image buffer) on the graphics card.
;This is typicly used for double buffering: There is a front buffer,
;which is currently displayed and a backbuffer the game is drawing to.
;If the game completed all drawing operations it flips the buffers to
;display the drawn image. And starts over with drawing on the buffer which
;is currently not displayed.
;This is done to prevent flickering, which would occur if the game would
;draw on a buffer while it's displayed.
;So this procedure is called once per frame in most cases. And is a good
;entry point to limit the FPS.
Procedure.i DDraw_Flip_Hook(*this, *lpDDSurfaceTargetOverride, dwFlags.i)
  
  Protected Ret.i
  Protected TimeGab.i
  
  ;Calculates the delay needed to limit the FPS.
  TimeGab = FpsTimerDuration - (timeGetTime_() - StartTime)
  
  ;If a delay is needed for the FPS limiting, we wait the calculated time.
  If TimeGab > 1
    Delay(TimeGab)
  EndIf
  
  ;Calls the original Flip procedure to do the Flip.
  Ret = Flip(*this, *lpDDSurfaceTargetOverride, dwFlags)
  
  ;Gets a new start time for the delay calculation to limit the FPS.
  StartTime = timeGetTime_()
  
  ;Returns the return value of the original Flip procedure.
  ProcedureReturn Ret
  
EndProcedure

;This procedure is called back by a DirectDraw hook.
Procedure DDrawCallback(*Object, Action.i, ObjectType.i)
  
  Select Action
    
    Case #GF_DD_ObjectCreate
      ;A new DirectDraw releated object was been created.
      
      Select ObjectType
          
        ;We only want to hook the Flip procedure, so we need to wait for surface object to be created.
        Case #GF_DD_IDirectDrawSurface, #GF_DD_IDirectDrawSurface2, #GF_DD_IDirectDrawSurface3, #GF_DD_IDirectDrawSurface4, #GF_DD_IDirectDrawSurface7

          If FlipHookId = 0
            
            ;If the Flip hook is not allready installed, we install it.
            FlipHookId  = InstallDDrawProcHook(*Object, #GF_DD_IDDS_Flip, @DDraw_Flip_Hook())

            ;We need to get a new address to call the original Flip procedure,
            ;without getting redirected to DDraw_Flip_Hook.
            ;For easy calling later, we use a prototype here.
            Flip = GetOrigStdProcAddr(FlipHookId)
            
            ;Initializes StartTime for the delay calculation to limit the FPS.
            StartTime = timeGetTime_()
            
          EndIf
          
      EndSelect
    
  EndSelect
  
EndProcedure

;This procedure is called if the plugin DLL is first loaded.
ProcedureDLL AttachProcess(Instance.i)
  
  ;We do nothing here.
  ;It's not needed to include this procedure.
  
EndProcedure

;This procedure is called if the plugin DLL unloads.
ProcedureDLL DetachProcess(Instance.i)
  
  ;If our plugin unloads we need to uninstall the hooks on Flip and DirectDraw.
  UninstallStdProcHook(FlipHookId)
  UnInstallDDrawHook(DDrawHookId)
  
EndProcedure

;This procedure is called by the GameFixer core to configure the plugin.
ProcedureDLL.i Config(Config.s)
  
  ;Installs the hook on DirectDraw.
  ;After that the DDrawCallback procedure is called by the GameFixer core
  ;every time a DirectDraw releated object is created or released.
  DDrawHookId = InstallDDrawHook(@DDrawCallback())
  
  If DDrawHookId = 0
    ;The hooking failed, so we tell the GameFixer core that our plugin failed by returning #False.
    ProcedureReturn #False
  EndIf
  
  ;Sets the FPS limit by the value thats in Config.
  MaxFps = Val(Config)
  If MaxFps < 1
    ;If the FPS limit is 0 or negativ we set it to 60.
    MaxFps = 60
  EndIf
  
  ;Needed for delay calculation to limit the FPS.
  FpsTimerDuration = 1000 / MaxFps
  
  ;We return #True to tell the GameFixer core that all wend fine.
  ProcedureReturn #True
  
EndProcedure