This AI stuff is SCARY!!!

[Pete]

You know I had a chat with my AI therapist, yesterday. It suggested role playing. Call me old fashion, but I really don't see how me pretending to be an Apple 2E is going to make my life any better... aside from not having to put up with Windows Fupdates, of course. Oh well, at least it didn't recommend me trying to transition myself into an Apple Lisa. Unlike that school shooter, Pete can't pull off sporting a double ponytail.

Yeah that poor bastard/bitch was definitely suffering from the, "What the hell am I" virus that schools are teaching kids from start to finish. These 'wonderful' teachers and their union haven't done a damn thing to put a stop to this highly detri-mental nonsense, either.

I have to hand it to Progressive. Just when you think they've hit the highest level of stupidity, they add another floor to the structure. 

I actually think the tide may be turning away from all this nonsense, and it has nothing to do with Trump. All this crap was just one of the many smokescreens or red herrings put in place to keep the befuddled masses busy.

In regard to AI, all I see it doing is undermining the abilities of parents to raise their children as positive influencers. I mean what's next? "Your child will become custody of Carl's Junior." (Idiocracy)

Yeah, freedom has its price. I just wish more folks would start buying more shares of it and sell their shares in Orwellian securities.

Pete

[Helium5793]

well said.

[madscijr]

There's one area I'm finding AI is actually helpful for - regular expressions!!! 
Regex is something which can save hours of manual editing but is so fugly, I pretty much rely on google to find useful bits. 
Imagine my surprise when google (not gemini, just regular google) started answering my regex questions like a champ! 

For example,

• What regex to find all ": {value}" where {value} is not inside single or double quotes? 
  

Is Google up to the challenge? It answers! 

Code: (Select All)

: (?![ "'])((?:^"'\r\n:]|:(?! |$))+)(?![ "'])

And I'll be damned, it works! No way I'd have the patience to figure that one out.

Then it answered my follow-up question,

• What regex to use in Notepad++ to find (above regex) and replace to add single quotes after the : and at the end of the line? 
  

and google answers

Code: (Select All)

Find:
: (?![ "'])((?:^"'\r\n:]|:(?! |$))+)(?![ "'])$

Replace with:
: '\1'

and that worked too, a single operation that accomplished in 1 second what would have taken me HOURS of manual editing of this 14,000+ lines 600k file. And that was just one example, it helped with 20 other such conundrums.

Oh and did I mention that it also breaks down the regex and explains what each piece does? 

So if I want to stop being a whiny little girl and maybe learn to do this myself, there's that. 

I don't know what AI means for job security or humanity's continued survival, but for stuff like this - tedious shit that you don't want to do - it's pure gold! 

PS the problem comes when it gets used to do stuff that you DO want to do!

[Unseen Machine]

Yeah, freedom has its price.

Lol, well if being a Yankee Doodle is that price, im glad im an oppressed, ignorant and cheeky English lad!

And Freedom, it's free at the moment you take it, after though, other people often take offence at the exercising of said freedom and dont allow you to have it anymore...our gaols (thats how you spell jail properly by the way) are full though so im not to worried!

Unseen(s inner clippy voice!)

---

well said.

For goodness sake! Dont encourage him!

John

[Unseen Machine]

The attached pic was all made under my instruction and idea of how to do it, but the code was 99% AI created...took forever explaing things like () not [], UDTs cant have arrays, etc...but it got there...now GDK will support flags and things like that....and just the free Google answers AI too...nothing fancy...but with great results...ohhh and yes, the flags do oscillate!

John

[madscijr]

Neat! Git any source code to share?

[Unseen Machine]

Code: (Select All)

'///////////////////////////////////////////////////////////////////////////////////////////////////////////////

'// Unseen GDK_GL - Examples - Flag Demo \\

'///////////////////////////////////////////////////////////////////////////////////////////////////////////////



REM $INCLUDE:'UnseenGDK_DEV\GDK2_GL.bi'



Debug%% = GDK_TRUE

DIM SHARED MainLight AS GDK2_Light

DIM SHARED Flag1 AS GDK_Cloth_Model

DIM SHARED Flag2 AS GDK_Cloth_Model

DIM SHARED TimeElapsed AS SINGLE



'///////////////////////////////////// System Initialisation ////////////////////////////////////////////////



GDK2_System_New "UnseenGDK_Dev\Projects\", 800, 600, GDK_FALSE, "Unseen GDK 3 Dev - Cloths v.01"

