// Copyright (c) Athena Dev Teams - Licensed under GNU GPL
// For more information, see LICENCE in the main folder
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <limits.h>
#include "../common/timer.h"
#include "../common/nullpo.h"
#include "../common/malloc.h"
#include "../common/showmsg.h"
#include "../common/grfio.h"
#include "../common/ers.h"
#include "skill.h"
#include "map.h"
#include "clif.h"
#include "pc.h"
#include "status.h"
#include "pet.h"
#include "mob.h"
#include "battle.h"
#include "party.h"
#include "itemdb.h"
#include "script.h"
#include "intif.h"
#include "log.h"
#include "chrif.h"
#include "guild.h"
#include "date.h"
#include "unit.h"
#define SKILLUNITTIMER_INVERVAL 100
//Guild Skills are shifted to these to make them stick into the skill array.
#define GD_SKILLRANGEMIN 900
#define GD_SKILLRANGEMAX GD_SKILLRANGEMIN+MAX_GUILDSKILL
#define HM_SKILLRANGEMIN 800
#define HM_SKILLRANGEMAX HM_SKILLRANGEMIN+MAX_HOMUNSKILL
int skill_names_id[MAX_SKILL_DB];
const struct skill_name_db skill_names[] = {
{ AC_CHARGEARROW, "AC_CHARGEARROW", "Arrow_Repel" } ,
{ AC_CONCENTRATION, "AC_CONCENTRATION", "Improve_Concentration" } ,
{ AC_DOUBLE, "AC_DOUBLE", "Double_Strafe" } ,
{ AC_MAKINGARROW, "AC_MAKINGARROW", "Arrow_Crafting" } ,
{ AC_OWL, "AC_OWL", "Owl's_Eye" } ,
{ AC_SHOWER, "AC_SHOWER", "Arrow_Shower" } ,
{ AC_VULTURE, "AC_VULTURE", "Vulture's_Eye" } ,
{ ALL_RESURRECTION, "ALL_RESURRECTION", "Resurrection" } ,
{ AL_ANGELUS, "AL_ANGELUS", "Angelus" } ,
{ AL_BLESSING, "AL_BLESSING", "Blessing" } ,
{ AL_CRUCIS, "AL_CRUCIS", "Signum_Crusis" } ,
{ AL_CURE, "AL_CURE", "Cure" } ,
{ AL_DECAGI, "AL_DECAGI", "Decrease_AGI" } ,
{ AL_DEMONBANE, "AL_DEMONBANE", "Demon_Bane" } ,
{ AL_DP, "AL_DP", "Divine_Protection" } ,
{ AL_HEAL, "AL_HEAL", "Heal" } ,
{ AL_HOLYLIGHT, "AL_HOLYLIGHT", "Holy_Light" } ,
{ AL_HOLYWATER, "AL_HOLYWATER", "Aqua_Benedicta" } ,
{ AL_INCAGI, "AL_INCAGI", "Increase_AGI" } ,
{ AL_PNEUMA, "AL_PNEUMA", "Pneuma" } ,
{ AL_RUWACH, "AL_RUWACH", "Ruwach" } ,
{ AL_TELEPORT, "AL_TELEPORT", "Teleport" } ,
{ AL_WARP, "AL_WARP", "Warp_Portal" } ,
{ AM_ACIDTERROR, "AM_ACIDTERROR", "Acid_Terror" } ,
{ AM_AXEMASTERY, "AM_AXEMASTERY", "Axe_Mastery" } ,
{ AM_BERSERKPITCHER, "AM_BERSERKPITCHER", "Aid_Berserk_Potion" } ,
{ AM_BIOETHICS, "AM_BIOETHICS", "Bioethics" } ,
{ AM_CALLHOMUN, "AM_CALLHOMUN", "Call_Homunculus" } ,
{ AM_CANNIBALIZE, "AM_CANNIBALIZE", "Summon_Flora" } ,
{ AM_CP_ARMOR, "AM_CP_ARMOR", "Synthetic_Armor" } ,
{ AM_CP_HELM, "AM_CP_HELM", "Biochemical_Helm" } ,
{ AM_CP_SHIELD, "AM_CP_SHIELD", "Synthetized_Shield" } ,
{ AM_CP_WEAPON, "AM_CP_WEAPON", "Alchemical_Weapon" } ,
{ AM_CULTIVATION, "AM_CULTIVATION", "Cultivation" } ,
{ AM_DEMONSTRATION, "AM_DEMONSTRATION", "Bomb" } ,
{ AM_LEARNINGPOTION, "AM_LEARNINGPOTION", "Potion_Research" } ,
{ AM_PHARMACY, "AM_PHARMACY", "Prepare_Potion" } ,
{ AM_POTIONPITCHER, "AM_POTIONPITCHER", "Aid_Potion" } ,
{ AM_REST, "AM_REST", "Vaporize" } ,
{ AM_RESURRECTHOMUN, "AM_RESURRECTHOMUN", "Homunculus_Resurrection" } ,
{ AM_SPHEREMINE, "AM_SPHEREMINE", "Summon_Marine_Sphere" } ,
{ AM_TWILIGHT1, "AM_TWILIGHT1", "Twilight_Pharmacy_1" } ,
{ AM_TWILIGHT2, "AM_TWILIGHT2", "Twilight_Pharmacy_2" } ,
{ AM_TWILIGHT3, "AM_TWILIGHT3", "Twilight_Pharmacy_3" } ,
{ ASC_BREAKER, "ASC_BREAKER", "Soul_Destroyer" } ,
{ ASC_CDP, "ASC_CDP", "Create_Deadly_Poison" } ,
{ ASC_EDP, "ASC_EDP", "Enchant_Deadly_Poison" } ,
{ ASC_KATAR, "ASC_KATAR", "Advanced_Katar_Mastery" } ,
{ ASC_METEORASSAULT, "ASC_METEORASSAULT", "Meteor_Assault" } ,
{ AS_CLOAKING, "AS_CLOAKING", "Cloaking" } ,
{ AS_ENCHANTPOISON, "AS_ENCHANTPOISON", "Enchant_Poison" } ,
{ AS_GRIMTOOTH, "AS_GRIMTOOTH", "Grimtooth" } ,
{ AS_KATAR, "AS_KATAR", "Katar_Mastery" } ,
{ AS_LEFT, "AS_LEFT", "Lefthand_Mastery" } ,
{ AS_POISONREACT, "AS_POISONREACT", "Poison_React" } ,
{ AS_RIGHT, "AS_RIGHT", "Righthand_Mastery" } ,
{ AS_SONICACCEL, "AS_SONICACCEL", "Sonic_Acceleration" } ,
{ AS_SONICBLOW, "AS_SONICBLOW", "Sonic_Blow" } ,
{ AS_SPLASHER, "AS_SPLASHER", "Venom_Splasher" } ,
{ AS_VENOMDUST, "AS_VENOMDUST", "Venom_Dust" } ,
{ AS_VENOMKNIFE, "AS_VENOMKNIFE", "Throw_Venom_Knife" } ,
{ BA_APPLEIDUN, "BA_APPLEIDUN", "Song_of_Lutie" } ,
{ BA_ASSASSINCROSS, "BA_ASSASSINCROSS", "Impressive_Riff" } ,
{ BA_DISSONANCE, "BA_DISSONANCE", "Unchained_Serenade" } ,
{ BA_FROSTJOKE, "BA_FROSTJOKE", "Unbarring_Octave" } ,
{ BA_MUSICALLESSON, "BA_MUSICALLESSON", "Music_Lessons" } ,
{ BA_MUSICALSTRIKE, "BA_MUSICALSTRIKE", "Melody_Strike" } ,
{ BA_PANGVOICE, "BA_PANGVOICE", "Pang_Voice" } ,
{ BA_POEMBRAGI, "BA_POEMBRAGI", "Magic_Strings" } ,
{ BA_WHISTLE, "BA_WHISTLE", "Perfect_Tablature" } ,
{ BD_ADAPTATION, "BD_ADAPTATION", "Amp" } ,
{ BD_DRUMBATTLEFIELD, "BD_DRUMBATTLEFIELD", "Battle_Theme" } ,
{ BD_ENCORE, "BD_ENCORE", "Encore" } ,
{ BD_ETERNALCHAOS, "BD_ETERNALCHAOS", "Down_Tempo" } ,
{ BD_INTOABYSS, "BD_INTOABYSS", "Power_Cord" } ,
{ BD_LULLABY, "BD_LULLABY", "Lullaby" } ,
{ BD_RICHMANKIM, "BD_RICHMANKIM", "Mental_Sensing" } ,
{ BD_RINGNIBELUNGEN, "BD_RINGNIBELUNGEN", "Harmonic_Lick" } ,
{ BD_ROKISWEIL, "BD_ROKISWEIL", "Classical_Pluck" } ,
{ BD_SIEGFRIED, "BD_SIEGFRIED", "Acoustic_Rhythm" } ,
{ BS_ADRENALINE, "BS_ADRENALINE", "Adrenaline_Rush" } ,
{ BS_ADRENALINE2, "BS_ADRENALINE2", "Advanced_Adrenaline_Rush" } ,
{ BS_AXE, "BS_AXE", "Smith_Axe" } ,
{ BS_DAGGER, "BS_DAGGER", "Smith_Dagger" } ,
{ BS_ENCHANTEDSTONE, "BS_ENCHANTEDSTONE", "Enchantedstone_Craft" } ,
{ BS_FINDINGORE, "BS_FINDINGORE", "Ore_Discovery" } ,
{ BS_GREED, "BS_GREED", "Greed" } ,
{ BS_HAMMERFALL, "BS_HAMMERFALL", "Hammer_Fall" } ,
{ BS_HILTBINDING, "BS_HILTBINDING", "Hilt_Binding" } ,
{ BS_IRON, "BS_IRON", "Iron_Tempering" } ,
{ BS_KNUCKLE, "BS_KNUCKLE", "Smith_Knucklebrace" } ,
{ BS_MACE, "BS_MACE", "Smith_Mace" } ,
{ BS_MAXIMIZE, "BS_MAXIMIZE", "Power_Maximize" } ,
{ BS_ORIDEOCON, "BS_ORIDEOCON", "Oridecon_Research" } ,
{ BS_OVERTHRUST, "BS_OVERTHRUST", "Power-Thrust" } ,
{ BS_REPAIRWEAPON, "BS_REPAIRWEAPON", "Weapon_Repair" } ,
{ BS_SKINTEMPER, "BS_SKINTEMPER", "Skin_Tempering" } ,
{ BS_SPEAR, "BS_SPEAR", "Smith_Spear" } ,
{ BS_STEEL, "BS_STEEL", "Steel_Tempering" } ,
{ BS_SWORD, "BS_SWORD", "Smith_Sword" } ,
{ BS_TWOHANDSWORD, "BS_TWOHANDSWORD", "Smith_Two-handed_Sword" } ,
{ BS_UNFAIRLYTRICK, "BS_UNFAIRLYTRICK", "Unfair_Trick" } ,
{ BS_WEAPONPERFECT, "BS_WEAPONPERFECT", "Weapon_Perfection" } ,
{ BS_WEAPONRESEARCH, "BS_WEAPONRESEARCH", "Weaponry_Research" } ,
{ CG_ARROWVULCAN, "CG_ARROWVULCAN", "Vulcan_Arrow" } ,
{ CG_HERMODE, "CG_HERMODE", "Wand_of_Hermode" } ,
{ CG_LONGINGFREEDOM, "CG_LONGINGFREEDOM", "Longing_for_Freedom" } ,
{ CG_MARIONETTE, "CG_MARIONETTE", "Marionette_Control" } ,
{ CG_MOONLIT, "CG_MOONLIT", "Sheltering_Bliss" } ,
{ CG_TAROTCARD, "CG_TAROTCARD", "Tarot_Card_of_Fate" } ,
{ CH_CHAINCRUSH, "CH_CHAINCRUSH", "Chain_Crush_Combo" } ,
{ CH_PALMSTRIKE, "CH_PALMSTRIKE", "Raging_Palm_Strike" } ,
{ CH_SOULCOLLECT, "CH_SOULCOLLECT", "Zen" } ,
{ CH_TIGERFIST, "CH_TIGERFIST", "Glacier_Fist" } ,
{ CR_ACIDDEMONSTRATION, "CR_ACIDDEMONSTRATION", "Acid_Demonstration" } ,
{ CR_ALCHEMY, "CR_ALCHEMY", "Alchemy" } ,
{ CR_AUTOGUARD, "CR_AUTOGUARD", "Guard" } ,
{ CR_CULTIVATION, "CR_CULTIVATION", "Plant_Cultivation" } ,
{ CR_DEFENDER, "CR_DEFENDER", "Defending_Aura" } ,
{ CR_DEVOTION, "CR_DEVOTION", "Sacrifice" } ,
{ CR_FULLPROTECTION, "CR_FULLPROTECTION", "Full_Protection" } ,
{ CR_GRANDCROSS, "CR_GRANDCROSS", "Grand_Cross" } ,
{ CR_HOLYCROSS, "CR_HOLYCROSS", "Holy_Cross" } ,
{ CR_PROVIDENCE, "CR_PROVIDENCE", "Resistant_Souls" } ,
{ CR_REFLECTSHIELD, "CR_REFLECTSHIELD", "Shield_Reflect" } ,
{ CR_SHIELDBOOMERANG, "CR_SHIELDBOOMERANG", "Shield_Boomerang" } ,
{ CR_SHIELDCHARGE, "CR_SHIELDCHARGE", "Smite" } ,
{ CR_SHRINK, "CR_SHRINK", "Shrink" } ,
{ CR_SLIMPITCHER, "CR_SLIMPITCHER", "Slim_Pitcher" } ,
{ CR_SPEARQUICKEN, "CR_SPEARQUICKEN", "Spear_Quicken" } ,
{ CR_SYNTHESISPOTION, "CR_SYNTHESISPOTION", "Potion_Synthesis" } ,
{ CR_TRUST, "CR_TRUST", "Faith" } ,
{ DC_DANCINGLESSON, "DC_DANCINGLESSON", "Dance_Lessons" } ,
{ DC_DONTFORGETME, "DC_DONTFORGETME", "Slow_Grace" } ,
{ DC_FORTUNEKISS, "DC_FORTUNEKISS", "Lady_Luck" } ,
{ DC_HUMMING, "DC_HUMMING", "Focus_Ballet" } ,
{ DC_SCREAM, "DC_SCREAM", "Dazzler" } ,
{ DC_SERVICEFORYOU, "DC_SERVICEFORYOU", "Gypsy's_Kiss" } ,
{ DC_THROWARROW, "DC_THROWARROW", "Slinging_Arrow" } ,
{ DC_UGLYDANCE, "DC_UGLYDANCE", "Hip_Shaker" } ,
{ DC_WINKCHARM, "DC_WINKCHARM", "Sexy_Wink" } ,
{ GD_APPROVAL, "GD_APPROVAL", "Official_Guild_Approval" } ,
{ GD_BATTLEORDER, "GD_BATTLEORDER", "Battle_Command" } ,
{ GD_DEVELOPMENT, "GD_DEVELOPMENT", "Permanent_Development" } ,
{ GD_EMERGENCYCALL, "GD_EMERGENCYCALL", "Urgent_Call" } ,
{ GD_EXTENSION, "GD_EXTENSION", "Guild_Extension" } ,
{ GD_GLORYGUILD, "GD_GLORYGUILD", "Glory_of_Guild" } ,
{ GD_GLORYWOUNDS, "GD_GLORYWOUNDS", "Glorious_Wounds" } ,
{ GD_GUARDUP, "GD_GUARDUP", "Strengthen_Guardian" } ,
{ GD_HAWKEYES, "GD_HAWKEYES", "Sharp_Gaze" } ,
{ GD_KAFRACONTRACT, "GD_KAFRACONTRACT", "Contract_with_Kafra" } ,
{ GD_LEADERSHIP, "GD_LEADERSHIP", "Great_Leadership" } ,
{ GD_REGENERATION, "GD_REGENERATION", "Regeneration" } ,
{ GD_RESTORE, "GD_RESTORE", "Restoration" } ,
{ GD_SOULCOLD, "GD_SOULCOLD", "Cold_Heart" } ,
{ GS_ADJUSTMENT, "GS_ADJUSTMENT", "Adjustment" } ,
{ GS_BULLSEYE, "GS_BULLSEYE", "Bulls_Eye" } ,
{ GS_CHAINACTION, "GS_CHAINACTION", "Chain_Action" } ,
{ GS_CRACKER, "GS_CRACKER", "Cracker" } ,
{ GS_DESPERADO, "GS_DESPERADO", "Desperado" } ,
{ GS_DISARM, "GS_DISARM", "Disarm" } ,
{ GS_DUST, "GS_DUST", "Dust" } ,
{ GS_FLING, "GS_FLING", "Fling" } ,
{ GS_FULLBUSTER, "GS_FULLBUSTER", "Full_Buster" } ,
{ GS_GATLINGFEVER, "GS_GATLINGFEVER", "Gatling_Fever" } ,
{ GS_GLITTERING, "GS_GLITTERING", "Flip_the_Coin" } ,
{ GS_GROUNDDRIFT, "GS_GROUNDDRIFT", "Ground_Drift" } ,
{ GS_INCREASING, "GS_INCREASING", "Increasing_Accuracy" } ,
{ GS_MADNESSCANCEL, "GS_MADNESSCANCEL", "Madness_Canceler" } ,
{ GS_MAGICALBULLET, "GS_MAGICALBULLET", "Magical_Bullet" } ,
{ GS_PIERCINGSHOT, "GS_PIERCINGSHOT", "Piercing_Shot" } ,
{ GS_RAPIDSHOWER, "GS_RAPIDSHOWER", "Rapid_Shower" } ,
{ GS_SINGLEACTION, "GS_SINGLEACTION", "Single_Action" } ,
{ GS_SNAKEEYE, "GS_SNAKEEYE", "Snake_Eye" } ,
{ GS_SPREADATTACK, "GS_SPREADATTACK", "Spread_Attack" } ,
{ GS_TRACKING, "GS_TRACKING", "Tracking" } ,
{ GS_TRIPLEACTION, "GS_TRIPLEACTION", "Triple_Action" } ,
{ HP_ASSUMPTIO, "HP_ASSUMPTIO", "Assumptio" } ,
{ HP_BASILICA, "HP_BASILICA", "Basilica" } ,
{ HP_MANARECHARGE, "HP_MANARECHARGE", "Mana_Recharge" } ,
{ HP_MEDITATIO, "HP_MEDITATIO", "Meditatio" } ,
{ HT_ANKLESNARE, "HT_ANKLESNARE", "Ankle_Snare" } ,
{ HT_BEASTBANE, "HT_BEASTBANE", "Beast_Bane" } ,
{ HT_BLASTMINE, "HT_BLASTMINE", "Blast_Mine" } ,
{ HT_BLITZBEAT, "HT_BLITZBEAT", "Blitz_Beat" } ,
{ HT_CLAYMORETRAP, "HT_CLAYMORETRAP", "Claymore_Trap" } ,
{ HT_DETECTING, "HT_DETECTING", "Detect" } ,
{ HT_FALCON, "HT_FALCON", "Falconry_Mastery" } ,
{ HT_FLASHER, "HT_FLASHER", "Flasher" } ,
{ HT_FREEZINGTRAP, "HT_FREEZINGTRAP", "Freezing_Trap" } ,
{ HT_LANDMINE, "HT_LANDMINE", "Land_Mine" } ,
{ HT_PHANTASMIC, "HT_PHANTASMIC", "Phantasmic_Arrow" } ,
{ HT_POWER, "HT_POWER", "Beast_Strafing" } ,
{ HT_REMOVETRAP, "HT_REMOVETRAP", "Remove_Trap" } ,
{ HT_SANDMAN, "HT_SANDMAN", "Sandman" } ,
{ HT_SHOCKWAVE, "HT_SHOCKWAVE", "Shockwave_Trap" } ,
{ HT_SKIDTRAP, "HT_SKIDTRAP", "Skid_Trap" } ,
{ HT_SPRINGTRAP, "HT_SPRINGTRAP", "Spring_Trap" } ,
{ HT_STEELCROW, "HT_STEELCROW", "Steel_Crow" } ,
{ HT_TALKIEBOX, "HT_TALKIEBOX", "Talkie_Box" } ,
{ HW_GANBANTEIN, "HW_GANBANTEIN", "Ganbantein" } ,
{ HW_GRAVITATION, "HW_GRAVITATION", "Gravitation_Field" } ,
{ HW_MAGICCRASHER, "HW_MAGICCRASHER", "Stave_Crasher" } ,
{ HW_MAGICPOWER, "HW_MAGICPOWER", "Mystical_Amplification" } ,
{ HW_NAPALMVULCAN, "HW_NAPALMVULCAN", "Napalm_Vulcan" } ,
{ HW_SOULDRAIN, "HW_SOULDRAIN", "Soul_Drain" } ,
{ ITM_TOMAHAWK, "ITM_TOMAHAWK", "Tomahawk_Throwing" } ,
{ KN_AUTOCOUNTER, "KN_AUTOCOUNTER", "Counter_Attack" } ,
{ KN_BOWLINGBASH, "KN_BOWLINGBASH", "Bowling_Bash" } ,
{ KN_BRANDISHSPEAR, "KN_BRANDISHSPEAR", "Brandish_Spear" } ,
{ KN_CAVALIERMASTERY, "KN_CAVALIERMASTERY", "Cavalier_Mastery" } ,
{ KN_CHARGEATK, "KN_CHARGEATK", "Charge_Attack" } ,
{ KN_ONEHAND, "KN_ONEHAND", "Onehand_Quicken" } ,
{ KN_PIERCE, "KN_PIERCE", "Pierce" } ,
{ KN_RIDING, "KN_RIDING", "Peco_Peco_Ride" } ,
{ KN_SPEARBOOMERANG, "KN_SPEARBOOMERANG", "Spear_Boomerang" } ,
{ KN_SPEARMASTERY, "KN_SPEARMASTERY", "Spear_Mastery" } ,
{ KN_SPEARSTAB, "KN_SPEARSTAB", "Spear_Stab" } ,
{ KN_TWOHANDQUICKEN, "KN_TWOHANDQUICKEN", "Twohand_Quicken" } ,
{ LK_AURABLADE, "LK_AURABLADE", "Aura_Blade" } ,
{ LK_BERSERK, "LK_BERSERK", "Frenzy" } ,
{ LK_CONCENTRATION, "LK_CONCENTRATION", "Spear_Dynamo" } ,
{ LK_HEADCRUSH, "LK_HEADCRUSH", "Traumatic_Blow" } ,
{ LK_JOINTBEAT, "LK_JOINTBEAT", "Vital_Strike" } ,
{ LK_PARRYING, "LK_PARRYING", "Parry" } ,
{ LK_SPIRALPIERCE, "LK_SPIRALPIERCE", "Clashing_Spiral" } ,
{ LK_TENSIONRELAX, "LK_TENSIONRELAX", "Relax" } ,
{ MC_CARTREVOLUTION, "MC_CARTREVOLUTION", "Cart_Revolution" } ,
{ MC_CHANGECART, "MC_CHANGECART", "Change_Cart" } ,
{ MC_DISCOUNT, "MC_DISCOUNT", "Discount" } ,
{ MC_IDENTIFY, "MC_IDENTIFY", "Item_Appraisal" } ,
{ MC_INCCARRY, "MC_INCCARRY", "Enlarge_Weight_Limit" } ,
{ MC_LOUD, "MC_LOUD", "Crazy_Uproar" } ,
{ MC_MAMMONITE, "MC_MAMMONITE", "Mammonite" } ,
{ MC_OVERCHARGE, "MC_OVERCHARGE", "Overcharge" } ,
{ MC_PUSHCART, "MC_PUSHCART", "Pushcart" } ,
{ MC_VENDING, "MC_VENDING", "Vending" } ,
{ MG_COLDBOLT, "MG_COLDBOLT", "Cold_Bolt" } ,
{ MG_ENERGYCOAT, "MG_ENERGYCOAT", "Energy_Coat" } ,
{ MG_FIREBALL, "MG_FIREBALL", "Fire_Ball" } ,
{ MG_FIREBOLT, "MG_FIREBOLT", "Fire_Bolt" } ,
{ MG_FIREWALL, "MG_FIREWALL", "Fire_Wall" } ,
{ MG_FROSTDIVER, "MG_FROSTDIVER", "Frost_Diver" } ,
{ MG_LIGHTNINGBOLT, "MG_LIGHTNINGBOLT", "Lightening_Bolt" } ,
{ MG_NAPALMBEAT, "MG_NAPALMBEAT", "Napalm_Beat" } ,
{ MG_SAFETYWALL, "MG_SAFETYWALL", "Safety_Wall" } ,
{ MG_SIGHT, "MG_SIGHT", "Sight" } ,
{ MG_SOULSTRIKE, "MG_SOULSTRIKE", "Soul_Strike" } ,
{ MG_SRECOVERY, "MG_SRECOVERY", "Increase_SP_Recovery" } ,
{ MG_STONECURSE, "MG_STONECURSE", "Stone_Curse" } ,
{ MG_THUNDERSTORM, "MG_THUNDERSTORM", "Thunderstorm" } ,
{ MO_ABSORBSPIRITS, "MO_ABSORBSPIRITS", "Spiritual_Sphere_Absorption" } ,
{ MO_BALKYOUNG, "MO_BALKYOUNG", "Ki_Explosion" } ,
{ MO_BLADESTOP, "MO_BLADESTOP", "Root" } ,
{ MO_BODYRELOCATION, "MO_BODYRELOCATION", "Snap" } ,
{ MO_CALLSPIRITS, "MO_CALLSPIRITS", "Summon_Spirit_Sphere" } ,
{ MO_CHAINCOMBO, "MO_CHAINCOMBO", "Raging_Quadruple_Blow" } ,
{ MO_COMBOFINISH, "MO_COMBOFINISH", "Raging_Thrust" } ,
{ MO_DODGE, "MO_DODGE", "Flee" } ,
{ MO_EXPLOSIONSPIRITS, "MO_EXPLOSIONSPIRITS", "Fury" } ,
{ MO_EXTREMITYFIST, "MO_EXTREMITYFIST", "Guillotine_Fist" } ,
{ MO_FINGEROFFENSIVE, "MO_FINGEROFFENSIVE", "Throw_Spirit_Sphere" } ,
{ MO_INVESTIGATE, "MO_INVESTIGATE", "Occult_Impaction" } ,
{ MO_IRONHAND, "MO_IRONHAND", "Iron_Fists" } ,
{ MO_KITRANSLATION, "MO_KITRANSLATION", "Ki_Translation" } ,
{ MO_SPIRITSRECOVERY, "MO_SPIRITSRECOVERY", "Spiritual_Cadence" } ,
{ MO_STEELBODY, "MO_STEELBODY", "Mental_Strength" } ,
{ MO_TRIPLEATTACK, "MO_TRIPLEATTACK", "Raging_Trifecta_Blow" } ,
{ NJ_BAKUENRYU, "NJ_BAKUENRYU", "NJ_BAKUENRYU" } ,
{ NJ_BUNSINJYUTSU, "NJ_BUNSINJYUTSU", "NJ_BUNSINJYUTSU" } ,
{ NJ_HUUJIN, "NJ_HUUJIN", "NJ_HUUJIN" } ,
{ NJ_HUUMA, "NJ_HUUMA", "NJ_HUUMA" } ,
{ NJ_HYOUSENSOU, "NJ_HYOUSENSOU", "NJ_HYOUSENSOU" } ,
{ NJ_HYOUSYOURAKU, "NJ_HYOUSYOURAKU", "NJ_HYOUSYOURAKU" } ,
{ NJ_ISSEN, "NJ_ISSEN", "NJ_ISSEN" } ,
{ NJ_KAENSIN, "NJ_KAENSIN", "NJ_KAENSIN" } ,
{ NJ_KAMAITACHI, "NJ_KAMAITACHI", "NJ_KAMAITACHI" } ,
{ NJ_KASUMIKIRI, "NJ_KASUMIKIRI", "NJ_KASUMIKIRI" } ,
{ NJ_KIRIKAGE, "NJ_KIRIKAGE", "NJ_KIRIKAGE" } ,
{ NJ_KOUENKA, "NJ_KOUENKA", "NJ_KOUENKA" } ,
{ NJ_KUNAI, "NJ_KUNAI", "NJ_KUNAI" } ,
{ NJ_NEN, "NJ_NEN", "NJ_NEN" } ,
{ NJ_NINPOU, "NJ_NINPOU", "NJ_NINPOU" } ,
{ NJ_RAIGEKISAI, "NJ_RAIGEKISAI", "NJ_RAIGEKISAI" } ,
{ NJ_SHADOWJUMP, "NJ_SHADOWJUMP", "NJ_SHADOWJUMP" } ,
{ NJ_SUITON, "NJ_SUITON", "NJ_SUITON" } ,
{ NJ_SYURIKEN, "NJ_SYURIKEN", "NJ_SYURIKEN" } ,
{ NJ_TATAMIGAESHI, "NJ_TATAMIGAESHI", "NJ_TATAMIGAESHI" } ,
{ NJ_TOBIDOUGU, "NJ_TOBIDOUGU", "NJ_TOBIDOUGU" } ,
{ NJ_UTSUSEMI, "NJ_UTSUSEMI", "NJ_UTSUSEMI" } ,
{ NJ_ZENYNAGE, "NJ_ZENYNAGE", "NJ_ZENYNAGE" } ,
{ NPC_AGIUP, "NPC_AGIUP", "NPC_AGIUP" } ,
{ NPC_ATTRICHANGE, "NPC_ATTRICHANGE", "NPC_ATTRICHANGE" } ,
{ NPC_BARRIER, "NPC_BARRIER", "NPC_BARRIER" } ,
{ NPC_BLINDATTACK, "NPC_BLINDATTACK", "NPC_BLINDATTACK" } ,
{ NPC_BLOODDRAIN, "NPC_BLOODDRAIN", "NPC_BLOODDRAIN" } ,
{ NPC_BREAKARMOR, "NPC_BREAKARMOR", "NPC_BREAKARMOR" } ,
{ NPC_BREAKHELM, "NPC_BREAKHELM", "NPC_BREAKHELM" } ,
{ NPC_BREAKSHIELD, "NPC_BREAKSHIELD", "NPC_BREAKSHIELD" } ,
{ NPC_BREAKWEAPON, "NPC_BREAKWEAPON", "NPC_BREAKWEAPON" } ,
{ NPC_CALLSLAVE, "NPC_CALLSLAVE", "NPC_CALLSLAVE" } ,
{ NPC_CHANGEDARKNESS, "NPC_CHANGEDARKNESS", "NPC_CHANGEDARKNESS" } ,
{ NPC_CHANGEFIRE, "NPC_CHANGEFIRE", "NPC_CHANGEFIRE" } ,
{ NPC_CHANGEGROUND, "NPC_CHANGEGROUND", "NPC_CHANGEGROUND" } ,
{ NPC_CHANGEHOLY, "NPC_CHANGEHOLY", "NPC_CHANGEHOLY" } ,
{ NPC_CHANGEPOISON, "NPC_CHANGEPOISON", "NPC_CHANGEPOISON" } ,
{ NPC_CHANGETELEKINESIS, "NPC_CHANGETELEKINESIS", "NPC_CHANGETELEKINESIS" } ,
{ NPC_CHANGEUNDEAD, "NPC_CHANGEUNDEAD", "NPC_CHANGEUNDEAD" } ,
{ NPC_CHANGEWATER, "NPC_CHANGEWATER", "NPC_CHANGEWATER" } ,
{ NPC_CHANGEWIND, "NPC_CHANGEWIND", "NPC_CHANGEWIND" } ,
{ NPC_COMBOATTACK, "NPC_COMBOATTACK", "NPC_COMBOATTACK" } ,
{ NPC_CRITICALSLASH, "NPC_CRITICALSLASH", "NPC_CRITICALSLASH" } ,
{ NPC_CURSEATTACK, "NPC_CURSEATTACK", "NPC_CURSEATTACK" } ,
{ NPC_DARKBLESSING, "NPC_DARKBLESSING", "NPC_DARKBLESSING" } ,
{ NPC_DARKBREATH, "NPC_DARKBREATH", "NPC_DARKBREATH" } ,
{ NPC_DARKCROSS, "NPC_DARKCROSS", "NPC_DARKCROSS" } ,
{ NPC_DARKNESSATTACK, "NPC_DARKNESSATTACK", "NPC_DARKNESSATTACK" } ,
{ NPC_DARKSTRIKE, "NPC_DARKSTRIKE", "NPC_DARKSTRIKE" } ,
{ NPC_DARKTHUNDER, "NPC_DARKTHUNDER", "NPC_DARKTHUNDER" } ,
{ NPC_DEFENDER, "NPC_DEFENDER", "NPC_DEFENDER" } ,
{ NPC_EMOTION, "NPC_EMOTION", "NPC_EMOTION" } ,
{ NPC_EMOTION_ON, "NPC_EMOTION_ON", "NPC_EMOTION_ON" } ,
{ NPC_ENERGYDRAIN, "NPC_ENERGYDRAIN", "NPC_ENERGYDRAIN" } ,
{ NPC_FIREATTACK, "NPC_FIREATTACK", "NPC_FIREATTACK" } ,
{ NPC_GRANDDARKNESS, "NPC_GRANDDARKNESS", "NPC_GRANDDARKNESS" } ,
{ NPC_GROUNDATTACK, "NPC_GROUNDATTACK", "NPC_GROUNDATTACK" } ,
{ NPC_GUIDEDATTACK, "NPC_GUIDEDATTACK", "NPC_GUIDEDATTACK" } ,
{ NPC_HALLUCINATION, "NPC_HALLUCINATION", "NPC_HALLUCINATION" } ,
{ NPC_HOLYATTACK, "NPC_HOLYATTACK", "NPC_HOLYATTACK" } ,
{ NPC_INVISIBLE, "NPC_INVISIBLE", "NPC_INVISIBLE" } ,
{ NPC_KEEPING, "NPC_KEEPING", "NPC_KEEPING" } ,
{ NPC_LICK, "NPC_LICK", "NPC_LICK" } ,
{ NPC_MAGICALATTACK, "NPC_MAGICALATTACK", "NPC_MAGICALATTACK" } ,
{ NPC_MENTALBREAKER, "NPC_MENTALBREAKER", "NPC_MENTALBREAKER" } ,
{ NPC_METAMORPHOSIS, "NPC_METAMORPHOSIS", "NPC_METAMORPHOSIS" } ,
{ NPC_PETRIFYATTACK, "NPC_PETRIFYATTACK", "NPC_PETRIFYATTACK" } ,
{ NPC_PIERCINGATT, "NPC_PIERCINGATT", "NPC_PIERCINGATT" } ,
{ NPC_POISON, "NPC_POISON", "NPC_POISON" } ,
{ NPC_POISONATTACK, "NPC_POISONATTACK", "NPC_POISONATTACK" } ,
{ NPC_POWERUP, "NPC_POWERUP", "NPC_POWERUP" } ,
{ NPC_PROVOCATION, "NPC_PROVOCATION", "NPC_PROVOCATION" } ,
{ NPC_RANDOMATTACK, "NPC_RANDOMATTACK", "NPC_RANDOMATTACK" } ,
{ NPC_RANDOMMOVE, "NPC_RANDOMMOVE", "NPC_RANDOMMOVE" } ,
{ NPC_RANGEATTACK, "NPC_RANGEATTACK", "NPC_RANGEATTACK" } ,
{ NPC_REBIRTH, "NPC_REBIRTH", "NPC_REBIRTH" } ,
{ NPC_REVENGE, "NPC_REVENGE", "NPC_REVENGE" } ,
{ NPC_RUN, "NPC_RUN", "NPC_RUN" },
{ NPC_SELFDESTRUCTION, "NPC_SELFDESTRUCTION", "Kabooooom!" } ,
{ NPC_SIEGEMODE, "NPC_SIEGEMODE", "NPC_SIEGEMODE" } ,
{ NPC_SILENCEATTACK, "NPC_SILENCEATTACK", "NPC_SILENCEATTACK" } ,
{ NPC_SLEEPATTACK, "NPC_SLEEPATTACK", "NPC_SLEEPATTACK" } ,
{ NPC_SMOKING, "NPC_SMOKING", "NPC_SMOKING" } ,
{ NPC_SPEEDUP, "NPC_SPEEDUP", "NPC_SPEEDUP" } ,
{ NPC_SPLASHATTACK, "NPC_SPLASHATTACK", "NPC_SPLASHATTACK" } ,
{ NPC_STOP, "NPC_STOP", "NPC_STOP" } ,
{ NPC_STUNATTACK, "NPC_STUNATTACK", "NPC_STUNATTACK" } ,
{ NPC_SUICIDE, "NPC_SUICIDE", "NPC_SUICIDE" } ,
{ NPC_SUMMONMONSTER, "NPC_SUMMONMONSTER", "NPC_SUMMONMONSTER" } ,
{ NPC_SUMMONSLAVE, "NPC_SUMMONSLAVE", "NPC_SUMMONSLAVE" } ,
{ NPC_TELEKINESISATTACK, "NPC_TELEKINESISATTACK", "NPC_TELEKINESISATTACK" } ,
{ NPC_TRANSFORMATION, "NPC_TRANSFORMATION", "NPC_TRANSFORMATION" } ,
{ NPC_UNDEADATTACK, "NPC_UNDEADATTACK", "NPC_UNDEADATTACK" } ,
{ NPC_WATERATTACK, "NPC_WATERATTACK", "NPC_WATERATTACK" } ,
{ NPC_WINDATTACK, "NPC_WINDATTACK", "NPC_WINDATTACK" } ,
{ NV_BASIC, "NV_BASIC", "Basic_Skill" } ,
{ NV_FIRSTAID, "NV_FIRSTAID", "First Aid" } ,
{ NV_TRICKDEAD, "NV_TRICKDEAD", "Play_Dead" } ,
{ PA_GOSPEL, "PA_GOSPEL", "Battle_Chant" } ,
{ PA_PRESSURE, "PA_PRESSURE", "Gloria_Domini" } ,
{ PA_SACRIFICE, "PA_SACRIFICE", "Martyr's_Reckoning" } ,
{ PA_SHIELDCHAIN, "PA_SHIELDCHAIN", "Shield_Chain" } ,
{ PF_DOUBLECASTING, "PF_DOUBLECASTING", "Double_Casting" } ,
{ PF_FOGWALL, "PF_FOGWALL", "Blinding_Mist" } ,
{ PF_HPCONVERSION, "PF_HPCONVERSION", "Indulge" } ,
{ PF_MEMORIZE, "PF_MEMORIZE", "Foresight" } ,
{ PF_MINDBREAKER, "PF_MINDBREAKER", "Mind_Breaker" } ,
{ PF_SOULBURN, "PF_SOULBURN", "Soul_Siphon" } ,
{ PF_SOULCHANGE, "PF_SOULCHANGE", "Soul_Exhale" } ,
{ PF_SPIDERWEB, "PF_SPIDERWEB", "Fiber_Lock" } ,
{ PR_ASPERSIO, "PR_ASPERSIO", "Aspersio" } ,
{ PR_BENEDICTIO, "PR_BENEDICTIO", "B.S_Sacramenti" } ,
{ PR_GLORIA, "PR_GLORIA", "Gloria" } ,
{ PR_IMPOSITIO, "PR_IMPOSITIO", "Impositio_Manus" } ,
{ PR_KYRIE, "PR_KYRIE", "Kyrie_Eleison" } ,
{ PR_LEXAETERNA, "PR_LEXAETERNA", "Lex_Aeterna" } ,
{ PR_LEXDIVINA, "PR_LEXDIVINA", "Lex_Divina" } ,
{ PR_MACEMASTERY, "PR_MACEMASTERY", "Mace_Mastery" } ,
{ PR_MAGNIFICAT, "PR_MAGNIFICAT", "Magnificat" } ,
{ PR_MAGNUS, "PR_MAGNUS", "Magnus_Exorcismus" } ,
{ PR_REDEMPTIO, "PR_REDEMPTIO", "Redemptio" } ,
{ PR_SANCTUARY, "PR_SANCTUARY", "Sanctuary" } ,
{ PR_SLOWPOISON, "PR_SLOWPOISON", "Slow_Poison" } ,
{ PR_STRECOVERY, "PR_STRECOVERY", "Status_Recovery" } ,
{ PR_SUFFRAGIUM, "PR_SUFFRAGIUM", "Suffragium" } ,
{ PR_TURNUNDEAD, "PR_TURNUNDEAD", "Turn_Undead" } ,
{ RG_BACKSTAP, "RG_BACKSTAP", "Back_Stab" } ,
{ RG_CLEANER, "RG_CLEANER", "Remover" } ,
{ RG_CLOSECONFINE, "RG_CLOSECONFINE", "Close_Confine"} ,
{ RG_COMPULSION, "RG_COMPULSION", "Haggle" } ,
{ RG_FLAGGRAFFITI, "RG_FLAGGRAFFITI", "Piece" } ,
{ RG_GANGSTER, "RG_GANGSTER", "Slyness" } ,
{ RG_GRAFFITI, "RG_GRAFFITI", "Scribble" } ,
{ RG_INTIMIDATE, "RG_INTIMIDATE", "Snatch" } ,
{ RG_PLAGIARISM, "RG_PLAGIARISM", "Intimidate" } ,
{ RG_RAID, "RG_RAID", "Sightless_Mind" } ,
{ RG_SNATCHER, "RG_SNATCHER", "Gank" } ,
{ RG_STEALCOIN, "RG_STEALCOIN", "Mug" } ,
{ RG_STRIPARMOR, "RG_STRIPARMOR", "Divest_Armor" } ,
{ RG_STRIPHELM, "RG_STRIPHELM", "Divest_Helm" } ,
{ RG_STRIPSHIELD, "RG_STRIPSHIELD", "Divest_Shield" } ,
{ RG_STRIPWEAPON, "RG_STRIPWEAPON", "Divest_Weapon" } ,
{ RG_TUNNELDRIVE, "RG_TUNNELDRIVE", "Stalk" } ,
{ SA_ABRACADABRA, "SA_ABRACADABRA", "Hocus-pocus" } ,
{ SA_ADVANCEDBOOK, "SA_ADVANCEDBOOK", "Advanced_Book" } ,
{ SA_AUTOSPELL, "SA_AUTOSPELL", "Hindsight" } ,
{ SA_CASTCANCEL, "SA_CASTCANCEL", "Cast_Cancel" } ,
{ SA_CLASSCHANGE, "SA_CLASSCHANGE", "Class_Change" } ,
{ SA_COMA, "SA_COMA", "Coma" } ,
{ SA_CREATECON, "SA_CREATECON", "Create_Elemental_Converter" } ,
{ SA_DEATH, "SA_DEATH", "Grim_Reaper" } ,
{ SA_DELUGE, "SA_DELUGE", "Deluge" } ,
{ SA_DISPELL, "SA_DISPELL", "Dispell" } ,
{ SA_DRAGONOLOGY, "SA_DRAGONOLOGY", "Dragonology" } ,
{ SA_ELEMENTFIRE, "SA_ELEMENTFIRE", "Elemental_Change_Fire" } ,
{ SA_ELEMENTGROUND, "SA_ELEMENTGROUND", "Elemental_Change_Earth" } ,
{ SA_ELEMENTWATER, "SA_ELEMENTWATER", "Elemental_Change_Water" } ,
{ SA_ELEMENTWIND, "SA_ELEMENTWIND", "Elemental_Change_Wind" } ,
{ SA_FLAMELAUNCHER, "SA_FLAMELAUNCHER", "Endow_Blaze" } ,
{ SA_FORTUNE, "SA_FORTUNE", "Gold_Digger" } ,
{ SA_FREECAST, "SA_FREECAST", "Free_Cast" } ,
{ SA_FROSTWEAPON, "SA_FROSTWEAPON", "Endow_Tsunami" } ,
{ SA_FULLRECOVERY, "SA_FULLRECOVERY", "Rejuvenation" } ,
{ SA_GRAVITY, "SA_GRAVITY", "Gravity" } ,
{ SA_INSTANTDEATH, "SA_INSTANTDEATH", "Suicide" } ,
{ SA_LANDPROTECTOR, "SA_LANDPROTECTOR", "Magnetic_Earth" } ,
{ SA_LEVELUP, "SA_LEVELUP", "Leveling" } ,
{ SA_LIGHTNINGLOADER, "SA_LIGHTNINGLOADER", "Endow_Tornado" } ,
{ SA_MAGICROD, "SA_MAGICROD", "Magic_Rod" } ,
{ SA_MONOCELL, "SA_MONOCELL", "Mono_Cell" } ,
{ SA_QUESTION, "SA_QUESTION", "Questioning" } ,
{ SA_REVERSEORCISH, "SA_REVERSEORCISH", "Grampus_Morph" } ,
{ SA_SEISMICWEAPON, "SA_SEISMICWEAPON", "Endow_Quake" } ,
{ SA_SPELLBREAKER, "SA_SPELLBREAKER", "Spell_Breaker" } ,
{ SA_SUMMONMONSTER, "SA_SUMMONMONSTER", "Monster_Chant" } ,
{ SA_TAMINGMONSTER, "SA_TAMINGMONSTER", "Beastly_Hypnosis" } ,
{ SA_VIOLENTGALE, "SA_VIOLENTGALE", "Whirlwind" } ,
{ SA_VOLCANO, "SA_VOLCANO", "Volcano" } ,
{ SG_DEVIL, "SG_DEVIL", "Devil_of_the_Sun,_Moon_and_Stars" } ,
{ SG_FEEL, "SG_FEEL", "Feeling_of_the_Sun,_Moon_and_Star" } ,
{ SG_FRIEND, "SG_FRIEND", "Companion_of_the_Sun_and_Moon" } ,
{ SG_FUSION, "SG_FUSION", "Union_of_the_Sun,_Moon_and_Stars" } ,
{ SG_HATE, "SG_HATE", "Hatred_of_the_Sun,_Moon_and_Stars" } ,
{ SG_KNOWLEDGE, "SG_KNOWLEDGE", "Knowledge_of_the_Sun,_Moon_and_Stars" } ,
{ SG_MOON_ANGER, "SG_MOON_ANGER", "Fury_of_the_Moon" } ,
{ SG_MOON_BLESS, "SG_MOON_BLESS", "Bless_of_the_Moon" } ,
{ SG_MOON_COMFORT, "SG_MOON_COMFORT", "Comfort_of_the_Moon" } ,
{ SG_MOON_WARM, "SG_MOON_WARM", "Warmth_of_the_Moon" } ,
{ SG_STAR_ANGER, "SG_STAR_ANGER", "Fury_of_the_Stars" } ,
{ SG_STAR_BLESS, "SG_STAR_BLESS", "Bless_of_the_Stars" } ,
{ SG_STAR_COMFORT, "SG_STAR_COMFORT", "Comfort_of_the_Stars" } ,
{ SG_STAR_WARM, "SG_STAR_WARM", "Warmth_of_the_Stars" } ,
{ SG_SUN_ANGER, "SG_SUN_ANGER", "Fury_of_the_Sun" } ,
{ SG_SUN_BLESS, "SG_SUN_BLESS", "Bless_of_the_Sun" } ,
{ SG_SUN_COMFORT, "SG_SUN_COMFORT", "Comfort_of_the_Sun" } ,
{ SG_SUN_WARM, "SG_SUN_WARM", "Warmth_of_the_Sun" } ,
{ SL_ALCHEMIST, "SL_ALCHEMIST", "Spirit_of_Alchemist" } ,
{ SL_ASSASIN, "SL_ASSASIN", "Spirit_of_Assassin" } ,
{ SL_BARDDANCER, "SL_BARDDANCER", "Spirit_of_Bard_and_Dancer" } ,
{ SL_BLACKSMITH, "SL_BLACKSMITH", "Spirit_of_Blacksmith" } ,
{ SL_CRUSADER, "SL_CRUSADER", "Spirit_of_Crusader" } ,
{ SL_HIGH, "SL_HIGH", "Spirit_of_Advanced_1st_Class" } ,
{ SL_HUNTER, "SL_HUNTER", "Spirit_of_Hunter" } ,
{ SL_KAAHI, "SL_KAAHI", "Kaahi" } ,
{ SL_KAINA, "SL_KAINA", "Kaina" } ,
{ SL_KAITE, "SL_KAITE", "Kaite" } ,
{ SL_KAIZEL, "SL_KAIZEL", "Kaizel" } ,
{ SL_KAUPE, "SL_KAUPE", "Kaupe" } ,
{ SL_KNIGHT, "SL_KNIGHT", "Spirit_of_Knight" } ,
{ SL_MONK, "SL_MONK", "Spirit_of_Monk" } ,
{ SL_PRIEST, "SL_PRIEST", "Spirit_of_Priest" } ,
{ SL_ROGUE, "SL_ROGUE", "Spirit_of_Rogue" } ,
{ SL_SAGE, "SL_SAGE", "Spirit_of_Sage" } ,
{ SL_SKA, "SL_SKA", "Eska" } ,
{ SL_SKE, "SL_SKE", "Eske" } ,
{ SL_SMA, "SL_SMA", "Esma" } ,
{ SL_SOULLINKER, "SL_SOULLINKER", "Spirit_of_Soul_Linker" } ,
{ SL_STAR, "SL_STAR", "Spirit_of_Stars" } ,
{ SL_STIN, "SL_STIN", "Estin" } ,
{ SL_STUN, "SL_STUN", "Estun" } ,
{ SL_SUPERNOVICE, "SL_SUPERNOVICE", "Spirit_of_Super_Novice" } ,
{ SL_SWOO, "SL_SWOO", "Eswoo" } ,
{ SL_WIZARD, "SL_WIZARD", "Spirit_of_Wizard" } ,
{ SM_AUTOBERSERK, "SM_AUTOBERSERK", "Berserk" } ,
{ SM_BASH, "SM_BASH", "Bash" } ,
{ SM_ENDURE, "SM_ENDURE", "Endure" } ,
{ SM_FATALBLOW, "SM_FATALBLOW", "Fatal_Blow" } ,
{ SM_MAGNUM, "SM_MAGNUM", "Magnum_Break" } ,
{ SM_MOVINGRECOVERY, "SM_MOVINGRECOVERY", "HP_Recovery_While_Moving" } ,
{ SM_PROVOKE, "SM_PROVOKE", "Provoke" } ,
{ SM_RECOVERY, "SM_RECOVERY", "Increase_HP_Recovery" } ,
{ SM_SWORD, "SM_SWORD", "Sword_Mastery" } ,
{ SM_TWOHAND, "SM_TWOHAND", "Two-Handed_Sword_Mastery" } ,
{ SN_FALCONASSAULT, "SN_FALCONASSAULT", "Falcon_Assault" } ,
{ SN_SHARPSHOOTING, "SN_SHARPSHOOTING", "Focused_Arrow_Strike" } ,
{ SN_SIGHT, "SN_SIGHT", "Falcon_Eyes" } ,
{ SN_WINDWALK, "SN_WINDWALK", "Wind_Walker" } ,
{ ST_CHASEWALK, "ST_CHASEWALK", "Stealth" } ,
{ ST_FULLSTRIP, "ST_FULLSTRIP", "Full_Divestment" } ,
{ ST_PRESERVE, "ST_PRESERVE", "Preserve" } ,
{ ST_REJECTSWORD, "ST_REJECTSWORD", "Counter_Instinct" } ,
{ TF_BACKSLIDING, "TF_BACKSLIDING", "Back_Slide" } ,
{ TF_DETOXIFY, "TF_DETOXIFY", "Detoxify" } ,
{ TF_DOUBLE, "TF_DOUBLE", "Double_Attack" } ,
{ TF_HIDING, "TF_HIDING", "Hiding" } ,
{ TF_MISS, "TF_MISS", "Improve_Dodge" } ,
{ TF_PICKSTONE, "TF_PICKSTONE", "Find_Stone" } ,
{ TF_POISON, "TF_POISON", "Envenom" } ,
{ TF_SPRINKLESAND, "TF_SPRINKLESAND", "Sand_Attack" } ,
{ TF_STEAL, "TF_STEAL", "Steal" } ,
{ TF_THROWSTONE, "TF_THROWSTONE", "Stone_Fling" } ,
{ TK_COUNTER, "TK_COUNTER", "Spin_Kick" } ,
{ TK_DODGE, "TK_DODGE", "Sprint" } ,
{ TK_DOWNKICK, "TK_DOWNKICK", "Heel_Drop" } ,
{ TK_HIGHJUMP, "TK_HIGHJUMP", "Taekwon_Jump" } ,
{ TK_HPTIME, "TK_HPTIME", "Peaceful_Break" } ,
{ TK_JUMPKICK, "TK_JUMPKICK", "Flying_Kick" } ,
{ TK_MISSION, "TK_MISSION", "Mission" } ,
{ TK_POWER, "TK_POWER", "Kihop" } ,
{ TK_READYCOUNTER, "TK_READYCOUNTER", "Spin_Kick_Stance" } ,
{ TK_READYDOWN, "TK_READYDOWN", "Heel_Drop_Stance" } ,
{ TK_READYSTORM, "TK_READYSTORM", "Tornado_Stance" } ,
{ TK_READYTURN, "TK_READYTURN", "Roundhouse_Stance" } ,
{ TK_RUN, "TK_RUN", "Sprint" } ,
{ TK_SEVENWIND, "TK_SEVENWIND", "Mild_Wind" } ,
{ TK_SPTIME, "TK_SPTIME", "Happy_Break" } ,
{ TK_STORMKICK, "TK_STORMKICK", "Storm_Kick" } ,
{ TK_TURNKICK, "TK_TURNKICK", "Turn_Kick" } ,
{ WE_BABY, "WE_BABY", "Mom,_Dad,_I_love_you!" } ,
{ WE_CALLBABY, "WE_CALLBABY", "Come_to_me,_honey~" } ,
{ WE_CALLPARENT, "WE_CALLPARENT", "Mom,_Dad,_I_miss_you!" } ,
{ WE_CALLPARTNER, "WE_CALLPARTNER", "Romantic_Rendezvous" } ,
{ WE_FEMALE, "WE_FEMALE", "Loving_Touch" } ,
{ WE_MALE, "WE_MALE", "Undying_Love" } ,
{ WS_CARTBOOST, "WS_CARTBOOST", "Cart_Boost" } ,
{ WS_CARTTERMINATION, "WS_CARTTERMINATION", "Cart_Termination" } ,
{ WS_CREATECOIN, "WS_CREATECOIN", "Coin_Craft" } ,
{ WS_CREATENUGGET, "WS_CREATENUGGET", "Nugget_Craft" } ,
{ WS_MELTDOWN, "WS_MELTDOWN", "Shattering_Strike" } ,
{ WS_OVERTHRUSTMAX, "WS_OVERTHRUSTMAX", "Max_Power-Thust" } ,
{ WS_SYSTEMCREATE, "WS_SYSTEMCREATE", "Auto_Attacking_Machine_Craft" } ,
{ WS_WEAPONREFINE, "WS_WEAPONREFINE", "Weapon_Refine" } ,
{ WZ_EARTHSPIKE, "WZ_EARTHSPIKE", "Earth_Spike" } ,
{ WZ_ESTIMATION, "WZ_ESTIMATION", "Sense" } ,
{ WZ_FIREPILLAR, "WZ_FIREPILLAR", "Fire_Pillar" } ,
{ WZ_FROSTNOVA, "WZ_FROSTNOVA", "Frost_Nova" } ,
{ WZ_HEAVENDRIVE, "WZ_HEAVENDRIVE", "Heaven's_Drive" } ,
{ WZ_ICEWALL, "WZ_ICEWALL", "Ice_Wall" } ,
{ WZ_JUPITEL, "WZ_JUPITEL", "Jupitel_Thunder" } ,
{ WZ_METEOR, "WZ_METEOR", "Meteor_Storm" } ,
{ WZ_QUAGMIRE, "WZ_QUAGMIRE", "Quagmire" } ,
{ WZ_SIGHTBLASTER, "WZ_SIGHTBLASTER", "Sight_Blaster" } ,
{ WZ_SIGHTRASHER, "WZ_SIGHTRASHER", "Sightrasher" } ,
{ WZ_STORMGUST, "WZ_STORMGUST", "Storm_Gust" } ,
{ WZ_VERMILION, "WZ_VERMILION", "Lord_of_Vermilion" } ,
{ WZ_WATERBALL, "WZ_WATERBALL", "Water_Ball" } ,
//[blackhole89]
{ HLIF_HEAL, "HLIF_HEAL", "Healing_Touch" },
{ HLIF_AVOID, "HLIF_AVOID", "Avoid" },
{ HLIF_BRAIN, "HLIF_BRAIN", "Brain_Surgery" },
{ HLIF_CHANGE, "HLIF_CHANGE", "Change" },
{ HAMI_CASTLE, "HAMI_CASTLE", "Castling" },
{ HAMI_DEFENCE, "HAMI_DEFENCE", "Defense" },
{ HAMI_SKIN, "HAMI_SKIN", "Adamantium_Skin" },
{ HAMI_BLOODLUST, "HAMI_BLOODLUST", "Bloodlust" },
{ HFLI_MOON, "HFLI_MOON", "Moonlight" },
{ HFLI_FLEET, "HFLI_FLEET", "Fleeting_Move" },
{ HFLI_SPEED, "HFLI_SPEED", "Speed" },
{ HFLI_SBR44, "HFLI_SBR44", "S.B.R.44" },
{ HVAN_CAPRICE, "HVAN_CAPRICE", "Caprice" },
{ HVAN_CHAOTIC, "HVAN_CHAOTIC", "Benediction_of_Chaos" },
{ HVAN_INSTRUCT, "HVAN_INSTRUCT", "Instruct" },
{ HVAN_EXPLOSION, "HVAN_EXPLOSION", "Bio_Explosion" },
{ 0, "UNKNOWN_SKILL", "Unknown_Skill" }
};
static const int dirx[8]={0,-1,-1,-1,0,1,1,1};
static const int diry[8]={1,1,0,-1,-1,-1,0,1};
static struct eri *skill_unit_ers = NULL; //For handling skill_unit's [Skotlex]
static struct eri *skill_timer_ers = NULL; //For handling skill_timerskills [Skotlex]
/* スキルデータベース */
struct skill_db skill_db[MAX_SKILL_DB];
/* アイテム作成データベース */
struct skill_produce_db skill_produce_db[MAX_SKILL_PRODUCE_DB];
/* 矢作成スキルデータベース */
struct skill_arrow_db skill_arrow_db[MAX_SKILL_ARROW_DB];
/* アブラカダブラ発動スキルデータベース */
struct skill_abra_db skill_abra_db[MAX_SKILL_ABRA_DB];
// macros to check for out of bounds errors [celest]
// i: Skill ID, l: Skill Level, var: Value to return after checking
// for values that don't require level just put a one (putting 0 will trigger return 0; instead
// for values that might need to use a different function just skill_chk would suffice.
#define skill_chk(i, l) \
if (i >= GD_SKILLRANGEMIN && i <= GD_SKILLRANGEMAX) { return 0; } \
if (i >= HM_SKILLRANGEMIN && i <= HM_SKILLRANGEMAX) { return 0; } \
if (i >= GD_SKILLBASE) {i = GD_SKILLRANGEMIN + i - GD_SKILLBASE;} \
if (i >= HM_SKILLBASE) {i = HM_SKILLRANGEMIN + i - HM_SKILLBASE;} \
if (i < 1 || i >= MAX_SKILL_DB) {return 0;} \
if (l <= 0 || l > MAX_SKILL_LEVEL) {return 0;}
#define skill_get(var, i, l) \
{ skill_chk(i, l); return var; }
// Skill DB
int skill_get_hit( int id ){ skill_get (skill_db[id].hit, id, 1); }
int skill_get_inf( int id ){ skill_get (skill_db[id].inf, id, 1); }
int skill_get_pl( int id ){ skill_get (skill_db[id].pl, id, 1); }
int skill_get_nk( int id ){ skill_get (skill_db[id].nk, id, 1); }
int skill_get_max( int id ){ skill_get (skill_db[id].max, id, 1); }
int skill_get_range( int id , int lv ){ skill_get(skill_db[id].range[lv-1], id, lv); }
int skill_get_splash( int id , int lv ){ skill_chk (id, lv); return (skill_db[id].splash[lv-1]>=0?skill_db[id].splash[lv-1]:AREA_SIZE); }
int skill_get_hp( int id ,int lv ){ skill_get (skill_db[id].hp[lv-1], id, lv); }
int skill_get_sp( int id ,int lv ){ skill_get (skill_db[id].sp[lv-1], id, lv); }
int skill_get_hp_rate(int id, int lv ){ skill_get (skill_db[id].hp_rate[lv-1], id, lv); }
int skill_get_sp_rate(int id, int lv ){ skill_get (skill_db[id].sp_rate[lv-1], id, lv); }
int skill_get_state(int id) { skill_get (skill_db[id].state, id, 1); }
int skill_get_spiritball(int id, int lv) { skill_get (skill_db[id].spiritball[lv-1], id, lv); }
int skill_get_itemid(int id, int idx) { skill_get (skill_db[id].itemid[idx], id, 1); }
int skill_get_itemqty(int id, int idx) { skill_get (skill_db[id].amount[idx], id, 1); }
int skill_get_zeny( int id ,int lv ){ skill_get (skill_db[id].zeny[lv-1], id, lv); }
int skill_get_num( int id ,int lv ){ skill_get (skill_db[id].num[lv-1], id, lv); }
int skill_get_cast( int id ,int lv ){ skill_get (skill_db[id].cast[lv-1], id, lv); }
int skill_get_delay( int id ,int lv ){ skill_get (skill_db[id].delay[lv-1], id, lv); }
int skill_get_walkdelay( int id ,int lv ){ skill_get (skill_db[id].walkdelay[lv-1], id, lv); }
int skill_get_time( int id ,int lv ){ skill_get (skill_db[id].upkeep_time[lv-1], id, lv); }
int skill_get_time2( int id ,int lv ){ skill_get (skill_db[id].upkeep_time2[lv-1], id, lv); }
int skill_get_castdef( int id ){ skill_get (skill_db[id].cast_def_rate, id, 1); }
int skill_get_weapontype( int id ){ skill_get (skill_db[id].weapon, id, 1); }
int skill_get_ammotype( int id ){ skill_get (skill_db[id].ammo, id, 1); }
int skill_get_ammo_qty( int id, int lv ){ skill_get (skill_db[id].ammo_qty[lv-1], id, lv); }
int skill_get_inf2( int id ){ skill_get (skill_db[id].inf2, id, 1); }
int skill_get_castcancel( int id ){ skill_get (skill_db[id].castcancel, id, 1); }
int skill_get_maxcount( int id ){ skill_get (skill_db[id].maxcount, id, 1); }
int skill_get_blewcount( int id ,int lv ){ skill_get (skill_db[id].blewcount[lv-1], id, lv); }
int skill_get_mhp( int id ,int lv ){ skill_get (skill_db[id].mhp[lv-1], id, lv); }
int skill_get_castnodex( int id ,int lv ){ skill_get (skill_db[id].castnodex[lv-1], id, lv); }
int skill_get_delaynodex( int id ,int lv ){ skill_get (skill_db[id].delaynodex[lv-1], id, lv); }
int skill_get_nocast ( int id ){ skill_get (skill_db[id].nocast, id, 1); }
int skill_get_type( int id ){ skill_get (skill_db[id].skill_type, id, 1); }
int skill_get_unit_id ( int id, int flag ){ skill_get (skill_db[id].unit_id[flag], id, 1); }
int skill_get_unit_layout_type( int id ,int lv ){ skill_get (skill_db[id].unit_layout_type[lv-1], id, lv); }
int skill_get_unit_interval( int id ){ skill_get (skill_db[id].unit_interval, id, 1); }
int skill_get_unit_range( int id, int lv ){ skill_get (skill_db[id].unit_range[lv-1], id, lv); }
int skill_get_unit_target( int id ){ skill_get ((skill_db[id].unit_target&BCT_ALL), id, 1); }
int skill_get_unit_bl_target( int id ){ skill_get ((skill_db[id].unit_target&BL_ALL), id, 1); }
int skill_get_unit_flag( int id ){ skill_get (skill_db[id].unit_flag, id, 1); }
const char* skill_get_name( int id ){
if (id >= GD_SKILLRANGEMIN && id <= GD_SKILLRANGEMAX)
return "UNKNOWN_SKILL";
if (id >= GD_SKILLBASE)
id = GD_SKILLRANGEMIN + id - GD_SKILLBASE;
if (id < 1 || id > MAX_SKILL_DB || skill_db[id].name==NULL)
return "UNKNOWN_SKILL"; //Can't use skill_chk because we return a string.
return skill_db[id].name;
}
int skill_tree_get_max(int id, int b_class){
int i, skillid;
for(i=0;(skillid=skill_tree[b_class][i].id)>0;i++)
if (id == skillid) return skill_tree[b_class][i].max;
return skill_get_max (id);
}
/* プロトタイプ */
int skill_castend_damage_id( struct block_list* src, struct block_list *bl,int skillid,int skilllv,unsigned int tick,int flag );
int skill_frostjoke_scream(struct block_list *bl,va_list ap);
int status_change_timer_sub(struct block_list *bl, va_list ap);
int skill_attack_area(struct block_list *bl,va_list ap);
struct skill_unit_group *skill_locate_element_field(struct block_list *bl); // [Skotlex]
int skill_graffitiremover(struct block_list *bl, va_list ap); // [Valaris]
int skill_greed(struct block_list *bl, va_list ap);
int skill_landprotector(struct block_list *bl, va_list ap);
int skill_ganbatein(struct block_list *bl, va_list ap);
int skill_trap_splash(struct block_list *bl, va_list ap);
int skill_count_target(struct block_list *bl, va_list ap);
struct skill_unit_group_tickset *skill_unitgrouptickset_search(struct block_list *bl,struct skill_unit_group *sg,int tick);
static int skill_unit_onplace(struct skill_unit *src,struct block_list *bl,unsigned int tick);
static int skill_unit_onleft(int skill_id, struct block_list *bl,unsigned int tick);
int skill_unit_effect(struct block_list *bl,va_list ap);
static void skill_moonlit(struct block_list* src, struct block_list* partner, int skilllv);
int enchant_eff[5] = { 10, 14, 17, 19, 20 };
int deluge_eff[5] = { 5, 9, 12, 14, 15 };
int skill_get_casttype (int id)
{
int inf = skill_get_inf(id);
if (inf&(INF_GROUND_SKILL))
return CAST_GROUND;
if (inf&INF_SUPPORT_SKILL)
return CAST_NODAMAGE;
if (inf&INF_SELF_SKILL) {
if(skill_get_inf2(id)&INF2_NO_TARGET_SELF)
return CAST_DAMAGE; //Combo skill.
return CAST_NODAMAGE;
}
if (skill_get_nk(id)&NK_NO_DAMAGE)
return CAST_NODAMAGE;
return CAST_DAMAGE;
};
//Returns actual skill range taking into account attack range and AC_OWL [Skotlex]
int skill_get_range2 (struct block_list *bl, int id, int lv)
{
int range = skill_get_range(id, lv);
if(range < 0) {
if (battle_config.use_weapon_skill_range)
return status_get_range(bl);
range *=-1;
}
//TODO: Find a way better than hardcoding the list of skills affected by AC_VULTURE
switch (id) {
case AC_SHOWER:
case AC_DOUBLE:
case HT_BLITZBEAT:
case AC_CHARGEARROW:
case SN_FALCONASSAULT:
case SN_SHARPSHOOTING:
case HT_POWER:
if (bl->type == BL_PC)
range += pc_checkskill((struct map_session_data *)bl, AC_VULTURE);
else
range += 10; //Assume level 10?
break;
// added to allow GS skills to be effected by the range of Snake Eyes [Reddozen]
case GS_RAPIDSHOWER:
case GS_TRACKING:
case GS_PIERCINGSHOT:
case GS_FULLBUSTER:
case GS_SPREADATTACK:
case GS_GROUNDDRIFT:
if (bl->type == BL_PC)
range += pc_checkskill((struct map_session_data *)bl, GS_SNAKEEYE);
else
range += 10; //Assume level 10?
break;
}
if(!range && bl->type != BL_PC)
return 9; // Enable non players to use self skills on others. [Skotlex]
return range;
}
int skill_calc_heal (struct block_list *bl, int skill_lv)
{
int skill, heal;
if (skill_lv >= battle_config.max_heal_lv)
return battle_config.max_heal;
heal = ( status_get_lv(bl)+status_get_int(bl) )/8 *(4+ skill_lv*8);
if(bl->type == BL_PC && (skill = pc_checkskill((TBL_PC*)bl, HP_MEDITATIO)) > 0)
heal += heal * skill * 2 / 100;
return heal;
}
// Making plagiarize check its own function [Aru]
int can_copy (struct map_session_data *sd, int skillid)
{
// Never copy NPC/Wedding Skills
if (skill_get_inf2(skillid)&(INF2_NPC_SKILL|INF2_WEDDING_SKILL))
return 0;
// High-class skills
if((skillid >= LK_AURABLADE && skillid <= ASC_CDP) || (skillid >= ST_PRESERVE && skillid <= CR_CULTIVATION))
{
if(battle_config.copyskill_restrict == 2)
return 0;
else if(battle_config.copyskill_restrict)
return (sd->status.class_ == JOB_STALKER);
}
return 1;
}
// [MouseJstr] - skill ok to cast? and when?
int skillnotok (int skillid, struct map_session_data *sd)
{
int i = skillid;
nullpo_retr (1, sd);
//if (sd == 0)
//return 0;
//return 1;
// I think it was meant to be "no skills allowed when not a valid sd"
if (skillid >= GD_SKILLRANGEMIN && skillid <= GD_SKILLRANGEMAX)
return 1;
if (i >= GD_SKILLBASE)
i = GD_SKILLRANGEMIN + i - GD_SKILLBASE;
if (i > MAX_SKILL || i < 0)
return 1;
if (sd->blockskill[i] > 0)
return 1;
if (battle_config.gm_skilluncond && pc_isGM(sd) >= battle_config.gm_skilluncond)
return 0; // gm's can do anything damn thing they want
// Check skill restrictions [Celest]
if(!map_flag_vs(sd->bl.m) && skill_get_nocast (skillid) & 1)
return 1;
if(map[sd->bl.m].flag.pvp && skill_get_nocast (skillid) & 2)
return 1;
if(map_flag_gvg(sd->bl.m) && skill_get_nocast (skillid) & 4)
return 1;
if(agit_flag && skill_get_nocast (skillid) & 8)
return 1;
if(map[sd->bl.m].flag.restricted && map[sd->bl.m].zone && skill_get_nocast (skillid) & (8*map[sd->bl.m].zone))
return 1;
switch (skillid) {
case AL_WARP:
if(map[sd->bl.m].flag.nowarp) {
clif_skill_teleportmessage(sd,0);
return 1;
}
return 0;
break;
case AL_TELEPORT:
if(map[sd->bl.m].flag.noteleport) {
clif_skill_teleportmessage(sd,0);
return 1;
}
return 0;
case TK_HIGHJUMP:
if(map[sd->bl.m].flag.noteleport && !map_flag_vs(sd->bl.m))
{ //Can't be used on noteleport maps, except for vs maps [Skotlex]
clif_skill_fail(sd,skillid,0,0);
return 1;
}
break;
case WE_CALLPARTNER:
case WE_CALLPARENT:
case WE_CALLBABY:
if (map[sd->bl.m].flag.nomemo) {
clif_skill_teleportmessage(sd,1);
return 1;
}
break;
case MC_VENDING:
case MC_IDENTIFY:
return 0; // always allowed
case WZ_ICEWALL:
// noicewall flag [Valaris]
if (map[sd->bl.m].flag.noicewall) {
clif_skill_fail(sd,skillid,0,0);
return 1;
}
break;
case GD_EMERGENCYCALL:
if (!battle_config.emergency_call ||
(map[sd->bl.m].flag.nowarpto && battle_config.emergency_call&1))
{
clif_skill_fail(sd,skillid,0,0);
return 1;
}
break;
}
return (map[sd->bl.m].flag.noskill);
}
/* スキルユニットの配置情報を返す */
struct skill_unit_layout skill_unit_layout[MAX_SKILL_UNIT_LAYOUT];
int firewall_unit_pos;
int icewall_unit_pos;
struct skill_unit_layout *skill_get_unit_layout (int skillid, int skilllv, struct block_list *src, int x, int y)
{
int pos = skill_get_unit_layout_type(skillid,skilllv);
int dir;
if (pos != -1)
return &skill_unit_layout[pos];
if (src->x == x && src->y == y)
dir = 2;
else
dir = map_calc_dir(src,x,y);
if (skillid == MG_FIREWALL)
return &skill_unit_layout [firewall_unit_pos + dir];
else if (skillid == WZ_ICEWALL)
return &skill_unit_layout [icewall_unit_pos + dir];
ShowError("Unknown unit layout for skill %d, %d\n",skillid,skilllv);
return &skill_unit_layout[0];
}
/*==========================================
* スキル追加効果
*------------------------------------------
*/
int skill_additional_effect (struct block_list* src, struct block_list *bl, int skillid, int skilllv, int attack_type, unsigned int tick)
{
struct map_session_data *sd=NULL, *dstsd=NULL;
struct mob_data *md=NULL, *dstmd=NULL;
struct status_data *sstatus, *tstatus;
struct status_change *sc, *tsc;
int skill;
int rate;
nullpo_retr(0, src);
nullpo_retr(0, bl);
if(skillid < 0)
{ // remove the debug print when this case is finished
ShowDebug("skill_additional_effect: skillid=%i\ncall: %p %p %i %i %i %i",skillid,
src, bl,skillid,skilllv,attack_type,tick);
return 0;
}
if(skillid > 0 && skilllv <= 0) return 0; // don't forget auto attacks! - celest
switch (src->type) {
case BL_PC:
sd = (struct map_session_data *)src;
break;
case BL_MOB:
md = (struct mob_data *)src;
break;
}
switch (bl->type) {
case BL_PC:
dstsd=(struct map_session_data *)bl;
break;
case BL_MOB:
dstmd=(struct mob_data *)bl;
break;
}
sc = status_get_sc(src);
tsc = status_get_sc(bl);
sstatus = status_get_status_data(src);
tstatus = status_get_status_data(bl);
if (!tsc) //skill additional effect is about adding effects to the target...
//So if the target can't be inflicted with statuses, this is pointless.
return 0;
switch(skillid){
case 0: // Normal attacks (no skill used)
{
if(sd) {
// Automatic trigger of Blitz Beat
if (pc_isfalcon(sd) && sd->status.weapon == W_BOW && (skill=pc_checkskill(sd,HT_BLITZBEAT))>0 &&
rand()%1000 <= sstatus->luk*10/3+1 ) {
int lv=(sd->status.job_level+9)/10;
skill_castend_damage_id(src,bl,HT_BLITZBEAT,(skill<lv)?skill:lv,tick,0xf00000);
}
// Gank
if(dstmd && dstmd->state.steal_flag<battle_config.skill_steal_max_tries && sd->status.weapon != W_BOW &&
(skill=pc_checkskill(sd,RG_SNATCHER)) > 0 &&
(skill*15 + 55) + pc_checkskill(sd,TF_STEAL)*10 > rand()%1000) {
if(pc_steal_item(sd,bl))
clif_skill_nodamage(src,bl,TF_STEAL,skill,1);
else if (battle_config.display_snatcher_skill_fail)
clif_skill_fail(sd,skillid,0,0);
}
// Chance to trigger Taekwon kicks [Dralnu]
if(sd->sc.count && sd->sc.data[SC_COMBO].timer == -1) {
if(sd->sc.data[SC_READYSTORM].timer != -1 &&
sc_start4(src,SC_COMBO, 15, TK_STORMKICK,0,0,0,
(2000 - 4*sstatus->agi - 2*sstatus->dex)))
; //Stance triggered
else if(sd->sc.data[SC_READYDOWN].timer != -1 &&
sc_start4(src,SC_COMBO, 15, TK_DOWNKICK,0,0,0,
(2000 - 4*sstatus->agi - 2*sstatus->dex)))
; //Stance triggered
else if(sd->sc.data[SC_READYTURN].timer != -1 &&
sc_start4(src,SC_COMBO, 15, TK_TURNKICK,0,0,0,
(2000 - 4*sstatus->agi - 2*sstatus->dex)))
; //Stance triggered
else if(sd->sc.data[SC_READYCOUNTER].timer != -1)
{ //additional chance from SG_FRIEND [Komurka]
rate = 20;
if (sd->sc.data[SC_SKILLRATE_UP].timer != -1 && sd->sc.data[SC_SKILLRATE_UP].val1 == TK_COUNTER) {
rate += rate*sd->sc.data[SC_SKILLRATE_UP].val2/100;
status_change_end(src,SC_SKILLRATE_UP,-1);
}
sc_start4(src,SC_COMBO, rate, TK_COUNTER, bl->id,0,0,
(2000 - 4*sstatus->agi - 2*sstatus->dex));
}
}
}
if (sc && sc->count) {
// Enchant Poison gives a chance to poison attacked enemies
if(sc->data[SC_ENCPOISON].timer != -1)
sc_start(bl,SC_POISON,10*sc->data[SC_ENCPOISON].val2,sc->data[SC_ENCPOISON].val1,
skill_get_time2(AS_ENCHANTPOISON,sc->data[SC_ENCPOISON].val1));
// Enchant Deadly Poison gives a chance to deadly poison attacked enemies
if(sc->data[SC_EDP].timer != -1)
sc_start4(bl,SC_DPOISON,sc->data[SC_EDP].val2,
sc->data[SC_EDP].val1,0,0,0,skill_get_time2(ASC_EDP,sc->data[SC_EDP].val1));
}
if (tsc->count) {
if (tsc->data[SC_SPLASHER].timer != -1)
sc_start4(bl,SC_POISON,2*tsc->data[SC_SPLASHER].val1+10,
tsc->data[SC_SPLASHER].val1,0,0,0,
skill_get_time2(tsc->data[SC_SPLASHER].val2,tsc->data[SC_SPLASHER].val1));
}
}
break;
case SM_BASH: /* バッシュ（急所攻撃） */
if( sd && skilllv > 5 && pc_checkskill(sd,SM_FATALBLOW)>0 ){
//TODO: How much % per base level it actually is?
sc_start(bl,SC_STUN,(5*(skilllv-5)+(int)sd->status.base_level/10),
skilllv,skill_get_time2(SM_FATALBLOW,skilllv));
}
break;
case AS_VENOMKNIFE:
if (sd) //Poison chance must be that of Envenom. [Skotlex]
skilllv = pc_checkskill(sd, TF_POISON);
case TF_POISON: /* インベナム */
case AS_SPLASHER: /* ベナムスプラッシャー */
if(!sc_start(bl,SC_POISON,(2*skilllv+10),skilllv,skill_get_time2(skillid,skilllv))
&& sd && skillid==TF_POISON
)
clif_skill_fail(sd,skillid,0,0);
break;
case AS_SONICBLOW: /* ソニックブロー */
sc_start(bl,SC_STUN,(2*skilllv+10),skilllv,skill_get_time2(skillid,skilllv));
break;
case AS_GRIMTOOTH:
{
int type = dstsd?SC_SLOWDOWN:SC_STOP;
if (tsc->data[type].timer == -1)
sc_start(bl,type,100,skilllv,skill_get_time2(skillid, skilllv));
break;
}
case MG_FROSTDIVER:
case WZ_FROSTNOVA:
sc_start(bl,SC_FREEZE,skilllv*3+35,skilllv,skill_get_time2(skillid,skilllv));
break;
case WZ_STORMGUST:
tsc->data[SC_FREEZE].val3++;
if(tsc->data[SC_FREEZE].val3 >= 3) //Tharis pointed out that this is normal freeze chance with a base of 300%
sc_start(bl,SC_FREEZE,300,skilllv,skill_get_time2(skillid,skilllv));
break;
case WZ_METEOR:
sc_start(bl,SC_STUN,3*skilllv,skilllv,skill_get_time2(skillid,skilllv));
break;
case WZ_VERMILION:
sc_start(bl,SC_BLIND,4*skilllv,skilllv,skill_get_time2(skillid,skilllv));
break;
case HT_FREEZINGTRAP: /* フリージングトラップ */
sc_start(bl,SC_FREEZE,(3*skilllv+35),skilllv,skill_get_time2(skillid,skilllv));
break;
case HT_FLASHER: /* フラッシャー */
sc_start(bl,SC_BLIND,(10*skilllv+30),skilllv,skill_get_time2(skillid,skilllv));
break;
case HT_LANDMINE: /* ランドマイン */
sc_start(bl,SC_STUN,(5*skilllv+30),skilllv,skill_get_time2(skillid,skilllv));
break;
case HT_SHOCKWAVE:
status_percent_damage(src, bl, 0, 15*skilllv+5);
break;
case HT_SANDMAN: /* サンドマン */
sc_start(bl,SC_SLEEP,(10*skilllv+40),skilllv,skill_get_time2(skillid,skilllv));
break;
case TF_SPRINKLESAND: /* 砂まき */
sc_start(bl,SC_BLIND,20,skilllv,skill_get_time2(skillid,skilllv));
break;
case TF_THROWSTONE: /* 石投げ */
sc_start(bl,SC_STUN,3,skilllv,skill_get_time(skillid,skilllv));
sc_start(bl,SC_BLIND,3,skilllv,skill_get_time2(skillid,skilllv));
break;
case NPC_DARKCROSS:
case CR_HOLYCROSS: /* ホーリークロス */
sc_start(bl,SC_BLIND,3*skilllv,skilllv,skill_get_time2(skillid,skilllv));
break;
case CR_GRANDCROSS: /* グランドクロス */
case NPC_GRANDDARKNESS: /*闇グランドクロス*/
{
if(battle_check_undead(tstatus->race,tstatus->def_ele) || tstatus->race == RC_DEMON)
sc_start(bl,SC_BLIND,100,skilllv,skill_get_time2(skillid,skilllv));
}
break;
case AM_ACIDTERROR:
sc_start(bl,SC_BLEEDING,(skilllv*3),skilllv,skill_get_time2(skillid,skilllv));
if (skill_break_equip(bl, EQP_ARMOR, 100*skill_get_time(skillid,skilllv), BCT_ENEMY))
clif_emotion(bl,23);
break;
case AM_DEMONSTRATION:
skill_break_equip(bl, EQP_WEAPON, 100*skilllv, BCT_ENEMY);
break;
case CR_SHIELDCHARGE: /* シールドチャージ */
sc_start(bl,SC_STUN,(15+skilllv*5),skilllv,skill_get_time2(skillid,skilllv));
break;
case PA_PRESSURE:
status_percent_damage(src, bl, 0, 15+5*skilllv);
break;
case RG_RAID: /* サプライズアタック */
sc_start(bl,SC_STUN,(10+3*skilllv),skilllv,skill_get_time(skillid,skilllv));
sc_start(bl,SC_BLIND,(10+3*skilllv),skilllv,skill_get_time2(skillid,skilllv));
break;
case BA_FROSTJOKE:
sc_start(bl,SC_FREEZE,(15+5*skilllv),skilllv,skill_get_time2(skillid,skilllv));
break;
case DC_SCREAM:
sc_start(bl,SC_STUN,(25+5*skilllv),skilllv,skill_get_time2(skillid,skilllv));
break;
case BD_LULLABY: /* 子守唄 */
sc_start(bl,SC_SLEEP,15,skilllv,skill_get_time2(skillid,skilllv));
break;
case DC_UGLYDANCE:
rate = 5+5*skilllv;
if(sd && (skill=pc_checkskill(sd,DC_DANCINGLESSON)))
rate += 5+skill;
status_zap(bl, 0, rate);
break;
case SL_STUN:
if (tstatus->size==1) //Only stuns mid-sized mobs.
sc_start(bl,SC_STUN,(30+10*skilllv),skilllv,skill_get_time(skillid,skilllv));
break;
/* MOBの追加効果付きスキル */
case NPC_PETRIFYATTACK:
case NPC_CURSEATTACK:
case NPC_SLEEPATTACK:
case NPC_BLINDATTACK:
case NPC_POISON:
case NPC_SILENCEATTACK:
case NPC_STUNATTACK:
sc_start(bl,SkillStatusChangeTable(skillid),50+10*skilllv,skilllv,src->type==BL_PET?skilllv*1000:skill_get_time2(skillid,skilllv));
break;
case NPC_MENTALBREAKER:
status_percent_damage(src, bl, 0, -(10+skilllv));
break;
// Equipment breaking monster skills [Celest]
case NPC_BREAKWEAPON:
skill_break_equip(bl, EQP_WEAPON, 150*skilllv, BCT_ENEMY);
break;
case NPC_BREAKARMOR:
skill_break_equip(bl, EQP_ARMOR, 150*skilllv, BCT_ENEMY);
break;
case NPC_BREAKHELM:
skill_break_equip(bl, EQP_HELM, 150*skilllv, BCT_ENEMY);
break;
case NPC_BREAKSHIELD:
skill_break_equip(bl, EQP_SHIELD, 150*skilllv, BCT_ENEMY);
break;
case CH_TIGERFIST:
sc_start(bl,SC_STOP,(10+skilllv*10),0,skill_get_time2(skillid,skilllv));
break;
case LK_SPIRALPIERCE:
sc_start(bl,SC_STOP,(15+skilllv*5),0,skill_get_time2(skillid,skilllv));
break;
case ST_REJECTSWORD: /* フリージングトラップ */
sc_start(bl,SC_AUTOCOUNTER,(skilllv*15),skilllv,skill_get_time2(skillid,skilllv));
break;
case PF_FOGWALL: /* ホーリークロス */
if (src != bl && tsc->data[SC_DELUGE].timer == -1)
status_change_start(bl,SC_BLIND,10000,skilllv,0,0,0,skill_get_time2(skillid,skilllv),8);
break;
case LK_HEADCRUSH: /* ヘッドクラッシュ */
if (!(battle_check_undead(tstatus->race, tstatus->def_ele) || tstatus->race == RC_DEMON))
sc_start(bl, SC_BLEEDING,50, skilllv, skill_get_time2(skillid,skilllv));
break;
case LK_JOINTBEAT: /* ジョイントビート */
//条件が良く分からないので適当に
sc_start(bl,SkillStatusChangeTable(skillid),(5*skilllv+5),skilllv,skill_get_time2(skillid,skilllv));
break;
case ASC_METEORASSAULT: /* メテオアサルト */
//Any enemies hit by this skill will receive Stun, Darkness, or external bleeding status ailment with a 5%+5*SkillLV% chance.
switch(rand()%3) {
case 0:
sc_start(bl,SC_BLIND,(5+skilllv*5),skilllv,skill_get_time2(skillid,1));
break;
case 1:
sc_start(bl,SC_STUN,(5+skilllv*5),skilllv,skill_get_time2(skillid,2));
break;
default:
sc_start(bl,SC_BLEEDING,(5+skilllv*5),skilllv,skill_get_time2(skillid,3));
}
break;
case HW_NAPALMVULCAN: /* ナパルムバルカン */
// skilllv*5%の確率で呪い
sc_start(bl,SC_CURSE,5*skilllv,skilllv,skill_get_time2(skillid,skilllv));
break;
case WS_CARTTERMINATION: // Cart termination
sc_start(bl,SC_STUN,5*skilllv,skilllv,skill_get_time2(skillid,skilllv));
break;
case CR_ACIDDEMONSTRATION:
skill_break_equip(bl, EQP_WEAPON|EQP_ARMOR, 100*skilllv, BCT_ENEMY);
break;
case TK_DOWNKICK:
sc_start(bl,SC_STUN,100,skilllv,skill_get_time2(skillid,skilllv));
break;
case TK_JUMPKICK:
//Cancel out Soul Linker status of the target. [Skotlex]
if (tsc->count) {
if (tsc->data[SC_PRESERVE].timer != -1) //preserve blocks the cleaning
break;
//Remove pitched potions effect.
if (tsc->data[SC_ASPDPOTION0].timer != -1 && tsc->data[SC_ASPDPOTION0].val4)
status_change_end(bl, SC_ASPDPOTION0, -1);
if (tsc->data[SC_ASPDPOTION1].timer != -1 && tsc->data[SC_ASPDPOTION1].val4)
status_change_end(bl, SC_ASPDPOTION1, -1);
if (tsc->data[SC_ASPDPOTION2].timer != -1 && tsc->data[SC_ASPDPOTION2].val4)
status_change_end(bl, SC_ASPDPOTION2, -1);
if (tsc->data[SC_ASPDPOTION3].timer != -1 && tsc->data[SC_ASPDPOTION3].val4)
status_change_end(bl, SC_ASPDPOTION3, -1);
if (tsc->data[SC_SPIRIT].timer != -1)
status_change_end(bl, SC_SPIRIT, -1);
if (tsc->data[SC_ONEHAND].timer != -1)
status_change_end(bl, SC_ONEHAND, -1);
if (tsc->data[SC_ADRENALINE2].timer != -1)
status_change_end(bl, SC_ADRENALINE2, -1);
}
break;
case TK_TURNKICK:
case MO_BALKYOUNG: //Note: attack_type is passed as BF_WEAPON for the actual target, BF_MISC for the splash-affected mobs.
if(attack_type == BF_MISC) //70% base stun chance...
sc_start(bl,SC_STUN,70,skilllv,skill_get_time2(skillid,skilllv));
break;
//Until they're at right position - gs_statuschange- [Vicious]
case GS_BULLSEYE: //0.1% coma rate.
status_change_start(bl,SC_COMA,10,skilllv,0,0,0,0,0);
break;
case GS_CRACKER:
if (!dstsd) // according to latest patch, should not work on players [Reddozen]
sc_start(bl,SC_STUN,(100 - 10*distance_bl(src, bl)),skilllv,skill_get_time2(skillid,skilllv)); //Temp stun rate
break;
case GS_PIERCINGSHOT:
sc_start(bl,SC_BLEEDING,(skilllv*3),skilllv,skill_get_time2(skillid,skilllv));
break;
case GS_FULLBUSTER:
sc_start(bl,SC_BLIND,(2*skilllv),skilllv,skill_get_time2(skillid,1));
break;
case NJ_HYOUSYOURAKU:
sc_start(bl,SC_FREEZE,(10+10*skilllv),skilllv,skill_get_time2(skillid,skilllv));
break;
case GS_FLING:
sc_start(bl,SC_FLING,100, sd?sd->spiritball_old:5,skill_get_time(skillid,skilllv));
break;
}
if(sd && attack_type&BF_WEAPON &&
skillid != MC_CARTREVOLUTION &&
skillid != AM_DEMONSTRATION &&
skillid != CR_REFLECTSHIELD
){ //Trigger status effects
int i, type;
for(i=0; i < MAX_PC_BONUS && sd->addeff[i].flag; i++)
{
rate = sd->addeff[i].rate;
type = sd->state.arrow_atk; //Ranged?
if (type)
rate += sd->addeff[i].arrow_rate;
if (!rate) continue;
if (!(sd->addeff[i].flag&ATF_LONG && sd->addeff[i].flag&ATF_SHORT))
{ //Trigger has range consideration.
if ((sd->addeff[i].flag&ATF_LONG && !type) ||
(sd->addeff[i].flag&ATF_SHORT && type))
continue; //Range Failed.
}
type = sd->addeff[i].id;
skill = skill_get_time2(StatusSkillChangeTable[type],7);
if (sd->addeff[i].flag&ATF_TARGET)
status_change_start(bl,type,rate,7,0,0,0,skill,0);
if (sd->addeff[i].flag&ATF_SELF)
status_change_start(src,type,rate,7,0,0,0,skill,0);
}
}
if (md && battle_config.summons_trigger_autospells && md->master_id && md->special_state.ai)
{ //Pass heritage to Master for status causing effects. [Skotlex]
sd = map_id2sd(md->master_id);
src = sd?&sd->bl:src;
}
//Reports say that autospell effects get triggered on skills and pretty much everything including splash attacks. [Skotlex]
if(sd && !status_isdead(bl) && src != bl &&
!(skillid && skill_get_nk(skillid)&NK_NO_DAMAGE)) {
struct block_list *tbl;
struct unit_data *ud;
int i, skilllv;
for (i = 0; i < MAX_PC_BONUS && sd->autospell[i].id; i++) {
skill = (sd->autospell[i].id > 0) ? sd->autospell[i].id : -sd->autospell[i].id;
if (skillnotok(skill, sd))
continue;
skilllv = (sd->autospell[i].lv > 0) ? sd->autospell[i].lv : 1;
rate = (!sd->state.arrow_atk) ? sd->autospell[i].rate : sd->autospell[i].rate / 2;
if (rand()%1000 > rate)
continue;
if (sd->autospell[i].id < 0)
tbl = src;
else
tbl = bl;
if (tbl != src && !battle_check_range(src, tbl, skill_get_range2(src, skill, skilllv)))
continue; //Autoskills DO check for target-src range. [Skotlex]
rate = skill_get_inf(skill);
switch (skill_get_casttype(skill)) {
case CAST_GROUND:
skill_castend_pos2(src, tbl->x, tbl->y, skill, skilllv, tick, 0);
break;
case CAST_NODAMAGE:
skill_castend_nodamage_id(src, tbl, skill, skilllv, tick, 0);
break;
case CAST_DAMAGE:
skill_castend_damage_id(src, tbl, skill, skilllv, tick, 0);
break;
}
//Set canact delay. [Skotlex]
ud = unit_bl2ud(src);
if (ud) {
rate = skill_delayfix(src, skill, skilllv)/2;
if (DIFF_TICK(ud->canact_tick, tick + rate) < 0)
ud->canact_tick = tick+rate;
}
break; //Only one auto skill comes off at a time.
}
}
return 0;
}
/* Splitted off from skill_additional_effect, which is never called when the
* attack skill kills the enemy. Place in this function counter status effects
* when using skills (eg: Asura's sp regen penalty, or counter-status effects
* from cards) that will take effect on the source, not the target. [Skotlex]
* Note: Currently this function only applies to Extremity Fist and BF_WEAPON
* type of skills, so not every instance of skill_additional_effect needs a call
* to this one.
*/
int skill_counter_additional_effect (struct block_list* src, struct block_list *bl, int skillid, int skilllv, int attack_type, unsigned int tick)
{
int rate;
struct map_session_data *sd=NULL;
struct map_session_data *dstsd=NULL;
struct status_change *tsc;
nullpo_retr(0, src);
nullpo_retr(0, bl);
if(skillid < 0)
{ // remove the debug print when this case is finished
ShowDebug("skill_counter_additional_effect: skillid=%i\ncall: %p %p %i %i %i %i",skillid,
src, bl,skillid,skilllv,attack_type,tick);
return 0;
}
if(skillid > 0 && skilllv <= 0) return 0; // don't forget auto attacks! - celest
tsc = status_get_sc(bl);
if (tsc && !tsc->count)
tsc = NULL;
BL_CAST(BL_PC, src, sd);
BL_CAST(BL_PC, bl, dstsd);
switch(skillid){
case 0: //Normal Attack
if(tsc && tsc->data[SC_KAAHI].timer != -1 && tsc->data[SC_KAAHI].val4 == -1)
tsc->data[SC_KAAHI].val4 = add_timer(
tick+skill_get_time2(SL_KAAHI,tsc->data[SC_KAAHI].val1),
kaahi_heal_timer, bl->id, SC_KAAHI); //Activate heal.
break;
case MO_EXTREMITYFIST: /* 阿修羅覇凰拳 */
//阿修羅を使うと5分間自然回復しないようになる
sc_start(src,SkillStatusChangeTable(skillid),100,skilllv,skill_get_time2(skillid,skilllv));
break;
}
if(sd && skillid && attack_type&BF_MAGIC && status_isdead(bl) &&
skill_get_inf(skillid)!=INF_GROUND_SKILL &&
(rate=pc_checkskill(sd,HW_SOULDRAIN))>0
){ //Soul Drain should only work on targetted spells [Skotlex]
if (pc_issit(sd)) pc_setstand(sd); //Character stuck in attacking animation while 'sitting' fix. [Skotlex]
clif_skill_nodamage(src,bl,HW_SOULDRAIN,rate,1);
status_heal(src, 0, status_get_lv(bl)*(95+15*rate)/100, 2);
}
if(dstsd && attack_type&BF_WEAPON)
{ //Counter effects.
int i, type, time;
for(i=0; i < MAX_PC_BONUS && dstsd->addeff2[i].flag; i++)
{
rate = dstsd->addeff2[i].rate;
type = (sd && sd->state.arrow_atk) || (status_get_range(src)>2);
if (type)
rate+=dstsd->addeff2[i].arrow_rate;
if (!rate) continue;
if (!(dstsd->addeff2[i].flag&ATF_LONG && dstsd->addeff2[i].flag&ATF_SHORT))
{ //Trigger has range consideration.
if ((dstsd->addeff2[i].flag&ATF_LONG && !type) ||
(dstsd->addeff2[i].flag&ATF_SHORT && type))
continue; //Range Failed.
}
type = dstsd->addeff2[i].id;
time = skill_get_time2(StatusSkillChangeTable[type],7);
if (dstsd->addeff2[i].flag&ATF_TARGET)
status_change_start(src,type,rate,7,0,0,0,time,0);
if (dstsd->addeff2[i].flag&ATF_SELF && !status_isdead(bl))
status_change_start(bl,type,rate,7,0,0,0,time,0);
}
}
//Trigger counter-spells to retaliate against damage causing skills. [Skotlex]
if(dstsd && !status_isdead(bl) && src != bl && !(skillid && skill_get_nk(skillid)&NK_NO_DAMAGE))
{
struct block_list *tbl;
struct unit_data *ud;
int i, skillid, skilllv, rate;
for (i = 0; i < MAX_PC_BONUS; i++) {
if (dstsd->autospell2[i].id == 0)
break;
skillid = (dstsd->autospell2[i].id > 0) ? dstsd->autospell2[i].id : -dstsd->autospell2[i].id;
skilllv = (dstsd->autospell2[i].lv > 0) ? dstsd->autospell2[i].lv : 1;
rate = ((sd && !sd->state.arrow_atk) || (status_get_range(src)<=2)) ?
dstsd->autospell2[i].rate : dstsd->autospell2[i].rate / 2;
if (skillnotok(skillid, dstsd))
continue;
if (rand()%1000 > rate)
continue;
if (dstsd->autospell2[i].id < 0)
tbl = bl;
else
tbl = src;
if (tbl != bl && !battle_check_range(bl, tbl, skill_get_range2(bl, skillid, skilllv)))
continue; //Autoskills DO check for target-src range. [Skotlex]
switch (skill_get_casttype(skillid)) {
case CAST_GROUND:
skill_castend_pos2(bl, tbl->x, tbl->y, skillid, skilllv, tick, 0);
break;
case CAST_NODAMAGE:
skill_castend_nodamage_id(bl, tbl, skillid, skilllv, tick, 0);
break;
case CAST_DAMAGE:
skill_castend_damage_id(bl, tbl, skillid, skilllv, tick, 0);
break;
}
//Set canact delay. [Skotlex]
ud = unit_bl2ud(bl);
if (ud) {
rate = skill_delayfix(bl, skillid, skilllv)/2;
if (DIFF_TICK(ud->canact_tick, tick + rate) < 0)
ud->canact_tick = tick+rate;
}
break; //trigger only one auto-spell per hit.
}
}
return 0;
}
/*=========================================================================
Breaks equipment. On-non players causes the corresponding strip effect.
- rate goes from 0 to 10000 (100.00%)
- flag is a BCT_ flag to indicate which type of adjustment should be used
(BCT_ENEMY/BCT_PARTY/BCT_SELF) are the valid values.
--------------------------------------------------------------------------*/
int skill_break_equip (struct block_list *bl, unsigned short where, int rate, int flag)
{
static int where_list[4] = {EQP_WEAPON, EQP_ARMOR, EQP_SHIELD, EQP_HELM};
static int scatk[4] = {SC_STRIPWEAPON, SC_STRIPARMOR, SC_STRIPSHIELD, SC_STRIPHELM};
static int scdef[4] = {SC_CP_WEAPON, SC_CP_ARMOR, SC_CP_SHIELD, SC_CP_HELM};
struct status_change *sc = status_get_sc(bl);
int i,j;
TBL_PC *sd;
BL_CAST(BL_PC, bl, sd);
if (sc && !sc->count)
sc = NULL;
if (sd) {
if (sd->unbreakable_equip)
where &= ~sd->unbreakable_equip;
if (sd->unbreakable)
rate -= rate*sd->unbreakable/100;
if (where&EQP_WEAPON) {
switch (sd->status.weapon) {
case W_FIST: //Bare fists should not break :P
case W_1HAXE:
case W_2HAXE:
case W_MACE: // Axes and Maces can't be broken [DracoRPG]
case W_STAFF:
case W_BOOK: //Rods and Books can't be broken [Skotlex]
where &= ~EQP_WEAPON;
}
}
}
if (flag&BCT_ENEMY) {
if (battle_config.equip_skill_break_rate != 100)
rate = rate*battle_config.equip_skill_break_rate/100;
} else if (flag&(BCT_PARTY|BCT_SELF)) {
if (battle_config.equip_self_break_rate != 100)
rate = rate*battle_config.equip_self_break_rate/100;
}
for (i = 0; i < 4; i++) {
if (where&where_list[i]) {
if (sc && sc->count && sc->data[scdef[i]].timer != -1)
where&=~where_list[i];
else if (rand()%10000 >= rate)
where&=~where_list[i];
else if (!sd) //Cause Strip effect.
sc_start(bl,scatk[i],100,0,skill_get_time(StatusSkillChangeTable[scatk[i]],1));
}
}
if (!where) //Nothing to break.
return 0;
if (sd) {
for (i = 0; i < EQI_MAX; i++) {
j = sd->equip_index[i];
if (j <= 0 || sd->status.inventory[j].attribute == 1 || !sd->inventory_data[j])
continue;
flag = 0;
switch(i) {
case EQI_HEAD_TOP: //Upper Head
flag = (where&EQP_HELM);
break;
case EQI_ARMOR: //Body
flag = (where&EQP_ARMOR);
break;
case EQI_HAND_R: //Left/Right hands
case EQI_HAND_L:
flag = (
(where&EQP_WEAPON && sd->inventory_data[j]->type == 4) ||
(where&EQP_SHIELD && sd->inventory_data[j]->type == 5));
break;
default:
continue;
}
if (flag) {
sd->status.inventory[j].attribute = 1;
pc_unequipitem(sd, j, 3);
}
}
clif_equiplist(sd);
}
return where; //Return list of pieces broken.
}
/*=========================================================================
Used to knock back players, monsters, traps, etc
If count&0xf00000, the direction is send in the 6th byte.
If count&0x10000, the direction is to the back of the target, otherwise is away from the src.
If count&0x20000, position update packets must not be sent.
IF count&0X40000, direction is random.
--------------------------------------------------------------------------*/
int skill_blown (struct block_list *src, struct block_list *target, int count)
{
int dx=0,dy=0,nx,ny;
int x=target->x,y=target->y;
int dir,ret;
struct skill_unit *su=NULL;
nullpo_retr(0, src);
if (src != target && map_flag_gvg(target->m))
return 0; //No knocking back in WoE
if (!count&0xffff)
return 0; //Actual knockback distance is 0.
switch (target->type) {
case BL_MOB:
if (((TBL_MOB*)target)->class_ == MOBID_EMPERIUM)
return 0;
break;
case BL_SKILL:
su=(struct skill_unit *)target;
break;
}
if (count&0xf00000)
dir = (count>>20)&0xf;
else if (count&0x10000 || (target->x==src->x && target->y==src->y))
dir = unit_getdir(target);
else if (count&0x40000) //Flag for random pushing.
dir = rand()%8;
else
dir = map_calc_dir(target,src->x,src->y);
if (dir>=0 && dir<8){
dx = -dirx[dir];
dy = -diry[dir];
}
ret=path_blownpos(target->m,x,y,dx,dy,count&0xffff);
nx=ret>>16;
ny=ret&0xffff;
if (!su)
unit_stop_walking(target,0);
dx = nx - x;
dy = ny - y;
if (!dx && !dy) //Could not knockback.
return 0;
map_foreachinmovearea(clif_outsight,target->m,
x-AREA_SIZE,y-AREA_SIZE,x+AREA_SIZE,y+AREA_SIZE,
dx,dy,target->type==BL_PC?BL_ALL:BL_PC,target);
if(su)
skill_unit_move_unit_group(su->group,target->m,dx,dy);
else
map_moveblock(target, nx, ny, gettick());
map_foreachinmovearea(clif_insight,target->m,
nx-AREA_SIZE,ny-AREA_SIZE,nx+AREA_SIZE,ny+AREA_SIZE,
-dx,-dy,target->type==BL_PC?BL_ALL:BL_PC,target);
if(!(count&0x20000))
clif_blown(target);
return 0;
}
/*
* =========================================================================
* スキル攻撃効果処理まとめ
* flagの説明。16進図
* 00XRTTff
* ff = magicで計算に渡される）
* TT = パケットのtype部分(0でデフォルト）
* X = パケットのスキルLv
* R = 予約（skill_area_subで使用する）
*-------------------------------------------------------------------------
*/
int skill_attack (int attack_type, struct block_list* src, struct block_list *dsrc, struct block_list *bl, int skillid, int skilllv, unsigned int tick, int flag)
{
struct Damage dmg;
struct status_data *sstatus, *tstatus;
struct status_change *sc;
struct map_session_data *sd=NULL, *tsd=NULL;
int type,lv,damage,rdamage=0;
if(skillid > 0 && skilllv <= 0) return 0;
nullpo_retr(0, src); //Source is the master behind the attack (player/mob/pet)
nullpo_retr(0, dsrc); //dsrc is the actual originator of the damage, can be the same as src, or a skill casted by src.
nullpo_retr(0, bl); //Target to be attacked.
if (src != dsrc) {
//When caster is not the src of attack, this is a ground skill, and as such, do the relevant target checking. [Skotlex]
if (!status_check_skilluse(battle_config.skill_caster_check?src:NULL, bl, skillid, 2))
return 0;
} else if (flag && skill_get_nk(skillid)&NK_SPLASH) {
//Note that splash attacks often only check versus the targetted mob, those around the splash area normally don't get checked for being hidden/cloaked/etc. [Skotlex]
if (!status_check_skilluse(dsrc, bl, skillid, 2))
return 0;
}
if (dsrc->type == BL_PC)
sd = (struct map_session_data *)dsrc;
if (bl->type == BL_PC)
tsd = (struct map_session_data *)bl;
sstatus = status_get_status_data(dsrc);
tstatus = status_get_status_data(bl);
// Is this check really needed? FrostNova won't hurt you if you step right where the caster is?
if(skillid == WZ_FROSTNOVA && dsrc->x == bl->x && dsrc->y == bl->y) //使用スキルがフロストノヴァで、dsrcとblが同じ場所なら何もしない
return 0;
type=-1;
lv=(flag>>20)&0xf;
dmg=battle_calc_attack(attack_type,src,bl,skillid,skilllv,flag&0xff );
//Skotlex: Adjusted to the new system
if(src->type==BL_PET && (struct pet_data *)src)
{ // [Valaris]
struct pet_data *pd = (struct pet_data *)src;
if (pd->a_skill && pd->a_skill->div_ && pd->a_skill->id == skillid)
{
int element = skill_get_pl(skillid);
if (skillid == -1)
element = sstatus->rhw.ele;
dmg.damage=battle_attr_fix(src, bl, skilllv, element, tstatus->def_ele, tstatus->ele_lv);
dmg.damage2=0;
dmg.div_= pd->a_skill->div_;
}
}
sc= status_get_sc(bl);
if (sc && !sc->count) sc = NULL; //Don't need it.
if (attack_type&BF_MAGIC) {
if(sc && sc->data[SC_KAITE].timer != -1 && (dmg.damage || dmg.damage2)
&& !(sstatus->mode&MD_BOSS) && (sd || status_get_lv(dsrc) <= 80)
) { //Works on players or mobs with level under 80.
clif_skill_nodamage(bl,bl,SL_KAITE,sc->data[SC_KAITE].val1,1);
if (--sc->data[SC_KAITE].val2 <= 0)
status_change_end(bl, SC_KAITE, -1);
bl = src; //Just make the skill attack yourself @.@
sc = status_get_sc(bl);
tsd = (bl->type == BL_PC)?(TBL_PC*)bl:NULL;
if (sc && !sc->count)
sc = NULL; //Don't need it.
if (sc && sc->data[SC_SPIRIT].timer != -1 && sc->data[SC_SPIRIT].val2 == SL_WIZARD)
{ //Spirit of Wizard blocks bounced back spells.
dmg.damage = dmg.damage2 = 0;
dmg.dmg_lv = ATK_FLEE;
}
}
if(sc && sc->data[SC_MAGICROD].timer != -1 && src == dsrc) {
dmg.damage = dmg.damage2 = 0;
dmg.dmg_lv = ATK_FLEE; //This will prevent skill additional effect from taking effect. [Skotlex]
if(tsd) {
int sp = skill_get_sp(skillid,skilllv);
sp = sp * sc->data[SC_MAGICROD].val2 / 100;
if(skillid == WZ_WATERBALL && skilllv > 1)
sp = sp/((skilllv|1)*(skilllv|1)); //Estimate SP cost of a single water-ball
if(sp > SHRT_MAX) sp = SHRT_MAX;
else if(sp < 1) sp = 1;
if(sp > tsd->status.max_sp - tsd->status.sp)
sp = tsd->status.max_sp - tsd->status.sp;
tsd->status.sp += sp;
clif_heal(tsd->fd,SP_SP,sp);
tsd->ud.canact_tick = tick + skill_delayfix(bl, SA_MAGICROD, sc->data[SC_MAGICROD].val1);
}
clif_skill_nodamage(bl,bl,SA_MAGICROD,sc->data[SC_MAGICROD].val1,1);
}
}
damage = dmg.damage + dmg.damage2;
if (damage > 0 && src != bl && src == dsrc)
rdamage = battle_calc_return_damage(bl, &damage, dmg.flag);
if(lv==15)
lv=-1;
if( flag&0xff00 )
type=(flag&0xff00)>>8;
if((damage <= 0 || damage < dmg.div_)
&& skillid != CH_PALMSTRIKE) //Palm Strike is the only skill that will knockback even if it misses. [Skotlex]
dmg.blewcount = 0;
if(skillid == CR_GRANDCROSS||skillid == NPC_GRANDDARKNESS) {//グランドクロス
if(battle_config.gx_disptype) dsrc = src; // 敵ダメージ白文字表示
if(src == bl) type = 4; // 反動はダメージモーションなし
}
//使用者がPCの場合の処理ここから
if(sd) {
//Sorry for removing the Japanese comments, but they were actually distracting
//from the actual code and I couldn't understand a thing anyway >.< [Skotlex]
if (sd->sc.data[SC_COMBO].timer!=-1)
{ //End combo state after skill is invoked. [Skotlex]
switch (skillid) {
case TK_TURNKICK:
case TK_STORMKICK:
case TK_DOWNKICK:
case TK_COUNTER:
//set this skill as previous one.
sd->skillid_old = skillid;
sd->skilllv_old = skilllv;
if (pc_famerank(sd->char_id,MAPID_TAEKWON))
break; //Do not end combo state.
default:
status_change_end(src,SC_COMBO,-1);
}
}
switch(skillid)
{
case MO_TRIPLEATTACK:
{
int delay = 1000 - 4*sstatus->agi - 2*sstatus->dex;
if (damage < (signed int)tstatus->hp &&
pc_checkskill(sd, MO_CHAINCOMBO) > 0)
delay += 300 * battle_config.combo_delay_rate / 100;
sc_start4(src,SC_COMBO,100,MO_TRIPLEATTACK,skilllv,0,0,delay);
clif_combo_delay(src, delay);
if (sd->status.party_id>0) //bonus from SG_FRIEND [Komurka]
party_skill_check(sd, sd->status.party_id, MO_TRIPLEATTACK, skilllv);
break;
}
case MO_CHAINCOMBO:
{
int delay = 1000 - 4*sstatus->agi - 2*sstatus->dex;
if(damage < (signed int)tstatus->hp &&
(pc_checkskill(sd, MO_COMBOFINISH) > 0 && sd->spiritball > 0))
delay += 300 * battle_config.combo_delay_rate /100;
sc_start4(src,SC_COMBO,100,MO_CHAINCOMBO,skilllv,0,0,delay);
clif_combo_delay(src,delay);
break;
}
case MO_COMBOFINISH:
{
int delay = 700 - 4*sstatus->agi - 2*sstatus->dex;
if(damage < (signed int)tstatus->hp &&
(
(pc_checkskill(sd, MO_EXTREMITYFIST) > 0 && sd->spiritball >= 4 && sd->sc.data[SC_EXPLOSIONSPIRITS].timer != -1) ||
(pc_checkskill(sd, CH_TIGERFIST) > 0 && sd->spiritball > 0) ||
(pc_checkskill(sd, CH_CHAINCRUSH) > 0 && sd->spiritball > 1)
))
delay += 300 * battle_config.combo_delay_rate /100;
sc_start4(src,SC_COMBO,100,MO_COMBOFINISH,skilllv,0,0,delay);
clif_combo_delay(src,delay);
break;
}
case CH_TIGERFIST:
{ //Tigerfist is now a combo-only skill. [Skotlex]
int delay = 1000 - 4*sstatus->agi - 2*sstatus->dex;
if(damage < (signed int)tstatus->hp &&
(
(pc_checkskill(sd, MO_EXTREMITYFIST) > 0 && sd->spiritball >= 3 && sd->sc.data[SC_EXPLOSIONSPIRITS].timer != -1) ||
(pc_checkskill(sd, CH_CHAINCRUSH) > 0)
))
delay += 300 * battle_config.combo_delay_rate /100;
sc_start4(src,SC_COMBO,100,CH_TIGERFIST,skilllv,0,0,delay);
clif_combo_delay(src,delay);
break;
}
case CH_CHAINCRUSH:
{
int delay = 1000 - 4*sstatus->agi - 2*sstatus->dex;
if(damage < (signed int)tstatus->hp)
delay += 300 * battle_config.combo_delay_rate /100;
sc_start4(src,SC_COMBO,100,CH_CHAINCRUSH,skilllv,0,0,delay);
clif_combo_delay(src,delay);
break;
}
case AC_DOUBLE:
if((tstatus->race == RC_BRUTE || tstatus->race == RC_INSECT) && damage < (signed int)tstatus->hp && pc_checkskill(sd, HT_POWER)) {
//TODO: This code was taken from Triple Blows, is this even how it should be? [Skotlex]
sc_start4(src,SC_COMBO,100,HT_POWER,bl->id,0,0,2000);
clif_combo_delay(src,2000);
}
break;
case TK_COUNTER:
{ //bonus from SG_FRIEND [Komurka]
int level;
if(sd->status.party_id>0 && (level = pc_checkskill(sd,SG_FRIEND)))
party_skill_check(sd, sd->status.party_id, TK_COUNTER,level);
}
break;
case SL_STIN:
case SL_STUN:
if (skilllv >= 7 && sd->sc.data[SC_SMA].timer == -1)
sc_start(src,SC_SMA,100,skilllv,skill_get_time(SL_SMA, skilllv));
break;
case GS_FULLBUSTER:
//Can't attack nor use items until skill's delay expires. [Skotlex]
sd->ud.attackabletime = sd->canuseitem_tick = sd->ud.canact_tick;
break;
} //Switch End
}
//Display damage.
switch(skillid){
//Skills who's damage should't show any skill-animation.
case SM_MAGNUM:
case AS_SPLASHER:
case ASC_METEORASSAULT:
case GS_SPREADATTACK:
dmg.dmotion = clif_skill_damage(dsrc,bl,tick,dmg.amotion,dmg.dmotion, damage, dmg.div_, skillid, -1, 5);
break;
case KN_BRANDISHSPEAR:
{ //Only display skill animation for skill's target.
struct unit_data *ud = unit_bl2ud(src);
if (ud && ud->skilltarget == bl->id)
dmg.dmotion = clif_skill_damage(dsrc,bl,tick,dmg.amotion,dmg.dmotion, damage, dmg.div_, skillid, (lv!=0)?lv:skilllv, type);
else
dmg.dmotion = clif_skill_damage(dsrc,bl,tick,dmg.amotion,dmg.dmotion, damage, dmg.div_, skillid, -1, 5);
break;
}
case PA_GOSPEL: //Should look like Holy Cross [Skotlex]
dmg.dmotion = clif_skill_damage(dsrc,bl,tick,dmg.amotion,dmg.dmotion, damage, dmg.div_, CR_HOLYCROSS, -1, 5);
break;
case NPC_SELFDESTRUCTION:
if(src->type==BL_PC)
dmg.blewcount = 10;
dmg.amotion = 0; //Disable delay or attack will do no damage since source is dead by the time it takes effect. [Skotlex]
case KN_AUTOCOUNTER: //Skills that need be passed as a normal attack for the client to display correctly.
case TF_DOUBLE:
case GS_CHAINACTION:
case SN_SHARPSHOOTING:
dmg.dmotion = clif_damage(src,bl,tick,dmg.amotion,dmg.dmotion,damage,dmg.div_,dmg.type,dmg.damage2);
break;
case CR_GRANDCROSS:
case NPC_GRANDDARKNESS:
//Only show animation when hitting yourself. [Skotlex]
if (src!=bl) {
dmg.dmotion = clif_skill_damage(dsrc,bl,tick,dmg.amotion,dmg.dmotion, damage, dmg.div_, skillid, -1, 5);
break;
}
default:
dmg.dmotion = clif_skill_damage(dsrc,bl,tick,dmg.amotion,dmg.dmotion, damage, dmg.div_, skillid, (lv!=0)?lv:skilllv, (skillid==0)? 5:type );
}
map_freeblock_lock();
if(damage > 0 && dmg.flag&BF_SKILL && tsd
&& pc_checkskill(tsd,RG_PLAGIARISM)
&& (!sc || sc->data[SC_PRESERVE].timer == -1)
&& damage < tsd->status.hp)
{ //Updated to not be able to copy skills if the blow will kill you. [Skotlex]
if ((!tsd->status.skill[skillid].id || tsd->status.skill[skillid].flag >= 13) &&
can_copy(tsd,skillid)) // Split all the check into their own function [Aru]
{
//既に盗んでいるスキルがあれば該当スキルを消す
if (tsd->cloneskill_id && tsd->status.skill[tsd->cloneskill_id].flag == 13){
tsd->status.skill[tsd->cloneskill_id].id = 0;
tsd->status.skill[tsd->cloneskill_id].lv = 0;
tsd->status.skill[tsd->cloneskill_id].flag = 0;
}
tsd->cloneskill_id = skillid;
tsd->status.skill[skillid].id = skillid;
tsd->status.skill[skillid].lv = skilllv;
if ((lv = pc_checkskill(tsd,RG_PLAGIARISM)) < skilllv)
tsd->status.skill[skillid].lv = lv;
tsd->status.skill[skillid].flag = 13;//cloneskill flag
pc_setglobalreg(tsd, "CLONE_SKILL", tsd->cloneskill_id);
pc_setglobalreg(tsd, "CLONE_SKILL_LV", tsd->status.skill[skillid].lv);
clif_skillinfoblock(tsd);
}
}
if (skillid != WZ_HEAVENDRIVE && bl->type == BL_SKILL && damage > 0) {
struct skill_unit* su = (struct skill_unit*)bl;
if (su->group && skill_get_inf2(su->group->skill_id)&INF2_TRAP)
damage = 0; //Only Heaven's drive may damage traps. [Skotlex]
}
if (!dmg.amotion) {
status_fix_damage(src,bl,damage,dmg.dmotion); //Deal damage before knockback to allow stuff like firewall+storm gust combo.
if (dmg.dmg_lv == ATK_DEF || damage > 0) {
if (!status_isdead(bl))
skill_additional_effect(src,bl,skillid,skilllv,attack_type,tick);
//Counter status effects [Skotlex]
skill_counter_additional_effect(dsrc,bl,skillid,skilllv,attack_type,tick);
}
}
//Only knockback if it's still alive, otherwise a "ghost" is left behind. [Skotlex]
if (dmg.blewcount > 0 && !status_isdead(bl))
skill_blown(dsrc,bl,dmg.blewcount);
//Delayed damage must be dealt after the knockback (it needs to know actual position of target)
if (dmg.amotion)
battle_delay_damage(tick+dmg.amotion,src,bl,attack_type,skillid,skilllv,damage,dmg.dmg_lv,dmg.dmotion);
if(skillid == RG_INTIMIDATE && damage > 0 && !(tstatus->mode&MD_BOSS)) {
int rate = 50 + skilllv * 5;
rate = rate + (status_get_lv(src) - status_get_lv(bl));
if(rand()%100 < rate)
skill_addtimerskill(src,tick + 800,bl->id,0,0,skillid,skilllv,0,flag);
}
if(sd && dmg.flag&BF_WEAPON && src != bl && src == dsrc && damage > 0) {
if (battle_config.left_cardfix_to_right)
battle_drain(sd, tsd, dmg.damage, dmg.damage, tstatus->race, tstatus->mode&MD_BOSS);
else
battle_drain(sd, tsd, dmg.damage, dmg.damage2, tstatus->race, tstatus->mode&MD_BOSS);
}
if (rdamage>0) {
if (dmg.amotion)
battle_delay_damage(tick+dmg.amotion,bl,src,0,0,0,rdamage,ATK_DEF,0);
else
status_fix_damage(bl,src,rdamage,0);
clif_damage(src,src,tick, dmg.amotion,0,rdamage,1,4,0);
//Use Reflect Shield to signal this kind of skill trigger. [Skotlex]
skill_additional_effect(bl,src,CR_REFLECTSHIELD, 1,BF_WEAPON,tick);
}
if (!(flag & 1) &&
(
skillid == MG_COLDBOLT || skillid == MG_FIREBOLT || skillid == MG_LIGHTNINGBOLT
) &&
(sc = status_get_sc(src)) &&
sc->count && sc->data[SC_DOUBLECAST].timer != -1 &&
rand() % 100 < 40+10*sc->data[SC_DOUBLECAST].val1)
{
// skill_addtimerskill(src, tick + dmg.div_*dmg.amotion, bl->id, 0, 0, skillid, skilllv, BF_MAGIC, flag|1);
skill_addtimerskill(src, tick + dmg.amotion, bl->id, 0, 0, skillid, skilllv, BF_MAGIC, flag|1);
}
map_freeblock_unlock();
return damage; /* 与ダメを返す */
}
/*==========================================
* スキル範囲攻撃用(map_foreachinareaから呼ばれる)
* flagについて：16進図を確認
* MSB <- 00fTffff ->LSB
* T =ターゲット選択用(BCT_*)
* ffff=自由に使用可能
* 0 =予約。0に固定
*------------------------------------------
*/
static int skill_area_temp[8]; /* 一時変数。必要なら使う。 */
static int skill_unit_temp[8]; /* For storing skill_unit ids as players move in/out of them. [Skotlex] */
static int skill_unit_index=0; //Well, yeah... am too lazy to pass pointers around :X
typedef int (*SkillFunc)(struct block_list *, struct block_list *, int, int, unsigned int, int);
int skill_area_sub (struct block_list *bl, va_list ap)
{
struct block_list *src;
int skill_id,skill_lv,flag;
unsigned int tick;
SkillFunc func;
nullpo_retr(0, bl);
nullpo_retr(0, ap);
src=va_arg(ap,struct block_list *); //ここではsrcの値を参照していないのでNULLチェックはしない
skill_id=va_arg(ap,int);
skill_lv=va_arg(ap,int);
tick=va_arg(ap,unsigned int);
flag=va_arg(ap,int);
func=va_arg(ap,SkillFunc);
if(battle_check_target(src,bl,flag) > 0)
func(src,bl,skill_id,skill_lv,tick,flag);
return 0;
}
static int skill_check_unit_range_sub (struct block_list *bl, va_list ap)
{
struct skill_unit *unit;
int skillid,g_skillid;
unit = (struct skill_unit *)bl;
if(bl->prev == NULL || bl->type != BL_SKILL)
return 0;
if(!unit->alive)
return 0;
skillid = va_arg(ap,int);
g_skillid = unit->group->skill_id;
switch (skillid)
{
case MG_SAFETYWALL:
case AL_PNEUMA:
if(g_skillid != MG_SAFETYWALL && g_skillid != AL_PNEUMA)
return 0;
break;
case AL_WARP:
case HT_SKIDTRAP:
case HT_LANDMINE:
case HT_ANKLESNARE:
case HT_SHOCKWAVE:
case HT_SANDMAN:
case HT_FLASHER:
case HT_FREEZINGTRAP:
case HT_BLASTMINE:
case HT_CLAYMORETRAP:
case HT_TALKIEBOX:
case HP_BASILICA:
//Non stackable on themselves and traps (including venom dust which does not has the trap inf2 set)
if (skillid != g_skillid && !(skill_get_inf2(g_skillid)&INF2_TRAP) && g_skillid != AS_VENOMDUST)
return 0;
break;
default: //Avoid stacking with same kind of trap. [Skotlex]
if (g_skillid != skillid)
return 0;
break;
}
return 1;
}
static int skill_check_unit_range (struct block_list *bl, int x, int y, int skillid, int skilllv)
{
//Non players do not check for the skill's splash-trigger area.
int range = bl->type==BL_PC?skill_get_unit_range(skillid, skilllv):0;
int layout_type = skill_get_unit_layout_type(skillid,skilllv);
if (layout_type==-1 || layout_type>MAX_SQUARE_LAYOUT) {
ShowError("skill_check_unit_range: unsupported layout type %d for skill %d\n",layout_type,skillid);
return 0;
}
range += layout_type;
return map_foreachinarea(skill_check_unit_range_sub,bl->m,
x-range,y-range,x+range,y+range,BL_SKILL,skillid);
}
static int skill_check_unit_range2_sub (struct block_list *bl, va_list ap)
{
int skillid;
if(bl->prev == NULL)
return 0;
if(status_isdead(bl))
return 0;
skillid = va_arg(ap,int);
if (skillid==HP_BASILICA && bl->type==BL_PC)
return 0;
if (skillid==AM_DEMONSTRATION && bl->type==BL_MOB && ((TBL_MOB*)bl)->class_ == MOBID_EMPERIUM)
return 0; //Allow casting Bomb/Demonstration Right under emperium [Skotlex]
return 1;
}
static int skill_check_unit_range2 (struct block_list *bl, int x, int y, int skillid, int skilllv)
{
int range, type;
switch (skillid) { // to be expanded later
case WZ_ICEWALL:
range = 2;
break;
default:
{
int layout_type = skill_get_unit_layout_type(skillid,skilllv);
if (layout_type==-1 || layout_type>MAX_SQUARE_LAYOUT) {
ShowError("skill_check_unit_range2: unsupported layout type %d for skill %d\n",layout_type,skillid);
return 0;
}
range = skill_get_unit_range(skillid,skilllv) + layout_type;
}
break;
}
// if the caster is a monster/NPC, only check for players
// otherwise just check characters
if (bl->type == BL_PC)
type = BL_CHAR;
else
type = BL_PC;
return map_foreachinarea(skill_check_unit_range2_sub, bl->m,
x - range, y - range, x + range, y + range,
type, skillid);
}
int skill_guildaura_sub (struct block_list *bl, va_list ap)
{
struct map_session_data *sd;
int gid, id, *flag;
nullpo_retr(0, sd = (struct map_session_data *)bl);
nullpo_retr(0, ap);
id = va_arg(ap,int);
gid = va_arg(ap,int);
if (sd->status.guild_id != gid)
return 0;
nullpo_retr(0, flag = va_arg(ap,int *));
if (flag && *flag > 0) {
if (sd->sc.count && sd->sc.data[SC_GUILDAURA].timer != -1) {
if (sd->sc.data[SC_GUILDAURA].val4 != *flag) {
sd->sc.data[SC_GUILDAURA].val4 = *flag;
status_calc_bl(&sd->bl, StatusChangeFlagTable[SC_GUILDAURA]);
}
return 0;
}
sc_start4(&sd->bl, SC_GUILDAURA,100, 1, id, 0, *flag, 1000);
}
return 0;
}
/*=========================================================================
* 範囲スキル使用処理小分けここから
*/
/* 対象の数をカウントする。（skill_area_temp[0]を初期化しておくこと） */
int skill_area_sub_count (struct block_list *src, struct block_list *target, int skillid, int skilllv, unsigned int tick, int flag)
{
if(skill_area_temp[0] < 0xffff)
skill_area_temp[0]++;
return 1;
}
int skill_count_water (struct block_list *src, int range)
{
int i,x,y,cnt = 0,size = range*2+1;
struct skill_unit *unit;
for (i=0;i<size*size;i++) {
x = src->x+(i%size-range);
y = src->y+(i/size-range);
if (map_getcell(src->m,x,y,CELL_CHKWATER)) {
cnt++;
continue;
}
unit = map_find_skill_unit_oncell(src,x,y,SA_DELUGE,NULL);
if (unit) {
cnt++;
skill_delunit(unit);
}
}
return cnt;
}
/*==========================================
*
*------------------------------------------
*/
static int skill_timerskill (int tid, unsigned int tick, int id, int data)
{
struct block_list *src = map_id2bl(id),*target;
struct unit_data *ud = unit_bl2ud(src);
struct skill_timerskill *skl = NULL;
int range;
nullpo_retr(0, src);
nullpo_retr(0, ud);
skl = ud->skilltimerskill[data];
nullpo_retr(0, skl);
ud->skilltimerskill[data] = NULL;
do {
if(src->prev == NULL)
break;
if(skl->target_id) {
target = map_id2bl(skl->target_id);
if(!target && skl->skill_id == RG_INTIMIDATE)
target = src; //Required since it has to warp.
if(target == NULL)
break;
if(target->prev == NULL)
break;
if(src->m != target->m)
break;
if(status_isdead(src))
break;
if(status_isdead(target) && skl->skill_id != RG_INTIMIDATE && skl->skill_id != WZ_WATERBALL)
break;
switch(skl->skill_id) {
case RG_INTIMIDATE:
if (unit_warp(src,-1,-1,-1,3) == 0) {
short x,y;
map_search_freecell(src, 0, &x, &y, 1, 1, 0);
if (target != src && !status_isdead(target))
unit_warp(target, -1, x, y, 3);
}
break;
case BA_FROSTJOKE: /* 寒いジョーク */
case DC_SCREAM: /* スクリーム */
range= skill_get_splash(skl->skill_id, skl->skill_lv);
map_foreachinarea(skill_frostjoke_scream,skl->map,skl->x-range,skl->y-range,
skl->x+range,skl->y+range,BL_CHAR,src,skl->skill_id,skl->skill_lv,tick);
break;
case WZ_WATERBALL:
if (!status_isdead(target))
skill_attack(BF_MAGIC,src,src,target,skl->skill_id,skl->skill_lv,tick,skl->flag);
if (skl->type>1 && !status_isdead(target)) {
skill_addtimerskill(src,tick+125,target->id,0,0,skl->skill_id,skl->skill_lv,skl->type-1,skl->flag);
} else {
struct status_change *sc = status_get_sc(src);
if(sc && sc->data[SC_MAGICPOWER].timer != -1)
status_change_end(src,SC_MAGICPOWER,-1);
}
break;
default:
skill_attack(skl->type,src,src,target,skl->skill_id,skl->skill_lv,tick,skl->flag);
break;
}
}
else {
if(src->m != skl->map)
break;
switch(skl->skill_id) {
case WZ_METEOR:
if(skl->type >= 0) {
skill_unitsetting(src,skl->skill_id,skl->skill_lv,skl->type>>16,skl->type&0xFFFF,skl->flag);
clif_skill_poseffect(src,skl->skill_id,skl->skill_lv,skl->x,skl->y,tick);
}
else
skill_unitsetting(src,skl->skill_id,skl->skill_lv,skl->x,skl->y,skl->flag);
break;
}
}
} while (0);
//Free skl now that it is no longer needed.
ers_free(skill_timer_ers, skl);
return 0;
}
/*==========================================
*
*------------------------------------------
*/
int skill_addtimerskill (struct block_list *src, unsigned int tick, int target, int x,int y, int skill_id, int skill_lv, int type, int flag)
{
int i;
struct unit_data *ud;
nullpo_retr(1, src);
ud = unit_bl2ud(src);
nullpo_retr(1, ud);
for(i=0;i<MAX_SKILLTIMERSKILL && ud->skilltimerskill[i]; i++);
if (i==MAX_SKILLTIMERSKILL) return 1;
ud->skilltimerskill[i] = ers_alloc(skill_timer_ers, struct skill_timerskill);
ud->skilltimerskill[i]->timer = add_timer(tick, skill_timerskill, src->id, i);
ud->skilltimerskill[i]->src_id = src->id;
ud->skilltimerskill[i]->target_id = target;
ud->skilltimerskill[i]->skill_id = skill_id;
ud->skilltimerskill[i]->skill_lv = skill_lv;
ud->skilltimerskill[i]->map = src->m;
ud->skilltimerskill[i]->x = x;
ud->skilltimerskill[i]->y = y;
ud->skilltimerskill[i]->type = type;
ud->skilltimerskill[i]->flag = flag;
return 0;
}
/*==========================================
*
*------------------------------------------
*/
int skill_cleartimerskill (struct block_list *src)
{
int i;
struct unit_data *ud;
nullpo_retr(0, src);
ud = unit_bl2ud(src);
nullpo_retr(0, ud);
for(i=0;i<MAX_SKILLTIMERSKILL;i++) {
if(ud->skilltimerskill[i]) {
delete_timer(ud->skilltimerskill[i]->timer, skill_timerskill);
ers_free(skill_timer_ers, ud->skilltimerskill[i]);
ud->skilltimerskill[i]=NULL;
}
}
return 1;
}
static int skill_reveal_trap (struct block_list *bl, va_list ap)
{
TBL_SKILL *su = (TBL_SKILL*)bl;
if (su->alive && su->group && skill_get_inf2(su->group->skill_id)&INF2_TRAP)
{ //Reveal trap.
//Change look is not good enough, the client ignores it as an actual trap still. [Skotlex]
//clif_changetraplook(bl, su->group->unit_id);
clif_skill_setunit(su);
return 1;
}
return 0;
}
/*==========================================
* スキル使用（詠唱完了、ID指定攻撃系）
* （スパゲッティに向けて１歩前進！(ダメポ)）
*------------------------------------------
*/
int skill_castend_damage_id (struct block_list* src, struct block_list *bl, int skillid, int skilllv, unsigned int tick, int flag)
{
struct map_session_data *sd = NULL, *tsd = NULL;
struct status_data *tstatus;
struct status_change *sc;
if (skillid > 0 && skilllv <= 0) return 0;
nullpo_retr(1, src);
nullpo_retr(1, bl);
if (src->m != bl->m)
return 1;
if (bl->prev == NULL)
return 1;
if (src->type == BL_PC)
sd = (struct map_session_data *)src;
if (bl->type == BL_PC)
tsd = (struct map_session_data *)bl;
if (status_isdead(src) || (src != bl && status_isdead(bl)))
return 1;
if (skillid && skill_get_type(skillid) == BF_MAGIC && status_isimmune(bl))
{
if (sd) clif_skill_fail(sd,skillid,0,0);
//GTB makes all targetted skills silently fail.
return 1;
}
sc = status_get_sc(src);
if (sc && !sc->count)
sc = NULL; //Unneeded
tstatus = status_get_status_data(bl);
map_freeblock_lock();
switch(skillid)
{
/* 武器攻撃系スキル */
case SM_BASH: /* バッシュ */
case MC_MAMMONITE: /* メマーナイト */
case TF_DOUBLE:
case AC_DOUBLE: /* ダブルストレイフィング */
case AS_SONICBLOW: /* ソニックブロー */
case KN_PIERCE: /* ピアース */
case KN_SPEARBOOMERANG: /* スピアブーメラン */
case KN_BRANDISHSPEAR: /* ブランディッシュスピア */
case TF_POISON: /* インベナム */
case TF_SPRINKLESAND: /* 砂まき */
case AC_CHARGEARROW: /* チャージアロー */
case RG_RAID: /* サプライズアタック */
case RG_INTIMIDATE: /* インティミデイト */
case AM_ACIDTERROR: /* アシッドテラー */
case BA_MUSICALSTRIKE: /* ミュージカルストライク */
case DC_THROWARROW: /* 矢撃ち */
case BA_DISSONANCE: /* 不協和音 */
case CR_HOLYCROSS: /* ホーリークロス */
case NPC_DARKCROSS:
case CR_SHIELDCHARGE:
case CR_SHIELDBOOMERANG:
/* 以下MOB専用 */
/* 単体攻撃、SP減少攻撃、遠距離攻撃、防御無視攻撃、多段攻撃 */
case NPC_PIERCINGATT:
case NPC_MENTALBREAKER:
case NPC_RANGEATTACK:
case NPC_CRITICALSLASH:
case NPC_COMBOATTACK:
/* 必中攻撃、毒攻撃、暗黒攻撃、沈黙攻撃、スタン攻撃 */
case NPC_GUIDEDATTACK:
case NPC_POISON:
case NPC_BLINDATTACK:
case NPC_SILENCEATTACK:
case NPC_STUNATTACK:
/* 石化攻撃、呪い攻撃、睡眠攻撃、ランダムATK攻撃 */
case NPC_PETRIFYATTACK:
case NPC_CURSEATTACK:
case NPC_SLEEPATTACK:
case NPC_RANDOMATTACK:
/* 水属性攻撃、地属性攻撃、火属性攻撃、風属性攻撃 */
case NPC_WATERATTACK:
case NPC_GROUNDATTACK:
case NPC_FIREATTACK:
case NPC_WINDATTACK:
/* 毒属性攻撃、聖属性攻撃、闇属性攻撃、念属性攻撃、SP減少攻撃 */
case NPC_POISONATTACK:
case NPC_HOLYATTACK:
case NPC_DARKNESSATTACK:
case NPC_TELEKINESISATTACK:
case NPC_UNDEADATTACK:
case NPC_BREAKARMOR:
case NPC_BREAKWEAPON:
case NPC_BREAKHELM:
case NPC_BREAKSHIELD:
case LK_AURABLADE: /* オーラブレード */
case LK_SPIRALPIERCE: /* スパイラルピアース */
case LK_HEADCRUSH: /* ヘッドクラッシュ */
case LK_JOINTBEAT: /* ジョイントビート */
case CG_ARROWVULCAN: /* アローバルカン */
case HW_MAGICCRASHER: /* マジッククラッシャー */
case ASC_METEORASSAULT: /* メテオアサルト */
case ITM_TOMAHAWK:
case MO_TRIPLEATTACK:
case CH_CHAINCRUSH: /* 連柱崩撃 */
case CH_TIGERFIST: /* 伏虎拳 */
case PA_SHIELDCHAIN: // Shield Chain
case PA_SACRIFICE: /* サクリファイス */
case WS_CARTTERMINATION: // Cart Termination
case AS_VENOMKNIFE:
case HT_PHANTASMIC:
case HT_POWER:
case TK_DOWNKICK:
case TK_COUNTER:
case ASC_BREAKER:
skill_attack(BF_WEAPON,src,src,bl,skillid,skilllv,tick,flag);
break;
case MO_COMBOFINISH:
if (!(flag&1) && sc && sc->data[SC_SPIRIT].timer != -1 && sc->data[SC_SPIRIT].val2 == SL_MONK)
{ //Becomes a splash attack when Soul Linked.
map_foreachinrange(skill_area_sub, bl,
skill_get_splash(skillid, skilllv),BL_CHAR,
src,skillid,skilllv,tick, flag|BCT_ENEMY|1,
skill_castend_damage_id);
} else
skill_attack(BF_WEAPON,src,src,bl,skillid,skilllv,tick,flag);
break;
case TK_STORMKICK: // Taekwon kicks [Dralnu]
clif_skill_nodamage(src,bl,skillid,skilllv,1);
map_foreachinrange(skill_attack_area, src,
skill_get_splash(skillid, skilllv), BL_CHAR,
BF_WEAPON, src, src, skillid, skilllv, tick, flag, BCT_ENEMY);
break;
case NJ_SHADOWJUMP: //[blackhole89]
case TK_JUMPKICK:
if (skillid == TK_JUMPKICK)
skill_attack(BF_WEAPON,src,src,bl,skillid,skilllv,tick,flag);
if (unit_movepos(src, bl->x, bl->y, 0, 0))
clif_slide(src,bl->x,bl->y);
break;
case SN_SHARPSHOOTING: /* シャープシューティング */
// Does it stop if touch an obstacle? it shouldn't shoot trough walls
map_foreachinpath (skill_attack_area,src->m,src->x,src->y,bl->x,bl->y,
skill_get_splash(skillid, skilllv),BL_CHAR,
BF_WEAPON,src,src,skillid,skilllv,tick,flag,BCT_ENEMY); // varargs
break;
case MO_INVESTIGATE: /* 発勁 */
skill_attack(BF_WEAPON,src,src,bl,skillid,skilllv,tick,flag);
if (sc && sc->data[SC_BLADESTOP].timer != -1)
status_change_end(src,SC_BLADESTOP,-1);
break;
case RG_BACKSTAP: /* バックスタブ */
{
int dir = map_calc_dir(src, bl->x, bl->y), t_dir = unit_getdir(bl);
if ((!check_distance_bl(src, bl, 0) && !map_check_dir(dir, t_dir)) || bl->type == BL_SKILL) {
if (sc && sc->data[SC_HIDING].timer != -1)
status_change_end(src, SC_HIDING, -1); // ハイディング解除
skill_attack(BF_WEAPON, src, src, bl, skillid, skilllv, tick, flag);
dir = dir < 4 ? dir+4 : dir-4; // change direction [Celest]
unit_setdir(bl,dir);
clif_changed_dir(bl);
}
else if (sd)
clif_skill_fail(sd,skillid,0,0);
}
break;
case MO_FINGEROFFENSIVE: /* 指弾 */
{
skill_attack(BF_WEAPON,src,src,bl,skillid,skilllv,tick,flag);
if (battle_config.finger_offensive_type && sd) {
int i;
for (i = 1; i < sd->spiritball_old; i++)
skill_addtimerskill(src, tick + i * 200, bl->id, 0, 0, skillid, skilllv, BF_WEAPON, flag);
// sd->canmove_tick = tick + (sd->spiritball_old - 1) * 200; Should be handled by the canmove delay on skill_cast_db [Skotlex]
}
if (sc && sc->data[SC_BLADESTOP].timer != -1)
status_change_end(src,SC_BLADESTOP,-1);
}
break;
case MO_CHAINCOMBO: /* 連打掌 */
{
skill_attack(BF_WEAPON,src,src,bl,skillid,skilllv,tick,flag);
if (sc && sc->data[SC_BLADESTOP].timer != -1)
status_change_end(src,SC_BLADESTOP,-1);
}
break;
case KN_CHARGEATK:
case MO_EXTREMITYFIST: /* 阿修羅覇鳳拳 */
if (skillid == MO_EXTREMITYFIST && sc && sc->count)
{
if (sc->data[SC_EXPLOSIONSPIRITS].timer != -1)
status_change_end(src, SC_EXPLOSIONSPIRITS, -1);
if (sc->data[SC_BLADESTOP].timer != -1)
status_change_end(src,SC_BLADESTOP,-1);
}
if(!check_distance_bl(src, bl, 2)) { //Need to move to target.
int dx,dy;
dx = bl->x - src->x;
dy = bl->y - src->y;
if(dx > 0) dx++;
else if(dx < 0) dx--;
if (dy > 0) dy++;
else if(dy < 0) dy--;
if (skillid == KN_CHARGEATK) //Store distance in flag [Skotlex]
flag = distance_bl(src, bl);
if (!unit_movepos(src, src->x+dx, src->y+dy, 1, 1)) {
if (sd) clif_skill_fail(sd,skillid,0,0);
break;
}
clif_slide(src,src->x,src->y);
if (skillid != MO_EXTREMITYFIST || battle_check_target(src, bl, BCT_ENEMY) > 0) //Check must be done here because EF should be broken this way.. [Skotlex]
skill_attack(BF_WEAPON,src,src,bl,skillid,skilllv,tick,flag);
else if (sd)
clif_skill_fail(sd,skillid,0,0);
}
else //Assume minimum distance of 1 for Charge.
skill_attack(BF_WEAPON,src,src,bl,skillid,skilllv,tick,skillid == KN_CHARGEATK?1:flag);
break;
/* 武器系範囲攻撃スキル */
case AS_GRIMTOOTH: /* グリムトゥース */
case MC_CARTREVOLUTION: /* カートレヴォリューション */
case NPC_SPLASHATTACK: /* スプラッシュアタック */
case AC_SHOWER: //Targetted skill implementation.
if(flag&1){
/* 個別にダメージを与える */
if(bl->id!=skill_area_temp[1]){
skill_attack(BF_WEAPON,src,src,bl,skillid,skilllv,tick,
0x0500);
}
} else {
skill_area_temp[1]=bl->id;
map_foreachinrange(skill_area_sub, bl,
skill_get_splash(skillid, skilllv), BL_CHAR,
src,skillid,skilllv,tick, flag|BCT_ENEMY|1,
skill_castend_damage_id);
//Skill-attack at the end in case it has knockback. [Skotlex]
skill_attack(BF_WEAPON,src,src,bl,skillid,skilllv,tick,0);
}
break;
case AS_SPLASHER:
if (flag & 1) { //Invoked from map_foreachinarea, skill_area_temp[0] holds number of targets to divide damage by.
if (bl->id != skill_area_temp[1])
skill_attack(BF_WEAPON, src, src, bl, skillid, skilllv, tick, skill_area_temp[0]);
else
skill_attack(BF_WEAPON, src, src, bl, skillid, skilllv, tick, 0);
} else {
skill_area_temp[0] = 0;
skill_area_temp[1] = bl->id;
map_foreachinrange(skill_area_sub, bl,
skill_get_splash(skillid, skilllv), BL_CHAR,
src, skillid, skilllv, tick, BCT_ENEMY, skill_area_sub_count);
skill_area_temp[0]--; //Substract one, the original target shouldn't count. [Skotlex]
map_foreachinrange(skill_area_sub, bl,
skill_get_splash(skillid, skilllv), BL_CHAR,
src, skillid, skilllv, tick, BCT_ENEMY|1,
skill_castend_damage_id);
}
break;
case SM_MAGNUM:
if(flag&1)
skill_attack(BF_WEAPON,src,src,bl,skillid,skilllv,tick,flag);
else {
//If we get here, someone changed magnum to be a enemy targetted skill,
//so treat it as such.
map_foreachinrange(skill_area_sub, bl,
skill_get_splash(skillid, skilllv),BL_CHAR,
src,skillid,skilllv,tick, flag|BCT_ENEMY|1,
skill_castend_damage_id);
//Initiate 10% of your damage becomes fire element.
clif_skill_nodamage (src,bl,skillid,skilllv,1);
sc_start4(src,SC_WATK_ELEMENT,100,3,20,0,0,skill_get_time2(skillid, skilllv));
if (sd) skill_blockpc_start (sd, skillid, skill_get_time(skillid, skilllv));
}
break;
case KN_BOWLINGBASH: /* ボウリングバッシュ */
if(flag&1){
/* 個別にダメージを与える */
if(bl->id!=skill_area_temp[1])
skill_attack(BF_WEAPON,src,src,bl,skillid,skilllv,tick,0x0500);
} else {
int i,c; /* 他人から聞いた動きなので間違ってる可能性大＆効率が悪いっす＞＜ */
/* まずターゲットに攻撃を加える */
c = skill_get_blewcount(skillid,skilllv);
if(map_flag_gvg(bl->m) || status_get_mexp(bl))
c = 0;
for(i=0;i<c;i++){
skill_blown(src,bl,0x20000|1);
skill_area_temp[0]=0;
map_foreachinrange(skill_area_sub,bl,
skill_get_splash(skillid, skilllv),BL_CHAR,
src,skillid,skilllv,tick, flag|BCT_ENEMY,
skill_area_sub_count);
if(skill_area_temp[0]>1) break;
}
clif_blown(bl); //Update target pos.
skill_area_temp[1]=bl->id;
/* その後ターゲット以外の範囲内の敵全体に処理を行う */
map_foreachinrange(skill_area_sub,bl,
skill_get_splash(skillid, skilllv),BL_CHAR,
src,skillid,skilllv,tick, flag|BCT_ENEMY|1,
skill_castend_damage_id);
skill_attack(BF_WEAPON,src,src,bl,skillid,skilllv,tick,0);
}
break;
case KN_SPEARSTAB: /* スピアスタブ */
if(flag&1){
/* 個別にダメージを与える */
if (bl->id==skill_area_temp[1])
break;
if (skill_attack(BF_WEAPON,src,src,bl,skillid,skilllv,tick,0x0500) && !status_get_mexp(bl))
skill_blown(src,bl,skill_area_temp[2]);
} else {
int x=bl->x,y=bl->y,i,dir;
/* まずターゲットに攻撃を加える */
dir = map_calc_dir(bl,src->x,src->y);
skill_area_temp[1] = bl->id;
skill_area_temp[2] = skill_get_blewcount(skillid,skilllv)|dir<<20;
if (skill_attack(BF_WEAPON,src,src,bl,skillid,skilllv,tick,0) && !status_get_mexp(bl))
skill_blown(src,bl,skill_area_temp[2]);
for (i=0;i<4;i++) {
map_foreachincell(skill_area_sub,bl->m,x,y,BL_CHAR,
src,skillid,skilllv,tick,flag|BCT_ENEMY|1,
skill_castend_damage_id);
x += dirx[dir];
y += diry[dir];
}
}
break;
case TK_TURNKICK:
case MO_BALKYOUNG: //Active part of the attack. Skill-attack [Skotlex]
{
skill_area_temp[1] = bl->id; //NOTE: This is used in skill_castend_nodamage_id to avoid affecting the target.
if (skill_attack(BF_WEAPON,src,src,bl,skillid,skilllv,tick,0))
map_foreachinrange(skill_area_sub,bl,
skill_get_splash(skillid, skilllv),BL_CHAR,
src,skillid,skilllv,tick,flag|BCT_ENEMY|1,
skill_castend_nodamage_id);
}
break;
case CH_PALMSTRIKE: // Palm Strike takes effect 1sec after casting. [Skotlex]
// clif_skill_nodamage(src,bl,skillid,skilllv,0); //Can't make this one display the correct attack animation delay :/
clif_damage(src,bl,tick,status_get_amotion(src),0,0,1,4,0); //Displays MISS, but better than nothing :X
skill_addtimerskill(src, tick + 1000, bl->id, 0, 0, skillid, skilllv, BF_WEAPON, flag);
break;
case PR_TURNUNDEAD:
case ALL_RESURRECTION:
if (!battle_check_undead(tstatus->race, tstatus->def_ele))
break;
skill_attack(BF_MAGIC,src,src,bl,skillid,skilllv,tick,flag);
break;
/* 魔法系スキル */
case MG_SOULSTRIKE: /* ソウルストライク */
case NPC_DARKSTRIKE: /*闇ソウルストライク*/
case MG_COLDBOLT: /* コールドボルト */
case MG_FIREBOLT: /* ファイアーボルト */
case MG_LIGHTNINGBOLT: /* ライトニングボルト */
case WZ_EARTHSPIKE: /* アーススパイク */
case AL_HEAL: /* ヒール */
case AL_HOLYLIGHT: /* ホーリーライト */
case WZ_JUPITEL: /* ユピテルサンダー */
case NPC_DARKTHUNDER: /*闇ユピテル*/
case NPC_MAGICALATTACK: /* MOB:魔法打撃攻撃 */
case PR_ASPERSIO: /* アスペルシオ */
case MG_FROSTDIVER: /* フロストダイバー */
case WZ_SIGHTBLASTER:
case WZ_SIGHTRASHER: /* サイトラッシャー */
skill_attack(BF_MAGIC,src,src,bl,skillid,skilllv,tick,flag);
break;
case HVAN_CAPRICE: //[blackhole89]
{
int ran=rand()%4;
int sid = 0;
switch(ran)
{
case 0: sid=MG_COLDBOLT; break;
case 1: sid=MG_FIREBOLT; break;
case 2: sid=MG_LIGHTNINGBOLT; break;
case 3: sid=WZ_EARTHSPIKE; break;
}
skill_attack(BF_MAGIC,src,src,bl,sid,skilllv,tick,flag);
}
break;
case WZ_WATERBALL: /* ウォーターボール */
skill_attack(BF_MAGIC,src,src,bl,skillid,skilllv,tick,flag);
if (skilllv>1) {
int range = skilllv/2;
int cnt;
if (sd)
cnt = skill_count_water(src,range);
else {
range = 2*range+1;
cnt = range*range;
}
cnt--;
if (cnt > 0)
skill_addtimerskill(src,tick+125,bl->id,0,0,
skillid,skilllv,cnt,flag);
} else if (sd) //Eat up deluge tiles.
skill_count_water(src,0);
break;
case PR_BENEDICTIO: /* 聖体降福 */
//Should attack undead and demons. [Skotlex]
if (battle_check_undead(tstatus->race, tstatus->def_ele) || tstatus->race == RC_DEMON)
skill_attack(BF_MAGIC, src, src, bl, skillid, skilllv, tick, flag);
break;
/* 魔法系範囲攻撃スキル */
case MG_NAPALMBEAT: /* ナパームビート */
case MG_FIREBALL: /* ファイヤーボール */
if (flag & 1) {
/* 個別にダメージを与える */
if (bl->id == skill_area_temp[1])
break;
if(skillid == MG_FIREBALL) //Store distance.
skill_area_temp[0] = distance_blxy(bl, skill_area_temp[2], skill_area_temp[3]);
skill_attack(BF_MAGIC,src,src,bl,skillid,skilllv,tick, skill_area_temp[0]| 0x0500);
} else {
skill_area_temp[0]=0;
skill_area_temp[1]=bl->id;
switch (skillid) {
case MG_NAPALMBEAT:
/* ナパームビート・ナパームバルカンは分散ダメージなので敵の数を数える */
map_foreachinrange(skill_area_sub, bl,
skill_get_splash(skillid, skilllv),BL_CHAR,
src,skillid,skilllv,tick,flag|BCT_ENEMY,
skill_area_sub_count);
break;
case MG_FIREBALL:
skill_area_temp[2]=bl->x;
skill_area_temp[3]=bl->y;
break;
}
/* ターゲットに攻撃を加える(スキルエフェクト表示) */
skill_attack(BF_MAGIC,src,src,bl,skillid,skilllv,tick, skill_area_temp[0]);
map_foreachinrange(skill_area_sub,bl,
skill_get_splash(skillid, skilllv),BL_CHAR,
src,skillid,skilllv,tick, flag|BCT_ENEMY|1,
skill_castend_damage_id);
}
break;
case HW_NAPALMVULCAN: // Fixed By SteelViruZ
if (flag & 1) {
if (bl->id != skill_area_temp[1])
skill_attack(BF_MAGIC, src, src, bl, skillid, skilllv, tick, skill_area_temp[0]);
} else {
skill_area_temp[0] = 0;
skill_area_temp[1] = bl->id;
map_foreachinrange(skill_area_sub, bl,
skill_get_splash(skillid, skilllv), BL_CHAR,
src, skillid, skilllv, tick, flag|BCT_ENEMY,
skill_area_sub_count);
skill_attack(BF_MAGIC, src, src, bl, skillid, skilllv, tick, skill_area_temp[0]);
map_foreachinrange(skill_area_sub, bl,
skill_get_splash(skillid, skilllv), BL_CHAR,
src, skillid, skilllv, tick, flag|BCT_ENEMY|1,
skill_castend_damage_id);
}
break;
case SL_STIN:
case SL_STUN:
case SL_SMA:
if (sd && !battle_config.allow_es_magic_pc && bl->type != BL_MOB) {
status_change_start(src,SC_STUN,10000,skilllv,0,0,0,500,10);
clif_skill_fail(sd,skillid,0,0);
break;
}
skill_attack(BF_MAGIC,src,src,bl,skillid,skilllv,tick,flag);
break;
/* その他 */
case HT_BLITZBEAT: /* ブリッツビート */
if (flag & 1) { //Invoked from map_foreachinarea, skill_area_temp[0] holds number of targets to divide damage by.
skill_attack(BF_MISC, src, src, bl, skillid, skilllv, tick, skill_area_temp[0]);
} else {
skill_area_temp[0] = 0;
skill_area_temp[1] = bl->id;
if (flag & 0xf00000) //Warning, 0x100000 is currently BCT_NEUTRAL, so don't mix it when asking for the enemy. [Skotlex]
map_foreachinrange(skill_area_sub, bl,
skill_get_splash(skillid, skilllv), BL_CHAR,
src, skillid, skilllv, tick, BCT_ENEMY, skill_area_sub_count);
map_foreachinrange(skill_area_sub, bl,
skill_get_splash(skillid, skilllv), BL_CHAR,
src, skillid, skilllv, tick, BCT_ENEMY|1,
skill_castend_damage_id);
}
break;
case NPC_DARKBREATH:
clif_emotion(src,7);
case SN_FALCONASSAULT:
case PA_PRESSURE:
case CR_ACIDDEMONSTRATION:
case TF_THROWSTONE:
case NPC_SMOKING:
case NPC_SELFDESTRUCTION:
case GS_FLING:
case NJ_ZENYNAGE:
skill_attack(BF_MISC,src,src,bl,skillid,skilllv,tick,flag);
break;
// Celest
case PF_SOULBURN:
if (rand()%100 < (skilllv < 5 ? 30 + skilllv * 10 : 70)) {
clif_skill_nodamage(src,bl,skillid,skilllv,1);
if (skilllv == 5)
skill_attack(BF_MAGIC,src,src,bl,skillid,skilllv,tick,0 );
status_percent_damage(src, bl, 0, 100);
} else {
clif_skill_nodamage(src,src,skillid,skilllv,1);
if (skilllv == 5)
skill_attack(BF_MAGIC,src,src,src,skillid,skilllv,tick,0 );
status_percent_damage(src, src, 0, 100);
}
if (sd) skill_blockpc_start (sd, skillid, (skilllv < 5 ? 10000: 15000));
break;
/* HP吸収/HP吸収魔法 */
case NPC_BLOODDRAIN:
case NPC_ENERGYDRAIN:
{
int heal = skill_attack( (skillid == NPC_BLOODDRAIN) ? BF_WEAPON : BF_MAGIC,
src, src, bl, skillid, skilllv, tick, flag);
if (heal > 0){
clif_skill_nodamage(NULL, src, AL_HEAL, heal, 1);
status_heal(src, heal, 0, 0);
}
}
break;
//Until they're at right position - gs_damage- [Vicious]
case GS_TRIPLEACTION:
case GS_MAGICALBULLET:
case GS_CRACKER:
case GS_TRACKING:
case GS_PIERCINGSHOT:
case GS_RAPIDSHOWER:
case GS_DUST:
case GS_FULLBUSTER:
case NJ_SYURIKEN:
case NJ_KUNAI:
case NJ_HUUMA:
skill_attack(BF_WEAPON,src,src,bl,skillid,skilllv,tick,flag);
break;
case GS_BULLSEYE:
if(tstatus->race == RC_BRUTE || tstatus->race == RC_DEMIHUMAN)
skill_attack(BF_WEAPON,src,src,bl,skillid,skilllv,tick,flag);
else if (sd)
clif_skill_fail(sd,skillid,0,0);
break;
case GS_DESPERADO:
case GS_SPREADATTACK:
if(flag&1)
skill_attack(BF_WEAPON,src,src,bl,skillid,skilllv,tick,flag);
else {
//If we get here, someone changed it to be a enemy targetted skill,
//so treat it as such.
map_foreachinrange(skill_area_sub, bl,
skill_get_splash(skillid, skilllv),BL_CHAR,
src,skillid,skilllv,tick, flag|BCT_ENEMY|1,
skill_castend_damage_id);
}
break;
case NJ_KASUMIKIRI:
skill_attack(BF_WEAPON,src,src,bl,skillid,skilllv,tick,flag);
sc_start(src,SC_HIDING,100,skilllv,skill_get_time(skillid,skilllv));
break;
case NJ_KIRIKAGE:
status_change_end(src, SC_HIDING, -1);
skill_attack(BF_WEAPON,src,src,bl,skillid,skilllv,tick,flag);
break;
case NJ_KOUENKA:
case NJ_HYOUSENSOU:
case NJ_HYOUSYOURAKU:
case NJ_HUUJIN:
skill_attack(BF_MAGIC,src,src,bl,skillid,skilllv,tick,flag);
break;
case NJ_KAMAITACHI:
// Does it stop if touch an obstacle? it shouldn't shoot trough walls
map_foreachinpath (skill_attack_area,src->m,src->x,src->y,bl->x,bl->y,
skill_get_splash(skillid, skilllv),BL_CHAR,
BF_WEAPON,src,src,skillid,skilllv,tick,flag,BCT_ENEMY); // varargs
break;
//Not implemented yet [Vicious]
//case NJ_SYURIKEN:
//case NJ_KUNAI:
//case NJ_HUUMA:
//case NJ_KASUMIKIRI:
//case NJ_KIRIKAGE:
//case NJ_KOUENKA:
case NJ_KAENSIN:
//case NJ_HYOUSENSOU:
//case NJ_HYOUSYOURAKU:
//case NJ_HUUJIN:
//case NJ_KAMAITACHI:
case NJ_ISSEN:
skill_attack(BF_MAGIC,src,src,bl,skillid,skilllv,tick,flag);
break;
case 0:
if(sd) {
if (flag & 3){
if (bl->id != skill_area_temp[1])
skill_attack(BF_WEAPON, src, src, bl, skillid, skilllv, tick, 0x0500);
} else {
skill_area_temp[1] = bl->id;
map_foreachinrange(skill_area_sub, bl,
sd->splash_range, BL_CHAR,
src, skillid, skilllv, tick, flag | BCT_ENEMY | 1,
skill_castend_damage_id);
}
}
break;
default:
ShowWarning("skill_castend_damage_id: Unknown skill used:%d\n",skillid);
map_freeblock_unlock();
return 1;
}
map_freeblock_unlock();
if (sd && !(flag&1) && sd->state.arrow_atk) //Consume arrow on last invocation to this skill.
battle_consume_ammo(sd, skillid, skilllv);
return 0;
}
/*==========================================
* スキル使用（詠唱完了、ID指定支援系）
*------------------------------------------
*/
int skill_castend_nodamage_id (struct block_list *src, struct block_list *bl, int skillid, int skilllv, unsigned int tick, int flag)
{
struct map_session_data *sd = NULL;
struct map_session_data *dstsd = NULL;
struct status_data *sstatus, *tstatus;
struct status_change *tsc;
struct mob_data *md = NULL;
struct mob_data *dstmd = NULL;
int i,type=-1;
if(skillid > 0 && skilllv <= 0) return 0; // celest
nullpo_retr(1, src);
nullpo_retr(1, bl);
if (src->m != bl->m)
return 1;
if (src->type == BL_PC) {
sd = (struct map_session_data *)src;
} else if (src->type == BL_MOB) {
md = (struct mob_data *)src;
}
if (bl->type == BL_PC){
dstsd = (struct map_session_data *)bl;
} else if (bl->type == BL_MOB){
dstmd = (struct mob_data *)bl;
}
if(bl->prev == NULL)
return 1;
if(status_isdead(src) && skillid != NPC_REBIRTH)
return 1;
if(status_isdead(bl) && skillid != NPC_REBIRTH && skillid != ALL_RESURRECTION && skillid != PR_REDEMPTIO)
return 1;
tstatus = status_get_status_data(bl);
sstatus = status_get_status_data(src);
//Check for undead skills that convert a no-damage skill into a damage one. [Skotlex]
switch (skillid) {
case AL_HEAL:
case ALL_RESURRECTION:
case PR_ASPERSIO:
if (battle_check_undead(tstatus->race,tstatus->def_ele)) {
if (battle_check_target(src, bl, BCT_ENEMY) < 1) {
//Offensive heal does not works on non-enemies. [Skotlex]
if (sd) clif_skill_fail(sd,skillid,0,0);
return 0;
}
if(!sd) {
//Prevent non-players from casting offensive heal. [Skotlex]
clif_emotion(src, 4);
return 0;
}
return skill_castend_damage_id (src, bl, skillid, skilllv, tick, flag);
}
break;
case NPC_SMOKING: //Since it is a self skill, this one ends here rather than in damage_id. [Skotlex]
return skill_castend_damage_id (src, bl, skillid, skilllv, tick, flag);
//These are actually ground placed.
case NJ_BAKUENRYU: //Doesn't works on the default because it is enemy-targetted.
return skill_castend_pos2(src,bl->x,bl->y,skillid,skilllv,tick,0);
default:
if (src == bl && skill_get_unit_id(skillid,0)) //Skill is actually ground placed.
return skill_castend_pos2(src,bl->x,bl->y,skillid,skilllv,tick,0);
}
if (skillid > 0)
type = SkillStatusChangeTable(skillid);
tsc = status_get_sc(bl);
map_freeblock_lock();
switch(skillid)
{
case AL_HEAL: /* ヒール */
{
int heal = skill_calc_heal(src, skilllv);
int heal_get_jobexp;
if (status_isimmune(bl) || (dstmd && dstmd->class_ == MOBID_EMPERIUM))
heal=0; /* 黄金蟲カード（ヒール量０） */
if (sd) {
if (sd && dstsd && sd->status.partner_id == dstsd->status.char_id &&
(sd->class_&MAPID_UPPERMASK) == MAPID_SUPER_NOVICE && sd->status.sex == 0) //自分も対象もPC、対象が自分のパートナー、自分がスパノビ、自分が♀なら
heal = heal*2; //スパノビの嫁が旦那にヒールすると2倍になる
}
if (tsc && tsc->count && tsc->data[SC_KAITE].timer != -1
&& !(sstatus->mode&MD_BOSS)
) { //Bounce back heal
if (--tsc->data[SC_KAITE].val2 <= 0)
status_change_end(bl, SC_KAITE, -1);
if (src == bl) heal=0; //When you try to heal yourself and you are under Kaite, the heal is voided.
clif_skill_nodamage (src, src, skillid, heal, 1);
heal_get_jobexp = status_heal(src,heal,0,0);
} else {
clif_skill_nodamage (src, bl, skillid, heal, 1);
heal_get_jobexp = status_heal(bl,heal,0,0);
}
// JOB経験値獲得
if(sd && dstsd && heal > 0 && sd != dstsd && battle_config.heal_exp > 0){
heal_get_jobexp = heal_get_jobexp * battle_config.heal_exp / 100;
if (heal_get_jobexp <= 0)
heal_get_jobexp = 1;
pc_gainexp (sd, bl, 0, heal_get_jobexp);
}
}
break;
case PR_REDEMPTIO:
if (sd && !(flag&1)) {
if (sd->status.party_id == 0) {
clif_skill_fail(sd,skillid,0,0);
break;
}
skill_area_temp[0] = 0;
party_foreachsamemap(skill_area_sub,
sd,skill_get_splash(skillid, skilllv),
src,skillid,skilllv,tick, flag|BCT_PARTY|1,
skill_castend_nodamage_id);
if (skill_area_temp[0] == 0) {
clif_skill_fail(sd,skillid,0,0);
break;
}
skill_area_temp[0] = 5 - skill_area_temp[0]; // The actual penalty...
if (skill_area_temp[0] > 0 && !map[src->m].flag.nopenalty) { //Apply penalty
sd->status.base_exp -= pc_nextbaseexp(sd) * skill_area_temp[0] * 2/1000; //0.2% penalty per each.
sd->status.job_exp -= pc_nextjobexp(sd) * skill_area_temp[0] * 2/1000;
clif_updatestatus(sd,SP_BASEEXP);
clif_updatestatus(sd,SP_JOBEXP);
}
status_zap(src, sstatus->hp-1, sstatus->sp-1);
break;
} else if (status_isdead(bl) && flag&1) { //Revive
skill_area_temp[0]++; //Count it in, then fall-through to the Resurrection code.
skilllv = 3; //Resurrection level 3 is used
} else //Invalid target, skip resurrection.
break;
case ALL_RESURRECTION: /* リザレクション */
if(sd && map_flag_gvg(bl->m))
{ //No reviving in WoE grounds!
clif_skill_fail(sd,skillid,0,0);
break;
}
if (!status_isdead(bl))
break;
{
int per = 0, sper = 0;
if (map[bl->m].flag.pvp && dstsd && dstsd->pvp_point < 0)
break;
switch(skilllv){
case 1: per=10; break;
case 2: per=30; break;
case 3: per=50; break;
case 4: per=80; break;
}
if(dstsd && dstsd->special_state.restart_full_recover)
per = sper = 100;
if (status_revive(bl, per, sper))
{
clif_skill_nodamage(src,bl,ALL_RESURRECTION,skilllv,1); //Both Redemption and Res show this skill-animation.
if(sd && dstsd && battle_config.resurrection_exp > 0)
{
int exp = 0,jexp = 0;
int lv = dstsd->status.base_level - sd->status.base_level, jlv = dstsd->status.job_level - sd->status.job_level;
if(lv > 0) {
exp = (int)((double)dstsd->status.base_exp * (double)lv * (double)battle_config.resurrection_exp / 1000000.);
if (exp < 1) exp = 1;
}
if(jlv > 0) {
jexp = (int)((double)dstsd->status.job_exp * (double)lv * (double)battle_config.resurrection_exp / 1000000.);
if (jexp < 1) jexp = 1;
}
if(exp > 0 || jexp > 0)
pc_gainexp (sd, bl, exp, jexp);
}
}
}
break;
case AL_DECAGI: /* 速度減少 */
clif_skill_nodamage (src, bl, skillid, skilllv,
sc_start(bl, type,
(40 + skilllv * 2 + (status_get_lv(src) + sstatus->int_)/5),
skilllv, skill_get_time(skillid,skilllv)));
break;
case AL_CRUCIS:
if (flag & 1) {
if (battle_check_target (src, bl, BCT_ENEMY))
sc_start(bl,type,
23+skilllv*4 +status_get_lv(src) -status_get_lv(bl),
skilllv,60000);
} else {
map_foreachinrange(skill_area_sub, src,
skill_get_splash(skillid, skilllv), BL_CHAR,
src, skillid, skilllv, tick, flag|BCT_ENEMY|1,
skill_castend_nodamage_id);
clif_skill_nodamage(src, bl, skillid, skilllv, 1);
}
break;
case PR_LEXDIVINA: /* レックスディビーナ */
if (tsc && tsc->count && tsc->data[type].timer != -1) {
status_change_end(bl,type, -1);
clif_skill_nodamage (src, bl, skillid, skilllv, 1);
} else
clif_skill_nodamage (src, bl, skillid, skilllv,
sc_start(bl,type,100,skilllv,skill_get_time(skillid,skilllv)));
break;
case SA_ABRACADABRA:
{
int abra_skillid = 0, abra_skilllv;
if (sd)
{ //Crash-fix [Skotlex]
//require 1 yellow gemstone even with mistress card or Into the Abyss
if ((i = pc_search_inventory(sd, 715)) < 0 )
{ //bug fixed by Lupus (item pos can be 0, too!)
clif_skill_fail(sd,skillid,0,0);
break;
}
pc_delitem(sd, i, 1, 0);
}
do {
abra_skillid = rand() % MAX_SKILL_ABRA_DB;
if (
//Unneeded check, use the "per" field to know if the skill is valid.
// skill_get_inf2(abra_skillid)&(INF2_NPC_SKILL|INF2_SONG_DANCE|INF2_ENSEMBLE_SKILL) || //NPC/Song/Dance skills are out
!skill_get_inf(abra_skillid) || //Passive skills cannot be casted
skill_abra_db[abra_skillid].req_lv > skilllv || //Required lv for it to appear
rand()%10000 >= skill_abra_db[abra_skillid].per
)
abra_skillid = 0; // reset to get a new id
} while (abra_skillid == 0);
abra_skilllv = skill_get_max(abra_skillid) > skilllv ? skilllv : skill_get_max(abra_skillid);
clif_skill_nodamage (src, bl, skillid, skilllv, 1);
if (sd)
{ //Crash-protection against Abracadabra casting pets
sd->skillitem = abra_skillid;
sd->skillitemlv = abra_skilllv;
sd->state.abra_flag = 1;
clif_item_skill (sd, abra_skillid, abra_skilllv, "Abracadabra");
} else
{ // [Skotlex]
struct unit_data *ud = unit_bl2ud(src);
int inf = skill_get_inf(abra_skillid);
int target_id = 0;
if (!ud) break;
if (inf&INF_SELF_SKILL || inf&INF_SUPPORT_SKILL) {
if (src->type == BL_PET)
bl = (struct block_list*)((TBL_PET*)src)->msd;
if (!bl) bl = src;
unit_skilluse_id(src, bl->id, abra_skillid, abra_skilllv);
} else { //Assume offensive skills
if (ud->target)
target_id = ud->target;
else switch (src->type) {
case BL_MOB:
target_id = ((TBL_MOB*)src)->target_id;
break;
case BL_PET:
target_id = ((TBL_PET*)src)->target_id;
break;
}
if (!target_id)
break;
if (skill_get_casttype(abra_skillid) == CAST_GROUND) {
bl = map_id2bl(target_id);
if (!bl) bl = src;
unit_skilluse_pos(src, bl->x, bl->y, abra_skillid, abra_skilllv);
} else
unit_skilluse_id(src, target_id, abra_skillid, abra_skilllv);
}
}
}
break;
case SA_COMA:
clif_skill_nodamage(src,bl,skillid,skilllv,
sc_start(bl,type,100,skilllv,skill_get_time2(skillid,skilllv)));
break;
case SA_FULLRECOVERY:
clif_skill_nodamage(src,bl,skillid,skilllv,1);
if (status_isimmune(bl))
break;
status_percent_heal(bl, 100, 100);
break;
case SA_SUMMONMONSTER:
clif_skill_nodamage(src,bl,skillid,skilllv,1);
if (sd) mob_once_spawn(sd,map[src->m].name,src->x,src->y,"--ja--",-1,1,"");
break;
case SA_LEVELUP:
clif_skill_nodamage(src,bl,skillid,skilllv,1);
if (sd && pc_nextbaseexp(sd)) pc_gainexp(sd, NULL, pc_nextbaseexp(sd) * 10 / 100, 0);
break;
case SA_INSTANTDEATH:
clif_skill_nodamage(src,bl,skillid,skilllv,1);
status_zap(bl,tstatus->hp-1,0);
break;
case SA_QUESTION:
case SA_GRAVITY:
clif_skill_nodamage(src,bl,skillid,skilllv,1);
break;
case SA_CLASSCHANGE:
{
//クラスチェンジ用ボスモンスターID
static int changeclass[]={1038,1039,1046,1059,1086,1087,1112,1115
,1157,1159,1190,1272,1312,1373,1492};
int class_ = mob_random_class (changeclass,sizeof(changeclass)/sizeof(changeclass[0]));
clif_skill_nodamage(src,bl,skillid,skilllv,1);
if(dstmd) mob_class_change(dstmd,class_);
}
break;
case SA_MONOCELL:
{
static int poringclass[]={1002};
int class_ = mob_random_class (poringclass,sizeof(poringclass)/sizeof(poringclass[0]));
clif_skill_nodamage(src,bl,skillid,skilllv,1);
if(dstmd) mob_class_change(dstmd,class_);
}
break;
case SA_DEATH:
clif_skill_nodamage(src,bl,skillid,skilllv,1);
status_kill(bl);
break;
case SA_REVERSEORCISH:
clif_skill_nodamage(src,bl,skillid,skilllv,
sc_start(bl,type,100,skilllv,skill_get_time(skillid, skilllv)));
break;
case SA_FORTUNE:
clif_skill_nodamage(src,bl,skillid,skilllv,1);
if(sd) pc_getzeny(sd,status_get_lv(bl)*100);
break;
case SA_TAMINGMONSTER:
clif_skill_nodamage(src,bl,skillid,skilllv,1);
if (sd && dstmd) {
for (i = 0; i < MAX_PET_DB; i++) {
if (dstmd->class_ == pet_db[i].class_) {
pet_catch_process1 (sd, dstmd->class_);
break;
}
}
}
break;
case AL_INCAGI: /* 速度増加 */
case AL_BLESSING: /* ブレッシング */
case PR_SLOWPOISON:
case PR_IMPOSITIO: /* イムポシティオマヌス */
case PR_LEXAETERNA: /* レックスエーテルナ */
case PR_SUFFRAGIUM: /* サフラギウム */
case PR_BENEDICTIO: /* 聖体降福 */
clif_skill_nodamage(src,bl,skillid,skilllv,
sc_start(bl,type,100,skilllv,skill_get_time(skillid,skilllv)));
break;
case CR_PROVIDENCE: /* プロヴィデンス */
if(sd && dstsd){ //Check they are not another crusader [Skotlex]
if ((dstsd->class_&MAPID_UPPERMASK) == MAPID_CRUSADER) {
clif_skill_fail(sd,skillid,0,0);
map_freeblock_unlock();
return 1;
}
}
clif_skill_nodamage(src,bl,skillid,skilllv,
sc_start(bl,type,100,skilllv,skill_get_time(skillid,skilllv)));
break;
case CG_MARIONETTE: /* マリオネットコントロール */
{
struct status_change *sc= status_get_sc(src);
int type2 = SC_MARIONETTE2;
if(sc && tsc){
if (sc->data[type].timer == -1 && tsc->data[type2].timer == -1) {
sc_start(src,type,100,bl->id,skill_get_time(skillid,skilllv));
sc_start(bl,type2,100,src->id,skill_get_time(skillid,skilllv));
clif_marionette(src, bl);
clif_skill_nodamage(src,bl,skillid,skilllv,1);
}
else if (sc->data[type].timer != -1 && tsc->data[type2].timer != -1 &&
sc->data[type].val1 == bl->id && tsc->data[type2].val1 == src->id) {
status_change_end(src, type, -1);
status_change_end(bl, type2, -1);
}
else {
if (sd) clif_skill_fail(sd,skillid,0,0);
map_freeblock_unlock();
return 1;
}
}
}
break;
case RG_CLOSECONFINE:
clif_skill_nodamage(src,bl,skillid,skilllv,
sc_start4(bl,type,100,skilllv,src->id,0,0,skill_get_time(skillid,skilllv)));
break;
case SA_FLAMELAUNCHER: // added failure chance and chance to break weapon if turned on [Valaris]
case SA_FROSTWEAPON:
case SA_LIGHTNINGLOADER:
case SA_SEISMICWEAPON:
if (dstsd) {
if(dstsd->status.weapon == W_FIST ||
(dstsd->sc.count && dstsd->sc.data[type].timer == -1 &&
( //Allow re-enchanting to lenghten time. [Skotlex]
dstsd->sc.data[SC_FIREWEAPON].timer != -1 ||
dstsd->sc.data[SC_WATERWEAPON].timer != -1 ||
dstsd->sc.data[SC_WINDWEAPON].timer != -1 ||
dstsd->sc.data[SC_EARTHWEAPON].timer != -1 ||
dstsd->sc.data[SC_SHADOWWEAPON].timer != -1 ||
dstsd->sc.data[SC_GHOSTWEAPON].timer != -1 ||
dstsd->sc.data[SC_ENCPOISON].timer != -1
))
) {
if (sd) clif_skill_fail(sd,skillid,0,0);
clif_skill_nodamage(src,bl,skillid,skilllv,0);
break;
}
}
if (sd) {
int i = pc_search_inventory (sd, skill_db[skillid].itemid[0]);
if(i < 0 || sd->status.inventory[i].amount < skill_db[skillid].amount[0]) {
clif_skill_fail(sd,skillid,0,0);
break;
}
pc_delitem(sd, i, skill_db[skillid].amount[0], 0);
}
// 100% success rate at lv4 & 5, but lasts longer at lv5
if(!clif_skill_nodamage(src,bl,skillid,skilllv,
sc_start(bl,type,(60+skilllv*10),skilllv,
skill_get_time(skillid,skilllv)))
) {
if (sd) clif_skill_fail(sd,skillid,0,0);
if (skill_break_equip(bl, EQP_WEAPON, 10000, BCT_PARTY) &&
sd && sd != dstsd)
clif_displaymessage(sd->fd,"You broke target's weapon");
}
break;
case PR_ASPERSIO: /* アスペルシオ */
if (sd && dstmd) {
clif_skill_nodamage(src,bl,skillid,skilllv,0);
break;
}
clif_skill_nodamage(src,bl,skillid,skilllv,
sc_start(bl,type,100,skilllv,skill_get_time(skillid,skilllv)));
break;
case TK_SEVENWIND:
switch(skilllv){
case 1:
type=SC_EARTHWEAPON;
break;
case 2:
type=SC_WINDWEAPON;
break;
case 3:
type=SC_WATERWEAPON;
break;
case 4:
type=SC_FIREWEAPON;
break;
case 5:
type=SC_GHOSTWEAPON;
break;
case 6:
type=SC_SHADOWWEAPON;
break;
case 7:
type=SC_ASPERSIO;
break;
}
clif_skill_nodamage(src,bl,skillid,skilllv,
sc_start(bl,type,100,skilllv,skill_get_time(skillid,skilllv)));
break;
case PR_KYRIE: /* キリエエレイソン */
clif_skill_nodamage(bl,bl,skillid,skilllv,
sc_start(bl,type,100,skilllv,skill_get_time(skillid,skilllv)));
break;
//Passive Magnum, should had been casted on yourself.
case SM_MAGNUM:
map_foreachinrange(skill_area_sub, src,
skill_get_splash(skillid, skilllv),BL_CHAR,
src,skillid,skilllv,tick, flag|BCT_ENEMY|1,
skill_castend_damage_id);
//Initiate 10% of your damage becomes fire element.
clif_skill_nodamage (src,src,skillid,skilllv,1);
sc_start4(src,SC_WATK_ELEMENT,100,3,20,0,0,skill_get_time2(skillid, skilllv));
if (sd) skill_blockpc_start (sd, skillid, skill_get_time(skillid, skilllv));
break;
case LK_BERSERK: /* バーサーク */
case KN_AUTOCOUNTER: /* オートカウンター */
case KN_TWOHANDQUICKEN: /* ツーハンドクイッケン */
case KN_ONEHAND:
case CR_SPEARQUICKEN: /* スピアクイッケン */
case CR_REFLECTSHIELD:
case AS_POISONREACT: /* ポイズンリアクト */
case MC_LOUD: /* ラウドボイス */
case MG_ENERGYCOAT: /* エナジーコート */
case MG_SIGHT: /* サイト */
case AL_RUWACH: /* ルアフ */
case MO_EXPLOSIONSPIRITS: // 爆裂波動
case MO_STEELBODY: // 金剛
case MO_BLADESTOP: // 白刃取り
case LK_AURABLADE: /* オーラブレード */
case LK_PARRYING: /* パリイング */
case LK_CONCENTRATION: /* コンセントレーション */
case WS_CARTBOOST: /* カートブースト */
case SN_SIGHT: /* トゥルーサイト */
case WS_MELTDOWN: /* メルトダウン */
case WS_OVERTHRUSTMAX: // Overthrust Max [Celest]
case ST_REJECTSWORD: /* リジェクトソード */
case HW_MAGICPOWER: /* 魔法力増幅 */
case PF_MEMORIZE: /* メモライズ */
case PA_SACRIFICE:
case ASC_EDP: // [Celest]
case NPC_STOP:
case WZ_SIGHTBLASTER:
case SG_SUN_COMFORT:
case SG_MOON_COMFORT:
case SG_STAR_COMFORT:
case NPC_HALLUCINATION:
case HP_ASSUMPTIO:
case GS_MADNESSCANCEL:
case GS_ADJUSTMENT:
case GS_INCREASING:
case GS_CRACKER:
case NJ_KASUMIKIRI:
case NJ_UTSUSEMI:
case NJ_BUNSINJYUTSU:
case NJ_NEN:
clif_skill_nodamage(src,bl,skillid,skilllv,
sc_start(bl,type,100,skilllv,skill_get_time(skillid,skilllv)));
break;
case CG_MOONLIT: /* 月明りの泉に落ちる花びら */
clif_skill_nodamage(src,bl,skillid,skilllv,1);
if (sd && battle_config.player_skill_partner_check &&
(!battle_config.gm_skilluncond || pc_isGM(sd) < battle_config.gm_skilluncond)) {
skill_check_pc_partner(sd, skillid, &skilllv, 1, 1);
} else
skill_moonlit(bl, NULL, skilllv); //The knockback must be invoked before starting the effect which places down the map cells. [Skotlex]
break;
/* Was modified to only affect targetted char. [Skotlex]
case HP_ASSUMPTIO:
if (flag&1)
sc_start(bl,type,100,skilllv,skill_get_time(skillid,skilllv));
else
{
map_foreachinrange(skill_area_sub, bl,
skill_get_splash(skillid, skilllv), BL_PC,
src, skillid, skilllv, tick, flag|BCT_ALL|1,
skill_castend_nodamage_id);
clif_skill_nodamage(src,bl,skillid,skilllv,1);
}
break;
*/
case SM_ENDURE: /* インデュア */
clif_skill_nodamage(src,bl,skillid,skilllv,
sc_start(bl,type,100,skilllv,skill_get_time(skillid,skilllv)));
if (sd)
skill_blockpc_start (sd, skillid, skill_get_time2(skillid,skilllv));
break;
case AS_ENCHANTPOISON: // Prevent spamming [Valaris]
if (sd && dstsd && dstsd->sc.count) {
if(dstsd->sc.data[SC_FIREWEAPON].timer != -1 ||
dstsd->sc.data[SC_WATERWEAPON].timer != -1 ||
dstsd->sc.data[SC_WINDWEAPON].timer != -1 ||
dstsd->sc.data[SC_EARTHWEAPON].timer != -1 ||
dstsd->sc.data[SC_SHADOWWEAPON].timer != -1 ||
dstsd->sc.data[SC_GHOSTWEAPON].timer != -1
// dstsd->sc.data[SC_ENCPOISON].timer != -1 //People say you should be able to recast to lengthen the timer. [Skotlex]
) {
clif_skill_nodamage(src,bl,skillid,skilllv,0);
clif_skill_fail(sd,skillid,0,0);
break;
}
}
clif_skill_nodamage(src,bl,skillid,skilllv,
sc_start(bl,type,100,skilllv,skill_get_time(skillid,skilllv)));
break;
case LK_TENSIONRELAX: /* テンションリラックス */
clif_skill_nodamage(src,bl,skillid,skilllv,
sc_start4(bl,type,100,skilllv,0,0,skill_get_time2(skillid,skilllv),
skill_get_time(skillid,skilllv)));
break;
case MC_CHANGECART:
clif_skill_nodamage(src,bl,skillid,skilllv,1);
break;
case TK_MISSION:
if (sd) {
int id;
if (sd->mission_mobid && (sd->mission_count || rand()%100)) { //Cannot change target when already have one
clif_mission_mob(sd, sd->mission_mobid, sd->mission_count);
clif_skill_fail(sd,skillid,0,0);
break;
}
id = mob_get_random_id(0,0, sd->status.base_level);
if (!id) {
clif_skill_fail(sd,skillid,0,0);
break;
}
sd->mission_mobid = id;
sd->mission_count = 0;
pc_setglobalreg(sd,"TK_MISSION_ID", id);
clif_mission_mob(sd, id, 0);
clif_skill_nodamage(src,bl,skillid,skilllv,1);
}
break;
case AC_CONCENTRATION: /* 集中力向上 */
{
clif_skill_nodamage(src,bl,skillid,skilllv,
sc_start(bl,type,100,skilllv,skill_get_time(skillid,skilllv)));
map_foreachinrange( status_change_timer_sub, src,
skill_get_splash(skillid, skilllv), BL_CHAR,
src,status_get_sc(src),type,tick);
}
break;
case SM_PROVOKE: /* プロボック */
/* MVPmobと不死には効かない */
if((tstatus->mode&MD_BOSS) || battle_check_undead(tstatus->race,tstatus->def_ele)) { //不死には?かない
map_freeblock_unlock();
return 1;
}
//TODO: How much does base level affects? Dummy value of 1% per level difference used. [Skotlex]
clif_skill_nodamage(src,bl,skillid,skilllv,
(i=sc_start(bl,type,
50 +3*skilllv +status_get_lv(src) -status_get_lv(bl),
skilllv,skill_get_time(skillid,skilllv))));
if (!i)
{
if (sd)
clif_skill_fail(sd,skillid,0,0);
map_freeblock_unlock();
return 0;
}
unit_skillcastcancel(bl, 2);
if(tsc && tsc->count){
if(tsc->data[SC_FREEZE].timer!=-1)
status_change_end(bl,SC_FREEZE,-1);
if(tsc->data[SC_STONE].timer!=-1 && tsc->data[SC_STONE].val2==0)
status_change_end(bl,SC_STONE,-1);
if(tsc->data[SC_SLEEP].timer!=-1)
status_change_end(bl,SC_SLEEP,-1);
}
if(dstmd) {
dstmd->state.provoke_flag = src->id;
mob_target(dstmd,src,skill_get_range2(src,skillid,skilllv));
}
break;
case CR_DEVOTION: /* ディボーション */
if(sd && dstsd)
{
//転生や養子の場合の元の職業を算出する
int lv = sd->status.base_level - dstsd->status.base_level;
if (lv < 0) lv = -lv;
if (lv > battle_config.devotion_level_difference ||
(dstsd->sc.data[type].timer != -1 && dstsd->sc.data[type].val1 != src->id) || //Avoid overriding [Skotlex]
(dstsd->class_&MAPID_UPPERMASK) == MAPID_CRUSADER) {
clif_skill_fail(sd,skillid,0,0);
map_freeblock_unlock();
return 1;
}
//Look for an empty slot (or reuse in case you cast it twice in the same char. [Skotlex]
for (i = 0; i < skilllv && i < 5 && sd->devotion[i]!=bl->id && sd->devotion[i]; i++);
if (i == skilllv)
{
clif_skill_fail(sd,skillid,0,0);
map_freeblock_unlock();
return 1;
}
sd->devotion[i] = bl->id;
clif_skill_nodamage(src,bl,skillid,skilllv,
sc_start4(bl,type,100,src->id,i,skill_get_range2(src,skillid,skilllv),skill_get_time2(skillid, skilllv),1000));
clif_devotion(sd);
}
else
if (sd)
clif_skill_fail(sd,skillid,0,0);
break;
case MO_CALLSPIRITS: // 気功
if(sd) {
clif_skill_nodamage(src,bl,skillid,skilllv,1);
pc_addspiritball(sd,skill_get_time(skillid,skilllv),skilllv);
}
break;
case CH_SOULCOLLECT: // 狂気功
if(sd) {
clif_skill_nodamage(src,bl,skillid,skilllv,1);
for (i = 0; i < 5; i++)
pc_addspiritball(sd,skill_get_time(skillid,skilllv),5);
}
break;
case MO_KITRANSLATION:
if(dstsd && (dstsd->class_&MAPID_BASEMASK)!=MAPID_GUNSLINGER) {
pc_addspiritball(dstsd,skill_get_time(skillid,skilllv),5);
}
break;
case TK_TURNKICK:
case MO_BALKYOUNG: //Passive part of the attack. Splash knock-back+stun. [Skotlex]
if (skill_area_temp[1] != bl->id) {
skill_blown(src,bl,skill_get_blewcount(skillid,skilllv));
skill_additional_effect(src,bl,skillid,skilllv,BF_MISC,tick); //Use Misc rather than weapon to signal passive pushback
}
break;
case MO_ABSORBSPIRITS: // 気奪
i = 0;
if (dstsd && dstsd->spiritball && (sd == dstsd || map_flag_vs(src->m)) && (dstsd->class_&MAPID_BASEMASK)!=MAPID_GUNSLINGER)
{ // split the if for readability, and included gunslingers in the check so that their coins cannot be removed [Reddozen]
i = dstsd->spiritball * 10;
pc_delspiritball(dstsd,dstsd->spiritball,0);
} else if (dstmd && !(tstatus->mode&MD_BOSS) && rand() % 100 < 20)
{ // check if target is a monster and not a Boss, for the 20% chance to absorb 2 SP per monster's level [Reddozen]
i = 2 * dstmd->db->lv;
mob_target(dstmd,src,0);
}
if (i) {
status_heal(src, 0, i, 3);
clif_skill_nodamage(src,bl,skillid,skilllv,0);
}
break;
case AC_MAKINGARROW: /* 矢作成 */
if(sd) {
clif_arrow_create_list(sd);
clif_skill_nodamage(src,bl,skillid,skilllv,1);
}
break;
case AM_PHARMACY: /* ポーション作成 */
if(sd) {
clif_skill_produce_mix_list(sd,22);
clif_skill_nodamage(src,bl,skillid,skilllv,1);
}
break;
case SA_CREATECON:
if(sd) {
clif_skill_produce_mix_list(sd,23);
clif_skill_nodamage(src,bl,skillid,skilllv,1);
}
break;
case BS_HAMMERFALL:
clif_skill_nodamage(src,bl,skillid,skilllv,
sc_start(bl,SC_STUN,(20 + 10 * skilllv),skilllv,skill_get_time2(skillid,skilllv)));
break;
case RG_RAID: /* サプライズアタック */
clif_skill_nodamage(src,bl,skillid,skilllv,1);
map_foreachinrange(skill_area_sub, bl,
skill_get_splash(skillid, skilllv), BL_CHAR,
src,skillid,skilllv,tick, flag|BCT_ENEMY|1,
skill_castend_damage_id);
status_change_end(src, SC_HIDING, -1); // ハイディング解除
break;
case ASC_METEORASSAULT: /* メテオアサルト */
case GS_SPREADATTACK:
clif_skill_nodamage(src,bl,skillid,skilllv,1);
map_foreachinrange(skill_area_sub, src,
skill_get_splash(skillid, skilllv), BL_CHAR,
src,skillid,skilllv,tick, flag|BCT_ENEMY|1,
skill_castend_damage_id);
break;
case KN_BRANDISHSPEAR: /*ブランディッシュスピア*/
{
int c,n=4;
int dir = map_calc_dir(src,bl->x,bl->y);
struct square tc;
int x=bl->x,y=bl->y;
skill_brandishspear_first(&tc,dir,x,y);
skill_brandishspear_dir(&tc,dir,4);
/* 範囲④ */
if(skilllv > 9){
for(c=1;c<4;c++){
map_foreachincell(skill_area_sub,
bl->m,tc.val1[c],tc.val2[c],BL_CHAR,
src,skillid,skilllv,tick, flag|BCT_ENEMY|n,
skill_castend_damage_id);
}
}
/* 範囲③② */
if(skilllv > 6){
skill_brandishspear_dir(&tc,dir,-1);
n--;
}else{
skill_brandishspear_dir(&tc,dir,-2);
n-=2;
}
if(skilllv > 3){
for(c=0;c<5;c++){
map_foreachincell(skill_area_sub,
bl->m,tc.val1[c],tc.val2[c],BL_CHAR,
src,skillid,skilllv,tick, flag|BCT_ENEMY|n,
skill_castend_damage_id);
if(skilllv > 6 && n==3 && c==4){
skill_brandishspear_dir(&tc,dir,-1);
n--;c=-1;
}
}
}
/* 範囲① */
for(c=0;c<10;c++){
if(c==0||c==5) skill_brandishspear_dir(&tc,dir,-1);
map_foreachincell(skill_area_sub,
bl->m,tc.val1[c%5],tc.val2[c%5],BL_CHAR,
src,skillid,skilllv,tick, flag|BCT_ENEMY|1,
skill_castend_damage_id);
}
}
break;
case WZ_SIGHTRASHER:
//Passive side of the attack.
status_change_end(src,SC_SIGHT,-1);
clif_skill_nodamage(src,bl,skillid,skilllv,1);
map_foreachinrange(skill_area_sub,src,
skill_get_splash(skillid, skilllv),BL_CHAR,
src,skillid,skilllv,tick, flag|BCT_ENEMY|1,
skill_castend_damage_id);
break;
case WZ_FROSTNOVA:
map_foreachinrange(skill_attack_area, src,
skill_get_splash(skillid, skilllv), BL_CHAR,
BF_MAGIC, src, src, skillid, skilllv, tick, flag, BCT_ENEMY);
break;
case NPC_SELFDESTRUCTION:
clif_skill_nodamage(src, src, skillid, -1, 1);
map_foreachinrange(skill_area_sub, bl,
skill_get_splash(skillid, skilllv), BL_CHAR,
src, skillid, skilllv, tick, flag|BCT_ENEMY,
skill_castend_damage_id);
status_damage(src, src, sstatus->max_hp,0,0,1);
break;
/* パーティスキル */
case AL_ANGELUS: /* エンジェラス */
case PR_MAGNIFICAT: /* マグニフィカート */
case PR_GLORIA: /* グロリア */
case SN_WINDWALK: /* ウインドウォーク */
if (sd == NULL || sd->status.party_id == 0 || (flag & 1)) {
clif_skill_nodamage(bl,bl,skillid,skilllv,
sc_start(bl,type,100,skilllv,skill_get_time(skillid,skilllv)));
} else if (sd) {
/* パーティ全体への処理 */
party_foreachsamemap (skill_area_sub,
sd,skill_get_splash(skillid, skilllv),
src,skillid,skilllv,tick, flag|BCT_PARTY|1,
skill_castend_nodamage_id);
}
break;
case BS_ADRENALINE: /* アドレナリンラッシュ */
case BS_ADRENALINE2:
case BS_WEAPONPERFECT: /* ウェポンパーフェクション */
case BS_OVERTHRUST: /* オーバートラスト */
if (sd == NULL || sd->status.party_id == 0 || (flag & 1)) {
/* 個別の処理 */
clif_skill_nodamage(bl,bl,skillid,skilllv,
sc_start4(bl,type,100,skilllv,(src == bl)? 1:0,0,0,skill_get_time(skillid,skilllv)));
} else if (sd) {
/* パーティ全体への処理 */
party_foreachsamemap(skill_area_sub,
sd,skill_get_splash(skillid, skilllv),
src,skillid,skilllv,tick, flag|BCT_PARTY|1,
skill_castend_nodamage_id);
}
break;
case BS_MAXIMIZE:
case NV_TRICKDEAD:
case CR_DEFENDER:
case CR_AUTOGUARD:
case TK_READYSTORM:
case TK_READYDOWN:
case TK_READYTURN:
case TK_READYCOUNTER:
case TK_DODGE:
case CR_SHRINK:
case ST_PRESERVE:
case SG_FUSION:
case GS_GATLINGFEVER:
if (tsc && tsc->data[type].timer != -1)
i = status_change_end(bl, type, -1);
else
i = sc_start(bl,type,100,skilllv,skill_get_time(skillid,skilllv));
clif_skill_nodamage(src,bl,skillid,skilllv,i);
break;
case SL_KAITE:
case SL_KAAHI:
case SL_KAIZEL:
case SL_KAUPE:
if (sd) {
if (!dstsd || !(
(sd->sc.data[SC_SPIRIT].timer != -1 && sd->sc.data[SC_SPIRIT].val2 == SL_SOULLINKER) ||
(dstsd->class_&MAPID_UPPERMASK) == MAPID_SOUL_LINKER ||
dstsd->char_id == sd->char_id ||
dstsd->char_id == sd->status.partner_id ||
dstsd->char_id == sd->status.child
)) {
status_change_start(src,SC_STUN,10000,skilllv,0,0,0,500,8);
clif_skill_fail(sd,skillid,0,0);
break;
}
}
clif_skill_nodamage(src,bl,skillid,skilllv,
sc_start(bl,type,100,skilllv,skill_get_time(skillid, skilllv)));
break;
case SM_AUTOBERSERK: // Celest
if (tsc && tsc->data[type].timer != -1)
i = status_change_end(bl, type, -1);
else
i = sc_start(bl,type,100,skilllv,60000);
clif_skill_nodamage(src,bl,skillid,skilllv,i);
break;
case TF_HIDING: /* ハイディング */
case ST_CHASEWALK: /* ハイディング */
if (tsc && tsc->data[type].timer != -1)
i = status_change_end(bl, type, -1);
else
i = sc_start(bl,type,100,skilllv,skill_get_time(skillid,skilllv));
clif_skill_nodamage(src,bl,skillid,-1,i); // Don't display the skill name as it is a hiding skill
break;
case TK_RUN:
if (tsc && tsc->data[type].timer != -1)
i = status_change_end(bl, type, -1);
else
i = sc_start4(bl,type,100,skilllv,unit_getdir(bl),0,0,0);
// If the client receives a skill-use packet inmediately before
// a walkok packet, it will discard the walk packet! [Skotlex]
// clif_skill_nodamage(src,bl,skillid,skilllv,i);
break;
case AS_CLOAKING: /* クローキング */
if(tsc && tsc->data[type].timer!=-1 )
/* 解除する */
i = status_change_end(bl, type, -1);
else
i = sc_start(bl,type,100,skilllv,skill_get_time(skillid,skilllv));
clif_skill_nodamage(src,bl,skillid,-1,i);
if (!i && sd)
clif_skill_fail(sd,skillid,0,0);
break;
case HP_BASILICA: /* バジリカ */
case CG_HERMODE: // Wand of Hermode
{
struct skill_unit_group *sg;
unit_stop_walking(src,1);
skill_clear_unitgroup(src);
sg = skill_unitsetting(src,skillid,skilllv,src->x,src->y,0);
if(skillid == CG_HERMODE)
i = sc_start4(src,SC_DANCING,100,
skillid,0,0,sg->group_id,skill_get_time(skillid,skilllv));
else
i = sc_start4(src,type,100,
skilllv,0,BCT_SELF,sg->group_id,
skill_get_time(skillid,skilllv));
clif_skill_nodamage(src,bl,skillid,skilllv,i);
}
break;
case BD_ADAPTATION: /* アドリブ */
if(tsc && tsc->data[SC_DANCING].timer!=-1){
clif_skill_nodamage(src,bl,skillid,skilllv,1);
skill_stop_dancing(bl);
}
break;
case BA_FROSTJOKE: /* 寒いジョーク */
case DC_SCREAM: /* スクリーム */
clif_skill_nodamage(src,bl,skillid,skilllv,1);
skill_addtimerskill(src,tick+2000,bl->id,src->x,src->y,skillid,skilllv,0,flag);
if (md) { // Mobは喋れないから、スキル名を叫ばせてみる
char temp[128];
if (strlen(md->name) + strlen(skill_db[skillid].desc) > 120)
break; //Message won't fit on buffer. [Skotlex]
sprintf(temp,"%s : %s !!",md->name,skill_db[skillid].desc);
clif_message(&md->bl,temp);
}
break;
case BA_PANGVOICE://パンボイス
clif_skill_nodamage(src,bl,skillid,skilllv,
sc_start(bl,SC_CONFUSION,50,7,skill_get_time(skillid,skilllv)));
break;
case DC_WINKCHARM://魅惑のウィンク
if(dstsd){
clif_skill_nodamage(src,bl,skillid,skilllv,
sc_start(bl,SC_CONFUSION,30,7,skill_get_time2(skillid,skilllv)));
}else if(dstmd)
{
if(status_get_lv(src)>status_get_lv(bl) && (tstatus->race == RC_DEMON || tstatus->race == RC_DEMIHUMAN || tstatus->race == RC_ANGEL)) {
clif_skill_nodamage(src,bl,skillid,skilllv,
sc_start(bl,type,70,skilllv,skill_get_time(skillid,skilllv)));
} else{
clif_skill_nodamage(src,bl,skillid,skilllv,0);
if(sd) clif_skill_fail(sd,skillid,0,0);
}
}
break;
case TF_STEAL: // スティール
if(sd) {
if(pc_steal_item(sd,bl))
clif_skill_nodamage(src,bl,skillid,skilllv,1);
else
clif_skill_fail(sd,skillid,0x0a,0);
}
break;
case RG_STEALCOIN: // スティールコイン
if(sd) {
if(pc_steal_coin(sd,bl))
clif_skill_nodamage(src,bl,skillid,skilllv,1);
else
clif_skill_fail(sd,skillid,0,0);
}
break;
case MG_STONECURSE: /* ストーンカース */
{
if (tstatus->mode&MD_BOSS) {
if (sd) clif_skill_fail(sd,skillid,0,0);
break;
}
if(status_isimmune(bl) || !tsc)
break;
if (dstmd)
mob_target(dstmd,src,skill_get_range2(src,skillid,skilllv));
if (tsc->data[SC_STONE].timer != -1) {
status_change_end(bl,SC_STONE,-1);
if (sd) clif_skill_fail(sd,skillid,0,0);
break;
}
if (sc_start(bl,SC_STONE,(skilllv*4+20),skilllv,skill_get_time2(skillid,skilllv)))
clif_skill_nodamage(src,bl,skillid,skilllv,1);
else if(sd) {
clif_skill_fail(sd,skillid,0,0);
// Level 6-10 doesn't consume a red gem if it fails [celest]
if (skilllv > 5) break;
}
if (sd) {
if (sd->sc.data[SC_SPIRIT].timer != -1 && sd->sc.data[SC_SPIRIT].val2 == SL_WIZARD)
break; //Do not delete the gemstone.
if ((i=pc_search_inventory(sd, skill_db[skillid].itemid[0])) >= 0 )
pc_delitem(sd, i, skill_db[skillid].amount[0], 0);
}
}
break;
case NV_FIRSTAID: /* 応急手当 */
clif_skill_nodamage(src,bl,skillid,5,1);
status_heal(bl,5,0,0);
break;
case AL_CURE: /* キュアー */
if(status_isimmune(bl)) {
clif_skill_nodamage(src,bl,skillid,skilllv,0);
break;
}
status_change_end(bl, SC_SILENCE , -1 );
status_change_end(bl, SC_BLIND , -1 );
status_change_end(bl, SC_CONFUSION, -1 );
if(battle_check_undead(tstatus->race,tstatus->def_ele))
sc_start(bl, SC_CONFUSION,100,1,skill_get_time2(skillid, skilllv));
clif_skill_nodamage(src,bl,skillid,skilllv,1);
break;
case TF_DETOXIFY: /* 解毒 */
clif_skill_nodamage(src,bl,skillid,skilllv,1);
status_change_end(bl, SC_POISON , -1 );
status_change_end(bl, SC_DPOISON , -1 );
break;
case PR_STRECOVERY: /* リカバリー */
if(status_isimmune(bl)) {
clif_skill_nodamage(src,bl,skillid,skilllv,0);
break;
}
status_change_end(bl, SC_FREEZE , -1 );
status_change_end(bl, SC_STONE , -1 );
status_change_end(bl, SC_SLEEP , -1 );
status_change_end(bl, SC_STUN , -1 );
//Is this equation really right? It looks so... special.
if(battle_check_undead(tstatus->race,tstatus->def_ele) )
{
status_change_start(bl, SC_BLIND,
100*(100-(tstatus->int_/2+tstatus->vit/3+tstatus->luk/10)),
1,0,0,0,
skill_get_time2(skillid, skilllv) * (100-(tstatus->int_+tstatus->vit)/2)/100,10);
}
clif_skill_nodamage(src,bl,skillid,skilllv,1);
if(dstmd)
mob_unlocktarget(dstmd,tick);
break;
case WZ_ESTIMATION: /* モンスター情報 */
if(sd) {
clif_skill_nodamage(src,bl,skillid,skilllv,1);
clif_skill_estimation((struct map_session_data *)src,bl);
}
break;
case BS_REPAIRWEAPON: /* 武器修理 */
if(sd && dstsd)
clif_item_repair_list(sd,dstsd);
break;
case MC_IDENTIFY: /* アイテム鑑定 */
if(sd)
clif_item_identify_list(sd);
break;
// Weapon Refining [Celest]
case WS_WEAPONREFINE:
if(sd)
clif_item_refine_list(sd);
break;
case MC_VENDING: /* 露店開設 */
if(sd)
{ //Prevent vending of GMs with unnecessary Level to trade/drop. [Skotlex]
if ( pc_can_give_items(pc_isGM(sd)) )
clif_skill_fail(sd,skillid,0,0);
else
clif_openvendingreq(sd,2+skilllv);
}
break;
case AL_TELEPORT: /* テレポート */
if(sd) {
if (map[bl->m].flag.noteleport) { /* テレポ禁止 */
clif_skill_teleportmessage(sd,0);
break;
}
if(!battle_config.duel_allow_teleport && sd->duel_group) { // duel restriction [LuzZza]
clif_displaymessage(sd->fd, "Duel: Can't use teleport in duel.");
break;
}
clif_skill_nodamage(src,bl,skillid,skilllv,1);
if(skilllv == 1) {
// possibility to skip menu [LuzZza]
if(!battle_config.skip_teleport_lv1_menu &&
sd->skillitem != AL_TELEPORT) //If skillid is not teleport, this was auto-casted! [Skotlex]
clif_skill_warppoint(sd,skillid,skilllv,"Random","","","");
else
pc_randomwarp(sd,3);
} else {
if (sd->skillitem != AL_TELEPORT)
clif_skill_warppoint(sd,skillid,skilllv,"Random",
mapindex_id2name(sd->status.save_point.map),"","");
else //Autocasted Teleport level 2??
pc_setpos(sd,sd->status.save_point.map,
sd->status.save_point.x,sd->status.save_point.y,3);
}
} else
unit_warp(bl,-1,-1,-1,3);
break;
case AL_HOLYWATER: /* アクアベネディクタ */
if(sd) {
if (skill_produce_mix(sd, skillid, 523, 0, 0, 0, 1))
clif_skill_nodamage(src,bl,skillid,skilllv,1);
else
clif_skill_fail(sd,skillid,0,0);
}
break;
case TF_PICKSTONE:
if(sd) {
int eflag;
struct item item_tmp;
struct block_list tbl;
clif_skill_nodamage(src,bl,skillid,skilllv,1);
memset(&item_tmp,0,sizeof(item_tmp));
memset(&tbl,0,sizeof(tbl)); // [MouseJstr]
item_tmp.nameid = 7049;
item_tmp.identify = 1;
tbl.id = 0;
clif_takeitem(&sd->bl,&tbl);
eflag = pc_additem(sd,&item_tmp,1);
if(eflag) {
clif_additem(sd,0,0,eflag);
map_addflooritem(&item_tmp,1,sd->bl.m,sd->bl.x,sd->bl.y,NULL,NULL,NULL,0);
}
}
break;
case ASC_CDP:
if(sd) {
clif_skill_nodamage(src,bl,skillid,skilllv,1);
skill_produce_mix(sd, skillid, 678, 0, 0, 0, 1); //Produce a Deadly Poison Bottle.
}
break;
case RG_STRIPWEAPON: /* ストリップウェポン */
case RG_STRIPSHIELD: /* ストリップシールド */
case RG_STRIPARMOR: /* ストリップアーマー */
case RG_STRIPHELM: /* ストリップヘルム */
case ST_FULLSTRIP: // Rewritten most of the code [DracoRPG]
case GS_DISARM: // Added disarm. [Reddozen]
{
int strip_fix, equip = 0;
int sclist[4] = {0,0,0,0};
if (skillid == RG_STRIPWEAPON || skillid == ST_FULLSTRIP || skillid == GS_DISARM)
equip |= EQP_WEAPON;
if (skillid == RG_STRIPSHIELD || skillid == ST_FULLSTRIP)
equip |= EQP_SHIELD;
if (skillid == RG_STRIPARMOR || skillid == ST_FULLSTRIP)
equip |= EQP_ARMOR;
if (skillid == RG_STRIPHELM || skillid == ST_FULLSTRIP)
equip |= EQP_HELM;
strip_fix = sstatus->dex - tstatus->dex;
if(strip_fix < 0)
strip_fix=0;
if (rand()%100 >= 5+2*skilllv+strip_fix/5)
{
if (sd)
clif_skill_fail(sd,skillid,0,0);
break;
}
if (dstsd) {
for (i=0;i<11;i++) {
if (dstsd->equip_index[i]<0 || !dstsd->inventory_data[dstsd->equip_index[i]])
continue;
switch (i) {
case 8: //Shield / left-hand weapon
if(dstsd->inventory_data[dstsd->equip_index[8]]->type == 5)
{ //Shield
if (equip&EQP_SHIELD &&
!(dstsd->unstripable_equip&EQP_SHIELD) &&
!(tsc && tsc->data[SC_CP_SHIELD].timer != -1)
){
sclist[1] = SC_STRIPSHIELD; // Okay, we found a shield to strip - It is really a shield, not a two-handed weapon or a left-hand weapon
pc_unequipitem(dstsd,dstsd->equip_index[i],3);
}
continue;
}
//Continue to weapon
case 9:
if (equip &EQP_WEAPON &&
!(dstsd->unstripable_equip&EQP_WEAPON) &&
!(tsc && tsc->data[SC_CP_WEAPON].timer != -1)
) {
sclist[0] = SC_STRIPWEAPON; // Okay, we found a weapon to strip - It can be a right-hand, left-hand or two-handed weapon
pc_unequipitem(dstsd,dstsd->equip_index[i],3);
}
break;
case 7: //Armor
if (equip &EQP_ARMOR &&
!(dstsd->unstripable_equip &EQP_ARMOR) &&
!(tsc && tsc->data[SC_CP_ARMOR].timer != -1)
) {
sclist[2] = SC_STRIPARMOR; // Okay, we found an armor to strip
pc_unequipitem(dstsd,dstsd->equip_index[i],3);
}
break;
case 6: //Helm
if (equip &EQP_HELM &&
!(dstsd->unstripable_equip &EQP_HELM) &&
!(tsc && tsc->data[SC_CP_HELM].timer != -1)
) {
sclist[3] = SC_STRIPHELM; // Okay, we found a helm to strip
pc_unequipitem(dstsd,dstsd->equip_index[i],3);
}
break;
}
}
} else if (!(tstatus->mode&MD_BOSS)) {
if (equip&EQP_WEAPON && !(tsc && tsc->data[SC_CP_WEAPON].timer != -1))
sclist[0] = SC_STRIPWEAPON;
if (equip&EQP_SHIELD && !(tsc && tsc->data[SC_CP_SHIELD].timer != -1))
sclist[1] = SC_STRIPSHIELD;
if (equip&EQP_ARMOR && !(tsc && tsc->data[SC_CP_ARMOR].timer != -1))
sclist[2] = SC_STRIPARMOR;
if (equip&EQP_HELM && !(tsc && tsc->data[SC_CP_HELM].timer != -1))
sclist[3] = SC_STRIPHELM;
}
equip = 0; //Reuse equip to hold how many stats are invoked.
for (i=0;i<4;i++) {
if (sclist[i]) // Start the SC only if an equipment was stripped from this location
equip+=sc_start(bl,sclist[i],100,skilllv,skill_get_time(skillid,skilllv)+strip_fix/2);
}
if (equip)
clif_skill_nodamage(src,bl,skillid,skilllv,1);
else if (sd) //Nothing stripped.
clif_skill_fail(sd,skillid,0,0);
break;
}
/* PotionPitcher */
case AM_BERSERKPITCHER:
case AM_POTIONPITCHER: /* ポーションピッチャー */
{
int i,x,hp = 0,sp = 0,bonus=100;
if(sd) {
x = skilllv%11 - 1;
i = pc_search_inventory(sd,skill_db[skillid].itemid[x]);
if(i < 0 || skill_db[skillid].itemid[x] <= 0) {
clif_skill_fail(sd,skillid,0,0);
map_freeblock_unlock();
return 1;
}
if(sd->inventory_data[i] == NULL || sd->status.inventory[i].amount < skill_db[skillid].amount[x]) {
clif_skill_fail(sd,skillid,0,0);
map_freeblock_unlock();
return 1;
}
if(skillid == AM_BERSERKPITCHER) { //Does not override use-level, and cannot be used on bows.
if (dstsd && (dstsd->status.base_level<(unsigned int)sd->inventory_data[i]->elv || dstsd->weapontype1 == W_BOW)) {
clif_skill_fail(sd,skillid,0,0);
map_freeblock_unlock();
return 1;
}
}
potion_flag = 1;
potion_hp = potion_sp = potion_per_hp = potion_per_sp = 0;
potion_target = bl->id;
run_script(sd->inventory_data[i]->script,0,sd->bl.id,0);
pc_delitem(sd,i,skill_db[skillid].amount[x],0);
potion_flag = potion_target = 0;
if (sd->sc.data[SC_SPIRIT].timer != -1 && sd->sc.data[SC_SPIRIT].val2 == SL_ALCHEMIST)
bonus += sd->status.base_level;
if(potion_per_hp > 0 || potion_per_sp > 0) {
hp = tstatus->max_hp * potion_per_hp / 100;
hp = hp * (100 + pc_checkskill(sd,AM_POTIONPITCHER)*10 + pc_checkskill(sd,AM_LEARNINGPOTION)*5)*bonus/10000;
if(dstsd) {
sp = dstsd->status.max_sp * potion_per_sp / 100;
sp = sp * (100 + pc_checkskill(sd,AM_POTIONPITCHER)*10 + pc_checkskill(sd,AM_LEARNINGPOTION)*5)*bonus/10000;
}
}
else {
if(potion_hp > 0) {
hp = potion_hp * (100 + pc_checkskill(sd,AM_POTIONPITCHER)*10 + pc_checkskill(sd,AM_LEARNINGPOTION)*5)*bonus/10000;
hp = hp * (100 + (tstatus->vit<<1)) / 100;
if(dstsd)
hp = hp * (100 + pc_checkskill(dstsd,SM_RECOVERY)*10) / 100;
}
if(potion_sp > 0) {
sp = potion_sp * (100 + pc_checkskill(sd,AM_POTIONPITCHER)*10 + pc_checkskill(sd,AM_LEARNINGPOTION)*5)*bonus/10000;
sp = sp * (100 + (tstatus->int_<<1)) / 100;
if(dstsd)
sp = sp * (100 + pc_checkskill(dstsd,MG_SRECOVERY)*10) / 100;
}
}
}
else {
hp = (1 + rand()%400) * (100 + skilllv*10) / 100;
hp = hp * (100 + (tstatus->vit<<1)) / 100;
if(dstsd)
hp = hp * (100 + pc_checkskill(dstsd,SM_RECOVERY)*10) / 100;
}
clif_skill_nodamage(src,bl,skillid,skilllv,1);
if(hp > 0 || (skillid == AM_POTIONPITCHER && hp <= 0 && sp <= 0))
clif_skill_nodamage(NULL,bl,AL_HEAL,hp,1);
if(sp > 0)
clif_skill_nodamage(NULL,bl,MG_SRECOVERY,sp,1);
status_heal(bl,hp,sp,0);
}
break;
case AM_CP_WEAPON:
case AM_CP_SHIELD:
case AM_CP_ARMOR:
case AM_CP_HELM:
{
int scid = SC_STRIPWEAPON + (skillid - AM_CP_WEAPON);
if(tsc && tsc->data[scid].timer != -1)
status_change_end(bl, scid, -1 );
clif_skill_nodamage(src,bl,skillid,skilllv,
sc_start(bl,type,100,skilllv,skill_get_time(skillid,skilllv)));
}
break;
case AM_TWILIGHT1:
if (sd) {
clif_skill_nodamage(src,bl,skillid,skilllv,1);
//Prepare 200 White Potions.
if (!skill_produce_mix(sd, skillid, 504, 0, 0, 0, 200))
clif_skill_fail(sd,skillid,0,0);
}
break;
case AM_TWILIGHT2:
if (sd) {
clif_skill_nodamage(src,bl,skillid,skilllv,1);
//Prepare 200 Slim White Potions.
if (!skill_produce_mix(sd, skillid, 547, 0, 0, 0, 200))
clif_skill_fail(sd,skillid,0,0);
}
break;
case AM_TWILIGHT3:
if (sd) {
//check if you can produce all three, if not, then fail:
if (!skill_can_produce_mix(sd,970,-1, 100) //100 Alcohol
|| !skill_can_produce_mix(sd,7136,-1, 50) //50 Acid Bottle
|| !skill_can_produce_mix(sd,7135,-1, 50) //50 Flame Bottle
) {
clif_skill_fail(sd,skillid,0,0);
break;
}
clif_skill_nodamage(src,bl,skillid,skilllv,1);
skill_produce_mix(sd, skillid, 970, 0, 0, 0, 100);
skill_produce_mix(sd, skillid, 7136, 0, 0, 0, 50);
skill_produce_mix(sd, skillid, 7135, 0, 0, 0, 50);
}
break;
case SA_DISPELL: /* ディスペル */
{
int i;
clif_skill_nodamage(src,bl,skillid,skilllv,1);
i = status_get_sc_def_mdef(bl);
if (i >= 10000 ||
tsc == NULL || (tsc->data[SC_SPIRIT].timer != -1 && tsc->data[SC_SPIRIT].val2 == SL_ROGUE) || //Rogue's spirit defends againt dispel.
//Fixed & changed to use a proportionnal reduction (no info, but seems far more logical) [DracoRPG]
rand()%10000 >= (10000-i)*(50+10*skilllv)/100)
{
if (sd)
clif_skill_fail(sd,skillid,0,0);
break;
}
if(status_isimmune(bl) || !tsc->count)
break;
for(i=0;i<SC_MAX;i++){
if (tsc->data[i].timer == -1)
continue;
if(i==SC_HALLUCINATION || i==SC_WEIGHT50 || i==SC_WEIGHT90
|| i==SC_STRIPWEAPON || i==SC_STRIPSHIELD || i==SC_STRIPARMOR || i==SC_STRIPHELM
|| i==SC_CP_WEAPON || i==SC_CP_SHIELD || i==SC_CP_ARMOR || i==SC_CP_HELM
|| i==SC_COMBO || i==SC_DANCING || i==SC_GUILDAURA || i==SC_EDP
|| i==SC_AUTOBERSERK || i==SC_CARTBOOST || i==SC_MELTDOWN || i==SC_MOONLIT
|| i==SC_SAFETYWALL || i==SC_SMA
)
continue;
if(i==SC_BERSERK) tsc->data[i].val4=1; //Mark a dispelled berserk to avoid setting hp to 100.
status_change_end(bl,i,-1);
}
}
break;
case TF_BACKSLIDING: //This is the correct implementation as per packet logging information. [Skotlex]
clif_skill_nodamage(src,bl,skillid,skilllv,1);
skill_blown(src,bl,skill_get_blewcount(skillid,skilllv)|0x10000);
break;
case TK_HIGHJUMP:
{
int x,y, dir = unit_getdir(src);
x = src->x + dirx[dir]*skilllv*2;
y = src->y + diry[dir]*skilllv*2;
clif_skill_nodamage(src,bl,TK_HIGHJUMP,skilllv,1);
if(map_getcell(src->m,x,y,CELL_CHKPASS)) {
unit_movepos(src, x, y, 1, 0);
clif_slide(src,x,y);
}
}
break;
case SA_CASTCANCEL:
clif_skill_nodamage(src,bl,skillid,skilllv,1);
unit_skillcastcancel(src,1);
if(sd) {
int sp = skill_get_sp(sd->skillid_old,sd->skilllv_old);
sp = sp * (90 - (skilllv-1)*20) / 100;
if(sp < 0) sp = 0;
status_zap(src, 0, sp);
}
break;
case SA_SPELLBREAKER: // スペルブレイカー
{
int sp;
if(tsc && tsc->data[SC_MAGICROD].timer != -1) {
sp = skill_get_sp(skillid,skilllv);
sp = sp * tsc->data[SC_MAGICROD].val2 / 100;
if(sp < 1) sp = 1;
status_heal(bl,0,sp,2);
clif_skill_nodamage(bl,bl,SA_MAGICROD,tsc->data[SC_MAGICROD].val1,1);
status_percent_damage(bl, src, 0, -20); //20% max SP damage.
} else {
struct unit_data *ud = unit_bl2ud(bl);
int bl_skillid=0,bl_skilllv=0,hp = 0;
if (!ud || ud->skilltimer == -1) break; //Nothing to cancel.
bl_skillid = ud->skillid;
bl_skilllv = ud->skilllv;
if (tstatus->mode & MD_BOSS)
{ //Only 10% success chance against bosses. [Skotlex]
if (rand()%100 < 90)
{
if (sd) clif_skill_fail(sd,skillid,0,0);
break;
}
} else if (!dstsd || map_flag_vs(bl->m)) //HP damage only on pvp-maps when against players.
hp = tstatus->max_hp/50; //Recover 2% HP [Skotlex]
clif_skill_nodamage(src,bl,skillid,skilllv,1);
unit_skillcastcancel(bl,0);
sp = skill_get_sp(bl_skillid,bl_skilllv);
status_zap(bl, hp, sp);
if (hp && skilllv >= 5)
hp>>=1; //Recover half damaged HP at level 5 [Skotlex]
else
hp = 0;
if (skilllv > 1 && sp) //Recover some of the SP used
sp = sp*(25*(skilllv-1))/100;
else
sp = 0;
if(hp || sp)
status_heal(src, hp, sp, 2);
}
}
break;
case SA_MAGICROD:
sc_start(bl,type,100,skilllv,skill_get_time(skillid,skilllv));
break;
case SA_AUTOSPELL: /* バックステップ */
clif_skill_nodamage(src,bl,skillid,skilllv,1);
if(sd)
clif_autospell(sd,skilllv);
else {
int maxlv=1,spellid=0;
static const int spellarray[3] = { MG_COLDBOLT,MG_FIREBOLT,MG_LIGHTNINGBOLT };
if(skilllv >= 10) {
spellid = MG_FROSTDIVER;
// if (tsc && tsc->data[SC_SPIRIT].timer != -1 && tsc->data[SC_SPIRIT].val2 == SA_SAGE)
// maxlv = 10;
// else
maxlv = skilllv - 9;
}
else if(skilllv >=8) {
spellid = MG_FIREBALL;
maxlv = skilllv - 7;
}
else if(skilllv >=5) {
spellid = MG_SOULSTRIKE;
maxlv = skilllv - 4;
}
else if(skilllv >=2) {
int i = rand()%3;
spellid = spellarray[i];
maxlv = skilllv - 1;
}
else if(skilllv > 0) {
spellid = MG_NAPALMBEAT;
maxlv = 3;
}
if(spellid > 0)
sc_start4(src,SC_AUTOSPELL,100,skilllv,spellid,maxlv,0,
skill_get_time(SA_AUTOSPELL,skilllv));
}
break;
case BS_GREED:
if(sd){
clif_skill_nodamage(src,bl,skillid,skilllv,1);
map_foreachinrange(skill_greed,bl,
skill_get_splash(skillid, skilllv),BL_ITEM,bl);
}
break;
case SA_ELEMENTWATER:
case SA_ELEMENTFIRE:
case SA_ELEMENTGROUND:
case SA_ELEMENTWIND:
if(sd && !dstmd) //Only works on monsters.
break;
if(tstatus->mode&MD_BOSS)
break;
case NPC_ATTRICHANGE:
case NPC_CHANGEWATER:
case NPC_CHANGEGROUND:
case NPC_CHANGEFIRE:
case NPC_CHANGEWIND:
case NPC_CHANGEPOISON:
case NPC_CHANGEHOLY:
case NPC_CHANGEDARKNESS:
case NPC_CHANGETELEKINESIS:
case NPC_CHANGEUNDEAD:
clif_skill_nodamage(src,bl,skillid,skilllv,
sc_start4(bl, type, 100, skilllv, skillid, skill_get_pl(skillid), 0,
skill_get_time(skillid, skilllv)));
break;
case NPC_PROVOCATION:
clif_skill_nodamage(src,bl,skillid,skilllv,1);
if(md && md->skillidx >= 0)
clif_pet_performance(src,md->db->skill[md->skillidx].val[0]);
break;
case NPC_KEEPING:
case NPC_BARRIER:
{
int skill_time = skill_get_time(skillid,skilllv);
struct unit_data *ud = unit_bl2ud(bl);
if (clif_skill_nodamage(src,bl,skillid,skilllv,
sc_start(bl,type,100,skilllv,skill_time))
&& ud) { //Disable attacking/acting/moving for skill's duration.
ud->attackabletime =
ud->canact_tick =
ud->canmove_tick = tick + skill_time;
}
}
break;
case NPC_REBIRTH:
//New rebirth System uses Kaizel lv1. [Skotlex]
sc_start(bl,type,100,1,skill_get_time(SL_KAIZEL,skilllv));
break;
case NPC_DARKBLESSING:
clif_skill_nodamage(src,bl,skillid,skilllv,
sc_start(bl,type,(50+skilllv*5),skilllv,skill_get_time2(skillid,skilllv)));
break;
case NPC_LICK:
status_zap(bl, 0, 100);
clif_skill_nodamage(src,bl,skillid,skilllv,
sc_start(bl,type,(skilllv*5),skilllv,skill_get_time2(skillid,skilllv)));
break;
case NPC_SUICIDE: /* 自決 */
clif_skill_nodamage(src,bl,skillid,skilllv,1);
status_kill(src); //When suiciding, neither exp nor drops is given.
break;
case NPC_SUMMONSLAVE: /* 手下召喚 */
case NPC_SUMMONMONSTER: /* MOB召喚 */
if(md && md->skillidx >= 0)
mob_summonslave(md,md->db->skill[md->skillidx].val,skilllv,skillid);
break;
case NPC_CALLSLAVE:
mob_warpslave(src,MOB_SLAVEDISTANCE);
break;
case NPC_RANDOMMOVE:
if (md) {
md->next_walktime = tick - 1;
mob_randomwalk(md,tick);
}
break;
case NPC_SPEEDUP:
{
// or does it increase casting rate? just a guess xD
int i = SC_ASPDPOTION0 + skilllv - 1;
if (i > SC_ASPDPOTION3)
i = SC_ASPDPOTION3;
clif_skill_nodamage(src,bl,skillid,skilllv,
sc_start(bl,i,100,skilllv,skilllv * 60000));
}
break;
case NPC_REVENGE:
// not really needed... but adding here anyway ^^
if (md && md->master_id > 0) {
struct block_list *mbl, *tbl;
if ((mbl = map_id2bl(md->master_id)) == NULL ||
(tbl = battle_gettargeted(mbl)) == NULL)
break;
md->state.provoke_flag = tbl->id;
mob_target(md, tbl, sstatus->rhw.range);
}
break;
case NPC_RUN: //後退
{
const int mask[8][2] = {{0,-1},{1,-1},{1,0},{1,1},{0,1},{-1,1},{-1,0},{-1,-1}};
int dir = (bl == src)?unit_getdir(src):map_calc_dir(src,bl->x,bl->y); //If cast on self, run forward, else run away.
unit_stop_attack(src);
//Run skillv tiles.
unit_walktoxy(src, bl->x + skilllv * mask[dir][0], bl->y + skilllv * mask[dir][1], 0);
}
break;
case NPC_TRANSFORMATION:
case NPC_METAMORPHOSIS:
if(md && md->skillidx >= 0) {
int class_ = mob_random_class (md->db->skill[md->skillidx].val,0);
if (skilllv > 1) //Multiply the rest of mobs. [Skotlex]
mob_summonslave(md,md->db->skill[md->skillidx].val,skilllv-1,skillid);
if (class_) mob_class_change(md, class_);
}
break;
case NPC_EMOTION_ON:
case NPC_EMOTION:
if(md && md->skillidx >= 0)
{
clif_emotion(&md->bl,md->db->skill[md->skillidx].val[0]);
if(!md->special_state.ai &&
(md->db->skill[md->skillidx].val[1] || md->db->skill[md->skillidx].val[2]))
//NPC_EMOTION & NPC_EMOTION_ON can change a mob's mode 'permanently' [Skotlex]
//val[1] 'sets' the mode, val[2] can add/remove from the current mode based on skill used:
//NPC_EMOTION_ON adds a mode / NPC_EMOTION removes it.
sc_start4(src, type, 100, skilllv,
md->db->skill[md->skillidx].val[1],
skillid==NPC_EMOTION_ON?md->db->skill[md->skillidx].val[2]:0,
skillid==NPC_EMOTION ?md->db->skill[md->skillidx].val[2]:0,
skill_get_time(skillid, skilllv));
}
break;
case NPC_DEFENDER:
clif_skill_nodamage(src,bl,skillid,skilllv,1);
break;
case NPC_POWERUP:
sc_start(bl,SC_INCATKRATE,100,40*skilllv,skill_get_time(skillid, skilllv));
clif_skill_nodamage(src,bl,skillid,skilllv,
sc_start(bl,type,100,40*skilllv,skill_get_time(skillid, skilllv)));
break;
case NPC_AGIUP:
sc_start(bl,SC_SPEEDUP1,100,skilllv,skill_get_time(skillid, skilllv));
clif_skill_nodamage(src,bl,skillid,skilllv,
sc_start(bl,type,100,40*skilllv,skill_get_time(skillid, skilllv)));
break;
case NPC_INVISIBLE:
//val4 passed as 1 is for "infinite cloak".
clif_skill_nodamage(src,bl,skillid,skilllv,
sc_start4(bl,type,100,skilllv,0,0,1,skill_get_time(skillid,skilllv)));
break;
case NPC_SIEGEMODE:
// not sure what it does
clif_skill_nodamage(src,bl,skillid,skilllv,1);
break;
case WE_MALE:
{
int hp_rate=(skilllv <= 0)? 0:skill_db[skillid].hp_rate[skilllv-1];
int gain_hp= tstatus->max_hp*abs(hp_rate)/100; // The earned is the same % of the target HP than it costed the caster. [Skotlex]
clif_skill_nodamage(src,bl,skillid,status_heal(bl, gain_hp, 0, 0),1);
}
break;
case WE_FEMALE:
{
int sp_rate=(skilllv <= 0)? 0:skill_db[skillid].sp_rate[skilllv-1];
int gain_sp=tstatus->max_sp*abs(sp_rate)/100;// The earned is the same % of the target SP than it costed the caster. [Skotlex]
clif_skill_nodamage(src,bl,skillid,status_heal(bl, 0, gain_sp, 0),1);
}
break;
// parent-baby skills
case WE_BABY:
if(sd){
struct map_session_data *f_sd = pc_get_father(sd);
struct map_session_data *m_sd = pc_get_mother(sd);
// if neither was found
if(!f_sd && !m_sd){
clif_skill_fail(sd,skillid,0,0);
map_freeblock_unlock();
return 0;
}
status_change_start(bl,SC_STUN,10000,skilllv,0,0,0,skill_get_time2(skillid,skilllv),8);
if (f_sd) sc_start(&f_sd->bl,type,100,skilllv,skill_get_time(skillid,skilllv));
if (m_sd) sc_start(&m_sd->bl,type,100,skilllv,skill_get_time(skillid,skilllv));
}
break;
case PF_HPCONVERSION:
{
int hp, sp;
hp = sstatus->max_hp/10;
sp = hp * 10 * skilllv / 100;
if (!status_charge(src,hp,0)) {
if (sd) clif_skill_fail(sd,skillid,0,0);
break;
}
clif_skill_nodamage(src, bl, skillid, skilllv, 1);
status_heal(bl,0,sp,2);
}
break;
case HT_REMOVETRAP: /* リムーブトラップ */
clif_skill_nodamage(src,bl,skillid,skilllv,1);
{
struct skill_unit *su=NULL;
struct item item_tmp;
int flag;
if((bl->type==BL_SKILL) &&
(su=(struct skill_unit *)bl) &&
(su->group->src_id == src->id || map_flag_vs(bl->m)) &&
(skill_get_inf2(su->group->skill_id) & INF2_TRAP))
{
if(sd && !su->group->state.into_abyss)
{ //Avoid collecting traps when it does not costs to place them down. [Skotlex]
if(battle_config.skill_removetrap_type){
for(i=0;i<10;i++) {
if(skill_db[su->group->skill_id].itemid[i] > 0){
memset(&item_tmp,0,sizeof(item_tmp));
item_tmp.nameid = skill_db[su->group->skill_id].itemid[i];
item_tmp.identify = 1;
if(item_tmp.nameid && (flag=pc_additem(sd,&item_tmp,skill_db[su->group->skill_id].amount[i]))){
clif_additem(sd,0,0,flag);
map_addflooritem(&item_tmp,skill_db[su->group->skill_id].amount[i],sd->bl.m,sd->bl.x,sd->bl.y,NULL,NULL,NULL,0);
}
}
}
}else{
memset(&item_tmp,0,sizeof(item_tmp));
item_tmp.nameid = 1065;
item_tmp.identify = 1;
if(item_tmp.nameid && (flag=pc_additem(sd,&item_tmp,1))){
clif_additem(sd,0,0,flag);
map_addflooritem(&item_tmp,1,sd->bl.m,sd->bl.x,sd->bl.y,NULL,NULL,NULL,0);
}
}
}
if(su->group->unit_id == UNT_ANKLESNARE && su->group->val2){
struct block_list *target=map_id2bl(su->group->val2);
if(target)
status_change_end(target,SC_ANKLE,-1);
}
skill_delunit(su);
}
}
break;
case HT_SPRINGTRAP: /* スプリングトラップ */
clif_skill_nodamage(src,bl,skillid,skilllv,1);
{
struct skill_unit *su=NULL;
if((bl->type==BL_SKILL) && (su=(struct skill_unit *)bl) && (su->group) ){
switch(su->group->unit_id){
case UNT_ANKLESNARE: // ankle snare
if (su->group->val2 != 0)
// if it is already trapping something don't spring it,
// remove trap should be used instead
break;
// otherwise fallthrough to below
case UNT_BLASTMINE:
case UNT_SKIDTRAP:
case UNT_LANDMINE:
case UNT_SHOCKWAVE:
case UNT_SANDMAN:
case UNT_FLASHER:
case UNT_FREEZINGTRAP:
case UNT_CLAYMORETRAP:
case UNT_TALKIEBOX:
su->group->unit_id = UNT_USED_TRAPS;
clif_changetraplook(bl, UNT_USED_TRAPS);
su->group->limit=DIFF_TICK(tick+1500,su->group->tick);
su->limit=DIFF_TICK(tick+1500,su->group->tick);
}
}
}
break;
case BD_ENCORE: /* アンコール */
clif_skill_nodamage(src,bl,skillid,skilllv,1);
if(sd)
unit_skilluse_id(src,src->id,sd->skillid_dance,sd->skilllv_dance);
break;
case AS_SPLASHER: /* ベナムスプラッシャー */
if(tstatus->max_hp*3/4 < tstatus->hp) {
map_freeblock_unlock();
return 1;
}
clif_skill_nodamage(src,bl,skillid,skilllv,
sc_start4(bl,type,100,
skilllv,skillid,src->id,skill_get_time(skillid,skilllv),1000));
break;
case PF_MINDBREAKER:
{
if(tstatus->mode&MD_BOSS || battle_check_undead(tstatus->race,tstatus->def_ele))
{
map_freeblock_unlock();
return 1;
}
//Has a 55% + skilllv*5% success chance.
if (!clif_skill_nodamage(src,bl,skillid,skilllv,
sc_start(bl,type,55+5*skilllv,skilllv,skill_get_time(skillid,skilllv))))
{
if (sd) clif_skill_fail(sd,skillid,0,0);
map_freeblock_unlock();
return 0;
}
unit_skillcastcancel(bl,0);
if(tsc && tsc->count){
if(tsc->data[SC_FREEZE].timer!=-1)
status_change_end(bl,SC_FREEZE,-1);
if(tsc->data[SC_STONE].timer!=-1 && tsc->data[SC_STONE].val2==0)
status_change_end(bl,SC_STONE,-1);
if(tsc->data[SC_SLEEP].timer!=-1)
status_change_end(bl,SC_SLEEP,-1);
}
if(dstmd)
mob_target(dstmd,src,skill_get_range2(src,skillid,skilllv));
}
break;
case PF_SOULCHANGE:
{
unsigned int sp1 = 0, sp2 = 0;
if (dstmd) {
if (dstmd->state.soul_change_flag) {
if(sd) clif_skill_fail(sd,skillid,0,0);
break;
}
dstmd->state.soul_change_flag = 1;
sp2 = sstatus->max_sp * 3 /100;
status_heal(src, 0, sp2, 2);
clif_skill_nodamage(src,bl,skillid,skilllv,1);
break;
}
sp1 = sstatus->sp;
sp2 = tstatus->sp;
//TODO: Will this work correctly once sp1/sp2 go above INT_MAX?
status_heal(src, 0, (signed int)(sp2-sp1), 3);
status_heal(bl, 0, (signed int)(sp1-sp2), 3);
clif_skill_nodamage(src,bl,skillid,skilllv,1);
}
break;
// Slim Pitcher
case CR_SLIMPITCHER:
if (potion_hp || potion_sp) {
int hp = potion_hp, sp = potion_sp;
hp = hp * (100 + (tstatus->vit<<1))/100;
sp = sp * (100 + (tstatus->int_<<1))/100;
if (dstsd) {
if (hp)
hp = hp * (100 + pc_checkskill(dstsd,SM_RECOVERY)*10)/100;
if (sp)
sp = sp * (100 + pc_checkskill(dstsd,MG_SRECOVERY)*10)/100;
}
if(hp > 0)
clif_skill_nodamage(NULL,bl,AL_HEAL,hp,1);
if(sp > 0)
clif_skill_nodamage(NULL,bl,MG_SRECOVERY,sp,1);
status_heal(bl,hp,sp,0);
}
break;
// Full Chemical Protection
case CR_FULLPROTECTION:
{
int i, skilltime;
skilltime = skill_get_time(skillid,skilllv);
if (!tsc) {
clif_skill_nodamage(src,bl,skillid,skilllv,0);
break;
}
for (i=0; i<4; i++) {
if(tsc->data[SC_STRIPWEAPON + i].timer != -1)
status_change_end(bl, SC_STRIPWEAPON + i, -1 );
sc_start(bl,SC_CP_WEAPON + i,100,skilllv,skilltime);
}
clif_skill_nodamage(src,bl,skillid,skilllv,1);
}
break;
case RG_CLEANER: //AppleGirl
clif_skill_nodamage(src,bl,skillid,skilllv,1);
break;
case PF_DOUBLECASTING:
if (!clif_skill_nodamage(src,bl,skillid,skilllv,
sc_start(bl,type,30+ 10*skilllv,skilllv,skill_get_time(skillid,skilllv))))
if (sd) clif_skill_fail(sd,skillid,0,0);
break;
case CG_LONGINGFREEDOM:
{
if (tsc && tsc->data[SC_LONGING].timer == -1 && tsc->data[SC_DANCING].timer != -1 && tsc->data[SC_DANCING].val4
&& tsc->data[SC_DANCING].val1 != CG_MOONLIT) //Can't use Longing for Freedom while under Moonlight Petals. [Skotlex]
{
clif_skill_nodamage(src,bl,skillid,skilllv,
sc_start(bl,type,100,skilllv,skill_get_time(skillid,skilllv)));
}
}
break;
case CG_TAROTCARD:
{
int eff, count = -1;
if (rand() % 100 > skilllv * 8) {
if (sd) clif_skill_fail(sd,skillid,0,0);
map_freeblock_unlock();
return 0;
}
do {
eff = rand() % 14;
clif_specialeffect(bl, 523 + eff, AREA);
switch (eff)
{
case 0: // heals SP to 0
status_percent_damage(src, bl, 0, 100);
break;
case 1: // matk halved
sc_start(bl,SC_INCMATKRATE,100,-50,skill_get_time2(skillid,skilllv));
break;
case 2: // all buffs removed
status_change_clear_buffs(bl,1);
break;
case 3: // 1000 damage, random armor destroyed
{
int where[] = { EQP_ARMOR, EQP_SHIELD, EQP_HELM };
status_fix_damage(src, bl, 1000, 0);
clif_damage(src,bl,tick,0,0,1000,0,0,0);
skill_break_equip(bl, where[rand()%3], 10000, BCT_ENEMY);
}
break;
case 4: // atk halved
sc_start(bl,SC_INCATKRATE,100,-50,skill_get_time2(skillid,skilllv));
break;
case 5: // 2000HP heal, random teleported
status_heal(src, 2000, 0, 0);
unit_warp(src, -1,-1,-1, 3);
break;
case 6: // random 2 other effects
if (count == -1)
count = 3;
else
count++; //Should not retrigger this one.
break;
case 7: // stop freeze or stoned
{
int sc[] = { SC_STOP, SC_FREEZE, SC_STONE };
sc_start(bl,sc[rand()%3],100,skilllv,skill_get_time2(skillid,skilllv));
}
break;
case 8: // curse coma and poison
sc_start(bl,SC_COMA,100,skilllv,skill_get_time2(skillid,skilllv));
sc_start(bl,SC_CURSE,100,skilllv,skill_get_time2(skillid,skilllv));
sc_start(bl,SC_POISON,100,skilllv,skill_get_time2(skillid,skilllv));
break;
case 9: // confusion
sc_start(bl,SC_CONFUSION,100,skilllv,skill_get_time2(skillid,skilllv));
break;
case 10: // 6666 damage, atk matk halved, cursed
status_fix_damage(src, bl, 6666, 0);
clif_damage(src,bl,tick,0,0,6666,0,0,0);
sc_start(bl,SC_INCATKRATE,100,-50,skill_get_time2(skillid,skilllv));
sc_start(bl,SC_INCMATKRATE,100,-50,skill_get_time2(skillid,skilllv));
sc_start(bl,SC_CURSE,skilllv,100,skill_get_time2(skillid,skilllv));
break;
case 11: // 4444 damage
status_fix_damage(src, bl, 4444, 0);
clif_damage(src,bl,tick,0,0,4444,0,0,0);
break;
case 12: // stun
sc_start(bl,SC_STUN,100,skilllv,5000);
break;
case 13: // atk,matk,hit,flee,def reduced
sc_start(bl,SC_INCATKRATE,100,-20,skill_get_time2(skillid,skilllv));
sc_start(bl,SC_INCMATKRATE,100,-20,skill_get_time2(skillid,skilllv));
sc_start(bl,SC_INCHITRATE,100,-20,skill_get_time2(skillid,skilllv));
sc_start(bl,SC_INCFLEERATE,100,-20,skill_get_time2(skillid,skilllv));
sc_start(bl,SC_INCDEFRATE,100,-20,skill_get_time2(skillid,skilllv));
break;
default:
break;
}
} while ((--count) > 0);
clif_skill_nodamage(src,bl,skillid,skilllv,1);
}
break;
case SL_ALCHEMIST:
case SL_ASSASIN:
case SL_BARDDANCER:
case SL_BLACKSMITH:
case SL_CRUSADER:
case SL_HUNTER:
case SL_KNIGHT:
case SL_MONK:
case SL_PRIEST:
case SL_ROGUE:
case SL_SAGE:
case SL_SOULLINKER:
case SL_STAR:
case SL_SUPERNOVICE:
case SL_WIZARD:
if (sd && !(dstsd && (dstsd->class_&MAPID_UPPERMASK) == type)) {
clif_skill_fail(sd,skillid,0,0);
break;
}
clif_skill_nodamage(src,bl,skillid,skilllv,
sc_start4(bl,SC_SPIRIT,100,skilllv,skillid,0,0,skill_get_time(skillid,skilllv)));
sc_start(src,SC_SMA,100,skilllv,skill_get_time(SL_SMA,skilllv));
break;
case SL_HIGH:
if (sd && !(dstsd && (dstsd->class_&JOBL_UPPER) && !(dstsd->class_&JOBL_2) && dstsd->status.base_level < 70)) {
clif_skill_fail(sd,skillid,0,0);
break;
}
clif_skill_nodamage(src,bl,skillid,skilllv,
sc_start4(bl,type,100,skilllv,skillid,0,0,skill_get_time(skillid,skilllv)));
sc_start(src,SC_SMA,100,skilllv,skill_get_time(SL_SMA,skilllv));
break;
case SL_SWOO:
if (tsc && tsc->data[type].timer != -1) {
sc_start(src,SC_STUN,100,skilllv,10000);
break;
}
case SL_SKA: // [marquis007]
case SL_SKE:
if (sd && !battle_config.allow_es_magic_pc && bl->type != BL_MOB) {
clif_skill_fail(sd,skillid,0,0);
status_change_start(src,SC_STUN,10000,skilllv,0,0,0,500,10);
} else
clif_skill_nodamage(src,bl,skillid,skilllv,
sc_start(bl,type,100,skilllv,skill_get_time(skillid,skilllv)));
if (skillid == SL_SKE)
sc_start(src,SC_SMA,100,skilllv,skill_get_time(SL_SMA,skilllv));
break;
// New guild skills [Celest]
case GD_BATTLEORDER:
if(flag&1) {
if (status_get_guild_id(src) == status_get_guild_id(bl))
sc_start(bl,type,100,skilllv,skill_get_time(skillid, skilllv));
} else if (status_get_guild_id(src)) {
clif_skill_nodamage(src,bl,skillid,skilllv,1);
map_foreachinrange(skill_area_sub, src,
skill_get_splash(skillid, skilllv), BL_CHAR,
src,skillid,skilllv,tick, flag|BCT_GUILD|1,
skill_castend_nodamage_id);
if (sd)
guild_block_skill(sd,skill_get_time2(skillid,skilllv));
}
break;
case GD_REGENERATION:
if(flag&1) {
if (status_get_guild_id(src) == status_get_guild_id(bl))
sc_start(bl,SC_REGENERATION,100,skilllv,skill_get_time(skillid, skilllv));
} else if (status_get_guild_id(src)) {
clif_skill_nodamage(src,bl,skillid,skilllv,1);
map_foreachinrange(skill_area_sub, src,
skill_get_splash(skillid, skilllv), BL_CHAR,
src,skillid,skilllv,tick, flag|BCT_GUILD|1,
skill_castend_nodamage_id);
if (sd)
guild_block_skill(sd,skill_get_time2(skillid,skilllv));
}
break;
case GD_RESTORE:
if(flag&1) {
if (status_get_guild_id(src) == status_get_guild_id(bl))
clif_skill_nodamage(src,bl,AL_HEAL,status_percent_heal(bl,90,90),1);
} else if (status_get_guild_id(src)) {
clif_skill_nodamage(src,bl,skillid,skilllv,1);
map_foreachinrange(skill_area_sub, src,
skill_get_splash(skillid, skilllv), BL_CHAR,
src,skillid,skilllv,tick, flag|BCT_GUILD|1,
skill_castend_nodamage_id);
if (sd)
guild_block_skill(sd,skill_get_time2(skillid,skilllv));
}
break;
case GD_EMERGENCYCALL:
{
int dx[9]={-1, 1, 0, 0,-1, 1,-1, 1, 0};
int dy[9]={ 0, 0, 1,-1, 1,-1,-1, 1, 0};
int j = 0;
struct guild *g = NULL;
// i don't know if it actually summons in a circle, but oh well. ;P
g = sd?sd->state.gmaster_flag:guild_search(status_get_guild_id(src));
if (!g)
break;
for(i = 0; i < g->max_member; i++, j++) {
if (j>8) j=0;
if ((dstsd = g->member[i].sd) != NULL && sd != dstsd) {
if (map[dstsd->bl.m].flag.nowarp && !map_flag_gvg(dstsd->bl.m))
continue;
clif_skill_nodamage(src,bl,skillid,skilllv,1);
if(map_getcell(src->m,src->x+dx[j],src->y+dy[j],CELL_CHKNOREACH))
dx[j] = dy[j] = 0;
pc_setpos(dstsd, map[src->m].index, src->x+dx[j], src->y+dy[j], 2);
}
}
if (sd)
guild_block_skill(sd,skill_get_time2(skillid,skilllv));
}
break;
case SG_FEEL:
if (sd) {
if(!sd->feel_map[skilllv-1].index) {
//AuronX reported you CAN memorize the same map as all three. [Skotlex]
clif_skill_nodamage(src,bl,skillid,skilllv,1);
clif_parse_ReqFeel(sd->fd,sd, skilllv);
}
else
clif_feel_info(sd, skilllv-1);
}
break;
case SG_HATE:
if (sd) {
clif_skill_nodamage(src,bl,skillid,skilllv,1);
if(dstsd) //PC
{
sd->hate_mob[skilllv-1] = dstsd->status.class_;
pc_setglobalreg(sd,"PC_HATE_MOB_STAR",sd->hate_mob[skilllv-1]+1);
clif_hate_mob(sd,skilllv,sd->hate_mob[skilllv-1]);
}
else if(dstmd) // mob
{
switch(skilllv)
{
case 1:
if (tstatus->size==0)
{
sd->hate_mob[0] = dstmd->class_;
pc_setglobalreg(sd,"PC_HATE_MOB_SUN",sd->hate_mob[0]+1);
clif_hate_mob(sd,skilllv,sd->hate_mob[skilllv-1]);
} else clif_skill_fail(sd,skillid,0,0);
break;
case 2:
if (tstatus->size==1 && tstatus->max_hp>=6000)
{
sd->hate_mob[1] = dstmd->class_;
pc_setglobalreg(sd,"PC_HATE_MOB_MOON",sd->hate_mob[1]+1);
clif_hate_mob(sd,skilllv,sd->hate_mob[skilllv-1]);
} else clif_skill_fail(sd,skillid,0,0);
break;
case 3:
if (tstatus->size==2 && tstatus->max_hp>=20000)
{
sd->hate_mob[2] = dstmd->class_;
pc_setglobalreg(sd,"PC_HATE_MOB_STAR",sd->hate_mob[2]+1);
clif_hate_mob(sd,skilllv,sd->hate_mob[skilllv-1]);
} else clif_skill_fail(sd,skillid,0,0);
break;
default:
clif_skill_fail(sd,skillid,0,0);
break;
}
}
}
break;
//Until they're at right position - gs_nodamage- [Vicious]
//Not implemented yet [Vicious]
case GS_GLITTERING:
if(sd) {
clif_skill_nodamage(src,bl,skillid,skilllv,1);
if(rand()%100 < (50+10*skilllv))
pc_addspiritball(sd,skill_get_time(skillid,skilllv),10);
else if(sd->spiritball > 0)
pc_delspiritball(sd,1,0);
}
break;
default:
ShowWarning("skill_castend_nodamage_id: Unknown skill used:%d\n",skillid);
map_freeblock_unlock();
return 1;
}
if (dstmd) //Mob skill event for no damage skills (damage ones are handled in battle_calc_damage) [Skotlex]
mobskill_event(dstmd, src, tick, MSC_SKILLUSED|(skillid<<16));
if (sd && !(flag&1) && sd->state.arrow_atk) //Consume arrow on last invocation to this skill.
battle_consume_ammo(sd, skillid, skilllv);
map_freeblock_unlock();
return 0;
}
/*==========================================
* スキル使用（詠唱完了、ID指定）
*------------------------------------------
*/
int skill_castend_id (int tid, unsigned int tick, int id, int data)
{
struct block_list *target, *src = map_id2bl(id);
struct map_session_data* sd = NULL;
struct mob_data* md = NULL;
struct unit_data* ud = unit_bl2ud(src);
struct status_change *sc;
int inf2;
nullpo_retr(0, ud);
BL_CAST( BL_PC, src, sd);
BL_CAST( BL_MOB, src, md);
if( src->prev == NULL ) {
ud->skilltimer = -1;
return 0;
}
switch (ud->skillid) {
//These three should become skill_castend_pos
case WE_CALLPARTNER:
case WE_CALLPARENT:
case WE_CALLBABY:
//Find a random spot to place the skill. [Skotlex]
inf2 = skill_get_splash(ud->skillid, ud->skilllv);
ud->skillx = src->x + inf2;
ud->skilly = src->y + inf2;
if (!map_random_dir(src, &ud->skillx, &ud->skilly)) {
ud->skillx = src->x;
ud->skilly = src->y;
}
return skill_castend_pos(tid,tick,id,data);
}
if(ud->skillid != SA_CASTCANCEL ) {
if( ud->skilltimer != tid ) {
ShowError("skill_castend_id: Timer mismatch %d!=%d!\n", ud->skilltimer, tid);
ud->skilltimer = -1;
return 0;
}
if( sd && ud->skilltimer != -1 && pc_checkskill(sd,SA_FREECAST))
status_freecast_switch(sd);
ud->skilltimer=-1;
}
if (ud->skilltarget == id)
target = src;
else
target = map_id2bl(ud->skilltarget);
// Use a do so that you can break out of it when the skill fails.
do {
if(!target || target->prev==NULL) break;
if(src->m != target->m || status_isdead(src)) break;
if(ud->skillid == RG_BACKSTAP) {
int dir = map_calc_dir(src,target->x,target->y),t_dir = unit_getdir(target);
if(check_distance_bl(src, target, 0) || map_check_dir(dir,t_dir)) {
break;
}
}
if (ud->skillid == PR_LEXDIVINA)
{
sc = status_get_sc(target);
if (battle_check_target(src,target, BCT_ENEMY)<=0 &&
(!sc || sc->data[SC_SILENCE].timer == -1))
{ //If it's not an enemy, and not silenced, you can't use the skill on them. [Skotlex]
clif_skill_nodamage (src, target, ud->skillid, ud->skilllv, 0);
break;
}
} else {
inf2 = skill_get_inf(ud->skillid);
if((inf2&INF_ATTACK_SKILL ||
(inf2&INF_SELF_SKILL && skill_get_inf2(ud->skillid)&INF2_NO_TARGET_SELF)) //Combo skills
&& battle_check_target(src, target, BCT_ENEMY)<=0
)
break;
}
//Avoid doing double checks for instant-cast skills.
if (tid != -1 && !status_check_skilluse(src, target, ud->skillid, 1))
break;
//沈黙や状態異常など
if(md) {
if(ud->skillid != NPC_EMOTION)//Set afterskill delay.
md->last_thinktime=tick + (tid==-1?md->status.adelay:md->status.amotion);
if(md->skillidx >= 0) {
md->skilldelay[md->skillidx]=tick;
if (md->db->skill[md->skillidx].emotion >= 0)
clif_emotion(src, md->db->skill[md->skillidx].emotion);
}
}
inf2 = skill_get_inf2(ud->skillid);
if(inf2 & (INF2_PARTY_ONLY|INF2_GUILD_ONLY) && src != target) {
inf2 =
(inf2&INF2_PARTY_ONLY?BCT_PARTY:0)|
(inf2&INF2_GUILD_ONLY?BCT_GUILD:0)|
(inf2&INF2_ALLOW_ENEMY?BCT_ENEMY:0);
if(battle_check_target(src, target, inf2) <= 0)
break;
}
if(src != target && battle_config.skill_add_range &&
!check_distance_bl(src, target, skill_get_range2(src,ud->skillid,ud->skilllv)+battle_config.skill_add_range))
{
if (sd) {
clif_skill_fail(sd,ud->skillid,0,0);
if(battle_config.skill_out_range_consume) //Consume items anyway. [Skotlex]
skill_check_condition(sd,ud->skillid, ud->skilllv,1);
}
break;
}
if(sd && !skill_check_condition(sd,ud->skillid, ud->skilllv,1)) /* 使用条件チェック */
break;
if (ud->walktimer != -1 && ud->skillid != TK_RUN)
unit_stop_walking(src,1);
if (ud->skillid == SA_MAGICROD)
ud->canact_tick = tick;
else
ud->canact_tick = tick + skill_delayfix(src, ud->skillid, ud->skilllv);
if (skill_get_state(ud->skillid) != ST_MOVE_ENABLE)
unit_set_walkdelay(src, tick, battle_config.default_skill_delay+skill_get_walkdelay(ud->skillid, ud->skilllv), 1);
if(battle_config.skill_log && battle_config.skill_log&src->type)
ShowInfo("Type %d, ID %d skill castend id [id =%d, lv=%d, target ID %d)\n",
src->type, src->id, ud->skillid, ud->skilllv, target->id);
if (skill_get_casttype(ud->skillid) == CAST_NODAMAGE)
skill_castend_nodamage_id(src,target,ud->skillid,ud->skilllv,tick,0);
else
skill_castend_damage_id(src,target,ud->skillid,ud->skilllv,tick,0);
sc = status_get_sc(src);
if(sc && sc->count && sc->data[SC_MAGICPOWER].timer != -1 && ud->skillid != HW_MAGICPOWER && ud->skillid != WZ_WATERBALL)
status_change_end(src,SC_MAGICPOWER,-1);
if (ud->skilltimer == -1) {
if(md) md->skillidx = -1;
else ud->skillid = 0; //mobs can't clear this one as it is used for skill condition 'afterskill'
ud->skilllv = ud->skilltarget = 0;
}
return 1;
} while(0);
//Skill failed.
ud->skillid = ud->skilllv = ud->skilltarget = 0;
ud->canact_tick = tick;
if(sd) sd->skillitem = sd->skillitemlv = -1;
if(md) md->skillidx = -1;
return 0;
}
/*==========================================
* スキル使用（詠唱完了、場所指定）
*------------------------------------------
*/
int skill_castend_pos (int tid, unsigned int tick, int id, int data)
{
struct block_list* src = map_id2bl(id);
int maxcount;
struct map_session_data *sd = NULL;
struct unit_data *ud = unit_bl2ud(src);
struct mob_data *md = NULL;
nullpo_retr(0, ud);
BL_CAST( BL_PC , src, sd);
BL_CAST( BL_MOB, src, md);
if( src->prev == NULL ) {
ud->skilltimer = -1;
return 0;
}
if( ud->skilltimer != tid ) /* タイマIDの確認 */
{
ShowError("skill_castend_pos: Timer mismatch %d!=%d\n", ud->skilltimer, tid);
ud->skilltimer = -1;
return 0;
}
if(sd && ud->skilltimer != -1 && pc_checkskill(sd,SA_FREECAST))
status_freecast_switch(sd);
ud->skilltimer=-1;
do {
if(status_isdead(src)) break;
if (!(battle_config.skill_reiteration && src->type&battle_config.skill_reiteration) &&
skill_get_unit_flag(ud->skillid)&UF_NOREITERATION &&
skill_check_unit_range(src,ud->skillx,ud->skilly,ud->skillid,ud->skilllv)
)
break;
if (battle_config.skill_nofootset && src->type&battle_config.skill_nofootset &&
skill_get_unit_flag(ud->skillid)&UF_NOFOOTSET &&
skill_check_unit_range2(src,ud->skillx,ud->skilly,ud->skillid,ud->skilllv)
)
break;
if(battle_config.land_skill_limit && src->type&battle_config.land_skill_limit &&
(maxcount = skill_get_maxcount(ud->skillid)) > 0
) {
int i;
for(i=0;i<MAX_SKILLUNITGROUP && ud->skillunit[i] && maxcount;i++) {
if(ud->skillunit[i]->skill_id == ud->skillid)
maxcount--;
}
if(!maxcount)
break;
}
if(tid != -1)
{ //Avoid double checks on instant cast skills. [Skotlex]
if (!status_check_skilluse(src, NULL, ud->skillid, 1))
break;
if(battle_config.skill_add_range &&
!check_distance_blxy(src, ud->skillx, ud->skilly, skill_get_range2(src,ud->skillid,ud->skilllv)+battle_config.skill_add_range)) {
if (sd && battle_config.skill_out_range_consume) //Consume items anyway.
skill_check_condition(sd,ud->skillid, ud->skilllv,1);
break;
}
}
if(sd && !skill_check_condition(sd,ud->skillid, ud->skilllv, 1)) /* 使用条件チェック */
break;
if(md) {
md->last_thinktime=tick + (tid==-1?md->status.adelay:md->status.amotion);
if(md->skillidx >= 0) {
md->skilldelay[md->skillidx]=tick;
if (md->db->skill[md->skillidx].emotion >= 0)
clif_emotion(src, md->db->skill[md->skillidx].emotion);
}
}
if(battle_config.skill_log && battle_config.skill_log&src->type)
ShowInfo("Type %d, ID %d skill castend pos [id =%d, lv=%d, (%d,%d)]\n",
src->type, src->id, ud->skillid, ud->skilllv, ud->skillx, ud->skilly);
unit_stop_walking(src,1);
ud->canact_tick = tick + skill_delayfix(src, ud->skillid, ud->skilllv);
unit_set_walkdelay(src, tick, battle_config.default_skill_delay+skill_get_walkdelay(ud->skillid, ud->skilllv), 1);
skill_castend_pos2(src,ud->skillx,ud->skilly,ud->skillid,ud->skilllv,tick,0);
if (ud->skilltimer == -1) {
if (md) md->skillidx = -1;
else ud->skillid = 0; //Non mobs can't clear this one as it is used for skill condition 'afterskill'
ud->skilllv = ud->skillx = ud->skilly = 0;
}
return 1;
} while(0);
ud->canact_tick = tick;
ud->skillid = ud->skilllv = 0;
if(sd) {
clif_skill_fail(sd,ud->skillid,0,0);
sd->skillitem = sd->skillitemlv = -1;
}
if(md) md->skillidx = -1;
return 0;
}
/*==========================================
* スキル使用（詠唱完了、場所指定の実際の処理）
*------------------------------------------
*/
int skill_castend_pos2 (struct block_list *src, int x, int y, int skillid, int skilllv, unsigned int tick, int flag)
{
struct map_session_data *sd=NULL;
struct status_change *sc;
struct skill_unit_group *sg;
int i,type;
//if(skilllv <= 0) return 0;
if(skillid > 0 && skilllv <= 0) return 0; // celest
nullpo_retr(0, src);
if(status_isdead(src))
return 0;
if(src->type==BL_PC)
sd=(struct map_session_data *)src;
sc = status_get_sc(src);
if (sc && !sc->count)
sc = NULL; //Unneeded.
type = SkillStatusChangeTable(skillid);
switch (skillid) { //Skill effect.
case WZ_METEOR:
case MO_BODYRELOCATION:
case CR_CULTIVATION:
case HW_GANBANTEIN:
break; //Effect is displayed on respective switch case.
default:
if(skill_get_inf(skillid)&INF_SELF_SKILL)
clif_skill_nodamage(src,src,skillid,skilllv,1);
else
clif_skill_poseffect(src,skillid,skilllv,x,y,tick);
}
switch(skillid)
{
case PR_BENEDICTIO:
skill_area_temp[1] = src->id;
i = skill_get_splash(skillid, skilllv);
map_foreachinarea(skill_area_sub,
src->m, x-i, y-i, x+i, y+i, BL_PC,
src, skillid, skilllv, tick, flag|BCT_ALL|1,
skill_castend_nodamage_id);
map_foreachinarea(skill_area_sub,
src->m, x-i, y-i, x+i, y+i, BL_CHAR,
src, skillid, skilllv, tick, flag|BCT_ENEMY|1,
skill_castend_damage_id);
break;
case BS_HAMMERFALL:
i = skill_get_splash(skillid, skilllv);
map_foreachinarea (skill_area_sub,
src->m, x-i, y-i, x+i, y+i, BL_CHAR,
src, skillid, skilllv, tick, flag|BCT_ENEMY|2,
skill_castend_nodamage_id);
break;
case HT_DETECTING:
i = skill_get_splash(skillid, skilllv);
map_foreachinarea( status_change_timer_sub,
src->m, x-i, y-i, x+i,y+i,BL_CHAR,
src,status_get_sc(src),SC_SIGHT,tick);
if(battle_config.traps_setting&1)
map_foreachinarea( skill_reveal_trap,
src->m, x-i, y-i, x+i,y+i,BL_SKILL);
break;
case MG_SAFETYWALL:
case MG_FIREWALL:
case MG_THUNDERSTORM:
case AL_PNEUMA:
case WZ_ICEWALL:
case WZ_FIREPILLAR:
case WZ_QUAGMIRE:
case WZ_VERMILION:
case WZ_STORMGUST:
case WZ_HEAVENDRIVE:
case PR_SANCTUARY:
case PR_MAGNUS:
case CR_GRANDCROSS:
case NPC_GRANDDARKNESS:
case HT_SKIDTRAP:
case HT_LANDMINE:
case HT_ANKLESNARE:
case HT_SHOCKWAVE:
case HT_SANDMAN:
case HT_FLASHER:
case HT_FREEZINGTRAP:
case HT_BLASTMINE:
case HT_CLAYMORETRAP:
case AS_VENOMDUST:
case AM_DEMONSTRATION:
case PF_FOGWALL:
case PF_SPIDERWEB:
case HT_TALKIEBOX:
case WE_CALLPARTNER:
case WE_CALLPARENT:
case WE_CALLBABY:
case AC_SHOWER: //Ground-placed skill implementation.
case SA_VOLCANO:
case SA_DELUGE:
case SA_VIOLENTGALE:
case SA_LANDPROTECTOR:
case BD_LULLABY:
case BD_RICHMANKIM:
case BD_ETERNALCHAOS:
case BD_DRUMBATTLEFIELD:
case BD_RINGNIBELUNGEN:
case BD_ROKISWEIL:
case BD_INTOABYSS:
case BD_SIEGFRIED:
case BA_DISSONANCE:
case BA_POEMBRAGI:
case BA_WHISTLE:
case BA_ASSASSINCROSS:
case BA_APPLEIDUN:
case DC_UGLYDANCE:
case DC_HUMMING:
case DC_DONTFORGETME:
case DC_FORTUNEKISS:
case DC_SERVICEFORYOU:
case GS_DESPERADO:
case NJ_SUITON:
case NJ_BAKUENRYU:
case NJ_KAENSIN:
case NJ_HYOUSYOURAKU:
case NJ_RAIGEKISAI:
flag|=1;//Set flag to 1 to prevent deleting ammo (it will be deleted on group-delete).
case GS_GROUNDDRIFT: //Ammo should be deleted right away.
skill_unitsetting(src,skillid,skilllv,x,y,0);
break;
case RG_GRAFFITI: /* Graffiti [Valaris] */
skill_clear_unitgroup(src);
skill_unitsetting(src,skillid,skilllv,x,y,0);
flag|=1;
break;
case RG_CLEANER: // [Valaris]
i = skill_get_splash(skillid, skilllv);
map_foreachinarea(skill_graffitiremover,src->m,x-i,y-i,x+i,y+i,BL_SKILL);
break;
case WZ_METEOR: //メテオストーム
{
int flag=0, area = skill_get_splash(skillid, skilllv);
short tmpx, tmpy, x1 = 0, y1 = 0;
if (sc && sc->data[SC_MAGICPOWER].timer != -1)
flag = flag|2; //Store the magic power flag for future use. [Skotlex]
for(i=0;i<2+(skilllv>>1);i++) {
tmpx = x;
tmpy = y;
if (!map_search_freecell(NULL, src->m, &tmpx, &tmpy, area, area, 1))
continue;
if(!(flag&1)){
clif_skill_poseffect(src,skillid,skilllv,tmpx,tmpy,tick);
flag=flag|1;
}
if(i > 0)
skill_addtimerskill(src,tick+i*1000,0,tmpx,tmpy,skillid,skilllv,(x1<<16)|y1,flag&2); //Only pass the Magic Power flag
x1 = tmpx;
y1 = tmpy;
}
skill_addtimerskill(src,tick+i*1000,0,tmpx,tmpy,skillid,skilllv,-1,flag&2); //Only pass the Magic Power flag
}
break;
case AL_WARP: /* ワープポータル */
if(sd) {
clif_skill_warppoint(sd,skillid,skilllv,mapindex_id2name(sd->status.save_point.map),
(skilllv>1 && sd->status.memo_point[0].map)?mapindex_id2name(sd->status.memo_point[0].map):"",
(skilllv>2 && sd->status.memo_point[1].map)?mapindex_id2name(sd->status.memo_point[1].map):"",
(skilllv>3 && sd->status.memo_point[2].map)?mapindex_id2name(sd->status.memo_point[2].map):"");
}
break;
case MO_BODYRELOCATION:
if (unit_movepos(src, x, y, 1, 1)) {
clif_skill_poseffect(src,skillid,skilllv,src->x,src->y,tick);
// clif_slide(src, src->x, src->y); //Poseffect is the one that makes the char snap on the client...
if (sd) skill_blockpc_start (sd, MO_EXTREMITYFIST, 2000);
}
break;
case AM_SPHEREMINE:
case AM_CANNIBALIZE:
if(sd) {
int summons[5] = { 1020, 1068, 1118, 1500, 1368 };
int class_ = skillid==AM_SPHEREMINE?1142:summons[skilllv-1];
struct mob_data *md;
// Correct info, don't change any of this! [celest]
md = mob_once_spawn_sub(src, src->m, -1, -1, sd->status.name,class_,"");
if (md) {
md->master_id = src->id;
md->special_state.ai = skillid==AM_SPHEREMINE?2:3;
md->deletetimer = add_timer (gettick() + skill_get_time(skillid,skilllv), mob_timer_delete, md->bl.id, 0);
mob_spawn (md); //Now it is ready for spawning.
}
}
break;
// Slim Pitcher [Celest]
case CR_SLIMPITCHER:
if (sd) {
int i = skilllv%11 - 1;
int j = pc_search_inventory(sd,skill_db[skillid].itemid[i]);
if(j < 0 || skill_db[skillid].itemid[i] <= 0 || sd->inventory_data[j] == NULL ||
sd->status.inventory[j].amount < skill_db[skillid].amount[i]) {
clif_skill_fail(sd,skillid,0,0);
return 1;
}
potion_flag = 1;
potion_hp = 0;
potion_sp = 0;
run_script(sd->inventory_data[j]->script,0,sd->bl.id,0);
pc_delitem(sd,j,skill_db[skillid].amount[i],0);
potion_flag = 0;
//Apply skill bonuses
i = pc_checkskill(sd,CR_SLIMPITCHER)*10
+ pc_checkskill(sd,AM_POTIONPITCHER)*10
+ pc_checkskill(sd,AM_LEARNINGPOTION)*5;
potion_hp = potion_hp * (100+i)/100;
potion_sp = potion_sp * (100+i)/100;
if(potion_hp > 0 || potion_sp > 0) {
i = skill_get_splash(skillid, skilllv);
map_foreachinarea(skill_area_sub,
src->m,x-i,y-i,x+i,y+i,BL_CHAR,
src,skillid,skilllv,tick,flag|BCT_PARTY|BCT_GUILD|1,
skill_castend_nodamage_id);
}
} else {
int i = skilllv%11 - 1;
struct item_data *item = itemdb_search(i);
i = skill_db[skillid].itemid[i];
item = itemdb_search(i);
potion_flag = 1;
potion_hp = 0;
potion_sp = 0;
run_script(item->script,0,src->id,0);
potion_flag = 0;
i = skill_get_max(CR_SLIMPITCHER)*10;
potion_hp = potion_hp * (100+i)/100;
potion_sp = potion_sp * (100+i)/100;
if(potion_hp > 0 || potion_sp > 0) {
i = skill_get_splash(skillid, skilllv);
map_foreachinarea(skill_area_sub,
src->m,x-i,y-i,x+i,y+i,BL_CHAR,
src,skillid,skilllv,tick,flag|BCT_PARTY|BCT_GUILD|1,
skill_castend_nodamage_id);
}
}
break;
case HW_GANBANTEIN:
if (rand()%100 < 80) {
clif_skill_poseffect(src,skillid,skilllv,x,y,tick);
i = skill_get_splash(skillid, skilllv);
map_foreachinarea (skill_ganbatein, src->m, x-i, y-i, x+i, y+i, BL_SKILL);
} else {
if (sd) clif_skill_fail(sd,skillid,0,0);
return 1;
}
break;
case HW_GRAVITATION:
sg = skill_unitsetting(src,skillid,skilllv,x,y,0);
sc_start4(src,type,100,skilllv,0,BCT_SELF,(int)sg,skill_get_time(skillid,skilllv));
flag|=1;
break;
// Plant Cultivation [Celest]
case CR_CULTIVATION:
if (sd) {
int i = skilllv - 1;
int j = pc_search_inventory(sd,skill_db[skillid].itemid[i]);
if(j < 0 || skill_db[skillid].itemid[i] <= 0 || sd->inventory_data[j] == NULL ||
sd->status.inventory[j].amount < skill_db[skillid].amount[i]) {
clif_skill_fail(sd,skillid,0,0);
return 1;
}
pc_delitem(sd,j,skill_db[skillid].amount[i],0);
clif_skill_poseffect(src,skillid,skilllv,x,y,tick);
if (rand()%100 < 50)
mob_once_spawn(sd, "this", x, y, "--ja--",(skilllv < 2 ? 1084+rand()%2 : 1078+rand()%6), 1, "");
else
clif_skill_fail(sd,skillid,0,0);
}
break;
case SG_SUN_WARM:
case SG_MOON_WARM:
case SG_STAR_WARM:
sg = skill_unitsetting(src,skillid,skilllv,src->x,src->y,0);
sc_start4(src,type,100,skilllv,0,0,(int)sg,skill_get_time(skillid,skilllv));
flag|=1;
break;
case PA_GOSPEL:
if (sc && sc->data[type].timer != -1 && sc->data[type].val4 == BCT_SELF)
status_change_end(src,SC_GOSPEL,-1);
else
{
sg = skill_unitsetting(src,skillid,skilllv,src->x,src->y,0);
if (sc && sc->data[type].timer != -1)
status_change_end(src,type,-1); //Was under someone else's Gospel. [Skotlex]
sc_start4(src,type,100,skilllv,0,(int)sg,BCT_SELF,skill_get_time(skillid,skilllv));
}
break;
case NJ_TATAMIGAESHI:
sc_start(src,type,100,skilllv,skill_get_time(skillid,skilllv));
skill_unitsetting(src,skillid,skilllv,src->x,src->y,0);
break;
default:
ShowWarning("skill_castend_pos2: Unknown skill used:%d\n",skillid);
return 1;
}
if (sc && sc->data[SC_MAGICPOWER].timer != -1)
status_change_end(&sd->bl,SC_MAGICPOWER,-1);
if (sd && !(flag&1) && sd->state.arrow_atk) //Consume arrow if a ground skill was not invoked. [Skotlex]
battle_consume_ammo(sd, skillid, skilllv);
return 0;
}
/*==========================================
* スキル使用（詠唱完了、map指定）
*------------------------------------------
*/
int skill_castend_map (struct map_session_data *sd, int skill_num, const char *map)
{
int x=0,y=0;
nullpo_retr(0, sd);
//Simplify skill_failed code.
#define skill_failed(sd) { sd->menuskill_id = sd->menuskill_lv = 0; }
if( sd->bl.prev == NULL || pc_isdead(sd) )
return 0;
if(sd->sc.opt1 || sd->sc.option&OPTION_HIDE ) {
skill_failed(sd);
return 0;
}
//スキルが使えない状態異常中
if(sd->sc.count && (
sd->sc.data[SC_SILENCE].timer!=-1 ||
sd->sc.data[SC_ROKISWEIL].timer!=-1 ||
sd->sc.data[SC_AUTOCOUNTER].timer != -1 ||
sd->sc.data[SC_STEELBODY].timer != -1 ||
sd->sc.data[SC_DANCING].timer!=-1 ||
sd->sc.data[SC_BERSERK].timer != -1 ||
sd->sc.data[SC_MARIONETTE].timer != -1
))
return 0;
if( skill_num != sd->menuskill_id) /* 不?ｳパケットらしい */
return 0;
if (strlen(map) > MAP_NAME_LENGTH-1)
{ //Map_length check, as it is sent by the client and we shouldn't trust it [Skotlex]
if (battle_config.error_log)
ShowError("skill_castend_map: Received map name '%s' too long!\n", map);
skill_failed(sd);
return 0;
}
pc_stop_attack(sd);
pc_stop_walking(sd,0);
if(battle_config.skill_log && battle_config.skill_log&BL_PC)
ShowInfo("PC %d skill castend skill =%d map=%s\n",sd->bl.id,skill_num,map);
if(strcmp(map,"cancel")==0) {
skill_failed(sd);
return 0;
}
switch(skill_num){
case AL_TELEPORT: /* テレポート */
if(strcmp(map,"Random")==0)
pc_randomwarp(sd,3);
else if (sd->menuskill_lv > 1) //Need lv2 to be able to warp here.
pc_setpos(sd,sd->status.save_point.map,
sd->status.save_point.x,sd->status.save_point.y,3);
break;
case AL_WARP: /* ワープポータル */
{
const struct point *p[4];
struct skill_unit_group *group;
int i, lv, wx, wy;
int maxcount=0;
unsigned short mapindex;
mapindex = mapindex_name2id((char*)map);
if(!mapindex) { //Given map not found?
clif_skill_fail(sd,skill_num,0,0);
skill_failed(sd);
return 0;
}
p[0] = &sd->status.save_point;
p[1] = &sd->status.memo_point[0];
p[2] = &sd->status.memo_point[1];
p[3] = &sd->status.memo_point[2];
if((maxcount = skill_get_maxcount(skill_num)) > 0) {
for(i=0;i<MAX_SKILLUNITGROUP && sd->ud.skillunit[i] && maxcount;i++) {
if(sd->ud.skillunit[i]->skill_id == skill_num)
maxcount--;
}
if(!maxcount) {
clif_skill_fail(sd,skill_num,0,0);
skill_failed(sd);
return 0;
}
}
//When it's an item-used warp-portal, the skill-lv used is lost.. assume max level.
lv = sd->skillitem==skill_num?skill_get_max(skill_num):pc_checkskill(sd,skill_num);
wx = sd->menuskill_lv>>16;
wy = sd->menuskill_lv&0xffff;
if(lv <= 0) return 0;
for(i=0;i<lv;i++){
if(mapindex == p[i]->map){
x=p[i]->x;
y=p[i]->y;
break;
}
}
if(x==0 || y==0) { /* 不正パケット？ */
skill_failed(sd);
return 0;
}
if(!skill_check_condition(sd, sd->menuskill_id, lv,3)) //This checks versus skillid/skilllv...
{
skill_failed(sd);
return 0;
}
if(skill_check_unit_range2(&sd->bl,wx,wy,skill_num,lv) > 0) {
clif_skill_fail(sd,0,0,0);
skill_failed(sd);
return 0;
}
if((group=skill_unitsetting(&sd->bl,skill_num,lv,wx,wy,0))==NULL) {
skill_failed(sd);
return 0;
}
//Now that there's a mapindex, use that in val3 rather than a string. [Skotlex]
group->val2=(x<<16)|y;
group->val3 = mapindex;
}
break;
}
sd->menuskill_id = sd->menuskill_lv = 0;
return 0;
#undef skill_failed
}
static int skill_dance_overlap_sub(struct block_list *bl, va_list ap)
{
struct skill_unit *target = (struct skill_unit*)bl,
*src = va_arg(ap, struct skill_unit*);
int flag = va_arg(ap, int);
if (!target || !target->group || !target->group->state.song_dance)
return 0;
if (!(target->val2 & src->val2 & ~UF_ENSEMBLE)) //They don't match (song + dance) is valid.
return 0;
if (flag) { //Set dissonance
target->val1 = src->val1 = target->val2&UF_SONG?BA_DISSONANCE:DC_UGLYDANCE;
target->val2 |= UF_ENSEMBLE; //Add ensemble to signal this unit is overlapping.
} else { //Remove dissonance
target->val1 = target->group->skill_id; //Restore skill id
target->val2 &= ~UF_ENSEMBLE;
}
clif_skill_setunit(target); //Update look of affected cell.
return 1;
}
//Does the song/dance overlapping -> dissonance check. [Skotlex]
//When flag is 0, this unit is about to be removed, cancel the dissonance effect
//When 1, this unit has been positioned, so start the cancel effect.
int skill_dance_overlap(struct skill_unit *unit, int flag)
{
if (!unit || !unit->group || !unit->group->state.song_dance)
return 0;
if (!flag && !(unit->val2&UF_ENSEMBLE))
return 0; //Nothing to remove, this unit is not overlapped.
if (unit->val1 != unit->group->skill_id)
{ //Reset state
unit->val1 = unit->group->skill_id;
unit->val2 &= ~UF_ENSEMBLE;
}
return map_foreachincell(skill_dance_overlap_sub,
unit->bl.m,unit->bl.x,unit->bl.y,BL_SKILL,unit,flag);
}
/*==========================================
* Initializes and sets a ground skill.
* flag&1 is used to determine when the skill 'morphs' (Warp portal becomes active, or Fire Pillar becomes active)
* flag&2 is used to determine if this skill was casted with Magic Power active.
*------------------------------------------
*/
struct skill_unit_group *skill_unitsetting (struct block_list *src, int skillid, int skilllv, int x, int y, int flag)
{
struct skill_unit_group *group;
int i,limit,val1=0,val2=0,val3=0;
int count=0;
int target,interval,range,unit_flag;
struct skill_unit_layout *layout;
struct map_session_data *sd;
struct status_data *status;
struct status_change *sc;
int active_flag=1;
nullpo_retr(0, src);
limit = skill_get_time(skillid,skilllv);
range = skill_get_unit_range(skillid,skilllv);
interval = skill_get_unit_interval(skillid);
target = skill_get_unit_target(skillid);
unit_flag = skill_get_unit_flag(skillid);
layout = skill_get_unit_layout(skillid,skilllv,src,x,y);
if (skillid == AL_WARP && flag && src->type == BL_SKILL)
{ //Warp Portal morphing to active mode, extract relevant data from src. [Skotlex]
group= ((TBL_SKILL*)src)->group;
src = map_id2bl(group->src_id);
if (!src) return NULL;
val2=group->val2; //Copy the (x,y) position you warp to
val3=group->val3; //as well as the mapindex to warp to.
}
BL_CAST(BL_PC, src, sd);
status = status_get_status_data(src);
sc= status_get_sc(src); // for traps, firewall and fogwall - celest
if (sc && !sc->count)
sc = NULL;
switch(skillid){ /* 設定 */
case MG_SAFETYWALL: /* セイフティウォール */
val2=skilllv+1;
break;
case MG_FIREWALL: /* ファイヤーウォール */
if(sc && sc->data[SC_VIOLENTGALE].timer!=-1)
limit = limit*3/2;
val2=4+skilllv;
break;
case AL_WARP: /* ワープポータル */
val1=skilllv+6;
if(!(flag&1))
limit=2000;
break;
case PR_SANCTUARY: /* サンクチュアリ */
val1=(skilllv+3)*2;
val2=(skilllv>6)?777:skilllv*100;
break;
case WZ_FIREPILLAR: /* ファイアーピラー */
if((flag&1)!=0)
limit=1000;
val1=skilllv+2;
break;
case WZ_QUAGMIRE: //The target changes to "all" if used in a gvg map. [Skotlex]
case AM_DEMONSTRATION:
if (map_flag_vs(src->m) && battle_config.vs_traps_bctall
&& (src->type&battle_config.vs_traps_bctall))
target = BCT_ALL;
break;
case HT_SHOCKWAVE: /* ショックウェーブトラップ */
val1=skilllv*15+10;
case HT_SANDMAN: /* サンドマン */
case HT_CLAYMORETRAP: /* クレイモアートラップ */
case HT_SKIDTRAP: /* スキッドトラップ */
case HT_LANDMINE: /* ランドマイン */
case HT_ANKLESNARE: /* アンクルスネア */
case HT_FLASHER: /* フラッシャー */
case HT_FREEZINGTRAP: /* フリージングトラップ */
case HT_BLASTMINE: /* ブラストマイン */
if (map_flag_gvg(src->m))
limit *= 4; // longer trap times in WOE [celest]
if (battle_config.vs_traps_bctall && map_flag_vs(src->m)
&& (src->type&battle_config.vs_traps_bctall))
target = BCT_ALL;
break;
case SA_LANDPROTECTOR: /* ランドプロテクター */
{
int aoe_diameter; // -- aoe_diameter (moonsoul) added for sage Area Of Effect skills
val1=skilllv*15+10;
aoe_diameter=skilllv+skilllv%2+5;
count=aoe_diameter*aoe_diameter; // -- this will not function if changed to ^2 (moonsoul)
}
//No break because we also have to check if we use gemstones. [Skotlex]
case SA_VOLCANO:
case SA_DELUGE:
case SA_VIOLENTGALE:
{
struct skill_unit_group *old_sg;
if ((old_sg = skill_locate_element_field(src)) != NULL)
{
if (old_sg->skill_id == skillid && old_sg->limit > 0)
{ //Use the previous limit (minus the elapsed time) [Skotlex]
limit = old_sg->limit - DIFF_TICK(gettick(), old_sg->tick);
if (limit < 0) //This can happen...
limit = skill_get_time(skillid,skilllv);
}
skill_clear_group(src,1);
}
break;
}
case BA_DISSONANCE:
case DC_UGLYDANCE:
val1 = 10; //FIXME: This value is not used anywhere, what is it for? [Skotlex]
break;
case BA_WHISTLE:
val1 = skilllv +status->agi/10; // Flee increase
val2 = ((skilllv+1)/2)+status->luk/10; // Perfect dodge increase
if(sd){
val1 += pc_checkskill(sd,BA_MUSICALLESSON);
val2 += pc_checkskill(sd,BA_MUSICALLESSON);
}
break;
case DC_HUMMING:
val1 = 2*skilllv+status->dex/10; // Hit increase
if(sd)
val1 += 2*pc_checkskill(sd,DC_DANCINGLESSON);
break;
case BA_POEMBRAGI:
val1 = 3*skilllv+status->dex/10; // Casting time reduction
//For some reason at level 10 the base delay reduction is 50%.
val2 = (skilllv<10?3*skilllv:50)+status->int_/10; // After-cast delay reduction
if(sd){
val1 += pc_checkskill(sd,BA_MUSICALLESSON);
val2 += pc_checkskill(sd,BA_MUSICALLESSON);
}
break;
case DC_DONTFORGETME:
val1 = 30*skilllv+status->dex; // ASPD decrease
val2 = 100+2*skilllv+status->agi/10; // Movement speed adjustment.
if(sd){
val1 += pc_checkskill(sd,DC_DANCINGLESSON);
val2 += pc_checkskill(sd,DC_DANCINGLESSON);
}
break;
case BA_APPLEIDUN:
val1 = 5+2*skilllv+status->vit/10; // MaxHP percent increase
val2 = 30+5*skilllv+5*(status->vit/10); // HP recovery
if(sd){
val1 += pc_checkskill(sd,BA_MUSICALLESSON);
val2 += 5*pc_checkskill(sd,BA_MUSICALLESSON);
}
break;
case DC_SERVICEFORYOU:
val1 = 10+skilllv+(status->int_/10); // MaxSP percent increase
val2 = 10+3*skilllv+(status->int_/10); // SP cost reduction
if(sd){
val1 += pc_checkskill(sd,DC_DANCINGLESSON);
val2 += pc_checkskill(sd,DC_DANCINGLESSON);
}
break;
case BA_ASSASSINCROSS:
val1 = 100+10*skilllv+status->agi; // ASPD increase
if(sd)
val1 += pc_checkskill(sd,BA_MUSICALLESSON);
break;
case DC_FORTUNEKISS:
val1 = 10+skilllv+(status->luk/10); // Critical increase
if(sd)
val1 += pc_checkskill(sd,DC_DANCINGLESSON);
val1*=10; //Because every 10 crit is an actual cri point.
break;
case BD_DRUMBATTLEFIELD:
val1 = (skilllv+1)*25; //Watk increase
val2 = (skilllv+1)*2; //Def increase
break;
case BD_RINGNIBELUNGEN:
val1 = (skilllv+2)*25; //Watk increase
break;
case BD_RICHMANKIM:
val1 = 25 + 11*skilllv; //Exp increase bonus.
break;
case BD_SIEGFRIED:
val1 = 55 + skilllv*5; //Elemental Resistance
val2 = skilllv*10; //Status ailment resistance
break;
case PF_FOGWALL: /* フォグウォール */
if(sc && sc->data[SC_DELUGE].timer!=-1) limit *= 2;
break;
case RG_GRAFFITI: /* Graffiti */
count=1; // Leave this at 1 [Valaris]
break;
case WE_CALLPARTNER:
if (sd) val1 = sd->status.partner_id;
break;
case WE_CALLPARENT:
if (sd) {
val1 = sd->status.father;
val2 = sd->status.mother;
}
break;
case WE_CALLBABY:
if (sd) val1 = sd->status.child;
break;
case NJ_KAENSIN:
val1 = skilllv;
val2 = (skilllv+1)/2 + 4;
break;
case NJ_BAKUENRYU:
val1 = 3;
break;
case GS_GROUNDDRIFT:
{ //Take on the base element, not the elemental one.
struct status_data *bstatus = status_get_base_status(src);
val1 = bstatus?bstatus->rhw.ele:status->rhw.ele;
if (sd) sd->state.arrow_atk = 0; //Disable consumption right away.
else if (!val1) val1 = ELE_WATER+rand()%(ELE_WIND-ELE_WATER);
break;
}
}
nullpo_retr(NULL, group=skill_initunitgroup(src,(count > 0 ? count : layout->count),
skillid,skilllv,skill_get_unit_id(skillid,flag&1), limit, interval));
group->val1=val1;
group->val2=val2;
group->val3=val3;
group->target_flag=target;
group->bl_flag= skill_get_unit_bl_target(skillid);
group->state.into_abyss = (sc && sc->data[SC_INTOABYSS].timer != -1); //Store into abyss state, to know it shouldn't give traps back. [Skotlex]
group->state.magic_power = (flag&2 || (sc && sc->data[SC_MAGICPOWER].timer != -1)); //Store the magic power flag. [Skotlex]
group->state.ammo_consume = (sd && sd->state.arrow_atk); //Store if this skill needs to consume ammo.
group->state.song_dance = (unit_flag&(UF_DANCE|UF_SONG)); //Signals if this is a song/dance (does not counts duets)
//if tick is greater than current, do not invoke onplace function just yet. [Skotlex]
if (DIFF_TICK(group->tick, gettick()) > 100)
active_flag = 0;
if(skillid==HT_TALKIEBOX ||
skillid==RG_GRAFFITI){
group->valstr=(char *) aMallocA(MESSAGE_SIZE*sizeof(char));
if(group->valstr==NULL){
ShowFatalError("skill_castend_map: out of memory !\n");
exit(1);
}
memcpy(group->valstr,talkie_mes,MESSAGE_SIZE-1);
group->valstr[MESSAGE_SIZE-1] = '\0';
}
//Why redefine local variables when the ones of the function can be reused? [Skotlex]
val1=skilllv;
val2=0;
limit=group->limit;
count=group->unit_count;
for(i=0;i<count;i++){
struct skill_unit *unit;
int ux,uy,alive=1;
ux = x + layout->dx[i];
uy = y + layout->dy[i];
switch (skillid) {
case MG_FIREWALL: /* ファイヤーウォール */
val2=group->val2;
break;
case WZ_ICEWALL: /* アイスウォール */
if(skilllv <= 1)
val1 = 500;
else
val1 = 200 + 200*skilllv;
break;
case RG_GRAFFITI: /* Graffiti [Valaris] */
ux+=(i%5-2);
uy+=(i/5-2);
break;
default:
if (group->state.song_dance) {
val1 = skillid; //Holds SKILL id to use.
val2 = unit_flag&(UF_DANCE|UF_SONG); //Store whether this is a song/dance
}
break;
}
//直上スキルの場合設置座標上にランドプロテクターがないかチェック
if(range<=0)
map_foreachincell(skill_landprotector,src->m,ux,uy,BL_SKILL,skillid,&alive, src);
if(alive && map_getcell(src->m,ux,uy,CELL_CHKWALL))
alive = 0;
if (alive && battle_config.skill_wall_check) {
//Check if there's a path between cell and center of casting.
if (!path_search_long(NULL,src->m,ux,uy,x,y))
alive = 0;
}
if(alive && skillid == WZ_ICEWALL) {
if(src->x == x && src->y==y) // Ice Wall not allowed on self [DracoRPG]
alive=0;
else {
val2=map_getcell(src->m,ux,uy,CELL_GETTYPE);
if(val2==5 || val2==1)
alive=0;
else
clif_changemapcell(src->m,ux,uy,5,0);
}
}
if(alive){
nullpo_retr(NULL, unit=skill_initunit(group,i,ux,uy,val1,val2));
unit->limit=limit;
unit->range=range;
if (range==0 && active_flag)
map_foreachincell(skill_unit_effect,unit->bl.m,
unit->bl.x,unit->bl.y,group->bl_flag,&unit->bl,gettick(),1);
}
}
return group;
}
/*==========================================
* スキルユニットの発動イベント
*------------------------------------------
*/
int skill_unit_onplace (struct skill_unit *src, struct block_list *bl, unsigned int tick)
{
struct skill_unit_group *sg;
struct block_list *ss;
struct status_change *sc;
int type,skillid;
nullpo_retr(0, src);
nullpo_retr(0, bl);
if(bl->prev==NULL || !src->alive || status_isdead(bl))
return 0;
nullpo_retr(0, sg=src->group);
nullpo_retr(0, ss=map_id2bl(sg->src_id));
if (skill_get_type(sg->skill_id) == BF_MAGIC &&
map_getcell(bl->m, bl->x, bl->y, CELL_CHKLANDPROTECTOR))
return 0; //AoE skills are ineffective. [Skotlex]
if (battle_check_target(&src->bl,bl,sg->target_flag)<=0)
return 0;
sc = status_get_sc(bl);
if (sc && sc->option&OPTION_HIDE && sg->skill_id != WZ_HEAVENDRIVE)
return 0; //Hidden characters are inmune to AoE skills except Heaven's Drive. [Skotlex]
type = SkillStatusChangeTable(sg->skill_id);
skillid = sg->skill_id; //In case the group is deleted, we need to return the correct skill id, still.
switch (sg->unit_id) {
case UNT_SAFETYWALL:
//TODO: Find a more reliable way to handle the link to sg, this could cause dangling pointers. [Skotlex]
if (sc && sc->data[type].timer == -1)
sc_start4(bl,type,100,sg->skill_lv,sg->group_id,(int)sg,0,sg->limit);
break;
case UNT_WARP_WAITING:
if(bl->type==BL_PC){
struct map_session_data *sd = (struct map_session_data *)bl;
if((!sd->chatID || battle_config.chat_warpportal)
&& sd->ud.to_x == src->bl.x && sd->ud.to_y == src->bl.y) {
if (pc_setpos(sd,sg->val3,sg->val2>>16,sg->val2&0xffff,3) == 0) {
if (--sg->val1<=0 || sg->src_id == bl->id)
skill_delunitgroup(NULL, sg);
}
}
} else if(battle_config.mob_warpportal && bl->type != BL_PET)
unit_warp(bl,map_mapindex2mapid(sg->val3),sg->val2>>16,sg->val2&0xffff,3);
break;
case UNT_QUAGMIRE:
if(sc && sc->data[type].timer==-1)
sc_start4(bl,type,100,sg->skill_lv,sg->group_id,0,0,sg->limit);
break;
case UNT_VOLCANO:
case UNT_DELUGE:
case UNT_VIOLENTGALE:
case UNT_SUITON:
if(sc && sc->data[type].timer==-1)
sc_start(bl,type,100,sg->skill_lv,skill_get_time2(sg->skill_id,sg->skill_lv));
break;
case UNT_RICHMANKIM:
case UNT_ETERNALCHAOS:
case UNT_DRUMBATTLEFIELD:
case UNT_RINGNIBELUNGEN:
case UNT_ROKISWEIL:
case UNT_INTOABYSS:
case UNT_SIEGFRIED:
case UNT_HERMODE:
//Needed to check when a dancer/bard leaves their ensemble area.
if (sg->src_id==bl->id && (!sc || sc->data[SC_SPIRIT].timer == -1 || sc->data[SC_SPIRIT].val2 != SL_BARDDANCER))
return sg->skill_id;
if (sc && sc->data[type].timer==-1)
sc_start4(bl,type,100,sg->skill_lv,sg->val1,sg->val2,0,sg->limit);
break;
case UNT_WHISTLE:
case UNT_ASSASSINCROSS:
case UNT_POEMBRAGI:
case UNT_APPLEIDUN:
case UNT_HUMMING:
case UNT_DONTFORGETME:
case UNT_FORTUNEKISS:
case UNT_SERVICEFORYOU:
if (sg->src_id==bl->id && (!sc || sc->data[SC_SPIRIT].timer == -1 || sc->data[SC_SPIRIT].val2 != SL_BARDDANCER))
return 0;
if (!sc) return 0;
if (sc->data[type].timer==-1)
sc_start4(bl,type,100,sg->skill_lv,sg->val1,sg->val2,0,sg->limit);
else if (sc->data[type].val4 == 1) {
//Readjust timers since the effect will not last long.
sc->data[type].val4 = 0;
delete_timer(sc->data[type].timer, status_change_timer);
sc->data[type].timer = add_timer(tick+sg->limit, status_change_timer, bl->id, type);
}
break;
case UNT_FOGWALL:
if (sc && sc->data[type].timer==-1)
{
sc_start4(bl, type, 100, sg->skill_lv, sg->val1, sg->val2, sg->group_id, sg->limit);
if (battle_check_target(&src->bl,bl,BCT_ENEMY)>0)
skill_additional_effect (ss, bl, sg->skill_id, sg->skill_lv, BF_MISC, tick);
}
break;
case UNT_GRAVITATION:
if (sc && sc->data[type].timer==-1)
sc_start4(bl,type,100,sg->skill_lv,0,BCT_ENEMY,sg->group_id,sg->limit);
break;
case UNT_ICEWALL: //Destroy the cell. [Skotlex]
src->val1 = 0;
if(src->limit + sg->tick > tick + 700)
src->limit = DIFF_TICK(tick+700,sg->tick);
break;
}
return skillid;
}
/*==========================================
* スキルユニットの発動イベント(タイマー発動)
*------------------------------------------
*/
int skill_unit_onplace_timer (struct skill_unit *src, struct block_list *bl, unsigned int tick)
{
struct skill_unit_group *sg;
struct block_list *ss;
struct map_session_data *sd;
struct status_data *tstatus, *sstatus;
struct status_change *tsc, *sc;
struct skill_unit_group_tickset *ts;
int matk_min = 0, matk_max = 0; //For Magic power...
int type, skillid;
int diff=0;
nullpo_retr(0, src);
nullpo_retr(0, bl);
if (bl->prev==NULL || !src->alive || status_isdead(bl))
return 0;
nullpo_retr(0, sg=src->group);
nullpo_retr(0, ss=map_id2bl(sg->src_id));
BL_CAST(BL_PC, ss, sd);
tsc = status_get_sc(bl);
tstatus = status_get_status_data(bl);
if (sg->state.magic_power) //For magic power.
{
sc = status_get_sc(ss);
sstatus = status_get_status_data(ss);
} else {
sc = NULL;
sstatus = NULL;
}
type = SkillStatusChangeTable(sg->skill_id);
skillid = sg->skill_id;
if (sg->state.song_dance && src->val2&UF_ENSEMBLE)
{ //Treat this group as if it were BA_DISSONANCE/DC_UGLYDANCE.
//Values will be restored on proper switch case.
src->val1 = sg->unit_id;
if (src->val2&UF_SONG) {
sg->unit_id = UNT_DISSONANCE;
sg->skill_id = BA_DISSONANCE;
} else {
sg->unit_id = UNT_UGLYDANCE;
sg->skill_id = DC_UGLYDANCE;
}
}
if (sg->interval == -1) {
switch (sg->unit_id) {
case UNT_ANKLESNARE: //These happen when a trap is splash-triggered by multiple targets on the same cell.
case UNT_SPIDERWEB:
case UNT_FIREPILLAR_ACTIVE:
return 0;
default:
if (battle_config.error_log)
ShowError("skill_unit_onplace_timer: interval error (unit id %x)\n", sg->unit_id);
return 0;
}
}
if ((ts = skill_unitgrouptickset_search(bl,sg,tick)))
{ //Not all have it, eg: Traps don't have it even though they can be hit by Heaven's Drive [Skotlex]
diff = DIFF_TICK(tick,ts->tick);
if (diff < 0)
return 0;
ts->tick = tick+sg->interval;
// GXは重なっていたら3HITしない
if ((skillid==CR_GRANDCROSS || skillid==NPC_GRANDDARKNESS) && !battle_config.gx_allhit)
ts->tick += sg->interval*(map_count_oncell(bl->m,bl->x,bl->y,0)-1);
}
//Temporarily set magic power to have it take effect. [Skotlex]
if (sg->state.magic_power && sc && sc->data[SC_MAGICPOWER].timer == -1)
{ //Store previous values.
matk_min = sstatus->matk_min;
matk_max = sstatus->matk_max;
//Note to NOT return from the function until this is unset!
sstatus->matk_min = sc->data[SC_MAGICPOWER].val3;
sstatus->matk_max = sc->data[SC_MAGICPOWER].val4;
}
switch (sg->unit_id)
{
case UNT_FIREWALL:
{
int count=0;
if (tstatus->def_ele == ELE_FIRE || battle_check_undead(tstatus->race, tstatus->def_ele)) {
//This is the best Aegis approximation we can do without
//changing the minimum skill unit interval. [Skotlex]
while (count++ < battle_config.firewall_hits_on_undead && src->val2-- && !status_isdead(bl))
skill_attack(BF_MAGIC,ss,&src->bl,bl,sg->skill_id,sg->skill_lv,tick+count*10,1);
} else {
skill_attack(BF_MAGIC,ss,&src->bl,bl,sg->skill_id,sg->skill_lv,tick,0);
src->val2--;
}
if (src->val2<=0)
skill_delunit(src);
break;
}
case UNT_SANCTUARY:
if (battle_check_undead(tstatus->race, tstatus->def_ele) || tstatus->race==RC_DEMON)
{ //Only damage enemies with offensive Sanctuary. [Skotlex]
if(battle_check_target(&src->bl,bl,BCT_ENEMY)>0 &&
skill_attack(BF_MAGIC, ss, &src->bl, bl, sg->skill_id, sg->skill_lv, tick, 0))
// reduce healing count if this was meant for damaging [hekate]
sg->val1 -= 2;
} else {
int heal = sg->val2;
if (tstatus->hp >= tstatus->max_hp)
break;
if (status_isimmune(bl))
heal = 0; /* 黄金蟲カード（ヒール量０） */
clif_skill_nodamage(&src->bl, bl, AL_HEAL, heal, 1);
status_heal(bl, heal, 0, 0);
if (diff >= 500)
sg->val1--;
}
if (sg->val1 <= 0)
skill_delunitgroup(NULL,sg);
break;
case UNT_MAGNUS:
if (!battle_check_undead(tstatus->race,tstatus->def_ele) && tstatus->race!=RC_DEMON)
break;
skill_attack(BF_MAGIC,ss,&src->bl,bl,sg->skill_id,sg->skill_lv,tick,0);
break;
case UNT_ATTACK_SKILLS:
switch (sg->skill_id)
{
case SG_SUN_WARM: //SG skills [Komurka]
case SG_MOON_WARM:
case SG_STAR_WARM:
if(bl->type==BL_PC)
//Only damage SP [Skotlex]
status_zap(bl, 0, 60);
else if(status_charge(bl, 0, 2))
//Otherwise, Knockback attack.
skill_attack(BF_WEAPON,ss,&src->bl,bl,sg->skill_id,sg->skill_lv,tick,0);
break;
default:
skill_attack(skill_get_type(sg->skill_id),ss,&src->bl,bl,sg->skill_id,sg->skill_lv,tick,0);
}
break;
case UNT_FIREPILLAR_WAITING:
skill_unitsetting(ss,sg->skill_id,sg->skill_lv,src->bl.x,src->bl.y,1);
skill_delunit(src);
break;
case UNT_FIREPILLAR_ACTIVE:
map_foreachinrange(skill_attack_area,bl,
skill_get_splash(sg->skill_id, sg->skill_lv), sg->bl_flag,
BF_MAGIC,ss,&src->bl,sg->skill_id,sg->skill_lv,tick,0,BCT_ENEMY); // area damage [Celest]
sg->interval = -1; //Mark it used up so others can't trigger it for massive splash damage. [Skotlex]
sg->limit=DIFF_TICK(tick,sg->tick) + 1500;
break;
case UNT_SKIDTRAP:
{
skill_blown(&src->bl,bl,skill_get_blewcount(sg->skill_id,sg->skill_lv)|0x10000);
sg->unit_id = UNT_USED_TRAPS;
clif_changetraplook(&src->bl, UNT_USED_TRAPS);
sg->limit=DIFF_TICK(tick,sg->tick)+1500;
sg->state.into_abyss = 1; //Prevent Remove Trap from giving you the trap back. [Skotlex]
}
break;
case UNT_SPIDERWEB:
case UNT_ANKLESNARE:
if(sg->val2==0 && tsc && tsc->data[type].timer==-1){
int sec = skill_get_time2(sg->skill_id,sg->skill_lv);
if (sc_start(bl,type,100,sg->skill_lv,sec))
{
struct TimerData* td = get_timer(tsc->data[type].timer);
if (td) sec = DIFF_TICK(td->tick, tick);
map_moveblock(bl, src->bl.x, src->bl.y, tick);
clif_fixpos(bl);
sg->val2=bl->id;
} else
sec = 3000; //Couldn't trap it?
//clif_01ac(&src->bl); //Removed? Check the openkore description of this packet: [Skotlex]
// 01AC: long ID
// Indicates that an object is trapped, but ID is not a
// valid monster or player ID.
sg->limit = DIFF_TICK(tick,sg->tick)+sec;
sg->interval = -1;
src->range = 0;
}
break;
case UNT_VENOMDUST:
if(tsc && tsc->data[type].timer==-1 )
status_change_start(bl,type,10000,sg->skill_lv,sg->group_id,0,0,skill_get_time2(sg->skill_id,sg->skill_lv),8);
break;
case UNT_LANDMINE:
skill_attack(BF_MISC,ss,&src->bl,bl,sg->skill_id,sg->skill_lv,tick,0);
sg->unit_id = UNT_USED_TRAPS;
clif_changetraplook(&src->bl, UNT_FIREPILLAR_ACTIVE);
sg->limit=DIFF_TICK(tick,sg->tick)+1500;
sg->state.into_abyss = 1; //Prevent Remove Trap from giving you the trap back. [Skotlex]
break;
case UNT_CLAYMORETRAP:
case UNT_BLASTMINE:
//Hold number of targets (required for damage calculation)
type = map_foreachinrange(skill_count_target,&src->bl,
skill_get_splash(sg->skill_id, sg->skill_lv), sg->bl_flag, &src->bl);
case UNT_SHOCKWAVE:
case UNT_SANDMAN:
case UNT_FLASHER:
case UNT_FREEZINGTRAP:
map_foreachinrange(skill_trap_splash,&src->bl,
skill_get_splash(sg->skill_id, sg->skill_lv), sg->bl_flag,
&src->bl,tick,type);
sg->unit_id = UNT_USED_TRAPS;
clif_changetraplook(&src->bl, UNT_USED_TRAPS);
sg->limit=DIFF_TICK(tick,sg->tick)+1500;
sg->state.into_abyss = 1; //Prevent Remove Trap from giving you the trap back. [Skotlex]
break;
case UNT_TALKIEBOX:
if (sg->src_id == bl->id) //自分が踏んでも発動しない
break;
if (sg->val2 == 0){
clif_talkiebox(&src->bl, sg->valstr);
sg->unit_id = UNT_USED_TRAPS;
clif_changetraplook(&src->bl, UNT_USED_TRAPS);
sg->limit = DIFF_TICK(tick, sg->tick) + 5000;
sg->val2 = -1; //踏んだ
sg->state.into_abyss = 1; //Prevent Remove Trap from giving you the trap back. [Skotlex]
}
break;
case UNT_LULLABY:
if (ss->id == bl->id)
break;
skill_additional_effect(ss, bl, sg->skill_id, sg->skill_lv, BF_LONG|BF_SKILL|BF_MISC, tick);
break;
case UNT_UGLYDANCE: //Ugly Dance [Skotlex]
if (ss->id != bl->id && bl->type == BL_PC)
skill_additional_effect(ss, bl, sg->skill_id, sg->skill_lv, BF_LONG|BF_SKILL|BF_MISC, tick);
if (sg->state.song_dance && src->val2&UF_ENSEMBLE)
{ //Restore values.
sg->skill_id = skillid;
sg->unit_id = src->val1;
src->val1 = DC_UGLYDANCE;
}
break;
case UNT_DISSONANCE:
skill_attack(BF_MISC, ss, &src->bl, bl, sg->skill_id, sg->skill_lv, tick, 0);
if (sg->state.song_dance && src->val2&UF_ENSEMBLE)
{ //Restore values.
sg->skill_id = skillid;
sg->unit_id = src->val1;
src->val1 = BA_DISSONANCE;
}
break;
case UNT_APPLEIDUN: //Apple of Idun [Skotlex]
{
int heal;
if (sg->src_id == bl->id)
break;
heal = sg->val2;
clif_skill_nodamage(&src->bl, bl, AL_HEAL, heal, 1);
status_heal(bl, heal, 0, 0);
break;
}
case UNT_TATAMIGAESHI:
case UNT_DEMONSTRATION:
skill_attack(BF_WEAPON,ss,&src->bl,bl,sg->skill_id,sg->skill_lv,tick,0);
break;
case UNT_GOSPEL:
if (rand()%100 > sg->skill_lv*10)
break;
if (ss != bl && battle_check_target(ss,bl,BCT_PARTY)>0) { // Support Effect only on party, not guild
int i = rand()%13; // Positive buff count
switch (i)
{
case 0: // Heal 1~9999 HP
{
int heal = rand() %9999+1;
clif_skill_nodamage(ss,bl,AL_HEAL,heal,1);
status_heal(bl,heal,0,0);
}
break;
case 1: // End all negative status
status_change_clear_buffs(bl,2);
break;
case 2: // Level 10 Blessing
sc_start(bl,SC_BLESSING,100,10,skill_get_time2(sg->skill_id, sg->skill_lv));
break;
case 3: // Level 10 Increase AGI
sc_start(bl,SC_INCREASEAGI,100,10,skill_get_time2(sg->skill_id, sg->skill_lv));
break;
case 4: // Enchant weapon with Holy element
sc_start(bl,SC_ASPERSIO,100,1,skill_get_time2(sg->skill_id, sg->skill_lv));
break;
case 5: // Enchant armor with Holy element
sc_start(bl,SC_BENEDICTIO,100,1,skill_get_time2(sg->skill_id, sg->skill_lv));
break;
case 6: // MaxHP +100%
sc_start(bl,SC_INCMHPRATE,100,100,skill_get_time2(sg->skill_id, sg->skill_lv));
break;
case 7: // MaxSP +100%
sc_start(bl,SC_INCMSPRATE,100,100,skill_get_time2(sg->skill_id, sg->skill_lv));
break;
case 8: // All stats +20
sc_start(bl,SC_INCALLSTATUS,100,20,skill_get_time2(sg->skill_id, sg->skill_lv));
break;
case 9: // DEF +25%
sc_start(bl,SC_INCDEFRATE,100,25,skill_get_time2(sg->skill_id, sg->skill_lv));
break;
case 10: // ATK +100%
sc_start(bl,SC_INCATKRATE,100,100,skill_get_time2(sg->skill_id, sg->skill_lv));
break;
case 11: // HIT/Flee +50
sc_start(bl,SC_INCHIT,100,50,skill_get_time2(sg->skill_id, sg->skill_lv));
sc_start(bl,SC_INCFLEE,100,50,skill_get_time2(sg->skill_id, sg->skill_lv));
break;
case 12: // Immunity to all status
sc_start(bl,SC_SCRESIST,100,100,skill_get_time2(sg->skill_id, sg->skill_lv));
break;
}
}
else if (battle_check_target(&src->bl,bl,BCT_ENEMY)>0) { // Offensive Effect
int i = rand()%9; // Negative buff count
switch (i)
{
case 0: // Deal 1~9999 damage
skill_attack(BF_MISC,ss,&src->bl,bl,sg->skill_id,sg->skill_lv,tick,0);
break;
case 1: // Curse
sc_start(bl,SC_CURSE,100,1,skill_get_time2(sg->skill_id, sg->skill_lv));
break;
case 2: // Blind
sc_start(bl,SC_BLIND,100,1,skill_get_time2(sg->skill_id, sg->skill_lv));
break;
case 3: // Poison
sc_start(bl,SC_POISON,100,1,skill_get_time2(sg->skill_id, sg->skill_lv));
break;
case 4: // Level 10 Provoke
sc_start(bl,SC_PROVOKE,100,10,skill_get_time2(sg->skill_id, sg->skill_lv));
break;
case 5: // DEF -100%
sc_start(bl,SC_INCDEFRATE,100,-100,skill_get_time2(sg->skill_id, sg->skill_lv));
break;
case 6: // ATK -100%
sc_start(bl,SC_INCATKRATE,100,-100,skill_get_time2(sg->skill_id, sg->skill_lv));
break;
case 7: // Flee -100%
sc_start(bl,SC_INCFLEERATE,100,-100,skill_get_time2(sg->skill_id, sg->skill_lv));
break;
case 8: // Speed/ASPD -25%
sc_start4(bl,SC_GOSPEL,100,1,0,0,BCT_ENEMY,skill_get_time2(sg->skill_id, sg->skill_lv));
break;
}
}
break;
case UNT_GRAVITATION:
skill_attack(BF_MAGIC,ss,&src->bl,bl,sg->skill_id,sg->skill_lv,tick,0);
break;
case UNT_DESPERADO:
if (!(rand()%10)) //Has a low chance of connecting. [Skotlex]
skill_attack(BF_WEAPON,ss,&src->bl,bl,sg->skill_id,sg->skill_lv,tick,0);
break;
case UNT_GROUNDDRIFT:
skill_attack(BF_WEAPON,ss,&src->bl,bl,sg->skill_id,sg->skill_lv,tick,sg->val1);
break;
case UNT_KAENSIN:
skill_attack(BF_MAGIC,ss,&src->bl,bl,sg->skill_id,sg->skill_lv,tick,0);
src->val2--;
if (--src->val2<=0)
skill_delunit(src);
break;
}
if (sg->state.magic_power && sc && sc->data[SC_MAGICPOWER].timer == -1)
{ //Unset magic power.
sstatus->matk_min = matk_min;
sstatus->matk_max = matk_max;
}
if (bl->type == BL_MOB && ss != bl)
mobskill_event((TBL_MOB*)bl, ss, tick, MSC_SKILLUSED|(skillid<<16));
return skillid;
}
/*==========================================
* スキルユニットから離脱する(もしくはしている)場合
*------------------------------------------
*/
int skill_unit_onout (struct skill_unit *src, struct block_list *bl, unsigned int tick)
{
struct skill_unit_group *sg;
struct status_change *sc;
int type;
nullpo_retr(0, src);
nullpo_retr(0, bl);
nullpo_retr(0, sg=src->group);
sc = status_get_sc(bl);
if (sc && !sc->count)
sc = NULL;
type = SkillStatusChangeTable(sg->skill_id);
if (bl->prev==NULL || !src->alive || //Need to delete the trap if the source died.
(status_isdead(bl) && sg->unit_id != UNT_ANKLESNARE && sg->unit_id != UNT_SPIDERWEB))
return 0;
switch(sg->unit_id){
case UNT_SAFETYWALL:
if (sc && sc->data[type].timer!=-1)
status_change_end(bl,type,-1);
break;
case UNT_ANKLESNARE:
{
struct block_list *target = map_id2bl(sg->val2);
if(target && target == bl){
status_change_end(bl,SC_ANKLE,-1);
sg->limit=DIFF_TICK(tick,sg->tick)+1000;
sg->state.into_abyss = 1; //Prevent Remove Trap from giving you the trap back. [Skotlex]
}
else
return 0;
break;
}
case UNT_BASILICA: //Clear basilica if the owner moved [Skotlex]
case UNT_HERMODE: //Clear Hermode if the owner moved.
if (sc && sc->data[type].timer!=-1 && sc->data[type].val3 == BCT_SELF && sc->data[type].val4 == sg->group_id)
status_change_end(bl,type,-1);
break;
case UNT_SPIDERWEB: /* スパイダーウェッブ */
{
struct block_list *target = map_id2bl(sg->val2);
if (target && target==bl)
{
status_change_end(bl,SC_SPIDERWEB,-1);
sg->limit = DIFF_TICK(tick,sg->tick)+1000;
}
break;
}
}
return sg->skill_id;
}
/*==========================================
* Triggered when a char steps out of a skill group [Skotlex]
*------------------------------------------
*/
static int skill_unit_onleft (int skill_id, struct block_list *bl, unsigned int tick)
{
struct status_change *sc;
int type;
sc = status_get_sc(bl);
if (sc && !sc->count)
sc = NULL;
type = SkillStatusChangeTable(skill_id);
switch (skill_id)
{
case WZ_QUAGMIRE:
if (bl->type==BL_MOB)
break;
if (sc && sc->data[type].timer != -1)
status_change_end(bl, type, -1);
break;
case BD_LULLABY:
case BD_RICHMANKIM:
case BD_ETERNALCHAOS:
case BD_DRUMBATTLEFIELD:
case BD_RINGNIBELUNGEN:
case BD_ROKISWEIL:
case BD_INTOABYSS:
case BD_SIEGFRIED:
if(sc && sc->data[SC_DANCING].timer != -1 && sc->data[SC_DANCING].val1 == skill_id)
{ //Check if you just stepped out of your ensemble skill to cancel dancing. [Skotlex]
//We don't check for SC_LONGING because someone could always have knocked you back and out of the song/dance.
//FIXME: This code is not perfect, it doesn't checks for the real ensemble's owner,
//it only checks if you are doing the same ensemble. So if there's two chars doing an ensemble
//which overlaps, by stepping outside of the other parther's ensemble will cause you to cancel
//your own. Let's pray that scenario is pretty unlikely and noone will complain too much about it.
skill_stop_dancing(bl);
}
case MG_SAFETYWALL:
case AL_PNEUMA:
case SA_VOLCANO:
case SA_DELUGE:
case SA_VIOLENTGALE:
case CG_HERMODE:
case HW_GRAVITATION:
case NJ_SUITON:
if (sc && sc->data[type].timer != -1)
status_change_end(bl, type, -1);
break;
case BA_POEMBRAGI:
case BA_WHISTLE:
case BA_ASSASSINCROSS:
case BA_APPLEIDUN:
case DC_HUMMING:
case DC_DONTFORGETME:
case DC_FORTUNEKISS:
case DC_SERVICEFORYOU:
if (sc && sc->data[type].timer != -1)
{
delete_timer(sc->data[type].timer, status_change_timer);
//NOTE: It'd be nice if we could get the skill_lv for a more accurate extra time, but alas...
//not possible on our current implementation.
sc->data[type].val4 = 1; //Store the fact that this is a "reduced" duration effect.
sc->data[type].timer = add_timer(tick+skill_get_time2(skill_id,1), status_change_timer, bl->id, type);
}
break;
case PF_FOGWALL:
if (sc && sc->data[type].timer != -1)
{
status_change_end(bl,type,-1);
if (sc->data[SC_BLIND].timer!=-1)
{
if (bl->type == BL_PC) //Players get blind ended inmediately, others have it still for 30 secs. [Skotlex]
status_change_end(bl, SC_BLIND, -1);
else {
delete_timer(sc->data[SC_BLIND].timer, status_change_timer);
sc->data[SC_BLIND].timer = add_timer(30000+tick, status_change_timer, bl->id, SC_BLIND);
}
}
}
break;
case UNT_GOSPEL:
if (sc && sc->data[type].timer != -1 && sc->data[type].val4 == BCT_ALL) //End item-no-use Gospel Effect. [Skotlex]
status_change_end(bl, type, -1);
break;
}
return skill_id;
}
/*==========================================
* Invoked when a unit cell has been placed/removed/deleted.
* flag values:
* flag&1: Invoke onplace function (otherwise invoke onout)
* flag&4: Invoke a onleft call (the unit might be scheduled for deletion)
*------------------------------------------
*/
int skill_unit_effect (struct block_list *bl, va_list ap)
{
struct skill_unit *unit;
struct skill_unit_group *group;
int flag;
unsigned int tick;
nullpo_retr(0, bl);
nullpo_retr(0, ap);
nullpo_retr(0, unit=va_arg(ap,struct skill_unit*));
tick = va_arg(ap,unsigned int);
flag = va_arg(ap,unsigned int);
if (!unit->alive || bl->prev==NULL)
return 0;
nullpo_retr(0, group=unit->group);
if (flag&1)
skill_unit_onplace(unit,bl,tick);
else
skill_unit_onout(unit,bl,tick);
if (flag&4) skill_unit_onleft(group->skill_id, bl, tick);
return 0;
}
/*==========================================
* スキルユニットの限界イベント
*------------------------------------------
*/
int skill_unit_onlimit (struct skill_unit *src, unsigned int tick)
{
struct skill_unit_group *sg;
nullpo_retr(0, src);
nullpo_retr(0, sg=src->group);
switch(sg->unit_id){
case UNT_WARP_ACTIVE:
skill_unitsetting(&src->bl,sg->skill_id,sg->skill_lv,src->bl.x,src->bl.y,1);
break;
case UNT_ICEWALL: /* アイスウォール */
clif_changemapcell(src->bl.m,src->bl.x,src->bl.y,src->val2,1);
break;
case UNT_CALLFAMILY: /* あなたに会いたい */
{
struct map_session_data *sd = NULL;
if(sg->val1) {
sd = map_charid2sd(sg->val1);
sg->val1 = 0;
if (sd && !map[sd->bl.m].flag.nowarp)
pc_setpos(sd,map[src->bl.m].index,src->bl.x,src->bl.y,3);
}
if(sg->val2) {
sd = map_charid2sd(sg->val2);
sg->val2 = 0;
if (sd && !map[sd->bl.m].flag.nowarp)
pc_setpos(sd,map[src->bl.m].index,src->bl.x,src->bl.y,3);
}
}
break;
}
return 0;
}
/*==========================================
* スキルユニットのダメージイベント
*------------------------------------------
*/
int skill_unit_ondamaged (struct skill_unit *src, struct block_list *bl, int damage, unsigned int tick)
{
struct skill_unit_group *sg;
nullpo_retr(0, src);
nullpo_retr(0, sg=src->group);
if (skill_get_inf2(sg->skill_id)&INF2_TRAP && damage > 0)
skill_delunitgroup(NULL,sg);
else
switch(sg->unit_id){
case UNT_ICEWALL:
src->val1-=damage;
break;
default:
damage = 0;
break;
}
return damage;
}
static int skill_moonlit_sub(struct block_list *bl, va_list ap) {
struct block_list *src = va_arg(ap, struct block_list*);
struct block_list *partner = va_arg(ap, struct block_list*);
int blowcount = va_arg(ap, int);
if (bl == src || bl == partner)
return 0;
skill_blown(src, bl, blowcount);
return 1;
}
/*==========================================
* Starts the moonlit effect by first knocking back all other characters in the vecinity.
* partner may be null, but src cannot be.
*------------------------------------------
*/
static void skill_moonlit (struct block_list* src, struct block_list* partner, int skilllv)
{
int range = skill_get_splash(CG_MOONLIT, skilllv);
int blowcount = range+1, time = skill_get_time(CG_MOONLIT,skilllv);
map_foreachinrange(skill_moonlit_sub,src,
range, BL_CHAR,src,partner,blowcount);
if(partner)
map_foreachinrange(skill_moonlit_sub,partner,
range, BL_CHAR,src,partner,blowcount);
sc_start4(src,SC_DANCING,100,CG_MOONLIT,0,0,partner?partner->id:BCT_SELF,time+1000);
sc_start4(src,SkillStatusChangeTable(CG_MOONLIT),100,skilllv,0,0,0,time);
if (partner) {
sc_start4(partner,SC_DANCING,100,CG_MOONLIT,0,0,src->id,time+1000);
sc_start4(partner,SkillStatusChangeTable(CG_MOONLIT),100,skilllv,0,0,0,time);
}
}
/*==========================================
* 範囲内キャラ存在確認判定処理(foreachinarea)
*------------------------------------------
*/
static int skill_check_condition_char_sub (struct block_list *bl, va_list ap)
{
int *c, skillid;
struct block_list *src;
struct map_session_data *sd;
struct map_session_data *tsd;
int *p_sd; //Contains the list of characters found.
nullpo_retr(0, bl);
nullpo_retr(0, ap);
nullpo_retr(0, tsd=(struct map_session_data*)bl);
nullpo_retr(0, src=va_arg(ap,struct block_list *));
nullpo_retr(0, sd=(struct map_session_data*)src);
c=va_arg(ap,int *);
p_sd = va_arg(ap, int *);
skillid = va_arg(ap,int);
if ((skillid != PR_BENEDICTIO && *c >=1) || *c >=2)
return 0; //Partner found for ensembles, or the two companions for Benedictio. [Skotlex]
if (bl == src)
return 0;
if(pc_isdead(tsd))
return 0;
if (tsd->sc.count && (tsd->sc.data[SC_SILENCE].timer != -1 || tsd->sc.data[SC_STUN].timer != -1))
return 0;
switch(skillid)
{
case PR_BENEDICTIO: /* 聖体降福 */
{
int dir = map_calc_dir(&sd->bl,tsd->bl.x,tsd->bl.y);
dir = (unit_getdir(&sd->bl) + dir)%8; //This adjusts dir to account for the direction the sd is facing.
if ((tsd->class_&MAPID_BASEMASK) == MAPID_ACOLYTE && (dir == 2 || dir == 6) //Must be standing to the left/right of Priest.
&& sd->status.sp >= 10)
p_sd[(*c)++]=tsd->bl.id;
return 1;
}
default: //Warning: Assuming Ensemble Dance/Songs for code speed. [Skotlex]
{
int skilllv;
if(pc_issit(tsd) || !unit_can_move(&tsd->bl))
return 0;
if (sd->status.sex != tsd->status.sex &&
(tsd->class_&MAPID_UPPERMASK) == MAPID_BARDDANCER &&
(skilllv = pc_checkskill(tsd, skillid)) > 0 &&
(tsd->weapontype1==W_MUSICAL || tsd->weapontype1==W_WHIP) &&
sd->status.party_id && tsd->status.party_id &&
sd->status.party_id == tsd->status.party_id &&
tsd->sc.data[SC_DANCING].timer == -1)
{
p_sd[(*c)++]=tsd->bl.id;
return skilllv;
} else {
return 0;
}
}
break;
}
return 0;
}
/*==========================================
* Checks and stores partners for ensemble skills [Skotlex]
*------------------------------------------
*/
int skill_check_pc_partner (struct map_session_data *sd, int skill_id, int* skill_lv, int range, int cast_flag)
{
static int c=0;
static int p_sd[2] = { 0, 0 };
int i;
if (cast_flag)
{ //Execute the skill on the partners.
struct map_session_data* tsd;
switch (skill_id)
{
case PR_BENEDICTIO:
for (i = 0; i < c; i++)
{
if ((tsd = map_id2sd(p_sd[i])) != NULL)
status_charge(&tsd->bl, 0, 10);
}
return c;
case CG_MOONLIT:
if (c > 0 && (tsd = map_id2sd(p_sd[0])) != NULL)
{
clif_skill_nodamage(&tsd->bl, &sd->bl, skill_id, *skill_lv, 1);
skill_moonlit(&sd->bl, &tsd->bl, *skill_lv);
tsd->skillid_dance = skill_id;
tsd->skilllv_dance = *skill_lv;
}
return c;
default: //Warning: Assuming Ensemble skills here (for speed)
if (c > 0 && (tsd = map_id2sd(p_sd[0])) != NULL)
{
sd->sc.data[SC_DANCING].val4= tsd->bl.id;
sc_start4(&tsd->bl,SC_DANCING,100,skill_id,sd->sc.data[SC_DANCING].val2,0,sd->bl.id,skill_get_time(skill_id,*skill_lv)+1000);
clif_skill_nodamage(&tsd->bl, &sd->bl, skill_id, *skill_lv, 1);
tsd->skillid_dance = skill_id;
tsd->skilllv_dance = *skill_lv;
}
return c;
}
}
//Else: new search for partners.
c = 0;
memset (p_sd, 0, sizeof(p_sd));
i = map_foreachinrange(skill_check_condition_char_sub, &sd->bl,
range, BL_PC, &sd->bl, &c, &p_sd, skill_id);
if (skill_id != PR_BENEDICTIO) //Apply the average lv to encore skills.
*skill_lv = (i+(*skill_lv))/(c+1); //I know c should be one, but this shows how it could be used for the average of n partners.
return c;
}
/*==========================================
* 範囲内バイオプラント、スフィアマイン用Mob存在確認判定処理(foreachinarea)
*------------------------------------------
*/
static int skill_check_condition_mob_master_sub (struct block_list *bl, va_list ap)
{
int *c,src_id=0,mob_class=0;
struct mob_data *md;
nullpo_retr(0, bl);
nullpo_retr(0, ap);
nullpo_retr(0, md=(struct mob_data*)bl);
nullpo_retr(0, src_id=va_arg(ap,int));
nullpo_retr(0, mob_class=va_arg(ap,int));
nullpo_retr(0, c=va_arg(ap,int *));
if(md->class_==mob_class && md->master_id==src_id)
(*c)++;
return 0;
}
static int skill_check_condition_hermod_sub(struct block_list *bl,va_list ap)
{
struct npc_data *nd;
nd=(struct npc_data*)bl;
if (nd->bl.subtype == WARP)
return 1;
return 0;
}
/*==========================================
* Determines if a given skill should be made to consume ammo
* when used by the player. [Skotlex]
*------------------------------------------
*/
int skill_isammotype (TBL_PC *sd, int skill)
{
return (
(sd->status.weapon == W_BOW || (sd->status.weapon >= W_REVOLVER && sd->status.weapon <= W_GRENADE)) &&
skill != HT_PHANTASMIC && skill != GS_MAGICALBULLET &&
skill_get_type(skill) == BF_WEAPON && !(skill_get_nk(skill)&NK_NO_DAMAGE)
);
}
/*==========================================
* Checks that you have the requirements for casting a skill.
* Flag:
* &1: finished casting the skill (invoke hp/sp/item consumption)
* &2: picked menu entry (Warp Portal, Teleport and other menu based skills)
*------------------------------------------
*/
int skill_check_condition (struct map_session_data *sd, int skill, int lv, int type)
{
struct status_data *status;
struct status_change *sc;
int i,j,hp,sp,hp_rate,sp_rate,zeny,weapon,ammo,ammo_qty,state,spiritball,mhp;
int index[10],itemid[10],amount[10];
int force_gem_flag = 0;
int delitem_flag = 1, checkitem_flag = 1;
nullpo_retr(0, sd);
if (lv <= 0) return 0;
if( battle_config.gm_skilluncond &&
pc_isGM(sd)>= battle_config.gm_skilluncond &&
sd->skillitem != skill)
{ //GMs don't override the skillItem check, otherwise they can use items without them being consumed! [Skotlex]
sd->skillitem = sd->skillitemlv = -1;
return 1;
}
status = &sd->battle_status;
sc = &sd->sc;
if (!sc->count)
sc = NULL;
if(pc_is90overweight(sd)) {
clif_skill_fail(sd,skill,9,0);
sd->skillitem = sd->skillitemlv = -1;
return 0;
}
if (sd->state.abra_flag)
{
sd->skillitem = sd->skillitemlv = -1;
if(type&1) sd->state.abra_flag = 0;
return 1;
}
if (sd->menuskill_id == AM_PHARMACY &&
(skill == AM_PHARMACY || skill == AC_MAKINGARROW || skill == BS_REPAIRWEAPON ||
skill == AM_TWILIGHT1 || skill == AM_TWILIGHT2 || skill == AM_TWILIGHT3
)) {
sd->skillitem = sd->skillitemlv = -1;
return 0;
}
if(sd->skillitem == skill) { /* アイテムの場合無条件成功 */
if(!type) //When a target was selected
{ //Consume items that were skipped in pc_use_item [Skotlex]
if((i = sd->itemindex) == -1 ||
sd->status.inventory[i].nameid != sd->itemid ||
sd->inventory_data[i] == NULL ||
!sd->inventory_data[i]->flag.delay_consume ||
sd->status.inventory[i].amount < 1
)
{ //Something went wrong, item exploit?
sd->itemid = sd->itemindex = -1;
return 0;
}
//Consume
sd->itemid = sd->itemindex = -1;
if(skill == WZ_EARTHSPIKE && sc &&
sc->data[SC_TKREST].timer != -1 && rand()%100 > sc->data[SC_TKREST].val2) // [marquis007]
; //Do not consume item.
else
pc_delitem(sd,i,1,0);
}
if (type&1) //Casting finished
sd->skillitem = sd->skillitemlv = -1;
return 1;
}
// for the guild skills [celest]
if (skill >= GD_SKILLBASE)
j = GD_SKILLRANGEMIN + skill - GD_SKILLBASE;
else
j = skill;
if (j < 0 || j >= MAX_SKILL_DB)
return 0;
//Code speedup, rather than using skill_get_* over and over again.
if (lv < 1 || lv > MAX_SKILL_LEVEL)
return 0;
hp = skill_db[j].hp[lv-1]; /* 消費HP */
sp = skill_db[j].sp[lv-1]; /* 消費SP */
if((sd->skillid_old == BD_ENCORE) && skill == sd->skillid_dance)
sp=sp/2; //アンコール時はSP消費が半分
hp_rate = skill_db[j].hp_rate[lv-1];
sp_rate = skill_db[j].sp_rate[lv-1];
zeny = skill_db[j].zeny[lv-1];
weapon = skill_db[j].weapon;
ammo = skill_db[j].ammo;
ammo_qty = skill_db[j].ammo_qty[lv-1];
state = skill_db[j].state;
spiritball = skill_db[j].spiritball[lv-1];
mhp = skill_db[j].mhp[lv-1]; /* 消費HP */
for(i = 0; i < 10; i++) {
itemid[i] = skill_db[j].itemid[i];
amount[i] = skill_db[j].amount[i];
}
if(mhp > 0)
hp += (status->max_hp * mhp)/100;
if(hp_rate > 0)
hp += (status->hp * hp_rate)/100;
else
hp += (status->max_hp * (-hp_rate))/100;
if(sp_rate > 0)
sp += (status->sp * sp_rate)/100;
else
sp += (status->max_sp * (-sp_rate))/100;
if (!ammo && skill && skill_isammotype(sd, skill))
{ //Assume this skill is using the weapon, therefore it requires arrows.
ammo = 2; //1<<1 <- look 1 (arrows) moved right 1 times.
ammo_qty = skill_get_num(skill, lv);
if (ammo_qty < 0) ammo_qty *= -1;
}
switch(skill) { // Check for cost reductions due to skills & SCs
case MC_MAMMONITE:
if(pc_checkskill(sd,BS_UNFAIRLYTRICK)>0)
zeny -= zeny*10/100;
break;
case AL_HOLYLIGHT:
if(sc && sc->data[SC_SPIRIT].timer!=-1 && sc->data[SC_SPIRIT].val2 == SL_PRIEST)
sp *= 5;
break;
case SL_SMA:
case SL_STUN:
case SL_STIN:
{
int kaina_lv = pc_checkskill(sd,SL_KAINA);
if(kaina_lv==0 || sd->status.base_level<70)
break;
if(sd->status.base_level>=90)
sp -= sp*7*kaina_lv/100;
else if(sd->status.base_level>=80)
sp -= sp*5*kaina_lv/100;
else if(sd->status.base_level>=70)
sp -= sp*3*kaina_lv/100;
}
break;
case MO_TRIPLEATTACK:
case MO_CHAINCOMBO:
case MO_COMBOFINISH:
case CH_TIGERFIST:
case CH_CHAINCRUSH:
if(sc && sc->data[SC_SPIRIT].timer!=-1 && sc->data[SC_SPIRIT].val2 == SL_MONK)
sp -= sp*25/100; //FIXME: Need real data. this is a custom value.
break;
}
if(sd->dsprate!=100)
sp=sp*sd->dsprate/100; /* 消費SP修正 */
switch(skill) {
case SA_CASTCANCEL:
if(sd->ud.skilltimer == -1) {
clif_skill_fail(sd,skill,0,0);
return 0;
}
break;
case BS_MAXIMIZE:
case NV_TRICKDEAD:
case TF_HIDING:
case AS_CLOAKING:
case CR_AUTOGUARD:
case CR_DEFENDER:
case ST_CHASEWALK:
case PA_GOSPEL:
case CR_SHRINK:
case TK_RUN:
if(sc && sc->data[SkillStatusChangeTable(skill)].timer!=-1)
return 1; //Allow turning off.
break;
case AL_WARP:
if(!(type&2)) //Delete the item when the portal has been selected (type&2). [Skotlex]
delitem_flag = 0;
if(!battle_config.duel_allow_teleport && sd->duel_group) { // duel restriction [LuzZza]
clif_displaymessage(sd->fd, "Duel: Can't use warp in duel.");
return 0;
}
break;
case MO_CALLSPIRITS: /* 気功 */
if(sd->spiritball >= lv) {
clif_skill_fail(sd,skill,0,0);
return 0;
}
break;
case CH_SOULCOLLECT: /* 狂気功 */
if(sd->spiritball >= 5) {
clif_skill_fail(sd,skill,0,0);
return 0;
}
break;
case MO_FINGEROFFENSIVE: //指弾
case GS_FLING:
if (sd->spiritball > 0 && sd->spiritball < spiritball) {
spiritball = sd->spiritball;
sd->spiritball_old = sd->spiritball;
}
else sd->spiritball_old = spiritball;
break;
case MO_BODYRELOCATION:
if (sc && sc->data[SC_EXPLOSIONSPIRITS].timer!=-1)
spiritball = 0;
break;
case MO_CHAINCOMBO: //連打掌
if(!sc)
return 0;
if(sc->data[SC_BLADESTOP].timer!=-1)
break;
if(sc->data[SC_COMBO].timer != -1 && sc->data[SC_COMBO].val1 == MO_TRIPLEATTACK)
break;
return 0;
case MO_COMBOFINISH: //猛龍拳
if(!sc || sc->data[SC_COMBO].timer == -1 || sc->data[SC_COMBO].val1 != MO_CHAINCOMBO)
return 0;
break;
case CH_TIGERFIST: //伏虎拳
if(!sc || sc->data[SC_COMBO].timer == -1 || sc->data[SC_COMBO].val1 != MO_COMBOFINISH)
return 0;
break;
case CH_CHAINCRUSH: //連柱崩撃
if(!sc || sc->data[SC_COMBO].timer == -1)
return 0;
if(sc->data[SC_COMBO].val1 != MO_COMBOFINISH && sc->data[SC_COMBO].val1 != CH_TIGERFIST)
return 0;
break;
case MO_EXTREMITYFIST:
// if(sc && sc->data[SC_EXTREMITYFIST].timer != -1) //To disable Asura during the 5 min skill block uncomment this...
// return 0;
if(sc && sc->data[SC_BLADESTOP].timer!=-1)
spiritball--;
else if (sc && sc->data[SC_COMBO].timer != -1) {
switch(sc->data[SC_COMBO].val1) {
case MO_COMBOFINISH:
spiritball = 4;
break;
case CH_TIGERFIST:
spiritball = 3;
break;
case CH_CHAINCRUSH: //It should consume whatever is left as long as it's at least 1.
spiritball = sd->spiritball?sd->spiritball:1;
break;
default:
return 0;
}
} else if(!type && !unit_can_move(&sd->bl)) //Check only on begin casting.
{ //Placed here as ST_MOVE_ENABLE should not apply if rooted or on a combo. [Skotlex]
clif_skill_fail(sd,skill,0,0);
return 0;
}
break;
case TK_MISSION: //Does not works on Non-Taekwon
if ((sd->class_&MAPID_UPPERMASK) != MAPID_TAEKWON) {
clif_skill_fail(sd,skill,0,0);
return 0;
}
break;
case TK_READYCOUNTER:
case TK_READYDOWN:
case TK_READYSTORM:
case TK_READYTURN:
if(sc && sc->data[SkillStatusChangeTable(skill)].timer!=-1)
return 1; //Enable disabling them regardless of who you are.
case TK_JUMPKICK:
if ((sd->class_&MAPID_UPPERMASK) == MAPID_SOUL_LINKER) {
//They do not work on Soul Linkers.
clif_skill_fail(sd,skill,0,0);
return 0;
}
break;
case TK_TURNKICK:
case TK_STORMKICK:
case TK_DOWNKICK:
case TK_COUNTER:
if ((sd->class_&MAPID_UPPERMASK) == MAPID_SOUL_LINKER)
return 0; //Anti-Soul Linker check in case you job-changed with Stances active.
if(!sc || sc->data[SC_COMBO].timer == -1)
return 0; //Combo needs to be ready
if (pc_famerank(sd->char_id,MAPID_TAEKWON))
{ //Unlimited Combo
if (skill == sd->skillid_old) {
status_change_end(&sd->bl, SC_COMBO, -1);
sd->skillid_old = sd->skilllv_old = 0;
return 0; //Can't repeat previous combo skill.
}
break;
} else
if(sc->data[SC_COMBO].val1 == skill)
break; //Combo ready.
return 0;
case BD_ADAPTATION: /* アドリブ */
{
struct skill_unit_group *group=NULL;
int time;
if(!sc || sc->data[SC_DANCING].timer==-1)
{
clif_skill_fail(sd,skill,0,0);
return 0;
}
group=(struct skill_unit_group*)sc->data[SC_DANCING].val2;
time = 1000*(sc->data[SC_DANCING].val3>>16);
if (!group || (skill_get_time(sc->data[SC_DANCING].val1,group->skill_lv) - time <= skill_get_time2(skill,lv)))
{
clif_skill_fail(sd,skill,0,0);
return 0;
}
}
break;
case PR_BENEDICTIO: /* 聖体降福 */
{
if (!battle_config.player_skill_partner_check ||
(battle_config.gm_skilluncond && pc_isGM(sd) >= battle_config.gm_skilluncond)
)
break; //No need to do any partner checking [Skotlex]
if (!(type&1))
{ //Started casting.
if (skill_check_pc_partner(sd, skill, &lv, 1, 0) < 2)
{
clif_skill_fail(sd,skill,0,0);
return 0;
}
}
else
{ //Done casting
//Should I repeat the check? If so, it would be best to only do this on cast-ending. [Skotlex]
skill_check_pc_partner(sd, skill, &lv, 1, 1);
}
}
break;
case AM_CANNIBALIZE: /* バイオプラント */
case AM_SPHEREMINE: /* スフィアーマイン */
if(type&1){
int c=0;
int summons[5] = { 1020, 1068, 1118, 1500, 1368 };
int maxcount = (skill==AM_CANNIBALIZE)? 6-lv : skill_get_maxcount(skill);
int mob_class = (skill==AM_CANNIBALIZE)? summons[lv-1] :1142;
if(battle_config.land_skill_limit && maxcount>0 && (battle_config.land_skill_limit&BL_PC)) {
map_foreachinmap(skill_check_condition_mob_master_sub ,sd->bl.m, BL_MOB, sd->bl.id, mob_class,&c );
if(c >= maxcount){
clif_skill_fail(sd,skill,0,0);
return 0;
}
}
}
break;
case WZ_FIREPILLAR: // celest
if (lv <= 5) // no gems required at level 1-5
itemid[0] = 0;
break;
case SL_SMA:
if(type) break; //Only do the combo check when the target is selected (type == 0)
if(!sc || sc->data[SC_SMA].timer == -1)
return 0;
break;
case HT_POWER:
if(!sc || sc->data[SC_COMBO].timer == -1 || sc->data[SC_COMBO].val1 != skill)
return 0;
break;
case HW_GANBANTEIN:
force_gem_flag = 1;
break;
case AM_BERSERKPITCHER:
case AM_POTIONPITCHER:
case CR_SLIMPITCHER:
case MG_STONECURSE:
case CR_CULTIVATION:
case SA_FLAMELAUNCHER:
case SA_FROSTWEAPON:
case SA_LIGHTNINGLOADER:
case SA_SEISMICWEAPON:
delitem_flag = 0;
break;
case SA_DELUGE:
case SA_VOLCANO:
case SA_VIOLENTGALE:
case SA_LANDPROTECTOR:
{ //Does not consumes if the skill is already active. [Skotlex]
struct skill_unit_group *sg;
if ((sg= skill_locate_element_field(&sd->bl)) != NULL && sg->skill_id == skill)
{
if (sg->limit - DIFF_TICK(gettick(), sg->tick) > 0)
checkitem_flag = delitem_flag = 0;
else sg->limit = 0; //Disable it.
}
break;
}
case CG_HERMODE:
if (map_foreachinrange (skill_check_condition_hermod_sub, &sd->bl,
skill_get_splash(skill, lv), BL_NPC) < 1)
{
clif_skill_fail(sd,skill,0,0);
return 0;
}
break;
case CG_MOONLIT: //Check there's no wall in the range+1 area around the caster. [Skotlex]
{
int i,x,y,range = skill_get_splash(skill, lv)+1;
int size = range*2+1;
for (i=0;i<size*size;i++) {
x = sd->bl.x+(i%size-range);
y = sd->bl.y+(i/size-range);
if (map_getcell(sd->bl.m,x,y,CELL_CHKWALL)) {
clif_skill_fail(sd,skill,0,0);
return 0;
}
}
}
break;
case PR_REDEMPTIO:
{
int exp;
if(((exp = pc_nextbaseexp(sd)) > 0 && sd->status.base_exp*100/exp < 1) ||
((exp = pc_nextjobexp(sd)) > 0 && sd->status.job_exp*100/exp < 1)) {
clif_skill_fail(sd,skill,0,0); //Not enough exp.
return 0;
}
break;
}
case AM_TWILIGHT2:
case AM_TWILIGHT3:
if (!party_skill_check(sd, sd->status.party_id, skill, lv))
{
clif_skill_fail(sd,skill,0,0);
return 0;
}
break;
//SHOULD BE OPTIMALIZED [Komurka]
//Optimized #1. optimize comfort later. [Vicious]
case SG_SUN_WARM:
case SG_MOON_WARM:
case SG_STAR_WARM:
if ((sd->bl.m == sd->feel_map[skill-SG_SUN_WARM].m) || (sc && sc->data[SC_MIRACLE].timer!=-1))
break;
clif_skill_fail(sd,skill,0,0);
return 0;
break;
case SG_SUN_COMFORT:
if ((sd->bl.m == sd->feel_map[0].m && (battle_config.allow_skill_without_day || is_day_of_sun())) || (sc && sc->data[SC_MIRACLE].timer!=-1))
break;
clif_skill_fail(sd,skill,0,0);
return 0;
case SG_MOON_COMFORT:
if ((sd->bl.m == sd->feel_map[1].m && (battle_config.allow_skill_without_day || is_day_of_moon())) || (sc && sc->data[SC_MIRACLE].timer!=-1))
break;
clif_skill_fail(sd,skill,0,0);
return 0;
case SG_STAR_COMFORT:
if ((sd->bl.m == sd->feel_map[2].m && (battle_config.allow_skill_without_day || is_day_of_star())) || (sc && sc->data[SC_MIRACLE].timer!=-1))
break;
clif_skill_fail(sd,skill,0,0);
return 0;
case SG_FUSION:
if (!sc || sc->data[SC_FUSION].timer!=-1)
return 1;
if (sc && sc->data[SC_SPIRIT].timer != -1 && sc->data[SC_SPIRIT].val2 == SL_STAR)
break;
return 0;
case GD_BATTLEORDER:
case GD_REGENERATION:
case GD_RESTORE:
case GD_EMERGENCYCALL:
if (!sd->status.guild_id || !sd->state.gmaster_flag)
return 0;
if (lv <= 0)
return 0;
if (skill == GD_EMERGENCYCALL) {
if (!map_flag_gvg(sd->bl.m))
{ //if not allowed to warp to the map (castles are always allowed)
clif_skill_fail(sd,skill,0,0);
return 0;
}
} else if (!agit_flag) {
clif_skill_fail(sd,skill,0,0);
return 0;
}
break;
//Until they're at right position - gs_skillcheck- [Vicious]
case GS_GLITTERING:
if(sd->spiritball >= 10) {
clif_skill_fail(sd,skill,0,0);
return 0;
}
break;
case NJ_ISSEN:
if (sc && sc->data[SC_NEN].timer!=-1)
return 0;
break;
case NJ_ZENYNAGE:
if(sd->status.zeny < zeny) {
clif_skill_fail(sd,skill,5,0);
return 0;
}
zeny = 0; //Zeny is reduced on skill_attack.
break;
}
if(!(type&2)){
if( hp>0 && status->hp <= (unsigned int)hp) { /* HPチェック */
clif_skill_fail(sd,skill,2,0); /* HP不足：失敗通知 */
return 0;
}
if( sp>0 && status->sp < (unsigned int)sp) { /* SPチェック */
clif_skill_fail(sd,skill,1,0); /* SP不足：失敗通知 */
return 0;
}
if( zeny>0 && sd->status.zeny < zeny) {
clif_skill_fail(sd,skill,5,0);
return 0;
}
if(!(weapon & (1<<sd->status.weapon) ) ) {
clif_skill_fail(sd,skill,6,0);
return 0;
}
if(ammo) { //Skill requires stuff equipped in the arrow slot.
if((i=sd->equip_index[10]) < 0 ||
!sd->inventory_data[i] ||
sd->status.inventory[i].amount < ammo_qty
) {
clif_arrow_fail(sd,0);
return 0;
}
if (!(ammo&1<<sd->inventory_data[i]->look))
{ //Ammo type check. Send the "wrong weapon type" message
//which is the closest we have to wrong ammo type. [Skotlex]
clif_arrow_fail(sd,0); //Haplo suggested we just send the equip-arrows message instead. [Skotlex]
//clif_skill_fail(sd,skill,6,0);
return 0;
}
}
if( spiritball > 0 && sd->spiritball < spiritball) {
clif_skill_fail(sd,skill,0,0); // 氣球不足
return 0;
}
}
switch(state) {
case ST_HIDING:
if(!(sc && sc->option&OPTION_HIDE)) {
clif_skill_fail(sd,skill,0,0);
return 0;
}
break;
case ST_CLOAKING:
if(!pc_iscloaking(sd)) {
clif_skill_fail(sd,skill,0,0);
return 0;
}
break;
case ST_HIDDEN:
if(!pc_ishiding(sd)) {
clif_skill_fail(sd,skill,0,0);
return 0;
}
break;
case ST_RIDING:
if(!pc_isriding(sd)) {
clif_skill_fail(sd,skill,0,0);
return 0;
}
break;
case ST_FALCON:
if(!pc_isfalcon(sd)) {
clif_skill_fail(sd,skill,0,0);
return 0;
}
break;
case ST_CART:
if(!pc_iscarton(sd)) {
clif_skill_fail(sd,skill,0,0);
return 0;
}
break;
case ST_SHIELD:
if(sd->status.shield <= 0) {
clif_skill_fail(sd,skill,0,0);
return 0;
}
break;
case ST_SIGHT:
if((!sc || sc->data[SC_SIGHT].timer == -1) && type&1) {
clif_skill_fail(sd,skill,0,0);
return 0;
}
break;
case ST_EXPLOSIONSPIRITS:
if(!sc || sc->data[SC_EXPLOSIONSPIRITS].timer == -1) {
clif_skill_fail(sd,skill,0,0);
return 0;
}
break;
case ST_CARTBOOST:
if(!pc_iscarton(sd) || !sc || sc->data[SC_CARTBOOST].timer == -1) {
clif_skill_fail(sd,skill,0,0);
return 0;
}
break;
case ST_RECOV_WEIGHT_RATE:
if(battle_config.natural_heal_weight_rate <= 100 && sd->weight*100/sd->max_weight >= battle_config.natural_heal_weight_rate) {
clif_skill_fail(sd,skill,0,0);
return 0;
}
break;
case ST_MOVE_ENABLE:
if(type)//Check only on begin casting. [Skotlex]
break;
if (sc && sc->data[SC_COMBO].timer != -1 && sc->data[SC_COMBO].val1 == skill)
sd->ud.canmove_tick = gettick(); //When using a combo, cancel the can't move delay to enable the skill. [Skotlex]
if (!unit_can_move(&sd->bl)) {
clif_skill_fail(sd,skill,0,0);
return 0;
}
break;
case ST_WATER:
if (
(!sc || (sc->data[SC_DELUGE].timer == -1 && sc->data[SC_SUITON].timer == -1)) &&
(!map_getcell(sd->bl.m,sd->bl.x,sd->bl.y,CELL_CHKWATER))
) {
clif_skill_fail(sd,skill,0,0);
return 0;
}
break;
}
if (checkitem_flag) {
for(i=0;i<10;i++) {
int x = lv%11 - 1;
index[i] = -1;
if(itemid[i] <= 0)
continue;
if(itemid[i] >= 715 && itemid[i] <= 717 && sd->special_state.no_gemstone && !force_gem_flag)
continue;
if(((itemid[i] >= 715 && itemid[i] <= 717) || itemid[i] == 1065)
&& sc && sc->data[SC_INTOABYSS].timer != -1 && !force_gem_flag)
continue;
if((skill == AM_POTIONPITCHER ||
skill == CR_SLIMPITCHER ||
skill == CR_CULTIVATION) && i != x)
continue;
index[i] = pc_search_inventory(sd,itemid[i]);
if(index[i] < 0 || sd->status.inventory[index[i]].amount < amount[i]) {
if(itemid[i] == 716 || itemid[i] == 717)
clif_skill_fail(sd,skill,(7+(itemid[i]-716)),0);
else
clif_skill_fail(sd,skill,0,0);
return 0;
}
if((itemid[i] >= 715 && itemid[i] <= 717) && sc && sc->data[SC_SPIRIT].timer != -1 && sc->data[SC_SPIRIT].val2 == SL_WIZARD)
index[i] = -1; //Gemstones are checked, but not substracted from inventory.
}
}
if(!(type&1))
return 1;
sd->state.arrow_atk = ammo?1:0; //Update arrow-atk state on cast-end.
if(delitem_flag) {
for(i=0;i<10;i++) {
if(index[i] >= 0)
pc_delitem(sd,index[i],amount[i],0); // アイテム消費
}
// Ammo is now reduced in battle_calc_weapon_attack. [Skotlex]
// if (ammo && battle_config.arrow_decrement)
// pc_delitem(sd,sd->equip_index[10],ammo_qty,0);
}
if(type&2)
return 1;
if(sp || hp)
status_zap(&sd->bl, hp, sp);
if(zeny > 0) // Zeny消費
pc_payzeny(sd,zeny);
if(spiritball > 0) // 氣球消費
pc_delspiritball(sd,spiritball,0);
return 1;
}
/*==========================================
* 詠唱時間計算
*------------------------------------------
*/
int skill_castfix (struct block_list *bl, int skill_id, int skill_lv)
{
int castnodex = skill_get_castnodex(skill_id, skill_lv);
int time = skill_get_cast(skill_id, skill_lv);
struct map_session_data *sd;
nullpo_retr(0, bl);
BL_CAST(BL_PC, bl, sd);
// calculate base cast time (reduced by dex)
if (!(castnodex&1)) { // castnodex&~1? wtf. [blackhole89]
int scale = battle_config.castrate_dex_scale - status_get_dex(bl);
if (scale > 0) // not instant cast
time = time * scale / battle_config.castrate_dex_scale;
else return 0; // instant cast
}
// calculate cast time reduced by card bonuses
if (sd && sd->castrate != 100)
time = time * sd->castrate / 100;
// config cast time multiplier
if (battle_config.cast_rate != 100)
time = time * battle_config.cast_rate / 100;
// calculate cast time reduced by skill bonuses
if (!(castnodex&2))
time = skill_castfix_sc(bl, time);
// return final cast time
return (time > 0) ? time : 0;
}
/*==========================================
* Does cast-time reductions based on sc data.
*------------------------------------------
*/
int skill_castfix_sc (struct block_list *bl, int time)
{
struct status_change *sc = status_get_sc(bl);
if (time <= 0) return 0;
if (sc && sc->count) {
if (sc->data[SC_SUFFRAGIUM].timer != -1) {
time -= time * (sc->data[SC_SUFFRAGIUM].val1 * 15) / 100;
status_change_end(bl, SC_SUFFRAGIUM, -1);
}
if (sc->data[SC_MEMORIZE].timer != -1) {
time>>=1;
if ((--sc->data[SC_MEMORIZE].val2) <= 0)
status_change_end(bl, SC_MEMORIZE, -1);
}
if (sc->data[SC_POEMBRAGI].timer != -1)
time -= time * sc->data[SC_POEMBRAGI].val2 / 100;
}
return (time > 0) ? time : 0;
}
/*==========================================
* ディレイ計算
*------------------------------------------
*/
int skill_delayfix (struct block_list *bl, int skill_id, int skill_lv)
{
int delaynodex = skill_get_delaynodex(skill_id, skill_lv);
int time = skill_get_delay(skill_id, skill_lv);
nullpo_retr(0, bl);
if (bl->type&battle_config.no_skill_delay)
return battle_config.min_skill_delay_limit;
// instant cast attack skills depend on aspd as delay [celest]
if (time == 0) {
if (skill_get_type(skill_id) == BF_WEAPON && !(skill_get_nk(skill_id)&NK_NO_DAMAGE))
time = status_get_adelay(bl); //Use attack delay as default delay.
else
time = battle_config.default_skill_delay;
} else if (time < 0)
time = -time + status_get_adelay(bl); // if set to <0, the attack delay is added.
if (battle_config.delay_dependon_dex && !(delaynodex&1))
{ // if skill casttime is allowed to be reduced by dex
int scale = battle_config.castrate_dex_scale - status_get_dex(bl);
if (scale > 0)
time = time * scale / battle_config.castrate_dex_scale;
else //To be capped later to minimum.
time = 0;
}
if (bl->type == BL_PC && ((TBL_PC*)bl)->delayrate != 100)
time = time * ((TBL_PC*)bl)->delayrate / 100;
if (battle_config.delay_rate != 100)
time = time * battle_config.delay_rate / 100;
if (!(delaynodex&2))
{ /* ブラギの詩 */
struct status_change *sc;
sc= status_get_sc(bl);
if (sc && sc->count) {
if (sc->data[SC_POEMBRAGI].timer != -1)
time -= time * sc->data[SC_POEMBRAGI].val3 / 100;
if (sc->data[SC_SPIRIT].timer != -1)
switch (skill_id) {
case CR_SHIELDBOOMERANG:
if (sc->data[SC_SPIRIT].val2 == SL_CRUSADER)
time /=2;
break;
case AS_SONICBLOW:
if (!map_flag_gvg(bl->m) && sc->data[SC_SPIRIT].val2 == SL_ASSASIN)
time /= 2;
break;
}
}
}
return (time < battle_config.min_skill_delay_limit)?
battle_config.min_skill_delay_limit:time;
}
/*=========================================
* ブランディッシュスピア 初期範囲決定
*----------------------------------------
*/
void skill_brandishspear_first (struct square *tc, int dir, int x, int y)
{
nullpo_retv(tc);
if(dir == 0){
tc->val1[0]=x-2;
tc->val1[1]=x-1;
tc->val1[2]=x;
tc->val1[3]=x+1;
tc->val1[4]=x+2;
tc->val2[0]=
tc->val2[1]=
tc->val2[2]=
tc->val2[3]=
tc->val2[4]=y-1;
}
else if(dir==2){
tc->val1[0]=
tc->val1[1]=
tc->val1[2]=
tc->val1[3]=
tc->val1[4]=x+1;
tc->val2[0]=y+2;
tc->val2[1]=y+1;
tc->val2[2]=y;
tc->val2[3]=y-1;
tc->val2[4]=y-2;
}
else if(dir==4){
tc->val1[0]=x-2;
tc->val1[1]=x-1;
tc->val1[2]=x;
tc->val1[3]=x+1;
tc->val1[4]=x+2;
tc->val2[0]=
tc->val2[1]=
tc->val2[2]=
tc->val2[3]=
tc->val2[4]=y+1;
}
else if(dir==6){
tc->val1[0]=
tc->val1[1]=
tc->val1[2]=
tc->val1[3]=
tc->val1[4]=x-1;
tc->val2[0]=y+2;
tc->val2[1]=y+1;
tc->val2[2]=y;
tc->val2[3]=y-1;
tc->val2[4]=y-2;
}
else if(dir==1){
tc->val1[0]=x-1;
tc->val1[1]=x;
tc->val1[2]=x+1;
tc->val1[3]=x+2;
tc->val1[4]=x+3;
tc->val2[0]=y-4;
tc->val2[1]=y-3;
tc->val2[2]=y-1;
tc->val2[3]=y;
tc->val2[4]=y+1;
}
else if(dir==3){
tc->val1[0]=x+3;
tc->val1[1]=x+2;
tc->val1[2]=x+1;
tc->val1[3]=x;
tc->val1[4]=x-1;
tc->val2[0]=y-1;
tc->val2[1]=y;
tc->val2[2]=y+1;
tc->val2[3]=y+2;
tc->val2[4]=y+3;
}
else if(dir==5){
tc->val1[0]=x+1;
tc->val1[1]=x;
tc->val1[2]=x-1;
tc->val1[3]=x-2;
tc->val1[4]=x-3;
tc->val2[0]=y+3;
tc->val2[1]=y+2;
tc->val2[2]=y+1;
tc->val2[3]=y;
tc->val2[4]=y-1;
}
else if(dir==7){
tc->val1[0]=x-3;
tc->val1[1]=x-2;
tc->val1[2]=x-1;
tc->val1[3]=x;
tc->val1[4]=x+1;
tc->val2[1]=y;
tc->val2[0]=y+1;
tc->val2[2]=y-1;
tc->val2[3]=y-2;
tc->val2[4]=y-3;
}
}
/*=========================================
* ブランディッシュスピア 方向判定 範囲拡張
*-----------------------------------------
*/
void skill_brandishspear_dir (struct square *tc, int dir, int are)
{
int c;
nullpo_retv(tc);
for(c=0;c<5;c++){
if(dir==0){
tc->val2[c]+=are;
}else if(dir==1){
tc->val1[c]-=are; tc->val2[c]+=are;
}else if(dir==2){
tc->val1[c]-=are;
}else if(dir==3){
tc->val1[c]-=are; tc->val2[c]-=are;
}else if(dir==4){
tc->val2[c]-=are;
}else if(dir==5){
tc->val1[c]+=are; tc->val2[c]-=are;
}else if(dir==6){
tc->val1[c]+=are;
}else if(dir==7){
tc->val1[c]+=are; tc->val2[c]+=are;
}
}
}
/*==========================================
* Weapon Repair [Celest/DracoRPG]
*------------------------------------------
*/
void skill_repairweapon (struct map_session_data *sd, int idx)
{
int material;
int materials[4] = { 1002, 998, 999, 756 };
struct item *item;
struct map_session_data *target_sd;
nullpo_retv(sd);
target_sd = map_id2sd(sd->menuskill_lv);
if (!target_sd) //Failed....
return;
if(idx==0xFFFF) // No item selected ('Cancel' clicked)
return;
if(idx < 0 || idx >= MAX_INVENTORY)
return; //Invalid index??
item = &target_sd->status.inventory[idx];
if(item->nameid <= 0 || item->attribute == 0)
return; //Again invalid item....
if(sd!=target_sd && !battle_check_range(&sd->bl,&target_sd->bl,skill_get_range2(&sd->bl, sd->menuskill_id,pc_checkskill(sd, sd->menuskill_id)))){
clif_item_repaireffect(sd,item->nameid,1);
return;
}
if (itemdb_type(item->nameid)==4)
material = materials [itemdb_wlv(item->nameid)-1]; // Lv1/2/3/4 weapons consume 1 Iron Ore/Iron/Steel/Rough Oridecon
else
material = materials [2]; // Armors consume 1 Steel
if (pc_search_inventory(sd,material) < 0 ) {
clif_skill_fail(sd,sd->menuskill_id,0,0);
return;
}
item->attribute=0;
clif_equiplist(target_sd);
pc_delitem(sd,pc_search_inventory(sd,material),1,0);
clif_item_repaireffect(sd,item->nameid,0);
if(sd!=target_sd)
clif_item_repaireffect(target_sd,item->nameid,0);
}
/*==========================================
* Item Appraisal
*------------------------------------------
*/
void skill_identify (struct map_session_data *sd, int idx)
{
int flag=1;
nullpo_retv(sd);
if(idx >= 0 && idx < MAX_INVENTORY) {
if(sd->status.inventory[idx].nameid > 0 && sd->status.inventory[idx].identify == 0 ){
flag=0;
sd->status.inventory[idx].identify=1;
}
}
clif_item_identified(sd,idx,flag);
}
/*==========================================
* Weapon Refine [Celest]
*------------------------------------------
*/
void skill_weaponrefine (struct map_session_data *sd, int idx)
{
int i = 0, ep = 0, per;
int material[5] = { 0, 1010, 1011, 984, 984 };
struct item *item;
nullpo_retv(sd);
if (idx >= 0 && idx < MAX_INVENTORY) {
struct item_data *ditem = sd->inventory_data[idx];
item = &sd->status.inventory[idx];
if(item->nameid > 0 && ditem->type == 4) {
if (item->refine >= sd->menuskill_lv ||
item->refine >= MAX_REFINE || // if it's no longer refineable
ditem->flag.no_refine || // if the item isn't refinable
(i = pc_search_inventory(sd, material [ditem->wlv])) < 0 ) { //fixed by Lupus (item pos can be = 0!)
clif_skill_fail(sd,sd->menuskill_id,0,0);
return;
}
per = percentrefinery [ditem->wlv][(int)item->refine];
per += (sd->status.job_level-50)/2; //Updated per the new kro descriptions. [Skotlex]
if (per > rand() % 100) {
item->refine++;
pc_delitem(sd, i, 1, 0);
if(item->equip) {
ep = item->equip;
pc_unequipitem(sd,idx,3);
}
clif_refine(sd->fd,sd,0,idx,item->refine);
clif_delitem(sd,idx,1);
clif_additem(sd,idx,1,0);
if (ep)
pc_equipitem(sd,idx,ep);
clif_misceffect(&sd->bl,3);
if(item->refine == MAX_REFINE && item->card[0] == CARD0_FORGE &&
MakeDWord(item->card[2],item->card[3]) == sd->char_id){ // Fame point system [DracoRPG]
switch(ditem->wlv){
case 1:
pc_addfame(sd,1); // Success to refine to +10 a lv1 weapon you forged = +1 fame point
break;
case 2:
pc_addfame(sd,25); // Success to refine to +10 a lv2 weapon you forged = +25 fame point
break;
case 3:
pc_addfame(sd,1000); // Success to refine to +10 a lv3 weapon you forged = +1000 fame point
break;
}
}
} else {
pc_delitem(sd, i, 1, 0);
item->refine = 0;
if(item->equip)
pc_unequipitem(sd,idx,3);
clif_refine(sd->fd,sd,1,idx,item->refine);
pc_delitem(sd,idx,1,0);
clif_misceffect(&sd->bl,2);
clif_emotion(&sd->bl, 23);
}
}
}
}
/*==========================================
* オートスペル
*------------------------------------------
*/
int skill_autospell (struct map_session_data *sd, int skillid)
{
int skilllv;
int maxlv=1,lv;
nullpo_retr(0, sd);
skilllv = sd->menuskill_lv;
lv=pc_checkskill(sd,skillid);
if(skilllv <= 0 || !lv) return 0; // Player must learn the skill before doing auto-spell [Lance]
if(skillid==MG_NAPALMBEAT) maxlv=3;
else if(skillid==MG_COLDBOLT || skillid==MG_FIREBOLT || skillid==MG_LIGHTNINGBOLT){
if (sd->sc.data[SC_SPIRIT].timer != -1 && sd->sc.data[SC_SPIRIT].val2 == SL_SAGE)
maxlv =10; //Soul Linker bonus. [Skotlex]
else if(skilllv==2) maxlv=1;
else if(skilllv==3) maxlv=2;
else if(skilllv>=4) maxlv=3;
}
else if(skillid==MG_SOULSTRIKE){
if(skilllv==5) maxlv=1;
else if(skilllv==6) maxlv=2;
else if(skilllv>=7) maxlv=3;
}
else if(skillid==MG_FIREBALL){
if(skilllv==8) maxlv=1;
else if(skilllv>=9) maxlv=2;
}
else if(skillid==MG_FROSTDIVER) maxlv=1;
else return 0;
if(maxlv > lv)
maxlv = lv;
sc_start4(&sd->bl,SC_AUTOSPELL,100,skilllv,skillid,maxlv,0,
skill_get_time(SA_AUTOSPELL,skilllv));
return 0;
}
/*==========================================
* ギャングスターパラダイス判定処理(foreachinarea)
*------------------------------------------
*/
static int skill_gangster_count (struct block_list *bl, va_list ap)
{
struct map_session_data *sd;
sd=(struct map_session_data*)bl;
if(sd && pc_issit(sd) && pc_checkskill(sd,RG_GANGSTER) > 0)
return 1;
return 0;
}
static int skill_gangster_in (struct block_list *bl, va_list ap)
{
struct map_session_data *sd;
sd=(struct map_session_data*)bl;
if(sd && pc_issit(sd) && pc_checkskill(sd,RG_GANGSTER) > 0)
sd->state.gangsterparadise=1;
return 0;
}
static int skill_gangster_out (struct block_list *bl, va_list ap)
{
struct map_session_data *sd;
sd=(struct map_session_data*)bl;
if(sd && sd->state.gangsterparadise)
sd->state.gangsterparadise=0;
return 0;
}
int skill_gangsterparadise (struct map_session_data *sd, int type)
{
int range;
nullpo_retr(0, sd);
if((range = pc_checkskill(sd,RG_GANGSTER)) <= 0)
return 0;
range = skill_get_splash(RG_GANGSTER, range);
if(type==1) {/* 座った時の処理 */
if (map_foreachinrange(skill_gangster_count,&sd->bl, range, BL_PC) > 1)
{ /*ギャングスター成功したら自分にもギャングスター属性付与*/
map_foreachinrange(skill_gangster_in,&sd->bl, range, BL_PC);
sd->state.gangsterparadise = 1;
}
return 0;
}
else if(type==0) {/* 立ち上がったときの処理 */
if (map_foreachinrange(skill_gangster_count,&sd->bl, range, BL_PC) < 2)
map_foreachinrange(skill_gangster_out,&sd->bl, range, BL_PC);
sd->state.gangsterparadise = 0;
return 0;
}
return 0;
}
/*==========================================
* Taekwon TK_HPTIME and TK_SPTIME skills [Dralnu]
*------------------------------------------
*/
static int skill_rest_count (struct block_list *bl, va_list ap)
{
struct map_session_data *sd;
sd=(struct map_session_data*)bl;
if(sd && pc_issit(sd) && (pc_checkskill(sd,TK_HPTIME) > 0 || pc_checkskill(sd,TK_SPTIME) > 0 ))
return 1;
return 0;
}
static int skill_rest_in(struct block_list *bl, va_list ap)
{
struct map_session_data *sd;
nullpo_retr(0, bl);
nullpo_retr(0, ap);
sd=(struct map_session_data*)bl;
if(sd && pc_issit(sd) && (pc_checkskill(sd,TK_HPTIME) > 0 || pc_checkskill(sd,TK_SPTIME) > 0 )){
sd->state.rest=1;
status_calc_pc(sd,0);
}
return 0;
}
static int skill_rest_out(struct block_list *bl, va_list ap)
{
struct map_session_data *sd;
sd=(struct map_session_data*)bl;
if(sd && sd->state.rest != 0)
sd->state.rest=0;
return 0;
}
int skill_rest(struct map_session_data *sd, int type)
{
int range;
nullpo_retr(0, sd);
if((range = pc_checkskill(sd,TK_HPTIME)) > 0)
range = skill_get_splash(TK_HPTIME, range);
else if ((range = pc_checkskill(sd,TK_SPTIME)) > 0)
range = skill_get_splash(TK_SPTIME, range);
else
return 0;
if(type==1) { //When you sit down
if (map_foreachinrange(skill_rest_count,&sd->bl, range, BL_PC) > 1)
{
map_foreachinrange(skill_rest_in,&sd->bl, range, BL_PC);
sd->state.rest = 1;
status_calc_pc(sd,0);
}
return 0;
}
else if(type==0) { //When you stand up
if (map_foreachinrange(skill_rest_count,&sd->bl, range, BL_PC) < 2)
map_foreachinrange(skill_rest_out,&sd->bl, range, BL_PC);
sd->state.rest = 0;
status_calc_pc(sd,0);
return 0;
}
return 0;
}
/*==========================================
* 寒いジョーク・スクリーム判定処理(foreachinarea)
*------------------------------------------
*/
int skill_frostjoke_scream (struct block_list *bl, va_list ap)
{
struct block_list *src;
int skillnum,skilllv;
unsigned int tick;
nullpo_retr(0, bl);
nullpo_retr(0, ap);
nullpo_retr(0, src=va_arg(ap,struct block_list*));
skillnum=va_arg(ap,int);
skilllv=va_arg(ap,int);
if(skilllv <= 0) return 0;
tick=va_arg(ap,unsigned int);
if (src == bl || //自分には?かない
bl->prev == NULL ||
status_isdead(bl))
return 0;
if (bl->type == BL_PC) {
struct map_session_data *sd = (struct map_session_data *)bl;
if (sd && sd->sc.option&OPTION_INVISIBLE)
return 0;
}
//It has been reported that Scream/Joke works the same regardless of woe-setting. [Skotlex]
if(battle_check_target(src,bl,BCT_ENEMY) > 0)
skill_additional_effect(src,bl,skillnum,skilllv,BF_MISC,tick);
else if(battle_check_target(src,bl,BCT_PARTY) > 0 && rand()%100 < 10)
skill_additional_effect(src,bl,skillnum,skilllv,BF_MISC,tick);
return 0;
}
/*==========================================
* バジリカのセルを設定する
*------------------------------------------
*/
void skill_unitsetmapcell (struct skill_unit *src, int skill_num, int skill_lv, int flag)
{
int i,x,y,range = skill_get_unit_range(skill_num,skill_lv);
int size = range*2+1;
for (i=0;i<size*size;i++) {
x = src->bl.x+(i%size-range);
y = src->bl.y+(i/size-range);
map_setcell(src->bl.m,x,y,flag);
}
}
/*==========================================
* Sets a map cell around the caster, according to the skill's splash range.
*------------------------------------------
*/
void skill_setmapcell (struct block_list *src, int skill_num, int skill_lv, int flag)
{
int i,x,y,range = skill_get_splash(skill_num, skill_lv);
int size = range*2+1;
for (i=0;i<size*size;i++) {
x = src->x+(i%size-range);
y = src->y+(i/size-range);
map_setcell(src->m,x,y,flag);
}
}
/*==========================================
*
*------------------------------------------
*/
int skill_attack_area (struct block_list *bl, va_list ap)
{
struct block_list *src,*dsrc;
int atk_type,skillid,skilllv,flag,type;
unsigned int tick;
nullpo_retr(0, bl);
nullpo_retr(0, ap);
atk_type = va_arg(ap,int);
if((src=va_arg(ap,struct block_list*)) == NULL)
return 0;
if((dsrc=va_arg(ap,struct block_list*)) == NULL)
return 0;
skillid=va_arg(ap,int);
skilllv=va_arg(ap,int);
if(skillid > 0 && skilllv <= 0) return 0; // celest
tick=va_arg(ap,unsigned int);
flag=va_arg(ap,int);
type=va_arg(ap,int);
if(battle_check_target(dsrc,bl,type) > 0)
skill_attack(atk_type,src,dsrc,bl,skillid,skilllv,tick,flag);
return 0;
}
/*==========================================
*
*------------------------------------------
*/
int skill_clear_group (struct block_list *bl, int flag)
{
struct unit_data *ud = unit_bl2ud(bl);
struct skill_unit_group *group[MAX_SKILLUNITGROUP];
int i, count=0;
nullpo_retr(0, bl);
if (!ud) return 0;
//All groups to be deleted are first stored on an array since the array elements shift around when you delete them. [Skotlex]
for (i=0;i<MAX_SKILLUNITGROUP && ud->skillunit[i];i++)
{
switch (ud->skillunit[i]->skill_id) {
case SA_DELUGE:
case SA_VOLCANO:
case SA_VIOLENTGALE:
case SA_LANDPROTECTOR:
case NJ_SUITON:
if (flag&1)
group[count++]= ud->skillunit[i];
break;
default:
if (flag&2 && skill_get_inf2(ud->skillunit[i]->skill_id)&INF2_TRAP)
group[count++]= ud->skillunit[i];
break;
}
}
for (i=0;i<count;i++)
skill_delunitgroup(bl, group[i]);
return count;
}
/*==========================================
* Returns the first element field found [Skotlex]
*------------------------------------------
*/
struct skill_unit_group *skill_locate_element_field(struct block_list *bl)
{
struct unit_data *ud = unit_bl2ud(bl);
int i;
nullpo_retr(0, bl);
if (!ud) return NULL;
for (i=0;i<MAX_SKILLUNITGROUP && ud->skillunit[i];i++) {
switch (ud->skillunit[i]->skill_id) {
case SA_DELUGE:
case SA_VOLCANO:
case SA_VIOLENTGALE:
case SA_LANDPROTECTOR:
case NJ_SUITON:
return ud->skillunit[i];
}
}
return NULL;
}
// for graffiti cleaner [Valaris]
int skill_graffitiremover (struct block_list *bl, va_list ap)
{
struct skill_unit *unit=NULL;
nullpo_retr(0, bl);
nullpo_retr(0, ap);
if(bl->type!=BL_SKILL || (unit=(struct skill_unit *)bl) == NULL)
return 0;
if((unit->group) && (unit->group->unit_id == UNT_GRAFFITI))
skill_delunit(unit);
return 0;
}
int skill_greed (struct block_list *bl, va_list ap)
{
struct block_list *src;
struct map_session_data *sd=NULL;
struct flooritem_data *fitem=NULL;
nullpo_retr(0, bl);
nullpo_retr(0, ap);
nullpo_retr(0, src = va_arg(ap, struct block_list *));
if(src->type == BL_PC && (sd=(struct map_session_data *)src) && bl->type==BL_ITEM && (fitem=(struct flooritem_data *)bl))
pc_takeitem(sd, fitem);
return 0;
}
/*==========================================
* ランドプロテクターチェック(foreachinarea)
*------------------------------------------
*/
int skill_landprotector (struct block_list *bl, va_list ap)
{
int skillid;
int *alive;
struct skill_unit *unit;
struct block_list *src;
skillid = va_arg(ap,int);
alive = va_arg(ap,int *);
src = va_arg(ap,struct block_list *);
unit = (struct skill_unit *)bl;
if (unit == NULL || unit->group == NULL)
return 0;
if (skillid == SA_LANDPROTECTOR && unit->group->skill_id == SA_LANDPROTECTOR
&& battle_check_target(bl, src, BCT_ENEMY) > 0)
{ //Check for offensive Land Protector to delete both. [Skotlex]
(*alive) = 0;
skill_delunit(unit);
return 1;
}
if (skill_get_type(unit->group->skill_id) != BF_MAGIC)
return 0; //Only blocks out magical skills.
if (skillid == SA_LANDPROTECTOR || skillid == HW_GANBANTEIN ) {
skill_delunit(unit);
} else
if (unit->group->skill_id == SA_LANDPROTECTOR) {
(*alive) = 0;
} else
if (skillid == HP_BASILICA && unit->group->skill_id == HP_BASILICA) {
//Basilica can't be placed on top of itself to avoid map-cell stacking problems. [Skotlex]
(*alive) = 0;
} else
return 0;
return 1;
}
/*==========================================
* variation of skill_landprotector
*------------------------------------------
*/
int skill_ganbatein (struct block_list *bl, va_list ap)
{
struct skill_unit *unit;
nullpo_retr(0, bl);
nullpo_retr(0, ap);
if ((unit = (struct skill_unit *)bl) == NULL || unit->group == NULL)
return 0;
// Apparently, it REMOVES traps.
// if (skill_get_inf2(unit->group->skill_id)&INF2_TRAP)
// return 0; //Do not remove traps.
if (unit->group->skill_id == SA_LANDPROTECTOR)
skill_delunit(unit);
else skill_delunitgroup(NULL, unit->group);
return 1;
}
/*==========================================
* 指定範囲内でsrcに対して有効なターゲットのblの数を数える(foreachinarea)
*------------------------------------------
*/
int skill_count_target (struct block_list *bl, va_list ap)
{
struct block_list *src = va_arg(ap,struct block_list *);
if (battle_check_target(src,bl,BCT_ENEMY) > 0)
return 1;
return 0;
}
/*==========================================
* トラップ範囲処理(foreachinarea)
*------------------------------------------
*/
int skill_trap_splash (struct block_list *bl, va_list ap)
{
struct block_list *src;
int tick;
struct skill_unit *unit;
struct skill_unit_group *sg;
struct block_list *ss;
int i,count;
src = va_arg(ap,struct block_list *);
unit = (struct skill_unit *)src;
tick = va_arg(ap,int);
count = va_arg(ap,int);
nullpo_retr(0, sg = unit->group);
nullpo_retr(0, ss = map_id2bl(sg->src_id));
if(battle_check_target(src,bl,BCT_ENEMY) > 0){
switch(sg->unit_id){
case UNT_SHOCKWAVE:
case UNT_SANDMAN:
case UNT_FLASHER:
skill_additional_effect(ss,bl,sg->skill_id,sg->skill_lv,BF_MISC,tick);
break;
case UNT_BLASTMINE:
case UNT_CLAYMORETRAP:
//Special property: Each target is hit N times (N = number of targets on splash area)
if (!count) count = 1;
for(i=0;i<count;i++)
skill_attack(BF_MISC,ss,src,bl,sg->skill_id,sg->skill_lv,tick,0);
break;
case UNT_FREEZINGTRAP:
skill_attack(BF_WEAPON,ss,src,bl,sg->skill_id,sg->skill_lv,tick,0);
break;
}
}
return 0;
}
/*==========================================
* ステータス異常
*------------------------------------------
*/
int skill_enchant_elemental_end (struct block_list *bl, int type)
{
struct status_change *sc;
nullpo_retr(0, bl);
nullpo_retr(0, sc= status_get_sc(bl));
if (!sc->count) return 0;
if (type != SC_ENCPOISON && sc->data[SC_ENCPOISON].timer != -1)
status_change_end(bl, SC_ENCPOISON, -1);
if (type != SC_ASPERSIO && sc->data[SC_ASPERSIO].timer != -1)
status_change_end(bl, SC_ASPERSIO, -1);
if (type != SC_FIREWEAPON && sc->data[SC_FIREWEAPON].timer != -1)
status_change_end(bl, SC_FIREWEAPON, -1);
if (type != SC_WATERWEAPON && sc->data[SC_WATERWEAPON].timer != -1)
status_change_end(bl, SC_WATERWEAPON, -1);
if (type != SC_WINDWEAPON && sc->data[SC_WINDWEAPON].timer != -1)
status_change_end(bl, SC_WINDWEAPON, -1);
if (type != SC_EARTHWEAPON && sc->data[SC_EARTHWEAPON].timer != -1)
status_change_end(bl, SC_EARTHWEAPON, -1);
if (type != SC_SHADOWWEAPON && sc->data[SC_SHADOWWEAPON].timer != -1)
status_change_end(bl, SC_SHADOWWEAPON, -1);
if (type != SC_GHOSTWEAPON && sc->data[SC_GHOSTWEAPON].timer != -1)
status_change_end(bl, SC_GHOSTWEAPON, -1);
return 0;
}
int skill_check_cloaking(struct block_list *bl, struct status_change *sc)
{
static int dx[] = { 0, 1, 0, -1, -1, 1, 1, -1}; //optimized by Lupus
static int dy[] = {-1, 0, 1, 0, -1, -1, 1, 1};
int end = 1,i;
if ((bl->type == BL_PC && battle_config.pc_cloak_check_type&1) ||
(bl->type != BL_PC && battle_config.monster_cloak_check_type&1))
{ //Check for walls.
for (i = 0; i < 8; i++)
if (map_getcell(bl->m, bl->x+dx[i], bl->y+dy[i], CELL_CHKNOPASS))
{
end = 0;
break;
}
} else
end = 0; //No wall check.
if(end){
if (sc->data[SC_CLOAKING].timer != -1) {
if (sc->data[SC_CLOAKING].val1 < 3) //End cloaking.
status_change_end(bl, SC_CLOAKING, -1);
else if(sc->data[SC_CLOAKING].val4&2)
{ //Remove wall bonus
sc->data[SC_CLOAKING].val4&=~2;
status_calc_bl(bl,SCB_SPEED);
}
}
}
else if(sc->data[SC_CLOAKING].timer != -1 && !(sc->data[SC_CLOAKING].val4&2))
{ //Add wall speed bonus
sc->data[SC_CLOAKING].val4|=2;
status_calc_bl(bl,SCB_SPEED);
}
return end;
}
/*
*----------------------------------------------------------------------------
* スキルユニット
*----------------------------------------------------------------------------
*/
/*==========================================
* 演奏/ダンスをやめる
* flag 1で合奏中なら相方にユニットを任せる
*
*------------------------------------------
*/
void skill_stop_dancing (struct block_list *src)
{
struct status_change* sc;
struct skill_unit_group* group;
struct map_session_data* dsd = NULL;
nullpo_retv(src);
nullpo_retv(sc = status_get_sc(src));
if(!sc->count || sc->data[SC_DANCING].timer == -1)
return;
group = (struct skill_unit_group *)sc->data[SC_DANCING].val2;
sc->data[SC_DANCING].val2 = 0;
if (sc->data[SC_DANCING].val4)
{
if (sc->data[SC_DANCING].val4 != BCT_SELF)
dsd = map_id2sd(sc->data[SC_DANCING].val4);
sc->data[SC_DANCING].val4 = 0;
}
if (group)
skill_delunitgroup(NULL, group);
if (dsd)
{
dsd->sc.data[SC_DANCING].val4 = dsd->sc.data[SC_DANCING].val2 = 0;
status_change_end(&dsd->bl, SC_DANCING, -1);
}
status_change_end(src, SC_DANCING, -1);
}
/*==========================================
* スキルユニット初期化
*------------------------------------------
*/
struct skill_unit *skill_initunit (struct skill_unit_group *group, int idx, int x, int y, int val1, int val2)
{
struct skill_unit *unit;
nullpo_retr(NULL, group);
nullpo_retr(NULL, unit=&group->unit[idx]);
if(!unit->alive)
group->alive_count++;
unit->bl.id=map_addobject(&unit->bl);
unit->bl.type=BL_SKILL;
unit->bl.m=group->map;
unit->bl.x=x;
unit->bl.y=y;
unit->group=group;
unit->alive=1;
unit->val1=val1;
unit->val2=val2;
map_addblock(&unit->bl);
switch (group->skill_id) {
case AL_PNEUMA:
skill_unitsetmapcell(unit,AL_PNEUMA,group->skill_lv,CELL_SETPNEUMA);
break;
case MG_SAFETYWALL:
skill_unitsetmapcell(unit,MG_SAFETYWALL,group->skill_lv,CELL_SETSAFETYWALL);
break;
case SA_LANDPROTECTOR:
skill_unitsetmapcell(unit,SA_LANDPROTECTOR,group->skill_lv,CELL_SETLANDPROTECTOR);
break;
case HP_BASILICA:
skill_unitsetmapcell(unit,HP_BASILICA,group->skill_lv,CELL_SETBASILICA);
break;
case WZ_ICEWALL:
skill_unitsetmapcell(unit,WZ_ICEWALL,group->skill_lv,CELL_SETICEWALL);
break;
default:
if (group->state.song_dance) //Check for dissonance.
skill_dance_overlap(unit, 1);
break;
}
clif_skill_setunit(unit);
return unit;
}
/*==========================================
* スキルユニット削除
*------------------------------------------
*/
int skill_delunit (struct skill_unit *unit)
{
struct skill_unit_group *group;
nullpo_retr(0, unit);
if(!unit->alive)
return 0;
nullpo_retr(0, group=unit->group);
/* onlimitイベント呼び出し */
skill_unit_onlimit( unit,gettick() );
if (group->state.song_dance) //Restore dissonance effect.
skill_dance_overlap(unit, 0);
/* ondeleteイベント呼び出し */
if (!unit->range) {
map_foreachincell(skill_unit_effect,unit->bl.m,
unit->bl.x,unit->bl.y,group->bl_flag,&unit->bl,gettick(),4);
}
switch (group->skill_id) {
case AL_PNEUMA:
skill_unitsetmapcell(unit,AL_PNEUMA,group->skill_lv,CELL_CLRPNEUMA);
break;
case MG_SAFETYWALL:
skill_unitsetmapcell(unit,MG_SAFETYWALL,group->skill_lv,CELL_CLRSAFETYWALL);
break;
case SA_LANDPROTECTOR:
skill_unitsetmapcell(unit,SA_LANDPROTECTOR,group->skill_lv,CELL_CLRLANDPROTECTOR);
break;
case HP_BASILICA:
skill_unitsetmapcell(unit,HP_BASILICA,group->skill_lv,CELL_CLRBASILICA);
break;
case WZ_ICEWALL:
skill_unitsetmapcell(unit,WZ_ICEWALL,group->skill_lv,CELL_CLRICEWALL);
break;
}
clif_skill_delunit(unit);
unit->group=NULL;
unit->alive=0;
map_delobjectnofree(unit->bl.id);
if(--group->alive_count==0)
skill_delunitgroup(NULL, group);
return 0;
}
/*==========================================
* スキルユニットグループ初期化
*------------------------------------------
*/
static int skill_unit_group_newid = MAX_SKILL_DB;
struct skill_unit_group *skill_initunitgroup (struct block_list *src, int count, int skillid, int skilllv, int unit_id, int limit, int interval)
{
struct unit_data *ud = unit_bl2ud(src);
struct skill_unit_group *group=NULL;
int i;
if(skilllv <= 0) return 0;
nullpo_retr(NULL, src);
nullpo_retr(NULL, ud);
for(i=0;i<MAX_SKILLUNITGROUP && ud->skillunit[i]; i++);
if(i == MAX_SKILLUNITGROUP) {
int j=0;
unsigned maxdiff=0,x,tick=gettick();
for(i=0;i<MAX_SKILLUNITGROUP && ud->skillunit[i];i++)
if((x=DIFF_TICK(tick,ud->skillunit[i]->tick))>maxdiff){
maxdiff=x;
j=i;
}
skill_delunitgroup(src, ud->skillunit[j]);
//Since elements must have shifted, we use the last slot.
i = MAX_SKILLUNITGROUP-1;
}
if (!ud->skillunit[i])
ud->skillunit[i] = ers_alloc(skill_unit_ers, struct skill_unit_group);
group=ud->skillunit[i];
group->src_id=src->id;
group->party_id=status_get_party_id(src);
group->guild_id=status_get_guild_id(src);
group->group_id=skill_unit_group_newid++;
if(skill_unit_group_newid<=0)
skill_unit_group_newid = MAX_SKILL_DB;
group->unit=(struct skill_unit *)aCalloc(count,sizeof(struct skill_unit));
group->unit_count=count;
group->alive_count=0;
group->val1=group->val2=group->val3=0;
group->skill_id=skillid;
group->skill_lv=skilllv;
group->unit_id=unit_id;
group->map=src->m;
group->limit=limit;
group->interval=interval;
group->tick=gettick();
if (skillid == PR_SANCTUARY) //Sanctuary starts healing +1500ms after casted. [Skotlex]
group->tick += 1500;
else if (skillid == PA_GOSPEL) //Prevent Gospel from triggering bonuses right away. [Skotlex]
group->tick += interval;
group->valstr=NULL;
i = skill_get_unit_flag(skillid); //Reuse for faster access from here on. [Skotlex]
if (i&(UF_DANCE|UF_SONG|UF_ENSEMBLE)) {
struct map_session_data *sd = NULL;
if(src->type==BL_PC && (sd=(struct map_session_data *)src) ){
sd->skillid_dance=skillid;
sd->skilllv_dance=skilllv;
}
sc_start4(src,SC_DANCING,100,skillid,(int)group,0,(i&UF_ENSEMBLE?BCT_SELF:0),skill_get_time(skillid,skilllv)+1000);
//合奏スキルは相方をダンス状態にする
if (sd && i&UF_ENSEMBLE &&
battle_config.player_skill_partner_check &&
(!battle_config.gm_skilluncond || pc_isGM(sd) < battle_config.gm_skilluncond)
) {
skill_check_pc_partner(sd, skillid, &skilllv, 1, 1);
}
}
return group;
}
/*==========================================
* スキルユニットグループ削除
*------------------------------------------
*/
int skill_delunitgroup (struct block_list *src, struct skill_unit_group *group)
{
struct unit_data *ud;
int i,j;
nullpo_retr(0, group);
if (!src) src=map_id2bl(group->src_id);
ud = unit_bl2ud(src);
if(!src || !ud) {
ShowError("skill_delunitgroup: Group's source not found! (src_id: %d skill_id: %d)\n", group->src_id, group->skill_id);
return 0;
}
if (skill_get_unit_flag(group->skill_id)&(UF_DANCE|UF_SONG|UF_ENSEMBLE))
{
struct status_change* sc = status_get_sc(src);
if (sc && sc->data[SC_DANCING].timer != -1)
{
sc->data[SC_DANCING].val2 = 0 ; //This prevents status_change_end attempting to redelete the group. [Skotlex]
status_change_end(src,SC_DANCING,-1);
}
}
if (group->unit_id == UNT_GOSPEL) { //Clear Gospel [Skotlex]
struct status_change *sc = status_get_sc(src);
if(sc && sc->data[SC_GOSPEL].timer != -1) {
sc->data[SC_GOSPEL].val3 = 0; //Remove reference to this group. [Skotlex]
status_change_end(src,SC_GOSPEL,-1);
}
}
if (group->skill_id == SG_SUN_WARM ||
group->skill_id == SG_MOON_WARM ||
group->skill_id == SG_STAR_WARM) {
struct status_change *sc = status_get_sc(src);
if(sc && sc->data[SC_WARM].timer != -1) {
sc->data[SC_WARM].val4 = 0;
status_change_end(src,SC_WARM,-1);
}
}
if (src->type==BL_PC && group->state.ammo_consume)
battle_consume_ammo((TBL_PC*)src, group->skill_id, group->skill_lv);
group->alive_count=0;
if(group->unit!=NULL){
for(i=0;i<group->unit_count;i++)
if(group->unit[i].alive)
skill_delunit(&group->unit[i]);
}
if(group->valstr!=NULL){
aFree(group->valstr);
group->valstr=NULL;
}
map_freeblock((struct block_list*)group->unit); /* aFree()の替わり */
group->unit=NULL;
group->group_id=0;
group->unit_count=0;
//Locate and clear this unit from the array.
for (i=0; i<MAX_SKILLUNITGROUP && ud->skillunit[i]!=group; i++);
for (j=i; j<MAX_SKILLUNITGROUP && ud->skillunit[j]; j++);
j--;
if (i<MAX_SKILLUNITGROUP) {
ud->skillunit[i] = ud->skillunit[j];
ud->skillunit[j] = NULL;
ers_free(skill_unit_ers, group);
} else
ShowError("skill_delunitgroup: Group not found! (src_id: %d skill_id: %d)\n", group->src_id, group->skill_id);
return 1;
}
/*==========================================
* スキルユニットグループ全削除
*------------------------------------------
*/
int skill_clear_unitgroup (struct block_list *src)
{
struct unit_data *ud = unit_bl2ud(src);
nullpo_retr(0, ud);
while (ud->skillunit[0])
skill_delunitgroup(src, ud->skillunit[0]);
return 1;
}
/*==========================================
* スキルユニットグループの被影響tick検索
*------------------------------------------
*/
struct skill_unit_group_tickset *skill_unitgrouptickset_search (struct block_list *bl, struct skill_unit_group *group, int tick)
{
int i,j=-1,k,s,id;
struct unit_data *ud;
struct skill_unit_group_tickset *set;
nullpo_retr(0, bl);
if (group->interval==-1)
return NULL;
ud = unit_bl2ud(bl);
if (!ud) return NULL;
set = ud->skillunittick;
if (skill_get_unit_flag(group->skill_id)&UF_NOOVERLAP)
id = s = group->skill_id;
else
id = s = group->group_id;
for (i=0; i<MAX_SKILLUNITGROUPTICKSET; i++) {
k = (i+s) % MAX_SKILLUNITGROUPTICKSET;
if (set[k].id == id)
return &set[k];
else if (j==-1 && (DIFF_TICK(tick,set[k].tick)>0 || set[k].id==0))
j=k;
}
if (j == -1) {
if(battle_config.error_log) {
ShowWarning ("skill_unitgrouptickset_search: tickset is full\n");
}
j = id % MAX_SKILLUNITGROUPTICKSET;
}
set[j].id = id;
set[j].tick = tick;
return &set[j];
}
/*==========================================
* スキルユニットタイマー発動処理用(foreachinarea)
*------------------------------------------
*/
int skill_unit_timer_sub_onplace (struct block_list *bl, va_list ap)
{
struct skill_unit *unit;
struct skill_unit_group *group;
unsigned int tick;
nullpo_retr(0, bl);
nullpo_retr(0, ap);
unit = va_arg(ap,struct skill_unit *);
tick = va_arg(ap,unsigned int);
if (!unit->alive || bl->prev==NULL)
return 0;
nullpo_retr(0, group=unit->group);
if (skill_get_type(group->skill_id)==BF_MAGIC
&& map_getcell(bl->m, bl->x, bl->y, CELL_CHKLANDPROTECTOR))
return 0; //AoE skills are ineffective. [Skotlex]
if (battle_check_target(&unit->bl,bl,group->target_flag)<=0)
return 0;
skill_unit_onplace_timer(unit,bl,tick);
return 0;
}
/*==========================================
* スキルユニットタイマー処理用(foreachobject)
*------------------------------------------
*/
int skill_unit_timer_sub (struct block_list *bl, va_list ap)
{
struct skill_unit *unit;
struct skill_unit_group *group;
unsigned int tick;
nullpo_retr(0, bl);
nullpo_retr(0, ap);
nullpo_retr(0, unit=(struct skill_unit *)bl);
tick=va_arg(ap,unsigned int);
if(!unit->alive)
return 0;
group=unit->group;
nullpo_retr(0, group);
/* onplace_timerイベント呼び出し */
if (unit->range>=0 && group->interval!=-1) {
if (battle_config.skill_wall_check)
map_foreachinshootrange(skill_unit_timer_sub_onplace, bl, unit->range,
group->bl_flag,bl,tick);
else
map_foreachinrange(skill_unit_timer_sub_onplace, bl, unit->range,
group->bl_flag,bl,tick);
if (!unit->alive)
return 0;
}
/* 時間切れ削除 */
if((DIFF_TICK(tick,group->tick)>=group->limit || DIFF_TICK(tick,group->tick)>=unit->limit)){
switch(group->unit_id){
case UNT_BLASTMINE:
group->unit_id = UNT_USED_TRAPS;
clif_changetraplook(bl, UNT_USED_TRAPS);
group->limit=DIFF_TICK(tick+1500,group->tick);
unit->limit=DIFF_TICK(tick+1500,group->tick);
break;
case UNT_SKIDTRAP:
case UNT_ANKLESNARE:
case UNT_LANDMINE:
case UNT_SHOCKWAVE:
case UNT_SANDMAN:
case UNT_FLASHER:
case UNT_FREEZINGTRAP:
case UNT_CLAYMORETRAP:
case UNT_TALKIEBOX:
{
struct block_list *src=map_id2bl(group->src_id);
if(group->unit_id == UNT_ANKLESNARE && group->val2);
else{
if(src && src->type==BL_PC && !group->state.into_abyss)
{ //Avoid generating trap items when it did not cost to create them. [Skotlex]
struct item item_tmp;
memset(&item_tmp,0,sizeof(item_tmp));
item_tmp.nameid=1065;
item_tmp.identify=1;
map_addflooritem(&item_tmp,1,bl->m,bl->x,bl->y,NULL,NULL,NULL,0); // 罠返還
}
}
skill_delunit(unit);
}
break;
case 0xc1:
case 0xc2:
case 0xc3:
case 0xc4:
{
struct block_list *src=map_id2bl(group->src_id);
if (src)
group->tick = tick;
}
break;
default:
skill_delunit(unit);
}
}
if(group->unit_id == UNT_ICEWALL) {
unit->val1 -= 5;
if(unit->val1 <= 0 && unit->limit + group->tick > tick + 700)
unit->limit = DIFF_TICK(tick+700,group->tick);
}
return 0;
}
/*==========================================
* スキルユニットタイマー処理
*------------------------------------------
*/
int skill_unit_timer (int tid, unsigned int tick, int id, int data)
{
map_freeblock_lock();
map_foreachobject( skill_unit_timer_sub, BL_SKILL, tick );
map_freeblock_unlock();
return 0;
}
/*==========================================
* スキルユニット移動時処理用(foreachinarea)
*------------------------------------------
*/
int skill_unit_move_sub (struct block_list *bl, va_list ap)
{
struct skill_unit *unit = (struct skill_unit *)bl;
struct block_list *target;
unsigned int tick,flag,result;
int skill_id;
target=va_arg(ap,struct block_list*);
tick = va_arg(ap,unsigned int);
flag = va_arg(ap,int);
nullpo_retr(0, unit->group);
if (!(unit->group->bl_flag&target->type))
return 0; //we don't target this type of bl
skill_id = unit->group->skill_id; //Necessary in case the group is deleted after calling on_place/on_out [Skotlex]
if (unit->group->interval!=-1 &&
!(skill_get_unit_flag(skill_id)&UF_DUALMODE)) //Skills in dual mode have to trigger both. [Skotlex]
return 0;
if (!unit->alive || target->prev==NULL)
return 0;
if (flag&1)
{
result = skill_unit_onplace(unit,target,tick);
if (flag&2 && result)
{ //Clear skill ids we have stored in onout.
int i;
for(i=0; i<8 && skill_unit_temp[i]!=result; i++);
if (i<8)
skill_unit_temp[i] = 0;
}
}
else
{
result = skill_unit_onout(unit,target,tick);
if (flag&2 && skill_unit_index < 7 && result) //Store this unit id.
skill_unit_temp[skill_unit_index++] = result;
}
if (flag&4)
skill_unit_onleft(skill_id,target,tick);
return 1;
}
/*==========================================
* Invoked when a char has moved and unit cells must be invoked (onplace, onout, onleft)
* Flag values:
* flag&1: invoke skill_unit_onplace (otherwise invoke skill_unit_onout)
* flag&2: this function is being invoked twice as a bl moves, store in memory the affected
* units to figure out when they have left a group.
* flag&4: Force a onleft event (triggered when the bl is killed, for example)
*------------------------------------------
*/
int skill_unit_move (struct block_list *bl, unsigned int tick, int flag)
{
nullpo_retr(0, bl);
if(bl->prev==NULL )
return 0;
if (flag&2 && !(flag&1))
{ //Onout, clear data
memset (&skill_unit_temp,0,sizeof(skill_unit_temp));
skill_unit_index=0;
}
map_foreachincell(skill_unit_move_sub,
bl->m,bl->x,bl->y,BL_SKILL,bl,tick,flag);
if (flag&2 && flag&1)
{ //Onplace, check any skill units you have left.
int i;
for (i=0; i< 8 && skill_unit_temp[i]>0; i++)
skill_unit_onleft(skill_unit_temp[i], bl, tick);
}
return 0;
}
/*==========================================
* スキルユニット自体の移動時処理
* 引数はグループと移動量
*------------------------------------------
*/
int skill_unit_move_unit_group (struct skill_unit_group *group, int m, int dx, int dy)
{
int i,j;
unsigned int tick = gettick();
int *m_flag;
struct skill_unit *unit1;
struct skill_unit *unit2;
nullpo_retr(0, group);
if (group->unit_count<=0)
return 0;
if (group->unit==NULL)
return 0;
if (skill_get_unit_flag(group->skill_id)&UF_ENSEMBLE) //Ensembles may not be moved around.
return 0;
m_flag = (int *) aMalloc(sizeof(int)*group->unit_count);
memset(m_flag,0,sizeof(int)*group->unit_count);
// m_flag
// 0: Neither of the following (skill_unit_onplace & skill_unit_onout are needed)
// 1: Unit will move to a slot that had another unit of the same group (skill_unit_onplace not needed)
// 2: Another unit from same group will end up positioned on this unit (skill_unit_onout not needed)
// 3: Both 1+2.
for(i=0;i<group->unit_count;i++){
unit1=&group->unit[i];
if (!unit1->alive || unit1->bl.m!=m)
continue;
for(j=0;j<group->unit_count;j++){
unit2=&group->unit[j];
if (!unit2->alive)
continue;
if (unit1->bl.x+dx==unit2->bl.x && unit1->bl.y+dy==unit2->bl.y){
m_flag[i] |= 0x1;
}
if (unit1->bl.x-dx==unit2->bl.x && unit1->bl.y-dy==unit2->bl.y){
m_flag[i] |= 0x2;
}
}
}
j = 0;
for (i=0;i<group->unit_count;i++) {
unit1=&group->unit[i];
if (!unit1->alive)
continue;
if (!(m_flag[i]&0x2)) {
if (group->state.song_dance) //Restore dissonance effect.
skill_dance_overlap(unit1, 0);
map_foreachincell(skill_unit_effect,unit1->bl.m,
unit1->bl.x,unit1->bl.y,group->bl_flag,&unit1->bl,tick,4);
}
//Move Cell using "smart" criteria (avoid useless moving around)
switch(m_flag[i])
{
case 0:
//Cell moves independently, safely move it.
map_moveblock(&unit1->bl, unit1->bl.x+dx, unit1->bl.y+dy, tick);
break;
case 1:
//Cell moves unto another cell, look for a replacement cell that won't collide
//and has no cell moving into it (flag == 2)
for(;j<group->unit_count;j++)
{
if(m_flag[j]!=2 || !group->unit[j].alive)
continue;
//Move to where this cell would had moved.
unit2 = &group->unit[j];
map_moveblock(&unit1->bl, unit2->bl.x+dx, unit2->bl.y+dy, tick);
j++; //Skip this cell as we have used it.
break;
}
break;
case 2:
case 3:
break; //Don't move the cell as a cell will end on this tile anyway.
}
if (!(m_flag[i]&0x2)) { //We only moved the cell in 0-1
if (group->state.song_dance) //Check for dissonance effect.
skill_dance_overlap(unit1, 1);
clif_skill_setunit(unit1);
map_foreachincell(skill_unit_effect,unit1->bl.m,
unit1->bl.x,unit1->bl.y,group->bl_flag,&unit1->bl,tick,1);
}
}
aFree(m_flag);
return 0;
}
/*----------------------------------------------------------------------------
* アイテム合成
*----------------------------------------------------------------------------
*/
/*==========================================
* アイテム合成可能判定
*------------------------------------------
*/
int skill_can_produce_mix (struct map_session_data *sd, int nameid, int trigger, int qty)
{
int i,j;
nullpo_retr(0, sd);
if(nameid<=0)
return 0;
for(i=0;i<MAX_SKILL_PRODUCE_DB;i++){
if(skill_produce_db[i].nameid == nameid )
break;
}
if( i >= MAX_SKILL_PRODUCE_DB ) /* データベースにない */
return 0;
if(trigger>=0){
if(trigger>20) { // Non-weapon, non-food item (itemlv must match)
if(skill_produce_db[i].itemlv!=trigger)
return 0;
} else if(trigger>10) { // Food (any item level between 10 and 20 will do)
if(skill_produce_db[i].itemlv<=10)
return 0;
} else { // Weapon (itemlv must be higher or equal)
if(skill_produce_db[i].itemlv>trigger)
return 0;
}
}
if( (j=skill_produce_db[i].req_skill)>0 && pc_checkskill(sd,j)<=0 )
return 0; /* スキルが足りない */
for(j=0;j<MAX_PRODUCE_RESOURCE;j++){
int id,x,y;
if( (id=skill_produce_db[i].mat_id[j]) <= 0 ) /* これ以上は材料要らない */
continue;
if(skill_produce_db[i].mat_amount[j] <= 0) {
if(pc_search_inventory(sd,id) < 0)
return 0;
}
else {
for(y=0,x=0;y<MAX_INVENTORY;y++)
if( sd->status.inventory[y].nameid == id )
x+=sd->status.inventory[y].amount;
if(x<qty*skill_produce_db[i].mat_amount[j]) /* アイテムが足りない */
return 0;
}
}
return i+1;
}
/*==========================================
* アイテム合成可能判定
*------------------------------------------
*/
int skill_produce_mix (struct map_session_data *sd, int skill_id, int nameid, int slot1, int slot2, int slot3, int qty)
{
int slot[3];
int i,sc,ele,idx,equip,wlv,make_per,flag;
struct status_data *status;
nullpo_retr(0, sd);
status = status_get_status_data(&sd->bl);
if( !(idx=skill_can_produce_mix(sd,nameid,-1, qty)) ) /* 条件不足 */
return 0;
idx--;
if (qty < 1)
qty = 1;
if (!skill_id) //A skill can be specified for some override cases.
skill_id = skill_produce_db[idx].req_skill;
slot[0]=slot1;
slot[1]=slot2;
slot[2]=slot3;
/* 埋め込み処理 */
for(i=0,sc=0,ele=0;i<3;i++){ //Note that qty should always be one if you are using these!
int j;
if( slot[i]<=0 )
continue;
j = pc_search_inventory(sd,slot[i]);
if(j < 0) /* 不正パケット(アイテム存在)チェック */
continue;
if(slot[i]==1000){ /* Star Crumb */
pc_delitem(sd,j,1,1);
sc++;
}
if(slot[i]>=994 && slot[i]<=997 && ele==0){ /* Flame Heart . . . Great Nature */
static const int ele_table[4]={3,1,4,2};
pc_delitem(sd,j,1,1);
ele=ele_table[slot[i]-994];
}
}
/* 材料消費 */
for(i=0;i<MAX_PRODUCE_RESOURCE;i++){
int j,id,x;
if( (id=skill_produce_db[idx].mat_id[i]) <= 0 )
continue;
x=qty*skill_produce_db[idx].mat_amount[i]; /* 必要な個数 */
do{ /* ２つ以上のインデックスにまたがっているかもしれない */
int y=0;
j = pc_search_inventory(sd,id);
if(j >= 0){
y = sd->status.inventory[j].amount;
if(y>x)y=x; /* 足りている */
pc_delitem(sd,j,y,0);
}else {
if(battle_config.error_log)
ShowError("skill_produce_mix: material item error\n");
}
x-=y; /* まだ足りない個数を計算 */
}while( j>=0 && x>0 ); /* 材料を消費するか、エラーになるまで繰り返す */
}
if((equip=itemdb_isequip(nameid)))
wlv = itemdb_wlv(nameid);
if(!equip) {
switch(skill_id){
case BS_IRON:
case BS_STEEL:
case BS_ENCHANTEDSTONE:
// Ores & Metals Refining - skill bonuses are straight from kRO website [DracoRPG]
i = pc_checkskill(sd,skill_id);
make_per = sd->status.job_level*20 + status->dex*10 + status->luk*10; //Base chance
switch(nameid){
case 998: // Iron
make_per += 4000+i*500; // Temper Iron bonus: +26/+32/+38/+44/+50
break;
case 999: // Steel
make_per += 3000+i*500; // Temper Steel bonus: +35/+40/+45/+50/+55
break;
case 1000: //Star Crumb
make_per = 100000; // Star Crumbs are 100% success crafting rate? (made 1000% so it succeeds even after penalties) [Skotlex]
break;
default: // Enchanted Stones
make_per += 1000+i*500; // Enchantedstone Craft bonus: +15/+20/+25/+30/+35
break;
}
break;
case ASC_CDP:
make_per = (2000 + 40*status->dex + 20*status->luk);
break;
case AL_HOLYWATER:
make_per = 100000; //100% success
break;
case AM_PHARMACY: // Potion Preparation - reviewed with the help of various Ragnainfo sources [DracoRPG]
case AM_TWILIGHT1:
case AM_TWILIGHT2:
case AM_TWILIGHT3:
make_per = pc_checkskill(sd,AM_LEARNINGPOTION)*100
+ pc_checkskill(sd,AM_PHARMACY)*300 + sd->status.job_level*20
+ status->int_*5 + status->dex*10+status->luk*10;
switch(nameid){
case 501: // Red Potion
case 503: // Yellow Potion
case 504: // White Potion
case 605: // Anodyne
case 606: // Aloevera
make_per += 2000;
break;
case 505: // Blue Potion
make_per -= 500;
break;
case 545: // Condensed Red Potion
case 546: // Condensed Yellow Potion
case 547: // Condensed White Potion
make_per -= 1000;
break;
case 970: // Alcohol
make_per += 1000;
break;
case 7139: // Glistening Coat
make_per -= 1000;
break;
case 7135: // Bottle Grenade
case 7136: // Acid Bottle
case 7137: // Plant Bottle
case 7138: // Marine Sphere Bottle
default:
break;
}
if(battle_config.pp_rate != 100)
make_per = make_per * battle_config.pp_rate / 100;
break;
case SA_CREATECON: // Elemental Converter Creation - skill bonuses are from kRO [DracoRPG]
make_per = pc_checkskill(sd, SA_ADVANCEDBOOK)*100 + //TODO: Advanced Book bonus is custom! [Skotlex]
sd->status.job_level*20 + status->int_*10 + status->dex*10;
switch(nameid){
case 12114:
flag = pc_checkskill(sd,SA_FLAMELAUNCHER);
if (flag > 0)
make_per += 1000*flag-500;
break;
case 12115:
flag = pc_checkskill(sd,SA_FROSTWEAPON);
if (flag > 0)
make_per += 1000*flag-500;
break;
case 12116:
flag = pc_checkskill(sd,SA_SEISMICWEAPON);
if (flag > 0)
make_per += 1000*flag-500;
break;
case 12117:
flag = pc_checkskill(sd,SA_LIGHTNINGLOADER);
if (flag > 0)
make_per += 1000*flag-500;
break;
}
break;
default:
if (sd->menuskill_id == AM_PHARMACY &&
sd->menuskill_lv > 10 && sd->menuskill_lv <= 20)
{ //Assume Cooking Dish
if (sd->menuskill_lv >= 15) //Legendary Cooking Set.
make_per = 10000; //100% Success
else
make_per = 1200*(sd->menuskill_lv-10) //12% chance per set level.
+ 7000 - 700*(skill_produce_db[idx].itemlv-10); //70% - 7% per dish level
break;
}
make_per = 5000;
break;
}
} else { // Weapon Forging - skill bonuses are straight from kRO website, other things from a jRO calculator [DracoRPG]
make_per = 5000 + sd->status.job_level*20 + status->dex*10 + status->luk*10; // Base
make_per += pc_checkskill(sd,skill_id)*500; // Smithing skills bonus: +5/+10/+15
make_per += pc_checkskill(sd,BS_WEAPONRESEARCH)*100 +((wlv >= 3)? pc_checkskill(sd,BS_ORIDEOCON)*100:0); // Weaponry Research bonus: +1/+2/+3/+4/+5/+6/+7/+8/+9/+10, Oridecon Research bonus (custom): +1/+2/+3/+4/+5
make_per -= (ele?2000:0) + sc*1500 + (wlv>1?wlv*1000:0); // Element Stone: -20%, Star Crumb: -15% each, Weapon level malus: -0/-20/-30
if(pc_search_inventory(sd,989) > 0) make_per+= 1000; // Emperium Anvil: +10
else if(pc_search_inventory(sd,988) > 0) make_per+= 500; // Golden Anvil: +5
else if(pc_search_inventory(sd,987) > 0) make_per+= 300; // Oridecon Anvil: +3
else if(pc_search_inventory(sd,986) > 0) make_per+= 0; // Anvil: +0?
if(battle_config.wp_rate != 100)
make_per = make_per * battle_config.wp_rate / 100;
}
// - Baby Class Penalty = 80% (from adult's chance) ----//
if (sd->class_&JOBL_BABY) //if it's a Baby Class
make_per = (make_per * 80) / 100; //Lupus
if(make_per < 1) make_per = 1;
if(rand()%10000 < make_per || qty > 1){ //Success, or crafting multiple items.
struct item tmp_item;
memset(&tmp_item,0,sizeof(tmp_item));
tmp_item.nameid=nameid;
tmp_item.amount=1;
tmp_item.identify=1;
if(equip){
tmp_item.card[0]=CARD0_FORGE;
tmp_item.card[1]=((sc*5)<<8)+ele;
tmp_item.card[2]=GetWord(sd->char_id,0); // CharId
tmp_item.card[3]=GetWord(sd->char_id,1);
} else {
//Flag is only used on the end, so it can be used here. [Skotlex]
switch (skill_id) {
case AM_PHARMACY:
case AM_TWILIGHT1:
case AM_TWILIGHT2:
case AM_TWILIGHT3:
flag = battle_config.produce_potion_name_input;
break;
case AL_HOLYWATER:
flag = battle_config.holywater_name_input;
break;
case ASC_CDP:
flag = battle_config.cdp_name_input;
break;
default:
flag = battle_config.produce_item_name_input;
break;
}
if (flag) {
tmp_item.card[0]=CARD0_CREATE;
tmp_item.card[1]=0;
tmp_item.card[2]=GetWord(sd->char_id,0); // CharId
tmp_item.card[3]=GetWord(sd->char_id,1);
}
}
// if(log_config.produce > 0)
// log_produce(sd,nameid,slot1,slot2,slot3,1);
//TODO update PICKLOG
if(equip){
clif_produceeffect(sd,0,nameid);
clif_misceffect(&sd->bl,3);
if(itemdb_wlv(nameid) >= 3 && ((ele? 1 : 0) + sc) >= 3) // Fame point system [DracoRPG]
pc_addfame(sd,10); // Success to forge a lv3 weapon with 3 additional ingredients = +10 fame point
} else {
int fame = 0;
tmp_item.amount = 0;
for (i=0; i< qty; i++)
{ //Apply quantity modifiers.
if (rand()%10000 < make_per || qty == 1)
{ //Success
tmp_item.amount++;
if(nameid < 545 || nameid > 547)
continue;
if(skill_id != AM_PHARMACY &&
skill_id != AM_TWILIGHT1 &&
skill_id != AM_TWILIGHT2 &&
skill_id != AM_TWILIGHT3)
continue;
//Add fame as needed.
switch(++sd->potion_success_counter) {
case 3:
fame+=1; // Success to prepare 3 Condensed Potions in a row
break;
case 5:
fame+=3; // Success to prepare 5 Condensed Potions in a row
break;
case 7:
fame+=10; // Success to prepare 7 Condensed Potions in a row
break;
case 10:
fame+=50; // Success to prepare 10 Condensed Potions in a row
sd->potion_success_counter = 0;
break;
}
} else //Failure
sd->potion_success_counter = 0;
}
if (fame)
pc_addfame(sd,fame);
//Visual effects and the like.
switch (skill_id) {
case AM_PHARMACY:
case AM_TWILIGHT1:
case AM_TWILIGHT2:
case AM_TWILIGHT3:
case ASC_CDP:
clif_produceeffect(sd,2,nameid);
clif_misceffect(&sd->bl,5);
break;
case BS_IRON:
case BS_STEEL:
case BS_ENCHANTEDSTONE:
clif_produceeffect(sd,0,nameid);
clif_misceffect(&sd->bl,3);
break;
default: //Those that don't require a skill?
if (skill_produce_db[idx].itemlv>10 &&
skill_produce_db[idx].itemlv<= 20) //Cooking items.
clif_specialeffect(&sd->bl, 608, AREA);
break;
}
}
if (tmp_item.amount) { //Success
if((flag = pc_additem(sd,&tmp_item,tmp_item.amount))) {
clif_additem(sd,0,0,flag);
map_addflooritem(&tmp_item,tmp_item.amount,sd->bl.m,sd->bl.x,sd->bl.y,NULL,NULL,NULL,0);
}
return 1;
}
}
//Failure
// if(log_config.produce)
// log_produce(sd,nameid,slot1,slot2,slot3,0);
//TODO update PICKLOG
if(equip){
clif_produceeffect(sd,1,nameid);
clif_misceffect(&sd->bl,2);
} else {
switch (skill_id) {
case ASC_CDP: //50% Damage yourself, and display same effect as failed potion.
status_percent_damage(NULL, &sd->bl, -50, 0);
case AM_PHARMACY:
case AM_TWILIGHT1:
case AM_TWILIGHT2:
case AM_TWILIGHT3:
clif_produceeffect(sd,3,nameid);
clif_misceffect(&sd->bl,6);
sd->potion_success_counter = 0; // Fame point system [DracoRPG]
break;
case BS_IRON:
case BS_STEEL:
case BS_ENCHANTEDSTONE:
clif_produceeffect(sd,1,nameid);
clif_misceffect(&sd->bl,2);
break;
default:
if (skill_produce_db[idx].itemlv>10 &&
skill_produce_db[idx].itemlv<= 20) //Cooking items.
clif_specialeffect(&sd->bl, 609, AREA);
}
}
return 0;
}
int skill_arrow_create (struct map_session_data *sd, int nameid)
{
int i,j,flag,index=-1;
struct item tmp_item;
nullpo_retr(0, sd);
if(nameid <= 0)
return 1;
for(i=0;i<MAX_SKILL_ARROW_DB;i++)
if(nameid == skill_arrow_db[i].nameid) {
index = i;
break;
}
if(index < 0 || (j = pc_search_inventory(sd,nameid)) < 0)
return 1;
pc_delitem(sd,j,1,0);
for(i=0;i<5;i++) {
memset(&tmp_item,0,sizeof(tmp_item));
tmp_item.identify = 1;
tmp_item.nameid = skill_arrow_db[index].cre_id[i];
tmp_item.amount = skill_arrow_db[index].cre_amount[i];
if(battle_config.making_arrow_name_input) {
tmp_item.card[0]=CARD0_CREATE;
tmp_item.card[1]=0;
tmp_item.card[2]=GetWord(sd->char_id,0); // CharId
tmp_item.card[3]=GetWord(sd->char_id,1);
}
if(tmp_item.nameid <= 0 || tmp_item.amount <= 0)
continue;
if((flag = pc_additem(sd,&tmp_item,tmp_item.amount))) {
clif_additem(sd,0,0,flag);
map_addflooritem(&tmp_item,tmp_item.amount,sd->bl.m,sd->bl.x,sd->bl.y,NULL,NULL,NULL,0);
}
}
return 0;
}
/*==========================================
*
*------------------------------------------
*/
int skill_blockpc_end (int tid, unsigned int tick, int id, int data)
{
struct map_session_data *sd = map_id2sd(id);
if (data <= 0 || data >= MAX_SKILL)
return 0;
if (sd) sd->blockskill[data] = 0;
return 1;
}
int skill_blockpc_start(struct map_session_data *sd, int skillid, int tick)
{
nullpo_retr (-1, sd);
if (skillid >= GD_SKILLBASE)
skillid = GD_SKILLRANGEMIN + skillid - GD_SKILLBASE;
if (skillid < 1 || skillid > MAX_SKILL)
return -1;
sd->blockskill[skillid] = 1;
return add_timer(gettick()+tick,skill_blockpc_end,sd->bl.id,skillid);
}
/*----------------------------------------------------------------------------
* 初期化系
*/
/*
* 文字列処理
* ',' で区切って val に戻す
*/
int skill_split_str (char *str, char **val, int num)
{
int i;
for (i=0; i<num && str; i++){
val[i] = str;
str = strchr(str,',');
if (str)
*str++=0;
}
return i;
}
/*
* 文字列処理
* ':' で区切ってatoiしてvalに戻す
*/
int skill_split_atoi (char *str, int *val)
{
int i, j, diff, step = 1;
for (i=0; i<MAX_SKILL_LEVEL; i++) {
if (!str) break;
val[i] = atoi(str);
str = strchr(str,':');
if (str)
*str++=0;
}
if(i==0) //No data found.
return 0;
if(i==1)
{ //Single value, have the whole range have the same value.
for (; i < MAX_SKILL_LEVEL; i++)
val[i] = val[i-1];
return i;
}
//Check for linear change with increasing steps until we reach half of the data acquired.
for (step = 1; step <= i/2; step++)
{
diff = val[i-1] - val[i-step-1];
for(j = i-1; j >= step; j--)
if ((val[j]-val[j-step]) != diff)
break;
if (j>=step) //No match, try next step.
continue;
for(; i < MAX_SKILL_LEVEL; i++)
{ //Apply linear increase
val[i] = val[i-step]+diff;
if (val[i] < 1 && val[i-1] >=0) //Check if we have switched from + to -, cap the decrease to 0 in said cases.
{ val[i] = 1; diff = 0; step = 1; }
}
return i;
}
//Okay.. we can't figure this one out, just fill out the stuff with the previous value.
for (;i<MAX_SKILL_LEVEL; i++)
val[i] = val[i-1];
return i;
}
/*
* スキルユニットの配置情報作成
*/
void skill_init_unit_layout (void)
{
int i,j,size,pos = 0;
memset(skill_unit_layout,0,sizeof(skill_unit_layout));
// 矩形のユニット配置を作成する
for (i=0; i<=MAX_SQUARE_LAYOUT; i++) {
size = i*2+1;
skill_unit_layout[i].count = size*size;
for (j=0; j<size*size; j++) {
skill_unit_layout[i].dx[j] = (j%size-i);
skill_unit_layout[i].dy[j] = (j/size-i);
}
}
pos = i;
// 矩形以外のユニット配置を作成する
for (i=0;i<MAX_SKILL_DB;i++) {
if (!skill_db[i].unit_id[0] || skill_db[i].unit_layout_type[0] != -1)
continue;
switch (i) {
case MG_FIREWALL:
case WZ_ICEWALL:
// ファイアーウォール、アイスウォールは方向で変わるので別処理
break;
case PR_SANCTUARY:
{
static const int dx[] = {
-1, 0, 1,-2,-1, 0, 1, 2,-2,-1,
0, 1, 2,-2,-1, 0, 1, 2,-1, 0, 1};
static const int dy[]={
-2,-2,-2,-1,-1,-1,-1,-1, 0, 0,
0, 0, 0, 1, 1, 1, 1, 1, 2, 2, 2};
skill_unit_layout[pos].count = 21;
memcpy(skill_unit_layout[pos].dx,dx,sizeof(dx));
memcpy(skill_unit_layout[pos].dy,dy,sizeof(dy));
break;
}
case PR_MAGNUS:
{
static const int dx[] = {
-1, 0, 1,-1, 0, 1,-3,-2,-1, 0,
1, 2, 3,-3,-2,-1, 0, 1, 2, 3,
-3,-2,-1, 0, 1, 2, 3,-1, 0, 1,-1, 0, 1};
static const int dy[] = {
-3,-3,-3,-2,-2,-2,-1,-1,-1,-1,
-1,-1,-1, 0, 0, 0, 0, 0, 0, 0,
1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 3, 3, 3};
skill_unit_layout[pos].count = 33;
memcpy(skill_unit_layout[pos].dx,dx,sizeof(dx));
memcpy(skill_unit_layout[pos].dy,dy,sizeof(dy));
break;
}
case AS_VENOMDUST:
{
static const int dx[] = {-1, 0, 0, 0, 1};
static const int dy[] = { 0,-1, 0, 1, 0};
skill_unit_layout[pos].count = 5;
memcpy(skill_unit_layout[pos].dx,dx,sizeof(dx));
memcpy(skill_unit_layout[pos].dy,dy,sizeof(dy));
break;
}
case CR_GRANDCROSS:
case NPC_GRANDDARKNESS:
{
static const int dx[] = {
0, 0,-1, 0, 1,-2,-1, 0, 1, 2,
-4,-3,-2,-1, 0, 1, 2, 3, 4,-2,
-1, 0, 1, 2,-1, 0, 1, 0, 0};
static const int dy[] = {
-4,-3,-2,-2,-2,-1,-1,-1,-1,-1,
0, 0, 0, 0, 0, 0, 0, 0, 0, 1,
1, 1, 1, 1, 2, 2, 2, 3, 4};
skill_unit_layout[pos].count = 29;
memcpy(skill_unit_layout[pos].dx,dx,sizeof(dx));
memcpy(skill_unit_layout[pos].dy,dy,sizeof(dy));
break;
}
case PF_FOGWALL:
{
static const int dx[] = {
-2,-1, 0, 1, 2,-2,-1, 0, 1, 2,-2,-1, 0, 1, 2};
static const int dy[] = {
-1,-1,-1,-1,-1, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1};
skill_unit_layout[pos].count = 15;
memcpy(skill_unit_layout[pos].dx,dx,sizeof(dx));
memcpy(skill_unit_layout[pos].dy,dy,sizeof(dy));
break;
}
case PA_GOSPEL:
{
static const int dx[] = {
-1, 0, 1,-1, 0, 1,-3,-2,-1, 0,
1, 2, 3,-3,-2,-1, 0, 1, 2, 3,
-3,-2,-1, 0, 1, 2, 3,-1, 0, 1,
-1, 0, 1};
static const int dy[] = {
-3,-3,-3,-2,-2,-2,-1,-1,-1,-1,
-1,-1,-1, 0, 0, 0, 0, 0, 0, 0,
1, 1, 1, 1, 1, 1, 1, 2, 2, 2,
3, 3, 3};
skill_unit_layout[pos].count = 33;
memcpy(skill_unit_layout[pos].dx,dx,sizeof(dx));
memcpy(skill_unit_layout[pos].dy,dy,sizeof(dy));
break;
}
case NJ_TATAMIGAESHI:
{
//Level 1 (count 4, cross of 3x3)
static const int dx1[] = {-1, 1, 0, 0};
static const int dy1[] = { 0, 0,-1, 1};
//Level 2-3 (count 8, cross of 5x5)
static const int dx2[] = {-2,-1, 1, 2, 0, 0, 0, 0};
static const int dy2[] = { 0, 0, 0, 0,-2,-1, 1, 2};
//Level 4-5 (count 12, cross of 7x7
static const int dx3[] = {-3,-2,-1, 1, 2, 3, 0, 0, 0, 0, 0, 0};
static const int dy3[] = { 0, 0, 0, 0, 0, 0,-3,-2,-1, 1, 2, 3};
//lv1
j = 0;
skill_unit_layout[pos].count = 4;
memcpy(skill_unit_layout[pos].dx,dx1,sizeof(dx1));
memcpy(skill_unit_layout[pos].dy,dy1,sizeof(dy1));
skill_db[i].unit_layout_type[j] = pos;
//lv2/3
j++;
pos++;
skill_unit_layout[pos].count = 8;
memcpy(skill_unit_layout[pos].dx,dx2,sizeof(dx2));
memcpy(skill_unit_layout[pos].dy,dy2,sizeof(dy2));
skill_db[i].unit_layout_type[j] = pos;
skill_db[i].unit_layout_type[++j] = pos;
//lv4/5
j++;
pos++;
skill_unit_layout[pos].count = 12;
memcpy(skill_unit_layout[pos].dx,dx3,sizeof(dx3));
memcpy(skill_unit_layout[pos].dy,dy3,sizeof(dy3));
skill_db[i].unit_layout_type[j] = pos;
skill_db[i].unit_layout_type[++j] = pos;
//Fill in the rest using lv 5.
for (;j<MAX_SKILL_LEVEL;j++)
skill_db[i].unit_layout_type[j] = pos;
//Skip, this way the check below will fail and continue to the next skill.
pos++;
break;
}
default:
ShowError("unknown unit layout at skill %d\n",i);
break;
}
if (!skill_unit_layout[pos].count)
continue;
for (j=0;j<MAX_SKILL_LEVEL;j++)
skill_db[i].unit_layout_type[j] = pos;
pos++;
}
// ファイヤーウォール
firewall_unit_pos = pos;
for (i=0;i<8;i++) {
if (i&1) { /* 斜め配置 */
skill_unit_layout[pos].count = 5;
if (i&0x2) {
int dx[] = {-1,-1, 0, 0, 1};
int dy[] = { 1, 0, 0,-1,-1};
memcpy(skill_unit_layout[pos].dx,dx,sizeof(dx));
memcpy(skill_unit_layout[pos].dy,dy,sizeof(dy));
} else {
int dx[] = { 1, 1 ,0, 0,-1};
int dy[] = { 1, 0, 0,-1,-1};
memcpy(skill_unit_layout[pos].dx,dx,sizeof(dx));
memcpy(skill_unit_layout[pos].dy,dy,sizeof(dy));
}
} else { /* 縦横配置 */
skill_unit_layout[pos].count = 3;
if (i%4==0) { /* 上下 */
int dx[] = {-1, 0, 1};
int dy[] = { 0, 0, 0};
memcpy(skill_unit_layout[pos].dx,dx,sizeof(dx));
memcpy(skill_unit_layout[pos].dy,dy,sizeof(dy));
} else { /* 左右 */
int dx[] = { 0, 0, 0};
int dy[] = {-1, 0, 1};
memcpy(skill_unit_layout[pos].dx,dx,sizeof(dx));
memcpy(skill_unit_layout[pos].dy,dy,sizeof(dy));
}
}
pos++;
}
// アイスウォール
icewall_unit_pos = pos;
for (i=0;i<8;i++) {
skill_unit_layout[pos].count = 5;
if (i&1) { /* 斜め配置 */
if (i&0x2) {
int dx[] = {-2,-1, 0, 1, 2};
int dy[] = { 2, 1, 0,-1,-2};
memcpy(skill_unit_layout[pos].dx,dx,sizeof(dx));
memcpy(skill_unit_layout[pos].dy,dy,sizeof(dy));
} else {
int dx[] = { 2, 1 ,0,-1,-2};
int dy[] = { 2, 1, 0,-1,-2};
memcpy(skill_unit_layout[pos].dx,dx,sizeof(dx));
memcpy(skill_unit_layout[pos].dy,dy,sizeof(dy));
}
} else { /* 縦横配置 */
if (i%4==0) { /* 上下 */
int dx[] = {-2,-1, 0, 1, 2};
int dy[] = { 0, 0, 0, 0, 0};
memcpy(skill_unit_layout[pos].dx,dx,sizeof(dx));
memcpy(skill_unit_layout[pos].dy,dy,sizeof(dy));
} else { /* 左右 */
int dx[] = { 0, 0, 0, 0, 0};
int dy[] = {-2,-1, 0, 1, 2};
memcpy(skill_unit_layout[pos].dx,dx,sizeof(dx));
memcpy(skill_unit_layout[pos].dy,dy,sizeof(dy));
}
}
pos++;
}
}
/*==========================================
* スキル関係ファイル読み込み
* skill_db.txt スキルデータ
* skill_cast_db.txt スキルの詠唱時間とディレイデータ
* produce_db.txt アイテム作成スキル用データ
* create_arrow_db.txt 矢作成スキル用データ
* abra_db.txt アブラカダブラ発動スキルデータ
*------------------------------------------
*/
int skill_readdb (void)
{
int i,j,k,l,m;
FILE *fp;
char line[1024],path[1024],*p;
char *filename[]={"produce_db.txt","produce_db2.txt"};
/* スキルデータベース */
memset(skill_db,0,sizeof(skill_db));
sprintf(path, "%s/skill_db.txt", db_path);
fp=fopen(path,"r");
if(fp==NULL){
ShowError("can't read %s\n", path);
return 1;
}
while(fgets(line,1020,fp)){
char *split[50];
if(line[0]=='/' && line[1]=='/')
continue;
j = skill_split_str(line,split,15);
if(j < 15 || split[14]==NULL)
continue;
i=atoi(split[0]);
if (i >= GD_SKILLRANGEMIN && i <= GD_SKILLRANGEMAX) {
ShowWarning("read skill_db: Can't use skill id %d as guild skills are placed there!\n");
continue;
}
if (i >= GD_SKILLBASE)
i = GD_SKILLRANGEMIN + i - GD_SKILLBASE;
if(i<=0 || i>MAX_SKILL_DB)
continue;
skill_split_atoi(split[1],skill_db[i].range);
skill_db[i].hit=atoi(split[2]);
skill_db[i].inf=atoi(split[3]);
skill_db[i].pl=atoi(split[4]);
skill_db[i].nk=atoi(split[5]);
skill_split_atoi(split[6],skill_db[i].splash);
skill_db[i].max=atoi(split[7]);
skill_split_atoi(split[8],skill_db[i].num);
if(strcmpi(split[9],"yes") == 0)
skill_db[i].castcancel=1;
else
skill_db[i].castcancel=0;
skill_db[i].cast_def_rate=atoi(split[10]);
skill_db[i].inf2=atoi(split[11]);
skill_db[i].maxcount=atoi(split[12]);
if(strcmpi(split[13],"weapon") == 0)
skill_db[i].skill_type=BF_WEAPON;
else if(strcmpi(split[13],"magic") == 0)
skill_db[i].skill_type=BF_MAGIC;
else if(strcmpi(split[13],"misc") == 0)
skill_db[i].skill_type=BF_MISC;
else
skill_db[i].skill_type=0;
skill_split_atoi(split[14],skill_db[i].blewcount);
for (j = 0; skill_names[j].id != 0; j++)
if (skill_names[j].id == i) {
skill_db[i].name = skill_names[j].name;
skill_db[i].desc = skill_names[j].desc;
break;
}
}
fclose(fp);
ShowStatus("Done reading '"CL_WHITE"%s"CL_RESET"'.\n",path);
sprintf(path, "%s/skill_require_db.txt", db_path);
fp=fopen(path,"r");
if(fp==NULL){
ShowError("can't read %s\n", path);
return 1;
}
while(fgets(line,1020,fp)){
char *split[50];
if(line[0]=='/' && line[1]=='/')
continue;
j = skill_split_str(line,split,32);
if(j < 32 || split[31]==NULL)
continue;
i=atoi(split[0]);
if (i >= GD_SKILLBASE)
i = GD_SKILLRANGEMIN + i - GD_SKILLBASE;
if(i<=0 || i>MAX_SKILL_DB)
continue;
skill_split_atoi(split[1],skill_db[i].hp);
skill_split_atoi(split[2],skill_db[i].mhp);
skill_split_atoi(split[3],skill_db[i].sp);
skill_split_atoi(split[4],skill_db[i].hp_rate);
skill_split_atoi(split[5],skill_db[i].sp_rate);
skill_split_atoi(split[6],skill_db[i].zeny);
p = split[7];
for(j=0;j<32;j++){
l = atoi(p);
if (l==99) {
skill_db[i].weapon = 0xffffffff;
break;
}
else
skill_db[i].weapon |= 1<<l;
p=strchr(p,':');
if(!p)
break;
p++;
}
p = split[8];
for(j=0;j<32;j++){
l = atoi(p);
if (l)
skill_db[i].ammo |= 1<<l;
p=strchr(p,':');
if(!p)
break;
p++;
}
skill_split_atoi(split[9],skill_db[i].ammo_qty);
if( strcmpi(split[10],"hiding")==0 ) skill_db[i].state=ST_HIDING;
else if( strcmpi(split[10],"cloaking")==0 ) skill_db[i].state=ST_CLOAKING;
else if( strcmpi(split[10],"hidden")==0 ) skill_db[i].state=ST_HIDDEN;
else if( strcmpi(split[10],"riding")==0 ) skill_db[i].state=ST_RIDING;
else if( strcmpi(split[10],"falcon")==0 ) skill_db[i].state=ST_FALCON;
else if( strcmpi(split[10],"cart")==0 ) skill_db[i].state=ST_CART;
else if( strcmpi(split[10],"shield")==0 ) skill_db[i].state=ST_SHIELD;
else if( strcmpi(split[10],"sight")==0 ) skill_db[i].state=ST_SIGHT;
else if( strcmpi(split[10],"explosionspirits")==0 ) skill_db[i].state=ST_EXPLOSIONSPIRITS;
else if( strcmpi(split[10],"cartboost")==0 ) skill_db[i].state=ST_CARTBOOST;
else if( strcmpi(split[10],"recover_weight_rate")==0 ) skill_db[i].state=ST_RECOV_WEIGHT_RATE;
else if( strcmpi(split[10],"move_enable")==0 ) skill_db[i].state=ST_MOVE_ENABLE;
else if( strcmpi(split[10],"water")==0 ) skill_db[i].state=ST_WATER;
else skill_db[i].state=ST_NONE;
skill_split_atoi(split[11],skill_db[i].spiritball);
for (j = 0; j < 10; j++) {
skill_db[i].itemid[j]=atoi(split[12+ 2*j]);
skill_db[i].amount[j]=atoi(split[13+ 2*j]);
}
}
fclose(fp);
ShowStatus("Done reading '"CL_WHITE"%s"CL_RESET"'.\n",path);
/* キャスティングデータベース */
sprintf(path, "%s/skill_cast_db.txt", db_path);
fp=fopen(path,"r");
if(fp==NULL){
ShowError("can't read %s\n", path);
return 1;
}
l=0;
while(fgets(line,1020,fp)){
char *split[50];
l++;
memset(split,0,sizeof(split)); // [Valaris] thanks to fov
if(line[0]=='/' && line[1]=='/')
continue;
j = skill_split_str(line,split,6);
if(split[0]==NULL || j<2)
continue; //Blank line.
if(split[5]==NULL || j<6) {
ShowWarning("skill_cast_db.txt: Insufficient number of fields at line %d\n", l);
continue;
}
i=atoi(split[0]);
if (i >= GD_SKILLBASE)
i = GD_SKILLRANGEMIN + i - GD_SKILLBASE;
if(i<=0 || i>MAX_SKILL_DB)
continue;
skill_split_atoi(split[1],skill_db[i].cast);
skill_split_atoi(split[2],skill_db[i].delay);
skill_split_atoi(split[3],skill_db[i].walkdelay);
skill_split_atoi(split[4],skill_db[i].upkeep_time);
skill_split_atoi(split[5],skill_db[i].upkeep_time2);
}
fclose(fp);
ShowStatus("Done reading '"CL_WHITE"%s"CL_RESET"'.\n",path);
/* スキルユニットデータベース */
sprintf(path, "%s/skill_unit_db.txt", db_path);
fp=fopen(path,"r");
if (fp==NULL) {
ShowError("can't read %s\n", path);
return 1;
}
k = 0;
while (fgets(line,1020,fp)) {
char *split[50];
if (line[0]=='/' && line[1]=='/')
continue;
j = skill_split_str(line,split,8);
if (split[7]==NULL || j<8)
continue;
i=atoi(split[0]);
if (i >= GD_SKILLBASE)
i = GD_SKILLRANGEMIN + i - GD_SKILLBASE;
if(i<=0 || i>MAX_SKILL_DB)
continue;
skill_db[i].unit_id[0] = strtol(split[1],NULL,16);
skill_db[i].unit_id[1] = strtol(split[2],NULL,16);
skill_split_atoi(split[3],skill_db[i].unit_layout_type);
skill_split_atoi(split[4],skill_db[i].unit_range);
skill_db[i].unit_interval = atoi(split[5]);
if( strcmpi(split[6],"noenemy")==0 ) skill_db[i].unit_target=BCT_NOENEMY;
else if( strcmpi(split[6],"friend")==0 ) skill_db[i].unit_target=BCT_NOENEMY;
else if( strcmpi(split[6],"party")==0 ) skill_db[i].unit_target=BCT_PARTY;
else if( strcmpi(split[6],"ally")==0 ) skill_db[i].unit_target=BCT_PARTY|BCT_GUILD;
else if( strcmpi(split[6],"all")==0 ) skill_db[i].unit_target=BCT_ALL;
else if( strcmpi(split[6],"enemy")==0 ) skill_db[i].unit_target=BCT_ENEMY;
else if( strcmpi(split[6],"self")==0 ) skill_db[i].unit_target=BCT_SELF;
else if( strcmpi(split[6],"noone")==0 ) skill_db[i].unit_target=BCT_NOONE;
else skill_db[i].unit_target = strtol(split[6],NULL,16);
skill_db[i].unit_flag = strtol(split[7],NULL,16);
if (skill_db[i].unit_flag&UF_DEFNOTENEMY && battle_config.defnotenemy)
skill_db[i].unit_target=BCT_NOENEMY;
//By default, target just characters.
skill_db[i].unit_target |= BL_CHAR;
if (skill_db[i].unit_flag&UF_NOPC)
skill_db[i].unit_target &= ~BL_PC;
if (skill_db[i].unit_flag&UF_NOMOB)
skill_db[i].unit_target &= ~BL_MOB;
if (skill_db[i].unit_flag&UF_SKILL)
skill_db[i].unit_target |= BL_SKILL;
k++;
}
fclose(fp);
ShowStatus("Done reading '"CL_WHITE"%s"CL_RESET"'.\n",path);
skill_init_unit_layout();
/* 製造系スキルデータベース */
memset(skill_produce_db,0,sizeof(skill_produce_db));
for(m=0;m<2;m++){
sprintf(path, "%s/%s", db_path, filename[m]);
fp=fopen(path,"r");
if(fp==NULL){
if(m>0)
continue;
ShowError("can't read %s\n",path);
return 1;
}
k=0;
while(fgets(line,1020,fp)){
char *split[6 + MAX_PRODUCE_RESOURCE * 2];
int x,y;
if(line[0]=='/' && line[1]=='/')
continue;
memset(split,0,sizeof(split));
j = skill_split_str(line,split,(3 + MAX_PRODUCE_RESOURCE * 2));
if(split[0]==0) //fixed by Lupus
continue;
i=atoi(split[0]);
if(i<=0) continue;
skill_produce_db[k].nameid=i;
skill_produce_db[k].itemlv=atoi(split[1]);
skill_produce_db[k].req_skill=atoi(split[2]);
for(x=3,y=0; split[x] && split[x+1] && y<MAX_PRODUCE_RESOURCE; x+=2,y++){
skill_produce_db[k].mat_id[y]=atoi(split[x]);
skill_produce_db[k].mat_amount[y]=atoi(split[x+1]);
}
k++;
if(k >= MAX_SKILL_PRODUCE_DB)
break;
}
fclose(fp);
ShowStatus("Done reading '"CL_WHITE"%d"CL_RESET"' entries in '"CL_WHITE"%s"CL_RESET"'.\n",k,path);
}
memset(skill_arrow_db,0,sizeof(skill_arrow_db));
sprintf(path, "%s/create_arrow_db.txt", db_path);
fp=fopen(path,"r");
if(fp==NULL){
ShowError("can't read %s\n", path);
return 1;
}
k=0;
while(fgets(line,1020,fp)){
char *split[16];
int x,y;
if(line[0]=='/' && line[1]=='/')
continue;
memset(split,0,sizeof(split));
j = skill_split_str(line,split,13);
if(split[0]==0) //fixed by Lupus
continue;
i=atoi(split[0]);
if(i<=0)
continue;
skill_arrow_db[k].nameid=i;
for(x=1,y=0;split[x] && split[x+1] && y<5;x+=2,y++){
skill_arrow_db[k].cre_id[y]=atoi(split[x]);
skill_arrow_db[k].cre_amount[y]=atoi(split[x+1]);
}
k++;
if(k >= MAX_SKILL_ARROW_DB)
break;
}
fclose(fp);
ShowStatus("Done reading '"CL_WHITE"%d"CL_RESET"' entries in '"CL_WHITE"%s"CL_RESET"'.\n",k,path);
memset(skill_abra_db,0,sizeof(skill_abra_db));
sprintf(path, "%s/abra_db.txt", db_path);
fp=fopen(path,"r");
if(fp==NULL){
ShowError("can't read %s\n", path);
return 1;
}
k=0;
while(fgets(line,1020,fp)){
char *split[16];
if(line[0]=='/' && line[1]=='/')
continue;
memset(split,0,sizeof(split));
j = skill_split_str(line,split,13);
if(split[0]==0) //fixed by Lupus
continue;
i=atoi(split[0]);
if(i<=0)
continue;
skill_abra_db[i].req_lv=atoi(split[2]);
skill_abra_db[i].per=atoi(split[3]);
k++;
if(k >= MAX_SKILL_ABRA_DB)
break;
}
fclose(fp);
ShowStatus("Done reading '"CL_WHITE"%d"CL_RESET"' entries in '"CL_WHITE"%s"CL_RESET"'.\n",k,path);
sprintf(path, "%s/skill_castnodex_db.txt", db_path);
fp=fopen(path,"r");
if(fp==NULL){
ShowError("can't read %s\n", path);
return 1;
}
while(fgets(line,1020,fp)){
char *split[50];
if(line[0]=='/' && line[1]=='/')
continue;
memset(split,0,sizeof(split));
j = skill_split_str(line,split,3);
if(split[0]==0) //fixed by Lupus
continue;
i=atoi(split[0]);
if (i >= GD_SKILLBASE)
i = GD_SKILLRANGEMIN + i - GD_SKILLBASE;
if(i<=0 || i>MAX_SKILL_DB)
continue;
skill_split_atoi(split[1],skill_db[i].castnodex);
if (!split[2])
continue;
skill_split_atoi(split[2],skill_db[i].delaynodex);
}
fclose(fp);
ShowStatus("Done reading '"CL_WHITE"%s"CL_RESET"'.\n",path);
sprintf(path, "%s/skill_nocast_db.txt", db_path);
fp=fopen(path,"r");
if(fp==NULL){
ShowError("can't read %s\n", path);
return 1;
}
k=0;
while(fgets(line,1020,fp)){
char *split[16];
if(line[0]=='/' && line[1]=='/')
continue;
memset(split,0,sizeof(split));
j = skill_split_str(line,split,2);
if(split[0]==0) //fixed by Lupus
continue;
i=atoi(split[0]);
if (i >= GD_SKILLBASE)
i = GD_SKILLRANGEMIN + i - GD_SKILLBASE;
if(i<=0 || i>MAX_SKILL_DB)
continue;
skill_db[i].nocast|=atoi(split[1]);
k++;
}
fclose(fp);
ShowStatus("Done reading '"CL_WHITE"%s"CL_RESET"'.\n",path);
return 0;
}
/*===============================================
* For reading leveluseskillspamount.txt [Celest]
*-----------------------------------------------
*/
static int skill_read_skillspamount (void)
{
char *buf,*p;
struct skill_db *skill = NULL;
int s, idx, new_flag=1, level=1, sp=0;
buf=(char *) grfio_reads("data\\leveluseskillspamount.txt",&s);
if(buf==NULL)
return -1;
buf[s]=0;
for(p=buf;p-buf<s;){
char buf2[64];
if (sscanf(p,"%[@]",buf2) == 1) {
level = 1;
new_flag = 1;
} else if (new_flag && sscanf(p,"%[^#]#",buf2) == 1) {
for (idx=0; skill_names[idx].id != 0; idx++) {
if (strstr(buf2, skill_names[idx].name) != NULL) {
skill = &skill_db[ skill_names[idx].id ];
new_flag = 0;
break;
}
}
} else if (!new_flag && sscanf(p,"%d#",&sp) == 1) {
skill->sp[level-1]=sp;
level++;
}
p=strchr(p,10);
if(!p) break;
p++;
}
aFree(buf);
ShowStatus("Done reading '"CL_WHITE"%s"CL_RESET"'.\n","data\\leveluseskillspamount.txt");
return 0;
}
void skill_reload (void)
{
skill_readdb();
if (battle_config.skill_sp_override_grffile)
skill_read_skillspamount();
}
/*==========================================
* スキル関係初期化処理
*------------------------------------------
*/
int do_init_skill (void)
{
skill_readdb();
skill_unit_ers = ers_new((uint32)sizeof(struct skill_unit_group));
skill_timer_ers = ers_new((uint32)sizeof(struct skill_timerskill));
if (battle_config.skill_sp_override_grffile)
skill_read_skillspamount();
add_timer_func_list(skill_unit_timer,"skill_unit_timer");
add_timer_func_list(skill_castend_id,"skill_castend_id");
add_timer_func_list(skill_castend_pos,"skill_castend_pos");
add_timer_func_list(skill_timerskill,"skill_timerskill");
add_timer_func_list(skill_blockpc_end, "skill_blockpc_end");
add_timer_interval(gettick()+SKILLUNITTIMER_INVERVAL,skill_unit_timer,0,0,SKILLUNITTIMER_INVERVAL);
return 0;
}
int do_final_skill(void)
{
ers_destroy(skill_unit_ers);
ers_destroy(skill_timer_ers);
return 0;
}
