queries/setting_variables

• C

  View on GitHub

  #include <setting_variables.h>
  #include <stdio.h>
   
  // This example extends the component_inheritance example, and shows how
  // we can use a single query to match units from different players and platoons
  // by setting query variables before we iterate.
  //
  // The units in this example belong to a platoon, with the platoons belonging
  // to a player.
   
  static const int PlayerCount = 100;
  static const int PlatoonsPerPlayer = 3;
   
  int main(int argc, char *argv[]) {
      ecs_world_t *ecs = ecs_init_w_args(argc, argv);
   
      // Unit datamodel - see component_inheritance example
      ECS_TAG(ecs, Unit);
      ecs_entity_t CombatUnit = ecs_entity(ecs, { .name = "CombatUnit" });
      ecs_add_pair(ecs, CombatUnit, EcsIsA, Unit);
      ecs_entity_t MeleeUnit = ecs_entity(ecs, { .name = "MeleeUnit" });
      ecs_add_pair(ecs, MeleeUnit, EcsIsA, CombatUnit);
      ecs_entity_t RangedUnit = ecs_entity(ecs, { .name = "RangedUnit" });
      ecs_add_pair(ecs, RangedUnit, EcsIsA, CombatUnit);
   
      ecs_entity_t Warrior = ecs_entity(ecs, { .name = "Warrior" });
   
      ecs_add_pair(ecs, Warrior, EcsIsA, MeleeUnit);
      ecs_entity_t Wizard = ecs_entity(ecs, { .name = "Wizard" });
      ecs_add_pair(ecs, Wizard, EcsIsA, RangedUnit);
      ecs_entity_t Marksman = ecs_entity(ecs, { .name = "Marksman" });
      ecs_add_pair(ecs, Marksman, EcsIsA, RangedUnit);
      ecs_entity_t Builder = ecs_entity(ecs, { .name = "Builder" });
      ecs_add_pair(ecs, Builder, EcsIsA, Unit);
   
      // Player/Platoon tags
      ECS_TAG(ecs, Player);
      ECS_TAG(ecs, Platoon);
   
      // Populate store with players and platoons
      for (int p = 0; p < PlayerCount; p ++) {
          ecs_entity_t player;
   
          // Give first player a name so we can look it up later
          if (p == 0) {
              player = ecs_entity(ecs, { .name = "MyPlayer" });
          } else {
              player = ecs_new(ecs);
          }
   
          // Add player tag so we can query for all players if we want to
          ecs_add(ecs, player, Player);
   
          for (int pl = 0; pl < PlatoonsPerPlayer; pl ++) {
              ecs_entity_t platoon = ecs_new_w_pair(ecs, Player, player);
   
              // Add platoon tag so we can query for all platoons if we want to
              ecs_add(ecs, platoon, Platoon);
   
              // Add warriors, wizards and marksmen to the platoon
              ecs_entity_t warrior = ecs_new_w_id(ecs, Warrior);
              ecs_add_pair(ecs, warrior, Platoon, platoon);
   
              ecs_entity_t marksman = ecs_new_w_id(ecs, Marksman);
              ecs_add_pair(ecs, marksman, Platoon, platoon);
   
              ecs_entity_t wizard = ecs_new_w_id(ecs, Wizard);
              ecs_add_pair(ecs, wizard, Platoon, platoon);
          }
      }
   
      // Create a query to find all RangedUnits for a platoon/player. The 
      // equivalent query in the query DSL would look like this:
      //   (Platoon, $Platoon), Player($Platoon, $Player)
      //
      // The way to read how this query is evaluated is:
      // - find all entities with (Platoon, *), store * in $platoon
      // - check if $platoon has (Player, *), store * in $player
      ecs_query_t *q = ecs_query(ecs, {
          .terms = {
              { .first.id = RangedUnit },
              { .first.id = Platoon, .second.name = "$platoon" },
              { .first.id = Player,  .src.name     = "$platoon", .second.name = "$player" }
          }
      });
   
      // If we would iterate this query it would return all ranged units for all
      // platoons & for all players. We can limit the results to just a single
      // platoon or a single player setting a variable beforehand. In this example
      // we'll just find all platoons & ranged units for a single player.
   
      int player_var = ecs_query_find_var(q, "player");
      int platoon_var = ecs_query_find_var(q, "platoon");
   
      // Iterate query, limit the results to units of MyPlayer
      ecs_iter_t it = ecs_query_iter(ecs, q);
      ecs_iter_set_var(&it, player_var, ecs_lookup(ecs, "MyPlayer"));
   
      while (ecs_query_next(&it)) {
          ecs_entity_t player = ecs_iter_get_var(&it, player_var);
          ecs_entity_t platoon = ecs_iter_get_var(&it, platoon_var);
          char *platoon_str = ecs_get_path(ecs, platoon);
          char *class_str = ecs_id_str(ecs, ecs_field_id(&it, 0));
   
          for (int i = 0; i < it.count; i ++) {
              char *unit_str = ecs_get_path(ecs, it.entities[i]);
              printf("Unit %s of class %s in platoon %s for player %s\n", 
                  unit_str, class_str, platoon_str,
                  ecs_get_name(ecs, player));
              ecs_os_free(unit_str);
          }
   
          ecs_os_free(class_str);
          ecs_os_free(platoon_str);
      }
   
      ecs_query_fini(q);
   
      // Output
      //  Unit 513 of class Wizard in platoon 510 for player MyPlayer
      //  Unit 517 of class Wizard in platoon 514 for player MyPlayer
      //  Unit 521 of class Wizard in platoon 518 for player MyPlayer
      //  Unit 512 of class Marksman in platoon 510 for player MyPlayer
      //  Unit 516 of class Marksman in platoon 514 for player MyPlayer
      //  Unit 520 of class Marksman in platoon 518 for player MyPlayer
   
      return ecs_fini(ecs);
  }