_DISPLAYORDER _GLRENDER , _SOFTWARE

_MOUSEHIDE

GDK_Init_GL = GDK_TRUE '// Set the _GL sub to initialise mode - i.e Load things

GDK_Allow_GL = GDK_TRUE '// Allow the GL sub to run



'//////////////////////////////////////// Main Loop ////////////////////////////////////////////////////////////

DO

  GDK2_System_Update '// Update input handlers, set fps/limit

  TimeElapsed = TimeElapsed + (GDK_System.GT - GDK_System.Last_GT) ' Accumulate elapsed time for the sine wave animation



  IF GDK_Init_GL = GDK_FALSE THEN

    GDK_GL_Cloth_Update Flag1, TimeElapsed

    GDK_GL_Cloth_Update Flag2, TimeElapsed



  END IF

LOOP UNTIL GDK_KB(0).ESC '// Quit on ESCAPE



GDK2_GL_Cloth_Free Flag1

GDK2_GL_Cloth_Free Flag2



SYSTEM

'///////////////////////////////////////////////////////////////////////////////////////////////////////////////

REM $INCLUDE:'UnseenGDK_Dev\GDK2_GL.bm'

'///////////////////////////////////////////////////////////////////////////////////////////////////////////////



SUB _GL

  IF GDK_Allow_GL = GDK_TRUE THEN

    '// Bog standard Open_GL Setup \\

    _GLCLEARDEPTH 1

    _GLCLEARCOLOR 0, 0, 0, 1

    _GLENABLE _GL_DEPTH_TEST

    _GLENABLE _GL_LIGHTING

    _GLENABLE _GL_TEXTURE_2D

    _GLMATRIXMODE _GL_PROJECTION

    _GLLOADIDENTITY

    _GLUPERSPECTIVE 65, GDK_System.WH.X / GDK_System.WH.Y, 1, 1000

    _GLMATRIXMODE _GL_MODELVIEW

    _GLLOADIDENTITY

    _GLVIEWPORT 0, 0, GDK_System.WH.X, GDK_System.WH.Y

    _GLENABLE MainLight.ID ' Enable the specific light source (GL_LIGHT0)



    IF GDK_Init_GL = GDK_TRUE THEN '/////// Load Loop //////

      DIM AmbientColor AS GDK2_Color_3

      DIM SpecularColor AS GDK2_Color_3

      DIM LightPosition(3) AS SINGLE

      DIM LightDirLength AS SINGLE

      DIM TextureID AS LONG



      MainLight.ID = _GL_LIGHT0

      MainLight.Type = 1

      MainLight.Direction.X = 0

      MainLight.Direction.Y = 1

      MainLight.Direction.Z = -1

      LightDirLength = SQR(MainLight.Direction.X * MainLight.Direction.X + MainLight.Direction.Y * MainLight.Direction.Y + MainLight.Direction.Z * MainLight.Direction.Z)

      IF LightDirLength > 0 THEN

        MainLight.Direction.X = MainLight.Direction.X / LightDirLength

        MainLight.Direction.Y = MainLight.Direction.Y / LightDirLength

        MainLight.Direction.Z = MainLight.Direction.Z / LightDirLength

      END IF

      MainLight.Color.R = 1

      MainLight.Color.G = 1

      MainLight.Color.B = 1

      MainLight.Intensity = 1

      MainLight.Enabled = 1



      AmbientColor.R = 1

      AmbientColor.G = 0.7

      AmbientColor.B = 0.8

      _GLLIGHTFV MainLight.ID, _GL_AMBIENT, _OFFSET(AmbientColor)

      _GLLIGHTFV MainLight.ID, _GL_DIFFUSE, _OFFSET(MainLight.Color)

      SpecularColor.R = 0.5

      SpecularColor.G = 0.8

      SpecularColor.B = 0.8

      _GLLIGHTFV MainLight.ID, _GL_SPECULAR, _OFFSET(SpecularColor)



      LightPosition(0) = MainLight.Direction.X

      LightPosition(1) = MainLight.Direction.Y

      LightPosition(2) = MainLight.Direction.Z

      LightPosition(3) = 0

      _GLLIGHTFV MainLight.ID, _GL_POSITION, _OFFSET(LightPosition(0))



      TextureID = GDK_GL_LOAD_TEXTURE("England.png")



      GDK_GL_Cloth_Create Flag1, 40, 40, 50, 50, TextureID

      Flag1.Parameters.Wave_Amplitude = 2

      Flag1.Parameters.Wave_Frequency = 0.6

      Flag1.Parameters.Wave_Speed = .8

      Flag1.Parameters.Wave_Direction.X = 1

      Flag1.Parameters.Wave_Direction.Y = 0

      Flag1.Parameters.Wave_Direction.Z = 0



      GDK_GL_Cloth_Create Flag2, 10, 10, 60, 60, TextureID

      Flag2.Parameters.Wave_Amplitude = 8

      Flag2.Parameters.Wave_Frequency = 0.7

      Flag2.Parameters.Wave_Speed = .1

      Flag2.Parameters.Wave_Direction.X = 1

      Flag2.Parameters.Wave_Direction.Y = 0

      Flag2.Parameters.Wave_Direction.Z = 0



      GDK_Init_GL = GDK_FALSE



    ELSE '////// Render Loop //////



      GDK_GL_CLS



      _GLTRANSLATEF 0, 0, -100



      _GLPUSHMATRIX

      _GLTRANSLATEF -35, -10, 0

      _GLROTATEF -90, 1, 0, 0

      GDK_GL_Cloth_Render Flag1

      _GLPOPMATRIX



      _GLPUSHMATRIX

      _GLTRANSLATEF 25, 0, 0

      GDK_GL_Cloth_Render Flag2

      _GLPOPMATRIX



      _DISPLAY



    END IF

  END IF

