I have a confession to make.

I started using Grok to code some really painful elements of my logic that integrate with Unity.

Just an hour ago I had this pain in the ass system where every time I changed or added a bonus (I have 75 currently) I would have to painstakingly find it in the project hierarchy, make sure it matched the internal naming in the scripts, update the player perfab with these links, update the core NPC prefab with these links and then find two sections of code and manually update the reference.

I had a ginormous “else if” logic chain that went through each and every bonus enum, and returned the proper bonus, and I had to manage all of this by hand, it was prone to errors and it was just so tedious. I really hated revising bonus names or adding new ones because of all the little things that could go wrong.

But on a whim after having a little luck with AI yesterday I decided, let’s ask Grok if there’s a better way of doing this crap, and sure enough, THERE IS!

And I gotta be honest, I don’t feel as though I’m cheating using AI in its current incarnation, at least the low grade public form that cost pennies a day to use. It’s prone to wild errors, it’s not going to magically interface with yoru project, you still need to know at an atomic level how the entire thing operates.

Long story short, all AI can really do for you unless you’re over relying on it is make logic that is a TOTAL PAIN IN THE BUM a bit more manageable.

In this instance I just wanted a means of being able to get the data for “Behemoth” from a variable called behemoth on a fish. It sounds so simple in your head, but in practice it’s this horrible monstrosity of logic dealing with coding paradigms that are like 40 years old at this point.

So apparently there are these things called dictionaries and Grok knows how to use them and it gave me this new code:

   private void InitializeBonusMap()

    {

        bonusMap = new Dictionary<zxBonus, Bonus>();

        // Get all public instance fields of type Bonus

        FieldInfo[] fields = GetType().GetFields(BindingFlags.Public | BindingFlags.Instance);

        foreach (FieldInfo field in fields)

        {

            if (field.FieldType == typeof(Bonus) || field.FieldType.IsSubclassOf(typeof(Bonus)))

            {

                Bonus bonus = (Bonus)field.GetValue(this);

                if (bonus != null && !bonusMap.ContainsKey(bonus.bonusEnum))

                {

                    bonusMap[bonus.bonusEnum] = bonus;

                }

            }

        }

    }

    public Bonus GetBonusFromEnum(zxBonus bonusEnum)

    {

        if (bonusMap == null)

        {

            InitializeBonusMap(); // Fallback in case Awake hasn’t run yet

        }

        if (bonusMap.TryGetValue(bonusEnum, out Bonus bonus))

        {

            return bonus;

        }

        // Log if not found and not None

        if (bonusEnum != zxBonus.None)

        {

            string onFishType = isNpc ? " on NPC fish: " : " on player fish: ";

            Debug.Log("Get Bonus not Registered" + onFishType + bonusEnum.ToString());

        }

        return none;

    }

}

And I used to have this:

public Bonus GetBonusFromEnum(zxBonus bonusEnum) {

 if (bonusEnum == afterShocks.bonusEnum) return afterShocks; 

else if (bonusEnum == anger.bonusEnum) return anger; 

else if (bonusEnum == armor.bonusEnum) return armor; 

else if (bonusEnum == berserker.bonusEnum) return berserker;

 else if (bonusEnum == behemoth.bonusEnum) return behemoth; 

else if (bonusEnum == blackJack.bonusEnum) return blackJack; 

else if (bonusEnum == block.bonusEnum) return block; 

else if (bonusEnum == bloodvision.bonusEnum) return bloodvision; 

else if (bonusEnum == blowback.bonusEnum) return blowback; 

else if (bonusEnum == bottomless.bonusEnum) return bottomless; 

else if (bonusEnum == bullys.bonusEnum) return bullys; 

else if (bonusEnum == caliber.bonusEnum) return caliber; 

else if (bonusEnum == camouflage.bonusEnum) return camouflage; 

else if (bonusEnum == camper.bonusEnum) return camper; 

else if (bonusEnum == chargers.bonusEnum) return chargers; 

else if (bonusEnum == chonker.bonusEnum) return chonker; 

else if (bonusEnum == chungus.bonusEnum) return chungus; 

else if (bonusEnum == crash.bonusEnum) return crash;

 else if (bonusEnum == critical.bonusEnum) return critical;

 else if (bonusEnum == infectiousBite.bonusEnum) return infectiousBite;

 else if (bonusEnum == dangerous.bonusEnum) return dangerous;

 else if (bonusEnum == damage.bonusEnum) return damage;

 else if (bonusEnum == dedication.bonusEnum) return dedication; 

else if (bonusEnum == density.bonusEnum) return density; 

else if (bonusEnum == destructive.bonusEnum) return destructive; 

else if (bonusEnum == electricField.bonusEnum) return electricField; 

else if (bonusEnum == enchanter.bonusEnum) return enchanter; 

else if (bonusEnum == explosivo.bonusEnum) return explosivo; 

else if (bonusEnum == finisher.bonusEnum) return finisher; 

else if (bonusEnum == flubby.bonusEnum) return flubby; 

else if (bonusEnum == fortify.bonusEnum) return fortify;

 else if (bonusEnum == fury.bonusEnum) return fury; 

else if (bonusEnum == grewsome.bonusEnum) return grewsome; 

else if (bonusEnum == heart.bonusEnum) return heart; 

else if (bonusEnum == heavy.bonusEnum) return heavy; 

else if (bonusEnum == homing.bonusEnum) return homing; 

else if (bonusEnum == impatient.bonusEnum) return impatient; 

else if (bonusEnum == insatiable.bonusEnum) return insatiable;

 else if (bonusEnum == kelps.bonusEnum) return kelps; 

else if (bonusEnum == lethality.bonusEnum) return lethality; 

else if (bonusEnum == leviathons.bonusEnum) return leviathons; 

else if (bonusEnum == linger.bonusEnum) return linger;

 else if (bonusEnum == lucky.bonusEnum) return lucky;

 else if (bonusEnum == magnet.bonusEnum) return magnet; 

else if (bonusEnum == medic.bonusEnum) return medic; 

else if (bonusEnum == metabolism.bonusEnum) return metabolism; 

else if (bonusEnum == momentum.bonusEnum) return momentum; 

else if (bonusEnum == overpower.bonusEnum) return overpower;

 else if (bonusEnum == phalanx.bonusEnum) return phalanx; 

else if (bonusEnum == prepared.bonusEnum) return prepared; 

else if (bonusEnum == proffesionals.bonusEnum) return proffesionals; 

else if (bonusEnum == protectors.bonusEnum) return protectors;

 else if (bonusEnum == puncture.bonusEnum) return puncture; 

else if (bonusEnum == radiance.bonusEnum) return radiance; 

else if (bonusEnum == razor.bonusEnum) return razor; 

else if (bonusEnum == Regenerative.bonusEnum) return Regenerative; 

else if (bonusEnum == seaCrit.bonusEnum) return seaCrit; 

else if (bonusEnum == scavenger.bonusEnum) return scavenger; 

else if (bonusEnum == shieldSpikes.bonusEnum) return shieldSpikes; 

else if (bonusEnum == shrapnel.bonusEnum) return shrapnel; 

else if (bonusEnum == sinister.bonusEnum) return sinister; 

else if (bonusEnum == scuttle.bonusEnum) return scuttle; 

else if (bonusEnum == snipers.bonusEnum) return snipers; 

else if (bonusEnum == spread.bonusEnum) return spread; 

else if (bonusEnum == squids.bonusEnum) return squids;

 else if (bonusEnum == stalkers.bonusEnum) return stalkers; 

else if (bonusEnum == stunning.bonusEnum) return stunning; 

else if (bonusEnum == swappy.bonusEnum) return swappy;

 else if (bonusEnum == thirsty.bonusEnum) return thirsty;

 else if (bonusEnum == training.bonusEnum) return training; 

else if (bonusEnum == unstoppeable.bonusEnum) return unstoppeable; 

else if (bonusEnum == vampires.bonusEnum) return vampires; 

else if (bonusEnum == warlord.bonusEnum) return warlord; 

else if (bonusEnum == waveSwim.bonusEnum) return waveSwim;

}

