Debug.scar

{==============================================================================\
|                         MSI Group Scripting Include                          |
|                                 Debug.scar                                   |
|==============================================================================|
| For all debugging and progress report routines                               |
|                                                                              |
| * procedure MSI_Debug();                           * by Rasta Magician       |
| * procedure MSI_AddToProggy();                     * by The MSI Team         |
| * function MSI_SkillActions(): TStringArray;       * by The MSI Team         |
| * procedure MSI_GetReportInfo();                   * by Coh3n                |
| * function MSI_LocToText(): String;                * by The MSI Team         |
| * function MSI_LocToCity(): String;                * by The MSI Team         |
| * function MSI_GroupDigits(): String;              * PriSoner and Nava2      |
| * function MSI_PrintSave;                          * by Naum                 |
| * Procedure MSI_SaveLog;                           * by Naum                 |
| * procedure MSI_ProgressReport();                  * by Coh3n                |
 \_____________________________________________________________________________}
 

{******************************************************************************}
{ procedure MSI_Debug(ProcName, TheMessage: string; DebugLevel:integer);       }
{ By: Rasta Magician                                                           }
{ Date: 10 June 2010                                                           }
{ Description: Used for Debugging. Will debug to DebugBox if                   }
{              DebugLevel >= Debug_LevelToDebug                                }
{******************************************************************************}
procedure MSI_Debug(ProcName, TheMessage: string; DebugLevel:integer);
var
  DebugMSG, path, str: string;
  theFile: Integer;