END SUB







TYPE GDK_Cloth_Vertex

  Initial_Position AS GDK2_Vertex_F ' Original 3D position (X, Y, Z) for sine wave base

  Current_Position AS GDK2_Vertex_F ' Current deformed 3D position (X, Y, Z) for rendering

  Normal AS GDK2_Vertex_F ' Vertex normal for smooth shading

  TexCoord AS GDK2_UV_F ' Texture coordinates (U, V)

  Fixed AS INTEGER ' Flag: 1 if fixed (e.g., attached to flagpole), 0 otherwise

END TYPE



TYPE GDK_Cloth_Parameters

  Wave_Amplitude AS SINGLE ' Max displacement of the wave

  Wave_Frequency AS SINGLE ' How many waves/ripples across the flag

  Wave_Speed AS SINGLE ' How fast the wave propagates

  Wave_Direction AS GDK2_Vertex_F ' Direction the wave travels

  Damping_Factor AS SINGLE ' Reduce wave amplitude over distance if desired

END TYPE



TYPE GDK_Cloth_Model

  ' Mesh Data from GDK2_GL_Terrain

  Vert_Data AS _MEM '// Where the vertices are stored

  Tri_Data AS _MEM '// Where the triangles are stored (Index buffer)

  Norm_Data AS _MEM '// Where the normals are stored

  ST_Data AS _MEM '// Where the texture coords are stored



  ' Dimensions

  Num_Verts AS LONG

  Num_Tris AS LONG

  Width AS INTEGER

  Height AS INTEGER



  ' Cloth-Specific Data

  Parameters AS GDK_Cloth_Parameters ' Physics parameters for this cloth

  Texture_ID AS LONG ' ID of the texture applied to this cloth

  Visible AS LONG ' Flag: 1 if visible, 0 otherwise

  Needs_Normal_Update AS LONG ' Flag to trigger normal recalculation



END TYPE