• C++

  View on GitHub

  #include <setting_variables.h>
  #include <iostream>
   
  // This example extends the component_inheritance example, and shows how
  // we can use a single query to match units from different players and platoons
  // by setting query variables before we iterate.
  //
  // The units in this example belong to a platoon, with the platoons belonging
  // to a player.
   
  // Unit datamodel
  struct Unit { };
  struct CombatUnit : Unit { };
  struct MeleeUnit : CombatUnit { };
  struct RangedUnit : CombatUnit { };
  struct Warrior : MeleeUnit { };
  struct Wizard : RangedUnit { };
  struct Marksman : RangedUnit { };
   
  // Player/Platoon tags
  struct Player { };
  struct Platoon { };
   
  static const int PlayerCount = 100;
  static const int PlatoonsPerPlayer = 3;
   
  int main(int, char *[]) {
      flecs::world ecs;
   
      // See component_inheritance example
      ecs.component<CombatUnit>().is_a<Unit>();
      ecs.component<MeleeUnit>().is_a<CombatUnit>();
      ecs.component<RangedUnit>().is_a<CombatUnit>();
   
      ecs.component<Warrior>().is_a<MeleeUnit>();
      ecs.component<Wizard>().is_a<RangedUnit>();
      ecs.component<Marksman>().is_a<RangedUnit>();
   
      // Populate store with players and platoons
      for (int p = 0; p < PlayerCount; p ++) {
          flecs::entity player;
   
          // Give first player a name so we can look it up later
          if (p == 0) {
              player = ecs.entity("MyPlayer");
          } else {
              player = ecs.entity();
          }
   
          // Add player tag so we can query for all players if we want to
          player.add<Player>();
   
          for (int pl = 0; pl < PlatoonsPerPlayer; pl ++) {
              flecs::entity platoon = ecs.entity().add<Player>(player);
   
              // Add platoon tag so we can query for all platoons if we want to
              platoon.add<Platoon>();
   
              // Add warriors, wizards and marksmen to the platoon
              ecs.entity().add<Warrior>().add<Platoon>(platoon);
              ecs.entity().add<Marksman>().add<Platoon>(platoon);
              ecs.entity().add<Wizard>().add<Platoon>(platoon);
          }
      }
   
      // Create a query to find all RangedUnits for a platoon/player. The 
      // equivalent query in the query DSL would look like this:
      //   (Platoon, $platoon), Player($platoon, $player)
      //
      // The way to read how this query is evaluated is:
      // - find all entities with (Platoon, *), store * in $platoon
      // - check if _Platoon has (Player, *), store * in $player
      flecs::query<RangedUnit> q = ecs.query_builder<RangedUnit>()
          .with<Platoon>("$platoon")
          .with<Player>("$player").src("$platoon")
          .build();
   
      // If we would iterate this query it would return all ranged units for all
      // platoons & for all players. We can limit the results to just a single
      // platoon or a single player setting a variable beforehand. In this example
      // we'll just find all platoons & ranged units for a single player.
   
      int player_var = q.find_var("player");
      int platoon_var = q.find_var("platoon");
   
      // Iterate query, limit the results to units of MyPlayer
      q.set_var(player_var, ecs.lookup("MyPlayer")) 
          .each([&](flecs::iter& it, size_t index, RangedUnit) {
              flecs::entity unit = it.entity(index);
              std::cout << "Unit " << unit.path() << " of class " 
                        << it.id(0).str() << " in platoon "
                        << it.get_var(platoon_var).path() << " for player "
                        << it.get_var(player_var).path() << "\n";
          });
   
      // Output:
      //  Unit ::499 of class Wizard in platoon ::496 for player ::MyPlayer
      //  Unit ::503 of class Wizard in platoon ::500 for player ::MyPlayer
      //  Unit ::507 of class Wizard in platoon ::504 for player ::MyPlayer
      //  Unit ::498 of class Marksman in platoon ::496 for player ::MyPlayer
      //  Unit ::502 of class Marksman in platoon ::500 for player ::MyPlayer
      //  Unit ::506 of class Marksman in platoon ::504 for player ::MyPlayer
   
      // Try removing the set_var call, this will cause the iterator to return
      // all units in all platoons for all players.
  }