Invalid Cast Exception

[TforTrevor]

I can't figure out exactly what's causing this exception to occur. I tried debugging it, however I was getting a different error when opening the file directly with Deltinteger.exe

Error:

An exception was thrown while parsing.
System.InvalidCastException: Unable to cast object of type 'Deltin.Deltinteger.Elements.EnumMember' to type 'Deltin.Deltinteger.Elements.Element'.
   at Deltin.Deltinteger.Parse.SetVariableAction.Translate(ActionSet actionSet) in C:\Users\Deltin\Documents\GitHub\Overwatch-Script-To-Workshop\Deltinteger\Deltinteger\Parse\Variables\SetVariable.cs:line 44
   at Deltin.Deltinteger.Parse.BlockAction.Translate(ActionSet actionSet) in C:\Users\Deltin\Documents\GitHub\Overwatch-Script-To-Workshop\Deltinteger\Deltinteger\Parse\Block.cs:line 49
   at Deltin.Deltinteger.Parse.DefinedConstructor.Parse(ActionSet actionSet, IWorkshopTree[] parameterValues, Object[] additionalParameterData) in C:\Users\Deltin\Documents\GitHub\Overwatch-Script-To-Workshop\Deltinteger\Deltinteger\Parse\Types\Constructor.cs:line 93
   at Deltin.Deltinteger.Parse.DefinedType.New(ActionSet actionSet, NewClassInfo newClassInfo) in C:\Users\Deltin\Documents\GitHub\Overwatch-Script-To-Workshop\Deltinteger\Deltinteger\Parse\Types\DefinedType.cs:line 163
   at Deltin.Deltinteger.Parse.ClassType.New(ActionSet actionSet, Constructor constructor, IWorkshopTree[] constructorValues, Object[] additionalParameterData) in C:\Users\Deltin\Documents\GitHub\Overwatch-Script-To-Workshop\Deltinteger\Deltinteger\Parse\Types\Classes.cs:line 122
   at Deltin.Deltinteger.Parse.CreateObjectAction.Parse(ActionSet actionSet, Boolean asElement) in C:\Users\Deltin\Documents\GitHub\Overwatch-Script-To-Workshop\Deltinteger\Deltinteger\Parse\Types\CreateObjectAction.cs:line 59
   at Deltin.Deltinteger.Parse.SetVariableAction.Translate(ActionSet actionSet) in C:\Users\Deltin\Documents\GitHub\Overwatch-Script-To-Workshop\Deltinteger\Deltinteger\Parse\Variables\SetVariable.cs:line 44
   at Deltin.Deltinteger.Parse.BlockAction.Translate(ActionSet actionSet) in C:\Users\Deltin\Documents\GitHub\Overwatch-Script-To-Workshop\Deltinteger\Deltinteger\Parse\Block.cs:line 49
   at Deltin.Deltinteger.Parse.DefinedMethod.ParseNormal(ActionSet actionSet, MethodCall methodCall) in C:\Users\Deltin\Documents\GitHub\Overwatch-Script-To-Workshop\Deltinteger\Deltinteger\Parse\Functions\DefinedMethod.cs:line 285
   at Deltin.Deltinteger.Parse.DefinedMethod.Parse(ActionSet actionSet, MethodCall methodCall) in C:\Users\Deltin\Documents\GitHub\Overwatch-Script-To-Workshop\Deltinteger\Deltinteger\Parse\Functions\DefinedMethod.cs:line 272
   at Deltin.Deltinteger.Parse.CallMethodAction.Parse(ActionSet actionSet, Boolean asElement) in C:\Users\Deltin\Documents\GitHub\Overwatch-Script-To-Workshop\Deltinteger\Deltinteger\Parse\Functions\CallMethod.cs:line 91
   at Deltin.Deltinteger.Parse.ExpressionTree.ParseTree(ActionSet actionSet, Boolean expectingValue, Boolean asElement) in C:\Users\Deltin\Documents\GitHub\Overwatch-Script-To-Workshop\Deltinteger\Deltinteger\Parse\ExpressionTree.cs:line 159
   at Deltin.Deltinteger.Parse.ExpressionTree.Translate(ActionSet actionSet) in C:\Users\Deltin\Documents\GitHub\Overwatch-Script-To-Workshop\Deltinteger\Deltinteger\Parse\ExpressionTree.cs:line 123
   at Deltin.Deltinteger.Parse.BlockAction.Translate(ActionSet actionSet) in C:\Users\Deltin\Documents\GitHub\Overwatch-Script-To-Workshop\Deltinteger\Deltinteger\Parse\Block.cs:line 49
   at Deltin.Deltinteger.Parse.TranslateRule..ctor(DeltinScript deltinScript, RuleAction ruleAction) in C:\Users\Deltin\Documents\GitHub\Overwatch-Script-To-Workshop\Deltinteger\Deltinteger\Parse\TranslateRule.cs:line 44
   at Deltin.Deltinteger.Parse.DeltinScript.ToWorkshop(Func`2 addRules) in C:\Users\Deltin\Documents\GitHub\Overwatch-Script-To-Workshop\Deltinteger\Deltinteger\Parse\Translate.cs:line 293
   at Deltin.Deltinteger.Parse.DeltinScript..ctor(TranslateSettings translateSettings) in C:\Users\Deltin\Documents\GitHub\Overwatch-Script-To-Workshop\Deltinteger\Deltinteger\Parse\Translate.cs:line 59
   at Deltin.Deltinteger.LanguageServer.DocumentHandler.Update() in C:\Users\Deltin\Documents\GitHub\Overwatch-Script-To-Workshop\Deltinteger\Deltinteger\Language Server\DocumentHandler.cs:line 181

Code:

DoomfistManager.del

import "InfinityStone.del";
import "SnappedPlayer.del";

class DoomfistManager {

    private static InfinityStone mindStone;
    private static InfinityStone powerStone;
    private static InfinityStone realityStone;
    private static InfinityStone soulStone;
    private static InfinityStone spaceStone;
    private static InfinityStone timeStone;
    private static define snappedPlayers;

    public static void CreateStones() {
        mindStone = new InfinityStone("Mind Stone", Color.Yellow);
        powerStone = new InfinityStone("Power Stone", Color.Purple);
        realityStone = new InfinityStone("Reality Stone", Color.Red);
        soulStone = new InfinityStone("Soul Stone", Color.Orange);
        spaceStone = new InfinityStone("Space Stone", Color.Blue);
        timeStone = new InfinityStone("Time Stone", Color.Green);
    }

    public static define GetStones(define player) {
        define stones;
        if (mindStone.GetHolder() == player) {
            Append(stones, mindStone);
        }
        if (powerStone.GetHolder() == player) {
            Append(stones, powerStone);
        }
        if (realityStone.GetHolder() == player) {
            Append(stones, realityStone);
        }
        if (soulStone.GetHolder() == player) {
            Append(stones, soulStone);
        }
        if (spaceStone.GetHolder() == player) {
            Append(stones, spaceStone);
        }
        if (timeStone.GetHolder() == player) {
            Append(stones, timeStone);
        }
        return stones;
    }

    public recursive static void DistributeStones() {
        define players = RandomizedArray(AllPlayers());
        mindStone.SetHolder(players[0]);
        powerStone.SetHolder(players[1]);
        realityStone.SetHolder(players[2]);
        soulStone.SetHolder(players[3]);
        spaceStone.SetHolder(players[4]);
        timeStone.SetHolder(players[5]);
    }

    public recursive static void Snap(define snapper) {
        define players = RemoveFromArray(RandomizedArray(AllLivingPlayers(Team.All)), snapper);
        foreach (define player in players) {
            SnappedPlayer snappedPlayer = new SnappedPlayer(player, snapper);
            Append(snappedPlayers, snappedPlayer);

            if (IsInSpawnRoom(player)) {
                Wait(10);
                snappedPlayer.Finish();
            }
        }
    }

    public recursive static void RemoveSnap(SnappedPlayer player) {
        RemoveFromArray(snappedPlayers, player);
        delete(player);
        if (CountOf(snappedPlayers) == 0) {
            Wait(5);
            DistributeStones();
        }
    }

    public static define GetSnappedPlayers() {
        return snappedPlayers;
    }
}

//Create stones and give them to players
rule: "Intialize"
Event.OngoingGlobal {
    DoomfistManager.CreateStones();
    DoomfistManager.DistributeStones();
}

//Distributes stones from the player that left
rule: "On Player Leave"
Event.OnPlayerLeave {
    define stones = DoomfistManager.GetStones(EventPlayer());
    define players = RandomizedArray(AllPlayers());
    for (define i = 0; i < CountOf(stones); i++) {
        InfinityStone stone = stones[i];
        stone.SetHolder(players[i]);
    }
}

rule: "On Kill"
Event.OnFinalBlow
Player.Doomfist {
    define stones = DoomfistManager.GetStones(Victim());
    foreach (InfinityStone stone in stones) {
        stone.SetHolder(EventPlayer());
    }

    if (CountOf(DoomfistManager.GetStones(EventPlayer())) == 6) {
        DoomfistManager.Snap(EventPlayer());
    }
}

rule: "On Death"
Event.OnDeath
Player.All {
    foreach (SnappedPlayer snappedPlayer in DoomfistManager.GetSnappedPlayers()) {
        if (snappedPlayer.GetPlayer() == EventPlayer()) {
            snappedPlayer.Finish();
        }
    }
}

InfinityStone.del

import "DoomfistManager.del";

class InfinityStone {
    private define name;
    private define color;
    private define effect;
    private define holder;
    private define stoneHud;

    public InfinityStone(define n, Color c) {
        name = n;
        color = c;
    }

    public void SetHolder(define player) {
        CreateEffect(player, Effect.Sphere, color, holder, 0.5, EffectRev.VisibleToPositionAndRadius);
        effect = LastCreatedEntity();
        holder = player;
        DestroyHudText(stoneHud);
        if (HeroOf(player) == Hero.DoomfistManager) {
            CreateHudText(player, "", "", name, Location.Right, 0, color, color, color, HudTextRev.VisibleToAndString, Spectators.VisibleNever);
            stoneHud = LastTextID();
        }
    }

    public define GetHolder() {
        return holder;
    }
}

SnappedPlayer.del

import "DoomfistManager.del";

class SnappedPlayer {
    private define player;
    private define dotId;

    public SnappedPlayer(define p, define snapper) {
        player = p;
        SetStatus(player, snapper, Status.KnockedDown, 9999);
        StartDamageOverTime(player, snapper, 9999, 50);
        dotId = LastDamageOverTime();
    }

    public recursive void Finish() {
        ClearStatus(player, Status.KnockedDown);
        StopDamageOverTime(dotId);
        DoomfistManager.RemoveSnap(this);
    }

    public define GetPlayer() {
        return player;
    }
}

[Suiranoil]

"InfinityStone.del" --> SetHolder --> if (HeroOf(player) == Hero.DoomfistManager) hero cannot be DoomfistManager

[TforTrevor]

Can't believe I missed that lol. Sadly, that was not the issue, I am still getting the error after fixing the typo.

[derwangler]

In your InfinityStone constructor, you attempt to store a workshop constant in a variable. You cannot do this.

public InfinityStone(define n, Color c) {
        name = n;
        color = c; // Errors
    }

[TforTrevor]

Yeah, that fixed it. Any plans on allowing this or am I going about colors the wrong way?

[derwangler]

It is a limitation of the workshop itself. You cannot store a constant workshop type such as Color in a variable.

[ItsDeltin]

There is a workaround however, you can do something like this.

enum StoreColor
{
    Blue,
    Red,
    Yellow,
    Green
}
...
private StoreColor color;
private define effect;
...
public InfinityStone(define n, StoreColor c) {
    name = n;
    color = c;
}
...
public void SetHolder(define player) {
    effect = MakeEffect();
...
define MakeEffect()
{
    switch (color)
    {
        case StoreColor.Blue: MakeEffect(Color.Blue); break;
        case StoreColor.Red: MakeEffect(Color.Red); break;
        case StoreColor.Yellow: MakeEffect(Color.Yellow); break;
        case StoreColor.Green: MakeEffect(Color.Green); break;
    }
    return LastCreatedEntity();
}

define MakeEffect(Color color)
{
    CreateEffect(player, Effect.Sphere, color, holder, 0.5, EffectRev.VisibleToPositionAndRadius);
}

Will label as bug since there should be a syntax error, not an exception.

[Protowalker]

This is fixed in 1.7