team.c

Go to the documentation of this file.

/***********************************************************************
 Freeciv - Copyright (C) 2005 - The Freeciv Project
   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2, or (at your option)
   any later version.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
***********************************************************************/
 
#ifdef HAVE_CONFIG_H
#include <fc_config.h>
#endif
 
#include <stdlib.h>
 
/* utility */
#include "fcintl.h"
#include "log.h"
#include "shared.h"
#include "support.h"
 
/* common */
#include "game.h"
#include "player.h"
#include "team.h"
 
struct team_slot {
  struct team *team;
  char *defined_name;                   /* Defined by the ruleset. */
  char *rule_name;                      /* Usable untranslated name. */
#ifdef FREECIV_ENABLE_NLS
  char *name_translation;               /* Translated name. */
#endif
};
 
struct team {
  struct player_list *plrlist;
  struct team_slot *slot;
};
 
static struct {
  struct team_slot *slots;
  int used_slots;
} team_slots;
 
/************************************************************************/
void team_slots_init(void)
{
  int i;
 
  /* Init team slots and names. */
  team_slots.slots = fc_calloc(team_slot_count(), sizeof(*team_slots.slots));
  /* Can't use the defined functions as the needed data will be
   * defined here. */
  for (i = 0; i < team_slot_count(); i++) {
    struct team_slot *tslot = team_slots.slots + i;
 
    tslot->team = nullptr;
    tslot->defined_name = nullptr;
    tslot->rule_name = nullptr;
#ifdef FREECIV_ENABLE_NLS
    tslot->name_translation = nullptr;
#endif
  }
  team_slots.used_slots = 0;
}
 
/************************************************************************/
bool team_slots_initialised(void)
{
  return (team_slots.slots != nullptr);
}
 
/************************************************************************/
void team_slots_free(void)
{
  team_slots_iterate(tslot) {
    if (tslot->team != nullptr) {
      team_destroy(tslot->team);
    }
    if (tslot->defined_name != nullptr) {
      free(tslot->defined_name);
    }
    if (tslot->rule_name != nullptr) {
      free(tslot->rule_name);
    }
#ifdef FREECIV_ENABLE_NLS
    if (tslot->name_translation != nullptr) {
      free(tslot->name_translation);
    }
#endif /* FREECIV_ENABLE_NLS */
  } team_slots_iterate_end;
  free(team_slots.slots);
  team_slots.slots = nullptr;
 
  team_slots.used_slots = 0;
}
 
/************************************************************************/
int team_slot_count(void)
{
  return (MAX_NUM_TEAM_SLOTS);
}
 
/************************************************************************/
struct team_slot *team_slot_first(void)
{
  return team_slots.slots;
}
 
/************************************************************************/
struct team_slot *team_slot_next(struct team_slot *tslot)
{
  tslot++;
  return (tslot < team_slots.slots + team_slot_count() ? tslot : nullptr);
}
 
 
/************************************************************************/
int team_slot_index(const struct team_slot *tslot)
{
  fc_assert_ret_val(team_slots_initialised(), -1);
  fc_assert_ret_val(tslot != nullptr, -1);
 
  return tslot - team_slots.slots;
}
 
/************************************************************************/
struct team *team_slot_get_team(const struct team_slot *tslot)
{
  fc_assert_ret_val(team_slots_initialised(), nullptr);
  fc_assert_ret_val(tslot != nullptr, nullptr);
 
  return tslot->team;
}
 
/************************************************************************/
bool team_slot_is_used(const struct team_slot *tslot)
{
  /* No team slot available, if the game is not initialised. */
  if (!team_slots_initialised()) {
    return FALSE;
  }
 
  return tslot->team != nullptr;
}
 
/************************************************************************/
struct team_slot *team_slot_by_number(int team_id)
{
  if (!team_slots_initialised()
      || !(0 <= team_id && team_id < team_slot_count())) {
    return nullptr;
  }
 
  return team_slots.slots + team_id;
}
 
/************************************************************************/
struct team_slot *team_slot_by_rule_name(const char *team_name)
{
  fc_assert_ret_val(team_name != nullptr, nullptr);
 
