atcommand.c

传奇3源程序, 用vc开发的

			char output[200];
					pc_setpos(pl_sd, sd->mapname, sd->bl.x, sd->bl.y, 2);
			snprintf(output, sizeof output, msg_table[46], character);
			clif_displaymessage(fd, output);
				}
	} else {
		clif_displaymessage(fd, msg_table[47]);
					}
	
	return 0;
}

int
atcommand_character_job(
	const int fd, struct map_session_data* sd,
	const char* command, const char* message)
{
	char character[100];
	struct map_session_data* pl_sd = NULL;
	int job = 0;
	
	if (!message || !*message)
		return -1;
	
	memset(character, '\0', sizeof character);
	if (sscanf(message, "%d %99[^\n]", &job, character) < 2)
		return -1;
	if ((pl_sd = map_nick2sd(character)) != NULL) {
		if (pc_isGM(sd) > pc_isGM(pl_sd)) {
			if ((job >= 0 && job < MAX_PC_CLASS)) {
				pc_jobchange(pl_sd, job);
				clif_displaymessage(fd, msg_table[48]);
			} else {
				clif_displaymessage(fd, msg_table[49]);
				}
			}
	} else {
		clif_displaymessage(fd, msg_table[50]);
		}
	
	return 0;
}

int
atcommand_revive(
	const int fd, struct map_session_data* sd,
	const char* command, const char* message)
{
	char character[100];
	struct map_session_data *pl_sd = NULL;
	
	if (!message || !*message)
		return -1;
	memset(character, '\0', sizeof character);
	sscanf(message, "%99[^\n]", character);
	if ((pl_sd = map_nick2sd(character)) != NULL) {
		pl_sd->status.hp = pl_sd->status.max_hp;
				pc_setstand(pl_sd);
		if (battle_config.pc_invincible_time > 0)
			pc_setinvincibletimer(sd, battle_config.pc_invincible_time);
		clif_updatestatus(pl_sd, SP_HP);
		clif_resurrection(&pl_sd->bl, 1);
		clif_displaymessage(fd, msg_table[51]);
	} else {
		clif_displaymessage(fd, msg_table[52]);
			}
	
	return 0;
}

int
atcommand_character_stats(
	const int fd, struct map_session_data* sd,
	const char* command, const char* message)
{
	char character[100];
	struct map_session_data *pl_sd = NULL;
	
	if (!message || !*message)
		return -1;
	memset(character, '\0', sizeof character);
	sscanf(message, "%99[^\n]", character);
	if ((pl_sd = map_nick2sd(character)) != NULL) {
		char output[200];
		int i = 0;
		struct {
			const char* format;
			int value;
		} output_table[] = {
			{ "Base Level - %d", pl_sd->status.base_level },
			{ "Job Level - %d", pl_sd->status.job_level },
			{ "Hp - %d", pl_sd->status.hp },
			{ "MaxHp - %d", pl_sd->status.max_hp },
			{ "Sp - %d", pl_sd->status.sp },
			{ "MaxSp - %d", pl_sd->status.max_sp },
			{ "Str - %d", pl_sd->status.str },
			{ "Agi - %d", pl_sd->status.agi },
			{ "Vit - %d", pl_sd->status.vit },
			{ "Int - %d", pl_sd->status.int_ },
			{ "Dex - %d", pl_sd->status.dex },
			{ "Luk - %d", pl_sd->status.luk },
			{ "Zeny - %d", pl_sd->status.zeny },
			{ NULL, 0 }
		};
		snprintf(output, sizeof output, msg_table[53], pl_sd->status.name);
		clif_displaymessage(fd, output);
		for (i = 0; output_table[i].format != NULL; i++) {
			snprintf(output, sizeof output,
				output_table[i].format, output_table[i].value);
			clif_displaymessage(fd, output);
		}
	} else {
				clif_displaymessage(fd,msg_table[54]);
			}
	
	return 0;
}

