class RipperdocMetersCapacity extends RipperdocMetersBase
{
	default m_slopeLengthModifier = 0.075f;
	default m_barWidgetLibraryName = 'CapacityMeterBar';
	default m_barsHeigh = 9.f;
	default m_barsMargin = 9.f;
	default BAR_COUNT = 50;
	[ category = "Capacity Bars" ]
	private editable var m_defaultRightBarScale : Float;
	default m_defaultRightBarScale = 1.f;
	[ category = "Capacity Bars" ]
	private editable var m_overchargeGapSize : Float;
	default m_overchargeGapSize = 9.f;
	[ category = "Capacity Labels" ]
	private editable var m_curCapacityLabelContainer : inkWidgetRef;
	[ category = "Capacity Labels" ]
	private editable var m_curCapacityLabelBackground : inkWidgetRef;
	[ category = "Capacity Labels" ]
	private editable var m_costLabelContainer : inkWidgetRef;
	[ category = "Capacity Labels" ]
	private editable var m_costLabelText : inkTextRef;
	[ category = "Capacity Labels" ]
	private editable var m_maxCapacityLabelContainer : inkWidgetRef;
	[ category = "Capacity Labels" ]
	private editable var m_maxCapacityLabelText : inkTextRef;
	[ category = "Overcharge Box" ]
	private editable var m_overchargeBox : inkWidgetRef;
	[ category = "Overcharge Box" ]
	private editable var m_thresholdLine : inkWidgetRef;
	[ category = "Overcharge Box" ]
	private editable var m_edgrunnerLock : inkWidgetRef;
	[ category = "Overcharge Box" ]
	private editable var m_overchargeGlow : inkWidgetRef;
	[ category = "Overcharge Box" ]
	private editable var m_overchargeGlowAnimName : CName;
	default m_overchargeGlowAnimName = 'overchargeGlow_pulse';
	[ tooltip = "Percent value of Max Possible Capacity below which Overcharge Box won't be Visible" ][ category = "Overcharge Box" ]
	private editable var m_overchargeVisibilityThreshold : Float;
	default m_overchargeVisibilityThreshold = 0.20f;
	private var m_currentCapacity : Int32;
	private var m_maxCapacity : Int32;
	private var m_maxCapacityPossible : Float;
	private var m_overchargeMaxCapacity : Int32;
	private var m_overchargeValue : Int32;
	default m_overchargeValue = 50;
	private var m_isEdgerunner : Bool;
	private var m_curCapacityLabel : weak< RipperdocFillLabel >;
	private var m_capacityLabelAnimation : inkAnimProxy;
	private var m_costLabelAnimation : inkAnimProxy;
	private var m_capacityPulseAnimation : PulseAnimation;
	private var m_costLabelPulseAnimation : PulseAnimation;
	private var m_overchargeGlowAnimProxy : inkAnimProxy;
	private var m_overchargeGlowAnimOptions : inkAnimOptions;
	private var m_overchargeBoxState : CName;
	private var m_maxBaseBar : Int32;
	private var m_overBars : Int32;
	private var m_barsSpawned : Bool;
	default m_barsSpawned = false;
	private var m_showOverchargeBox : Bool;
	private var m_isHoverdCyberwareEquipped : Bool;
	private var C_costLabelAnchorPoint_ADD : Vector2;
	private var C_costLabelAnchorPoint_SUBTRACT : Vector2;
	private var C_costLabelAnchorPoint_EQUIPPED : Vector2;
	private var C_costLabelAnchorPoint_EQUIPPED_EDGRUNNER : Vector2;

