SpellDefines.h

Go to the documentation of this file.

/*
 * This file is part of the TrinityCore Project. See AUTHORS file for Copyright information
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by the
 * Free Software Foundation; either version 2 of the License, or (at your
 * option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
 * more details.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program. If not, see <http://www.gnu.org/licenses/>.
 */
 
#ifndef TRINITY_SPELLDEFINES_H
#define TRINITY_SPELLDEFINES_H
 
#include "Define.h"
#include "FlagsArray.h"
#include "EnumFlag.h"
#include "ObjectGuid.h"
#include "Optional.h"
#include "Position.h"
#include <any>
#include <vector>
 
class AuraEffect;
class Corpse;
class GameObject;
class Item;
class Player;
class Spell;
class Unit;
class WorldObject;
enum Difficulty : uint8;
enum ProcFlags : uint32;
enum ProcFlags2 : int32;
 
namespace UF
{
 struct SpellCastVisual;
}
 
namespace WorldPackets
{
 namespace Spells
 {
 struct SpellCastRequest;
 struct SpellCastVisual;
 struct SpellTargetData;
 }
}
 
enum class SpellInterruptFlags : uint32
{
 None = 0,
 Movement = 0x00000001,
 DamagePushbackPlayerOnly = 0x00000002,
 Stun = 0x00000004, // useless, even spells without it get interrupted
 Combat = 0x00000008,
 DamageCancelsPlayerOnly = 0x00000010,
 MeleeCombat = 0x00000020, // NYI
 Immunity = 0x00000040, // NYI
 DamageAbsorb = 0x00000080,
 ZeroDamageCancels = 0x00000100,
 DamagePushback = 0x00000200,
 DamageCancels = 0x00000400
};
 
DEFINE_ENUM_FLAG(SpellInterruptFlags);
 
enum class SpellAuraInterruptFlags : uint32
{
 None = 0,
 HostileActionReceived = 0x00000001,
 Damage = 0x00000002,
 Action = 0x00000004,
 Moving = 0x00000008,
 Turning = 0x00000010,
 Anim = 0x00000020,
 Dismount = 0x00000040,
 UnderWater = 0x00000080, // TODO: disallow casting when swimming (SPELL_FAILED_ONLY_ABOVEWATER)
 AboveWater = 0x00000100, // TODO: disallow casting when not swimming (SPELL_FAILED_ONLY_UNDERWATER)
 Sheathing = 0x00000200,
 Interacting = 0x00000400, // TODO: more than gossip, replace all the feign death removals by aura type
 Looting = 0x00000800,
 Attacking = 0x00001000,
 ItemUse = 0x00002000,
 DamageChannelDuration = 0x00004000,
 Shapeshifting = 0x00008000,
 ActionDelayed = 0x00010000,
 Mount = 0x00020000,
 Standing = 0x00040000,
 LeaveWorld = 0x00080000,
 StealthOrInvis = 0x00100000,
 InvulnerabilityBuff = 0x00200000,
 EnterWorld = 0x00400000,
 PvPActive = 0x00800000,
 NonPeriodicDamage = 0x01000000,
 LandingOrFlight = 0x02000000,
 Release = 0x04000000,
 DamageCancelsScript = 0x08000000, // NYI dedicated aura script hook
 EnteringCombat = 0x10000000,
 Login = 0x20000000,
 Summon = 0x40000000,
 LeavingCombat = 0x80000000,
 
 NOT_VICTIM = (HostileActionReceived | Damage | NonPeriodicDamage)
};
 
DEFINE_ENUM_FLAG(SpellAuraInterruptFlags);
 
