Ist das hier Delphi ?

[Eifelhexe]

Hallo,
ich hoffe hier Hilfe zu finden und zwar geht es um Folgendes:
vorneweg, ich habe keine Ahnung vom Programmieren aber ich muss trotzdem einen Quellcode aendern
bzw nur ein paar Worte vom Deutschen ins englische uebersetzen, damit das Programm fuer meine Zwecke verwendbar ist und dann das Ding natuerlich wieder ans Laufen bringen.
den kompletten Quellcode habe ich hier runtergeladen:
http://moras.svn.sourceforge.net/vie...branches/1.73/

und ja ich habe auch schon mit einem Resource Editor versucht, aber die zu uebersetzenden Woerter finde ich nur in diesem untenstehenden Quellcode.
aber bevor ich euer Forum mit "doofen" Fragen zuspamme frage ich lieber erst mal ob das hier ueberhaupt Delphi code ist

Code:

/*****************************************************************************/
/*                                                                           */
/* Moras Ausrüstungsplaner für Dark Age of Camelot                           */
/* Copyright (C) 2003 - 2004  Mora                                           */
/*                                                                           */
/* This program is free software; you can redistribute it and/or modify      */
/* it under the terms of the GNU General Public License as published by      */
/* the Free Software Foundation; either version 2 of the License, or         */
/* (at your option) any later version.                                       */
/*                                                                           */
/* This program is distributed in the hope that it will be useful,           */
/* but WITHOUT ANY WARRANTY; without even the implied warranty of            */
/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the             */
/* GNU General Public License for more details.                              */
/*                                                                           */
/* You should have received a copy of the GNU General Public License         */
/* along with this program; if not, write to the Free Software               */
/* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
/*                                                                           */
/*****************************************************************************/

//---------------------------------------------------------------------------


#include <assert.h>
#include <StrUtils.hpp>

#pragma hdrstop

#include "ChatLog.h"
#include "Utils.h"
#include "MainFrame.h"   // Brauch die xml_config Struktur

// Mit diesem String beginnt der Info-Bereich
const char strInfoStart[] = "<Info-Beginn:";
// Mit diesem String endet der Info-Bereich
const char strInfoStop[] = "<Info-Ende>";
// Mit diesem String beginnt der Info-Bereich
const char strMagBoniStart[] = "Magieboni:";
// Ein paar Strings zur identifikation bestimmter Werte
const char strAF[] = "Ausgangswert";
const char strAbsorb[] = "Absorption";   // Daraus läßt sich Rüstungsklasse gewinnen
const char strQuality[] = "Qualität";
const char strSpeed[] = "Waffengeschwindigkeit";
const char strUnique[] = "Einzigartiger Gegenstand";
const char strCrafted[] = "Hergestellt von:";
const char strBonus[] = "Bonus auf";
const char strBonus2[] = "Bonus zum";
const char strRestriction[] = "Geeignet für:";
const char strArtifact[] = "Artefakt:";
const char strActivLevel[] = "  (Benötigte Objektstufe:";

//---------------------------------------------------------------------------
CChatLog::CChatLog()
{
   fChatLog = NULL;
   arItemNames =  new TStringList;
};

CChatLog::~CChatLog()
{
   CloseChatLog();
   delete arItemNames;
};

// Öffnet die ChatLog-Datei für Lesezugriff
int CChatLog::OpenChatLog(const char* Filename)
{
   if (fChatLog != NULL) delete fChatLog;
   // Seek funktioniert nur richtig im binary-mode. Nur ist jetzt immer /r hinter einem String
   fChatLog = new fstream(Filename, ios_base::in | ios_base::binary);
   iLineNo = 0;
   if (fChatLog->is_open()) return true;
   else return false;
};

void CChatLog::CloseChatLog()
{
   if (fChatLog != NULL)
   {
      fChatLog->close();
      delete fChatLog;
   }
   fChatLog = NULL;
};

// enumwerte des Parsers in Init
enum ParserStateInit
{
   STATE_START,   // Scanne nach Start einer Info-Section
   STATE_ITEM,   // Suche danach in der Sektion, das es ein Gegenstand ist
};