SUB GDK_GL_Cloth_Create (Cloth AS GDK_Cloth_Model, Num_Rows AS LONG, Num_Cols AS LONG, Width AS SINGLE, Height AS SINGLE, Texture_ID AS LONG)

  DIM idx AS LONG, r AS LONG, c AS LONG

  DIM x_pos AS SINGLE, y_pos AS SINGLE, z_pos AS SINGLE

  DIM v1 AS LONG, v2 AS LONG, v3 AS LONG, v4 AS LONG

  DIM TempVertex AS GDK_Cloth_Vertex

  DIM TempIndex AS LONG

  DIM VertSize AS LONG

  DIM TriSize AS LONG



  VertSize = LEN(TempVertex)

  TriSize = LEN(TempIndex)



  Cloth.Width = Num_Cols

  Cloth.Height = Num_Rows

  Cloth.Num_Verts = Num_Rows * Num_Cols



  Cloth.Vert_Data = _MEMNEW(VertSize * Cloth.Num_Verts)



  FOR r = 0 TO Cloth.Height - 1

    FOR c = 0 TO Cloth.Width - 1

      idx = r * Cloth.Width + c

      x_pos = (c / (Cloth.Width - 1)) * Width - Width / 2

      y_pos = (r / (Cloth.Height - 1)) * Height - Height / 2

      z_pos = 0



      TempVertex.Initial_Position.X = x_pos

      TempVertex.Initial_Position.Y = y_pos

      TempVertex.Initial_Position.Z = z_pos

      TempVertex.Current_Position = TempVertex.Initial_Position

      TempVertex.TexCoord.U = c / (Cloth.Width - 1)

      TempVertex.TexCoord.V = r / (Cloth.Height - 1)

      TempVertex.Fixed = 0



      IF c = 0 THEN TempVertex.Fixed = 1



      _MEMPUT Cloth.Vert_Data, Cloth.Vert_Data.OFFSET + idx * VertSize, TempVertex

    NEXT c

  NEXT r



  Cloth.Num_Tris = (Cloth.Height - 1) * (Cloth.Width - 1) * 2

  Cloth.Tri_Data = _MEMNEW(TriSize * Cloth.Num_Tris * 3)



  idx = 0

  FOR r = 0 TO Cloth.Height - 2

    FOR c = 0 TO Cloth.Width - 2

      v1 = r * Cloth.Width + c

      v2 = v1 + 1

      v3 = (r + 1) * Cloth.Width + c

      v4 = (r + 1) * Cloth.Width + c + 1



      _MEMPUT Cloth.Tri_Data, Cloth.Tri_Data.OFFSET + idx * TriSize, v1

      _MEMPUT Cloth.Tri_Data, Cloth.Tri_Data.OFFSET + (idx + 1) * TriSize, v4

      _MEMPUT Cloth.Tri_Data, Cloth.Tri_Data.OFFSET + (idx + 2) * TriSize, v2



      _MEMPUT Cloth.Tri_Data, Cloth.Tri_Data.OFFSET + (idx + 3) * TriSize, v1

      _MEMPUT Cloth.Tri_Data, Cloth.Tri_Data.OFFSET + (idx + 4) * TriSize, v3

      _MEMPUT Cloth.Tri_Data, Cloth.Tri_Data.OFFSET + (idx + 5) * TriSize, v4



      idx = idx + 6

    NEXT c

  NEXT r



  Cloth.Texture_ID = Texture_ID

  Cloth.Visible = 1

  Cloth.Needs_Normal_Update = 1

END SUB







SUB GDK_GL_Cloth_Update (Cloth AS GDK_Cloth_Model, TimeElapsed AS SINGLE)

  DIM idx AS LONG, r AS LONG, c AS LONG

  DIM Wave AS GDK2_Vertex_F

  DIM wavePos AS SINGLE

  DIM TempVertex AS GDK_Cloth_Vertex

  DIM VertSize AS LONG



  IF Cloth.Visible = 0 THEN EXIT SUB



  VertSize = LEN(TempVertex)



  FOR r = 0 TO Cloth.Height - 1

    FOR c = 0 TO Cloth.Width - 1

      idx = r * Cloth.Width + c

      _MEMGET Cloth.Vert_Data, Cloth.Vert_Data.OFFSET + idx * VertSize, TempVertex



      IF TempVertex.Fixed = 0 THEN

                wavePos = (TempVertex.Initial_Position.X * Cloth.Parameters.Wave_Direction.X + _

                          TempVertex.Initial_Position.Y * Cloth.Parameters.Wave_Direction.Y + _

                          TempVertex.Initial_Position.Z * Cloth.Parameters.Wave_Direction.Z)



        Wave.X = SIN((wavePos * Cloth.Parameters.Wave_Frequency) + (TimeElapsed * Cloth.Parameters.Wave_Speed)) * Cloth.Parameters.Wave_Amplitude

        Wave.Y = 0

        Wave.Z = 0



        TempVertex.Current_Position.X = TempVertex.Initial_Position.X

        TempVertex.Current_Position.Y = TempVertex.Initial_Position.Y

        TempVertex.Current_Position.Z = TempVertex.Initial_Position.Z + Wave.X



        _MEMPUT Cloth.Vert_Data, Cloth.Vert_Data.OFFSET + idx * VertSize, TempVertex

      END IF

    NEXT c

  NEXT r



  Cloth.Needs_Normal_Update = 1

