Introduction: When Classes End, Trouble Begins

Anyone old enough to remember Scorched Earth?

The old DOS artillery game where two tiny combatants spent an unreasonable amount of time trying to calculate the exact angle needed to ruin somebody else’s afternoon?

The one where terrain got destroyed, shots missed spectacularly, and friendships were tested over bad aim and questionable judgment?

Yes.

That one.

Only this time, somebody looked at PowerShell and thought:

What if we did that again… but inside a terminal window?

What happens when you got a sysadmin that knows PowerShell scripting and classes are done?

Apparently, artillery.

Not real artillery, thankfully. Just the terminal-based variety, the kind that exists somewhere between nostalgia, technical curiosity, and the dangerous freedom that comes from finally finishing coursework and having enough energy left to make irresponsible decisions with administrative privileges.

Some people relax after classes.

Some watch Netflix.

Some rediscover the outdoors.

And then there are those who just effing stare at PowerShell, a tool designed for automation, compliance, and the quiet suffering of enterprise systems, and wonder:

Could this thing launch missiles?

The correct answer was probably “no.”

Naturally, that answer was ignored.

The Misuse of Enterprise Tools

PowerShell was never meant for this.

PowerShell was supposed to reset passwords, restart services, and occasionally help explain why something stopped working at exactly 4:58 PM on a Friday.

It was not supposed to become a game engine.

Yet somehow:

Get-ADUser

Restart-Service

Get-WinEvent

became:

Terminal-based warfare.

Two players.

One battlefield.

Questionable physics.

And enough explosives to turn a mountain into a planning problem.

PowerShell Accidentally Learns Physics

At some point, a strange thing happens.

You stop scripting.

You start negotiating with gravity.

The projectile cannot simply move in a straight line like a well-behaved spreadsheet.

No.

It must arc.

It must suffer.

Like all meaningful things.

$velocityY -= $gravity

One line.

One small subtraction.

And suddenly PowerShell is reenacting Newton.

Then there is this:

$radians = $Angle * [Math]::PI / 180

$velocityX = [Math]::Cos($radians) * ($Power / 1.5)

$velocityY = [Math]::Sin($radians) * ($Power / 1.5)

Which is the technical way of saying:

Aim carefully. Regret arrives quickly.

Geography With a Grievance

Flat terrain would have been merciful.

Mercy, however, was not invited.

The battlefield generates mountains, ridges, cliffs, and geological inconveniences using mathematical waves and random variation.

$wave1 = [Math]::Sin(($x / 7.0) + ($phase1 / 100.0)) * 3.0

$wave2 = [Math]::Sin(($x / 13.0) + ($phase2 / 100.0)) * 2.0

$wave3 = [Math]::Sin(($x / 3.5) + ($phase3 / 100.0)) * 1.0

Translation:

The terrain is actively judging you.

You will blame the hill.

The hill will not care.

Unicode, Civilization, and Other Small Victories

Extended ASCII proved unreliable.

As many things eventually do.

So Unicode stepped in.

Terrain became:

$script:terrainChar = [char]0x2593

Resulting in beautiful terminal geology:

▓▓▓▓▓▓▓▓▓▓▓▓

▓▓▓▓ ▓▓▓

▓▓ A ▓

Which somehow made destruction look respectable.

MIRV, or the Failure of Restraint

One projectile could have been enough.

But restraint is not always a technical person’s strongest attribute.

So there is MIRV.

One missile.

Then five.

Because moderation felt underwhelming.

Then suddenly:

$projectiles = @(

@{ X = $x; Y = $y; VX = $velocityX + (-4 * $direction) },

@{ X = $x; Y = $y; VX = $velocityX + (-2 * $direction) },

@{ X = $x; Y = $y; VX = $velocityX },

@{ X = $x; Y = $y; VX = $velocityX + ( 2 * $direction) },

@{ X = $x; Y = $y; VX = $velocityX + ( 4 * $direction) }

)

Which is less a weapon and more an argument against impulse control.

Destruction as a Learning Experience

Terrain does not merely sit there.

It suffers consequences.

Crashes into reality.

Becomes cratered.

for ($dx = -1; $dx -le 1; $dx++) {

$damageDepth = 3 - [Math]::Abs($dx)

}

Which means cover is temporary.

Like stability in IT.

The Things Technical People Do When Unsupervised

This project started as curiosity.

Then quietly became:

• Physics
• Animation
• Terrain generation
• Collision detection
• Terminal graphics
• Late-night bad decisions

All because somebody looked at PowerShell and thought:

Surely this can become artillery.

And somehow, inconveniently, it worked.

Final Thought

Sometimes learning comes from coursework.

Sometimes from certifications.

And sometimes from doing something mildly ridiculous just to see if it can be done.

Because once you build a game in PowerShell, automation suddenly feels ordinary.