From 78d0348440ea4856e44044fff370b8bd4dfe90db Mon Sep 17 00:00:00 2001 From: ultramage Date: Tue, 26 Aug 2008 05:11:58 +0000 Subject: Added mercenary code (it should have been done this way in r13122). Removed 2 unused variables in homunculus code. git-svn-id: https://rathena.svn.sourceforge.net/svnroot/rathena/trunk@13137 54d463be-8e91-2dee-dedb-b68131a5f0ec --- src/map/homunculus.c | 1 - src/map/mercenary.c | 383 +++++++++++++++++++++++++++++++++++++++++++++++++++ src/map/mercenary.h | 48 +++++++ 3 files changed, 431 insertions(+), 1 deletion(-) create mode 100644 src/map/mercenary.c create mode 100644 src/map/mercenary.h (limited to 'src') diff --git a/src/map/homunculus.c b/src/map/homunculus.c index 02177552e..6acd969fa 100644 --- a/src/map/homunculus.c +++ b/src/map/homunculus.c @@ -594,7 +594,6 @@ int merc_hom_alloc(struct map_session_data *sd, struct s_homunculus *hom) { struct homun_data *hd; int i = 0; - short x,y; nullpo_retr(1, sd); diff --git a/src/map/mercenary.c b/src/map/mercenary.c new file mode 100644 index 000000000..dc49f5e21 --- /dev/null +++ b/src/map/mercenary.c @@ -0,0 +1,383 @@ +// Copyright (c) Athena Dev Teams - Licensed under GNU GPL +// For more information, see LICENCE in the main folder + +#include "../common/cbasetypes.h" +#include "../common/malloc.h" +#include "../common/socket.h" +#include "../common/timer.h" +#include "../common/nullpo.h" +#include "../common/mmo.h" +#include "../common/showmsg.h" +#include "../common/utils.h" + +#include "log.h" +#include "clif.h" +#include "chrif.h" +#include "intif.h" +#include "itemdb.h" +#include "map.h" +#include "pc.h" +#include "status.h" +#include "skill.h" +#include "mob.h" +#include "pet.h" +#include "battle.h" +#include "party.h" +#include "guild.h" +#include "atcommand.h" +#include "script.h" +#include "npc.h" +#include "trade.h" +#include "unit.h" +#include "mercenary.h" + +#include +#include +#include +#include + +struct s_mercenary_db mercenary_db[MAX_MERCENARY_CLASS]; // Mercenary Database + +int merc_search_index(int class_) +{ + int i; + ARR_FIND(0, MAX_MERCENARY_CLASS, i, mercenary_db[i].class_ == class_); + return (i == MAX_MERCENARY_CLASS)?-1:i; +} + +bool merc_class(int class_) +{ + return (bool)(merc_search_index(class_) > -1); +} + +struct view_data * merc_get_viewdata(int class_) +{ + int i = merc_search_index(class_); + if( i < 0 ) + return 0; + + return &mercenary_db[i].vd; +} + +int merc_create(struct map_session_data *sd, int class_, unsigned int lifetime) +{ + struct s_mercenary merc; + struct s_mercenary_db *db; + int i; + nullpo_retr(1,sd); + + if( (i = merc_search_index(class_)) < 0 ) + return 0; + + db = &mercenary_db[i]; + memset(&merc,0,sizeof(struct s_mercenary)); + + merc.char_id = sd->status.char_id; + merc.class_ = class_; + merc.hp = db->status.max_hp; + merc.sp = db->status.max_sp; + merc.remain_life_time = lifetime; + + // Request Char Server to create this mercenary + intif_mercenary_create(&merc); + + return 1; +} + +int mercenary_save(struct mercenary_data *md) +{ + const struct TimerData * td = get_timer(md->contract_timer); + + md->mercenary.hp = md->battle_status.hp; + md->mercenary.sp = md->battle_status.sp; + if( td != NULL ) + md->mercenary.remain_life_time = DIFF_TICK(td->tick, gettick()); + else + { + md->mercenary.remain_life_time = 0; + ShowWarning("mercenary_save : mercenary without timer (tid %d)\n", md->contract_timer); + } + + intif_mercenary_save(&md->mercenary); + return 1; +} + +static int merc_contract_end(int tid, unsigned int tick, int id, intptr data) +{ + struct map_session_data *sd; + struct mercenary_data *md; + + if( (sd = map_id2sd(id)) == NULL ) + return 1; + if( (md = sd->md) == NULL ) + return 1; + + if( md->contract_timer != tid ) + { + ShowError("merc_contract_end %d != %d.\n", md->contract_timer, tid); + return 0; + } + + md->contract_timer = INVALID_TIMER; + merc_delete(md, 0); // Mercenary soldier's duty hour is over. + + return 0; +} + +int merc_delete(struct mercenary_data *md, int reply) +{ + struct map_session_data *sd = md->master; + md->mercenary.remain_life_time = 0; + + merc_contract_stop(md); + + if( !sd ) + return unit_free(&md->bl, 1); + clif_mercenary_message(sd->fd, reply); + + return unit_remove_map(&md->bl, 1); +} + +void merc_contract_stop(struct mercenary_data *md) +{ + nullpo_retv(md); + if( md->contract_timer != INVALID_TIMER ) + delete_timer(md->contract_timer, merc_contract_end); + md->contract_timer = INVALID_TIMER; +} + +void merc_contract_init(struct mercenary_data *md) +{ + if( md->contract_timer == INVALID_TIMER ) + md->contract_timer = add_timer(gettick() + md->mercenary.remain_life_time, merc_contract_end, md->master->bl.id, 0); + + md->regen.state.block = 0; +} + +int merc_data_received(struct s_mercenary *merc, bool flag) +{ + struct map_session_data *sd; + struct mercenary_data *md; + struct s_mercenary_db *db; + int i = merc_search_index(merc->class_); + + if( (sd = map_charid2sd(merc->char_id)) == NULL ) + return 0; + if( !flag || i < 0 ) + { // Not created - loaded - DB info + sd->status.mer_id = 0; + return 0; + } + + sd->status.mer_id = merc->mercenary_id; + db = &mercenary_db[i]; + + if( !sd->md ) + { + sd->md = md = (struct mercenary_data*)aCalloc(1,sizeof(struct mercenary_data)); + md->bl.type = BL_MER; + md->bl.id = npc_get_new_npc_id(); + + md->master = sd; + md->db = db; + memcpy(&md->mercenary, merc, sizeof(struct s_mercenary)); + status_set_viewdata(&md->bl, md->mercenary.class_); + status_change_init(&md->bl); + unit_dataset(&md->bl); + md->ud.dir = sd->ud.dir; + + md->bl.m = sd->bl.m; + md->bl.x = sd->bl.x; + md->bl.y = sd->bl.y; + unit_calc_pos(&md->bl, sd->bl.x, sd->bl.y, sd->ud.dir); + md->bl.x = md->ud.to_x; + md->bl.y = md->ud.to_y; + + map_addiddb(&md->bl); + status_calc_mercenary(md,1); + md->contract_timer = INVALID_TIMER; + merc_contract_init(md); + } + else + memcpy(&sd->md->mercenary, merc, sizeof(struct s_mercenary)); + + md = sd->md; + if( md && md->bl.prev == NULL && sd->bl.prev != NULL ) + { + map_addblock(&md->bl); + clif_spawn(&md->bl); + clif_mercenary_info(sd); + clif_mercenary_skillblock(sd); + } + + return 1; +} + +int read_mercenarydb(void) +{ + FILE *fp; + char line[1024], *p; + char *str[26]; + int i, j = 0, k = 0, ele; + struct s_mercenary_db *db; + struct status_data *status; + + sprintf(line, "%s/%s", db_path, "mercenary_db.txt"); + memset(mercenary_db,0,sizeof(mercenary_db)); + + fp = fopen(line, "r"); + if( !fp ) + { + ShowError("read_mercenarydb : can't read mercenary_db.txt\n"); + return -1; + } + + while( fgets(line, sizeof(line), fp) && j < MAX_MERCENARY_CLASS ) + { + k++; + if( line[0] == '/' && line[1] == '/' ) + continue; + + i = 0; + p = strtok(line, ","); + while( p != NULL && i < 26 ) + { + str[i++] = p; + p = strtok(NULL, ","); + } + if( i < 26 ) + { + ShowError("read_mercenarydb : Incorrect number of columns at mercenary_db.txt line %d.\n", k); + continue; + } + + db = &mercenary_db[j]; + db->class_ = atoi(str[0]); + strncpy(db->sprite, str[1], NAME_LENGTH); + strncpy(db->name, str[2], NAME_LENGTH); + db->lv = atoi(str[3]); + + status = &db->status; + db->vd.class_ = db->class_; + + status->max_hp = atoi(str[4]); + status->max_sp = atoi(str[5]); + status->rhw.range = atoi(str[6]); + status->rhw.atk = atoi(str[7]); + status->rhw.atk2 = atoi(str[8]); + status->def = atoi(str[9]); + status->mdef = atoi(str[10]); + status->str = atoi(str[11]); + status->agi = atoi(str[12]); + status->vit = atoi(str[13]); + status->int_ = atoi(str[14]); + status->dex = atoi(str[15]); + status->luk = atoi(str[16]); + db->range2 = atoi(str[17]); + db->range3 = atoi(str[18]); + status->size = atoi(str[19]); + status->race = atoi(str[20]); + + ele = atoi(str[21]); + status->def_ele = ele%10; + status->ele_lv = ele/20; + if( status->def_ele >= ELE_MAX ) + { + ShowWarning("Mercenary %d has invalid element type %d (max element is %d)\n", db->class_, status->def_ele, ELE_MAX - 1); + status->def_ele = ELE_NEUTRAL; + } + if( status->ele_lv < 1 || status->ele_lv > 4 ) + { + ShowWarning("Mercenary %d has invalid element level %d (max is 4)\n", db->class_, status->ele_lv); + status->ele_lv = 1; + } + + status->speed = atoi(str[22]); + status->adelay = atoi(str[23]); + status->amotion = atoi(str[24]); + status->dmotion = atoi(str[25]); + + j++; + } + + fclose(fp); + ShowStatus("Done reading '"CL_WHITE"%d"CL_RESET"' mercenaries in '"CL_WHITE"db/mercenary_db.txt"CL_RESET"'.\n",j); + + return 0; +} + +int read_mercenary_skilldb(void) +{ + FILE *fp; + char line[1024], *p; + char *str[3]; + struct s_mercenary_db *db; + int i, j = 0, k = 0, class_; + int skillid, skilllv; + + sprintf(line, "%s/%s", db_path, "mercenary_skill_db.txt"); + fp = fopen(line, "r"); + if( !fp ) + { + ShowError("read_mercenary_skilldb : can't read mercenary_skill_db.txt\n"); + return -1; + } + + while( fgets(line, sizeof(line), fp) ) + { + k++; + if( line[0] == '/' && line[1] == '/' ) + continue; + + i = 0; + p = strtok(line, ","); + while( p != NULL && i < 3 ) + { + str[i++] = p; + p = strtok(NULL, ","); + } + if( i < 3 ) + { + ShowError("read_mercenary_skilldb : Incorrect number of columns at mercenary_skill_db.txt line %d.\n", k); + continue; + } + + class_ = atoi(str[0]); + ARR_FIND(0, MAX_MERCENARY_CLASS, i, class_ == mercenary_db[i].class_); + if( i == MAX_MERCENARY_CLASS ) + { + ShowError("read_mercenary_skilldb : Class not found in mercenary_db for skill entry, line %d.\n", k); + continue; + } + + skillid = atoi(str[1]); + if( skillid < MC_SKILLBASE || skillid >= MC_SKILLBASE + MAX_MERCSKILL ) + { + ShowError("read_mercenary_skilldb : Skill out of range, line %d.\n", k); + continue; + } + + db = &mercenary_db[i]; + skilllv = atoi(str[2]); + + i = skillid - MC_SKILLBASE; + db->skill[i].id = skillid; + db->skill[i].lv = skilllv; + j++; + } + + fclose(fp); + ShowStatus("Done reading '"CL_WHITE"%d"CL_RESET"' entries in '"CL_WHITE"db/mercenary_skill_db.txt"CL_RESET"'.\n",j); + return 0; +} + +int do_init_mercenary(void) +{ + read_mercenarydb(); + read_mercenary_skilldb(); + + //add_timer_func_list(mercenary_contract, "mercenary_contract"); + return 0; +} + +int do_final_mercenary(void); diff --git a/src/map/mercenary.h b/src/map/mercenary.h new file mode 100644 index 000000000..bc2046dc7 --- /dev/null +++ b/src/map/mercenary.h @@ -0,0 +1,48 @@ +// Copyright (c) Athena Dev Teams - Licensed under GNU GPL +// For more information, see LICENCE in the main folder + +#ifndef _MERCENARY_H_ +#define _MERCENARY_H_ + +#include "status.h" // struct status_data, struct status_change +#include "unit.h" // struct unit_data + +struct s_mercenary_db { + int class_; + char sprite[NAME_LENGTH], name[NAME_LENGTH]; + unsigned short lv; + short range2, range3; + struct status_data status; + struct view_data vd; + struct { + unsigned short id, lv; + } skill[MAX_MERCSKILL]; +}; + +extern struct s_mercenary_db mercenary_db[MAX_MERCENARY_CLASS]; + +struct mercenary_data { + struct block_list bl; + struct unit_data ud; + struct view_data *vd; + struct status_data base_status, battle_status; + struct status_change sc; + struct regen_data regen; + + struct s_mercenary_db *db; + struct s_mercenary mercenary; + + struct map_session_data *master; + int contract_timer; +}; + +bool merc_class(int class_); +struct view_data * merc_get_viewdata(int class_); +int merc_create(struct map_session_data *sd, int class_, unsigned int lifetime); +int merc_data_received(struct s_mercenary *merc, bool flag); +int mercenary_save(struct mercenary_data *md); +int do_init_mercenary(void); +int merc_delete(struct mercenary_data *md, int reply); +void merc_contract_stop(struct mercenary_data *md); + +#endif /* _MERCENARY_H_ */ -- cgit v1.2.3-70-g09d2