enum class SpellAuraInterruptFlags2 : uint32
{
 None = 0,
 Falling = 0x00000001, // Implemented in Unit::UpdatePosition
 Swimming = 0x00000002,
 NotMoving = 0x00000004, // NYI
 Ground = 0x00000008,
 Transform = 0x00000010, // NYI
 Jump = 0x00000020,
 ChangeSpec = 0x00000040,
 AbandonVehicle = 0x00000080, // Implemented in Unit::_ExitVehicle
 StartOfEncounter = 0x00000100, // Implemented in Unit::AtStartOfEncounter
 EndOfEncounter = 0x00000200, // Implemented in Unit::AtEndOfEncounter
 Disconnect = 0x00000400, // NYI
 EnteringInstance = 0x00000800, // Implemented in Map::AddPlayerToMap
 DuelEnd = 0x00001000, // Implemented in Player::DuelComplete
 LeaveArenaOrBattleground = 0x00002000, // Implemented in Battleground::RemovePlayerAtLeave
 ChangeTalent = 0x00004000,
 ChangeGlyph = 0x00008000,
 SeamlessTransfer = 0x00010000, // NYI
 WarModeLeave = 0x00020000, // Implemented in Player::UpdateWarModeAuras
 TouchingGround = 0x00040000, // NYI
 ChromieTime = 0x00080000, // NYI
 SplineFlightOrFreeFlight = 0x00100000, // NYI
 ProcOrPeriodicAttacking = 0x00200000, // NYI
 StartOfMythicPlusRun = 0x00400000, // Implemented in Unit::AtStartOfEncounter
 StartOfDungeonEncounter = 0x00800000, // Implemented in Unit::AtStartOfEncounter - Similar to StartOfEncounter (but only with bosses, not m+ run or battleground)
 EndOfDungeonEncounter = 0x01000000, // Implemented in Unit::AtEndOfEncounter - Similar to EndOfEncounter (but only with bosses, not m+ run or battleground)
};
 
DEFINE_ENUM_FLAG(SpellAuraInterruptFlags2);
 
enum class SpellModOp : uint8
{
 HealingAndDamage = 0,
 Duration = 1,
 Hate = 2,
 PointsIndex0 = 3,
 ProcCharges = 4,
 Range = 5,
 Radius = 6,
 CritChance = 7,
 Points = 8,
 ResistPushback = 9,
 ChangeCastTime = 10,
 Cooldown = 11,
 PointsIndex1 = 12,
 TargetResistance = 13,
 PowerCost0 = 14, // Used when SpellPowerEntry::PowerIndex == 0
 CritDamageAndHealing = 15,
 HitChance = 16,
 ChainTargets = 17,
 ProcChance = 18,
 Period = 19,
 ChainAmplitude = 20,
 StartCooldown = 21,
 PeriodicHealingAndDamage = 22,
 PointsIndex2 = 23,
 BonusCoefficient = 24,
 TriggerDamage = 25, // NYI
 ProcFrequency = 26,
 Amplitude = 27,
 DispelResistance = 28,
 CrowdDamage = 29, // NYI
 PowerCostOnMiss = 30,
 Doses = 31,
 PointsIndex3 = 32,
 PointsIndex4 = 33,
 PowerCost1 = 34, // Used when SpellPowerEntry::PowerIndex == 1
 ChainJumpDistance = 35,
 AreaTriggerMaxSummons = 36, // NYI
 MaxAuraStacks = 37,
 ProcCooldown = 38,
 PowerCost2 = 39, // Used when SpellPowerEntry::PowerIndex == 2
};
 
#define MAX_SPELLMOD 40
 
enum SpellValueMod : uint8
{
 SPELLVALUE_BASE_POINT0,
 SPELLVALUE_BASE_POINT1,
 SPELLVALUE_BASE_POINT2,
 SPELLVALUE_BASE_POINT3,
 SPELLVALUE_BASE_POINT4,
 SPELLVALUE_BASE_POINT5,
 SPELLVALUE_BASE_POINT6,
 SPELLVALUE_BASE_POINT7,
 SPELLVALUE_BASE_POINT8,
 SPELLVALUE_BASE_POINT9,
 SPELLVALUE_BASE_POINT10,
 SPELLVALUE_BASE_POINT11,
 SPELLVALUE_BASE_POINT12,
 SPELLVALUE_BASE_POINT13,
 SPELLVALUE_BASE_POINT14,
 SPELLVALUE_BASE_POINT15,
 SPELLVALUE_BASE_POINT16,
 SPELLVALUE_BASE_POINT17,
 SPELLVALUE_BASE_POINT18,
 SPELLVALUE_BASE_POINT19,
 SPELLVALUE_BASE_POINT20,
 SPELLVALUE_BASE_POINT21,
 SPELLVALUE_BASE_POINT22,
 SPELLVALUE_BASE_POINT23,
 SPELLVALUE_BASE_POINT24,
 SPELLVALUE_BASE_POINT25,
 SPELLVALUE_BASE_POINT26,
 SPELLVALUE_BASE_POINT27,
 SPELLVALUE_BASE_POINT28,
 SPELLVALUE_BASE_POINT29,
 SPELLVALUE_BASE_POINT30,
 SPELLVALUE_BASE_POINT31,
 SPELLVALUE_BASE_POINT_END,
 SPELLVALUE_RADIUS_MOD,
 SPELLVALUE_MAX_TARGETS,
 SPELLVALUE_AURA_STACK,
 SPELLVALUE_CRIT_CHANCE,
 SPELLVALUE_DURATION_PCT,
 SPELLVALUE_DURATION,
 SPELLVALUE_PARENT_SPELL_TARGET_COUNT,
 SPELLVALUE_PARENT_SPELL_TARGET_INDEX
};
 
