void merc_hom_skillup(struct homun_data *hd,int skillnum)
{
int i = 0 ;
nullpo_retv(hd);
if(hd->homunculus.vaporize)
return;
i = skillnum - HM_SKILLBASE;
if(hd->homunculus.skillpts > 0 &&
hd->homunculus.hskill[i].id &&
hd->homunculus.hskill[i].flag == SKILL_FLAG_PERMANENT && //Don't allow raising while you have granted skills. [Skotlex]
hd->homunculus.hskill[i].lv < merc_skill_tree_get_max(skillnum, hd->homunculus.class_)
)
{
hd->homunculus.hskill[i].lv++;
hd->homunculus.skillpts-- ;
status_calc_homunculus(hd,0);
if (hd->master) {
clif_homskillup(hd->master, skillnum);
clif_hominfo(hd->master,hd,0);
clif_homskillinfoblock(hd->master);
}
}
}
/**
* Level up an homunculus skill
* @param hd
* @param skill_id
*/
void hom_skillup(struct homun_data *hd, uint16 skill_id)
{
short idx = 0;
nullpo_retv(hd);
if (hd->homunculus.vaporize)
return;
if ((idx = hom_skill_get_index(skill_id)) < 0)
return;
if (hd->homunculus.skillpts > 0 &&
hd->homunculus.hskill[idx].id &&
hd->homunculus.hskill[idx].flag == SKILL_FLAG_PERMANENT && //Don't allow raising while you have granted skills. [Skotlex]
hd->homunculus.hskill[idx].lv < hom_skill_tree_get_max(skill_id, hd->homunculus.class_)
)
{
hd->homunculus.hskill[idx].lv++;
hd->homunculus.skillpts-- ;
status_calc_homunculus(hd, SCO_NONE);
if (hd->master) {
clif_homskillup(hd->master, skill_id);
clif_hominfo(hd->master,hd,0);
clif_homskillinfoblock(hd->master);
}
}
}
int merc_hom_gainexp(struct homun_data *hd,int exp)
{
if(hd->homunculus.vaporize)
return 1;
if( hd->exp_next == 0 ) {
hd->homunculus.exp = 0 ;
return 0;
}
hd->homunculus.exp += exp;
if(hd->homunculus.exp < hd->exp_next) {
clif_hominfo(hd->master,hd,0);
return 0;
}
//levelup
do
{
merc_hom_levelup(hd) ;
}
while(hd->homunculus.exp > hd->exp_next && hd->exp_next != 0 );
if( hd->exp_next == 0 )
hd->homunculus.exp = 0 ;
clif_specialeffect(&hd->bl,568,AREA);
status_calc_homunculus(hd,0);
status_percent_heal(&hd->bl, 100, 100);
return 0;
}
int merc_hom_mutation(struct homun_data *hd, int class_)
{
struct s_homunculus *hom;
struct map_session_data *sd;
nullpo_ret(hd);
//Only allows mutating level 99 evolved homunculus and also prevents mutating already mutated homunculus.
if( hd->homunculus.level < 99 || !(hd->homunculus.class_ >= 6009 && hd->homunculus.class_ <= 6016) ||
hd->homunculus.class_ >= MH_CLASS_BASE && hd->homunculus.class_ <= MH_CLASS_MAX)
{
clif_emotion(&hd->bl, E_SWT);
return 0 ;
}
sd = hd->master;
if (!sd)
return 0;
if (!merc_hom_change_class(hd, class_)) {
ShowError("merc_hom_mutation: Can't mutate homunc from %d to %d", hd->homunculus.class_, class_);
return 0;
}
// Its said the player can rename the homunculus again after mutation.
// This might be true since the homunculus's form completely changes.
hd->homunculus.rename_flag = 0;
//Apply mutation bonuses.
//Bonuses are the same for all mutations.
hom = &hd->homunculus;
hom->max_hp += rand(1000, 2000);
hom->max_sp += rand(10, 200);
hom->str += 10*rand(1, 10);
hom->agi += 10*rand(1, 10);
hom->vit += 10*rand(1, 10);
hom->int_+= 10*rand(1, 10);
hom->dex += 10*rand(1, 10);
hom->luk += 10*rand(1, 10);
unit_remove_map(&hd->bl, CLR_OUTSIGHT);
map_addblock(&hd->bl);
clif_spawn(&hd->bl);
clif_emotion(&sd->bl, E_NO1);
clif_specialeffect(&hd->bl,568,AREA);
//status_Calc flag&1 will make current HP/SP be reloaded from hom structure
hom->hp = hd->battle_status.hp;
hom->sp = hd->battle_status.sp;
status_calc_homunculus(hd,1);
if (!(battle_config.hom_setting&0x2))
skill_unit_move(&sd->hd->bl,gettick(),1); // apply land skills immediately
return 1 ;
}
/**
* Make an homonculus evolve, (changing in evolution class and apply bonus)
* @param hd : homonculus datas
* @return 0:failure, 1:success
*/
int merc_hom_evolution(struct homun_data *hd)
{
struct s_homunculus *hom;
struct h_stats *max, *min;
struct map_session_data *sd;
nullpo_ret(hd);
if(!hd->homunculusDB->evo_class || hd->homunculus.class_ == hd->homunculusDB->evo_class)
{
clif_emotion(&hd->bl, E_SWT);
return 0 ;
}
sd = hd->master;
if (!sd)
return 0;
if (!merc_hom_change_class(hd, hd->homunculusDB->evo_class)) {
ShowError("merc_hom_evolution: Can't evolve homunc from %d to %d", hd->homunculus.class_, hd->homunculusDB->evo_class);
return 0;
}
//Apply evolution bonuses
hom = &hd->homunculus;
max = &hd->homunculusDB->emax;
min = &hd->homunculusDB->emin;
hom->max_hp += rnd_value(min->HP, max->HP);
hom->max_sp += rnd_value(min->SP, max->SP);
hom->str += 10*rnd_value(min->str, max->str);
hom->agi += 10*rnd_value(min->agi, max->agi);
hom->vit += 10*rnd_value(min->vit, max->vit);
hom->int_+= 10*rnd_value(min->int_,max->int_);
hom->dex += 10*rnd_value(min->dex, max->dex);
hom->luk += 10*rnd_value(min->luk, max->luk);
hom->intimacy = 500;
unit_remove_map(&hd->bl, CLR_OUTSIGHT);
if(map_addblock(&hd->bl))
return 0;
clif_spawn(&hd->bl);
clif_emotion(&sd->bl, E_NO1);
clif_specialeffect(&hd->bl,568,AREA);
//status_Calc flag&1 will make current HP/SP be reloaded from hom structure
hom->hp = hd->battle_status.hp;
hom->sp = hd->battle_status.sp;
status_calc_homunculus(hd,1);
if (!(battle_config.hom_setting&0x2))
skill_unit_move(&sd->hd->bl,gettick(),1); // apply land skills immediately
return 1 ;
}
/**
* Shuffle homunculus status
* @param hd
*/
int hom_shuffle(struct homun_data *hd)
{
struct map_session_data *sd;
int lv, i, skillpts;
unsigned int exp;
struct s_skill b_skill[MAX_HOMUNSKILL];
if (!hom_is_active(hd))
return 0;
sd = hd->master;
lv = hd->homunculus.level;
exp = hd->homunculus.exp;
memcpy(&b_skill, &hd->homunculus.hskill, sizeof(b_skill));
skillpts = hd->homunculus.skillpts;
//Reset values to level 1.
hom_reset_stats(hd);
//Level it back up
for (i = 1; i < lv && hd->exp_next; i++){
hd->homunculus.exp += hd->exp_next;
// Should never happen, but who knows
if( !hom_levelup(hd) ) {
break;
}
}
if(hd->homunculus.class_ == hd->homunculusDB->evo_class) {
//Evolved bonuses
struct s_homunculus *hom = &hd->homunculus;
struct h_stats *max = &hd->homunculusDB->emax, *min = &hd->homunculusDB->emin;
hom->max_hp += rnd_value(min->HP, max->HP);
hom->max_sp += rnd_value(min->SP, max->SP);
hom->str += 10*rnd_value(min->str, max->str);
hom->agi += 10*rnd_value(min->agi, max->agi);
hom->vit += 10*rnd_value(min->vit, max->vit);
hom->int_+= 10*rnd_value(min->int_,max->int_);
hom->dex += 10*rnd_value(min->dex, max->dex);
hom->luk += 10*rnd_value(min->luk, max->luk);
}
hd->homunculus.exp = exp;
memcpy(&hd->homunculus.hskill, &b_skill, sizeof(b_skill));
hd->homunculus.skillpts = skillpts;
clif_homskillinfoblock(sd);
status_calc_homunculus(hd, SCO_NONE);
status_percent_heal(&hd->bl, 100, 100);
clif_specialeffect(&hd->bl,568,AREA);
return 1;
}
// Create homunc structure
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);
Assert((sd->status.hom_id == 0 || sd->hd == 0) || sd->hd->master == sd);
i = search_homunculusDB_index(hom->class_,HOMUNCULUS_CLASS);
if(i < 0) {
ShowError("merc_hom_alloc: unknown class [%d] for homunculus '%s', requesting deletion.\n", hom->class_, hom->name);
sd->status.hom_id = 0;
intif_homunculus_requestdelete(hom->hom_id);
return 1;
}
sd->hd = hd = aCalloc(1,sizeof(struct homun_data));
hd->bl.type = BL_HOM;
hd->bl.id = npc_get_new_npc_id();
hd->master = sd;
hd->homunculusDB = &homunculus_db[i];
memcpy(&hd->homunculus, hom, sizeof(struct s_homunculus));
hd->exp_next = hexptbl[hd->homunculus.level - 1];
status_set_viewdata(&hd->bl, hd->homunculus.class_);
status_change_init(&hd->bl);
unit_dataset(&hd->bl);
hd->ud.dir = sd->ud.dir;
// Find a random valid pos around the player
hd->bl.m = sd->bl.m;
hd->bl.x = sd->bl.x;
hd->bl.y = sd->bl.y;
x = sd->bl.x + 1;
y = sd->bl.y + 1;
map_random_dir(&hd->bl, &x, &y);
hd->bl.x = x;
hd->bl.y = y;
map_addiddb(&hd->bl);
status_calc_homunculus(hd,1);
hd->hungry_timer = -1;
return 0;
}
/**
* Make an homonculus mutate in renewal homon
* @param hd : homonculus datas
* @param homun_id : id to make it transform into (must be a valid homon class)
* @return 0:failure, 1:sucess
*/
int hom_mutate(struct homun_data *hd, int homun_id)
{
struct s_homunculus *hom;
struct map_session_data *sd;
int m_class, m_id, prev_class = 0;
nullpo_ret(hd);
m_class = hom_class2mapid(hd->homunculus.class_);
m_id = hom_class2mapid(homun_id);
if( m_class == -1 || m_id == -1 || !(m_class&HOM_EVO) || !(m_id&HOM_S) ) {
clif_emotion(&hd->bl, E_SWT);
return 0;
}
sd = hd->master;
if (!sd)
return 0;
prev_class = hd->homunculus.class_;
if (!hom_change_class(hd, homun_id)) {
ShowError("hom_mutate: Can't evolve homunc from %d to %d", hd->homunculus.class_, homun_id);
return 0;
}
unit_remove_map(&hd->bl, CLR_OUTSIGHT);
if(map_addblock(&hd->bl))
return 0;
clif_spawn(&hd->bl);
clif_emotion(&sd->bl, E_NO1);
clif_specialeffect(&hd->bl,568,AREA);
//status_Calc flag&1 will make current HP/SP be reloaded from hom structure
hom = &hd->homunculus;
hom->hp = hd->battle_status.hp;
hom->sp = hd->battle_status.sp;
hom->prev_class = prev_class;
status_calc_homunculus(hd, SCO_FIRST);
if (!(battle_config.hom_setting&0x2))
skill_unit_move(&sd->hd->bl,gettick(),1); // apply land skills immediately
return 1;
}
/**
* Create homunc structure
* @param sd
* @param hom
*/
void hom_alloc(struct map_session_data *sd, struct s_homunculus *hom)
{
struct homun_data *hd;
int i = 0;
nullpo_retv(sd);
Assert((sd->status.hom_id == 0 || sd->hd == 0) || sd->hd->master == sd);
i = hom_search(hom->class_,HOMUNCULUS_CLASS);
if(i < 0) {
ShowError("hom_alloc: unknown class [%d] for homunculus '%s', requesting deletion.\n", hom->class_, hom->name);
sd->status.hom_id = 0;
intif_homunculus_requestdelete(hom->hom_id);
return;
}
sd->hd = hd = (struct homun_data*)aCalloc(1,sizeof(struct homun_data));
hd->bl.type = BL_HOM;
hd->bl.id = npc_get_new_npc_id();
hd->master = sd;
hd->homunculusDB = &homunculus_db[i];
memcpy(&hd->homunculus, hom, sizeof(struct s_homunculus));
hd->exp_next = hexptbl[hd->homunculus.level - 1];
status_set_viewdata(&hd->bl, hd->homunculus.class_);
status_change_init(&hd->bl);
unit_dataset(&hd->bl);
hd->ud.dir = sd->ud.dir;
// Find a random valid pos around the player
hd->bl.m = sd->bl.m;
hd->bl.x = sd->bl.x;
hd->bl.y = sd->bl.y;
unit_calc_pos(&hd->bl, sd->bl.x, sd->bl.y, sd->ud.dir);
hd->bl.x = hd->ud.to_x;
hd->bl.y = hd->ud.to_y;
map_addiddb(&hd->bl);
status_calc_homunculus(hd, SCO_FIRST);
status_percent_heal(&hd->bl, 100, 100);
hd->hungry_timer = INVALID_TIMER;
hd->masterteleport_timer = INVALID_TIMER;
}
/**
* Add homunculus exp
* @param hd
* @param exp Added EXP
*/
void hom_gainexp(struct homun_data *hd,int exp)
{
int m_class;
nullpo_retv(hd);
if(hd->homunculus.vaporize)
return;
if((m_class = hom_class2mapid(hd->homunculus.class_)) == -1) {
ShowError("hom_gainexp: Invalid class %d. \n", hd->homunculus.class_);
return;
}
if( hd->exp_next == 0 ||
((m_class&HOM_REG) && hd->homunculus.level >= battle_config.hom_max_level) ||
((m_class&HOM_S) && hd->homunculus.level >= battle_config.hom_S_max_level) )
{
hd->homunculus.exp = 0;
return;
}
hd->homunculus.exp += exp;
if (hd->homunculus.exp < hd->exp_next) {
clif_hominfo(hd->master,hd,0);
return;
}
// Do the levelup(s)
while( hd->homunculus.exp > hd->exp_next ){
// Max level reached or error
if( !hom_levelup(hd) ){
break;
}
}
if( hd->exp_next == 0 )
hd->homunculus.exp = 0 ;
clif_specialeffect(&hd->bl,568,AREA);
status_calc_homunculus(hd, SCO_NONE);
status_percent_heal(&hd->bl, 100, 100);
}
int merc_hom_gainexp(struct homun_data *hd,int exp)
{
struct map_session_data *sd;
struct s_homunculus *hom;
hom = &hd->homunculus;
sd = hd->master;
if(hd->homunculus.vaporize)
return 1;
if( hd->exp_next == 0 ) {
hd->homunculus.exp = 0 ;
return 0;
}
if (sd->sc.data[SC_EXPBOOST])
exp += exp*((sd->sc.data[SC_EXPBOOST]->val1)/100);
hd->homunculus.exp += exp;
if(hd->homunculus.exp < hd->exp_next) {
clif_hominfo(hd->master,hd,0);
return 0;
}
//levelup
do
{
merc_hom_levelup(hd) ;
}
while(hd->homunculus.exp > hd->exp_next && hd->exp_next != 0 && hom->evomoment == 0 );
if( hd->exp_next == 0 )
hd->homunculus.exp = 0 ;
clif_specialeffect(&hd->bl,705,AREA);
status_calc_homunculus(hd,0);
status_percent_heal(&hd->bl, 100, 100);
return 0;
}
int merc_hom_gainexp(struct homun_data *hd,int exp)
{
int m_class;
if(hd->homunculus.vaporize)
return 1;
if((m_class = hom_class2mapid(hd->homunculus.class_)) == -1) {
ShowError("merc_hom_gainexp: Invalid class %d. \n", hd->homunculus.class_);
return 0;
}
if( hd->exp_next == 0 ||
((m_class&HOM_REG) && hd->homunculus.level >= battle_config.hom_max_level) ||
((m_class&HOM_S) && hd->homunculus.level >= battle_config.hom_S_max_level) ) {
hd->homunculus.exp = 0;
return 0;
}
hd->homunculus.exp += exp;
if(hd->homunculus.exp < hd->exp_next) {
clif_hominfo(hd->master,hd,0);
return 0;
}
//levelup
do
{
merc_hom_levelup(hd) ;
}
while(hd->homunculus.exp > hd->exp_next && hd->exp_next != 0 );
if( hd->exp_next == 0 )
hd->homunculus.exp = 0 ;
clif_specialeffect(&hd->bl,568,AREA);
status_calc_homunculus(hd,0);
status_percent_heal(&hd->bl, 100, 100);
return 0;
}
/**
* Homunculus leveled up
* @param hd
*/
int hom_levelup(struct homun_data *hd)
{
struct s_homunculus *hom;
struct h_stats *min = NULL, *max = NULL;
int growth_str, growth_agi, growth_vit, growth_int, growth_dex, growth_luk ;
int growth_max_hp, growth_max_sp ;
int m_class;
if ((m_class = hom_class2mapid(hd->homunculus.class_)) == -1) {
ShowError("hom_levelup: Invalid class %d. \n", hd->homunculus.class_);
return 0;
}
/// When homunculus is homunculus S, we check to see if we need to apply previous class stats
if(m_class&HOM_S && hd->homunculus.level < battle_config.hom_S_growth_level) {
int i;
if (!hd->homunculus.prev_class) {
/// We also need to be sure that the previous class exists, otherwise give it something to work with
hd->homunculus.prev_class = 6001;
}
// Give the homunculus the level up stats database it needs
i = hom_search(hd->homunculus.prev_class,HOMUNCULUS_CLASS);
if (i < 0) // Nothing should go wrong here, but check anyways
return 0;
max = &homunculus_db[i].gmax;
min = &homunculus_db[i].gmin;
}
if (((m_class&HOM_REG) && hd->homunculus.level >= battle_config.hom_max_level)
|| ((m_class&HOM_S) && hd->homunculus.level >= battle_config.hom_S_max_level)
|| !hd->exp_next || hd->homunculus.exp < hd->exp_next)
return 0;
hom = &hd->homunculus;
hom->level++ ;
if (!(hom->level % 3))
hom->skillpts++ ; //1 skillpoint each 3 base level
hom->exp -= hd->exp_next ;
hd->exp_next = hexptbl[hom->level - 1] ;
if (!max) {
max = &hd->homunculusDB->gmax;
min = &hd->homunculusDB->gmin;
}
growth_max_hp = rnd_value(min->HP, max->HP);
growth_max_sp = rnd_value(min->SP, max->SP);
growth_str = rnd_value(min->str, max->str);
growth_agi = rnd_value(min->agi, max->agi);
growth_vit = rnd_value(min->vit, max->vit);
growth_dex = rnd_value(min->dex, max->dex);
growth_int = rnd_value(min->int_,max->int_);
growth_luk = rnd_value(min->luk, max->luk);
//Aegis discards the decimals in the stat growth values!
growth_str-=growth_str%10;
growth_agi-=growth_agi%10;
growth_vit-=growth_vit%10;
growth_dex-=growth_dex%10;
growth_int-=growth_int%10;
growth_luk-=growth_luk%10;
hom->max_hp += growth_max_hp;
hom->max_sp += growth_max_sp;
hom->str += growth_str;
hom->agi += growth_agi;
hom->vit += growth_vit;
hom->dex += growth_dex;
hom->int_+= growth_int;
hom->luk += growth_luk;
APPLY_HOMUN_LEVEL_STATWEIGHT();
// Needed to update skill list for mutated homunculus so unlocked skills will appear when the needed level is reached.
status_calc_homunculus(hd,SCO_NONE);
clif_hominfo(hd->master,hd,0);
clif_homskillinfoblock(hd->master);
if ( hd->master && battle_config.homunculus_show_growth ) {
char output[256] ;
sprintf(output,
"Growth: hp:%d sp:%d str(%.2f) agi(%.2f) vit(%.2f) int(%.2f) dex(%.2f) luk(%.2f) ",
growth_max_hp, growth_max_sp,
growth_str/10.0, growth_agi/10.0, growth_vit/10.0,
growth_int/10.0, growth_dex/10.0, growth_luk/10.0);
clif_messagecolor(&hd->master->bl, color_table[COLOR_LIGHT_GREEN], output, false, SELF);
}
return 1;
}