	protected event OnInitialize()
	{
		var size : Vector2;
		C_costLabelAnchorPoint_EQUIPPED = Vector2( 4.30000019, -0.2 );
		C_costLabelAnchorPoint_EQUIPPED_EDGRUNNER = Vector2( 4.5, -0.2 );
		C_costLabelAnchorPoint_ADD = inkWidgetRef.GetAnchorPoint( m_costLabelContainer );
		C_costLabelAnchorPoint_SUBTRACT = Vector2( 0.0, -1.25 );
		m_capacityPulseAnimation = new PulseAnimation;
		m_costLabelPulseAnimation = new PulseAnimation;
		m_tooltipData = new RipperdocBarTooltipTooltipData;
		m_tooltipData.barType = BarType.CurrentCapacity;
		m_curCapacityLabel = ( ( RipperdocFillLabel )( inkWidgetRef.GetController( m_curCapacityLabelContainer ) ) );
		m_overchargeGlowAnimOptions.loopType = inkanimLoopType.Cycle;
		m_overchargeGlowAnimOptions.loopInfinite = true;
		m_overchargeGlowAnimOptions.dependsOnTimeDilation = false;
		m_barGaps.PushBack( 10 );
		m_barGaps.PushBack( 20 );
		m_barGaps.PushBack( 30 );
		m_barGaps.PushBack( 40 );
		inkWidgetRef.SetVisible( m_maxCapacityLabelContainer, false );
		inkWidgetRef.SetVisible( m_overchargeBox, false );
		inkWidgetRef.SetVisible( m_thresholdLine, false );
		inkWidgetRef.SetVisible( m_costLabelContainer, false );
		inkWidgetRef.SetVisible( m_curCapacityLabelContainer, false );
		SetupBarIntroAnimation();
		SetupPulseAnimParams( m_pulseAnimtopOpacity, m_pulseAnimbottomOpacity, m_pulseAnimpulseRate, m_pulseAnimdelay );
		inkWidgetRef.RegisterToCallback( m_hoverArea, 'OnEnter', this, 'OnBarHoverOver' );
		inkWidgetRef.RegisterToCallback( m_hoverArea, 'OnLeave', this, 'OnBarHoverOut' );
		inkWidgetRef.RegisterToCallback( m_overchargeBox, 'OnEnter', this, 'OnOverchargeHoverOver' );
		inkWidgetRef.RegisterToCallback( m_overchargeBox, 'OnLeave', this, 'OnOverchargeHoverOut' );
		size = GetRootWidget().GetSize();
		m_curCapacityLabel.Configure( size.Y );
		inkWidgetRef.SetState( m_costLabelContainer, 'Default' );
	}

	protected event OnUninitialize()
	{
		inkWidgetRef.UnregisterFromCallback( m_hoverArea, 'OnEnter', this, 'OnBarHoverOver' );
		inkWidgetRef.UnregisterFromCallback( m_hoverArea, 'OnLeave', this, 'OnBarHoverOut' );
		inkWidgetRef.UnregisterFromCallback( m_overchargeBox, 'OnEnter', this, 'OnOverchargeHoverOver' );
		inkWidgetRef.UnregisterFromCallback( m_overchargeBox, 'OnLeave', this, 'OnOverchargeHoverOut' );
	}

	protected event OnOverchargeHoverOver( evt : inkPointerEvent )
	{
		m_tooltipData.barType = BarType.Edgerunner;
		m_overchargeBoxState = inkWidgetRef.GetState( m_overchargeBox );
		inkWidgetRef.SetState( m_overchargeBox, 'Hover' );
		OnBarHoverOver( evt );
	}

	protected event OnOverchargeHoverOut( evt : inkPointerEvent )
	{
		m_tooltipData.barType = BarType.CurrentCapacity;
		inkWidgetRef.SetState( m_overchargeBox, m_overchargeBoxState );
		OnBarHoverOut( evt );
	}

	private function SpawnBars()
	{
		var i : Int32;
		for( i = 0; i < BAR_COUNT; i += 1 )
		{
			AsyncSpawnFromLocal( inkWidgetRef.Get( m_barAnchor ), m_barWidgetLibraryName, this, 'OnBarSpawned', NULL );
		}
	}

	protected event OnBarSpawned( widget : inkWidget, data : IScriptable )
	{
		var controller : RipperdocNewMeterBar;
		var g : Int32;
		controller = ( ( RipperdocNewMeterBar )( widget.GetController() ) );
		m_bars.PushBack( controller );
		for( g = 0; g < m_barGaps.Size(); g += 1 )
		{
			if( m_bars.Size() == m_barGaps[ g ] )
			{
				controller.GetRootWidget().UpdateMargin( 0.0, m_barGapSize, 0.0, 0.0 );
			}
		}
		m_barIntroAnimProxy = widget.PlayAnimation( m_barIntroAnimDef );
		if( m_bars.Size() == BAR_COUNT )
		{
			m_barIntroAnimProxy.RegisterToCallback( inkanimEventType.OnFinish, this, 'OnLastBarIntroFinished' );
		}
	}

