library.ostw

import "Pathmaps\Hanamura.pathmap" as Hanamura;

# Total value of an array
method SumOfArray(define arrayToSum)
{
	define total = 0;
	foreach (define value in arrayToSum)
	{
		total += arrayToSum[value];
	}
	return total;
}

# Average value of an array
method AverageOfArray(define arrayToAverage)
{
	return SumOfArray(arrayToAverage) / CountOf(arrayToAverage);
}

# Imperfect way of getting position of nearest solid surface. Accuracy is amount of times looped.
method NearestSolidSurface(define point, define accuracy)
{
	define directions = [Up(), Down(), Forward(), Right(), Backward(), Left()];
	for (define i = 0; i < accuracy; i++)
	{
		directions = SortedArray(directions, DistanceBetween(point, RayCastHitPosition(point, point + (ArrayElement() * 10000))));
		directions = [directions, Midpoint(directions[0], directions[1])];
	}
	directions = SortedArray(directions, DistanceBetween(point, RayCastHitPosition(point, point + (ArrayElement() * 10000))));
	return RayCastHitPosition(point, point + (directions[0] * 10000));
}

# Gets height of hero measured from eyes to feet
method TallnessOfHero(define hero)
{
	return
		(hero == Hero.Dva) ? 1.74
		: ((hero == Hero.Orisa) ? 1.78
		: ((hero == Hero.Reinhardt) ? 1.8
		: ((hero == Hero.Roadhog || hero == Hero.Zarya) ? 1.6
		: ((hero == Hero.Winston || hero == Hero.Doomfist || hero == Hero.Widowmaker) ? 1.5
		: ((hero == Hero.WreckingBall) ? 1.83
		: ((hero == Hero.Ashe || hero == Hero.Mercy) ? 1.45
		: ((hero == Hero.Bastion) ? 1.82
		: ((hero == Hero.Genji) ? 1.2
		: ((hero == Hero.Hanzo || hero == Hero.Pharah || hero == Hero.Baptiste) ? 1.35
		: ((hero == Hero.Junkrat || hero == Hero.Tracer || hero == Hero.Ana) ? 1.25
		: ((hero == Hero.Mccree) ? 1.43
		: ((hero == Hero.Mei || hero == Hero.Sombra || hero == Hero.Symmetra) ? 1.3
		: ((hero == Hero.Reaper || hero == Hero.Soldier76 || hero == Hero.Zenyatta) ? 1.55
		: ((hero == Hero.Torbjorn) ? 1
		: ((hero == Hero.Brigitte) ? 1.58
		: ((hero == Hero.Lucio) ? 1.17
		: ((hero == Hero.Moira) ? 1.7 : Null()
		)))))))))))))))))
	;
}

# Generates an array of a length where each value is equal to its index. Great for using for Filtered and Sorted arrays.
method GenerateForeachArray(define length)
{
	define returnArray;
	for (define i = 0; i < length; i++)
		returnArray[i] = i;
	return returnArray;
}

class Dictionary 
{
	define Keys;
	define Values;

	public Dictionary(define keys, define values)
	{
		Keys = keys;
		Values = values;
	}
	
	# Gets the value corresponding to a key
	public method GetValueFromKey(define key)
	{
		return Values[IndexOfArrayValue(Keys, key)];
	}

	# Gets the key corresponding to a value
	public method GetKeyFromValue(define value)
	{
		return Keys[IndexOfArrayValue(Values, value)];
	}

	# Sets the value corresponding to a key
	public method SetValueAtKey(define key, define value)
	{
		Values[IndexOfArrayValue(Keys, key)] = value;
	}

	# Sets the key corresponding to a value
	public method SetKeyAtValue(define value, define key)
	{
		Keys[IndexOfArrayValue(Values, value)] = key;
	}

	# Removes all entries of players that have left the game
	public method RemoveLeftPlayers()
	{
		for (define i = 0; 0 < CountOf(Keys); i++)
		{
			if (EntityExists(Keys[i]) == false)
			{
				RemoveFromArrayAtIndex(Keys, i);
				RemoveFromArrayAtIndex(Values, i);
				i--;
			}
		}
	}

	# Adds a new entry
	public method AddEntry(define key, define value)
	{
		Keys = [Keys, key];
		Values = [Values, value];
	}

	# Removes all entries with either an empty key or empty value
	public method RemoveEmptyEntries()
	{
		for (define i = 0; i < CountOf(Keys); i++)
		{
			if (Keys[i] == Null() || Values[i] == Null())
			{
				RemoveFromArrayAtIndex(Keys, i);
				RemoveFromArrayAtIndex(Values, i);
				i--;
			}
		}
	}

