Teaching Ballistics Through Play: How I Implemented Real Physics in My High School Classroom

By Guillermo Ithier • Physics Teacher & Game Designer
PROJECTILE WAR (v2.0 Final) • Ridgefield Park Junior/Senior High School • 11th Grade Physics

Most “physics games” fail in one of two directions.

They either paint numbers on top of gameplay—physics as flavor text, where nothing behaves the way the real world does—or they turn into a calculator disguised as a board game: accurate, but slow, fragile, and not fun.

When I built PROJECTILE WAR, I wanted a third path: authentic physics that creates predictable, competitive potency. Not a lesson stapled onto a game—but a game whose tactics are stronger because the physics underneath is real.

This post is how I implemented that in my 11th grade physics classroom and turned real ballistics into a playable combat model using a GURPS-inspired √(Energy) conversion pipeline.

Why I Built This

PROJECTILE WAR is a fast, head-to-head artillery duel designed for 10–12 minute matches. Players command three cannons protected by two shields, and every decision is a trade:

• Fire to gain tempo and break defenses…
  but generate Stress (σ) that can destroy your cannon.
• Maintenance to stabilize cannons or support shields…
  but give up tempo and momentum.

The core experience is simple: push your system, or preserve it—and win by knowing when to do each.

But for the game to feel honest, the offense needed to behave like real projectiles. That meant solving the hardest tabletop problem:

How do you translate mass, caliber, and velocity into damage that feels believable—and still plays fast?

Design Goal: Real Physics, Tabletop Speed

I set a clear target for the physics layer:

• Authentic: heavier, faster, denser projectiles hit harder in a way players can feel.
• Readable: players can estimate outcomes without pausing the game.
• Balanced: damage values land in a playable range (no runaway scaling).
• Teachable: the system reinforces physics concepts naturally—without feeling like homework.

The win condition was never “students can compute.”
The win condition was: students make better decisions because the physics makes sense.

The Breakthrough: Borrowing the Right Kind of Realism

I pulled from a modeling philosophy I trust: GURPS.

GURPS has a way of translating real-world energy into game damage that remains playable: damage scales roughly with √(Energy) instead of linearly. That’s crucial because energy rises extremely fast with velocity, and a game that follows raw physics too directly becomes unplayable.

So I implemented a tabletop-friendly ballistic conversion pipeline built around four anchors:

1) Bore / Caliber is not a label

In my classroom, I hammered this early:

Bore = internal barrel diameter (in inches).
Caliber isn’t a vibe. It’s a measurable quantity, and it belongs in the math.

This alone cleaned up a lot of student misconceptions. It also gave the game a grounded starting point: every “shell” begins with a real physical diameter.

2) Sectional Density (SD) is the “why it hits” number

To keep damage from being arbitrary, I used Sectional Density as the physical proxy for impact/penetration potential:

SD captures a real-world truth: a projectile’s weight relative to its diameter matters.

And because real projectile data shows up in different unit systems, I supported SD computation using either:

• weight in pounds (lb) or
• weight in grains (gr)

That flexibility mattered in practice—both in design and in student reasoning.

3) Velocity is the amplifier

Students don’t need to memorize kinetic energy to learn this truth:

speed dominates outcomes.

Velocity became the lever that makes some shots feel terrifying, but the √(Energy) step keeps it from exploding the game.

4) √(Energy) gives “predictable potency”

This is the key phrase I use for the system:

predictable authentic potency means the output feels powerful and stable.

The square-root relationship makes damage scale realistically while staying inside a range you can actually balance.

The Method: A Ballistic Pipeline That Works in a Classroom

Here’s the procedure I used to turn real projectile specs into game-ready damage bands:

1. Identity: Get C (true bore in inches).
2. Density: Compute SD from projectile weight and caliber.
3. Lookup: Find P, a constant based on caliber (C) from a table.
4. Convert: Use V (ft/s), SD, C, and P to compute D_raw.
5. Round + Scale:
• round fractional dice sensibly
• apply a >12d scaling rule to keep results playable

