ModdingTools.del

//Imports
import "UI.del";
//Behaviors
import "Behaviors/All.del";
import "Behaviors/Ana.del";
import "Behaviors/Ashe.del";
import "Behaviors/Baptiste.del";
import "Behaviors/Bastion.del";
import "Behaviors/Brigitte.del";
import "Behaviors/Doomfist.del";
import "Behaviors/Dva.del";
import "Behaviors/Genji.del";
import "Behaviors/Hanzo.del";
import "Behaviors/Junkrat.del";
import "Behaviors/Lucio.del";
import "Behaviors/Mccree.del";
import "Behaviors/Mei.del";
import "Behaviors/Mercy.del";
import "Behaviors/Moira.del";
import "Behaviors/Orisa.del";
import "Behaviors/Pharah.del";
import "Behaviors/Reaper.del";
import "Behaviors/Reinhardt.del";
import "Behaviors/Roadhog.del";
import "Behaviors/Sigma.del";
import "Behaviors/Soldier76.del";
import "Behaviors/Sombra.del";
import "Behaviors/Symmetra.del";
import "Behaviors/Torbjorn.del";
import "Behaviors/Tracer.del";
import "Behaviors/Widowmaker.del";
import "Behaviors/Winston.del";
import "Behaviors/WreckingBall.del";
import "Behaviors/Zarya.del";
import "Behaviors/Zenyatta.del";

// Global Variables
define globalvar heroes;
define globalvar modes;
define globalvar behaviors;

define globalvar flySpeed;
define globalvar boostSpeed;
define globalvar cameraSmoothing;

define globalvar savedBots;

define globalvar map;

// Player Variables
define playervar mode;
define playervar isFlying;
define playervar hasAbilities;
define playervar heroIndex;
define playervar behaviorIndex;
define playervar selectedHero;
define playervar selectedTeam;
define playervar selectedPlayer;
define playervar flyPosition;
define playervar facingDirection;
define playervar hitPosition;
define playervar hitPlayer;
define playervar initialPosition;
define playervar initialFacing;
define playervar lastCreatedBot;



rule: "SETUP: Setup global variables"
Event.OngoingGlobal
{
    //Set fly mode values
    flySpeed = 20;
    boostSpeed = 20;
    cameraSmoothing = 60;

    // Setup Heroes
    heroes = [
        //Tank Heroes
        Hero.Dva, 
        Hero.Orisa, 
        Hero.Reinhardt, 
        Hero.Roadhog, 
        Hero.Sigma, 
        Hero.Winston, 
        Hero.WreckingBall, 
        Hero.Zarya,
        //Damage Heroes
        Hero.Ashe,
        Hero.Bastion,
        Hero.Doomfist,
        Hero.Genji,
        Hero.Hanzo,
        Hero.Junkrat,
        Hero.Mccree,
        Hero.Mei,
        Hero.Pharah,
        Hero.Reaper,
        Hero.Soldier76,
        Hero.Sombra,
        Hero.Symmetra,
        Hero.Torbjorn,
        Hero.Tracer,
        Hero.Widowmaker,
        //Support Heroes
        Hero.Ana,
        Hero.Baptiste,
        Hero.Brigitte,
        Hero.Lucio,
        Hero.Mercy,
        Hero.Moira,
        Hero.Zenyatta
        ];
    
    savedBots = [];

    // Setup Modes
    modes = [
        // Play Mode
        new Mode(false, true),
        // Pick Heroes Mode
        new Mode(true, false),
        // Build Heroes Mode
        new Mode(true, false)
    ];

    // Setup Behaviors
    behaviors = [
        0,
        1,
        2,
        3,
        4,
        5,
        6,
        7,
        8,
        201,
        301,
        501,
        601,
        701,
        801,
        1001,
        1101,
        2701
    ];

    map = GetMap();
}