enum SpellFacingFlags
{
 SPELL_FACING_FLAG_INFRONT = 0x0001
};
 
enum TriggerCastFlags : uint32
{
 TRIGGERED_NONE = 0x00000000, 
 TRIGGERED_IGNORE_GCD = 0x00000001, 
 TRIGGERED_IGNORE_SPELL_AND_CATEGORY_CD = 0x00000002, 
 TRIGGERED_IGNORE_POWER_AND_REAGENT_COST = 0x00000004, 
 TRIGGERED_IGNORE_CAST_ITEM = 0x00000008, 
 TRIGGERED_IGNORE_AURA_SCALING = 0x00000010, 
 TRIGGERED_IGNORE_CAST_IN_PROGRESS = 0x00000020, 
 // reuse = 0x00000040,
 TRIGGERED_CAST_DIRECTLY = 0x00000080, 
 // reuse = 0x00000100,
 TRIGGERED_IGNORE_SET_FACING = 0x00000200, 
 TRIGGERED_IGNORE_SHAPESHIFT = 0x00000400, 
 // reuse = 0x00000800,
 TRIGGERED_DISALLOW_PROC_EVENTS = 0x00001000, 
 TRIGGERED_IGNORE_CASTER_MOUNTED_OR_ON_VEHICLE = 0x00002000, 
 // reuse = 0x00004000,
 // reuse = 0x00008000,
 TRIGGERED_IGNORE_CASTER_AURAS = 0x00010000, 
 TRIGGERED_DONT_RESET_PERIODIC_TIMER = 0x00020000, 
 TRIGGERED_DONT_REPORT_CAST_ERROR = 0x00040000, 
 TRIGGERED_FULL_MASK = 0x0007FFFF, 
 
 // debug flags (used with .cast triggered commands)
 TRIGGERED_IGNORE_EQUIPPED_ITEM_REQUIREMENT = 0x00080000, 
 TRIGGERED_IGNORE_TARGET_CHECK = 0x00100000, 
 TRIGGERED_IGNORE_CASTER_AURASTATE = 0x00200000, 
 TRIGGERED_FULL_DEBUG_MASK = 0xFFFFFFFF
};
 
DEFINE_ENUM_FLAG(TriggerCastFlags);
 