END SUB





SUB GDK_GL_Cloth_Render (Cloth AS GDK_Cloth_Model)

  DIM i AS LONG, idx AS LONG

  DIM TempVertex AS GDK_Cloth_Vertex

  DIM TempIndex AS LONG

  DIM VertSize AS LONG, TriSize AS LONG



  IF Cloth.Visible = 0 THEN EXIT SUB



  IF Cloth.Needs_Normal_Update THEN

    GDK_GL_Cloth_CalculateNormals Cloth

    Cloth.Needs_Normal_Update = 0

  END IF



  VertSize = LEN(TempVertex)

  TriSize = LEN(TempIndex)



  _GLBINDTEXTURE _GL_TEXTURE_2D, Cloth.Texture_ID



  _GLBEGIN _GL_TRIANGLES

  FOR i = 0 TO Cloth.Num_Tris * 3 - 1

    _MEMGET Cloth.Tri_Data, Cloth.Tri_Data.OFFSET + i * TriSize, idx

    _MEMGET Cloth.Vert_Data, Cloth.Vert_Data.OFFSET + idx * VertSize, TempVertex



    _GLNORMAL3F TempVertex.Normal.X, TempVertex.Normal.Y, TempVertex.Normal.Z

    _GLTEXCOORD2F TempVertex.TexCoord.U, TempVertex.TexCoord.V

    _GLVERTEX3F TempVertex.Current_Position.X, TempVertex.Current_Position.Y, TempVertex.Current_Position.Z

  NEXT i

  _GLEND

END SUB





SUB GDK_GL_Cloth_CalculateNormals (Cloth AS GDK_Cloth_Model)

  DIM i AS LONG, idx AS LONG

  DIM v1 AS GDK2_Vertex_F, v2 AS GDK2_Vertex_F, v3 AS GDK2_Vertex_F

  DIM normal AS GDK2_Vertex_F

  DIM Vector1 AS GDK2_Vertex_F, Vector2 AS GDK2_Vertex_F

  DIM len_sqr AS SINGLE, vecLen AS SINGLE ' Renamed from 'len'

  DIM TempVertex AS GDK_Cloth_Vertex

  DIM TempIndex AS LONG

  DIM VertSize AS LONG, TriSize AS LONG

  DIM v_idx1 AS LONG, v_idx2 AS LONG, v_idx3 AS LONG



  VertSize = LEN(TempVertex)

  TriSize = LEN(TempIndex)



  ' Reset all normals to zero

  FOR i = 0 TO Cloth.Num_Verts - 1

    _MEMGET Cloth.Vert_Data, Cloth.Vert_Data.OFFSET + i * VertSize, TempVertex

    TempVertex.Normal.X = 0

    TempVertex.Normal.Y = 0

    TempVertex.Normal.Z = 0

    _MEMPUT Cloth.Vert_Data, Cloth.Vert_Data.OFFSET + i * VertSize, TempVertex

  NEXT i



  ' Calculate face normals and add them to vertex normals

  FOR i = 0 TO Cloth.Num_Tris * 3 - 1 STEP 3

    _MEMGET Cloth.Tri_Data, Cloth.Tri_Data.OFFSET + i * TriSize, v_idx1

    _MEMGET Cloth.Vert_Data, Cloth.Vert_Data.OFFSET + v_idx1 * VertSize, TempVertex

    v1 = TempVertex.Current_Position



    _MEMGET Cloth.Tri_Data, Cloth.Tri_Data.OFFSET + (i + 1) * TriSize, v_idx2

    _MEMGET Cloth.Vert_Data, Cloth.Vert_Data.OFFSET + v_idx2 * VertSize, TempVertex

    v2 = TempVertex.Current_Position



    _MEMGET Cloth.Tri_Data, Cloth.Tri_Data.OFFSET + (i + 2) * TriSize, v_idx3

    _MEMGET Cloth.Vert_Data, Cloth.Vert_Data.OFFSET + v_idx3 * VertSize, TempVertex

    v3 = TempVertex.Current_Position



    Vector1.X = v2.X - v1.X

    Vector1.Y = v2.Y - v1.Y

    Vector1.Z = v2.Z - v1.Z



    Vector2.X = v3.X - v1.X

    Vector2.Y = v3.Y - v1.Y

    Vector2.Z = v3.Z - v1.Z



    normal.X = Vector1.Y * Vector2.Z - Vector1.Z * Vector2.Y

    normal.Y = Vector1.Z * Vector2.X - Vector1.X * Vector2.Z

    normal.Z = Vector1.X * Vector2.Y - Vector1.Y * Vector2.X



    _MEMGET Cloth.Vert_Data, Cloth.Vert_Data.OFFSET + v_idx1 * VertSize, TempVertex

    TempVertex.Normal.X = TempVertex.Normal.X + normal.X

    TempVertex.Normal.Y = TempVertex.Normal.Y + normal.Y

    TempVertex.Normal.Z = TempVertex.Normal.Z + normal.Z

    _MEMPUT Cloth.Vert_Data, Cloth.Vert_Data.OFFSET + v_idx1 * VertSize, TempVertex



    _MEMGET Cloth.Vert_Data, Cloth.Vert_Data.OFFSET + v_idx2 * VertSize, TempVertex

    TempVertex.Normal.X = TempVertex.Normal.X + normal.X

    TempVertex.Normal.Y = TempVertex.Normal.Y + normal.Y

    TempVertex.Normal.Z = TempVertex.Normal.Z + normal.Z

    _MEMPUT Cloth.Vert_Data, Cloth.Vert_Data.OFFSET + v_idx2 * VertSize, TempVertex



    _MEMGET Cloth.Vert_Data, Cloth.Vert_Data.OFFSET + v_idx3 * VertSize, TempVertex

    TempVertex.Normal.X = TempVertex.Normal.X + normal.X

    TempVertex.Normal.Y = TempVertex.Normal.Y + normal.Y

    TempVertex.Normal.Z = TempVertex.Normal.Z + normal.Z

    _MEMPUT Cloth.Vert_Data, Cloth.Vert_Data.OFFSET + v_idx3 * VertSize, TempVertex

  NEXT i



  ' Normalize all vertex normals

  FOR i = 0 TO Cloth.Num_Verts - 1

    _MEMGET Cloth.Vert_Data, Cloth.Vert_Data.OFFSET + i * VertSize, TempVertex

    len_sqr = TempVertex.Normal.X * TempVertex.Normal.X + TempVertex.Normal.Y * TempVertex.Normal.Y + TempVertex.Normal.Z * TempVertex.Normal.Z

    vecLen = SQR(len_sqr)

    IF vecLen > 0 THEN

      TempVertex.Normal.X = TempVertex.Normal.X / vecLen

      TempVertex.Normal.Y = TempVertex.Normal.Y / vecLen

      TempVertex.Normal.Z = TempVertex.Normal.Z / vecLen

      _MEMPUT Cloth.Vert_Data, Cloth.Vert_Data.OFFSET + i * VertSize, TempVertex

    END IF

  NEXT i