	# Finds an entry by its key and removes it
	public method RemoveEntryByKey(define key)
	{
		Values = RemoveFromArray(Values, this.GetValueFromKey(key));
		Keys = RemoveFromArray(Keys, key);
	}

	# Finds an entry by its value and removes it
	public method RemoveEntryByValue(define value)
	{
		Keys = RemoveFromArray(Keys, this.GetKeyFromValue(value));
		Values = RemoveFromArray(Values, value);
	}

	# Converts the Dictionary object to a tuple-like array where each entry is an array structured like so: [key, value]
	public method GetTupleArray()
	{
		define array;
		for (define i = 0; i < CountOf(Keys); i++)
			array[i] = [Keys[i], Values[i]];
		return array;
	}
}

class Trigger
{
	define IsActive;

	public Trigger() 
	{
		IsActive = False();
	}

	# Activates the trigger
	public method Activate()
	{
		IsActive = True();
	}

	# Deactivates the trigger
	public method Deactivate()
	{
		IsActive = False();
	}

	# Activates the trigger for X seconds
	public method ActivateFor(define seconds)
	{
		IsActive = True();
		Wait(seconds);
		IsActive = False();
	}

	# Deactivates the trigger for X seconds
	public method DeactivateFor(define seconds)
	{
		IsActive = False();
		Wait(seconds);
		IsActive = True();
	}
}

class SphericalBarrier
{
	define Position;
	define Radius;

	public SphericalBarrier(define position, define radius)
	{
		Position = position;
		Radius = radius;
	}

	# Whether the player is inside the the barrier
	public macro IsPlayerInside(define player):
		DistanceBetween(PositionOf(player), Position) <= Radius;

	# Whether the player is outside the barrier
	public macro IsPlayerOutside(define player):
		DistanceBetween(PositionOf(player), Position) > Radius;

	# Teleport the player inside the barrier
	public method TeleportPlayerInside(define player)
	{
		Teleport(player, Destination(PositionOf(player), DirectionTowards(PositionOf(player), Position), DistanceBetween(PositionOf(player), Position) - Radius));
	}

	# Teleports the player outside the barrier
	public method TeleportPlayerOutside(define player)
	{
		Teleport(player, Destination(PositionOf(player), DirectionTowards(Position, PositionOf(player)), Radius - DistanceBetween(PositionOf(player), Position)));
	}

	# Boops the player into the barrier
	public method BoopPlayerInside(define player, define speed)
	{
		while (IsPlayerOutside(player))
			ApplyImpulse(player, DirectionTowards(PositionOf(player), Position), speed, Relative.ToWorld, ContraryMotion.Cancel);
	}

	# Boops the player outside the barrier
	public method BoopPlayerOutside(define player, define speed)
	{
		while (IsPlayerInside(player))
			ApplyImpulse(player, DirectionTowards(Position, PositionOf(player)), speed, Relative.ToWorld, ContraryMotion.Cancel);
	}

	# An array of the players outside the barrier
	public macro PlayersOutside():
		FilteredArray(AllPlayers(), IsPlayerOutside(ArrayElement()));
	
	# An array of the players inside the barrier
	public macro PlayersInside():
		FilteredArray(AllPlayers(), IsPlayerInside(ArrayElement()));
}

class CylindricalBarrier
{
	define Position;
	define Radius;

	public CylindricalBarrier(define position, define radius)
	{
		Position = position;
		Radius = radius;
	}

	# Whether the player is inside the the barrier
	public macro IsPlayerInside(define player):
		HorizontalDistance(PositionOf(player), Position) <= Radius;

	# Whether the player is inside the the barrier. This method can not be used in conditions
	public method OptimisedIsPlayerInside(define player)
	{
		define pos = PositionOf(player);
		return HorizontalDistance(pos, Position) <= Radius;
	}

	# Whether the player is outside the barrier
	public macro IsPlayerOutside(define player):
		HorizontalDistance(PositionOf(player), Position) > Radius;

	# Whether the player is Outside the the barrier. This method can not be used in conditions
	public method OptimisedIsPlayerOutside(define player)
	{
		define pos = PositionOf(player);
		return HorizontalDistance(pos, Position) > Radius;
	}