int
atcommand_character_option(
	const int fd, struct map_session_data* sd,
	const char* command, const char* message)
{
	char character[100];
	int opt1 = 0, opt2 = 0, opt3 = 0;
	struct map_session_data* pl_sd = NULL;
	
	if (!message || !*message)
		return -1;
	memset(character, '\0', sizeof character);
	if (sscanf(message, "%d %d %d %99[^\n]",
			&opt1, &opt2, &opt3, character) < 4)
		return -1;
	if ((pl_sd = map_nick2sd(character)) != NULL) {
		if (pc_isGM(sd) > pc_isGM(pl_sd)) {
			pl_sd->opt1 = opt1;
			pl_sd->opt2 = opt2;
			pl_sd->status.option = opt3;
					clif_changeoption(&pl_sd->bl);
			clif_displaymessage(fd, msg_table[55]);
			}
	} else {
		clif_displaymessage(fd, msg_table[56]);
				}
	
	return 0;
}

int
atcommand_character_save(
	const int fd, struct map_session_data* sd,
	const char* command, const char* message)
{
	char map_name[100];
	char character[100];
	struct map_session_data* pl_sd = NULL;
	int x = 0, y = 0;
	
	if (!message || !*message)
		return -1;
	memset(character, '\0', sizeof character);
	if (sscanf(message, "%99s %d %d %99[^\n]", map_name, &x, &y, character) < 4)
		return -1;
	if ((pl_sd = map_nick2sd(character)) != NULL) {
		if (pc_isGM(sd) > pc_isGM(pl_sd)) {
			pc_setsavepoint(pl_sd, map_name, x, y);
			clif_displaymessage(fd, msg_table[57]);
			}
	} else {
		clif_displaymessage(fd, msg_table[58]);
		}
	
	return 0;
}

int
atcommand_night(
	const int fd, struct map_session_data* sd,
	const char* command, const char* message)
{
	struct map_session_data *pl_sd = NULL;
	int i = 0;
	for(i = 0; i < fd_max; i++) {
		if (session[i] && (pl_sd = session[i]->session_data) &&
			pl_sd->state.auth) {
			pl_sd->opt2 |= STATE_BLIND;
					clif_changeoption(&pl_sd->bl);
			clif_displaymessage(pl_sd->fd, msg_table[59]);
			}
		}
	
	return 0;
}

int
atcommand_day(
	const int fd, struct map_session_data* sd,
	const char* command, const char* message)
{
	struct map_session_data *pl_sd = NULL;
	int i = 0;
	for(i = 0; i < fd_max; i++) {
		if (session[i] && (pl_sd = session[i]->session_data) &&
			pl_sd->state.auth) {
			pl_sd->opt2 &= ~STATE_BLIND;
					clif_changeoption(&pl_sd->bl);
			clif_displaymessage(pl_sd->fd, msg_table[60]);
				}
			}
	
	return 0;
}

int
atcommand_doom(
	const int fd, struct map_session_data* sd,
	const char* command, const char* message)
{
	struct map_session_data *pl_sd = NULL;
	int i = 0;
	for(i = 0; i < fd_max; i++) {
		if (session[i] && (pl_sd = session[i]->session_data) &&
			pl_sd->state.auth) {
			pl_sd = session[i]->session_data;
			if (pc_isGM(sd) > pc_isGM(pl_sd)) {
				pc_damage(NULL, pl_sd, pl_sd->status.hp + 1);
				clif_displaymessage(pl_sd->fd, msg_table[61]);
		}
			}
		}
	
	return 0;
}

int
atcommand_doommap(
	const int fd, struct map_session_data* sd,
	const char* command, const char* message)
{
	struct map_session_data *pl_sd = NULL;
	int i = 0;
	for (i = 0; i < fd_max; i++) {
		if (session[i] && (pl_sd = session[i]->session_data) &&
			pl_sd->state.auth && sd->bl.m == pl_sd->bl.m &&
			pc_isGM(sd) > pc_isGM(pl_sd)) {
					pc_damage(NULL, pl_sd, pl_sd->status.hp + 1);
					clif_displaymessage(pl_sd->fd, msg_table[61]);
	}
				}
	clif_displaymessage(fd, msg_table[62]);
	
	return 0;
}

static void
atcommand_raise_sub(struct map_session_data* sd)
{
	if (sd && sd->state.auth && pc_isdead(sd)) {
		sd->status.hp = sd->status.max_hp;
		sd->status.sp = sd->status.max_sp;
		pc_setstand(sd);
		clif_updatestatus(sd, SP_HP);
		clif_resurrection(&sd->bl, 1);
		clif_displaymessage(sd->fd, msg_table[63]);
			}
}