enum SpellCastTargetFlags : uint32
{
 TARGET_FLAG_NONE = 0x00000000,
 TARGET_FLAG_UNUSED_1 = 0x00000001, // not used
 TARGET_FLAG_UNIT = 0x00000002, // pguid
 TARGET_FLAG_UNIT_RAID = 0x00000004, // not sent, used to validate target (if raid member)
 TARGET_FLAG_UNIT_PARTY = 0x00000008, // not sent, used to validate target (if party member)
 TARGET_FLAG_ITEM = 0x00000010, // pguid
 TARGET_FLAG_SOURCE_LOCATION = 0x00000020, // pguid, 3 float
 TARGET_FLAG_DEST_LOCATION = 0x00000040, // pguid, 3 float
 TARGET_FLAG_UNIT_ENEMY = 0x00000080, // not sent, used to validate target (if enemy)
 TARGET_FLAG_UNIT_ALLY = 0x00000100, // not sent, used to validate target (if ally)
 TARGET_FLAG_CORPSE_ENEMY = 0x00000200, // pguid
 TARGET_FLAG_UNIT_DEAD = 0x00000400, // not sent, used to validate target (if dead creature)
 TARGET_FLAG_GAMEOBJECT = 0x00000800, // pguid, used with TARGET_GAMEOBJECT_TARGET
 TARGET_FLAG_TRADE_ITEM = 0x00001000, // pguid
 TARGET_FLAG_STRING = 0x00002000, // string
 TARGET_FLAG_GAMEOBJECT_ITEM = 0x00004000, // not sent, used with TARGET_GAMEOBJECT_ITEM_TARGET
 TARGET_FLAG_CORPSE_ALLY = 0x00008000, // pguid
 TARGET_FLAG_UNIT_MINIPET = 0x00010000, // pguid, used to validate target (if non combat pet)
 TARGET_FLAG_GLYPH_SLOT = 0x00020000, // used in glyph spells
 TARGET_FLAG_DEST_TARGET = 0x00040000, // sometimes appears with DEST_TARGET spells (may appear or not for a given spell)
 TARGET_FLAG_EXTRA_TARGETS = 0x00080000, // uint32 counter, loop { vec3 - screen position (?), guid }, not used so far
 TARGET_FLAG_UNIT_PASSENGER = 0x00100000, // guessed, used to validate target (if vehicle passenger)
 TARGET_FLAG_UNK400000 = 0X00400000,
 TARGET_FLAG_UNK1000000 = 0X01000000,
 TARGET_FLAG_UNK4000000 = 0X04000000,
 TARGET_FLAG_UNK10000000 = 0X10000000,
 TARGET_FLAG_UNK40000000 = 0X40000000,
 
 TARGET_FLAG_UNIT_MASK = TARGET_FLAG_UNIT | TARGET_FLAG_UNIT_RAID | TARGET_FLAG_UNIT_PARTY
 | TARGET_FLAG_UNIT_ENEMY | TARGET_FLAG_UNIT_ALLY | TARGET_FLAG_UNIT_DEAD | TARGET_FLAG_UNIT_MINIPET | TARGET_FLAG_UNIT_PASSENGER,
 TARGET_FLAG_GAMEOBJECT_MASK = TARGET_FLAG_GAMEOBJECT | TARGET_FLAG_GAMEOBJECT_ITEM,
 TARGET_FLAG_CORPSE_MASK = TARGET_FLAG_CORPSE_ALLY | TARGET_FLAG_CORPSE_ENEMY,
 TARGET_FLAG_ITEM_MASK = TARGET_FLAG_TRADE_ITEM | TARGET_FLAG_ITEM | TARGET_FLAG_GAMEOBJECT_ITEM
};
 
struct TC_GAME_API SpellDestination
{
 SpellDestination();
 SpellDestination(float x, float y, float z, float orientation = 0.0f, uint32 mapId = MAPID_INVALID);
 SpellDestination(Position const& pos);
 SpellDestination(WorldLocation const& loc);
 SpellDestination(WorldObject const& wObj);
 
 void Relocate(Position const& pos);
 void RelocateOffset(Position const& offset);
 
 WorldLocation _position;
 ObjectGuid _transportGUID;
 Position _transportOffset;
};
 
class TC_GAME_API SpellCastTargets
{
public:
 SpellCastTargets();
 SpellCastTargets(Unit* caster, WorldPackets::Spells::SpellCastRequest const& spellCastRequest);
 ~SpellCastTargets();
 
 void Write(WorldPackets::Spells::SpellTargetData& data);
 
 uint32 GetTargetMask() const { return m_targetMask; }
 void SetTargetMask(uint32 newMask) { m_targetMask = newMask; }
 
 void SetTargetFlag(SpellCastTargetFlags flag) { m_targetMask |= flag; }
 
 ObjectGuid GetUnitTargetGUID() const;
 Unit* GetUnitTarget() const;
 void SetUnitTarget(Unit* target);
 
 ObjectGuid GetGOTargetGUID() const;
 GameObject* GetGOTarget() const;
 void SetGOTarget(GameObject* target);
 
 ObjectGuid GetCorpseTargetGUID() const;
 Corpse* GetCorpseTarget() const;
 
 WorldObject* GetObjectTarget() const;
 ObjectGuid GetObjectTargetGUID() const;
 void RemoveObjectTarget();
 
