mirror of
https://bitbucket.org/Ioncannon/project-meteor-server.git
synced 2025-04-02 19:42:05 -04:00
922fb80f3d
Added stoneskin effect to database. Fixed Rampage not working Fixed bug where abilities didn't equip correctly when leveling up Added a temporary fix for returning while dead Added handling for abilities that don't have an actiontype set, like elusive jump
447 lines
18 KiB
C#
447 lines
18 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Text;
|
|
using System.Threading.Tasks;
|
|
using FFXIVClassic.Common;
|
|
using FFXIVClassic_Map_Server.Actors;
|
|
using FFXIVClassic_Map_Server.lua;
|
|
using FFXIVClassic_Map_Server.actors.area;
|
|
using FFXIVClassic_Map_Server.packets.send;
|
|
using FFXIVClassic_Map_Server.packets.send.actor;
|
|
using FFXIVClassic_Map_Server.packets.send.actor.battle;
|
|
using System.Collections.ObjectModel;
|
|
using FFXIVClassic_Map_Server.utils;
|
|
|
|
namespace FFXIVClassic_Map_Server.actors.chara.ai
|
|
{
|
|
class StatusEffectContainer
|
|
{
|
|
private Character owner;
|
|
private readonly Dictionary<uint, StatusEffect> effects;
|
|
public static readonly int MAX_EFFECTS = 20;
|
|
private bool sendUpdate = false;
|
|
private DateTime lastTick;// Do all effects tick at the same time like regen?
|
|
private List<SubPacket> statusSubpackets;
|
|
private ActorPropertyPacketUtil statusTimerPropPacketUtil;
|
|
|
|
public StatusEffectContainer(Character owner)
|
|
{
|
|
this.owner = owner;
|
|
this.effects = new Dictionary<uint, StatusEffect>();
|
|
statusSubpackets = new List<SubPacket>();
|
|
statusTimerPropPacketUtil = new ActorPropertyPacketUtil("charawork/Status", owner);
|
|
}
|
|
|
|
public void Update(DateTime tick)
|
|
{
|
|
//Regen/Refresh/Regain effects tick every 3 seconds
|
|
if ((DateTime.Now - lastTick).Seconds >= 3)
|
|
{
|
|
RegenTick(tick);
|
|
lastTick = DateTime.Now;
|
|
}
|
|
// list of effects to remove
|
|
|
|
// if (owner is Player) UpdateTimeAtIndex(4, 4294967295);
|
|
var removeEffects = new List<StatusEffect>();
|
|
for (int i = 0; i < effects.Values.Count; i++)
|
|
{
|
|
// effect's update function returns true if effect has completed
|
|
if (effects.Values.ElementAt(i).Update(tick))
|
|
removeEffects.Add(effects.Values.ElementAt(i));
|
|
|
|
}
|
|
|
|
// remove effects from this list
|
|
foreach (var effect in removeEffects)
|
|
{
|
|
RemoveStatusEffect(effect);
|
|
}
|
|
|
|
if (sendUpdate)
|
|
{
|
|
owner.zone.BroadcastPacketsAroundActor(owner, owner.GetActorStatusPackets());
|
|
sendUpdate = false;
|
|
}
|
|
}
|
|
|
|
//regen/refresh/regain
|
|
public void RegenTick(DateTime tick)
|
|
{
|
|
ushort dotTick = (ushort) owner.GetMod(Modifier.RegenDown);
|
|
ushort regenTick = (ushort) owner.GetMod(Modifier.Regen);
|
|
ushort refreshtick = (ushort) owner.GetMod(Modifier.Refresh);
|
|
short regainTick = (short) owner.GetMod(Modifier.Regain);
|
|
|
|
//DoTs tick before regen and the full dot damage is displayed, even if some or all of it is nullified by regen. Only effects like stoneskin actually alter the number shown
|
|
if (dotTick > 0)
|
|
{
|
|
BattleAction action = new BattleAction(owner.actorId, 30331, (uint)(HitEffect.HitEffectType | HitEffect.Hit), dotTick);
|
|
utils.BattleUtils.HandleStoneskin(owner, action);
|
|
// todo: figure out how to make red numbers appear for enemies getting hurt by dots
|
|
//owner.DelHP(action.amount);
|
|
utils.BattleUtils.DamageTarget(owner, owner, action, null);
|
|
owner.DoBattleAction(0, 0, action);
|
|
}
|
|
|
|
//DoTs are the only effect to show numbers, so that doesnt need to be handled for these
|
|
owner.AddHP(regenTick);
|
|
owner.AddMP(refreshtick);
|
|
owner.AddTP(regainTick);
|
|
}
|
|
|
|
public bool HasStatusEffect(uint id)
|
|
{
|
|
return effects.ContainsKey(id);
|
|
}
|
|
|
|
public bool HasStatusEffect(StatusEffectId id)
|
|
{
|
|
return effects.ContainsKey((uint)id);
|
|
}
|
|
|
|
public BattleAction AddStatusForBattleAction(uint id, byte tier = 1)
|
|
{
|
|
BattleAction action = null;
|
|
|
|
if (AddStatusEffect(id, tier))
|
|
action = new BattleAction(owner.actorId, 30328, id | (uint)HitEffect.StatusEffectType);
|
|
|
|
return action;
|
|
}
|
|
|
|
public bool AddStatusEffect(uint id)
|
|
{
|
|
var se = Server.GetWorldManager().GetStatusEffect(id);
|
|
|
|
return AddStatusEffect(se, owner);
|
|
}
|
|
|
|
public bool AddStatusEffect(uint id, byte tier)
|
|
{
|
|
var se = Server.GetWorldManager().GetStatusEffect(id);
|
|
|
|
se.SetTier(tier);
|
|
|
|
return AddStatusEffect(se, owner);
|
|
}
|
|
|
|
public bool AddStatusEffect(uint id, byte tier, UInt64 magnitude)
|
|
{
|
|
var se = Server.GetWorldManager().GetStatusEffect(id);
|
|
|
|
se.SetMagnitude(magnitude);
|
|
se.SetTier(tier);
|
|
|
|
return AddStatusEffect(se, owner);
|
|
}
|
|
|
|
public bool AddStatusEffect(uint id, byte tier, UInt64 magnitude, uint duration, int tickMs = 3000)
|
|
{
|
|
var se = Server.GetWorldManager().GetStatusEffect(id);
|
|
if (se != null)
|
|
{
|
|
se.SetDuration(duration);
|
|
se.SetStartTime(DateTime.Now);
|
|
se.SetOwner(owner);
|
|
}
|
|
return AddStatusEffect(se ?? new StatusEffect(this.owner, id, magnitude, 3000, duration, tier), owner);
|
|
}
|
|
|
|
public bool AddStatusEffect(StatusEffect newEffect, Character source, bool silent = false, bool hidden = false)
|
|
{
|
|
/*
|
|
worldMasterTextId
|
|
32001 [@2B([@IF($E4($EB(1),$EB(2)),you,[@IF($E9(7),[@SHEETEN(xtx/displayName,2,$E9(7),1,1)],$EB(2))])])] [@IF($E4($EB(1),$EB(2)),resist,resists)] the effect of [@SHEET(xtx/status,$E8(11),3)].
|
|
32002 [@SHEET(xtx/status,$E8(11),3)] fails to take effect.
|
|
*/
|
|
|
|
var effect = GetStatusEffectById(newEffect.GetStatusEffectId());
|
|
|
|
bool canOverwrite = false;
|
|
if (effect != null)
|
|
{
|
|
var overwritable = effect.GetOverwritable();
|
|
canOverwrite = (overwritable == (uint)StatusEffectOverwrite.Always) ||
|
|
(overwritable == (uint)StatusEffectOverwrite.GreaterOnly && (effect.GetDuration() < newEffect.GetDuration() || effect.GetMagnitude() < newEffect.GetMagnitude())) ||
|
|
(overwritable == (uint)StatusEffectOverwrite.GreaterOrEqualTo && (effect.GetDuration() <= newEffect.GetDuration() || effect.GetMagnitude() <= newEffect.GetMagnitude()));
|
|
}
|
|
|
|
if (canOverwrite || effect == null)
|
|
{
|
|
// send packet to client with effect added message
|
|
if (effect != null && (!silent || !effect.GetSilent() || (effect.GetFlags() & (uint)StatusEffectFlags.Silent) == 0))
|
|
{
|
|
// todo: send packet to client with effect added message
|
|
}
|
|
|
|
// wont send a message about losing effect here
|
|
if (canOverwrite)
|
|
effects.Remove(newEffect.GetStatusEffectId());
|
|
|
|
newEffect.SetStartTime(DateTime.Now);
|
|
newEffect.SetEndTime(DateTime.Now.AddSeconds(newEffect.GetDuration()));
|
|
newEffect.SetOwner(owner);
|
|
|
|
if (effects.Count < MAX_EFFECTS)
|
|
{
|
|
if(newEffect.script != null)
|
|
newEffect.CallLuaFunction(this.owner, "onGain", this.owner, newEffect);
|
|
else
|
|
LuaEngine.CallLuaStatusEffectFunction(this.owner, newEffect, "onGain", this.owner, newEffect);
|
|
effects.Add(newEffect.GetStatusEffectId(), newEffect);
|
|
newEffect.SetSilent(silent);
|
|
newEffect.SetHidden(hidden);
|
|
|
|
if (!newEffect.GetHidden())
|
|
{
|
|
int index = 0;
|
|
|
|
//If effect is already in the list of statuses, get that index, otherwise find the first open index
|
|
if (owner.charaWork.status.Contains(newEffect.GetStatusId()))
|
|
index = Array.IndexOf(owner.charaWork.status, newEffect.GetStatusId());
|
|
else
|
|
index = Array.IndexOf(owner.charaWork.status, (ushort) 0);
|
|
|
|
//owner.charaWork.status[index] = newEffect.GetStatusId();
|
|
SetStatusAtIndex(index, newEffect.GetStatusId());
|
|
//Stance statuses need their time set to an extremely high number so their icon doesn't flash
|
|
//Adding getduration with them doesn't work because it overflows
|
|
uint time = (newEffect.GetFlags() & (uint) StatusEffectFlags.Stance) == 0 ? Utils.UnixTimeStampUTC(newEffect.GetEndTime()) : 0xFFFFFFFF;
|
|
SetTimeAtIndex(index, time);
|
|
//owner.charaWork.statusShownTime[index] = time;
|
|
//owner.zone.BroadcastPacketAroundActor(owner, SetActorStatusPacket.BuildPacket(owner.actorId, (ushort)index, newEffect.GetStatusId()));
|
|
//owner.zone.BroadcastPacketsAroundActor(owner, owner.GetActorStatusPackets());
|
|
}
|
|
owner.RecalculateStats();
|
|
}
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public bool RemoveStatusEffect(StatusEffect effect, bool silent = false)
|
|
{
|
|
bool removedEffect = false;
|
|
if (effect != null && effects.ContainsKey(effect.GetStatusEffectId()))
|
|
{
|
|
// send packet to client with effect remove message
|
|
if (!silent && !effect.GetSilent() && (effect.GetFlags() & (uint)StatusEffectFlags.Silent) == 0)
|
|
{
|
|
owner.DoBattleAction(0, 0, new BattleAction(owner.actorId, 30331, effect.GetStatusEffectId()));
|
|
}
|
|
|
|
//hidden effects not in charawork
|
|
if(!effect.GetHidden())
|
|
{
|
|
var index = Array.IndexOf(owner.charaWork.status, effect.GetStatusId());
|
|
|
|
owner.charaWork.status[index] = 0;
|
|
owner.charaWork.statusShownTime[index] = 0;
|
|
this.owner.zone.BroadcastPacketAroundActor(this.owner, SetActorStatusPacket.BuildPacket(owner.actorId, (ushort)index, (ushort)0));
|
|
}
|
|
// function onLose(actor, effect)
|
|
effects.Remove(effect.GetStatusEffectId());
|
|
if(effect.script != null)
|
|
effect.CallLuaFunction(owner, "onLose", owner, effect);
|
|
else
|
|
LuaEngine.CallLuaStatusEffectFunction(this.owner, effect, "onLose", this.owner, effect);
|
|
owner.RecalculateStats();
|
|
sendUpdate = true;
|
|
removedEffect = true;
|
|
}
|
|
|
|
return removedEffect;
|
|
}
|
|
|
|
public bool RemoveStatusEffect(uint effectId, bool silent = false)
|
|
{
|
|
bool removedEffect = false;
|
|
foreach (var effect in effects.Values)
|
|
{
|
|
if (effect.GetStatusEffectId() == effectId)
|
|
{
|
|
RemoveStatusEffect(effect, effect.GetSilent() || silent);
|
|
removedEffect = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
return removedEffect;
|
|
}
|
|
|
|
|
|
//Remove status effect and return the battleaction message instead of sending it immediately
|
|
public BattleAction RemoveStatusEffectForBattleAction(uint effectId, ushort worldMasterTextId = 30331)
|
|
{
|
|
BattleAction action = null;
|
|
if (RemoveStatusEffect(effectId, true))
|
|
action = new BattleAction(owner.actorId, worldMasterTextId, effectId);
|
|
|
|
return action;
|
|
}
|
|
|
|
//Remove status effect and return the battleaction message instead of sending it immediately
|
|
public BattleAction RemoveStatusEffectForBattleAction(StatusEffect effect, ushort worldMasterTextId = 30331)
|
|
{
|
|
BattleAction action = null;
|
|
if (RemoveStatusEffect(effect, true))
|
|
action = new BattleAction(owner.actorId, worldMasterTextId, effect.GetStatusEffectId());
|
|
return action;
|
|
}
|
|
|
|
public StatusEffect CopyEffect(StatusEffect effect)
|
|
{
|
|
var newEffect = new StatusEffect(owner, effect);
|
|
newEffect.SetOwner(owner);
|
|
// todo: should source be copied too?
|
|
return AddStatusEffect(newEffect, effect.GetSource()) ? newEffect : null;
|
|
}
|
|
|
|
public bool RemoveStatusEffectsByFlags(uint flags, bool silent = false)
|
|
{
|
|
// build list of effects to remove
|
|
var removeEffects = GetStatusEffectsByFlag(flags);
|
|
|
|
// remove effects from main list
|
|
foreach (var effect in removeEffects)
|
|
RemoveStatusEffect(effect, silent);
|
|
|
|
// removed an effect with one of these flags
|
|
return removeEffects.Count > 0;
|
|
}
|
|
|
|
public StatusEffect GetStatusEffectById(uint id, byte tier = 0xFF)
|
|
{
|
|
StatusEffect effect;
|
|
|
|
if (effects.TryGetValue(id, out effect) && effect.GetStatusEffectId() == id && (tier != 0xFF ? effect.GetTier() == tier : true))
|
|
return effect;
|
|
|
|
return null;
|
|
}
|
|
|
|
public List<StatusEffect> GetStatusEffectsByFlag(uint flag)
|
|
{
|
|
var list = new List<StatusEffect>();
|
|
foreach (var effect in effects.Values)
|
|
if ((effect.GetFlags() & flag) != 0)
|
|
list.Add(effect);
|
|
|
|
return list;
|
|
}
|
|
|
|
// todo: why the fuck cant c# convert enums/
|
|
public bool HasStatusEffectsByFlag(StatusEffectFlags flags)
|
|
{
|
|
return HasStatusEffectsByFlag((uint)flags);
|
|
}
|
|
|
|
public bool HasStatusEffectsByFlag(uint flag)
|
|
{
|
|
foreach (var effect in effects.Values)
|
|
{
|
|
if ((effect.GetFlags() & flag) != 0)
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public IEnumerable<StatusEffect> GetStatusEffects()
|
|
{
|
|
return effects.Values;
|
|
}
|
|
|
|
void SaveStatusEffectsToDatabase(StatusEffectFlags removeEffectFlags = StatusEffectFlags.None)
|
|
{
|
|
if (owner is Player)
|
|
{
|
|
Database.SavePlayerStatusEffects((Player)owner);
|
|
}
|
|
}
|
|
|
|
public void CallLuaFunctionByFlag(uint flag, string function, params object[] args)
|
|
{
|
|
var effects = GetStatusEffectsByFlag(flag);
|
|
|
|
object[] argsWithEffect = new object[args.Length + 1];
|
|
|
|
for (int i = 0; i < args.Length; i++)
|
|
argsWithEffect[i + 1] = args[i];
|
|
|
|
foreach (var effect in effects)
|
|
{
|
|
argsWithEffect[0] = effect;
|
|
effect.CallLuaFunction(owner, function, argsWithEffect);
|
|
}
|
|
}
|
|
|
|
//Sets the status id at an index.
|
|
//Changing a status to another doesn't seem to work. If updating an index that already has an effect, set it to 0 first then to the correct status
|
|
public void SetStatusAtIndex(int index, ushort statusId)
|
|
{
|
|
owner.charaWork.status[index] = statusId;
|
|
//owner.zone.BroadcastPacketAroundActor(owner, SetActorStatusPacket.BuildPacket(owner.actorId, (ushort)index, statusId));
|
|
|
|
statusSubpackets.Add(SetActorStatusPacket.BuildPacket(owner.actorId, (ushort)index, statusId));
|
|
owner.updateFlags |= ActorUpdateFlags.Status;
|
|
}
|
|
|
|
public void SetTimeAtIndex(int index, uint time)
|
|
{
|
|
owner.charaWork.statusShownTime[index] = time;
|
|
statusTimerPropPacketUtil.AddProperty($"charaWork.statusShownTime[{index}]");
|
|
owner.updateFlags |= ActorUpdateFlags.StatusTime;
|
|
}
|
|
|
|
public List<SubPacket> GetStatusPackets()
|
|
{
|
|
return statusSubpackets;
|
|
}
|
|
|
|
public List<SubPacket> GetStatusTimerPackets()
|
|
{
|
|
return statusTimerPropPacketUtil.Done();
|
|
}
|
|
|
|
public void ResetPropPacketUtil()
|
|
{
|
|
statusTimerPropPacketUtil = new ActorPropertyPacketUtil("charaWork/status", owner);
|
|
}
|
|
|
|
//Overwrites effectToBeReplaced with a new status effect
|
|
//Returns the message of the new effect being added
|
|
//Doing this instead of simply calling remove then add so that the new effect is in the same slot as the old one
|
|
//There should be a better way to do this
|
|
//Currently causes the icons to blink whenb eing rpelaced
|
|
public BattleAction ReplaceEffect(StatusEffect effectToBeReplaced, uint newEffectId, byte tier, double magnitude, uint duration)
|
|
{
|
|
StatusEffect newEffect = Server.GetWorldManager().GetStatusEffect(newEffectId);
|
|
newEffect.SetTier(tier);
|
|
newEffect.SetMagnitude(magnitude);
|
|
newEffect.SetDuration(duration);
|
|
newEffect.SetOwner(effectToBeReplaced.GetOwner());
|
|
effectToBeReplaced.CallLuaFunction(owner, "onLose", owner, effectToBeReplaced);
|
|
newEffect.CallLuaFunction(owner, "onGain", owner, newEffect);
|
|
effects.Remove(effectToBeReplaced.GetStatusEffectId());
|
|
|
|
newEffect.SetStartTime(DateTime.Now);
|
|
newEffect.SetEndTime(DateTime.Now.AddSeconds(newEffect.GetDuration()));
|
|
uint time = (newEffect.GetFlags() & (uint)StatusEffectFlags.Stance) == 0 ? Utils.UnixTimeStampUTC(newEffect.GetEndTime()) : 0xFFFFFFFF;
|
|
int index = Array.IndexOf(owner.charaWork.status, effectToBeReplaced.GetStatusId());
|
|
|
|
//owner.charaWork.status[index] = newEffect.GetStatusId();
|
|
owner.charaWork.statusShownTime[index] = time;
|
|
effects[newEffectId] = newEffect;
|
|
|
|
SetStatusAtIndex(index, 0);
|
|
|
|
//charawork/status
|
|
SetStatusAtIndex(index, (ushort) (newEffectId - 200000));
|
|
SetTimeAtIndex(index, time);
|
|
|
|
return new BattleAction(owner.actorId, 30328, (uint) HitEffect.StatusEffectType | newEffectId);
|
|
}
|
|
}
|
|
} |