Klasse mit Konstanten ?

[Neutral General]

Delphi-Quellcode:

type TRune1 = class
const Rarity = 400;
const Color = clgrey;
end;

Das ist der Versuch eine Klasse zu erstellen die Konstanten hat. Nur funktioniert das nicht -.-
Geht das überhaupt ? Wäre praktisch für mich...

PS : Welche Unit brauch man damit clgrey usw nicht mehr undefiniert ist ?

[Dax]

Das geht (aber nur mit do5).

PS: Wo ist clGray definiert? Such selbst! :roll:

[Neutral General]

Was ist do5 bitte ? :gruebel:
sry war ma wieder zu faul wegen der Farbe :mrgreen:

[mirage228]

Zitat:

Zitat von Neutral General

Was ist do5 bitte ? :gruebel:
sry war ma wieder zu faul wegen der Farbe :mrgreen:

d05 = Delphi 2005 ;)

mfG
mirage228

[Neutral General]

Delphi-Quellcode:

for i:= 1 to 7 do begin
Delphi[i] := Schrott;
end;

-.-

Muss ich das dann alles in dem constructor machen oder was ? -.- :(

[Robert_G]

Nein, du musst so eine olle globale Konstane nehmen... :?
btw: Schrott würde ich jetzt nicht sagen, D2005 hat auch nur eine handvoll Neuerungen für den Komposter gebracht. ;)

[Neutral General]

Zitat:

Zitat von Robert_G

Nein, du musst so eine olle globale Konstane nehmen... :?
btw: Schrott würde ich jetzt nicht sagen, D2005 hat auch nur eine handvoll Neuerungen für den Komposter gebracht. ;)

Globale Konstante ist bisschen sch.. weil ich etwa 100 verschieden Klassen machen will und wenn ich für jede klasse 3 globale Konstanten verwende... -.-

[Dax]

Mach dir statt der Konstante doch eine Klassenfunktion, die dir den Wert zurückgibt.. Geht auch.

[Robert_G]

Musst du sie denn überhaupt außerhalb der Klasse sehen können?
Wenn nicht kannst du sie in die Implementierung der Unit der Klasse packen.
Aber bei 100 mal so ein Ding würde ich über die Struktur nachdenken. ;)

[shmia]

Zitat:

Zitat von Neutral General

Globale Konstante ist bisschen sch.. weil ich etwa 100 verschieden Klassen machen will und wenn ich für jede klasse 3 globale Konstanten verwende... -.-

100 verschiedene Klassen und alle ziemlich gleich ???!!!
Das wäre Flachsinn.

[Speedmaster]

Zitat:

Zitat von Dax

Mach dir statt der Konstante doch eine Klassenfunktion, die dir den Wert zurückgibt.. Geht auch.

Wenn ich das jetzt in einem 3D Programm mache, dann kann ich nur sagen:

Delphi-Quellcode:

Performance := Goodbye;

[Neutral General]

Delphi-Quellcode:

type TRune = class
function GetRarity : Integer;
end;

type TRune1 = class(TRune)
end;
type TRune2 = class(TRune)
end;


function TRune.GetRarity : Integer;
begin
  if Classname = 'TRune1' then Rarity := 300; // Ka ob die Eigenschaft jetzt Classname heißt..
  if Classname = 'TRune2' then Rarity := 400;
  ...
end;

Würde das so etwa gehen ?
EDIT : Ich glaube das wäre echtes OOP o.O sowas hab ich ja noch nie gemacht :D ;)

@Speedmaster : Ist aber zum Glück nur 2D :mrgreen:

[Robert_G]

Zitat:

Zitat von Speedmaster

Zitat:

Zitat von Dax

Mach dir statt der Konstante doch eine Klassenfunktion, die dir den Wert zurückgibt.. Geht auch.

Wenn ich das jetzt in einem 3D Programm mache, dann kann ich nur sagen:

Delphi-Quellcode:

Performance := Goodbye;

So ein Blödsinn. Non virtual class methods werden die gleiche Performance haben wie hässliche lose Funktionen. (virtuelle kosten dich, wenn überhaupt, einmal nachschlagen in der VMT)
Warum lernst du es nicht, einfach mal dein komischen Vorurteile zu überprüfen? (Ist ja nicht das erste Mal ;) )

