gpkernel.pas

游戏修改工具(内存高低阶

end;
////////////根据输入值判断输出可用///////////////////////////////////////////////////////
Function  GetVarTypeAndVarValue(InputValue:String;theTaskIndex:integer):Integer;
var ByteTemp:Byte;
    WordTemp:word;
    DwordTemp:Dword;
    Int64Temp:int64;
    SingleTemp:Single;
    DoubleTemp:Double;
    ECode:integer;
begin
Result:=-999; //error value
with theTask[theTaskIndex] do
begin

   if (ScanType<>Number_Scan) and (ScanType<>String_Scan) then
   begin
   Result:=LowLevel_value;
   Exit;
   end;
   
   if (ScanType=String_Scan) then
   begin
   ScanValue:=inputvalue;
   Result:=CommonLevel_value;
   Exit;
   end;


  if ScanType=Number_Scan then
  begin

  if (VarType=Auto_value) then
     begin
//is integer
      if pos('.',inputValue)=0 then
          try
          begin
          inputValue:=HexIntChange(inputValue);
          val(inputvalue,int64Temp,Ecode);
          if Ecode>0 then Exit;
          ScanValue:=inputValue;
             if (int64Temp shr 8)=0 then Result:=Byte_value
             else if (int64Temp shr 16)=0 then Result:=Word_value
             else if (int64Temp shr 32)=0 then Result:=DWord_value
             else if (int64Temp shr 64)=0 then Result:=Int64_value
            else Result:=Int64_value;
           exit;
          end;
          except
          Exit;
          end;

       //is float
      if pos('.',inputValue)>0 then
      try
      begin
         val(inputValue,DoubleTemp,Ecode);
         if Ecode>0 then Exit;
         ScanValue:=inputValue;
         if ( DoubleTemp-Exp(ln(2)*128)>0 ) or ( DoubleTemp-Exp(ln(2)*(-126))<0) then
         Result:=Double_value else
         Result:=single_value;
         exit;
     end;
     except
     exit;
     end;

     end///Auto_value
     else
     begin

    case VarType of
    Byte_value:  begin
             val(InputValue,ByteTemp,Ecode);
             if Ecode<>0 then Exit else
             begin
             ScanValue:=InputValue;
             Result:=Byte_value;
             end;
                end;
    Word_value:  begin
             val(InputValue,WordTemp,Ecode);
             if Ecode<>0 then Exit else
             begin
             ScanValue:=InputValue;
             Result:=Word_value;
             end;
                end;
    Dword_value: begin
             val(InputValue,DwordTemp,Ecode);
             if Ecode<>0 then Exit else
             begin
             ScanValue:=InputValue;
             Result:=DWord_value;
             end;
             end;
    Int64_value: begin
             val(InputValue,int64Temp,Ecode);
             if Ecode<>0 then Exit else
             begin
             ScanValue:=InputValue;
             Result:=Int64_value;
             end;
                 end;
    Single_value:begin
             val(InputValue,SingleTemp,Ecode);
             if Ecode<>0 then Exit else
             begin
             ScanValue:=InputValue;
             Result:=Single_value;
             end;
                 end;
   Double_value:begin
             val(InputValue,DoubleTemp,Ecode);
             if Ecode<>0 then Exit else
             begin
             ScanValue:=InputValue;
             Result:=Double_value;
             end;
                end;
   String_value:begin
             ScanValue:=InputValue;
             Result:=String_value;
               end;

   end; //case end;

     end; ///not auto_value End;

   end;///Extrac_scan end
end;///with end;
end;
///////////////////////////////////////////////////////////////////////////////////////////
/////////////得到进程在内存的起始位置大小/////////////////////////////////
Procedure GetMemoryRanges(theTaskIndex:integer);
var TempStartAddress: Dword;
    TempEndAddress:Dword;
    Tempsize:DWord;
    i,j,k,m:Integer;
    NewMemoryRegions:array [0..20000] of TmemoryRegion;
begin
With theTask[theTaskIndex] do
begin
   MemoryRegionsIndex:=0;
   TempStartAddress:=FromAddress;
   TempEndAddress:=ToAddress;

////////////////////////////////
While (VirtualQueryEx(ProcessHandle,pointer(TempStartAddress),MBI,sizeof(MBI))>0) and (TempStartAddress<TempEndAddress) do
begin
   if (MBI.State=MEM_COMMIT)   then  //许可操作内存??
    begin      
        if (MBI.Protect=PAGE_READWRITE) or
           (MBI.Protect=PAGE_WRITECOPY) or
           (MBI.Protect=PAGE_EXECUTE_READWRITE) or
           (MBI.Protect=PAGE_EXECUTE_WRITECOPY) 
        then
        begin
          MemoryRegions[MemoryRegionsIndex].BaseAddress:=Dword(MBI.BaseAddress);
          MemoryRegions[MemoryRegionsIndex].MemorySize:=MBI.RegionSize;
          inc(MemoryRegionsIndex); /// so MemoryRegions[MemoryRegionsIndex]is invalid
        end;
    end;
    TempStartAddress:=Dword(MBI.BaseAddress)+MBI.RegionSize;
end;
if MemoryRegionsIndex=0 then Exit;
////检查由VirtualQueryEx内存范围是否真的在用户指定范围 ///////////////,
with  MemoryRegions[0] do
begin
  if (BaseAddress<FromAddress)  and  (BaseAddress+MemorySize-FromAddress>0 )  then
  begin
    MemorySize:=BaseAddress+MemorySize-FromAddress;
    BaseAddress:=FromAddress;
  end;
end;
////右边界//////////////////
with  MemoryRegions[MemoryRegionsIndex-1] do
begin
 if (BaseAddress+MemorySize)>ToAddress   then
 begin
 Dec( MemorySize,(BaseAddress+MemorySize-ToAddress) );
 end;
end;

////////////////////
//!!!!!!!!!!!警告内存块不能过大否则以后不能正常读写///////////////////////////
/////将连续的内存块整合起来/////////////////////////////////////////////////////////////////////////
  j:=0;
  TempStartaddress:=memoryregions[0].BaseAddress;
  Tempsize:=memoryregions[0].MemorySize;

  for i:=1 to memoryregionsIndex-1 do
  begin
    if memoryregions[i].BaseAddress=TempStartaddress+Tempsize then
    begin
      inc(Tempsize,memoryregions[i].MemorySize);
    end
    else
    begin
      memoryregions[j].BaseAddress:=TempStartaddress;
      memoryregions[j].MemorySize:=Tempsize;

      TempStartaddress:=memoryregions[i].BaseAddress;
      Tempsize:=memoryregions[i].MemorySize;
      inc(j);
    end;
  end;

  memoryregions[j].BaseAddress:=TempStartaddress;
  memoryregions[j].MemorySize:=Tempsize;
  memoryregionsIndex:=j+1;       // fit MemoryRegions[MemoryRegionsIndex]is invalid

///分隔内存如果某一块过大以后用Stream,以及动态数组都将退出程序  ////////////////////////

  j:=0;
  i:=0;
  while i<=MemoryregionsIndex-1 do
  begin
    k:=(memoryregions[i].MemorySize div SplitValue);
    if k>0 then
    begin
      for m:=0 to k do
      begin
      NewMemoryRegions[j].BaseAddress:=Memoryregions[i].BaseAddress+SplitValue*m;

      if m<k then    NewMemoryRegions[j].MemorySize:=Splitvalue else
      NewMemoryRegions[j].MemorySize:=Memoryregions[i].MemorySize-SplitValue*m;
      inc(j);
      end;
    end else
    begin
     Newmemoryregions[j].BaseAddress:=Memoryregions[i].BaseAddress;
     Newmemoryregions[j].MemorySize:=Memoryregions[i].MemorySize;
     inc(j);
    end;
   
  inc(i);
  end;
//////////////////////////////////////////////
  MemoryRegionsIndex:=j; //  MemoryRegions[MemoryRegionsIndex]is invalid
  for i:=0 to MemoryRegionsIndex-1 do
  begin
  Memoryregions[i].BaseAddress:=Newmemoryregions[i].BaseAddress;
  Memoryregions[i].MemorySize:=NewMemoryregions[i].MemorySize;
  end;
///////////////////////////////////////////////////////////////////////////////

 for i:=0 to MemoryRegionsIndex-1 do
TotalProcess:=TotalProcess+MemoryRegions[i].MemorySize;
NowProcess:=0;
     
end;////end with
end;
//////必须考虑前面的搜索类型
function AnalyseScan(theIndex:Integer):integer;
var thehandle:Dword;
    TempLength:Dword;
    TempSize:Dword;
begin
result:=-999;
with theTask[theIndex] do
begin
    ////////////////////检查应用程序是否关闭 /////////////////////////////////////
    theHandle:=OpenProcess(PROCESS_ALL_ACCESS,False,ProcessID);
    if theHandle=0 then
    begin
    Result:=0;
     Exit;
    end;
    ProcessHandle:=thehandle;
    ////////////////////////////////////////////////////////////
    if  SearchTimes=0 then
    begin
     Result:=4;
     exit;
    end;
   /////////////////////是否重复低阶搜索初始化////////////////////////////////////////
    if ((SearchTimes=1) and (OldVartype=LowLevel_value) and (ScanType=InitialLowLevel_Scan) )then
    begin
     Result:=1;
     Exit;
    end;
   //////////////////高低阶是否匹配///////////////////////////////////////////////
   if SearchTimes>0 then
   begin
     if ( (OldVarType=Lowlevel_Value) and (VarType<>Lowlevel_Value) )  or
        ( (OldVarType<>Lowlevel_Value) and (VarType=Lowlevel_Value)) 
    then
   begin
   result:=2;
   exit;
   end;

  end;
  /////////////////////确定搜索范围大小，////////////////////////////////////////////////////////////
   if SearchTimes>0 then
   begin
    if (SearchTimes=1) and (OldvarType=LowLevel_Value) then
    begin
     TempLength:=AdvancedAddressMemStream.Size;
     TempSize:=TempLength shr 3;  ////Dword  Address Dword Size
    end else
    begin
     TempLength:=AddressMemStream.Size;
     TempSize:=TempLength shr 2;
    end;
    if TempSize=0 then     begin      Result:=3;      exit;   end;
    TotalProcess:= TempSize;
    Result:=4;/////ok
    end;
  ///////////////////////////////

    
end;//////with end
end;

//////////////////初次扫描////////////////////////////////
constructor TFirstScanThread.Create(theIndex:integer);
begin
TheTaskIndex:=theIndex;
FreeOnTerminate:=True;
inherited Create(False);
end;


Procedure TFirstScanThread.Execute;
var ReadMemory_ArrayByte: Array[0..$FFFF] of Byte;
    ReadMemory_ArrayWord: Array[0..$7FFF] of Word;
    ReadMemory_ArrayDWord: Array[0..$3FFF] of Dword;
    ReadMemory_ArrayInt64: Array[0..$1FFF] of Int64;
    ReadMemory_ArraySingleDword:Array[0..$3FFF] of Dword; //single length is same to dowrd
    ReadMemory_ArrayDoubleInt64: Array[0..$1FFF] of int64; //Double length is same to int64
    ReadMemory_ArrayStringByte:Array[0..$FF] of Byte;
    AdvancedReadMemory_ArrayByte:Array[0..$FFFF] of Byte;
    AdvancedReadFile_ArrayByte:Array[0..$FFFF] of Byte;
    
var TempLength: DWORD;               ////每个内存块的大小字节
    TempSize:DWORD;                 ////缓存区array num的数目
    ActualRead:Dword;
    PhelpSingleDword:^Dword;
    helpsingleDWord1:DWord;  //存放原数的符号位与指数位
    HelpSingleDword2:Dword;

    PhelpDoubleint64:^int64;
    helpDoubleint641:int64;  //存放原数的符号位与指数位
    HelpDoubleint642:int64;

    HelpStringLength:Byte;
    chartoFind:integer;

    Time1:Dword;
    Time2:Dword;

    i: integer;
    j: integer;
    k: integer;

    ByteValue: Byte;
    WordValue: Word;
    DWordValue: Dword;
    Int64Value: Int64;
    SingleValue: Single;
    doubleValue: double;


    tempAddress:Dword;
    actualwrite:Dword;
    MemoryFileStream:TFileStream;  ///低阶内存svae to memroyFilename
begin

with theTask[theTaskIndex] do
begin
GetMemoryRanges(theTaskIndex);
if MemoryRegionsIndex=0 then
begin
Raise Exception.Create(String_Nomemory);
Exit;
end;

/////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////
/////////////再次并得到最终数据/////////////////////////////////////////
if (scanType=Number_Scan) then
begin
    if Vartype=Byte_value then
    begin
      val(scanvalue,bytevalue,i);
      if i>0 then raise Exception.Create(Format(String_InvalidByte,[scanvalue]));
    end;
    if vartype=word_value then
    begin
      val(scanvalue,wordvalue,i);
      if i>0 then raise Exception.Create(Format(String_InvalidWord,[scanvalue]));
    end;
    if vartype=dword_value then
    begin
      val(scanvalue,dwordvalue,i);
      if i>0 then raise Exception.Create(Format(String_InvalidDword,[scanvalue]));
    end;
    if vartype=Int64_value then
    begin
      val(scanvalue,Int64value,i);
      if i>0 then raise Exception.Create(Format(String_InvalidInt64,[scanvalue]));
    end;
   if vartype=single_value then
    begin
      val(scanvalue,singlevalue,i);
      if i>0 then raise Exception.Create(Format(String_InvalidSingle,[scanvalue]));
    end;
    if vartype=double_value then
    begin
      val(scanvalue,doublevalue,i);
      if i>0 then raise Exception.create(Format(String_InvalidDouble,[scanvalue]));
    end;
    if vartype=String_value then