	protected event OnLastBarIntroFinished( animProxy : inkAnimProxy )
	{
		inkWidgetRef.SetVisible( m_maxCapacityLabelContainer, true );
		inkWidgetRef.SetVisible( m_overchargeBox, true );
		if( m_isEdgerunner )
		{
			SetMaxZone( m_thresholdLine, m_maxCapacityLabelContainer );
			inkWidgetRef.SetState( m_overchargeGlow, 'Available' );
			inkWidgetRef.SetVisible( m_overchargeGlow, true );
		}
		else
		{
			SetMaxZone( m_maxCapacityLabelContainer, m_thresholdLine );
			inkWidgetRef.SetState( m_overchargeGlow, 'Default' );
			inkWidgetRef.SetVisible( m_overchargeGlow, false );
		}
		m_barsSpawned = true;
		ConfigureBar( m_currentCapacity, 0, m_maxCapacity, m_overchargeMaxCapacity, true );
		inkWidgetRef.SetVisible( m_curCapacityLabelContainer, true );
		m_barIntroAnimProxy.UnregisterFromCallback( inkanimEventType.OnFinish, this, 'OnLastBarIntroFinished' );
	}

	private function ConfigureBar( curEquippedCapacity, newEquippedCapacity, maxCapacity, overclockCapacity : Int32, isChange : Bool )
	{
		var i : Int32;
		var state : CName;
		var isSafe : Bool;
		var delay : Float;
		var sizeOffset : Float;
		var percent : Float;
		var newPercent : Float;
		var currentBars : Int32;
		var equipBars : Int32;
		var newBars : Int32;
		var baseBars : Int32;
		percent = ( ( Float )( curEquippedCapacity ) ) / m_maxCapacityPossible;
		newPercent = ( ( Float )( ( newEquippedCapacity + curEquippedCapacity ) ) ) / m_maxCapacityPossible;
		equipBars = Min( RoundMath( ( ( Float )( BAR_COUNT ) ) * newPercent ), BAR_COUNT );
		currentBars = Min( RoundMath( ( ( Float )( BAR_COUNT ) ) * percent ), BAR_COUNT );
		newBars = equipBars - currentBars;
		baseBars = currentBars - BAR_SLOPE_COUNT;
		inkWidgetRef.SetOpacity( m_maxCapacityLabelContainer, 1.0 );
		if( newEquippedCapacity > 0 )
		{
			inkWidgetRef.SetAnchorPoint( m_costLabelContainer, C_costLabelAnchorPoint_ADD );
			inkWidgetRef.SetVisible( m_costLabelContainer, true );
			inkTextRef.SetText( m_costLabelText, "+" + IntToString( Abs( newEquippedCapacity ) ) );
			StartPulse( m_costLabelPulseAnimation, m_pulseAnimationParams, inkWidgetRef.Get( m_costLabelContainer ) );
			StopPulse( m_capacityPulseAnimation );
		}
		else if( m_isHoverdCyberwareEquipped && ( newEquippedCapacity != 0 ) )
		{
			inkWidgetRef.SetAnchorPoint( m_costLabelContainer, ( ( currentBars > m_maxBaseBar ) ? ( C_costLabelAnchorPoint_EQUIPPED_EDGRUNNER ) : ( C_costLabelAnchorPoint_EQUIPPED ) ) );
			inkWidgetRef.SetVisible( m_costLabelContainer, true );
			m_curCapacityLabel.AnimateLabel( curEquippedCapacity, 0.2 );
			inkTextRef.SetText( m_costLabelText, IntToString( Abs( newEquippedCapacity ) ) );
			inkWidgetRef.SetOpacity( m_maxCapacityLabelContainer, 0.2 );
			StartPulse( m_costLabelPulseAnimation, m_pulseAnimationParams, inkWidgetRef.Get( m_costLabelContainer ) );
			StopPulse( m_capacityPulseAnimation );
		}
		else if( newEquippedCapacity < 0 )
		{
			inkWidgetRef.SetAnchorPoint( m_costLabelContainer, C_costLabelAnchorPoint_SUBTRACT );
			inkWidgetRef.SetVisible( m_costLabelContainer, true );
			inkTextRef.SetText( m_costLabelText, "-" + IntToString( Abs( newEquippedCapacity ) ) );
			StartPulse( m_costLabelPulseAnimation, m_pulseAnimationParams, inkWidgetRef.Get( m_costLabelContainer ) );
			StopPulse( m_capacityPulseAnimation );
		}
		else
		{
			inkWidgetRef.SetVisible( m_costLabelContainer, false );
			m_curCapacityLabel.AnimateLabel( curEquippedCapacity, 0.2 );
			StopPulse( m_costLabelPulseAnimation );
		}
		inkTextRef.SetText( m_maxCapacityLabelText, IntToString( overclockCapacity ) );
		delay = BAR_DELAY_OFFSET * ( ( Float )( ( equipBars - 1 ) ) );
		if( inkWidgetRef.IsVisible( m_overchargeGlow ) )
		{
			if( m_isHoverdCyberwareEquipped )
			{
				m_overchargeGlowAnimProxy.GotoStartAndStop();
			}
			else if( equipBars <= m_maxBaseBar )
			{
				m_overchargeGlowAnimProxy.GotoStartAndStop();
				inkWidgetRef.SetState( m_overchargeGlow, 'Available' );
				inkWidgetRef.SetVisible( m_thresholdLine, ( ( newBars >= 0 ) && ( currentBars != m_maxBaseBar ) ) && m_showOverchargeBox );
			}
			else
			{
				inkWidgetRef.SetState( m_overchargeGlow, 'Used' );
				if( !( m_overchargeGlowAnimProxy.IsPlaying() ) )
				{
					m_overchargeGlowAnimProxy = PlayLibraryAnimation( m_overchargeGlowAnimName, m_overchargeGlowAnimOptions );
				}
				inkWidgetRef.SetVisible( m_thresholdLine, false );
			}
		}
		else
		{
			inkWidgetRef.SetVisible( m_thresholdLine, m_showOverchargeBox );
		}
		for( i = 0; i < BAR_COUNT; i += 1 )
		{
			if( ( ( i == 0 ) && ( equipBars == 0 ) ) && ( newBars == 0 ) )
			{
				state = 'Safe_Default';
			}
			else
			{
				isSafe = ( i < m_maxBaseBar ) || ( i >= ( m_maxBaseBar + m_overBars ) );
				state = GetState( isSafe, m_isEdgerunner, i, currentBars, newBars );
			}
			if( ( ( state == 'Safe_Add' || state == 'Safe_Remove' ) || state == 'Unsafe_Add' ) || state == 'Unsafe_Remove' )
			{
				m_bars[ i ].StartPulse( m_pulseAnimationParams );
			}
			else
			{
				m_bars[ i ].StopPulse();
			}
			m_bars[ i ].SetState( state );
			sizeOffset = 0.0;
			if( ( ( ( newBars > 0 ) && ( i >= currentBars ) ) && ( i < equipBars ) ) || ( ( ( newBars >= 0 ) && ( equipBars == 0 ) ) && ( i == 0 ) ) )
			{
				sizeOffset = GetSlopeAnimOffset( BAR_SLOPE_COUNT, 1 );
			}
			else if( ( i > baseBars ) && ( i < currentBars ) )
			{
				sizeOffset = GetSlopeAnimOffset( i, baseBars );
			}
			if( sizeOffset > 0.0 )
			{
				m_bars[ i ].SetSizeAnimation( 1.5, sizeOffset, delay, BAR_ANIM_DURATION );
			}
			else if( i < currentBars )
			{
				m_bars[ i ].SetSizeAnimation( m_defaultRightBarScale, 0.0, delay, BAR_ANIM_DURATION );
			}
			else
			{
				m_bars[ i ].SetSizeAnimation( m_defaultRightBarScale, 0.0, 0.0, BAR_ANIM_DURATION );
			}
			if( ( i + 1 ) < ( currentBars + Abs( newBars ) ) )
			{
				delay -= BAR_DELAY_OFFSET;
			}
			else if( ( i + 1 ) > ( currentBars + Abs( newBars ) ) )
			{
				delay += BAR_DELAY_OFFSET;
			}
			if( ( i == ( currentBars - 1 ) ) || ( ( currentBars == 0 ) && ( i == 0 ) ) )
			{
				MoveLabelToBar( m_curCapacityLabelContainer, m_bars[ i ], m_capacityLabelAnimation, true, false );
				if( ( ( state == 'Safe_Default' || state == 'Unsafe_Default' ) || state == 'Safe_Remove' ) || state == 'Unsafe_Remove' )
				{
					inkWidgetRef.SetState( m_curCapacityLabelContainer, state );
				}
			}
			if( i == currentBars )
			{
				if( ( curEquippedCapacity + newEquippedCapacity ) > overclockCapacity )
				{
					inkWidgetRef.SetState( m_costLabelContainer, 'Unsafe_Add' );
				}
				else if( newEquippedCapacity > 0 )
				{
					inkWidgetRef.SetState( m_costLabelContainer, 'Safe_Add' );
				}
				else if( m_isHoverdCyberwareEquipped )
				{
					inkWidgetRef.SetState( m_costLabelContainer, 'Hovering_Equipped_Cyberware' );
				}
				else
				{
					inkWidgetRef.SetState( m_costLabelContainer, 'Default' );
				}
				if( i == 0 )
				{
					MoveLabelToBar( m_costLabelContainer, m_bars[ i + 1 ], m_costLabelAnimation, false, false );
				}
				else
				{
					MoveLabelToBar( m_costLabelContainer, m_bars[ i ], m_costLabelAnimation, false, false );
				}
			}
		}
	}