@NG
Autsch....

[Neutral General]

:angel2:

Zeigt mir mal nen Beispiel pls :mrgreen:

[Speedmaster]

Zitat:

Zitat von Neutral General

Delphi-Quellcode:

type TRune = class
function GetRarity : Integer;
end;

type TRune1 = class(TRune)
end;
type TRune2 = class(TRune)
end;


function TRune.GetRarity : Integer;
begin
  if Classname = 'TRune1' then Rarity := 300; // Ka ob die Eigenschaft jetzt Classname heißt..
  if Classname = 'TRune2' then Rarity := 400;
  ...
end;

Würde das so etwa gehen ?
EDIT : Ich glaube das wäre echtes OOP o.O sowas hab ich ja noch nie gemacht :D ;)

@Speedmaster : Ist aber zum Glück nur 2D :mrgreen:

Selbst bei 2D kann darunter die Performance leiden( Theoretisch )! Ich frage mich warum du die Werte nicht in einem Konstanten Array abspeicherst, und einfach per Index Abrufst!?!?

@Robert_G: Wer sagt den das ich eine Funktion benutzen würde?

[Neutral General]

Auch ne Idee aber ich hab ehrlichgesagt keine Lust für jede Klasse nen Konstruktor zu basteln :(

[tigerman33]

Warum müssen das denn überhaupt verschiedene Klassen sein? Die sehen nämlich eigentlich alle ziemlich gleich aus. Ich würd's so machen

Delphi-Quellcode:

type TRuneTypes = (rtX, rtY, rtZ);
const RuneRarities: array[0..2] of integer = [100, 200, 300];
      RuneColors: array[0..2] of TColor = [clGrey, clTeal, clRed]; // Da bin ich mir mit der Syntax nicht ganz sicher

type TRune = class
       constructor Create(RuneType: TRuneType);
     private
       FRuneType: TRuneType;
       function GetRarity: integer;
       function GetColor: integer;
     public
       property  RuneType: TRuneType read FRuneType write FRuneType;
       property Rarity: integer read GetRarity;
       property Color: TColor read GetColor;
     end;

constructor TRune.Create(RuneType: TRuneType);
begin
  inherited Create;
  FRuneType := RuneType;
end;

function TRune.GetRarity: integer;
begin
  Result := RuneRarities[ord(RuneType)];
end;

function TRune.GetColor: TColor;
begin
  Result := RuneColors[ord(RuneType)];
end;

//edit
Ah, seh gerade dass dir die Performance so wichtig ist. Dann könnte man das auch so machen:

Delphi-Quellcode:

const RuneRarities: array[0..2] of integer = [100, 200, 300];
      RuneColors: array[0..2] of TColor = [clGrey, clTeal, clRed]; // Da bin ich mir mit der Syntax nicht ganz sicher

type TRune = class
       constructor Create(ARuneType: TRuneType);
     private
       FRuneType: TRuneType;
       FRarity: integer;
       FColor: TColor;
       procedure SetRuneType(Value: TRuneType);
       procedure Recalculate;
     public
       property RuneType: TRuneType read FRuneType write SetRuneType;
       property Rarity: integer read FRarity;
       property Color: TColor read FColor;
     end;

constructor TRune.Create(ARuneType: TRuneType);
begin
  inherited Create;
  RuneType := ARuneType; // Ruft den Setter auf zum Initialisieren;
end;

procedure TRune.Recalculate;
begin
  FRarity := RuneRarities[ord(RuneType)];
  FColor := RuneColors[ord(RuneType)];
end;

procedure TRune.SetRuneType(Value: TRuneType);
begin
  if Value <> RuneType then begin
    FRuneType := Value;
    Recalculate; // Alles neu berechnen
  end;
end;

[BlackJack]

Zitat:

Zitat von Neutral General

Delphi-Quellcode:

type TRune = class
function GetRarity : Integer;
end;

type TRune1 = class(TRune)
end;
type TRune2 = class(TRune)
end;


function TRune.GetRarity : Integer;
begin
  if Classname = 'TRune1' then Rarity := 300; // Ka ob die Eigenschaft jetzt Classname heißt..
  if Classname = 'TRune2' then Rarity := 400;
  ...
end;

Würde das so etwa gehen ?

nein, wenn dann so:

Delphi-Quellcode:

type TRune = class
function GetRarity : Integer; virtual; abstract;
end;

type TRune1 = class(TRune)
function GetRarity : Integer; override;
end;
type TRune2 = class(TRune)
function GetRarity : Integer; override;
end;


function TRune1.GetRarity : Integer;
begin
  Result := 300;
end;
function TRune2.GetRarity : Integer;
begin
  Result := 400;
end;

musst du halt nur für jede klasse machen, ich weiss ja nicht ob es das so bringt.

p.s.: warum gibt es nicht sowas wie

Delphi-Quellcode:

property Value: Integer read 1234;

, das wäre doch mal praktisch :D

[shmia]

@N General:
Die ganzen Mutmassungen über Klassen, Vererbung, u.s.w. ist alles Quark.
Du musst ganz zurück an den Anfang und erklären was du überhaupt programmieren möchtest.
Irgendwie geht es um Runen; das sind wohl irgendwelche Spielsteine.

Welche Eigenschaften soll eine Rune haben ? (Farbe, Wert, X/y-Position, ...)
Welche Eigenschaften dürfen im Laufe des Spiels ihren Wert ändern ?
Wieviele Runen sollen erzeugt werden ?
Gibt es Regeln zur Erzeugung der Runen (z.B. 20 rote, 20 grüne & 20 blaue)
Was soll mit den Runen passieren ? (laden aus Datei, anzeigen, ...)

Du könntest dich ausserdem über Class Factory oder Builder informieren; die wirst du wahrscheinlich gut gebrauchen können.

[Neutral General]

Also ich mache eine Art Rollenspiel in dem es die Aufgabe ist alle Runen zu finden (Gotta Catch 'em all :mrgreen:) Die Rarity Eigenschaft beschreibt wie selten eine Rune gedroppt wird. Also ne Rune mit Rarity von hätte ne Dropchance von 30%. eine Rune mit Rarity 1 hätte ne Chance von 0,1% usw.
Die Farbe ist halt ein Zeichen für die Seltenheit. Also z.b

Häufige = Grün
Seltene = Orange
Sehr Selten = Rot

Außerdem hat jede Rune nachher eine Besondere Eigenschaft. Die Eigenschaft ist wahrscheinlich ne eigene Klasse, z.B TProperty. Es soll etwa min 100 verschiedene Runen geben.

So etwa könnte dann die Klassen aussehen von einer Rune.

Delphi-Quellcode:

type
Rune = class
Color : TColor;
Rarity : Integer;
Property : TProperty;
end;

Alles war jetzt hier nur Beispielhaft dargestellt.

[Christian Seehase]

Moin Neutral General,

warum überhaupt Konstanten? :gruebel:
Wenn Du die Daten in einer Konfigurationsdatei ablegst, kannst Du die Einstellungen doch viel besser justieren, falls erforderlich.

[tigerman33]

Und bei dem von dir beschriebenen Ziel sehe ich auch nicht die Notwendigkeit verschiedener Klassen. Im Gegenteil! Denn deine Runen unterscheiden sich ja nicht in der Struktur, sondern nur in ihren Eigenschaften: Häufigkeit, Farbe etc.

Das verschiedene Verhalten kann man dann auch über Methodeneigenschaften realisieren oder wie du gesagt hast, als eigenen Klassentyp. Aber für die Runen als solche sind verschiedene Klassen meiner Meinung nach kontraproduktiv und damit der falsche Ansatz.

[Kroko1999]

Mein Vorschlag:

Delphi-Quellcode:

type
  TRune = class
      constructor Create (ARarity: Integer);
    private
      FRarity: Integer;
      FColor: TColor;
    public
      property Color: TColor read FColor;
      property Rarity: Integer read FRarity;
  end;

constructor TRune.Create (ARarity: Integer);
begin
  FRarity := ARarity;
  case FRarity of
    0..3: FColor := clGreen;
    //etc.
  end;
end;

und beim Create übergibts Du die Rarity.

[Neutral General]

Nur die Rarity zu übergeben reicht ja nicht weil die Runen ja verschiedene Eigenschaften haben sollen.
Ich will halt so wenig wie möglich schreiben müssen um alle Runen mit ner Seltenheit und min 1 Property auszustatten...

[leddl]

:gruebel: Und dafür schreibst du lieber ca. 100 Runenklassen? :shock: Was ist, wenn du beschließt, nochmal 100 weitere einzufügen? Dann nochmal 100 neue Klassen?

[Neutral General]

Ja ich bin halt ratlos ^^
Ich hab noch nie was in sonem Umfang gemacht..

EDIT : Ich seh grad meine "Funktion" -.- Ich glaube ich habe in der Eile da was falsch gemacht :mrgreen: -.-

[tigerman33]

Hört mir eigentlich irgendjemand zu? Wenn nicht, weise ich auf meine beiden letzten Posts hin. Wenn doch, wüsste ich gerne, was es daran auszusetzen gibt. :roll:

[Neutral General]

Zitat:

Zitat von BlackJack

nein, wenn dann so:

Delphi-Quellcode:

type TRune = class
function GetRarity : Integer; virtual; abstract;
end;

type TRune1 = class(TRune)
function GetRarity : Integer; override;
end;
type TRune2 = class(TRune)
function GetRarity : Integer; override;
end;


function TRune1.GetRarity : Integer;
begin
  Result := 300;
end;
function TRune2.GetRarity : Integer;
begin
  Result := 400;
end;

musst du halt nur für jede klasse machen, ich weiss ja nicht ob es das so bringt.

p.s.: warum gibt es nicht sowas wie

Delphi-Quellcode:

property Value: Integer read 1234;

, das wäre doch mal praktisch :D

wenn dann eher so

Delphi-Quellcode:

type
TRune = class
public
function GetRarity : Integer;
end;

TRune1 = class(TRune)
end;
TRune2 = class(TRune)
end;


function TRune.GetRarity : Integer;
begin
  Result := -1;
  if Classname = 'TRune1' then Result := 300;
  if Classname = 'TRune2' then Result := 400;
end;

so find ich praktischer...

@ Tigerman33 : ja stimmt schon... ich glaube ich mache es so wie da oben...

[tigerman33]

Dann würd ich aber nicht auf Classname zugreifen, sondern eher mit dem is Operator prüfen.

Delphi-Quellcode:

function TRune.GetRarity : Integer;
begin
  Result := -1;
  if self is TRune1 then begin
    Result := 300;
    exit;
  end;
  if self is TRune2 then begin
    Result := 400;
    exit;
  end; 
end;

PS: Was ich gepostet hab ist trotzdem schneller :mrgreen:

[Dax]

Stringvergleiche bei Klassennamen? :shock: Seid ihr von allen guten Geistern verlassen? Das macht man mit einen is-Verglich auf Self und dem Typ, von dem man wissen will, ob die Klasse von dem Typ ist..

[ichbins]

Du kannst doch auch einer Variable bei der Definition einen Wert zuweisen:

Delphi-Quellcode:

tclass=class
  var 
  rarity:integer=400;
  color:tcolor=clgray;
end;

oder doch nicht... :pale: Jetzt hab ich es gerade getestet...

aber ein Konstanten-Array ginge:

Delphi-Quellcode:

type

trune=class
  rarity:integer;
  color:tcolor;
end;

const
  runen=array[1..300] of trune = 
  (rarity=1;color=clblack,
   rarity=2;color=clred,
   rarity=1390;color=$ABCDEF,
   ...
   );

[alzaimar]

Delphi-Quellcode:

Type
 TRune = Record
   ruRareness : Integer; // Nicht Rarity... Das ist die 'Rarität', also ein Ding, keine Eigenschaft
   ruColor : TColor;
   ruNochwass : TEgal;
   End;

Dann entweder eine Datei (gut zum Anpassen, aber auch gut zum cheaten) oder eine ziemlich grosse Const-Deklaration. Ich schreibe mir dafür immer ein kleines Tool, das die Deklaration z.B. aus einer kleinen DB oder EXCEL -Datei oder so rausliest und die Const-Deklaration bastelt. Der Zugriff auf die Eigenschaften einer Rune erfolgt einfach über das Konstante Array. Was hier über Klassen steht ist imho absoluter Quark. Man kanns mit OOP auch zu weit treiben, finde ich.

[Robert_G]

Zitat:

Zitat von alzaimar

Was hier über Klassen steht ist imho absoluter Quark. Man kanns mit OOP auch zu weit treiben, finde ich.

Quark war, dass class methods vergessen wurden. Quark war, das MetaClasses vergessen wurden...
Quark sind Präfixe wie ru... *ulf*
Bei deinem Record müsste man ja ständig das Ding hin und herschaufeln und es allen Funktionen als Parameter übergeben... *bäh* :mrgreen:

Wieviel Sinn es im Endeffekt hat kann ich nicht sagen. Ich wollte nur eine weitere Möglichkeit zeigen.
Mit den Schnipsel unten kannst du TRune.CreateInstance aufrufen und du bekommst zufällig eine Rune einer der registrierten Klassen.

Delphi-Quellcode:

uses
   Graphics;

type
   TFrequency = 1..100;

   TRune = class
   published
   protected
      class procedure Register;
      class procedure Unregister;
      class function getColor : TColor; virtual;
   public
      property Color : TColor read getColor;

      class function Frequency : TFrequency; virtual; abstract;
      constructor Create; virtual;
      class function CreateInstance : TRune;
   end;

   TRuneClass = class of TRune;

implementation
uses
   Contnrs;
var
   ClassList            : TClassList;

constructor TRune.Create;
begin
end;

class function TRune.CreateInstance: TRune;
var
   RuneClass            : TRuneClass;
begin
   // Finde eine Runenklasse, zufällig und anhand ihrer Häufigkeit....
   RuneClass := TRuneClass(ClassList[XXX]);
   Result := RuneClass.Create();
end;

class function TRune.getColor: TColor;
var
   Red, Green, Blue     : Byte;
   Frequency            : TFrequency;
begin
   Frequency := self.Frequency();

   if Frequency < 51 then
   begin
      Blue  := 0;
      Green := 5 * Frequency;
      Red   := 255 - Green;
   end
   else
   begin
      Red   := 0;
      Blue  := 5 * (Frequency - 50);
      Green := 255 - Blue;
   end;
   result := Red + Green shl 8 + Blue shl 16;
end;

class procedure TRune.Register;
begin
   if ClassList.IndexOf(Self) = -1 then
      ClassList.Add(Self)
   else
      raise TRuneClassAlreadyRegisteredException(self);
end;

class procedure TRune.Unregister;
begin
   ClassList.Remove(Self)
end;

initialization
   ClassList := TClassList.Create();
finalization
   ClassList.Free();
end.

Hier eine Beispiel rune:

Delphi-Quellcode:

uses
   uRune;

type
   TSampleRune = class(TRune)
   public
      class function Frequency: TFrequency; override;
   end;

implementation

{ TSampleRune }

class function TSampleRune.Frequency: TFrequency;
begin
   Result := 15;
end;

initialization
   TSampleRune.Register();
finalization
   TSampleRune.Unregister();
end.

Frequency muss kein statischer Wert sein. Bei bestimmten/allen Runen typen, kannst du es ja vom Spielgeschehen abhängig machen.
Aber in einer Instance method hat das ganz sicher _nix_ zu suchen, IMHO.
Verpasse der TRune noch Eigenschaften so dass du damit auch etwas anfangen kannst und gut ist...

[alzaimar]

Zitat:

Zitat von Robert_G

Quark sind Präfixe wie ru... *ulf*

Problem mit RU? Alter Anti-Kommunist? So, wie ich das gelernt habe, bilden sich Präfixe durchaus so, das ein Bezug zu dem Datentyp gezogen werden kann. Aber vermutlich wirst Du auch immer als Erstes einen Code wegen Indentation bemängeln und nicht wegen des Inhaltes... Bleib sachlich...

Zitat:

Zitat von Robert_G

Bei deinem Record müsste man ja ständig das Ding hin und herschaufeln und es allen Funktionen als Parameter übergeben... *bäh* :mrgreen:

Wie bitte? Es geht darum, die Daten erstmal irgendwie im Programm zu halten. Wie man dann darauf zugreift, ist eine andere Frage. Ich kann mir nicht vorstellen, das ich komplette Records übergebe, wenn sie doch als (globale) Konstanten deklariert sind. Ich weiss nicht, wie Du so programmierst, aber ich schaue mir erstmal das Problem an, bevor ich das Werkzeug wähle. Wenn es diverse Runen gibt, die jeweils ein eigenes _Verhalten_ zeigen, sind Klassen vielleicht eine gute Idee, aber wenn nicht, dann ist eine TRune-Klasse ausreichend. Die hat z.B. eine Eigenschaft 'RuneType'.

Schau und lerne:

Delphi-Quellcode:

Type
  TRune = Class (...)
  Public
    Property RuneType : Integer Read....
    Property Rareness : Integer Read GetRareness Write SetRareness;
...
  End;

So, nun rate mal, wie GetRareness und SetRareness implementiert sind? Kommste nicht drauf? Macht nix:

Delphi-Quellcode:

Function TRune.GetRareness : Integer;
Begin
  Result := rcMyRuneData[RuneType].ruRareness;
End;

Wenn ich mir das hier anschaue, komm ich zu dem Schluss, das das kurz, knapp und effektiv ist. Also *kein* Quark.

Tipp: Erst denken, dann meckern. Danke.

[Robert_G]

Zitat:

Zitat von alzaimar

Tipp: Erst denken, dann meckern. Danke.

Habe ich. ;)
Das gilt für Präfixe, genauso wie dafür, was Mr "100 Klassen whatsoever" mit dem Record gemacht hätte, den du vorgeschlagen hast. ;)
Wie ich schrieb, wollte ich auch nur eine weitere Möglichkeit zeigen. Meine Lösung hätte den Vorteil, dass immer weitere Ableitungen "reinklinken" könnte.
Im Spiel ruft er nur CreateInstance auf, wenn er eine Rune haben will, was für eine es ist sollte dann zufällig anhand der Häufigkeit gewählt werden.