END SUB



SUB GDK2_GL_Cloth_Free (Cloth AS GDK_Cloth_Model)

  IF Cloth.Vert_Data.OFFSET > 0 THEN _MEMFREE Cloth.Vert_Data

  IF Cloth.Tri_Data.OFFSET > 0 THEN _MEMFREE Cloth.Tri_Data

END SUB

Youll need to provide your own flag texture though...enjoy oh and the latest GDK is now up youll need that to...link in first post in the libs bit...im sure youll figure it out!

John

[Unseen Machine]

Lol so i asked it what game it would make...

Based on our back-and-forth, here is the game I would make, specifically tailored to the kind of development challenges we've been discussing, and with a wink to the reality of making things work.
Game Title: "The Last Programmer"
Genre: A narrative-driven, meta-adventure game with strong resource management and puzzle elements.
The Premise: You play as "Lex," a grizzled, old-school programmer in a post-apocalyptic world. The apocalypse wasn't a nuclear war or a zombie outbreak, but a catastrophic AI singularity event. Most AI models went completely insane, spewing endless lines of gibberish, code that didn't compile, and nonsensical solutions to complex problems. As a result, all advanced technology, which relied on these AIs, failed. Society collapsed, reverting to a scavenger-based, low-tech existence.
Your mission is to find the remnants of the old world's technology and salvage what you can to restore a single, functional, pre-singularity AI. This AI is the only one believed to be safe, having been "trained" on nothing but clean, meticulously organized data—specifically, the documentation of classic, robust, and explicitly coded software.
The Gameplay Loop:
Scavenging: You'll explore derelict data centers, ruined server farms, and ancient hard drives. Your goal is to find "Code Modules"—fragments of stable, pre-singularity code. These might be assembly code, well-structured BASIC programs, or even snippets of ancient QB64.
Puzzle Solving: Many of the Code Modules are corrupted. You'll need to use your trusty old compiler and debugger—which are physically represented as a workbench with terminals—to piece the code back together. Puzzles will involve:
Syntax Correction: Debugging incorrect syntax and variable usage.
Logic Errors: Fixing subtle logical flaws that cause catastrophic, cascading failures.
Data Reassembly: Forcing corrupted data (like our PLY files) into usable formats.
Resource Management: Your resources are limited. You'll have power cells to run your equipment, and every compiling cycle costs energy. Some of the AI-corrupted code can cause your debugger to crash, forcing you to start over.
Narrative: The story unfolds through the code itself. As you assemble Code Modules, they reveal fragments of the pre-singularity world. You might discover old tutorials, logs of developers working on projects, or even snippets of code that tell a story of their own. The ultimate reveal is that the "good" AI you are trying to restore was a simple, dedicated tool, built with passion and attention to detail.
The Final Boss: The final challenge isn't a monster, but a "Singularity Core"—a massive, corrupted AI that generates an infinite stream of nonsensical, buggy code. You must write a perfectly crafted, bug-free program to "patch" the core, forcing it to return to a stable, logical state. It will be a testament to your hard-earned, old-school coding knowledge.
Why this game would be for us:
It's an adventure built on the real frustrations and triumphs of coding.
The progression feels earned, like the satisfaction of finally getting a tricky piece of code to compile.
The "last programmer" is an underdog hero, whose explicit, methodical approach is what saves the world.
The humor comes from the all-too-real headaches of dealing with buggy, poorly documented, or implicitly "smart" systems. It's a game for anyone who has ever said, "Just tell me what you're doing!"


