Summary of "Learn Problem Solving (FREE Course, MOST VALUABLE skill)"

High-level summary

This is a practical, hands-on mini-course by Code Monkey focused on learning problem solving — the core skill behind building games, programs and systems. The course emphasizes how to think, debug and design systems rather than providing step‑by‑step tutorials for a single game. Active practice is required: pause the videos, open the companion Unity project, code, solve the included problems, and repeat to build skill. A free video version is substantial; a paid “premium” version expands exercises and adds live support and community bonuses.

Key lessons / concepts

• Problem solving is the fundamental, high-value skill employers look for; it’s learned by doing many problems, not passively watching tutorials.
• Tutorials usually show a polished final implementation — this course exposes the unseen steps: research, design alternatives, debugging, refactors and failed iterations.
• Start small: implement the simplest working version of a system, then expand or refactor as new requirements appear.
• Problem solving improves incrementally: the same bug or design problem that takes days at first can take minutes after repeated practice.
• The instructor provides two reusable frameworks (one for design, one for technical bugs) that can be applied to virtually any problem.

Active practice is essential: pause the video, try the exercise, debug, fail, and iterate.

Methodologies / frameworks

1) Design problem‑solving framework — 4 steps

Used to design systems (e.g., health, movement, quest systems).

1. Identify the problem
   • Clarify what you want the system to do at a high level (e.g., “health system” = represent and change hit points).
2. Break it into core components
   • Decompose until you reach the smallest independent pieces (e.g., store current HP, damage, heal, min/max, death).
   • Don’t add non-core features; if a feature can be expressed by composing core components, leave it out for now.
3. High‑level implementation (pseudo‑code / blueprint)
   • Decide which data and behaviors map to variables, functions, events, etc. (e.g., healthAmount, Damage(amount), Heal(amount), clamp between 0 and max).
   • Keep this language‑agnostic / pseudo‑code level.
4. Implement details
   • Write real code (types, access modifiers, API exposure, events). Start private, expose only what other systems need; serialize fields for the Unity editor; add events to communicate changes (e.g., OnHealthChanged).
   • Test, then refactor (add getters, normalized health for UI, events, etc.) as new requirements appear.

2) Technical (bug) problem‑solving framework — 3 steps

Applied to runtime bugs and behavior problems.

1. Identify the problem
   • Reproduce and describe the incorrect behavior (what you expect vs what happens).
2. Locate the problem
   • Inspect the code path using:
     • Debug.Log (console logging) — preferred by the instructor; confirm code reaches points and inspect values.
     • Debugger / breakpoints (Visual Studio + Unity) — pause, inspect variables, step through functions.
   • Narrow down to the line or subsystem where behavior diverges (null refs, wrong math, wrong condition, wrong component, wrong physics type).
3. Fix the problem
   • Apply the appropriate correction (change math sign, clamp values, cast ints to floats, attach missing component, use correct 2D vs 3D class, unsubscribe listeners, fix timer logic, etc.).
   • Re-test and consider whether a refactor or better design is needed.

Practical debugging checklist / common pitfalls

• Use Debug.Log to confirm:
  • code paths execute, functions are called, values before and after modification.
• Use the debugger when you prefer step‑through inspection.
• Common errors and fixes:
  • Wrong operator: health += damage → should be health -= damage.
  • Event not fired: add event invocation (e.g., OnHealthChanged?.Invoke(...)).
  • Component not attached / null reference: drag the reference in the inspector or check GetComponent results.
  • Integer division when you need float: cast to float for normalized values (e.g., float norm = (float)health / maxHealth).
  • 2D vs 3D mismatch: use Rigidbody2D/Collider2D vs Rigidbody/Collider.
  • Kinematic vs Dynamic Rigidbody: kinematic objects moved by code won’t be pushed by physics — change to Dynamic if physics needs to push the object.
  • If/else used incorrectly for independent axes: use separate if statements to allow diagonal movement.
  • Clamping values: use Mathf.Clamp(value, min, max) to avoid underflow/overflow.
  • Events and subscriptions: store and unsubscribe event handlers correctly (avoid anonymous-lambda pitfalls) to prevent memory leaks or duplicate callbacks.
  • Update ordering bug: update lastPosition after computing delta; ensure per-frame values are reset properly.

Course structure and companion project — how to use

Companion project:

• Download the ZIP from the course page, extract, add the folder in Unity Hub, and open with the specified Unity version.
• Use the Code Monkey menu in the editor to open:
  • Main window (lecture list and scenario overview)
  • Exercise window (per‑scenario exercises: Start Exercise / Show Hint / Show Solution / Complete Exercise)
  • Live chat window (direct messages to instructor when online)

Workflow for an exercise (recommended):

1. In the video, pause when prompted and click Start Exercise in the companion project (unpacks files & loads the scene).
2. Run the scene to reproduce the problem.
3. Use logs or the debugger to locate the fault and attempt a fix.
4. Use “Hint” if stuck; use “Show Solution” only if you cannot progress.
5. When finished, click “Complete Exercise” — note: completing removes exercise files from the project, so back up your code if you want to keep your version.

Lecture types:

• Design problem lectures (first two per scenario): break down and design systems from idea to implementation.
• Technical problem lectures: bite‑sized bugs (over 200 exercises across scenarios) with walkthrough solutions.
• High‑level overviews: design breakdowns of larger services (Twitter, Steam, Discord, etc.) to practice system decomposition.

Study flow:

• Watch the first two core lectures, then start the simplest scenario (health system).
• The course is non-linear: you can proceed start→finish or jump between scenarios. Instructor recommends beginning with early basics and then working through scenarios and their exercises.
• Pause the videos and code actively; practice is essential.

Course content (scenarios covered)

Short descriptions of covered scenarios:

• Health system: HP storage, damage/heal functions, min/max, UI update via events.
• Movement system: WASD movement, physics collisions, pushing objects, diagonal movement.
• Inventory system: pick up / drop items, item storage.
• Crafting: combine input items into output items (recipes).
• Enemy AI (NEI): simple finite state machine — look for target, chase, attack (shoot).
• Key & door: keys with colors that open matching doors (consume key).
• Gathering system: resource nodes, gather/stop, item spawn.
• Save system: save/load game state (items, positions, values).
• Interaction system: context interactions (NPC talk, pickup weapon).
• Quest system: scriptable object quests, quest list, modular quest logic (e.g., get X apples, walk Y meters).
• Equipment system: multiple equipment types (bow, pickaxe), different behaviors per equipment.
• Building system: blueprints, deposit resources, construction progress, buildings with logic.
• Needs system: hunger/thirst decrease and cause damage; consume items to restore.
• Farming system: planting seeds, watering, growth stages, harvest.

Note: the premium course contains extended exercises — 200+ technical problems and 15 scenarios.

Practical examples highlighted

• Health system: design → pseudo‑code → C# implementation → attach to enemy → bullets damage → health bar UI uses OnHealthChanged event and normalized health; includes refactor and event flow.
• Debugging examples: bullets healing instead of damaging (fix +/-), health bar not updating (invoke event), health values going past bounds (Mathf.Clamp), integer division vs float for normalized values.
• Movement examples: wrong input mapping, missing script, inverted axes fixed by correcting signs, no diagonals fixed by removing else branches, collider/rigidbody type mismatches fixed (2D vs 3D and Kinematic → Dynamic).
• Enemy AI examples: wrong distance comparison (greater vs less), aim vector calculation (targetPosition - currentPosition), attack timer sign bug.

Instructor’s recommended tools / preferences

• Debugging preference: instructor relies heavily on Debug.Log (20 years experience). The debugger is also valid — choose your personal preference.
• Unity & Visual Studio integration for breakpoints is demonstrated as an alternative workflow.

Premium course & community features

Premium includes:

• 200+ practical technical problems across many scenarios.
• 15 scenarios each with many exercises.
• Live chat window, private Discord, weekly private live streams.
• Priority Q&A with a 24-hour response target.

Free version on YouTube is substantial, but premium provides the full set and live support.

Course philosophy & final reminders

• Problem solving cannot be learned passively; you must attempt exercises, get stuck, debug, fail, and iterate.
• Beginners should start with basic Unity and C# courses first (examples: Kitchen Chaos, 2D beginner course, C# course).
• Treat refactoring as a normal part of development: implement the simplest version, then expand when needed.

Speakers / sources featured

• Code Monkey — course instructor and speaker; author of the videos and companion project.

Category

Educational

---

Share this summary

Share on X/Twitter Share on Facebook Share on LinkedIn Share on Reddit Share on WhatsApp Share on Telegram

---

Is the summary off?

If you think the summary is inaccurate, you can reprocess it with the latest model.

Reprocess summary

Video