begin
  if DebugLevel < Debug_LevelToDebug then exit;
  DebugMSG := TheTime+': ';

  try
    DebugMSG := DebugMSG + Capitalize(Players[CurrentPlayer].Name)+': ';
  except end;
  
  case DebugLevel of
    //to add some more detail
    DEBUG_PLAYER_ACTIONS: DebugMSG := DebugMSG + 'Player Action: ';
    DEBUG_FUNCTIONS     : DebugMSG := DebugMSG + 'Entering Func: ';
    DEBUG_SMALL_DETAILS : DebugMSG := DebugMSG + 'Detail: ';
  end;
  
  DebugMSG := DebugMSG + ProcName + ': ';
  DebugMSG := DebugMSG + TheMessage;
  writeln(DebugMSG);

  //Save the message to a file
  if (saveDebug) then
    try
      path := AppPath + 'Includes\SRL\SRL\msi\MSI Logs\';
      if FileExists(path + scriptStart + '.txt') then
      begin
        theFile := OpenFile(path + scriptStart + '.txt', False);
        ReadFileString(theFile, str, FileSize(theFile));
        CloseFile(theFile);
      end;

      theFile := RewriteFile(path + scriptStart + '.txt', False);

      WriteFileString(theFile, str + #10 + DebugMSG);
      CloseFile(theFile);
    except
      Writeln('Debug saving - error occurred');
    end;
end;

{******************************************************************************}
{ procedure MSI_AddToProggy(item, quantity, which: Integer);                   }
{ By: The MSI Team                                                             }
{ Date: 10 June 2010                                                           }
{ Description: Adds specified element to the progress report - if parameter    }
{              is unused, set to -1                                            }
{******************************************************************************}
const
  ADD_EXP   = 0;
  ADD_ITEMS = 1;
  ADD_LOADS = 2;
procedure MSI_AddToProggy(item, quantity, which: Integer);
begin
  if (quantity = 0) then
    Exit;

  case which of
    ADD_EXP:
      begin
        IncEx(ProgressReportArray[CurrentPlayer].SkillInfo[CurrentSkill].TotalEXP, quantity);
        IncEx(Stats_CustomVars[STATS_EXP], quantity);
      end;
      
    ADD_ITEMS:
      begin
        IncEx(ProgressReportArray[CurrentPlayer].SkillInfo[CurrentSkill].ObjQuants[item], quantity);

        case PlayerSkills[CurrentPlayer][CurrentSkill] of
          SKILL_WOODCUTTING:
            IncEx(Stats_CustomVars[STATS_LOGS], quantity);
            
          SKILL_MINING:
            IncEx(Stats_CustomVars[STATS_ORES], quantity);
        end;
      end;
      
    ADD_LOADS:
      begin
        Inc(ProgressReportArray[CurrentPlayer].SkillInfo[CurrentSkill].TotalLoads);
        Inc(Stats_CustomVars[STATS_LOADS]);
      end;
  end;
  
  MSI_SendStats;
end;

{******************************************************************************}
{ function MSI_SkillActions(what: variant): TStringArray;                      }
{ By: The MSI Team                                                             }
{ Date: 10 June 2010                                                           }
{ Description: Gets an array of skill actions                                  }
{******************************************************************************}
function MSI_SkillActions(what: variant): TStringArray;
begin
  case what of
{
    SKILL_ATTACK        : Result := ['Attack', 'Attacked'];
    SKILL_STRENGTH      : Result := ['Stength', 'Strengthed'];
    SKILL_DEFENSE       : Result := ['Defence', 'Defended'];
    SKILL_RANGE         : Result := ['Range', 'Ranged'];
    SKILL_PRAYER        : Result := ['Prayer', 'Prayed'];
    SKILL_MAGE          : Result := ['Magic', 'Maged'];
    SKILL_RUNECRAFTING  : Result := ['Runecrafting', 'RuneCrafted'];
    SKILL_HP            : Result := ['Hitpoints', 'HPed'];
    SKILL_AGILITY       : Result := ['Agility', 'Agilised'];
    SKILL_HERBLORE      : Result := ['Herblore', 'Herblored'];
    SKILL_THIEVING      : Result := ['Thieving', 'Thieved'];
    SKILL_CRAFTING      : Result := ['Crafting', 'Crafted'];
    SKILL_FLETCHING     : Result := ['Flecthing', 'Flecthed'];
    SKILL_SLAYER        : Result := ['Slayer', 'Slayed'];
    SKILL_MINING        : Result := ['Mining', 'Mined'];
    SKILL_SMITHING      : Result := ['Smithing', 'Smithed'];
    SKILL_FISHING       : Result := ['Fishing', 'Fished'];
    SKILL_COOKING       : Result := ['Cooking', 'Cooked'];
    SKILL_FIREMAKING    : Result := ['Firemaking', 'Burned'];
}
    SKILL_WOODCUTTING   : Result := ['Woodcutting', 'Chopped'];
{
    SKILL_FARMING       : Result := ['Farming', 'Farmed'];
    SKILL_CONSTRUCTION  : Result := ['Construction', 'Constructed'];
    SKILL_HUNTER        : Result := ['Hunter', 'Hunted'];
    SKILL_SUMMONING     : Result := ['Summoning', 'Summoned'];
}
  end;
end;

{******************************************************************************}
{ procedure MSI_GetReportInfo;                                                 }
{ By: Coh3n                                                                    }
{ Date: 10 June 2010                                                           }
{ Description: Gets the necessary proggy info that ISN'T reset during runtime  }
{******************************************************************************}
procedure MSI_GetReportInfo;
var
  i, level: Integer;
  skills: TVariantArray;
  theSkill: TStringArray;
begin
  //Gets the levels of each skill in the Players array
  skills := PlayerSkills[CurrentPlayer];
  for i := 0 to High(skills) do
  begin
    theSkill := MSI_SkillActions(skills[i]);
    level := GetSkillLevel(theSkill[0]);
    ProgressReportArray[CurrentPlayer].SkillInfo[i].Level := level;
  end;
  
  //Gets the player's location
  ProgressReportArray[CurrentPlayer].PlayerLoc := Players[CurrentPlayer].Integers[P_LOC];
  //Gets teh player's activity
  ProgressReportArray[CurrentPlayer].PlayerStatus := Players[CurrentPlayer].Active;
end;

{******************************************************************************}
{ function MSI_LocToText(Which: Integer): string;                              }
{ By: The MSI Team                                                             }
{ Date: 10 June 2010                                                           }
{ Description: Converts the location constant to a string                      }
{******************************************************************************}
function MSI_LocToText(Which: Integer): string;
begin
  case Which of
    LOC_POWER_SKILL:
      Result := 'Powerskilling';
  
    LOC_LOST:
      Result := 'Lost';
      
    LOC_VE_BANK:
      Result := 'Varrock east bank';
      
    LOC_VE_TREES:
      Result := 'Varrock east trees';
      
    LOC_IN_RANDOM:
      Result := 'In random';
      
    else
      MSI_Debug('MSI_LocToText', 'Invalid location!', debug_Functions);
  end;
end;

{******************************************************************************}
{ function MSI_LocToCity(which: Integer): string;                              }
{ By: The MSI Team                                                             }
{ Date: 10 June 2010                                                           }
{ Description: Converts the location constant to a string of the RS city       }
{******************************************************************************}
function MSI_LocToCity(which: Integer): string;
begin
  case Which of
    LOC_VE_BANK, LOC_VE_TREES:
      Result := 'Varrock';

    else
      Result := 'The wonderful world of Runescape!';
  end;
end;


{******************************************************************************}
{ function MSI_GroupDigits(n: integer; token: String): String;                 }
{ By: PriSoner and Nava2                                                       }
{ Date: 10 June 2010                                                           }
{ Description: Formats an integer into groups of 3 seperated by `token' and    }
{              returns a formatted string (i.e 1234567 would become 1,234,567) }
{******************************************************************************}
function MSI_GroupDigits(n: integer; token: String): String;
var
  b: integer;
begin
  Result := IntToStr(n);
  b := length(Result) + 1;
  if b > 3 then
  repeat
    b := b - 3;
    if b > 1 then
      insert(token, Result, b);
  until (b < 3);
end;

{******************************************************************************}
{ procedure MSI_PrintSave(FileH, S : String);                                  }
{ By: Naum                                                                     }
{ Date: 10 June 2010                                                           }
{ Description: Prints the string in the report and debug box also saves the    }
{              report                                                          }
{******************************************************************************}
Procedure MSI_PrintSave(FH : Integer; S : String);
Begin
  {$IFDEF SIMBA}
    Writeln(s);
  {$ELSE}
    AddToReport(S);
  {$ENDIF}

  if (saveDebug) then
    WriteFileString(FH, S+#13+#10);
End;

{******************************************************************************}
{ procedure MSI_ProgressReport;                                                }
{ By: Coh3n                                                                    }
{ Date: 10 June 2010                                                           }
{ Description: Prints the progress report of each player                       }
{******************************************************************************}
function MSI_GetItemList(whichPlayer, whichSkill: Integer): TIntegerArray; forward;
procedure MSI_ProgressReport;
var
  i, j, k, FileH: Integer;
  skill: TStringArray;
  intItems: TIntegerArray;
  path: String;
begin
  try
    if (saveDebug) then
    begin
      path := AppPath + 'Includes\SRL\SRL\MSI\MSI Progress Reports\';
      FileH := ReWriteFile(path + scriptStart + '.txt', False);
      WriteFileString(FileH, 'Progress Report Saved:' + #13 + #10);
      WriteFileString(fileH, #13 + #10 + 'This proggie was written ' + TheDate(Date_Formal )+ ' at ' + TheTime + #13 + #10);
    end;

    {$IFNDEF SIMBA}
      ClearReport;
    {$ENDIF}
    ClearDebug;
    MSI_GetReportInfo;
    MSI_PrintSave(FileH, '{----------------------------------------------------------------}');                   //64 from '{' to '}'
    MSI_PrintSave(FileH, '{                   MSI Phoenix Player Report                    }');
    MSI_PrintSave(FileH, '{------------------------------ ' + MSI_VERSION_NUMBER + ' -----------------------------}');
    MSI_PrintSave(FileH, '{     ' + PadR('Time Running: ' + TimeRunning, 59) + '}');
    MSI_PrintSave(FileH, '{----------------------------------------------------------------}');

    for i := 0 to (HowManyPlayers - 1) do
      with ProgressReportArray[i] do
      begin
        MSI_PrintSave(FileH, '{                                                                }');
        MSI_PrintSave(FileH, '{     ' + PadR('Player ' + IntToStr(i) + ': ' + Capitalize(PlayerName), 59) + '}');       //PlayerName
        MSI_PrintSave(FileH, '{     ' + PadR('City: ' + PlayerCity, 59) + '}');                          //PlayerCity
        MSI_PrintSave(FileH, '{     ' + PadR('Location: ' + MSI_LocToText(PlayerLoc), 59) + '}');                                      //PlayerLoc
        MSI_PrintSave(FileH, '{     ' + PadR('Time: ' + MsToTime(PlayerTime, Time_Short), 59) + '}');                   //TotalTime
        MSI_PrintSave(FileH, '{     ' + PadR('Active: ' + Capitalize(BoolToStr(PlayerStatus)), 59) + '}');              //PlayerStatus

        if (not PlayerStatus) then                                                                                      //FalseReason
          MSI_PrintSave(FileH, '{       ' + PadR('Reason: ' + FalseReason, 57) + '}');

        MSI_PrintSave(FileH, '{                                                                }');

        for j := 0 to High(SkillInfo) do                                                                                //SkillInfo
          with SkillInfo[j] do
          begin
            skill := MSI_SkillActions(PlayerSkills[CurrentPlayer][j]);
            MSI_PrintSave(FileH, '{     ' + PadR('Skill: ' + skill[0], 59) + '}');
            MSI_PrintSave(FileH, '{       ' + PadR('Time: ' + MsToTime(TotalTime, Time_Short), 57) + '}');              //TotalTime                                           }
            MSI_PrintSave(FileH, '{       ' + PadR('Loads: ' + IntToStr(TotalLoads), 57) + '}');                        //TotalLoads                                   }
            MSI_PrintSave(FileH, '{       ' + PadR('Experience: ' + MSI_GroupDigits(Round(TotalEXP), ','), 57) + '}');  //TotalEXP

            if (Level < 1) then
              MSI_PrintSave(FileH, '{       ' + PadR('Level: Not yet defined', 57) + '}')
            else
              MSI_PrintSave(FileH, '{       ' + PadR('Level: ' + IntToStr(Level), 57) + '}');                           //Level

            intItems := MSI_GetItemList(i, j);
            for k := 0 to High(intItems) do                                                                             //TotalObj
            begin
              MSI_PrintSave(FileH, '{         ' + PadR('Item: ' + MSI_Item[intItems[k]].Name, 55) + '}');
              MSI_PrintSave(FileH, '{         ' + PadR('Amount: ' + MSI_GroupDigits(ObjQuants[k], ','), 55) + '}');     //ObjQuants
            end;

            MSI_PrintSave(FileH, '{                                                                }');
            MSI_PrintSave(FileH, '{----------------------------------------------------------------}');
          end;
      end;

    MSI_PrintSave(FileH, '{----------------------------------------------------------------}');

    if (saveDebug) then
      CloseFile(FileH);
  except
    WriteLn('Proggie saving - error occured');
  end;
end;