Send us a text

Podcast Show Notes: Deep Dive into Plastic SCM for Game Developers

Episode Title: Plastic SCM: The Ultimate Game Dev Version Control or Just Hype?

Episode Summary:
Version control is a crucial part of game development, and today we’re tackling one of the biggest debates in the industry: Is Plastic SCM the best version control system for game developers, or is it overhyped? We break down its strengths, weaknesses, and how it compares to Git with LFS. Whether you're an indie dev, part of a large studio, or just curious about how games are managed behind the scenes, this episode will give you everything you need to decide if Plastic SCM is right for you.

Key Topics Covered

What is Plastic SCM?

• A version control system designed for game developers.
• Unlike Git, it focuses on managing large game assets efficiently.
• Uses a snapshot-based approach rather than tracking every individual change.

Why Game Devs Are Talking About It

• Indie and AAA devs are weighing in.
• Studios like Unknown Worlds (Subnautica) are using it for massive projects.
• Some swear by it, while others question the cost and reliability.

How Plastic SCM Stands Out from Git

• Handles massive files better (3D models, textures, audio).
• Engine agnostic—works with Unreal, Unity, Godot, etc.
• Gluon Mode: A simplified UI for artists and non-coders.

The Good, the Bad, and the Price Tag

✅ Pros:

• Better for large teams and projects with huge assets.
• Easier merging for non-programmers.
• Faster handling of binary files compared to Git.

❌ Cons:

• Paid plans for cloud-based use; local version is free but limited.
• Reports of crashes and sync issues, especially with Unity.
• Indie devs may find Git LFS more cost-effective.

Real-World Use Cases & Workflows

• Branch Per Task Approach: Keeping changes separate and organized.
• Visual Merge Tool: Compare and merge game assets without dealing with code.
• Exclusive Checkout: Preventing accidental overwrites on shared files.
• Performance Considerations: Speed vs. repository size.

Git with LFS: A Viable Alternative?

• Free and open-source, but has a steeper learning curve.
• Better control over data and workflows.
• More flexible for solo developers or small teams.

Best Practices for Version Control in Game Dev

• Clear branch naming conventions.
• Frequent small commits for easier tracking.
• Using .ignore files to exclude unnecessary assets.
• Balancing repository size with external cloud storage.

Key Takeaways

• Plastic SCM is great for large game studios or teams with heavy asset workflows.
• Git with LFS is a strong alternative for budget-conscious indie devs.
• The right version control system depends on your team size, workflow, and project complexity.

Resources & Links

• Plastic SCM Official Site
• Git LFS Guide
• Unity & Plastic SCM Integration
• Subnautica Devs on Plastic SCM

🎧 Thanks for tuning in! Have thoughts on this episode? Let us know!

Send us a text

Podcast Show Notes: Unreal Engine Deep Dive – Essential Nodes Everyone Needs to Know

Episode Overview

In this episode, we take a deep dive into Unreal Engine, focusing on the essential nodes that every developer needs to understand. Using a tutorial from Unreal University as our guide, we explore the building blocks that make game development with Unreal less intimidating and more exciting.

Key Topics Covered

Introduction to Unreal Engine

• Unreal Engine as a game-changer for popular titles like Fortnite and Hellblade: Senua's Sacrifice.
• Overcoming the overwhelming first impression when starting with Unreal.

The Event Graph: The Heart of Game Logic

• Event Nodes:
  • Event Begin Play: Initializes game settings like player inventory or weather systems.
• Event Actor Begin Overlap: Triggers actions when objects collide or overlap (e.g., opening a treasure chest).
• Event Tick: A constant update loop managing animations, movement, and other dynamic elements.

Variables: The Ingredients of Game Development

• Boolean: True/False switches for conditional logic.
• Integer: Whole numbers for values like health or ammo.
• Vector: Key for 3D positioning, scaling, and movement.
• Examples: Controlling doors with Boolean conditions, spawning enemies with integers, and resizing objects with vectors.