	# Teleports the player inside the barrier
	public method TeleportPlayerInside(define player)
	{
		Teleport(player, Destination(PositionOf(player), DirectionTowards(PositionOf(player), Vector(XOf(Position), YOf(PositionOf(player)), ZOf(Position))), HorizontalDistance(PositionOf(player), Position) - Radius));
	}

	# Teleports the player outside the barrier
	public method TeleportPlayerOutside(define player)
	{
		Teleport(player, Destination(PositionOf(player), DirectionTowards(Vector(XOf(Position), YOf(PositionOf(player)), ZOf(Position)), PositionOf(player)), Radius - HorizontalDistance(PositionOf(player), Position)));
	}

	# Boops the player inside the barrier
	public method BoopPlayerInside(define player, define speed)
	{
		while (IsPlayerOutside(player))
			ApplyImpulse(player, DirectionTowards(PositionOf(player), Vector(XOf(Position), YOf(PositionOf(player)), ZOf(Position))), speed, Relative.ToWorld, ContraryMotion.Cancel);
	}

	# Boops the player outside the barrier
	public method BoopPlayerOutside(define player, define speed)
	{
		while (IsPlayerInside(player))
			ApplyImpulse(player, DirectionTowards(Vector(XOf(Position), YOf(PositionOf(player)), ZOf(Position)), PositionOf(player)), speed, Relative.ToWorld, ContraryMotion.Cancel);
	}

	# An array of players inside the barrier
	public macro PlayersInside():
		FilteredArray(AllPlayers(), IsPlayerInside(ArrayElement()));

	# An array of players outside the barrier
	public macro PlayersOutside():
		FilteredArray(AllPlayers(), IsPlayerOutside(ArrayElement()));
}

class CuboidBarrier
{
	define Min;
	define Max;

	public CuboidBarrier(define corner1, define corner2)
	{
		Min = Vector(
			Min(XOf(corner1), XOf(corner2)),
			Min(YOf(corner1), YOf(corner2)),
			Min(ZOf(corner1), ZOf(corner2))
		);
		Max = Vector(
			Max(XOf(corner1), XOf(corner2)),
			Max(YOf(corner1), YOf(corner2)),
			Max(ZOf(corner1), ZOf(corner2))
		);
	}

	# Visualises the barrier. Returns an effect array of the beams that can be destroyed with DestroyEffectArray. Has a delay of 0.016 seconds.
	public method Visualise(define visibleTo)
	{
		define effects = [];

		Beam(Min, Vector(XOf(Max), YOf(Min), ZOf(Min)), visibleTo);
		effects = [effects, LastCreatedEntity()];
		Beam(Min, Vector(XOf(Min), YOf(Max), ZOf(Min)), visibleTo);
		effects = [effects, LastCreatedEntity()];
		Beam(Min, Vector(XOf(Min), YOf(Min), ZOf(Max)), visibleTo);
		effects = [effects, LastCreatedEntity()];
		Beam(Max, Vector(XOf(Min), YOf(Max), ZOf(Max)), visibleTo);
		effects = [effects, LastCreatedEntity()];
		Beam(Max, Vector(XOf(Max), YOf(Min), ZOf(Max)), visibleTo);
		effects = [effects, LastCreatedEntity()];
		Beam(Max, Vector(XOf(Max), YOf(Max), ZOf(Min)), visibleTo);
		effects = [effects, LastCreatedEntity()];
		Beam(Vector(XOf(Min), YOf(Max), ZOf(Min)), Vector(XOf(Max), YOf(Max), ZOf(Min)), visibleTo);
		effects = [effects, LastCreatedEntity()];
		Beam(Vector(XOf(Min), YOf(Max), ZOf(Min)), Vector(XOf(Min), YOf(Max), ZOf(Max)), visibleTo);
		effects = [effects, LastCreatedEntity()];
		Beam(Vector(XOf(Min), YOf(Max), ZOf(Max)), Vector(XOf(Min), YOf(Min), ZOf(Max)), visibleTo);
		effects = [effects, LastCreatedEntity()];
		Beam(Vector(XOf(Max), YOf(Max), ZOf(Min)), Vector(XOf(Max), YOf(Min), ZOf(Min)), visibleTo);
		effects = [effects, LastCreatedEntity()];
		Beam(Vector(XOf(Min), YOf(Min), ZOf(Max)), Vector(XOf(Max), YOf(Min), ZOf(Max)), visibleTo);
		effects = [effects, LastCreatedEntity()];
		Beam(Vector(XOf(Max), YOf(Min), ZOf(Min)), Vector(XOf(Max), YOf(Min), ZOf(Max)), visibleTo);
		effects = [effects, LastCreatedEntity()];

		MinWait();
		return effects;
	}