  team_slots_iterate(tslot) {
    const char *tname = team_slot_rule_name(tslot);
 
    if (tname != nullptr && 0 == fc_strcasecmp(tname, team_name)) {
      return tslot;
    }
  } team_slots_iterate_end;
 
  return nullptr;
}
 
/************************************************************************/
static inline void team_slot_create_default_name(struct team_slot *tslot)
{
  char buf[MAX_LEN_NAME];
 
  fc_assert(tslot->defined_name == nullptr);
  fc_assert(tslot->rule_name == nullptr);
#ifdef FREECIV_ENABLE_NLS
  fc_assert(tslot->name_translation == nullptr);
#endif /* FREECIV_ENABLE_NLS */
 
  fc_snprintf(buf, sizeof(buf), "Team %d", team_slot_index(tslot) + 1);
  tslot->rule_name = fc_strdup(buf);
 
#ifdef FREECIV_ENABLE_NLS
  fc_snprintf(buf, sizeof(buf), _("Team %d"), team_slot_index(tslot) + 1);
  tslot->name_translation = fc_strdup(buf);
#endif /* FREECIV_ENABLE_NLS */
 
  log_verbose("No name defined for team %d! Creating a default name: %s.",
              team_slot_index(tslot), tslot->rule_name);
}
 
/************************************************************************/
const char *team_slot_rule_name(const struct team_slot *tslot)
{
  fc_assert_ret_val(team_slots_initialised(), nullptr);
  fc_assert_ret_val(tslot != nullptr, nullptr);
 
  if (tslot->rule_name == nullptr) {
    /* Get the team slot as changeable (not _const_) struct. */
    struct team_slot *changeable
      = team_slot_by_number(team_slot_index(tslot));
    team_slot_create_default_name(changeable);
    return changeable->rule_name;
  }
 
  return tslot->rule_name;
}
 
/************************************************************************/
const char *team_slot_name_translation(const struct team_slot *tslot)
{
#ifdef FREECIV_ENABLE_NLS
  fc_assert_ret_val(team_slots_initialised(), nullptr);
  fc_assert_ret_val(tslot != nullptr, nullptr);
 
  if (tslot->name_translation == nullptr) {
    /* Get the team slot as changeable (not _const_) struct. */
    struct team_slot *changeable
      = team_slot_by_number(team_slot_index(tslot));
    team_slot_create_default_name(changeable);
    return changeable->name_translation;
  }
 
  return tslot->name_translation;
#else  /* FREECIV_ENABLE_NLS */
  return team_slot_rule_name(tslot);
#endif /* FREECIV_ENABLE_NLS */
}
 
/************************************************************************/
const char *team_slot_defined_name(const struct team_slot *tslot)
{
  fc_assert_ret_val(team_slots_initialised(), nullptr);
  fc_assert_ret_val(tslot != nullptr, nullptr);
 
  return tslot->defined_name;
}
 
/************************************************************************/
void team_slot_set_defined_name(struct team_slot *tslot,
                                const char *team_name)
{
  fc_assert_ret(team_slots_initialised());
  fc_assert_ret(tslot != nullptr);
  fc_assert_ret(team_name != nullptr);
 
  if (tslot->defined_name != nullptr) {
    free(tslot->defined_name);
  }
  tslot->defined_name = fc_strdup(team_name);
 
  if (tslot->rule_name != nullptr) {
    free(tslot->rule_name);
  }
  tslot->rule_name = fc_strdup(Qn_(team_name));
 
#ifdef FREECIV_ENABLE_NLS
  if (tslot->name_translation != nullptr) {
    free(tslot->name_translation);
  }
  tslot->name_translation = fc_strdup(Q_(team_name));
#endif /* FREECIV_ENABLE_NLS */
}
 
/************************************************************************/
struct team *team_new(struct team_slot *tslot)
{
  struct team *pteam;
 
  fc_assert_ret_val(team_slots_initialised(), nullptr);
 
  if (tslot == nullptr) {
    team_slots_iterate(aslot) {
      if (!team_slot_is_used(aslot)) {
        tslot = aslot;
        break;
      }
    } team_slots_iterate_end;
 
    if (tslot == nullptr) {
      return nullptr;
    }
  } else if (tslot->team != nullptr) {
    return tslot->team;
  }
 