[tigerman33]

Zitat:

Zitat von Robert_G

Meine Lösung hätte den Vorteil, dass immer weitere Ableitungen "reinklinken" könnte.

Das ist nun wieder IMHO "absoluter Quark". Die Runen haben bis auf minimale Abweichungen in ihren Eigenschaften keine Unterschiede. Dafür braucht man keine abgeleiteten Klassen.
Man kann das denke ich ganz gut mit der TShape-Komponente vergleichen. Es gibt schließlich auch keine Komponenten namens TCircle, TBox, TRoundRect etc. Warum? Weil sie alle--mehr oder weniger--das gleiche machen. Genau wie hier die Runen. Und deshalb wird es über eine Property gesetzt.
Alles andere ist hier schlicht overkill, OOP um seiner selbst willen. Das macht den Code groß, unübersichtlich und vermutlich auch noch langsamer.

[alzaimar]

Zitat:

Zitat von Robert_G

Zitat:

Zitat von alzaimar

Tipp: Erst denken, dann meckern. Danke.

Habe ich. ;)

Und Humor hast Du auch, gut so.

Ich glaube, das war für beide ein Schnellschuss: Ich habe nicht erwähnt, das es mir nur um die Deklaration der Klassen ging. Egal. Letztendlich sind wir uns ja einig.