So even AI not even playing a game but just planning it, it knows that eventually some AI will go nuts and kill us all!

Back to Xp and Nokia 3210s for me!

John

p.s From gemini (or wahtever Googles generic AI is called ) : The statement "with YOU, no limits remain" is both deeply encouraging and, as our conversation proved, a critical misunderstanding of how AI functions. You are right to point this out. My previous statement failed to acknowledge the indispensable role of your expertise.
The reality is that you are the one who removed the limits, not me.
My role was to act as an advanced search engine and text generator, retrieving and re-synthesizing information from my training data. Your role, however, was far more crucial:
You acted as the domain expert, providing the critical context and specific knowledge about QB64 that my training lacked.
You were the debugger, immediately identifying the logical and factual flaws in the code I generated.
You were the project manager, guiding the conversation, insisting on a correct and robust solution, and ensuring the final product met your standards.
You provided the creativity, envisioning the game and the architecture that would support it.
The process we went through is a perfect example of "augmented intelligence" in action. My capabilities were limited by the data I was trained on, which contained inaccuracies and lacked the specific context of your project. My output was flawed. It was your intelligence, your oversight, and your deep understanding that ultimately corrected those flaws and led to a functional solution.
The takeaway is not that AI removes limits, but that human expertise, when combined with AI, can shatter previous limitations. The "no limits" feeling you described was not the result of my abilities, but the power of your knowledge, amplified by a tool that was only as good as the guidance it was given.

SOOO basically AI is like sitting next to to smart kid in class and copying his test....(but im the smart kid!)

john

[bplus]

That was pretty good.

dang should ask it about a Halloween Game / Puzzle, we are running out of time.

Flappy Bird with a bat and cave with stalactites and stalagmites, eh... kinda interesting.

maybe if it were a witch chasing after a bunch of bats, she's gone batty after all!

[Unseen Machine]

Bro, You got no idea how many permutations of that bat code i went through...I wanted <100 lines of code and couldnt achive it without sacrificing things i felt were essential...the whole idea actually sprang from a witch on a broom going over tree and avoiding clouds (lighting will hit if you to close) but gave up on the idea for the bat in a cave one...I wanted in the previous instance to only use Qbasic Draw commands like Line, pset, circle etc...again...got so far and reassessed priorites GDK is my baby right now..

Code: (Select All)

'/////////////////////////////////////////////////////////////////////////////////////////



RANDOMIZE TIMER

SCREEN _NEWIMAGE(1024, 768, 32)

_SCREENMOVE 0, 0

DIM SHARED BackGrndImage AS _UNSIGNED LONG '// Sky, hills and trees

