/**
* This file is part of Hercules.
* http://herc.ws - http://github.com/HerculesWS/Hercules
*
* Copyright (C) 2017 Hercules Dev Team
*
* Hercules 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 3 of the License, 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.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#define HERCULES_CORE
#include "config/core.h"
#include "clan.h"
#include "map/clif.h"
#include "map/chrif.h"
#include "map/homunculus.h"
#include "map/intif.h"
#include "map/log.h"
#include "map/mercenary.h"
#include "map/mob.h"
#include "map/npc.h"
#include "map/pc.h"
#include "map/pet.h"
#include "map/script.h"
#include "map/skill.h"
#include "map/status.h"
#include "common/HPM.h"
#include "common/conf.h"
#include "common/cbasetypes.h"
#include "common/db.h"
#include "common/memmgr.h"
#include "common/mapindex.h"
#include "common/nullpo.h"
#include "common/showmsg.h"
#include "common/socket.h"
#include "common/strlib.h"
#include "common/timer.h"
#include "common/utils.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
struct clan_interface clan_s;
struct clan_interface *clan;
/**
* Searches a Clan by clan_id
*
* @param clan_id Clan ID
* @return struct clan*
*/
struct clan *clan_search(int clan_id)
{
if (clan_id <= 0) {
return NULL;
}
return (struct clan *)idb_get(clan->db, clan_id);
}
/**
* Searches a Clan by clan_name or constant
*
* @param name Clan Name
* @return struct clan*
*/
struct clan *clan_searchname(const char *name)
{
struct clan *c;
struct DBIterator *iter;
nullpo_retr(NULL, name);
iter = db_iterator(clan->db);
for (c = dbi_first(iter); dbi_exists(iter); c = dbi_next(iter)) {
if (strncmpi(c->name, name, NAME_LENGTH) == 0 || strncmpi(c->constant, name, NAME_LENGTH) == 0) {
break;
}
}
dbi_destroy(iter);
return c;
}
/**
* Returns the first online character of clan
*
* @param (struct clan *) c clan structure
* @return (struct map_session_data *)
*/
struct map_session_data *clan_getonlinesd(struct clan *c)
{
int i;
nullpo_retr(NULL, c);
ARR_FIND(0, VECTOR_LENGTH(c->members), i, (VECTOR_INDEX(c->members, i).sd != NULL && VECTOR_INDEX(c->members, i).online == 1));
return (i < VECTOR_LENGTH(c->members)) ? VECTOR_INDEX(c->members, i).sd : NULL;
}
/**
* Returns the member index of given Player
*
* @param c Clan Data
* @param char_id Player's Char ID
* @return int
*/
int clan_getindex(const struct clan *c, int char_id)
{
int i;
nullpo_retr(INDEX_NOT_FOUND, c);
ARR_FIND(0, VECTOR_LENGTH(c->members), i, VECTOR_INDEX(c->members, i).char_id == char_id);
if (i == VECTOR_LENGTH(c->members)) {
return INDEX_NOT_FOUND;
}
return i;
}
/**
* Starts clan buff
*/
void clan_buff_start(struct map_session_data *sd, struct clan *c)
{
nullpo_retv(sd);
nullpo_retv(c);
if (c->buff.icon <= 0) {
return;
}
clif->sc_load(&sd->bl, sd->bl.id, SELF, c->buff.icon, 0, c->clan_id, 0);
script->run(c->buff.script, 0, sd->bl.id, npc->fake_nd->bl.id);
}
/**
* Ends clan buff
*/
void clan_buff_end(struct map_session_data *sd, struct clan *c)
{
nullpo_retv(sd);
nullpo_retv(c);
if (c->buff.icon <= 0) {
return;
}
clif->sc_end(&sd->bl, sd->bl.id, SELF, c->buff.icon);
}
/**
* Joins a Player into a Clan
*
* @param sd Player's Map Session Data
* @param clan_id Clan which will add this player
* @return bool
*/
bool clan_join(struct map_session_data *sd, int clan_id)
{
struct clan *c;
struct clan_member m;
nullpo_ret(sd);
// Already joined a guild or clan
if (sd->status.guild_id > 0 || sd->guild != NULL) {
ShowError("clan_join: Player already joined in a guild. char_id: %d\n", sd->status.char_id);
return false;
} else if ( sd->status.clan_id > 0 || sd->clan != NULL) {
ShowError("clan_join: Player already joined in a clan. char_id: %d\n", sd->status.char_id);
return false;
}
c = clan->search(clan_id);
if (c == NULL) {
ShowError("clan_join: Invalid Clan ID: %d\n", clan_id);
return false;
}
if (!c->received) {
return false;
}
if (clan->getindex(c, sd->status.char_id) != INDEX_NOT_FOUND) {
ShowError("clan_join: Player already joined this clan. char_id: %d clan_id: %d\n", sd->status.char_id, clan_id);
return false;
}
if (VECTOR_LENGTH(c->members) >= c->max_member || c->member_count >= c->max_member) {
ShowError("clan_join: Clan '%s' already reached its max capacity!\n", c->name);
return false;
}
VECTOR_ENSURE(c->members, 1, 1);
m.sd = sd;
m.char_id = sd->status.char_id;
m.online = 1;
m.last_login = sd->status.last_login;
VECTOR_PUSH(c->members, m);
c->connect_member++;
c->member_count++;
sd->status.clan_id = c->clan_id;
sd->clan = c;
sc_start2(NULL, &sd->bl, SC_CLAN_INFO, 10000, 0, c->clan_id, INFINITE_DURATION);
status_calc_pc(sd, SCO_FORCE);
chrif->save(sd, 0);
clif->clan_basicinfo(sd);
clif->clan_onlinecount(c);
return true;
}
/**
* Invoked when a player joins
* It assumes that clan_id is not 0
*
* @param sd Player Data
*/
void clan_member_online(struct map_session_data *sd, bool first)
{
struct clan *c;
int i, inactivity;
nullpo_retv(sd);
// For invalid values we must reset it to 0 (no clan)
if (sd->status.clan_id < 0) {
ShowError("clan_member_online: Invalid clan id, changing to '0'. clan_id='%d' char_id='%d'\n", sd->status.clan_id, sd->status.char_id);
sd->status.clan_id = 0;
return;
}
c = clan->search(sd->status.clan_id);
if (c == NULL) {
// This is a silent return because it will reset clan_id in case
// a custom clan that was removed and this is a remaining member
sd->status.clan_id = 0;
sd->clan = NULL;
if (!first) {
status_change_end(&sd->bl, SC_CLAN_INFO, INVALID_TIMER); // Remove the status
status_calc_pc(sd, SCO_FORCE);
}
clif->clan_leave(sd);
return;
}
if (!c->received) {
return;
}
if (c->max_member <= c->member_count || VECTOR_LENGTH(c->members) >= c->max_member) {
ShowError("Clan System: More members than the maximum allowed in clan #%d\n", c->clan_id);
return;
}
i = clan->getindex(c, sd->status.char_id);
inactivity = (int)(time(NULL) - sd->status.last_login);
if (i == INDEX_NOT_FOUND) {
struct clan_member m;
if (c->kick_time > 0 && inactivity > c->kick_time) {
sd->status.clan_id = 0;
sd->clan = NULL;
clan->buff_end(sd, c);
status_change_end(&sd->bl, SC_CLAN_INFO, INVALID_TIMER);
clif->clan_leave(sd);
return;
}
VECTOR_ENSURE(c->members, 1, 1);
m.sd = sd;
m.char_id = sd->status.char_id;
m.online = 1;
m.last_login = sd->status.last_login;
VECTOR_PUSH(c->members, m);
} else {
struct clan_member *m = &VECTOR_INDEX(c->members, i);
if (c->kick_time > 0 && inactivity > c->kick_time) {
if (m->online == 1) {
m->online = 0;
m->sd = NULL;
c->connect_member--;
c->member_count--;
}
clan->buff_end(sd, c);
sd->status.clan_id = 0;
sd->clan = NULL;
status_change_end(&sd->bl, SC_CLAN_INFO, INVALID_TIMER);
VECTOR_ERASE(c->members, i);
clif->clan_leave(sd);
return;
}
m->sd = sd;
m->online = 1;
m->last_login = sd->status.last_login;
}
sd->clan = c;
c->connect_member++;
sc_start2(NULL, &sd->bl, SC_CLAN_INFO, 10000, 0, c->clan_id, INFINITE_DURATION);
if (!first) {
// When first called from pc.c we don't need to do status_calc
status_calc_pc(sd, SCO_FORCE);
}
clif->clan_basicinfo(sd);
clif->clan_onlinecount(c);
}
/**
* Re-join a player on its clan
*/
int clan_rejoin(struct map_session_data *sd, va_list ap)
{
nullpo_ret(sd);
if (sd->status.clan_id != 0) {
// Note: Even if the value is invalid (lower than zero)
// the function will fix the invalid value
clan->member_online(sd, false);
}
return 0;
}
/**
* Removes Player from clan
*/
bool clan_leave(struct map_session_data *sd, bool first)
{
int i;
struct clan *c;
nullpo_ret(sd);
c = sd->clan;
if (c == NULL) {
return false;
}
if (!c->received) {
return false;
}
i = clan->getindex(c, sd->status.char_id);
if (i != INDEX_NOT_FOUND) {
VECTOR_ERASE(c->members, i);
c->connect_member--;
c->member_count--;
}
sd->status.clan_id = 0;
sd->clan = NULL;
clan->buff_end(sd, c);
status_change_end(&sd->bl, SC_CLAN_INFO, INVALID_TIMER);
if (!first) {
status_calc_pc(sd, SCO_FORCE);
}
chrif->save(sd, 0);
clif->clan_onlinecount(c);
clif->clan_leave(sd);
return true;
}
/**
* Sets a player offline
*
* @param (struct map_session_data *) sd Player Data
*/
void clan_member_offline(struct map_session_data *sd)
{
struct clan *c;
int i;
nullpo_retv(sd);
c = sd->clan;
if (c == NULL) {
return;
}
i = clan->getindex(c, sd->status.char_id);
if (i != INDEX_NOT_FOUND && VECTOR_INDEX(c->members, i).online == 1) {
// Only if it is online, because unit->free is called twice
VECTOR_INDEX(c->members, i).online = 0;
VECTOR_INDEX(c->members, i).sd = NULL;
c->connect_member--;
}
clif->clan_onlinecount(c);
}
/**
* Sends a message to the whole clan
*/
bool clan_send_message(struct map_session_data *sd, const char *mes)
{
int len;
nullpo_retr(false, sd);
nullpo_retr(false, mes);
len = (int)strlen(mes);
if (sd->status.clan_id == 0) {
return false;
}
clan->recv_message(sd->clan, mes, len);
// Chat logging type 'C' / Clan Chat
logs->chat(LOG_CHAT_CLAN, sd->status.clan_id, sd->status.char_id, sd->status.account_id, mapindex_id2name(sd->mapindex), sd->bl.x, sd->bl.y, NULL, mes);
return true;
}
/**
* Clan receive a message, will be displayed to whole clan
*/
void clan_recv_message(struct clan *c, const char *mes, int len)
{
clif->clan_message(c, mes, len);
}
/**
* Set constants for each clan
*/
void clan_set_constants(void)
{
struct DBIterator *iter = db_iterator(clan->db);
struct clan *c;
for (c = dbi_first(iter); dbi_exists(iter); c = dbi_next(iter)) {
script->set_constant2(c->constant, c->clan_id, false, false);
}
dbi_destroy(iter);
}
/**
* Returns the clan_id of bl
*/
int clan_get_id(const struct block_list *bl)
{
nullpo_ret(bl);
switch (bl->type) {
case BL_PC: {
const struct map_session_data *sd = BL_UCCAST(BL_PC, bl);
return sd->status.clan_id;
}
case BL_NPC: {
const struct npc_data *nd = BL_UCCAST(BL_NPC, bl);
return nd->clan_id;
}
case BL_PET: {
const struct pet_data *pd = BL_UCCAST(BL_PET, bl);
if (pd->msd != NULL)
return pd->msd->status.clan_id;
}
break;
case BL_MOB: {
const struct mob_data *md = BL_UCCAST(BL_MOB, bl);
const struct map_session_data *msd;
if (md->special_state.ai != AI_NONE && (msd = map->id2sd(md->master_id)) != NULL) {
return msd->status.clan_id;
}
return md->clan_id;
}
case BL_HOM: {
const struct homun_data *hd = BL_UCCAST(BL_HOM, bl);
if (hd->master != NULL) {
return hd->master->status.clan_id;
}
}
break;
case BL_MER: {
const struct mercenary_data *md = BL_UCCAST(BL_MER, bl);
if (md->master != NULL) {
return md->master->status.clan_id;
}
}
break;
case BL_SKILL: {
const struct skill_unit *su = BL_UCCAST(BL_SKILL, bl);
if (su->group != NULL)
return su->group->clan_id;
}
break;
}
return 0;
}
/**
* Checks every clan player and remove those who are inactive
*/
int clan_inactivity_kick(int tid, int64 tick, int id, intptr_t data)
{
struct clan *c = NULL;
int i;
if ((c = clan->search(id)) != NULL) {
if (!c->kick_time || c->tid != tid || tid == INVALID_TIMER || c->tid == INVALID_TIMER) {
ShowError("Timer Mismatch (Time: %d seconds) %d != %d", c->kick_time, c->tid, tid);
Assert_report(0);
return 0;
}
for (i = 0; i < VECTOR_LENGTH(c->members); i++) {
struct clan_member *m = &VECTOR_INDEX(c->members, i);
if (m->char_id <= 0 || m->online <= 0)
continue;
if (m->online) {
struct map_session_data *sd = m->sd;
if (DIFF_TICK32(sockt->last_tick, sd->idletime) > c->kick_time) {
clan->leave(sd, false);
}
} else if ((time(NULL) - m->last_login) > c->kick_time) {
VECTOR_ERASE(c->members, i);
c->member_count--;
clif->clan_onlinecount(c);
}
}
//Perform the kick for offline members that didn't connect after a server restart
c->received = false;
intif->clan_kickoffline(c->clan_id, c->kick_time);
c->tid = timer->add(timer->gettick() + c->check_time, clan->inactivity_kick, c->clan_id, 0);
}
return 1;
}
/**
* Timeout for the request of offline kick
*/
int clan_request_kickoffline(int tid, int64 tick, int id, intptr_t data)
{
struct clan *c = NULL;
if ((c = clan->search(id)) != NULL) {
if (c->req_kick_tid != tid || c->req_kick_tid == INVALID_TIMER) {
ShowError("Timer Mismatch %d != %d", c->tid, tid);
return 0;
}
if (c->received) {
c->req_kick_tid = INVALID_TIMER;
return 1;
}
intif->clan_kickoffline(c->clan_id, c->kick_time);
c->req_kick_tid = timer->add(timer->gettick() + clan->req_timeout, clan->request_kickoffline, c->clan_id, 0);
}
return 1;
}
/**
* Timeout of the request for counting members
*/
int clan_request_membercount(int tid, int64 tick, int id, intptr_t data)
{
struct clan *c = NULL;
if ((c = clan->search(id)) != NULL) {
if (c->req_count_tid != tid || c->req_count_tid == INVALID_TIMER) {
ShowError("Timer Mismatch %d != %d", c->tid, tid);
return 0;
}
if (c->received) {
c->req_count_tid = INVALID_TIMER;
return 1;
}
intif->clan_membercount(c->clan_id, c->kick_time);
c->req_count_tid = timer->add(timer->gettick() + clan->req_timeout, clan->request_membercount, c->clan_id, 0);
}
return 1;
}
/**
* Processes any (plugin-defined) additional fields for a clan entry.
*
* @param[in, out] entry The destination clan entry, already initialized (clan_id is expected to be already set).
* @param[in] t The libconfig entry.
* @param[in] n Ordinal number of the entry, to be displayed in case of validation errors.
* @param[in] source Source of the entry (file name), to be displayed in case of validation errors.
*/
void clan_read_db_additional_fields(struct clan *entry, struct config_setting_t *t, int n, const char *source)
{
// do nothing. plugins can do own work
}
void clan_read_buffs(struct clan *c, struct config_setting_t *buff, const char *source)
{
struct clan_buff *b;
const char *str = NULL;
nullpo_retv(c);
nullpo_retv(buff);
b = &c->buff;
if (!libconfig->setting_lookup_int(buff, "Icon", &b->icon)) {
const char *temp_str = NULL;
if (libconfig->setting_lookup_string(buff, "Icon", &temp_str)) {
if (*temp_str && !script->get_constant(temp_str, &b->icon)) {
ShowWarning("Clan %d: Invalid Buff icon value. Defaulting to SI_BLANK.\n", c->clan_id);
b->icon = -1; // SI_BLANK
}
}
}
if (libconfig->setting_lookup_string(buff, "Script", &str)) {
b->script = *str ? script->parse(str, source, -b->icon, SCRIPT_IGNORE_EXTERNAL_BRACKETS, NULL) : NULL;
}
}
/**
* Processes one clandb entry from the libconfig file, loading and inserting it
* into the clan database.
*
* @param settings Libconfig setting entry. It is expected to be valid and it
* won't be freed (it is care of the caller to do so if
* necessary).
* @param source Source of the entry (file name), to be displayed in case of
* validation errors.
* @return int.
*/
int clan_read_db_sub(struct config_setting_t *settings, const char *source, bool reload)
{
int total, s, valid = 0;
nullpo_retr(false, settings);
total = libconfig->setting_length(settings);
for (s = 0; s < total; s++) {
struct clan *c;
struct config_setting_t *cl, *buff, *allies, *antagonists;
const char *aName, *aLeader, *aMap, *aConst;
int max_members, kicktime = 0, kickchecktime = 0, id, i, j;
cl = libconfig->setting_get_elem(settings, s);
if (libconfig->setting_lookup_int(cl, "Id", &id)) {
if (id <= 0) {
ShowError("clan_read_db: Invalid Clan Id %d, skipping...\n", id);
return false;
}
if (clan->search(id) != NULL) {
ShowError("clan_read_db: Duplicate entry for Clan Id %d, skipping...\n", id);
return false;
}
} else {
ShowError("clan_read_db: failed to find 'Id' for clan #%d\n", s);
return false;
}
if (libconfig->setting_lookup_string(cl, "Const", &aConst)) {
if (!*aConst) {
ShowError("clan_read_db: Invalid Clan Const '%s', skipping...\n", aConst);
return false;
}
if (strlen(aConst) > NAME_LENGTH) {
ShowError("clan_read_db: Clan Name '%s' is longer than %d characters, skipping...\n", aConst, NAME_LENGTH);
return false;
}
if (clan->searchname(aConst) != NULL) {
ShowError("clan_read_db: Duplicate entry for Clan Const '%s', skipping...\n", aConst);
return false;
}
} else {
ShowError("clan_read_db: failed to find 'Const' for clan #%d\n", s);
return false;
}
if (libconfig->setting_lookup_string(cl, "Name", &aName)) {
if (!*aName) {
ShowError("clan_read_db: Invalid Clan Name '%s', skipping...\n", aName);
return false;
}
if (strlen(aName) > NAME_LENGTH) {
ShowError("clan_read_db: Clan Name '%s' is longer than %d characters, skipping...\n", aName, NAME_LENGTH);
return false;
}
if (clan->searchname(aName) != NULL) {
ShowError("clan_read_db: Duplicate entry for Clan Name '%s', skipping...\n", aName);
return false;
}
} else {
ShowError("clan_read_db: failed to find 'Name' for clan #%d\n", s);
return false;
}
if (!libconfig->setting_lookup_string(cl, "Leader", &aLeader)) {
ShowError("clan_read_db: failed to find 'Leader' for clan #%d\n", s);
return false;
}
if (!libconfig->setting_lookup_string(cl, "Map", &aMap)) {
ShowError("clan_read_db: failed to find 'Map' for clan #%d\n", s);
return false;
}
CREATE(c, struct clan, 1);
c->clan_id = id;
safestrncpy(c->constant, aConst, NAME_LENGTH);
safestrncpy(c->name, aName, NAME_LENGTH);
safestrncpy(c->master, aLeader, NAME_LENGTH);
safestrncpy(c->map, aMap, MAP_NAME_LENGTH_EXT);
c->connect_member = 0;
c->member_count = 0; // Char server will count members for us
c->received = false;
c->req_count_tid = INVALID_TIMER;
c->req_kick_tid = INVALID_TIMER;
c->tid = INVALID_TIMER;
if (libconfig->setting_lookup_int(cl, "MaxMembers", &max_members)) {
if (max_members > 0) {
c->max_member = max_members;
} else {
ShowError("clan_read_db: Clan #%d has invalid value for 'MaxMembers' setting, defaulting to 'clan->max'...\n", id);
c->max_member = clan->max;
}
} else {
c->max_member = clan->max;
}
if (libconfig->setting_lookup_int(cl, "KickTime", &kicktime)) {
c->kick_time = 60 * 60 * kicktime;
} else {
c->kick_time = clan->kicktime;
}
if (libconfig->setting_lookup_int(cl, "CheckTime", &kickchecktime)) {
c->check_time = 60 * 60 * max(1, kickchecktime) * 1000;
} else {
c->check_time = clan->checktime;
}
if ((buff = libconfig->setting_get_member(cl, "Buff")) != NULL) {
clan->read_buffs(c, buff, source);
}
allies = libconfig->setting_get_member(cl, "Allies");
if (allies != NULL) {
int a = libconfig->setting_length(allies);
VECTOR_INIT(c->allies);
if (a > 0 && clan->max_relations > 0) {
const char *allyConst;
if (a > clan->max_relations) {
ShowWarning("clan_read_db: Clan %d has more allies(%d) than allowed(%d), reading only the first %d...\n", c->clan_id, a, clan->max_relations, clan->max_relations);
a = clan->max_relations;
}
VECTOR_ENSURE(c->allies, a, 1);
for (i = 0; i < a; i++) {
struct clan_relationship r;
if ((allyConst = libconfig->setting_get_string_elem(allies, i)) != NULL) {
ARR_FIND(0, VECTOR_LENGTH(c->allies), j, strcmp(VECTOR_INDEX(c->allies, j).constant, allyConst) == 0);
if (j != VECTOR_LENGTH(c->allies)) {
ShowError("clan_read_db: Duplicate entry '%s' in allies for Clan %d in '%s', skipping...\n", allyConst, c->clan_id, source);
continue;
} else if (strcmp(allyConst, c->constant) == 0) {
ShowError("clan_read_db: Clans can't be allies of themselves! Clan Id: %d, in '%s'\n", c->clan_id, source);
continue;
}
safestrncpy(r.constant, allyConst, NAME_LENGTH);
VECTOR_PUSH(c->allies, r);
}
}
}
}
antagonists = libconfig->setting_get_member(cl, "Antagonists");
if (antagonists != NULL) {
int a = libconfig->setting_length(antagonists);
VECTOR_INIT(c->antagonists);
if (a > 0 && clan->max_relations > 0) {
const char *antagonistConst;
if (a > clan->max_relations) {
ShowWarning("clan_read_db: Clan %d has more antagonists(%d) than allowed(%d), reading only the first %d...\n", c->clan_id, a, clan->max_relations, clan->max_relations);
a = clan->max_relations;
}
VECTOR_ENSURE(c->antagonists, a, 1);
for (i = 0; i < a; i++) {
struct clan_relationship r;
if ((antagonistConst = libconfig->setting_get_string_elem(antagonists, i)) != NULL) {
ARR_FIND(0, VECTOR_LENGTH(c->antagonists), j, strcmp(VECTOR_INDEX(c->antagonists, j).constant, antagonistConst) == 0);
if (j != VECTOR_LENGTH(c->antagonists)) {
ShowError("clan_read_db: Duplicate entry '%s' in antagonists for Clan %d in '%s', skipping...\n", antagonistConst, c->clan_id, source);
continue;
} else if (strcmp(antagonistConst, c->constant) == 0) {
ShowError("clan_read_db: Clans can't be antagonists of themselves! Clan Id: %d, in '%s'\n", c->clan_id, source);
continue;
}
safestrncpy(r.constant, antagonistConst, NAME_LENGTH);
VECTOR_PUSH(c->antagonists, r);
}
}
}
}
clan->read_db_additional_fields(c, cl, s, source);
if (c->kick_time > 0) {
c->tid = timer->add(timer->gettick() + c->check_time, clan->inactivity_kick, c->clan_id, 0);
}
c->received = false;
c->req_state = reload ? CLAN_REQ_RELOAD : CLAN_REQ_FIRST;
c->req_count_tid = timer->add(timer->gettick() + clan->req_timeout, clan->request_membercount, c->clan_id, 0);
idb_put(clan->db, c->clan_id, c);
VECTOR_INIT(c->members);
valid++;
}
// Validating Relations
if (valid > 0) {
struct DBIterator *iter = db_iterator(clan->db);
struct clan *c_ok, *c;
int i;
for (c_ok = dbi_first(iter); dbi_exists(iter); c_ok = dbi_next(iter)) {
i = VECTOR_LENGTH(c_ok->allies);
while ( i > 0) {
struct clan_relationship *r;
i--;
r = &VECTOR_INDEX(c_ok->allies, i);
if ((c = clan->searchname(r->constant)) == NULL) {
ShowError("clan_read_db: Invalid (nonexistent) Ally '%s' for clan %d in '%s', skipping ally...\n", r->constant, c_ok->clan_id, source);
VECTOR_ERASE(c_ok->allies, i);
} else {
r->clan_id = c->clan_id;
}
}
i = VECTOR_LENGTH(c_ok->antagonists);
while ( i > 0) {
struct clan_relationship *r;
i--;
r = &VECTOR_INDEX(c_ok->antagonists, i);
if ((c = clan->searchname(r->constant)) == NULL) {
ShowError("clan_read_db: Invalid (nonexistent) Antagonist '%s' for clan %d in '%s', skipping antagonist...", r->constant, c_ok->clan_id, source);
VECTOR_ERASE(c_ok->antagonists, i);
} else {
r->clan_id = c->clan_id;
}
}
}
dbi_destroy(iter);
}
ShowStatus("Done reading '" CL_WHITE "%d" CL_RESET "' valid clans of '" CL_WHITE "%d" CL_RESET "' entries in '" CL_WHITE "%s" CL_RESET "'.\n", valid, total, source);
return valid;
}
/**
* Reads Clan DB included by clan configuration file.
*
* @param settings The Settings Group from config file.
* @param source File name.
*/
void clan_read_db(struct config_setting_t *settings, const char *source, bool reload)
{
struct config_setting_t *clans;
nullpo_retv(settings);
if ((clans = libconfig->setting_get_member(settings, "clans")) != NULL) {
int read;
read = clan->read_db_sub(clans, source, reload);
if (read > 0) {
clan->set_constants();
}
} else {
ShowError("clan_read_db: Can't find setting 'clans' in '%s'. No Clans found.\n", source);
}
}
/**
* Reads clan config file
*
* @param bool clear Whether to clear clan->db before reading clans
*/
bool clan_config_read(bool reload)
{
struct config_t clan_conf;
struct config_setting_t *settings = NULL;
const char *config_filename = "conf/clans.conf"; // FIXME: hardcoded name
int kicktime = 0, kickchecktime = 0;
if (reload) {
struct DBIterator *iter = db_iterator(clan->db);
struct clan *c_clear;
for (c_clear = dbi_first(iter); dbi_exists(iter); c_clear = dbi_next(iter)) {
if (c_clear->buff.script != NULL) {
script->free_code(c_clear->buff.script);
}
if (c_clear->tid != INVALID_TIMER) {
timer->delete(c_clear->tid, clan->inactivity_kick);
}
VECTOR_CLEAR(c_clear->allies);
VECTOR_CLEAR(c_clear->antagonists);
VECTOR_CLEAR(c_clear->members);
HPM->data_store_destroy(&c_clear->hdata);
}
dbi_destroy(iter);
clan->db->clear(clan->db, NULL);
}
if (!libconfig->load_file(&clan_conf, config_filename)) {
return false;
}
if ((settings = libconfig->lookup(&clan_conf, "clan_configuration")) == NULL) {
ShowError("clan_config_read: failed to find 'clan_configuration'.\n");
return false;
}
libconfig->setting_lookup_int(settings, "MaxMembers", &clan->max);
libconfig->setting_lookup_int(settings, "MaxRelations", &clan->max_relations);
libconfig->setting_lookup_int(settings, "InactivityKickTime", &kicktime);
if (!libconfig->setting_lookup_int(settings, "InactivityCheckTime", &kickchecktime)) {
ShowError("clan_config_read: failed to find InactivityCheckTime using official value.\n");
kickchecktime = 24;
}
// On config file we set the time in hours but here we use in seconds
clan->kicktime = 60 * 60 * kicktime;
clan->checktime = 60 * 60 * max(kickchecktime, 1) * 1000;
clan->config_read_additional_settings(settings, config_filename);
clan->read_db(settings, config_filename, reload);
libconfig->destroy(&clan_conf);
return true;
}
/**
* Processes any (plugin-defined) additional settings for clan config.
*
* @param settings The Settings Group from config file.
* @param source Source of the entry (file name), to be displayed in
* case of validation errors.
*/
void clan_config_read_additional_settings(struct config_setting_t *settings, const char *source)
{
// do nothing. plugins can do own work
}
/**
* Reloads Clan DB
*/
void clan_reload(void)
{
clan->config_read(true);
}
/**
*
*/
void do_init_clan(bool minimal)
{
if (minimal) {
return;
}
clan->db = idb_alloc(DB_OPT_RELEASE_DATA);
clan->config_read(false);
timer->add_func_list(clan->inactivity_kick, "clan_inactivity_kick");
}
/**
*
*/
void do_final_clan(void)
{
struct DBIterator *iter = db_iterator(clan->db);
struct clan *c;
for (c = dbi_first(iter); dbi_exists(iter); c = dbi_next(iter)) {
if (c->buff.script) {
script->free_code(c->buff.script);
}
if (c->tid != INVALID_TIMER) {
timer->delete(c->tid, clan->inactivity_kick);
}
VECTOR_CLEAR(c->allies);
VECTOR_CLEAR(c->antagonists);
VECTOR_CLEAR(c->members);
HPM->data_store_destroy(&c->hdata);
}
dbi_destroy(iter);
db_destroy(clan->db);
}
/**
* Inits Clan Defaults
*/
void clan_defaults(void)
{
clan = &clan_s;
clan->init = do_init_clan;
clan->final = do_final_clan;
/* */
clan->db = NULL;
clan->max = 0;
clan->max_relations = 0;
clan->kicktime = 0;
clan->checktime = 0;
clan->req_timeout = 60;
/* */
clan->config_read = clan_config_read;
clan->config_read_additional_settings = clan_config_read_additional_settings;
clan->read_db = clan_read_db;
clan->read_db_sub = clan_read_db_sub;
clan->read_db_additional_fields = clan_read_db_additional_fields;
clan->read_buffs = clan_read_buffs;
clan->search = clan_search;
clan->searchname = clan_searchname;
clan->getonlinesd = clan_getonlinesd;
clan->getindex = clan_getindex;
clan->join = clan_join;
clan->member_online = clan_member_online;
clan->leave = clan_leave;
clan->send_message = clan_send_message;
clan->recv_message = clan_recv_message;
clan->member_offline = clan_member_offline;
clan->set_constants = clan_set_constants;
clan->get_id = clan_get_id;
clan->buff_start = clan_buff_start;
clan->buff_end = clan_buff_end;
clan->reload = clan_reload;
clan->rejoin = clan_rejoin;
clan->inactivity_kick = clan_inactivity_kick;
clan->request_kickoffline = clan_request_kickoffline;
clan->request_membercount = clan_request_membercount;
}