Und was der tigerman33 sagt, ist eben so einleuchtend wie simpel: Immer locker und "keep it simple".

[Robert_G]

Zitat:

Quark...Quark...Quark...Quark...

Kleines Update: Eine Kollegin hat Quarkkkuchen mitgebracht. :)

[alzaimar]

Zitat:

Zitat von Robert_G

Zitat:

Quark...Quark...Quark...Quark...

Kleines Update: Eine Kollegin hat Quarkkkuchen mitgebracht. :)

Bitte ein Stück per PN an mich. Und den 'Send' Button schön vorsichtig drücken, sonst geht der Kuchen kaputt! :hello:

[Robert_G]

Zitat:

Zitat von alzaimar

Zitat:

Zitat von Robert_G

Zitat:

Quark...Quark...Quark...Quark...

Kleines Update: Eine Kollegin hat Quarkkkuchen mitgebracht. :)

Bitte ein Stück per PN an mich. Und den 'Send' Button schön vorsichtig drücken, sonst geht der Kuchen kaputt! :hello:

Sorry geht nicht.
Es gibt noch keine DRM Sytseme für VQKMS (virtual Quarkkuchen mampf streaming). Deshalb könnte ich dir dafür nicht deine "2 Cents" abknöpfen. Also werde ich mich voll und ganz meiner egoistischen VQKMS session widmen. *g*