rule: "SETUP: Set player properties"
Event.OngoingPlayer
{
    mode = 0;
    behavior = 0;
    isFlying = (<Mode>modes[mode]).allowFlying;
    hasAbilities = (<Mode>modes[mode]).allowAbilities;
    heroIndex = 0;
    behaviorIndex = 0;
    selectedHero = heroes[heroIndex];
    selectedTeam = Team.Team1;
    selectedPlayer = PlayersOnHero(selectedHero, selectedTeam)[0];
}

rule: "SETUP: Skip assembly"
Event.OngoingGlobal
if (IsAssemblingHeroes())
{
    SetMatchTime(0);
}

rule: "SETUP: Skip setup"
Event.OngoingGlobal
if (IsInSetup())
{
    SetMatchTime(0);
}

rule: "SETUP: Remove Scoring"
Event.OngoingGlobal
if (IsGameInProgress())
{
    DisableScoring();
}

rule: "FUNCTION: Switch Mode"
Event.OngoingPlayer
if (IsButtonHeld(EventPlayer(), Button.Interact) 
    && IsGameInProgress())
{
    define prevmode;
    prevmode = EventPlayer().mode;
    if(!IsButtonHeld(EventPlayer(), Button.Ability1))
    {
        if (EventPlayer().mode >= CountOf(modes) - 1)
        {
            EventPlayer().mode = 0;
        }
        else
        {
            EventPlayer().mode++;
        }
    }
    else if (IsButtonHeld(EventPlayer(), Button.Ability1))
    {
        if (EventPlayer().mode <= 0)
        {
            EventPlayer().mode = CountOf(modes) - 1;
        }
        else
        {
            EventPlayer().mode--;
        }
    }

    EventPlayer().hasAbilities = (<Mode>modes[EventPlayer().mode]).allowAbilities;
    if (!EventPlayer().hasAbilities)
    {
        disableAbilities(EventPlayer());
    }
    else
    {
        enableAbilities(EventPlayer());
    }
    if ((<Mode>modes[EventPlayer().mode]).allowFlying != (<Mode>modes[prevmode]).allowFlying)
    {
        EventPlayer().isFlying = toggleFlying(EventPlayer(), EventPlayer().isFlying);
    }
    Wait(0.25);   
}

rule: "MODE: Play Mode"
Event.OngoingPlayer
if (EventPlayer().mode == 0 
    && IsGameInProgress())
{
    CleanHUD();
    Wait(0.25);
    CreateModeMenu(mode);
}

rule: "MODE: Pick Heroes"
Event.OngoingPlayer
if (EventPlayer().mode == 1 
    && IsGameInProgress())
{
    CleanHUD();
    Wait(0.025);
    CreateModeMenu(mode);
    CreatePickHeroMenu();
    CreateBotInfoHUD();
    CreateCursor(mode);
    CreateSelectionMarker();
    //FixEffects();
}

rule: "MODE: Build Heroes"
Event.OngoingPlayer
if (EventPlayer().mode == 2 
    && IsGameInProgress())
{
    CleanHUD();
    Wait(0.025);
    CreateModeMenu(mode);
    CreateBuildHeroMenu();
    CreateBotInfoHUD();
    CreateCursor(mode);
    CreateSelectionMarker();
    //FixEffects();
}

rule: "FUNCTION: Fly"
Event.OngoingPlayer
if (EventPlayer().isFlying 
    && IsGameInProgress())
{
    while (EventPlayer().isFlying)
    {
        EventPlayer().facingDirection = FacingDirectionOf(EventPlayer());
        EventPlayer().flyPosition = EventPlayer().flyPosition + (EventPlayer().facingDirection * Vector(ZOf(ThrottleOf(EventPlayer())), ZOf(ThrottleOf(EventPlayer())), ZOf(ThrottleOf(EventPlayer()))) + WorldVectorOf(Vector(1, 0, 0), EventPlayer(), LocalVector.Rotation) * Vector(XOf(ThrottleOf(EventPlayer())), XOf(ThrottleOf(EventPlayer())), XOf(ThrottleOf(EventPlayer()))) + Vector(0, IsButtonHeld(EventPlayer(), Button.Jump) * 1 + IsButtonHeld(EventPlayer(), Button.Crouch) * -1,0)) * Vector(0.4,0.4,0.4);
        EventPlayer().hitPosition = RayCastHitPosition(flyPosition, flyPosition + facingDirection * 1000, AllPlayers(), EventPlayer(),false);
        EventPlayer().hitPlayer = RayCastHitPlayer(flyPosition, flyPosition + facingDirection * 1000, AllPlayers(), EventPlayer(),false);
    }
}

