Operator in Variable speichern?

[Rudinii]

Hallo zusammen,
ich habe eine kleine Frage bezüglich Operatoren:
Ich möchte eine Art Spiel programmieren bei dem ein wichtiger Part "Upgrades" sind. Diese möchte ich als Records abspeichern.
Diese Upgrades sollen mit einem bestimmten Zahlenwert (Integer) entweder eine Multiplikation oder Addition durchführen. Da dies
für jedes Upgrade anders sein soll dachte ich mir ich speichere es in einer Variable ab.

Also ungefähr so:

Delphi-Quellcode:

var 
Zahlwert:Integer;
BeispielUpgrade:Upgrade;
begin
Zahlwert    Beispielupgrade.Rechenzeichen     BeispielUpgrade.Stärke //Hier soll BeispielUpgrade.Rechenzeichen entweder '*' oder '+' sein und BeispielUpgrade.Stärke ist ein Integerwert

Irgendwelche Tipps wie ich das realisieren könnte?
Danke im Vorraus,
Rudinii

[Valle]

Ich würde einen Funktionspointer speichern.

Pseudocode:

Code:

function addiere(a, b): return a+b
function multipliziere(a, b): return a*b

a = 4
b = 2
op = addiere

result = op(a, b)

[Rudinii]

Hey, schonmal danke :)
Bin leider noch ein Anfänger, könntest du vielleicht erläutern wie das in meinen "Code" passen würde?
Grüße,
Rudinii

EDIT: Habs raus gekriegt, kann geschlossen werden^^

[Neutral General]

Valles Vorschlag würde auf jeden Fall funktionieren und ist evtl auch etwas schöner, aber einfacher zu verstehen ist das:

Frag einfach mit einem if das Rechenzeichen ab:

Delphi-Quellcode:

if upgrade.Rechenzeichen = '+' then // oder mit nem Aufzählungstyp (besser) sowas wie rzPlus
  Ergebnis := Wert + upgrade.Stärke
else
if upgrade.Rechenzeichen = '*' then // oder mit nem Aufzählungstyp (besser) sowas wie rzMal
  Ergebnis := Wert * upgrade.Stärke
else
  // usw..

[Sir Rufo]

Oder man nimmt einen OOP Ansatz

Delphi-Quellcode:

program Project2;

{$APPTYPE CONSOLE}
{$R *.res}

uses
  System.SysUtils;

type
  TBase = class abstract
  protected
    procedure InteractionTo( Dest: TBase ); virtual;
  public
    procedure InteractWith( Source: TBase ); virtual;
  end;

  TStrength = class( TBase )
  private
    FValue: Integer;
  public
    function ToString: string; override;
    property Value: Integer read FValue write FValue;
  end;

  TUpgrade = class abstract( TBase )
  private
    FValue: Integer;
  public
    constructor Create( Value: Integer );
    property Value: Integer read FValue;
  end;

  TSomeUpgrade = class( TUpgrade )
  protected
    procedure InteractionTo( Dest: TBase ); override;
  end;

  TSomeOtherUpgrade = class( TUpgrade )
  protected
    procedure InteractionTo( Dest: TBase ); override;
  end;

  { TBase }

procedure TBase.InteractionTo( Dest: TBase );
begin
  raise Exception.Create( 'Cannot interact' );
end;

procedure TBase.InteractWith( Source: TBase );
begin
  Source.InteractionTo( Self );
end;

{ TStrength }

function TStrength.ToString: string;
begin
  Result := Format( 'Strength = %d', [ FValue ] );
end;

{ TSomeUpgrade }

procedure TSomeUpgrade.InteractionTo( Dest: TBase );
begin
  if Dest is TStrength
  then
    begin
      TStrength( Dest ).Value := TStrength( Dest ).Value + Self.Value;
      Self.FValue             := 0;
    end
  else
    inherited;
end;

{ TSomeOtherUpgrade }

procedure TSomeOtherUpgrade.InteractionTo( Dest: TBase );
begin
  if Dest is TStrength
  then
    begin
      TStrength( Dest ).Value := TStrength( Dest ).Value * Self.Value;
      Self.FValue             := 1;
    end
  else
    inherited;
end;

procedure Test;
var
  s: TStrength;
  u: TUpgrade;
begin
  s       := TStrength.Create;
  try
    s.Value := 10;

    WriteLn( s.ToString( ) );

    u := TSomeUpgrade.Create( 10 );
    try
      s.InteractWith( u );
    finally
      u.Free;
    end;

    WriteLn( s.ToString( ) );

    u := TSomeOtherUpgrade.Create( 10 );
    try
      s.InteractWith( u );
    finally
      u.Free;
    end;

    WriteLn( s.ToString( ) );
  finally
    s.Free;
  end;
end;

{ TUpgrade }

constructor TUpgrade.Create( Value: Integer );
begin
  inherited Create;
  FValue := Value;
end;

begin
  try
    Test;
  except
    on E: Exception do
      WriteLn( E.ClassName, ': ', E.Message );
  end;

  ReadLn;

end.

Allerdings würde es wohl eher Sinn machen statt der

Delphi-Quellcode:

TStrength

Klasse eine Spieler-Klasse zu definieren und die Upgrades können dann auf die unterschiedlichsten Eigenschaften der Spieler-Klasse wirken.

Dann kann man auch noch alle anderen Klassen definieren, die in irgendeiner Art und Weise untereinander interagieren, was man dann einfach in den jeweiligen Klassen hinterlegt.

[Stevie]

Soll die Reihenfolge der Upgrades eine Rolle spielen? Ansonsten musst du dir darüber im Klaren sein, dass du nicht Addition und Multiplikation gleich behandeln darfst sondern eine Regel festlegen musst, wie sie angewendet werden (z.B. erst die additiven Upgrades auf den Basiswert und dann mit der Summe der multiplikativen verrechnen) - und dann könnte es noch Upgrades geben, die nicht miteinander stacken ;)