	private function GetState( isSafe, isEdgerunner : Bool, cur, start, dif : Int32 ) : CName
	{
		var result : CName;
		var state : CName;
		if( ( !( isSafe ) && !( isEdgerunner ) ) && m_showOverchargeBox )
		{
			state = 'Unsafe_Locked';
			return state;
		}
		if( isSafe || !( m_showOverchargeBox ) )
		{
			state = 'Default';
		}
		else
		{
			state = 'Unsafe_Unlocekd';
		}
		result = ( ( isSafe ) ? ( 'Safe_' ) : ( 'Unsafe_' ) );
		if( dif >= 0 )
		{
			if( cur < start )
			{
				state = result + 'Default';
			}
			else if( ( cur >= start ) && ( cur < ( start + dif ) ) )
			{
				state = result + 'Add';
			}
		}
		else if( dif < 0 )
		{
			if( cur < ( start + dif ) )
			{
				state = result + 'Default';
			}
			else if( ( cur >= ( start + dif ) ) && ( cur < start ) )
			{
				state = result + 'Remove';
			}
		}
		return state;
	}

	private function SetCapacity( cur, max, over : Int32, maxPossible : Float )
	{
		m_currentCapacity = cur;
		m_maxCapacity = max;
		m_overchargeMaxCapacity = max + over;
		if( max > RoundMath( maxPossible ) )
		{
			m_maxCapacityPossible = ( ( Float )( max + m_overchargeValue ) );
		}
		else
		{
			m_maxCapacityPossible = MaxF( maxPossible, ( ( Float )( m_overchargeMaxCapacity ) ) );
		}
		m_maxBaseBar = RoundMath( ( ( Float )( BAR_COUNT ) ) * ( ( ( Float )( m_maxCapacity ) ) / m_maxCapacityPossible ) );
		m_overBars = RoundMath( ( ( Float )( BAR_COUNT ) ) * ( ( ( Float )( m_overchargeValue ) ) / m_maxCapacityPossible ) );
		m_showOverchargeBox = ( ( Float )( m_maxCapacity ) ) >= ( m_maxCapacityPossible * m_overchargeVisibilityThreshold );
	}