// Diese Funktion scannt erstmal das gesamte Log nach Gegenständen und merkt
// sich deren Position. In einem zweiten durchlauf wird versucht, die Herkunft
// der Gegenstände herauszubekommen. Doppelte Items werden herausgefiltert
void CChatLog::Init(void)
{
   int posStart;   // Startposition des aktuellen Info-Bereichs
   AnsiString strName;   // Name des aktuellen Info-Bereichs
   char Line[1024];   // Hier eine maximale Länge eines Textes heruasfinden
   bool bIsItem;

   nItems = 0;
   iLineNo = 0;
   arItemNames->Clear();
   arOffsets.Length = 0;
   ParserStateInit State = STATE_START;
   fChatLog->seekg(0, ios::beg);   // Lesezeiger auf Dateianfang
   fChatLog->getline(Line, 1024);
   while(!fChatLog->eof())
   {
      assert(StrLen(Line) < 1024);
      iLineNo++;
      switch (State)
      {
      case STATE_START:
         {   // Suche nach dem Start eines Info-Bereichs
            char *pStart = AnsiStrPos(Line, (char*)strInfoStart);
            if (pStart != NULL)
            {
               posStart = fChatLog->tellg() - fChatLog->gcount();
               AnsiString sTemp = pStart;
               strName = sTemp.SubString(sizeof(strInfoStart) + 1, StrLen(pStart) - sizeof(strInfoStart)- 2);
               // Jetzt mal schauen, ob es einen Doppelpunkt gibt.
               int p = strName.AnsiPos(':');
               if (p > 0)
               {   // Wenn ja, dann den String bis dorthin abschneiden
                  strName = strName.SubString(p + 2, strName.Length() - p - 1);
               }
               bIsItem = false;
               State = STATE_ITEM;
            }
         }
         break;
      case STATE_ITEM:
         {   // Suche nach Magieboni oder Info-Sektion Ende
            char *pStart = AnsiStrPos(Line, (char*)strMagBoniStart);
            if (pStart != NULL) bIsItem = true;
            // Ist Info-Sektion zu Ende?
            pStart = AnsiStrPos(Line, (char*)strInfoStop);
            if (pStart != NULL)
            {
               State = STATE_START;   // Nach der nächsten Info-Sektion suchen
               if (bIsItem)
               {   // Ende Info-Sektion und es ist ein Gegenstand
                  // Also in die Liste der zu untersuchenden Gegenstände aufnehmen
                  int index;
                  if ((index = arItemNames->IndexOf(strName)) == -1)
                  {   // Item mit diesem Namen gibts noch nicht (im Logfile)
                     arItemNames->Add(strName);
                     arOffsets.Length = nItems + 1;
                     arOffsets[nItems] = posStart;
                     nItems++;
                  }
                  else
                  {   // Name gibts schon. Offset aber auf diesen setzen,
                     // da immer das letzte das aktuellste sein sollte
                     arOffsets[index] = posStart;
                  }
               }
            }
         }
         break;
      }

      fChatLog->getline(Line, 1024);
   }
}