int
atcommand_raise(
	const int fd, struct map_session_data* sd,
	const char* command, const char* message)
{
	int i = 0;
	for (i = 0; i < fd_max; i++) {
		if (session[i])
			atcommand_raise_sub(session[i]->session_data);
		}
	clif_displaymessage(fd, msg_table[64]);
	
	return 0;
}

int
atcommand_raisemap(
	const int fd, struct map_session_data* sd,
	const char* command, const char* message)
{
	struct map_session_data *pl_sd = NULL;
	int i = 0;
	for (i = 0; i < fd_max; i++) {
		if (session[i] && (pl_sd = session[i]->session_data) &&
			pl_sd->state.auth && pc_isdead(pl_sd) && sd->bl.m == pl_sd->bl.m)
				atcommand_raise_sub(pl_sd);
	}
	clif_displaymessage(fd, msg_table[64]);
	
	return 0;
}

int
atcommand_character_baselevel(
	const int fd, struct map_session_data* sd,
	const char* command, const char* message)
{
	struct map_session_data *pl_sd = NULL;
	char character[100];
	int level = 0, i = 0;
	
	if (!message || !*message)
		return -1;
	memset(character, '\0', sizeof character);
	if (sscanf(message, "%d %99[^\n]", &level, character) < 2)
		return -1;
	if ((pl_sd = map_nick2sd(character)) != NULL) {
		if (pc_isGM(sd) > pc_isGM(pl_sd)) {
			if (level >= 1) {
				for (i = 1; i <= level; i++) {
					if (pl_sd->status.base_level + i >= 99)
								pl_sd->status.status_point += 22;
							else
						pl_sd->status.status_point += (i + 14) / 5 ;
					}
				pl_sd->status.base_level += level;
				clif_updatestatus(pl_sd, SP_BASELEVEL);
				clif_updatestatus(pl_sd, SP_NEXTBASEEXP);
				clif_updatestatus(pl_sd, SP_STATUSPOINT);
				pc_calcstatus(pl_sd, 0);
				pc_heal(pl_sd, pl_sd->status.max_hp, pl_sd->status.max_sp);
				clif_misceffect(&pl_sd->bl, 0);
				clif_displaymessage(fd, msg_table[65]);
			} else if (level < 0 && pl_sd->status.base_level + level > 0) {
				pl_sd->status.base_level += level;
				clif_updatestatus(pl_sd, SP_BASELEVEL);
				clif_updatestatus(pl_sd, SP_NEXTBASEEXP);
				pc_calcstatus(pl_sd, 0);
				clif_displaymessage(fd, msg_table[66]);
				}
			}
					}
	return 0;
}

int
atcommand_character_joblevel(
	const int fd, struct map_session_data* sd,
	const char* command, const char* message)
{
	struct map_session_data *pl_sd = NULL;
	char character[100];
	int max_level = 50, level = 0;
	
	if (!message || !*message)
		return -1;
	memset(character, '\0', sizeof character);
	if (sscanf(message, "%d %99[^\n]", &level, character) < 2)
		return -1;
	if ((pl_sd = map_nick2sd(character)) != NULL) {
		if (pc_isGM(sd) > pc_isGM(pl_sd)) {
			if (pl_sd->status.class == 0)
				max_level -= 40;
			if (pl_sd->status.job_level == max_level) {
				clif_displaymessage(fd, msg_table[67]);
			} else if (level >= 1) {
				if (pl_sd->status.job_level + level > max_level)
					level = max_level - pl_sd->status.job_level;
				pl_sd->status.job_level += level;
				clif_updatestatus(pl_sd, SP_JOBLEVEL);
				clif_updatestatus(pl_sd, SP_NEXTJOBEXP);
				pl_sd->status.skill_point += level;
				clif_updatestatus(pl_sd, SP_SKILLPOINT);
				pc_calcstatus(pl_sd, 0);
				clif_misceffect(&pl_sd->bl, 1);
				clif_displaymessage(fd, msg_table[68]);
			} else if (level < 0 && sd->status.job_level + max_level > 0) {
				pl_sd->status.job_level += level;
				clif_updatestatus(pl_sd, SP_JOBLEVEL);
				clif_updatestatus(pl_sd, SP_NEXTJOBEXP);
				pc_calcstatus(pl_sd, 0);
				clif_displaymessage(fd, msg_table[69]);
				}
			}
		}

	return 0;
}