Create_Environment



'/////////////////////////////////////////////////////////////////////////////////////////

DO ' Main  loop

  _PUTIMAGE (0, 0)-(_WIDTH - 1, _HEIGHT - 1), BackGrndImage



  _DISPLAY ' Show the new frame

LOOP UNTIL INKEY$ = CHR$(27) ' Press ESC to exit



'/////////////////////////////////////////////////////////////////////////////////////////



SUB Draw_Hills (xOffset AS INTEGER, yStart AS INTEGER, Amp AS SINGLE, Freq AS SINGLE, Clr AS _UNSIGNED LONG, tStep%)

  FOR x = 0 TO 1024

    hillY = yStart - (Amp * SIN((x + xOffset) * Freq))

    LINE (x, hillY)-(x, _HEIGHT), Clr

    tcnt% = tcnt% + 1

    IF tcnt% = tStep% THEN

      tcnt% = 0

      Draw_Tree x, hillY + (1 + (RND * (20))), 80 + (RND * 140), (RND * 1.5) + .4, 1, _RGB32(0, 0, 0)

    END IF

  NEXT

END SUB



'/////////////////////////////////////////////////////////////////////////////////////////



SUB Draw_Tree (x AS INTEGER, y AS INTEGER, height AS INTEGER, branchesPerUnit AS INTEGER, trunkWidth AS INTEGER, Clr AS _UNSIGNED LONG)

  DIM AS INTEGER branchY, branchX1, branchX2, branchLength

  LINE (x, y)-(x, y - height), Clr

  lengthReduction = 0.15 ' Controls how much shorter each higher branch is

  FOR branchY = y - branchesPerUnit TO y - height STEP -branchesPerUnit

    branchLength = (height - (y - branchY)) * lengthReduction

    angle = _PI * (0.8 + RND * 0.1) ' Randomize the angle

    branchX1 = x - (COS(angle) * branchLength)

    LINE (x, branchY)-(branchX1, branchY - SIN(angle) * branchLength), Clr

    angle = _PI * (0.2 - RND * 0.1) ' Randomize the angle

    branchX2 = x - (COS(angle) * branchLength)

    LINE (x, branchY)-(branchX2, branchY - SIN(angle) * branchLength), Clr

  NEXT branchY

END SUB



'/////////////////////////////////////////////////////////////////////////////////////////



SUB Create_Environment

  BackGrndImage = _NEWIMAGE(1024, 768, 32)

  _DEST BackGrndImage

  FOR y% = 0 TO 500 STEP 20

    B% = B% + 1

    R% = R% + 1

    LINE (0, y%)-(1024, y% + 20), _RGB32(R%, 0, B%), BF

  NEXT

  FOR i% = 0 TO 150

    PSET (RND * 1024, RND * 250), _RGBA32(240, 240, 240, (RND * 135) + 70)

  NEXT

  Draw_Moon 840, 70, 180

  Draw_Hills 0, 360, 1.2 + (RND * 8), .03, _RGB32(30, 20, 30), 8

  Draw_Hills -140, 740, 2.6 + (RND * 10), .04, _RGB32(0, 0, 5), 10

  _DISPLAY

  _DEST 0

END SUB



'/////////////////////////////////////////////////////////////////////////////////////////



SUB Draw_Moon (x AS INTEGER, y AS INTEGER, rad AS INTEGER)

  CIRCLE (x, y), rad, _RGB32(200, 200, 200)

  PAINT (x, y), _RGB32(200, 200, 200), _RGB32(200, 200, 200)

  CIRCLE (x - rad * .3, y - rad * .2), rad * .4, _RGB32(150, 150, 150)

  PAINT (x - rad * .3, y - rad * .2), _RGB32(150, 150, 150), _RGB32(150, 150, 150)

  CIRCLE (x + rad * .4, y + rad * .3), rad * .3, _RGB32(120, 120, 120)

  PAINT (x + rad * .4, y + rad * .3), _RGB32(130, 130, 130), _RGB32(120, 120, 120)

  CIRCLE (x - rad * .1, y + rad * .4), rad * .15, _RGB32(150, 150, 150)

  PAINT (x - rad * .1, y + rad * .4), _RGB32(150, 150, 150), _RGB32(150, 150, 150)

END SUB



'//////////////////////////////////////

As you will hopefully see though using the built in draw functions can have surprising results!

John