Mirroristas/rathena
2
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

It kinda works!

Browse Source
This commit is contained in:
vstumpf 2024-07-05 08:57:19 +00:00
parent 920b6a78c5
commit fd1e582156
13 changed files with 7506 additions and 9231 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
src/map/CMakeLists.txt
View File

@ -43,7 +43,8 @@ set(MAP_SOURCES
"vending.cpp" "vending.cpp"
"skills/skill.cpp" "skills/skill.cpp"
"skills/swordsman/bash.cpp" "skills/skillrepository.cpp"
"skills/swordsman.cpp"
) )
set(MAP_HEADERS set(MAP_HEADERS

263
src/map/skill.cpp
View File

@ -46,6 +46,8 @@
#include "status.hpp" #include "status.hpp"
#include "unit.hpp" #include "unit.hpp"
#include "skills/skillrepository.hpp"
using namespace rathena; using namespace rathena;
#define SKILLUNITTIMER_INTERVAL 100 #define SKILLUNITTIMER_INTERVAL 100
@ -5135,9 +5137,18 @@ int skill_castend_damage_id (struct block_list* src, struct block_list *bl, uint
map_freeblock_lock(); map_freeblock_lock();
try {
const Skill& skill = skillRepository.getSkill(static_cast<e_skill>(skill_id));
int ret = skill.castendDamage(src, bl, skill_lv, tick, flag);
if (ret != 0) {
map_freeblock_unlock();
return ret;
}
} catch (SkillRepository::SkillNotFoundException e) {
// fallback on switch
switch(skill_id) { switch(skill_id) {
case MER_CRASH: case MER_CRASH:
case SM_BASH:
case MS_BASH: case MS_BASH:
case MC_MAMMONITE: case MC_MAMMONITE:
case TF_DOUBLE: case TF_DOUBLE:
@ -5187,9 +5198,9 @@ int skill_castend_damage_id (struct block_list* src, struct block_list *bl, uint
case NPC_PETRIFYATTACK: case NPC_PETRIFYATTACK:
case NPC_CURSEATTACK: case NPC_CURSEATTACK:
case NPC_SLEEPATTACK: case NPC_SLEEPATTACK:
#ifdef RENEWAL #ifdef RENEWAL
case CR_ACIDDEMONSTRATION: case CR_ACIDDEMONSTRATION:
#endif #endif
case LK_AURABLADE: case LK_AURABLADE:
case LK_SPIRALPIERCE: case LK_SPIRALPIERCE:
case ML_SPIRALPIERCE: case ML_SPIRALPIERCE:
@ -5207,9 +5218,9 @@ int skill_castend_damage_id (struct block_list* src, struct block_list *bl, uint
case TK_COUNTER: case TK_COUNTER:
case GS_CHAINACTION: case GS_CHAINACTION:
case GS_TRIPLEACTION: case GS_TRIPLEACTION:
#ifndef RENEWAL #ifndef RENEWAL
case GS_MAGICALBULLET: case GS_MAGICALBULLET:
#endif #endif
case GS_TRACKING: case GS_TRACKING:
case GS_PIERCINGSHOT: case GS_PIERCINGSHOT:
case GS_RAPIDSHOWER: case GS_RAPIDSHOWER:
@ -5367,11 +5378,11 @@ int skill_castend_damage_id (struct block_list* src, struct block_list *bl, uint
case KN_CHARGEATK: case KN_CHARGEATK:
{ {
bool path = path_search_long(nullptr, src->m, src->x, src->y, bl->x, bl->y,CELL_CHKWALL); bool path = path_search_long(nullptr, src->m, src->x, src->y, bl->x, bl->y,CELL_CHKWALL);
#ifdef RENEWAL #ifdef RENEWAL
int dist = skill_get_blewcount(skill_id, skill_lv); int dist = skill_get_blewcount(skill_id, skill_lv);
#else #else
unsigned int dist = distance_bl(src, bl); unsigned int dist = distance_bl(src, bl);
#endif #endif
uint8 dir = map_calc_dir(bl, src->x, src->y); uint8 dir = map_calc_dir(bl, src->x, src->y);
// teleport to target (if not on WoE grounds) // teleport to target (if not on WoE grounds)
@ -5381,10 +5392,10 @@ int skill_castend_damage_id (struct block_list* src, struct block_list *bl, uint
// cause damage and knockback if the path to target was a straight one // cause damage and knockback if the path to target was a straight one
if (path) { if (path) {
if(skill_attack(BF_WEAPON, src, src, bl, skill_id, skill_lv, tick, dist)) { if(skill_attack(BF_WEAPON, src, src, bl, skill_id, skill_lv, tick, dist)) {
#ifdef RENEWAL #ifdef RENEWAL
if (map_getmapdata(src->m)->getMapFlag(MF_PVP)) if (map_getmapdata(src->m)->getMapFlag(MF_PVP))
dist += 2; // Knockback is 4 on PvP maps dist += 2; // Knockback is 4 on PvP maps
#endif #endif
skill_blown(src, bl, dist, dir, BLOWN_NONE); skill_blown(src, bl, dist, dir, BLOWN_NONE);
} }
//HACK: since knockback officially defaults to the left, the client also turns to the left... therefore, //HACK: since knockback officially defaults to the left, the client also turns to the left... therefore,
@ -5409,11 +5420,11 @@ int skill_castend_damage_id (struct block_list* src, struct block_list *bl, uint
} }
break; break;
#ifndef RENEWAL #ifndef RENEWAL
case SN_SHARPSHOOTING: case SN_SHARPSHOOTING:
flag |= 2; // Flag for specific mob damage formula flag |= 2; // Flag for specific mob damage formula
[[fallthrough]]; [[fallthrough]];
#endif #endif
case MA_SHARPSHOOTING: case MA_SHARPSHOOTING:
case NJ_KAMAITACHI: case NJ_KAMAITACHI:
case NPC_DARKPIERCING: case NPC_DARKPIERCING:
@ -5433,10 +5444,10 @@ int skill_castend_damage_id (struct block_list* src, struct block_list *bl, uint
if (!(map_foreachindir(skill_attack_area, src->m, src->x, src->y, bl->x, bl->y, if (!(map_foreachindir(skill_attack_area, src->m, src->x, src->y, bl->x, bl->y,
skill_get_splash(skill_id, skill_lv), skill_get_maxcount(skill_id, skill_lv), 0, splash_target(src), skill_get_splash(skill_id, skill_lv), skill_get_maxcount(skill_id, skill_lv), 0, splash_target(src),
skill_get_type(skill_id), src, src, skill_id, skill_lv, tick, flag, BCT_ENEMY))) { skill_get_type(skill_id), src, src, skill_id, skill_lv, tick, flag, BCT_ENEMY))) {
#ifndef RENEWAL #ifndef RENEWAL
if (skill_id == SN_SHARPSHOOTING) if (skill_id == SN_SHARPSHOOTING)
flag &= ~2; // Only targets in the splash area are affected flag &= ~2; // Only targets in the splash area are affected
#endif #endif
//These skills hit at least the target if the AoE doesn't hit //These skills hit at least the target if the AoE doesn't hit
skill_attack(skill_get_type(skill_id), src, src, bl, skill_id, skill_lv, tick, flag); skill_attack(skill_get_type(skill_id), src, src, bl, skill_id, skill_lv, tick, flag);
@ -5458,7 +5469,7 @@ int skill_castend_damage_id (struct block_list* src, struct block_list *bl, uint
case RG_BACKSTAP: case RG_BACKSTAP:
{ {
if (!check_distance_bl(src, bl, 0)) { if (!check_distance_bl(src, bl, 0)) {
#ifdef RENEWAL #ifdef RENEWAL
uint8 dir = map_calc_dir(src, bl->x, bl->y); uint8 dir = map_calc_dir(src, bl->x, bl->y);
short x, y; short x, y;
@ -5477,17 +5488,17 @@ int skill_castend_damage_id (struct block_list* src, struct block_list *bl, uint
y = 0; y = 0;
if (battle_check_target(src, bl, BCT_ENEMY) > 0 && unit_movepos(src, bl->x + x, bl->y + y, 2, true)) { // Display movement + animation. if (battle_check_target(src, bl, BCT_ENEMY) > 0 && unit_movepos(src, bl->x + x, bl->y + y, 2, true)) { // Display movement + animation.
#else #else
uint8 dir = map_calc_dir(src, bl->x, bl->y), t_dir = unit_getdir(bl); uint8 dir = map_calc_dir(src, bl->x, bl->y), t_dir = unit_getdir(bl);
if (!map_check_dir(dir, t_dir) || bl->type == BL_SKILL) { if (!map_check_dir(dir, t_dir) || bl->type == BL_SKILL) {
#endif #endif
status_change_end(src, SC_HIDING); status_change_end(src, SC_HIDING);
dir = dir < 4 ? dir+4 : dir-4; // change direction [Celest] dir = dir < 4 ? dir+4 : dir-4; // change direction [Celest]
unit_setdir(bl,dir); unit_setdir(bl,dir);
#ifdef RENEWAL #ifdef RENEWAL
clif_blown(src); clif_blown(src);
#endif #endif
skill_attack(BF_WEAPON, src, src, bl, skill_id, skill_lv, tick, flag); skill_attack(BF_WEAPON, src, src, bl, skill_id, skill_lv, tick, flag);
} }
else if (sd) else if (sd)
@ -5510,19 +5521,19 @@ int skill_castend_damage_id (struct block_list* src, struct block_list *bl, uint
status_change_end(src, SC_BLADESTOP); status_change_end(src, SC_BLADESTOP);
break; break;
#ifndef RENEWAL #ifndef RENEWAL
case NJ_ISSEN: case NJ_ISSEN:
#endif #endif
case MO_EXTREMITYFIST: case MO_EXTREMITYFIST:
{ {
struct block_list *mbl = bl; // For NJ_ISSEN struct block_list *mbl = bl; // For NJ_ISSEN
short x, y, i = 2; // Move 2 cells (From target) short x, y, i = 2; // Move 2 cells (From target)
short dir = map_calc_dir(src,bl->x,bl->y); short dir = map_calc_dir(src,bl->x,bl->y);
#ifdef RENEWAL #ifdef RENEWAL
if (skill_id == MO_EXTREMITYFIST && sd && sd->spiritball_old > 5) if (skill_id == MO_EXTREMITYFIST && sd && sd->spiritball_old > 5)
flag |= 1; // Give +100% damage increase flag |= 1; // Give +100% damage increase
#endif #endif
skill_attack(BF_WEAPON,src,src,bl,skill_id,skill_lv,tick,flag); skill_attack(BF_WEAPON,src,src,bl,skill_id,skill_lv,tick,flag);
if (skill_id == MO_EXTREMITYFIST) { if (skill_id == MO_EXTREMITYFIST) {
status_set_sp(src, 0, 0); status_set_sp(src, 0, 0);
@ -5590,9 +5601,9 @@ int skill_castend_damage_id (struct block_list* src, struct block_list *bl, uint
case MG_NAPALMBEAT: case MG_NAPALMBEAT:
case MG_FIREBALL: case MG_FIREBALL:
case RG_RAID: case RG_RAID:
#ifdef RENEWAL #ifdef RENEWAL
case SN_SHARPSHOOTING: case SN_SHARPSHOOTING:
#endif #endif
case HW_NAPALMVULCAN: case HW_NAPALMVULCAN:
case NJ_HUUMA: case NJ_HUUMA:
case ASC_METEORASSAULT: case ASC_METEORASSAULT:
@ -5765,11 +5776,11 @@ int skill_castend_damage_id (struct block_list* src, struct block_list *bl, uint
status_heal(src, heal, 0, 0); status_heal(src, heal, 0, 0);
} }
break; break;
#ifdef RENEWAL #ifdef RENEWAL
case SN_SHARPSHOOTING: case SN_SHARPSHOOTING:
status_change_end(src, SC_CAMOUFLAGE); status_change_end(src, SC_CAMOUFLAGE);
break; break;
#endif #endif
case SJ_PROMINENCEKICK: // Trigger the 2nd hit. (100% fire damage.) case SJ_PROMINENCEKICK: // Trigger the 2nd hit. (100% fire damage.)
skill_attack(skill_get_type(skill_id), src, src, bl, skill_id, skill_lv, tick, sflag|8|SD_ANIMATION); skill_attack(skill_get_type(skill_id), src, src, bl, skill_id, skill_lv, tick, sflag|8|SD_ANIMATION);
break; break;
@ -5801,9 +5812,9 @@ int skill_castend_damage_id (struct block_list* src, struct block_list *bl, uint
case HN_JUPITEL_THUNDER_STORM: case HN_JUPITEL_THUNDER_STORM:
clif_skill_nodamage(src,bl,skill_id,skill_lv,1); clif_skill_nodamage(src,bl,skill_id,skill_lv,1);
break; break;
#ifdef RENEWAL #ifdef RENEWAL
case NJ_HUUMA: case NJ_HUUMA:
#endif #endif
case LG_MOONSLASHER: case LG_MOONSLASHER:
case MH_XENO_SLASHER: case MH_XENO_SLASHER:
clif_skill_damage(src,bl,tick, status_get_amotion(src), 0, -30000, 1, skill_id, skill_lv, DMG_SINGLE); clif_skill_damage(src,bl,tick, status_get_amotion(src), 0, -30000, 1, skill_id, skill_lv, DMG_SINGLE);
@ -5984,13 +5995,13 @@ int skill_castend_damage_id (struct block_list* src, struct block_list *bl, uint
} }
break; break;
#ifdef RENEWAL #ifdef RENEWAL
case KN_BRANDISHSPEAR: case KN_BRANDISHSPEAR:
skill_attack(skill_get_type(skill_id), src, src, bl, skill_id, skill_lv, tick, flag); skill_attack(skill_get_type(skill_id), src, src, bl, skill_id, skill_lv, tick, flag);
break; break;
#else #else
case KN_BRANDISHSPEAR: case KN_BRANDISHSPEAR:
#endif #endif
case ML_BRANDISH: case ML_BRANDISH:
//Coded apart for it needs the flag passed to the damage calculation. //Coded apart for it needs the flag passed to the damage calculation.
if (skill_area_temp[1] != bl->id) if (skill_area_temp[1] != bl->id)
@ -5999,7 +6010,7 @@ int skill_castend_damage_id (struct block_list* src, struct block_list *bl, uint
skill_attack(skill_get_type(skill_id), src, src, bl, skill_id, skill_lv, tick, flag); skill_attack(skill_get_type(skill_id), src, src, bl, skill_id, skill_lv, tick, flag);
break; break;
#ifdef RENEWAL #ifdef RENEWAL
case KN_BOWLINGBASH: case KN_BOWLINGBASH:
if (flag & 1) { if (flag & 1) {
skill_attack(skill_get_type(skill_id), src, src, bl, skill_id, skill_lv, tick, (skill_area_temp[0]) > 0 ? SD_ANIMATION | skill_area_temp[0] : skill_area_temp[0]); skill_attack(skill_get_type(skill_id), src, src, bl, skill_id, skill_lv, tick, (skill_area_temp[0]) > 0 ? SD_ANIMATION | skill_area_temp[0] : skill_area_temp[0]);
@ -6008,9 +6019,9 @@ int skill_castend_damage_id (struct block_list* src, struct block_list *bl, uint
map_foreachinrange(skill_area_sub, bl, skill_get_splash(skill_id, skill_lv), BL_CHAR|BL_SKILL, src, skill_id, skill_lv, tick, flag | BCT_ENEMY | SD_SPLASH | 1, skill_castend_damage_id); map_foreachinrange(skill_area_sub, bl, skill_get_splash(skill_id, skill_lv), BL_CHAR|BL_SKILL, src, skill_id, skill_lv, tick, flag | BCT_ENEMY | SD_SPLASH | 1, skill_castend_damage_id);
} }
break; break;
#else #else
case KN_BOWLINGBASH: case KN_BOWLINGBASH:
#endif #endif
case MS_BOWLINGBASH: case MS_BOWLINGBASH:
{ {
int min_x,max_x,min_y,max_y,i,c,dir,tx,ty; int min_x,max_x,min_y,max_y,i,c,dir,tx,ty;
@ -6150,9 +6161,9 @@ int skill_castend_damage_id (struct block_list* src, struct block_list *bl, uint
case MG_FROSTDIVER: case MG_FROSTDIVER:
case WZ_SIGHTBLASTER: case WZ_SIGHTBLASTER:
case WZ_SIGHTRASHER: case WZ_SIGHTRASHER:
#ifdef RENEWAL #ifdef RENEWAL
case PA_PRESSURE: case PA_PRESSURE:
#endif #endif
case NJ_KOUENKA: case NJ_KOUENKA:
case NJ_HYOUSENSOU: case NJ_HYOUSENSOU:
case NJ_HUUJIN: case NJ_HUUJIN:
@ -6258,10 +6269,10 @@ int skill_castend_damage_id (struct block_list* src, struct block_list *bl, uint
break; // 50% chance break; // 50% chance
[[fallthrough]]; [[fallthrough]];
case SN_FALCONASSAULT: case SN_FALCONASSAULT:
#ifndef RENEWAL #ifndef RENEWAL
case PA_PRESSURE: case PA_PRESSURE:
case CR_ACIDDEMONSTRATION: case CR_ACIDDEMONSTRATION:
#endif #endif
case TF_THROWSTONE: case TF_THROWSTONE:
case NPC_SMOKING: case NPC_SMOKING:
case GS_FLING: case GS_FLING:
@ -6270,7 +6281,7 @@ int skill_castend_damage_id (struct block_list* src, struct block_list *bl, uint
case RL_B_TRAP: case RL_B_TRAP:
skill_attack(skill_get_type(skill_id),src,src,bl,skill_id,skill_lv,tick,flag); skill_attack(skill_get_type(skill_id),src,src,bl,skill_id,skill_lv,tick,flag);
break; break;
#ifdef RENEWAL #ifdef RENEWAL
case NJ_ISSEN: { case NJ_ISSEN: {
short x, y; short x, y;
short dir = map_calc_dir(src, bl->x, bl->y); short dir = map_calc_dir(src, bl->x, bl->y);
@ -6299,7 +6310,7 @@ int skill_castend_damage_id (struct block_list* src, struct block_list *bl, uint
status_change_end(src, SC_HIDING); status_change_end(src, SC_HIDING);
} }
break; break;
#endif #endif
case RK_DRAGONBREATH_WATER: case RK_DRAGONBREATH_WATER:
case RK_DRAGONBREATH: case RK_DRAGONBREATH:
case NPC_DRAGONBREATH: case NPC_DRAGONBREATH:
@ -6535,9 +6546,9 @@ int skill_castend_damage_id (struct block_list* src, struct block_list *bl, uint
if (sd) { if (sd) {
int i; int i;
#ifndef RENEWAL #ifndef RENEWAL
skill_toggle_magicpower(src, skill_id); // No hit will be amplified skill_toggle_magicpower(src, skill_id); // No hit will be amplified
#endif #endif
if (skill_lv == 1) { // SpellBook if (skill_lv == 1) { // SpellBook
if (sc->getSCE(SC_FREEZE_SP) == nullptr) if (sc->getSCE(SC_FREEZE_SP) == nullptr)
break; break;
@ -7142,6 +7153,7 @@ int skill_castend_damage_id (struct block_list* src, struct block_list *bl, uint
map_freeblock_unlock(); map_freeblock_unlock();
return 1; return 1;
} }
}
if( sc && sc->getSCE(SC_CURSEDCIRCLE_ATKER) ) //Should only remove after the skill has been casted. if( sc && sc->getSCE(SC_CURSEDCIRCLE_ATKER) ) //Should only remove after the skill has been casted.
status_change_end(src,SC_CURSEDCIRCLE_ATKER); status_change_end(src,SC_CURSEDCIRCLE_ATKER);
@ -7365,6 +7377,12 @@ int skill_castend_nodamage_id (struct block_list *src, struct block_list *bl, ui
return 1; //Skills that cause an status should be blocked if the target element blocks its element. return 1; //Skills that cause an status should be blocked if the target element blocks its element.
map_freeblock_lock(); map_freeblock_lock();
try {
const Skill& skill = skillRepository.getSkill(static_cast<e_skill>(skill_id));
skill.castendNoDamage(src, bl, skill_lv, tick, flag);
} catch (SkillRepository::SkillNotFoundException e) {
// fallback on switch
switch(skill_id) switch(skill_id)
{ {
case HLIF_HEAL: //[orn] case HLIF_HEAL: //[orn]
@ -7439,14 +7457,14 @@ int skill_castend_nodamage_id (struct block_list *src, struct block_list *bl, ui
clif_skill_fail( *sd, skill_id ); clif_skill_fail( *sd, skill_id );
break; break;
} }
#ifndef RENEWAL #ifndef RENEWAL
skill_area_temp[0] = battle_config.exp_cost_redemptio_limit - skill_area_temp[0]; // The actual penalty... skill_area_temp[0] = battle_config.exp_cost_redemptio_limit - skill_area_temp[0]; // The actual penalty...
if (skill_area_temp[0] > 0 && !map_getmapflag(src->m, MF_NOEXPPENALTY) && battle_config.exp_cost_redemptio) { //Apply penalty if (skill_area_temp[0] > 0 && !map_getmapflag(src->m, MF_NOEXPPENALTY) && battle_config.exp_cost_redemptio) { //Apply penalty
//If total penalty is 1% => reduced 0.2% penalty per each revived player //If total penalty is 1% => reduced 0.2% penalty per each revived player
pc_lostexp(sd, u64min(sd->status.base_exp, (pc_nextbaseexp(sd) * skill_area_temp[0] * battle_config.exp_cost_redemptio / battle_config.exp_cost_redemptio_limit) / 100), 0); pc_lostexp(sd, u64min(sd->status.base_exp, (pc_nextbaseexp(sd) * skill_area_temp[0] * battle_config.exp_cost_redemptio / battle_config.exp_cost_redemptio_limit) / 100), 0);
} }
status_set_sp(src, 0, 0); status_set_sp(src, 0, 0);
#endif #endif
status_set_hp(src, 1, 0); status_set_hp(src, 1, 0);
break; break;
} else if (!(status_isdead(bl) && flag&1)) { } else if (!(status_isdead(bl) && flag&1)) {
@ -7753,9 +7771,9 @@ int skill_castend_nodamage_id (struct block_list *src, struct block_list *bl, ui
clif_skill_nodamage(src,bl,skill_id,skill_lv,0); clif_skill_nodamage(src,bl,skill_id,skill_lv,0);
break; break;
} }
#ifdef RENEWAL #ifdef RENEWAL
clif_skill_nodamage(src, bl, skill_id, skill_lv, sc_start(src, bl, type, 100, skill_lv, skill_get_time(skill_id, skill_lv))); clif_skill_nodamage(src, bl, skill_id, skill_lv, sc_start(src, bl, type, 100, skill_lv, skill_get_time(skill_id, skill_lv)));
#else #else
// 100% success rate at lv4 & 5, but lasts longer at lv5 // 100% success rate at lv4 & 5, but lasts longer at lv5
if(!clif_skill_nodamage(src,bl,skill_id,skill_lv, sc_start(src,bl,type,(60+skill_lv*10),skill_lv, skill_get_time(skill_id,skill_lv)))) { if(!clif_skill_nodamage(src,bl,skill_id,skill_lv, sc_start(src,bl,type,(60+skill_lv*10),skill_lv, skill_get_time(skill_id,skill_lv)))) {
if (dstsd){ if (dstsd){
@ -7766,7 +7784,7 @@ int skill_castend_nodamage_id (struct block_list *src, struct block_list *bl, ui
if (sd) if (sd)
clif_skill_fail( *sd, skill_id ); clif_skill_fail( *sd, skill_id );
} }
#endif #endif
break; break;
case PR_ASPERSIO: case PR_ASPERSIO:
@ -7854,11 +7872,11 @@ int skill_castend_nodamage_id (struct block_list *src, struct block_list *bl, ui
src,skill_id,skill_lv,tick, flag|BCT_ENEMY|1, skill_castend_damage_id); src,skill_id,skill_lv,tick, flag|BCT_ENEMY|1, skill_castend_damage_id);
clif_skill_nodamage (src,src,skill_id,skill_lv,1); clif_skill_nodamage (src,src,skill_id,skill_lv,1);
// Initiate 20% of your damage becomes fire element. // Initiate 20% of your damage becomes fire element.
#ifdef RENEWAL #ifdef RENEWAL
sc_start4(src,src,SC_SUB_WEAPONPROPERTY,100,ELE_FIRE,20,skill_id,0,skill_get_time2(skill_id, skill_lv)); sc_start4(src,src,SC_SUB_WEAPONPROPERTY,100,ELE_FIRE,20,skill_id,0,skill_get_time2(skill_id, skill_lv));
#else #else
sc_start4(src,src,SC_WATK_ELEMENT,100,ELE_FIRE,20,0,0,skill_get_time2(skill_id, skill_lv)); sc_start4(src,src,SC_WATK_ELEMENT,100,ELE_FIRE,20,0,0,skill_get_time2(skill_id, skill_lv));
#endif #endif
break; break;
case MH_BLAZING_AND_FURIOUS: case MH_BLAZING_AND_FURIOUS:
@ -7900,10 +7918,10 @@ int skill_castend_nodamage_id (struct block_list *src, struct block_list *bl, ui
[[fallthrough]]; [[fallthrough]];
case PR_SLOWPOISON: case PR_SLOWPOISON:
case PR_LEXAETERNA: case PR_LEXAETERNA:
#ifndef RENEWAL #ifndef RENEWAL
case PR_IMPOSITIO: case PR_IMPOSITIO:
case PR_SUFFRAGIUM: case PR_SUFFRAGIUM:
#endif #endif
case LK_BERSERK: case LK_BERSERK:
case MS_BERSERK: case MS_BERSERK:
case KN_TWOHANDQUICKEN: case KN_TWOHANDQUICKEN:
@ -7911,9 +7929,9 @@ int skill_castend_nodamage_id (struct block_list *src, struct block_list *bl, ui
case MER_QUICKEN: case MER_QUICKEN:
case CR_SPEARQUICKEN: case CR_SPEARQUICKEN:
case AS_POISONREACT: case AS_POISONREACT:
#ifndef RENEWAL #ifndef RENEWAL
case MC_LOUD: case MC_LOUD:
#endif #endif
case MG_ENERGYCOAT: case MG_ENERGYCOAT:
case MO_EXPLOSIONSPIRITS: case MO_EXPLOSIONSPIRITS:
case MO_STEELBODY: case MO_STEELBODY:
@ -7922,9 +7940,9 @@ int skill_castend_nodamage_id (struct block_list *src, struct block_list *bl, ui
case LK_PARRYING: case LK_PARRYING:
case MS_PARRYING: case MS_PARRYING:
case LK_CONCENTRATION: case LK_CONCENTRATION:
#ifdef RENEWAL #ifdef RENEWAL
case HP_BASILICA: case HP_BASILICA:
#endif #endif
case WS_CARTBOOST: case WS_CARTBOOST:
case SN_SIGHT: case SN_SIGHT:
case WS_MELTDOWN: case WS_MELTDOWN:
@ -7940,9 +7958,9 @@ int skill_castend_nodamage_id (struct block_list *src, struct block_list *bl, ui
case GS_MADNESSCANCEL: case GS_MADNESSCANCEL:
case GS_ADJUSTMENT: case GS_ADJUSTMENT:
case GS_INCREASING: case GS_INCREASING:
#ifdef RENEWAL #ifdef RENEWAL
case GS_MAGICALBULLET: case GS_MAGICALBULLET:
#endif #endif
case NJ_KASUMIKIRI: case NJ_KASUMIKIRI:
case NJ_UTSUSEMI: case NJ_UTSUSEMI:
case NJ_NEN: case NJ_NEN:
@ -8044,11 +8062,11 @@ int skill_castend_nodamage_id (struct block_list *src, struct block_list *bl, ui
case ASC_EDP: case ASC_EDP:
clif_skill_nodamage(src,bl,skill_id,skill_lv, clif_skill_nodamage(src,bl,skill_id,skill_lv,
sc_start(src,bl,type,100,skill_lv,skill_get_time(skill_id,skill_lv))); sc_start(src,bl,type,100,skill_lv,skill_get_time(skill_id,skill_lv)));
#ifdef RENEWAL #ifdef RENEWAL
sc_start4(src, src, SC_SUB_WEAPONPROPERTY, 100, ELE_POISON, 25, skill_id, 0, skill_get_time(skill_id, skill_lv)); sc_start4(src, src, SC_SUB_WEAPONPROPERTY, 100, ELE_POISON, 25, skill_id, 0, skill_get_time(skill_id, skill_lv));
#else #else
sc_start4(src, src, SC_WATK_ELEMENT, 100, ELE_POISON, 25, 0, 0, skill_get_time(skill_id, skill_lv)); sc_start4(src, src, SC_WATK_ELEMENT, 100, ELE_POISON, 25, 0, 0, skill_get_time(skill_id, skill_lv));
#endif #endif
break; break;
case LG_SHIELDSPELL: case LG_SHIELDSPELL:
@ -8247,7 +8265,7 @@ int skill_castend_nodamage_id (struct block_list *src, struct block_list *bl, ui
sc_start(src,bl,type,100,skill_lv,skill_get_time(skill_id,skill_lv))); sc_start(src,bl,type,100,skill_lv,skill_get_time(skill_id,skill_lv)));
status_change_end(bl, SC_NEN); status_change_end(bl, SC_NEN);
break; break;
/* Was modified to only affect targetted char. [Skotlex] /* Was modified to only affect targetted char. [Skotlex]
case HP_ASSUMPTIO: case HP_ASSUMPTIO:
if (flag&1) if (flag&1)
sc_start(bl,type,100,skill_lv,skill_get_time(skill_id,skill_lv)); sc_start(bl,type,100,skill_lv,skill_get_time(skill_id,skill_lv));
@ -8260,7 +8278,7 @@ int skill_castend_nodamage_id (struct block_list *src, struct block_list *bl, ui
clif_skill_nodamage(src,bl,skill_id,skill_lv,1); clif_skill_nodamage(src,bl,skill_id,skill_lv,1);
} }
break; break;
*/ */
case SM_ENDURE: case SM_ENDURE:
clif_skill_nodamage(src,bl,skill_id,skill_lv, clif_skill_nodamage(src,bl,skill_id,skill_lv,
sc_start(src,bl,type,100,skill_lv,skill_get_time(skill_id,skill_lv))); sc_start(src,bl,type,100,skill_lv,skill_get_time(skill_id,skill_lv)));
@ -8328,7 +8346,6 @@ int skill_castend_nodamage_id (struct block_list *src, struct block_list *bl, ui
} }
break; break;
case SM_PROVOKE:
case SM_SELFPROVOKE: case SM_SELFPROVOKE:
case MER_PROVOKE: case MER_PROVOKE:
if( status_has_mode(tstatus,MD_STATUSIMMUNE) || battle_check_undead(tstatus->race,tstatus->def_ele) ) { if( status_has_mode(tstatus,MD_STATUSIMMUNE) || battle_check_undead(tstatus->race,tstatus->def_ele) ) {
@ -8740,11 +8757,11 @@ int skill_castend_nodamage_id (struct block_list *src, struct block_list *bl, ui
case NPC_IGNITIONBREAK: case NPC_IGNITIONBREAK:
case RK_IGNITIONBREAK: case RK_IGNITIONBREAK:
skill_area_temp[1] = 0; skill_area_temp[1] = 0;
#if PACKETVER >= 20180207 #if PACKETVER >= 20180207
clif_skill_nodamage(src,bl,skill_id,skill_lv,1); clif_skill_nodamage(src,bl,skill_id,skill_lv,1);
#else #else
clif_skill_damage(src, src, tick, status_get_amotion(src), 0, -30000, 1, skill_id, skill_lv, DMG_SINGLE); clif_skill_damage(src, src, tick, status_get_amotion(src), 0, -30000, 1, skill_id, skill_lv, DMG_SINGLE);
#endif #endif
map_foreachinrange(skill_area_sub, bl, skill_get_splash(skill_id, skill_lv), BL_CHAR|BL_SKILL, src, skill_id, skill_lv, tick, flag|BCT_ENEMY|SD_SPLASH|1, skill_castend_damage_id); map_foreachinrange(skill_area_sub, bl, skill_get_splash(skill_id, skill_lv), BL_CHAR|BL_SKILL, src, skill_id, skill_lv, tick, flag|BCT_ENEMY|SD_SPLASH|1, skill_castend_damage_id);
break; break;
@ -8764,16 +8781,16 @@ int skill_castend_nodamage_id (struct block_list *src, struct block_list *bl, ui
skill_castend_damage_id(src, src, skill_id, skill_lv, tick, flag); skill_castend_damage_id(src, src, skill_id, skill_lv, tick, flag);
break; break;
#ifdef RENEWAL #ifdef RENEWAL
case KN_BRANDISHSPEAR: case KN_BRANDISHSPEAR:
map_foreachindir(skill_area_sub, src->m, src->x, src->y, bl->x, bl->y, map_foreachindir(skill_area_sub, src->m, src->x, src->y, bl->x, bl->y,
skill_get_splash(skill_id, skill_lv), skill_get_maxcount(skill_id, skill_lv), 0, splash_target(src), skill_get_splash(skill_id, skill_lv), skill_get_maxcount(skill_id, skill_lv), 0, splash_target(src),
src, skill_id, skill_lv, tick, flag | BCT_ENEMY | 0, src, skill_id, skill_lv, tick, flag | BCT_ENEMY | 0,
skill_castend_damage_id); skill_castend_damage_id);
break; break;
#else #else
case KN_BRANDISHSPEAR: case KN_BRANDISHSPEAR:
#endif #endif
case ML_BRANDISH: case ML_BRANDISH:
skill_area_temp[1] = bl->id; skill_area_temp[1] = bl->id;
@ -8842,10 +8859,10 @@ int skill_castend_nodamage_id (struct block_list *src, struct block_list *bl, ui
} }
break; break;
case AL_ANGELUS: case AL_ANGELUS:
#ifdef RENEWAL #ifdef RENEWAL
case PR_SUFFRAGIUM: case PR_SUFFRAGIUM:
case PR_IMPOSITIO: case PR_IMPOSITIO:
#endif #endif
case PR_MAGNIFICAT: case PR_MAGNIFICAT:
case PR_GLORIA: case PR_GLORIA:
if (sd == nullptr || sd->status.party_id == 0 || (flag & 1)) { if (sd == nullptr || sd->status.party_id == 0 || (flag & 1)) {
@ -8859,9 +8876,9 @@ int skill_castend_nodamage_id (struct block_list *src, struct block_list *bl, ui
else if (sd) else if (sd)
party_foreachsamemap(skill_area_sub, sd, skill_get_splash(skill_id, skill_lv), src, skill_id, skill_lv, tick, flag | BCT_PARTY | 1, skill_castend_nodamage_id); party_foreachsamemap(skill_area_sub, sd, skill_get_splash(skill_id, skill_lv), src, skill_id, skill_lv, tick, flag | BCT_PARTY | 1, skill_castend_nodamage_id);
break; break;
#ifdef RENEWAL #ifdef RENEWAL
case MC_LOUD: case MC_LOUD:
#endif #endif
case SN_WINDWALK: case SN_WINDWALK:
case CASH_BLESSING: case CASH_BLESSING:
case CASH_INCAGI: case CASH_INCAGI:
@ -9034,15 +9051,15 @@ int skill_castend_nodamage_id (struct block_list *src, struct block_list *bl, ui
break; break;
case BD_ADAPTATION: case BD_ADAPTATION:
#ifdef RENEWAL #ifdef RENEWAL
clif_skill_nodamage(src, bl, skill_id, skill_lv, 1); clif_skill_nodamage(src, bl, skill_id, skill_lv, 1);
sc_start(src, bl, type, 100, skill_lv, skill_get_time(skill_id, skill_lv)); sc_start(src, bl, type, 100, skill_lv, skill_get_time(skill_id, skill_lv));
#else #else
if(tsc && tsc->getSCE(SC_DANCING)){ if(tsc && tsc->getSCE(SC_DANCING)){
clif_skill_nodamage(src,bl,skill_id,skill_lv,1); clif_skill_nodamage(src,bl,skill_id,skill_lv,1);
status_change_end(bl, SC_DANCING); status_change_end(bl, SC_DANCING);
} }
#endif #endif
break; break;
case BA_FROSTJOKER: case BA_FROSTJOKER:
@ -9061,17 +9078,17 @@ int skill_castend_nodamage_id (struct block_list *src, struct block_list *bl, ui
case BA_PANGVOICE: case BA_PANGVOICE:
clif_skill_nodamage(src,bl,skill_id,skill_lv, sc_start(src,bl,SC_CONFUSION,70,7,skill_get_time(skill_id,skill_lv))); clif_skill_nodamage(src,bl,skill_id,skill_lv, sc_start(src,bl,SC_CONFUSION,70,7,skill_get_time(skill_id,skill_lv)));
#ifdef RENEWAL #ifdef RENEWAL
sc_start(src, bl, SC_BLEEDING, 30, skill_lv, skill_get_time2(skill_id, skill_lv)); // TODO: Confirm success rate sc_start(src, bl, SC_BLEEDING, 30, skill_lv, skill_get_time2(skill_id, skill_lv)); // TODO: Confirm success rate
#endif #endif
break; break;
case DC_WINKCHARM: case DC_WINKCHARM:
if( dstsd ) { if( dstsd ) {
clif_skill_nodamage(src,bl,skill_id,skill_lv, sc_start(src,bl,SC_CONFUSION,10,7,skill_get_time2(skill_id,skill_lv))); clif_skill_nodamage(src,bl,skill_id,skill_lv, sc_start(src,bl,SC_CONFUSION,10,7,skill_get_time2(skill_id,skill_lv)));
#ifdef RENEWAL #ifdef RENEWAL
sc_start(src, bl, SC_HALLUCINATION, 30, skill_lv, skill_get_time(skill_id, skill_lv)); // TODO: Confirm success rate and duration sc_start(src, bl, SC_HALLUCINATION, 30, skill_lv, skill_get_time(skill_id, skill_lv)); // TODO: Confirm success rate and duration
#endif #endif
} else } else
if( dstmd ) if( dstmd )
{ {
@ -9087,7 +9104,7 @@ int skill_castend_nodamage_id (struct block_list *src, struct block_list *bl, ui
} }
break; break;
#ifdef RENEWAL #ifdef RENEWAL
case BD_LULLABY: case BD_LULLABY:
case BD_RICHMANKIM: case BD_RICHMANKIM:
case BD_ETERNALCHAOS: case BD_ETERNALCHAOS:
@ -9108,7 +9125,7 @@ int skill_castend_nodamage_id (struct block_list *src, struct block_list *bl, ui
case DC_SERVICEFORYOU: case DC_SERVICEFORYOU:
skill_castend_song(src, skill_id, skill_lv, tick); skill_castend_song(src, skill_id, skill_lv, tick);
break; break;
#endif #endif
case TF_STEAL: case TF_STEAL:
if(sd) { if(sd) {
@ -9543,10 +9560,10 @@ int skill_castend_nodamage_id (struct block_list *src, struct block_list *bl, ui
} }
} }
#ifdef RENEWAL #ifdef RENEWAL
if (bl->type == BL_HOM) if (bl->type == BL_HOM)
hp *= 3; // Heal effectiveness is 3x for Homunculus hp *= 3; // Heal effectiveness is 3x for Homunculus
#endif #endif
clif_skill_nodamage(src,bl,skill_id,skill_lv,1); clif_skill_nodamage(src,bl,skill_id,skill_lv,1);
if( hp > 0 || (skill_id == AM_POTIONPITCHER && sp <= 0) ) if( hp > 0 || (skill_id == AM_POTIONPITCHER && sp <= 0) )
@ -9554,10 +9571,10 @@ int skill_castend_nodamage_id (struct block_list *src, struct block_list *bl, ui
if( sp > 0 ) if( sp > 0 )
clif_skill_nodamage(nullptr,bl,MG_SRECOVERY,sp,1); clif_skill_nodamage(nullptr,bl,MG_SRECOVERY,sp,1);
if (tsc) { if (tsc) {
#ifdef RENEWAL #ifdef RENEWAL
if (tsc->getSCE(SC_EXTREMITYFIST)) if (tsc->getSCE(SC_EXTREMITYFIST))
sp = 0; sp = 0;
#endif #endif
if (tsc->getSCE(SC_NORECOVER_STATE)) { if (tsc->getSCE(SC_NORECOVER_STATE)) {
hp = 0; hp = 0;
sp = 0; sp = 0;
@ -9683,17 +9700,17 @@ int skill_castend_nodamage_id (struct block_list *src, struct block_list *bl, ui
case TF_BACKSLIDING: //This is the correct implementation as per packet logging information. [Skotlex] case TF_BACKSLIDING: //This is the correct implementation as per packet logging information. [Skotlex]
{ {
short blew_count = skill_blown(src,bl,skill_get_blewcount(skill_id,skill_lv),unit_getdir(bl),(enum e_skill_blown)(BLOWN_IGNORE_NO_KNOCKBACK short blew_count = skill_blown(src,bl,skill_get_blewcount(skill_id,skill_lv),unit_getdir(bl),(enum e_skill_blown)(BLOWN_IGNORE_NO_KNOCKBACK
#ifdef RENEWAL #ifdef RENEWAL
|BLOWN_DONT_SEND_PACKET |BLOWN_DONT_SEND_PACKET
#endif #endif
)); ));
clif_skill_nodamage(src, bl, skill_id, skill_lv, 1); clif_skill_nodamage(src, bl, skill_id, skill_lv, 1);
#ifdef RENEWAL #ifdef RENEWAL
if(blew_count > 0) if(blew_count > 0)
clif_blown(src); // Always blow, otherwise it shows a casting animation. [Lemongrass] clif_blown(src); // Always blow, otherwise it shows a casting animation. [Lemongrass]
#else #else
clif_slide(bl, bl->x, bl->y); //Show the casting animation on pre-re clif_slide(bl, bl->x, bl->y); //Show the casting animation on pre-re
#endif #endif
} }
break; break;
@ -9764,9 +9781,9 @@ int skill_castend_nodamage_id (struct block_list *src, struct block_list *bl, ui
break; break;
} }
} }
#ifdef RENEWAL #ifdef RENEWAL
else // HP damage does not work on bosses in renewal else // HP damage does not work on bosses in renewal
#endif #endif
if (skill_lv >= 5 && (!dstsd || map_flag_vs(bl->m))) //HP damage only on pvp-maps when against players. if (skill_lv >= 5 && (!dstsd || map_flag_vs(bl->m))) //HP damage only on pvp-maps when against players.
hp = tstatus->max_hp / 50; //Siphon 2% HP at level 5 hp = tstatus->max_hp / 50; //Siphon 2% HP at level 5
@ -9788,9 +9805,9 @@ int skill_castend_nodamage_id (struct block_list *src, struct block_list *bl, ui
} }
break; break;
case SA_MAGICROD: case SA_MAGICROD:
#ifdef RENEWAL #ifdef RENEWAL
clif_skill_nodamage(src,src,SA_MAGICROD,skill_lv,1); clif_skill_nodamage(src,src,SA_MAGICROD,skill_lv,1);
#endif #endif
sc_start(src,bl,type,100,skill_lv,skill_get_time(skill_id,skill_lv)); sc_start(src,bl,type,100,skill_lv,skill_get_time(skill_id,skill_lv));
break; break;
case SA_AUTOSPELL: case SA_AUTOSPELL:
@ -9804,9 +9821,9 @@ int skill_castend_nodamage_id (struct block_list *src, struct block_list *bl, ui
if(skill_lv >= 10) { if(skill_lv >= 10) {
spellid = MG_FROSTDIVER; spellid = MG_FROSTDIVER;
// if (tsc && tsc->getSCE(SC_SPIRIT) && tsc->getSCE(SC_SPIRIT)->val2 == SA_SAGE) // if (tsc && tsc->getSCE(SC_SPIRIT) && tsc->getSCE(SC_SPIRIT)->val2 == SA_SAGE)
// maxlv = 10; // maxlv = 10;
// else // else
maxlv = skill_lv - 9; maxlv = skill_lv - 9;
} }
else if(skill_lv >=8) { else if(skill_lv >=8) {
@ -10247,9 +10264,9 @@ int skill_castend_nodamage_id (struct block_list *src, struct block_list *bl, ui
case AS_SPLASHER: case AS_SPLASHER:
if( status_has_mode(tstatus,MD_STATUSIMMUNE) if( status_has_mode(tstatus,MD_STATUSIMMUNE)
// Renewal dropped the 3/4 hp requirement // Renewal dropped the 3/4 hp requirement
#ifndef RENEWAL #ifndef RENEWAL
|| tstatus-> hp > tstatus->max_hp*3/4 || tstatus-> hp > tstatus->max_hp*3/4
#endif #endif
) { ) {
if (sd) clif_skill_fail( *sd, skill_id ); if (sd) clif_skill_fail( *sd, skill_id );
map_freeblock_unlock(); map_freeblock_unlock();
@ -10305,12 +10322,12 @@ int skill_castend_nodamage_id (struct block_list *src, struct block_list *bl, ui
} }
sp1 = sstatus->sp; sp1 = sstatus->sp;
sp2 = tstatus->sp; sp2 = tstatus->sp;
#ifdef RENEWAL #ifdef RENEWAL
sp1 = sp1 / 2; sp1 = sp1 / 2;
sp2 = sp2 / 2; sp2 = sp2 / 2;
if (tsc && tsc->getSCE(SC_EXTREMITYFIST)) if (tsc && tsc->getSCE(SC_EXTREMITYFIST))
sp1 = tstatus->sp; sp1 = tstatus->sp;
#endif #endif
if (tsc && tsc->getSCE(SC_NORECOVER_STATE)) if (tsc && tsc->getSCE(SC_NORECOVER_STATE))
sp1 = tstatus->sp; sp1 = tstatus->sp;
status_set_sp(src, sp2, 3); status_set_sp(src, sp2, 3);
@ -10384,7 +10401,7 @@ int skill_castend_nodamage_id (struct block_list *src, struct block_list *bl, ui
clif_skill_nodamage(src,bl,skill_id,skill_lv,1); clif_skill_nodamage(src,bl,skill_id,skill_lv,1);
break; break;
#ifndef RENEWAL #ifndef RENEWAL
case CG_LONGINGFREEDOM: case CG_LONGINGFREEDOM:
{ {
if (tsc && !tsce && (tsce=tsc->getSCE(SC_DANCING)) && tsce->val4 if (tsc && !tsce && (tsce=tsc->getSCE(SC_DANCING)) && tsce->val4
@ -10395,7 +10412,7 @@ int skill_castend_nodamage_id (struct block_list *src, struct block_list *bl, ui
} }
} }
break; break;
#endif #endif
case CG_TAROTCARD: case CG_TAROTCARD:
{ {
@ -10406,9 +10423,9 @@ int skill_castend_nodamage_id (struct block_list *src, struct block_list *bl, ui
return 0; return 0;
} }
if( rnd() % 100 > skill_lv * 8 || if( rnd() % 100 > skill_lv * 8 ||
#ifndef RENEWAL #ifndef RENEWAL
(tsc && tsc->getSCE(SC_BASILICA)) || (tsc && tsc->getSCE(SC_BASILICA)) ||
#endif #endif
(dstmd && ((dstmd->guardian_data && dstmd->mob_id == MOBID_EMPERIUM) || status_get_class_(bl) == CLASS_BATTLEFIELD)) ) { (dstmd && ((dstmd->guardian_data && dstmd->mob_id == MOBID_EMPERIUM) || status_get_class_(bl) == CLASS_BATTLEFIELD)) ) {
if( sd ) if( sd )
clif_skill_fail( *sd, skill_id ); clif_skill_fail( *sd, skill_id );
@ -10523,11 +10540,11 @@ int skill_castend_nodamage_id (struct block_list *src, struct block_list *bl, ui
src,skill_id,skill_lv,tick, flag|BCT_GUILD|1, src,skill_id,skill_lv,tick, flag|BCT_GUILD|1,
skill_castend_nodamage_id); skill_castend_nodamage_id);
if (sd) if (sd)
#ifdef RENEWAL #ifdef RENEWAL
skill_blockpc_start(sd, skill_id, skill_get_cooldown(skill_id, skill_lv)); skill_blockpc_start(sd, skill_id, skill_get_cooldown(skill_id, skill_lv));
#else #else
guild_block_skill(sd, skill_get_time2(skill_id, skill_lv)); guild_block_skill(sd, skill_get_time2(skill_id, skill_lv));
#endif #endif
} }
break; break;
case GD_EMERGENCYCALL: case GD_EMERGENCYCALL:
@ -10565,11 +10582,11 @@ int skill_castend_nodamage_id (struct block_list *src, struct block_list *bl, ui
} }
} }
if (sd) if (sd)
#ifdef RENEWAL #ifdef RENEWAL
skill_blockpc_start(sd, skill_id, skill_get_cooldown(skill_id, skill_lv)); skill_blockpc_start(sd, skill_id, skill_get_cooldown(skill_id, skill_lv));
#else #else
guild_block_skill(sd, skill_get_time2(skill_id, skill_lv)); guild_block_skill(sd, skill_get_time2(skill_id, skill_lv));
#endif #endif
} }
break; break;
case GD_CHARGESHOUT_FLAG: case GD_CHARGESHOUT_FLAG:
@ -10659,10 +10676,10 @@ int skill_castend_nodamage_id (struct block_list *src, struct block_list *bl, ui
case AM_CALLHOMUN: //[orn] case AM_CALLHOMUN: //[orn]
if (sd && !hom_call(sd)) if (sd && !hom_call(sd))
clif_skill_fail( *sd, skill_id ); clif_skill_fail( *sd, skill_id );
#ifdef RENEWAL #ifdef RENEWAL
else if (sd && hom_is_active(sd->hd)) else if (sd && hom_is_active(sd->hd))
skill_area_temp[0] = 1; // Already passed pre-cast checks skill_area_temp[0] = 1; // Already passed pre-cast checks
#endif #endif
break; break;
case AM_REST: case AM_REST:
@ -12335,11 +12352,11 @@ int skill_castend_nodamage_id (struct block_list *src, struct block_list *bl, ui
case MH_SILENT_BREEZE: case MH_SILENT_BREEZE:
{ {
int heal = 5 * status_get_lv(&hd->bl) + int heal = 5 * status_get_lv(&hd->bl) +
#ifdef RENEWAL #ifdef RENEWAL
status_base_matk_min(bl, &hd->battle_status, status_get_lv(&hd->bl)); status_base_matk_min(bl, &hd->battle_status, status_get_lv(&hd->bl));
#else #else
status_base_matk_min(&hd->battle_status); status_base_matk_min(&hd->battle_status);
#endif #endif
//Silences the homunculus and target //Silences the homunculus and target
status_change_start(src,src,SC_SILENCE,10000,skill_lv,0,0,0,skill_get_time(skill_id,skill_lv),SCSTART_NONE); status_change_start(src,src,SC_SILENCE,10000,skill_lv,0,0,0,skill_get_time(skill_id,skill_lv),SCSTART_NONE);
status_change_start(src,bl,SC_SILENCE,10000,skill_lv,0,0,0,skill_get_time(skill_id,skill_lv),SCSTART_NONE); status_change_start(src,bl,SC_SILENCE,10000,skill_lv,0,0,0,skill_get_time(skill_id,skill_lv),SCSTART_NONE);
@ -12903,11 +12920,11 @@ int skill_castend_nodamage_id (struct block_list *src, struct block_list *bl, ui
} }
break; break;
#ifdef RENEWAL #ifdef RENEWAL
case CG_HERMODE: case CG_HERMODE:
skill_castend_song(src, skill_id, skill_lv, tick); skill_castend_song(src, skill_id, skill_lv, tick);
break; break;
#endif #endif
case NPC_LEASH: case NPC_LEASH:
clif_skill_nodamage( src, bl, skill_id, skill_lv, 1 ); clif_skill_nodamage( src, bl, skill_id, skill_lv, 1 );
@ -12994,6 +13011,8 @@ int skill_castend_nodamage_id (struct block_list *src, struct block_list *bl, ui
return 1; return 1;
} }
} }
}
if (skill_id != SR_CURSEDCIRCLE && skill_id != NPC_SR_CURSEDCIRCLE) { if (skill_id != SR_CURSEDCIRCLE && skill_id != NPC_SR_CURSEDCIRCLE) {
if (sc && sc->getSCE(SC_CURSEDCIRCLE_ATKER)) // Should only remove after the skill had been casted. if (sc && sc->getSCE(SC_CURSEDCIRCLE_ATKER)) // Should only remove after the skill had been casted.
@ -25344,6 +25363,8 @@ void do_init_skill(void)
{ {
skill_readdb(); skill_readdb();
init_skill_repository();
skillunit_db = idb_alloc(DB_OPT_BASE); skillunit_db = idb_alloc(DB_OPT_BASE);
skillusave_db = idb_alloc(DB_OPT_RELEASE_DATA); skillusave_db = idb_alloc(DB_OPT_RELEASE_DATA);
bowling_db = idb_alloc(DB_OPT_BASE); bowling_db = idb_alloc(DB_OPT_BASE);

41
src/map/skills/main.cpp
View File

@ -1,41 +0,0 @@
#include "skill.hpp"
#include "skills.hpp"
// #include "swordsman/bash.hpp"
// #include "swordsman/provoke.hpp"
#include "skilllist.hpp"
int main() {
constexpr int skill_id = SM_BASH;
const auto &sk = skill_db.at(static_cast<e_skill>(skill_id));
const SkillImpl sk2 = Bash{};
std::visit([](auto &skill) {
skill.getSkillID();
skill.castend_damage_id(); // error
// skill.hpp:19:26: error: ‘const class Provoke’ has no member named ‘castendDamageId’; did you mean ‘castendNoDamageId’?
// 19 | return as_underlying().castendDamageId();
// | ~~~~~~~~~~~~~~~~^~~~~~~~~~~~~~~
// | castendNoDamageId
}, sk2);
for (auto &it : skill_db) {
std::visit([](auto &skill) {
skill.getSkillID();
// skill.castend_damage_id();
}, it.second);
}
return 0;
}

53
src/map/skills/skill.cpp Normal file
View File

@ -0,0 +1,53 @@
// Copyright (c) rAthena Dev Teams - Licensed under GNU GPL
// For more information, see LICENCE in the main folder
#include <common/showmsg.hpp>
#include "skill.hpp"
#include "map/battle.hpp"
#include "map/skill.hpp"
#include "map/clif.hpp"
#include "map/map.hpp"
#include "map/status.hpp"
uint16_t Skill::getSkillId() const {
return skill_id_;
}
int Skill::castendDamageImpl(block_list *src, block_list *target, uint16 skill_lv, t_tick tick, int flag) const {
throw SkillNotImplementedException(skill_id_);
}
int Skill::castendNoDamageImpl(block_list *src, block_list *target, uint16 skill_lv, t_tick tick, int flag) const {
throw SkillNotImplementedException(skill_id_);
}
int Skill::castendPositionImpl() const {
throw SkillNotImplementedException(skill_id_);
}
int Skill::castendDamage(block_list *src, block_list *target, uint16 skill_lv, t_tick tick, int flag) const {
try {
return castendDamageImpl(src, target, skill_lv, tick, flag);
} catch (SkillNotImplementedException e) {
ShowWarning("castendDamage: %s\n", e.what());
clif_skill_damage(src, target, tick, status_get_amotion(src), status_get_status_data(target)->dmotion, 0, abs(skill_get_num(skill_id_, skill_lv)), skill_id_, skill_lv, skill_get_hit(skill_id_));
return 1;
}
}
int Skill::castendNoDamage(block_list *src, block_list *target, uint16 skill_lv, t_tick tick, int flag) const {
try {
return castendNoDamageImpl(src, target, skill_lv, tick, flag);
} catch (SkillNotImplementedException e) {
ShowWarning("castendNoDamage: %s\n", e.what());
clif_skill_damage(src, target, tick, status_get_amotion(src), status_get_status_data(target)->dmotion, 0, abs(skill_get_num(skill_id_, skill_lv)), skill_id_, skill_lv, skill_get_hit(skill_id_));
return 1;
}
}
int WeaponSkill::castendDamageImpl(block_list *src, block_list *target, uint16 skill_lv, t_tick tick, int flag) const {
skill_attack(BF_WEAPON, src, src, target, skill_id_, skill_lv, tick, flag);
return 0;
};

39
src/map/skills/skill.hpp
View File

@ -7,30 +7,37 @@
#include <array> #include <array>
#include <string> #include <string>
#include "skills.hpp" #include "map/skill.hpp"
constexpr int MAX_SKILL_LEVEL = 13;
class SkillNotImplementedException : public std::logic_error {
public:
explicit SkillNotImplementedException(const std::string &what_arg) : std::logic_error(what_arg) {};
explicit SkillNotImplementedException(uint16_t skill_id) : std::logic_error("Skill " + std::to_string(skill_id) + " not implemented") {};
};
class Skill { class Skill {
public: public:
virtual int castendDamageId() const; uint16_t getSkillId() const;
virtual int castendNodamageId() const;
virtual int castendPos2() const;
uint16_t getSkillID() const { virtual ~Skill() = default;
return nameid;
} explicit Skill(e_skill skillid) : skill_id_(static_cast<uint16_t>(skillid)) {};
int castendDamage(block_list *src, block_list *target, uint16 skill_lv, t_tick tick, int flag) const;
int castendNoDamage(block_list *src, block_list *target, uint16 skill_lv, t_tick tick, int flag) const;
protected: protected:
explicit Skill(e_skill skillid) : nameid(static_cast<uint16_t>(skillid)) {}; virtual int castendDamageImpl(block_list *src, block_list *target, uint16 skill_lv, t_tick tick, int flag) const;
private: virtual int castendNoDamageImpl(block_list *src, block_list *target, uint16 skill_lv, t_tick tick, int flag) const;
virtual int castendPositionImpl() const;
uint16_t nameid; uint16_t skill_id_;
std::string name;
std::string desc;
std::array<int32_t, MAX_SKILL_LEVEL> range;
}; };
class WeaponSkill : public Skill {
public:
explicit WeaponSkill(e_skill skill_id) : Skill(skill_id) {};
protected:
virtual int castendDamageImpl(block_list *src, block_list *target, uint16 skill_lv, t_tick tick, int flag) const override;
};
#endif // MAP_SKILL_HPP #endif // MAP_SKILL_HPP

15
src/map/skills/skilllist.hpp
View File

@ -1,15 +0,0 @@
#include <variant>
#include "skill.hpp"
#include "skills.hpp"
#include "swordsman/bash.hpp"
#include "swordsman/provoke.hpp"
using SkillImpl = std::variant<Bash, Provoke>;
std::unordered_map<e_skill, SkillImpl> skill_db = {
{ e_skill::SM_BASH, Bash{} },
{ e_skill::SM_PROVOKE, Provoke{} }
};

25
src/map/skills/skillrepository.cpp Normal file
View File

@ -0,0 +1,25 @@
// Copyright (c) rAthena Dev Teams - Licensed under GNU GPL
// For more information, see LICENCE in the main folder
#include "skillrepository.hpp"
#include "swordsman.hpp"
#include <memory>
SkillRepository skillRepository;
const Skill& SkillRepository::getSkill(e_skill skill_id) {
auto skill = skill_db_.find(skill_id);
if (skill == skill_db_.end()) {
throw SkillNotFoundException{};
}
return *skill->second;
}
void SkillRepository::addSkill(e_skill skill_id, std::unique_ptr<Skill> skill) {
skill_db_.emplace(skill_id, std::move(skill));
}
void init_skill_repository() {
init_swordsman_skills(skillRepository);
}

25
src/map/skills/skillrepository.hpp Normal file
View File

@ -0,0 +1,25 @@
// Copyright (c) rAthena Dev Teams - Licensed under GNU GPL
// For more information, see LICENCE in the main folder
#pragma once
#include <memory>
#include "skill.hpp"
#include "map/skill.hpp"
class SkillRepository {
public:
class SkillNotFoundException : public std::exception {};
const Skill& getSkill(e_skill skill_id);
void addSkill(e_skill skill_id, std::unique_ptr<Skill> skill);
private:
std::unordered_map<e_skill, std::unique_ptr<Skill>> skill_db_;
};
extern SkillRepository skillRepository;
void init_skill_repository();

1833
src/map/skills/skills.hpp
View File

File diff suppressed because it is too large Load Diff

56
src/map/skills/swordsman.cpp Normal file
View File

@ -0,0 +1,56 @@
#include "swordsman.hpp"
#include "skillrepository.hpp"
#include "map/battle.hpp"
#include "map/clif.hpp"
#include "map/mob.hpp"
#include "map/skill.hpp"
#include "map/status.hpp"
#include "map/unit.hpp"
Provoke::Provoke() : Skill(e_skill::SM_PROVOKE) {};
int Provoke::castendNoDamageImpl(block_list *src, block_list *target, uint16 skill_lv, t_tick tick, int flag) const {
status_data *target_status = status_get_status_data(target);
if (status_has_mode(target_status, MD_STATUSIMMUNE) || battle_check_undead(target_status->race, target_status->def_ele)) {
return 1;
}
map_session_data *sd = BL_CAST(BL_PC, src);
mob_data *target_md = BL_CAST(BL_MOB, target);
sc_type type = skill_get_sc(skill_id_);
// official chance is 70% + 3% per skill level + srcBaseLevel% - targetBaseLevel%
int chance = 70 + 3 * skill_lv + status_get_lv(src) - status_get_lv(target);
int i = sc_start(src, target, type, skill_id_ == SM_SELFPROVOKE ? 100 : chance, skill_lv, skill_get_time(skill_id_, skill_lv));
if (!i) {
if (sd) {
clif_skill_fail(*sd, skill_id_);
}
return 0;
}
clif_skill_nodamage(src, target, skill_id_ == SM_SELFPROVOKE ? SM_PROVOKE : skill_id_, skill_lv, i);
unit_skillcastcancel(target, 2);
if (target_md) {
target_md->state.provoke_flag = src->id;
mob_target(target_md, src, skill_get_range2(src, skill_id_, skill_lv, true));
}
// Provoke can cause Coma even though it's a nodamage skill
if (sd && battle_check_coma(*sd, *target, BF_MISC)) {
status_change_start(src, target, SC_COMA, 10000, skill_lv, 0, src->id, 0, 0, SCSTART_NONE);
}
return 0;
}
void init_swordsman_skills(SkillRepository& repo) {
repo.addSkill(e_skill::SM_BASH, std::make_unique<WeaponSkill>(e_skill::SM_BASH));
repo.addSkill(e_skill::SM_PROVOKE, std::make_unique<Provoke>());
}

12
src/map/skills/swordsman.hpp Normal file
View File

@ -0,0 +1,12 @@
#pragma once
#include "skillrepository.hpp"
class Provoke : public Skill {
public:
Provoke();
virtual int castendNoDamageImpl(block_list *src, block_list *target, uint16 skill_lv, t_tick tick, int flag) const override;
};
void init_swordsman_skills(SkillRepository& repo);

18
src/map/skills/swordsman/bash.hpp
View File

@ -1,18 +0,0 @@
#ifndef SKILLS_SWORDSMAN_BASH_HPP
#define SKILLS_SWORDSMAN_BASH_HPP
#include "../skill.hpp"
#include "../skills.hpp"
class Bash : public Skill {
public:
int castendDamageId() const {
skill_attack(BF_WEAPON,src,src,bl,skill_id,skill_lv,tick,flag);
};
Bash() : Skill(e_skill::SM_BASH) {};
};
#endif // SKILLS_SWORDSMAN_BASH_HPP

18
src/map/skills/swordsman/provoke.hpp
View File

@ -1,18 +0,0 @@
#ifndef SKILLS_SWORDSMAN_PROVOKE_HPP
#define SKILLS_SWORDSMAN_PROVOKE_HPP
#include "../skill.hpp"
class Provoke : public Skill {
public:
int castendNoDamageId() const {
return 0;
};
Provoke() : Skill(e_skill::SM_PROVOKE) {};
private:
};
#endif // SKILLS_SWORDSMAN_PROVOKE_HPP