rule: "PICK HEROES: Cycle Heroes - Forward"
Event.OngoingPlayer
if (IsButtonHeld(EventPlayer(), Button.Ability2) 
    && !IsButtonHeld(EventPlayer(), Button.Ability1) 
    && IsGameInProgress() 
    && EventPlayer().mode == 1)
{
    if (heroIndex >= CountOf(heroes) - 1)
    {
        heroIndex = 0;
    }
    else
    {
        heroIndex++;
    }
    selectedHero = heroes[heroIndex];
}

rule: "PICK HEROES: Cycle Heroes - Back"
Event.OngoingPlayer
if (IsButtonHeld(EventPlayer(), Button.Ultimate) 
    && !IsButtonHeld(EventPlayer(), Button.Ability1) 
    && IsGameInProgress() 
    && EventPlayer().mode == 1)
{
    if (heroIndex <= 0)
    {
        heroIndex = CountOf(heroes) - 1;
    }
    else
    {
        heroIndex--;
    }
    selectedHero = heroes[heroIndex];
}

rule: "PICK HEROES: Place Heroes"
Event.OngoingPlayer
if (IsButtonHeld(EventPlayer(), Button.PrimaryFire) 
    && IsButtonHeld(EventPlayer(), Button.Ability1)
    && IsGameInProgress() 
    && EventPlayer().mode == 1)
{
    if(CountOf(AllPlayers(selectedTeam)) < 6)
    {
        CreateDummyBot(selectedHero, selectedTeam, -1, hitPosition, FacingDirectionOf(EventPlayer()));
        lastCreatedBot = LastCreatedEntity();
        Wait(0.1);
        EventPlayer().selectedPlayer = lastCreatedBot;
        selectedPlayer.behavior = 0;
        selectedPlayer.initialPosition = PositionOf(selectedPlayer);
        selectedPlayer.initialFacing = FacingDirectionOf(selectedPlayer);
        PlayEffect(EventPlayer(), PlayEffect.GoodPickupEffect, Color.Green, selectedPlayer, 1);
        PlayEffect(EventPlayer(), PlayEffect.BuffExplosionSound, Color.White, EventPlayer().flyPosition, 100);
        Wait(0.1);
    }
}

rule: "PICK HEROES: Select Player"
Event.OngoingPlayer
if (IsButtonHeld(EventPlayer(), Button.PrimaryFire) 
    && !IsButtonHeld(EventPlayer(), Button.Ability1) 
    && IsGameInProgress() 
    && EventPlayer().mode == 1)
{
    if (IsTrueForAny(heroes, ArrayElement() == HeroOf(hitPlayer)))
    {
        EventPlayer().selectedPlayer = hitPlayer;
        PlayEffect(EventPlayer(), PlayEffect.RingExplosion, Color.Green, PositionOf(selectedPlayer), 3.5);
    }
}

rule: "PICK HEROES: Move Player"
Event.OngoingPlayer
if (IsButtonHeld(EventPlayer(), Button.SecondaryFire) 
    && !IsButtonHeld(EventPlayer(), Button.Ability1) 
    && IsGameInProgress() 
    && EventPlayer().mode == 1)
{
    Teleport(EventPlayer().selectedPlayer, hitPosition);
    Wait(0.05);
    selectedPlayer.initialPosition = PositionOf(selectedPlayer);
}

