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

Merge branch 'master' into hotfix/vanilmirth_skills

Browse Source
This commit is contained in:
Daegaladh 2024-09-16 20:46:54 +02:00 committed by GitHub
commit 13abe0c66b
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
33 changed files with 1212 additions and 973 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
conf/atcommands.yml
View File

@ -1032,6 +1032,11 @@ Body:
- Command: setcard
Help: |
Adds a card or enchant to the specific slot of the equipment.
- Command: resetcooltime
Aliases:
- resetcooldown
Help: |
Resets the cooldown of all skills of the player and if active also of the homunculus or the mercenary.
Footer:
Imports:

3
conf/msg_conf/map_msg.conf
View File

@ -1823,5 +1823,8 @@
1534: Usage: @stockall {<type>}
1535: %d items are transferred (%d skipped)!
1536: Log configuration has been reloaded.
1537: Found skill '%s', unblocking...
//Custom translations
import: conf/msg_conf/import/map_msg_eng_conf.txt

80
db/re/enchantgrade.yml
View File

@ -76,15 +76,15 @@ Body:
- Refine: 15
Chance: 7000
- Refine: 16
Chance: 7000
Chance: 8000
- Refine: 17
Chance: 7000
Chance: 8000
- Refine: 18
Chance: 7000
Chance: 8000
- Refine: 19
Chance: 7000
Chance: 8000
- Refine: 20
Chance: 7000
Chance: 8000
Bonus: 10
Catalyst:
Item: Blessed_Etel_Dust
@ -116,15 +116,15 @@ Body:
- Refine: 15
Chance: 6000
- Refine: 16
Chance: 6000
Chance: 7000
- Refine: 17
Chance: 6000
Chance: 7000
- Refine: 18
Chance: 6000
Chance: 7000
- Refine: 19
Chance: 6000
Chance: 7000
- Refine: 20
Chance: 6000
Chance: 7000
Bonus: 30
Catalyst:
Item: Blessed_Etel_Dust
@ -154,15 +154,15 @@ Body:
- Refine: 15
Chance: 5000
- Refine: 16
Chance: 5000
Chance: 6000
- Refine: 17
Chance: 5000
Chance: 6000
- Refine: 18
Chance: 5000
Chance: 6000
- Refine: 19
Chance: 5000
Chance: 6000
- Refine: 20
Chance: 5000
Chance: 6000
Bonus: 50
AnnounceFail: true
Catalyst:
@ -193,15 +193,15 @@ Body:
- Refine: 15
Chance: 4000
- Refine: 16
Chance: 4000
Chance: 5000
- Refine: 17
Chance: 4000
Chance: 5000
- Refine: 18
Chance: 4000
Chance: 5000
- Refine: 19
Chance: 4000
Chance: 5000
- Refine: 20
Chance: 4000
Chance: 5000
Bonus: 100
AnnounceFail: true
Catalyst:
@ -240,15 +240,15 @@ Body:
- Refine: 15
Chance: 7000
- Refine: 16
Chance: 7000
Chance: 8000
- Refine: 17
Chance: 7000
Chance: 8000
- Refine: 18
Chance: 7000
Chance: 8000
- Refine: 19
Chance: 7000
Chance: 8000
- Refine: 20
Chance: 7000
Chance: 8000
Bonus: 10
Catalyst:
Item: Blessed_Etel_Dust
@ -280,15 +280,15 @@ Body:
- Refine: 15
Chance: 6000
- Refine: 16
Chance: 6000
Chance: 7000
- Refine: 17
Chance: 6000
Chance: 7000
- Refine: 18
Chance: 6000
Chance: 7000
- Refine: 19
Chance: 6000
Chance: 7000
- Refine: 20
Chance: 6000
Chance: 7000
Bonus: 30
Catalyst:
Item: Blessed_Etel_Dust
@ -318,15 +318,15 @@ Body:
- Refine: 15
Chance: 5000
- Refine: 16
Chance: 5000
Chance: 6000
- Refine: 17
Chance: 5000
Chance: 6000
- Refine: 18
Chance: 5000
Chance: 6000
- Refine: 19
Chance: 5000
Chance: 6000
- Refine: 20
Chance: 5000
Chance: 6000
Bonus: 50
AnnounceFail: true
Catalyst:
@ -357,15 +357,15 @@ Body:
- Refine: 15
Chance: 4000
- Refine: 16
Chance: 4000
Chance: 5000
- Refine: 17
Chance: 4000
Chance: 5000
- Refine: 18
Chance: 4000
Chance: 5000
- Refine: 19
Chance: 4000
Chance: 5000
- Refine: 20
Chance: 4000
Chance: 5000
Bonus: 100
AnnounceFail: true
Catalyst:

8
db/re/item_db_equip.yml
View File

@ -83053,7 +83053,7 @@ Body:
Hunter: true
Rogue: true
Locations:
Right_Hand: true
Both_Hand: true
WeaponLevel: 4
EquipLevelMin: 70
Refineable: true
@ -139532,7 +139532,7 @@ Body:
AegisName: Ein_BHAXE
Name: Saw Axe
Type: Weapon
SubType: 1hAxe
SubType: 2hAxe
Weight: 5000
Attack: 350
Range: 1
@ -169197,6 +169197,8 @@ Body:
Defense: 12
Slots: 1
Jobs:
Crusader: true
Knight: true
Swordman: true
Classes:
All_Upper: true
@ -169217,6 +169219,8 @@ Body:
Defense: 12
Slots: 1
Jobs:
Crusader: true
Knight: true
Swordman: true
Classes:
All_Upper: true

3
db/re/status.yml
View File

@ -7022,7 +7022,9 @@ Body:
CalcFlags:
Regen: true
- Status: Earthshaker
Icon: EFST_EARTHSHAKER
Flags:
BlEffect: true
NoWarning: true
- Status: Weaponblock_On
Icon: EFST_WEAPONBLOCK_ON
@ -7037,6 +7039,7 @@ Body:
Icon: EFST_SPORE_EXPLOSION_DEBUFF
DurationLookup: GN_SPORE_EXPLOSION
Flags:
BlEffect: true
NoDispell: true
NoBanishingBuster: true
NoClearance: true

5
doc/atcommands.txt
View File

@ -1250,6 +1250,11 @@ Adds a card or enchant to the specific slot of the equipment.
---------------------------------------
@resetcooltime
/resetcooltime
Resets the cooldown of all skills of the player and if active also of the homunculus or the mercenary.
==============================
| 5. Administrative Commands |
==============================

4
npc/re/mobs/dungeons/slabw01.txt
View File

@ -5,9 +5,9 @@
//===== Additional Comments: =================================
//= 1.0 First version.
// Venomous Chimera spawn timer is custom. [Capuche]
//= 1.1 Updated Venomous Chimera spawn timer. [Capuche]
//============================================================
slabw01 monster Human Chimera 3631,45
slabw01 monster Material Chimera 3632,45
// unknown timer
slabw01 monster Venomous Chimera 3633,1,18000000,600000,0
slabw01 boss_monster Venomous Chimera 3633,1,3600000,600000,0

1
sql-files/main.sql
View File

@ -527,6 +527,7 @@ CREATE TABLE IF NOT EXISTS `guild_expulsion` (
`account_id` int(11) unsigned NOT NULL default '0',
`name` varchar(24) NOT NULL default '',
`mes` varchar(40) NOT NULL default '',
`char_id` int(11) unsigned NOT NULL default '0',
PRIMARY KEY (`guild_id`,`name`)
) ENGINE=MyISAM;

1
sql-files/upgrades/upgrade_20240914.sql Normal file
View File

@ -0,0 +1 @@
ALTER TABLE `guild_expulsion` ADD COLUMN `char_id` int(11) unsigned NOT NULL default '0';

2
src/char/char.cpp
View File

@ -2425,7 +2425,7 @@ bool char_checkdb(void){
return false;
}
//checking guild_expulsion_db
if( SQL_ERROR == Sql_Query(sql_handle, "SELECT `guild_id`,`account_id`,`name`,`mes` FROM `%s` LIMIT 1;", schema_config.guild_expulsion_db) ){
if( SQL_ERROR == Sql_Query(sql_handle, "SELECT `guild_id`,`account_id`,`name`,`mes`,`char_id` FROM `%s` LIMIT 1;", schema_config.guild_expulsion_db) ){
Sql_ShowDebug(sql_handle);
return false;
}

8
src/char/int_guild.cpp
View File

@ -308,8 +308,8 @@ int inter_guild_tosql( mmo_guild &g, int flag ){
Sql_EscapeStringLen(sql_handle, esc_name, e->name, strnlen(e->name, NAME_LENGTH));
Sql_EscapeStringLen(sql_handle, esc_mes, e->mes, strnlen(e->mes, sizeof(e->mes)));
if( SQL_ERROR == Sql_Query(sql_handle, "REPLACE INTO `%s` (`guild_id`,`account_id`,`name`,`mes`) "
"VALUES ('%d','%d','%s','%s')", schema_config.guild_expulsion_db, g.guild_id, e->account_id, esc_name, esc_mes) )
if( SQL_ERROR == Sql_Query(sql_handle, "REPLACE INTO `%s` (`guild_id`,`account_id`,`name`,`mes`,`char_id`) "
"VALUES ('%u','%u','%s','%s','%u')", schema_config.guild_expulsion_db, g.guild_id, e->account_id, esc_name, esc_mes, e->char_id) )
Sql_ShowDebug(sql_handle);
}
}
@ -487,7 +487,7 @@ std::shared_ptr<CharGuild> inter_guild_fromsql( int32 guild_id ){
}
//printf("- Read guild_expulsion %d from sql \n",guild_id);
if( SQL_ERROR == Sql_Query(sql_handle, "SELECT `account_id`,`name`,`mes` FROM `%s` WHERE `guild_id`='%d'", schema_config.guild_expulsion_db, guild_id) )
if( SQL_ERROR == Sql_Query(sql_handle, "SELECT `account_id`,`name`,`mes`,`char_id` FROM `%s` WHERE `guild_id`='%d'", schema_config.guild_expulsion_db, guild_id) )
{
Sql_ShowDebug(sql_handle);
return nullptr;
@ -499,6 +499,7 @@ std::shared_ptr<CharGuild> inter_guild_fromsql( int32 guild_id ){
Sql_GetData(sql_handle, 0, &data, nullptr); e->account_id = atoi(data);
Sql_GetData(sql_handle, 1, &data, &len); memcpy(e->name, data, zmin(len, NAME_LENGTH));
Sql_GetData(sql_handle, 2, &data, &len); memcpy(e->mes, data, zmin(len, sizeof(e->mes)));
Sql_GetData(sql_handle, 3, &data, nullptr); e->char_id = strtoul(data, nullptr, 10);
}
//printf("- Read guild_skill %d from sql \n",guild_id);
@ -1343,6 +1344,7 @@ int mapif_parse_GuildLeave(int fd, int guild_id, uint32 account_id, uint32 char_
}
// Save the expulsion entry
g->guild.expulsion[j].account_id = account_id;
g->guild.expulsion[j].char_id = char_id;
safestrncpy(g->guild.expulsion[j].name, g->guild.member[i].name, NAME_LENGTH);
safestrncpy(g->guild.expulsion[j].mes, mes, 40);
}

1
src/common/mmo.hpp
View File