  /* Now create the team. */
  log_debug("Create team for slot %d.", team_slot_index(tslot));
  pteam = fc_calloc(1, sizeof(*pteam));
  pteam->slot = tslot;
  tslot->team = pteam;
 
  /* Set default values. */
  pteam->plrlist = player_list_new();
 
  /* Increase number of teams. */
  team_slots.used_slots++;
 
  return pteam;
}
 
/************************************************************************/
void team_destroy(struct team *pteam)
{
  struct team_slot *tslot;
 
  fc_assert_ret(team_slots_initialised());
  fc_assert(0 == player_list_size(pteam->plrlist));
 
  tslot = pteam->slot;
  fc_assert(tslot->team == pteam);
 
  player_list_destroy(pteam->plrlist);
  free(pteam);
  tslot->team = nullptr;
  team_slots.used_slots--;
}
 
/************************************************************************/
int team_count(void)
{
  return team_slots.used_slots;
}
 
/************************************************************************/
int team_index(const struct team *pteam)
{
  return team_number(pteam);
}
 
/************************************************************************/
int team_number(const struct team *pteam)
{
  fc_assert_ret_val(pteam != nullptr, -1);
 
  return team_slot_index(pteam->slot);
}
 
/************************************************************************/
struct team *team_by_number(const int team_id)
{
  const struct team_slot *tslot = team_slot_by_number(team_id);
 
  return (tslot != nullptr ? team_slot_get_team(tslot) : nullptr);
}
 
/************************************************************************/
const char *team_rule_name(const struct team *pteam)
{
  fc_assert_ret_val(pteam != nullptr, nullptr);
 
  return team_slot_rule_name(pteam->slot);
}
 
/************************************************************************/
const char *team_name_translation(const struct team *pteam)
{
  fc_assert_ret_val(pteam != nullptr, nullptr);
 
  return team_slot_name_translation(pteam->slot);
}
 
/************************************************************************/
int team_pretty_name(const struct team *pteam, char *buf, size_t buf_len)
{
  if (pteam != nullptr) {
    if (pteam->slot->defined_name != nullptr) {
      /* TRANS: %s is ruleset-chosen team name (e.g. "Red") */
      return fc_snprintf(buf, buf_len, _("team %s"),
                         team_slot_name_translation(pteam->slot));
    } else {
      /* The generated name already contains word "Team" so don't repeat it.
       * Also note that number of teams may have changed since the name
       * was originally generated, so the number in it can be
       * something else than current team_number(). */
      return fc_snprintf(buf, buf_len, "%s", team_name_translation(pteam));
    }
  }
 
  /* No need to translate, it's an error. */
  fc_strlcpy(buf, "(null team)", buf_len);
  return -1;
}
 
/************************************************************************/
const struct player_list *team_members(const struct team *pteam)
{
  fc_assert_ret_val(pteam != nullptr, nullptr);
 
  return pteam->plrlist;
}
 
/************************************************************************/
bool team_add_player(struct player *pplayer, struct team *pteam)
{
  fc_assert_ret_val(pplayer != nullptr, FALSE);
 
  if (pteam == nullptr) {
    pteam = team_new(nullptr);
  } else if (pteam == pplayer->team) {
    /* It is the team of the player. */
    return TRUE;
  }
 
  if (pteam == nullptr) {
    return FALSE;
  }
 
  log_debug("Adding player %d/%s to team %s.", player_number(pplayer),
            pplayer->username, team_rule_name(pteam));
 
  /* Remove the player from the old team, if any. */
  team_remove_player(pplayer);
 
  /* Put the player on the new team. */
  pplayer->team = pteam;
  player_list_append(pteam->plrlist, pplayer);
 
  return TRUE;
}
 
/************************************************************************/
void team_remove_player(struct player *pplayer)
{
  struct team *pteam;
 
  if (pplayer->team != nullptr) {
    pteam = pplayer->team;
 
    log_debug("Removing player %d/%s from team %s (%d)",
              player_number(pplayer), player_name(pplayer),
              team_rule_name(pteam), player_list_size(pteam->plrlist));
    player_list_remove(pteam->plrlist, pplayer);
 
    if (player_list_size(pteam->plrlist) == 0) {
      team_destroy(pteam);
    }
  }
 
  pplayer->team = nullptr;
}