Compare text

Find the difference between two text files

Real-time diff

Unified diff

Collapse lines

Highlight change

Syntax highlighting

Tools

Island Party 2.0.0-21

Created 4 years agoDiff never expires

settings

{

main

{

Description: "Island Party - Heroes Minigames v1.1.1-19 Play rounds of 19 classic and new games as minigames and score points. Widow HS only, McCree Hot Potato, Zen Sparta, Echo Rings... Code: W468T Join my discord.gg/ZdukXgB to choose the next minigame or give feedback. ~Created by Jokaes#2263 My codes in: jokaes.github.io"

Description: "Island Party - Heroes Minigames v2.0.0-21 Play rounds of 21 classic and new games as minigames and score points. Widow HS only, McCree Hot Potato, Zen Sparta, Echo Rings... Code: W468T Join my discord.gg/ZdukXgB to choose the next minigame or give feedback. ~Created by Jokaes#2263 My codes in: jokaes.github.io"

}

lobby

{

Allow Players Who Are In Queue: Yes

Map Rotation: After A Game

Match Voice Chat: Enabled

Max Spectators: 6

Return To Lobby: Never

}

modes

{

Deathmatch

{

enabled maps

{

Workshop Island

Workshop Island Night

}

General

{

Allow Hero Switching: Off

Game Mode Start: Immediately

Hero Limit: Off

Kill Cam: Off

Kill Feed: Off

Respawn As Random Hero: On

Score To Win: 50

Score To Win: 30

Self Initiated Respawn: Off

Skins: Off

}

heroes

{

General

{

Ana

{

Biotic Grenade: Off

Damage Dealt: 500%

Damage Received: 500%

Health: 10%

No Ammunition Requirement: On

Quick Melee: Off

Sleep Dart Cooldown Time: 25%

Ultimate Ability Nano Boost: Off

}

Bastion

{

Infinite Ultimate Duration: On

No Ammunition Requirement: On

Quick Melee: Off

Reconfigure: Off

Self-Repair: Off

Spawn With Ultimate Ready: On

Ultimate Duration: 500%

Ultimate Generation - Combat Configuration: Tank: 500%

Ultimate Generation - Passive Configuration: Tank: 500%

Ultimate Generation Configuration: Tank: 500%

}

Brigitte

{

Barrier Shield Cooldown Time: 200%

Barrier Shield Recharge Rate: 150%

Damage Dealt: 500%

Jump Vertical Speed: 200%

Primary Fire: Off

Quick Melee: Off

Repair Pack: Off

Shield Bash Cooldown Time: 35%

Ultimate Generation - Combat Rally: 200%

Ultimate Generation - Passive Rally: 0%

Whip Shot Cooldown Time: 30%

Whip Shot Knockback Scalar: 200%

}

D.Va

{

Boosters Cooldown Time: 0%

Damage Dealt: 10%

Damage Received: 10%

Defense Matrix: Off

Micro Missiles: Off

Primary Fire: Off

Quick Melee: Off

Ultimate Ability Self-Destruct: Off

Ultimate Generation - Combat Self-Destruct: 0%

Ultimate Generation - Passive Self-Destruct: 0%

}

Doomfist

{

Damage Dealt: 10%

Damage Received: 10%

Health: 500%

Quick Melee: Off

Rocket Punch Cooldown Time: 50%

Rocket Punch Knockback Scalar: 250%

Seismic Slam: Off

Ultimate Generation - Combat Meteor Strike: 50%

Ultimate Generation - Passive Meteor Strike: 0%

}

Echo

{

Flight Cooldown Time: 50%

Focusing Beam Cooldown Time: 50%

Movement Speed: 200%

Primary Fire: Off

Sticky Bombs: Off

Ultimate Ability Duplicate: Off

}

Genji

{

Damage Dealt: 500%

Deflect: Off

Primary Fire: Off

Secondary Fire: Off

Swift Strike Cooldown Time: 30%

Ultimate Generation - Combat Dragonblade: 500%

Ultimate Generation - Passive Dragonblade: 0%

Ultimate Generation Dragonblade: 200%

}

Lúcio

{

Amp It Up: Off

Crossfade: Off

No Ammunition Requirement: On

Primary Fire: Off

Quick Melee: Off

Soundwave: Off

Ultimate Ability Sound Barrier: Off

}

McCree

{

Combat Roll Cooldown Time: 80%

Damage Dealt: 10%

Damage Received: 10%

Flashbang: Off

Jump Vertical Speed: 300%

No Ammunition Requirement: On

Secondary Fire: Off

Ultimate Ability Deadeye: Off

}

Mei

{

Damage Dealt: 500%

Damage Received: 500%

No Ammunition Requirement: On

Primary Fire: Off

Projectile Gravity: 500%

Projectile Speed: 38%

Ultimate Generation - Combat Blizzard: 125%

}

Mercy

{

Damage Dealt: 500%

Damage Received: 500%

Guardian Angel: Off

Movement Speed: 150%

Primary Fire: Off

Resurrect: Off

Secondary Fire: Off

Ultimate Generation - Combat Valkyrie: 500%

Ultimate Generation Valkyrie: 500%

}

Roadhog

{

Chain Hook Cooldown Time: 25%

Damage Dealt: 10%

Damage Received: 10%

Movement Speed: 150%

Primary Fire: Off

Quick Melee: Off

Secondary Fire: Off

Take a Breather: Off

Ultimate Ability Whole Hog: Off

}

Sigma

{

Accretion Cooldown Time: 25%

Damage Dealt: 500%

Experimental Barrier Cooldown Time: 200%

Experimental Barrier Recharge Rate: 50%

Health: 25%

Jump Vertical Speed: 150%

Movement Speed: 150%

Primary Fire: Off

Projectile Speed: 162%

Quick Melee: Off

Ultimate Generation - Combat Gravitic Flux: 260%

Ultimate Generation - Passive Gravitic Flux: 0%

Ultimate Generation Gravitic Flux: 260%

}

Soldier: 76

{

Biotic Field: Off

Helix Rockets: Off

Primary Fire: Off

Quick Melee: Off

Ultimate Ability Tactical Visor: Off

}

Sombra

{

Hack Cooldown Time: 0%

Primary Fire: Off

Quick Melee: Off

Ultimate Generation - Combat EMP: 10%

Ultimate Generation - Passive EMP: 500%

}

Torbjörn

{

Deploy Turret: Off

Overload Cooldown Time: 25%

Secondary Fire: Off

Ultimate Ability Molten Core: Off

Weapons Enabled: Forge Hammer Only

}

Tracer

{

Damage Dealt: 10%

Damage Received: 10%

Movement Speed: 130%

Primary Fire: Off

Recall Cooldown Time: 1%

Ultimate Ability Pulse Bomb: Off

}

Widowmaker

{

Grappling Hook Cooldown Time: 25%

No Ammunition Requirement: On

No Automatic Fire: On

Quick Melee: Off

Receive Headshots Only: On

Ultimate Ability Infra-Sight: Off

Venom Mine: Off

}

Winston

{

Barrier Projector: Off

Damage Dealt: 10%

Damage Received: 10%

Health: 500%

Infinite Ultimate Duration: On

Jump Pack Knockback Scalar: 400%

Primal Rage Melee Knockback Scalar: 300%

Spawn With Ultimate Ready: On

Ultimate Duration: 500%

Ultimate Generation - Combat Primal Rage: 500%

Ultimate Generation - Passive Primal Rage: 500%

Ultimate Generation Primal Rage: 500%

}

Zenyatta

{

Damage Dealt: 10%

Damage Received: 10%

Orb of Discord: Off

Orb of Harmony: Off

Primary Fire: Off

Secondary Fire: Off

Ultimate Ability Transcendence: Off

}

disabled heroes

{

Ashe

Baptiste

Hanzo

Junkrat

Lúcio

Mei

Moira

Orisa

Reaper

Reinhardt

Symmetra

Wrecking Ball

Zarya

}

variables

{

global:

0: timeCounter

1: roundTimer

2: roundNumber

3: playersStartOfTheRound

4: heroList

5: heroModeSelector

6: heroesRounds

7: heroOfTheRound

8: heroOfPreviousRound

8: heroesOfPreviousRounds

9: minigameStringTitles

10: minigameStringCodes

11: minigameStringCredit

12: minigameStringInstructions

13: discordSubtringArray

14: pointfeedHud

15: pointfeedHudTimes

16: pointfeedHudId

17: pointfeedHudTimesIt

18: hofPlayers

19: hofPlayersCounter

20: crownPos

21: crownEffect

22: tracerQueen

23: soldierObjectivePos

24: soldierObjectiveEffects

25: soldierDestructorIt

26: soldierObjectiveIcons

26: tracerQueenHud

27: potatoPos

28: potatoHolder

29: potatoEffect

30: potatoIcon

31: commonRingsEffects

32: rareRingsEffects

33: epicRingsEffects

34: legendaryRingsEffects

35: commonRingsPos

36: rareRingsPos

37: epicRingsPos

38: legendaryRingsPos

39: ringsIt

40: echoTeleportEffects

41: echoTeleportPos

42: echoRightHUD

43: dvaObjectivePos

44: dvaObjectiveEffects

45: dvaDestructorIt

46: dvaObjectiveIcons

47: roadhogHoleRadius

48: roadhogHoleEffects

49: roadhogHoleEffectsIt

50: meiSnowEffects

51: meiSnowPos

52: meiSnowIt

53: snotPos

54: snotPosRandomXComp

55: snotPosRandomYComp

56: snotPosRandomZComp

57: snotEffects

58: destructorIt

59: heroOfLastRound

60: islandPartyCode

61: islandPartySpecialEdition

62: tracerQueenPositionIcon

player:

0: queenPoints

1: queenPointsHud

2: soldierSprint

3: soldierPoints

4: soldierPointsHud

5: mccreeInvincibleTime

6: mccreeInvincibleText

7: mccreeInvincibleHud

8: mccreeHealthHud

9: pharahHealEffect

10: pharahDamageBoostEffect

11: pharahHeal

12: pharahDamageBoost

13: pharahHealHud

14: pharahDamageBoostHud

15: echoPoints

16: echoPointsHud

17: echoClosestRing

18: sigmaUsingGrasp

19: sigmaCatch

20: dvaPoints

21: dvaPointsHud

22: roadhogPostion

23: roadhogYanked

24: dvaDistanceText

25: roadhogFalling

26: meiMeeleCatchCooldown

27: meiAmmo

28: meiClosestSnow

29: meiIsPickingSnow

30: meiPickingSnowTimer

31: meiIsCatching

32: meiCatchCooldownHud

33: meiAmmoHud

34: meiHasAmmoIcon

35: thirdCameraDirection

36: thirdCameraZoom

37: isOnThirdCamera

38: meiCrouchOnMeText

39: meiHasPickedUpAnyAmmo

40: lucioClosestSnotIcon

41: meiCatchActiveCooldownHud

42: meiCatchSphereEffect

43: lucioSpeed

44: lucioPoints

45: lucioPointsHud

46: lucioClosestSnot

47: lucioHasBeenOnWall

48: playerSpeedHud

50: playerClosestObjectiveIcon

}

subroutines

{

0: gameModeDescriptionMessages

}

1: startNewRound

2: restartStats

rule("Disable bulit-in game mode & start timer variables {Game in progress GLOBAL}")

{

event

{

Ongoing - Global;

}

conditions

{

Is Game In Progress == True;

}

actions

{

Disable Built-In Game Mode Completion;

Disable Built-In Game Mode Music;

Disable Built-In Game Mode Announcer;

Disable Built-In Game Mode Scoring;

Enable Death Spectate All Players(All Players(All Teams));

Disable Built-In Game Mode Respawning(All Players(All Teams));

Set Respawn Max Time(All Players(All Teams), 60);

disabled Disable Inspector Recording;

Pause Match Time;

Global.timeCounter = 0.001;

Global.roundTimer = 60;

"Timer of the round HUD {Standard}"

Create HUD Text(Filtered Array(All Players(All Teams), Global.roundTimer > 10), Custom String(":{0}", Round To Integer(

Global.roundTimer, To Nearest)), Null, Null, Right, -999, White, White, White, Visible To and String, Default Visibility);

"Timer of the round HUD {Last moments}"

Create HUD Text(Filtered Array(All Players(All Teams), Global.roundTimer <= 10), Custom String(":{0}", Round To Integer(

Global.roundTimer, To Nearest)), Null, Null, Right, -999, Red, White, White, Visible To and String, Default Visibility);

"Timer of the round HUD separator"

Create HUD Text(All Players(All Teams), Null, Custom String(" "), Null, Right, -998, White, White, White, Visible To and String,

Default Visibility);

"Creates a HUD in the top with [svr load: {0} | svr avg: {1} | svr peak: {2}]"

Create HUD Text(Filtered Array(Host Player, (Server Load + Server Load Average + Server Load Peak) / 3 < 128 && Custom String(

"#Jokaes") == String("#{0}", Host Player)), Null, Custom String("svr load: {0} | svr avg: {1} | svr peak: {2}", Server Load,

Server Load Average, Server Load Peak), Null, Top, -100, White, Lime Green, White, Visible To and String, Default Visibility);

"Creates a HUD in the top with [svr load: {0} | svr avg: {1} | svr peak: {2}]"

Create HUD Text(Filtered Array(Host Player, (Server Load + Server Load Average + Server Load Peak) / 3 >= 128 && (

Server Load + Server Load Average + Server Load Peak) / 3 <= 192 && Custom String("#Jokaes") == String("#{0}", Host Player)),

Null, Custom String("svr load: {0} | svr avg: {1} | svr peak: {2}", Server Load, Server Load Average, Server Load Peak), Null,

Top, -100, White, Orange, White, Visible To and String, Default Visibility);

"Creates a HUD in the top with [svr load: {0} | svr avg: {1} | svr peak: {2}]"

Create HUD Text(Filtered Array(Host Player, (Server Load + Server Load Average + Server Load Peak) / 3 > 192 && Custom String(

"#Jokaes") == String("#{0}", Host Player)), Null, Custom String("svr load: {0} | svr avg: {1} | svr peak: {2}", Server Load,

Server Load Average, Server Load Peak), Null, Top, -100, White, Red, White, Visible To and String, Default Visibility);

Global.hofPlayers = Empty Array;

Global.pointfeedHud = Empty Array;

Global.pointfeedHudTimes = Array(True, True, True, True, True, True);

Global.pointfeedHudId = 0;

Create HUD Text(All Players(All Teams), Global.minigameStringTitles[Global.heroModeSelector],

Global.minigameStringCodes[Global.heroModeSelector], Global.minigameStringCredit[Global.heroModeSelector], Top, 0.001, Orange,

White, White, Visible To Sort Order and String, Default Visibility);

}

disabled rule("First to 50 EDITION")

{

event

{

Ongoing - Global;

}

conditions

{

Is Game In Progress == True;

}

actions

{

Wait(0.250, Ignore Condition);

Create HUD Text(All Players(All Teams), Null, Null, Custom String("FIRST TO 50 POINTS EDITION"), Top, 0.500, White, White,

Sky Blue, Visible To and String, Default Visibility);

Enable Built-In Game Mode Completion;

Enable Built-In Game Mode Announcer;

}

rule("Time Counter - Add minute")

{

event

{

Ongoing - Global;

}

conditions

{

Is Game In Progress == True;

}

actions

{

Set Match Time(Global.timeCounter);

Wait(60, Ignore Condition);

Global.timeCounter += 1;

Loop;

}

rule("Is in setup {GLOBAL}")

{

event

{

Ongoing - Global;

}

conditions

{

Is In Setup == True;

}

actions

{

disabled Disable Inspector Recording;

Global.roundTimer = 60;

Enable Death Spectate All Players(All Players(All Teams));

Disable Built-In Game Mode Respawning(All Players(All Teams));

Set Respawn Max Time(All Players(All Teams), 60);

Global.roundNumber = -1;

Global.islandPartyCode = Custom String("W468T");

Global.heroModeSelector = Random Integer(0, Count Of(Global.heroList) - 1);

Global.islandPartySpecialEdition = Custom String("");

Global.roundNumber = 0;

disabled Global.heroModeSelector = Random Integer(0, Count Of(Global.heroList) - 1);

Global.heroList = Empty Array;

Global.heroesOfPreviousRounds = Empty Array;

Global.discordSubtringArray = Array(Custom String("vote for the next minigame"), Custom String("give feedback"), Custom String(

"report bugs"));

Modify Global Variable(heroList, Append To Array, Hero(Ana));

Modify Global Variable(heroList, Append To Array, Hero(Bastion));

Modify Global Variable(heroList, Append To Array, Hero(Brigitte));

Modify Global Variable(heroList, Append To Array, Hero(Doomfist));

Modify Global Variable(heroList, Append To Array, Hero(D.Va));

Modify Global Variable(heroList, Append To Array, Hero(Echo));

Modify Global Variable(heroList, Append To Array, Hero(Genji));

Modify Global Variable(heroList, Append To Array, Hero(Lúcio));

Modify Global Variable(heroList, Append To Array, Hero(McCree));

Modify Global Variable(heroList, Append To Array, Hero(Mei));

Modify Global Variable(heroList, Append To Array, Hero(Mercy));

Modify Global Variable(heroList, Append To Array, Hero(Pharah));

Modify Global Variable(heroList, Append To Array, Hero(Roadhog));

Modify Global Variable(heroList, Append To Array, Hero(Sigma));

Modify Global Variable(heroList, Append To Array, Hero(Soldier: 76));

Modify Global Variable(heroList, Append To Array, Hero(Sombra));

Modify Global Variable(heroList, Append To Array, Hero(Torbjörn));

Modify Global Variable(heroList, Append To Array, Hero(Tracer));

Modify Global Variable(heroList, Append To Array, Hero(Widowmaker));

Modify Global Variable(heroList, Append To Array, Hero(Winston));

Modify Global Variable(heroList, Append To Array, Hero(Zenyatta));

Global.heroOfTheRound = Global.heroList[Global.heroModeSelector];

disabled Global.heroOfTheRound = Global.heroList[Global.heroModeSelector];

Create HUD Text(All Players(All Teams), Custom String("CODE: W468T"), Null, Null, Left, -998.500, White, White, White,

disabled Global.heroOfTheRound = Random Value In Array(Remove From Array(Global.heroList, Global.heroesOfPreviousRounds));

Visible To and String, Default Visibility);

Create HUD Text(All Players(All Teams), Custom String("CODE: {0}", Global.islandPartyCode),

Create HUD Text(All Players(All Teams), Null, Custom String(" "), Custom String("Island Party - Heroes Minigames v1.1.1-19"), Left,

Global.islandPartyCode == Custom String("W468T") ? Custom String("") : Custom String("SPECIAL EDITION"),

-998, White, White, Orange, Visible To and String, Default Visibility);

Global.islandPartySpecialEdition, Left, -998.500, White, Sky Blue, White, Visible To and String, Default Visibility);

Create HUD Text(All Players(All Teams), Null, Custom String(" "), Custom String(

"Island Party - Heroes Minigames v2.0.0-21"), Left, -998, White, White, Orange, Visible To and String,

Default Visibility);

Create HUD Text(All Players(All Teams), Null, Null, Custom String("Play rounds of {0} classic and new games as minigames",

Count Of(Global.heroList)), Left, -997, White, White, White, Visible To and String, Default Visibility);

Create HUD Text(All Players(All Teams), Null, Null, Custom String("Join discord.gg/4N4BAE6 and {0}",

Global.discordSubtringArray[Global.roundNumber % 3]), Left, -996, White, White, White, Visible To and String,

Default Visibility);

Create HUD Text(All Players(All Teams), Null, Null, Custom String("Find all my codes in: jokaes.github.io"), Left, -995.500, White,

White, White, Visible To and String, Default Visibility);

Create HUD Text(All Players(All Teams), Null, Custom String("Created by Jokaes#2263"), Null, Left, -995, White, White, White,

Visible To and String, Default Visibility);

Create HUD Text(All Players(All Teams), Null, Custom String(" \n ", String("Round"), Global.roundNumber), Null, Left, -994, White,

White, White, Visible To and String, Default Visibility);

Create HUD Text(All Players(All Teams), Null, Custom String("{0}", String("Round {0}", Global.roundNumber)), Null, Top, 999.999,

White, White, White, Visible To and String, Default Visibility);

Wait(1.500, Ignore Condition);

Start Forcing Player To Be Hero(All Players(All Teams), Global.heroOfTheRound);

disabled Start Forcing Player To Be Hero(All Players(All Teams), Global.heroOfTheRound);

Global.potatoPos = Vector(500, 500, 500);

Create HUD Text(Global.tracerQueen, Custom String("QUEEN"), Null, Null, Left, 2, Yellow, White, White, Visible To and String,

Default Visibility);

Create HUD Text(All Players(All Teams), Null, Null, Custom String(" \r\n \r\n \r\n \r\n \r\n \r\n "), Left, -999, White,

White, White, Visible To and String, Default Visibility);

Create HUD Text(Filtered Array(All Players(All Teams), Count Of(Global.hofPlayers) > 0), Null, Null, Custom String("Hall of fame"),

Right, -600, White, White, Orange, Visible To and Sort Order, Default Visibility);

Create In-World Text(All Players(All Teams), Custom String("CODE: W468T"), Vector(0, 200, 0), 4, Clip Against Surfaces,

Create In-World Text(All Players(All Teams), Custom String("CODE: {0}", Global.islandPartyCode), Vector(0, 200, 0), 4,

Visible To Position and String, White, Default Visibility);

Clip Against Surfaces, Visible To Position and String, White, Default Visibility);

Create Icon(Filtered Array(All Players(All Teams), Global.heroOfTheRound == Hero(Tracer)), Global.crownPos, Arrow: Down,

Visible To and Position, Yellow, True);

Wait(3.500, Ignore Condition);

Communicate(All Players(All Teams), Countdown);

}

rule("Disable bulit-in game mode & start timer variables {Game in progress GLOBAL}")

{

event

{

Ongoing - Global;

}

conditions

{

Is Game In Progress == True;

}

actions

{

Disable Built-In Game Mode Completion;

Disable Built-In Game Mode Music;

Disable Built-In Game Mode Announcer;

Disable Built-In Game Mode Scoring;

Enable Death Spectate All Players(All Players(All Teams));

Disable Built-In Game Mode Respawning(All Players(All Teams));

Set Respawn Max Time(All Players(All Teams), 60);

Pause Match Time;

Global.timeCounter = 0.001;

Global.roundTimer = 60;

"Timer of the round HUD {Standard}"

Create HUD Text(Filtered Array(All Players(All Teams), Global.roundTimer > 10), Custom String(":{0}", Round To Integer(

Global.roundTimer, To Nearest)), Null, Null, Right, -999, White, White, White, Visible To and String, Default Visibility);

"Timer of the round HUD {Last moments}"

Create HUD Text(Filtered Array(All Players(All Teams), Global.roundTimer <= 10), Custom String(":{0}", Round To Integer(

Global.roundTimer, To Nearest)), Null, Null, Right, -999, Red, White, White, Visible To and String, Default Visibility);

"Timer of the round HUD separator"

Create HUD Text(All Players(All Teams), Null, Custom String(" "), Null, Right, -998, White, White, White, Visible To and String,

Default Visibility);

"Creates a HUD in the top with [svr load: {0} | svr avg: {1} | svr peak: {2}] LOW LOAD(GREEN)"

Create HUD Text(Filtered Array(Host Player, (Server Load + Server Load Average + Server Load Peak) / 3 < 128 && Custom String(

"#Jokaes") == String("#{0}", Host Player)), Null, Custom String("svr load: {0} | svr avg: {1} | svr peak: {2}", Server Load,

Server Load Average, Server Load Peak), Null, Top, -100, White, Lime Green, White, Visible To and String, Default Visibility);

"Creates a HUD in the top with [svr load: {0} | svr avg: {1} | svr peak: {2}] MID LOAD(ORANGE)"

Create HUD Text(Filtered Array(Host Player, (Server Load + Server Load Average + Server Load Peak) / 3 >= 128 && (

Server Load + Server Load Average + Server Load Peak) / 3 <= 192 && Custom String("#Jokaes") == String("#{0}", Host Player)),

Null, Custom String("svr load: {0} | svr avg: {1} | svr peak: {2}", Server Load, Server Load Average, Server Load Peak), Null,

Top, -100, White, Orange, White, Visible To and String, Default Visibility);

"Creates a HUD in the top with [svr load: {0} | svr avg: {1} | svr peak: {2}] HIGH LOAD(RED)"

Create HUD Text(Filtered Array(Host Player, (Server Load + Server Load Average + Server Load Peak) / 3 > 192 && Custom String(

"#Jokaes") == String("#{0}", Host Player)), Null, Custom String("svr load: {0} | svr avg: {1} | svr peak: {2}", Server Load,

Server Load Average, Server Load Peak), Null, Top, -100, White, Red, White, Visible To and String, Default Visibility);

Global.hofPlayers = Empty Array;

Global.pointfeedHud = Empty Array;

Global.pointfeedHudTimes = Array(True, True, True, True, True, True);

Global.pointfeedHudId = 0;

Create HUD Text(All Players(All Teams), Global.minigameStringTitles[Global.heroModeSelector],

Global.minigameStringCodes[Global.heroModeSelector], Global.minigameStringCredit[Global.heroModeSelector], Top, 0.001, Orange,

White, White, Visible To Sort Order and String, Default Visibility);

Global.playersStartOfTheRound = All Players(All Teams);

}

rule("Is game in progress {PLAYER}")

{

event

{

Ongoing - Each Player;

All;

}

conditions

{

Is Game In Progress == True;

}

actions

{

Start Rule(gameModeDescriptionMessages, Do Nothing);

Enable Death Spectate All Players(Event Player);

Disable Built-In Game Mode Respawning(Event Player);

Set Respawn Max Time(Event Player, 60);

Preload Hero(Event Player, Global.heroList);

Global.playersStartOfTheRound = All Players(All Teams);

}

rule("Player join in setup")

{

event

{

Player Joined Match;

All;

}

conditions

{

Is In Setup == True;

Has Spawned(Event Player) == True;

Is Alive(Event Player) == True;

}

actions

{

Wait(0.512, Ignore Condition);

Event Player.queenPoints = 0;

Event Player.soldierPoints = 0;

Start Forcing Player To Be Hero(Event Player, Global.heroOfTheRound);

Preload Hero(Event Player, Global.heroList);

Set Respawn Max Time(Event Player, 9999);

}

rule("Player join with game in progress")

{

event

{

Player Joined Match;

All;

}

conditions

{

Is Game In Progress == True;

Is Alive(Event Player) == True;

}

actions

{

Start Rule(gameModeDescriptionMessages, Do Nothing);

Event Player.queenPoints = 0;

Event Player.soldierPoints = 0;

Disable Built-In Game Mode Respawning(Event Player);

Set Respawn Max Time(Event Player, 60);

Wait(0.512, Ignore Condition);

Start Forcing Player To Be Hero(Event Player, Global.heroOfTheRound);

Teleport(Event Player, Vector(500, 500, 500));

Clear Status(Event Player, Unkillable);

Wait(0.512, Ignore Condition);

Kill(Event Player, Null);

Preload Hero(Event Player, Global.heroList);

Set Respawn Max Time(Event Player, 9999);

}

disabled rule("First to 30 EDITION")

{

event

{

Ongoing - Global;

}

conditions

{

disabled Is Game In Progress == True;

Is In Setup == True;

}

actions

{

Wait(0.250, Ignore Condition);

Create HUD Text(All Players(All Teams), Null, Null, Custom String("FIRST TO 30 POINTS EDITION"), Top, 0.500, White, White,

Sky Blue, Visible To and String, Default Visibility);

Global.islandPartyCode = Custom String("Z9VEE");

Global.islandPartySpecialEdition = Custom String("FIRST TO 30 POINTS");

Wait(10, Ignore Condition);

Enable Built-In Game Mode Completion;

Enable Built-In Game Mode Announcer;

}

rule("Time Counter - Add minute")

{

event

{

Ongoing - Global;

}

conditions

{

Is Game In Progress == True;

}

actions

{

Set Match Time(Global.timeCounter);

Wait(60, Ignore Condition);

Global.timeCounter += 1;

Loop;

}

rule("Force players to be the hero of the round")

{

event

{

Ongoing - Each Player;

All;

}

conditions

{

Has Spawned(Event Player) == True;

Is Alive(Event Player) == True;

}

actions

{

Start Forcing Player To Be Hero(Event Player, Global.heroOfTheRound);

}

rule("Create new round {OUT OF TIME}")

rule("Create new round {SETUP}")

{

event

{

Ongoing - Global;

}

conditions

{

Global.roundTimer <= 0;

Is In Setup == True;

}

actions

{

Set Move Speed(All Players(All Teams), 100);

Wait(0.048, Ignore Condition);

Global.roundTimer = 60;

Global.heroOfTheRound = Random Value In Array(Global.heroList);

Wait(0.032, Ignore Condition);

Preload Hero(All Players(All Teams), Global.heroOfTheRound);

Global.heroOfPreviousRound = Global.heroOfTheRound;

Global.heroModeSelector = Index Of Array Value(Global.heroList, Global.heroOfTheRound);

Global.heroModeSelector = Random Integer(0, Count Of(Global.heroList) - 1);

Wait(0.272, Ignore Condition);

Global.heroesRounds[Global.heroModeSelector] = True;

Global.heroOfTheRound = Global.heroList[Global.heroModeSelector];

Wait(0.032, Ignore Condition);

Loop If(Global.heroOfTheRound == Global.heroOfPreviousRound);

Skip If(Global.heroOfTheRound == Hero(Roadhog), 1);

Respawn(All Players(All Teams));

Resurrect(All Players(All Teams));

Wait(0.250, Ignore Condition);

Start Forcing Player To Be Hero(All Players(All Teams), Global.heroOfTheRound);

Global.roundNumber += 1;

disabled Big Message(All Players(All Teams), Custom String("ROUND {0}", Global.roundNumber));

Small Message(All Players(All Teams), Custom String("ROUND {0}", Global.roundNumber));

Chase Global Variable At Rate(roundTimer, 0, 1, None);

Global.playersStartOfTheRound = All Players(All Teams);

Destroy Effect(All Players(All Teams).pharahHealEffect);

Global.roundTimer = 60;

Destroy Effect(All Players(All Teams).pharahDamageBoostEffect);

Chase Global Variable At Rate(roundTimer, 0, 1, None);

Play Effect(All Players(All Teams), Explosion Sound, White, All Players(All Teams), 200);

}

rule("Create new round {OUT OF TIME}")

{

event

{

Ongoing - Global;

}

conditions

{

Global.roundTimer <= 0;

Is Game In Progress == True;

}

actions

{

Start Rule(startNewRound, Do Nothing);

}

rule("Create new round {LAST PLAYER ALIVE}")

{

event

{

Ongoing - Global;

}

conditions

{

Number of Living Players(All Teams) <= 1;

Is Game In Progress == True;

}

actions

{

Set Move Speed(All Players(All Teams), 100);

Start Rule(startNewRound, Do Nothing);

}

rule("Create new round 2")

{

event

{

Subroutine;

startNewRound;

}

actions

{

Global.roundTimer = 60;

Wait(0.032, Ignore Condition);

Start Rule(restartStats, Do Nothing);

Global.heroOfPreviousRound = Global.heroOfTheRound;

If(Count Of(Global.heroesOfPreviousRounds) == Count Of(Global.heroList) - 1);

Global.heroModeSelector = Random Integer(0, Count Of(Global.heroList) - 1);

Global.heroesOfPreviousRounds = Empty Array;

Global.heroesRounds[Global.heroModeSelector] = True;

End;

Global.heroOfTheRound = Global.heroList[Global.heroModeSelector];

Global.heroOfLastRound = Global.heroOfTheRound;

Wait(0.032, Ignore Condition);

Modify Global Variable(heroesOfPreviousRounds, Append To Array, Global.heroOfTheRound);

Loop If(Global.heroOfTheRound == Global.heroOfPreviousRound);

Global.heroOfTheRound = Null;

Wait(0.048, Ignore Condition);

Global.heroOfTheRound = Random Value In Array(Remove From Array(Global.heroList, Global.heroesOfPreviousRounds));

Preload Hero(All Players(All Teams), Global.heroOfTheRound);

Global.heroModeSelector = Index Of Array Value(Global.heroList, Global.heroOfTheRound);

disabled Skip If(Global.heroOfTheRound == Hero(Roadhog), 1);

Respawn(All Players(All Teams));

Resurrect(All Players(All Teams));

Wait(0.250, Ignore Condition);

Wait(0.272, Ignore Condition);

Start Forcing Player To Be Hero(All Players(All Teams), Global.heroOfTheRound);

Wait(0.272, Ignore Condition);

Global.roundNumber += 1;

disabled Big Message(All Players(All Teams), Custom String("ROUND {0}", Global.roundNumber));

Small Message(All Players(All Teams), Custom String("ROUND {0}", Global.roundNumber));

Chase Global Variable At Rate(roundTimer, 0, 1, None);

Global.playersStartOfTheRound = All Players(All Teams);

Destroy Effect(All Players(All Teams).pharahHealEffect);

disabled Destroy Effect(All Players(All Teams).pharahHealEffect);

Destroy Effect(All Players(All Teams).pharahDamageBoostEffect);

disabled Destroy Effect(All Players(All Teams).pharahDamageBoostEffect);

Play Effect(All Players(All Teams), Explosion Sound, White, All Players(All Teams), 200);

Start Forcing Throttle(All Players(All Teams), 0, 0, 0, 0, 0, 0);

Set Aim Speed(All Players(All Teams), Absolute Value(0));

Wait(0.750, Ignore Condition);

Stop Forcing Throttle(All Players(All Teams));

Set Aim Speed(All Players(All Teams), 100);

Chase Global Variable At Rate(roundTimer, 0, 1, None);

}

rule("String Arrays (Title, credit, code and instructions)")

disabled rule("Create new round")

{

event

{

Ongoing - Global;

Subroutine;

startNewRound;

}

actions

{

disabled Create HUD Text(All Players(All Teams), Global.minigameStringTitles[Global.heroModeSelector], Null, Null, Top, -3, Orange, White,

Set Move Speed(All Players(All Teams), 100);

White, Visible To and String, Default Visibility);

Set Gravity(All Players(All Teams), 100);

disabled Create HUD Text(All Players(All Teams), Null, Null, Global.minigameStringCodes[Global.heroModeSelector], Top, -2, White, White,

Global.roundTimer = 60;

White, Visible To and String, Default Visibility);

Wait(0.032, Ignore Condition);

disabled Create HUD Text(All Players(All Teams), Null, Null, Global.minigameStringCredit[Global.heroModeSelector], Top, -1, White, White,

If(Count Of(Global.heroesOfPreviousRounds) == Count Of(Global.heroList) - 1);

White, Visible To and String, Default Visibility);

Global.heroesOfPreviousRounds = Empty Array;

Create HUD Text(All Players(All Teams), Null, Null, Global.minigameStringInstructions[Global.heroModeSelector], Top, 1, White,

End;

White, White, Visible To and String, Default Visibility);

Global.heroOfLastRound = Global.heroOfTheRound;

Global.minigameStringTitles = Empty Array;

Modify Global Variable(heroesOfPreviousRounds, Append To Array, Global.heroOfTheRound);

Modify Global Variable(minigameStringTitles, Append To Array, Custom String("{0} PAINTBALL {0}", Hero Icon String(Hero(Ana))));

disabled Global.heroModeSelector = Random Integer(0, Count Of(Global.heroList) - 1);

Modify Global Variable(minigameStringTitles, Append To Array, Custom String("{0} WORLD OF TANKS {0}", Hero Icon String(Hero(

disabled Global.heroesRounds[Global.heroModeSelector] = True;

Bastion))));

disabled Global.heroOfTheRound = Global.heroList[Global.heroModeSelector];

Modify Global Variable(minigameStringTitles, Append To Array, Custom String("{0} BOOP {0}", Hero Icon String(Hero(Brigitte))));

Global.heroOfTheRound = Null;

Modify Global Variable(minigameStringTitles, Append To Array, Custom String("{0} DOOM SUMO {0}", Hero Icon String(Hero(

Wait(0.048, Ignore Condition);

Doomfist))));

Global.heroOfTheRound = Random Value In Array(Remove From Array(Global.heroList, Global.heroesOfPreviousRounds));

Modify Global Variable(minigameStringTitles, Append To Array, Custom String("{0} AIR RACE {0}", Hero Icon String(Hero(D.Va))));

disabled Loop If(Global.heroOfTheRound == Global.heroesOfPreviousRounds);

Modify Global Variable(minigameStringTitles, Append To Array, Custom String("{0} RINGS {0}", Hero Icon String(Hero(Echo))));

Loop If(Is True For Any(Global.heroesOfPreviousRounds, Current Array Element == Global.heroOfTheRound));

Modify Global Variable(minigameStringTitles, Append To Array, Custom String("{0} DASH {0}", Hero Icon String(Hero(Genji))));

Preload Hero(All Players(All Teams), Global.heroOfTheRound);

Modify Global Variable(minigameStringTitles, Append To Array, Custom String("{0} HOT POTATO {0}", Hero Icon String(Hero(McCree))));

Global.heroModeSelector = Index Of Array Value(Global.heroList, Global.heroOfTheRound);

Modify Global Variable(minigameStringTitles, Append To Array, Custom String("{0} 1 PUNCH {0}", Hero Icon String(Hero(Mercy))));

Skip If(Global.heroOfTheRound == Hero(Roadhog), 1);

Modify Global Variable(minigameStringTitles, Append To Array, Custom String("{0} PHARMERCY SIMULATED {0}", Hero Icon String(Hero(

Respawn(All Players(All Teams));

Pharah))));

Resurrect(All Players(All Teams));

Modify Global Variable(minigameStringTitles, Append To Array, Custom String("{0} {1} HOOKS 1 HOLE {0}", Hero Icon String(Hero(

Wait(0.250, Ignore Condition);

Roadhog)), Count Of(Global.playersStartOfTheRound)));

Start Forcing Player To Be Hero(All Players(All Teams), Global.heroOfTheRound);

Modify Global Variable(minigameStringTitles, Append To Array, Custom String("{0} DODGEBALL {0}", Hero Icon String(Hero(Sigma))));

Global.roundNumber += 1;

Modify Global Variable(minigameStringTitles, Append To Array, Custom String("{0} SPRINT RACING {0}", Hero Icon String(Hero(

disabled Big Message(All Players(All Teams), Custom String("ROUND {0}", Global.roundNumber));

Soldier: 76))));

Small Message(All Players(All Teams), Custom String("ROUND {0}", Global.roundNumber));

Modify Global Variable(minigameStringTitles, Append To Array, Custom String("{0} HACK TO KILL {0}", Hero Icon String(Hero(

Chase Global Variable At Rate(roundTimer, 0, 1, None);

Sombra))));

Global.playersStartOfTheRound = All Players(All Teams);

Modify Global Variable(minigameStringTitles, Append To Array, Custom String("{0} HAMMER ONLY {0}", Hero Icon String(Hero(

Destroy Effect(All Players(All Teams).pharahHealEffect);

Torbjörn))));

Destroy Effect(All Players(All Teams).pharahDamageBoostEffect);

Modify Global Variable(minigameStringTitles, Append To Array, Custom String("{0} STEAL THE CROWN {0}", Hero Icon String(Hero(

Tracer))));

Modify Global Variable(minigameStringTitles, Append To Array, Custom String("{0} HS ONLY {0}", Hero Icon String(Hero(

Widowmaker))));

Modify Global Variable(minigameStringTitles, Append To Array, Custom String("{0} MONKEY SUMO {0}", Hero Icon String(Hero(

Winston))));

Modify Global Variable(minigameStringTitles, Append To Array, Custom String("{0} SPARTA {0}", Hero Icon String(Hero(Zenyatta))));

Global.minigameStringCodes = Empty Array;

Modify Global Variable(minigameStringCodes, Append To Array, Custom String("Play it more on ?????"));

Modify Global Variable(minigameStringCodes, Append To Array, Custom String("Play it more on 55MMT / VQVRG"));

Modify Global Variable(minigameStringC

Saved diffs

Original text

Open file

settings
{
	main
	{
		Description: "Island Party - Heroes Minigames    v1.1.1-19    Play rounds of 19 classic and new games as minigames and score points.    Widow HS only, McCree Hot Potato, Zen Sparta, Echo Rings...    Code: W468T    Join my discord.gg/ZdukXgB to choose the next minigame or give feedback.    ~Created by Jokaes#2263 My codes in: jokaes.github.io"
	}

	lobby
	{
		Allow Players Who Are In Queue: Yes
		Match Voice Chat: Enabled
		Max Spectators: 6
	}

	modes
	{
		Deathmatch
		{
			enabled maps
			{
				Workshop Island
				Workshop Island Night
			}
		}

		General
		{
			Allow Hero Switching: Off
			Game Mode Start: Immediately
			Hero Limit: Off
			Kill Cam: Off
			Kill Feed: Off
			Respawn As Random Hero: On
			Score To Win: 50
			Self Initiated Respawn: Off
			Skins: Off
		}
	}

	heroes
	{
		General
		{
			Ana
			{
				Biotic Grenade: Off
				Damage Dealt: 500%
				Damage Received: 500%
				Health: 10%
				No Ammunition Requirement: On
				Quick Melee: Off
				Sleep Dart Cooldown Time: 25%
				Ultimate Ability Nano Boost: Off
			}

			Bastion
			{
				Infinite Ultimate Duration: On
				No Ammunition Requirement: On
				Quick Melee: Off
				Reconfigure: Off
				Self-Repair: Off
				Spawn With Ultimate Ready: On
				Ultimate Duration: 500%
				Ultimate Generation - Combat Configuration: Tank: 500%
				Ultimate Generation - Passive Configuration: Tank: 500%
				Ultimate Generation Configuration: Tank: 500%
			}

			Brigitte
			{
				Barrier Shield Cooldown Time: 200%
				Barrier Shield Recharge Rate: 150%
				Damage Dealt: 500%
				Jump Vertical Speed: 200%
				Primary Fire: Off
				Quick Melee: Off
				Repair Pack: Off
				Shield Bash Cooldown Time: 35%
				Ultimate Generation - Combat Rally: 200%
				Ultimate Generation - Passive Rally: 0%
				Whip Shot Cooldown Time: 30%
				Whip Shot Knockback Scalar: 200%
			}

			D.Va
			{
				Boosters Cooldown Time: 0%
				Damage Dealt: 10%
				Damage Received: 10%
				Defense Matrix: Off
				Micro Missiles: Off
				Primary Fire: Off
				Quick Melee: Off
				Ultimate Ability Self-Destruct: Off
			}

			Doomfist
			{
				Damage Dealt: 10%
				Damage Received: 10%
				Health: 500%
				Quick Melee: Off
				Rocket Punch Cooldown Time: 50%
				Rocket Punch Knockback Scalar: 250%
				Seismic Slam: Off
				Ultimate Generation - Combat Meteor Strike: 50%
				Ultimate Generation - Passive Meteor Strike: 0%
			}

			Echo
			{
				Flight Cooldown Time: 50%
				Focusing Beam Cooldown Time: 50%
				Primary Fire: Off
				Sticky Bombs: Off
				Ultimate Ability Duplicate: Off
			}

			Genji
			{
				Damage Dealt: 500%
				Deflect: Off
				Primary Fire: Off
				Secondary Fire: Off
				Swift Strike Cooldown Time: 30%
				Ultimate Generation - Combat Dragonblade: 500%
				Ultimate Generation - Passive Dragonblade: 0%
				Ultimate Generation Dragonblade: 200%
			}

			McCree
			{
				Combat Roll Cooldown Time: 80%
				Damage Dealt: 10%
				Damage Received: 10%
				Flashbang: Off
				Jump Vertical Speed: 300%
				No Ammunition Requirement: On
				Secondary Fire: Off
				Ultimate Ability Deadeye: Off
			}

			Mercy
			{
				Damage Dealt: 500%
				Damage Received: 500%
				Guardian Angel: Off
				Movement Speed: 150%
				Primary Fire: Off
				Resurrect: Off
				Secondary Fire: Off
				Ultimate Generation - Combat Valkyrie: 500%
				Ultimate Generation Valkyrie: 500%
			}

			Roadhog
			{
				Chain Hook Cooldown Time: 25%
				Damage Dealt: 10%
				Damage Received: 10%
				Movement Speed: 150%
				Primary Fire: Off
				Quick Melee: Off
				Secondary Fire: Off
				Take a Breather: Off
				Ultimate Ability Whole Hog: Off
			}

			Sigma
			{
				Accretion Cooldown Time: 25%
				Damage Dealt: 500%
				Experimental Barrier Cooldown Time: 200%
				Experimental Barrier Recharge Rate: 50%
				Health: 25%
				Jump Vertical Speed: 150%
				Movement Speed: 150%
				Primary Fire: Off
				Projectile Speed: 162%
				Quick Melee: Off
				Ultimate Generation - Combat Gravitic Flux: 260%
				Ultimate Generation - Passive Gravitic Flux: 0%
				Ultimate Generation Gravitic Flux: 260%
			}

			Soldier: 76
			{
				Biotic Field: Off
				Helix Rockets: Off
				Primary Fire: Off
				Quick Melee: Off
				Ultimate Ability Tactical Visor: Off
			}

			Sombra
			{
				Hack Cooldown Time: 0%
				Primary Fire: Off
				Quick Melee: Off
				Ultimate Generation - Combat EMP: 10%
				Ultimate Generation - Passive EMP: 500%
			}

			Torbjörn
			{
				Deploy Turret: Off
				Overload Cooldown Time: 25%
				Secondary Fire: Off
				Ultimate Ability Molten Core: Off
				Weapons Enabled: Forge Hammer Only
			}

			Tracer
			{
				Damage Dealt: 10%
				Damage Received: 10%
				Movement Speed: 130%
				Primary Fire: Off
				Recall Cooldown Time: 1%
				Ultimate Ability Pulse Bomb: Off
			}

			Widowmaker
			{
				Grappling Hook Cooldown Time: 25%
				No Ammunition Requirement: On
				No Automatic Fire: On
				Quick Melee: Off
				Receive Headshots Only: On
				Ultimate Ability Infra-Sight: Off
				Venom Mine: Off
			}

			Winston
			{
				Barrier Projector: Off
				Damage Dealt: 10%
				Damage Received: 10%
				Health: 500%
				Infinite Ultimate Duration: On
				Jump Pack Knockback Scalar: 400%
				Primal Rage Melee Knockback Scalar: 300%
				Spawn With Ultimate Ready: On
				Ultimate Duration: 500%
				Ultimate Generation - Combat Primal Rage: 500%
				Ultimate Generation - Passive Primal Rage: 500%
				Ultimate Generation Primal Rage: 500%
			}

			Zenyatta
			{
				Damage Dealt: 10%
				Damage Received: 10%
				Orb of Discord: Off
				Orb of Harmony: Off
				Primary Fire: Off
				Secondary Fire: Off
				Ultimate Ability Transcendence: Off
			}

			disabled heroes
			{
				Ashe
				Baptiste
				Hanzo
				Junkrat
				Lúcio
				Mei
				Moira
				Orisa
				Reaper
				Reinhardt
				Symmetra
				Wrecking Ball
				Zarya
			}
		}
	}
}

variables
{
	global:
		0: timeCounter
		1: roundTimer
		2: roundNumber
		3: playersStartOfTheRound
		4: heroList
		5: heroModeSelector
		6: heroesRounds
		7: heroOfTheRound
		8: heroOfPreviousRound
		9: minigameStringTitles
		10: minigameStringCodes
		11: minigameStringCredit
		12: minigameStringInstructions
		13: discordSubtringArray
		14: pointfeedHud
		15: pointfeedHudTimes
		16: pointfeedHudId
		17: pointfeedHudTimesIt
		18: hofPlayers
		19: hofPlayersCounter
		20: crownPos
		21: crownEffect
		22: tracerQueen
		23: soldierObjectivePos
		24: soldierObjectiveEffects
		25: soldierDestructorIt
		26: soldierObjectiveIcons
		27: potatoPos
		28: potatoHolder
		29: potatoEffect
		30: potatoIcon
		31: commonRingsEffects
		32: rareRingsEffects
		33: epicRingsEffects
		34: legendaryRingsEffects
		35: commonRingsPos
		36: rareRingsPos
		37: epicRingsPos
		38: legendaryRingsPos
		39: ringsIt
		40: echoTeleportEffects
		41: echoTeleportPos
		42: echoRightHUD
		43: dvaObjectivePos
		44: dvaObjectiveEffects
		45: dvaDestructorIt
		46: dvaObjectiveIcons
		47: roadhogHoleRadius
		48: roadhogHoleEffects
		49: roadhogHoleEffectsIt

	player:
		0: queenPoints
		1: queenPointsHud
		2: soldierSprint
		3: soldierPoints
		4: soldierPointsHud
		5: mccreeInvincibleTime
		6: mccreeInvincibleText
		7: mccreeInvincibleHud
		8: mccreeHealthHud
		9: pharahHealEffect
		10: pharahDamageBoostEffect
		11: pharahHeal
		12: pharahDamageBoost
		13: pharahHealHud
		14: pharahDamageBoostHud
		15: echoPoints
		16: echoPointsHud
		17: echoClosestRing
		18: sigmaUsingGrasp
		19: sigmaCatch
		20: dvaPoints
		21: dvaPointsHud
		22: roadhogPostion
		23: roadhogYanked
		24: dvaDistanceText
		25: roadhogFalling
}

subroutines
{
	0: gameModeDescriptionMessages
}

rule("Disable bulit-in game mode & start timer variables {Game in progress GLOBAL}")
{
	event
	{
		Ongoing - Global;
	}

	conditions
	{
		Is Game In Progress == True;
	}

	actions
	{
		Disable Built-In Game Mode Completion;
		Disable Built-In Game Mode Music;
		Disable Built-In Game Mode Announcer;
		Disable Built-In Game Mode Scoring;
		Enable Death Spectate All Players(All Players(All Teams));
		Disable Built-In Game Mode Respawning(All Players(All Teams));
		Set Respawn Max Time(All Players(All Teams), 60);
		disabled Disable Inspector Recording;
		Pause Match Time;
		Global.timeCounter = 0.001;
		Global.roundTimer = 60;
		"Timer of the round HUD {Standard}"
		Create HUD Text(Filtered Array(All Players(All Teams), Global.roundTimer > 10), Custom String(":{0}", Round To Integer(
			Global.roundTimer, To Nearest)), Null, Null, Right, -999, White, White, White, Visible To and String, Default Visibility);
		"Timer of the round HUD {Last moments}"
		Create HUD Text(Filtered Array(All Players(All Teams), Global.roundTimer <= 10), Custom String(":{0}", Round To Integer(
			Global.roundTimer, To Nearest)), Null, Null, Right, -999, Red, White, White, Visible To and String, Default Visibility);
		"Timer of the round HUD separator"
		Create HUD Text(All Players(All Teams), Null, Custom String(" "), Null, Right, -998, White, White, White, Visible To and String,
			Default Visibility);
		"Creates a HUD in the top with [svr load: {0} | svr avg: {1} | svr peak: {2}]"
		Create HUD Text(Filtered Array(Host Player, (Server Load + Server Load Average + Server Load Peak) / 3 < 128 && Custom String(
			"#Jokaes") == String("#{0}", Host Player)), Null, Custom String("svr load: {0} | svr avg: {1} | svr peak: {2}", Server Load,
			Server Load Average, Server Load Peak), Null, Top, -100, White, Lime Green, White, Visible To and String, Default Visibility);
		"Creates a HUD in the top with [svr load: {0} | svr avg: {1} | svr peak: {2}]"
		Create HUD Text(Filtered Array(Host Player, (Server Load + Server Load Average + Server Load Peak) / 3 >= 128 && (
			Server Load + Server Load Average + Server Load Peak) / 3 <= 192 && Custom String("#Jokaes") == String("#{0}", Host Player)),
			Null, Custom String("svr load: {0} | svr avg: {1} | svr peak: {2}", Server Load, Server Load Average, Server Load Peak), Null,
			Top, -100, White, Orange, White, Visible To and String, Default Visibility);
		"Creates a HUD in the top with [svr load: {0} | svr avg: {1} | svr peak: {2}]"
		Create HUD Text(Filtered Array(Host Player, (Server Load + Server Load Average + Server Load Peak) / 3 > 192 && Custom String(
			"#Jokaes") == String("#{0}", Host Player)), Null, Custom String("svr load: {0} | svr avg: {1} | svr peak: {2}", Server Load,
			Server Load Average, Server Load Peak), Null, Top, -100, White, Red, White, Visible To and String, Default Visibility);
		Global.hofPlayers = Empty Array;
		Global.pointfeedHud = Empty Array;
		Global.pointfeedHudTimes = Array(True, True, True, True, True, True);
		Global.pointfeedHudId = 0;
		Create HUD Text(All Players(All Teams), Global.minigameStringTitles[Global.heroModeSelector],
			Global.minigameStringCodes[Global.heroModeSelector], Global.minigameStringCredit[Global.heroModeSelector], Top, 0.001, Orange,
			White, White, Visible To Sort Order and String, Default Visibility);
	}
}

disabled rule("First to 50 EDITION")
{
	event
	{
		Ongoing - Global;
	}

	conditions
	{
		Is Game In Progress == True;
	}

	actions
	{
		Wait(0.250, Ignore Condition);
		Create HUD Text(All Players(All Teams), Null, Null, Custom String("FIRST TO 50 POINTS EDITION"), Top, 0.500, White, White,
			Sky Blue, Visible To and String, Default Visibility);
		Enable Built-In Game Mode Completion;
		Enable Built-In Game Mode Announcer;
	}
}

rule("Time Counter - Add minute")
{
	event
	{
		Ongoing - Global;
	}

	conditions
	{
		Is Game In Progress == True;
	}

	actions
	{
		Set Match Time(Global.timeCounter);
		Wait(60, Ignore Condition);
		Global.timeCounter += 1;
		Loop;
	}
}

rule("Is in setup {GLOBAL}")
{
	event
	{
		Ongoing - Global;
	}

	conditions
	{
		Is In Setup == True;
	}

	actions
	{
		disabled Disable Inspector Recording;
		Enable Death Spectate All Players(All Players(All Teams));
		Disable Built-In Game Mode Respawning(All Players(All Teams));
		Set Respawn Max Time(All Players(All Teams), 60);
		Global.roundNumber = -1;
		Global.heroModeSelector = Random Integer(0, Count Of(Global.heroList) - 1);
		Global.heroList = Empty Array;
		Global.discordSubtringArray = Array(Custom String("vote for the next minigame"), Custom String("give feedback"), Custom String(
			"report bugs"));
		Modify Global Variable(heroList, Append To Array, Hero(Ana));
		Modify Global Variable(heroList, Append To Array, Hero(Bastion));
		Modify Global Variable(heroList, Append To Array, Hero(Brigitte));
		Modify Global Variable(heroList, Append To Array, Hero(Doomfist));
		Modify Global Variable(heroList, Append To Array, Hero(D.Va));
		Modify Global Variable(heroList, Append To Array, Hero(Echo));
		Modify Global Variable(heroList, Append To Array, Hero(Genji));
		Modify Global Variable(heroList, Append To Array, Hero(McCree));
		Modify Global Variable(heroList, Append To Array, Hero(Mercy));
		Modify Global Variable(heroList, Append To Array, Hero(Pharah));
		Modify Global Variable(heroList, Append To Array, Hero(Roadhog));
		Modify Global Variable(heroList, Append To Array, Hero(Sigma));
		Modify Global Variable(heroList, Append To Array, Hero(Soldier: 76));
		Modify Global Variable(heroList, Append To Array, Hero(Sombra));
		Modify Global Variable(heroList, Append To Array, Hero(Torbjörn));
		Modify Global Variable(heroList, Append To Array, Hero(Tracer));
		Modify Global Variable(heroList, Append To Array, Hero(Widowmaker));
		Modify Global Variable(heroList, Append To Array, Hero(Winston));
		Modify Global Variable(heroList, Append To Array, Hero(Zenyatta));
		Global.heroOfTheRound = Global.heroList[Global.heroModeSelector];
		Create HUD Text(All Players(All Teams), Custom String("CODE: W468T"), Null, Null, Left, -998.500, White, White, White,
			Visible To and String, Default Visibility);
		Create HUD Text(All Players(All Teams), Null, Custom String(" "), Custom String("Island Party - Heroes Minigames v1.1.1-19"), Left,
			-998, White, White, Orange, Visible To and String, Default Visibility);
		Create HUD Text(All Players(All Teams), Null, Null, Custom String("Play rounds of {0} classic and new games as minigames",
			Count Of(Global.heroList)), Left, -997, White, White, White, Visible To and String, Default Visibility);
		Create HUD Text(All Players(All Teams), Null, Null, Custom String("Join discord.gg/4N4BAE6 and {0}",
			Global.discordSubtringArray[Global.roundNumber % 3]), Left, -996, White, White, White, Visible To and String,
			Default Visibility);
		Create HUD Text(All Players(All Teams), Null, Null, Custom String("Find all my codes in: jokaes.github.io"), Left, -995.500, White,
			White, White, Visible To and String, Default Visibility);
		Create HUD Text(All Players(All Teams), Null, Custom String("Created by Jokaes#2263"), Null, Left, -995, White, White, White,
			Visible To and String, Default Visibility);
		Create HUD Text(All Players(All Teams), Null, Custom String("  \n ", String("Round"), Global.roundNumber), Null, Left, -994, White,
			White, White, Visible To and String, Default Visibility);
		Create HUD Text(All Players(All Teams), Null, Custom String("{0}", String("Round {0}", Global.roundNumber)), Null, Top, 999.999,
			White, White, White, Visible To and String, Default Visibility);
		Wait(1.500, Ignore Condition);
		Start Forcing Player To Be Hero(All Players(All Teams), Global.heroOfTheRound);
		Global.potatoPos = Vector(500, 500, 500);
		Create HUD Text(Global.tracerQueen, Custom String("QUEEN"), Null, Null, Left, 2, Yellow, White, White, Visible To and String,
			Default Visibility);
		Create HUD Text(All Players(All Teams), Null, Null, Custom String(" \r\n		\r\n		\r\n		\r\n		\r\n		\r\n		"), Left, -999, White,
			White, White, Visible To and String, Default Visibility);
		Create HUD Text(Filtered Array(All Players(All Teams), Count Of(Global.hofPlayers) > 0), Null, Null, Custom String("Hall of fame"),
			Right, -600, White, White, Orange, Visible To and Sort Order, Default Visibility);
		Create In-World Text(All Players(All Teams), Custom String("CODE: W468T"), Vector(0, 200, 0), 4, Clip Against Surfaces,
			Visible To Position and String, White, Default Visibility);
		Create Icon(Filtered Array(All Players(All Teams), Global.heroOfTheRound == Hero(Tracer)), Global.crownPos, Arrow: Down,
			Visible To and Position, Yellow, True);
		Wait(3.500, Ignore Condition);
		Communicate(All Players(All Teams), Countdown);
	}
}

rule("Is game in progress {PLAYER}")
{
	event
	{
		Ongoing - Each Player;
		All;
		All;
	}

	conditions
	{
		Is Game In Progress == True;
	}

	actions
	{
		Start Rule(gameModeDescriptionMessages, Do Nothing);
		Enable Death Spectate All Players(Event Player);
		Disable Built-In Game Mode Respawning(Event Player);
		Set Respawn Max Time(Event Player, 60);
		Preload Hero(Event Player, Global.heroList);
		Global.playersStartOfTheRound = All Players(All Teams);
	}
}

rule("Player join in setup")
{
	event
	{
		Player Joined Match;
		All;
		All;
	}

	conditions
	{
		Is In Setup == True;
		Has Spawned(Event Player) == True;
	}

	actions
	{
		Wait(0.512, Ignore Condition);
		Event Player.queenPoints = 0;
		Event Player.soldierPoints = 0;
		Start Forcing Player To Be Hero(Event Player, Global.heroOfTheRound);
		Preload Hero(Event Player, Global.heroList);
		Set Respawn Max Time(Event Player, 9999);
	}
}

rule("Player join with game in progress")
{
	event
	{
		Player Joined Match;
		All;
		All;
	}

	conditions
	{
		Is Game In Progress == True;
		Is Alive(Event Player) == True;
	}

	actions
	{
		Start Rule(gameModeDescriptionMessages, Do Nothing);
		Event Player.queenPoints = 0;
		Event Player.soldierPoints = 0;
		Disable Built-In Game Mode Respawning(Event Player);
		Set Respawn Max Time(Event Player, 60);
		Wait(0.512, Ignore Condition);
		Start Forcing Player To Be Hero(Event Player, Global.heroOfTheRound);
		Teleport(Event Player, Vector(500, 500, 500));
		Clear Status(Event Player, Unkillable);
		Wait(0.512, Ignore Condition);
		Kill(Event Player, Null);
		Preload Hero(Event Player, Global.heroList);
		Set Respawn Max Time(Event Player, 9999);
	}
}

rule("Force players to be the hero of the round")
{
	event
	{
		Ongoing - Each Player;
		All;
		All;
	}

	conditions
	{
		Has Spawned(Event Player) == True;
		Is Alive(Event Player) == True;
	}

	actions
	{
		Start Forcing Player To Be Hero(Event Player, Global.heroOfTheRound);
	}
}

rule("Create new round {OUT OF TIME}")
{
	event
	{
		Ongoing - Global;
	}

	conditions
	{
		Global.roundTimer <= 0;
	}

	actions
	{
		Set Move Speed(All Players(All Teams), 100);
		Global.roundTimer = 60;
		Wait(0.032, Ignore Condition);
		Global.heroOfPreviousRound = Global.heroOfTheRound;
		Global.heroModeSelector = Random Integer(0, Count Of(Global.heroList) - 1);
		Global.heroesRounds[Global.heroModeSelector] = True;
		Global.heroOfTheRound = Global.heroList[Global.heroModeSelector];
		Wait(0.032, Ignore Condition);
		Loop If(Global.heroOfTheRound == Global.heroOfPreviousRound);
		Skip If(Global.heroOfTheRound == Hero(Roadhog), 1);
		Respawn(All Players(All Teams));
		Resurrect(All Players(All Teams));
		Wait(0.250, Ignore Condition);
		Start Forcing Player To Be Hero(All Players(All Teams), Global.heroOfTheRound);
		Global.roundNumber += 1;
		disabled Big Message(All Players(All Teams), Custom String("ROUND {0}", Global.roundNumber));
		Small Message(All Players(All Teams), Custom String("ROUND {0}", Global.roundNumber));
		Chase Global Variable At Rate(roundTimer, 0, 1, None);
		Global.playersStartOfTheRound = All Players(All Teams);
		Destroy Effect(All Players(All Teams).pharahHealEffect);
		Destroy Effect(All Players(All Teams).pharahDamageBoostEffect);
		Play Effect(All Players(All Teams), Explosion Sound, White, All Players(All Teams), 200);
	}
}

rule("Create new round {LAST PLAYER ALIVE}")
{
	event
	{
		Ongoing - Global;
	}

	conditions
	{
		Number of Living Players(All Teams) <= 1;
	}

	actions
	{
		Set Move Speed(All Players(All Teams), 100);
		Global.roundTimer = 60;
		Wait(0.032, Ignore Condition);
		Global.heroOfPreviousRound = Global.heroOfTheRound;
		Global.heroModeSelector = Random Integer(0, Count Of(Global.heroList) - 1);
		Global.heroesRounds[Global.heroModeSelector] = True;
		Global.heroOfTheRound = Global.heroList[Global.heroModeSelector];
		Wait(0.032, Ignore Condition);
		Loop If(Global.heroOfTheRound == Global.heroOfPreviousRound);
		Respawn(All Players(All Teams));
		Resurrect(All Players(All Teams));
		Wait(0.250, Ignore Condition);
		Start Forcing Player To Be Hero(All Players(All Teams), Global.heroOfTheRound);
		Global.roundNumber += 1;
		disabled Big Message(All Players(All Teams), Custom String("ROUND {0}", Global.roundNumber));
		Small Message(All Players(All Teams), Custom String("ROUND {0}", Global.roundNumber));
		Chase Global Variable At Rate(roundTimer, 0, 1, None);
		Global.playersStartOfTheRound = All Players(All Teams);
		Destroy Effect(All Players(All Teams).pharahHealEffect);
		Destroy Effect(All Players(All Teams).pharahDamageBoostEffect);
		Play Effect(All Players(All Teams), Explosion Sound, White, All Players(All Teams), 200);
	}
}

rule("String Arrays (Title, credit, code and instructions)")
{
	event
	{
		Ongoing - Global;
	}

	actions
	{
		disabled Create HUD Text(All Players(All Teams), Global.minigameStringTitles[Global.heroModeSelector], Null, Null, Top, -3, Orange, White,
			White, Visible To and String, Default Visibility);
		disabled Create HUD Text(All Players(All Teams), Null, Null, Global.minigameStringCodes[Global.heroModeSelector], Top, -2, White, White,
			White, Visible To and String, Default Visibility);
		disabled Create HUD Text(All Players(All Teams), Null, Null, Global.minigameStringCredit[Global.heroModeSelector], Top, -1, White, White,
			White, Visible To and String, Default Visibility);
		Create HUD Text(All Players(All Teams), Null, Null, Global.minigameStringInstructions[Global.heroModeSelector], Top, 1, White,
			White, White, Visible To and String, Default Visibility);
		Global.minigameStringTitles = Empty Array;
		Modify Global Variable(minigameStringTitles, Append To Array, Custom String("{0} PAINTBALL {0}", Hero Icon String(Hero(Ana))));
		Modify Global Variable(minigameStringTitles, Append To Array, Custom String("{0} WORLD OF TANKS {0}", Hero Icon String(Hero(
			Bastion))));
		Modify Global Variable(minigameStringTitles, Append To Array, Custom String("{0} BOOP {0}", Hero Icon String(Hero(Brigitte))));
		Modify Global Variable(minigameStringTitles, Append To Array, Custom String("{0} DOOM SUMO {0}", Hero Icon String(Hero(
			Doomfist))));
		Modify Global Variable(minigameStringTitles, Append To Array, Custom String("{0} AIR RACE {0}", Hero Icon String(Hero(D.Va))));
		Modify Global Variable(minigameStringTitles, Append To Array, Custom String("{0} RINGS {0}", Hero Icon String(Hero(Echo))));
		Modify Global Variable(minigameStringTitles, Append To Array, Custom String("{0} DASH {0}", Hero Icon String(Hero(Genji))));
		Modify Global Variable(minigameStringTitles, Append To Array, Custom String("{0} HOT POTATO {0}", Hero Icon String(Hero(McCree))));
		Modify Global Variable(minigameStringTitles, Append To Array, Custom String("{0} 1 PUNCH {0}", Hero Icon String(Hero(Mercy))));
		Modify Global Variable(minigameStringTitles, Append To Array, Custom String("{0} PHARMERCY SIMULATED {0}", Hero Icon String(Hero(
			Pharah))));
		Modify Global Variable(minigameStringTitles, Append To Array, Custom String("{0} {1} HOOKS 1 HOLE {0}", Hero Icon String(Hero(
			Roadhog)), Count Of(Global.playersStartOfTheRound)));
		Modify Global Variable(minigameStringTitles, Append To Array, Custom String("{0} DODGEBALL {0}", Hero Icon String(Hero(Sigma))));
		Modify Global Variable(minigameStringTitles, Append To Array, Custom String("{0} SPRINT RACING {0}", Hero Icon String(Hero(
			Soldier: 76))));
		Modify Global Variable(minigameStringTitles, Append To Array, Custom String("{0} HACK TO KILL {0}", Hero Icon String(Hero(
			Sombra))));
		Modify Global Variable(minigameStringTitles, Append To Array, Custom String("{0} HAMMER ONLY {0}", Hero Icon String(Hero(
			Torbjörn))));
		Modify Global Variable(minigameStringTitles, Append To Array, Custom String("{0} STEAL THE CROWN {0}", Hero Icon String(Hero(
			Tracer))));
		Modify Global Variable(minigameStringTitles, Append To Array, Custom String("{0} HS ONLY {0}", Hero Icon String(Hero(
			Widowmaker))));
		Modify Global Variable(minigameStringTitles, Append To Array, Custom String("{0} MONKEY SUMO {0}", Hero Icon String(Hero(
			Winston))));
		Modify Global Variable(minigameStringTitles, Append To Array, Custom String("{0} SPARTA {0}", Hero Icon String(Hero(Zenyatta))));
		Global.minigameStringCodes = Empty Array;
		Modify Global Variable(minigameStringCodes, Append To Array, Custom String("Play it more on ?????"));
		Modify Global Variable(minigameStringCodes, Append To Array, Custom String("Play it more on ?????"));
		Modify Global Variable(minigameStringCodes, Append To Array, Custom String("Play it more on 55MMT / VQVRG"));
		Modify Global Variable(minigameStringCodes, Append To Array, Custom String("Play it more on 9G11W"));
		Modify Global Variable(minigameStringCodes, Append To Array, Custom String("Play it more on ?????"));
		Modify Global Variable(minigameStringCodes, Append To Array, Custom String("Play it more on ?????"));
		Modify Global Variable(minigameStringCodes, Append To Array, Custom String("Play it more on DDNSZ"));
		Modify Global Variable(minigameStringCodes, Append To Array, Custom String("Play it more on E515J"));
		Modify Global Variable(minigameStringCodes, Append To Array, Custom String("Play it more on ?????"));
		Modify Global Variable(minigameStringCodes, Append To Array, Custom String("Play it more on DKKKD"));
		Modify Global Variable(minigameStringCodes, Append To Array, Custom String("Play it more on WQHER"));
		Modify Global Variable(minigameStringCodes, Append To Array, Custom String("Play it more on 8P769 / AN5P7"));
		Modify Global Variable(minigameStringCodes, Append To Array, Custom String("Play it more on STJTC"));
		Modify Global Variable(minigameStringCodes, Append To Array, Custom String("Play it more on YJK0D6"));
		Modify Global Variable(minigameStringCodes, Append To Array, Custom String("Play it more on ?????"));
		Modify Global Variable(minigameStringCodes, Append To Array, Custom String("Play it more on 1FM74"));
		Modify Global Variable(minigameStringCodes, Append To Array, Custom String("Play it more on ?????"));
		Modify Global Variable(minigameStringCodes, Append To Array, Custom String("Play it more on ?????"));
		Modify Global Variable(minigameStringCodes, Append To Array, Custom String("Play it more on ?????"));
		Global.minigameStringCredit = Empty Array;
		Modify Global Variable(minigameStringCredit, Append To Array, Custom String("BY JOKAES"));
		Modify Global Variable(minigameStringCredit, Append To Array, Custom String("BY JOKAES"));
		Modify Global Variable(minigameStringCredit, Append To Array, Custom String("BY FARRON / BLOCK"));
		Modify Global Variable(minigameStringCredit, Append To Array, Custom String("BY CREBOS & CLAMINIUM"));
		Modify Global Variable(minigameStringCredit, Append To Array, Custom String("BY JOKAES"));
		Modify Global Variable(minigameStringCredit, Append To Array, Custom String("BY JOKAES"));
		Modify Global Variable(minigameStringCredit, Append To Array, Custom String("BY GANTZ"));
		Modify Global Variable(minigameStringCredit, Append To Array, Custom String("BY KEVLAR"));
		Modify Global Variable(minigameStringCredit, Append To Array, Custom String("BY ?????"));
		Modify Global Variable(minigameStringCredit, Append To Array, Custom String("BY SEITA"));
		Modify Global Variable(minigameStringCredit, Append To Array, Custom String("BY BLOCK"));
		Modify Global Variable(minigameStringCredit, Append To Array, Custom String("BY PUG / VOXCAE"));
		Modify Global Variable(minigameStringCredit, Append To Array, Custom String("BY DARWIN"));
		Modify Global Variable(minigameStringCredit, Append To Array, Custom String("BY TEHFOOT"));
		Modify Global Variable(minigameStringCredit, Append To Array, Custom String("BY JOKAES"));
		Modify Global Variable(minigameStringCredit, Append To Array, Custom String("BY KEVLAR"));
		Modify Global Variable(minigameStringCredit, Append To Array, Custom String("BY JOKAES"));
		Modify Global Variable(minigameStringCredit, Append To Array, Custom String("BY JOKAES"));
		Modify Global Variable(minigameStringCredit, Append To Array, Custom String("ORIGINALLY CREATED BY DARWIN"));
		Global.minigameStringInstructions = Empty Array;
		Modify Global Variable(minigameStringInstructions, Append To Array, Custom String("One shoot to kill!"));
		Modify Global Variable(minigameStringInstructions, Append To Array, Custom String("BOO BEE BEE BEE BOO BEEEE!"));
		Modify Global Variable(minigameStringInstructions, Append To Array, Custom String("Protect yourself and boop the others!"));
		Modify Global Variable(minigameStringInstructions, Append To Array, Custom String("Use your punches to get them out!"));
		Modify Global Variable(minigameStringInstructions, Append To Array, Custom String("Boost and race!"));
		Modify Global Variable(minigameStringInstructions, Append To Array, Custom String("Collect those rings!"));
		Modify Global Variable(minigameStringInstructions, Append To Array, Custom String("Dash!"));
		Modify Global Variable(minigameStringInstructions, Append To Array, Custom String("Shoot to pass the hot potato!"));
		Modify Global Variable(minigameStringInstructions, Append To Array, Custom String("Punch to kill and get ultimate!"));
		Modify Global Variable(minigameStringInstructions, Append To Array, Custom String(
			"Kill'em all with your Mercy pocket simulated!"));
		Modify Global Variable(minigameStringInstructions, Append To Array, Custom String("Yank'em into the hole!"));
		Modify Global Variable(minigameStringInstructions, Append To Array, Custom String("Knock them out with your big rock!"));
		Modify Global Variable(minigameStringInstructions, Append To Array, Custom String("Gotta go fast!"));
		Modify Global Variable(minigameStringInstructions, Append To Array, Custom String("Hack your opponents to kill'em!"));
		Modify Global Variable(minigameStringInstructions, Append To Array, Custom String("Overload and hammer down!"));
		Modify Global Variable(minigameStringInstructions, Append To Array, Custom String("Meele to steal the crown!"));
		Modify Global Variable(minigameStringInstructions, Append To Array, Custom String("Aim for the head!"));
		Modify Global Variable(minigameStringInstructions, Append To Array, Custom String("Ape kill ape!"));
		Modify Global Variable(minigameStringInstructions, Append To Array, Custom String("Kick them for Spartaaa!"));
	}
}

rule("Description and credit (Small Messages)")
{
	event
	{
		Subroutine;
		gameModeDescriptionMessages;
	}

	actions
	{
		Wait(3.500, Ignore Condition);
		Small Message(Event Player, Custom String("Island Party - Heroes Minigames v1.1.1-19"));
		Wait(3.500, Ignore Condition);
		Small Message(Event Player, Custom String("Play rounds of {0} minigames", Count Of(Global.heroList)));
		Wait(3.500, Ignore Condition);
		Small Message(Event Player, Custom String("Created by Jokaes#2263"));
	}
}

rule("Full heal, score and cooldown reset on kill")
{
	event
	{
		Player Dealt Final Blow;
		All;
		All;
	}

	conditions
	{
		Victim != Event Player;
		Hero Of(Event Player) != Hero(Echo);
		Hero Of(Event Player) != Hero(McCree);
		Hero Of(Event Player) != Hero(Tracer);
		Hero Of(Event Player) != Hero(Winston);
		Hero Of(Event Player) != Hero(Sigma);
	}

	actions
	{
		If(Hero Of(Event Player) != Hero(Pharah));
			Play Effect(All Players(All Teams), Good Pickup Effect, Green, Event Player, 1);
			Heal(Event Player, Null, Max Health(Event Player));
		End;
		Modify Player Score(Event Player, 1);
		Small Message(Event Player, Custom String("+1 point with {0} {1}", Hero Icon String(Hero Of(Event Player)), Hero Of(
			Event Player)));
		Set Ability Cooldown(Event Player, Button(Primary Fire), 0);
		Set Ability Cooldown(Event Player, Button(Secondary Fire), 0);
		If(Hero Of(Event Player) == Hero(Ana));
			While(Is Using Ability 1(Event Player) == True);
				Wait(0.032, Ignore Condition);
			End;
			Set Ability Cooldown(Event Player, Button(Ability 1), 0);
		End;
		Set Ability Cooldown(Event Player, Button(Ability 1), 0);
		Set Ability Cooldown(Event Player, Button(Ability 2), 0);
		Wait(0.032, Ignore Condition);
		disabled Create HUD Text(All Players(All Teams), Hero Icon String(Hero Of(Event Player)), Event Player, Custom String("+1 point"), Right,
			Count Of(Global.pointfeedHud) * -1, Orange, White, Orange, Visible To, Default Visibility);
		Create HUD Text(All Players(All Teams), Hero Icon String(Hero Of(Event Player)), Event Player, Custom String("+1 point"), Right,
			-1 + Global.pointfeedHudId, Orange, White, Orange, Visible To, Default Visibility);
		Modify Global Variable(pointfeedHud, Append To Array, Last Text ID);
		Global.pointfeedHudTimes[Count Of(Global.pointfeedHud) - 1] = 3.744;
		Global.pointfeedHudId -= 0.010;
		disabled Wait(0.016, Ignore Condition);
		disabled Small Message(All Players(All Teams), -1 + Global.pointfeedHudId);
	}
}

rule("Last seconds sound")
{
	event
	{
		Ongoing - Each Player;
		All;
		All;
	}

	conditions
	{
		Global.roundTimer <= 5;
	}

	actions
	{
		Play Effect(Event Player, Explosion Sound, White, Event Player, 200);
		Wait(1, Ignore Condition);
		Loop If Condition Is True;
	}
}

rule("HUD Pointfeed reduce times")
{
	event
	{
		Ongoing - Global;
	}

	conditions
	{
		Is True For Any(Global.pointfeedHudTimes, Current Array Element == 3.744) == True;
	}

	actions
	{
		While(True);
			For Global Variable(pointfeedHudTimesIt, 0, Count Of(Global.pointfeedHudTimes), 1);
				If(Global.pointfeedHudTimes[Global.pointfeedHudTimesIt] > 0);
					Global.pointfeedHudTimes[Global.pointfeedHudTimesIt] -= 0.016;
				End;
			End;
			Wait(0.016, Ignore Condition);
		End;
	}
}

rule("Destroy HUD Pointfeed {more than 6}")
{
	event
	{
		Ongoing - Global;
	}

	conditions
	{
		Count Of(Global.pointfeedHud) > 6;
	}

	actions
	{
		While(Count Of(Global.pointfeedHud) > 6);
			Destroy HUD Text(Global.pointfeedHud[0]);
			Modify Global Variable(pointfeedHud, Remove From Array By Index, 0);
			Wait(0.032, Ignore Condition);
		End;
	}
}

rule("Destroy HUD Pointfeed {time}")
{
	event
	{
		Ongoing - Global;
	}

	conditions
	{
		Is True For Any(Global.pointfeedHudTimes, Current Array Element <= 0) == True;
	}

	actions
	{
		While(True);
			For Global Variable(pointfeedHudTimesIt, 0, Count Of(Global.pointfeedHudTimes), 1);
				If(Global.pointfeedHudTimes[Global.pointfeedHudTimesIt] <= 0);
					Destroy HUD Text(Global.pointfeedHud[Global.pointfeedHudTimesIt]);
					Modify Global Variable(pointfeedHud, Remove From Array By Index, Global.pointfeedHudTimesIt);
					Modify Global Variable(pointfeedHudTimes, Remove From Array By Index, Global.pointfeedHudTimesIt);
				End;
			End;
			Wait(0.016, Ignore Condition);
		End;
	}
}

rule("Reset HUD Pointfeed ID")
{
	event
	{
		Ongoing - Global;
	}

	conditions
	{
		Count Of(Global.pointfeedHud) == 0;
	}

	actions
	{
		Global.pointfeedHudId = 0;
	}
}

rule("HoF player HUD")
{
	event
	{
		Ongoing - Global;
	}

	conditions
	{
		Global.hofPlayersCounter != Count Of(Global.hofPlayers);
	}

	actions
	{
		Create HUD Text(All Players(All Teams), Null, Null, Custom String("{0}", Last Of(Global.hofPlayers)), Right, -500, White, White,
			Orange, Visible To and Sort Order, Default Visibility);
		Global.hofPlayersCounter = Count Of(Global.hofPlayers);
	}
}

rule("Hof append")
{
	event
	{
		Ongoing - Each Player;
		All;
		All;
	}

	actions
	{
		If(Score Of(Event Player) >= 200);
			If(Array Contains(Global.hofPlayers, Custom String("{0}", Event Player)) == False);
				Modify Global Variable(hofPlayers, Append To Array, Custom String("{0}", Event Player));
			End;
		End;
		Wait(10, Ignore Condition);
		Loop;
	}
}

rule("HoF effect")
{
	event
	{
		Ongoing - Each Player;
		All;
		All;
	}

	conditions
	{
		Score Of(Event Player) >= 200;
	}

	actions
	{
		Create Effect(Filtered Array(All Players(All Teams), Is Alive(Event Player)), Sparkles, Orange, Event Player, 1,
			Visible To Position and Radius);
		Play Effect(Event Player, Buff Impact Sound, White, Event Player, 200);
		Wait(1, Ignore Condition);
		Play Effect(Event Player, Buff Explosion Sound, White, Event Player, 200);
		Play Effect(Event Player, Buff Impact Sound, White, Event Player, 200);
		Wait(1, Ignore Condition);
		Play Effect(Event Player, Buff Explosion Sound, White, Event Player, 200);
		Play Effect(Event Player, Buff Impact Sound, White, Event Player, 200);
		Wait(1, Ignore Condition);
		Play Effect(Event Player, Buff Explosion Sound, White, Event Player, 200);
	}
}

rule("----- HEROES -----")
{
	event
	{
		Ongoing - Global;
	}
}

rule("BASTION tank")
{
	event
	{
		Ongoing - Each Player;
		All;
		Bastion;
	}

	conditions
	{
		Is Game In Progress == True;
		Is Alive(Event Player) == True;
		Global.heroOfTheRound == Hero(Bastion);
		Is Using Ultimate(Event Player) == False;
	}

	actions
	{
		Press Button(Event Player, Ultimate);
		Wait(0.016, Ignore Condition);
		Loop If Condition Is True;
	}
}

rule("BRIG init")
{
	event
	{
		Ongoing - Each Player;
		All;
		Brigitte;
	}

	conditions
	{
		Is Game In Progress == True;
		Global.heroOfTheRound == Hero(Brigitte);
	}

	actions
	{
		Set Status(Event Player, Null, Unkillable, Global.roundTimer);
	}
}

rule("BRIG standard gravity")
{
	event
	{
		Ongoing - Each Player;
		All;
		Brigitte;
	}

	conditions
	{
		Is Game In Progress == True;
		Global.heroOfTheRound == Hero(Brigitte);
		Is Firing Secondary(Event Player) != True;
		Has Status(Event Player, Stunned) == False;
	}

	actions
	{
		Set Gravity(Event Player, 100);
	}
}

rule("BRIG shield gravity")
{
	event
	{
		Ongoing - Each Player;
		All;
		Brigitte;
	}

	conditions
	{
		Is Game In Progress == True;
		Global.heroOfTheRound == Hero(Brigitte);
		Is Firing Secondary(Event Player) == True;
	}

	actions
	{
		Set Gravity(Event Player, 200);
	}
}

rule("BRIG stunned gravity & longer stun")
{
	event
	{
		Ongoing - Each Player;
		All;
		Brigitte;
	}

	conditions
	{
		Is Game In Progress == True;
		Global.heroOfTheRound == Hero(Brigitte);
		Has Status(Event Player, Stunned) == True;
	}

	actions
	{
		Set Gravity(Event Player, 25);
		Set Status(Event Player, Null, Stunned, 1.500);
	}
}

rule("BRIG speed-boosted shield bash")
{
	event
	{
		Ongoing - Each Player;
		All;
		Brigitte;
	}

	conditions
	{
		Is Game In Progress == True;
		Global.heroOfTheRound == Hero(Brigitte);
		Is Firing Primary(Event Player) == True;
		Is Firing Secondary(Event Player) == True;
	}

	actions
	{
		Set Move Speed(Event Player, 200);
		Wait(0.250, Ignore Condition);
		Set Move Speed(Event Player, 100);
	}
}

rule("BRIG ult cooldown reset")
{
	event
	{
		Ongoing - Each Player;
		All;
		Brigitte;
	}

	conditions
	{
		Is Game In Progress == True;
		Global.heroOfTheRound == Hero(Brigitte);
		Is Using Ultimate(Event Player) == True;
	}

	actions
	{
		Set Ability Cooldown(Event Player, Button(Primary Fire), 0);
		Set Ability Cooldown(Event Player, Button(Secondary Fire), 0);
		Set Ability Cooldown(Event Player, Button(Ability 1), 0);
	}
}

rule("BRIG auto-healing")
{
	event
	{
		Ongoing - Each Player;
		All;
		Brigitte;
	}

	conditions
	{
		Is Game In Progress == True;
		Global.heroOfTheRound == Hero(Brigitte);
		Health(Event Player) < Max Health(Event Player);
	}

	actions
	{
		Heal(Event Player, Null, Max Health(Event Player));
		Wait(0.032, Ignore Condition);
		Loop If Condition Is True;
	}
}

rule("BRIG end of the round {EACH PLAYER}")
{
	event
	{
		Ongoing - Each Player;
		All;
		All;
	}

	conditions
	{
		Is Game In Progress == True;
		Global.heroOfTheRound != Hero(Brigitte);
	}

	actions
	{
		Clear Status(Event Player, Unkillable);
		Set Gravity(Event Player, 100);
		Set Move Speed(Event Player, 100);
	}
}

rule("DOOM init player")
{
	event
	{
		Ongoing - Each Player;
		All;
		All;
	}

	conditions
	{
		Is Game In Progress == True;
		Global.heroOfTheRound == Hero(Doomfist);
	}

	actions
	{
		Wait(0.064, Ignore Condition);
		Disallow Button(Event Player, Primary Fire);
	}
}

rule("DOOM ult stun")
{
	event
	{
		Player Dealt Damage;
		All;
		Doomfist;
	}

	conditions
	{
		Is Game In Progress == True;
		Global.heroOfTheRound == Hero(Doomfist);
		Is Using Ultimate(Attacker) == True;
	}

	actions
	{
		Set Status(Victim, Event Player, Stunned, 3);
	}
}

rule("DOOM not using ult")
{
	event
	{
		Ongoing - Each Player;
		All;
		All;
	}

	conditions
	{
		Is Game In Progress == True;
		Global.heroOfTheRound == Hero(Doomfist);
		Is Using Ultimate(Event Player) == False;
	}

	actions
	{
		Set Move Speed(Event Player, 100);
		Disallow Button(Event Player, Primary Fire);
	}
}

rule("DOOM using ult")
{
	event
	{
		Ongoing - Each Player;
		All;
		All;
	}

	conditions
	{
		Is Game In Progress == True;
		Global.heroOfTheRound == Hero(Doomfist);
		Is Using Ultimate(Event Player) == True;
	}

	actions
	{
		Set Move Speed(Event Player, 150);
		Allow Button(Event Player, Primary Fire);
		Set Ability Cooldown(Event Player, Button(Secondary Fire), 0);
		Set Ability Cooldown(Event Player, Button(Ability 1), 0);
	}
}

rule("DOOM end of the round {EACH PLAYER}")
{
	event
	{
		Ongoing - Each Player;
		All;
		All;
	}

	conditions
	{
		Is Game In Progress == True;
		Global.heroOfTheRound != Hero(Doomfist);
	}

	actions
	{
		Allow Button(Event Player, Primary Fire);
	}
}

rule("DVA init player")
{
	event
	{
		Ongoing - Each Player;
		All;
		D.Va;
	}

	conditions
	{
		Is Game In Progress == True;
		Global.heroOfTheRound == Hero(D.Va);
	}

	actions
	{
		Set Facing(Event Player, Direction Towards(Eye Position(Event Player), Global.dvaObjectivePos[0]), To World);
		Set Status(Event Player, Null, Phased Out, 60);
		Set Gravity(Event Player, 0);
		Teleport(Event Player, Vector(0, 0, 0));
		Event Player.dvaPoints = 0;
		Wait(0.256, Ignore Condition);
		Set Facing(Event Player, Direction Towards(Eye Position(Event Player), Global.dvaObjectivePos[0]), To World);
		Set Status(Event Player, Null, Phased Out, 60);
		Create HUD Text(All Players(All Teams), Null, Null, Custom String("{0} : {1} / 5", Event Player, Event Player.dvaPoints), Left, (
			Event Player.dvaPoints + 10) * -1, White, White, Purple, Visible To Sort Order and String, Default Visibility);
		Event Player.dvaPointsHud = Last Text ID;
		Create In-World Text(Event Player, Custom String("{0} M", Distance Between(Position Of(Event Player),
			Global.dvaObjectivePos[Event Player.dvaPoints])), Global.dvaObjectivePos[Event Player.dvaPoints], 2, Clip Against Surfaces,
			Visible To Position and String, White, Default Visibility);
		Event Player.dvaDistanceText = Last Text ID;
		Set Facing(Event Player, Direction Towards(Eye Position(Event Player), Global.dvaObjectivePos[0]), To World);
	}
}

rule("DVA init global")
{
	event
	{
		Ongoing - Global;
	}

	conditions
	{
		Is Game In Progress == True;
		Global.heroOfTheRound == Hero(D.Va);
	}

	actions
	{
		Global.dvaObjectiveEffects = Empty Array;
		Global.dvaObjectiveIcons = Empty Array;
		Global.dvaObjectivePos = Array(Vector(Random Real(-100, 100), Random Real(45, 100), Random Real(-100, 100)), Vector(Random Real(
			-100, 100), Random Real(45, 100), Random Real(-100, 100)), Vector(Random Real(-100, 100), Random Real(45, 100), Random Real(
			-100, 100)), Vector(Random Real(-100, 100), Random Real(45, 100), Random Real(-100, 100)), Vector(Random Real(-100, 100),
			Random Real(45, 100), Random Real(-100, 100)));
		Create Effect(Filtered Array(All Players(All Teams), Current Array Element.dvaPoints == 0), Good Aura, Purple,
			Global.dvaObjectivePos[0], 2, Visible To Position and Radius);
		Modify Global Variable(dvaObjectiveEffects, Append To Array, Last Created Entity);
		Create Effect(Filtered Array(All Players(All Teams), Current Array Element.dvaPoints == 0), Good Aura, Purple,
			Global.dvaObjectivePos[0], 2, Visible To Position and Radius);
		Modify Global Variable(dvaObjectiveEffects, Append To Array, Last Created Entity);
		Create Effect(Filtered Array(All Players(All Teams), Current Array Element.dvaPoints == 0), Good Aura, Purple,
			Global.dvaObjectivePos[0], 2, Visible To Position and Radius);
		Modify Global Variable(dvaObjectiveEffects, Append To Array, Last Created Entity);
		Create Effect(Filtered Array(All Players(All Teams), Current Array Element.dvaPoints == 1), Good Aura, Purple,
			Global.dvaObjectivePos[1], 2, Visible To Position and Radius);
		Modify Global Variable(dvaObjectiveEffects, Append To Array, Last Created Entity);
		Create Effect(Filtered Array(All Players(All Teams), Current Array Element.dvaPoints == 1), Good Aura, Purple,
			Global.dvaObjectivePos[1], 2, Visible To Position and Radius);
		Modify Global Variable(dvaObjectiveEffects, Append To Array, Last Created Entity);
		Create Effect(Filtered Array(All Players(All Teams), Current Array Element.dvaPoints == 1), Good Aura, Purple,
			Global.dvaObjectivePos[1], 2, Visible To Position and Radius);
		Modify Global Variable(dvaObjectiveEffects, Append To Array, Last Created Entity);
		Create Effect(Filtered Array(All Players(All Teams), Current Array Element.dvaPoints == 2), Good Aura, Purple,
			Global.dvaObjectivePos[2], 2, Visible To Position and Radius);
		Modify Global Variable(dvaObjectiveEffects, Append To Array, Last Created Entity);
		Create Effect(Filtered Array(All Players(All Teams), Current Array Element.dvaPoints == 2), Good Aura, Purple,
			Global.dvaObjectivePos[2], 2, Visible To Position and Radius);
		Modify Global Variable(dvaObjectiveEffects, Append To Array, Last Created Entity);
		Create Effect(Filtered Array(All Players(All Teams), Current Array Element.dvaPoints == 2), Good Aura, Purple,
			Global.dvaObjectivePos[2], 2, Visible To Position and Radius);
		Modify Global Variable(dvaObjectiveEffects, Append To Array, Last Created Entity);
		Create Effect(Filtered Array(All Players(All Teams), Current Array Element.dvaPoints == 3), Good Aura, Purple,
			Global.dvaObjectivePos[3], 2, Visible To Position and Radius);
		Modify Global Variable(dvaObjectiveEffects, Append To Array, Last Created Entity);
		Create Effect(Filtered Array(All Players(All Teams), Current Array Element.dvaPoints == 3), Good Aura, Purple,
			Global.dvaObjectivePos[3], 2, Visible To Position and Radius);
		Modify Global Variable(dvaObjectiveEffects, Append To Array, Last Created Entity);
		Create Effect(Filtered Array(All Players(All Teams), Current Array Element.dvaPoints == 3), Good Aura, Purple,
			Global.dvaObjectivePos[3], 2, Visible To Position and Radius);
		Modify Global Variable(dvaObjectiveEffects, Append To Array, Last Created Entity);
		Create Effect(Filtered Array(All Players(All Teams), Current Array Element.dvaPoints == 4), Good Aura, Purple,
			Global.dvaObjectivePos[4], 2, Visible To Position and Radius);
		Modify Global Variable(dvaObjectiveEffects, Append To Array, Last Created Entity);
		Create Effect(Filtered Array(All Players(All Teams), Current Array Element.dvaPoints == 4), Good Aura, Purple,
			Global.dvaObjectivePos[4], 2, Visible To Position and Radius);
		Modify Global Variable(dvaObjectiveEffects, Append To Array, Last Created Entity);
		Create Effect(Filtered Array(All Players(All Teams), Current Array Element.dvaPoints == 4), Good Aura, Purple,
			Global.dvaObjectivePos[4], 2, Visible To Position and Radius);
		Modify Global Variable(dvaObjectiveEffects, Append To Array, Last Created Entity);
		Wait(0.016, Ignore Condition);
		Create Icon(Filtered Array(All Players(All Teams), Current Array Element.dvaPoints == 0), Global.dvaObjectivePos[0] + Vector(0,
			1.500, 0), Flag, Visible To and Position, Purple, True);
		Modify Global Variable(dvaObjectiveIcons, Append To Array, Last Created Entity);
		Create Icon(Filtered Array(All Players(All Teams), Current Array Element.dvaPoints == 1), Global.dvaObjectivePos[1] + Vector(0,
			1.500, 0), Flag, Visible To and Position, Purple, True);
		Modify Global Variable(dvaObjectiveIcons, Append To Array, Last Created Entity);
		Create Icon(Filtered Array(All Players(All Teams), Current Array Element.dvaPoints == 2), Global.dvaObjectivePos[2] + Vector(0,
			1.500, 0), Flag, Visible To and Position, Purple, True);
		Modify Global Variable(dvaObjectiveIcons, Append To Array, Last Created Entity);
		Create Icon(Filtered Array(All Players(All Teams), Current Array Element.dvaPoints == 3), Global.dvaObjectivePos[3] + Vector(0,
			1.500, 0), Flag, Visible To and Position, Purple, True);
		Modify Global Variable(dvaObjectiveIcons, Append To Array, Last Created Entity);
		Create Icon(Filtered Array(All Players(All Teams), Current Array Element.dvaPoints == 4), Global.dvaObjectivePos[4] + Vector(0,
			1.500, 0), Flag, Visible To and Position, Purple, True);
		Modify Global Variable(dvaObjectiveIcons, Append To Array, Last Created Entity);
	}
}

rule("DVA point")
{
	event
	{
		Ongoing - Each Player;
		All;
		D.Va;
	}

	conditions
	{
		Is Game In Progress == True;
		Is Alive(Event Player) == True;
		Global.heroOfTheRound == Hero(D.Va);
		Event Player.dvaPoints < 5;
	}

	actions
	{
		If(Distance Between(Event Player, Global.dvaObjectivePos[Event Player.dvaPoints]) <= 5 && True);
			Modify Player Score(Event Player, 1);
			Small Message(Event Player, Custom String("+1 point with {0} {1}", Hero Icon String(Hero Of(Event Player)), Hero Of(
				Event Player)));
			Event Player.dvaPoints += 1;
			Play Effect(All Players(All Teams), Good Pickup Effect, Purple, Event Player, 1);
			Play Effect(Event Player, Buff Explosion Sound, Purple, Event Player, 100);
			Create HUD Text(All Players(All Teams), Hero Icon String(Hero Of(Event Player)), Event Player, Custom String("+1 point"), Right,
				-1 + Global.pointfeedHudId, Orange, White, Orange, Visible To, Default Visibility);
			Modify Global Variable(pointfeedHud, Append To Array, Last Text ID);
			Global.pointfeedHudTimes[Count Of(Global.pointfeedHud) - 1] = 3.744;
			Global.pointfeedHudId -= 0.010;
		End;
		Wait(0.112, Ignore Condition);
		Loop If Condition Is True;
	}
}

rule("DVA boosting")
{
	event
	{
		Ongoing - Each Player;
		All;
		D.Va;
	}

	conditions
	{
		Is Game In Progress == True;
		Global.heroOfTheRound == Hero(D.Va);
		Is Using Ability 1(Event Player) == True;
	}

	actions
	{
		Set Move Speed(Event Player, 500);
		Set Gravity(Event Player, 0);
	}
}

rule("DVA not boosting in air")
{
	event
	{
		Ongoing - Each Player;
		All;
		D.Va;
	}

	conditions
	{
		Is Game In Progress == True;
		Global.heroOfTheRound == Hero(D.Va);
		Is Using Ability 1(Event Player) == False;
		Is In Air(Event Player) == True;
	}

	actions
	{
		Set Move Speed(Event Player, 10);
		Set Gravity(Event Player, 0);
	}
}

rule("DVA not boosting on ground")
{
	event
	{
		Ongoing - Each Player;
		All;
		D.Va;
	}

	conditions
	{
		Is Game In Progress == True;
		Global.heroOfTheRound == Hero(D.Va);
		Is Using Ability 1(Event Player) == False;
		Is On Ground(Event Player) == True;
	}

	actions
	{
		Set Move Speed(Event Player, 100);
		Set Gravity(Event Player, 100);
	}
}

rule("DVA winner")
{
	event
	{
		Ongoing - Each Player;
		All;
		D.Va;
	}

	conditions
	{
		Is Game In Progress == True;
		Global.heroOfTheRound == Hero(D.Va);
		Event Player.dvaPoints >= 5;
	}

	actions
	{
		Global.roundTimer = 0.032;
	}
}

rule("DVA end of the round {GLOBAL}")
{
	event
	{
		Ongoing - Global;
	}

	conditions
	{
		Is Game In Progress == True;
		Global.heroOfTheRound != Hero(D.Va);
	}

	actions
	{
		Global.dvaDestructorIt = 0;
		For Global Variable(dvaDestructorIt, 0, Count Of(Global.dvaObjectiveEffects), 1);
			Destroy Effect(Global.dvaObjectiveEffects[Global.dvaDestructorIt]);
			Destroy Icon(Global.dvaObjectiveIcons[Global.dvaDestructorIt]);
		End;
	}
}

rule("DVA end of the round {EACH PLAYER}")
{
	event
	{
		Ongoing - Each Player;
		All;
		All;
	}

	conditions
	{
		Is Game In Progress == True;
		Global.heroOfTheRound != Hero(D.Va);
	}

	actions
	{
		Event Player.dvaPoints = 0;
		disabled Destroy HUD Text(Event Player.dvaPointsHud);
		Destroy HUD Text(Event Player.dvaPointsHud);
		Destroy In-World Text(Event Player.dvaDistanceText);
		Clear Status(Event Player, Phased Out);
		Set Gravity(Event Player, 100);
		Set Move Speed(Event Player, 100);
	}
}

rule("ECHO init player")
{
	event
	{
		Ongoing - Each Player;
		All;
		Echo;
	}

	conditions
	{
		Is Game In Progress == True;
		Global.heroOfTheRound == Hero(Echo);
	}

	actions
	{
		Event Player.echoPoints = 0;
		Wait(0.256, Ignore Condition);
		Create HUD Text(All Players(All Teams), Null, Null, Custom String("{0} : {1}/40 = {2}/4 points", Event Player,
			Event Player.echoPoints, Round To Integer(Event Player.echoPoints / 10, Down)), Left, (Event Player.echoPoints + 10) * -1,
			White, White, Aqua, Visible To Sort Order and String, Default Visibility);
		Event Player.echoPointsHud = Last Text ID;
		Set Move Speed(Event Player, 200);
		Set Status(Event Player, Null, Unkillable, Global.roundTimer);
	}
}

rule("ECHO init global")
{
	event
	{
		Ongoing - Global;
	}

	conditions
	{
		Is Game In Progress == True;
		Global.heroOfTheRound == Hero(Echo);
	}

	actions
	{
		"Creates the array to store the effects of the common rings"
		Global.commonRingsEffects = Empty Array;
		"Creates the array to store the positions of the common rings"
		Global.commonRingsPos = Empty Array;
		"Append to the array commonRingsPos the not random common ring position"
		Modify Global Variable(commonRingsPos, Append To Array, Vector(0, 16, 0));
		"Append to the array commonRingsPos a new position"
		Modify Global Variable(commonRingsPos, Append To Array, Vector(Random Real(-32, 32), Random Real(2, 32), Random Real(-32, 32)));
		"Append to the array commonRingsPos a new position"
		Modify Global Variable(commonRingsPos, Append To Array, Vector(Random Real(-32, 32), Random Real(2, 32), Random Real(-32, 32)));
		"Append to the array commonRingsPos a new position"
		Modify Global Variable(commonRingsPos, Append To Array, Vector(Random Real(-32, 32), Random Real(2, 32), Random Real(-32, 32)));
		"Append to the array commonRingsPos a new position"
		Modify Global Variable(commonRingsPos, Append To Array, Vector(Random Real(-32, 32), Random Real(2, 32), Random Real(-32, 32)));
		"Append to the array commonRingsPos a new position"
		Modify Global Variable(commonRingsPos, Append To Array, Vector(Random Real(-32, 32), Random Real(2, 32), Random Real(-32, 32)));
		"Append to the array commonRingsPos a new position"
		Modify Global Variable(commonRingsPos, Append To Array, Vector(Random Real(-32, 32), Random Real(2, 32), Random Real(-32, 32)));
		"Append to the array commonRingsPos a new position"
		Modify Global Variable(commonRingsPos, Append To Array, Vector(Random Real(-32, 32), Random Real(2, 32), Random Real(-32, 32)));
		"Creates the not random common ring"
		Create Effect(All Players(All Teams), Good Aura, White, Global.commonRingsPos[0], 1, Visible To Position and Radius);
		"Append the last created common ring to commonRingsEffects"
		Modify Global Variable(commonRingsEffects, Append To Array, Last Created Entity);
		"Create a common ring effect in the position in commonRingsPos"
		Create Effect(All Players(All Teams), Good Aura, White, Global.commonRingsPos[1], 1, Visible To Position and Radius);
		"Append the last created common ring to commonRingsEffects"
		Modify Global Variable(commonRingsEffects, Append To Array, Last Created Entity);
		"Create a common ring effect in the position in commonRingsPos"
		Create Effect(All Players(All Teams), Good Aura, White, Global.commonRingsPos[2], 1, Visible To Position and Radius);
		"Append the last created common ring to commonRingsEffects"
		Modify Global Variable(commonRingsEffects, Append To Array, Last Created Entity);
		"Create a common ring effect in the position in commonRingsPos"
		Create Effect(All Players(All Teams), Good Aura, White, Global.commonRingsPos[3], 1, Visible To Position and Radius);
		"Append the last created common ring to commonRingsEffects"
		Modify Global Variable(commonRingsEffects, Append To Array, Last Created Entity);
		"Create a common ring effect in the position in commonRingsPos"
		Create Effect(All Players(All Teams), Good Aura, White, Global.commonRingsPos[4], 1, Visible To Position and Radius);
		"Append the last created common ring to commonRingsEffects"
		Modify Global Variable(commonRingsEffects, Append To Array, Last Created Entity);
		"Create a common ring effect in the position in commonRingsPos"
		Create Effect(All Players(All Teams), Good Aura, White, Global.commonRingsPos[5], 1, Visible To Position and Radius);
		"Append the last created common ring to commonRingsEffects"
		Modify Global Variable(commonRingsEffects, Append To Array, Last Created Entity);
		"Create a common ring effect in the position in commonRingsPos"
		Create Effect(All Players(All Teams), Good Aura, White, Global.commonRingsPos[6], 1, Visible To Position and Radius);
		"Append the last created common ring to commonRingsEffects"
		Modify Global Variable(commonRingsEffects, Append To Array, Last Created Entity);
		"Create a common ring effect in the position in commonRingsPos"
		Create Effect(All Players(All Teams), Good Aura, White, Global.commonRingsPos[7], 1, Visible To Position and Radius);
		"Append the last created common ring to commonRingsEffects"
		Modify Global Variable(commonRingsEffects, Append To Array, Last Created Entity);
		"Creates the array to store the effects of the rare rings"
		Global.rareRingsEffects = Empty Array;
		"Creates the array to store the positions of the rare rings"
		Global.rareRingsPos = Empty Array;
		"Append to the array rareRingsPos a new position"
		Modify Global Variable(rareRingsPos, Append To Array, Vector(Random Real(-36, 36), Random Real(2, 36), Random Real(-36, 36)));
		"Append to the array rareRingsPos a new position"
		Modify Global Variable(rareRingsPos, Append To Array, Vector(Random Real(-36, 36), Random Real(2, 36), Random Real(-36, 36)));
		"Append to the array rareRingsPos a new position"
		Modify Global Variable(rareRingsPos, Append To Array, Vector(Random Real(-36, 36), Random Real(2, 36), Random Real(-36, 36)));
		"Append to the array rareRingsPos a new position"
		Modify Global Variable(rareRingsPos, Append To Array, Vector(Random Real(-36, 36), Random Real(2, 36), Random Real(-36, 36)));
		"Append to the array rareRingsPos a new position"
		Modify Global Variable(rareRingsPos, Append To Array, Vector(Random Real(-36, 36), Random Real(2, 36), Random Real(-36, 36)));
		"Append to the array rareRingsPos a new position"
		Modify Global Variable(rareRingsPos, Append To Array, Vector(Random Real(-36, 36), Random Real(2, 36), Random Real(-36, 36)));
		"Create a rare ring effect in the position in rareRingsPos"
		Create Effect(All Players(All Teams), Good Aura, Aqua, Global.rareRingsPos[0], 1, Visible To Position and Radius);
		"Append the last created rare ring to rareRingsEffects"
		Modify Global Variable(rareRingsEffects, Append To Array, Last Created Entity);
		"Create a rare ring effect in the position in rareRingsPos"
		Create Effect(All Players(All Teams), Good Aura, Aqua, Global.rareRingsPos[1], 1, Visible To Position and Radius);
		"Append the last created rare ring to rareRingsEffects"
		Modify Global Variable(rareRingsEffects, Append To Array, Last Created Entity);
		"Create a rare ring effect in the position in rareRingsPos"
		Create Effect(All Players(All Teams), Good Aura, Aqua, Global.rareRingsPos[2], 1, Visible To Position and Radius);
		"Append the last created rare ring to rareRingsEffects"
		Modify Global Variable(rareRingsEffects, Append To Array, Last Created Entity);
		"Create a rare ring effect in the position in rareRingsPos"
		Create Effect(All Players(All Teams), Good Aura, Aqua, Global.rareRingsPos[3], 1, Visible To Position and Radius);
		"Append the last created rare ring to rareRingsEffects"
		Modify Global Variable(rareRingsEffects, Append To Array, Last Created Entity);
		"Create a rare ring effect in the position in rareRingsPos"
		Create Effect(All Players(All Teams), Good Aura, Aqua, Global.rareRingsPos[4], 1, Visible To Position and Radius);
		"Append the last created rare ring to rareRingsEffects"
		Modify Global Variable(rareRingsEffects, Append To Array, Last Created Entity);
		"Create a rare ring effect in the position in rareRingsPos"
		Create Effect(All Players(All Teams), Good Aura, Aqua, Global.rareRingsPos[5], 1, Visible To Position and Radius);
		"Append the last created rare ring to rareRingsEffects"
		Modify Global Variable(rareRingsEffects, Append To Array, Last Created Entity);
		"Creates the array to store the effects of the epic rings"
		Global.epicRingsEffects = Empty Array;
		"Creates the array to store the positions of the epic rings"
		Global.epicRingsPos = Empty Array;
		"Append to the array epicRingsPos a new position"
		Modify Global Variable(epicRingsPos, Append To Array, Vector(Random Real(-44, 44), Random Real(2, 44), Random Real(-44, 44)));
		"Append to the array epicRingsPos a new position"
		Modify Global Variable(epicRingsPos, Append To Array, Vector(Random Real(-44, 44), Random Real(2, 44), Random Real(-44, 44)));
		"Create a epic ring effect in the position in epicRingsPos"
		Create Effect(All Players(All Teams), Good Aura, Purple, Global.epicRingsPos[0], 1, Visible To Position and Radius);
		"Append the last created epic ring to epicRingsEffects"
		Modify Global Variable(epicRingsEffects, Append To Array, Last Created Entity);
		"Create a epic ring effect in the position in epicRingsPos"
		Create Effect(All Players(All Teams), Good Aura, Purple, Global.epicRingsPos[1], 1, Visible To Position and Radius);
		"Append the last created epic ring to epicRingsEffects"
		Modify Global Variable(epicRingsEffects, Append To Array, Last Created Entity);
		"Creates the array to store the effects of the legendary rings"
		Global.legendaryRingsEffects = Empty Array;
		"Creates the array to store the positions of the legendary rings"
		Global.legendaryRingsPos = Empty Array;
		"Append to the array legendaryRingsPos a new position"
		Modify Global Variable(legendaryRingsPos, Append To Array, Vector(Random Real(-48, 48), Random Real(2, 48), Random Real(-48, 48)));
		"Create a legendary ring effect in the position in legendaryRingsPos"
		Create Effect(All Players(All Teams), Good Aura, Orange, Global.legendaryRingsPos[0], 1, Visible To Position and Radius);
		"Append the last created legendary ring to legendaryRingsEffects"
		Modify Global Variable(legendaryRingsEffects, Append To Array, Last Created Entity);
		"Creates the array to store the effects of the teleport orbs"
		Global.echoTeleportEffects = Empty Array;
		"Creates the array to store the positions of the teleport orbs"
		Global.echoTeleportPos = Empty Array;
		"Append to the array echoTeleportPos a new position"
		Modify Global Variable(echoTeleportPos, Append To Array, Vector(Random Real(-40, 40), Random Real(2, 40), Random Real(-40, 40)));
		"Create a teleport orb effect in the position in echoTeleportPos"
		Create Effect(All Players(All Teams), Orb, Green, Global.echoTeleportPos[0], 1, Visible To Position and Radius);
		"Append the last created teleport orb to echoTeleportEffects"
		Modify Global Variable(echoTeleportEffects, Append To Array, Last Created Entity);
		"Append to the array echoTeleportPos a new position"
		Modify Global Variable(echoTeleportPos, Append To Array, Vector(Random Real(-40, 40), Random Real(2, 40), Random Real(-40, 40)));
		"Create a boost orb effect in the position in echoTeleportPos"
		Create Effect(All Players(All Teams), Orb, Green, Global.echoTeleportPos[1], 1, Visible To Position and Radius);
		"Append the last created teleport orb to echoTeleportEffects"
		Modify Global Variable(echoTeleportEffects, Append To Array, Last Created Entity);
		Global.echoRightHUD = Empty Array;
		Create HUD Text(All Players(All Teams), Null, Null, Custom String(" \n"), Right, 995, White, White, White, Visible To and String,
			Default Visibility);
		Modify Global Variable(echoRightHUD, Append To Array, Last Text ID);
		Create HUD Text(All Players(All Teams), Null, Null, Custom String("White rings: 1 point"), Right, 996, White, White, White,
			Visible To and String, Default Visibility);
		Modify Global Variable(echoRightHUD, Append To Array, Last Text ID);
		Create HUD Text(All Players(All Teams), Null, Null, Custom String("Blue rings: 2 points"), Right, 997, White, White, Aqua,
			Visible To and String, Default Visibility);
		Modify Global Variable(echoRightHUD, Append To Array, Last Text ID);
		Create HUD Text(All Players(All Teams), Null, Null, Custom String("Purple rings: 4 points"), Right, 998, White, White, Purple,
			Visible To and String, Default Visibility);
		Modify Global Variable(echoRightHUD, Append To Array, Last Text ID);
		Create HUD Text(All Players(All Teams), Null, Null, Custom String("Orange rings: 5 points"), Right, 999, White, White, Orange,
			Visible To and String, Default Visibility);
		Modify Global Variable(echoRightHUD, Append To Array, Last Text ID);
		Create HUD Text(All Players(All Teams), Null, Null, Custom String(" \nTeleport"), Right, 1000, White, White, Green,
			Visible To and String, Default Visibility);
		Modify Global Variable(echoRightHUD, Append To Array, Last Text ID);
	}
}

rule("ECHO reduce speed when taking damage")
{
	event
	{
		Player Took Damage;
		All;
		All;
	}

	conditions
	{
		Is Game In Progress == True;
		Global.heroOfTheRound == Hero(Echo);
	}

	actions
	{
		Set Move Speed(Event Player, 75);
		Wait(0.500, Ignore Condition);
		Set Move Speed(Event Player, 200);
	}
}

rule("ECHO meele stun")
{
	event
	{
		Player Dealt Damage;
		All;
		Echo;
	}

	conditions
	{
		Is Game In Progress == True;
		Global.heroOfTheRound == Hero(Echo);
		Is Button Held(Attacker, Melee) == True;
	}

	actions
	{
		If(Is Button Held(Attacker, Melee) == True);
			Set Status(Victim, Event Player, Stunned, 0.750);
		End;
	}
}

rule("ECHO healing like Mercy passive")
{
	event
	{
		Ongoing - Each Player;
		All;
		Echo;
	}

	conditions
	{
		Is Game In Progress == True;
		Global.heroOfTheRound == Hero(Echo);
		Health(Event Player) < 200;
	}

	actions
	{
		Wait(0.064, Ignore Condition);
		Start Heal Over Time(Event Player, Null, Global.roundTimer, 200);
	}
}

rule("ECHO not healing")
{
	event
	{
		Ongoing - Each Player;
		All;
		Echo;
	}

	conditions
	{
		Is Game In Progress == True;
		Global.heroOfTheRound == Hero(Echo);
		Health(Event Player) == 200;
	}

	actions
	{
		Stop All Heal Over Time(Event Player);
		Wait(0.016, Ignore Condition);
	}
}

rule("ECHO points common rings")
{
	event
	{
		Ongoing - Each Player;
		All;
		Echo;
	}

	conditions
	{
		Is True For Any(Global.commonRingsPos, Distance Between(Event Player, Current Array Element) <= 2) == True;
		Is Game In Progress == True;
		Is Alive(Event Player) == True;
		Global.heroOfTheRound == Hero(Echo);
	}

	actions
	{
		Event Player.echoClosestRing = First Of(Sorted Array(Global.commonRingsPos, Distance Between(Event Player,
			Current Array Element)));
		Wait(0.016, Ignore Condition);
		Event Player.echoClosestRing = Index Of Array Value(Global.commonRingsPos, Event Player.echoClosestRing);
		Event Player.echoPoints += 1;
		Play Effect(All Players(All Teams), Good Pickup Effect, White, Event Player, 1);
		Play Effect(All Players(All Teams), Buff Explosion Sound, White, Event Player, 100);
		Global.commonRingsPos[Event Player.echoClosestRing] = Vector(Random Real(-32, 32), Random Real(2, 32), Random Real(-32, 32));
	}
}

rule("ECHO points rare rings")
{
	event
	{
		Ongoing - Each Player;
		All;
		Echo;
	}

	conditions
	{
		Is True For Any(Global.rareRingsPos, Distance Between(Event Player, Current Array Element) <= 2) == True;
		Is Game In Progress == True;
		Is Alive(Event Player) == True;
		Global.heroOfTheRound == Hero(Echo);
	}

	actions
	{
		Event Player.echoClosestRing = First Of(Sorted Array(Global.rareRingsPos, Distance Between(Event Player, Current Array Element)));
		Wait(0.016, Ignore Condition);
		Event Player.echoClosestRing = Index Of Array Value(Global.rareRingsPos, Event Player.echoClosestRing);
		Event Player.echoPoints += 2;
		Play Effect(All Players(All Teams), Good Pickup Effect, Aqua, Event Player, 1);
		Play Effect(All Players(All Teams), Buff Explosion Sound, Aqua, Event Player, 100);
		Global.rareRingsPos[Event Player.echoClosestRing] = Vector(Random Real(-36, 36), Random Real(2, 36), Random Real(-36, 36));
	}
}

rule("ECHO points epic rings")
{
	event
	{
		Ongoing - Each Player;
		All;
		Echo;
	}

	conditions
	{
		Is True For Any(Global.epicRingsPos, Distance Between(Event Player, Current Array Element) <= 2) == True;
		Is Game In Progress == True;
		Is Alive(Event Player) == True;
		Global.heroOfTheRound == Hero(Echo);
	}

	actions
	{
		Event Player.echoClosestRing = First Of(Sorted Array(Global.epicRingsPos, Distance Between(Event Player, Current Array Element)));
		Wait(0.016, Ignore Condition);
		Event Player.echoClosestRing = Index Of Array Value(Global.epicRingsPos, Event Player.echoClosestRing);
		Event Player.echoPoints += 4;
		Play Effect(All Players(All Teams), Good Pickup Effect, Purple, Event Player, 1);
		Play Effect(All Players(All Teams), Buff Explosion Sound, Purple, Event Player, 100);
		Global.epicRingsPos[Event Player.echoClosestRing] = Vector(Random Real(-44, 44), Random Real(2, 44), Random Real(-44, 44));
	}
}

rule("ECHO points legendary rings")
{
	event
	{
		Ongoing - Each Player;
		All;
		Echo;
	}

	conditions
	{
		Is True For Any(Global.legendaryRingsPos, Distance Between(Event Player, Current Array Element) <= 2) == True;
		Is Game In Progress == True;
		Is Alive(Event Player) == True;
		Global.heroOfTheRound == Hero(Echo);
	}

	actions
	{
		Event Player.echoClosestRing = First Of(Sorted Array(Global.legendaryRingsPos, Distance Between(Event Player,
			Current Array Element)));
		Wait(0.016, Ignore Condition);
		Event Player.echoClosestRing = Index Of Array Value(Global.legendaryRingsPos, Event Player.echoClosestRing);
		Event Player.echoPoints += 5;
		Play Effect(All Players(All Teams), Good Pickup Effect, Orange, Event Player, 1);
		Play Effect(All Players(All Teams), Buff Explosion Sound, Orange, Event Player, 100);
		Global.legendaryRingsPos[Event Player.echoClosestRing] = Vector(Random Real(-48, 48), Random Real(2, 48), Random Real(-48, 48));
	}
}

rule("ECHO teleports")
{
	event
	{
		Ongoing - Each Player;
		All;
		Echo;
	}

	conditions
	{
		Is True For Any(Global.echoTeleportPos, Distance Between(Event Player, Current Array Element) <= 2) == True;
		Is Game In Progress == True;
		Is Alive(Event Player) == True;
		Global.heroOfTheRound == Hero(Echo);
	}

	actions
	{
		Teleport(Event Player, Sorted Array(Global.echoTeleportPos, Distance Between(Event Player, Current Array Element))[1]);
		Wait(0.016, Ignore Condition);
		Play Effect(All Players(All Teams), Good Explosion, Green, Event Player, 1);
		Play Effect(All Players(All Teams), Explosion Sound, Green, Event Player, 100);
		Global.echoTeleportPos[0] = Vector(Random Real(-40, 40), Random Real(2, 40), Random Real(-40, 40));
		Global.echoTeleportPos[1] = Vector(Random Real(-40, 40), Random Real(2, 40), Random Real(-40, 40));
		Wait(1.500, Ignore Condition);
	}
}

rule("ECHO winner")
{
	event
	{
		Ongoing - Each Player;
		All;
		Echo;
	}

	conditions
	{
		Is Game In Progress == True;
		Global.heroOfTheRound == Hero(Echo);
		Event Player.echoPoints >= 40;
	}

	actions
	{
		Global.roundTimer = 0.032;
	}
}

rule("ECHO end of the round {GLOBAL}")
{
	event
	{
		Ongoing - Global;
	}

	conditions
	{
		Is Game In Progress == True;
		Global.heroOfTheRound != Hero(Echo);
	}

	actions
	{
		Wait(0.064, Ignore Condition);
		For Global Variable(ringsIt, 0, 8, 1);
			Destroy Effect(Global.commonRingsEffects[Global.ringsIt]);
			Destroy Effect(Global.rareRingsEffects[Global.ringsIt]);
			Destroy Effect(Global.epicRingsEffects[Global.ringsIt]);
			Destroy Effect(Global.legendaryRingsEffects[Global.ringsIt]);
			Destroy Effect(Global.echoTeleportEffects[Global.ringsIt]);
			Destroy HUD Text(Global.echoRightHUD[Global.ringsIt]);
		End;
		"Creates the array to store the effects of the common rings"
		Global.commonRingsEffects = Empty Array;
		"Creates the array to store the positions of the common rings"
		Global.commonRingsPos = Empty Array;
		"Creates the array to store the effects of the rare rings"
		Global.rareRingsEffects = Empty Array;
		"Creates the array to store the positions of the rare rings"
		Global.rareRingsPos = Empty Array;
		"Creates the array to store the effects of the epic rings"
		Global.epicRingsEffects = Empty Array;
		"Creates the array to store the positions of the epic rings"
		Global.epicRingsPos = Empty Array;
		"Creates the array to store the effects of the legendary rings"
		Global.legendaryRingsEffects = Empty Array;
		"Creates the array to store the positions of the legendary rings"
		Global.legendaryRingsPos = Empty Array;
		"Creates the array to store the effects of the teleports"
		Global.echoTeleportEffects = Empty Array;
		"Creates the array to store the positions of the teleports"
		Global.echoTeleportPos = Empty Array;
		For Global Variable(ringsIt, 0, 8, 1);
			"Append to the array commonRingsPos the not random common ring position"
			Modify Global Variable(commonRingsPos, Append To Array, Vector(0, -16, 0));
			"Append to the array rareRingsPos the not random rare ring position"
			Modify Global Variable(rareRingsPos, Append To Array, Vector(0, -16, 0));
			"Append to the array epicRingsPos the not random epic ring position"
			Modify Global Variable(epicRingsPos, Append To Array, Vector(0, -16, 0));
			"Append to the array legendaryRingsPos the not random legendary ring position"
			Modify Global Variable(legendaryRingsPos, Append To Array, Vector(0, -16, 0));
			"Append to the array echoTeleportPos the not random legendary ring position"
			Modify Global Variable(echoTeleportPos, Append To Array, Vector(0, -16, 0));
		End;
	}
}

rule("ECHO end of the round {EACH PLAYER}")
{
	event
	{
		Ongoing - Each Player;
		All;
		Echo;
	}

	conditions
	{
		Is Game In Progress == True;
		Global.heroOfTheRound != Hero(Echo);
	}

	actions
	{
		Wait(Event Player.echoPoints * 0.001, Ignore Condition);
		Modify Player Score(Event Player, Round To Integer(Event Player.echoPoints / 10, Down));
		If(Event Player.echoPoints >= 10);
			Small Message(Event Player, Custom String("+{0} with {1} {2}", Custom String("{0} {1}", Round To Integer(
				Event Player.echoPoints / 10, Down), Round To Integer(Event Player.echoPoints / 10, Down) > 1 ? Custom String("points")
				: Custom String("point")), Hero Icon String(Hero Of(Event Player)), Hero Of(Event Player)));
			Play Effect(All Players(All Teams), Good Pickup Effect, White, Event Player, 1);
			Play Effect(All Players(All Teams), Buff Explosion Sound, White, Event Player, 100);
			disabled Create HUD Text(All Players(All Teams), Hero Icon String(Hero Of(Event Player)), Event Player, Custom String("+{1} {2}", Null,
				Round To Integer(Event Player.echoPoints / 10, Down), Round To Integer(Event Player.echoPoints / 10, Down) > 1 ? Custom String(
				"points") : Custom String("point")), Right, Count Of(Global.pointfeedHud) * -1, Orange, White, Orange, Visible To,
				Default Visibility);
			Create HUD Text(All Players(All Teams), Hero Icon String(Hero Of(Event Player)), Event Player, Custom String("+{1} {2}", Null,
				Round To Integer(Event Player.echoPoints / 10, Down), Round To Integer(Event Player.echoPoints / 10, Down) > 1 ? Custom String(
				"points") : Custom String("point")), Right, -1 + Global.pointfeedHudId, Orange, White, Orange, Visible To, Default Visibility);
			Modify Global Variable(pointfeedHud, Append To Array, Last Text ID);
			Global.pointfeedHudTimes[Count Of(Global.pointfeedHud) - 1] = 3.744;
			Global.pointfeedHudId -= 0.010;
		End;
		Wait(0.016, Ignore Condition);
		Clear Status(Event Player, Unkillable);
		Set Move Speed(Event Player, 100);
		Destroy HUD Text(Event Player.echoPointsHud);
		Stop All Heal Over Time(Event Player);
	}
}

rule("MERCY go back, told you")
{
	event
	{
		Ongoing - Each Player;
		All;
		Mercy;
	}

	conditions
	{
		Is Game In Progress == True;
		Global.heroOfTheRound == Hero(Mercy);
		Distance Between(Event Player, Vector(0, 0, 0)) >= 60;
	}

	actions
	{
		Small Message(Event Player, Custom String("go back"));
		Set Status(Event Player, Null, Stunned, 1);
		Wait(4, Ignore Condition);
		Abort If Condition Is False;
		Small Message(Event Player, Custom String("told you"));
		Set Status(Event Player, Null, Stunned, 5);
	}
}

rule("MCCREE init player")
{
	event
	{
		Ongoing - Each Player;
		All;
		McCree;
	}

	conditions
	{
		Is Game In Progress == True;
		Global.heroOfTheRound == Hero(McCree);
	}

	actions
	{
		Wait(0.256, Ignore Condition);
		Create HUD Text(All Players(All Teams), Null, Null, Custom String("{0} : {1} HP {2}", Event Player, Round To Integer(Health(
			Event Player), Up), Global.potatoHolder == Event Player ? Icon String(Fire) : Custom String(" ")), Left, Health(Event Player)
			* -1, White, White, Red, Visible To Sort Order and String, Default Visibility);
		Event Player.mccreeHealthHud = Last Text ID;
		Start Damage Modification(All Players(All Teams), All Players(All Teams), 50, Receivers Damagers and Damage Percent);
	}
}

rule("MCCREE choose a potato holder")
{
	event
	{
		Ongoing - Global;
	}

	conditions
	{
		Is Game In Progress == True;
		Global.heroOfTheRound == Hero(McCree);
		Global.potatoHolder == Null;
	}

	actions
	{
		Global.potatoHolder = Random Value In Array(All Living Players(All Teams));
		Global.potatoPos = Global.potatoHolder;
	}
}

rule("MCCREE potato effect")
{
	event
	{
		Ongoing - Global;
	}

	conditions
	{
		Is Game In Progress == True;
		Global.heroOfTheRound == Hero(McCree);
	}

	actions
	{
		Create Effect(All Players(All Teams), Bad Aura, Red, Global.potatoPos, 1, Visible To Position and Radius);
		Global.potatoEffect = Last Created Entity;
		Create Icon(All Players(All Teams), Global.potatoPos, Fire, Visible To and Position, Red, True);
		Global.potatoIcon = Last Created Entity;
	}
}

rule("MCCREE potato holder")
{
	event
	{
		Ongoing - Each Player;
		All;
		McCree;
	}

	conditions
	{
		Is Game In Progress == True;
		Is Alive(Event Player) == True;
		Global.heroOfTheRound == Hero(McCree);
		Event Player == Global.potatoHolder;
	}

	actions
	{
		Set Status(Event Player, Null, Burning, Global.roundTimer);
		Play Effect(All Players(All Teams), Debuff Impact Sound, White, Event Player, 50);
		Start Damage Over Time(Event Player, Null, Global.roundTimer, 250);
		Set Move Speed(Event Player, 110);
		Allow Button(Event Player, Primary Fire);
		Allow Button(Event Player, Melee);
		Set Ability Cooldown(Event Player, Button(Ability 1), 0);
	}
}

rule("MCCREE not potato holder")
{
	event
	{
		Ongoing - Each Player;
		All;
		McCree;
	}

	conditions
	{
		Is Game In Progress == True;
		Global.heroOfTheRound == Hero(McCree);
		Event Player != Global.potatoHolder;
	}

	actions
	{
		Clear Status(Event Player, Burning);
		Stop All Damage Over Time(Event Player);
		Set Move Speed(Event Player, 100);
		Disallow Button(Event Player, Primary Fire);
		Disallow Button(Event Player, Melee);
	}
}

rule("MCCREE pass the potato")
{
	event
	{
		Player Dealt Damage;
		All;
		McCree;
	}

	conditions
	{
		Is Game In Progress == True;
		Is Alive(Event Player) == True;
		Global.heroOfTheRound == Hero(McCree);
		Event Player == Global.potatoHolder;
	}

	actions
	{
		Destroy In-World Text(Event Player.mccreeInvincibleText);
		Destroy HUD Text(Event Player.mccreeInvincibleHud);
		Global.potatoHolder = Victim;
		Global.potatoPos = Victim;
		Event Player.mccreeInvincibleTime = 1;
		Set Status(Event Player, Null, Invincible, Event Player.mccreeInvincibleTime);
		Create In-World Text(Filtered Array(All Players(All Teams), Event Player.mccreeInvincibleTime > 0), Custom String(
			"INVINCIBLE: {0}", Event Player.mccreeInvincibleTime), Attacker, 1, Clip Against Surfaces, Visible To Position and String,
			Yellow, Default Visibility);
		Event Player.mccreeInvincibleText = Last Text ID;
		Wait(0.016, Ignore Condition);
		Create HUD Text(Filtered Array(Event Player, Event Player.mccreeInvincibleTime > 0), Custom String("INVINCIBLE: {0}",
			Event Player.mccreeInvincibleTime), Null, Null, Left, 2, Yellow, White, White, Visible To and String, Default Visibility);
		Event Player.mccreeInvincibleHud = Last Text ID;
		Wait(0.016, Ignore Condition);
		Chase Player Variable Over Time(Event Player, mccreeInvincibleTime, 0, Event Player.mccreeInvincibleTime,
			Destination and Duration);
		Set Ability Cooldown(Attacker, Button(Ability 1), 0);
		Set Ability Cooldown(Victim, Button(Ability 1), 0);
		If(Event Ability == Button(Melee));
			Create Effect(All Players(All Teams), Sparkles, Green, Attacker, 1, Visible To Position and Radius);
			Heal(Attacker, Null, Round To Integer(Health(Event Player) / 25, Up) * 25 - Health(Event Player));
			Wait(0.750, Ignore Condition);
			Destroy Effect(Last Created Entity);
		End;
	}
}

rule("MCCREE potato holder dies")
{
	event
	{
		Player Died;
		All;
		All;
	}

	conditions
	{
		Is Game In Progress == True;
		Global.heroOfTheRound == Hero(McCree);
		Event Player == Global.potatoHolder;
	}

	actions
	{
		Global.potatoHolder = Null;
	}
}

rule("MCCREE potato holder leaves")
{
	event
	{
		Player Left Match;
		All;
		All;
	}

	conditions
	{
		Is Game In Progress == True;
		Global.heroOfTheRound == Hero(McCree);
		Event Player == Global.potatoHolder;
	}

	actions
	{
		Global.potatoHolder = Null;
	}
}

rule("MCCREE end of the round {GLOBAL}")
{
	event
	{
		Ongoing - Global;
	}

	conditions
	{
		Is Game In Progress == True;
		Global.heroOfTheRound != Hero(McCree);
	}

	actions
	{
		Destroy Effect(Global.potatoEffect);
		Destroy Icon(Global.potatoIcon);
		Global.potatoHolder = Null;
	}
}

rule("MCCREE end of the round {EACH PLAYER}")
{
	event
	{
		Ongoing - Each Player;
		All;
		All;
	}

	conditions
	{
		Is Game In Progress == True;
		Global.heroOfTheRound != Hero(McCree);
	}

	actions
	{
		Clear Status(Event Player, Burning);
		Stop Damage Over Time(Last Damage Over Time ID);
		Stop All Damage Modifications;
		Set Move Speed(Event Player, 100);
		Allow Button(Event Player, Primary Fire);
		Allow Button(Event Player, Melee);
		Destroy HUD Text(Event Player.mccreeHealthHud);
	}
}

rule("MCCREE win {OUT OF TIME}")
{
	event
	{
		Ongoing - Each Player;
		All;
		McCree;
	}

	conditions
	{
		Is Game In Progress == True;
		Is Alive(Event Player) == True;
		Global.heroOfTheRound == Hero(McCree);
		Global.roundTimer <= 0.500;
		Number of Players(All Teams) > 1;
	}

	actions
	{
		Play Effect(All Players(All Teams), Good Pickup Effect, White, Event Player, 1);
		Play Effect(All Players(All Teams), Buff Explosion Sound, White, Event Player, 100);
		disabled Modify Player Score(Event Player, Round To Integer(Count Of(Global.playersStartOfTheRound) / Number of Living Players(All Teams),
			Up));
		disabled Small Message(Event Player, Custom String("+{0} with {1} {2}", Custom String("{0} {1}", Round To Integer(Count Of(
			Global.playersStartOfTheRound) / Number of Living Players(All Teams), Up), Round To Integer(Count Of(
			Global.playersStartOfTheRound) / Number of Living Players(All Teams), Up) > 1 ? Custom String("points") : Custom String(
			"point")), Hero Icon String(Hero Of(Event Player)), Hero Of(Event Player)));
		disabled Create HUD Text(All Players(All Teams), Hero Icon String(Hero Of(Event Player)), Event Player, Custom String("+{1} {2}", Null,
			Round To Integer(Count Of(Global.playersStartOfTheRound) / Count Of(All Living Players(All Teams)), Up), Round To Integer(
			Count Of(Global.playersStartOfTheRound) / Number of Living Players(All Teams), Up) > 1 ? Custom String("points")
			: Custom String("point")), Right, -1 + Global.pointfeedHudId, Orange, White, Orange, Visible To, Default Visibility);
		Modify Player Score(Event Player, Round To Integer(Count Of(Global.playersStartOfTheRound) / Number of Living Players(All Teams),
			Up) - 1);
		Small Message(Event Player, Custom String("+{0} with {1} {2}", Custom String("{0} {1}", Round To Integer(Count Of(
			Global.playersStartOfTheRound) / Number of Living Players(All Teams), Up) - 1, Round To Integer(Count Of(
			Global.playersStartOfTheRound) / Number of Living Players(All Teams), Up) - 1 > 1 ? Custom String("points") : Custom String(
			"point")), Hero Icon String(Hero Of(Event Player)), Hero Of(Event Player)));
		Create HUD Text(All Players(All Teams), Hero Icon String(Hero Of(Event Player)), Event Player, Custom String("+{1} {2}", Null,
			Round To Integer(Count Of(Global.playersStartOfTheRound) / Count Of(All Living Players(All Teams)), Up) - 1, Round To Integer(
			Count Of(Global.playersStartOfTheRound) / Number of Living Players(All Teams), Up) - 1 > 1 ? Custom String("points")
			: Custom String("point")), Right, -1 + Global.pointfeedHudId, Orange, White, Orange, Visible To, Default Visibility);
		Modify Global Variable(pointfeedHud, Append To Array, Last Text ID);
		Global.pointfeedHudTimes[Count Of(Global.pointfeedHud) - 1] = 3.744;
		Global.pointfeedHudId -= 0.010;
	}
}

rule("MCCREE win {LAST PLAYER ALIVE}")
{
	event
	{
		Ongoing - Each Player;
		All;
		McCree;
	}

	conditions
	{
		Is Game In Progress == True;
		Is Alive(Event Player) == True;
		Global.heroOfTheRound == Hero(McCree);
		Number of Living Players(All Teams) <= 1;
		Number of Players(All Teams) > 1;
	}

	actions
	{
		Play Effect(All Players(All Teams), Good Pickup Effect, White, Event Player, 1);
		Play Effect(All Players(All Teams), Buff Explosion Sound, White, Event Player, 100);
		disabled Modify Player Score(Event Player, Count Of(Global.playersStartOfTheRound));
		disabled Small Message(Event Player, Custom String("+{0} with {1} {2}", Custom String("{0} {1}", Round To Integer(Count Of(
			Global.playersStartOfTheRound) / Number of Living Players(All Teams), Up), Round To Integer(Count Of(
			Global.playersStartOfTheRound) / Number of Living Players(All Teams), Up) > 1 ? Custom String("points") : Custom String(
			"point")), Hero Icon String(Hero Of(Event Player)), Hero Of(Event Player)));
		disabled Create HUD Text(All Players(All Teams), Hero Icon String(Hero Of(Event Player)), Event Player, Custom String("+{1} {2}", Null,
			Round To Integer(Count Of(Global.playersStartOfTheRound) / Count Of(All Living Players(All Teams)), Up), Round To Integer(
			Count Of(Global.playersStartOfTheRound) / Number of Living Players(All Teams), Up) > 1 ? Custom String("points")
			: Custom String("point")), Right, -1 + Global.pointfeedHudId, Orange, White, Orange, Visible To, Default Visibility);
		Modify Player Score(Event Player, Count Of(Global.playersStartOfTheRound) - 1);
		Small Message(Event Player, Custom String("+{0} with {1} {2}", Custom String("{0} {1}", Round To Integer(Count Of(
			Global.playersStartOfTheRound) / Number of Living Players(All Teams), Up) - 1, Round To Integer(Count Of(
			Global.playersStartOfTheRound) / Number of Living Players(All Teams), Up) - 1 > 1 ? Custom String("points") : Custom String(
			"point")), Hero Icon String(Hero Of(Event Player)), Hero Of(Event Player)));
		Create HUD Text(All Players(All Teams), Hero Icon String(Hero Of(Event Player)), Event Player, Custom String("+{1} {2}", Null,
			Round To Integer(Count Of(Global.playersStartOfTheRound) / Count Of(All Living Players(All Teams)), Up) - 1, Round To Integer(
			Count Of(Global.playersStartOfTheRound) / Number of Living Players(All Teams), Up) - 1 > 1 ? Custom String("points")
			: Custom String("point")), Right, -1 + Global.pointfeedHudId, Orange, White, Orange, Visible To, Default Visibility);
		Modify Global Variable(pointfeedHud, Append To Array, Last Text ID);
		Global.pointfeedHudTimes[Count Of(Global.pointfeedHud) - 1] = 3.744;
		Global.pointfeedHudId -= 0.010;
	}
}

rule("PHARAH init effects")
{
	event
	{
		Ongoing - Each Player;
		All;
		Pharah;
	}

	conditions
	{
		Is Game In Progress == True;
		Global.heroOfTheRound == Hero(Pharah);
	}

	actions
	{
		Wait(2, Ignore Condition);
		Create Effect(Filtered Array(All Players(All Teams), Event Player.pharahHeal == True), Good Aura, Yellow, Event Player, 1,
			Visible To Position and Radius);
		Event Player.pharahHealEffect = Last Created Entity;
		Create Effect(Filtered Array(All Players(All Teams), Health(Event Player) > 199), Good Aura, Aqua, Event Player, 1,
			Visible To Position and Radius);
		Event Player.pharahDamageBoostEffect = Last Created Entity;
		Create HUD Text(Filtered Array(Event Player, Event Player.pharahHeal == True), Custom String("HEALING"), Null, Null, Left, 2,
			Yellow, White, White, Visible To and String, Default Visibility);
		Event Player.pharahHealHud = Last Text ID;
		Create HUD Text(Filtered Array(Event Player, Health(Event Player) > 199), Custom String("DAMAGE BOOST"), Null, Null, Left, 2, Blue,
			White, White, Visible To and String, Default Visibility);
		Event Player.pharahDamageBoostHud = Last Text ID;
	}
}

rule("PHARAH damage boost")
{
	event
	{
		Ongoing - Each Player;
		All;
		Pharah;
	}

	conditions
	{
		Is Game In Progress == True;
		Global.heroOfTheRound == Hero(Pharah);
		Health(Event Player) > 199;
		Event Player.pharahHeal == True;
	}

	actions
	{
		Event Player.pharahHeal = False;
		Event Player.pharahDamageBoost = True;
		Set Damage Dealt(Event Player, 130);
		Stop All Heal Over Time(Event Player);
		Wait(0.016, Ignore Condition);
	}
}

rule("PHARAH healing")
{
	event
	{
		Ongoing - Each Player;
		All;
		Pharah;
	}

	conditions
	{
		Is Game In Progress == True;
		Global.heroOfTheRound == Hero(Pharah);
		Health(Event Player) < 200;
	}

	actions
	{
		Event Player.pharahDamageBoost = False;
		Wait(0.500, Ignore Condition);
		Event Player.pharahHeal = True;
		Set Damage Dealt(Event Player, 100);
		Start Heal Over Time(Event Player, Null, Global.roundTimer, 50);
	}
}

rule("PHARAH dead")
{
	event
	{
		Player Died;
		All;
		All;
	}

	conditions
	{
		Is Game In Progress == True;
		Global.heroOfTheRound == Hero(Pharah);
	}

	actions
	{
		Wait(0.032, Ignore Condition);
		Event Player.pharahHeal = False;
		Event Player.pharahDamageBoost = False;
		Wait(0.032, Ignore Condition);
		Destroy Effect(Event Player.pharahHealEffect);
		Wait(0.032, Ignore Condition);
		Destroy Effect(Event Player.pharahDamageBoostEffect);
		Stop All Heal Over Time(Event Player);
		Set Damage Dealt(Event Player, 100);
		Destroy HUD Text(Event Player.pharahHealHud);
		Destroy HUD Text(Event Player.pharahDamageBoostHud);
	}
}

rule("PHARAH end of the round {EACH PLAYER}")
{
	event
	{
		Ongoing - Each Player;
		All;
		All;
	}

	conditions
	{
		Is Game In Progress == True;
		Global.heroOfTheRound != Hero(Pharah);
	}

	actions
	{
		Event Player.pharahHeal = False;
		Event Player.pharahDamageBoost = False;
		Destroy Effect(Event Player.pharahHealEffect);
		Destroy Effect(Event Player.pharahDamageBoostEffect);
		Destroy HUD Text(Event Player.pharahHealHud);
		Destroy HUD Text(Event Player.pharahDamageBoostHud);
		Stop All Heal Over Time(Event Player);
		Set Damage Dealt(Event Player, 100);
	}
}

rule("ROADHOG init global")
{
	event
	{
		Ongoing - Global;
	}

	conditions
	{
		Is Game In Progress == True;
		Global.heroOfTheRound == Hero(Roadhog);
	}

	actions
	{
		Global.roadhogHoleRadius = 7;
		Global.roadhogHoleEffects = Empty Array;
		Create Effect(All Players(All Teams), Light Shaft, Red, Vector(0, 0, 0), Global.roadhogHoleRadius, Visible To Position and Radius);
		Modify Global Variable(roadhogHoleEffects, Append To Array, Last Created Entity);
		Create Effect(All Players(All Teams), Light Shaft, Red, Vector(0, 0, 0), Global.roadhogHoleRadius, Visible To Position and Radius);
		Modify Global Variable(roadhogHoleEffects, Append To Array, Last Created Entity);
		Create Effect(All Players(All Teams), Light Shaft, Red, Vector(0, 0, 0), Global.roadhogHoleRadius, Visible To Position and Radius);
		Modify Global Variable(roadhogHoleEffects, Append To Array, Last Created Entity);
		Create Effect(All Players(All Teams), Ring, White, Vector(0, 0, 0), Global.roadhogHoleRadius, Visible To Position and Radius);
		Modify Global Variable(roadhogHoleEffects, Append To Array, Last Created Entity);
		Create Effect(All Players(All Teams), Ring, White, Vector(0, 0, 0), Global.roadhogHoleRadius, Visible To Position and Radius);
		Modify Global Variable(roadhogHoleEffects, Append To Array, Last Created Entity);
		Create Effect(All Players(All Teams), Ring, White, Vector(0, 0, 0), Global.roadhogHoleRadius, Visible To Position and Radius);
		Modify Global Variable(roadhogHoleEffects, Append To Array, Last Created Entity);
		Create Effect(All Players(All Teams), Light Shaft, Red, Vector(0, 0, 0), Global.roadhogHoleRadius, Visible To Position and Radius);
		Modify Global Variable(roadhogHoleEffects, Append To Array, Last Created Entity);
		Create Effect(All Players(All Teams), Light Shaft, Red, Vector(0, 0, 0), Global.roadhogHoleRadius, Visible To Position and Radius);
		Modify Global Variable(roadhogHoleEffects, Append To Array, Last Created Entity);
		Chase Global Variable Over Time(roadhogHoleRadius, 9, 60, None);
		Modify Global Variable(minigameStringTitles, Append To Array, Custom String("{0} {1} HOOKS 1 HOLE {0}", Hero Icon String(Hero(
			Roadhog)), Count Of(Global.playersStartOfTheRound)));
		Global.minigameStringTitles[Index Of Array Value(Global.heroList, Hero(Roadhog))] = Custom String("{0} {1} HOOKS 1 HOLE {0}",
			Hero Icon String(Hero(Roadhog)), Count Of(Global.playersStartOfTheRound));
	}
}

rule("ROADHOG init player")
{
	event
	{
		Ongoing - Each Player;
		All;
		All;
	}

	conditions
	{
		Is Game In Progress == True;
		Global.heroOfTheRound == Hero(Roadhog);
	}

	actions
	{
		Start Forcing Throttle(Event Player, 0, 0, 0, 0, 0, 0);
		Set Gravity(Event Player, 0);
		disabled While(Y Component Of(Position Of(Event Player)) < 9);
		Teleport(Event Player, 10 * Normalize(Vector(Random Real(-1, 1), 0, Random Real(-1, 1))));
		While(Distance Between(Position Of(Event Player) * Vector(1, 0, 1), Vector(0, 10, 0) * Vector(1, 0, 1))
			<= Global.roadhogHoleRadius);
			Teleport(Event Player, 10 * Normalize(Vector(Random Real(-1, 1), 0, Random Real(-1, 1))));
			Wait(0.175, Ignore Condition);
		End;
		Disallow Button(Event Player, Ability 1);
		Event Player.roadhogYanked = True;
		Wait(0.512, Ignore Condition);
		While(Y Component Of(Position Of(Event Player)) < 9);
			Teleport(Event Player, Position Of(Event Player) + Vector(0, 10, 0));
			Wait(0.175, Ignore Condition);
			While(Y Component Of(Position Of(Event Player)) >= 10.500);
				Teleport(Event Player, Vector(X Component Of(Position Of(Event Player)), 10, Z Component Of(Position Of(Event Player))));
				Wait(0.175, Ignore Condition);
			End;
		End;
		Allow Button(Event Player, Ability 1);
		Set Gravity(Event Player, 0);
		Apply Impulse(Event Player, Down, 0.001, To World, Cancel Contrary Motion);
		Apply Impulse(Event Player, Up, 0.001, To World, Cancel Contrary Motion);
		Apply Impulse(Event Player, Backward, 0.001, To World, Cancel Contrary Motion);
		Apply Impulse(Event Player, Forward, 0.001, To World, Cancel Contrary Motion);
		Apply Impulse(Event Player, Right, 0.001, To World, Cancel Contrary Motion);
		Apply Impulse(Event Player, Left, 0.001, To World, Cancel Contrary Motion);
		Event Player.roadhogYanked = False;
		Event Player.roadhogFalling = False;
		Wait(1.500, Ignore Condition);
		Stop Forcing Throttle(Event Player);
	}
}

rule("ROADHOG Hole gravity")
{
	event
	{
		Ongoing - Each Player;
		All;
		Roadhog;
	}

	conditions
	{
		disabled Distance Between(Vector(X Component Of(Position Of(Event Player)), 10, Z Component Of(Position Of(Event Player))), Vector(0, 10,
			0)) <= Global.roadhogHoleRadius;
		Distance Between(Position Of(Event Player) * Vector(1, 0, 1), Vector(0, 10, 0) * Vector(1, 0, 1)) <= Global.roadhogHoleRadius;
		Event Player.roadhogYanked == False;
		Is Game In Progress == True;
		Global.heroOfTheRound == Hero(Roadhog);
		Global.roundTimer <= 58.500;
	}

	actions
	{
		Event Player.roadhogFalling = True;
		Wait(0.250, Ignore Condition);
		Event Player.roadhogPostion = Position Of(Event Player);
		disabled While(Is Alive(Event Player) && Event Player.roadhogYanked == False && Hero Of(Event Player) == Hero(Roadhog));
		While(Is Alive(Event Player) && Hero Of(Event Player) == Hero(Roadhog));
			Event Player.roadhogPostion = Event Player.roadhogPostion - Vector(0, 0.500, 0);
			Teleport(Event Player, Event Player.roadhogPostion);
			Wait(0.016, Ignore Condition);
		End;
		Event Player.roadhogFalling = False;
	}
}

rule("ROADHOG water")
{
	event
	{
		Ongoing - Each Player;
		All;
		Roadhog;
	}

	conditions
	{
		disabled Distance Between(Vector(X Component Of(Position Of(Event Player)), 10, Z Component Of(Position Of(Event Player))), Vector(0, 10,
			0)) <= Global.roadhogHoleRadius;
		disabled Distance Between(Position Of(Event Player) * Vector(1, 0, 1), Vector(0, 10, 0) * Vector(1, 0, 1)) <= Global.roadhogHoleRadius;
		Event Player.roadhogYanked == False;
		Is Game In Progress == True;
		Global.heroOfTheRound == Hero(Roadhog);
		Y Component Of(Ray Cast Hit Position(Position Of(Event Player), Vector(X Component Of(Position Of(Event Player)), -200,
			Z Component Of(Position Of(Event Player))), Null, All Players(All Teams), True)) <= -1;
		Global.roundTimer <= 58.500;
	}

	actions
	{
		Event Player.roadhogFalling = True;
		Wait(0.250, Ignore Condition);
		Event Player.roadhogPostion = Position Of(Event Player);
		While(Is Alive(Event Player) && Event Player.roadhogYanked == False && Hero Of(Event Player) == Hero(Roadhog));
			Event Player.roadhogPostion = Event Player.roadhogPostion - Vector(0, 0.500, 0);
			Teleport(Event Player, Event Player.roadhogPostion);
			Wait(0.016, Ignore Condition);
		End;
		Small Message(Event Player, Custom String("{0}", Random Value In Array(Array(Custom String("sleep with the fishes"), Custom String(
			"be water my friend")))));
		Event Player.roadhogFalling = False;
	}
}

rule("ROADHOG Yank")
{
	event
	{
		Player Dealt Damage;
		All;
		Roadhog;
	}

	conditions
	{
		Event Ability == Button(Ability 1);
		Is Game In Progress == True;
		Global.heroOfTheRound == Hero(Roadhog);
	}

	actions
	{
		While(Is Using Ability 1(Attacker));
			Wait(0.016, Ignore Condition);
			Victim.roadhogYanked = True;
			Disallow Button(Event Player, Ability 1);
		End;
		Wait(0.128, Ignore Condition);
		Victim.roadhogYanked = False;
		Allow Button(Event Player, Ability 1);
	}
}

rule("ROADHOG fix position")
{
	event
	{
		Ongoing - Each Player;
		All;
		Roadhog;
	}

	conditions
	{
		Is Game In Progress == True;
		Global.heroOfTheRound == Hero(Roadhog);
		Is Alive(Event Player) == True;
		(Y Component Of(Position Of(Event Player)) >= 9.500 && Y Component Of(Position Of(Event Player)) <= 10.500) == False;
		Global.roundTimer <= 57.500;
		Event Player.roadhogFalling == False;
	}

	actions
	{
		disabled Small Message(Event Player, Custom String("preparing fix..."));
		Wait(2.500, Abort When False);
		Teleport(Event Player, Vector(X Component Of(Position Of(Event Player)), 10, Z Component Of(Position Of(Event Player))));
		disabled Small Message(Event Player, Custom String("fixing..."));
	}
}

rule("ROADHOG end of the round")
{
	event
	{
		Ongoing - Each Player;
		All;
		All;
	}

	conditions
	{
		Is Game In Progress == True;
		Global.heroOfTheRound != Hero(Roadhog);
	}

	actions
	{
		Set Gravity(Event Player, 100);
		For Global Variable(roadhogHoleEffectsIt, 0, Count Of(Global.roadhogHoleEffects), 1);
			Destroy Effect(Global.roadhogHoleEffects[Global.roadhogHoleEffectsIt]);
		End;
		Event Player.roadhogYanked = True;
	}
}

rule("SIGMA init player")
{
	event
	{
		Ongoing - Each Player;
		All;
		Sigma;
	}

	conditions
	{
		Is Game In Progress == True;
		Global.heroOfTheRound == Hero(Sigma);
	}

	actions
	{
		Start Damage Modification(Event Player, Event Player, 0, Receivers Damagers and Damage Percent);
		Event Player.sigmaCatch = False;
	}
}

rule("SIGMA Ult damage off")
{
	event
	{
		Ongoing - Each Player;
		All;
		Sigma;
	}

	conditions
	{
		Is Using Ultimate(Event Player) == True;
		Is Game In Progress == True;
		Global.heroOfTheRound == Hero(Sigma);
	}

	actions
	{
		Set Damage Dealt(Event Player, 0);
	}
}

rule("SIGMA no Ult damage on")
{
	event
	{
		Ongoing - Each Player;
		All;
		Sigma;
	}

	conditions
	{
		Is Using Ultimate(Event Player) == False;
		Is Game In Progress == True;
		Global.heroOfTheRound == Hero(Sigma);
	}

	actions
	{
		Set Damage Dealt(Event Player, 100);
	}
}

rule("SIGMA Ult stunt")
{
	event
	{
		Player Dealt Knockback;
		All;
		All;
	}

	conditions
	{
		Is Using Ultimate(Event Player) == True;
		Is Game In Progress == True;
		Global.heroOfTheRound == Hero(Sigma);
	}

	actions
	{
		Set Status(Victim, Null, Stunned, 5);
	}
}

rule("SIGMA grasp cooldown")
{
	event
	{
		Ongoing - Each Player;
		All;
		Sigma;
	}

	conditions
	{
		Is Using Ability 1(Event Player) == True;
		Is Game In Progress == True;
		Global.heroOfTheRound == Hero(Sigma);
	}

	actions
	{
		Event Player.sigmaUsingGrasp = True;
		Set Damage Received(Event Player, 1);
		Wait(0.125, Ignore Condition);
		Cancel Primary Action(Event Player);
		Set Damage Received(Event Player, 100);
		While(Is Using Ability 1(Event Player));
			Wait(0.032, Ignore Condition);
		End;
		If(Event Player.sigmaCatch == True);
			Set Ability Cooldown(Event Player, Button(Ability 1), 2);
		Else;
			Set Ability Cooldown(Event Player, Button(Ability 1), 10);
		End;
		Event Player.sigmaUsingGrasp = False;
		Event Player.sigmaCatch = False;
	}
}

rule("SIGMA catch")
{
	event
	{
		Player Dealt Damage;
		All;
		Sigma;
	}

	conditions
	{
		Is In View Angle(Victim, Attacker, 45) == True;
		Victim.sigmaUsingGrasp == True;
		Is Game In Progress == True;
		Global.heroOfTheRound == Hero(Sigma);
	}

	actions
	{
		Victim.sigmaCatch = True;
		Kill(Attacker, Victim);
		Small Message(Array(Victim, Attacker), Custom String("rock catched {0} by {1}", Custom String("{0}{1}", Ability Icon String(Hero(
			Sigma), Button(Ability 2)), Ability Icon String(Hero(Sigma), Button(Ability 1))), Victim));
	}
}

rule("SIGMA no catch")
{
	event
	{
		Player Dealt Damage;
		All;
		Sigma;
	}

	conditions
	{
		Is In View Angle(Victim, Attacker, 45) == False;
		Victim.sigmaUsingGrasp == False;
		Is Game In Progress == True;
		Global.heroOfTheRound == Hero(Sigma);
	}

	actions
	{
		Event Player.sigmaCatch = False;
		Kill(Victim, Attacker);
	}
}

rule("SIGMA kill")
{
	event
	{
		Player Dealt Final Blow;
		All;
		Sigma;
	}

	conditions
	{
		Is Game In Progress == True;
		Global.heroOfTheRound == Hero(Sigma);
	}

	actions
	{
		Play Effect(All Players(All Teams), Good Pickup Effect, Green, Event Player, 1);
		Modify Player Score(Event Player, 1);
		Small Message(Event Player, Custom String("+1 point with {0} {1}", Hero Icon String(Hero Of(Event Player)), Hero Of(
			Event Player)));
		Create HUD Text(All Players(All Teams), Hero Icon String(Hero Of(Event Player)), Event Player, Custom String("+1 point"), Right,
			-1 + Global.pointfeedHudId, Orange, White, Orange, Visible To, Default Visibility);
		Modify Global Variable(pointfeedHud, Append To Array, Last Text ID);
		Global.pointfeedHudTimes[Count Of(Global.pointfeedHud) - 1] = 3.744;
		Global.pointfeedHudId -= 0.010;
	}
}

rule("SIGMA end of the round")
{
	event
	{
		Ongoing - Each Player;
		All;
		Sigma;
	}

	conditions
	{
		Is Game In Progress == True;
		Global.heroOfTheRound != Hero(Sigma);
	}

	actions
	{
		Set Damage Dealt(Event Player, 100);
		Start Damage Modification(Event Player, Event Player, 100, Receivers Damagers and Damage Percent);
	}
}

rule("SOLDIER init global")
{
	event
	{
		Ongoing - Global;
	}

	conditions
	{
		Is Game In Progress == True;
		Global.heroOfTheRound == Hero(Soldier: 76);
	}

	actions
	{
		Global.soldierObjectiveEffects = Empty Array;
		Global.soldierObjectiveIcons = Empty Array;
		Global.soldierObjectivePos = Array(Vector(-18, 0, -18), Vector(-18, 0, 0), Vector(-18, 0, 18), Vector(0, 0, -18), Vector(0, 0, 18),
			Vector(18, 0, -18), Vector(18, 0, 0), Vector(18, 0, 18));
		Global.soldierObjectivePos = Array Slice(Randomized Array(Global.soldierObjectivePos), 0, 5);
		Create Effect(Filtered Array(All Players(All Teams), Current Array Element.soldierPoints == 0), Light Shaft, Blue,
			Global.soldierObjectivePos[0], 1.500, Visible To Position and Radius);
		Modify Global Variable(soldierObjectiveEffects, Append To Array, Last Created Entity);
		Create Effect(Filtered Array(All Players(All Teams), Current Array Element.soldierPoints == 0), Light Shaft, Blue,
			Global.soldierObjectivePos[0], 1.500, Visible To Position and Radius);
		Modify Global Variable(soldierObjectiveEffects, Append To Array, Last Created Entity);
		Create Effect(Filtered Array(All Players(All Teams), Current Array Element.soldierPoints == 0), Light Shaft, Blue,
			Global.soldierObjectivePos[0], 1.500, Visible To Position and Radius);
		Modify Global Variable(soldierObjectiveEffects, Append To Array, Last Created Entity);
		Create Effect(Filtered Array(All Players(All Teams), Current Array Element.soldierPoints == 1), Light Shaft, Blue,
			Global.soldierObjectivePos[1], 1.500, Visible To Position and Radius);
		Modify Global Variable(soldierObjectiveEffects, Append To Array, Last Created Entity);
		Create Effect(Filtered Array(All Players(All Teams), Current Array Element.soldierPoints == 1), Light Shaft, Blue,
			Global.soldierObjectivePos[1], 1.500, Visible To Position and Radius);
		Modify Global Variable(soldierObjectiveEffects, Append To Array, Last Created Entity);
		Create Effect(Filtered Array(All Players(All Teams), Current Array Element.soldierPoints == 1), Light Shaft, Blue,
			Global.soldierObjectivePos[1], 1.500, Visible To Position and Radius);
		Modify Global Variable(soldierObjectiveEffects, Append To Array, Last Created Entity);
		Create Effect(Filtered Array(All Players(All Teams), Current Array Element.soldierPoints == 2), Light Shaft, Blue,
			Global.soldierObjectivePos[2], 1.500, Visible To Position and Radius);
		Modify Global Variable(soldierObjectiveEffects, Append To Array, Last Created Entity);
		Create Effect(Filtered Array(All Players(All Teams), Current Array Element.soldierPoints == 2), Light Shaft, Blue,
			Global.soldierObjectivePos[2], 1.500, Visible To Position and Radius);
		Modify Global Variable(soldierObjectiveEffects, Append To Array, Last Created Entity);
		Create Effect(Filtered Array(All Players(All Teams), Current Array Element.soldierPoints == 2), Light Shaft, Blue,
			Global.soldierObjectivePos[2], 1.500, Visible To Position and Radius);
		Modify Global Variable(soldierObjectiveEffects, Append To Array, Last Created Entity);
		Create Effect(Filtered Array(All Players(All Teams), Current Array Element.soldierPoints == 3), Light Shaft, Blue,
			Global.soldierObjectivePos[3], 1.500, Visible To Position and Radius);
		Modify Global Variable(soldierObjectiveEffects, Append To Array, Last Created Entity);
		Create Effect(Filtered Array(All Players(All Teams), Current Array Element.soldierPoints == 3), Light Shaft, Blue,
			Global.soldierObjectivePos[3], 1.500, Visible To Position and Radius);
		Modify Global Variable(soldierObjectiveEffects, Append To Array, Last Created Entity);
		Create Effect(Filtered Array(All Players(All Teams), Current Array Element.soldierPoints == 3), Light Shaft, Blue,
			Global.soldierObjectivePos[3], 1.500, Visible To Position and Radius);
		Modify Global Variable(soldierObjectiveEffects, Append To Array, Last Created Entity);
		Create Effect(Filtered Array(All Players(All Teams), Current Array Element.soldierPoints == 4), Light Shaft, Blue,
			Global.soldierObjectivePos[4], 1.500, Visible To Position and Radius);
		Modify Global Variable(soldierObjectiveEffects, Append To Array, Last Created Entity);
		Create Effect(Filtered Array(All Players(All Teams), Current Array Element.soldierPoints == 4), Light Shaft, Blue,
			Global.soldierObjectivePos[4], 1.500, Visible To Position and Radius);
		Modify Global Variable(soldierObjectiveEffects, Append To Array, Last Created Entity);
		Create Effect(Filtered Array(All Players(All Teams), Current Array Element.soldierPoints == 4), Light Shaft, Blue,
			Global.soldierObjectivePos[4], 1.500, Visible To Position and Radius);
		Modify Global Variable(soldierObjectiveEffects, Append To Array, Last Created Entity);
		Wait(0.016, Ignore Condition);
		Create Icon(Filtered Array(All Players(All Teams), Current Array Element.soldierPoints == 0),
			Global.soldierObjectivePos[0] + Vector(0, 1.500, 0), Flag, Visible To and Position, Blue, True);
		Modify Global Variable(soldierObjectiveIcons, Append To Array, Last Created Entity);
		Create Icon(Filtered Array(All Players(All Teams), Current Array Element.soldierPoints == 1),
			Global.soldierObjectivePos[1] + Vector(0, 1.500, 0), Flag, Visible To and Position, Blue, True);
		Modify Global Variable(soldierObjectiveIcons, Append To Array, Last Created Entity);
		Create Icon(Filtered Array(All Players(All Teams), Current Array Element.soldierPoints == 2),
			Global.soldierObjectivePos[2] + Vector(0, 1.500, 0), Flag, Visible To and Position, Blue, True);
		Modify Global Variable(soldierObjectiveIcons, Append To Array, Last Created Entity);
		Create Icon(Filtered Array(All Players(All Teams), Current Array Element.soldierPoints == 3),
			Global.soldierObjectivePos[3] + Vector(0, 1.500, 0), Flag, Visible To and Position, Blue, True);
		Modify Global Variable(soldierObjectiveIcons, Append To Array, Last Created Entity);
		Create Icon(Filtered Array(All Players(All Teams), Current Array Element.soldierPoints == 4),
			Global.soldierObjectivePos[4] + Vector(0, 1.500, 0), Flag, Visible To and Position, Blue, True);
		Modify Global Variable(soldierObjectiveIcons, Append To Array, Last Created Entity);
	}
}

rule("SOLDIER init & phased out")
{
	event
	{
		Ongoing - Each Player;
		All;
		Soldier: 76;
	}

	conditions
	{
		Is Game In Progress == True;
		Global.heroOfTheRound == Hero(Soldier: 76);
	}

	actions
	{
		Teleport(Event Player, Vector(0, 0, 0));
		Set Facing(Event Player, Direction Towards(Eye Position(Event Player), Global.soldierObjectivePos[0]), To World);
		Set Status(Event Player, Null, Phased Out, 60);
		Event Player.soldierPoints = 0;
		Wait(0.256, Ignore Condition);
		Create HUD Text(All Players(All Teams), Null, Null, Custom String("{0} : {1} / 5", Event Player, Event Player.soldierPoints), Left,
			(Event Player.soldierPoints + 10) * -1, White, White, Blue, Visible To Sort Order and String, Default Visibility);
		Event Player.soldierPointsHud = Last Text ID;
		Teleport(Event Player, Vector(0, 0, 0));
		Set Facing(Event Player, Direction Towards(Eye Position(Event Player), Global.soldierObjectivePos[0]), To World);
		Wait(0.256, Ignore Condition);
		Teleport(Event Player, Vector(0, 0, 0));
		Set Facing(Event Player, Direction Towards(Eye Position(Event Player), Global.soldierObjectivePos[0]), To World);
	}
}

rule("SOLDIER sprint")
{
	event
	{
		Ongoing - Each Player;
		All;
		Soldier: 76;
	}

	conditions
	{
		Is Game In Progress == True;
		Is Using Ability 1(Event Player) == True;
		Horizontal Speed Of(Event Player) > 5;
		Global.heroOfTheRound == Hero(Soldier: 76);
	}

	actions
	{
		Set Status(Event Player, Null, Phased Out, 60);
		Event Player.soldierSprint += 1;
		Set Move Speed(Event Player, Event Player.soldierSprint);
		Wait(0.100, Ignore Condition);
		Loop If Condition Is True;
		Event Player.soldierSprint = 100;
		Set Move Speed(Event Player, 100);
	}
}

rule("SOLDIER off phased out and speed")
{
	event
	{
		Ongoing - Each Player;
		All;
		All;
	}

	conditions
	{
		Is Game In Progress == True;
		Global.heroOfTheRound != Hero(Soldier: 76);
		Hero Of(Event Player) != Hero(Soldier: 76);
	}

	actions
	{
		Clear Status(Event Player, Phased Out);
		Set Move Speed(Event Player, 100);
	}
}

rule("SOLDIER point")
{
	event
	{
		Ongoing - Each Player;
		All;
		Soldier: 76;
	}

	conditions
	{
		Is Game In Progress == True;
		Is Alive(Event Player) == True;
		Global.heroOfTheRound == Hero(Soldier: 76);
		Event Player.soldierPoints < 5;
	}

	actions
	{
		If(Distance Between(Event Player, Global.soldierObjectivePos[Event Player.soldierPoints]) <= 1.550 && True);
			Modify Player Score(Event Player, 1);
			Small Message(Event Player, Custom String("+1 point with {0} {1}", Hero Icon String(Hero Of(Event Player)), Hero Of(
				Event Player)));
			Event Player.soldierPoints += 1;
			Play Effect(All Players(All Teams), Good Pickup Effect, Blue, Event Player, 1);
			Play Effect(Event Player, Buff Explosion Sound, Blue, Event Player, 100);
			Create HUD Text(All Players(All Teams), Hero Icon String(Hero Of(Event Player)), Event Player, Custom String("+1 point"), Right,
				-1 + Global.pointfeedHudId, Orange, White, Orange, Visible To, Default Visibility);
			Modify Global Variable(pointfeedHud, Append To Array, Last Text ID);
			Global.pointfeedHudTimes[Count Of(Global.pointfeedHud) - 1] = 3.744;
			Global.pointfeedHudId -= 0.010;
		End;
		Wait(0.112, Ignore Condition);
		Loop If Condition Is True;
	}
}

rule("SOLDIER winner")
{
	event
	{
		Ongoing - Each Player;
		All;
		Soldier: 76;
	}

	conditions
	{
		Is Game In Progress == True;
		Global.heroOfTheRound == Hero(Soldier: 76);
		Event Player.soldierPoints >= 5;
	}

	actions
	{
		Global.roundTimer = 0.032;
	}
}

rule("SOLDIER end of the round {GLOBAL}")
{
	event
	{
		Ongoing - Global;
	}

	conditions
	{
		Is Game In Progress == True;
		Global.heroOfTheRound != Hero(Soldier: 76);
	}

	actions
	{
		Global.soldierDestructorIt = 0;
		For Global Variable(soldierDestructorIt, 0, Count Of(Global.soldierObjectiveEffects), 1);
			Destroy Effect(Global.soldierObjectiveEffects[Global.soldierDestructorIt]);
			Destroy Icon(Global.soldierObjectiveIcons[Global.soldierDestructorIt]);
		End;
	}
}

rule("SOLDIER end of the round {EACH PLAYER}")
{
	event
	{
		Ongoing - Each Player;
		All;
		All;
	}

	conditions
	{
		Is Game In Progress == True;
		Global.heroOfTheRound != Hero(Soldier: 76);
	}

	actions
	{
		Event Player.soldierPoints = 0;
		Destroy HUD Text(Event Player.soldierPointsHud);
	}
}

rule("SOMBRA hack to kill")
{
	event
	{
		Ongoing - Each Player;
		All;
		Sombra;
	}

	conditions
	{
		Has Status(Event Player, Hacked) == True;
		Is Game In Progress == True;
		Global.heroOfTheRound == Hero(Sombra);
	}

	actions
	{
		Teleport(Event Player, Vector(0, -500, 0));
	}
}

rule("SOMBRA limit stealth duration")
{
	event
	{
		Ongoing - Each Player;
		All;
		Sombra;
	}

	conditions
	{
		Is Using Ability 1(Event Player) == True;
		Is Game In Progress == True;
		Global.heroOfTheRound == Hero(Sombra);
	}

	actions
	{
		Wait(6, Abort When False);
		Press Button(Event Player, Ability 1);
		Small Message(Event Player, Custom String("Maximum Stealth Duration Reached"));
	}
}

rule("TRACER create crown")
{
	event
	{
		Ongoing - Global;
	}

	conditions
	{
		Is Game In Progress == True;
		Global.heroOfTheRound == Hero(Tracer);
		Global.tracerQueen == Null;
	}

	actions
	{
		Destroy Effect(Global.crownEffect);
		Global.crownPos = Vector(0, 1.500, 0);
		Create Effect(All Players(All Teams), Good Aura, Yellow, Global.crownPos, 1, Visible To Position and Radius);
		Global.crownEffect = Last Created Entity;
	}
}

rule("TRACER stun & steal")
{
	event
	{
		Player Dealt Damage;
		All;
		Tracer;
	}

	conditions
	{
		Is Game In Progress == True;
		Global.heroOfTheRound == Hero(Tracer);
	}

	actions
	{
		If(Global.tracerQueen == Attacker);
			Set Status(Victim, Event Player, Stunned, 1);
		End;
		If(Global.tracerQueen == Victim);
			Set Status(Victim, Event Player, Stunned, 0.750);
			Play Effect(All Players(All Teams), Buff Impact Sound, Yellow, Event Player, 50);
			Global.tracerQueen = Attacker;
			Global.crownPos = Attacker;
		End;
	}
}

rule("TRACER init queen")
{
	event
	{
		Ongoing - Each Player;
		All;
		All;
	}

	conditions
	{
		Is Game In Progress == True;
		Global.heroOfTheRound == Hero(Tracer);
	}

	actions
	{
		Event Player.queenPoints = 0;
		Wait(0.256, Ignore Condition);
		Create HUD Text(All Players(All Teams), Null, Null, Custom String("{0} : {1} / 10", Event Player, Event Player.queenPoints), Left,
			(Event Player.queenPoints + 10) * -1, White, White, Yellow, Visible To Sort Order and String, Default Visibility);
		Event Player.queenPointsHud = Last Text ID;
		Set Gravity(Event Player, 100);
	}
}

rule("TRACER first queen")
{
	event
	{
		Ongoing - Each Player;
		All;
		All;
	}

	conditions
	{
		Is Game In Progress == True;
		Is Alive(Event Player) == True;
		Distance Between(Event Player, Position Of(Global.crownEffect)) <= 1.500;
		Global.heroOfTheRound == Hero(Tracer);
		Global.tracerQueen == Null;
	}

	actions
	{
		Wait(0.064, Abort When False);
		Play Effect(Event Player, Buff Impact Sound, Yellow, Event Player, 50);
		Global.tracerQueen = Event Player;
		Global.crownPos = Event Player;
	}
}

rule("TRACER is queen = points, gravity")
{
	event
	{
		Ongoing - Each Player;
		All;
		Tracer;
	}

	conditions
	{
		Is Game In Progress == True;
		Is Alive(Event Player) == True;
		Global.heroOfTheRound == Hero(Tracer);
		Global.tracerQueen == Event Player;
	}

	actions
	{
		Set Gravity(Event Player, 500);
		Wait(1, Abort When False);
		Event Player.queenPoints += 1;
		Play Effect(All Players(All Teams), Good Pickup Effect, Yellow, Event Player, 1);
		Play Effect(All Players(All Teams), Buff Explosion Sound, Yellow, Event Player, 50);
		Loop If Condition Is True;
	}
}

rule("TRACER is not queen = points, gravity")
{
	event
	{
		Ongoing - Each Player;
		All;
		Tracer;
	}

	conditions
	{
		Is Game In Progress == True;
		Is Alive(Event Player) == True;
		Global.heroOfTheRound == Hero(Tracer);
		Global.tracerQueen != Event Player;
	}

	actions
	{
		Set Gravity(Event Player, 100);
	}
}

rule("TRACER queen winner")
{
	event
	{
		Ongoing - Each Player;
		All;
		Tracer;
	}

	conditions
	{
		Is Game In Progress == True;
		Global.heroOfTheRound == Hero(Tracer);
		Global.tracerQueen == Event Player;
		Event Player.queenPoints >= 10;
	}

	actions
	{
		disabled Modify Player Score(Event Player, Count Of(Global.playersStartOfTheRound));
		disabled Small Message(Event Player, Custom String("+{0} with {1} {2}", Custom String("{0} {1}", Count Of(Global.playersStartOfTheRound),
			Count Of(Global.playersStartOfTheRound) > 1 ? Custom String("points") : Custom String("point")), Hero Icon String(Hero Of(
			Event Player)), Hero Of(Event Player)));
		disabled Create HUD Text(All Players(All Teams), Hero Icon String(Hero Of(Event Player)), Event Player, Custom String("+{1}", Null,
			Custom String("{0} {1}", Count Of(Global.playersStartOfTheRound), Count Of(Global.playersStartOfTheRound) > 1 ? Custom String(
			"points") : Custom String("point"))), Right, -1 + Global.pointfeedHudId, Orange, White, Orange, Visible To,
			Default Visibility);
		Modify Player Score(Event Player, Count Of(Global.playersStartOfTheRound) - 1);
		Small Message(Event Player, Custom String("+{0} with {1} {2}", Custom String("{0} {1}", Count Of(Global.playersStartOfTheRound),
			Count Of(Global.playersStartOfTheRound) - 1 > 1 ? Custom String("points") : Custom String("point")), Hero Icon String(Hero Of(
			Event Player)), Hero Of(Event Player)));
		Create HUD Text(All Players(All Teams), Hero Icon String(Hero Of(Event Player)), Event Player, Custom String("+{1}", Null,
			Custom String("{0} {1}", Count Of(Global.playersStartOfTheRound) - 1, Count Of(Global.playersStartOfTheRound)
			- 1 > 1 ? Custom String("points") : Custom String("point"))), Right, -1 + Global.pointfeedHudId, Orange, White, Orange,
			Visible To, Default Visibility);
		Modify Global Variable(pointfeedHud, Append To Array, Last Text ID);
		Global.pointfeedHudTimes[Count Of(Global.pointfeedHud) - 1] = 3.744;
		Global.pointfeedHudId -= 0.010;
		Global.roundTimer = 0.032;
	}
}

rule("TRACER dead queen")
{
	event
	{
		Player Died;
		All;
		All;
	}

	conditions
	{
		Is Game In Progress == True;
		Global.heroOfTheRound == Hero(Tracer);
		Global.tracerQueen == Event Player;
	}

	actions
	{
		Global.tracerQueen = Null;
		Global.crownPos = Vector(0, 1.500, 0);
	}
}

rule("TRACER leaver queen")
{
	event
	{
		Player Left Match;
		All;
		All;
	}

	conditions
	{
		Is Game In Progress == True;
		Global.heroOfTheRound == Hero(Tracer);
		Global.tracerQueen == Event Player;
	}

	actions
	{
		Global.tracerQueen = Null;
		Global.crownPos = Vector(0, 1.500, 0);
	}
}

rule("TRACER destroy crown")
{
	event
	{
		Ongoing - Global;
	}

	conditions
	{
		Is Game In Progress == True;
		Global.heroOfTheRound != Hero(Tracer);
	}

	actions
	{
		Destroy Effect(Global.crownEffect[0]);
		Global.tracerQueen = Null;
	}
}

rule("TRACER queen end of the round")
{
	event
	{
		Ongoing - Each Player;
		All;
		All;
	}

	conditions
	{
		Is Game In Progress == True;
		Global.heroOfTheRound != Hero(Tracer);
	}

	actions
	{
		Event Player.queenPoints = 0;
		Destroy HUD Text(Event Player.queenPointsHud);
		Global.tracerQueen = Null;
		Set Gravity(Event Player, 100);
	}
}

rule("WINSTOM rage")
{
	event
	{
		Ongoing - Each Player;
		All;
		Winston;
	}

	conditions
	{
		Is Game In Progress == True;
		Is Alive(Event Player) == True;
		Global.heroOfTheRound == Hero(Winston);
		Is Using Ultimate(Event Player) == False;
	}

	actions
	{
		Press Button(Event Player, Ultimate);
		Wait(0.016, Ignore Condition);
		Loop If Condition Is True;
	}
}

rule("WINSTOM jump cooldown")
{
	event
	{
		Ongoing - Each Player;
		All;
		Winston;
	}

	conditions
	{
		Is Game In Progress == True;
		Is Alive(Event Player) == True;
		Global.heroOfTheRound == Hero(Winston);
		Is Using Ability 1(Event Player) == True;
	}

	actions
	{
		Wait(0.032, Ignore Condition);
		Set Ability Cooldown(Event Player, Button(Ability 1), 12);
	}
}

rule("WINSTON kill")
{
	event
	{
		Player Dealt Final Blow;
		All;
		Winston;
	}

	conditions
	{
		Is Game In Progress == True;
		Global.heroOfTheRound == Hero(Winston);
	}

	actions
	{
		Play Effect(All Players(All Teams), Good Pickup Effect, Green, Event Player, 1);
		Modify Player Score(Event Player, 1);
		Small Message(Event Player, Custom String("+1 point with {0} {1}", Hero Icon String(Hero Of(Event Player)), Hero Of(
			Event Player)));
		Create HUD Text(All Players(All Teams), Hero Icon String(Hero Of(Event Player)), Event Player, Custom String("+1 point"), Right,
			-1 + Global.pointfeedHudId, Orange, White, Orange, Visible To, Default Visibility);
		Modify Global Variable(pointfeedHud, Append To Array, Last Text ID);
		Global.pointfeedHudTimes[Count Of(Global.pointfeedHud) - 1] = 3.744;
		Global.pointfeedHudId -= 0.010;
	}
}

rule("ZEN mega-kick")
{
	event
	{
		Player Dealt Damage;
		All;
		Zenyatta;
	}

	actions
	{
		Apply Impulse(Victim, Facing Direction Of(Event Player) + Vector(0, 0.100, 0), 75, To World, Cancel Contrary Motion);
	}
}

rule("----- TEST -----")
{
	event
	{
		Ongoing - Global;
	}
}

disabled rule("Lobby with Dummies (TEST)")
{
	event
	{
		Ongoing - Global;
	}

	conditions
	{
		Is In Setup == True;
		(Custom String("Jokaes") == Custom String("{0}", Host Player)) == True;
	}

	actions
	{
		Create Dummy Bot(Hero(Ashe), All Teams, -1, Vector(0, 0, 0), Vector(0, 0, 0));
		disabled Loop If(Count Of(All Players(All Teams)) < 2);
		disabled Loop If(Count Of(All Players(All Teams)) < 3);
		Loop If(Count Of(All Players(All Teams)) < 5);
		disabled Loop If(Count Of(All Players(All Teams)) < 6);
		disabled Loop If(Count Of(All Players(All Teams)) < 12);
	}
}

disabled rule("Dummys Summon (TEST)")
{
	event
	{
		Ongoing - Each Player;
		All;
		All;
	}

	conditions
	{
		Is Communicating(Event Player, Hello) == True;
		(Custom String("Jokaes") == Custom String("{0}", Host Player)) == True;
	}

	actions
	{
		Create Dummy Bot(Hero(Ashe), All Teams, -1, Position Of(Event Player), Vector(0, 0, 0));
	}
}

disabled rule("Dummy Aim Bot (TEST)")
{
	event
	{
		Ongoing - Each Player;
		All;
		All;
	}

	conditions
	{
		Is Dummy Bot(Event Player) == True;
		(Custom String("Jokaes") == Custom String("{0}", Host Player)) == True;
	}

	actions
	{
		Start Facing(Event Player, Direction Towards(Event Player, Sorted Array(Filtered Array(All Players(All Teams), Is Alive(
			Current Array Element)), Distance Between(Event Player, Current Array Element))[1]), 10000, To World, Direction and Turn Rate);
		Start Holding Button(Event Player, Ability 2);
		Start Holding Button(Event Player, Ability 1);
		Start Holding Button(Event Player, Secondary Fire);
		Start Holding Button(Event Player, Primary Fire);
		disabled Press Button(Event Player, Jump);
		Wait(Random Real(0.900, 1.100), Ignore Condition);
		Stop Holding Button(Event Player, Primary Fire);
		Stop Holding Button(Event Player, Secondary Fire);
		Stop Holding Button(Event Player, Ability 1);
		Stop Holding Button(Event Player, Ability 2);
		Loop If Condition Is True;
	}
}

disabled rule("Dummy Ult (TEST)")
{
	event
	{
		Ongoing - Each Player;
		All;
		All;
	}

	conditions
	{
		Is Dummy Bot(Event Player) == True;
		Ultimate Charge Percent(Event Player) == 100;
		(Custom String("Jokaes") == Custom String("{0}", Host Player)) == True;
	}

	actions
	{
		Press Button(Event Player, Ultimate);
	}
}

disabled rule("Dummy Meele loop (TEST)")
{
	event
	{
		Ongoing - Each Player;
		All;
		All;
	}

	conditions
	{
		Is Dummy Bot(Event Player) == True;
		(Custom String("Jokaes") == Custom String("{0}", Host Player)) == True;
	}

	actions
	{
		Start Facing(Event Player, Direction Towards(Event Player, Closest Player To(Event Player, Opposite Team Of(Team Of(
			Event Player)))), 10000, To World, Direction and Turn Rate);
		Press Button(Event Player, Melee);
		Wait(Random Real(0.250, 0.350), Ignore Condition);
		Loop If Condition Is True;
	}
}

disabled rule("Dummy Moving (TEST)")
{
	event
	{
		Ongoing - Each Player;
		All;
		All;
	}

	conditions
	{
		Is Dummy Bot(Event Player) == True;
		(Custom String("Jokaes") == Custom String("{0}", Host Player)) == True;
	}

	actions
	{
		Start Throttle In Direction(Event Player, Direction Towards(Event Player, Sorted Array(Filtered Array(All Players(All Teams),
			Is Alive(Current Array Element)), Distance Between(Event Player, Current Array Element))[1]), 1, To World,
			Replace existing throttle, Direction and Magnitude);
	}
}

disabled rule("Skip until (TEST)")
{
	event
	{
		Ongoing - Each Player;
		All;
		All;
	}

	conditions
	{
		disabled Is Button Held(Event Player, Interact) == True;
		Global.heroOfTheRound != Hero(Pharah);
		Global.roundTimer <= 58;
		(Custom String("Jokaes") == Custom String("{0}", Host Player)) == True;
	}

	actions
	{
		Global.roundTimer = 1;
		disabled Press Button(Event Player, Interact);
	}
}

disabled rule("Skip round (TEST)")
{
	event
	{
		Ongoing - Each Player;
		All;
		All;
	}

	conditions
	{
		Is Button Held(Event Player, Interact) == True;
		(Custom String("Jokaes") == Custom String("{0}", Host Player)) == True;
		(Custom String("Jokaes") == Custom String("{0}", Event Player)) == True;
	}

	actions
	{
		disabled Kill(All Players(All Teams), Null);
		Global.roundTimer = 1;
		disabled Set Status(Event Player, Null, Stunned, 1);
	}
}

disabled rule("Force dummy to be hero of the round (TEST)")
{
	event
	{
		Ongoing - Each Player;
		All;
		All;
	}

	conditions
	{
		Is Dummy Bot(Event Player) == True;
		Hero Of(Event Player) == Hero(Ashe);
		(Custom String("Jokaes") == Custom String("{0}", Host Player)) == True;
	}

	actions
	{
		Start Forcing Player To Be Hero(Event Player, Global.heroOfTheRound);
	}
}

disabled rule("Destroy the dummies (TEST)")
{
	event
	{
		Ongoing - Each Player;
		All;
		All;
	}

	conditions
	{
		(Custom String("Jokaes") == Custom String("{0}", Host Player)) == True;
		(Custom String("Jokaes") == Custom String("{0}", Event Player)) == True;
		Is Button Held(Event Player, Ultimate) == True;
		Is Button Held(Event Player, Reload) == True;
		Is Button Held(Event Player, Interact) == True;
	}

	actions
	{
		Destroy All Dummy Bots;
	}
}

disabled rule("Debug HUDs (TEST)")
{
	event
	{
		Ongoing - Each Player;
		All;
		All;
	}

	conditions
	{
		(Custom String("Jokaes") == Custom String("{0}", Host Player)) == True;
	}

	actions
	{
		disabled Create HUD Text(Event Player, Custom String("{0}", Horizontal Speed Of(Event Player)), Null, Null, Left, 0, White, White, White,
			Visible To and String, Default Visibility);
		Create HUD Text(Event Player, Custom String("{0}", Position Of(Event Player)), Null, Null, Left, 0, White, White, White,
			Visible To and String, Default Visibility);
		Create HUD Text(Event Player, Custom String("{0}", Y Component Of(Position Of(Event Player))), Null, Null, Left, 0, White, White,
			White, Visible To and String, Default Visibility);
		disabled Create HUD Text(Event Player, Custom String("{0}", Distance Between(Event Player, Vector(0, 10, 0))), Null, Null, Left, 0, White,
			White, White, Visible To and String, Default Visibility);
		disabled Create HUD Text(Event Player, Custom String("{0}", Count Of(Global.pointfeedHud)), Null, Null, Left, 0, White, White, White,
			Visible To and String, Default Visibility);
		disabled Create HUD Text(Event Player, Custom String("{0}", Count Of(Global.pointfeedHudTimes)), Null, Null, Left, 0, White, White, White,
			Visible To and String, Default Visibility);
	}
}

rule("Created by Jokaes#2263")
{
	event
	{
		Ongoing - Global;
	}
}

rule("Code: W468T")
{
	event
	{
		Ongoing - Global;
	}
}

Changed text

Open file

settings
{
	main
	{
		Description: "Island Party - Heroes Minigames    v2.0.0-21    Play rounds of 21 classic and new games as minigames and score points.    Widow HS only, McCree Hot Potato, Zen Sparta, Echo Rings...    Code: W468T    Join my discord.gg/ZdukXgB to choose the next minigame or give feedback.    ~Created by Jokaes#2263 My codes in: jokaes.github.io"
	}

	lobby
	{
		Allow Players Who Are In Queue: Yes
		Map Rotation: After A Game
		Match Voice Chat: Enabled
		Max Spectators: 6
		Return To Lobby: Never
	}

	modes
	{
		Deathmatch
		{
			enabled maps
			{
				Workshop Island
				Workshop Island Night
			}
		}

		General
		{
			Allow Hero Switching: Off
			Game Mode Start: Immediately
			Hero Limit: Off
			Kill Cam: Off
			Kill Feed: Off
			Respawn As Random Hero: On
			Score To Win: 30
			Self Initiated Respawn: Off
			Skins: Off
		}
	}

	heroes
	{
		General
		{
			Ana
			{
				Biotic Grenade: Off
				Damage Dealt: 500%
				Damage Received: 500%
				Health: 10%
				No Ammunition Requirement: On
				Quick Melee: Off
				Sleep Dart Cooldown Time: 25%
				Ultimate Ability Nano Boost: Off
			}

			Bastion
			{
				Infinite Ultimate Duration: On
				No Ammunition Requirement: On
				Quick Melee: Off
				Reconfigure: Off
				Self-Repair: Off
				Spawn With Ultimate Ready: On
				Ultimate Duration: 500%
				Ultimate Generation - Combat Configuration: Tank: 500%
				Ultimate Generation - Passive Configuration: Tank: 500%
				Ultimate Generation Configuration: Tank: 500%
			}

			Brigitte
			{
				Barrier Shield Cooldown Time: 200%
				Barrier Shield Recharge Rate: 150%
				Damage Dealt: 500%
				Jump Vertical Speed: 200%
				Primary Fire: Off
				Quick Melee: Off
				Repair Pack: Off
				Shield Bash Cooldown Time: 35%
				Ultimate Generation - Combat Rally: 200%
				Ultimate Generation - Passive Rally: 0%
				Whip Shot Cooldown Time: 30%
				Whip Shot Knockback Scalar: 200%
			}

			D.Va
			{
				Boosters Cooldown Time: 0%
				Damage Dealt: 10%
				Damage Received: 10%
				Defense Matrix: Off
				Micro Missiles: Off
				Primary Fire: Off
				Quick Melee: Off
				Ultimate Generation - Combat Self-Destruct: 0%
				Ultimate Generation - Passive Self-Destruct: 0%
			}

			Doomfist
			{
				Damage Dealt: 10%
				Damage Received: 10%
				Health: 500%
				Quick Melee: Off
				Rocket Punch Cooldown Time: 50%
				Rocket Punch Knockback Scalar: 250%
				Seismic Slam: Off
				Ultimate Generation - Combat Meteor Strike: 50%
				Ultimate Generation - Passive Meteor Strike: 0%
			}

			Echo
			{
				Flight Cooldown Time: 50%
				Focusing Beam Cooldown Time: 50%
				Movement Speed: 200%
				Primary Fire: Off
				Sticky Bombs: Off
				Ultimate Ability Duplicate: Off
			}

			Genji
			{
				Damage Dealt: 500%
				Deflect: Off
				Primary Fire: Off
				Secondary Fire: Off
				Swift Strike Cooldown Time: 30%
				Ultimate Generation - Combat Dragonblade: 500%
				Ultimate Generation - Passive Dragonblade: 0%
				Ultimate Generation Dragonblade: 200%
			}

			Lúcio
			{
				Amp It Up: Off
				Crossfade: Off
				No Ammunition Requirement: On
				Primary Fire: Off
				Quick Melee: Off
				Soundwave: Off
				Ultimate Ability Sound Barrier: Off
			}

			McCree
			{
				Combat Roll Cooldown Time: 80%
				Damage Dealt: 10%
				Damage Received: 10%
				Flashbang: Off
				Jump Vertical Speed: 300%
				No Ammunition Requirement: On
				Secondary Fire: Off
				Ultimate Ability Deadeye: Off
			}

			Mei
			{
				Damage Dealt: 500%
				Damage Received: 500%
				No Ammunition Requirement: On
				Primary Fire: Off
				Projectile Gravity: 500%
				Projectile Speed: 38%
				Ultimate Generation - Combat Blizzard: 125%
			}

			Mercy
			{
				Damage Dealt: 500%
				Damage Received: 500%
				Guardian Angel: Off
				Movement Speed: 150%
				Primary Fire: Off
				Resurrect: Off
				Secondary Fire: Off
				Ultimate Generation - Combat Valkyrie: 500%
				Ultimate Generation Valkyrie: 500%
			}

			Roadhog
			{
				Chain Hook Cooldown Time: 25%
				Damage Dealt: 10%
				Damage Received: 10%
				Movement Speed: 150%
				Primary Fire: Off
				Quick Melee: Off
				Secondary Fire: Off
				Take a Breather: Off
				Ultimate Ability Whole Hog: Off
			}

			Sigma
			{
				Accretion Cooldown Time: 25%
				Damage Dealt: 500%
				Experimental Barrier Cooldown Time: 200%
				Experimental Barrier Recharge Rate: 50%
				Health: 25%
				Jump Vertical Speed: 150%
				Movement Speed: 150%
				Primary Fire: Off
				Projectile Speed: 162%
				Quick Melee: Off
				Ultimate Generation - Combat Gravitic Flux: 260%
				Ultimate Generation - Passive Gravitic Flux: 0%
				Ultimate Generation Gravitic Flux: 260%
			}

			Soldier: 76
			{
				Biotic Field: Off
				Helix Rockets: Off
				Primary Fire: Off
				Quick Melee: Off
				Ultimate Ability Tactical Visor: Off
			}

			Sombra
			{
				Hack Cooldown Time: 0%
				Primary Fire: Off
				Quick Melee: Off
				Ultimate Generation - Combat EMP: 10%
				Ultimate Generation - Passive EMP: 500%
			}

			Torbjörn
			{
				Deploy Turret: Off
				Overload Cooldown Time: 25%
				Secondary Fire: Off
				Ultimate Ability Molten Core: Off
				Weapons Enabled: Forge Hammer Only
			}

			Tracer
			{
				Damage Dealt: 10%
				Damage Received: 10%
				Movement Speed: 130%
				Primary Fire: Off
				Recall Cooldown Time: 1%
				Ultimate Ability Pulse Bomb: Off
			}

			Widowmaker
			{
				Grappling Hook Cooldown Time: 25%
				No Ammunition Requirement: On
				No Automatic Fire: On
				Quick Melee: Off
				Receive Headshots Only: On
				Ultimate Ability Infra-Sight: Off
				Venom Mine: Off
			}

			Winston
			{
				Barrier Projector: Off
				Damage Dealt: 10%
				Damage Received: 10%
				Health: 500%
				Infinite Ultimate Duration: On
				Jump Pack Knockback Scalar: 400%
				Primal Rage Melee Knockback Scalar: 300%
				Spawn With Ultimate Ready: On
				Ultimate Duration: 500%
				Ultimate Generation - Combat Primal Rage: 500%
				Ultimate Generation - Passive Primal Rage: 500%
				Ultimate Generation Primal Rage: 500%
			}

			Zenyatta
			{
				Damage Dealt: 10%
				Damage Received: 10%
				Orb of Discord: Off
				Orb of Harmony: Off
				Primary Fire: Off
				Secondary Fire: Off
				Ultimate Ability Transcendence: Off
			}

			disabled heroes
			{
				Ashe
				Baptiste
				Hanzo
				Junkrat
				Moira
				Orisa
				Reaper
				Reinhardt
				Symmetra
				Wrecking Ball
				Zarya
			}
		}
	}
}

variables
{
	global:
		0: timeCounter
		1: roundTimer
		2: roundNumber
		3: playersStartOfTheRound
		4: heroList
		5: heroModeSelector
		6: heroesRounds
		7: heroOfTheRound
		8: heroesOfPreviousRounds
		9: minigameStringTitles
		10: minigameStringCodes
		11: minigameStringCredit
		12: minigameStringInstructions
		13: discordSubtringArray
		14: pointfeedHud
		15: pointfeedHudTimes
		16: pointfeedHudId
		17: pointfeedHudTimesIt
		18: hofPlayers
		19: hofPlayersCounter
		20: crownPos
		21: crownEffect
		22: tracerQueen
		23: soldierObjectivePos
		24: soldierObjectiveEffects
		25: soldierDestructorIt
		26: tracerQueenHud
		27: potatoPos
		28: potatoHolder
		29: potatoEffect
		30: potatoIcon
		31: commonRingsEffects
		32: rareRingsEffects
		33: epicRingsEffects
		34: legendaryRingsEffects
		35: commonRingsPos
		36: rareRingsPos
		37: epicRingsPos
		38: legendaryRingsPos
		39: ringsIt
		40: echoTeleportEffects
		41: echoTeleportPos
		42: echoRightHUD
		43: dvaObjectivePos
		44: dvaObjectiveEffects
		45: dvaDestructorIt
		46: dvaObjectiveIcons
		47: roadhogHoleRadius
		48: roadhogHoleEffects
		49: roadhogHoleEffectsIt
		50: meiSnowEffects
		51: meiSnowPos
		52: meiSnowIt
		53: snotPos
		54: snotPosRandomXComp
		55: snotPosRandomYComp
		56: snotPosRandomZComp
		57: snotEffects
		58: destructorIt
		59: heroOfLastRound
		60: islandPartyCode
		61: islandPartySpecialEdition
		62: tracerQueenPositionIcon

	player:
		0: queenPoints
		1: queenPointsHud
		2: soldierSprint
		3: soldierPoints
		4: soldierPointsHud
		5: mccreeInvincibleTime
		6: mccreeInvincibleText
		7: mccreeInvincibleHud
		8: mccreeHealthHud
		9: pharahHealEffect
		10: pharahDamageBoostEffect
		11: pharahHeal
		12: pharahDamageBoost
		13: pharahHealHud
		14: pharahDamageBoostHud
		15: echoPoints
		16: echoPointsHud
		17: echoClosestRing
		18: sigmaUsingGrasp
		19: sigmaCatch
		20: dvaPoints
		21: dvaPointsHud
		22: roadhogPostion
		23: roadhogYanked
		24: dvaDistanceText
		25: roadhogFalling
		26: meiMeeleCatchCooldown
		27: meiAmmo
		28: meiClosestSnow
		29: meiIsPickingSnow
		30: meiPickingSnowTimer
		31: meiIsCatching
		32: meiCatchCooldownHud
		33: meiAmmoHud
		34: meiHasAmmoIcon
		35: thirdCameraDirection
		36: thirdCameraZoom
		37: isOnThirdCamera
		38: meiCrouchOnMeText
		39: meiHasPickedUpAnyAmmo
		40: lucioClosestSnotIcon
		41: meiCatchActiveCooldownHud
		42: meiCatchSphereEffect
		43: lucioSpeed
		44: lucioPoints
		45: lucioPointsHud
		46: lucioClosestSnot
		47: lucioHasBeenOnWall
		48: playerSpeedHud
		50: playerClosestObjectiveIcon
}

subroutines
{
	0: gameModeDescriptionMessages
	1: startNewRound
	2: restartStats
}

rule("Is in setup {GLOBAL}")
{
	event
	{
		Ongoing - Global;
	}

	conditions
	{
		Is In Setup == True;
	}

	actions
	{
		Global.roundTimer = 60;
		Enable Death Spectate All Players(All Players(All Teams));
		Disable Built-In Game Mode Respawning(All Players(All Teams));
		Set Respawn Max Time(All Players(All Teams), 60);
		Global.islandPartyCode = Custom String("W468T");
		Global.islandPartySpecialEdition = Custom String("");
		Global.roundNumber = 0;
		disabled Global.heroModeSelector = Random Integer(0, Count Of(Global.heroList) - 1);
		Global.heroList = Empty Array;
		Global.heroesOfPreviousRounds = Empty Array;
		Global.discordSubtringArray = Array(Custom String("vote for the next minigame"), Custom String("give feedback"), Custom String(
			"report bugs"));
		Modify Global Variable(heroList, Append To Array, Hero(Ana));
		Modify Global Variable(heroList, Append To Array, Hero(Bastion));
		Modify Global Variable(heroList, Append To Array, Hero(Brigitte));
		Modify Global Variable(heroList, Append To Array, Hero(Doomfist));
		Modify Global Variable(heroList, Append To Array, Hero(D.Va));
		Modify Global Variable(heroList, Append To Array, Hero(Echo));
		Modify Global Variable(heroList, Append To Array, Hero(Genji));
		Modify Global Variable(heroList, Append To Array, Hero(Lúcio));
		Modify Global Variable(heroList, Append To Array, Hero(McCree));
		Modify Global Variable(heroList, Append To Array, Hero(Mei));
		Modify Global Variable(heroList, Append To Array, Hero(Mercy));
		Modify Global Variable(heroList, Append To Array, Hero(Pharah));
		Modify Global Variable(heroList, Append To Array, Hero(Roadhog));
		Modify Global Variable(heroList, Append To Array, Hero(Sigma));
		Modify Global Variable(heroList, Append To Array, Hero(Soldier: 76));
		Modify Global Variable(heroList, Append To Array, Hero(Sombra));
		Modify Global Variable(heroList, Append To Array, Hero(Torbjörn));
		Modify Global Variable(heroList, Append To Array, Hero(Tracer));
		Modify Global Variable(heroList, Append To Array, Hero(Widowmaker));
		Modify Global Variable(heroList, Append To Array, Hero(Winston));
		Modify Global Variable(heroList, Append To Array, Hero(Zenyatta));
		disabled Global.heroOfTheRound = Global.heroList[Global.heroModeSelector];
		disabled Global.heroOfTheRound = Random Value In Array(Remove From Array(Global.heroList, Global.heroesOfPreviousRounds));
		Create HUD Text(All Players(All Teams), Custom String("CODE: {0}", Global.islandPartyCode),
			Global.islandPartyCode == Custom String("W468T") ? Custom String("") : Custom String("SPECIAL EDITION"),
			Global.islandPartySpecialEdition, Left, -998.500, White, Sky Blue, White, Visible To and String, Default Visibility);
		Create HUD Text(All Players(All Teams), Null, Custom String(" "), Custom String(
			"Island Party - Heroes Minigames v2.0.0-21"), Left, -998, White, White, Orange, Visible To and String,
			Default Visibility);
		Create HUD Text(All Players(All Teams), Null, Null, Custom String("Play rounds of {0} classic and new games as minigames",
			Count Of(Global.heroList)), Left, -997, White, White, White, Visible To and String, Default Visibility);
		Create HUD Text(All Players(All Teams), Null, Null, Custom String("Join discord.gg/4N4BAE6 and {0}",
			Global.discordSubtringArray[Global.roundNumber % 3]), Left, -996, White, White, White, Visible To and String,
			Default Visibility);
		Create HUD Text(All Players(All Teams), Null, Null, Custom String("Find all my codes in: jokaes.github.io"), Left, -995.500, White,
			White, White, Visible To and String, Default Visibility);
		Create HUD Text(All Players(All Teams), Null, Custom String("Created by Jokaes#2263"), Null, Left, -995, White, White, White,
			Visible To and String, Default Visibility);
		Create HUD Text(All Players(All Teams), Null, Custom String("  \n ", String("Round"), Global.roundNumber), Null, Left, -994, White,
			White, White, Visible To and String, Default Visibility);
		Create HUD Text(All Players(All Teams), Null, Custom String("{0}", String("Round {0}", Global.roundNumber)), Null, Top, 999.999,
			White, White, White, Visible To and String, Default Visibility);
		Wait(1.500, Ignore Condition);
		disabled Start Forcing Player To Be Hero(All Players(All Teams), Global.heroOfTheRound);
		Global.potatoPos = Vector(500, 500, 500);
		Create HUD Text(All Players(All Teams), Null, Null, Custom String(" \r\n		\r\n		\r\n		\r\n		\r\n		\r\n		"), Left, -999, White,
			White, White, Visible To and String, Default Visibility);
		Create HUD Text(Filtered Array(All Players(All Teams), Count Of(Global.hofPlayers) > 0), Null, Null, Custom String("Hall of fame"),
			Right, -600, White, White, Orange, Visible To and Sort Order, Default Visibility);
		Create In-World Text(All Players(All Teams), Custom String("CODE: {0}", Global.islandPartyCode), Vector(0, 200, 0), 4,
			Clip Against Surfaces, Visible To Position and String, White, Default Visibility);
		Wait(3.500, Ignore Condition);
		Communicate(All Players(All Teams), Countdown);
	}
}

rule("Disable bulit-in game mode & start timer variables {Game in progress GLOBAL}")
{
	event
	{
		Ongoing - Global;
	}

	conditions
	{
		Is Game In Progress == True;
	}

	actions
	{
		Disable Built-In Game Mode Completion;
		Disable Built-In Game Mode Music;
		Disable Built-In Game Mode Announcer;
		Disable Built-In Game Mode Scoring;
		Enable Death Spectate All Players(All Players(All Teams));
		Disable Built-In Game Mode Respawning(All Players(All Teams));
		Set Respawn Max Time(All Players(All Teams), 60);
		Pause Match Time;
		Global.timeCounter = 0.001;
		Global.roundTimer = 60;
		"Timer of the round HUD {Standard}"
		Create HUD Text(Filtered Array(All Players(All Teams), Global.roundTimer > 10), Custom String(":{0}", Round To Integer(
			Global.roundTimer, To Nearest)), Null, Null, Right, -999, White, White, White, Visible To and String, Default Visibility);
		"Timer of the round HUD {Last moments}"
		Create HUD Text(Filtered Array(All Players(All Teams), Global.roundTimer <= 10), Custom String(":{0}", Round To Integer(
			Global.roundTimer, To Nearest)), Null, Null, Right, -999, Red, White, White, Visible To and String, Default Visibility);
		"Timer of the round HUD separator"
		Create HUD Text(All Players(All Teams), Null, Custom String(" "), Null, Right, -998, White, White, White, Visible To and String,
			Default Visibility);
		"Creates a HUD in the top with [svr load: {0} | svr avg: {1} | svr peak: {2}] LOW LOAD(GREEN)"
		Create HUD Text(Filtered Array(Host Player, (Server Load + Server Load Average + Server Load Peak) / 3 < 128 && Custom String(
			"#Jokaes") == String("#{0}", Host Player)), Null, Custom String("svr load: {0} | svr avg: {1} | svr peak: {2}", Server Load,
			Server Load Average, Server Load Peak), Null, Top, -100, White, Lime Green, White, Visible To and String, Default Visibility);
		"Creates a HUD in the top with [svr load: {0} | svr avg: {1} | svr peak: {2}] MID LOAD(ORANGE)"
		Create HUD Text(Filtered Array(Host Player, (Server Load + Server Load Average + Server Load Peak) / 3 >= 128 && (
			Server Load + Server Load Average + Server Load Peak) / 3 <= 192 && Custom String("#Jokaes") == String("#{0}", Host Player)),
			Null, Custom String("svr load: {0} | svr avg: {1} | svr peak: {2}", Server Load, Server Load Average, Server Load Peak), Null,
			Top, -100, White, Orange, White, Visible To and String, Default Visibility);
		"Creates a HUD in the top with [svr load: {0} | svr avg: {1} | svr peak: {2}] HIGH LOAD(RED)"
		Create HUD Text(Filtered Array(Host Player, (Server Load + Server Load Average + Server Load Peak) / 3 > 192 && Custom String(
			"#Jokaes") == String("#{0}", Host Player)), Null, Custom String("svr load: {0} | svr avg: {1} | svr peak: {2}", Server Load,
			Server Load Average, Server Load Peak), Null, Top, -100, White, Red, White, Visible To and String, Default Visibility);
		Global.hofPlayers = Empty Array;
		Global.pointfeedHud = Empty Array;
		Global.pointfeedHudTimes = Array(True, True, True, True, True, True);
		Global.pointfeedHudId = 0;
		Create HUD Text(All Players(All Teams), Global.minigameStringTitles[Global.heroModeSelector],
			Global.minigameStringCodes[Global.heroModeSelector], Global.minigameStringCredit[Global.heroModeSelector], Top, 0.001, Orange,
			White, White, Visible To Sort Order and String, Default Visibility);
		Global.playersStartOfTheRound = All Players(All Teams);
	}
}

rule("Is game in progress {PLAYER}")
{
	event
	{
		Ongoing - Each Player;
		All;
		All;
	}

	conditions
	{
		Is Game In Progress == True;
	}

	actions
	{
		Start Rule(gameModeDescriptionMessages, Do Nothing);
		Enable Death Spectate All Players(Event Player);
		Disable Built-In Game Mode Respawning(Event Player);
		Set Respawn Max Time(Event Player, 60);
		Preload Hero(Event Player, Global.heroList);
		Global.playersStartOfTheRound = All Players(All Teams);
	}
}

rule("Player join in setup")
{
	event
	{
		Player Joined Match;
		All;
		All;
	}

	conditions
	{
		Is In Setup == True;
		Has Spawned(Event Player) == True;
		Is Alive(Event Player) == True;
	}

	actions
	{
		Wait(0.512, Ignore Condition);
		Start Forcing Player To Be Hero(Event Player, Global.heroOfTheRound);
		Preload Hero(Event Player, Global.heroList);
		Set Respawn Max Time(Event Player, 9999);
	}
}

rule("Player join with game in progress")
{
	event
	{
		Player Joined Match;
		All;
		All;
	}

	conditions
	{
		Is Game In Progress == True;
		Is Alive(Event Player) == True;
	}

	actions
	{
		Start Rule(gameModeDescriptionMessages, Do Nothing);
		Disable Built-In Game Mode Respawning(Event Player);
		Set Respawn Max Time(Event Player, 60);
		Wait(0.512, Ignore Condition);
		Start Forcing Player To Be Hero(Event Player, Global.heroOfTheRound);
		Teleport(Event Player, Vector(500, 500, 500));
		Clear Status(Event Player, Unkillable);
		Wait(0.512, Ignore Condition);
		Kill(Event Player, Null);
		Preload Hero(Event Player, Global.heroList);
		Set Respawn Max Time(Event Player, 9999);
	}
}

disabled rule("First to 30 EDITION")
{
	event
	{
		Ongoing - Global;
	}

	conditions
	{
		disabled Is Game In Progress == True;
		Is In Setup == True;
	}

	actions
	{
		Wait(0.250, Ignore Condition);
		Create HUD Text(All Players(All Teams), Null, Null, Custom String("FIRST TO 30 POINTS EDITION"), Top, 0.500, White, White,
			Sky Blue, Visible To and String, Default Visibility);
		Global.islandPartyCode = Custom String("Z9VEE");
		Global.islandPartySpecialEdition = Custom String("FIRST TO 30 POINTS");
		Wait(10, Ignore Condition);
		Enable Built-In Game Mode Completion;
		Enable Built-In Game Mode Announcer;
	}
}

rule("Time Counter - Add minute")
{
	event
	{
		Ongoing - Global;
	}

	conditions
	{
		Is Game In Progress == True;
	}

	actions
	{
		Set Match Time(Global.timeCounter);
		Wait(60, Ignore Condition);
		Global.timeCounter += 1;
		Loop;
	}
}

rule("Force players to be the hero of the round")
{
	event
	{
		Ongoing - Each Player;
		All;
		All;
	}

	conditions
	{
		Has Spawned(Event Player) == True;
		Is Alive(Event Player) == True;
	}

	actions
	{
		Start Forcing Player To Be Hero(Event Player, Global.heroOfTheRound);
	}
}

rule("Create new round {SETUP}")
{
	event
	{
		Ongoing - Global;
	}

	conditions
	{
		Is In Setup == True;
	}

	actions
	{
		Wait(0.048, Ignore Condition);
		Global.heroOfTheRound = Random Value In Array(Global.heroList);
		Preload Hero(All Players(All Teams), Global.heroOfTheRound);
		Global.heroModeSelector = Index Of Array Value(Global.heroList, Global.heroOfTheRound);
		Wait(0.272, Ignore Condition);
		Start Forcing Player To Be Hero(All Players(All Teams), Global.heroOfTheRound);
		Global.roundNumber += 1;
		Small Message(All Players(All Teams), Custom String("ROUND {0}", Global.roundNumber));
		Global.playersStartOfTheRound = All Players(All Teams);
		Global.roundTimer = 60;
		Chase Global Variable At Rate(roundTimer, 0, 1, None);
	}
}

rule("Create new round {OUT OF TIME}")
{
	event
	{
		Ongoing - Global;
	}

	conditions
	{
		Global.roundTimer <= 0;
		Is Game In Progress == True;
	}

	actions
	{
		Start Rule(startNewRound, Do Nothing);
	}
}

rule("Create new round {LAST PLAYER ALIVE}")
{
	event
	{
		Ongoing - Global;
	}

	conditions
	{
		Number of Living Players(All Teams) <= 1;
		Is Game In Progress == True;
	}

	actions
	{
		Start Rule(startNewRound, Do Nothing);
	}
}

rule("Create new round 2")
{
	event
	{
		Subroutine;
		startNewRound;
	}

	actions
	{
		Global.roundTimer = 60;
		Start Rule(restartStats, Do Nothing);
		If(Count Of(Global.heroesOfPreviousRounds) == Count Of(Global.heroList) - 1);
			Global.heroesOfPreviousRounds = Empty Array;
		End;
		Global.heroOfLastRound = Global.heroOfTheRound;
		Modify Global Variable(heroesOfPreviousRounds, Append To Array, Global.heroOfTheRound);
		Global.heroOfTheRound = Null;
		Wait(0.048, Ignore Condition);
		Global.heroOfTheRound = Random Value In Array(Remove From Array(Global.heroList, Global.heroesOfPreviousRounds));
		Preload Hero(All Players(All Teams), Global.heroOfTheRound);
		Global.heroModeSelector = Index Of Array Value(Global.heroList, Global.heroOfTheRound);
		disabled Skip If(Global.heroOfTheRound == Hero(Roadhog), 1);
		Respawn(All Players(All Teams));
		Resurrect(All Players(All Teams));
		Wait(0.272, Ignore Condition);
		Start Forcing Player To Be Hero(All Players(All Teams), Global.heroOfTheRound);
		Wait(0.272, Ignore Condition);
		Global.roundNumber += 1;
		Small Message(All Players(All Teams), Custom String("ROUND {0}", Global.roundNumber));
		Global.playersStartOfTheRound = All Players(All Teams);
		disabled Destroy Effect(All Players(All Teams).pharahHealEffect);
		disabled Destroy Effect(All Players(All Teams).pharahDamageBoostEffect);
		Start Forcing Throttle(All Players(All Teams), 0, 0, 0, 0, 0, 0);
		Set Aim Speed(All Players(All Teams), Absolute Value(0));
		Wait(0.750, Ignore Condition);
		Stop Forcing Throttle(All Players(All Teams));
		Set Aim Speed(All Players(All Teams), 100);
		Chase Global Variable At Rate(roundTimer, 0, 1, None);
	}
}

disabled rule("Create new round")
{
	event
	{
		Subroutine;
		startNewRound;
	}

	actions
	{
		Set Move Speed(All Players(All Teams), 100);
		Set Gravity(All Players(All Teams), 100);
		Global.roundTimer = 60;
		Wait(0.032, Ignore Condition);
		If(Count Of(Global.heroesOfPreviousRounds) == Count Of(Global.heroList) - 1);
			Global.heroesOfPreviousRounds = Empty Array;
		End;
		Global.heroOfLastRound = Global.heroOfTheRound;
		Modify Global Variable(heroesOfPreviousRounds, Append To Array, Global.heroOfTheRound);
		disabled Global.heroModeSelector = Random Integer(0, Count Of(Global.heroList) - 1);
		disabled Global.heroesRounds[Global.heroModeSelector] = True;
		disabled Global.heroOfTheRound = Global.heroList[Global.heroModeSelector];
		Global.heroOfTheRound = Null;
		Wait(0.048, Ignore Condition);
		Global.heroOfTheRound = Random Value In Array(Remove From Array(Global.heroList, Global.heroesOfPreviousRounds));
		disabled Loop If(Global.heroOfTheRound == Global.heroesOfPreviousRounds);
		Loop If(Is True For Any(Global.heroesOfPreviousRounds, Current Array Element == Global.heroOfTheRound));
		Preload Hero(All Players(All Teams), Global.heroOfTheRound);
		Global.heroModeSelector = Index Of Array Value(Global.heroList, Global.heroOfTheRound);
		Skip If(Global.heroOfTheRound == Hero(Roadhog), 1);
		Respawn(All Players(All Teams));
		Resurrect(All Players(All Teams));
		Wait(0.250, Ignore Condition);
		Start Forcing Player To Be Hero(All Players(All Teams), Global.heroOfTheRound);
		Global.roundNumber += 1;
		disabled Big Message(All Players(All Teams), Custom String("ROUND {0}", Global.roundNumber));
		Small Message(All Players(All Teams), Custom String("ROUND {0}", Global.roundNumber));
		Chase Global Variable At Rate(roundTimer, 0, 1, None);
		Global.playersStartOfTheRound = All Players(All Teams);
		Destroy Effect(All Players(All Teams).pharahHealEffect);
		Destroy Effect(All Players(All Teams).pharahDamageBoostEffect);
		Play Effect(All Players(All Teams), Explosion Sound, White, All Players(All Teams), 200);
		Start Forcing Throttle(All Players(All Teams), 0, 0, 0, 0, 0, 0);
		Set Aim Speed(All Players(All Teams), Absolute Value(0));
		Wait(0.750, Ignore Condition);
		Stop Forcing Throttle(All Players(All Teams));
		Set Aim Speed(All Players(All Teams), 100);
	}
}

rule("Restart stats")
{
	event
	{
		Subroutine;
		restartStats;
	}

	actions
	{
		Set Move Speed(All Players(All Teams), 100);
		Set Gravity(All Players(All Teams), 100);
	}
}

rule("String Arrays (Title, credit, code and instructions)")
{
	event
	{
		Ongoing - Global;
	}

	actions
	{
		disabled Create HUD Text(All Players(All Teams), Global.minigameStringTitles[Global.heroModeSelector], Null, Null, Top, -3, Orange, White,
			White, Visible To and String, Default Visibility);
		disabled Create HUD Text(All Players(All Teams), Null, Null, Global.minigameStringCodes[Global.heroModeSelector], Top, -2, White, White,
			White, Visible To and String, Default Visibility);
		disabled Create HUD Text(All Players(All Teams), Null, Null, Global.minigameStringCredit[Global.heroModeSelector], Top, -1, White, White,
			White, Visible To and String, Default Visibility);
		Create HUD Text(All Players(All Teams), Null, Null, Global.minigameStringInstructions[Global.heroModeSelector], Top, 1, White,
			White, White, Visible To and String, Default Visibility);
		Global.minigameStringTitles = Empty Array;
		"Ana"
		Modify Global Variable(minigameStringTitles, Append To Array, Custom String("{0} PAINTBALL {0}", Hero Icon String(Hero(Ana))));
		"Bastion"
		Modify Global Variable(minigameStringTitles, Append To Array, Custom String("{0} WORLD OF TANKS {0}", Hero Icon String(Hero(
			Bastion))));
		"Brigitte"
		Modify Global Variable(minigameStringTitles, Append To Array, Custom String("{0} BOOP {0}", Hero Icon String(Hero(Brigitte))));
		"Doomfist"
		Modify Global Variable(minigameStringTitles, Append To Array, Custom String("{0} DOOM SUMO {0}", Hero Icon String(Hero(
			Doomfist))));
		"D.Va"
		Modify Global Variable(minigameStringTitles, Append To Array, Custom String("{0} AIR RACE {0}", Hero Icon String(Hero(D.Va))));
		"Echo"
		Modify Global Variable(minigameStringTitles, Append To Array, Custom String("{0} RINGS {0}", Hero Icon String(Hero(Echo))));
		"Genji"
		Modify Global Variable(minigameStringTitles, Append To Array, Custom String("{0} DASH {0}", Hero Icon String(Hero(Genji))));
		"Lúcio"
		Modify Global Variable(minigameStringTitles, Append To Array, Custom String("{0} SNOT COLLECTOR {0}", Hero Icon String(Hero(
			Lúcio))));
		"McCree"
		Modify Global Variable(minigameStringTitles, Append To Array, Custom String("{0} HOT POTATO {0}", Hero Icon String(Hero(McCree))));
		"Mei"
		Modify Global Variable(minigameStringTitles, Append To Array, Custom String("{0} SNOWBALL {0}", Hero Icon String(Hero(Mei))));
		"Mercy"
		Modify Global Variable(minigameStringTitles, Append To Array, Custom String("{0} 1 PUNCH {0}", Hero Icon String(Hero(Mercy))));
		"Pharah"
		Modify Global Variable(minigameStringTitles, Append To Array, Custom String("{0} PHARMERCY SIMULATED {0}", Hero Icon String(Hero(
			Pharah))));
		"Roadhog"
		Modify Global Variable(minigameStringTitles, Append To Array, Custom String("{0} {1} HOOKS 1 HOLE {0}", Hero Icon String(Hero(
			Roadhog)), Number of Living Players(All Teams)));
		"Sigma"
		Modify Global Variable(minigameStringTitles, Append To Array, Custom String("{0} DODGEBALL {0}", Hero Icon String(Hero(Sigma))));
		"Soldier: 76"
		Modify Global Variable(minigameStringTitles, Append To Array, Custom String("{0} SPRINT RACING {0}", Hero Icon String(Hero(
			Soldier: 76))));
		"Sombra"
		Modify Global Variable(minigameStringTitles, Append To Array, Custom String("{0} HACK TO KILL {0}", Hero Icon String(Hero(
			Sombra))));
		"Torbjörn"
		Modify Global Variable(minigameStringTitles, Append To Array, Custom String("{0} HAMMER ONLY {0}", Hero Icon String(Hero(
			Torbjörn))));
		"Tracer"
		Modify Global Variable(minigameStringTitles, Append To Array, Custom String("{0} STEAL THE CROWN {0}", Hero Icon String(Hero(
			Tracer))));
		"Widowmaker"
		Modify Global Variable(minigameStringTitles, Append To Array, Custom String("{0} HS ONLY {0}", Hero Icon String(Hero(
			Widowmaker))));
		"Winston"
		Modify Global Variable(minigameStringTitles, Append To Array, Custom String("{0} MONKEY SUMO {0}", Hero Icon String(Hero(
			Winston))));
		"Zenyatta"
		Modify Global Variable(minigameStringTitles, Append To Array, Custom String("{0} SPARTA {0}", Hero Icon String(Hero(Zenyatta))));
		Global.minigameStringCodes = Empty Array;
		"Ana"
		Modify Global Variable(minigameStringCodes, Append To Array, Custom String("Play it more on 9G11W"));
		"Bastion"
		Modify Global Variable(minigameStringCodes, Append To Array, Custom String("Play it more on 33NKS"));
		"Brigitte"
		Modify Global Variable(minigameStringCodes, Append To Array, Custom String("Play it more on 55MMT / ZYDQM"));
		"Doomfist"
		Modify Global Variable(minigameStringCodes, Append To Array, Custom String("Play it more on 9G11W / 2A2YA"));
		"D.Va"
		Modify Global Variable(minigameStringCodes, Append To Array, Custom String("Play it more on DV5CA"));
		"Echo"
		Modify Global Variable(minigameStringCodes, Append To Array, Custom String("Play it more on XECF0"));
		"Genji"
		Modify Global Variable(minigameStringCodes, Append To Array, Custom String("Play it more on BBQ9Z"));
		"Lúcio"
		Modify Global Variable(minigameStringCodes, Append To Array, Custom String("Play it more on KAJAB"));
		"McCree"
		Modify Global Variable(minigameStringCodes, Append To Array, Custom String("Play it more on E515J"));
		"Mei"
		Modify Global Variable(minigameStringCodes, Append To Array, Custom String("Play it more on MQCCY"));
		"Mercy"
		Modify Global Variable(minigameStringCodes, Append To Array, Custom String("Play it more on YWKSZ & D7VC0S"));
		"Pharah"
		Modify Global Variable(minigameStringCodes, Append To Array, Custom String("Play it more on DKKKD"));
		"Roadhog"
		Modify Global Variable(minigameStringCodes, Append To Array, Custom String("Play it more on WQHER"));
		"Sigma"
		Modify Global Variable(minigameStringCodes, Append To Array, Custom String("Play it more on 8P769 / AN5P7"));
		"Soldier: 76"
		Modify Global Variable(minigameStringCodes, Append To Array, Custom String("Play it more on STJTC"));
		"Sombra"
		Modify Global Variable(minigameStringCodes, Append To Array, Custom String("Play it more on YJK0D6"));
		"Torbjörn"
		Modify Global Variable(minigameStringCodes, Append To Array, Custom String("Play it more on PHGM1"));
		"Tracer"
		Modify Global Variable(minigameStringCodes, Append To Array, Custom String("Play it more on 0X8N0"));
		"Widowmaker"
		Modify Global Variable(minigameStringCodes, Append To Array, Custom String("Play it more on EA5XD"));
		"Winston"
		Modify Global Variable(minigameStringCodes, Append To Array, Custom String("Play it more on RA906"));
		"Zenyatta"
		Modify Global Variable(minigameStringCodes, Append To Array, Custom String("Play it more on RZEX5"));
		Global.minigameStringCredit = Empty Array;
		"Ana"
		Modify Global Variable(minigameStringCredit, Append To Array, Custom String("BY TOOTHPASTE"));
		"Bastion"
		Modify Global Variable(minigameStringCredit, Append To Array, Custom String("BY JOKAES"));
		"Brigitte"
		Modify Global Variable(minigameStringCredit, Append To Array, Custom String("BY FARRON / BLOCK"));
		"Doomfist"
		Modify Global Variable(minigameStringCredit, Append To Array, Custom String("BY CREBOS & CLAMINIUM / KIKUGIE"));
		"D.Va"
		Modify Global Variable(minigameStringCredit, Append To Array, Custom String("BY JOKAES"));
		"Echo"
		Modify Global Variable(minigameStringCredit, Append To Array, Custom String("BY JOKAES"));
		"Genji"
		Modify Global Variable(minigameStringCredit, Append To Array, Custom String("BY GANTZ"));
		"Lúcio"
		Modify Global Variable(minigameStringCredit, Append To Array, Custom String("BY JOKAES"));
		"McCree"
		Modify Global Variable(minigameStringCredit, Append To Array, Custom String("BY KEVLAR"));
		"Mei"
		Modify Global Variable(minigameStringCredit, Append To Array, Custom String("BY MITSIEE"));
		"Mercy"
		Modify Global Variable(minigameStringCredit, Append To Array, Custom String("BY PARACHOR"));
		"Pharah"
		Modify Global Variable(minigameStringCredit, Append To Array, Custom String("BY SEITA"));
		"Roadhog"
		Modify Global Variable(minigameStringCredit, Append To Array, Custom String("BY BLOCK"));
		"Sigma"
		Modify Global Variable(minigameStringCredit, Append To Array, Custom String("BY PUG / VOXCAE"));
		"Soldier: 76"
		Modify Global Variable(minigameStringCredit, Append To Array, Custom String("BY DARWIN"));
		"Sombra"
		Modify Global Variable(minigameStringCredit, Append To Array, Custom String("BY TEHFOOT"));
		"Torbjörn"
		Modify Global Variable(minigameStringCredit, Append To Array, Custom String("BY JOKAES"));
		"Tracer"
		Modify Global Variable(minigameStringCredit, Append To Array, Custom String("BY KEVLAR"));
		"Widowmaker"
		Modify Global Variable(minigameStringCredit, Append To Array, Custom String("BY TOOTHPASTE"));
		"Winston"
		Modify Global Variable(minigameStringCredit, Append To Array, Custom String("BY JOKAES"));
		"Zenyatta"
		Modify Global Variable(minigameStringCredit, Append To Array, Custom String("BY JOKAES. ORIGINAL CREATION BY DARWIN"));
		Global.minigameStringInstructions = Empty Array;
		"Ana"
		Modify Global Variable(minigameStringInstructions, Append To Array, Custom String("One shoot to kill!"));
		"Bastion"
		Modify Global Variable(minigameStringInstructions, Append To Array, Custom String("BOO BEE BEE BEE BOO BEEEE!"));
		"Brigitte"
		Modify Global Variable(minigameStringInstructions, Append To Array, Custom String("Protect yourself and boop the others!"));
		"Doomfist"
		Modify Global Variable(minigameStringInstructions, Append To Array, Custom String("Use your punches to get them out!"));
		"D.Va"
		Modify Global Variable(minigameStringInstructions, Append To Array, Custom String("Boost and race!"));
		"Echo"
		Modify Global Variable(minigameStringInstructions, Append To Array, Custom String("Collect those rings!"));
		"Genji"
		Modify Global Variable(minigameStringInstructions, Append To Array, Custom String("Dash!"));
		"Lúcio"
		Modify Global Variable(minigameStringInstructions, Append To Array, Custom String("Collect snot from the wall to gain speed!"));
		"McCree"
		Modify Global Variable(minigameStringInstructions, Append To Array, Custom String("Shoot to pass the hot potato!"));
		"Mei"
		Modify Global Variable(minigameStringInstructions, Append To Array, Custom String("Pick up snow and shoot!"));
		"Mercy"
		Modify Global Variable(minigameStringInstructions, Append To Array, Custom String("Punch to kill and get ultimate!"));
		"Pharah"
		Modify Global Variable(minigameStringInstructions, Append To Array, Custom String(
			"Kill'em all with your Mercy pocket simulated!"));
		"Roadhog"
		Modify Global Variable(minigameStringInstructions, Append To Array, Custom String("Yank'em into the hole!"));
		"Sigma"
		Modify Global Variable(minigameStringInstructions, Append To Array, Custom String("Knock them out with your big rock!"));
		"Soldier: 76"
		Modify Global Variable(minigameStringInstructions, Append To Array, Custom String("Gotta go fast!"));
		"Sombra"
		Modify Global Variable(minigameStringInstructions, Append To Array, Custom String("Hack your opponents to kill'em!"));
		"Torbjörn"
		Modify Global Variable(minigameStringInstructions, Append To Array, Custom String("Overload and hammer down!"));
		"Tracer"
		Modify Global Variable(minigameStringInstructions, Append To Array, Custom String("Meele to steal the crown!"));
		"Widowmaker"
		Modify Global Variable(minigameStringInstructions, Append To Array, Custom String("Aim for the head!"));
		"Winston"
		Modify Global Variable(minigameStringInstructions, Append To Array, Custom String("Ape kill ape!"));
		"Zenyatta"
		Modify Global Variable(minigameStringInstructions, Append To Array, Custom String("Kick them for Spartaaa!"));
	}
}

rule("Description and credit (Small Messages)")
{
	event
	{
		Subroutine;
		gameModeDescriptionMessages;
	}

	actions
	{
		Wait(3.500, Ignore Condition);
		Small Message(Event Player, Custom String("Island Party - Heroes Minigames v2.0.0-21"));
		Wait(3.500, Ignore Condition);
		Small Message(Event Player, Custom String("Play rounds of {0} minigames", Count Of(Global.heroList)));
		Wait(3.500, Ignore Condition);
		Small Message(Event Player, Custom String("Created by Jokaes#2263"));
	}
}

rule("On kill: full heal")
{
	event
	{
		Player Dealt Final Blow;
		All;
		All;
	}

	conditions
	{
		Victim != Event Player;
		Hero Of(Event Player) != Hero(Ana);
		Hero Of(Event Player) != Hero(Brigitte);
		Hero Of(Event Player) != Hero(Doomfist);
		Hero Of(Event Player) != Hero(D.Va);
		Hero Of(Event Player) != Hero(Echo);
		Hero Of(Event Player) != Hero(McCree);
		Hero Of(Event Player) != Hero(Mei);
		Hero Of(Event Player) != Hero(Mercy);
		Hero Of(Event Player) != Hero(Pharah);
		Hero Of(Event Player) != Hero(Roadhog);
		Hero Of(Event Player) != Hero(Sigma);
		Hero Of(Event Player) != Hero(Soldier: 76);
		Hero Of(Event Player) != Hero(Sombra);
		Hero Of(Event Player) != Hero(Tracer);
		Hero Of(Event Player) != Hero(Winston);
		Hero Of(Event Player) != Hero(Zenyatta);
	}

	actions
	{
		Play Effect(All Players(All Teams), Good Pickup Effect, Yellow, Event Player, 1);
		Heal(Event Player, Null, Max Health(Event Player));
	}
}

rule("On kill: cooldown reset")
{
	event
	{
		Player Dealt Final Blow;
		All;
		All;
	}

	conditions
	{
		Victim != Event Player;
		Hero Of(Event Player) != Hero(Ana);
		Hero Of(Event Player) != Hero(Echo);
		Hero Of(Event Player) != Hero(McCree);
		Hero Of(Event Player) != Hero(Sigma);
		Hero Of(Event Player) != Hero(Tracer);
		Hero Of(Event Player) != Hero(Winston);
	}

	actions
	{
		Set Ability Cooldown(Event Player, Button(Primary Fire), 0);
		Set Ability Cooldown(Event Player, Button(Secondary Fire), 0);
		Set Ability Cooldown(Event Player, Button(Ability 1), 0);
		Set Ability Cooldown(Event Player, Button(Ability 2), 0);
	}
}

rule("On kill: score")
{
	event
	{
		Player Dealt Final Blow;
		All;
		All;
	}

	conditions
	{
		Victim != Event Player;
		Hero Of(Event Player) != Hero(D.Va);
		Hero Of(Event Player) != Hero(Echo);
		Hero Of(Event Player) != Hero(McCree);
		Hero Of(Event Player) != Hero(Sigma);
		Hero Of(Event Player) != Hero(Tracer);
	}

	actions
	{
		Play Effect(All Players(All Teams), Good Pickup Effect, White, Event Player, 1);
		Play Effect(All Players(All Teams), Buff Explosion Sound, White, Event Player, 100);
		Modify Player Score(Event Player, 1);
		Small Message(Event Player, Custom String("+1 point with {0} {1}", Hero Icon String(Hero Of(Event Player)), Hero Of(
			Event Player)));
		Wait(0.032, Ignore Condition);
		Create HUD Text(All Players(All Teams), Hero Icon String(Hero Of(Event Player)), Event Player, Custom String("+1 point"), Right,
			-1 + Global.pointfeedHudId, Orange, White, Orange, Visible To, Default Visibility);
		Modify Global Variable(pointfeedHud, Append To Array, Last Text ID);
		Global.pointfeedHudTimes[Count Of(Global.pointfeedHud) - 1] = 3.744;
		Global.pointfeedHudId -= 0.010;
	}
}

rule("Last seconds sound")
{
	event
	{
		Ongoing - Each Player;
		All;
		All;
	}

	conditions
	{
		Global.roundTimer <= 5;
	}

	actions
	{
		Play Effect(Event Player, Explosion Sound, White, Event Player, 200);
		Wait(1, Ignore Condition);
		Loop If Condition Is True;
	}
}

rule("HUD Pointfeed reduce times")
{
	event
	{
		Ongoing - Global;
	}

	conditions
	{
		Is True For Any(Global.pointfeedHudTimes, Current Array Element == 3.744) == True;
	}

	actions
	{
		While(True);
			For Global Variable(pointfeedHudTimesIt, 0, Count Of(Global.pointfeedHudTimes), 1);
				If(Global.pointfeedHudTimes[Global.pointfeedHudTimesIt] > 0);
					Global.pointfeedHudTimes[Global.pointfeedHudTimesIt] -= 0.016;
				End;
			End;
			Wait(0.016, Ignore Condition);
		End;
	}
}

rule("Destroy HUD Pointfeed {more than 6}")
{
	event
	{
		Ongoing - Global;
	}

	conditions
	{
		Count Of(Global.pointfeedHud) > 6;
	}

	actions
	{
		While(Count Of(Global.pointfeedHud) > 6);
			Destroy HUD Text(Global.pointfeedHud[0]);
			Modify Global Variable(pointfeedHud, Remove From Array By Index, 0);
			Wait(0.032, Ignore Condition);
		End;
	}
}

rule("Destroy HUD Pointfeed {time}")
{
	event
	{
		Ongoing - Global;
	}

	conditions
	{
		Is True For Any(Global.pointfeedHudTimes, Current Array Element <= 0) == True;
	}

	actions
	{
		While(True);
			For Global Variable(pointfeedHudTimesIt, 0, Count Of(Global.pointfeedHudTimes), 1);
				If(Global.pointfeedHudTimes[Global.pointfeedHudTimesIt] <= 0);
					Destroy HUD Text(Global.pointfeedHud[Global.pointfeedHudTimesIt]);
					Modify Global Variable(pointfeedHud, Remove From Array By Index, Global.pointfeedHudTimesIt);
					Modify Global Variable(pointfeedHudTimes, Remove From Array By Index, Global.pointfeedHudTimesIt);
				End;
			End;
			Wait(0.016, Ignore Condition);
		End;
	}
}

rule("Reset HUD Pointfeed ID")
{
	event
	{
		Ongoing - Global;
	}

	conditions
	{
		Count Of(Global.pointfeedHud) == 0;
	}

	actions
	{
		Global.pointfeedHudId = 0;
	}
}

rule("HoF player HUD")
{
	event
	{
		Ongoing - Global;
	}

	conditions
	{
		Global.hofPlayersCounter != Count Of(Global.hofPlayers);
	}

	actions
	{
		Create HUD Text(All Players(All Teams), Null, Null, Custom String("{0}", Last Of(Global.hofPlayers)), Right, -500, White, White,
			Orange, Visible To and Sort Order, Default Visibility);
		Global.hofPlayersCounter = Count Of(Global.hofPlayers);
	}
}

rule("Hof append")
{
	event
	{
		Ongoing - Each Player;
		All;
		All;
	}

	actions
	{
		If(Score Of(Event Player) >= 200);
			If(Array Contains(Global.hofPlayers, Custom String("{0}", Event Player)) == False);
				Modify Global Variable(hofPlayers, Append To Array, Custom String("{0}", Event Player));
			End;
		End;
		Wait(10, Ignore Condition);
		Loop;
	}
}

rule("HoF effect")
{
	event
	{
		Ongoing - Each Player;
		All;
		All;
	}

	conditions
	{
		Score Of(Event Player) >= 200;
	}

	actions
	{
		Create Effect(Filtered Array(All Players(All Teams), Is Alive(Event Player)), Sparkles, Orange, Event Player, 1,
			Visible To Position and Radius);
		Play Effect(Event Player, Buff Impact Sound, White, Event Player, 200);
		Wait(1, Ignore Condition);
		Play Effect(Event Player, Buff Explosion Sound, White, Event Player, 200);
		Play Effect(Event Player, Buff Impact Sound, White, Event Player, 200);
		Wait(1, Ignore Condition);
		Play Effect(Event Player, Buff Explosion Sound, White, Event Player, 200);
		Play Effect(Event Player, Buff Impact Sound, White, Event Player, 200);
		Wait(1, Ignore Condition);
		Play Effect(Event Player, Buff Explosion Sound, White, Event Player, 200);
	}
}

rule("----- HEROES -----")
{
	event
	{
		Ongoing - Global;
	}
}

rule("ANA on kill")
{
	event
	{
		Player Dealt Final Blow;
		All;
		Ana;
	}

	conditions
	{
		Is Game In Progress == True;
		Global.heroOfTheRound == Hero(Ana);
	}

	actions
	{
		While(Is Using Ability 1(Event Player) == True);
			Wait(0.032, Ignore Condition);
		End;
		Set Ability Cooldown(Event Player, Button(Ability 1), 0);
	}
}

rule("BASTION tank")
{
	event
	{
		Ongoing - Each Player;
		All;
		Bastion;
	}

	conditions
	{
		Is Game In Progress == True;
		Is Alive(Event Player) == True;
		Global.heroOfTheRound == Hero(Bastion);
		Is Using Ultimate(Event Player) == False;
	}

	actions
	{
		Press Button(Event Player, Ultimate);
		Wait(0.016, Ignore Condition);
		Loop If Condition Is True;
	}
}

rule("BRIG init")
{
	event
	{
		Ongoing - Each Player;
		All;
		Brigitte;
	}

	conditions
	{
		Global.heroOfTheRound == Hero(Brigitte);
		Is Game In Progress == True;
	}

	actions
	{
		Wait(0.032, Ignore Condition);
		Set Status(Event Player, Null, Unkillable, Global.roundTimer);
	}
}

rule("BRIG standard gravity")
{
	event
	{
		Ongoing - Each Player;
		All;
		Brigitte;
	}

	conditions
	{
		Is Game In Progress == True;
		Global.heroOfTheRound == Hero(Brigitte);
		Is Firing Secondary(Event Player) != True;
		Has Status(Event Player, Stunned) == False;
	}

	actions
	{
		Set Gravity(Event Player, 100);
	}
}

rule("BRIG shield gravity")
{
	event
	{
		Ongoing - Each Player;
		All;
		Brigitte;
	}

	conditions
	{
		Is Game In Progress == True;
		Global.heroOfTheRound == Hero(Brigitte);
		Is Firing Secondary(Event Player) == True;
	}

	actions
	{
		Set Gravity(Event Player, 200);
	}
}

rule("BRIG stunned gravity & longer stun")
{
	event
	{
		Ongoing - Each Player;
		All;
		Brigitte;
	}

	conditions
	{
		Is Game In Progress == True;
		Global.heroOfTheRound == Hero(Brigitte);
		Has Status(Event Player, Stunned) == True;
	}

	actions
	{
		Set Gravity(Event Player, 25);
		Set Status(Event Player, Null, Stunned, 1.500);
	}
}

rule("BRIG speed-boosted shield bash")
{
	event
	{
		Ongoing - Each Player;
		All;
		Brigitte;
	}

	conditions
	{
		Is Game In Progress == True;
		Global.heroOfTheRound == Hero(Brigitte);
		Is Firing Primary(Event Player) == True;
		Is Firing Secondary(Event Player) == True;
	}

	actions
	{
		Set Move Speed(Event Player, 200);
		Wait(0.250, Ignore Condition);
		Set Move Speed(Event Player, 100);
	}
}

rule("BRIG ult cooldown reset")
{
	event
	{
		Ongoing - Each Player;
		All;
		Brigitte;
	}

	conditions
	{
		Is Game In Progress == True;
		Global.heroOfTheRound == Hero(Brigitte);
		Is Using Ultimate(Event Player) == True;
	}

	actions
	{
		Set Ability Cooldown(Event Player, Button(Primary Fire), 0);
		Set Ability Cooldown(Event Player, Button(Secondary Fire), 0);
		Set Ability Cooldown(Event Player, Button(Ability 1), 0);
	}
}

rule("BRIG auto-healing")
{
	event
	{
		Ongoing - Each Player;
		All;
		Brigitte;
	}

	conditions
	{
		Is Game In Progress == True;
		Global.heroOfTheRound == Hero(Brigitte);
		Health(Event Player) < Max Health(Event Player);
	}

	actions
	{
		Heal(Event Player, Null, Max Health(Event Player));
		Wait(0.032, Ignore Condition);
		Loop If Condition Is True;
	}
}

rule("BRIG end of the round {EACH PLAYER}")
{
	event
	{
		Ongoing - Each Player;
		All;
		All;
	}

	conditions
	{
		Is Game In Progress == True;
		Global.heroOfTheRound != Hero(Brigitte);
		Global.heroOfLastRound == Hero(Brigitte);
	}

	actions
	{
		Clear Status(Event Player, Unkillable);
		Set Gravity(Event Player, 100);
		Set Move Speed(Event Player, 100);
	}
}

rule("DOOM init player")
{
	event
	{
		Ongoing - Each Player;
		All;
		Doomfist;
	}

	conditions
	{
		Global.heroOfTheRound == Hero(Doomfist);
		Is Game In Progress == True;
	}

	actions
	{
		Wait(0.064, Ignore Condition);
		Disallow Button(Event Player, Primary Fire);
	}
}

rule("DOOM ult stun")
{
	event
	{
		Player Dealt Damage;
		All;
		Doomfist;
	}

	conditions
	{
		Is Game In Progress == True;
		Global.heroOfTheRound == Hero(Doomfist);
		Is Using Ultimate(Attacker) == True;
	}

	actions
	{
		Set Status(Victim, Event Player, Stunned, 3);
	}
}

rule("DOOM not using ult")
{
	event
	{
		Ongoing - Each Player;
		All;
		All;
	}

	conditions
	{
		Is Game In Progress == True;
		Global.heroOfTheRound == Hero(Doomfist);
		Is Using Ultimate(Event Player) == False;
	}

	actions
	{
		Set Move Speed(Event Player, 100);
		Disallow Button(Event Player, Primary Fire);
	}
}

rule("DOOM using ult")
{
	event
	{
		Ongoing - Each Player;
		All;
		All;
	}

	conditions
	{
		Is Game In Progress == True;
		Global.heroOfTheRound == Hero(Doomfist);
		Is Using Ultimate(Event Player) == True;
	}

	actions
	{
		Set Move Speed(Event Player, 150);
		Allow Button(Event Player, Primary Fire);
		Set Ability Cooldown(Event Player, Button(Secondary Fire), 0);
		Set Ability Cooldown(Event Player, Button(Ability 1), 0);
	}
}

rule("DOOM end of the round {EACH PLAYER}")
{
	event
	{
		Ongoing - Each Player;
		All;
		All;
	}

	conditions
	{
		Is Game In Progress == True;
		Global.heroOfTheRound != Hero(Doomfist);
		Global.heroOfLastRound == Hero(Doomfist);
	}

	actions
	{
		Allow Button(Event Player, Primary Fire);
	}
}

rule("DVA init player")
{
	event
	{
		Ongoing - Each Player;
		All;
		All;
	}

	conditions
	{
		Global.heroOfTheRound == Hero(D.Va);
		Is Alive(Event Player) == True;
		Is Game In Progress == True;
		Is In Alternate Form(Event Player) == False;
		Event Player.dvaPointsHud == Null;
	}

	actions
	{
		Event Player.dvaPointsHud = Null;
		Set Facing(Event Player, Direction Towards(Eye Position(Event Player), Global.dvaObjectivePos[0]), To World);
		Set Status(Event Player, Null, Phased Out, 60);
		Wait(0.256, Ignore Condition);
		Teleport(Event Player, Vector(0, 0, 0));
		Event Player.dvaPoints = 0;
		Set Facing(Event Player, Direction Towards(Eye Position(Event Player), Global.dvaObjectivePos[0]), To World);
		Set Status(Event Player, Null, Phased Out, 60);
		Set Status(Event Player, Null, Unkillable, Global.roundTimer);
		If(Event Player.dvaPointsHud == Null);
			Create HUD Text(All Players(All Teams), Null, Null, Custom String("{0}: {1}/5", Event Player, Event Player.dvaPoints), Left, (
				Event Player.dvaPoints + 10) * -1, White, White, Purple, Visible To Sort Order and String, Default Visibility);
			Event Player.dvaPointsHud = Last Text ID;
		End;
		Create In-World Text(Event Player, Custom String("{0} M", Distance Between(Position Of(Event Player),
			Global.dvaObjectivePos[Event Player.dvaPoints])), Global.dvaObjectivePos[Event Player.dvaPoints], 2, Clip Against Surfaces,
			Visible To Position and String, White, Default Visibility);
		Event Player.dvaDistanceText = Last Text ID;
		Set Facing(Event Player, Direction Towards(Eye Position(Event Player), Global.dvaObjectivePos[0]), To World);
		Create Icon(Event Player, Global.dvaObjectivePos[Event Player.dvaPoints] + Vector(0, 1.500, 0), Flag, Visible To and Position,
			Purple, True);
		Event Player.playerClosestObjectiveIcon = Last Created Entity;
		Set Gravity(Event Player, 0);
	}
}

rule("DVA init global")
{
	event
	{
		Ongoing - Global;
	}

	conditions
	{
		Global.heroOfTheRound == Hero(D.Va);
	}

	actions
	{
		Global.dvaObjectiveEffects = Empty Array;
		Global.dvaObjectiveIcons = Empty Array;
		Global.dvaObjectivePos = Array(Vector(Random Real(-100, 100), Random Real(45, 100), Random Real(-100, 100)), Vector(Random Real(
			-100, 100), Random Real(45, 100), Random Real(-100, 100)), Vector(Random Real(-100, 100), Random Real(45, 100), Random Real(
			-100, 100)), Vector(Random Real(-100, 100), Random Real(45, 100), Random Real(-100, 100)), Vector(Random Real(-100, 100),
			Random Real(45, 100), Random Real(-100, 100)));
		Create Effect(Filtered Array(All Players(All Teams), Current Array Element.dvaPoints == 0), Good Aura, Purple,
			Global.dvaObjectivePos[0], 3, Visible To Position and Radius);
		Modify Global Variable(dvaObjectiveEffects, Append To Array, Last Created Entity);
		Create Effect(Filtered Array(All Players(All Teams), Current Array Element.dvaPoints == 0), Good Aura, Purple,
			Global.dvaObjectivePos[0], 2, Visible To Position and Radius);
		Modify Global Variable(dvaObjectiveEffects, Append To Array, Last Created Entity);
		Create Effect(Filtered Array(All Players(All Teams), Current Array Element.dvaPoints == 0), Good Aura, Purple,
			Global.dvaObjectivePos[0], 1, Visible To Position and Radius);
		Modify Global Variable(dvaObjectiveEffects, Append To Array, Last Created Entity);
		Create Effect(Filtered Array(All Players(All Teams), Current Array Element.dvaPoints == 1), Good Aura, Purple,
			Global.dvaObjectivePos[1], 3, Visible To Position and Radius);
		Modify Global Variable(dvaObjectiveEffects, Append To Array, Last Created Entity);
		Create Effect(Filtered Array(All Players(All Teams), Current Array Element.dvaPoints == 1), Good Aura, Purple,
			Global.dvaObjectivePos[1], 2, Visible To Position and Radius);
		Modify Global Variable(dvaObjectiveEffects, Append To Array, Last Created Entity);
		Create Effect(Filtered Array(All Players(All Teams), Current Array Element.dvaPoints == 1), Good Aura, Purple,
			Global.dvaObjectivePos[1], 1, Visible To Position and Radius);
		Modify Global Variable(dvaObjectiveEffects, Append To Array, Last Created Entity);
		Create Effect(Filtered Array(All Players(All Teams), Current Array Element.dvaPoints == 2), Good Aura, Purple,
			Global.dvaObjectivePos[2], 3, Visible To Position and Radius);
		Modify Global Variable(dvaObjectiveEffects, Append To Array, Last Created Entity);
		Create Effect(Filtered Array(All Players(All Teams), Current Array Element.dvaPoints == 2), Good Aura, Purple,
			Global.dvaObjectivePos[2], 2, Visible To Position and Radius);
		Modify Global Variable(dvaObjectiveEffects, Append To Array, Last Created Entity);
		Create Effect(Filtered Array(All Players(All Teams), Current Array Element.dvaPoints == 2), Good Aura, Purple,
			Global.dvaObjectivePos[2], 1, Visible To Position and Radius);
		Modify Global Variable(dvaObjectiveEffects, Append To Array, Last Created Entity);
		Create Effect(Filtered Array(All Players(All Teams), Current Array Element.dvaPoints == 3), Good Aura, Purple,
			Global.dvaObjectivePos[3], 3, Visible To Position and Radius);
		Modify Global Variable(dvaObjectiveEffects, Append To Array, Last Created Entity);
		Create Effect(Filtered Array(All Players(All Teams), Current Array Element.dvaPoints == 3), Good Aura, Purple,
			Global.dvaObjectivePos[3], 2, Visible To Position and Radius);
		Modify Global Variable(dvaObjectiveEffects, Append To Array, Last Created Entity);
		Create Effect(Filtered Array(All Players(All Teams), Current Array Element.dvaPoints == 3), Good Aura, Purple,
			Global.dvaObjectivePos[3], 1, Visible To Position and Radius);
		Modify Global Variable(dvaObjectiveEffects, Append To Array, Last Created Entity);
		Create Effect(Filtered Array(All Players(All Teams), Current Array Element.dvaPoints == 4), Good Aura, Purple,
			Global.dvaObjectivePos[4], 3, Visible To Position and Radius);
		Modify Global Variable(dvaObjectiveEffects, Append To Array, Last Created Entity);
		Create Effect(Filtered Array(All Players(All Teams), Current Array Element.dvaPoints == 4), Good Aura, Purple,
			Global.dvaObjectivePos[4], 2, Visible To Position and Radius);
		Modify Global Variable(dvaObjectiveEffects, Append To Array, Last Created Entity);
		Create Effect(Filtered Array(All Players(All Teams), Current Array Element.dvaPoints == 4), Good Aura, Purple,
			Global.dvaObjectivePos[4], 1, Visible To Position and Radius);
		Modify Global Variable(dvaObjectiveEffects, Append To Array, Last Created Entity);
		disabled Wait(0.016, Ignore Condition);
		disabled Create Icon(Filtered Array(All Players(All Teams), Current Array Element.dvaPoints == 0), Global.dvaObjectivePos[0] + Vector(0,
			1.500, 0), Flag, Visible To and Position, Purple, True);
		disabled Modify Global Variable(dvaObjectiveIcons, Append To Array, Last Created Entity);
		disabled Create Icon(Filtered Array(All Players(All Teams), Current Array Element.dvaPoints == 1), Global.dvaObjectivePos[1] + Vector(0,
			1.500, 0), Flag, Visible To and Position, Purple, True);
		disabled Modify Global Variable(dvaObjectiveIcons, Append To Array, Last Created Entity);
		disabled Create Icon(Filtered Array(All Players(All Teams), Current Array Element.dvaPoints == 2), Global.dvaObjectivePos[2] + Vector(0,
			1.500, 0), Flag, Visible To and Position, Purple, True);
		disabled Modify Global Variable(dvaObjectiveIcons, Append To Array, Last Created Entity);
		disabled Create Icon(Filtered Array(All Players(All Teams), Current Array Element.dvaPoints == 3), Global.dvaObjectivePos[3] + Vector(0,
			1.500, 0), Flag, Visible To and Position, Purple, True);
		disabled Modify Global Variable(dvaObjectiveIcons, Append To Array, Last Created Entity);
		disabled Create Icon(Filtered Array(All Players(All Teams), Current Array Element.dvaPoints == 4), Global.dvaObjectivePos[4] + Vector(0,
			1.500, 0), Flag, Visible To and Position, Purple, True);
		disabled Modify Global Variable(dvaObjectiveIcons, Append To Array, Last Created Entity);
	}
}

rule("DVA point")
{
	event
	{
		Ongoing - Each Player;
		All;
		D.Va;
	}

	conditions
	{
		Is Game In Progress == True;
		Is Alive(Event Player) == True;
		Global.heroOfTheRound == Hero(D.Va);
		Event Player.dvaPoints < 5;
		Distance Between(Position Of(Event Player), Global.dvaObjectivePos[Event Player.dvaPoints]) <= 7.500;
	}

	actions
	{
		Modify Player Score(Event Player, 1);
		Small Message(Event Player, Custom String("+1 point with {0} {1}", Hero Icon String(Hero Of(Event Player)), Hero Of(
			Event Player)));
		Event Player.dvaPoints += 1;
		Play Effect(All Players(All Teams), Good Pickup Effect, Purple, Event Player, 1);
		Play Effect(Event Player, Buff Explosion Sound, Purple, Event Player, 100);
		Create HUD Text(All Players(All Teams), Hero Icon String(Hero Of(Event Player)), Event Player, Custom String("+1 point"), Right,
			-1 + Global.pointfeedHudId, Orange, White, Orange, Visible To, Default Visibility);
		Modify Global Variable(pointfeedHud, Append To Array, Last Text ID);
		Global.pointfeedHudTimes[Count Of(Global.pointfeedHud) - 1] = 3.744;
		Global.pointfeedHudId -= 0.010;
	}
}

rule("DVA boosting")
{
	event
	{
		Ongoing - Each Player;
		All;
		D.Va;
	}

	conditions
	{
		Is Game In Progress == True;
		Global.heroOfTheRound == Hero(D.Va);
		Is Using Ability 1(Event Player) == True;
	}

	actions
	{
		Set Move Speed(Event Player, 500);
		Set Gravity(Event Player, 0);
	}
}

rule("DVA not boosting in air")
{
	event
	{
		Ongoing - Each Player;
		All;
		D.Va;
	}

	conditions
	{
		Is Game In Progress == True;
		Global.heroOfTheRound == Hero(D.Va);
		Is Using Ability 1(Event Player) == False;
		Is In Air(Event Player) == True;
	}

	actions
	{
		Set Move Speed(Event Player, 10);
		Set Gravity(Event Player, 0);
	}
}

rule("DVA not boosting on ground")
{
	event
	{
		Ongoing - Each Player;
		All;
		D.Va;
	}

	conditions
	{
		Is Game In Progress == True;
		Global.heroOfTheRound == Hero(D.Va);
		Is Using Ability 1(Event Player) == False;
		Is On Ground(Event Player) == True;
	}

	actions
	{
		Set Move Speed(Event Player, 100);
		Set Gravity(Event Player, 100);
	}
}

disabled rule("DVA brake")
{
	event
	{
		Ongoing - Each Player;
		All;
		D.Va;
	}

	conditions
	{
		Is Game In Progress == True;
		Global.heroOfTheRound == Hero(D.Va);
		Is Button Held(Event Player, Crouch) == True;
	}

	actions
	{
		Cancel Primary Action(Event Player);
		Wait(0.048, Ignore Condition);
		disabled Apply Impulse(Event Player, Down, 0.001, To World, Cancel Contrary Motion);
		disabled Apply Impulse(Event Player, Up, 0.001, To World, Cancel Contrary Motion);
		disabled Apply Impulse(Event Player, Backward, 0.001, To World, Cancel Contrary Motion);
		disabled Apply Impulse(Event Player, Forward, 0.001, To World, Cancel Contrary Motion);
		disabled Apply Impulse(Event Player, Right, 0.001, To World, Cancel Contrary Motion);
		disabled Apply Impulse(Event Player, Left, 0.001, To World, Cancel Contrary Motion);
		Start Accelerating(Event Player, Facing Direction Of(Event Player) * -1, 100, Speed Of(Event Player), To World,
			Direction Rate and Max Speed);
		disabled Wait(1, Ignore Condition);
		Wait(0.400, Ignore Condition);
		Stop Accelerating(Event Player);
	}
}

rule("DVA baby call mecha")
{
	event
	{
		Ongoing - Each Player;
		All;
		D.Va;
	}

	conditions
	{
		Is Game In Progress == True;
		Global.heroOfTheRound == Hero(D.Va);
		Is In Alternate Form(Event Player) == True;
	}

	actions
	{
		Set Ultimate Charge(Event Player, 100);
		Press Button(Event Player, Ultimate);
		Wait(0.016, Ignore Condition);
		Set Status(Event Player, Null, Phased Out, 60);
		Set Status(Event Player, Null, Unkillable, Global.roundTimer);
		Loop If Condition Is True;
	}
}

rule("DVA winner")
{
	event
	{
		Ongoing - Each Player;
		All;
		D.Va;
	}

	conditions
	{
		Is Game In Progress == True;
		Global.heroOfTheRound == Hero(D.Va);
		Event Player.dvaPoints >= 5;
	}

	actions
	{
		Global.roundTimer = 0.032;
	}
}

rule("DVA end of the round {GLOBAL}")
{
	event
	{
		Ongoing - Global;
	}

	conditions
	{
		Is Game In Progress == True;
		Global.heroOfTheRound != Hero(D.Va);
		Global.heroOfLastRound == Hero(D.Va);
	}

	actions
	{
		Global.dvaDestructorIt = 0;
		For Global Variable(dvaDestructorIt, 0, Count Of(Global.dvaObjectiveEffects), 1);
			Destroy Effect(Global.dvaObjectiveEffects[Global.dvaDestructorIt]);
			Destroy Icon(Global.dvaObjectiveIcons[Global.dvaDestructorIt]);
		End;
	}
}

rule("DVA end of the round {EACH PLAYER}")
{
	event
	{
		Ongoing - Each Player;
		All;
		All;
	}

	conditions
	{
		Is Game In Progress == True;
		Global.heroOfTheRound != Hero(D.Va);
		Global.heroOfLastRound == Hero(D.Va);
	}

	actions
	{
		Event Player.dvaPoints = 0;
		Wait(0.016, Ignore Condition);
		Clear Status(Event Player, Phased Out);
		Clear Status(Event Player, Unkillable);
		Set Gravity(Event Player, 100);
		Set Move Speed(Event Player, 100);
		Stop Accelerating(Event Player);
		Wait(0.512, Ignore Condition);
		Destroy HUD Text(Event Player.dvaPointsHud);
		Destroy In-World Text(Event Player.dvaDistanceText);
		Destroy Icon(Event Player.playerClosestObjectiveIcon);
		Wait(0.064, Ignore Condition);
		Event Player.dvaPointsHud = Null;
	}
}

rule("ECHO init player")
{
	event
	{
		Ongoing - Each Player;
		All;
		Echo;
	}

	conditions
	{
		Global.heroOfTheRound == Hero(Echo);
		Is Alive(Event Player) == True;
	}

	actions
	{
		Event Player.echoPointsHud = Null;
		Event Player.echoPoints = 0;
		Wait(1, Ignore Condition);
		If(Event Player.echoPointsHud == Null);
			Create HUD Text(All Players(All Teams), Null, Null, Custom String("{0}: {1}/40 = {2}/4 points", Event Player,
				Event Player.echoPoints, Round To Integer(Event Player.echoPoints / 10, Down)), Left, (Event Player.echoPoints + 10) * -1,
				White, White, Aqua, Visible To Sort Order and String, Default Visibility);
			Event Player.echoPointsHud = Last Text ID;
		End;
		Set Status(Event Player, Null, Unkillable, Global.roundTimer);
	}
}

rule("ECHO init global")
{
	event
	{
		Ongoing - Global;
	}

	conditions
	{
		Global.heroOfTheRound == Hero(Echo);
	}

	actions
	{
		"Creates the array to store the effects of the common rings"
		Global.commonRingsEffects = Empty Array;
		"Creates the array to store the positions of the common rings"
		Global.commonRingsPos = Empty Array;
		"Append to the array commonRingsPos the not random common ring position"
		Modify Global Variable(commonRingsPos, Append To Array, Vector(0, 16, 0));
		"Append to the array commonRingsPos a new position"
		Modify Global Variable(commonRingsPos, Append To Array, Vector(Random Real(-32, 32), Random Real(2, 32), Random Real(-32, 32)));
		"Append to the array commonRingsPos a new position"
		Modify Global Variable(commonRingsPos, Append To Array, Vector(Random Real(-32, 32), Random Real(2, 32), Random Real(-32, 32)));
		"Append to the array commonRingsPos a new position"
		Modify Global Variable(commonRingsPos, Append To Array, Vector(Random Real(-32, 32), Random Real(2, 32), Random Real(-32, 32)));
		"Append to the array commonRingsPos a new position"
		Modify Global Variable(commonRingsPos, Append To Array, Vector(Random Real(-32, 32), Random Real(2, 32), Random Real(-32, 32)));
		"Append to the array commonRingsPos a new position"
		Modify Global Variable(commonRingsPos, Append To Array, Vector(Random Real(-32, 32), Random Real(2, 32), Random Real(-32, 32)));
		"Append to the array commonRingsPos a new position"
		Modify Global Variable(commonRingsPos, Append To Array, Vector(Random Real(-32, 32), Random Real(2, 32), Random Real(-32, 32)));
		"Append to the array commonRingsPos a new position"
		Modify Global Variable(commonRingsPos, Append To Array, Vector(Random Real(-32, 32), Random Real(2, 32), Random Real(-32, 32)));
		"Creates the not random common ring"
		Create Effect(All Players(All Teams), Good Aura, White, Global.commonRingsPos[0], 1, Visible To Position and Radius);
		"Append the last created common ring to commonRingsEffects"
		Modify Global Variable(commonRingsEffects, Append To Array, Last Created Entity);
		"Create a common ring effect in the position in commonRingsPos"
		Create Effect(All Players(All Teams), Good Aura, White, Global.commonRingsPos[1], 1, Visible To Position and Radius);
		"Append the last created common ring to commonRingsEffects"
		Modify Global Variable(commonRingsEffects, Append To Array, Last Created Entity);
		"Create a common ring effect in the position in commonRingsPos"
		Create Effect(All Players(All Teams), Good Aura, White, Global.commonRingsPos[2], 1, Visible To Position and Radius);
		"Append the last created common ring to commonRingsEffects"
		Modify Global Variable(commonRingsEffects, Append To Array, Last Created Entity);
		"Create a common ring effect in the position in commonRingsPos"
		Create Effect(All Players(All Teams), Good Aura, White, Global.commonRingsPos[3], 1, Visible To Position and Radius);
		"Append the last created common ring to commonRingsEffects"
		Modify Global Variable(commonRingsEffects, Append To Array, Last Created Entity);
		"Create a common ring effect in the position in commonRingsPos"
		Create Effect(All Players(All Teams), Good Aura, White, Global.commonRingsPos[4], 1, Visible To Position and Radius);
		"Append the last created common ring to commonRingsEffects"
		Modify Global Variable(commonRingsEffects, Append To Array, Last Created Entity);
		"Create a common ring effect in the position in commonRingsPos"
		Create Effect(All Players(All Teams), Good Aura, White, Global.commonRingsPos[5], 1, Visible To Position and Radius);
		"Append the last created common ring to commonRingsEffects"
		Modify Global Variable(commonRingsEffects, Append To Array, Last Created Entity);
		"Create a common ring effect in the position in commonRingsPos"
		Create Effect(All Players(All Teams), Good Aura, White, Global.commonRingsPos[6], 1, Visible To Position and Radius);
		"Append the last created common ring to commonRingsEffects"
		Modify Global Variable(commonRingsEffects, Append To Array, Last Created Entity);
		"Create a common ring effect in the position in commonRingsPos"
		Create Effect(All Players(All Teams), Good Aura, White, Global.commonRingsPos[7], 1, Visible To Position and Radius);
		"Append the last created common ring to commonRingsEffects"
		Modify Global Variable(commonRingsEffects, Append To Array, Last Created Entity);
		"Creates the array to store the effects of the rare rings"
		Global.rareRingsEffects = Empty Array;
		"Creates the array to store the positions of the rare rings"
		Global.rareRingsPos = Empty Array;
		"Append to the array rareRingsPos a new position"
		Modify Global Variable(rareRingsPos, Append To Array, Vector(Random Real(-36, 36), Random Real(2, 36), Random Real(-36, 36)));
		"Append to the array rareRingsPos a new position"
		Modify Global Variable(rareRingsPos, Append To Array, Vector(Random Real(-36, 36), Random Real(2, 36), Random Real(-36, 36)));
		"Append to the array rareRingsPos a new position"
		Modify Global Variable(rareRingsPos, Append To Array, Vector(Random Real(-36, 36), Random Real(2, 36), Random Real(-36, 36)));
		"Append to the array rareRingsPos a new position"
		Modify Global Variable(rareRingsPos, Append To Array, Vector(Random Real(-36, 36), Random Real(2, 36), Random Real(-36, 36)));
		"Append to the array rareRingsPos a new position"
		Modify Global Variable(rareRingsPos, Append To Array, Vector(Random Real(-36, 36), Random Real(2, 36), Random Real(-36, 36)));
		"Append to the array rareRingsPos a new position"
		Modify Global Variable(rareRingsPos, Append To Array, Vector(Random Real(-36, 36), Random Real(2, 36), Random Real(-36, 36)));
		"Create a rare ring effect in the position in rareRingsPos"
		Create Effect(All Players(All Teams), Good Aura, Aqua, Global.rareRingsPos[0], 1, Visible To Position and Radius);
		"Append the last created rare ring to rareRingsEffects"
		Modify Global Variable(rareRingsEffects, Append To Array, Last Created Entity);
		"Create a rare ring effect in the position in rareRingsPos"
		Create Effect(All Players(All Teams), Good Aura, Aqua, Global.rareRingsPos[1], 1, Visible To Position and Radius);
		"Append the last created rare ring to rareRingsEffects"
		Modify Global Variable(rareRingsEffects, Append To Array, Last Created Entity);
		"Create a rare ring effect in the position in rareRingsPos"
		Create Effect(All Players(All Teams), Good Aura, Aqua, Global.rareRingsPos[2], 1, Visible To Position and Radius);
		"Append the last created rare ring to rareRingsEffects"
		Modify Global Variable(rareRingsEffects, Append To Array, Last Created Entity);
		"Create a rare ring effect in the position in rareRingsPos"
		Create Effect(All Players(All Teams), Good Aura, Aqua, Global.rareRingsPos[3], 1, Visible To Position and Radius);
		"Append the last created rare ring to rareRingsEffects"
		Modify Global Variable(rareRingsEffects, Append To Array, Last Created Entity);
		"Create a rare ring effect in the position in rareRingsPos"
		Create Effect(All Players(All Teams), Good Aura, Aqua, Global.rareRingsPos[4], 1, Visible To Position and Radius);
		"Append the last created rare ring to rareRingsEffects"
		Modify Global Variable(rareRingsEffects, Append To Array, Last Created Entity);
		"Create a rare ring effect in the position in rareRingsPos"
		Create Effect(All Players(All Teams), Good Aura, Aqua, Global.rareRingsPos[5], 1, Visible To Position and Radius);
		"Append the last created rare ring to rareRingsEffects"
		Modify Global Variable(rareRingsEffects, Append To Array, Last Created Entity);
		"Creates the array to store the effects of the epic rings"
		Global.epicRingsEffects = Empty Array;
		"Creates the array to store the positions of the epic rings"
		Global.epicRingsPos = Empty Array;
		"Append to the array epicRingsPos a new position"
		Modify Global Variable(epicRingsPos, Append To Array, Vector(Random Real(-44, 44), Random Real(2, 44), Random Real(-44, 44)));
		"Append to the array epicRingsPos a new position"
		Modify Global Variable(epicRingsPos, Append To Array, Vector(Random Real(-44, 44), Random Real(2, 44), Random Real(-44, 44)));
		"Create a epic ring effect in the position in epicRingsPos"
		Create Effect(All Players(All Teams), Good Aura, Purple, Global.epicRingsPos[0], 1, Visible To Position and Radius);
		"Append the last created epic ring to epicRingsEffects"
		Modify Global Variable(epicRingsEffects, Append To Array, Last Created Entity);
		"Create a epic ring effect in the position in epicRingsPos"
		Create Effect(All Players(All Teams), Good Aura, Purple, Global.epicRingsPos[1], 1, Visible To Position and Radius);
		"Append the last created epic ring to epicRingsEffects"
		Modify Global Variable(epicRingsEffects, Append To Array, Last Created Entity);
		"Creates the array to store the effects of the legendary rings"
		Global.legendaryRingsEffects = Empty Array;
		"Creates the array to store the positions of the legendary rings"
		Global.legendaryRingsPos = Empty Array;
		"Append to the array legendaryRingsPos a new position"
		Modify Global Variable(legendaryRingsPos, Append To Array, Vector(Random Real(-48, 48), Random Real(2, 48), Random Real(-48, 48)));
		"Create a legendary ring effect in the position in legendaryRingsPos"
		Create Effect(All Players(All Teams), Good Aura, Orange, Global.legendaryRingsPos[0], 1, Visible To Position and Radius);
		"Append the last created legendary ring to legendaryRingsEffects"
		Modify Global Variable(legendaryRingsEffects, Append To Array, Last Created Entity);
		"Creates the array to store the effects of the teleport orbs"
		Global.echoTeleportEffects = Empty Array;
		"Creates the array to store the positions of the teleport orbs"
		Global.echoTeleportPos = Empty Array;
		"Append to the array echoTeleportPos a new position"
		Modify Global Variable(echoTeleportPos, Append To Array, Vector(Random Real(-40, 40), Random Real(2, 40), Random Real(-40, 40)));
		"Create a teleport orb effect in the position in echoTeleportPos"
		Create Effect(All Players(All Teams), Orb, Green, Global.echoTeleportPos[0], 1, Visible To Position and Radius);
		"Append the last created teleport orb to echoTeleportEffects"
		Modify Global Variable(echoTeleportEffects, Append To Array, Last Created Entity);
		"Append to the array echoTeleportPos a new position"
		Modify Global Variable(echoTeleportPos, Append To Array, Vector(Random Real(-40, 40), Random Real(2, 40), Random Real(-40, 40)));
		"Create a boost orb effect in the position in echoTeleportPos"
		Create Effect(All Players(All Teams), Orb, Green, Global.echoTeleportPos[1], 1, Visible To Position and Radius);
		"Append the last created teleport orb to echoTeleportEffects"
		Modify Global Variable(echoTeleportEffects, Append To Array, Last Created Entity);
		Global.echoRightHUD = Empty Array;
		Create HUD Text(All Players(All Teams), Null, Null, Custom String(" \n"), Right, 995, White, White, White, Visible To and String,
			Default Visibility);
		Modify Global Variable(echoRightHUD, Append To Array, Last Text ID);
		Create HUD Text(All Players(All Teams), Null, Null, Custom String("White rings: 1 point"), Right, 996, White, White, White,
			Visible To and String, Default Visibility);
		Modify Global Variable(echoRightHUD, Append To Array, Last Text ID);
		Create HUD Text(All Players(All Teams), Null, Null, Custom String("Blue rings: 2 points"), Right, 997, White, White, Aqua,
			Visible To and String, Default Visibility);
		Modify Global Variable(echoRightHUD, Append To Array, Last Text ID);
		Create HUD Text(All Players(All Teams), Null, Null, Custom String("Purple rings: 4 points"), Right, 998, White, White, Purple,
			Visible To and String, Default Visibility);
		Modify Global Variable(echoRightHUD, Append To Array, Last Text ID);
		Create HUD Text(All Players(All Teams), Null, Null, Custom String("Orange rings: 5 points"), Right, 999, White, White, Orange,
			Visible To and String, Default Visibility);
		Modify Global Variable(echoRightHUD, Append To Array, Last Text ID);
		Create HUD Text(All Players(All Teams), Null, Null, Custom String(" \nTeleport"), Right, 1000, White, White, Green,
			Visible To and String, Default Visibility);
		Modify Global Variable(echoRightHUD, Append To Array, Last Text ID);
	}
}

rule("ECHO reduce speed when taking damage")
{
	event
	{
		Player Took Damage;
		All;
		All;
	}

	conditions
	{
		Is Game In Progress == True;
		Global.heroOfTheRound == Hero(Echo);
	}

	actions
	{
		Set Move Speed(Event Player, 50);
		Wait(0.500, Ignore Condition);
		Set Move Speed(Event Player, 100);
	}
}

rule("ECHO meele stun")
{
	event
	{
		Player Dealt Damage;
		All;
		Echo;
	}

	conditions
	{
		Is Game In Progress == True;
		Global.heroOfTheRound == Hero(Echo);
		Is Button Held(Attacker, Melee) == True;
	}

	actions
	{
		If(Is Button Held(Attacker, Melee) == True);
			Set Status(Victim, Event Player, Stunned, 0.750);
		End;
	}
}

rule("ECHO healing like Mercy passive")
{
	event
	{
		Ongoing - Each Player;
		All;
		Echo;
	}

	conditions
	{
		Is Game In Progress == True;
		Global.heroOfTheRound == Hero(Echo);
		Health(Event Player) < 200;
	}

	actions
	{
		Wait(0.064, Ignore Condition);
		Start Heal Over Time(Event Player, Null, Global.roundTimer, 200);
	}
}

rule("ECHO not healing")
{
	event
	{
		Ongoing - Each Player;
		All;
		Echo;
	}

	conditions
	{
		Is Game In Progress == True;
		Global.heroOfTheRound == Hero(Echo);
		Health(Event Player) == 200;
	}

	actions
	{
		Stop All Heal Over Time(Event Player);
		Wait(0.016, Ignore Condition);
	}
}

rule("ECHO points common rings")
{
	event
	{
		Ongoing - Each Player;
		All;
		Echo;
	}

	conditions
	{
		Is True For Any(Global.commonRingsPos, Distance Between(Event Player, Current Array Element) <= 2) == True;
		Is Game In Progress == True;
		Is Alive(Event Player) == True;
		Global.heroOfTheRound == Hero(Echo);
	}

	actions
	{
		Event Player.echoClosestRing = First Of(Sorted Array(Global.commonRingsPos, Distance Between(Event Player,
			Current Array Element)));
		Wait(0.016, Ignore Condition);
		Event Player.echoClosestRing = Index Of Array Value(Global.commonRingsPos, Event Player.echoClosestRing);
		Event Player.echoPoints += 1;
		Play Effect(All Players(All Teams), Good Pickup Effect, White, Event Player, 1);
		Play Effect(All Players(All Teams), Buff Explosion Sound, White, Event Player, 100);
		Global.commonRingsPos[Event Player.echoClosestRing] = Vector(Random Real(-32, 32), Random Real(2, 32), Random Real(-32, 32));
	}
}

rule("ECHO points rare rings")
{
	event
	{
		Ongoing - Each Player;
		All;
		Echo;
	}

	conditions
	{
		Is True For Any(Global.rareRingsPos, Distance Between(Event Player, Current Array Element) <= 2) == True;
		Is Game In Progress == True;
		Is Alive(Event Player) == True;
		Global.heroOfTheRound == Hero(Echo);
	}

	actions
	{
		Event Player.echoClosestRing = First Of(Sorted Array(Global.rareRingsPos, Distance Between(Event Player, Current Array Element)));
		Wait(0.016, Ignore Condition);
		Event Player.echoClosestRing = Index Of Array Value(Global.rareRingsPos, Event Player.echoClosestRing);
		Event Player.echoPoints += 2;
		Play Effect(All Players(All Teams), Good Pickup Effect, Aqua, Event Player, 1);
		Play Effect(All Players(All Teams), Buff Explosion Sound, Aqua, Event Player, 100);
		Global.rareRingsPos[Event Player.echoClosestRing] = Vector(Random Real(-36, 36), Random Real(2, 36), Random Real(-36, 36));
	}
}

rule("ECHO points epic rings")
{
	event
	{
		Ongoing - Each Player;
		All;
		Echo;
	}

	conditions
	{
		Is True For Any(Global.epicRingsPos, Distance Between(Event Player, Current Array Element) <= 2) == True;
		Is Game In Progress == True;
		Is Alive(Event Player) == True;
		Global.heroOfTheRound == Hero(Echo);
	}

	actions
	{
		Event Player.echoClosestRing = First Of(Sorted Array(Global.epicRingsPos, Distance Between(Event Player, Current Array Element)));
		Wait(0.016, Ignore Condition);
		Event Player.echoClosestRing = Index Of Array Value(Global.epicRingsPos, Event Player.echoClosestRing);
		Event Player.echoPoints += 4;
		Play Effect(All Players(All Teams), Good Pickup Effect, Purple, Event Player, 1);
		Play Effect(All Players(All Teams), Buff Explosion Sound, Purple, Event Player, 100);
		Global.epicRingsPos[Event Player.echoClosestRing] = Vector(Random Real(-44, 44), Random Real(2, 44), Random Real(-44, 44));
	}
}

rule("ECHO points legendary rings")
{
	event
	{
		Ongoing - Each Player;
		All;
		Echo;
	}

	conditions
	{
		Is True For Any(Global.legendaryRingsPos, Distance Between(Event Player, Current Array Element) <= 2) == True;
		Is Game In Progress == True;
		Is Alive(Event Player) == True;
		Global.heroOfTheRound == Hero(Echo);
	}

	actions
	{
		Event Player.echoClosestRing = First Of(Sorted Array(Global.legendaryRingsPos, Distance Between(Event Player,
			Current Array Element)));
		Wait(0.016, Ignore Condition);
		Event Player.echoClosestRing = Index Of Array Value(Global.legendaryRingsPos, Event Player.echoClosestRing);
		Event Player.echoPoints += 5;
		Play Effect(All Players(All Teams), Good Pickup Effect, Orange, Event Player, 1);
		Play Effect(All Players(All Teams), Buff Explosion Sound, Orange, Event Player, 100);
		Global.legendaryRingsPos[Event Player.echoClosestRing] = Vector(Random Real(-48, 48), Random Real(2, 48), Random Real(-48, 48));
	}
}

rule("ECHO teleports")
{
	event
	{
		Ongoing - Each Player;
		All;
		Echo;
	}

	conditions
	{
		Is True For Any(Global.echoTeleportPos, Distance Between(Event Player, Current Array Element) <= 2) == True;
		Is Game In Progress == True;
		Is Alive(Event Player) == True;
		Global.heroOfTheRound == Hero(Echo);
	}

	actions
	{
		Teleport(Event Player, Sorted Array(Global.echoTeleportPos, Distance Between(Event Player, Current Array Element))[1]);
		Wait(0.016, Ignore Condition);
		Play Effect(All Players(All Teams), Good Explosion, Green, Event Player, 1);
		Play Effect(All Players(All Teams), Explosion Sound, Green, Event Player, 100);
		Global.echoTeleportPos[0] = Vector(Random Real(-40, 40), Random Real(2, 40), Random Real(-40, 40));
		Global.echoTeleportPos[1] = Vector(Random Real(-40, 40), Random Real(2, 40), Random Real(-40, 40));
		Wait(1.500, Ignore Condition);
	}
}

rule("ECHO winner")
{
	event
	{
		Ongoing - Each Player;
		All;
		Echo;
	}

	conditions
	{
		Is Game In Progress == True;
		Global.heroOfTheRound == Hero(Echo);
		Event Player.echoPoints >= 40;
	}

	actions
	{
		Global.roundTimer = 0.032;
	}
}

rule("ECHO end of the round {GLOBAL}")
{
	event
	{
		Ongoing - Global;
	}

	conditions
	{
		Is Game In Progress == True;
		Global.heroOfTheRound != Hero(Echo);
		Global.heroOfLastRound == Hero(Echo);
	}

	actions
	{
		Wait(0.064, Ignore Condition);
		For Global Variable(ringsIt, 0, 8, 1);
			Destroy Effect(Global.commonRingsEffects[Global.ringsIt]);
			Destroy Effect(Global.rareRingsEffects[Global.ringsIt]);
			Destroy Effect(Global.epicRingsEffects[Global.ringsIt]);
			Destroy Effect(Global.legendaryRingsEffects[Global.ringsIt]);
			Destroy Effect(Global.echoTeleportEffects[Global.ringsIt]);
			Destroy HUD Text(Global.echoRightHUD[Global.ringsIt]);
		End;
		"Creates the array to store the effects of the common rings"
		Global.commonRingsEffects = Empty Array;
		"Creates the array to store the positions of the common rings"
		Global.commonRingsPos = Empty Array;
		"Creates the array to store the effects of the rare rings"
		Global.rareRingsEffects = Empty Array;
		"Creates the array to store the positions of the rare rings"
		Global.rareRingsPos = Empty Array;
		"Creates the array to store the effects of the epic rings"
		Global.epicRingsEffects = Empty Array;
		"Creates the array to store the positions of the epic rings"
		Global.epicRingsPos = Empty Array;
		"Creates the array to store the effects of the legendary rings"
		Global.legendaryRingsEffects = Empty Array;
		"Creates the array to store the positions of the legendary rings"
		Global.legendaryRingsPos = Empty Array;
		"Creates the array to store the effects of the teleports"
		Global.echoTeleportEffects = Empty Array;
		"Creates the array to store the positions of the teleports"
		Global.echoTeleportPos = Empty Array;
		For Global Variable(ringsIt, 0, 8, 1);
			"Append to the array commonRingsPos the not random common ring position"
			Modify Global Variable(commonRingsPos, Append To Array, Vector(0, -16, 0));
			"Append to the array rareRingsPos the not random rare ring position"
			Modify Global Variable(rareRingsPos, Append To Array, Vector(0, -16, 0));
			"Append to the array epicRingsPos the not random epic ring position"
			Modify Global Variable(epicRingsPos, Append To Array, Vector(0, -16, 0));
			"Append to the array legendaryRingsPos the not random legendary ring position"
			Modify Global Variable(legendaryRingsPos, Append To Array, Vector(0, -16, 0));
			"Append to the array echoTeleportPos the not random legendary ring position"
			Modify Global Variable(echoTeleportPos, Append To Array, Vector(0, -16, 0));
		End;
	}
}

rule("ECHO end of the round {EACH PLAYER}")
{
	event
	{
		Ongoing - Each Player;
		All;
		All;
	}

	conditions
	{
		Is Game In Progress == True;
		Global.heroOfTheRound != Hero(Echo);
		Global.heroOfLastRound == Hero(Echo);
	}

	actions
	{
		Wait(Event Player.echoPoints * 0.001, Ignore Condition);
		Modify Player Score(Event Player, Round To Integer(Event Player.echoPoints / 10, Down));
		If(Event Player.echoPoints >= 10);
			Small Message(Event Player, Custom String("+{0} with {1} {2}", Custom String("{0} {1}", Round To Integer(
				Event Player.echoPoints / 10, Down), Round To Integer(Event Player.echoPoints / 10, Down) > 1 ? Custom String("points")
				: Custom String("point")), Hero Icon String(Hero Of(Event Player)), Hero Of(Event Player)));
			Play Effect(All Players(All Teams), Good Pickup Effect, White, Event Player, 1);
			Play Effect(All Players(All Teams), Buff Explosion Sound, White, Event Player, 100);
			Create HUD Text(All Players(All Teams), Hero Icon String(Hero Of(Event Player)), Event Player, Custom String("+{1} {2}", Null,
				Round To Integer(Event Player.echoPoints / 10, Down), Round To Integer(Event Player.echoPoints / 10, Down) > 1 ? Custom String(
				"points") : Custom String("point")), Right, -1 + Global.pointfeedHudId, Orange, White, Orange, Visible To, Default Visibility);
			Modify Global Variable(pointfeedHud, Append To Array, Last Text ID);
			Global.pointfeedHudTimes[Count Of(Global.pointfeedHud) - 1] = 3.744;
			Global.pointfeedHudId -= 0.010;
		End;
		Clear Status(Event Player, Unkillable);
		Stop All Heal Over Time(Event Player);
		Wait(0.256, Ignore Condition);
		Destroy HUD Text(Event Player.echoPointsHud);
	}
}

rule("LUCIO init player")
{
	event
	{
		Ongoing - Each Player;
		All;
		Lúcio;
	}

	conditions
	{
		Is Game In Progress == True;
		Global.heroOfTheRound == Hero(Lúcio);
	}

	actions
	{
		Event Player.lucioPointsHud = Null;
		Create Icon(Event Player, First Of(Sorted Array(Global.snotPos, Distance Between(Position Of(Event Player),
			Current Array Element))), Circle, Visible To and Position, Green, True);
		Event Player.lucioClosestSnotIcon = Last Created Entity;
		Event Player.lucioSpeed = 100;
		Event Player.lucioPoints = 0;
		Event Player.lucioHasBeenOnWall = False;
		Wait(0.256, Ignore Condition);
		Create HUD Text(Event Player, String("{0} m/s", Horizontal Speed Of(Event Player)), Null, Null, Left, 2, Green, White, White,
			Visible To and String, Default Visibility);
		Event Player.playerSpeedHud = Last Text ID;
		Wait(0.016, Ignore Condition);
		If(Event Player.lucioPointsHud == Null);
			Create HUD Text(All Players(All Teams), Null, Null, Custom String("{0}: {1}/8 = {2}/4 points", Event Player,
				Event Player.lucioPoints, Round To Integer(Event Player.lucioPoints / 2, Down)), Left, (Event Player.lucioPoints + 10) * -1,
				White, White, Green, Visible To Sort Order and String, Default Visibility);
			Event Player.lucioPointsHud = Last Text ID;
		End;
	}
}

rule("LUCIO Snot")
{
	event
	{
		Ongoing - Global;
	}

	conditions
	{
		Is Game In Progress == True;
		Global.heroOfTheRound == Hero(Lúcio);
	}

	actions
	{
		Global.snotPos = Empty Array;
		Global.snotEffects = Empty Array;
		Global.snotPosRandomXComp = Random Real(-18, 18);
		Global.snotPosRandomYComp = Random Real(-4, -14);
		Modify Global Variable(snotPos, Append To Array, Ray Cast Hit Position(Vector(Global.snotPosRandomXComp, Global.snotPosRandomYComp,
			35), Vector(Global.snotPosRandomXComp, Global.snotPosRandomYComp, -35), Null, All Players(All Teams), False));
		Create Effect(All Players(All Teams), Orb, Green, Global.snotPos[0] + Forward, 1, Visible To Position and Radius);
		Modify Global Variable(snotEffects, Append To Array, Last Created Entity);
		Global.snotPosRandomXComp = Random Real(-18, 18);
		Global.snotPosRandomYComp = Random Real(-4, -14);
		Modify Global Variable(snotPos, Append To Array, Ray Cast Hit Position(Vector(Global.snotPosRandomXComp, Global.snotPosRandomYComp,
			35), Vector(Global.snotPosRandomXComp, Global.snotPosRandomYComp, -35), Null, All Players(All Teams), False));
		Create Effect(All Players(All Teams), Orb, Green, Global.snotPos[1] + Forward, 1, Visible To Position and Radius);
		Modify Global Variable(snotEffects, Append To Array, Last Created Entity);
		Global.snotPosRandomXComp = Random Real(-18, 18);
		Global.snotPosRandomYComp = Random Real(-4, -14);
		Modify Global Variable(snotPos, Append To Array, Ray Cast Hit Position(Vector(Global.snotPosRandomXComp, Global.snotPosRandomYComp,
			-35), Vector(Global.snotPosRandomXComp, Global.snotPosRandomYComp, 35), Null, All Players(All Teams), False));
		Create Effect(All Players(All Teams), Orb, Green, Global.snotPos[2] + Backward, 1, Visible To Position and Radius);
		Modify Global Variable(snotEffects, Append To Array, Last Created Entity);
		Global.snotPosRandomXComp = Random Real(-18, 18);
		Global.snotPosRandomYComp = Random Real(-4, -14);
		Modify Global Variable(snotPos, Append To Array, Ray Cast Hit Position(Vector(Global.snotPosRandomXComp, Global.snotPosRandomYComp,
			-35), Vector(Global.snotPosRandomXComp, Global.snotPosRandomYComp, 35), Null, All Players(All Teams), False));
		Create Effect(All Players(All Teams), Orb, Green, Global.snotPos[3] + Backward, 1, Visible To Position and Radius);
		Modify Global Variable(snotEffects, Append To Array, Last Created Entity);
		Wait(1, Ignore Condition);
		Global.snotPosRandomZComp = Random Real(-18, 18);
		Global.snotPosRandomYComp = Random Real(-4, -14);
		Modify Global Variable(snotPos, Append To Array, Ray Cast Hit Position(Vector(35, Global.snotPosRandomYComp,
			Global.snotPosRandomZComp), Vector(-35, Global.snotPosRandomYComp, Global.snotPosRandomZComp), Null, All Players(All Teams),
			False));
		Create Effect(All Players(All Teams), Orb, Green, Global.snotPos[4] + Left, 1, Visible To Position and Radius);
		Modify Global Variable(snotEffects, Append To Array, Last Created Entity);
		Global.snotPosRandomZComp = Random Real(-18, 18);
		Global.snotPosRandomYComp = Random Real(-4, -14);
		Modify Global Variable(snotPos, Append To Array, Ray Cast Hit Position(Vector(35, Global.snotPosRandomYComp,
			Global.snotPosRandomZComp), Vector(-35, Global.snotPosRandomYComp, Global.snotPosRandomZComp), Null, All Players(All Teams),
			False));
		Create Effect(All Players(All Teams), Orb, Green, Global.snotPos[5] + Left, 1, Visible To Position and Radius);
		Modify Global Variable(snotEffects, Append To Array, Last Created Entity);
		Global.snotPosRandomZComp = Random Real(-18, 18);
		Global.snotPosRandomYComp = Random Real(-4, -14);
		Modify Global Variable(snotPos, Append To Array, Ray Cast Hit Position(Vector(-35, Global.snotPosRandomYComp,
			Global.snotPosRandomZComp), Vector(35, Global.snotPosRandomYComp, Global.snotPosRandomZComp), Null, All Players(All Teams),
			False));
		Create Effect(All Players(All Teams), Orb, Green, Global.snotPos[6] + Right, 1, Visible To Position and Radius);
		Modify Global Variable(snotEffects, Append To Array, Last Created Entity);
		Global.snotPosRandomZComp = Random Real(-18, 18);
		Global.snotPosRandomYComp = Random Real(-4, -14);
		Modify Global Variable(snotPos, Append To Array, Ray Cast Hit Position(Vector(-35, Global.snotPosRandomYComp,
			Global.snotPosRandomZComp), Vector(35, Global.snotPosRandomYComp, Global.snotPosRandomZComp), Null, All Players(All Teams),
			False));
		Create Effect(All Players(All Teams), Orb, Green, Global.snotPos[7] + Right, 1, Visible To Position and Radius);
		Modify Global Variable(snotEffects, Append To Array, Last Created Entity);
	}
}

rule("LUCIO point")
{
	event
	{
		Ongoing - Each Player;
		All;
		Lúcio;
	}

	conditions
	{
		Is True For Any(Global.snotPos, Distance Between(Event Player, Current Array Element) <= 2) == True;
		Is Game In Progress == True;
		Is Alive(Event Player) == True;
		Global.heroOfTheRound == Hero(Lúcio);
	}

	actions
	{
		Event Player.lucioClosestSnot = First Of(Sorted Array(Global.snotPos, Distance Between(Event Player, Current Array Element)));
		Wait(0.016, Ignore Condition);
		Event Player.lucioClosestSnot = Index Of Array Value(Global.snotPos, Event Player.lucioClosestSnot);
		Event Player.lucioPoints += 1;
		Event Player.lucioSpeed = Event Player.lucioSpeed + 12.500;
		Set Move Speed(Event Player, Event Player.lucioSpeed);
		Skip(Random Value In Array(Array(0, 7)));
		Global.snotPosRandomXComp = Random Real(-18, 18);
		Global.snotPosRandomYComp = Random Real(-4, -14);
		Skip(Random Value In Array(Array(0, 2)));
		Global.snotPos[Event Player.lucioClosestSnot] = Ray Cast Hit Position(Vector(Global.snotPosRandomXComp, Global.snotPosRandomYComp,
			35), Vector(Global.snotPosRandomXComp, Global.snotPosRandomYComp, -35), Null, All Players(All Teams), False) + Forward;
		Skip(1);
		Global.snotPos[Event Player.lucioClosestSnot] = Ray Cast Hit Position(Vector(Global.snotPosRandomXComp, Global.snotPosRandomYComp,
			-35), Vector(Global.snotPosRandomXComp, Global.snotPosRandomYComp, 35), Null, All Players(All Teams), False) + Backward;
		Skip(6);
		Global.snotPosRandomZComp = Random Real(-18, 18);
		Global.snotPosRandomYComp = Random Real(-4, -14);
		Skip(Random Value In Array(Array(0, 2)));
		Global.snotPos[Event Player.lucioClosestSnot] = Ray Cast Hit Position(Vector(35, Global.snotPosRandomYComp,
			Global.snotPosRandomZComp), Vector(-35, Global.snotPosRandomYComp, Global.snotPosRandomZComp), Null, All Players(All Teams),
			False) + Left;
		Skip(1);
		Global.snotPos[Event Player.lucioClosestSnot] = Ray Cast Hit Position(Vector(-35, Global.snotPosRandomYComp,
			Global.snotPosRandomZComp), Vector(35, Global.snotPosRandomYComp, Global.snotPosRandomZComp), Null, All Players(All Teams),
			False) + Right;
		Wait(0.016, Ignore Condition);
		Play Effect(All Players(All Teams), Good Pickup Effect, Green, Event Player, 1);
		Play Effect(All Players(All Teams), Buff Explosion Sound, Green, Event Player, 100);
	}
}

rule("LUCIO on ground = reset speed")
{
	event
	{
		Ongoing - Each Player;
		All;
		Lúcio;
	}

	conditions
	{
		Is Game In Progress == True;
		Is Alive(Event Player) == True;
		Global.heroOfTheRound == Hero(Lúcio);
		Is On Ground(Event Player) == True;
		Event Player.lucioSpeed > 100;
	}

	actions
	{
		Event Player.lucioSpeed = 100;
		Set Move Speed(Event Player, Event Player.lucioSpeed);
		Play Effect(Event Player, Debuff Impact Sound, Green, Event Player, 100);
		Small Message(Event Player, Custom String("on ground = speed reset"));
	}
}

rule("LUCIO winner")
{
	event
	{
		Ongoing - Each Player;
		All;
		Lúcio;
	}

	conditions
	{
		Is Game In Progress == True;
		Global.heroOfTheRound == Hero(Lúcio);
		Event Player.lucioPoints >= 8;
	}

	actions
	{
		Global.roundTimer = 0.032;
	}
}

rule("LUCIO end of the round {GLOBAL}")
{
	event
	{
		Ongoing - Global;
	}

	conditions
	{
		Is Game In Progress == True;
		Global.heroOfTheRound != Hero(Lúcio);
		Global.heroOfLastRound == Hero(Lúcio);
	}

	actions
	{
		Wait(0.064, Ignore Condition);
		For Global Variable(destructorIt, 0, 8, 1);
			Destroy Effect(Global.snotEffects[Global.destructorIt]);
		End;
		Global.snotEffects = Empty Array;
		For Global Variable(ringsIt, 0, 8, 1);
			Modify Global Variable(snotPos, Append To Array, Vector(0, -16, 0));
		End;
	}
}

rule("LUCIO end of the round {EACH PLAYER}")
{
	event
	{
		Ongoing - Each Player;
		All;
		All;
	}

	conditions
	{
		Is Game In Progress == True;
		Global.heroOfTheRound != Hero(Lúcio);
		Global.heroOfLastRound == Hero(Lúcio);
	}

	actions
	{
		Wait(Event Player.lucioPoints * 0.016, Ignore Condition);
		Modify Player Score(Event Player, Round To Integer(Event Player.lucioPoints / 2, Down));
		If(Event Player.lucioPoints >= 2);
			Small Message(Event Player, Custom String("+{0} with {1} {2}", Custom String("{0} {1}", Round To Integer(
				Event Player.lucioPoints / 2, Down), Round To Integer(Event Player.lucioPoints / 2, Down) > 1 ? Custom String("points")
				: Custom String("point")), Hero Icon String(Hero Of(Event Player)), Hero Of(Event Player)));
			Play Effect(All Players(All Teams), Good Pickup Effect, White, Event Player, 1);
			Play Effect(All Players(All Teams), Buff Explosion Sound, White, Event Player, 100);
			Create HUD Text(All Players(All Teams), Hero Icon String(Hero Of(Event Player)), Event Player, Custom String("+{1} {2}", Null,
				Round To Integer(Event Player.lucioPoints / 2, Down), Round To Integer(Event Player.lucioPoints / 2, Down) > 1 ? Custom String(
				"points") : Custom String("point")), Right, -1 + Global.pointfeedHudId, Orange, White, Orange, Visible To, Default Visibility);
			Modify Global Variable(pointfeedHud, Append To Array, Last Text ID);
			Global.pointfeedHudTimes[Count Of(Global.pointfeedHud) - 1] = 3.744;
			Global.pointfeedHudId -= 0.010;
		End;
		Destroy HUD Text(Event Player.playerSpeedHud);
		Destroy Icon(Event Player.lucioClosestSnotIcon);
		Set Move Speed(Event Player, 100);
		Wait(0.256, Ignore Condition);
		Destroy HUD Text(Event Player.lucioPointsHud);
	}
}

rule("MCCREE init player")
{
	event
	{
		Ongoing - Each Player;
		All;
		McCree;
	}

	conditions
	{
		Global.heroOfTheRound == Hero(McCree);
		disabled Is Alive(Event Player) == True;
	}

	actions
	{
		Event Player.mccreeHealthHud = Null;
		Wait(0.256, Ignore Condition);
		If(Event Player.mccreeHealthHud == Null);
			Create HUD Text(All Players(All Teams), Null, Null, Custom String("{0} : {1} HP {2}", Event Player, Round To Integer(Health(
				Event Player), Up), Global.potatoHolder == Event Player ? Icon String(Fire) : Custom String(" ")), Left, Health(Event Player)
				* -1, White, White, Red, Visible To Sort Order and String, Default Visibility);
			Event Player.mccreeHealthHud = Last Text ID;
		End;
		Start Damage Modification(All Players(All Teams), All Players(All Teams), 50, Receivers Damagers and Damage Percent);
	}
}

rule("MCCREE choose a potato holder")
{
	event
	{
		Ongoing - Global;
	}

	conditions
	{
		Is Game In Progress == True;
		Global.heroOfTheRound == Hero(McCree);
		Global.potatoHolder == Null;
	}

	actions
	{
		Global.potatoHolder = Random Value In Array(All Living Players(All Teams));
		Global.potatoPos = Global.potatoHolder;
		Loop If Condition Is True;
	}
}

rule("MCCREE potato effect")
{
	event
	{
		Ongoing - Global;
	}

	conditions
	{
		Is Game In Progress == True;
		Global.heroOfTheRound == Hero(McCree);
	}

	actions
	{
		Create Effect(All Players(All Teams), Bad Aura, Red, Global.potatoPos, 1, Visible To Position and Radius);
		Global.potatoEffect = Last Created Entity;
		Create Icon(All Players(All Teams), Global.potatoPos, Fire, Visible To and Position, Red, True);
		Global.potatoIcon = Last Created Entity;
	}
}

rule("MCCREE potato holder")
{
	event
	{
		Ongoing - Each Player;
		All;
		McCree;
	}

	conditions
	{
		Is Game In Progress == True;
		Is Alive(Event Player) == True;
		Global.heroOfTheRound == Hero(McCree);
		Event Player == Global.potatoHolder;
	}

	actions
	{
		Set Status(Event Player, Null, Burning, Global.roundTimer);
		Play Effect(All Players(All Teams), Debuff Impact Sound, White, Event Player, 50);
		Start Damage Over Time(Event Player, Null, Global.roundTimer, 250);
		Set Move Speed(Event Player, 110);
		Allow Button(Event Player, Primary Fire);
		Allow Button(Event Player, Melee);
		Set Ability Cooldown(Event Player, Button(Ability 1), 0);
	}
}

rule("MCCREE not potato holder")
{
	event
	{
		Ongoing - Each Player;
		All;
		McCree;
	}

	conditions
	{
		Is Game In Progress == True;
		Global.heroOfTheRound == Hero(McCree);
		Event Player != Global.potatoHolder;
	}

	actions
	{
		Clear Status(Event Player, Burning);
		Stop All Damage Over Time(Event Player);
		Set Move Speed(Event Player, 100);
		Disallow Button(Event Player, Primary Fire);
		Disallow Button(Event Player, Melee);
	}
}

rule("MCCREE pass the potato")
{
	event
	{
		Player Dealt Damage;
		All;
		McCree;
	}

	conditions
	{
		Is Game In Progress == True;
		Is Alive(Event Player) == True;
		Global.heroOfTheRound == Hero(McCree);
		Event Player == Global.potatoHolder;
	}

	actions
	{
		Destroy In-World Text(Event Player.mccreeInvincibleText);
		Destroy HUD Text(Event Player.mccreeInvincibleHud);
		Global.potatoHolder = Victim;
		Global.potatoPos = Victim;
		Event Player.mccreeInvincibleTime = 1;
		Set Status(Event Player, Null, Invincible, Event Player.mccreeInvincibleTime);
		Create In-World Text(Filtered Array(All Players(All Teams), Event Player.mccreeInvincibleTime > 0), Custom String(
			"INVINCIBLE: {0}", Event Player.mccreeInvincibleTime), Attacker, 1, Clip Against Surfaces, Visible To Position and String,
			Yellow, Default Visibility);
		Event Player.mccreeInvincibleText = Last Text ID;
		Wait(0.016, Ignore Condition);
		Create HUD Text(Filtered Array(Event Player, Event Player.mccreeInvincibleTime > 0), Custom String("INVINCIBLE: {0}",
			Event Player.mccreeInvincibleTime), Null, Null, Left, 2, Yellow, White, White, Visible To and String, Default Visibility);
		Event Player.mccreeInvincibleHud = Last Text ID;
		Wait(0.016, Ignore Condition);
		Chase Player Variable Over Time(Event Player, mccreeInvincibleTime, 0, Event Player.mccreeInvincibleTime,
			Destination and Duration);
		Set Ability Cooldown(Attacker, Button(Ability 1), 0);
		Set Ability Cooldown(Victim, Button(Ability 1), 0);
		If(Event Ability == Button(Melee));
			Heal(Attacker, Null, 15);
			Play Effect(All Players(All Teams), Ring Explosion, Yellow, Event Player, 1);
			Play Effect(All Players(All Teams), Ring Explosion, Yellow, Event Player, 2);
			Play Effect(All Players(All Teams), Ring Explosion, Yellow, Event Player, 3);
		End;
	}
}

rule("MCCREE potato holder dies")
{
	event
	{
		Player Died;
		All;
		All;
	}

	conditions
	{
		Is Game In Progress == True;
		Global.heroOfTheRound == Hero(McCree);
		Event Player == Global.potatoHolder;
	}

	actions
	{
		Global.potatoHolder = Null;
	}
}

rule("MCCREE potato holder leaves")
{
	event
	{
		Player Left Match;
		All;
		All;
	}

	conditions
	{
		Is Game In Progress == True;
		Global.heroOfTheRound == Hero(McCree);
		Event Player == Global.potatoHolder;
	}

	actions
	{
		Global.potatoHolder = Null;
	}
}

rule("MCCREE win {OUT OF TIME}")
{
	event
	{
		Ongoing - Each Player;
		All;
		McCree;
	}

	conditions
	{
		Is Game In Progress == True;
		Is Alive(Event Player) == True;
		Global.heroOfTheRound == Hero(McCree);
		Global.roundTimer <= 0.500;
		Number of Players(All Teams) > 1;
		Round To Integer(Count Of(Global.playersStartOfTheRound) / Number of Living Players(All Teams), Up) - 1 > 0;
	}

	actions
	{
		Play Effect(All Players(All Teams), Good Pickup Effect, White, Event Player, 1);
		Play Effect(All Players(All Teams), Buff Explosion Sound, White, Event Player, 100);
		Modify Player Score(Event Player, Round To Integer(Count Of(Global.playersStartOfTheRound) / Number of Living Players(All Teams),
			Up) - 1);
		Small Message(Event Player, Custom String("+{0} with {1} {2}", Custom String("{0} {1}", Round To Integer(Count Of(
			Global.playersStartOfTheRound) / Number of Living Players(All Teams), Up) - 1, Round To Integer(Count Of(
			Global.playersStartOfTheRound) / Number of Living Players(All Teams), Up) - 1 > 1 ? Custom String("points") : Custom String(
			"point")), Hero Icon String(Hero Of(Event Player)), Hero Of(Event Player)));
		Create HUD Text(All Players(All Teams), Hero Icon String(Hero Of(Event Player)), Event Player, Custom String("+{1} {2}", Null,
			Round To Integer(Count Of(Global.playersStartOfTheRound) / Count Of(All Living Players(All Teams)), Up) - 1, Round To Integer(
			Count Of(Global.playersStartOfTheRound) / Number of Living Players(All Teams), Up) - 1 > 1 ? Custom String("points")
			: Custom String("point")), Right, -1 + Global.pointfeedHudId, Orange, White, Orange, Visible To, Default Visibility);
		Modify Global Variable(pointfeedHud, Append To Array, Last Text ID);
		Global.pointfeedHudTimes[Count Of(Global.pointfeedHud) - 1] = 3.744;
		Global.pointfeedHudId -= 0.010;
	}
}

rule("MCCREE win {LAST PLAYER ALIVE}")
{
	event
	{
		Ongoing - Each Player;
		All;
		McCree;
	}

	conditions
	{
		Is Game In Progress == True;
		Is Alive(Event Player) == True;
		Global.heroOfTheRound == Hero(McCree);
		Number of Living Players(All Teams) <= 1;
		Number of Players(All Teams) > 1;
		Round To Integer(Count Of(Global.playersStartOfTheRound) / Number of Living Players(All Teams), Up) - 1 > 0;
	}

	actions
	{
		Play Effect(All Players(All Teams), Good Pickup Effect, White, Event Player, 1);
		Play Effect(All Players(All Teams), Buff Explosion Sound, White, Event Player, 100);
		Modify Player Score(Event Player, Count Of(Global.playersStartOfTheRound) - 1);
		Small Message(Event Player, Custom String("+{0} with {1} {2}", Custom String("{0} {1}", Round To Integer(Count Of(
			Global.playersStartOfTheRound) / Number of Living Players(All Teams), Up) - 1, Round To Integer(Count Of(
			Global.playersStartOfTheRound) / Number of Living Players(All Teams), Up) - 1 > 1 ? Custom String("points") : Custom String(
			"point")), Hero Icon String(Hero Of(Event Player)), Hero Of(Event Player)));
		Create HUD Text(All Players(All Teams), Hero Icon String(Hero Of(Event Player)), Event Player, Custom String("+{1} {2}", Null,
			Round To Integer(Count Of(Global.playersStartOfTheRound) / Count Of(All Living Players(All Teams)), Up) - 1, Round To Integer(
			Count Of(Global.playersStartOfTheRound) / Number of Living Players(All Teams), Up) - 1 > 1 ? Custom String("points")
			: Custom String("point")), Right, -1 + Global.pointfeedHudId, Orange, White, Orange, Visible To, Default Visibility);
		Modify Global Variable(pointfeedHud, Append To Array, Last Text ID);
		Global.pointfeedHudTimes[Count Of(Global.pointfeedHud) - 1] = 3.744;
		Global.pointfeedHudId -= 0.010;
	}
}

rule("MCCREE end of the round {GLOBAL}")
{
	event
	{
		Ongoing - Global;
	}

	conditions
	{
		Is Game In Progress == True;
		Global.heroOfTheRound != Hero(McCree);
		Global.heroOfLastRound == Hero(McCree);
	}

	actions
	{
		Destroy Effect(Global.potatoEffect);
		Destroy Icon(Global.potatoIcon);
		Global.potatoHolder = Null;
	}
}

rule("MCCREE end of the round {EACH PLAYER}")
{
	event
	{
		Ongoing - Each Player;
		All;
		All;
	}

	conditions
	{
		Is Game In Progress == True;
		Global.heroOfTheRound != Hero(McCree);
		Global.heroOfLastRound == Hero(McCree);
	}

	actions
	{
		Clear Status(Event Player, Burning);
		Stop Damage Over Time(Last Damage Over Time ID);
		Stop All Damage Modifications;
		Set Move Speed(Event Player, 100);
		Allow Button(Event Player, Primary Fire);
		Allow Button(Event Player, Melee);
		Wait(1, Ignore Condition);
		Destroy HUD Text(Event Player.mccreeHealthHud);
	}
}

rule("MEI init player")
{
	event
	{
		Ongoing - Each Player;
		All;
		Mei;
	}

	conditions
	{
		Global.heroOfTheRound == Hero(Mei);
		Is Alive(Event Player) == True;
		Is Game In Progress == True;
	}

	actions
	{
		Wait(0.016, Ignore Condition);
		Set Max Health(Event Player, 0.001);
		Set Damage Dealt(Event Player, 1000);
		Event Player.meiAmmo = 0;
		Disallow Button(Event Player, Secondary Fire);
		Disallow Button(Event Player, Ultimate);
		Event Player.meiIsPickingSnow = False;
		Set Status(Event Player, Null, Unkillable, 60);
		Wait(1, Ignore Condition);
		disabled Allow Button(Event Player, Secondary Fire);
		Event Player.meiAmmo = 1;
		Event Player.meiPickingSnowTimer = 1;
		Set Max Health(Event Player, 0.001);
		Create HUD Text(Event Player, Custom String("{1} AMMO: {0}/3", Event Player.meiAmmo, Ability Icon String(Hero(Mei), Button(
			Secondary Fire))), Null, Null, Left, 0, Sky Blue, White, White, Visible To and String, Default Visibility);
		Event Player.meiAmmoHud = Last Text ID;
		Create HUD Text(Filtered Array(Event Player, Event Player.meiMeeleCatchCooldown >= 2), Custom String("{1} CATCH COOLDOWN: {0}",
			Event Player.meiMeeleCatchCooldown, Ability Icon String(Hero(Mei), Button(Melee))), Null, Null, Left, 0.100, Sky Blue, White,
			White, Visible To and String, Default Visibility);
		Event Player.meiCatchActiveCooldownHud = Last Text ID;
		Create HUD Text(Filtered Array(Event Player, Event Player.meiMeeleCatchCooldown > 0 && Event Player.meiMeeleCatchCooldown < 2),
			Custom String("{1} CATCH COOLDOWN: {0}", Event Player.meiMeeleCatchCooldown, Ability Icon String(Hero(Mei), Button(Melee))),
			Null, Null, Left, 0.100, White, White, White, Visible To and String, Default Visibility);
		Event Player.meiCatchCooldownHud = Last Text ID;
		Create Icon(Filtered Array(All Players(All Teams), Event Player.meiAmmo > 0 && Is Alive(Event Player)), Event Player, Asterisk,
			Visible To and Position, Sky Blue, False);
		Event Player.meiHasAmmoIcon = Last Created Entity;
		Create In-World Text(Filtered Array(Event Player, Event Player.meiHasPickedUpAnyAmmo == False), Custom String("{0} crouch on me",
			Icon String(Arrow: Down)), First Of(Sorted Array(Global.meiSnowPos, Distance Between(Position Of(Event Player),
			Current Array Element))) + Vector(0, 0.500, 0), 1, Clip Against Surfaces, Visible To Position and String, Sky Blue,
			Default Visibility);
		Event Player.meiCrouchOnMeText = Last Text ID;
		Create Effect(Filtered Array(All Players(All Teams), Event Player.meiMeeleCatchCooldown >= 2), Sphere, Sky Blue, Event Player, 1,
			Visible To Position and Radius);
		Event Player.meiCatchSphereEffect = Last Created Entity;
	}
}

rule("MEI init global")
{
	event
	{
		Ongoing - Global;
	}

	conditions
	{
		Global.heroOfTheRound == Hero(Mei);
		Is Game In Progress == True;
	}

	actions
	{
		"Creates the array to store the effects of the snow spots"
		Global.meiSnowEffects = Empty Array;
		"Creates the array to store the positions of the snow spots"
		Global.meiSnowPos = Empty Array;
		For Global Variable(meiSnowIt, 0, Round To Integer(Count Of(Global.playersStartOfTheRound) / 3, Up) + 1, 1);
			"Append to the array meiSnowPos a new position"
			Modify Global Variable(meiSnowPos, Append To Array, Vector(Random Real(-16, 16), -0.500, Random Real(-16, 16)));
			Wait(0.016, Ignore Condition);
		End;
		"Create a snow spot effect in the position in meiSnowPos"
		Create Effect(All Players(All Teams), Sphere, White, Global.meiSnowPos[0], 1, Visible To Position and Radius);
		"Append the last created snow spot to meiSnowEffects"
		Modify Global Variable(meiSnowEffects, Append To Array, Last Created Entity);
		"Create a snow sparkle effect in the position in meiSnowPos"
		Create Effect(All Players(All Teams), Sparkles, White, Global.meiSnowPos[0] + Vector(0, 0.500, 0), 1,
			Visible To Position and Radius);
		"Append the last created snow spot to meiSnowEffects"
		Modify Global Variable(meiSnowEffects, Append To Array, Last Created Entity);
		Abort If(Round To Integer(Count Of(Global.playersStartOfTheRound) / 3, Up) + 1 == 1);
		"Create a snow spot effect in the position in meiSnowPos"
		Create Effect(All Players(All Teams), Sphere, White, Global.meiSnowPos[1], 1, Visible To Position and Radius);
		"Append the last created snow spot to meiSnowEffects"
		Modify Global Variable(meiSnowEffects, Append To Array, Last Created Entity);
		"Create a snow sparkle effect in the position in meiSnowPos"
		Create Effect(All Players(All Teams), Sparkles, White, Global.meiSnowPos[1] + Vector(0, 0.500, 0), 1,
			Visible To Position and Radius);
		"Append the last created snow spot to meiSnowEffects"
		Modify Global Variable(meiSnowEffects, Append To Array, Last Created Entity);
		Abort If(Round To Integer(Count Of(Global.playersStartOfTheRound) / 3, Up) + 1 == 2);
		"Create a snow spot effect in the position in meiSnowPos"
		Create Effect(All Players(All Teams), Sphere, White, Global.meiSnowPos[2], 1, Visible To Position and Radius);
		"Append the last created snow spot to meiSnowEffects"
		Modify Global Variable(meiSnowEffects, Append To Array, Last Created Entity);
		"Create a snow sparkle effect in the position in meiSnowPos"
		Create Effect(All Players(All Teams), Sparkles, White, Global.meiSnowPos[2] + Vector(0, 0.500, 0), 1,
			Visible To Position and Radius);
		"Append the last created snow spot to meiSnowEffects"
		Modify Global Variable(meiSnowEffects, Append To Array, Last Created Entity);
		Abort If(Round To Integer(Count Of(Global.playersStartOfTheRound) / 3, Up) + 1 == 3);
		"Create a snow spot effect in the position in meiSnowPos"
		Create Effect(All Players(All Teams), Sphere, White, Global.meiSnowPos[3], 1, Visible To Position and Radius);
		"Append the last created snow spot to meiSnowEffects"
		Modify Global Variable(meiSnowEffects, Append To Array, Last Created Entity);
		"Create a snow sparkle effect in the position in meiSnowPos"
		Create Effect(All Players(All Teams), Sparkles, White, Global.meiSnowPos[3] + Vector(0, 0.500, 0), 1,
			Visible To Position and Radius);
		"Append the last created snow spot to meiSnowEffects"
		Modify Global Variable(meiSnowEffects, Append To Array, Last Created Entity);
		Abort If(Round To Integer(Count Of(Global.playersStartOfTheRound) / 4, Up) + 1 == 4);
		"Create a snow spot effect in the position in meiSnowPos"
		Create Effect(All Players(All Teams), Sphere, White, Global.meiSnowPos[4], 1, Visible To Position and Radius);
		"Append the last created snow spot to meiSnowEffects"
		Modify Global Variable(meiSnowEffects, Append To Array, Last Created Entity);
		"Create a snow sparkle effect in the position in meiSnowPos"
		Create Effect(All Players(All Teams), Sparkles, White, Global.meiSnowPos[4] + Vector(0, 0.500, 0), 1,
			Visible To Position and Radius);
		"Append the last created snow spot to meiSnowEffects"
		Modify Global Variable(meiSnowEffects, Append To Array, Last Created Entity);
	}
}

rule("MEI Kill")
{
	event
	{
		Player Took Damage;
		All;
		All;
	}

	conditions
	{
		Is Game In Progress == True;
		Is Alive(Event Player) == True;
		Global.heroOfTheRound == Hero(Mei);
		Event Ability != Button(Melee);
	}

	actions
	{
		If(Victim.meiIsCatching == False);
			Clear Status(Event Player, Unkillable);
			Kill(Victim, Attacker);
			"10 ult % = 20 ult %"
			Set Ultimate Charge(Attacker, Ultimate Charge Percent(Attacker) + 10);
		End;
		If(Victim.meiIsCatching == True);
			Small Message(Victim, Custom String("You catched {0} snowball", Attacker));
			Small Message(Attacker, Custom String("{0} catched your snowball", Victim));
		End;
	}
}

rule("MEI Pick up Snow")
{
	event
	{
		Ongoing - Each Player;
		All;
		Mei;
	}

	conditions
	{
		Is True For Any(Global.meiSnowPos, Distance Between(Event Player, Current Array Element) <= 2) == True;
		disabled (Is Crouching(Event Player) || Is Button Held(Event Player, Primary Fire)) == True;
		Is Crouching(Event Player) == True;
		Is Game In Progress == True;
		Is Alive(Event Player) == True;
		Global.heroOfTheRound == Hero(Mei);
	}

	actions
	{
		If(Event Player.meiAmmo < 3);
			Event Player.meiClosestSnow = First Of(Sorted Array(Global.meiSnowPos, Distance Between(Event Player, Current Array Element)));
			Wait(0.016, Ignore Condition);
			Event Player.meiClosestSnow = Index Of Array Value(Global.meiSnowPos, Event Player.meiClosestSnow);
			Play Effect(All Players(All Teams), Good Pickup Effect, White, Event Player, 1);
			Play Effect(Event Player, Buff Explosion Sound, White, Event Player, 100);
			Global.meiSnowPos[Event Player.meiClosestSnow] = Vector(Random Real(-16, 16), -0.500, Random Real(-16, 16));
			Event Player.meiAmmo += 1;
			Event Player.meiHasPickedUpAnyAmmo = True;
		Else;
			Small Message(Event Player, Custom String("MAX AMMO REACHED"));
		End;
	}
}

rule("MEI Meele Catch Cooldown")
{
	event
	{
		Ongoing - Each Player;
		All;
		Mei;
	}

	conditions
	{
		Is Game In Progress == True;
		Is Alive(Event Player) == True;
		Global.heroOfTheRound == Hero(Mei);
		Is Button Held(Event Player, Melee) == True;
		Event Player.meiMeeleCatchCooldown == 0;
	}

	actions
	{
		Wait(0.016, Ignore Condition);
		Event Player.meiIsCatching = True;
		Event Player.meiMeeleCatchCooldown = 3;
		Set Ability Cooldown(Event Player, Button(Melee), Event Player.meiMeeleCatchCooldown);
		Chase Player Variable At Rate(Event Player, meiMeeleCatchCooldown, 0, 1, None);
	}
}

rule("MEI No Meele Catch")
{
	event
	{
		Ongoing - Each Player;
		All;
		Mei;
	}

	conditions
	{
		Is Game In Progress == True;
		Is Alive(Event Player) == True;
		Global.heroOfTheRound == Hero(Mei);
		Event Player.meiMeeleCatchCooldown < 2;
	}

	actions
	{
		Event Player.meiIsCatching = False;
	}
}

rule("MEI Meele Catch Catch")
{
	event
	{
		Player Took Damage;
		All;
		All;
	}

	conditions
	{
		disabled Is In View Angle(Victim, Attacker, 45) == True;
		Victim.meiIsCatching == True;
		Is Game In Progress == True;
		Global.heroOfTheRound == Hero(Mei);
		Event Player.meiMeeleCatchCooldown >= 2;
		Event Ability == Button(Secondary Fire);
	}

	actions
	{
		disabled Victim.meiIsCatching = True;
		Victim.meiAmmo += 1;
	}
}

rule("MEI Disallow Meele")
{
	event
	{
		Ongoing - Each Player;
		All;
		All;
	}

	conditions
	{
		Is Game In Progress == True;
		Global.heroOfTheRound == Hero(Mei);
		Event Player.meiMeeleCatchCooldown > 0;
	}

	actions
	{
		Disallow Button(Event Player, Melee);
	}
}

rule("MEI Allow Meele")
{
	event
	{
		Ongoing - Each Player;
		All;
		All;
	}

	conditions
	{
		Is Game In Progress == True;
		Global.heroOfTheRound == Hero(Mei);
		Event Player.meiMeeleCatchCooldown == 0;
	}

	actions
	{
		Allow Button(Event Player, Melee);
	}
}

rule("MEI Disallow Sec. Fire")
{
	event
	{
		Ongoing - Each Player;
		All;
		All;
	}

	conditions
	{
		Is Game In Progress == True;
		Global.heroOfTheRound == Hero(Mei);
		(Event Player.meiAmmo <= 0 || Event Player.meiIsPickingSnow == True) == True;
	}

	actions
	{
		Disallow Button(Event Player, Secondary Fire);
	}
}

rule("MEI Allow Sec. Fire")
{
	event
	{
		Ongoing - Each Player;
		All;
		All;
	}

	conditions
	{
		Is Game In Progress == True;
		Is Alive(Event Player) == True;
		Global.heroOfTheRound == Hero(Mei);
		disabled Is Button Held(Event Player, Secondary Fire) == True;
		(Event Player.meiAmmo > 0 && Event Player.meiIsPickingSnow == False) == True;
		disabled (Is Crouching(Event Player) || Is Button Held(Event Player, Primary Fire)) == False;
	}

	actions
	{
		Allow Button(Event Player, Secondary Fire);
	}
}

rule("MEI Shoot")
{
	event
	{
		Ongoing - Each Player;
		All;
		Mei;
	}

	conditions
	{
		Is Game In Progress == True;
		Is Alive(Event Player) == True;
		Global.heroOfTheRound == Hero(Mei);
		Is Button Held(Event Player, Secondary Fire) == True;
		Is Firing Secondary(Event Player) == True;
		(Event Player.meiAmmo > 0 && Event Player.meiIsPickingSnow == False) == True;
		disabled (Is Crouching(Event Player) || Is Button Held(Event Player, Primary Fire)) == False;
	}

	actions
	{
		disabled Wait(0.032, Abort When False);
		Wait(0.016, Ignore Condition);
		Disallow Button(Event Player, Melee);
		If(Is Firing Secondary(Event Player) == False);
			Event Player.meiAmmo -= 1;
			If(Event Player.meiMeeleCatchCooldown == 0);
				Allow Button(Event Player, Melee);
			End;
			Abort;
		End;
		Loop;
	}
}

rule("MEI Stop Shoot")
{
	event
	{
		Ongoing - Each Player;
		All;
		Mei;
	}

	conditions
	{
		Is Game In Progress == True;
		Is Alive(Event Player) == True;
		Global.heroOfTheRound == Hero(Mei);
		Is Button Held(Event Player, Secondary Fire) == True;
	}

	actions
	{
		disabled Wait(0.368, Ignore Condition);
		If(Event Player.meiAmmo <= 0);
			Disallow Button(Event Player, Secondary Fire);
			disabled Set Status(Event Player, Null, Stunned, 0.016);
			Cancel Primary Action(Event Player);
		End;
		Wait(0.016, Ignore Condition);
		Disallow Button(Event Player, Secondary Fire);
		Loop If Condition Is True;
		disabled If(Event Player.meiAmmo > 0);
		disabled Event Player.meiAmmo -= 1;
		If(Event Player.meiAmmo > 0);
			Allow Button(Event Player, Secondary Fire);
		End;
		disabled End;
	}
}

rule("MEI Ultimate")
{
	event
	{
		Ongoing - Each Player;
		All;
		Mei;
	}

	conditions
	{
		Is Game In Progress == True;
		Is Alive(Event Player) == True;
		Global.heroOfTheRound == Hero(Mei);
		Is Button Held(Event Player, Ultimate) == True;
		Ultimate Charge Percent(Event Player) >= 100;
	}

	actions
	{
		Destroy HUD Text(Event Player.meiAmmoHud);
		Create HUD Text(Event Player, Custom String("AMMO: ∞/3", Event Player.meiAmmo), Null, Null, Left, 0, Sky Blue, White, White,
			Visible To and String, Default Visibility);
		Event Player.meiAmmoHud = Last Text ID;
		Event Player.meiAmmo = 9999;
		Set Status(Event Player, Null, Burning, Global.roundTimer);
	}
}

rule("MEI end of the round {EACH PLAYER}")
{
	event
	{
		Ongoing - Each Player;
		All;
		All;
	}

	conditions
	{
		Is Game In Progress == True;
		Global.heroOfTheRound != Hero(Mei);
		Global.heroOfLastRound == Hero(Mei);
	}

	actions
	{
		Event Player.meiAmmo = 1;
		Allow Button(Event Player, Melee);
		Allow Button(Event Player, Secondary Fire);
		Allow Button(Event Player, Ultimate);
		Event Player.meiIsPickingSnow = False;
		Set Damage Dealt(Event Player, 100);
		Clear Status(Event Player, Unkillable);
		Clear Status(Event Player, Burning);
		Set Max Health(Event Player, 100);
		Destroy HUD Text(Event Player.meiAmmoHud);
		Destroy HUD Text(Event Player.meiCatchActiveCooldownHud);
		Destroy HUD Text(Event Player.meiCatchCooldownHud);
		Destroy Icon(Event Player.meiHasAmmoIcon);
		Destroy In-World Text(Event Player.meiCrouchOnMeText);
		Destroy Effect(Event Player.meiCatchSphereEffect);
	}
}

rule("MEI end of the round {GLOBAL}")
{
	event
	{
		Ongoing - Global;
	}

	conditions
	{
		Is Game In Progress == True;
		Global.heroOfTheRound != Hero(Mei);
		Global.heroOfLastRound == Hero(Mei);
	}

	actions
	{
		Wait(0.064, Ignore Condition);
		For Global Variable(meiSnowIt, 0, 10, 1);
			Destroy Effect(Global.meiSnowEffects[Global.meiSnowIt]);
			disabled Destroy HUD Text(Global.echoRightHUD[Global.ringsIt]);
		End;
		disabled Wait(1, Ignore Condition);
		Global.meiSnowEffects = Empty Array;
		Global.meiSnowPos = Empty Array;
	}
}

rule("MERCY go back, told you")
{
	event
	{
		Ongoing - Each Player;
		All;
		Mercy;
	}

	conditions
	{
		Is Game In Progress == True;
		Global.heroOfTheRound == Hero(Mercy);
		Distance Between(Event Player, Vector(0, 0, 0)) >= 60;
	}

	actions
	{
		Small Message(Event Player, Custom String("go back"));
		Set Status(Event Player, Null, Stunned, 1);
		Wait(4, Ignore Condition);
		Abort If Condition Is False;
		Small Message(Event Player, Custom String("told you"));
		Set Status(Event Player, Null, Stunned, 5);
	}
}

rule("MERCY secondary buttons")
{
	event
	{
		Ongoing - Each Player;
		All;
		All;
	}

	conditions
	{
		Is Game In Progress == True;
		Is Alive(Event Player) == True;
		Global.heroOfTheRound == Hero(Mercy);
		(Is Button Held(Event Player, Primary Fire) || Is Button Held(Event Player, Secondary Fire)) == True;
	}

	actions
	{
		Press Button(Event Player, Melee);
	}
}

rule("PHARAH init effects")
{
	event
	{
		Ongoing - Each Player;
		All;
		Pharah;
	}

	conditions
	{
		Global.heroOfTheRound == Hero(Pharah);
		Is Alive(Event Player) == True;
	}

	actions
	{
		Wait(2, Ignore Condition);
		Create Effect(Filtered Array(All Players(All Teams), Event Player.pharahHeal == True), Good Aura, Yellow, Event Player, 1,
			Visible To Position and Radius);
		Event Player.pharahHealEffect = Last Created Entity;
		Create Effect(Filtered Array(All Players(All Teams), Health(Event Player) > 199), Good Aura, Aqua, Event Player, 1,
			Visible To Position and Radius);
		Event Player.pharahDamageBoostEffect = Last Created Entity;
		Create HUD Text(Filtered Array(Event Player, Event Player.pharahHeal == True), Custom String("HEALING"), Null, Null, Left, 2,
			Yellow, White, White, Visible To and String, Default Visibility);
		Event Player.pharahHealHud = Last Text ID;
		Create HUD Text(Filtered Array(Event Player, Health(Event Player) > 199), Custom String("DAMAGE BOOST"), Null, Null, Left, 2, Blue,
			White, White, Visible To and String, Default Visibility);
		Event Player.pharahDamageBoostHud = Last Text ID;
	}
}

rule("PHARAH damage boost")
{
	event
	{
		Ongoing - Each Player;
		All;
		Pharah;
	}

	conditions
	{
		Is Game In Progress == True;
		Global.heroOfTheRound == Hero(Pharah);
		Health(Event Player) > 199;
		Event Player.pharahHeal == True;
	}

	actions
	{
		Event Player.pharahHeal = False;
		Event Player.pharahDamageBoost = True;
		Set Damage Dealt(Event Player, 130);
		Stop All Heal Over Time(Event Player);
		Wait(0.016, Ignore Condition);
	}
}

rule("PHARAH healing")
{
	event
	{
		Ongoing - Each Player;
		All;
		Pharah;
	}

	conditions
	{
		Is Game In Progress == True;
		Global.heroOfTheRound == Hero(Pharah);
		Health(Event Player) < Max Health(Event Player);
	}

	actions
	{
		Event Player.pharahDamageBoost = False;
		Wait(0.500, Ignore Condition);
		Event Player.pharahHeal = True;
		Set Damage Dealt(Event Player, 100);
		Start Heal Over Time(Event Player, Null, Global.roundTimer, 50);
	}
}

rule("PHARAH dead")
{
	event
	{
		Player Died;
		All;
		All;
	}

	conditions
	{
		Is Game In Progress == True;
		Global.heroOfTheRound == Hero(Pharah);
	}

	actions
	{
		Wait(0.032, Ignore Condition);
		Event Player.pharahHeal = False;
		Event Player.pharahDamageBoost = False;
		Wait(0.032, Ignore Condition);
		Destroy Effect(Event Player.pharahHealEffect);
		Wait(0.032, Ignore Condition);
		Destroy Effect(Event Player.pharahDamageBoostEffect);
		Stop All Heal Over Time(Event Player);
		Set Damage Dealt(Event Player, 100);
		Destroy HUD Text(Event Player.pharahHealHud);
		Destroy HUD Text(Event Player.pharahDamageBoostHud);
	}
}

rule("PHARAH end of the round {EACH PLAYER}")
{
	event
	{
		Ongoing - Each Player;
		All;
		All;
	}

	conditions
	{
		Is Game In Progress == True;
		Global.heroOfTheRound != Hero(Pharah);
		Global.heroOfLastRound == Hero(Pharah);
	}

	actions
	{
		Event Player.pharahHeal = False;
		Event Player.pharahDamageBoost = False;
		Destroy Effect(Event Player.pharahHealEffect);
		Destroy Effect(Event Player.pharahDamageBoostEffect);
		Destroy HUD Text(Event Player.pharahHealHud);
		Destroy HUD Text(Event Player.pharahDamageBoostHud);
		Stop All Heal Over Time(Event Player);
		Set Damage Dealt(Event Player, 100);
	}
}

rule("ROADHOG init global")
{
	event
	{
		Ongoing - Global;
	}

	conditions
	{
		Global.heroOfTheRound == Hero(Roadhog);
	}

	actions
	{
		Global.roadhogHoleRadius = 7;
		Global.roadhogHoleEffects = Empty Array;
		Create Effect(All Players(All Teams), Light Shaft, Red, Vector(0, 0, 0), Global.roadhogHoleRadius, Visible To Position and Radius);
		Modify Global Variable(roadhogHoleEffects, Append To Array, Last Created Entity);
		Create Effect(All Players(All Teams), Light Shaft, Red, Vector(0, 0, 0), Global.roadhogHoleRadius, Visible To Position and Radius);
		Modify Global Variable(roadhogHoleEffects, Append To Array, Last Created Entity);
		Create Effect(All Players(All Teams), Light Shaft, Red, Vector(0, 0, 0), Global.roadhogHoleRadius, Visible To Position and Radius);
		Modify Global Variable(roadhogHoleEffects, Append To Array, Last Created Entity);
		Create Effect(All Players(All Teams), Ring, White, Vector(0, 0, 0), Global.roadhogHoleRadius, Visible To Position and Radius);
		Modify Global Variable(roadhogHoleEffects, Append To Array, Last Created Entity);
		Create Effect(All Players(All Teams), Ring, White, Vector(0, 0, 0), Global.roadhogHoleRadius, Visible To Position and Radius);
		Modify Global Variable(roadhogHoleEffects, Append To Array, Last Created Entity);
		Create Effect(All Players(All Teams), Ring, White, Vector(0, 0, 0), Global.roadhogHoleRadius, Visible To Position and Radius);
		Modify Global Variable(roadhogHoleEffects, Append To Array, Last Created Entity);
		Create Effect(All Players(All Teams), Light Shaft, Red, Vector(0, 0, 0), Global.roadhogHoleRadius, Visible To Position and Radius);
		Modify Global Variable(roadhogHoleEffects, Append To Array, Last Created Entity);
		Create Effect(All Players(All Teams), Light Shaft, Red, Vector(0, 0, 0), Global.roadhogHoleRadius, Visible To Position and Radius);
		Modify Global Variable(roadhogHoleEffects, Append To Array, Last Created Entity);
		Chase Global Variable Over Time(roadhogHoleRadius, 9, 60, None);
		Wait(0.500, Ignore Condition);
		Global.minigameStringTitles[Index Of Array Value(Global.heroList, Hero(Roadhog))] = Custom String("{0} {1} HOOKS 1 HOLE {0}",
			Hero Icon String(Hero(Roadhog)), Number of Living Players(All Teams));
	}
}

rule("ROADHOG init player")
{
	event
	{
		Ongoing - Each Player;
		All;
		All;
	}

	conditions
	{
		Global.heroOfTheRound == Hero(Roadhog);
		Is Alive(Event Player) == True;
	}

	actions
	{
		Start Forcing Throttle(Event Player, 0, 0, 0, 0, 0, 0);
		Set Gravity(Event Player, 0);
		disabled While(Y Component Of(Position Of(Event Player)) < 9);
		Teleport(Event Player, 10 * Normalize(Vector(Random Real(-1, 1), 0, Random Real(-1, 1))));
		While(Distance Between(Position Of(Event Player) * Vector(1, 0, 1), Vector(0, 10, 0) * Vector(1, 0, 1))
			<= Global.roadhogHoleRadius);
			Teleport(Event Player, 10 * Normalize(Vector(Random Real(-1, 1), 0, Random Real(-1, 1))));
			Wait(0.175, Ignore Condition);
		End;
		Disallow Button(Event Player, Ability 1);
		Event Player.roadhogYanked = True;
		Wait(0.512, Ignore Condition);
		While(Y Component Of(Position Of(Event Player)) < 9);
			Teleport(Event Player, Position Of(Event Player) + Vector(0, 10, 0));
			Wait(0.175, Ignore Condition);
			While(Y Component Of(Position Of(Event Player)) >= 10.500);
				Teleport(Event Player, Vector(X Component Of(Position Of(Event Player)), 10, Z Component Of(Position Of(Event Player))));
				Wait(0.175, Ignore Condition);
			End;
		End;
		Allow Button(Event Player, Ability 1);
		Set Gravity(Event Player, 0);
		Apply Impulse(Event Player, Down, 0.001, To World, Cancel Contrary Motion);
		Apply Impulse(Event Player, Up, 0.001, To World, Cancel Contrary Motion);
		Apply Impulse(Event Player, Backward, 0.001, To World, Cancel Contrary Motion);
		Apply Impulse(Event Player, Forward, 0.001, To World, Cancel Contrary Motion);
		Apply Impulse(Event Player, Right, 0.001, To World, Cancel Contrary Motion);
		Apply Impulse(Event Player, Left, 0.001, To World, Cancel Contrary Motion);
		Event Player.roadhogYanked = False;
		Event Player.roadhogFalling = False;
		Wait(1.500, Ignore Condition);
		Stop Forcing Throttle(Event Player);
	}
}

rule("ROADHOG Hole gravity")
{
	event
	{
		Ongoing - Each Player;
		All;
		Roadhog;
	}

	conditions
	{
		disabled Distance Between(Vector(X Component Of(Position Of(Event Player)), 10, Z Component Of(Position Of(Event Player))), Vector(0, 10,
			0)) <= Global.roadhogHoleRadius;
		Distance Between(Position Of(Event Player) * Vector(1, 0, 1), Vector(0, 10, 0) * Vector(1, 0, 1)) <= Global.roadhogHoleRadius;
		Event Player.roadhogYanked == False;
		Is Game In Progress == True;
		Global.heroOfTheRound == Hero(Roadhog);
		Global.roundTimer <= 58;
	}

	actions
	{
		Event Player.roadhogFalling = True;
		Wait(0.250, Ignore Condition);
		Event Player.roadhogPostion = Position Of(Event Player);
		disabled While(Is Alive(Event Player) && Event Player.roadhogYanked == False && Hero Of(Event Player) == Hero(Roadhog));
		While(Is Alive(Event Player) && Hero Of(Event Player) == Hero(Roadhog));
			Event Player.roadhogPostion = Event Player.roadhogPostion - Vector(0, 0.500, 0);
			Teleport(Event Player, Event Player.roadhogPostion);
			Wait(0.016, Ignore Condition);
		End;
		Event Player.roadhogFalling = False;
	}
}

rule("ROADHOG water")
{
	event
	{
		Ongoing - Each Player;
		All;
		Roadhog;
	}

	conditions
	{
		disabled Distance Between(Vector(X Component Of(Position Of(Event Player)), 10, Z Component Of(Position Of(Event Player))), Vector(0, 10,
			0)) <= Global.roadhogHoleRadius;
		disabled Distance Between(Position Of(Event Player) * Vector(1, 0, 1), Vector(0, 10, 0) * Vector(1, 0, 1)) <= Global.roadhogHoleRadius;
		Event Player.roadhogYanked == False;
		Is Game In Progress == True;
		Global.heroOfTheRound == Hero(Roadhog);
		Y Component Of(Ray Cast Hit Position(Position Of(Event Player), Vector(X Component Of(Position Of(Event Player)), -200,
			Z Component Of(Position Of(Event Player))), Null, All Players(All Teams), True)) <= -1;
		Global.roundTimer <= 58;
	}

	actions
	{
		Event Player.roadhogFalling = True;
		Wait(0.250, Ignore Condition);
		Event Player.roadhogPostion = Position Of(Event Player);
		While(Is Alive(Event Player) && Event Player.roadhogYanked == False && Hero Of(Event Player) == Hero(Roadhog));
			Event Player.roadhogPostion = Event Player.roadhogPostion - Vector(0, 0.500, 0);
			Teleport(Event Player, Event Player.roadhogPostion);
			Wait(0.016, Ignore Condition);
		End;
		Small Message(Event Player, Custom String("{0}", Random Value In Array(Array(Custom String("sleep with the fishes"), Custom String(
			"be water my friend")))));
		Event Player.roadhogFalling = False;
	}
}

rule("ROADHOG Yank")
{
	event
	{
		Player Dealt Damage;
		All;
		Roadhog;
	}

	conditions
	{
		Event Ability == Button(Ability 1);
		Is Game In Progress == True;
		Global.heroOfTheRound == Hero(Roadhog);
	}

	actions
	{
		While(Is Using Ability 1(Attacker));
			Wait(0.016, Ignore Condition);
			Victim.roadhogYanked = True;
			Disallow Button(Event Player, Ability 1);
		End;
		Wait(0.128, Ignore Condition);
		Victim.roadhogYanked = False;
		Allow Button(Event Player, Ability 1);
	}
}

rule("ROADHOG fix position")
{
	event
	{
		Ongoing - Each Player;
		All;
		Roadhog;
	}

	conditions
	{
		Is Game In Progress == True;
		Global.heroOfTheRound == Hero(Roadhog);
		Is Alive(Event Player) == True;
		(Y Component Of(Position Of(Event Player)) >= 9.500 && Y Component Of(Position Of(Event Player)) <= 10.500) == False;
		Global.roundTimer <= 57.500;
		Event Player.roadhogFalling == False;
	}

	actions
	{
		disabled Small Message(Event Player, Custom String("preparing fix..."));
		Wait(2.500, Abort When False);
		Teleport(Event Player, Vector(X Component Of(Position Of(Event Player)), 10, Z Component Of(Position Of(Event Player))));
		disabled Small Message(Event Player, Custom String("fixing..."));
	}
}

rule("ROADHOG stop movement")
{
	event
	{
		Ongoing - Each Player;
		All;
		Roadhog;
	}

	conditions
	{
		Event Player.roadhogYanked == False;
		Is Game In Progress == True;
		Global.heroOfTheRound == Hero(Roadhog);
		Throttle Of(Event Player) == Vector(0, 0, 0);
	}

	actions
	{
		Wait(0.048, Ignore Condition);
		disabled Apply Impulse(Event Player, Down, 0.001, To World, Cancel Contrary Motion);
		disabled Apply Impulse(Event Player, Up, 0.001, To World, Cancel Contrary Motion);
		disabled Apply Impulse(Event Player, Backward, 0.001, To World, Cancel Contrary Motion);
		disabled Apply Impulse(Event Player, Forward, 0.001, To World, Cancel Contrary Motion);
		disabled Apply Impulse(Event Player, Right, 0.001, To World, Cancel Contrary Motion);
		disabled Apply Impulse(Event Player, Left, 0.001, To World, Cancel Contrary Motion);
		Start Forcing Player Position(Event Player, Position Of(Event Player), False);
		Wait(0.048, Ignore Condition);
		Stop Forcing Player Position(Event Player);
	}
}

rule("ROADHOG secondary buttons")
{
	event
	{
		Ongoing - Each Player;
		All;
		All;
	}

	conditions
	{
		Is Game In Progress == True;
		Is Alive(Event Player) == True;
		Global.heroOfTheRound == Hero(Roadhog);
		(Is Button Held(Event Player, Primary Fire) || Is Button Held(Event Player, Secondary Fire)) == True;
	}

	actions
	{
		Press Button(Event Player, Ability 1);
	}
}

rule("ROADHOG end of the round {GLOBAL}")
{
	event
	{
		Ongoing - Global;
	}

	conditions
	{
		Is Game In Progress == True;
		Global.heroOfTheRound != Hero(Roadhog);
		Global.heroOfLastRound == Hero(Roadhog);
	}

	actions
	{
		For Global Variable(roadhogHoleEffectsIt, 0, Count Of(Global.roadhogHoleEffects), 1);
			Destroy Effect(Global.roadhogHoleEffects[Global.roadhogHoleEffectsIt]);
		End;
	}
}

rule("ROADHOG end of the round {EACH PLAYER}")
{
	event
	{
		Ongoing - Each Player;
		All;
		All;
	}

	conditions
	{
		Is Game In Progress == True;
		Global.heroOfTheRound != Hero(Roadhog);
		Global.heroOfLastRound == Hero(Roadhog);
	}

	actions
	{
		Set Gravity(Event Player, 100);
		Event Player.roadhogYanked = True;
	}
}

rule("SIGMA init player")
{
	event
	{
		Ongoing - Each Player;
		All;
		Sigma;
	}

	conditions
	{
		Global.heroOfTheRound == Hero(Sigma);
	}

	actions
	{
		Start Damage Modification(Event Player, Event Player, 0, Receivers Damagers and Damage Percent);
		Event Player.sigmaCatch = False;
	}
}

rule("SIGMA Ult damage off")
{
	event
	{
		Ongoing - Each Player;
		All;
		Sigma;
	}

	conditions
	{
		Is Using Ultimate(Event Player) == True;
		Is Game In Progress == True;
		Global.heroOfTheRound == Hero(Sigma);
	}

	actions
	{
		Set Damage Dealt(Event Player, 0);
	}
}

rule("SIGMA no Ult damage on")
{
	event
	{
		Ongoing - Each Player;
		All;
		Sigma;
	}

	conditions
	{
		Is Using Ultimate(Event Player) == False;
		Is Game In Progress == True;
		Global.heroOfTheRound == Hero(Sigma);
	}

	actions
	{
		Set Damage Dealt(Event Player, 100);
	}
}

rule("SIGMA Ult stunt")
{
	event
	{
		Player Dealt Knockback;
		All;
		All;
	}

	conditions
	{
		Is Using Ultimate(Event Player) == True;
		Is Game In Progress == True;
		Global.heroOfTheRound == Hero(Sigma);
	}

	actions
	{
		Set Status(Victim, Null, Stunned, 5);
	}
}

rule("SIGMA grasp cooldown")
{
	event
	{
		Ongoing - Each Player;
		All;
		Sigma;
	}

	conditions
	{
		Is Using Ability 1(Event Player) == True;
		Is Game In Progress == True;
		Global.heroOfTheRound == Hero(Sigma);
	}

	actions
	{
		Event Player.sigmaUsingGrasp = True;
		Set Damage Received(Event Player, 1);
		Wait(0.125, Ignore Condition);
		Cancel Primary Action(Event Player);
		Set Damage Received(Event Player, 100);
		While(Is Using Ability 1(Event Player));
			Wait(0.032, Ignore Condition);
		End;
		If(Event Player.sigmaCatch == True);
			Set Ability Cooldown(Event Player, Button(Ability 1), 2);
		Else;
			Set Ability Cooldown(Event Player, Button(Ability 1), 10);
		End;
		Event Player.sigmaUsingGrasp = False;
		Event Player.sigmaCatch = False;
	}
}

rule("SIGMA catch")
{
	event
	{
		Player Dealt Damage;
		All;
		Sigma;
	}

	conditions
	{
		Is In View Angle(Victim, Attacker, 45) == True;
		Victim.sigmaUsingGrasp == True;
		Is Game In Progress == True;
		Global.heroOfTheRound == Hero(Sigma);
	}

	actions
	{
		Victim.sigmaCatch = True;
		Kill(Attacker, Victim);
		Small Message(Array(Victim, Attacker), Custom String("rock catched {0} by {1}", Custom String("{0}{1}", Ability Icon String(Hero(
			Sigma), Button(Ability 2)), Ability Icon String(Hero(Sigma), Button(Ability 1))), Victim));
	}
}

rule("SIGMA no catch")
{
	event
	{
		Player Dealt Damage;
		All;
		Sigma;
	}

	conditions
	{
		Is In View Angle(Victim, Attacker, 45) == False;
		Victim.sigmaUsingGrasp == False;
		Is Game In Progress == True;
		Global.heroOfTheRound == Hero(Sigma);
	}

	actions
	{
		Event Player.sigmaCatch = False;
		Kill(Victim, Attacker);
	}
}

rule("SIGMA kill")
{
	event
	{
		Player Dealt Final Blow;
		All;
		Sigma;
	}

	conditions
	{
		Is Game In Progress == True;
		Global.heroOfTheRound == Hero(Sigma);
	}

	actions
	{
		Play Effect(All Players(All Teams), Good Pickup Effect, Green, Event Player, 1);
		Modify Player Score(Event Player, 1);
		Small Message(Event Player, Custom String("+1 point with {0} {1}", Hero Icon String(Hero Of(Event Player)), Hero Of(
			Event Player)));
		Create HUD Text(All Players(All Teams), Hero Icon String(Hero Of(Event Player)), Event Player, Custom String("+1 point"), Right,
			-1 + Global.pointfeedHudId, Orange, White, Orange, Visible To, Default Visibility);
		Modify Global Variable(pointfeedHud, Append To Array, Last Text ID);
		Global.pointfeedHudTimes[Count Of(Global.pointfeedHud) - 1] = 3.744;
		Global.pointfeedHudId -= 0.010;
	}
}

rule("SIGMA end of the round")
{
	event
	{
		Ongoing - Each Player;
		All;
		Sigma;
	}

	conditions
	{
		Is Game In Progress == True;
		Global.heroOfTheRound != Hero(Sigma);
		Global.heroOfLastRound == Hero(Sigma);
	}

	actions
	{
		Set Damage Dealt(Event Player, 100);
		Start Damage Modification(Event Player, Event Player, 100, Receivers Damagers and Damage Percent);
	}
}

rule("SOLDIER init global")
{
	event
	{
		Ongoing - Global;
	}

	conditions
	{
		Global.heroOfTheRound == Hero(Soldier: 76);
	}

	actions
	{
		Global.soldierObjectiveEffects = Empty Array;
		Global.soldierObjectivePos = Empty Array;
		Global.soldierObjectivePos = Array(Vector(-18, 0, -18), Vector(-18, 0, 0), Vector(-18, 0, 18), Vector(0, 0, -18), Vector(0, 0, 18),
			Vector(18, 0, -18), Vector(18, 0, 0), Vector(18, 0, 18));
		Global.soldierObjectivePos = Randomized Array(Global.soldierObjectivePos);
		Create Effect(Filtered Array(All Players(All Teams), Current Array Element.soldierPoints == 0), Light Shaft, Blue,
			Global.soldierObjectivePos[0], 1.500, Visible To Position and Radius);
		Modify Global Variable(soldierObjectiveEffects, Append To Array, Last Created Entity);
		Create Effect(Filtered Array(All Players(All Teams), Current Array Element.soldierPoints == 0), Light Shaft, Blue,
			Global.soldierObjectivePos[0], 1.500, Visible To Position and Radius);
		Modify Global Variable(soldierObjectiveEffects, Append To Array, Last Created Entity);
		Create Effect(Filtered Array(All Players(All Teams), Current Array Element.soldierPoints == 0), Light Shaft, Blue,
			Global.soldierObjectivePos[0], 1.500, Visible To Position and Radius);
		Modify Global Variable(soldierObjectiveEffects, Append To Array, Last Created Entity);
		Create Effect(Filtered Array(All Players(All Teams), Current Array Element.soldierPoints == 1), Light Shaft, Blue,
			Global.soldierObjectivePos[1], 1.500, Visible To Position and Radius);
		Modify Global Variable(soldierObjectiveEffects, Append To Array, Last Created Entity);
		Create Effect(Filtered Array(All Players(All Teams), Current Array Element.soldierPoints == 1), Light Shaft, Blue,
			Global.soldierObjectivePos[1], 1.500, Visible To Position and Radius);
		Modify Global Variable(soldierObjectiveEffects, Append To Array, Last Created Entity);
		Create Effect(Filtered Array(All Players(All Teams), Current Array Element.soldierPoints == 1), Light Shaft, Blue,
			Global.soldierObjectivePos[1], 1.500, Visible To Position and Radius);
		Modify Global Variable(soldierObjectiveEffects, Append To Array, Last Created Entity);
		Create Effect(Filtered Array(All Players(All Teams), Current Array Element.soldierPoints == 2), Light Shaft, Blue,
			Global.soldierObjectivePos[2], 1.500, Visible To Position and Radius);
		Modify Global Variable(soldierObjectiveEffects, Append To Array, Last Created Entity);
		Create Effect(Filtered Array(All Players(All Teams), Current Array Element.soldierPoints == 2), Light Shaft, Blue,
			Global.soldierObjectivePos[2], 1.500, Visible To Position and Radius);
		Modify Global Variable(soldierObjectiveEffects, Append To Array, Last Created Entity);
		Create Effect(Filtered Array(All Players(All Teams), Current Array Element.soldierPoints == 2), Light Shaft, Blue,
			Global.soldierObjectivePos[2], 1.500, Visible To Position and Radius);
		Modify Global Variable(soldierObjectiveEffects, Append To Array, Last Created Entity);
		Create Effect(Filtered Array(All Players(All Teams), Current Array Element.soldierPoints == 3), Light Shaft, Blue,
			Global.soldierObjectivePos[3], 1.500, Visible To Position and Radius);
		Modify Global Variable(soldierObjectiveEffects, Append To Array, Last Created Entity);
		Create Effect(Filtered Array(All Players(All Teams), Current Array Element.soldierPoints == 3), Light Shaft, Blue,
			Global.soldierObjectivePos[3], 1.500, Visible To Position and Radius);
		Modify Global Variable(soldierObjectiveEffects, Append To Array, Last Created Entity);
		Create Effect(Filtered Array(All Players(All Teams), Current Array Element.soldierPoints == 3), Light Shaft, Blue,
			Global.soldierObjectivePos[3], 1.500, Visible To Position and Radius);
		Modify Global Variable(soldierObjectiveEffects, Append To Array, Last Created Entity);
		Create Effect(Filtered Array(All Players(All Teams), Current Array Element.soldierPoints == 4), Light Shaft, Blue,
			Global.soldierObjectivePos[4], 1.500, Visible To Position and Radius);
		Modify Global Variable(soldierObjectiveEffects, Append To Array, Last Created Entity);
		Create Effect(Filtered Array(All Players(All Teams), Current Array Element.soldierPoints == 4), Light Shaft, Blue,
			Global.soldierObjectivePos[4], 1.500, Visible To Position and Radius);
		Modify Global Variable(soldierObjectiveEffects, Append To Array, Last Created Entity);
		Create Effect(Filtered Array(All Players(All Teams), Current Array Element.soldierPoints == 4), Light Shaft, Blue,
			Global.soldierObjectivePos[4], 1.500, Visible To Position and Radius);
		Create Effect(Filtered Array(All Players(All Teams), Current Array Element.soldierPoints == 5), Light Shaft, Blue,
			Global.soldierObjectivePos[5], 1.500, Visible To Position and Radius);
		Modify Global Variable(soldierObjectiveEffects, Append To Array, Last Created Entity);
		Create Effect(Filtered Array(All Players(All Teams), Current Array Element.soldierPoints == 5), Light Shaft, Blue,
			Global.soldierObjectivePos[5], 1.500, Visible To Position and Radius);
		Modify Global Variable(soldierObjectiveEffects, Append To Array, Last Created Entity);
		Create Effect(Filtered Array(All Players(All Teams), Current Array Element.soldierPoints == 5), Light Shaft, Blue,
			Global.soldierObjectivePos[5], 1.500, Visible To Position and Radius);
		Create Effect(Filtered Array(All Players(All Teams), Current Array Element.soldierPoints == 6), Light Shaft, Blue,
			Global.soldierObjectivePos[6], 1.500, Visible To Position and Radius);
		Modify Global Variable(soldierObjectiveEffects, Append To Array, Last Created Entity);
		Create Effect(Filtered Array(All Players(All Teams), Current Array Element.soldierPoints == 6), Light Shaft, Blue,
			Global.soldierObjectivePos[6], 1.500, Visible To Position and Radius);
		Modify Global Variable(soldierObjectiveEffects, Append To Array, Last Created Entity);
		Create Effect(Filtered Array(All Players(All Teams), Current Array Element.soldierPoints == 6), Light Shaft, Blue,
			Global.soldierObjectivePos[6], 1.500, Visible To Position and Radius);
		Create Effect(Filtered Array(All Players(All Teams), Current Array Element.soldierPoints == 7), Light Shaft, Blue,
			Global.soldierObjectivePos[7], 1.500, Visible To Position and Radius);
		Modify Global Variable(soldierObjectiveEffects, Append To Array, Last Created Entity);
		Create Effect(Filtered Array(All Players(All Teams), Current Array Element.soldierPoints == 7), Light Shaft, Blue,
			Global.soldierObjectivePos[7], 1.500, Visible To Position and Radius);
		Modify Global Variable(soldierObjectiveEffects, Append To Array, Last Created Entity);
		Create Effect(Filtered Array(All Players(All Teams), Current Array Element.soldierPoints == 7), Light Shaft, Blue,
			Global.soldierObjectivePos[7], 1.500, Visible To Position and Radius);
		Modify Global Variable(soldierObjectiveEffects, Append To Array, Last Created Entity);
	}
}

rule("SOLDIER init & phased out")
{
	event
	{
		Ongoing - Each Player;
		All;
		Soldier: 76;
	}

	conditions
	{
		Global.heroOfTheRound == Hero(Soldier: 76);
		Is Alive(Event Player) == True;
	}

	actions
	{
		Event Player.soldierPointsHud = Null;
		Start Forcing Throttle(Event Player, 0, 0, 0, 0, 0, 0);
		Wait(0.512, Ignore Condition);
		Teleport(Event Player, Vector(0, 0, 0));
		Set Facing(Event Player, Direction Towards(Eye Position(Event Player), Global.soldierObjectivePos[0]), To World);
		Set Status(Event Player, Null, Phased Out, 60);
		Event Player.soldierPoints = 0;
		Stop Forcing Throttle(Event Player);
		Wait(0.256, Ignore Condition);
		If(Event Player.soldierPointsHud == Null);
			Create HUD Text(All Players(All Teams), Null, Null, Custom String("{0}: {1}/8 = {2}/4 points", Event Player,
				Event Player.soldierPoints, Round To Integer(Event Player.soldierPoints / 2, Down)), Left, (Event Player.soldierPoints + 10)
				* -1, White, White, Blue, Visible To Sort Order and String, Default Visibility);
			Event Player.soldierPointsHud = Last Text ID;
		End;
		Teleport(Event Player, Vector(0, 0, 0));
		Set Facing(Event Player, Direction Towards(Eye Position(Event Player), Global.soldierObjectivePos[0]), To World);
		Wait(0.256, Ignore Condition);
		Teleport(Event Player, Vector(0, 0, 0));
		Set Facing(Event Player, Direction Towards(Eye Position(Event Player), Global.soldierObjectivePos[0]), To World);
		Create HUD Text(Event Player, String("{0} m/s", Horizontal Speed Of(Event Player)), Null, Null, Left, 2, Blue, White, White,
			Visible To and String, Default Visibility);
		Event Player.playerSpeedHud = Last Text ID;
		Create Icon(Event Player, Global.soldierObjectivePos[Event Player.soldierPoints] + Vector(0, 1.500, 0), Flag,
			Visible To and Position, Blue, True);
		Event Player.playerClosestObjectiveIcon = Last Created Entity;
	}
}

rule("SOLDIER sprint")
{
	event
	{
		Ongoing - Each Player;
		All;
		Soldier: 76;
	}

	conditions
	{
		Is Game In Progress == True;
		Is Using Ability 1(Event Player) == True;
		Horizontal Speed Of(Event Player) > 5;
		Global.heroOfTheRound == Hero(Soldier: 76);
	}

	actions
	{
		Set Status(Event Player, Null, Phased Out, 60);
		Event Player.soldierSprint += 1.500;
		Set Move Speed(Event Player, Event Player.soldierSprint);
		Wait(0.100, Ignore Condition);
		Loop If Condition Is True;
		Event Player.soldierSprint = 100;
		Set Move Speed(Event Player, 100);
	}
}

rule("SOLDIER point")
{
	event
	{
		Ongoing - Each Player;
		All;
		Soldier: 76;
	}

	conditions
	{
		Is Game In Progress == True;
		Is Alive(Event Player) == True;
		Global.heroOfTheRound == Hero(Soldier: 76);
		Event Player.soldierPoints < 8;
		Distance Between(Position Of(Event Player), Global.soldierObjectivePos[Event Player.soldierPoints]) <= 1.550;
	}

	actions
	{
		Play Effect(All Players(All Teams), Good Pickup Effect, Blue, Event Player, 1);
		Play Effect(Event Player, Buff Explosion Sound, Blue, Event Player, 100);
		Event Player.soldierPoints += 1;
		If(Event Player.soldierPoints % 2 == 0);
			Modify Player Score(Event Player, 1);
			Small Message(Event Player, Custom String("+1 point with {0} {1}", Hero Icon String(Hero Of(Event Player)), Hero Of(
				Event Player)));
			Create HUD Text(All Players(All Teams), Hero Icon String(Hero Of(Event Player)), Event Player, Custom String("+1 point"), Right,
				-1 + Global.pointfeedHudId, Orange, White, Orange, Visible To, Default Visibility);
			Modify Global Variable(pointfeedHud, Append To Array, Last Text ID);
			Global.pointfeedHudTimes[Count Of(Global.pointfeedHud) - 1] = 3.744;
			Global.pointfeedHudId -= 0.010;
		End;
	}
}

rule("SOLDIER winner")
{
	event
	{
		Ongoing - Each Player;
		All;
		Soldier: 76;
	}

	conditions
	{
		Is Game In Progress == True;
		Global.heroOfTheRound == Hero(Soldier: 76);
		Event Player.soldierPoints >= 8;
	}

	actions
	{
		Global.roundTimer = 0.032;
	}
}

rule("SOLDIER end of the round {GLOBAL}")
{
	event
	{
		Ongoing - Global;
	}

	conditions
	{
		Is Game In Progress == True;
		Global.heroOfTheRound != Hero(Soldier: 76);
		Global.heroOfLastRound == Hero(Soldier: 76);
	}

	actions
	{
		Global.soldierDestructorIt = 0;
		For Global Variable(soldierDestructorIt, 0, Count Of(Global.soldierObjectiveEffects), 1);
			Destroy Effect(Global.soldierObjectiveEffects[Global.soldierDestructorIt]);
		End;
	}
}

rule("SOLDIER end of the round {EACH PLAYER}")
{
	event
	{
		Ongoing - Each Player;
		All;
		All;
	}

	conditions
	{
		Is Game In Progress == True;
		Global.heroOfTheRound != Hero(Soldier: 76);
		Global.heroOfLastRound == Hero(Soldier: 76);
	}

	actions
	{
		Wait(0.016, Ignore Condition);
		Event Player.soldierPoints = 0;
		Destroy HUD Text(Event Player.playerSpeedHud);
		Destroy Icon(Event Player.playerClosestObjectiveIcon);
		Clear Status(Event Player, Phased Out);
		Set Move Speed(Event Player, 100);
		Wait(0.256, Ignore Condition);
		Destroy HUD Text(Event Player.soldierPointsHud);
	}
}

rule("SOMBRA hack to kill")
{
	event
	{
		Ongoing - Each Player;
		All;
		Sombra;
	}

	conditions
	{
		Has Status(Event Player, Hacked) == True;
		Is Game In Progress == True;
		Global.heroOfTheRound == Hero(Sombra);
	}

	actions
	{
		Teleport(Event Player, Vector(0, -500, 0));
	}
}

rule("SOMBRA limit stealth duration")
{
	event
	{
		Ongoing - Each Player;
		All;
		Sombra;
	}

	conditions
	{
		Is Using Ability 1(Event Player) == True;
		Is Game In Progress == True;
		Global.heroOfTheRound == Hero(Sombra);
	}

	actions
	{
		Wait(6, Abort When False);
		Press Button(Event Player, Ability 1);
		Small Message(Event Player, Custom String("Maximum Stealth Duration Reached"));
	}
}

rule("TRACER create crown")
{
	event
	{
		Ongoing - Global;
	}

	conditions
	{
		Is Game In Progress == True;
		Global.heroOfTheRound == Hero(Tracer);
		disabled Global.tracerQueen == Null;
	}

	actions
	{
		disabled Destroy Effect(Global.crownEffect);
		Global.crownPos = Vector(0, 1.500, 0);
		Create Effect(All Players(All Teams), Good Aura, Orange, Global.crownPos, 1, Visible To Position and Radius);
		Global.crownEffect = Last Created Entity;
		Create HUD Text(Global.tracerQueen, Custom String("QUEEN"), Null, Null, Left, 2, Orange, White, White, Visible To and String,
			Default Visibility);
		Global.tracerQueenHud = Last Text ID;
		Create Icon(All Players(All Teams), Global.crownPos, Arrow: Down, Visible To and Position, Orange, True);
		Global.tracerQueenPositionIcon = Last Created Entity;
	}
}

rule("TRACER stun & steal")
{
	event
	{
		Player Dealt Damage;
		All;
		Tracer;
	}

	conditions
	{
		Is Game In Progress == True;
		Global.heroOfTheRound == Hero(Tracer);
	}

	actions
	{
		If(Global.tracerQueen == Attacker);
			Set Status(Victim, Event Player, Stunned, 1);
		End;
		If(Global.tracerQueen == Victim);
			Set Status(Victim, Event Player, Stunned, 0.750);
			Play Effect(All Players(All Teams), Buff Impact Sound, Orange, Event Player, 50);
			Global.tracerQueen = Attacker;
			Global.crownPos = Attacker;
		End;
	}
}

rule("TRACER init queen")
{
	event
	{
		Ongoing - Each Player;
		All;
		All;
	}

	conditions
	{
		Is Game In Progress == True;
		Global.heroOfTheRound == Hero(Tracer);
	}

	actions
	{
		Event Player.queenPointsHud = Null;
		Event Player.queenPoints = 0;
		Wait(0.256, Ignore Condition);
		If(Event Player.queenPointsHud == Null);
			Create HUD Text(All Players(All Teams), Null, Null, Custom String("{0}: {1}/10 {2}", Event Player, Event Player.queenPoints,
				Event Player == Global.tracerQueen ? Custom String("queen") : Custom String("")), Left, (Event Player.queenPoints + 10) * -1,
				White, White, Orange, Visible To Sort Order and String, Default Visibility);
			Event Player.queenPointsHud = Last Text ID;
		End;
		Set Gravity(Event Player, 100);
	}
}

rule("TRACER first queen")
{
	event
	{
		Ongoing - Each Player;
		All;
		All;
	}

	conditions
	{
		Is Game In Progress == True;
		Is Alive(Event Player) == True;
		Distance Between(Event Player, Position Of(Global.crownEffect)) <= 1.500;
		Global.heroOfTheRound == Hero(Tracer);
		Global.tracerQueen == Null;
		Global.roundTimer <= 58.500;
	}

	actions
	{
		Wait(0.064, Abort When False);
		Play Effect(Event Player, Buff Impact Sound, Orange, Event Player, 50);
		Global.tracerQueen = Event Player;
		Global.crownPos = Event Player;
	}
}

rule("TRACER is queen = points, gravity")
{
	event
	{
		Ongoing - Each Player;
		All;
		Tracer;
	}

	conditions
	{
		Is Game In Progress == True;
		Is Alive(Event Player) == True;
		Global.heroOfTheRound == Hero(Tracer);
		Global.tracerQueen == Event Player;
	}

	actions
	{
		Set Gravity(Event Player, 500);
		Wait(1, Abort When False);
		Event Player.queenPoints += 1;
		Play Effect(All Players(All Teams), Good Pickup Effect, Orange, Event Player, 1);
		Play Effect(All Players(All Teams), Buff Explosion Sound, Orange, Event Player, 50);
		Loop If Condition Is True;
	}
}

rule("TRACER is not queen = points, gravity")
{
	event
	{
		Ongoing - Each Player;
		All;
		Tracer;
	}

	conditions
	{
		Is Game In Progress == True;
		Is Alive(Event Player) == True;
		Global.heroOfTheRound == Hero(Tracer);
		Global.tracerQueen != Event Player;
	}

	actions
	{
		Set Gravity(Event Player, 100);
	}
}

rule("TRACER queen winner")
{
	event
	{
		Ongoing - Each Player;
		All;
		Tracer;
	}

	conditions
	{
		Is Game In Progress == True;
		Global.heroOfTheRound == Hero(Tracer);
		Global.tracerQueen == Event Player;
		Event Player.queenPoints >= 10;
	}

	actions
	{
		Play Effect(All Players(All Teams), Good Pickup Effect, White, Event Player, 1);
		Play Effect(All Players(All Teams), Buff Explosion Sound, White, Event Player, 100);
		Modify Player Score(Event Player, Count Of(Global.playersStartOfTheRound) - 1);
		Small Message(Event Player, Custom String("+{0} with {1} {2}", Custom String("{0} {1}", Count Of(Global.playersStartOfTheRound)
			- 1, Count Of(Global.playersStartOfTheRound) - 1 > 1 ? Custom String("points") : Custom String("point")), Hero Icon String(
			Hero Of(Event Player)), Hero Of(Event Player)));
		Create HUD Text(All Players(All Teams), Hero Icon String(Hero Of(Event Player)), Event Player, Custom String("+{1}", Null,
			Custom String("{0} {1}", Count Of(Global.playersStartOfTheRound) - 1, Count Of(Global.playersStartOfTheRound)
			- 1 > 1 ? Custom String("points") : Custom String("point"))), Right, -1 + Global.pointfeedHudId, Orange, White, Orange,
			Visible To, Default Visibility);
		Modify Global Variable(pointfeedHud, Append To Array, Last Text ID);
		Global.pointfeedHudTimes[Count Of(Global.pointfeedHud) - 1] = 3.744;
		Global.pointfeedHudId -= 0.010;
		Global.roundTimer = 0.032;
	}
}

rule("TRACER dead queen")
{
	event
	{
		Player Died;
		All;
		All;
	}

	conditions
	{
		Is Game In Progress == True;
		Global.heroOfTheRound == Hero(Tracer);
		Global.tracerQueen == Event Player;
	}

	actions
	{
		Global.tracerQueen = Null;
		Global.crownPos = Vector(0, 1.500, 0);
	}
}

rule("TRACER leaver queen")
{
	event
	{
		Player Left Match;
		All;
		All;
	}

	conditions
	{
		Is Game In Progress == True;
		Global.heroOfTheRound == Hero(Tracer);
		Global.tracerQueen == Event Player;
	}

	actions
	{
		Global.tracerQueen = Null;
		Global.crownPos = Vector(0, 1.500, 0);
	}
}

rule("TRACER destroy crown")
{
	event
	{
		Ongoing - Global;
	}

	conditions
	{
		Is Game In Progress == True;
		Global.heroOfTheRound != Hero(Tracer);
	}

	actions
	{
		Destroy Effect(Global.crownEffect[0]);
		Global.tracerQueen = Null;
	}
}

rule("TRACER secondary buttons")
{
	event
	{
		Ongoing - Each Player;
		All;
		All;
	}

	conditions
	{
		Is Game In Progress == True;
		Is Alive(Event Player) == True;
		Global.heroOfTheRound == Hero(Tracer);
		Is Button Held(Event Player, Primary Fire) == True;
	}

	actions
	{
		Press Button(Event Player, Melee);
	}
}

rule("TRACER end of the round {EACH PLAYER}")
{
	event
	{
		Ongoing - Each Player;
		All;
		All;
	}

	conditions
	{
		Is Game In Progress == True;
		Global.heroOfTheRound != Hero(Tracer);
		Global.heroOfLastRound == Hero(Tracer);
	}

	actions
	{
		Event Player.queenPoints = 0;
		Set Gravity(Event Player, 100);
		Wait(0.256, Ignore Condition);
		Destroy HUD Text(Event Player.queenPointsHud);
	}
}

rule("TRACER end of the round {GLOBAL}")
{
	event
	{
		Ongoing - Global;
	}

	conditions
	{
		Is Game In Progress == True;
		Global.heroOfTheRound != Hero(Tracer);
		Global.heroOfLastRound == Hero(Tracer);
	}

	actions
	{
		Global.tracerQueen = Null;
		Wait(0.256, Ignore Condition);
		Destroy Icon(Global.tracerQueenPositionIcon);
		Destroy HUD Text(Global.tracerQueenHud);
	}
}

rule("WINSTON rage")
{
	event
	{
		Ongoing - Each Player;
		All;
		Winston;
	}

	conditions
	{
		Is Game In Progress == True;
		Is Alive(Event Player) == True;
		Global.heroOfTheRound == Hero(Winston);
		Is Using Ultimate(Event Player) == False;
	}

	actions
	{
		Press Button(Event Player, Ultimate);
		Wait(0.016, Ignore Condition);
		Loop If Condition Is True;
	}
}

rule("WINSTON jump cooldown")
{
	event
	{
		Ongoing - Each Player;
		All;
		Winston;
	}

	conditions
	{
		Is Game In Progress == True;
		Is Alive(Event Player) == True;
		Global.heroOfTheRound == Hero(Winston);
		Is Using Ability 1(Event Player) == True;
	}

	actions
	{
		Wait(0.032, Ignore Condition);
		Set Ability Cooldown(Event Player, Button(Ability 1), 12);
	}
}

rule("ZEN mega-kick")
{
	event
	{
		Player Dealt Damage;
		All;
		Zenyatta;
	}

	conditions
	{
		Is Game In Progress == True;
		Is Alive(Event Player) == True;
		Global.heroOfTheRound == Hero(Zenyatta);
	}

	actions
	{
		Apply Impulse(Victim, Facing Direction Of(Event Player) + Vector(0, 0.100, 0), 75, To World, Cancel Contrary Motion);
	}
}

rule("ZEN secondary buttons")
{
	event
	{
		Ongoing - Each Player;
		All;
		All;
	}

	conditions
	{
		Is Game In Progress == True;
		Is Alive(Event Player) == True;
		Global.heroOfTheRound == Hero(Zenyatta);
		(Is Button Held(Event Player, Primary Fire) || Is Button Held(Event Player, Secondary Fire)) == True;
	}

	actions
	{
		Press Button(Event Player, Melee);
	}
}

rule("----- THIRD CAMERA PERSON ----- Made by Mitsiee. More at https://workshop.codes/third-person")
{
	event
	{
		Ongoing - Global;
	}
}

rule("Enable/disable third camera person")
{
	event
	{
		Ongoing - Each Player;
		All;
		All;
	}

	conditions
	{
		Is Communicating(Event Player, Fall Back) == True;
	}

	actions
	{
		If(Event Player.isOnThirdCamera == False);
			Event Player.isOnThirdCamera = True;
			Small Message(Event Player, Custom String(
				"----- THIRD CAMERA PERSON ----- Made by Mitsiee. More at https://workshop.codes/third-person"));
		Else;
			Event Player.isOnThirdCamera = False;
			Stop Camera(Event Player);
		End;
	}
}

rule("Initialise")
{
	event
	{
		Ongoing - Each Player;
		All;
		All;
	}

	conditions
	{
		Event Player.isOnThirdCamera == True;
	}

	actions
	{
		Event Player.thirdCameraDirection = 1;
		Event Player.thirdCameraZoom = -2.500;
	}
}

rule("Set Third Person")
{
	event
	{
		Ongoing - Each Player;
		All;
		All;
	}

	conditions
	{
		Is Alive(Event Player) == True;
		((Hero Of(Event Player) == Hero(Widowmaker) || Hero Of(Event Player) == Hero(Ashe) || Hero Of(Event Player) == Hero(Ana))
			&& Is Button Held(Event Player, Secondary Fire)) != True;
		Event Player.isOnThirdCamera == True;
	}

	actions
	{
		Start Camera(Event Player, Ray Cast Hit Position(Eye Position(Event Player), Eye Position(Event Player) + World Vector Of(Vector(
			Event Player.thirdCameraDirection * Min(Event Player.thirdCameraZoom / 2.500, -0.750), 0, 0), Event Player, Rotation)
			+ Facing Direction Of(Event Player) * Event Player.thirdCameraZoom, All Players(All Teams), Event Player, False),
			Ray Cast Hit Position(Eye Position(Event Player), Eye Position(Event Player) + Facing Direction Of(Event Player) * 200,
			All Players(All Teams), Event Player, False), 60);
		disabled Start Camera(Event Player, Ray Cast Hit Position(Eye Position(Event Player), Eye Position(Event Player) + World Vector Of(Vector(
			Event Player.thirdCameraDirection, 0, 0), Event Player, Rotation) + Facing Direction Of(Event Player)
			* Event Player.thirdCameraZoom, All Players(All Teams), Event Player, False), Ray Cast Hit Position(Eye Position(Event Player),
			Eye Position(Event Player) + Facing Direction Of(Event Player) * 200, All Players(All Teams), Event Player, False), 60);
	}
}

rule("Unset Third Person for specific conditions")
{
	event
	{
		Ongoing - Each Player;
		All;
		All;
	}

	conditions
	{
		((Hero Of(Event Player) == Hero(Widowmaker) || Hero Of(Event Player) == Hero(Ashe) || Hero Of(Event Player) == Hero(Ana))
			&& Is Button Held(Event Player, Secondary Fire)) == True;
		Event Player.isOnThirdCamera == True;
	}

	actions
	{
		Stop Camera(Event Player);
	}
}

rule("Pressing Interact")
{
	event
	{
		Ongoing - Each Player;
		All;
		All;
	}

	conditions
	{
		Is Button Held(Event Player, Interact) == True;
		Event Player.isOnThirdCamera == True;
	}

	actions
	{
		If(Event Player.thirdCameraDirection == -1);
			Event Player.thirdCameraDirection = 1;
		Else;
			Event Player.thirdCameraDirection = -1;
		End;
	}
}

rule("----- TEST -----")
{
	event
	{
		Ongoing - Global;
	}
}

disabled rule("Lobby with Dummies (TEST)")
{
	event
	{
		Ongoing - Global;
	}

	conditions
	{
		Is In Setup == True;
		(Custom String("Jokaes") == Custom String("{0}", Host Player)) == True;
	}

	actions
	{
		Create Dummy Bot(Hero(Ashe), All Teams, -1, Vector(0, 0, 0), Vector(0, 0, 0));
		disabled Loop If(Count Of(All Players(All Teams)) < 2);
		disabled Loop If(Count Of(All Players(All Teams)) < 3);
		Loop If(Count Of(All Players(All Teams)) < 5);
		disabled Loop If(Count Of(All Players(All Teams)) < 6);
		disabled Loop If(Count Of(All Players(All Teams)) < 12);
	}
}

disabled rule("Dummys Summon (TEST)")
{
	event
	{
		Ongoing - Each Player;
		All;
		All;
	}

	conditions
	{
		Is Communicating(Event Player, Hello) == True;
		(Custom String("Jokaes") == Custom String("{0}", Host Player)) == True;
	}

	actions
	{
		Create Dummy Bot(Hero(Ashe), All Teams, -1, Position Of(Event Player), Vector(0, 0, 0));
	}
}

disabled rule("Dummy Aim Bot (TEST)")
{
	event
	{
		Ongoing - Each Player;
		All;
		All;
	}

	conditions
	{
		Is Dummy Bot(Event Player) == True;
		(Custom String("Jokaes") == Custom String("{0}", Host Player)) == True;
	}

	actions
	{
		Start Facing(Event Player, Direction Towards(Event Player, Sorted Array(Filtered Array(All Players(All Teams), Is Alive(
			Current Array Element)), Distance Between(Event Player, Current Array Element))[1]), 10000, To World, Direction and Turn Rate);
		Start Holding Button(Event Player, Ability 2);
		Start Holding Button(Event Player, Ability 1);
		Start Holding Button(Event Player, Secondary Fire);
		Start Holding Button(Event Player, Primary Fire);
		Wait(Random Real(0.300, 1), Ignore Condition);
		Stop Holding Button(Event Player, Primary Fire);
		Stop Holding Button(Event Player, Secondary Fire);
		Stop Holding Button(Event Player, Ability 1);
		Stop Holding Button(Event Player, Ability 2);
		Loop If Condition Is True;
	}
}

disabled rule("Dummy Ult (TEST)")
{
	event
	{
		Ongoing - Each Player;
		All;
		All;
	}

	conditions
	{
		Is Dummy Bot(Event Player) == True;
		Ultimate Charge Percent(Event Player) == 100;
		(Custom String("Jokaes") == Custom String("{0}", Host Player)) == True;
	}

	actions
	{
		Press Button(Event Player, Ultimate);
	}
}

disabled rule("Dummy Meele loop (TEST)")
{
	event
	{
		Ongoing - Each Player;
		All;
		All;
	}

	conditions
	{
		Is Dummy Bot(Event Player) == True;
		(Custom String("Jokaes") == Custom String("{0}", Host Player)) == True;
	}

	actions
	{
		Start Facing(Event Player, Direction Towards(Event Player, Closest Player To(Event Player, Opposite Team Of(Team Of(
			Event Player)))), 10000, To World, Direction and Turn Rate);
		Press Button(Event Player, Melee);
		Wait(Random Real(0.250, 0.350), Ignore Condition);
		Loop If Condition Is True;
	}
}

disabled rule("Dummy Moving (TEST)")
{
	event
	{
		Ongoing - Each Player;
		All;
		All;
	}

	conditions
	{
		Is Dummy Bot(Event Player) == True;
		(Custom String("Jokaes") == Custom String("{0}", Host Player)) == True;
	}

	actions
	{
		Start Throttle In Direction(Event Player, Direction Towards(Event Player, Sorted Array(Filtered Array(All Players(All Teams),
			Is Alive(Current Array Element)), Distance Between(Event Player, Current Array Element))[1]), 1, To World,
			Replace existing throttle, Direction and Magnitude);
	}
}

disabled rule("Skip until (TEST)")
{
	event
	{
		Ongoing - Each Player;
		All;
		All;
	}

	conditions
	{
		disabled Is Button Held(Event Player, Interact) == True;
		Global.heroOfTheRound != Hero(Mei);
		Global.roundTimer <= 58;
		(Custom String("Jokaes") == Custom String("{0}", Host Player)) == True;
	}

	actions
	{
		Global.roundTimer = 1;
		disabled Press Button(Event Player, Interact);
	}
}

disabled rule("Skip round (TEST)")
{
	event
	{
		Ongoing - Each Player;
		All;
		All;
	}

	conditions
	{
		Is Button Held(Event Player, Interact) == True;
		(Custom String("Jokaes") == Custom String("{0}", Host Player)) == True;
		(Custom String("Jokaes") == Custom String("{0}", Event Player)) == True;
	}

	actions
	{
		disabled Kill(All Players(All Teams), Null);
		Global.roundTimer = 1;
		disabled Set Status(Event Player, Null, Stunned, 1);
	}
}

disabled rule("Force dummy to be hero of the round (TEST)")
{
	event
	{
		Ongoing - Each Player;
		All;
		All;
	}

	conditions
	{
		Is Dummy Bot(Event Player) == True;
		Hero Of(Event Player) == Hero(Ashe);
		(Custom String("Jokaes") == Custom String("{0}", Host Player)) == True;
	}

	actions
	{
		Start Forcing Player To Be Hero(Event Player, Global.heroOfTheRound);
	}
}

disabled rule("Destroy the dummies (TEST)")
{
	event
	{
		Ongoing - Each Player;
		All;
		All;
	}

	conditions
	{
		(Custom String("Jokaes") == Custom String("{0}", Host Player)) == True;
		(Custom String("Jokaes") == Custom String("{0}", Event Player)) == True;
		Is Button Held(Event Player, Ultimate) == True;
		Is Button Held(Event Player, Reload) == True;
		Is Button Held(Event Player, Interact) == True;
	}

	actions
	{
		Destroy All Dummy Bots;
	}
}

disabled rule("Ray Cast Detector (TEST)")
{
	event
	{
		Ongoing - Each Player;
		All;
		All;
	}

	conditions
	{
		Is Button Held(Event Player, Primary Fire) == True;
	}

	actions
	{
		Create HUD Text(All Players(All Teams), Ray Cast Hit Position(Eye Position(Event Player), Eye Position(Event Player)
			+ Facing Direction Of(Event Player) * 200, Null, All Players(All Teams), False), Null, Null, Left, 0, White, White, White,
			Visible To, Default Visibility);
		Create Effect(Event Player, Orb, Yellow, Ray Cast Hit Position(Eye Position(Event Player), Eye Position(Event Player)
			+ Facing Direction Of(Event Player) * 200, Null, All Players(All Teams), False), 1, None);
		Create Beam Effect(All Players(All Teams), Good Beam, Eye Position(Event Player), Ray Cast Hit Position(Eye Position(Event Player),
			Eye Position(Event Player) + Facing Direction Of(Event Player) * 200, All Players(All Teams), All Players(All Teams), False),
			Red, None);
	}
}

disabled rule("Debug HUDs (TEST)")
{
	event
	{
		Ongoing - Each Player;
		All;
		All;
	}

	conditions
	{
		(Custom String("Jokaes") == Custom String("{0}", Host Player)) == True;
	}

	actions
	{
		Create HUD Text(Event Player, Custom String("{0} m/s", Horizontal Speed Of(Event Player)), Null, Null, Left, 0, White, White,
			White, Visible To and String, Default Visibility);
		disabled Create HUD Text(Event Player, Custom String("{0}", Position Of(Event Player)), Null, Null, Left, 0, White, White, White,
			Visible To and String, Default Visibility);
		disabled Create HUD Text(Event Player, Custom String("{0}", Y Component Of(Position Of(Event Player))), Null, Null, Left, 0, White, White,
			White, Visible To and String, Default Visibility);
		disabled Create HUD Text(Event Player, Custom String("{0}", Distance Between(Event Player, Vector(0, 10, 0))), Null, Null, Left, 0, White,
			White, White, Visible To and String, Default Visibility);
		disabled Create HUD Text(Event Player, Custom String("{0}", Count Of(Global.pointfeedHud)), Null, Null, Left, 0, White, White, White,
			Visible To and String, Default Visibility);
		disabled Create HUD Text(Event Player, Custom String("{0}", Count Of(Global.pointfeedHudTimes)), Null, Null, Left, 0, White, White, White,
			Visible To and String, Default Visibility);
		disabled Create HUD Text(Event Player, Custom String("{0}", Throttle Of(Event Player)), Null, Null, Left, 0, White, White, White,
			Visible To and String, Default Visibility);
	}
}

rule("Created by Jokaes#2263")
{
	event
	{
		Ongoing - Global;
	}
}

rule("Code: W468T")
{
	event
	{
		Ongoing - Global;
	}
}