 ObjectGuid GetItemTargetGUID() const { return m_itemTargetGUID; }
 Item* GetItemTarget() const { return m_itemTarget; }
 uint32 GetItemTargetEntry() const { return m_itemTargetEntry; }
 void SetItemTarget(Item* item);
 void SetTradeItemTarget(Player* caster);
 void UpdateTradeSlotItem();
 
 SpellDestination const* GetSrc() const;
 Position const* GetSrcPos() const;
 void SetSrc(float x, float y, float z);
 void SetSrc(Position const& pos);
 void SetSrc(WorldObject const& wObj);
 void ModSrc(Position const& pos);
 void RemoveSrc();
 
 SpellDestination const* GetDst() const;
 WorldLocation const* GetDstPos() const;
 void SetDst(float x, float y, float z, float orientation, uint32 mapId = MAPID_INVALID);
 void SetDst(Position const& pos);
 void SetDst(WorldObject const& wObj);
 void SetDst(SpellDestination const& spellDest);
 void SetDst(SpellCastTargets const& spellTargets);
 void ModDst(Position const& pos);
 void ModDst(SpellDestination const& spellDest);
 void RemoveDst();
 
 bool HasSrc() const;
 bool HasDst() const;
 bool HasTraj() const { return m_speed != 0; }
 
 float GetPitch() const { return m_pitch; }
 void SetPitch(float pitch) { m_pitch = pitch; }
 float GetSpeed() const { return m_speed; }
 void SetSpeed(float speed) { m_speed = speed; }
 
 float GetDist2d() const { return m_src._position.GetExactDist2d(&m_dst._position); }
 float GetSpeedXY() const { return m_speed * std::cos(m_pitch); }
 float GetSpeedZ() const { return m_speed * std::sin(m_pitch); }
 
 void Update(WorldObject* caster);
 std::string GetTargetString() const { return m_strTarget; }
 
private:
 uint32 m_targetMask;
 
 // objects (can be used at spell creating and after Update at casting)
 WorldObject* m_objectTarget;
 Item* m_itemTarget;
 
 // object GUID/etc, can be used always
 ObjectGuid m_objectTargetGUID;
 ObjectGuid m_itemTargetGUID;
 uint32 m_itemTargetEntry;
 
 SpellDestination m_src;
 SpellDestination m_dst;
 
 float m_pitch, m_speed;
 std::string m_strTarget;
};
 
struct TC_GAME_API CastSpellTargetArg
{
 CastSpellTargetArg() { Targets.emplace(); }
 CastSpellTargetArg(std::nullptr_t) { Targets.emplace(); }
 CastSpellTargetArg(WorldObject* target);
 CastSpellTargetArg(Item* itemTarget)
 {
 Targets.emplace();
 Targets->SetItemTarget(itemTarget);
 }
 CastSpellTargetArg(Position const& dest)
 {
 Targets.emplace();
 Targets->SetDst(dest);
 }
 CastSpellTargetArg(SpellDestination const& dest)
 {
 Targets.emplace();
 Targets->SetDst(dest);
 }
 CastSpellTargetArg(SpellCastTargets&& targets)
 {
 Targets.emplace(std::move(targets));
 }
 
 Optional<SpellCastTargets> Targets; // empty optional used to signal error state
};
 
struct TC_GAME_API CastSpellExtraArgs
{
 CastSpellExtraArgs();
 CastSpellExtraArgs(bool triggered) : TriggerFlags(triggered ? TRIGGERED_FULL_MASK : TRIGGERED_NONE) {}
 CastSpellExtraArgs(TriggerCastFlags trigger) : TriggerFlags(trigger) {}
 CastSpellExtraArgs(Item* item) : TriggerFlags(TRIGGERED_FULL_MASK), CastItem(item) {}
 CastSpellExtraArgs(Spell const* triggeringSpell) : TriggerFlags(TRIGGERED_FULL_MASK) { SetTriggeringSpell(triggeringSpell); }
 CastSpellExtraArgs(AuraEffect const* eff) : TriggerFlags(TRIGGERED_FULL_MASK) { SetTriggeringAura(eff); }
 CastSpellExtraArgs(Difficulty castDifficulty) : CastDifficulty(castDifficulty) {}
 CastSpellExtraArgs(SpellValueMod mod, int32 val) { SpellValueOverrides.AddMod(mod, val); }
 