	private function SetMaxZone( downLine : inkWidgetRef, upperLine : inkWidgetRef )
	{
		var g : Int32;
		var upperOffset : Float;
		var downOffset : Float;
		var downBarIndex : Int32;
		var upperBarIndex : Int32;
		var oldUpperMargin : inkMargin;
		var oldDownMargin : inkMargin;
		var boxMargin : inkMargin;
		var verticalDelta : Float;
		upperBarIndex = Min( m_maxBaseBar + m_overBars, BAR_COUNT );
		downBarIndex = Min( m_maxBaseBar, BAR_COUNT - 1 );
		upperOffset = ( ( Float )( ( BAR_COUNT - upperBarIndex ) ) ) * ( m_barsHeigh + m_barsMargin );
		downOffset = ( ( Float )( ( BAR_COUNT - downBarIndex ) ) ) * ( m_barsHeigh + m_barsMargin );
		upperOffset -= m_barsMargin;
		downOffset -= m_barsMargin;
		for( g = 0; g < m_barGaps.Size(); g += 1 )
		{
			if( m_barGaps[ g ] >= upperBarIndex )
			{
				upperOffset += m_barGapSize;
			}
			if( m_barGaps[ g ] >= downBarIndex )
			{
				downOffset += m_barGapSize;
			}
		}
		oldUpperMargin = inkWidgetRef.GetMargin( upperLine );
		oldDownMargin = inkWidgetRef.GetMargin( downLine );
		inkWidgetRef.SetMargin( upperLine, oldUpperMargin.left, upperOffset, oldUpperMargin.right, oldUpperMargin.bottom );
		inkWidgetRef.SetMargin( downLine, oldDownMargin.left, downOffset, oldDownMargin.right, oldDownMargin.bottom );
		verticalDelta = downOffset - upperOffset;
		boxMargin = inkWidgetRef.GetMargin( m_overchargeBox );
		inkWidgetRef.SetMargin( m_overchargeBox, boxMargin.left, upperOffset, boxMargin.right, boxMargin.bottom );
		inkWidgetRef.SetHeight( m_overchargeBox, verticalDelta );
		if( !( m_showOverchargeBox ) && !( m_isEdgerunner ) )
		{
			inkWidgetRef.SetVisible( m_thresholdLine, false );
			inkWidgetRef.SetVisible( m_overchargeBox, false );
			inkWidgetRef.SetVisible( m_overchargeGlow, false );
		}
	}