	private macro Beam(define start, define end, define visible):
		CreateBeamEffect(visible, BeamType.GrappleBeam, start, end, Color.White, EffectRev.PositionAndRadius);

	# Whether the player is inside the the barrier
	public macro IsPlayerInside(define player):
		XOf(Min) > XOf(PositionOf(player)) &&
		YOf(Min) > YOf(PositionOf(player)) &&
		ZOf(Min) > ZOf(PositionOf(player)) &&
		XOf(Max) < XOf(PositionOf(player)) &&
		YOf(Max) < YOf(PositionOf(player)) &&
		ZOf(Max) < ZOf(PositionOf(player))
	;

	# Whether the player is inside the barrier. This method can not be used in a condition
	public method OptimisedIsPlayerInside(define player)
	{
		define pos = PositionOf(player);
		return
			XOf(Min) > XOf(pos) &&
			YOf(Min) > YOf(pos) &&
			ZOf(Min) > ZOf(pos) &&
			XOf(Max) < XOf(pos) &&
			YOf(Max) < YOf(pos) &&
			ZOf(Max) < ZOf(pos)
		;
	}

	# Whether the player is outside the barrier
	public macro IsPlayerOutside(define player):
		XOf(Min) < XOf(PositionOf(player)) &&
		YOf(Min) < YOf(PositionOf(player)) &&
		ZOf(Min) < ZOf(PositionOf(player)) &&
		XOf(Max) > XOf(PositionOf(player)) &&
		YOf(Max) > YOf(PositionOf(player)) &&
		ZOf(Max) > ZOf(PositionOf(player))
	;

	# Whether the player is outside the barrier. This method can not be used in a condition
	public method OptimisedIsPlayerOutside(define player)
	{
		define pos = PositionOf(player);
		return
			XOf(Min) < XOf(pos) &&
			YOf(Min) < YOf(pos) &&
			ZOf(Min) < ZOf(pos) &&
			XOf(Max) > XOf(pos) &&
			YOf(Max) > YOf(pos) &&
			ZOf(Max) > ZOf(pos)
		;
	}

	# Teleports the player inside the barrier
	public method TeleportPlayerInside(define player)
	{
		Teleport(player, Vector(
			Max(XOf(Min), Min(XOf(Max), XOf(PositionOf(player)))),
			Max(YOf(Min), Min(YOf(Max), YOf(PositionOf(player)))),
			Max(ZOf(Min), Min(ZOf(Max), ZOf(PositionOf(player))))
		));
	}

	# Teleports the player outside the barrier
	public method TeleportPlayerOutside(define player)
	{
		Teleport(player, Vector(
			Min(XOf(Min), Max(XOf(Max), XOf(PositionOf(player)))),
			Min(YOf(Min), Max(YOf(Max), YOf(PositionOf(player)))),
			Min(ZOf(Min), Max(ZOf(Max), ZOf(PositionOf(player))))
		));
	}

	# Boops the player inside the barrier
	public method BoopPlayerInside(define player, define speed)
	{
		while (IsPlayerOutside(player))
			ApplyImpulse(player, DirectionTowards(PositionOf(player), Vector(
				Max(XOf(Min), Min(XOf(Max), XOf(PositionOf(player)))),
				Max(YOf(Min), Min(YOf(Max), YOf(PositionOf(player)))),
				Max(ZOf(Min), Min(ZOf(Max), ZOf(PositionOf(player))))
			)), speed, Relative.ToWorld, ContraryMotion.Cancel);
	}

	# Boops the player outside the barrier
	public method BoopPlayerOutside(define player, define speed)
	{
		while (IsPlayerInside(player))
			ApplyImpulse(player, DirectionTowards(Vector(
				Min(XOf(Min), Max(XOf(Max), XOf(PositionOf(player)))),
				Min(YOf(Min), Max(YOf(Max), YOf(PositionOf(player)))),
				Min(ZOf(Min), Max(ZOf(Max), ZOf(PositionOf(player))))
			), PositionOf(player)), speed, Relative.ToWorld, ContraryMotion.Cancel);
	}

	# An array of players inside the barrier
	public macro PlayersInside():
		FilteredArray(AllPlayers(),
			IsPlayerInside(ArrayElement())
		);

	# An array of players outside the barrier
	public macro PlayersOutside():
		FilteredArray(AllPlayers(),
			IsPlayerOutside(ArrayElement())
		);
}