SandPoot
512 lines
23 KiB
Plaintext
512 lines
23 KiB
Plaintext
// Active parry system goes in here.
|
|
/**
|
|
* Determines if we can actively parry.
|
|
*/
|
|
/obj/item/proc/can_active_parry(mob/user)
|
|
return block_parry_data && (item_flags & ITEM_CAN_PARRY)
|
|
|
|
/**
|
|
* Called from keybindings.
|
|
*/
|
|
/mob/living/proc/keybind_parry()
|
|
initiate_parry_sequence()
|
|
|
|
/**
|
|
* Initiates a parrying sequence.
|
|
*/
|
|
/mob/living/proc/initiate_parry_sequence(silent = FALSE, list/override_method_data)
|
|
if(parrying)
|
|
return FALSE // already parrying
|
|
if(!(mobility_flags & MOBILITY_USE))
|
|
if(!silent)
|
|
to_chat(src, "<span class='warning'>You can't move your arms!</span>")
|
|
return FALSE
|
|
if(!(combat_flags & COMBAT_FLAG_PARRY_CAPABLE))
|
|
if(!silent)
|
|
to_chat(src, "<span class='warning'>You are not something that can parry attacks.</span>")
|
|
return FALSE
|
|
if(!(mobility_flags & MOBILITY_STAND))
|
|
if(!silent)
|
|
to_chat(src, "<span class='warning'>You aren't able to parry without solid footing!</span>")
|
|
return FALSE
|
|
var/datum/block_parry_data/data
|
|
var/list/determined = override_method_data || determine_parry_method(FALSE, FALSE)
|
|
if(!islist(determined))
|
|
return FALSE
|
|
var/method = determined[1]
|
|
data = return_block_parry_datum(determined[2])
|
|
var/datum/tool = determined[3]
|
|
var/full_parry_duration = data.parry_time_windup + data.parry_time_active + data.parry_time_spindown
|
|
// no system in place to "fallback" if out of the 3 the top priority one can't parry due to constraints but something else can.
|
|
// can always implement it later, whatever.
|
|
if((data.parry_respect_clickdelay && !CheckActionCooldown()) || ((parry_end_time_last + data.parry_cooldown) > world.time))
|
|
if(!silent)
|
|
to_chat(src, "<span class='warning'>You are not ready to parry (again)!</span>")
|
|
return FALSE
|
|
// Point of no return, make sure everything is set.
|
|
parrying = method
|
|
if(method == ITEM_PARRY)
|
|
active_parry_item = tool
|
|
if(!UseStaminaBuffer(data.parry_stamina_cost, TRUE))
|
|
return FALSE
|
|
parry_start_time = world.time
|
|
successful_parries = list()
|
|
successful_parry_counterattacks = list()
|
|
addtimer(CALLBACK(src, PROC_REF(end_parry_sequence)), full_parry_duration)
|
|
if(data.parry_flags & PARRY_LOCK_ATTACKING)
|
|
ADD_TRAIT(src, TRAIT_MOBILITY_NOUSE, ACTIVE_PARRY_TRAIT)
|
|
if(data.parry_flags & PARRY_LOCK_SPRINTING)
|
|
ADD_TRAIT(src, TRAIT_SPRINT_LOCKED, ACTIVE_PARRY_TRAIT)
|
|
handle_parry_starting_effects(data)
|
|
return TRUE
|
|
|
|
/**
|
|
* Massive snowflake proc for getting something to parry with.
|
|
*
|
|
* @return list of [method, data, tool], where method is the parry method define, data is the block_parry_data var that must be run through return_block_parry_data, and tool is the concept/object/martial art/etc used.
|
|
*/
|
|
/mob/living/proc/determine_parry_method(silent = TRUE, autoparry = FALSE)
|
|
// Prioritize item, then martial art, then unarmed.
|
|
// yanderedev else if time
|
|
var/obj/item/using_item = get_active_held_item()
|
|
var/datum/block_parry_data/data
|
|
var/datum/tool
|
|
var/method
|
|
if(using_item?.can_active_parry(src))
|
|
data = using_item.block_parry_data
|
|
method = ITEM_PARRY
|
|
tool = using_item
|
|
else if(mind?.martial_art?.can_martial_parry)
|
|
data = mind.martial_art.block_parry_data
|
|
method = MARTIAL_PARRY
|
|
tool = mind.martial_art
|
|
else if((combat_flags & COMBAT_FLAG_UNARMED_PARRY) && check_unarmed_parry_activation_special())
|
|
data = block_parry_data
|
|
method = UNARMED_PARRY
|
|
tool = src
|
|
else
|
|
// QOL: If none of the above work, try to find another item.
|
|
var/obj/item/backup = find_backup_parry_item()
|
|
if(backup)
|
|
tool = backup
|
|
data = backup.block_parry_data
|
|
using_item = backup
|
|
method = ITEM_PARRY
|
|
var/list/other_items = list()
|
|
var/list/override = list()
|
|
if(SEND_SIGNAL(src, COMSIG_LIVING_ACTIVE_PARRY_START, method, tool, other_items, override) & COMPONENT_PREVENT_PARRY_START)
|
|
if(!silent)
|
|
to_chat(src, "<span class='warning'>Something is preventing you from parrying!</span>")
|
|
return
|
|
if(length(override))
|
|
var/datum/thing = override[1]
|
|
var/_method = override[thing]
|
|
if(_method == ITEM_PARRY)
|
|
using_item = thing
|
|
tool = using_item
|
|
method = ITEM_PARRY
|
|
data = using_item.block_parry_data
|
|
else if(_method == UNARMED_PARRY)
|
|
method = UNARMED_PARRY
|
|
tool = src
|
|
data = thing
|
|
if(!using_item && !method && length(other_items))
|
|
using_item = other_items[1]
|
|
tool = using_item
|
|
method = ITEM_PARRY
|
|
data = using_item.block_parry_data
|
|
if(!method)
|
|
if(!silent)
|
|
to_chat(src, "<span class='warning'>You have nothing to parry with!</span>")
|
|
return FALSE
|
|
return list(method, data, tool)
|
|
|
|
/**
|
|
* Tries to find a backup parry item.
|
|
* Does not look at active held item.
|
|
*/
|
|
/mob/living/proc/find_backup_parry_item()
|
|
for(var/obj/item/I in held_items - get_active_held_item())
|
|
if(I.can_active_parry(src))
|
|
return I
|
|
|
|
/**
|
|
* Check if we can unarmed parry
|
|
*/
|
|
/mob/living/proc/check_unarmed_parry_activation_special()
|
|
return TRUE
|
|
|
|
/**
|
|
* Called via timer when the parry sequence ends.
|
|
*/
|
|
/mob/living/proc/end_parry_sequence()
|
|
if(!parrying)
|
|
return
|
|
REMOVE_TRAIT(src, TRAIT_MOBILITY_NOUSE, ACTIVE_PARRY_TRAIT)
|
|
REMOVE_TRAIT(src, TRAIT_SPRINT_LOCKED, ACTIVE_PARRY_TRAIT)
|
|
if(parry_visual_effect)
|
|
QDEL_NULL(parry_visual_effect)
|
|
var/datum/block_parry_data/data = get_parry_data()
|
|
var/list/effect_text = list()
|
|
var/successful = FALSE
|
|
for(var/efficiency in successful_parries)
|
|
if(efficiency >= data.parry_efficiency_considered_successful)
|
|
successful = TRUE
|
|
break
|
|
if(!successful) // didn't parry anything successfully
|
|
if(data.parry_failed_stagger_duration)
|
|
Stagger(data.parry_failed_stagger_duration)
|
|
effect_text += "staggering themselves"
|
|
if(data.parry_failed_clickcd_duration)
|
|
DelayNextAction(data.parry_failed_clickcd_duration, flush = TRUE)
|
|
effect_text += "throwing themselves off balance"
|
|
handle_parry_ending_effects(data, effect_text)
|
|
parrying = NOT_PARRYING
|
|
parry_start_time = 0
|
|
parry_end_time_last = world.time + (successful? 0 : data.parry_failed_cooldown_duration)
|
|
successful_parries = null
|
|
successful_parry_counterattacks = null
|
|
|
|
/**
|
|
* Handles starting effects for parrying.
|
|
*/
|
|
/mob/living/proc/handle_parry_starting_effects(datum/block_parry_data/data)
|
|
playsound(src, data.parry_start_sound, 75, 1)
|
|
parry_visual_effect = new /obj/effect/abstract/parry/main(null, TRUE, src, data.parry_effect_icon_state, data.parry_time_windup_visual_override || data.parry_time_windup, data.parry_time_active_visual_override || data.parry_time_active, data.parry_time_spindown_visual_override || data.parry_time_spindown)
|
|
switch(parrying)
|
|
if(ITEM_PARRY)
|
|
visible_message("<span class='warning'>[src] swings [active_parry_item]!</span>")
|
|
else
|
|
visible_message("<span class='warning'>[src] rushes forwards!</span>")
|
|
|
|
/**
|
|
* Handles ending effects for parrying.
|
|
*/
|
|
/mob/living/proc/handle_parry_ending_effects(datum/block_parry_data/data, list/failed_effect_text)
|
|
if(length(successful_parries))
|
|
return
|
|
visible_message("<span class='warning'>[src] fails to connect their parry[failed_effect_text? ", [english_list(failed_effect_text)]" : ""]!")
|
|
|
|
/**
|
|
* Gets this item's datum/block_parry_data
|
|
*/
|
|
/obj/item/proc/get_block_parry_data()
|
|
return return_block_parry_datum(block_parry_data)
|
|
|
|
//Stubs.
|
|
|
|
/**
|
|
* Called when an attack is parried using this, whether or not the parry was successful.
|
|
*/
|
|
/obj/item/proc/on_active_parry(mob/living/owner, atom/object, damage, attack_text, attack_type, armour_penetration, mob/attacker, def_zone, list/block_return, parry_efficiency, parry_time, autoparry = FALSE)
|
|
|
|
/**
|
|
* Called when an attack is parried innately, whether or not the parry was successful.
|
|
*/
|
|
/mob/living/proc/on_active_parry(mob/living/owner, atom/object, damage, attack_text, attack_type, armour_penetration, mob/attacker, def_zone, list/block_return, parry_efficiency, parry_time, autoparry = FALSE)
|
|
|
|
/**
|
|
* Called when an attack is parried using this, whether or not the parry was successful.
|
|
*/
|
|
/datum/martial_art/proc/on_active_parry(mob/living/owner, atom/object, damage, attack_text, attack_type, armour_penetration, mob/attacker, def_zone, list/block_return, parry_efficiency, parry_time, autoparry = FALSE)
|
|
|
|
/**
|
|
* Called when an attack is parried and block_parra_data indicates to use a proc to handle counterattack.
|
|
*/
|
|
/obj/item/proc/active_parry_reflex_counter(mob/living/owner, atom/object, damage, attack_text, attack_type, armour_penetration, mob/attacker, def_zone, list/return_list, parry_efficiency, list/effect_text)
|
|
|
|
/**
|
|
* Called when an attack is parried and block_parra_data indicates to use a proc to handle counterattack.
|
|
*/
|
|
/mob/living/proc/active_parry_reflex_counter(mob/living/owner, atom/object, damage, attack_text, attack_type, armour_penetration, mob/attacker, def_zone, list/return_list, parry_efficiency, list/effect_text)
|
|
|
|
/**
|
|
* Called when an attack is parried and block_parra_data indicates to use a proc to handle counterattack.
|
|
*/
|
|
/datum/martial_art/proc/active_parry_reflex_counter(mob/living/owner, atom/object, damage, attack_text, attack_type, armour_penetration, mob/attacker, def_zone, list/return_list, parry_efficiency, list/effect_text)
|
|
|
|
/**
|
|
* Attempts to automatically parry an attacker.
|
|
*/
|
|
/mob/living/proc/attempt_auto_parry(atom/object, damage, attack_text, attack_type, armour_penetration, mob/attacker, def_zone, list/return_list = list())
|
|
// determine how we'll parry
|
|
var/list/determined = determine_parry_method(TRUE, TRUE)
|
|
if(!islist(determined))
|
|
return BLOCK_NONE
|
|
var/datum/block_parry_data/data = return_block_parry_datum(determined[2])
|
|
if(!data.parry_automatic_enabled || (last_autoparry > (world.time - data.autoparry_cooldown_absolute)))
|
|
return BLOCK_NONE
|
|
if(attack_type && !(attack_type & data.parry_attack_types))
|
|
return BLOCK_NONE
|
|
// before doing anything, check if the user moused over them properly
|
|
if(!client)
|
|
return BLOCK_NONE
|
|
var/found = attacker == client.mouse_object_ref?.resolve()
|
|
if(!found)
|
|
for(var/i in client.moused_over_objects)
|
|
if(i == object)
|
|
if((client.moused_over_objects[i] + (data.autoparry_mouse_delay_maximum)) >= world.time)
|
|
found = TRUE
|
|
break
|
|
if(!found)
|
|
return BLOCK_NONE
|
|
|
|
// if that works, try to start parry
|
|
// first, check cooldowns
|
|
|
|
// now, depending on if we're doing a single simulation or a full sequence
|
|
last_autoparry = world.time
|
|
if(data.autoparry_sequence_simulation)
|
|
// for full sequence simulation
|
|
initiate_parry_sequence(TRUE, determined)
|
|
if(data.autoparry_sequence_start_time == -1)
|
|
parry_start_time = world.time - data.parry_time_windup
|
|
else
|
|
parry_start_time = world.time - data.autoparry_sequence_start_time
|
|
// recurse back to original
|
|
return run_parry(object, damage, attack_text, attack_type, armour_penetration, attacker, def_zone, return_list, FALSE)
|
|
else
|
|
// yes, this is mostly a copypaste of run_parry.
|
|
var/efficiency = data.attack_type_list_scan(data.autoparry_single_efficiency_override, attack_type)
|
|
if(isnull(efficiency))
|
|
efficiency = data.autoparry_single_efficiency
|
|
var/method = determined[1]
|
|
switch(method)
|
|
if(ITEM_PARRY)
|
|
var/obj/item/I = determined[3]
|
|
. = I.on_active_parry(src, object, damage, attack_text, attack_type, armour_penetration, attacker, def_zone, return_list, efficiency, null, TRUE)
|
|
if(UNARMED_PARRY)
|
|
. = on_active_parry(src, object, damage, attack_text, attack_type, armour_penetration, attacker, def_zone, return_list, efficiency, null, TRUE)
|
|
if(MARTIAL_PARRY)
|
|
. = mind.martial_art.on_active_parry(src, object, damage, attack_text, attack_type, armour_penetration, attacker, def_zone, return_list, efficiency, null, TRUE)
|
|
if(!isnull(return_list[BLOCK_RETURN_OVERRIDE_PARRY_EFFICIENCY])) // one of our procs overrode
|
|
efficiency = return_list[BLOCK_RETURN_OVERRIDE_PARRY_EFFICIENCY]
|
|
if(efficiency <= 0) // Do not allow automatically handled/standardized parries that increase damage for now.
|
|
return
|
|
. |= BLOCK_SHOULD_PARTIAL_MITIGATE
|
|
if(efficiency >= data.parry_efficiency_perfect)
|
|
. |= data.perfect_parry_block_return_flags
|
|
if(data.perfect_parry_block_return_list)
|
|
return_list |= data.perfect_parry_block_return_list
|
|
else if(efficiency >= data.parry_efficiency_considered_successful)
|
|
. |= data.imperfect_parry_block_return_flags
|
|
if(data.imperfect_parry_block_return_list)
|
|
return_list |= data.imperfect_parry_block_return_list
|
|
else
|
|
. |= data.failed_parry_block_return_flags
|
|
if(data.failed_parry_block_return_list)
|
|
return_list |= data.failed_parry_block_return_list
|
|
if(isnull(return_list[BLOCK_RETURN_MITIGATION_PERCENT])) // if one of the on_active_parry procs overrode. We don't have to worry about interference since parries are the first thing checked in the [do_run_block()] sequence.
|
|
return_list[BLOCK_RETURN_MITIGATION_PERCENT] = clamp(efficiency, 0, 100) // do not allow > 100% or < 0% for now.
|
|
if((return_list[BLOCK_RETURN_MITIGATION_PERCENT] >= 100) || (damage <= 0))
|
|
. |= BLOCK_SUCCESS
|
|
var/list/effect_text
|
|
var/pacifist_counter_check = TRUE
|
|
if(HAS_TRAIT(src, TRAIT_PACIFISM))
|
|
switch(parrying)
|
|
if(ITEM_PARRY)
|
|
pacifist_counter_check = (!active_parry_item.force || active_parry_item.damtype == STAMINA)
|
|
else
|
|
pacifist_counter_check = FALSE //Both martial and unarmed counter attacks generally are harmful, so no need to have the same line twice.
|
|
if(efficiency >= data.parry_efficiency_to_counterattack && pacifist_counter_check && !return_list[BLOCK_RETURN_FORCE_NO_PARRY_COUNTERATTACK] && (!(attacker in successful_parry_counterattacks) && !data.parry_allow_repeated_counterattacks))
|
|
effect_text = run_parry_countereffects(object, damage, attack_text, attack_type, armour_penetration, attacker, def_zone, return_list, efficiency, data)
|
|
if(data.parry_flags & PARRY_DEFAULT_HANDLE_FEEDBACK)
|
|
handle_parry_feedback(object, damage, attack_text, attack_type, armour_penetration, attacker, def_zone, return_list, efficiency, effect_text, data)
|
|
|
|
/**
|
|
* Gets the stage of our parry sequence we're currently in.
|
|
*/
|
|
/mob/living/proc/get_parry_stage()
|
|
if(!parrying)
|
|
return NOT_PARRYING
|
|
var/datum/block_parry_data/data = get_parry_data()
|
|
var/windup_end = data.parry_time_windup
|
|
var/active_end = windup_end + data.parry_time_active
|
|
var/spindown_end = active_end + data.parry_time_spindown
|
|
var/current_time = get_parry_time()
|
|
// Not a switch statement because byond switch statements don't support floats at time of writing with "to" keyword.
|
|
if(current_time < 0)
|
|
return NOT_PARRYING
|
|
else if(current_time < windup_end)
|
|
return PARRY_WINDUP
|
|
else if(current_time <= active_end) // this uses <= on purpose, give a slight bit of advantage because time is rounded to world.tick_lag
|
|
return PARRY_ACTIVE
|
|
else if(current_time <= spindown_end)
|
|
return PARRY_SPINDOWN
|
|
else
|
|
return NOT_PARRYING
|
|
|
|
/**
|
|
* Gets the current decisecond "frame" of an active parry.
|
|
*/
|
|
/mob/living/proc/get_parry_time()
|
|
return world.time - parry_start_time
|
|
|
|
/// same return values as normal blocking, called with absolute highest priority in the block "chain".
|
|
/mob/living/proc/run_parry(atom/object, damage, attack_text, attack_type, armour_penetration, mob/attacker, def_zone, list/return_list = list(), allow_auto = TRUE)
|
|
var/stage = get_parry_stage()
|
|
if(attack_type & ATTACK_TYPE_PARRY_COUNTERATTACK)
|
|
return BLOCK_NONE // don't infinite loop
|
|
if(stage != PARRY_ACTIVE)
|
|
// If they're not currently parrying, attempt auto parry
|
|
if(stage == NOT_PARRYING)
|
|
if(!allow_auto || SEND_SIGNAL(src, COMSIG_COMBAT_MODE_CHECK, COMBAT_MODE_INACTIVE))
|
|
return BLOCK_NONE
|
|
return attempt_auto_parry(object, damage, attack_text, attack_type, armour_penetration, attacker, def_zone, return_list)
|
|
else
|
|
return BLOCK_NONE
|
|
var/datum/block_parry_data/data = get_parry_data()
|
|
if(attack_type && !(attack_type & data.parry_attack_types))
|
|
return BLOCK_NONE
|
|
var/efficiency = data.get_parry_efficiency(attack_type, get_parry_time())
|
|
switch(parrying)
|
|
if(ITEM_PARRY)
|
|
if(!active_parry_item.can_active_parry(src))
|
|
return BLOCK_NONE
|
|
. = active_parry_item.on_active_parry(src, object, damage, attack_text, attack_type, armour_penetration, attacker, def_zone, return_list, efficiency, get_parry_time())
|
|
if(UNARMED_PARRY)
|
|
. = on_active_parry(src, object, damage, attack_text, attack_type, armour_penetration, attacker, def_zone, return_list, efficiency, get_parry_time())
|
|
if(MARTIAL_PARRY)
|
|
. = mind.martial_art.on_active_parry(src, object, damage, attack_text, attack_type, armour_penetration, attacker, def_zone, return_list, efficiency, get_parry_time())
|
|
if(!isnull(return_list[BLOCK_RETURN_OVERRIDE_PARRY_EFFICIENCY])) // one of our procs overrode
|
|
efficiency = return_list[BLOCK_RETURN_OVERRIDE_PARRY_EFFICIENCY]
|
|
if(efficiency <= 0) // Do not allow automatically handled/standardized parries that increase damage for now.
|
|
return
|
|
. |= BLOCK_SHOULD_PARTIAL_MITIGATE
|
|
if(efficiency >= data.parry_efficiency_perfect)
|
|
. |= data.perfect_parry_block_return_flags
|
|
if(data.perfect_parry_block_return_list)
|
|
return_list |= data.perfect_parry_block_return_list
|
|
else if(efficiency >= data.parry_efficiency_considered_successful)
|
|
. |= data.imperfect_parry_block_return_flags
|
|
if(data.imperfect_parry_block_return_list)
|
|
return_list |= data.imperfect_parry_block_return_list
|
|
else
|
|
. |= data.failed_parry_block_return_flags
|
|
if(data.failed_parry_block_return_list)
|
|
return_list |= data.failed_parry_block_return_list
|
|
if(isnull(return_list[BLOCK_RETURN_MITIGATION_PERCENT])) // if one of the on_active_parry procs overrode. We don't have to worry about interference since parries are the first thing checked in the [do_run_block()] sequence.
|
|
return_list[BLOCK_RETURN_MITIGATION_PERCENT] = clamp(efficiency, 0, 100) // do not allow > 100% or < 0% for now.
|
|
if((return_list[BLOCK_RETURN_MITIGATION_PERCENT] >= 100) || (damage <= 0))
|
|
. |= BLOCK_SUCCESS
|
|
var/list/effect_text
|
|
var/pacifist_counter_check = TRUE
|
|
if(HAS_TRAIT(src, TRAIT_PACIFISM))
|
|
switch(parrying)
|
|
if(ITEM_PARRY)
|
|
pacifist_counter_check = (!active_parry_item.force || active_parry_item.damtype == STAMINA)
|
|
else
|
|
pacifist_counter_check = FALSE //Both martial and unarmed counter attacks generally are harmful, so no need to have the same line twice.
|
|
if(efficiency >= data.parry_efficiency_to_counterattack && pacifist_counter_check && !return_list[BLOCK_RETURN_FORCE_NO_PARRY_COUNTERATTACK] && (!(attacker in successful_parry_counterattacks) && !data.parry_allow_repeated_counterattacks))
|
|
effect_text = run_parry_countereffects(object, damage, attack_text, attack_type, armour_penetration, attacker, def_zone, return_list, efficiency)
|
|
if(data.parry_flags & PARRY_DEFAULT_HANDLE_FEEDBACK)
|
|
handle_parry_feedback(object, damage, attack_text, attack_type, armour_penetration, attacker, def_zone, return_list, efficiency, effect_text)
|
|
successful_parries += efficiency
|
|
if(length(successful_parries) >= data.parry_max_attacks)
|
|
end_parry_sequence()
|
|
|
|
/mob/living/proc/handle_parry_feedback(atom/object, damage, attack_text, attack_type, armour_penetration, mob/attacker, def_zone, list/return_list = list(), parry_efficiency, list/effect_text, datum/block_parry_data/data)
|
|
if(!data)
|
|
data = get_parry_data()
|
|
var/knockdown_check = FALSE
|
|
if(data.parry_data[PARRY_KNOCKDOWN_ATTACKER] && parry_efficiency >= data.parry_efficiency_to_counterattack)
|
|
knockdown_check = TRUE
|
|
if(data.parry_sounds)
|
|
playsound(src, pick(data.parry_sounds), 75)
|
|
visible_message("<span class='danger'>[src] parries [attack_text][length(effect_text)? ", [english_list(effect_text)] [attacker]" : ""][length(effect_text) && knockdown_check? " and" : ""][knockdown_check? " knocking them to the ground" : ""]!</span>")
|
|
|
|
/// Run counterattack if any
|
|
/mob/living/proc/run_parry_countereffects(atom/object, damage, attack_text, attack_type, armour_penetration, mob/attacker, def_zone, list/return_list = list(), parry_efficiency, datum/block_parry_data/data)
|
|
if(!isliving(attacker))
|
|
return
|
|
var/mob/living/L = attacker
|
|
if(!data)
|
|
data = get_parry_data()
|
|
var/list/effect_text = list()
|
|
successful_parry_counterattacks |= attacker
|
|
// Always proc so items can override behavior easily
|
|
switch(parrying)
|
|
if(ITEM_PARRY)
|
|
active_parry_item.active_parry_reflex_counter(src, object, damage, attack_text, attack_type, armour_penetration, attacker, def_zone, return_list, parry_efficiency, effect_text)
|
|
if(UNARMED_PARRY)
|
|
active_parry_reflex_counter(src, object, damage, attack_text, attack_type, armour_penetration, attacker, def_zone, return_list, parry_efficiency, effect_text)
|
|
if(MARTIAL_PARRY)
|
|
mind.martial_art.active_parry_reflex_counter(src, object, damage, attack_text, attack_type, armour_penetration, attacker, def_zone, return_list, parry_efficiency, effect_text)
|
|
if(Adjacent(attacker) || data.parry_data[PARRY_COUNTERATTACK_IGNORE_ADJACENCY])
|
|
if(data.parry_data[PARRY_COUNTERATTACK_MELEE_ATTACK_CHAIN])
|
|
switch(parrying)
|
|
if(ITEM_PARRY)
|
|
active_parry_item.melee_attack_chain(src, attacker, null, ATTACK_IS_PARRY_COUNTERATTACK | ATTACK_IGNORE_CLICKDELAY | ATTACK_IGNORE_ACTION | NO_AUTO_CLICKDELAY_HANDLING, data.parry_data[PARRY_COUNTERATTACK_MELEE_ATTACK_CHAIN])
|
|
effect_text += "reflexively counterattacking with [active_parry_item]"
|
|
if(UNARMED_PARRY) // WARNING: If you are using these two, the attackchain parry counterattack flags and damage multipliers are unimplemented. Be careful with how you handle this.
|
|
UnarmedAttack(attacker)
|
|
effect_text += "reflexively counterattacking in the process"
|
|
if(MARTIAL_PARRY) // Not well implemeneted, recommend custom implementation using the martial art datums.
|
|
UnarmedAttack(attacker)
|
|
effect_text += "reflexively maneuvering to retaliate"
|
|
if(data.parry_data[PARRY_DISARM_ATTACKER])
|
|
L.drop_all_held_items()
|
|
effect_text += "disarming"
|
|
if(data.parry_data[PARRY_STAGGER_ATTACKER])
|
|
L.Stagger(data.parry_data[PARRY_STAGGER_ATTACKER])
|
|
effect_text += "staggering"
|
|
if(data.parry_data[PARRY_DAZE_ATTACKER])
|
|
L.Daze(data.parry_data[PARRY_DAZE_ATTACKER])
|
|
effect_text += "dazing"
|
|
if(data.parry_data[PARRY_KNOCKDOWN_ATTACKER])
|
|
L.DefaultCombatKnockdown(data.parry_data[PARRY_KNOCKDOWN_ATTACKER])
|
|
// effect_text += "knocking them to the ground" - snowflaked above
|
|
return effect_text
|
|
|
|
/// Gets the datum/block_parry_data we're going to use to parry.
|
|
/mob/living/proc/get_parry_data()
|
|
if(parrying == ITEM_PARRY)
|
|
return active_parry_item.get_block_parry_data()
|
|
else if(parrying == UNARMED_PARRY)
|
|
return return_block_parry_datum(block_parry_data)
|
|
else if(parrying == MARTIAL_PARRY)
|
|
return return_block_parry_datum(mind.martial_art.block_parry_data)
|
|
|
|
/// Effects
|
|
/obj/effect/abstract/parry
|
|
icon = 'icons/effects/block_parry.dmi'
|
|
mouse_opacity = MOUSE_OPACITY_TRANSPARENT
|
|
layer = FLOAT_LAYER
|
|
plane = FLOAT_PLANE
|
|
vis_flags = VIS_INHERIT_LAYER|VIS_INHERIT_PLANE
|
|
/// The person we're on
|
|
var/mob/living/owner
|
|
|
|
/obj/effect/abstract/parry/main
|
|
name = null
|
|
|
|
/obj/effect/abstract/parry/main/Initialize(mapload, autorun, mob/living/owner, set_icon_state, windup, active, spindown)
|
|
. = ..()
|
|
icon_state = set_icon_state
|
|
if(owner)
|
|
attach_to(owner)
|
|
if(autorun)
|
|
INVOKE_ASYNC(src, PROC_REF(run_animation), windup, active, spindown)
|
|
|
|
/obj/effect/abstract/parry/main/Destroy()
|
|
detach_from(owner)
|
|
return ..()
|
|
|
|
/obj/effect/abstract/parry/main/proc/attach_to(mob/living/attaching)
|
|
if(owner)
|
|
detach_from(owner)
|
|
owner = attaching
|
|
owner.vis_contents += src
|
|
|
|
/obj/effect/abstract/parry/main/proc/detach_from(mob/living/detaching)
|
|
if(detaching == owner)
|
|
owner = null
|
|
detaching.vis_contents -= src
|
|
|
|
/obj/effect/abstract/parry/main/proc/run_animation(windup_time = 2, active_time = 5, spindown_time = 3)
|
|
var/matrix/current = transform
|
|
transform = matrix(0.1, 0, 0, 0, 0.1, 0)
|
|
animate(src, transform = current, time = windup_time)
|
|
sleep(active_time)
|
|
animate(src, alpha = 0, spindown_time)
|