// Diese Funktion macht die eigentliche Lesearbeit
// Input ist dabei der Index des zu beschaffenden Items und einen Zeiger
// auf eine CItem-Klasse, welche ausgefüllt werden soll
// Rückgabe ist true für keinen Fehler
int CChatLog::GetItem(int index, CItem* Item)
{
   int i;
   char Line[1024];   // Hier eine maximale Länge eines Textes heruasfinden
   char sArg[64];   // Längere Bonusbezeichnungen gibts glaub nicht
   int NextBonus = 0;   // Welche Position soll der nächste Bonus eingetragen werden
   int NextRestriction = 0;   // Nächster Index einer Klassenbeschränkung
   bool bRestriction = false;

   if ((index < 0) && (index >= nItems)) return false;   // Itemindex nicht im gültigen Bereich
   Item->Init();
   Item->Name = arItemNames->Strings[index];
   Item->Realm = player->Realm;   // Immer Realm des Spielers annehmen
   Item->Quality = 0;
   // Versuche Aufgrund des Namen auf den Itemslot zu schliessen
   AnsiString strTemp = Item->Name.LowerCase();
   for (i = 0; i < 18; i++)
   {
      for (int j = 0; j < xml_config.arItemSlots[i].arIds.Length; j++)
      {
         if (strTemp.AnsiPos(xml_config.arItemSlots[i].arIds[j]) > 0)
            Item->Position = i;
      }
   }
   // Lesezeiger auf Beginn der entsprechenden Info-Sektion stellen
   fChatLog->clear();   // Ist nötig, da wir eventuell noch im eof-state sind
   fChatLog->seekg(arOffsets[index], ios::beg);
   fChatLog->getline(Line, 1024);   // Erste Zeile Lesen (kann ignoriert werden)
   fChatLog->getline(Line, 1024);   // Erste Zeile mit Infos
   while(!fChatLog->eof())
   {
      assert(StrLen(Line) < 1024);
      int Value = 0;
      // Ist Info-Sektion zu Ende?
      char   *pStart = AnsiStrPos(Line, (char*)strInfoStop);
      if (pStart!= NULL) break;
      if (Line[11] == '-')
      {   // Alles danach ist ein Wert, der mich interessiert
         // Suche erstmal nach einem Zahlenwert. Sollte immer nur einer sein
         // Bonus-Argument ist immer der String vor einem Doppelpunkt,
         // oder der String hinter einer Zahl
         bool bValue = false;   // Gibts eine Zahl?
         bool bDoppel = false;   // gibt es einen Doppelpunkt im String
         bool bPercent = false;   // Es ist ein Prozent-Wert
         int pArg = 0;   // Aktuelle Position im Argument-String
         for (i = 13; i < StrLen(Line); i++)
         {
            if ((Line[i] >= '0') && (Line[i] <= '9'))
            {
               bValue = true;
               Value = Value * 10 + Line[i] - '0';
            }
            else if (Line[i] == ':') bDoppel = true;
            else if (Line[i] == ' ')
            {
               if (bValue && (bDoppel || (pArg > 0))) break;
               pArg = 0;
            }
            else if (Line[i] == '%')
               bPercent = true;
            else if ((Line[i] == '\r') || (Line[i] == '.')) {}   // Diese Zeichen ignorieren
            else
            {
               sArg[pArg++] = Line[i];
               sArg[pArg] = 0;
            }
         }
         if (bValue)
         {   // In xml_config nach einem entsprechendem Boni suchen
            int bid = xml_config.GetBonusId(sArg, bPercent);
            if (bid < 0)
            {   // testen, ob der gesamte Text nicht vielleicht doch ein Bonus ist
               bid = xml_config.GetBonusId(MidStr(Line, 14, i - 16), bPercent);
            }
            if (bid >= 0)
            {   // Es ist ein regulärer Bonus
               Item->Effect[NextBonus] = bid;
               Item->EffectValue[NextBonus] = Value;
               NextBonus++;
            }
            else
            {   // Hier ein paar zusätzliche Werte nehmen, die keine Boni sind
               if (strcmp(sArg, strAF) == 0) Item->AF = Value;
               if (strcmp(sArg, strQuality) == 0) Item->Quality = Value;
               if (strcmp(sArg, strSpeed) == 0) Item->Speed = Value;
               if (strcmp(sArg, strAbsorb) == 0)
               {   // Value in Rüstungsklasse umwandeln
                  switch (Value)
                  {
                  case 0: Item->Class = 0; Item->Level = Item->AF;break;
                  case 10: Item->Class = 1; Item->Level = Item->AF / 2; break;
                  case 19: Item->Class = 2; Item->Level = Item->AF / 2; break;
                  case 27: Item->Class = 3; Item->Level = Item->AF / 2; break;
                  case 34: Item->Class = 4; Item->Level = Item->AF / 2; break;
                  }
                  //if (Item->Position < 0)
                  //   Item->Position = 0;   // Alle Rüstungen als Handschuhe annehmen
                  // Es gibt leider keine Info darüber im Log
                  // Wenn wir die Position auf -1 lassen, dann kommt automatisch eine Auswahlbox
               }
               if (strcmp(sArg, "DPS") == 0)
               {   // Nur ersten DPS-Wert speichern
                  if (Item->DPS == 0)
                  {
                     Item->DPS = Value;
                     // Berechne den Itemlevel
                     int level = (Value - 11) / 3;
                     if (level > 51) level = 51;
                     Item->Level = level;
                  }
               }
            }
         }
      }
//      else
      {   // noch ein paar besondere Strings auswerten
         if (strncmp(&Line[11], strUnique, sizeof(strUnique) - 1) == 0)
         {   // Unique Gegenstände nicht importieren
            return false;
         }
         if (strncmp(&Line[11], strCrafted, sizeof(strCrafted) - 1) == 0)
         {   // Craftet Gegenstände nicht importieren
            return false;
         }
         if (strncmp(&Line[11], strArtifact, sizeof(strArtifact) - 1) == 0)
         {
            Item->MaxLevel = 10;
            Item->Realm = 7;
         }
         if ((strncmp(&Line[11], strBonus, sizeof(strBonus) - 1) == 0) \
          || (strncmp(&Line[11], strBonus2, sizeof(strBonus2) - 1) == 0))
         {   // Spezielle Werte (meist Bonuserhöhungen)
            // Bonus auf BONUS: VALUE
            unsigned int i;
            for (i = 21; i < StrLen(Line); i++)
            {   // Alles bis zum Doppelpunkt in sArg kopieren
               if (Line[i] == ':') break;
               sArg[i - 21] = Line[i];
            }
            sArg[i - 21] = 0;
            for (; i < StrLen(Line); i++)
            {
               if ((Line[i] >= '0') && (Line[i] <= '9'))
               {
                  Value = Value * 10 + Line[i] - '0';
               }
            }
            // In xml_config nach einem entsprechendem Boni suchen
            int bid = xml_config.GetBonusId(sArg);
            if (bid >= 0)
            {   // Es ist ein regulärer Bonus
               Item->Effect[NextBonus] = bid;
               Item->EffectValue[NextBonus] = Value;
               NextBonus++;
            }
            else
            {   // Fehlermeldung
               Application->MessageBoxA(AnsiString("Ein Bonus '" + AnsiString(sArg) + "' ist unbekannt!\nDie Datei 'config.xml' bzw. die entsprechende Sprachdatei anpassen!").c_str(), "Fehler");
            }
         }
         if (strncmp(&Line[11], strActivLevel, sizeof(strActivLevel) - 1) == 0)
         {   // Danach kommt ne Zahl, welche den Level angibt
            int level = Str2Int(&Line[11 + sizeof(strActivLevel)]);
            Item->EffectLevel[NextBonus - 1] = level;
         }
         unsigned int cp = 12;
         if ((strncmp(&Line[11], strRestriction, sizeof(strRestriction) - 1) == 0) \
          || (strncmp(&Line[12], strRestriction, sizeof(strRestriction) - 1) == 0))
         {   // Solange nachfolgende Strings eine Klasse darstellen, solange
            // diese bei den Beschränkungen eintragen
            bRestriction = true;
            cp = 12 + sizeof(strRestriction);
         }
         while (bRestriction && (cp < StrLen(Line)))
         {
            int pArg = 0;
            for (; cp < StrLen(Line); cp++)
            {
               if ((Line[cp] == ' ') || (Line[cp] == ',') || (Line[cp] == '-') || (Line[cp] == '\r'))
               {
                  sArg[pArg] = 0;
                  if (pArg > 0)
                  {   // Es gibt einen String. Schauen obs ne Klasse ist
                     int cid = xml_config.GetClassId(sArg);
                     if (cid >= 0)
                     {
                        Item->ClassRestriction[NextRestriction++] = cid;
                     }
                     else
                     {   // Keine Klasse mehr, Modus aufheben
                        bRestriction = false;
                     }
                  }
                  pArg = 0;
               }
               else
               {
                  sArg[pArg++] = Line[cp];
               }
            }
         }
      }
      fChatLog->getline(Line, 1024);
   }
   return true;
}

#pragma package(smart_init)