This created a physics layer that was:

• accurate enough to feel real,
• consistent enough for tuning,
• fast enough for an 85-minute block schedule.

And here’s the crucial implementation detail:

Students did not need to run the full conversion mid-game.
I used the pipeline primarily for design tuning and reference truth, then printed the outcomes on cards in an accessible way.

That’s how you get authentic physics without turning gameplay into a worksheet.

How This Plugged Into PROJECTILE WAR

PROJECTILE WAR already had a clean, classroom-friendly structure:

• One action per turn (Fire / Maintenance / Utility)
• Immediate resolution (roll only when firing)
• Hand refills to 5 (pressure stays high, downtime stays low)

It also already featured a physics-forward legality check:

M × A ≥ F

That check trains the habit of constraint verification. The GURPS-style pipeline then ensured that once a shot was legal, the damage behavior was physically honest too.

“Shell Specs” → Deck Tuning

I treated each offensive card like a shell specification:

• Projectile weight → SD
• Bore/caliber → SD + P lookup
• Muzzle velocity → energy driver
• √(Energy) → damage dice band

Then I tuned the deck so those physically grounded outcomes matched the game’s pacing needs:

• shield HP pacing
• stress escalation (σ) and risk windows
• preventing a single “best projectile” from dominating the meta

The result: the numbers didn’t just look scientific—they behaved scientifically in aggregate.

The “Real Enough” Proof: SD Examples Students Could Feel

I used worked examples both as sanity checks and as classroom anchors—numbers that build intuition even before full conversion:

Example	Weight	Caliber	SD
1	6.1 lb	3.67″	0.453
2	660 gr	0.51″	0.362
3	10 lb	2.00″	2.500
4	500 gr	0.308″	0.753
5	1 lb	1.00″	1.000

And quick practice prompts reinforced the point fast:

• 300 gr, 0.30 in → SD ≈ 0.476
• 8 lb, 4.0 in → SD = 0.5
• 900 gr, 0.45 in → SD ≈ 0.635

Even without full conversions, students could reliably predict which shots should hit harder. That’s the goal: physics intuition becomes tactical instinct.

Classroom Implementation: Making It Play Like a Real Game

Because I’m a teacher, I didn’t treat this as “let’s try a fun thing.” I treated it like a design validation exercise inside real constraints.

What I wanted students to feel

Not: “I’m doing math.”
But: “I’m making a better play.”

If the physics is authentic and readable, students naturally build heuristics:

• “dense + fast is scary”
• “big bore isn’t automatically best”
• “rotation matters because systems degrade”

That’s exactly what happened.

What Changed After Testing (Human Factors > Physics)

In real play, the physics held up. The friction points were usability:

1) Decision timing must be forced

Students would play Maintenance and delay choosing its mode.

Fix: Maintenance now requires choosing Shield Support or Cannon Support at the moment it’s played.

2) Fast games need checklists

In high-tempo turns, students occasionally missed σ/Φ updates.

Fix: I added an end-of-turn checklist to the reference sheet:
Update σ/Φ → Apply damage/HP → Discard → Draw to 5

These weren’t physics problems. They were interface problems. Fixing them made the physics layer usable at speed.

Outcomes: The Rare Combination I Was Hunting

This implementation produced something I don’t see often:

• A competitive duel that reliably plays in 10–12 minutes
• Authentic projectile logic grounded in caliber, SD, velocity, and √(Energy) scaling
• A classroom-tested system that survives real players, real time pressure, and mixed math fluency—inside one 85-minute block

And that matters, because a design isn’t “smart” if it only works with ideal players.
It’s smart if it works on Tuesday, third period, when the room is loud and the clock is real.

Portfolio Takeaway

PROJECTILE WAR shows my approach as both a teacher and a designer:

• I can translate real-world models into playable systems.
• I can preserve pace and fun under classroom constraints.
• I iterate based on observed friction, not assumptions.

This isn’t a physics-themed game.
It’s a game where physics is the invisible engine that makes the tactics honest—and makes students want a rematch.

— Guillermo Ithier