Stilllegung des Forums
Das Forum wurde am 05.06.2023 nach über 20 Jahren stillgelegt (weitere Informationen und ein kleiner Rückblick).
Registrierungen, Anmeldungen und Postings sind nicht mehr möglich. Öffentliche Inhalte sind weiterhin zugänglich.
Das Team von spieleprogrammierer.de bedankt sich bei der Community für die vielen schönen Jahre.
Wenn du eine deutschsprachige Spieleentwickler-Community suchst, schau doch mal im Discord und auf ZFX vorbei!
Werbeanzeige
C-/C++-Quelltext |
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 |
#include <cstdint> #include <iostream> using ObjectType = std::uint8_t; namespace types { ObjectType const Focusable = 0x01; ObjectType const Collideable = 0x02; ObjectType const Lighted = 0x04; ObjectType const Damageable = 0x08; ObjectType const Lootable = 0x10; ObjectType const Interactable = 0x20; } int main() { ObjectType corpse, chest, player, torch, switch_; corpse = types::Focusable | types::Lootable; chest = types::Focusable | types::Collideable | types::Lootable; player = types::Focusable | types::Collideable | types::Lighted | types::Damageable; torch = types::Lighted; switch_ = types::Focusable | types::Interactable; if (corpse & types::Lootable) { std::cout << "Corpses can be looted" << std::endl; } if ((chest & types::Collideable) && !(chest & types::Lighted)) { std::cout << "You can collide with chests but their are not lighted" << std::endl; } if (player & types::Damageable) { std::cout << "Players can be harmed" << std::endl; } if (!(torch & types::Focusable) && (torch & types::Lighted)) { std::cout << "Torches cannot be focused but their are lighted" << std::endl; } if (switch_ & types::Interactable) { std::cout << "You can interact with switches" << std::endl; } } |
Doof finde ich, dass beim Debuggen nicht gerade gut ersichtlich ist, was der Objekttypen ist.
Strings würde ich vor allem für frameworks benutzen, weil man dann einfach Erweiterungen implementieren kann.
Was spricht gegen ein normales enum?
Für dein Component Based System solltest du ja die meisten Typen ja schon schön getrennt halt, womit keine Type Deduction während der Laufzeit nötig sein sollte.
Aber für spezielle Szenarien könnte eine Bitmask relative simple den Typ heraus finden.
Zitat
Ein Enum würde mir helfen wenn ich eine kleine Anzahl verschiedener Typen habe. Ich möchte aber viele verschiedene Objekttypen aus einer Hand voll (oder zwei ) Eigenschaften erzeugen.
Das verstehe ich nicht so ganz bzw. sehe nicht, inwiefern ein enum da nicht passt. Kannst du das nochmal deutlicher machen?
C-/C++-Quelltext |
|
1 2 3 4 5 6 |
using ObjectType = std::uint8_t; ObjectType const Focusable = 0x01; // ob es ein anderes Objekt fokussieren kann ObjectType const Collideable = 0x02; // ob es mit einem anderen Objekt kollidieren kann ObjectType const Lighted = 0x04; // ob es beleuchtet ist (einfache Variante: Sichtradius dargestellt) ObjectType const Lootable = 0x08; // ob es gelootet werden kann ObjectType const Damageable = 0x10; // ob es beschädigt werden kann |
C-/C++-Quelltext |
|
1 2 3 |
myChest.type = Focusable | Collideable | Lootable; myTorch.type = Lighted myEnemy.type = Focusable | Collideable | Damageable |
C-/C++-Quelltext |
|
1 2 3 |
if (object.type & Lighted) { // draw lighted area around object } |
C-/C++-Quelltext |
|
1 2 3 |
if (object.type & Collideable) { // check for collision with object } |
C-/C++-Quelltext |
|
1 2 3 4 5 |
enum ObjectType { Chest, // Focus + Collide + Loot Torch, // Lighted Enemy // Focus + Collide + Damage } |
C-/C++-Quelltext |
|
1 2 3 |
myChest.type = ObjectType::Chest; // usw. myFireplace.type = ObjectType::Fireplace; // <-- enum nachträglich erweitern |
C-/C++-Quelltext |
|
1 2 3 |
if (object.type == Chest || object.type == Enemy) { // <-- wird u.U. lang // check for collision with object } |
C-/C++-Quelltext
1 2 3 4 5 6 7 enum ObjectTypes { Focusable = 1 << 0, Collideable = 1 << 1, Lighted = 1 << 2, Lootable = 1 << 3, };
C-/C++-Quelltext |
|
1 |
int type = ObjectTypes::Focusable | ObjectTypes::Collideable; |
Zitat
fatal error: assigning to 'ObjectTypes' from incompatible type 'int'
Ich denke das mit den Enums war eher so gemeint, dass du deine ObjectTypes zu nem Enum machst.
C-/C++-Quelltext
1 2 3 4 5 6 7 enum ObjectTypes { Focusable = 1 << 0, Collideable = 1 << 1, Lighted = 1 << 2, Lootable = 1 << 3, };
Ich finde aber auch, dass das sehr Eingeschränkt ist, was Erweiterbarkeit angeht. (Bits)
-> std::bitset
Werbeanzeige