/* Actions
*
* When selecting an action (pressing a button), we do several things.
*
* 1. Make sure we can actually afford the skill.
* 2. If the currentAbility is NULL (value == 0), add it. Otherwise, queue it up. Queue only holds one ability; the last one pressed.
* 3. Set the amount to add to the actionBar each frame such that it takes castTime seconds to use the ability. actionBar increments from 0 to 100.
*/
void setNextAbility(AbilityID nextAbility, int buttonIndex)
{
if (Abilities.allAbilities[(int)nextAbility].cost <= mana.value)
{
if (abilityCooldowns[buttonIndex] == 0)
{
if (currentAbility == (int)AbilityID.NULL)
{
currentAbility = (int)nextAbility;
currentAbilityButton = buttonIndex;
actionText.text = Abilities.allAbilities[(int)nextAbility].name;
actionProgressPerFrame = actionBar.maxValue / (Abilities.allAbilities[(int)nextAbility].castTime * SystemController.FRAME_RATE);
}
else
{
if ((currentAbility != (int)nextAbility || Abilities.allAbilities[(int)currentAbility].cooldown == 0.0f))
{
queuedAbility = (int)nextAbility;
queuedAbilityButton = buttonIndex;
}
}
}
else
{
Debug.Log("Ability still on cooldown!");
}
}
else
{
Debug.Log("No mana to cast!");
}
}
public void Write(WorldPacket data)
{
data.WriteUInt64(DbID);
data.WriteUInt32(GarrFollowerID);
data.WriteUInt32(Quality);
data.WriteUInt32(FollowerLevel);
data.WriteUInt32(ItemLevelWeapon);
data.WriteUInt32(ItemLevelArmor);
data.WriteUInt32(Xp);
data.WriteUInt32(Durability);
data.WriteUInt32(CurrentBuildingID);
data.WriteUInt32(CurrentMissionID);
data.WriteInt32(AbilityID.Count);
data.WriteUInt32(ZoneSupportSpellID);
data.WriteUInt32(FollowerStatus);
data.WriteInt32(Health);
data.WriteInt8(BoardIndex);
data.WriteInt32(HealingTimestamp);
AbilityID.ForEach(ability => data.WriteUInt32(ability.Id));
data.WriteBits(CustomName.GetByteCount(), 7);
data.FlushBits();
data.WriteString(CustomName);
}
public AbilityCaster(Entity caster, AbilityID abilityID, bool waitsForInput, string desc)
{
this.caster = caster;
this.abID = abilityID;
this.abilityDesc = desc;
this.waitsForInput = waitsForInput;
}
public NPCTypeInfo(Element primary, Element secondary, Element offensive, AbilityID ability)
{
Primary = primary;
Secondary = secondary;
Offensive = offensive;
Container = new AbilityContainer(ability);
ModifyType = ModifyTypeByEnvironmentDefault;
}
public IAbility GetAndDeActivateAbilityByID(AbilityID id)
{
IAbility ability = Array.Find(abilityDatabase.abilities, x => (x.id == id)).iAbility;
controller.DeactivateAbility(ability);
return(ability);
}
private void SpawnRandomAbility()
{
int rand = UnityEngine.Random.Range(0, Enum.GetNames(typeof(AbilityID)).Length);
//Enum.GetNames(typeof(MyEnum)).Length;
AbilityID id = (AbilityID)rand;
SpawnAbility(id);
}
private void OnRemove(GameObject go)
{
Debug.Log("removed: " + go.name);
GamePiece piece = go.GetComponent <GamePiece>();
AbilityID id = piece.abilityID;
messenger.SendAbilityMessage("inactive", ((int)id).ToString());
}
public Ability(string name, AbilityID id, int cost, float castTime, float cooldown, int power, string damageType)
{
this.name = name;
this.id = id;
this.cost = cost;
this.castTime = castTime;
this.cooldown = cooldown;
this.power = power;
this.damageType = damageType;
}
public void OnSelectAtkActionButton(PlayerSeat Seat, AbilityID Id)
{
if (Seat == seat && ability != null && Id == ability.Ability.AbilityID)
{
OnToggle.Invoke(!actionOutline.Active);
GameEvents.Instance.Notify <IActionBoard>(i => i.OnBoardActionCheck(seat, actionOutline.Active ? ability : null));
}
else
{
OnToggle.Invoke(false);
}
}
public void SpawnAbility(AbilityID id)
{
GameObject abilityPrefab = Array.Find(abilityDatabase.abilities, x => (x.id == id)).block;
GameObject newAbilityObject = Instantiate(abilityPrefab, blockPosition.position, Quaternion.identity, BlocksParent) as GameObject;
GamePiece gamePiece = newAbilityObject.GetComponent <GamePiece>();
gamePiece.packingManager = this;
gamePiece.abilityID = Array.Find(abilityDatabase.abilities, x => (x.id == id)).id;
gamePiece.OnSuccessfulPlace += OnPlace;
gamePiece.OnRemove += OnRemove;
}
private void OnPlace(GameObject go, AbilityID ability)
{
Debug.Log("placed: " + go.name);
GamePiece piece = go.GetComponent <GamePiece>();
piece.abilityID = ability;
pieces.Add(piece);
Debug.Log(((int)ability).ToString());
messenger.SendAbilityMessage("active", ((int)ability).ToString());
}
/// <summary>
/// Reads values from AION's memory and sets struct values accordingly.
/// </summary>
public void Update()
{
if (PtrBase != 0)
{
PtrChild1 = (int)Memory.ReadUInt(Process.handle, (uint)PtrBase);
PtrChild2 = (int)Memory.ReadUInt(Process.handle, (uint)(PtrBase + 0x04));
PtrChild3 = (int)Memory.ReadUInt(Process.handle, (uint)(PtrBase + 0x08));
AbilityID = (int)Memory.ReadUInt(Process.handle, (uint)(PtrBase + 0x0C));
if (AbilityID != 0)
{
AbilityName = AbilityID.ToString();
}
}
}
public int GetModifier(AbilityID ability)
{
float total;
if (GetAbilityScore(ability) % 2 != 0)
{
total = ((GetAbilityScore(ability) - 1f) / 2) - 5;
}
else
{
total = (GetAbilityScore(ability) / 2) - 5;
}
return((int)total);
}
public static Ability getAbility(AbilityID id)
{
if (instance == null)
{
instance = FindObjectOfType <AbilityIDList>();
}
foreach (AbilityIDAndAbility item in instance.list)
{
if (item.id == id)
{
return(item.ability);
}
}
Debug.LogError("Tried to get ability with id " + id + " but there is no ability with that id in the list.");
return(null);
}
public ItemKindRec(int name, byte order, int color,
bool rndImage, byte images, string imageSign,
AbilityID ability, ItemFlags flags, EquipMode equipMode)
{
Name = name;
Order = order;
Color = color;
RndImage = rndImage;
Images = images;
ImageSign = imageSign;
Ability = ability;
Flags = flags;
EquipMode = equipMode;
ImageIndex = -1;
ImagesLoaded = 0;
}
public static ItemKindRec Create(int name, byte order, int color,
bool rndImage, byte images, string imageSign,
AbilityID ability, ItemFlags flags, EquipMode equipMode)
{
ItemKindRec result = new ItemKindRec();
result.Name = name;
result.Order = order;
result.Color = color;
result.RndImage = rndImage;
result.Images = images;
result.ImageSign = imageSign;
result.Ability = ability;
result.Flags = flags;
result.EquipMode = equipMode;
result.ImageIndex = -1;
result.ImagesLoaded = 0;
return(result);
}
public static void RearrangeID(float xPos, AbilityID id, string droneData)
{
if (id != AbilityID.SpawnDrone)
{
var list = (instance.visibleAbilityOrder.GetList((int)instance.currentVisibles) as List <AbilityID>);
int index = GetAbilityPosInverse(xPos);
list.Remove(id);
list.Insert(index, id);
}
else
{
var list = (instance.visibleAbilityOrder.GetList((int)instance.currentVisibles) as List <string>);
int index = GetAbilityPosInverse(xPos);
list.Remove(droneData);
list.Insert(index, droneData);
}
instance.Rearrange();
}
public EffectRec(int name, EffectParams reqParams, EffectFlags flags,
int frameCount, string gfx, string sfx, MNXRange duration,
MNXRange magnitude, int mpReq, int levReq,
AbilityID resistance, MNXRange damage)
{
NameRS = name;
ReqParams = reqParams;
Flags = flags;
FrameCount = (sbyte)frameCount;
GFX = gfx;
SFX = sfx;
Duration = duration;
Magnitude = magnitude;
MPReq = (short)mpReq;
LevReq = (short)levReq;
Resistance = resistance;
Damage = damage;
ImageIndex = -1;
}
public void Cast(AbilityID abilityType)
{
if (!isReady)
return;
if (Cooldowns.ContainsKey(abilityType) && Cooldowns[abilityType] > 0)
return;
// Do nothing if we're under global cooldown.
if (Animations.ContainsKey("attacking"))
sprite.PlayAnimation(Animations["attacking"]);
AbilityFactory.Create(abilityType, this);
// Delay after cast.
if (isReady)
DelayTimer = 150f;
}
public void AddAbility(AbilityID abID, bool requiresInput, string description)
{
string[] ab = abID.ToString().Split('_');
string abName = string.Empty;
for (int i = 0; i < ab.Length; i++)
{
abName += ab[i] + " ";
}
if (abilities == null)
{
abilities = new Ability[] { new Ability(abID, requiresInput, description) };
// add input
playerInputSystem.AddDynamicKeys(() => abilitySystem.CallAbility(abilities[0], thisEntity), "1");
UI_Manager.instance.AddButtonAction(() => abilitySystem.CallAbility(abilities[0], thisEntity), abName + description);
return;
}
if (abilities.Length >= 10)
{
// ABILITIES FULL!
return;
}
// Extend array of abilities
Ability[] origAbilities = abilities;
abilities = new Ability[origAbilities.Length + 1];
for (int i = 0; i < origAbilities.Length; i++)
{
abilities[i] = origAbilities[i];
}
abilities[abilities.Length - 1] = new Ability(abID, requiresInput, description);
// add input only for new last one added
string keyName = (abilities.Length).ToString();
if (abilities.Length >= 10)
{
keyName = "0";
}
playerInputSystem.AddDynamicKeys(() => abilitySystem.CallAbility(abilities[abilities.Length - 1], thisEntity), keyName);
UI_Manager.instance.AddButtonAction(() => abilitySystem.CallAbility(abilities[abilities.Length - 1], thisEntity), abName + description);
}
private void CastAbility(Entity caster, AbilityID abilityID, string description)
{
PositionComponent poC = (PositionComponent)caster.GetEntityComponent(ComponentID.Position);
FighterComponent fighter = (FighterComponent)caster.GetEntityComponent(ComponentID.Fighter);
switch (abilityID)
{
case AbilityID.Blood_For_Light:
CastBloodForLight(fighter, poC.moveData, poC.directionData, description);
break;
case AbilityID.Teleport:
CastTeleport(fighter, poC, description);
break;
default:
break;
}
}
public static float Stab <A, D>(A offensiveType, D user)
where A : IOffensiveType
where D : ITarget, IPrimaryType, ISecondaryType, IAbility
{
Element defensePrimary = user.Primary;
Element defenseSecondary = user.Secondary;
AbilityID abilityID = user.GetAbility;
Ability ability = GetAbility(abilityID);
Element offensive = offensiveType.Offensive;
float multiplier = 1.0f;
bool stab = false;
if (offensive != Element.none)
{
if (defensePrimary == offensive)
{
stab = true;
}
if (defenseSecondary == offensive)
{
stab = true;
}
}
if (ability.ForceStab(offensive))
{
stab = true;
}
if (stab)
{
multiplier *= ModContent.GetInstance <Config>().STAB;
}
return(multiplier);
}
public override void SetDefaults(NPC npc)
{
base.SetDefaults(npc);
this.NPC = npc;
if (DictionaryHelper.NPC(npc).ContainsKey(npc.type))
{
NPCTypeInfo typeInfo = DictionaryHelper.NPC(npc)[npc.type];
AbilityContainer abilityContainer = typeInfo.Container;
float chance = ModContent.GetInstance <Config>().HiddenAbilityChancePercent;
AbilityID ability = abilityContainer.PrimaryAbility;
if (abilityContainer.SecondaryAbility != AbilityID.None)
{
if (Main.rand.NextDouble() <= 0.5)
{
ability = abilityContainer.SecondaryAbility;
}
}
if (abilityContainer.HiddenAbility != AbilityID.None)
{
if (Main.rand.NextDouble() <= (chance * 0.01))
{
ability = abilityContainer.HiddenAbility;
}
}
CurrentAbilityID = ability;
//Main.NewText(
// $"NPC: {NPCID.GetUniqueKey(npc.type)}. " +
// $"Possible Abilities: {abilityContainer.PrimaryAbility}, {abilityContainer.SecondaryAbility}, ({abilityContainer.HiddenAbility}). " +
// $"Selected Ability: {AbilityID}. ");
}
}
public ArmorTypeInfo(Element primary, Element secondary, AbilityID abilityID)
{
Primary = primary;
Secondary = secondary;
AbilityID = abilityID;
}
public ArmorTypeInfo(Element primary, Element secondary)
{
Primary = primary;
Secondary = secondary;
AbilityID = AbilityID.None;
}
public TypeSet(ArmorTypeInfo armorTypeInfo)
{
Primary = armorTypeInfo.Primary;
Secondary = armorTypeInfo.Secondary;
GetAbility = armorTypeInfo.AbilityID;
}
//[Obsolete]
///// <summary>
///// Will create an Ability Container for an NPC with no secondary or hidden ability.
///// </summary>
//public AbilityContainer(AbilityID primaryAbility)
//{
// PrimaryAbility = primaryAbility;
// SecondaryAbility = AbilityID.None;
// HiddenAbility = AbilityID.None;
//}
/// <summary>
/// Will create an Ability Container for an NPC with a primary, secondary, and hidden ability.
/// </summary>
public AbilityContainer(AbilityID primaryAbility, AbilityID secondaryAbility = AbilityID.None, AbilityID hiddenAbility = AbilityID.None)
{
PrimaryAbility = primaryAbility;
SecondaryAbility = secondaryAbility;
HiddenAbility = hiddenAbility;
}
public int GetAbilityScore(AbilityID ability)
{
return(_abilityScores[(int)ability]);
}
/// <summary>
/// Sets the cooldown of an ability.
/// </summary>
/// <param name="abilityID">AbilityID of the casted ability.</param>
/// <param name="cooldownDuration">Duration to set the cooldown for.</param>
public void SetCooldown(AbilityID abilityID, float cooldownDuration)
{
if (Cooldowns.ContainsKey(abilityID))
{
Cooldowns[abilityID] = cooldownDuration;
}
else
{
Cooldowns.Add(AbilityID.RangedAttack, cooldownDuration);
}
return;
}
public static Ability Create(AbilityID abilityID, Unit caster)
{
Ability ability = AbilityFactory.FastReflect(abilityID, caster);
caster.SetCooldown(AbilityID.RangedAttack, ability.Cooldown);
ability.Position = caster.Position;
GameManager.TheGameManager.Lists.AddOnNextFrameList.Add(ability);
return ability;
}
public static Ability FastReflect(AbilityID abilityID, Unit caster)
{
switch (abilityID)
{
case AbilityID.Grenade: return new Grenade(caster);
//case AbilityID.Bullet: return new Bullet(caster);
//case AbilityID.BulletBomb: return new BulletBomb(caster);
case AbilityID.BulletSpiral: return new BulletSpiral(caster);
case AbilityID.BulletCross: return new BulletCross(caster);
case AbilityID.ChargeStrike: return new ChargeStrike(caster);
case AbilityID.SweepLaser: return new SweepLaser(caster);
case AbilityID.SlimeAbility: return new SlimeAbility(caster);
}
return null;
}
protected void SetAbilityScore(AbilityID attribute, int value)
{
_abilityScores[(int)attribute] = value;
}
public TypeSet(Element primary, Element secondary, AbilityID abilityID = AbilityID.None)
{
Primary = primary;
Secondary = secondary;
GetAbility = abilityID;
}
private void UpdateView()
{
fDisciplinesList.Items.BeginUpdate();
fDisciplinesList.Items.Clear();
NWCreature clt = fCollocutor;
Player p = GlobalVars.nwrGame.Player;
for (int i = 0; i < StaticData.dbTeachable.Length; i++)
{
int id = StaticData.dbTeachable[i].Id;
bool res = false;
TeachableKind kind = StaticData.dbTeachable[i].Kind;
string s = "";
int imageIndex = -1;
int curLev = 0;
switch (kind)
{
case TeachableKind.Ability:
AbilityRec abRec = StaticData.dbAbilities[id];
AbilityID ab = (AbilityID)id;
if (clt.GetAbility(ab) > 0)
{
s = BaseLocale.GetStr(abRec.Name);
imageIndex = -1;
curLev = p.GetAbility(ab);
res = (curLev < clt.GetAbility(ab));
}
break;
case TeachableKind.Skill:
SkillRec skRec = StaticData.dbSkills[id];
SkillID sk = (SkillID)id;
if (clt.GetSkill(sk) >= 0)
{
s = BaseLocale.GetStr(skRec.Name);
imageIndex = skRec.ImageIndex;
curLev = p.GetSkill(sk);
res = (curLev < clt.GetSkill(sk));
}
break;
}
int price = (int)GlobalVars.nwrGame.GetTeachablePrice(i, curLev);
if (res)
{
string st = " ( " + Convert.ToString(curLev) + " -> " + Convert.ToString(curLev + 1) + " )";
LBItem listItem = fDisciplinesList.Items.Add(s + st, new TeachItem(i, curLev, price));
if (price > p.Money)
{
listItem.Color = Colors.Red;
}
else
{
listItem.Color = Colors.Gold;
}
listItem.ImageIndex = imageIndex;
listItem.SubItems.Add(Convert.ToString(price), null);
}
}
fDisciplinesList.Items.EndUpdate();
}