 CastSpellExtraArgs(CastSpellExtraArgs const& other);
 CastSpellExtraArgs(CastSpellExtraArgs&& other) noexcept;
 
 CastSpellExtraArgs& operator=(CastSpellExtraArgs const& other);
 CastSpellExtraArgs& operator=(CastSpellExtraArgs&& other) noexcept;
 
 ~CastSpellExtraArgs();
 
 CastSpellExtraArgs& SetTriggerFlags(TriggerCastFlags flag) { TriggerFlags = flag; return *this; }
 CastSpellExtraArgs& SetCastItem(Item* item) { CastItem = item; return *this; }
 CastSpellExtraArgs& SetTriggeringSpell(Spell const* triggeringSpell);
 CastSpellExtraArgs& SetTriggeringAura(AuraEffect const* triggeringAura);
 CastSpellExtraArgs& SetOriginalCaster(ObjectGuid const& guid) { OriginalCaster = guid; return *this; }
 CastSpellExtraArgs& SetCastDifficulty(Difficulty castDifficulty) { CastDifficulty = castDifficulty; return *this; }
 CastSpellExtraArgs& SetOriginalCastId(ObjectGuid const& castId) { OriginalCastId = castId; return *this; }
 CastSpellExtraArgs& AddSpellMod(SpellValueMod mod, int32 val) { SpellValueOverrides.AddMod(mod, val); return *this; }
 CastSpellExtraArgs& AddSpellBP0(int32 val) { return AddSpellMod(SPELLVALUE_BASE_POINT0, val); } // because i don't want to type SPELLVALUE_BASE_POINT0 300 times
 CastSpellExtraArgs& SetCustomArg(std::any customArg) { CustomArg = std::move(customArg); return *this; }
 
 TriggerCastFlags TriggerFlags = TRIGGERED_NONE;
 Item* CastItem = nullptr;
 Spell const* TriggeringSpell = nullptr;
 AuraEffect const* TriggeringAura = nullptr;
 ObjectGuid OriginalCaster = ObjectGuid::Empty;
 Difficulty CastDifficulty = Difficulty(0);
 ObjectGuid OriginalCastId = ObjectGuid::Empty;
 Optional<int32> OriginalCastItemLevel;
 struct
 {
 friend struct CastSpellExtraArgs;
 friend class WorldObject;
 
 private:
 void AddMod(SpellValueMod mod, int32 val) { data.push_back({ mod, val }); }
 
 auto begin() const { return data.cbegin(); }
 auto end() const { return data.cend(); }
 
 std::vector<std::pair<SpellValueMod, int32>> data;
 } SpellValueOverrides;
 std::any CustomArg;
};
 
struct SpellCastVisual
{
 uint32 SpellXSpellVisualID = 0;
 uint32 ScriptVisualID = 0;
 
 operator UF::SpellCastVisual() const;
 operator WorldPackets::Spells::SpellCastVisual() const;
};
 
class ProcFlagsInit : public FlagsArray<int32, 2>
{
 using Base = FlagsArray<int32, 2>;
 
public:
 constexpr ProcFlagsInit(ProcFlags procFlags = {}, ProcFlags2 procFlags2 = {})
 {
 _storage[0] = int32(procFlags);
 _storage[1] = int32(procFlags2);
 }
 
 constexpr ProcFlagsInit& operator|=(ProcFlags procFlags)
 {
 _storage[0] |= int32(procFlags);
 return *this;
 }
 
 constexpr ProcFlagsInit& operator|=(ProcFlags2 procFlags2)
 {
 _storage[1] |= int32(procFlags2);
 return *this;
 }
 
 using Base::operator&;
 
 constexpr ProcFlags operator&(ProcFlags procFlags) const
 {
 return static_cast<ProcFlags>(_storage[0] & procFlags);
 }
 
 constexpr ProcFlags2 operator&(ProcFlags2 procFlags2) const
 {
 return static_cast<ProcFlags2>(_storage[1] & procFlags2);
 }
 
 using Base::operator=;
 
 constexpr ProcFlagsInit& operator=(Base const& right)
 {
 _storage[0] = right[0];
 _storage[1] = right[1];
 return *this;
 }
};
 
#endif