@ -741,6 +741,7 @@ struct guild_expulsion {
char name[NAME_LENGTH];
char mes[40];
uint32 account_id;
uint32 char_id;
};
struct guild_skill {

57
src/map/atcommand.cpp
View File

@ -1150,6 +1150,51 @@ ACMD_FUNC(hide)
return 0;
}
ACMD_FUNC(resetcooltime)
{
nullpo_retr(-1, sd);
for( size_t i = 0; i < ARRAYLENGTH( sd->scd ); i++ ){
if( sd->scd[i] != nullptr ) {
sprintf( atcmd_output, msg_txt( sd, 1537 ), skill_db.find( sd->scd[i]->skill_id )->name ); // Found skill '%s', unblocking...
clif_displaymessage( sd->fd, atcmd_output );
if (battle_config.display_status_timers)
clif_skill_cooldown( *sd, sd->scd[i]->skill_id, 0 );
delete_timer(sd->scd[i]->timer, skill_blockpc_end);
aFree(sd->scd[i]);
sd->scd[i] = nullptr;
}
}
if( sd->hd != nullptr && hom_is_active( sd->hd ) ){
for( const uint16& skill_id : sd->hd->blockskill ){
sprintf( atcmd_output, msg_txt( sd, 1537 ), skill_db.find( skill_id )->name ); // Found skill '%s', unblocking...
clif_displaymessage( sd->fd, atcmd_output );
if (battle_config.display_status_timers)
clif_skill_cooldown( *sd, skill_id, 0 );
}
sd->hd->blockskill.clear();
}
if( sd->md != nullptr ){
for( const uint16& skill_id : sd->md->blockskill ){
sprintf( atcmd_output, msg_txt( sd, 1537 ), skill_db.find( skill_id )->name ); // Found skill '%s', unblocking...
clif_displaymessage( sd->fd, atcmd_output );
if (battle_config.display_status_timers)
clif_skill_cooldown( *sd, skill_id, 0 );
}
sd->md->blockskill.clear();
}
return 0;
}
/*==========================================
* Changes a character's class
*------------------------------------------*/
@ -1241,7 +1286,7 @@ ACMD_FUNC(alive)
clif_displaymessage(fd, msg_txt(sd,667)); // You're not dead.
return -1;
}
clif_skill_nodamage(&sd->bl,&sd->bl,ALL_RESURRECTION,4,1);
clif_skill_nodamage(&sd->bl,sd->bl,ALL_RESURRECTION,4);
clif_displaymessage(fd, msg_txt(sd,16)); // You've been revived! It's a miracle!
return 0;
}
@ -3547,7 +3592,7 @@ static void atcommand_raise_sub(map_session_data* sd) {
status_revive(&sd->bl, 100, 100);
clif_skill_nodamage(&sd->bl,&sd->bl,ALL_RESURRECTION,4,1);
clif_skill_nodamage(&sd->bl,sd->bl,ALL_RESURRECTION,4);
clif_displaymessage(sd->fd, msg_txt(sd,63)); // Mercy has been shown.
}
@ -3747,7 +3792,7 @@ ACMD_FUNC(lostskill)
sd->status.skill[sk_idx].lv = 0;
sd->status.skill[sk_idx].flag = SKILL_FLAG_PERMANENT;
clif_deleteskill(sd,skill_id);
clif_deleteskill(*sd,skill_id);
clif_displaymessage(fd, msg_txt(sd,71)); // You have forgotten the skill.
return 0;
@ -4330,6 +4375,9 @@ ACMD_FUNC(reload) {
}else if( strstr( command, "barterdb" ) || strncmp( message, "barterdb", 4 ) == 0 ){
barter_db.reload();
clif_displaymessage(fd, msg_txt(sd, 830)); // Barter database has been reloaded.
} else if (strstr(command, "logconf") || strncmp(message, "logconf", 3) == 0) {
log_config_read(LOG_CONF_NAME);
clif_displaymessage(fd, msg_txt(sd,1536)); // Log configuration has been reloaded.
}
return 0;
@ -6269,7 +6317,7 @@ ACMD_FUNC(displayskill)
if (type == 0 || type == 2)
clif_skill_damage(&sd->bl, &sd->bl, tick, status->amotion, status->dmotion, 1, 1, skill_id, skill_lv, DMG_SPLASH);
if (type == 0 || type == 3)
clif_skill_nodamage(&sd->bl, &sd->bl, skill_id, skill_lv, 1);
clif_skill_nodamage(&sd->bl, sd->bl, skill_id, skill_lv);
if (type == 0 || type == 4)
clif_skill_poseffect(&sd->bl, skill_id, skill_lv, sd->bl.x, sd->bl.y, tick);
return 0;
@ -11016,6 +11064,7 @@ void atcommand_basecommands(void) {
ACMD_DEF(guildstorage),
ACMD_DEF(option),
ACMD_DEF(hide), // + /hide
ACMD_DEF(resetcooltime), // + /resetcooltime
ACMD_DEFR(jobchange, ATCMD_NOCONSOLE),
ACMD_DEF(kill),
ACMD_DEF(alive),

16
src/map/battle.cpp
View File

@ -1290,7 +1290,7 @@ bool battle_status_block_damage(struct block_list *src, struct block_list *targe
// Weapon Blocking can be triggered while the above statuses are active.
if ((sce = sc->getSCE(SC_WEAPONBLOCKING)) && flag & (BF_SHORT | BF_WEAPON) && rnd() % 100 < sce->val2) {
clif_skill_nodamage(target, src, GC_WEAPONBLOCKING, sce->val1, 1);
clif_skill_nodamage(target, *src, GC_WEAPONBLOCKING, sce->val1);
sc_start(src, target, SC_WEAPONBLOCK_ON, 100, src->id, skill_get_time2(GC_WEAPONBLOCKING, sce->val1));
d->dmg_lv = ATK_BLOCK;
return false;
@ -1407,12 +1407,12 @@ bool battle_status_block_damage(struct block_list *src, struct block_list *targe
(d_bl->type == BL_PC && ((TBL_PC*)d_bl)->devotion[sce_d->val2] == target->id)) &&
check_distance_bl(target, d_bl, sce_d->val3))
{ //If player is target of devotion, show guard effect on the devotion caster rather than the target
clif_skill_nodamage(d_bl, d_bl, CR_AUTOGUARD, sce->val1, 1);
clif_skill_nodamage(d_bl, *d_bl, CR_AUTOGUARD, sce->val1);
unit_set_walkdelay(d_bl, gettick(), delay, 1);
d->dmg_lv = ATK_MISS;
return false;
} else {
clif_skill_nodamage(target, target, CR_AUTOGUARD, sce->val1, 1);
clif_skill_nodamage(target, *target, CR_AUTOGUARD, sce->val1);
unit_set_walkdelay(target, gettick(), delay, 1);
#ifdef RENEWAL
if (sc->getSCE(SC_SHRINK))
@ -1455,7 +1455,7 @@ bool battle_status_block_damage(struct block_list *src, struct block_list *targe
return false;
if ((sce = sc->getSCE(SC_PARRYING)) && flag&BF_WEAPON && skill_id != WS_CARTTERMINATION && rnd() % 100 < sce->val2) {
clif_skill_nodamage(target, target, LK_PARRYING, sce->val1, 1);
clif_skill_nodamage(target, *target, LK_PARRYING, sce->val1);
if (skill_id == LK_PARRYING) {
unit_data *ud = unit_bl2ud(target);
@ -1471,7 +1471,7 @@ bool battle_status_block_damage(struct block_list *src, struct block_list *targe
if (sd && pc_issit(sd))
pc_setstand(sd, true); //Stand it to dodge.
clif_skill_nodamage(target, target, TK_DODGE, 1, 1);
clif_skill_nodamage(target, *target, TK_DODGE, 1);
sc_start4(src, target, SC_COMBO, 100, TK_JUMPKICK, src->id, 1, 0, 2000);
return false;
}
@ -6990,7 +6990,7 @@ static void battle_calc_weapon_final_atk_modifiers(struct Damage* wd, struct blo
)
{
ATK_RATER(wd->damage, 50)
clif_skill_nodamage(target,target,ST_REJECTSWORD, tsc->getSCE(SC_REJECTSWORD)->val1,1);
clif_skill_nodamage(target, *target,ST_REJECTSWORD, tsc->getSCE(SC_REJECTSWORD)->val1);
battle_fix_damage(target,src,wd->damage,clif_damage(*target,*src,gettick(),0,0,wd->damage,0,DMG_NORMAL,0,false),ST_REJECTSWORD);
if (status_isdead(*target))
return;
@ -9434,7 +9434,7 @@ struct Damage battle_calc_attack(int attack_type,struct block_list *bl,struct bl
status_change_entry *tsce = tsc->getSCE(SC_WEAPONBLOCKING);
if (attack_type == BF_WEAPON && rnd() % 100 < tsce->val2) {
clif_skill_nodamage(target, bl, GC_WEAPONBLOCKING, tsce->val1, 1);
clif_skill_nodamage(target, *bl, GC_WEAPONBLOCKING, tsce->val1);
sc_start(bl, target, SC_WEAPONBLOCK_ON, 100, bl->id, skill_get_time2(GC_WEAPONBLOCKING, tsce->val1));
}
}
@ -9973,7 +9973,7 @@ enum damage_lv battle_weapon_attack(struct block_list* src, struct block_list* t
}
if (tsc && tsc->getSCE(SC_MTF_MLEATKED) && rnd()%100 < tsc->getSCE(SC_MTF_MLEATKED)->val2)
clif_skill_nodamage(target, target, SM_ENDURE, tsc->getSCE(SC_MTF_MLEATKED)->val1, sc_start(src, target, SC_ENDURE, 100, tsc->getSCE(SC_MTF_MLEATKED)->val1, skill_get_time(SM_ENDURE, tsc->getSCE(SC_MTF_MLEATKED)->val1)));
clif_skill_nodamage(target, *target, SM_ENDURE, tsc->getSCE(SC_MTF_MLEATKED)->val1, sc_start(src, target, SC_ENDURE, 100, tsc->getSCE(SC_MTF_MLEATKED)->val1, skill_get_time(SM_ENDURE, tsc->getSCE(SC_MTF_MLEATKED)->val1)));
if(tsc && tsc->getSCE(SC_KAAHI) && tstatus->hp < tstatus->max_hp && status_charge(target, 0, tsc->getSCE(SC_KAAHI)->val3)) {
int hp_heal = tstatus->max_hp - tstatus->hp;

10
src/map/chat.cpp
View File

@ -218,7 +218,7 @@ int chat_leavechat(map_session_data* sd, bool kicked)
cd->usersd[i] = cd->usersd[i+1];
if( cd->users == 0 && cd->owner->type == BL_PC ) { // Delete empty chatroom
clif_clearchat(cd, 0);
clif_clearchat(*cd);
db_destroy(cd->kick_list);
map_deliddb(&cd->bl);
map_delblock(&cd->bl);
@ -235,7 +235,7 @@ int chat_leavechat(map_session_data* sd, bool kicked)
if( leavechar == 0 && cd->owner->type == BL_PC ) { // Set and announce new owner
cd->owner = (struct block_list*) cd->usersd[0];
clif_changechatowner(cd, cd->usersd[0]);
clif_clearchat(cd, 0);
clif_clearchat(*cd);
//Adjust Chat location after owner has been changed.
map_delblock( &cd->bl );
@ -276,7 +276,7 @@ int chat_changechatowner(map_session_data* sd, const char* nextownername)
return -1; // name not found
// erase temporarily
clif_clearchat(cd,0);
clif_clearchat(*cd);
// set new owner
cd->owner = (struct block_list*) cd->usersd[i];
@ -326,7 +326,7 @@ int chat_changechatstatus(map_session_data* sd, const char* title, const char* p
cd->limit = min(limit, ARRAYLENGTH(cd->usersd));
cd->pub = pub;
clif_changechatstatus(cd);
clif_changechatstatus(*cd);
clif_dispchat(cd,0);
return 0;
@ -437,7 +437,7 @@ int chat_deletenpcchat(struct npc_data* nd)
return 0;
chat_npckickall(cd);
clif_clearchat(cd, 0);
clif_clearchat(*cd);
map_deliddb(&cd->bl);
map_delblock(&cd->bl);
map_freeblock(&cd->bl);

4
src/map/chrif.cpp
View File

@ -1065,7 +1065,7 @@ int chrif_deadopt(uint32 father_id, uint32 mother_id, uint32 child_id) {
sd->status.skill[idx].id = 0;
sd->status.skill[idx].lv = 0;
sd->status.skill[idx].flag = SKILL_FLAG_PERMANENT;
clif_deleteskill(sd,WE_CALLBABY);
clif_deleteskill(*sd,WE_CALLBABY);
}
if( mother_id && ( sd = map_charid2sd(mother_id) ) != nullptr && sd->status.child == child_id ) {
@ -1073,7 +1073,7 @@ int chrif_deadopt(uint32 father_id, uint32 mother_id, uint32 child_id) {
sd->status.skill[idx].id = 0;
sd->status.skill[idx].lv = 0;
sd->status.skill[idx].flag = SKILL_FLAG_PERMANENT;
clif_deleteskill(sd,WE_CALLBABY);
clif_deleteskill(*sd,WE_CALLBABY);
}
return 0;

689
src/map/clif.cpp
View File

@ -56,7 +56,6 @@
#include "skill.hpp"
#include "status.hpp"
#include "storage.hpp"
#include "trade.hpp"
#include "unit.hpp"
#include "vending.hpp"
@ -4247,35 +4246,22 @@ void clif_equipitemack( map_session_data& sd, uint8 flag, int index, int pos ){
/// 00ac <index>.W <equip location>.W <result>.B (ZC_REQ_TAKEOFF_EQUIP_ACK)
/// 08d1 <index>.W <equip location>.W <result>.B (ZC_REQ_TAKEOFF_EQUIP_ACK2)
/// 099a <index>.W <equip location>.L <result>.B (ZC_ACK_TAKEOFF_EQUIP_V5)
/// @ok : //inversed for v2 v5
/// @success : //inversed for v2 v5
/// 0 = failure
/// 1 = success
void clif_unequipitemack(map_session_data *sd,int n,int pos,int ok)
{
int fd, header, offs = 0;
#if PACKETVER >= 20130000
header = 0x99a;
ok = ok ? 0 : 1;
#elif PACKETVER >= 20110824
header = 0x8d1;
ok = ok ? 0 : 1;
#else
header = 0xac;
void clif_unequipitemack( map_session_data& sd, uint16 server_index, int32 pos, bool success ){
#if PACKETVER >= 20110824
success = !success;
#endif
nullpo_retv(sd);
fd=sd->fd;
WFIFOHEAD(fd, packet_len(header));
WFIFOW(fd,offs+0) = header;
WFIFOW(fd,offs+2) = n+2;
#if PACKETVER >= 20130000
WFIFOL(fd,offs+4) = pos;
offs += 2;
#else
WFIFOW(fd,offs+4) = pos;
#endif
WFIFOB(fd,offs+6) = ok;
WFIFOSET(fd, packet_len(header));
PACKET_ZC_REQ_TAKEOFF_EQUIP_ACK p{};
p.packetType = HEADER_ZC_REQ_TAKEOFF_EQUIP_ACK;
p.index = client_index(server_index);
p.wearLocation = static_cast<decltype(p.wearLocation)>(pos);
p.flag = success;
clif_send(&p,sizeof(p),&sd.bl,SELF);
}
@ -4486,48 +4472,58 @@ void clif_dispchat(struct chat_data* cd, int fd)
/// 1 = public
/// 2 = arena (npc waiting room)
/// 3 = PK zone (non-clickable)
void clif_changechatstatus(struct chat_data* cd)
{
unsigned char buf[128];
uint8 type;
void clif_changechatstatus(chat_data& cd) {
if( cd == nullptr || cd->usersd[0] == nullptr )
if(cd.usersd[0] == nullptr )
return;
type = (cd->owner->type == BL_PC ) ? (cd->pub) ? 1 : 0
: (cd->owner->type == BL_NPC) ? (cd->limit) ? 2 : 3
: 1;
enum e_chat_flags:uint8 {
CHAT_PRIVATE = 0,
CHAT_PUBLIC,
CHAT_ARENA,
CHAT_PK
};
WBUFW(buf, 0) = 0xdf;
WBUFW(buf, 2) = (uint16)(17 + strlen(cd->title));
WBUFL(buf, 4) = cd->owner->id;
WBUFL(buf, 8) = cd->bl.id;
WBUFW(buf,12) = cd->limit;
WBUFW(buf,14) = (cd->owner->type == BL_NPC) ? cd->users+1 : cd->users;
WBUFB(buf,16) = type;
memcpy(WBUFCP(buf,17), cd->title, strlen(cd->title)); // not zero-terminated
PACKET_ZC_CHANGE_CHATROOM* p = reinterpret_cast<PACKET_ZC_CHANGE_CHATROOM*>( packet_buffer );
clif_send(buf,WBUFW(buf,2),cd->owner,CHAT);
p->packetType = HEADER_ZC_CHANGE_CHATROOM;
p->packetSize = static_cast<decltype(p->packetSize)>(sizeof(*p) + strlen(cd.title));
p->ownerId = cd.owner->id;
p->chatId = cd.bl.id;
p->limit = cd.limit;
p->users = cd.users;
// not zero-terminated
strncpy(p->title, cd.title, strlen(cd.title));
if(cd.owner->type == BL_NPC){
// NPC itself counts as additional chat user
p->users++;
if(cd.limit)
p->flag = CHAT_ARENA;
else
p->flag = CHAT_PK;
}else if(cd.owner->type == BL_PC && cd.pub == false){
p->flag = CHAT_PRIVATE;
}else{
p->flag = CHAT_PUBLIC;
}
clif_send(p,p->packetSize,cd.owner,CHAT);
}
/// Removes the chatroom (ZC_DESTROY_ROOM).
/// 00d8 <chat id>.L
void clif_clearchat(struct chat_data *cd,int fd)
{
unsigned char buf[32];
/// Removes the chatroom
/// 00d8 <chat id>.L (ZC_DESTROY_ROOM)
void clif_clearchat(chat_data &cd){
nullpo_retv(cd);
PACKET_ZC_DESTROY_ROOM p{};
WBUFW(buf,0) = 0xd8;
WBUFL(buf,2) = cd->bl.id;
if( session_isActive(fd) ) {
WFIFOHEAD(fd,packet_len(0xd8));
memcpy(WFIFOP(fd,0),buf,packet_len(0xd8));
WFIFOSET(fd,packet_len(0xd8));
} else {
clif_send(buf,packet_len(0xd8),cd->owner,AREA_WOSC);
}
p.packetType = HEADER_ZC_DESTROY_ROOM;
p.chatId = cd.bl.id;
clif_send(&p,sizeof(p),cd.owner,AREA_WOSC);
}
@ -4659,33 +4655,27 @@ void clif_leavechat(struct chat_data* cd, map_session_data* sd, bool flag)
/// Opens a trade request window from char 'name'.
/// 00e5 <nick>.24B (ZC_REQ_EXCHANGE_ITEM)
/// 01f4 <nick>.24B <charid>.L <baselvl>.W (ZC_REQ_EXCHANGE_ITEM2)
void clif_traderequest(map_session_data* sd, const char* name)
{
int fd = sd->fd;
/// 01f4 <nick>.24B <targetid>.L <baselvl>.W (ZC_REQ_EXCHANGE_ITEM2)
void clif_traderequest(map_session_data& sd, const char* name){
#if PACKETVER < 6
WFIFOHEAD(fd,packet_len(0xe5));
WFIFOW(fd,0) = 0xe5;
safestrncpy(WFIFOCP(fd,2), name, NAME_LENGTH);
WFIFOSET(fd,packet_len(0xe5));
#else
map_session_data* tsd = map_id2sd(sd->trade_partner);
if( !tsd ) return;
PACKET_ZC_REQ_EXCHANGE_ITEM p{};
WFIFOHEAD(fd,packet_len(0x1f4));
WFIFOW(fd,0) = 0x1f4;
safestrncpy(WFIFOCP(fd,2), name, NAME_LENGTH);
WFIFOL(fd,26) = tsd->status.char_id;
WFIFOW(fd,30) = tsd->status.base_level;
WFIFOSET(fd,packet_len(0x1f4));
p.packetType = HEADER_ZC_REQ_EXCHANGE_ITEM;
safestrncpy(p.requesterName, name, sizeof(p.requesterName));
#if PACKETVER > 6
p.targetId = sd.trade_partner.id; // Client generates a random char[5] with this info
p.targetLv = sd.trade_partner.lv;
#endif
clif_send(&p,sizeof(p),&sd.bl,SELF);
}
/// Reply to a trade-request.
/// 00e7 <result>.B (ZC_ACK_EXCHANGE_ITEM)
/// 01f5 <result>.B <charid>.L <baselvl>.W (ZC_ACK_EXCHANGE_ITEM2)
/// 01f5 <result>.B <targetid>.L <baselvl>.W (ZC_ACK_EXCHANGE_ITEM2)
/// result:
/// 0 = Char is too far
/// 1 = Character does not exist
@ -4693,23 +4683,19 @@ void clif_traderequest(map_session_data* sd, const char* name)
/// 3 = Accept
/// 4 = Cancel
/// 5 = Busy
void clif_tradestart(map_session_data* sd, uint8 type)
{
int fd = sd->fd;
map_session_data* tsd = map_id2sd(sd->trade_partner);
if( PACKETVER < 6 || !tsd ) {
WFIFOHEAD(fd,packet_len(0xe7));
WFIFOW(fd,0) = 0xe7;
WFIFOB(fd,2) = type;
WFIFOSET(fd,packet_len(0xe7));
} else {
WFIFOHEAD(fd,packet_len(0x1f5));
WFIFOW(fd,0) = 0x1f5;
WFIFOB(fd,2) = type;
WFIFOL(fd,3) = tsd->status.char_id;
WFIFOW(fd,7) = tsd->status.base_level;
WFIFOSET(fd,packet_len(0x1f5));
}
void clif_traderesponse( map_session_data& sd, e_ack_trade_response result ){
PACKET_ZC_ACK_EXCHANGE_ITEM p{};
p.packetType = HEADER_ZC_ACK_EXCHANGE_ITEM;
p.result = static_cast<decltype(p.result)>( result );
#if PACKETVER > 6
p.targetId = sd.trade_partner.id; // Client generates a random char[5] with this info
p.targetLv = sd.trade_partner.lv;
#endif
clif_send(&p,sizeof(p),&sd.bl,SELF);
}
@ -5712,28 +5698,26 @@ void clif_addskill(map_session_data *sd, int skill_id)
}
/// Deletes a skill from the skill tree (ZC_SKILLINFO_DELETE).
/// 0441 <skill id>.W
void clif_deleteskill(map_session_data *sd, int skill_id, bool skip_infoblock)
{
#if PACKETVER >= 20081217
nullpo_retv(sd);
int fd = sd->fd;
/// Deletes a skill from the skill tree.
/// 0441 <skill id>.W (ZC_SKILLINFO_DELETE)
void clif_deleteskill(map_session_data& sd, uint16 skill_id, bool skip_infoblock){
#if PACKETVER >= 20081126
uint16 idx = skill_get_index(skill_id);
if (!session_isActive(fd) || !idx)
if (idx == 0)
return;
WFIFOHEAD(fd,packet_len(0x441));
WFIFOW(fd,0) = 0x441;
WFIFOW(fd,2) = skill_id;
WFIFOSET(fd,packet_len(0x441));
PACKET_ZC_SKILLINFO_DELETE p{};
p.packetType = HEADER_ZC_SKILLINFO_DELETE;
p.skillID = skill_id;
clif_send(&p,sizeof(p),&sd.bl,SELF);
#endif
#if PACKETVER_MAIN_NUM >= 20190807 || PACKETVER_RE_NUM >= 20190807 || PACKETVER_ZERO_NUM >= 20190918
if (!skip_infoblock)
#endif
clif_skillinfoblock(sd);
clif_skillinfoblock(&sd);
}
/// Updates a skill in the skill tree (ZC_SKILLINFO_UPDATE).
@ -6090,45 +6074,35 @@ int clif_skill_damage2(struct block_list *src,struct block_list *dst,t_tick tick
/// Non-damaging skill effect
/// 011a <skill id>.W <heal>.W <dst id>.L <src id>.L <result>.B (ZC_USE_SKILL).
/// 09cb <skill id>.W <heal>.L <dst id>.L <src id>.L <result>.B (ZC_USE_SKILL2).
bool clif_skill_nodamage(struct block_list *src,struct block_list *dst, uint16 skill_id, int heal, t_tick tick)
{
unsigned char buf[17];
#if PACKETVER < 20130731
const int cmd = 0x11a;
#else
const int cmd = 0x9cb;
#endif
int offset = 0;
bool success = ( tick != 0 );
/// 011a <skill id>.W <heal>.W <dst id>.L <src id>.L <result>.B (ZC_USE_SKILL)
/// 09cb <skill id>.W <heal>.L <dst id>.L <src id>.L <result>.B (ZC_USE_SKILL2)
bool clif_skill_nodamage( block_list* src, block_list& dst, uint16 skill_id, int32 heal, bool success ){
PACKET_ZC_USE_SKILL p{};
nullpo_ret(dst);
WBUFW(buf,0) = cmd;
WBUFW(buf,2) = skill_id;
#if PACKETVER < 20130731
WBUFW(buf,4) = min(heal, INT16_MAX);
#else
WBUFL(buf,4) = min(heal, INT32_MAX);
offset += 2;
#endif
WBUFL(buf,6+offset) = dst->id;
WBUFL(buf,10+offset) = src ? src->id : 0;
WBUFB(buf,14+offset) = success;
if (disguised(dst)) {
clif_send(buf, packet_len(cmd), dst, AREA_WOS);
WBUFL(buf,6+offset) = disguised_bl_id(dst->id);
clif_send(buf, packet_len(cmd), dst, SELF);
p.PacketType = HEADER_ZC_USE_SKILL;
p.SKID = skill_id;
p.level = std::min( static_cast<decltype(p.level)>( heal ), std::numeric_limits<decltype(p.level)>::max() );
p.targetAID = dst.id;
p.result = success;
if(src != nullptr){
p.srcAID = src->id;
}else{
p.srcAID = 0;
}
if (disguised(&dst)) {
clif_send(&p, sizeof(p), &dst, AREA_WOS);
p.targetAID = disguised_bl_id(dst.id);
clif_send(&p, sizeof(p), &dst, SELF);
} else
clif_send(buf, packet_len(cmd), dst, AREA);
clif_send(&p, sizeof(p), &dst, AREA);
if(src && disguised(src)) {
WBUFL(buf,10+offset) = disguised_bl_id(src->id);
if (disguised(dst))
WBUFL(buf,6+offset) = dst->id;
clif_send(buf, packet_len(cmd), src, SELF);
if(src != nullptr && disguised(src)) {
p.srcAID = disguised_bl_id(src->id);
if (disguised(&dst)){
// It is necessary to revert the changes done above for the disguised target
p.targetAID = dst.id;
}
clif_send(&p, sizeof(p), src, SELF);
}
return success;
@ -6158,37 +6132,71 @@ void clif_skill_poseffect(struct block_list *src,uint16 skill_id,int val,int x,i
clif_send(buf,packet_len(0x117),src,AREA);
}
/// Presents a list of available warp destinations (ZC_WARPLIST).
/// 011c <skill id>.W { <map name>.16B }*4
void clif_skill_warppoint( map_session_data* sd, uint16 skill_id, uint16 skill_lv, const char* map1, const char* map2, const char* map3, const char* map4 ){
int fd;
nullpo_retv(sd);
fd = sd->fd;
/// Presents a list of available warp destinations.
/// 011c <skill id>.W { <map name>.16B }*4 (ZC_WARPLIST)
/// 0abe <lenght>.W <skill id>.W { <map name>.16B }*? (ZC_WARPLIST2)
void clif_skill_warppoint( map_session_data& sd, uint16 skill_id, uint16 skill_lv, std::vector<std::string>& maps ){
if(maps.empty())
return;
WFIFOHEAD(fd,packet_len(0x11c));
WFIFOW(fd,0) = 0x11c;
WFIFOW(fd,2) = skill_id;
memset(WFIFOP(fd,4), 0x00, 4*MAP_NAME_LENGTH_EXT);
if( strcmp( "", map1 ) != 0 ){
mapindex_getmapname_ext( map1, WFIFOCP( fd, 4 ) );
}
if( strcmp( "", map2 ) != 0 ){
mapindex_getmapname_ext( map2, WFIFOCP( fd, 20 ) );
}
if( strcmp( "", map3 ) != 0 ){
mapindex_getmapname_ext( map3, WFIFOCP( fd, 36 ) );
}
if( strcmp( "", map4 ) != 0 ){
mapindex_getmapname_ext( map4, WFIFOCP( fd, 52 ) );
}
WFIFOSET(fd,packet_len(0x11c));
#if PACKETVER_MAIN_NUM >= 20170502 || PACKETVER_RE_NUM >= 20170419 || defined(PACKETVER_ZERO)
PACKET_ZC_WARPLIST* p = reinterpret_cast<PACKET_ZC_WARPLIST*>( packet_buffer );
sd->menuskill_id = skill_id;
p->packetType = HEADER_ZC_WARPLIST;
p->packetLength = sizeof( *p );
p->skillId = skill_id;
size_t memoCount = 0;
for( std::string& map : maps ){
if( map.empty() ){
continue;
}
PACKET_ZC_WARPLIST_sub& warp = p->maps[memoCount];
mapindex_getmapname_ext( map.c_str(), warp.map );
p->packetLength += static_cast<decltype(p->packetLength)>( sizeof( warp ) );
memoCount++;
}
clif_send( p, p->packetLength, &sd.bl, SELF );
#else
PACKET_ZC_WARPLIST p = {};
p.packetType = HEADER_ZC_WARPLIST;
p.skillId = skill_id;
size_t memoCount = 0, max = 4;
for( std::string& map : maps ){
if( map.empty() ){
continue;
}
PACKET_ZC_WARPLIST_sub& warp = p.maps[memoCount];
mapindex_getmapname_ext( map.c_str(), warp.map );
if( memoCount++ == max ){
break;
}
}
for( ; memoCount < max; memoCount++ ){
PACKET_ZC_WARPLIST_sub& warp = p.maps[memoCount];
strcpy( warp.map, "" );
}
clif_send( &p, sizeof( p ), &sd.bl, SELF );
#endif
sd.menuskill_id = skill_id;
if (skill_id == AL_WARP) {
sd->menuskill_val = (sd->ud.skillx<<16)|sd->ud.skilly; //Store warp position here.
sd->state.workinprogress = WIP_DISABLE_ALL;
sd.menuskill_val = (sd.ud.skillx<<16)|sd.ud.skilly; //Store warp position here.
sd.state.workinprogress = WIP_DISABLE_ALL;
} else
sd->menuskill_val = skill_lv;
sd.menuskill_val = skill_lv;
}
@ -8664,8 +8672,8 @@ void clif_guild_send_onlineinfo(map_session_data *sd)
}
/// Bitmask of enabled guild window tabs (ZC_ACK_GUILD_MENUINTERFACE).
/// 014e <menu flag>.L
/// Bitmask of enabled guild window tabs
/// 014e <menu flag>.L (ZC_ACK_GUILD_MENUINTERFACE)
/// menu flag:
/// 0x00 = Basic Info (always on)
/// &0x01 = Member manager
@ -8674,17 +8682,18 @@ void clif_guild_send_onlineinfo(map_session_data *sd)
/// &0x10 = Expulsion list
/// &0x40 = Unknown (GMENUFLAG_ALLGUILDLIST)
/// &0x80 = Notice
void clif_guild_masterormember(map_session_data *sd)
{
int fd;
void clif_guild_masterormember(map_session_data& sd){
nullpo_retv(sd);
PACKET_ZC_ACK_GUILD_MENUINTERFACE p{};
fd=sd->fd;
WFIFOHEAD(fd,packet_len(0x14e));
WFIFOW(fd,0) = 0x14e;
WFIFOL(fd,2) = (sd->state.gmaster_flag) ? 0xd7 : 0x57;
WFIFOSET(fd,packet_len(0x14e));
p.packetType = HEADER_ZC_ACK_GUILD_MENUINTERFACE;
if(sd.state.gmaster_flag){
p.menuFlag = 0xd7;
}else{
p.menuFlag = 0x57;
}
clif_send(&p,sizeof(p),&sd.bl,SELF);
}
@ -8728,31 +8737,38 @@ void clif_guild_basicinfo( map_session_data& sd ){
}
/// Guild alliance and opposition list (ZC_MYGUILD_BASIC_INFO).
/// 014c <packet len>.W { <relation>.L <guild id>.L <guild name>.24B }*
void clif_guild_allianceinfo(map_session_data *sd)
{
int fd,i,c;
/// Guild alliance and opposition list
/// 014c <packet len>.W { <relation>.L <guild id>.L <guild name>.24B }* (ZC_MYGUILD_BASIC_INFO)
void clif_guild_allianceinfo(map_session_data& sd){
auto &g = sd.guild;
nullpo_retv(sd);
auto &g = sd->guild;
if (!g)
if (g == nullptr){
return;
}
fd = sd->fd;
WFIFOHEAD(fd, MAX_GUILDALLIANCE * 32 + 4);
WFIFOW(fd, 0)=0x14c;
for(i=c=0;i<MAX_GUILDALLIANCE;i++){
struct guild_alliance *a=&g->guild.alliance[i];
if(a->guild_id>0){
WFIFOL(fd,c*32+4)=a->opposition;
WFIFOL(fd,c*32+8)=a->guild_id;
safestrncpy(WFIFOCP(fd,c*32+12),a->name,NAME_LENGTH);
PACKET_ZC_MYGUILD_BASIC_INFO* p = reinterpret_cast<PACKET_ZC_MYGUILD_BASIC_INFO*>( packet_buffer );
p->PacketType = HEADER_ZC_MYGUILD_BASIC_INFO;
p->PacketLength = sizeof(*p);
for(size_t i=0, c = 0;i<MAX_GUILDALLIANCE;i++){
guild_alliance &a = g->guild.alliance[i];
if(a.guild_id<=0){
continue;
}
RELATED_GUILD_INFO& info = p->rgInfo[c];
info.relation = a.opposition;
info.GDID = a.guild_id;
safestrncpy(info.guildname,a.name,sizeof(info.guildname));
p->PacketLength += static_cast<decltype(p->PacketLength)>(sizeof(info));
c++;
}
}
WFIFOW(fd, 2)=c*32+4;
WFIFOSET(fd,WFIFOW(fd,2));
clif_send(p,p->PacketLength,&sd.bl,SELF);
}
@ -8835,34 +8851,36 @@ void clif_guild_positionnamelist(map_session_data *sd)
}
/// Guild position information (ZC_POSITION_INFO).
/// 0160 <packet len>.W { <position id>.L <mode>.L <ranking>.L <pay rate>.L }*
/// Guild position information
/// 0160 <packet len>.W { <position id>.L <mode>.L <ranking>.L <pay rate>.L }* (ZC_POSITION_INFO)
/// mode:
/// &0x01 = allow invite
/// &0x10 = allow expel
/// See enum e_guild_permission
/// ranking:
/// TODO
void clif_guild_positioninfolist(map_session_data *sd)
{
int i,fd;
static void clif_guild_positioninfolist(map_session_data& sd){
auto &g = sd.guild;
nullpo_retv(sd);
auto &g = sd->guild;
if (!g)
if (g == nullptr){
return;
fd = sd->fd;
WFIFOHEAD(fd, MAX_GUILDPOSITION * 16 + 4);
WFIFOW(fd, 0)=0x160;
for(i=0;i<MAX_GUILDPOSITION;i++){
struct guild_position *p=&g->guild.position[i];
WFIFOL(fd,i*16+ 4)=i;
WFIFOL(fd,i*16+ 8)=p->mode;
WFIFOL(fd,i*16+12)=i;
WFIFOL(fd,i*16+16)=p->exp_mode;
}
WFIFOW(fd, 2)=i*16+4;
WFIFOSET(fd,WFIFOW(fd,2));
PACKET_ZC_POSITION_INFO* p = reinterpret_cast<PACKET_ZC_POSITION_INFO*>( packet_buffer );
p->PacketType = HEADER_ZC_POSITION_INFO;
p->PacketLength = sizeof(*p);
for(size_t i=0;i<MAX_GUILDPOSITION;i++){
guild_position& gp = g->guild.position[i];
p->posInfo[i].positionID = i;
p->posInfo[i].right = gp.mode;
p->posInfo[i].ranking = i;
p->posInfo[i].payRate = gp.exp_mode;
p->PacketLength += static_cast<decltype(p->PacketLength)>( sizeof( p->posInfo[0] ) );
}
clif_send(p,p->PacketLength,&sd.bl,SELF);
}
@ -9096,94 +9114,95 @@ void clif_guild_expulsion( map_session_data& sd, const char* name, uint32 char_i
}
/// Guild expulsion list (ZC_BAN_LIST).
/// 0163 <packet len>.W { <char name>.24B <account name>.24B <reason>.40B }*
/// 0163 <packet len>.W { <char name>.24B <reason>.40B }* (PACKETVER >= 20100803)
void clif_guild_expulsionlist(map_session_data* sd)
{
#if PACKETVER < 20100803
const int offset = NAME_LENGTH*2+40;
#else
const int offset = NAME_LENGTH+40;
#endif
int fd, i, c = 0;
/// Guild expulsion list
/// 0163 <packet len>.W { <char name>.24B <account name>.24B <reason>.40B }* (ZC_BAN_LIST)
/// 0163 <packet len>.W { <char name>.24B <reason>.40B }* (PACKETVER >= 20100803) (ZC_BAN_LIST)
/// 0a87 <packet len>.W { <charid>.L <reason>.40B }* (ZC_BAN_LIST2)
/// 0b7c <packet len>.W { <charid>.L <reason>.40B <char name>.24B }* (ZC_BAN_LIST3)
static void clif_guild_expulsionlist(map_session_data& sd){
nullpo_retv(sd);
auto &g = sd->guild;
auto &g = sd.guild;
if (!g)
return;
fd = sd->fd;
PACKET_ZC_BAN_LIST* p = reinterpret_cast<PACKET_ZC_BAN_LIST*>( packet_buffer );
WFIFOHEAD(fd,4 + MAX_GUILDEXPULSION * offset);
WFIFOW(fd,0) = 0x163;
p->packetType = HEADER_ZC_BAN_LIST;
p->packetLen = sizeof(*p);
for( i = 0; i < MAX_GUILDEXPULSION; i++ )
{
struct guild_expulsion* e = &g->guild.expulsion[i];
for( size_t i = 0, c = 0; i < MAX_GUILDEXPULSION; i++ ){
struct guild_expulsion& e = g->guild.expulsion[i];
if( e->account_id > 0 )
{
safestrncpy(WFIFOCP(fd,4 + c*offset), e->name, NAME_LENGTH);
#if PACKETVER < 20100803
memset(WFIFOP(fd,4 + c*offset+24), 0, NAME_LENGTH); // account name (not used for security reasons)
memcpy(WFIFOP(fd,4 + c*offset+48), e->mes, 40);
#else
memcpy(WFIFOP(fd,4 + c*offset+24), e->mes, 40);
if( e.account_id == 0 ){
continue;
}
PACKET_ZC_BAN_LIST_sub& banned = p->chars[c];
#if PACKETVER >= 20161019
banned.char_id = e.char_id;
#elif PACKETVER < 20100803
// account name (not used for security reasons)
safestrncpy(banned.account_name, "", sizeof(banned.account_name));
#endif
#if PACKETVER >= 20200902 || PACKETVER < 20161019
safestrncpy(banned.char_name, e.name, sizeof(banned.char_name));
#endif
safestrncpy(banned.message, e.mes, sizeof(banned.message));
p->packetLen += static_cast<decltype(p->packetLen)>(sizeof(banned));
c++;
}
}
WFIFOW(fd,2) = 4 + c*offset;
WFIFOSET(fd,WFIFOW(fd,2));
clif_send(p,p->packetLen,&sd.bl,SELF);
}
/// Guild chat message (ZC_GUILD_CHAT).
/// 017f <packet len>.W <message>.?B
void clif_guild_message( const struct mmo_guild& g, uint32 account_id, const char* mes, size_t len ){
// TODO: account_id is not used, candidate for deletion? [Ai4rei]
map_session_data *sd;
uint8 buf[256];
/// Guild chat message
/// 017f <packet len>.W <message>.?B (ZC_GUILD_CHAT)
void clif_guild_message( const struct mmo_guild& g, const char* mes, size_t len ){
PACKET_ZC_GUILD_CHAT *p = reinterpret_cast<PACKET_ZC_GUILD_CHAT*>( packet_buffer );
// -1 for null terminator
static const size_t max_len = CHAT_SIZE_MAX - sizeof( *p ) - 1;
if( len == 0 )
{
map_session_data* sd = guild_getavailablesd(g);
// Ignore this message, if no guildmember is available
if (sd == nullptr)
return;
}
else if( len > sizeof(buf)-5 )
{
ShowWarning("clif_guild_message: Truncated message '%s' (len=%d, max=%" PRIuPTR ", guild_id=%d).\n", mes, len, sizeof(buf)-5, g.guild_id);
len = sizeof(buf)-5;
}
WBUFW(buf, 0) = 0x17f;
WBUFW( buf, 2 ) = static_cast<int16>( len + 5 );
safestrncpy(WBUFCP(buf,4), mes, len+1);
if( len == 0 ){
return;
} else if( len > max_len ){
ShowWarning("clif_guild_message: Truncated message '%s' (len=%" PRIuPTR ", max=%" PRIuPTR ", guild_id=%u).\n", mes, len, max_len, g.guild_id);
len = max_len;
}
p->packetType = HEADER_ZC_GUILD_CHAT;
p->packetLength = sizeof(*p);
if ((sd = guild_getavailablesd(g)) != nullptr)
clif_send(buf, WBUFW(buf,2), &sd->bl, GUILD_NOBG);
safestrncpy(p->message, mes, len+1);
p->packetLength += static_cast<decltype(p->packetLength)>( len + 1 );
clif_send(p, p->packetLength, &sd->bl, GUILD_NOBG);
}
/// Request for guild alliance (ZC_REQ_ALLY_GUILD).
/// 0171 <inviter account id>.L <guild name>.24B
void clif_guild_reqalliance(map_session_data *sd,uint32 account_id,const char *name)
/// Request for guild alliance
/// 0171 <inviter account id>.L <guild name>.24B (ZC_REQ_ALLY_GUILD).
void clif_guild_reqalliance(map_session_data& sd,uint32 account_id,const char *name)
{
int fd;
PACKET_ZC_REQ_ALLY_GUILD p{};
nullpo_retv(sd);
p.packetType = HEADER_ZC_REQ_ALLY_GUILD;
p.inviterId = account_id;
safestrncpy(p.inviterGuildName,name,sizeof(p.inviterGuildName));
fd=sd->fd;
WFIFOHEAD(fd,packet_len(0x171));
WFIFOW(fd,0)=0x171;
WFIFOL(fd,2)=account_id;
safestrncpy(WFIFOCP(fd,6),name,NAME_LENGTH);
WFIFOSET(fd,packet_len(0x171));
clif_send(&p,sizeof(p),&sd.bl,SELF);
}
/// Notifies the client about the result of a alliance request (ZC_ACK_REQ_ALLY_GUILD).
/// 0173 <answer>.B
/// Notifies the client about the result of a alliance request.
/// 0173 <answer>.B (ZC_ACK_REQ_ALLY_GUILD)
/// answer:
/// 0 = Already allied.
/// 1 = You rejected the offer.
@ -9191,60 +9210,50 @@ void clif_guild_reqalliance(map_session_data *sd,uint32 account_id,const char *n
/// 3 = They have too any alliances.
/// 4 = You have too many alliances.
/// 5 = Alliances are disabled.
void clif_guild_allianceack(map_session_data *sd,int flag)
{
int fd;
void clif_guild_allianceack(map_session_data& sd,uint8 flag){
nullpo_retv(sd);
PACKET_ZC_ACK_REQ_ALLY_GUILD p{};
fd=sd->fd;
WFIFOHEAD(fd,packet_len(0x173));
WFIFOW(fd,0)=0x173;
WFIFOL(fd,2)=flag;
WFIFOSET(fd,packet_len(0x173));
p.packetType = HEADER_ZC_ACK_REQ_ALLY_GUILD;
p.flag = flag;
clif_send(&p,sizeof(p),&sd.bl,SELF);
}
/// Notifies the client that a alliance or opposition has been removed (ZC_DELETE_RELATED_GUILD).
/// 0184 <other guild id>.L <relation>.L
/// Notifies the client that a alliance or opposition has been removed.
/// 0184 <other guild id>.L <relation>.L (ZC_DELETE_RELATED_GUILD)
/// relation:
/// 0 = Ally
/// 1 = Enemy
void clif_guild_delalliance(map_session_data *sd,int guild_id,int flag)
void clif_guild_delalliance(map_session_data& sd,uint32 guild_id,uint32 flag)
{
nullpo_retv(sd);
int fd = sd->fd;
PACKET_ZC_DELETE_RELATED_GUILD p{};
if ( !session_isActive(fd) )
return;
p.packetType = HEADER_ZC_DELETE_RELATED_GUILD;
p.allyID = guild_id;
p.flag = flag;
WFIFOHEAD(fd,packet_len(0x184));
WFIFOW(fd,0)=0x184;
WFIFOL(fd,2)=guild_id;
WFIFOL(fd,6)=flag;
WFIFOSET(fd,packet_len(0x184));
clif_send(&p,sizeof(p),&sd.bl,SELF);
}
/// Notifies the client about the result of a opposition request (ZC_ACK_REQ_HOSTILE_GUILD).
/// 0181 <result>.B
/// Notifies the client about the result of a opposition request.
/// 0181 <result>.B (ZC_ACK_REQ_HOSTILE_GUILD)
/// result:
/// 0 = Antagonist has been set.
/// 1 = Guild has too many Antagonists.
/// 2 = Already set as an Antagonist.
/// 3 = Antagonists are disabled.
void clif_guild_oppositionack(map_session_data *sd,int flag)
{
int fd;
void clif_guild_oppositionack(map_session_data& sd,uint8 flag){
nullpo_retv(sd);
PACKET_ZC_ACK_REQ_HOSTILE_GUILD p{};
fd=sd->fd;
WFIFOHEAD(fd,packet_len(0x181));
WFIFOW(fd,0)=0x181;
WFIFOB(fd,2)=flag;
WFIFOSET(fd,packet_len(0x181));
p.packetType = HEADER_ZC_ACK_REQ_HOSTILE_GUILD;
p.flag = flag;
clif_send(&p,sizeof(p),&sd.bl,SELF);
}
@ -12351,13 +12360,8 @@ void clif_parse_TradeRequest(int fd,map_session_data *sd)
}
if (t_sd->state.mail_writing) {
int old = sd->trade_partner;
// Fake trading
sd->trade_partner = t_sd->status.account_id;
clif_tradestart(sd, 5);
// Restore old state
sd->trade_partner = old;
clif_traderesponse(*sd,TRADE_ACK_BUSY);
return;
}
@ -14047,11 +14051,13 @@ void clif_parse_CreateGuild(int fd,map_session_data *sd){
}
/// Request for guild window interface permissions (CZ_REQ_GUILD_MENUINTERFACE).
/// 014d
void clif_parse_GuildCheckMaster(int fd, map_session_data *sd)
{
clif_guild_masterormember(sd);
/// Request for guild window interface permissions
/// 014d (CZ_REQ_GUILD_MENUINTERFACE)
static void clif_parse_GuildCheckMaster(int fd, map_session_data *sd){
if(sd == nullptr)
return;
clif_guild_masterormember(*sd);
}
@ -14075,7 +14081,7 @@ void clif_parse_GuildRequestInfo(int fd, map_session_data *sd)
{
case 0: // Basic Information Guild, hostile alliance information
clif_guild_basicinfo( *sd );
clif_guild_allianceinfo(sd);
clif_guild_allianceinfo(*sd);
clif_guild_castle_list(*sd);
break;
case 1: // Members list, list job title
@ -14084,13 +14090,13 @@ void clif_parse_GuildRequestInfo(int fd, map_session_data *sd)
break;
case 2: // List job title, title information list
clif_guild_positionnamelist(sd);
clif_guild_positioninfolist(sd);
clif_guild_positioninfolist(*sd);
break;
case 3: // Skill list
clif_guild_skillinfo( *sd );
break;
case 4: // Expulsion list
clif_guild_expulsionlist(sd);
clif_guild_expulsionlist(*sd);
break;
default:
ShowError("clif: guild request info: unknown type %d\n", type);
@ -14774,6 +14780,19 @@ void clif_parse_GMHide(int fd, map_session_data *sd) {
}
/// /resetcooltime
/// 0a88 (CZ_CMD_RESETCOOLTIME).
void clif_parse_gm_resetcooltime( int fd, map_session_data* sd ){
#if PACKETVER_MAIN_NUM >= 20160622 || PACKETVER_RE_NUM >= 20160622 || defined(PACKETVER_ZERO)
const PACKET_CZ_CMD_RESETCOOLTIME* p = reinterpret_cast<const PACKET_CZ_CMD_RESETCOOLTIME*>( RFIFOP( fd, 0 ) );
char cmd[CHAT_SIZE_MAX];
safesnprintf(cmd,sizeof(cmd),"%cresetcooltime",atcommand_symbol);
is_atcommand(fd, sd, cmd, 1);
#endif
}
/// Request to adjust player's manner points (CZ_REQ_GIVE_MANNER_POINT).
/// 0149 <account id>.L <type>.B <value>.W
/// type:
@ -15032,7 +15051,7 @@ void clif_parse_NoviceExplosionSpirits(int fd, map_session_data *sd)
if( percent && ( percent%100 ) == 0 ) {// 10.0%, 20.0%, ..., 90.0%
sc_start(&sd->bl,&sd->bl, SC_EXPLOSIONSPIRITS, 100, 17, skill_get_time(MO_EXPLOSIONSPIRITS, 5)); //Lv17-> +50 critical (noted by Poki) [Skotlex]
clif_skill_nodamage(&sd->bl, &sd->bl, MO_EXPLOSIONSPIRITS, 5, 1); // prayer always shows successful Lv5 cast and disregards noskill restrictions
clif_skill_nodamage(&sd->bl, sd->bl, MO_EXPLOSIONSPIRITS, 5); // prayer always shows successful Lv5 cast and disregards noskill restrictions
}
}
}
@ -16206,7 +16225,7 @@ void clif_parse_Mail_beginwrite( int fd, map_session_data *sd ){
return;
}
if( sd->state.storage_flag || sd->state.mail_writing || sd->trade_partner ){
if( sd->state.storage_flag || sd->state.mail_writing || sd->state.trading ){
clif_send_Mail_beginwrite_ack(sd, name, false);
return;
}

31
src/map/clif.hpp
View File

@ -14,6 +14,7 @@
#include "packets.hpp"
#include "script.hpp"
#include "trade.hpp"
struct Channel;
struct clan;
@ -874,7 +875,7 @@ void clif_arrow_fail( map_session_data& sd, e_action_failure type );
void clif_arrow_create_list( map_session_data& sd );
void clif_statusupack( map_session_data& sd, int32 type, bool success, int32 val = 0 );
void clif_equipitemack( map_session_data& sd, uint8 flag, int index, int pos = 0 ); // self
void clif_unequipitemack(map_session_data *sd,int n,int pos,int ok); // self
void clif_unequipitemack( map_session_data& sd, uint16 server_index, int32 pos, bool success );
void clif_misceffect( block_list& bl, e_notify_effect type );
void clif_changeoption_target(struct block_list* bl, struct block_list* target);
#define clif_changeoption(bl) clif_changeoption_target(bl, nullptr) // area
@ -887,9 +888,9 @@ void clif_joinchatfail( map_session_data& sd, e_refuse_enter_room result );
void clif_joinchatok(map_session_data& sd,chat_data& cd);
void clif_addchat(struct chat_data* cd,map_session_data *sd); // chat
void clif_changechatowner(struct chat_data* cd, map_session_data* sd); // chat
void clif_clearchat(struct chat_data *cd,int fd); // area or fd
void clif_clearchat(chat_data &cd);
void clif_leavechat(struct chat_data* cd, map_session_data* sd, bool flag); // chat
void clif_changechatstatus(struct chat_data* cd); // chat
void clif_changechatstatus(chat_data& cd);
void clif_refresh_storagewindow(map_session_data *sd);
void clif_refresh(map_session_data *sd); // self
@ -905,8 +906,8 @@ void clif_parse_LoadEndAck(int fd,map_session_data *sd);
void clif_hotkeys_send(map_session_data *sd, int tab);
// trade
void clif_traderequest(map_session_data* sd, const char* name);
void clif_tradestart(map_session_data* sd, uint8 type);
void clif_traderequest(map_session_data& sd, const char* name);
void clif_traderesponse( map_session_data& sd, e_ack_trade_response result );
void clif_tradeadditem(map_session_data* sd, map_session_data* tsd, int index, int amount);
void clif_tradeitemok(map_session_data& sd, int index, e_exitem_add_result result);
void clif_tradedeal_lock( map_session_data& sd, bool who );
@ -932,7 +933,7 @@ void clif_skillinfoblock(map_session_data *sd);
void clif_skillup(map_session_data *sd, uint16 skill_id, int lv, int range, int upgradable);
void clif_skillinfo(map_session_data *sd,int skill_id, int inf);
void clif_addskill(map_session_data *sd, int skill_id);
void clif_deleteskill(map_session_data *sd, int skill_id, bool skip_infoblock = false);
void clif_deleteskill(map_session_data& sd, uint16 skill_id, bool skip_infoblock = false);
void clif_skillcasting(struct block_list* bl, int src_id, int dst_id, int dst_x, int dst_y, uint16 skill_id, uint16 skill_lv, int property, int casttime);
void clif_skillcastcancel( block_list& bl );
@ -940,10 +941,10 @@ void clif_skill_fail( map_session_data& sd, uint16 skill_id, enum useskill_fail_
void clif_skill_cooldown( map_session_data &sd, uint16 skill_id, t_tick tick );
int clif_skill_damage(struct block_list *src,struct block_list *dst,t_tick tick,int sdelay,int ddelay,int64 sdamage,int div,uint16 skill_id,uint16 skill_lv,enum e_damage_type type);
//int clif_skill_damage2(struct block_list *src,struct block_list *dst,t_tick tick,int sdelay,int ddelay,int damage,int div,uint16 skill_id,uint16 skill_lv,enum e_damage_type type);
bool clif_skill_nodamage(struct block_list *src,struct block_list *dst,uint16 skill_id,int heal,t_tick tick);
bool clif_skill_nodamage( block_list* src, block_list& dst, uint16 skill_id, int32 heal, bool success = true );
void clif_skill_poseffect(struct block_list *src,uint16 skill_id,int val,int x,int y,t_tick tick);
void clif_skill_estimation(map_session_data *sd,struct block_list *dst);
void clif_skill_warppoint( map_session_data* sd, uint16 skill_id, uint16 skill_lv, const char* map1, const char* map2 = "", const char* map3 = "", const char* map4 = "" );
void clif_skill_warppoint( map_session_data& sd, uint16 skill_id, uint16 skill_lv, std::vector<std::string>& maps );
void clif_skill_memomessage( map_session_data& sd, e_ack_remember_warppoint_result result );
void clif_skill_teleportmessage( map_session_data& sd, e_notify_mapinfo_result result );
void clif_skill_produce_mix_list( map_session_data& sd, int skill_id, int trigger );
@ -1040,9 +1041,9 @@ void clif_party_dead( map_session_data& sd );
// guild
void clif_guild_created( map_session_data& sd, int flag );
void clif_guild_belonginfo( map_session_data& sd );
void clif_guild_masterormember(map_session_data *sd);
void clif_guild_masterormember(map_session_data& sd);
void clif_guild_basicinfo( map_session_data& sd );
void clif_guild_allianceinfo(map_session_data *sd);
void clif_guild_allianceinfo(map_session_data& sd);
void clif_guild_memberlist( map_session_data& sd );
void clif_guild_skillinfo( map_session_data& sd );
void clif_guild_send_onlineinfo(map_session_data *sd); //[LuzZza]
@ -1056,11 +1057,11 @@ void clif_guild_memberpositionchanged(const struct mmo_guild &g,int idx);
void clif_guild_emblem(const map_session_data &sd, const struct mmo_guild &g);
void clif_guild_emblem_area(struct block_list* bl);
void clif_guild_notice( map_session_data& sd );
void clif_guild_message( const struct mmo_guild& g, uint32 account_id, const char* mes, size_t len );
void clif_guild_reqalliance(map_session_data *sd,uint32 account_id,const char *name);
void clif_guild_allianceack(map_session_data *sd,int flag);
void clif_guild_delalliance(map_session_data *sd,int guild_id,int flag);
void clif_guild_oppositionack(map_session_data *sd,int flag);
void clif_guild_message( const struct mmo_guild& g, const char* mes, size_t len );
void clif_guild_reqalliance(map_session_data& sd,uint32 account_id,const char *name);
void clif_guild_allianceack(map_session_data& sd, uint8 flag);
void clif_guild_delalliance(map_session_data& sd,uint32 guild_id,uint32 flag);
void clif_guild_oppositionack(map_session_data& sd,uint8 flag);
void clif_guild_broken( map_session_data& sd, int flag );
void clif_guild_xy( map_session_data& sd );
void clif_guild_xy_single( map_session_data& sd, map_session_data& tsd );

27
src/map/clif_packetdb.hpp
View File

@ -46,7 +46,6 @@
parseable_packet(0x0094,6,clif_parse_GetCharNameRequest,2);
parseable_packet(0x0096,-1,clif_parse_WisMessage,2,4,28);
parseable_packet(0x0099,-1,clif_parse_Broadcast,2,4);
packet(0x009a,-1);
parseable_packet(0x009b,5,clif_parse_ChangeDir,2,4);
packet( HEADER_ZC_ITEM_ENTRY, sizeof( struct PACKET_ZC_ITEM_ENTRY ) );
packet(0x009e,17);
@ -60,7 +59,6 @@
packet( useItemAckType, sizeof( struct PACKET_ZC_USE_ITEM_ACK ) );
parseable_packet(0x00a9,6,clif_parse_EquipItem,2,4);
parseable_packet(0x00ab,4,clif_parse_UnequipItem,2);
packet(0x00ac,7);
packet(0x00ae,-1);
parseable_packet(0x00b2,3,clif_parse_Restart,2);
parseable_packet(0x00b8,7,clif_parse_NpcSelectMenu,2,6);
@ -88,12 +86,10 @@
packet(0x00d4,-1);
parseable_packet(0x00d5,-1,clif_parse_CreateChatRoom,2,4,6,7,15);
packet(0x00d7,-1);
packet(0x00d8,6);
parseable_packet(0x00d9,14,clif_parse_ChatAddMember,2,6);
packet(0x00dc,28);
packet(0x00dd,29);
parseable_packet(0x00de,-1,clif_parse_ChatRoomStatusChange,2,4,6,7,15);
packet(0x00df,-1);
parseable_packet(0x00e0,30,clif_parse_ChangeChatOwner,2,6);
packet(0x00e1,30);
parseable_packet(0x00e2,26,clif_parse_KickFromChat,2);
@ -101,7 +97,6 @@
parseable_packet(0x00e4,6,clif_parse_TradeRequest,2);
packet(0x00e5,26);
parseable_packet(0x00e6,3,clif_parse_TradeAck,2);
packet(0x00e7,3);
parseable_packet(0x00e8,8,clif_parse_TradeAddItem,2,4);
packet(0x00ea,5);
parseable_packet(0x00eb,2,clif_parse_TradeOk,0);
@ -138,9 +133,7 @@
packet(0x0117,18);
parseable_packet(0x0118,2,clif_parse_StopAttack,0);
packet(0x0119,13);
packet(0x011a,15);
parseable_packet(0x011b,20,clif_parse_UseSkillMap,2,4);
packet(0x011c,68);
parseable_packet(0x011d,2,clif_parse_RequestMemo,0);
packet(0x011f,16);
packet( cartlistequipType, -1 );
@ -166,9 +159,7 @@
parseable_packet(0x0149,9,clif_parse_GMReqNoChat,2,6,7);
packet(0x014a,6);
packet(0x014b,27);
packet(0x014c,-1);
parseable_packet(0x014d,2,clif_parse_GuildCheckMaster,0);
packet(0x014e,6);
parseable_packet(0x014f,6,clif_parse_GuildRequestInfo,2);
packet(0x0150,110);
parseable_packet(0x0151,6,clif_parse_GuildRequestEmblem,2);
@ -183,9 +174,7 @@
parseable_packet( HEADER_CZ_REQ_BAN_GUILD, sizeof( PACKET_CZ_REQ_BAN_GUILD ), clif_parse_GuildExpulsion, 0 );
parseable_packet( HEADER_CZ_REQ_DISORGANIZE_GUILD, sizeof( PACKET_CZ_REQ_DISORGANIZE_GUILD ), clif_parse_GuildBreak, 0 );
packet(0x015f,42);
packet(0x0160,-1);
parseable_packet(0x0161,-1,clif_parse_GuildChangePositionInfo,2,4);
packet(0x0163,-1);
packet(0x0164,-1);
parseable_packet(0x0165,30,clif_parse_CreateGuild,2,6);
packet(0x0166,-1);
@ -195,9 +184,7 @@
packet(0x016d,14);
parseable_packet(0x016e,186,clif_parse_GuildChangeNotice,2,6,66);
parseable_packet(0x0170,14,clif_parse_GuildRequestAlliance,2,6,10);
packet(0x0171,30);
parseable_packet(0x0172,10,clif_parse_GuildReplyAlliance,2,6);
packet(0x0173,3);
packet(0x0174,-1);
packet(0x0175,6);
packet(0x0176,106);
@ -207,12 +194,9 @@
packet(0x017b,-1);
parseable_packet(0x017c,6,clif_parse_InsertCard,2,4);
parseable_packet(0x017e,-1,clif_parse_GuildMessage,2,4);
packet(0x017f,-1);
parseable_packet(0x0180,6,clif_parse_GuildOpposition,2);
packet(0x0181,3);
packet(0x0182,106);
parseable_packet(0x0183,10,clif_parse_GuildDelAlliance,2,6);
packet(0x0184,10);
packet(0x0185,34);
packet(0x0187,6);
parseable_packet(0x018a,4,clif_parse_QuitGame,2);
@ -301,8 +285,6 @@
packet(0x01f1,-1);
packet(0x01f2,20);
packet(0x01f3,10);
packet(0x01f4,32);
packet(0x01f5,9);
packet(0x01f6,34);
parseable_packet(0x01f7,14,clif_parse_Adopt_reply,2,6,10);
packet(0x01f8,2);
@ -1227,7 +1209,6 @@
// 2008-11-26aSakexe
#if PACKETVER >= 20081126
packet(0x01a2,37);
packet(0x0441,4);
#endif
// 2008-12-10aSakexe
@ -1501,7 +1482,6 @@
parseable_packet(0x0838,6,clif_parse_SolveCharName,2);
parseable_packet(0x0439,8,clif_parse_UseItem,2,4);
packet(0x08d2,10);
packet(0x08d1,7);
#endif
// 2011-11-02aRagexe
@ -1734,7 +1714,6 @@
parseable_packet(0x0978,6,clif_parse_reqworldinfo,2);
packet(0x0979,50); //ackworldinfo
parseable_packet(0x0998,8,clif_parse_EquipItem,2,4); // CZ_REQ_WEAR_EQUIP_V5
packet(0x099a,9); // take_off_equipv5
packet(0x099b,8); //maptypeproperty2
// New Packets
packet(0x08ff,24); // ZC_EFST_SET_ENTER
@ -1765,7 +1744,6 @@
// 2013-07-31cRagexe
#if PACKETVER >= 20130731
packet(0x09ca,23); // ZC_SKILL_ENTRY5
packet(0x09cb,17); // ZC_USE_SKILL2
#endif
// 2013-08-07Ragexe
@ -1951,9 +1929,8 @@
parseable_packet( HEADER_CZ_REQ_RANDOM_COMBINE_ITEM, -1, clif_parse_laphine_synthesis, 0 );
#endif
// 2016-06-22aRagexeRE
#if PACKETVER >= 20160622
packet(0x0A84,94);
#if PACKETVER_MAIN_NUM >= 20160622 || PACKETVER_RE_NUM >= 20160622 || defined(PACKETVER_ZERO)
parseable_packet( HEADER_CZ_CMD_RESETCOOLTIME, sizeof( PACKET_CZ_CMD_RESETCOOLTIME ), clif_parse_gm_resetcooltime, 0 );
#endif
// 2016-10-12aRagexeRE

46
src/map/guild.cpp
View File

@ -847,7 +847,7 @@ int guild_recv_info(const struct mmo_guild &sg) {
sd->guild = g;
sd->state.gmaster_flag = 1;
clif_name_area(&sd->bl); // [LuzZza]
clif_guild_masterormember(sd);
clif_guild_masterormember(*sd);
}
} else {
before = g->guild;
@ -963,7 +963,7 @@ bool guild_invite( map_session_data& sd, map_session_data* tsd ){
}
// Checking if there no other invitation pending
if( !battle_config.invite_request_check && ( tsd->party_invite > 0 || tsd->trade_partner || tsd->adopt_invite ) ){
if( !battle_config.invite_request_check && ( tsd->party_invite > 0 || tsd->state.trading || tsd->adopt_invite ) ){
clif_guild_inviteack( sd, 0 );
return false;
}
@ -1476,7 +1476,7 @@ int guild_recv_message( int guild_id, uint32 account_id, const char *mes, size_t
auto g = guild_search(guild_id);
if (!g)
return 0;
clif_guild_message(g->guild,account_id,mes,len);
clif_guild_message(g->guild,mes,len);
return 0;
}
@ -1862,7 +1862,7 @@ int guild_reqalliance(map_session_data *sd,map_session_data *tsd) {
// Check, is tsd guild master, if not - cancel alliance. [f0und3r]
if (battle_config.guild_alliance_onlygm && !tsd->state.gmaster_flag) {
clif_guild_allianceack(sd, 5);
clif_guild_allianceack(*sd, 5);
return 0;
}
@ -1877,23 +1877,23 @@ int guild_reqalliance(map_session_data *sd,map_session_data *tsd) {
return 0;
if( guild_get_alliance_count(g->guild,0) >= battle_config.max_guild_alliance ) {
clif_guild_allianceack(sd,4);
clif_guild_allianceack(*sd,4);
return 0;
}
if( guild_get_alliance_count(tg->guild,0) >= battle_config.max_guild_alliance ) {
clif_guild_allianceack(sd,3);
clif_guild_allianceack(*sd,3);
return 0;
}
if( tsd->guild_alliance>0 ){
clif_guild_allianceack(sd,1);
clif_guild_allianceack(*sd,1);
return 0;
}
for (i = 0; i < MAX_GUILDALLIANCE; i++) { // check if already allied
if( g->guild.alliance[i].guild_id==tsd->status.guild_id &&
g->guild.alliance[i].opposition==0){
clif_guild_allianceack(sd,0);
clif_guild_allianceack(*sd,0);
return 0;
}
}
@ -1901,7 +1901,7 @@ int guild_reqalliance(map_session_data *sd,map_session_data *tsd) {
tsd->guild_alliance=sd->status.guild_id;
tsd->guild_alliance_account=sd->status.account_id;
clif_guild_reqalliance(tsd,sd->status.account_id,g->guild.name);
clif_guild_reqalliance(*tsd,sd->status.account_id,g->guild.name);
return 0;
}
@ -1914,7 +1914,7 @@ int guild_reply_reqalliance(map_session_data *sd,uint32 account_id,int flag) {
nullpo_ret(sd);
tsd= map_id2sd( account_id );
if (!tsd) { //Character left? Cancel alliance.
clif_guild_allianceack(sd,3);
clif_guild_allianceack(*sd,3);
return 0;
}
@ -1928,13 +1928,13 @@ int guild_reply_reqalliance(map_session_data *sd,uint32 account_id,int flag) {
auto &tg = tsd->guild;
if (!g || guild_get_alliance_count(g->guild,0) >= battle_config.max_guild_alliance) {
clif_guild_allianceack(sd,4);
clif_guild_allianceack(tsd,3);
clif_guild_allianceack(*sd,4);
clif_guild_allianceack(*tsd,3);
return 0;
}
if (!tg || guild_get_alliance_count(tg->guild,0) >= battle_config.max_guild_alliance) {
clif_guild_allianceack(sd,3);
clif_guild_allianceack(tsd,4);
clif_guild_allianceack(*sd,3);
clif_guild_allianceack(*tsd,4);
return 0;
}
@ -1959,7 +1959,7 @@ int guild_reply_reqalliance(map_session_data *sd,uint32 account_id,int flag) {
sd->guild_alliance=0;
sd->guild_alliance_account=0;
if(tsd!=nullptr)
clif_guild_allianceack(tsd,3);
clif_guild_allianceack(*tsd,3);
}
return 0;
}
@ -1996,14 +1996,14 @@ int guild_opposition(map_session_data *sd,map_session_data *tsd) {
return 0;
if( guild_get_alliance_count(g->guild,1) >= battle_config.max_guild_alliance ) {
clif_guild_oppositionack(sd,1);
clif_guild_oppositionack(*sd,1);
return 0;
}
for (i = 0; i < MAX_GUILDALLIANCE; i++) { // checking relations
if(g->guild.alliance[i].guild_id==tsd->status.guild_id){
if (g->guild.alliance[i].opposition == 1) { // check if not already hostile
clif_guild_oppositionack(sd,2);
clif_guild_oppositionack(*sd,2);
return 0;
}
if(is_agit_start()) // Prevent the changing of alliances to oppositions during WoE.
@ -2049,7 +2049,7 @@ int guild_allianceack(int guild_id1,int guild_id2,uint32 account_id1,uint32 acco
if (flag & 0x70) { // failure
for(i=0;i<2-(flag&1);i++)
if( sd[i]!=nullptr )
clif_guild_allianceack(sd[i],((flag>>4)==i+1)?3:4);
clif_guild_allianceack(*sd[i],((flag>>4)==i+1)?3:4);
return 0;
}
@ -2073,16 +2073,16 @@ int guild_allianceack(int guild_id1,int guild_id2,uint32 account_id1,uint32 acco
g[i]->alliance[j].guild_id = 0;
}
if (sd[i] != nullptr) // notify players
clif_guild_delalliance(sd[i],guild_id[1-i],(flag&1));
clif_guild_delalliance(*sd[i],guild_id[1-i],(flag&1));
}
}
if ((flag & 0x0f) == 0) { // alliance notification
if( sd[1]!=nullptr )
clif_guild_allianceack(sd[1],2);
clif_guild_allianceack(*sd[1],2);
} else if ((flag & 0x0f) == 1) { // enemy notification
if( sd[0]!=nullptr )
clif_guild_oppositionack(sd[0],0);
clif_guild_oppositionack(*sd[0],0);
}
@ -2091,7 +2091,7 @@ int guild_allianceack(int guild_id1,int guild_id2,uint32 account_id1,uint32 acco
for(j=0;j<g[i]->max_member;j++) {
map_session_data *sd_mem = g[i]->member[j].sd;
if( sd_mem!=nullptr){
clif_guild_allianceinfo(sd_mem);
clif_guild_allianceinfo(*sd_mem);
// join ally channel
if( channel_config.ally_tmpl.name[0] && (channel_config.ally_tmpl.opt&CHAN_OPT_AUTOJOIN) ) {
@ -2112,7 +2112,7 @@ int guild_broken_sub(struct mmo_guild &g, int guild_id) {
if (g.alliance[i].guild_id == guild_id) {
for (int j = 0; j < g.max_member; j++) {
if (g.member[j].sd)
clif_guild_delalliance(g.member[j].sd, guild_id, g.alliance[i].opposition);
clif_guild_delalliance(*g.member[j].sd, guild_id, g.alliance[i].opposition);
}
intif_guild_alliance(g.guild_id, guild_id, 0, 0, g.alliance[i].opposition | 8);
g.alliance[i].guild_id = 0;

2
src/map/mob.cpp
View File

@ -3682,7 +3682,7 @@ int mob_summonslave(struct mob_data *md2,int *value,int amount,uint16 skill_id)
if (md2->state.copy_master_mode)
md->status.mode = md2->status.mode;
clif_skill_nodamage(&md->bl,&md->bl,skill_id,amount,1);
clif_skill_nodamage(&md->bl,md->bl,skill_id,amount);
}
return 0;

127
src/map/packets.hpp
View File

@ -362,6 +362,38 @@ struct PACKET_ZC_ACK_OPEN_BANKING{
} __attribute__((packed));
DEFINE_PACKET_HEADER(ZC_ACK_OPEN_BANKING, 0x9b7)
#if PACKETVER > 6
struct PACKET_ZC_REQ_EXCHANGE_ITEM{
uint16 packetType;
char requesterName[NAME_LENGTH];
uint32 targetId;
uint16 targetLv;
} __attribute__((packed));
DEFINE_PACKET_HEADER(ZC_REQ_EXCHANGE_ITEM, 0x1f4)
#else
struct PACKET_ZC_REQ_EXCHANGE_ITEM{
uint16 packetType;
char requesterName[NAME_LENGTH];
} __attribute__((packed));
DEFINE_PACKET_HEADER(ZC_REQ_EXCHANGE_ITEM, 0x9a)
#endif
#if PACKETVER > 6
struct PACKET_ZC_ACK_EXCHANGE_ITEM{
uint16 packetType;
uint8 result;
uint32 targetId;
uint16 targetLv;
} __attribute__((packed));
DEFINE_PACKET_HEADER(ZC_ACK_EXCHANGE_ITEM, 0x1f5)
#else
struct PACKET_ZC_ACK_EXCHANGE_ITEM{
uint16 packetType;
uint8 result;
} __attribute__((packed));
DEFINE_PACKET_HEADER(ZC_ACK_EXCHANGE_ITEM, 0xe7)
#endif
struct PACKET_ZC_ACK_ADD_EXCHANGE_ITEM {
int16 packetType;
uint16 index;
@ -728,6 +760,32 @@ struct PACKET_ZC_OPEN_EDITDLGSTR {
} __attribute__((packed));
DEFINE_PACKET_HEADER(ZC_OPEN_EDITDLGSTR, 0x1d4)
struct PACKET_ZC_ACK_REQ_ALLY_GUILD {
int16 packetType;
uint8 flag;
} __attribute__((packed));
DEFINE_PACKET_HEADER(ZC_ACK_REQ_ALLY_GUILD, 0x173)
struct PACKET_ZC_DELETE_RELATED_GUILD {
int16 packetType;
uint32 allyID;
uint32 flag;
} __attribute__((packed));
DEFINE_PACKET_HEADER(ZC_DELETE_RELATED_GUILD, 0x184)
struct PACKET_ZC_REQ_ALLY_GUILD {
int16 packetType;
uint32 inviterId;
char inviterGuildName[NAME_LENGTH];
} __attribute__((packed));
DEFINE_PACKET_HEADER(ZC_REQ_ALLY_GUILD, 0x171)
struct PACKET_ZC_ACK_REQ_HOSTILE_GUILD {
int16 packetType;
uint8 flag;
} __attribute__((packed));
DEFINE_PACKET_HEADER(ZC_ACK_REQ_HOSTILE_GUILD, 0x181)
struct PACKET_ZC_COMPASS {
int16 packetType;
uint32 npcId;
@ -759,6 +817,12 @@ struct PACKET_ZC_CARTOFF {
} __attribute__((packed));
DEFINE_PACKET_HEADER(ZC_CARTOFF, 0x12b)
struct PACKET_ZC_ACK_GUILD_MENUINTERFACE {
int16 packetType;
int menuFlag;
} __attribute__((packed));
DEFINE_PACKET_HEADER(ZC_ACK_GUILD_MENUINTERFACE, 0x014e)
struct PACKET_ZC_NOTIFY_POSITION_TO_GUILDM {
int16 packetType;
uint32 aid;
@ -767,6 +831,13 @@ struct PACKET_ZC_NOTIFY_POSITION_TO_GUILDM {
} __attribute__((packed));
DEFINE_PACKET_HEADER(ZC_NOTIFY_POSITION_TO_GUILDM, 0x1eb)
struct PACKET_ZC_GUILD_CHAT {
int16 packetType;
int16 packetLength;
char message[];
} __attribute__((packed));
DEFINE_PACKET_HEADER(ZC_GUILD_CHAT, 0x17f)
struct PACKET_ZC_STATUS {
int16 packetType;
uint16 point;
@ -846,12 +917,50 @@ struct PACKET_ZC_PAR_CHANGE_USER {
} __attribute__((packed));
DEFINE_PACKET_HEADER(ZC_PAR_CHANGE_USER, 0x1ab)
struct PACKET_ZC_CHANGE_CHATROOM{
uint16 packetType;
uint16 packetSize;
uint32 ownerId;
uint32 chatId;
uint16 limit;
uint16 users;
uint8 flag;
char title[];
} __attribute__((packed));
DEFINE_PACKET_HEADER(ZC_CHANGE_CHATROOM, 0xdf);
struct PACKET_ZC_EQUIP_ARROW {
int16 packetType;
uint16 index;
} __attribute__((packed));
DEFINE_PACKET_HEADER(ZC_EQUIP_ARROW, 0x13c)
#if PACKETVER >= 20130000
struct PACKET_ZC_REQ_TAKEOFF_EQUIP_ACK{
uint16 packetType;
uint16 index;
uint32 wearLocation;
uint8 flag;
} __attribute__((packed));
DEFINE_PACKET_HEADER(ZC_REQ_TAKEOFF_EQUIP_ACK, 0x99a)
#elif PACKETVER >= 20110824
struct PACKET_ZC_REQ_TAKEOFF_EQUIP_ACK{
uint16 packetType;
uint16 index;
uint16 wearLocation;
uint8 flag;
} __attribute__((packed));
DEFINE_PACKET_HEADER(ZC_REQ_TAKEOFF_EQUIP_ACK, 0x8d1)
#else
struct PACKET_ZC_REQ_TAKEOFF_EQUIP_ACK{
uint16 packetType;
uint16 index;
uint16 wearLocation;
bool flag;
} __attribute__((packed));
DEFINE_PACKET_HEADER(ZC_REQ_TAKEOFF_EQUIP_ACK, 0xac)
#endif
struct PACKET_ZC_CLOSE_STORE {
int16 packetType;
} __attribute__((packed));
@ -906,6 +1015,12 @@ struct PACKET_ZC_REFUSE_ENTER_ROOM {
} __attribute__((packed));
DEFINE_PACKET_HEADER(ZC_REFUSE_ENTER_ROOM, 0xda);
struct PACKET_ZC_DESTROY_ROOM {
int16 packetType;
uint32 chatId;
} __attribute__((packed));
DEFINE_PACKET_HEADER(ZC_DESTROY_ROOM, 0xd8);
struct PACKET_ZC_ENTER_ROOM_sub{
uint32 flag;
char name[NAME_LENGTH];
@ -1003,6 +1118,12 @@ struct PACKET_ZC_SKILL_DISAPPEAR {
} __attribute__((packed));
DEFINE_PACKET_HEADER(ZC_SKILL_DISAPPEAR, 0x120);
struct PACKET_ZC_SKILLINFO_DELETE {
uint16 packetType;
uint16 skillID;
} __attribute__((packed));
DEFINE_PACKET_HEADER(ZC_SKILLINFO_DELETE, 0x441);
struct PACKET_ZC_SKILL_UPDATE {
int16 packetType;
uint32 GID;
@ -1286,6 +1407,12 @@ DEFINE_PACKET_HEADER(CZ_REQ_STYLE_CHANGE2, 0xafc)
DEFINE_PACKET_HEADER(ZC_REMOVE_EFFECT, 0x0b0d)
DEFINE_PACKET_HEADER(ZC_FEED_MER, 0x22f)
DEFINE_PACKET_HEADER(ZC_FEED_PET, 0x1a3)
#if PACKETVER_MAIN_NUM >= 20170502 || PACKETVER_RE_NUM >= 20170419 || defined(PACKETVER_ZERO)
DEFINE_PACKET_HEADER(ZC_WARPLIST, 0xabe)
#else
DEFINE_PACKET_HEADER(ZC_WARPLIST, 0x11c)
#endif
const int16 MAX_INVENTORY_ITEM_PACKET_NORMAL = ( ( INT16_MAX - ( sizeof( struct packet_itemlist_normal ) - ( sizeof( struct NORMALITEM_INFO ) * MAX_ITEMLIST) ) ) / sizeof( struct NORMALITEM_INFO ) );
const int16 MAX_INVENTORY_ITEM_PACKET_EQUIP = ( ( INT16_MAX - ( sizeof( struct packet_itemlist_equip ) - ( sizeof( struct EQUIPITEM_INFO ) * MAX_ITEMLIST ) ) ) / sizeof( struct EQUIPITEM_INFO ) );

2
src/map/party.cpp
View File

@ -446,7 +446,7 @@ bool party_invite( map_session_data& sd, map_session_data *tsd ){
return false;
}
if( !battle_config.invite_request_check && ( tsd->guild_invite > 0 || tsd->trade_partner || tsd->adopt_invite ) ){
if( !battle_config.invite_request_check && ( tsd->guild_invite > 0 || tsd->state.trading || tsd->adopt_invite ) ){
clif_party_invite_reply( sd, tsd->status.name, PARTY_REPLY_JOIN_OTHER_PARTY );
return false;
}

18
src/map/pc.cpp
View File

@ -5345,7 +5345,7 @@ bool pc_skill(map_session_data* sd, uint16 skill_id, int level, enum e_addskill_
sd->status.skill[idx].flag = SKILL_FLAG_PERMANENT;
if (level == 0) { //Remove skill.
sd->status.skill[idx].id = 0;
clif_deleteskill(sd,skill_id);
clif_deleteskill(*sd,skill_id);
} else
clif_addskill(sd,skill_id);
if (!skill_get_inf(skill_id) || pc_checkskill_summoner(sd, SUMMONER_POWER_LAND) >= 20 || pc_checkskill_summoner(sd, SUMMONER_POWER_SEA) >= 20) //Only recalculate for passive skills.
@ -5380,7 +5380,7 @@ bool pc_skill(map_session_data* sd, uint16 skill_id, int level, enum e_addskill_
sd->status.skill[idx].flag = SKILL_FLAG_PERM_GRANTED;
if (level == 0) { //Remove skill.
sd->status.skill[idx].id = 0;
clif_deleteskill(sd,skill_id);
clif_deleteskill(*sd,skill_id);
} else
clif_addskill(sd,skill_id);
if (!skill_get_inf(skill_id) || pc_checkskill_summoner(sd, SUMMONER_POWER_LAND) >= 20 || pc_checkskill_summoner(sd, SUMMONER_POWER_SEA) >= 20) //Only recalculate for passive skills.
@ -5462,7 +5462,7 @@ bool pc_skill_plagiarism_reset(map_session_data &sd, uint8 type)
sd.status.skill[idx].id = 0;
sd.status.skill[idx].lv = 0;
sd.status.skill[idx].flag = SKILL_FLAG_PERMANENT;
clif_deleteskill(&sd, skill_id);
clif_deleteskill(sd, skill_id);
if (type == 1) {
sd.cloneskill_idx = 0;
@ -10053,7 +10053,7 @@ bool pc_revive_item(map_session_data *sd) {
else
pc_delitem(sd, item_position, 1, 0, 1, LOG_TYPE_CONSUME);
clif_skill_nodamage(&sd->bl, &sd->bl, ALL_RESURRECTION, 4, 1);
clif_skill_nodamage(&sd->bl, sd->bl, ALL_RESURRECTION, 4);
return true;
}
@ -12262,18 +12262,18 @@ bool pc_unequipitem(map_session_data *sd, int n, int flag) {
nullpo_retr(false,sd);
if (n < 0 || n >= MAX_INVENTORY) {
clif_unequipitemack(sd,0,0,0);
clif_unequipitemack(*sd,0,0,false);
return false;
}
if (!(pos = sd->inventory.u.items_inventory[n].equip)) {
clif_unequipitemack(sd,n,0,0);
clif_unequipitemack(*sd,n,0,false);
return false; //Nothing to unequip
}
// status change that makes player cannot unequip equipment
if (!(flag&2) && sd->sc.count &&( sd->sc.cant.unequip ||
(sd->sc.getSCE(SC_PYROCLASTIC) && sd->inventory_data[n]->type == IT_WEAPON))) // can't switch weapon
{
clif_unequipitemack(sd,n,0,0);
clif_unequipitemack(*sd,n,0,false);
return false;
}
@ -12312,7 +12312,7 @@ bool pc_unequipitem(map_session_data *sd, int n, int flag) {
if(pos & EQP_SHOES)
clif_changelook(&sd->bl,LOOK_SHOES,0);
clif_unequipitemack(sd,n,pos,1);
clif_unequipitemack(*sd,n,pos,true);
pc_set_costume_view(sd);
status_db.removeByStatusFlag(&sd->bl, { SCF_REMOVEONUNEQUIP });
@ -12333,7 +12333,7 @@ bool pc_unequipitem(map_session_data *sd, int n, int flag) {
if (idx >= 0) {
sd->equip_index[EQI_AMMO] = -1;
clif_unequipitemack(sd, idx, sd->inventory.u.items_inventory[idx].equip, 1);
clif_unequipitemack(*sd, idx, sd->inventory.u.items_inventory[idx].equip, true);
pc_unequipitem_sub(sd, idx, 0);
}
}

6
src/map/pc.hpp
View File

@ -706,7 +706,11 @@ public:
int united_soul[MAX_UNITED_SOULS]; // Stores the account ID's of character's who's soul is united.
int servant_sign[MAX_SERVANT_SIGN]; // Stores the account ID's of character's with a servant sign.
int trade_partner;
struct{
uint32 id;
unsigned int lv;
}trade_partner;
struct s_deal {
struct s_item {
short index, amount;

6
src/map/pet.cpp
View File

@ -1192,7 +1192,7 @@ int pet_select_egg(map_session_data *sd,short egg_index)
if(egg_index < 0 || egg_index >= MAX_INVENTORY)
return 0; //Forged packet!
if(sd->trade_partner) //The player have trade in progress.
if(sd->state.trading) //The player have trade in progress.
return 0;
std::shared_ptr<s_pet_db> pet = pet_db_search(sd->inventory.u.items_inventory[egg_index].nameid, PET_EGG);
@ -2073,7 +2073,7 @@ TIMER_FUNC(pet_recovery_timer){
if(sd->sc.getSCE(pd->recovery->type)) {
//Display a heal animation?
//Detoxify is chosen for now.
clif_skill_nodamage(&pd->bl,&sd->bl,TF_DETOXIFY,1,1);
clif_skill_nodamage(&pd->bl,sd->bl,TF_DETOXIFY,1);
status_change_end(&sd->bl, pd->recovery->type);
clif_emotion(&pd->bl, ET_OK);
}
@ -2116,7 +2116,7 @@ TIMER_FUNC(pet_heal_timer){
pet_stop_attack(pd);
pet_stop_walking(pd,1);
clif_skill_nodamage(&pd->bl,&sd->bl,AL_HEAL,pd->s_skill->lv,1);
clif_skill_nodamage(&pd->bl,sd->bl,AL_HEAL,pd->s_skill->lv);
status_heal(&sd->bl, pd->s_skill->lv,0, 0);
pd->s_skill->timer = add_timer(tick+pd->s_skill->delay*1000,pet_heal_timer,sd->bl.id,0);
return 0;

4
src/map/quest.cpp
View File

@ -242,7 +242,7 @@ uint64 QuestDatabase::parseBodyNode(const ryml::NodeRef& node) {
}
if (constant < SZ_SMALL || constant > SZ_ALL) {
this->invalidWarning(targetNode["size"], "Unsupported size %s, skipping.\n", size_.c_str());
this->invalidWarning(targetNode["Size"], "Unsupported size %s, skipping.\n", size_.c_str());
return 0;
}
@ -385,7 +385,7 @@ uint64 QuestDatabase::parseBodyNode(const ryml::NodeRef& node) {
}
if (!this->nodeExists(dropNode, "Rate")) {
this->invalidWarning(dropNode["Item"], "Drops has no Rate value specified, skipping.\n");
this->invalidWarning(dropNode["Rate"], "Drops has no Rate value specified, skipping.\n");
continue;
}

2
src/map/script.cpp
View File

@ -15343,7 +15343,7 @@ static inline void script_skill_effect( block_list& bl, uint16 skill_id, uint16
clif_skill_poseffect(&bl, skill_id, skill_lv, x, y, gettick());
break;
case CAST_NODAMAGE:
clif_skill_nodamage(&bl, &bl, skill_id, skill_lv, 1);
clif_skill_nodamage(&bl, bl, skill_id, skill_lv);
break;
case CAST_DAMAGE:
clif_skill_damage(&bl, &bl, gettick(), status_get_amotion(&bl), status_get_dmotion(&bl), 0, 1, skill_id, skill_lv, skill_get_hit(skill_id));

886
src/map/skill.cpp
View File

File diff suppressed because it is too large Load Diff

14
src/map/status.cpp
View File

@ -1647,7 +1647,7 @@ int status_damage(struct block_list *src,struct block_list *target,int64 dhp, in
else
status_revive(target, sc->getSCE(SC_KAIZEL)->val2, 0);
status_change_clear(target,0);
clif_skill_nodamage(target,target,ALL_RESURRECTION,1,1);
clif_skill_nodamage(target,*target,ALL_RESURRECTION,1);
sc_start(src,target,SC_KYRIE,100,10,time);
if( target->type == BL_MOB )
@ -1660,7 +1660,7 @@ int status_damage(struct block_list *src,struct block_list *target,int64 dhp, in
if (sc && sc->getSCE(SC_ULTIMATE_S) && !map_flag_gvg2(target->m)) {
status_revive(target, 100, 100);
status_change_clear(target, 0);
clif_skill_nodamage(target, target, ALL_RESURRECTION, 1, 1);
clif_skill_nodamage(target, *target, ALL_RESURRECTION, 1);
if (target->type == BL_MOB)
((TBL_MOB*)target)->state.rebirth = 1;
@ -4914,7 +4914,7 @@ int status_calc_pc_sub(map_session_data* sd, uint8 opt)
// Client doesn't delete unavailable skills even if we refresh the skill tree, individually delete them.
for (i = 0; i < MAX_SKILL; i++) {
if (b_skill[i].id != 0 && sd->status.skill[i].id == 0)
clif_deleteskill(sd, b_skill[i].id, true);
clif_deleteskill(*sd, b_skill[i].id, true);
}
#endif
clif_skillinfoblock(sd);
@ -13139,19 +13139,19 @@ int status_change_start(struct block_list* src, struct block_list* bl,enum sc_ty
switch(sce->val1) {
case TK_STORMKICK:
skill_combo_toggle_inf(bl, TK_JUMPKICK, 0);
clif_skill_nodamage(bl,bl,TK_READYSTORM,1,1);
clif_skill_nodamage(bl,*bl,TK_READYSTORM,1);
break;
case TK_DOWNKICK:
skill_combo_toggle_inf(bl, TK_JUMPKICK, 0);
clif_skill_nodamage(bl,bl,TK_READYDOWN,1,1);
clif_skill_nodamage(bl,*bl,TK_READYDOWN,1);
break;
case TK_TURNKICK:
skill_combo_toggle_inf(bl, TK_JUMPKICK, 0);
clif_skill_nodamage(bl,bl,TK_READYTURN,1,1);
clif_skill_nodamage(bl,*bl,TK_READYTURN,1);
break;
case TK_COUNTER:
skill_combo_toggle_inf(bl, TK_JUMPKICK, 0);
clif_skill_nodamage(bl,bl,TK_READYCOUNTER,1,1);
clif_skill_nodamage(bl,*bl,TK_READYCOUNTER,1);
break;
default: // Rest just toggle inf to enable autotarget
skill_combo_toggle_inf(bl,sce->val1,INF_SELF_SKILL);

94
src/map/trade.cpp
View File

@ -38,54 +38,58 @@ void trade_traderequest(map_session_data *sd, map_session_data *target_sd)
}
if (target_sd == nullptr || sd == target_sd) {
clif_tradestart(sd, 1); // character does not exist
clif_traderesponse(*sd, TRADE_ACK_CHARNOTEXIST);
return;
}
if (target_sd->npc_id) { // Trade fails if you are using an NPC.
clif_tradestart(sd, 2);
clif_traderesponse(*sd, TRADE_ACK_FAILED);
return;
}
if (!battle_config.invite_request_check) {
if (target_sd->guild_invite > 0 || target_sd->party_invite > 0 || target_sd->adopt_invite) {
clif_tradestart(sd, 2);
clif_traderesponse(*sd, TRADE_ACK_FAILED);
return;
}
}
if ( sd->trade_partner != 0 ) { // If a character tries to trade to another one then cancel the previous one
map_session_data *previous_sd = map_id2sd(sd->trade_partner);
if ( sd->trade_partner.id != 0 ) { // If a character tries to trade to another one then cancel the previous one
map_session_data *previous_sd = map_id2sd(sd->trade_partner.id);
if( previous_sd != nullptr ){
previous_sd->trade_partner = 0;
previous_sd->trade_partner = {0,0};
clif_tradecancelled( *previous_sd );
} // Once cancelled then continue to the new one.
sd->trade_partner = 0;
sd->trade_partner = {0,0};
clif_tradecancelled( *sd );
}
if (target_sd->trade_partner != 0) {
clif_tradestart(sd, 2); // person is in another trade
if (target_sd->trade_partner.id != 0) {
clif_traderesponse(*sd, TRADE_ACK_FAILED); // person is in another trade
return;
}
if (!pc_can_give_items(sd) || !pc_can_give_items(target_sd)) { // check if both GMs are allowed to trade
clif_displaymessage(sd->fd, msg_txt(sd,246));
clif_tradestart(sd, 2); // GM is not allowed to trade
clif_traderesponse(*sd, TRADE_ACK_FAILED); // GM is not allowed to trade
return;
}
// Players can not request trade from far away, unless they are allowed to use @trade.
if (!pc_can_use_command(sd, "trade", COMMAND_ATCOMMAND) &&
(sd->bl.m != target_sd->bl.m || !check_distance_bl(&sd->bl, &target_sd->bl, TRADE_DISTANCE))) {
clif_tradestart(sd, 0); // too far
clif_traderesponse(*sd, TRADE_ACK_TOOFAR);
return ;
}
target_sd->trade_partner = sd->status.account_id;
sd->trade_partner = target_sd->status.account_id;
clif_traderequest(target_sd, sd->status.name);
target_sd->trade_partner.id = sd->status.account_id;
target_sd->trade_partner.lv = sd->status.base_level;
sd->trade_partner.id = target_sd->status.account_id;
sd->trade_partner.lv = target_sd->status.base_level;
clif_traderequest(*target_sd, sd->status.name);
}
@ -107,28 +111,28 @@ void trade_tradeack(map_session_data *sd, int type)
nullpo_retv(sd);
if (sd->state.trading || !sd->trade_partner)
if (sd->state.trading || !sd->trade_partner.id)
return; // Already trading or no partner set.
if ((tsd = map_id2sd(sd->trade_partner)) == nullptr) {
clif_tradestart(sd, 1); // Character does not exist
sd->trade_partner=0;
if ((tsd = map_id2sd(sd->trade_partner.id)) == nullptr) {
clif_traderesponse(*sd, TRADE_ACK_CHARNOTEXIST);
sd->trade_partner = {0,0};
return;
}
if (tsd->state.trading || tsd->trade_partner != sd->bl.id) {
clif_tradestart(sd, 2);
sd->trade_partner=0;
if (tsd->state.trading || tsd->trade_partner.id != sd->bl.id) {
clif_traderesponse(*sd, TRADE_ACK_FAILED);
sd->trade_partner = {0,0};
return; // Already trading or wrong partner.
}
if (type == 4) { // Cancel
clif_tradestart(tsd, type);
clif_tradestart(sd, type);
clif_traderesponse(*tsd, TRADE_ACK_CANCEL);
clif_traderesponse(*sd, TRADE_ACK_CANCEL);
sd->state.deal_locked = 0;
sd->trade_partner = 0;
sd->trade_partner = {0,0};
tsd->state.deal_locked = 0;
tsd->trade_partner = 0;
tsd->trade_partner = {0,0};
return;
}
@ -139,21 +143,21 @@ void trade_tradeack(map_session_data *sd, int type)
// Check here as well since the original character could had warped.
if (!pc_can_use_command(sd, "trade", COMMAND_ATCOMMAND) &&
(sd->bl.m != tsd->bl.m || !check_distance_bl(&sd->bl, &tsd->bl, TRADE_DISTANCE))) {
clif_tradestart(sd, 0); // too far
sd->trade_partner=0;
tsd->trade_partner = 0;
clif_traderesponse(*sd, TRADE_ACK_TOOFAR);
sd->trade_partner = {0,0};
tsd->trade_partner = {0,0};
return;
}
// Check if you can start trade.
if (sd->npc_id || sd->state.vending || sd->state.buyingstore || sd->state.storage_flag ||
tsd->npc_id || tsd->state.vending || tsd->state.buyingstore || tsd->state.storage_flag) { // Fail
clif_tradestart(sd, 2);
clif_tradestart(tsd, 2);
clif_traderesponse(*sd, TRADE_ACK_FAILED);
clif_traderesponse(*tsd, TRADE_ACK_FAILED);
sd->state.deal_locked = 0;
sd->trade_partner = 0;
sd->trade_partner = {0,0};
tsd->state.deal_locked = 0;
tsd->trade_partner = 0;
tsd->trade_partner = {0,0};
return;
}
@ -162,8 +166,8 @@ void trade_tradeack(map_session_data *sd, int type)
tsd->state.trading = 1;
memset(&sd->deal, 0, sizeof(sd->deal));
memset(&tsd->deal, 0, sizeof(tsd->deal));
clif_tradestart(tsd, type);
clif_tradestart(sd, type);
clif_traderesponse(*tsd, static_cast<e_ack_trade_response>( type ));
clif_traderesponse(*sd, static_cast<e_ack_trade_response>( type ));
}
/**
@ -356,7 +360,7 @@ void trade_tradeadditem(map_session_data *sd, short index, short amount)
if( !sd->state.trading || sd->state.deal_locked > 0 )
return; // Can't add stuff.
if( (target_sd = map_id2sd(sd->trade_partner)) == nullptr ) {
if( (target_sd = map_id2sd(sd->trade_partner.id)) == nullptr ) {
trade_tradecancel(sd);
return;
}
@ -453,7 +457,7 @@ void trade_tradeaddzeny(map_session_data* sd, int amount)
if( !sd->state.trading || sd->state.deal_locked > 0 )
return; //Can't add stuff.
if( (target_sd = map_id2sd(sd->trade_partner)) == nullptr ) {
if( (target_sd = map_id2sd(sd->trade_partner.id)) == nullptr ) {
trade_tradecancel(sd);
return;
}
@ -478,7 +482,7 @@ void trade_tradeok(map_session_data *sd)
if(sd->state.deal_locked || !sd->state.trading)
return;
if ((target_sd = map_id2sd(sd->trade_partner)) == nullptr) {
if ((target_sd = map_id2sd(sd->trade_partner.id)) == nullptr) {
trade_tradecancel(sd);
return;
}
@ -500,15 +504,15 @@ void trade_tradecancel(map_session_data *sd)
nullpo_retv(sd);
target_sd = map_id2sd(sd->trade_partner);
target_sd = map_id2sd(sd->trade_partner.id);
sd->state.isBoundTrading = 0;
if(!sd->state.trading) { // Not trade accepted
if( target_sd != nullptr ) {
target_sd->trade_partner = 0;
target_sd->trade_partner = {0,0};
clif_tradecancelled( *target_sd );
}
sd->trade_partner = 0;
sd->trade_partner = {0,0};
clif_tradecancelled( *sd );
return;
}
@ -529,7 +533,7 @@ void trade_tradecancel(map_session_data *sd)
sd->state.deal_locked = 0;
sd->state.trading = 0;
sd->trade_partner = 0;
sd->trade_partner = {0,0};
clif_tradecancelled( *sd );
if (!target_sd)
@ -549,7 +553,7 @@ void trade_tradecancel(map_session_data *sd)
}
target_sd->state.deal_locked = 0;
target_sd->trade_partner = 0;
target_sd->trade_partner = {0,0};
target_sd->state.trading = 0;
clif_tradecancelled( *target_sd );
}
@ -569,7 +573,7 @@ void trade_tradecommit(map_session_data *sd)
if (!sd->state.trading || !sd->state.deal_locked) //Locked should be 1 (pressed ok) before you can press trade.
return;
if ((tsd = map_id2sd(sd->trade_partner)) == nullptr) {
if ((tsd = map_id2sd(sd->trade_partner.id)) == nullptr) {
trade_tradecancel(sd);
return;
}
@ -642,12 +646,12 @@ void trade_tradecommit(map_session_data *sd)
}
sd->state.deal_locked = 0;
sd->trade_partner = 0;
sd->trade_partner = {0,0};
sd->state.trading = 0;
sd->state.isBoundTrading = 0;
tsd->state.deal_locked = 0;
tsd->trade_partner = 0;
tsd->trade_partner = {0,0};
tsd->state.trading = 0;
tsd->state.isBoundTrading = 0;

11
src/map/trade.hpp
View File

@ -4,8 +4,19 @@
#ifndef TRADE_HPP
#define TRADE_HPP
#include <common/cbasetypes.hpp>
class map_session_data;
enum e_ack_trade_response : uint8 {
TRADE_ACK_TOOFAR = 0,
TRADE_ACK_CHARNOTEXIST,
TRADE_ACK_FAILED,
TRADE_ACK_ACCEPT,
TRADE_ACK_CANCEL,
TRADE_ACK_BUSY
};
void trade_traderequest(map_session_data *sd, map_session_data *target_sd);
void trade_tradeack(map_session_data *sd,int type);
void trade_tradeadditem(map_session_data *sd,short index,short amount);

6
src/map/unit.cpp
View File

@ -1639,9 +1639,9 @@ TIMER_FUNC(unit_resume_running){
TBL_PC *sd = map_id2sd(id);
if (sd && pc_isridingwug(sd))
clif_skill_nodamage(ud->bl,ud->bl,RA_WUGDASH,ud->skill_lv,sc_start4(ud->bl,ud->bl,SC_WUGDASH,100,ud->skill_lv,unit_getdir(ud->bl),0,0,0));
clif_skill_nodamage(ud->bl,*ud->bl,RA_WUGDASH,ud->skill_lv,sc_start4(ud->bl,ud->bl,SC_WUGDASH,100,ud->skill_lv,unit_getdir(ud->bl),0,0,0));
else
clif_skill_nodamage(ud->bl,ud->bl,TK_RUN,ud->skill_lv,sc_start4(ud->bl,ud->bl,SC_RUN,100,ud->skill_lv,unit_getdir(ud->bl),0,0,0));
clif_skill_nodamage(ud->bl,*ud->bl,TK_RUN,ud->skill_lv,sc_start4(ud->bl,ud->bl,SC_RUN,100,ud->skill_lv,unit_getdir(ud->bl),0,0,0));
if (sd)
clif_walkok(*sd);
@ -3266,7 +3266,7 @@ int unit_remove_map_(struct block_list *bl, clr_type clrtype, const char* file,
if(sd->chatID)
chat_leavechat(sd,0);
if(sd->trade_partner)
if(sd->trade_partner.id > 0)
trade_tradecancel(sd);
searchstore_close(*sd);