rule: "PICK HEROES: Delete Player"
Event.OngoingPlayer
if (IsButtonHeld(EventPlayer(), Button.Ultimate) 
    && IsButtonHeld(EventPlayer(), Button.Ability1) 
    && IsGameInProgress() 
    && EventPlayer().mode == 1)
{
    DestroyDummyBot(TeamOf(selectedPlayer), SlotOf(selectedPlayer));
    PlayEffect(EventPlayer(), PlayEffect.BadPickupEffect, Color.Red, selectedPlayer, 1);
    PlayEffect(EventPlayer(), PlayEffect.ExplosionSound, Color.White, EventPlayer().flyPosition, 100);
    Wait(0.5);
    if(EventPlayer() != AllPlayers()[0])
    {
        EventPlayer().selectedPlayer = AllPlayers()[0];
    }
}

rule: "PICK HEROES: Set facing"
Event.OngoingPlayer
if (IsButtonHeld(EventPlayer(), Button.SecondaryFire) 
    && IsButtonHeld(EventPlayer(), Button.Ability1) 
    && IsGameInProgress() 
    && EventPlayer().mode == 1)
{
    SetFacing(selectedPlayer, hitPosition - EyePosition(selectedPlayer), Relative.ToWorld);
    selectedPlayer.initialFacing = FacingDirectionOf(selectedPlayer);
}

rule: "PICK HEROES: Change Team"
Event.OngoingPlayer
if (IsButtonHeld(EventPlayer(), Button.Ability2) 
    && IsButtonHeld(EventPlayer(), Button.Ability1) 
    && IsGameInProgress() 
    && EventPlayer().mode == 1)
{
    if(selectedTeam == Team.Team1)
    {
        selectedTeam = Team.Team2;
    }
    else if (selectedTeam == Team.Team2)
    {
        selectedTeam = Team.Team1;
    }
}

rule: "BUILD HEROES: Select Player"
Event.OngoingPlayer
if (IsButtonHeld(EventPlayer(), Button.PrimaryFire) 
    && !IsButtonHeld(EventPlayer(), Button.Ability1) 
    && IsGameInProgress() 
    && EventPlayer().mode == 2)
{
    if (IsTrueForAny(heroes, ArrayElement() == HeroOf(hitPlayer)))
    {
        EventPlayer().selectedPlayer = hitPlayer;
        PlayEffect(EventPlayer(), PlayEffect.RingExplosion, Color.Green, PositionOf(selectedPlayer), 3.5);
    }
}

rule: "BUILD HEROES: Cycle Behaviors - Forward"
Event.OngoingPlayer
if (IsButtonHeld(EventPlayer(), Button.Ability2) 
    && IsGameInProgress() 
    && !IsButtonHeld(EventPlayer(), Button.Ability1) 
    && EventPlayer().mode == 2)
{
    if (behaviorIndex >= CountOf(behaviors) - 1)
    {
        behaviorIndex = 0;
    }   
    else
    {
        behaviorIndex++;
    }
    while(RoundToInteger(behaviors[behaviorIndex]/100, Rounding.Down) != 0 
        && RoundToInteger(behaviors[behaviorIndex]/100, Rounding.Down) != IndexOfArrayValue(heroes, HeroOf(EventPlayer().selectedPlayer)) + 1)
    {
        if (behaviorIndex >= CountOf(behaviors) - 1)
        {
            behaviorIndex = 0;
        }   
        else
        {
            behaviorIndex++;
        }
    }
    
}

rule: "BUILD HEROES: Cycle Behaviors - Back"
Event.OngoingPlayer
if (IsButtonHeld(EventPlayer(), Button.Ultimate) 
    && IsGameInProgress() 
    && !IsButtonHeld(EventPlayer(), Button.Ability1) 
    && EventPlayer().mode == 2)
{
    if (behaviorIndex <= 0)
    {
        behaviorIndex = CountOf(behaviors) - 1;
    }
    else
    {
        behaviorIndex--;
    }
    while(RoundToInteger(behaviors[behaviorIndex]/100, Rounding.Down) != 0 && RoundToInteger(behaviors[behaviorIndex]/100, Rounding.Down) != IndexOfArrayValue(heroes, HeroOf(EventPlayer().selectedPlayer)) + 1)
    {
        if (behaviorIndex <= 0)
        {
            behaviorIndex = CountOf(behaviors) - 1;
        }
        else
        {
            behaviorIndex--;
        }
    }
}