Specialized Nodes for Advanced Control

• Delay and Retriggerable Delay: Adds pauses or resets timers dynamically.
• Flip-Flop: Toggles between two states, such as opening/closing doors or turning lights on/off.
• Sequence: Ensures actions happen in a specific order, like animations or puzzle setups.
• Do Once: Executes unique, one-time actions, such as cut scenes or giving special items.

Interactivity Through Collision and Overlap

• Event Begin Overlap, Event End Overlap, and On Component Hit: Creates dynamic interactions like triggering traps or changing music zones.

Repetition and Timing

• For Loop: Automates repetitive tasks like spawning objects or designing grids.
• Timeline: Smooth animations and transitions for objects, cameras, and mechanics like health regeneration.
• Set Timer by Event: Schedules recurring events at specific intervals for rhythmic gameplay or countdowns.

Custom Events and Object Behavior

• Custom Events: Tailor-made triggers for specific game mechanics (e.g., "enemy defeated" or "key collected").
• Find Look at Rotation: Enables objects to face others dynamically, perfect for tracking players or creating lifelike behaviors.

Key Takeaways

• Modularity: Each node serves a specific purpose, but their true power lies in combining them creatively—like building with Legos.
• Flow Control: Directing game logic through nodes like branches, sequences, and loops ensures smooth execution and player immersion.
• Experimentation: The best way to learn Unreal Engine is by experimenting, making mistakes, and iterating.

Final Thought

Unreal Engine may seem daunting at first, but with these essential nodes and a modular approach, the possibilities are endless. What game mechanic would you create with the tools we've discussed? Let your imagination run wild—happy game developing!

Send us a text

Show Notes: Exploring Unreal Engine's Blueprints

Episode Title: Unreal Engine Blueprints: A Beginner to Pro Deep Dive

Episode Highlights:

1. Introduction to Blueprints
   • Visual scripting system in Unreal Engine—perfect for both beginners and pros.
   • Think of Blueprints as building game logic with "digital Legos."
   • No prior coding knowledge required!
2. Blueprint Basics
   • Types of Blueprints:
     • Level Blueprints: Control events within a specific game level (e.g., traps, interactive elements).
     • Blueprint Classes: Reusable templates for objects (e.g., health potions, characters).
   • Event Graphs and Nodes: A flowchart-style system for game logic.
3. Customizable Prefabs and Construction Scripts
   • Create diverse environments (e.g., forests with varied trees) using construction scripts.
   • Add randomness for realism (e.g., treasure chest contents, enemy spawn points).
4. Playable Characters
   • Design character states (e.g., walking, sneaking, fighting).
   • Use variables to track attributes like health, speed, or abilities.
   • Create dynamic animations and smooth transitions between actions.
5. Blueprint Communication
   • Events: Broadcast signals between blueprints (e.g., key used to open a door).
   • Interfaces: Define consistent interactions across objects (e.g., interactable items).
   • Direct References: Enable close collaboration between blueprints (e.g., player controlling a pet companion).
6. Advanced Blueprint Features
   • Blend animations for realism.
   • Use Blueprints for AI behaviors, HUD creation, and game mechanics.
7. Why Blueprints Matter
   • Lowers barriers to entry for game development.
   • Empowers creators to experiment and innovate without coding experience.
8. Final Takeaway
   • Blueprints democratize game development, offering powerful tools for anyone with a game idea.

Additional Resources:

• Unreal Engine Documentation on Blueprints.
• Community tutorials and forums.
• Suggested reading: Blueprint Visual Scripting for Unreal Engine.

Disclaimer:
This podcast episode was AI-generated for educational and entertainment purposes. It is not affiliated with Epic Games or Unreal Engine.

Call-to-Action:

• Join the conversation! Share your Blueprints projects or questions here on Buzzsprout.
• Subscribe for more deep dives into game development tools and techniques.