	protected event OnIntroAnimationFinished_METER( proxy : inkAnimProxy )
	{
		proxy.UnregisterFromCallback( inkanimEventType.OnStart, this, 'OnIntroAnimationFinished_METER' );
		proxy = PlayLibraryAnimation( 'meter_intro_LEFT' );
		proxy.RegisterToCallback( inkanimEventType.OnFinish, this, 'OnMeterIntroFinished_LEFT' );
	}

	protected event OnMeterIntroFinished_LEFT( proxy : inkAnimProxy )
	{
		QueueEvent( new CapacityBarFinalizedEvent );
		proxy.UnregisterFromCallback( inkanimEventType.OnFinish, this, 'OnMeterIntroFinished_LEFT' );
	}

	protected event OnApply( evt : RipperdocMeterCapacityApplyEvent )
	{
		SetCapacity( evt.CurrentCapacity, evt.MaxCapacity, evt.OverchargeCapacity, evt.MaxCapacityPossible );
		if( !( m_barsSpawned ) )
		{
			SpawnBars();
		}
		else
		{
			ConfigureBar( m_currentCapacity, 0, m_maxCapacity, m_overchargeMaxCapacity, evt.IsPurchase );
		}
		if( m_isEdgerunner )
		{
			SetMaxZone( m_thresholdLine, m_maxCapacityLabelContainer );
		}
		else
		{
			SetMaxZone( m_maxCapacityLabelContainer, m_thresholdLine );
		}
		m_tooltipData.totalValue = evt.CurrentCapacity;
		m_tooltipData.maxValue = evt.MaxCapacity;
	}

	protected event OnEdgrunnerPerkEvent( evt : EdgrunnerPerkEvent )
	{
		inkWidgetRef.SetVisible( m_edgrunnerLock, !( evt.isPurchased ) );
		m_isEdgerunner = evt.isPurchased;
	}

	protected event OnHover( evt : RipperdocMeterCapacityHoverEvent )
	{
		if( evt.IsHover )
		{
			m_isHoverdCyberwareEquipped = evt.isCyberwareEquipped;
			ConfigureBar( m_currentCapacity, evt.CapacityChange, m_maxCapacity, m_overchargeMaxCapacity, true );
		}
		else
		{
			m_isHoverdCyberwareEquipped = false;
			ConfigureBar( m_currentCapacity, 0, m_maxCapacity, m_overchargeMaxCapacity, true );
		}
	}

	protected event OnRipperdocMeterCapacityBarHoverEvent( evt : RipperdocMeterCapacityBarHoverEvent )
	{
		OnBarHoverOver( new inkPointerEvent );
	}

}

class EdgrunnerPerkEvent extends Event
{
	var isPurchased : Bool;
}

class BarHoverOutEvent extends Event
{
}

class RipperdocMeterCapacityHoverEvent extends Event
{
	var IsHover : Bool;
	var CapacityChange : Int32;
	var isCyberwareEquipped : Bool;
}

class RipperdocMeterCapacityBarHoverEvent extends Event
{
}

class RipperdocMeterCapacityApplyEvent extends Event
{
	var CurrentCapacity : Int32;
	var MaxCapacity : Int32;
	var OverchargeCapacity : Int32;
	var MaxCapacityPossible : Float;
	var IsPurchase : Bool;
}