rule: "BUILD HEROES: Apply Behavior"
Event.OngoingPlayer
if (IsButtonHeld(EventPlayer(), Button.Ultimate) 
    && IsButtonHeld(EventPlayer(), Button.Ability1) 
    && IsGameInProgress() 
    && EventPlayer().mode == 2)
{
    PlayEffect(EventPlayer(), PlayEffect.GoodPickupEffect, Color.SkyBlue, selectedPlayer, 1);
    resetBehaviors(selectedPlayer);
    selectedPlayer.behavior = behaviors[behaviorIndex];
}

rule: "BUILD HEROES: SaveBot"
Event.OngoingPlayer
if (IsButtonHeld(EventPlayer(), Button.Ability2) 
    && IsButtonHeld(EventPlayer(), Button.Ability1) 
    && IsGameInProgress() 
    && EventPlayer().mode == 2)
{
    define bot;
    bot = new Bot(
        HeroOf(selectedPlayer), 
        SlotOf(selectedPlayer), 
        TeamOf(selectedPlayer), 
        selectedPlayer.behavior, 
        selectedPlayer.initialPosition, 
        selectedPlayer.initialFacing
    );
    Append(savedBots, bot);
    SmallMessage(EventPlayer(), <"Hero: <0> Saved", HeroOf(selectedPlayer)>);
}

rule: "FUNCTION: Destroy bot on death"
Event.OngoingPlayer
if (IsDead(EventPlayer()) 
    && IsDummyBot(EventPlayer()))
{
    DestroyDummyBot(TeamOf(EventPlayer()), SlotOf(EventPlayer()));
}

class Mode
{
    public define allowFlying;
    public define allowAbilities;

    public Mode(define setFlying, define setAbilities)
    {
        allowFlying = setFlying;
        allowAbilities = setAbilities;
    }
    
}

class Bot
{
    public define botHero;
    public define botSlot;
    public define botTeam;
    public define botBehavior;
    public define botInitialPosition;
    public define botInitialFacing;

    public Bot(define inHero, define inSlot, define inTeam, define inBehavior, define inPosition, define inFacing)
    {
        botHero = inHero;
        botSlot = inSlot;
        botTeam = inTeam;
        botBehavior = inBehavior;
        botInitialPosition = inPosition;
        botInitialFacing = inFacing;
    }

}

method toggleFlying(define player, define flying)
{
    if (flying)
    {
        ClearStatus(player, Status.Invincible);
        
        StopCamera(player);

        Teleport(player, flyPosition);
        SetGravity(player, 100);
        StopAccelerating(player);

        flying = false;
    }
    else if (!flying)
    {
        player.flyPosition = EyePosition(player);
        player.facingDirection = FacingDirectionOf(player);
        StartCamera(player, player.flyPosition, player.flyPosition + player.facingDirection, cameraSmoothing);

        SetFacing(player, player.facingDirection,Relative.ToWorld);
        SetStatus(player, null, Status.Invincible, 9999);

        Teleport(player, Vector(XOf(player), YOf(player) + 3000, ZOf(player)));
        SetGravity(player, 0);
        StartAccelerating(player, Vector(0,1,0),100, 1.4, Relative.ToWorld, AccelerateRev.None);    

        flying = true;
    }
    return flying;
}

method enableAbilities(define player)
{

    AllowButton(player, Button.PrimaryFire);
    AllowButton(player, Button.SecondaryFire);
    AllowButton(player, Button.Ability2);
    AllowButton(player, Button.Ultimate);
    AllowButton(player, Button.Jump);
    AllowButton(player, Button.Crouch);
    Wait(0.3);
    AllowButton(player, Button.Ability1);
}

method disableAbilities(define player)
{
    DisallowButton(player, Button.PrimaryFire);
    DisallowButton(player, Button.SecondaryFire);
    DisallowButton(player, Button.Ability1);
    DisallowButton(player, Button.Ability2);
    DisallowButton(player, Button.Ultimate);
    DisallowButton(player, Button.Jump);
    DisallowButton(player, Button.Crouch);

}