/**
* Unbans a character from the given channel.
*
* @param chan The channel.
* @param ssd The source character, if any.
* @param tsd The target character. If no target character is specified, all characters are unbanned.
* @retval HCS_STATUS_OK if the operation succeeded.
* @retval HCS_STATUS_ALREADY if the target character is not banned.
* @retval HCS_STATUS_NOPERM if the source character doesn't have enough permissions.
* @retval HCS_STATUS_FAIL in case of generic failure.
*/
enum channel_operation_status channel_unban(struct channel_data *chan, const struct map_session_data *ssd, struct map_session_data *tsd)
{
nullpo_retr(HCS_STATUS_FAIL, chan);
if (ssd && chan->owner != ssd->status.char_id && !pc_has_permission(ssd, PC_PERM_HCHSYS_ADMIN))
return HCS_STATUS_NOPERM;
if (!chan->banned)
return HCS_STATUS_ALREADY;
if (!tsd) {
// Unban all
db_destroy(chan->banned);
chan->banned = NULL;
return HCS_STATUS_OK;
}
// Unban one
if (!idb_exists(chan->banned, tsd->status.account_id))
return HCS_STATUS_ALREADY;
idb_remove(chan->banned, tsd->status.account_id);
if (!db_size(chan->banned)) {
db_destroy(chan->banned);
chan->banned = NULL;
}
return HCS_STATUS_OK;
}
/**
* Deletes a chat channel.
*
* @param chan The channel to delete
*/
void channel_delete(struct channel_data *chan)
{
nullpo_retv(chan);
if (db_size(chan->users) && !channel->config->closing) {
struct map_session_data *sd;
struct DBIterator *iter = db_iterator(chan->users);
for (sd = dbi_first(iter); dbi_exists(iter); sd = dbi_next(iter)) {
channel->leave_sub(chan, sd);
}
dbi_destroy(iter);
}
if (chan->banned) {
db_destroy(chan->banned);
chan->banned = NULL;
}
db_destroy(chan->users);
if (chan->m) {
map->list[chan->m].channel = NULL;
aFree(chan);
} else if (chan->type == HCS_TYPE_ALLY) {
aFree(chan);
} else if (!channel->config->closing) {
strdb_remove(channel->db, chan->name);
}
}
/**
* Leaves a channel.
*
* @param chan The channel to leave
* @param sd The character
*/
void channel_leave(struct channel_data *chan, struct map_session_data *sd)
{
nullpo_retv(chan);
nullpo_retv(sd);
if (!idb_remove(chan->users,sd->status.char_id))
return;
if (chan == sd->gcbind)
sd->gcbind = NULL;
if (!db_size(chan->users) && chan->type == HCS_TYPE_PRIVATE) {
channel->delete(chan);
} else if (!channel->config->closing && (chan->options & HCS_OPT_ANNOUNCE_JOIN)) {
static inline size_t _env_newsize(db_t db, int flags){
MDB_envinfo info;
size_t ret = 0;
int r;
if(flags & MDB_RDONLY)
return 0;
size_t size = db_size(db);
r = mdb_env_info(db->env, &info);
assert(MDB_SUCCESS == r);
if(size + db->padsize > info.me_mapsize)
ret = ((size / (db->padsize)) + 2) * db->padsize;
return ret;
}
/**
* Make a player join a channel
* - Add player to channel user list
* - Add channel to user channel list
* @param channel: Channel data
* @param sd: Player data
* @return
* 0: Success
* -1: Invalid channel or player
* -2: Player already in channel
* -3: Player banned
* -4: Reached max limit
*/
int channel_join(struct Channel *channel, struct map_session_data *sd) {
if(!channel || !sd)
return -1;
if(sd->state.autotrade)
return 0; // fake success
if(channel_haspc(channel,sd)==1)
return -2;
if (!pc_has_permission(sd, PC_PERM_CHANNEL_ADMIN) && !channel_pccheckgroup(channel, sd->group_id))
return -2;
if(channel_haspcbanned(channel,sd)==1){
char output[CHAT_SIZE_MAX];
sprintf(output, msg_txt(sd,1438),channel->name); //You're currently banned from the '%s' channel.
clif_displaymessage(sd->fd, output);
return -3;
}
if (channel->type == CHAN_TYPE_PRIVATE && db_size(channel->users) >= channel_config.private_channel.max_member) {
char output[CHAT_SIZE_MAX];
sprintf(output, msg_txt(sd,760), channel->name, channel_config.private_channel.max_member); // You cannot join channel '%s'. Limit of %d has been met.
clif_displaymessage(sd->fd, output);
return -4;
}
RECREATE(sd->channels, struct Channel *, ++sd->channel_count);
sd->channels[ sd->channel_count - 1 ] = channel;
idb_put(channel->users, sd->status.char_id, sd);
RECREATE(sd->channel_tick, t_tick, sd->channel_count);
sd->channel_tick[sd->channel_count-1] = 0;
if( sd->stealth ) {
sd->stealth = false;
} else if( channel->opt & CHAN_OPT_ANNOUNCE_JOIN ) {
char output[CHAT_SIZE_MAX];
safesnprintf(output, CHAT_SIZE_MAX, msg_txt(sd,761), channel->alias, sd->status.name); // %s %s has joined.
clif_channel_msg(channel,output,channel->color);
}
/* someone is cheating, we kindly disconnect the bastard */
if( sd->channel_count > 200 ) {
set_eof(sd->fd);
}
return 0;
}
/**
* Make player leave the channel and cleanup association
* - If no one remains in the chat, delete it
* @param channel: Channel data
* @param sd: Player data
* @param flag: Called from deletion process, do not recall delete
* @return
* 0: Success
* -1: Invalid player or channel
*/
int channel_clean(struct Channel *channel, struct map_session_data *sd, int flag) {
unsigned char i;
if(!channel || !sd)
return -1;
if( channel == sd->gcbind )
sd->gcbind = NULL;
ARR_FIND(0, sd->channel_count, i, sd->channels[i] == channel);
if( i < sd->channel_count ) {
unsigned char cursor = i;
sd->channels[i] = NULL;
sd->channel_tick[i] = 0;
for(; i < sd->channel_count; i++ ) { //slice move list down
if( sd->channels[i] == NULL )
continue;
if(i != cursor) {
sd->channels[cursor] = sd->channels[i];
sd->channel_tick[cursor] = sd->channel_tick[i];
}
cursor++;
}
if ( !(sd->channel_count = cursor) ) { //if in no more chan delete db
aFree(sd->channels);
aFree(sd->channel_tick);
sd->channels = NULL;
sd->channel_tick = NULL;
}
}
idb_remove(channel->users,sd->status.char_id); //remove user for channel user list
//auto delete when no more user in
if( !db_size(channel->users) && !(flag&1) )
channel_delete(channel,false);
return 0;
}
/**
* Delete a channel
* - Checks if there is any user in channel and make them quit
* @param channel: Channel data
* @param force: Forcefully remove channel
* @return
* 0: Success
* -1: Invalid channel
* -2: Can't delete now
*/
int channel_delete(struct Channel *channel, bool force) {
if(!channel)
return -1;
if(!force && channel->type == CHAN_TYPE_PUBLIC && runflag == MAPSERVER_ST_RUNNING) //only delete those serv stop
return -2;
if( db_size(channel->users)) {
struct map_session_data *sd;
DBIterator *iter = db_iterator(channel->users);
for( sd = (struct map_session_data *)dbi_first(iter); dbi_exists(iter); sd = (struct map_session_data *)dbi_next(iter) ) { //for all users
channel_clean(channel,sd,1); //make all quit
}
dbi_destroy(iter);
}
if (battle_config.etc_log)
ShowInfo("Deleting channel %s alias %s type %d\n",channel->name,channel->alias,channel->type);
db_destroy(channel->users);
db_destroy(channel->banned);
if (channel->groups)
aFree(channel->groups);
channel->groups = NULL;
channel->group_count = 0;
switch(channel->type){
case CHAN_TYPE_MAP:
map_getmapdata(channel->m)->channel = NULL;
aFree(channel);
break;
case CHAN_TYPE_ALLY: {
struct guild *g = guild_search(channel->gid);
if(g) g->channel = NULL;
aFree(channel);
break;
}
default:
strdb_remove(channel_db, channel->name);
break;
}
return 0;
}
/**
* Initializing autotraders from table
*/
void do_init_buyingstore_autotrade( void ) {
if(battle_config.feature_autotrade) {
if (Sql_Query(mmysql_handle,
"SELECT `id`, `account_id`, `char_id`, `sex`, `title`, `limit`, `body_direction`, `head_direction`, `sit` "
"FROM `%s` "
"WHERE `autotrade` = 1 AND `limit` > 0 AND (SELECT COUNT(`buyingstore_id`) FROM `%s` WHERE `buyingstore_id` = `id`) > 0 "
"ORDER BY `id`;",
buyingstores_table, buyingstore_items_table ) != SQL_SUCCESS )
{
Sql_ShowDebug(mmysql_handle);
return;
}
if( Sql_NumRows(mmysql_handle) > 0 ) {
uint16 items = 0;
DBIterator *iter = NULL;
struct s_autotrader *at = NULL;
// Init each autotrader data
while (SQL_SUCCESS == Sql_NextRow(mmysql_handle)) {
size_t len;
char* data;
at = NULL;
CREATE(at, struct s_autotrader, 1);
Sql_GetData(mmysql_handle, 0, &data, NULL); at->id = atoi(data);
Sql_GetData(mmysql_handle, 1, &data, NULL); at->account_id = atoi(data);
Sql_GetData(mmysql_handle, 2, &data, NULL); at->char_id = atoi(data);
Sql_GetData(mmysql_handle, 3, &data, NULL); at->sex = (data[0] == 'F') ? 0 : 1;
Sql_GetData(mmysql_handle, 4, &data, &len); safestrncpy(at->title, data, zmin(len + 1, MESSAGE_SIZE));
Sql_GetData(mmysql_handle, 5, &data, NULL); at->limit = atoi(data);
Sql_GetData(mmysql_handle, 6, &data, NULL); at->dir = atoi(data);
Sql_GetData(mmysql_handle, 7, &data, NULL); at->head_dir = atoi(data);
Sql_GetData(mmysql_handle, 8, &data, NULL); at->sit = atoi(data);
at->count = 0;
if (battle_config.feature_autotrade_direction >= 0)
at->dir = battle_config.feature_autotrade_direction;
if (battle_config.feature_autotrade_head_direction >= 0)
at->head_dir = battle_config.feature_autotrade_head_direction;
if (battle_config.feature_autotrade_sit >= 0)
at->sit = battle_config.feature_autotrade_sit;
// initialize player
CREATE(at->sd, struct map_session_data, 1);
pc_setnewpc(at->sd, at->account_id, at->char_id, 0, gettick(), at->sex, 0);
at->sd->state.autotrade = 1|4;
at->sd->state.monster_ignore = (battle_config.autotrade_monsterignore);
chrif_authreq(at->sd, true);
uidb_put(buyingstore_autotrader_db, at->char_id, at);
}
Sql_FreeResult(mmysql_handle);
// Init items for each autotraders
iter = db_iterator(buyingstore_autotrader_db);
for (at = (struct s_autotrader *)dbi_first(iter); dbi_exists(iter); at = (struct s_autotrader *)dbi_next(iter)) {
uint16 j = 0;
if (SQL_ERROR == Sql_Query(mmysql_handle,
"SELECT `item_id`, `amount`, `price` "
"FROM `%s` "
"WHERE `buyingstore_id` = %d "
"ORDER BY `index` ASC;",
buyingstore_items_table, at->id ) )
{
Sql_ShowDebug(mmysql_handle);
continue;
}
if (!(at->count = (uint16)Sql_NumRows(mmysql_handle))) {
map_quit(at->sd);
buyingstore_autotrader_remove(at, true);
continue;
}
//Init the list
CREATE(at->entries, struct s_autotrade_entry *,at->count);
//Add the item into list
j = 0;
while (SQL_SUCCESS == Sql_NextRow(mmysql_handle) && j < at->count) {
char *data;
CREATE(at->entries[j], struct s_autotrade_entry, 1);
Sql_GetData(mmysql_handle, 0, &data, NULL); at->entries[j]->item_id = atoi(data);
Sql_GetData(mmysql_handle, 1, &data, NULL); at->entries[j]->amount = atoi(data);
Sql_GetData(mmysql_handle, 2, &data, NULL); at->entries[j]->price = atoi(data);
j++;
}
items += j;
Sql_FreeResult(mmysql_handle);
}
dbi_destroy(iter);
ShowStatus("Done loading '"CL_WHITE"%d"CL_RESET"' buyingstore autotraders with '"CL_WHITE"%d"CL_RESET"' items.\n", db_size(buyingstore_autotrader_db), items);
}
}
/**
* Open buyingstore for Autotrader
* @param sd Player as autotrader
*/
void buyingstore_reopen( struct map_session_data* sd ){
struct s_autotrader *at = NULL;
int8 fail = -1;
nullpo_retv(sd);
// Ready to open buyingstore for this char
if ((at = (struct s_autotrader *)uidb_get(buyingstore_autotrader_db, sd->status.char_id)) && at->count && at->entries) {
uint8 *data, *p;
uint16 j, count;
// Init buyingstore data for autotrader
CREATE(data, uint8, at->count * 8);
for (j = 0, p = data, count = at->count; j < at->count; j++) {
struct s_autotrade_entry *entry = at->entries[j];
unsigned short *item_id = (uint16*)(p + 0);
uint16 *amount = (uint16*)(p + 2);
uint32 *price = (uint32*)(p + 4);
*item_id = entry->item_id;
*amount = entry->amount;
*price = entry->price;
p += 8;
}
sd->state.autotrade = 1;
// Make sure abort all NPCs
npc_event_dequeue(sd);
pc_cleareventtimer(sd);
// Open the buyingstore again
if( (fail = buyingstore_setup( sd, (unsigned char)at->count )) == 0 &&
(fail = buyingstore_create( sd, at->limit, 1, at->title, data, at->count, at )) == 0 )
{
// Make buyer look perfect
pc_setdir(sd, at->dir, at->head_dir);
clif_changed_dir(&sd->bl, AREA_WOS);
if( at->sit ) {
pc_setsit(sd);
skill_sit(sd, 1);
clif_sitting(&sd->bl);
}
// Immediate save
chrif_save(sd, CSAVE_AUTOTRADE);
ShowInfo("Buyingstore loaded for '"CL_WHITE"%s"CL_RESET"' with '"CL_WHITE"%d"CL_RESET"' items at "CL_WHITE"%s (%d,%d)"CL_RESET"\n",
sd->status.name, count, mapindex_id2name(sd->mapindex), sd->bl.x, sd->bl.y);
}
aFree(data);
}
if (at) {
buyingstore_autotrader_remove(at, true);
if (db_size(buyingstore_autotrader_db) == 0)
buyingstore_autotrader_db->clear(buyingstore_autotrader_db, buyingstore_autotrader_free);
}
if (fail != 0) {
ShowError("buyingstore_reopen: (Error:%d) Load failed for autotrader '"CL_WHITE"%s"CL_RESET"' (CID=%/AID=%d)\n", fail, sd->status.name, sd->status.char_id, sd->status.account_id);
map_quit(sd);
}
}
/**
* Loads group configuration from config file into memory.
* @private
*/
static void read_config(void) {
config_t pc_group_config;
config_setting_t *groups = NULL;
const char *config_filename = "conf/groups.conf"; // FIXME hardcoded name
int group_count = 0;
if (conf_read_file(&pc_group_config, config_filename))
return;
groups = config_lookup(&pc_group_config, "groups");
if (groups != NULL) {
GroupSettings *group_settings = NULL;
DBIterator *iter = NULL;
int i, loop = 0;
group_count = config_setting_length(groups);
for (i = 0; i < group_count; ++i) {
int id = 0, level = 0;
const char *groupname = NULL;
int log_commands = 0;
config_setting_t *group = config_setting_get_elem(groups, i);
if (!config_setting_lookup_int(group, "id", &id)) {
ShowConfigWarning(group, "pc_groups:read_config: \"groups\" list member #%d has undefined id, removing...", i);
config_setting_remove_elem(groups, i);
--i;
--group_count;
continue;
}
if (pc_group_exists(id)) {
ShowConfigWarning(group, "pc_groups:read_config: duplicate group id %d, removing...", i);
config_setting_remove_elem(groups, i);
--i;
--group_count;
continue;
}
config_setting_lookup_int(group, "level", &level);
config_setting_lookup_bool(group, "log_commands", &log_commands);
if (!config_setting_lookup_string(group, "name", &groupname)) {
char temp[20];
config_setting_t *name = NULL;
snprintf(temp, sizeof(temp), "Group %d", id);
if ((name = config_setting_add(group, "name", CONFIG_TYPE_STRING)) == NULL ||
!config_setting_set_string(name, temp)) {
ShowError("pc_groups:read_config: failed to set missing group name, id=%d, skipping... (%s:%d)\n",
id, config_setting_source_file(group), config_setting_source_line(group));
--i;
--group_count;
continue;
}
config_setting_lookup_string(group, "name", &groupname); // Retrieve the pointer
}
if (name2group(groupname) != NULL) {
ShowConfigWarning(group, "pc_groups:read_config: duplicate group name %s, removing...", groupname);
config_setting_remove_elem(groups, i);
--i;
--group_count;
continue;
}
CREATE(group_settings, GroupSettings, 1);
group_settings->id = id;
group_settings->level = level;
group_settings->name = aStrdup(groupname);
group_settings->log_commands = (bool)log_commands;
group_settings->inherit = config_setting_get_member(group, "inherit");
group_settings->commands = config_setting_get_member(group, "commands");
group_settings->permissions = config_setting_get_member(group, "permissions");
group_settings->inheritance_done = false;
group_settings->root = group;
group_settings->index = i;
strdb_put(pc_groupname_db, groupname, group_settings);
idb_put(pc_group_db, id, group_settings);
}
group_count = config_setting_length(groups); // Save number of groups
assert(group_count == db_size(pc_group_db));
// Check if all commands and permissions exist
iter = db_iterator(pc_group_db);
for (group_settings = dbi_first(iter); dbi_exists(iter); group_settings = dbi_next(iter)) {
config_setting_t *commands = group_settings->commands, *permissions = group_settings->permissions;
int count = 0, i;
// Make sure there is "commands" group
if (commands == NULL)
commands = group_settings->commands = config_setting_add(group_settings->root, "commands", CONFIG_TYPE_GROUP);
count = config_setting_length(commands);
for (i = 0; i < count; ++i) {
config_setting_t *command = config_setting_get_elem(commands, i);
const char *name = config_setting_name(command);
if (!atcommand->exists(name)) {
ShowConfigWarning(command, "pc_groups:read_config: non-existent command name '%s', removing...", name);
config_setting_remove(commands, name);
--i;
--count;
}
}
// Make sure there is "permissions" group
if (permissions == NULL)
permissions = group_settings->permissions = config_setting_add(group_settings->root, "permissions", CONFIG_TYPE_GROUP);
count = config_setting_length(permissions);
for(i = 0; i < count; ++i) {
config_setting_t *permission = config_setting_get_elem(permissions, i);
const char *name = config_setting_name(permission);
int j;
ARR_FIND(0, ARRAYLENGTH(pc_g_permission_name), j, strcmp(pc_g_permission_name[j].name, name) == 0);
if (j == ARRAYLENGTH(pc_g_permission_name)) {
ShowConfigWarning(permission, "pc_groups:read_config: non-existent permission name '%s', removing...", name);
config_setting_remove(permissions, name);
--i;
--count;
}
}
}
dbi_destroy(iter);
// Apply inheritance
i = 0; // counter for processed groups
while (i < group_count) {
iter = db_iterator(pc_group_db);
for (group_settings = dbi_first(iter); dbi_exists(iter); group_settings = dbi_next(iter)) {
config_setting_t *inherit = NULL,
*commands = group_settings->commands,
*permissions = group_settings->permissions;
int j, inherit_count = 0, done = 0;
if (group_settings->inheritance_done) // group already processed
continue;
if ((inherit = group_settings->inherit) == NULL ||
(inherit_count = config_setting_length(inherit)) <= 0) { // this group does not inherit from others
++i;
group_settings->inheritance_done = true;
continue;
}
for (j = 0; j < inherit_count; ++j) {
GroupSettings *inherited_group = NULL;
const char *groupname = config_setting_get_string_elem(inherit, j);
if (groupname == NULL) {
ShowConfigWarning(inherit, "pc_groups:read_config: \"inherit\" array member #%d is not a name, removing...", j);
config_setting_remove_elem(inherit,j);
continue;
}
if ((inherited_group = name2group(groupname)) == NULL) {
ShowConfigWarning(inherit, "pc_groups:read_config: non-existent group name \"%s\", removing...", groupname);
config_setting_remove_elem(inherit,j);
continue;
}
if (!inherited_group->inheritance_done)
continue; // we need to do that group first
// Copy settings (commands/permissions) that are not defined yet
if (inherited_group->commands != NULL) {
int i = 0, commands_count = config_setting_length(inherited_group->commands);
for (i = 0; i < commands_count; ++i)
config_setting_copy(commands, config_setting_get_elem(inherited_group->commands, i));
}
if (inherited_group->permissions != NULL) {
int i = 0, permissions_count = config_setting_length(inherited_group->permissions);
for (i = 0; i < permissions_count; ++i)
config_setting_copy(permissions, config_setting_get_elem(inherited_group->permissions, i));
}
++done; // copied commands and permissions from one of inherited groups
}
if (done == inherit_count) { // copied commands from all of inherited groups
++i;
group_settings->inheritance_done = true; // we're done with this group
}
}
dbi_destroy(iter);
if (++loop > group_count) {
ShowWarning("pc_groups:read_config: Could not process inheritance rules, check your config '%s' for cycles...\n",
config_filename);
break;
}
} // while(i < group_count)
// Pack permissions into GroupSettings.e_permissions for faster checking
iter = db_iterator(pc_group_db);
for (group_settings = dbi_first(iter); dbi_exists(iter); group_settings = dbi_next(iter)) {
config_setting_t *permissions = group_settings->permissions;
int i, count = config_setting_length(permissions);
for (i = 0; i < count; ++i) {
config_setting_t *perm = config_setting_get_elem(permissions, i);
const char *name = config_setting_name(perm);
int val = config_setting_get_bool(perm);
int j;
if (val == 0) // does not have this permission
continue;
ARR_FIND(0, ARRAYLENGTH(pc_g_permission_name), j, strcmp(pc_g_permission_name[j].name, name) == 0);
group_settings->e_permissions |= pc_g_permission_name[j].permission;
}
}
dbi_destroy(iter);
// Atcommand permissions are processed by atcommand module.
// Fetch all groups and relevant config setting and send them
// to atcommand->load_group() for processing.
if (group_count > 0) {
int i = 0;
GroupSettings **groups = NULL;
config_setting_t **commands = NULL;
CREATE(groups, GroupSettings*, group_count);
CREATE(commands, config_setting_t*, group_count);
iter = db_iterator(pc_group_db);
for (group_settings = dbi_first(iter); dbi_exists(iter); group_settings = dbi_next(iter)) {
groups[i] = group_settings;
commands[i] = group_settings->commands;
i++;
}
atcommand->load_groups(groups, commands, group_count);
dbi_destroy(iter);
aFree(groups);
aFree(commands);
}
}
ShowStatus("Done reading '"CL_WHITE"%d"CL_RESET"' groups in '"CL_WHITE"%s"CL_RESET"'.\n", group_count, config_filename);
// All data is loaded now, discard config
config_destroy(&pc_group_config);
}
/**
* Open vending for Autotrader
* @param sd Player as autotrader
*/
void vending_reopen( struct map_session_data* sd )
{
struct s_autotrader *at = NULL;
int8 fail = -1;
nullpo_retv(sd);
// Open vending for this autotrader
if ((at = uidb_get(vending_autotrader_db, sd->status.char_id)) && at->count && at->entries) {
uint8 *data, *p;
uint16 j, count;
// Init vending data for autotrader
CREATE(data, uint8, at->count * 8);
for (j = 0, p = data, count = at->count; j < at->count; j++) {
struct s_autotrade_entry *entry = at->entries[j];
uint16 *index = (uint16*)(p + 0);
uint16 *amount = (uint16*)(p + 2);
uint32 *value = (uint32*)(p + 4);
// Find item position in cart
ARR_FIND(0, MAX_CART, entry->index, sd->status.cart[entry->index].id == entry->cartinventory_id);
if (entry->index == MAX_CART) {
count--;
continue;
}
*index = entry->index + 2;
*amount = itemdb_isstackable(sd->status.cart[entry->index].nameid) ? entry->amount : 1;
*value = entry->price;
p += 8;
}
sd->state.prevend = 1; // Set him into a hacked prevend state
sd->state.autotrade = 1;
// Make sure abort all NPCs
npc_event_dequeue(sd);
pc_cleareventtimer(sd);
// Open the vending again
if( (fail = vending_openvending(sd, at->title, data, count, at)) == 0 ) {
// Make vendor look perfect
pc_setdir(sd, at->dir, at->head_dir);
clif_changed_dir(&sd->bl, AREA_WOS);
if( at->sit ) {
pc_setsit(sd);
skill_sit(sd, 1);
clif_sitting(&sd->bl);
}
// Immediate save
chrif_save(sd, 3);
ShowInfo("Vending loaded for '"CL_WHITE"%s"CL_RESET"' with '"CL_WHITE"%d"CL_RESET"' items at "CL_WHITE"%s (%d,%d)"CL_RESET"\n",
sd->status.name, count, mapindex_id2name(sd->mapindex), sd->bl.x, sd->bl.y);
}
aFree(data);
}
if (at) {
vending_autotrader_remove(at, true);
if (db_size(vending_autotrader_db) == 0)
vending_autotrader_db->clear(vending_autotrader_db, vending_autotrader_free);
}
if (fail != 0) {
ShowError("vending_reopen: (Error:%d) Load failed for autotrader '"CL_WHITE"%s"CL_RESET"' (CID=%/AID=%d)\n", fail, sd->status.name, sd->status.char_id, sd->status.account_id);
map_quit(sd);
}
}
/**
* A player is attempting to modify the banlist
* @param sd: Player data
* @param chname: Channel name
* @param pname: Player to ban or unban
* @param flag: Ban options (0 - Ban, 1 - Unban, 2 - Unban all, 3 - Ban list)
* @return 0 on success or -1 on failure
*/
int channel_pcban(struct map_session_data *sd, char *chname, char *pname, int flag){
struct Channel *channel;
char output[CHAT_SIZE_MAX];
struct map_session_data *tsd = map_nick2sd(pname,false);
if( channel_chk(chname,NULL,1) ) {
clif_displaymessage(sd->fd, msg_txt(sd,1405));// Channel name must start with '#'.
return -1;
}
channel = channel_name2channel(chname,sd,0);
if( !channel ) {
sprintf(output, msg_txt(sd,1407), chname);// Channel '%s' is not available.
clif_displaymessage(sd->fd, output);
return -1;
}
if( !pc_has_permission(sd, PC_PERM_CHANNEL_ADMIN) ) {
if (channel->char_id != sd->status.char_id) {
sprintf(output, msg_txt(sd,1412), chname);// You're not the owner of channel '%s'.
clif_displaymessage(sd->fd, output);
return -1;
} else if (!channel_config.private_channel.ban) {
sprintf(output, msg_txt(sd,765), chname); // You're not allowed to ban a player.
clif_displaymessage(sd->fd, output);
return -1;
}
}
if(flag != 2 && flag != 3){
char banned;
if(!tsd || pc_has_permission(tsd, PC_PERM_CHANNEL_ADMIN) ) {
sprintf(output, msg_txt(sd,1464), pname);// Ban failed for player '%s'.
clif_displaymessage(sd->fd, output);
return -1;
}
banned = channel_haspcbanned(channel,tsd);
if(!flag && banned==1) {
sprintf(output, msg_txt(sd,1465), tsd->status.name);// Player '%s' is already banned from this channel.
clif_displaymessage(sd->fd, output);
return -1;
}
else if(flag==1 && banned==0) {
sprintf(output, msg_txt(sd,1440), tsd->status.name);// Player '%s' is not banned from this channel.
clif_displaymessage(sd->fd, output);
return -1;
}
}
else {
if( !db_size(channel->banned) ) {
sprintf(output, msg_txt(sd,1439), chname);// Channel '%s' contains no banned players.
clif_displaymessage(sd->fd, output);
return 0;
}
}
//let properly alter the list now
switch(flag){
case 0: {
struct chan_banentry *cbe;
if (!tsd)
return -1;
CREATE(cbe, struct chan_banentry, 1);
cbe->char_id = tsd->status.char_id;
strcpy(cbe->char_name,tsd->status.name);
idb_put(channel->banned, tsd->status.char_id, cbe);
channel_clean(channel,tsd,0);
sprintf(output, msg_txt(sd,1437),tsd->status.name,chname); // Player '%s' is banned from the '%s' channel.
break;
}
case 1:
if (!tsd)
return -1;
idb_remove(channel->banned, tsd->status.char_id);
sprintf(output, msg_txt(sd,1441),tsd->status.name,chname); // Player '%s' is unbanned from the '%s' channel.
break;
case 2:
db_clear(channel->banned);
sprintf(output, msg_txt(sd,1442),chname); // Cleared all bans from the '%s' channel.
break;
case 3: {
DBIterator *iter = db_iterator(channel->banned);
struct chan_banentry *cbe;
sprintf(output, msg_txt(sd,1443), channel->name);// ---- '#%s' Ban List:
clif_displaymessage(sd->fd, output);
for( cbe = (struct chan_banentry *)dbi_first(iter); dbi_exists(iter); cbe = (struct chan_banentry *)dbi_next(iter) ) { //for all users
if (cbe->char_name[0])
sprintf(output, "%d: %s",cbe->char_id,cbe->char_name);
else
sprintf(output, "%d: ****",cbe->char_id);
clif_displaymessage(sd->fd, output);
}
dbi_destroy(iter);
}
return 0;
}
clif_displaymessage(sd->fd, output);
return 0;
}
/**
* Display some information to users in channel
* @param sd: Player data
* @param options:
* colors: Display available colors for channel system
* mine: List of players in channel and number of users
* void: List of public channel and map and guild and number of users
* @return 0 on success or -1 on failure
*/
int channel_display_list(struct map_session_data *sd, const char *options){
if(!sd || !options)
return -1;
//display availaible colors
if( options[0] != '\0' && strcmpi(options,"colors") == 0 ) {
char msg[40];
unsigned char k;
clif_displaymessage(sd->fd, msg_txt(sd,1444)); // ---- Available Colors ----
for( k = 0; k < channel_config.colors_count; k++ ) {
if (channel_config.colors[k]) {
sprintf(msg, msg_txt(sd,1445),channel_config.colors_name[k]);// - '%s'
clif_messagecolor(&sd->bl,channel_config.colors[k],msg,false,SELF);
}
}
}
else if( options[0] != '\0' && strcmpi(options,"mine") == 0 ) { //display chan I'm into
clif_displaymessage(sd->fd, msg_txt(sd,1475)); // ---- My Channels ----
if(!sd->channel_count)
clif_displaymessage(sd->fd, msg_txt(sd,1476)); // You have not joined any channels.
else {
unsigned char k;
for(k = 0; k < sd->channel_count; k++) {
char output[CHAT_SIZE_MAX];
struct Channel *channel;
if (!(channel = sd->channels[k]))
continue;
sprintf(output, msg_txt(sd,1409), channel->name, db_size(channel->users));// - #%s (%d users)
clif_displaymessage(sd->fd, output);
}
}
}
else { //display public chanels
DBIterator *iter;
bool has_perm = pc_has_permission(sd, PC_PERM_CHANNEL_ADMIN) ? true : false;
struct Channel *channel;
char output[CHAT_SIZE_MAX];
struct map_data *mapdata = map_getmapdata(sd->bl.m);
clif_displaymessage(sd->fd, msg_txt(sd,1410)); // ---- Public Channels ----
if( channel_config.map_tmpl.name[0] && mapdata->channel ) {
sprintf(output, msg_txt(sd,1409), mapdata->channel->name, db_size(mapdata->channel->users));// - #%s (%d users)
clif_displaymessage(sd->fd, output);
}
if( channel_config.ally_tmpl.name[0] && sd->status.guild_id ) {
struct guild *g = sd->guild;
if (g && g->channel) {
sprintf(output, msg_txt(sd,1409), g->channel->name, db_size(((struct Channel *)g->channel)->users));// - #%s (%d users)
clif_displaymessage(sd->fd, output);
}
}
iter = db_iterator(channel_db);
for(channel = (struct Channel *)dbi_first(iter); dbi_exists(iter); channel = (struct Channel *)dbi_next(iter)) {
if (!has_perm && !channel_pccheckgroup(channel, sd->group_id))
continue;
if( has_perm || channel->type == CHAN_TYPE_PUBLIC ) {
sprintf(output, msg_txt(sd,1409), channel->name, db_size(channel->users));// - #%s (%d users)
clif_displaymessage(sd->fd, output);
}
}
dbi_destroy(iter);
}
return 0;
}
/*==========================================
* アイテムデータベースの読み込み
*------------------------------------------*/
static int itemdb_readdb(void)
{
const char* filename[] = {
DBPATH"item_db.txt",
"item_db2.txt" };
int fi;
DBMap* item_combo_db = idb_alloc(DB_OPT_RELEASE_DATA);
itemdb_read_combos(item_combo_db);
for( fi = 0; fi < ARRAYLENGTH(filename); ++fi ) {
uint32 lines = 0, count = 0;
char line[1024];
char path[256];
FILE* fp;
sprintf(path, "%s/%s", db_path, filename[fi]);
fp = fopen(path, "r");
if( fp == NULL ) {
ShowWarning("itemdb_readdb: File not found \"%s\", skipping.\n", path);
continue;
}
// process rows one by one
while(fgets(line, sizeof(line), fp))
{
char *str[32], *p;
int i;
struct item_combo *ic = NULL;
char *script2 = NULL;
lines++;
if(line[0] == '/' && line[1] == '/')
continue;
memset(str, 0, sizeof(str));
p = line;
while( ISSPACE(*p) )
++p;
if( *p == '\0' )
continue;// empty line
for( i = 0; i < 19; ++i )
{
str[i] = p;
p = strchr(p,',');
if( p == NULL )
break;// comma not found
*p = '\0';
++p;
}
if( p == NULL )
{
ShowError("itemdb_readdb: Insufficient columns in line %d of \"%s\" (item with id %d), skipping.\n", lines, path, atoi(str[0]));
continue;
}
// Script
if( *p != '{' )
{
ShowError("itemdb_readdb: Invalid format (Script column) in line %d of \"%s\" (item with id %d), skipping.\n", lines, path, atoi(str[0]));
continue;
}
str[19] = p;
p = strstr(p+1,"},");
if( p == NULL )
{
ShowError("itemdb_readdb: Invalid format (Script column) in line %d of \"%s\" (item with id %d), skipping.\n", lines, path, atoi(str[0]));
continue;
}
p[1] = '\0';
p += 2;
// OnEquip_Script
if( *p != '{' )
{
ShowError("itemdb_readdb: Invalid format (OnEquip_Script column) in line %d of \"%s\" (item with id %d), skipping.\n", lines, path, atoi(str[0]));
continue;
}
str[20] = p;
p = strstr(p+1,"},");
if( p == NULL )
{
ShowError("itemdb_readdb: Invalid format (OnEquip_Script column) in line %d of \"%s\" (item with id %d), skipping.\n", lines, path, atoi(str[0]));
continue;
}
p[1] = '\0';
p += 2;
// OnUnequip_Script (last column)
if( *p != '{' )
{
ShowError("itemdb_readdb: Invalid format (OnUnequip_Script column) in line %d of \"%s\" (item with id %d), skipping.\n", lines, path, atoi(str[0]));
continue;
}
str[21] = p;
p = strstr(p+1,"}");
if ( strchr(p,',') != NULL )
{
ShowError("itemdb_readdb: Extra columns in line %d of \"%s\" (item with id %d), skipping.\n", lines, path, atoi(str[0]));
continue;
}
if ((ic = idb_get(item_combo_db, atoi(str[0])))) {
script2 = ic->script;
}
if (!itemdb_parse_dbrow(str, path, lines, 0, script2))
continue;
if( script2 != NULL )
idb_remove(item_combo_db,atoi(str[0]));
count++;
}
fclose(fp);
ShowStatus("Done reading '"CL_WHITE"%lu"CL_RESET"' entries in '"CL_WHITE"%s"CL_RESET"'.\n", count, filename[fi]);
}
if( db_size(item_combo_db) ) {
DBIterator * iter = db_iterator(item_combo_db);
struct item_combo * ic = NULL;
int icount = 1;
/* non-processed entries */
ShowWarning("item_combo_db: There are %d unused entries in the file (combo(s) with non-available item IDs)\n",db_size(item_combo_db));
for( ic = dbi_first(iter); dbi_exists(iter); ic = dbi_next(iter) ) {
ShowWarning("item_combo_db(%d): (ID:%d) \"%s\" combo unused\n",icount++,ic->nameid,ic->script);
}
dbi_destroy(iter);
}
db_destroy(item_combo_db);
return 0;
}
