Voltage

Yeah, I'm very familiar with the tech, I've been interested in games dev and web dev for a few decades now. So you could be right, that the models aren't ready to "play on their own" yet.

I tried doing a warcraft 1 clone, but that felt too complex for the model being used (openai 4.1). That model was just the default setting in copilot.

I dug a little deeper this morning, and it turns out I hadn't actually enabled my copilot 'pro' mode, which has granted access to some more current or dev focused models. So I'll take them for a spin to see what they're capable of.

My goal here is to roughly get a sense for when a task is too complex for an "agent" to handle.

I also want to try adding custom tools to suit certain project needs. For example, Unreal Engine has a python editor interface, so I'd like to have an agent drive the editor to build something. I have my doubts.

Once I have a feeling for what level of complexity can be handled, I'll see if I can manage the tools better using this understanding, by breaking large and complex projects into appropriate chunks of work / complexity.

/endBrainDump

I will. I'm just trying to evaluate the tools on a medium size task. I'm trying copilot's agent mode with the goal of creating a warcraft 1 clone. Or something resembling it.

* It's not mobile friendly, and you use arrow keys to move around

Given my interest in games and demos, I feel the opposite. I'm always in search of the real-time method that looks plausible and can cover huge areas in 3d space.

Computational accuracy is not important to me at all.

1) Can build to web mobile 2) Editor for the art team

A big smiley face. :)

    uniform float time;
    varying vec2 vUv;

    // https://iquilezles.org/articles/distfunctions2d/ (Thanks IQ!)
    float sdRing( in vec2 p, in vec2 n, in float r, float th )
    {
        p.x = abs(p.x);
   
        p = mat2x2(n.x,n.y,-n.y,n.x)*p;

        return max( abs(length(p)-r)-th*0.5,
                length(vec2(p.x,max(0.0,abs(r-p.y)-th*0.5)))*sign(p.x) );
    }

    void main() {

        // create coordinates at visual centre (y coords doubled for circles)
        vec2 centre = vec2(0.25, 0.25);        
        vec2 uv = vUv * vec2(1.0, 0.5) - centre;

        // mirror x to get both eyes for the price of one, and find eye offset
        float eyes = length(vec2(abs(uv.x), uv.y) - vec2(0.035, 0.03));
        // carve them out using smoothstep
        eyes = smoothstep(0.015, 0.016, eyes);

        float mouth = sdRing(vec2(uv.x, -uv.y + 0.03), vec2(7), 0.65, 0.1);
        mouth = smoothstep(0.02, 0.025, mouth);

        float shade = min(eyes, mouth);
    
        vec3 yellow = vec3(0.9, 0.7, 0.0);
        vec3 color = shade * yellow;

        gl_FragColor = vec4(color, 1.0);
    }

Thanks for the tip.

I thought I recognized your handle! You wrote the "A Primer on Bézier Curves" article. Thanks for providing that amazing resource, it's been invaluable during my learning process.

Great article! I didn't know about Rotation Minimizing Frames or the double reflection method.

I've run up against the issue of unexpected twisting of splines at work more than once.

As an Australian, is the best approach to encrypt all my storage and communications? Is that even possible when the potential threat is the government?