int
atcommand_kick(
	const int fd, struct map_session_data* sd,
	const char* command, const char* message)
{
	struct map_session_data *pl_sd = NULL;
	char character[100];
	
	if (!message || !*message)
		return -1;
	memset(character, '\0', sizeof character);
	if (sscanf(message, "%99[^\n]", character) < 1)
		return -1;
	if ((pl_sd = map_nick2sd(character)) == NULL)
		return -1;
	if (pc_isGM(sd) > pc_isGM(pl_sd))
		clif_GM_kick(sd, pl_sd, 1);
			else
		clif_GM_kickack(sd, 0);
	return 0;
}

int
atcommand_kickall(
	const int fd, struct map_session_data* sd,
	const char* command, const char* message)
{
	struct map_session_data *pl_sd = NULL;
	int i = 0;
	for (i = 0; i < fd_max; i++) {
		if (session[i] &&
			(pl_sd = session[i]->session_data) && pl_sd->state.auth) {
			if (sd->status.account_id != pl_sd->status.account_id)
				clif_GM_kick(sd, pl_sd, 0);
			}
		}
	clif_GM_kick(sd, sd, 0);
	
	return 0;
}

int
atcommand_allskill(
	const int fd, struct map_session_data* sd,
	const char* command, const char* message)
{
			pc_allskillup(sd);
	clif_displaymessage(fd, msg_table[76]);
	return 0;
}

int
atcommand_questskill(
	const int fd, struct map_session_data* sd,
	const char* command, const char* message)
{
	int skill_id = 0;
	if (!message || !*message)
		return -1;
	skill_id = atoi(message);
	if (skill_get_inf2(skill_id) & 0x01) {
		pc_skill(sd, skill_id, 1, 0);
		clif_displaymessage(fd, msg_table[70]);
		}
	return 0;
}

int
atcommand_lostskill(
	const int fd, struct map_session_data* sd,
	const char* command, const char* message)
{
	int skill_id = 0;
	if (!message || !*message)
		return -1;
	skill_id = atoi(message);
	if (skill_id > 0 && skill_id < MAX_SKILL &&
		pc_checkskill(sd, skill_id) == 0)
		return -1;
	sd->status.skill[skill_id].lv = 0;
	sd->status.skill[skill_id].flag = 0;
				clif_skillinfoblock(sd);
	clif_displaymessage(fd, msg_table[71]);

	return 0;
}

int
atcommand_spiritball(
	const int fd, struct map_session_data* sd,
	const char* command, const char* message)
{
	int number = 0;

	if (!message || !*message)
		return -1;
	number = atoi(message);
	if (number >= 0 && number <= 0x7FFF) {
		if (sd->spiritball > 0)
			pc_delspiritball(sd, sd->spiritball, 1);
		sd->spiritball = number;
		clif_spiritball(sd);
	}

	return 0;
}

int
atcommand_party(
	const int fd, struct map_session_data* sd,
	const char* command, const char* message)
{
	char party[100];
	if (!message || !*message)
		return -1;
	if (sscanf(message, "%99[^\n]", party))
		party_create(sd, party);
	return 0;
}

int
atcommand_guild(
	const int fd, struct map_session_data* sd,
	const char* command, const char* message)
{
	char guild[100];
	int prev = 0;
	if (!message || !*message)
		return -1;
	if (sscanf(message, "%99[^\n]", guild) == 0)
		return -1;

	prev = battle_config.guild_emperium_check;
	battle_config.guild_emperium_check = 0;
	guild_create(sd, guild);
	battle_config.guild_emperium_check = prev;
	return 0;
}
	
int
atcommand_agitstart(
	const int fd, struct map_session_data* sd,
	const char* command, const char* message)
{
	if (agit_flag == 1) {
		clif_displaymessage(fd, msg_table[73]);
			return 1;
		}
	agit_flag = 1;
	guild_agit_start();
	clif_displaymessage(fd, msg_table[72]);
	return 0;
}

int
atcommand_agitend(
	const int fd, struct map_session_data* sd,
	const char* command, const char* message)
{
	if (agit_flag == 0) {
		clif_displaymessage(fd, msg_table[75]);
		return 1;
	}
	agit_flag = 0;
	guild_agit_end();
	clif_displaymessage(fd, msg_table[74]);
	return 0;
}