Oh and I created this awesome new script with the help of AI that if an asset is tagged as “SelectPrefab” it will now automagically select the parent prefab asset in the project hierarchy. What this means is I will no longer be applying changes to things in the scene and i will ALWAYS be changing values on the root prefab meaning i don’t have to worry if those changes are propagating or just some random modifier on an inconsequential scene object! I’ve been wanting this since FOREVER.

It took WAY too long getting this set up and messing with AI, it was the first time I really got knee deep into trying to architect something from AI that didn’t just automatically work, and it was an interesting and frustrating experience. I learned a lot, you basically have to use AI like a research too, ask it to do things, take the raw things you know work, but finagle things around till you can make it usable then  refeed that new logic back in to expand on it a little more. It’s an interesting new workflow with mostly the same considerations. You gotta be sure you save good bits of important logic while experimenting and finding better ways of doing things.

AI is TERRIBLE at knowing if things are going to recursively break stuff, or lag in engine, or if there might be a better way of optimizing performance. It genuinely feels good to know that our oversight is still absolutely the most important aspect of these systems coming together. I JUST started getting into coding these past few years so it woulda been a gut punch to never feel as though I got to capitalize on all that investment.

As much as I’m enjoying using AI to sew up a few things that were really annoying me and to get some really neat new features in Unity, I AM SO GLAD that I haven’t been using it much, and I’ve been doubling down on developing core coding competencies and organizations.

I don’t think people realize how important it is to keep things readable and try to keep a uniform style of simplicity and organization for our “Discrete Math”. This is the only reason I’m able to push for more and more complex systems without going crazy. Simply put…

Wax on, wax off.

Years and years of using lerps at this point, of figuring out little tricks to simplifying equations and distilling logic to its most ingestible, usable, and modular forms. Scope starts to click, you develop quick workflows for upgrading or downgrading code in a myriad of ways.

All my life I thought I’d be bad at code or was just too old to start picking it up. I think what threw me off was that they called it a language, and I HATED trying to learn French, and Spanish. 

"Je ne suis pas bueno con las grandes fromage puant mots des buveurs de vino de frijoles!"

Anyhow, I’m getting dangerously close to saying I think I MIGHT be starting to be pretty OK at code at this point. I know if I were to put my resume into any studio for a coding gig i’d likely be rejected. Never worked with other coders, I don’t know any of the jargon, I just use R-Tard logic. 

SeaCrit runs on R-Tard strength.

I was so worried AI would be so much better than it is. I was stressing it could just improve every single bit of logic I made in all manner of ways. AND IT CAN! But only if you have intimate knowledge of EXACTLY how to do that, because every bit of logic we create is so insanely custom.

A good analogy for making a video game is like building a custom car. You can’t use stock parts, you can’t just find someone off the street and have them watch youtube videos on how to do things. You gotta just start making shit and start learning how everything interconnects at an absolutely fundamental level.

All this time I thought AI was like going to have this omnipresent intellect that would have to deal with me as if I was some diminutive moron. But it’s actually the opposite, having AI is like having an army of monkeys all coming up with thousands of random bits of logic on their keyboard with no concept of the larger unknown of what COULD BE.

AI is a master of knowing our present cognitive dissonances. It is a MASTER of doing things the absolute average, by the book way. 

The ENTIRE POINT of SeaCrit was to challenge convention, to push the boundaries and create fun new stuff!

I’m SO GLAD that I’m almost done using AI just a touch to improve clunky and horrendous areas of our project where our green coding skills were holding us back. It really wasn’t much, just some initializations for a few mechanics that don’t sync easily with each other with property types and names.

Really looking forward to getting back to basics and just churning out our idiot logic again building up the foundations with raw autistic elbow grease.