⚙️ Core Mechanic Demo

Week 12: Polish & Design Feedback

Game Programming - CSCI 3213

Spring 2026 - Week 12

Oklahoma City University

📚 Today's Objectives

Demonstrate your polished core mechanic
Analyze game feel and juice
Receive design-focused feedback
Discuss design patterns implementation
Evaluate progression and difficulty curve
Plan for Vertical Slice (Week 13)

Core Mechanic Demo: Your primary game mechanic should feel good and be fun to use repeatedly

🎯 Core Mechanic Demo - What's Different?

First Playable (Week 11):

Basic functionality working
Can play the game start to finish
Rough edges and bugs acceptable
Focus on "does it work?"

Core Mechanic Demo (Week 12):

✅ Primary mechanic feels good to use
✅ Added feedback and juice (particles, sounds, screen shake)
✅ Responsive and satisfying input
✅ Critical bugs fixed
✅ Clear communication of game state
✅ Focus on "is it fun?"

Key Shift: From functional to enjoyable

🎮 Understanding Game Feel

Game Feel = Juice + Responsiveness

                    Responsiveness:
                    Input lag minimized (immediate feedback)
Controls feel tight and precise
Player actions have weight and momentum
Animations match player intent

                

                    Juice (Visual & Audio Feedback):
                    Particles: Dust when landing, sparks when hitting
Screen Shake: Camera shake on impact
Sound Effects: Audio cues for every action
Animation: Squash/stretch, anticipation
Hitstop: Brief pause on impact for emphasis
Color Flashes: Visual feedback on damage/success

                

Read: "The Art of Screenshake" by Jan Willem Nijman

✨ Adding Juice - Examples

Before vs After:

Action	Without Juice	With Juice
Player Jump	Position changes instantly	Squash on landing, dust particles, "whoosh" sound
Enemy Hit	Health decrements	Flash white, knockback, impact sound, screen shake, damage number
Coin Collect	Coin disappears	Sparkle effect, "ding" sound, UI counter animates up, coin flies to HUD
Button Click	Action executes	Button depresses, click sound, brief hover effect

Compound Effects: Layering multiple small effects creates impactful feedback

🎬 Demo Presentation Format

5-Minute Presentation Structure:

Core Mechanic Overview (1 min):
- What is your primary mechanic?
- Why is it fun/interesting?
Live Demo (2 min):
- Show the mechanic in action
- Highlight improvements since Week 11
- Point out juice/feel enhancements
Design Patterns (1 min):
- Which patterns have you implemented?
- Where and why did you use them?
Q&A (1 min):
- Open floor for design feedback
- Specific questions you have for the class

🔍 Design Feedback Focus

Today's Feedback Should Address:

Fun Factor:
- Is the mechanic enjoyable to repeat?
- Does it create interesting decisions?
Game Feel:
- Does it feel responsive and satisfying?
- Is there enough feedback?
Clarity:
- Is it clear how the mechanic works?
- Can players intuit the controls?
Depth:
- Does it have mastery potential?
- Can skilled players do cool things?
Balance:
- Is it too easy or too hard?
- Are there exploits or cheese strategies?

🏗️ Design Patterns Check-In

Pattern Requirements:

Your project must implement at least 3 design patterns from the course.

Common Patterns at This Stage:

Pattern	Typical Use Case
Singleton	GameManager, AudioManager
Object Pool	Bullets, enemies, particles
Observer	Health changes, score updates, events
State	Player states (idle, jump, attack)
Command	Input handling, undo/redo
Strategy	AI behaviors, difficulty levels

Be Prepared: Explain where and why you chose each pattern

💻 Code Quality Mini-Lecture

As Your Project Grows, Focus On:

Organization:
- Group scripts into folders (Player/, Enemies/, Managers/, etc.)
- Use namespaces to avoid conflicts
Readability:
- Clear variable names (avoid single letters)
- Comment complex logic
- Break long methods into smaller ones
SOLID Principles:
- S: Single Responsibility (one class, one job)
- O: Open/Closed (extend via inheritance, not modification)
- L: Liskov Substitution (subclasses should work where base class works)
- I: Interface Segregation (small, focused interfaces)
- D: Dependency Inversion (depend on abstractions, not concretions)

Refactor Now: Easier to clean up code now than during final week

🎤 Demo Session - Round 1

First Half of Class:

Students 1-[N/2] present their Core Mechanic Demos

Feedback Format:

Developer presents (5 min)
Class provides feedback using framework:

✅ What feels good
⚠️ What could be improved
💡 Ideas to consider

Take Notes: Feedback from today will guide your Vertical Slice work

🎤 Demo Session - Round 2

Second Half of Class:

Students [N/2+1]-N present their Core Mechanic Demos

Questions to Answer in Feedback:

Does the mechanic feel satisfying to use?
Is there enough visual/audio feedback?
Would you want to play more?
What's the most fun part?
What pattern implementation was most clever/effective?

⚠️ Common Core Mechanic Issues

Issue: Mechanic Feels Unresponsive

Solution: Reduce input lag, speed up animations, add anticipation frames

Issue: Mechanic is Repetitive/Boring

Solution: Add variation, risk/reward, skill ceiling, or combos

Issue: Too Much or Too Little Feedback

Solution: Balance juice - test with players to find sweet spot

Issue: Unclear How Mechanic Works

Solution: Tutorial, on-screen hints, clearer visual language

Issue: Mechanic Works But Isn't Fun

Solution: Hardest problem - may need to pivot or iterate on core design

📈 Difficulty Curve Discussion

Planning Your Progression:

                    Good Difficulty Curve:
                    Start easy - teach the mechanic
Gradually increase challenge
Introduce new elements over time
Spike difficulty, then give breather
End with satisfying challenge

                

                    Common Mistakes:
                    ❌ Starting too hard (players quit immediately)
❌ No progression (gets boring)
❌ Spikes too steep (frustration)
❌ Randomness instead of designed challenge

                

Playtest: Difficulty that feels easy to you is often hard for new players

🎯 Next Week: Vertical Slice

What is a Vertical Slice?

A complete, polished experience of one part of your game that represents the final quality.

Vertical Slice = Core Mechanic Demo + Context:

One full level or game loop
Polish equal to final game quality
Start to finish experience (intro → gameplay → end)
Representative of final art/audio direction
All systems working together

What to Add This Week:

Context: menus, intro, win/lose states
One complete level/scenario
Placeholder → Final art (at least for this slice)
Sound effects and music
UI polish

📝 Homework for Week 13

Build Your Vertical Slice:

Complete One Level/Loop:
- Full experience from start to finish
- Should take 3-5 minutes to play through
Add Context Systems:
- Main menu or intro screen
- Win/lose conditions and screens
- Basic UI (health, score, etc.)
Visual & Audio Polish:
- Replace key placeholders with final art
- Add sound effects for main actions
- Background music
Bug Fixes:
- No game-breaking bugs in the slice
- Smooth, playable experience

Quality > Quantity: Better to have 1 perfect level than 5 rough ones

📚 Resources for Game Feel

Unity Tools for Juice:

Cinemachine: Camera shake and effects
Particle System: Built-in visual effects
DOTween: Animation and tweening library
Audio Mixer: Sound effect management

Free Sound Resources:

Freesound.org - Sound effects
Incompetech - Royalty-free music
BFXR - Generate game sound effects

📝 Summary

Today's Accomplishments:

✅ Demonstrated polished core mechanics
✅ Analyzed game feel and juice
✅ Discussed design pattern implementations
✅ Received targeted design feedback
✅ Planned for Vertical Slice milestone

Key Takeaways:

Game feel = Responsiveness + Juice
Small details create big impact
Patterns help organize growing codebases
Vertical Slice = Quality sample of final game

Next week: Show us your best work! 🎮✨