OOP und RPG

[Khabarakh]

Zitat von 3_of_8:

Bei Vergiftung usw. musst du das halt dann anders machen:

Poisoned, Frozen, Burning: Boolean;
PoisonDamage, PoisonTime, FrozenTime, BurnTime: Cardinal; //(in ms)

Das würde ich aber um einiges generischer gestalten.

Delphi-Quellcode:

  ITiming = interface
    procedure Advance(dTime: Cardinal);
  end;

  //[...]

  TState = class
  protected
    FOwner: TAvatar;
  public
    constructor Create(AOwner: TAvatar);
  end;

  TTimeBasedState = class(TState, ITiming)
  protected
    FRemainingTime: Cardinal;
    class function GetDuration: Cardinal; virtual; abstract;
  public
    property RemainingTime: Cardinal read FRemainingTime;

    constructor Create(AOwner: TAvatar);
    procedure Advance(dTime: Cardinal); virtual;
  end;

  TPoison = class(TTimeBasedState)
  protected
    class function GetDuration: Cardinal; override;
  public
    procedure Advance(dTime: Cardinal); override;
  end;

implementation

{$R *.dfm}

{ TState }

constructor TState.Create(AOwner: TAvatar);
begin
  FOwner := AOwner;
end;

{ TTimeBasedState }

constructor TTimeBasedState.Create(AOwner: TAvatar);
begin
  FRemainingTime := GetDuration;
end;

procedure TTimeBasedState.Advance(dTime: Cardinal);
begin
  Dec(FRemainingTime, dTime);
  FOwner.States.RemoveMe;
end;

{ TPoison }

class function TPoison.GetDuration: Cardinal;
begin
  Result := 10 * 1000; // 10 s
end;

procedure TPoison.Advance(dTime: Cardinal);
begin
  inherited;
  FOwner.Health -= 10 * dTime / 1000; // 10 Schaden pro Sekunde
end;

Dazu noch eine globale Liste, in die sich der State einfügt (nur über das Interface) und die dann jeden Frame ihre Items durchrattert.
Naja, so könnte ich es mir jedenfalls vorstellen ^^ .

*diskussionwiederauftopicführ*

[3_of_8]

Immer ich. Aber er hat ja recht. Ich bin so strenge OT Regelungen nicht gewohnt.

[Der_Unwissende]

Zitat von Speedmaster:

Versuch mal DirectX ohne emulator auf Linux zum laufen zu bekommen. Oder schreib mir mal ein Game mit Brainf*ck( Ok schlechtes Beispiel ), sicherlich hat jeder Vorlieben, aber warum nichts neues Probieren?

Äh, was neues probieren ist super (auch Coke bei 5°C, echt lecker), aber man muss ja nicht alles neu machen. OOP ist sicher neu und man findet auch in ein und der selben Sprache bei jedem Lauf (bestimmt) mal was neues, aber du hast schon recht, zu OT.

Zitat:

Gut... dann wären da wieder Fragen: Wie geht das mit dem Vererben, bzw. wie stelle ich das am blödsten an?
Und... wie kann ich dann so eine Art ZIP-Archiv ertsllen?
Wegen den verschiedenen Dateien:
Ich hatt ja schonmal ein RPG versucht
Da hab ich dann eben für jeden Charakter/Avatar einen exra Ordner angelegt, in dem jede Menge Dateien waren ^^
Und... wie kann ich "streamen"? Wie schwer ist das?

Ja, das "streamen" an sich ist wirklich sehr einfach. Du kannst da wirklich gut die Hilfe von Delphi (TMemoryStream, TFileStream) benutzen. Du hast wirklich nur ein Objekt, dass Stream heißt und kannst beliebige Daten wegschreiben. Die liegen halt als Array von Bytes im Speicher (z.B. in einer Datei). Beim lesen hast du dann aber auch nur eine Menge Bytes. Du solltest also überlegen, welche Bytes eigentlich zusammen gehören (z.B. ein Integer sind) und die dann sinnvoll auslesen. Aber es ist echt flink. Einfach auch, aber halt mehr von der Art des Zugriffs.
Was das zippen angeht, es gibt ein paar Komponenten die das können. Hab leider im Moment keine, die ich verwende. Aber du findest mit googlen oder hier suchen sicher schnell was passendes. Und da ist es eigentlich die Regel, dass die in einer Datei beliebig viele weitere speichern können. Würde dir dazu raten, dann eine Datei für die NPCs, eine für die Quests usw. anzulegen. In den Dateien kannst du dann (hoffentlich) die gespeicherten Daten immer gleich strukturiert (also gleich groß) ablegen, dass macht das lesen schonmal leichter.

Was das Vererben angeht, auch dass ist eigentlich sehr einfach. Du hast eine Klasse

Delphi-Quellcode:

type
  TBaseClass = class(TObject) 
    private 
      // Felder & Methoden die nur TBaseClass sehen soll
    protected 
      // Felder & Methoden die beim vererben auch von der erbenden Klasse gesehen werden
    public 
      // Felder & Methoden die jeder sieht
  end;

Beim ableiten schreibst du die Basisklasse (immer nur eine möglich) in die Klammern hinter class

Delphi-Quellcode:

type
  TCharacter = class(TObject) 
    protected
      job : TJob;
      aussehen : TAussehen;
      procedure doFoo();
    public 
      constructor create(...);
      destructor destroy; override;  
  end; 

  TNpc = class(TCharacter) 
    private 
      building : TBuilding;
    public 
  end;

wobei dann TNpc auch das Feld aussehen, job und die Methode doFoo hat, zusätzlich halt auch building.

[3_of_8]

Nebenbei bemerkt kann man das (TObject) nach dem Klassennamen auch weglassen.

[Master_RC]

Zitat von Khabarakh:

Zitat von 3_of_8:

Bei Vergiftung usw. musst du das halt dann anders machen:

Poisoned, Frozen, Burning: Boolean;
PoisonDamage, PoisonTime, FrozenTime, BurnTime: Cardinal; //(in ms)

Das würde ich aber um einiges generischer gestalten.
//der ganze delphi code von vorhin Dazu noch eine globale Liste, in die sich der State einfügt (nur über das Interface) und die dann jeden Frame ihre Items durchrattert.
Naja, so könnte ich es mir jedenfalls vorstellen ^^ .

*diskussionwiederauftopicführ*

So wie ich das jett auf shcnellem blick erkenne, ist das so gemacht, dass dadurch ein spieler sozusagen mehrere Vergiftungseffekte haben kann?
Hui, denn genauso will ichs haben

Nur kann ich mit dem Code wenig anfangen, vlcht. muss ich nur näher hingucken...
kann mir jemand zu dem code von Khabarakh eine Art "Tutorial" - oder eher eine gute Beschreibung liefern?

So...
jetzt ist mir noch was aufgefallen:
Wenn das vorhin der Code fürs Vergisten war.
So... nehmen wir an, ich hätte noch Verbrennung, Dies, Das, Et cetera, Et ceteri (hihi, "ceteri" gibts nicht ^^)

Dann wird das ja im Quelltcode nen Haufen Text...
Kann ich den Code vlcht. irgendwie irgendwo auslagern oder so?

[Airblader]

Auch mal ne Frage zum Thema (MMO)RPG
Ich bin grad lustigerweise auch dran *fg* und schreib grad die Klasse für einen NPC.
Laufen tut er ja - allerdings sollte er sich etwas schlauer verhalten im Laufen.

Momentan mache ich es so, dass ich per "if Random(200)=0" entscheide, ob er überhaupt die Richtung wechseln soll.
Allerdings führt das eben zu recht blöden Laufverhalten *fg*
Gibt es da evtl. eine bessere Lösung, die ihn etwas realistischer laufen lässt?

air

[3_of_8]

Du kannst ihm einen vorgefertigten Weg vorgeben. Oder nur bei jedem x-ten Durchlauf eine Richtungsänderung vorschlagen.

[Master_RC]

@airblader:
Bitte mach damit ein eigenes Thema auf, ich bin hier sowieso schon stark gefordert! Danke
(Arrrgh... wär ich doch nur in der Schule gefordert, wär ichs gewohnt )

[Speedmaster]

Die Idee ist Grundsätzlich richtig, nur würde ich mir über den Aufbau noch Gedanken machen.

Code:

interface IDamage
{
  int  TakeDamage(int mode, int damage);
  int  GetDamageMode();
  void DirectDamage(int damage);
}


class RPGObject
{
  private int health;
  private Vector3f position;
  //.... propertys und sowas
       
}

class Human : RPGObject
{
  private HumanDamage Damagesystem;
  // ....blablabla
  
  void TakeFightAction(IDamage damagesystem)
  {
    ....
  }

}

class HumanDamage : IDamage
{
  int  TakeDamage(int mode, int damage)
  {
    ....
  }

  int  GetDamageMode()
  {
    ....
  }

  void DirectDamage(int damage)
  {
     ....
  }
}

Dies Stellt eine Sinnvolle Schnittstelle dar( Ist allerdings sicher noch ein Fehler drin ), welche demonstrieren soll wie man ein Schadenssystem erstellt!


Dies ist nur ein kurzer Hinweiss von mir wie man ein Spiel mithilfe von Klassen und Interfaces aufbauen kann.
Wenn man mit Interfaces Arbeitet kann man sich einige Lästige Dinge Erspaaren, und kann unabhängig von Fähigkeiten und Spezialfähigkeiten ein Spiel Programmieren welches auch ohne Fehler läuft. Dazu muss man eben wie oben im Beispiel gezeigt z.b. eine Sinnvolle Schnittstelle für das Schadenssystem programmieren.

[Master_RC]

muss das unbedingt C sein?