Callbacks and function references in Godot 3 using FuncRefs The Shaggy Dev 2021-11-29 | While functions are not first-class objects in Godot, FuncRefs can help replace some of that missing functionality. Using the built-in funcref() function, we can create objects that maintain a reference to and can call a selected function anywhere in our code.Intro and first-class functions: 00:00Funcref overview: 01:31Sample project: 02:10Source code: github.com/theshaggydev/the-shaggy-dev-projects/tree/main/projects/godot-3/funcrefText post: shaggydev.com/2021/11/28/funcrefGodot documentation: docs.godotengine.org/en/stable/classes/class_funcref.html
Fixing menu transparency issues in Godot 4 The Shaggy Dev 2024-10-15 | Transparent menus on things like OptionButtons are not exactly as straightforward as you would expect, so here's a look at how I fixed it for Unto Deepest Depths.Text version and code snippets: shaggydev.com/2024/10/14/godot-transparent-popupsWishlist Unto Deepest Depths: store.steampowered.com/app/3106600/Unto_Deepest_Depths?utm_source=yt
How unit selection works in my tactical strategy game The Shaggy Dev 2024-09-25 | Here's a brief look at how I handle map-based unit selection in Unto Deepest Depths.Wishlist Unto Deepest Depths at: store.steampowered.com/app/3106600/Unto_Deepest_Depths?utm_source=ytRead this video at shaggydev.com/2024/09/25/udd-unit-selection
Programming a tactical strategy game in Godot 4 The Shaggy Dev 2024-09-05 | Let's look at how my latest strategy game, Unto Deepest Depths, is designed. I'll break down the application architecture, how I manage turn order, and show the core code snippets behind the main game loop.Text version: shaggydev.com/2024/09/04/unto-deepest-depths-devlogWishlist the game here: store.steampowered.com/app/3106600/Unto_Deepest_Depths?utm_source=ytWhat I'm making: 00:00Game architecture: 02:26Code breakdown: 07:00
Unto Deepest Depths - Announcement Trailer The Shaggy Dev 2024-09-03 | Unto Deepest Depths is a dark fantasy strategy game where you must build a party and lead them into the unknown to vanquish the horrors below. Battle through turn-based combat, upgrade your units, and plan your moves carefully in this punishing roguelite where any move could be your last.Wishlist here: store.steampowered.com/app/3106600/Unto_Deepest_DepthsNew devlog series starts soon!
10 small ways to make your life easier in GDScript The Shaggy Dev 2024-06-20 | Here's a collection of miscellaneous tips when working with GDScript to make your life easier. Improve working with the terminal, organizing your code, and learn a few shortcuts you might find handy.Text version and code snippets: shaggydev.com/2024/06/19/small-gdscript-tips
Game development in the dying days of Flash The Shaggy Dev 2024-05-16 | It's been ten years since my first "commercial" game project, so let's take a look back at what game development was like in 2014. Flash was on the way out, HTML5 was up and coming, and Steam hadn't yet opened the floodgates. The business model of web games was quite different back then, so let's dive in!Text version: shaggydev.com/2024/05/15/flash-developmentBig thanks to Internet Archive for providing many long lost references!- More reading and sources -The United States of Mobile Gaming: statista.com/chart/995/gamers-in-the-the-united-statesThe 5 Most Important Things to Consider When Getting Your Flash Game Sponsored: gamedevelopment.tutsplus.com/the-5-most-important-things-to-consider-when-getting-your-flash-game-sponsored--gamedev-8559aSteamBirds: By the Numbers: web.archive.org/web/20120221143256/http://www.andymoore.ca/2010/03/steambirds-by-the-numbersWhere's the Cash for Flash: web.archive.org/web/20150425232801/http://www.gamasutra.com/view/feature/3924/wheres_the_cash_for_flash.php?page=1Thoughts on Flash: web.archive.org/web/20170615060422/apple.com/hotnews/thoughts-on-flashFlashpoint Archive: flashpointarchive.orgRuffle Emulator: https://ruffle.rs/
Come join the Discord! The Shaggy Dev 2024-04-29 | Come hang out, get tech support, or tell me why I'm wrong.discord.gg/udafrsSzcy
Making a golfing roguelike in one week The Shaggy Dev 2024-04-02 | Here's a look at my entry for The 7DRL Challenge, a mashup of golf game and roguelike, I'll talk about how the levels are generated and some challenges I ran into along the way.Text version: shaggydev.com/2024/04/02/7drl-2024-devlogThe game: theshaggydev.itch.io/par-for-the-corpseAStarGrid2D: youtu.be/QRr_P_uqz8w00:00 What I made01:00 How the levels are made04:55 How the ball works
Making a dev console in Godot The Shaggy Dev 2024-01-10 | Here's a look at how I implemented a simple dev console in my game to speed up development. The core functionality is driven by Godot's Expression class, but I've also added a history and autocomplete system to let me work even more effectively.Text version and code snippets: shaggydev.com/2024/01/09/dev-consoleThe Expression class: docs.godotengine.org/en/stable/classes/class_expression.htmlMore on Expressions: docs.godotengine.org/en/stable/tutorials/scripting/evaluating_expressions.html
Advanced state machine techniques in Godot 4 The Shaggy Dev 2023-11-28 | Here's a look at some more advanced techniques you can implement in your state machine when you need something a bit more complex than the starter state machine I showed in the last video. We'll look at three techniques worth understanding for building out the state machine you need and address a few common pain points people run into when programming a state machine.Text version with code snippets: shaggydev.com/2023/11/28/godot-4-advanced-state-machinesSample project: github.com/theshaggydev/the-shaggy-dev-projects/tree/main/projects/godot-4/advanced-state-machines00:00 Dependency injection02:50 Composition07:15 Hierarchical state machines09:25 How to do multiple things at once10:30 Sharing data between states
Starter state machines in Godot 4 The Shaggy Dev 2023-10-10 | Here's an updated look at how I like to do state machines in Godot 4. I'm going to go over some simpler, starter techniques today, and in the next video I'll go in-depth about techniques you can use when today's examples don't cut it.Text version: shaggydev.com/2023/10/08/godot-4-state-machinesSample project: github.com/theshaggydev/the-shaggy-dev-projects/tree/main/projects/godot-4/state-machinesSimple state management: 00:00Node-based states: 02:22A few examples: 08:00Theory video: youtu.be/-ZP2Xm-mY4E
Making tactical units - A devlog The Shaggy Dev 2023-09-05 | Let's talk about how the data behind units is structured, how artwork is implemented, and how I'm handling unit AI in my tactics game.00:00 - What I'm making01:40 - Unit data04:35 - Artwork08:33 - Unit AIText version: shaggydev.com/2023/09/04/tactics-devlog-iiThe previous devlog: youtu.be/8fLbf7n9I9IAn introduction to Utility AI: youtu.be/78AcS_0lQSMGDC talks of interest:gdcvault.com/play/1012410/Improving-AI-Decision-Modeling-Throughgdcvault.com/play/1021848/Building-a-Better-Centaur-AI
Developing a tactics engine in Godot The Shaggy Dev 2023-07-05 | In this devlog of sorts, we'll look at how I'm structuring the game engine for my future tactics game using Godot. Topics include level structure, unit structure, and action management.Text version: shaggydev.com/2023/07/04/tactics-engine-devlogElemechs video: youtube.com/watch?v=GYFnyiwa9iwWhat I'm making: 00:00Level structure: 01:28Unit structure: 06:00Godot 3 vs 4: 08:22Actions: 10:33
Making an atmospheric incremental game in Godot in 9 days The Shaggy Dev 2023-06-06 | For the 57th Godot Wild Jam, I made Flame Forged, an incremental game with a heavy emphasis on lore and atmosphere. Here's a quick mini-devlog containing a few interesting things from my time developing the game.Text post: shaggydev.com/2023/06/05/godot-wild-jam-57Flame Forged: theshaggydev.itch.io/flame-forged
Creating volume sliders in Godot 4 The Shaggy Dev 2023-05-23 | Here's the right way to let the user adjust the volume of different types of audio in your game.Sample project: github.com/theshaggydev/the-shaggy-dev-projects/tree/main/projects/godot-4/volume-slidersText version: shaggydev.com/2023/05/22/volume-slidersFurther reading- docs.godotengine.org/en/stable/tutorials/audio/audio_buses.html- docs.godotengine.org/en/stable/classes/class_%40globalscope.html#class-globalscope-method-linear-to-db
An introduction to Utility AI The Shaggy Dev 2023-04-20 | Utility AI is a common technique for creating effective AI across a variety of game genres. By turning data about the current game state into numbers, we can allow our AI to make informed decisions about what it should do next.Decisions are hard: 00:00Utility AI: 01:13Scoring actions: 03:04Refining the process: 06:03Text post: shaggydev.com/2023/04/19/utility-aiFurther readingAn Introduction to Utility Theory - Game AI Pro - http://www.gameaipro.com/GameAIPro/GameAIPro_Chapter09_An_Introduction_to_Utility_Theory.pdfImproving AI Decision Modeling Through Utility Theory - gdcvault.com/play/1012410/Improving-AI-Decision-Modeling-ThroughBuilding a Better Centaur: AI at Massive Scale - gdcvault.com/play/1021848/Building-a-Better-Centaur-AI
5 more changes to GDScript 2 in Godot 4 youll want to know about The Shaggy Dev 2023-03-08 | From signal and tween updates, to debugging help, here's another grab bag overview of some changes to GDScript in Godot 4 that you may want to know about.Text version and code snippets: shaggydev.com/2023/03/07/gdscript1-to-gdscript2-part2Part 1: youtube.com/watch?v=8BgAeN4RRR4Signals: docs.godotengine.org/en/latest/classes/class_signal.htmlY-sorting: docs.godotengine.org/en/latest/classes/class_canvasitem.html#class-canvasitem-property-y-sort-enabledDocumentation comments: docs.godotengine.org/en/latest/tutorials/scripting/gdscript/gdscript_documentation_comments.htmlTween: docs.godotengine.org/en/latest/classes/class_tween.htmlSceneTreeTween: docs.godotengine.org/en/3.5/classes/class_scenetreetween.htmlPerformance monitors: docs.godotengine.org/en/stable/tutorials/scripting/debug/custom_performance_monitors.htmlMigrating from Godot 3: docs.godotengine.org/en/stable/tutorials/migrating/upgrading_to_godot_4.html
Godot 4 lambda functions The Shaggy Dev 2023-02-03 | Lambda functions are small, anonymous functions that can be declared inline rather than via full function declaration. Let's take a quick look at how to write them in Godot 4.Text version and code snippets: shaggydev.com/2023/02/02/godot-4-lambda-functionsGodot docs: docs.godotengine.org/en/latest/tutorials/scripting/gdscript/gdscript_basics.html#lambda-functionsCorrections:01:09 This only applies to local variables where the lambda is declared, such as the variable and lambda inside of _ready() in this example. Changes to variables declared at a higher scope are not subject to this, such as moving the variable declaration outside of the _ready() function.
A few common code smells to be aware of and how to fix them The Shaggy Dev 2023-01-17 | Code smells are things in a codebase that readily stick out and imply something may be off with how it has been designed. Here's a few common ones you may find in your own codebase, why they can be concerning, and how to fix them.Text version: shaggydev.com/2023/01/16/code-smellsMartin Folwer on code smells: martinfowler.com/bliki/CodeSmell.html
Using the AStarGrid2D class in Godot 4 The Shaggy Dev 2022-12-19 | New to Godot 4, the AStarGrid2D class makes solving grid-based layouts a lot easier than the existing AStar2D class while also adding some performance improvements and control for how that pass is found.Basic usage: 00:00Customizing the heuristic: 01:26Using diagonals: 02:24Jumping: 02:58Text version: shaggydev.com/2022/12/19/godot-astargrid2dSample code: github.com/theshaggydev/the-shaggy-dev-projects/tree/main/projects/godot-4/astargrid2dAStarGrid2D documentation: docs.godotengine.org/en/latest/classes/class_astargrid2d.htmlIntroduction to A*: redblobgames.com/pathfinding/a-star/introduction.htmlA* Heuristics: https://theory.stanford.edu/~amitp/GameProgramming/Heuristics.html
An introduction to graph rewriting for procedural content generation The Shaggy Dev 2022-11-21 | Graph rewriting is a great way to generate interesting procedural content for games, suitable for generating both grid-based and non-grid-based maps, quest structures, and more. In this introductory video, we'll look at what a graph is, how graph rewriting can be used to generate content for games, and what some common techniques and usages look like.Intro: 00:00What is a graph?: 00:42Graph rewriting: 02:30Generating a graph: 04:09Common uses: 05:26Text version: shaggydev.com/2022/11/20/graph-rewritingAnd here's a few links you might want to check out regarding implementation:Metazelda Algorithm: web.archive.org/web/20210628151946/bytten-studio.com/devlog/2012/11/30/lock-and-key-puzzle-generationGraph Grammar based Procedural Generation for a Roguelike: youtube.com/watch?v=RAtdFKiqs34Unexplored's generation method: aiandgames.com/2021/01/28/unexploreds-secret-cyclic-dungeon-generation
8 changes to GDScript in Godot 4 youll want to know about The Shaggy Dev 2022-10-25 | Here are five things that are different in GDScript from Godot 3 to Godot 4, along with three new features that you may want to know about. Here's the changes we'll look at: the introduction of Callables, the "await" command, calling functions from a superclass, changing scenes, and annotations. Additionally, we'll look at a few new additions to typing variables in GDScript 2.Text post and code snippets: shaggydev.com/2022/10/24/gdscript1-to-gdscript2Doc links:Callables: docs.godotengine.org/en/latest/classes/class_callable.htmlAwait: docs.godotengine.org/en/latest/tutorials/scripting/gdscript/gdscript_basics.html#awaiting-for-signalsAnnotations: docs.godotengine.org/en/latest/tutorials/scripting/gdscript/gdscript_basics.html#annotationsExports: docs.godotengine.org/en/latest/tutorials/scripting/gdscript/gdscript_exports.html
How to use setter and getter functions in Godot 4 The Shaggy Dev 2022-09-28 | Setter and getter functions let you run custom logic when a variable to written to or read from. There have been some minor changes in how this works in Godot 4, so let's look at the new syntax and how it differs from Godot 3.Text version of this content: shaggydev.com/2022/09/27/godot-4-setter-getterSample project: github.com/theshaggydev/the-shaggy-dev-projects/tree/main/projects/godot-4/setget
Godot 4 beta + channel update The Shaggy Dev 2022-09-15 | The Godot 4 beta is here, which means it's time to do some housekeeping regarding my existing Godot content.Text version: shaggydev.com/2022/09/15/godot-4-beta
How to write more flexible game code The Shaggy Dev 2022-09-14 | Writing code that is flexible and receptive to change can be a challenge, but these tips can help you improve your codebase, no matter the size of your game.The application hierarchy: 00:00Managing data and logic: 02:32Use components: 04:01Dependency injection: 04:38On design patterns: 05:59The final tip: 07:37Text writeup: shaggydev.com/2022/09/13/flexible-code
How to make a tactics game in only two weeks The Shaggy Dev 2022-08-16 | Let's take a deep dive into the design of the elemental tactics game I made for Mech Jam III, Elemechs. This game is far from perfect, but the processes for art and sound production, application architecture, and overall design should still be of interest to anyone curious about making their own tactics game.What is Elemechs? 00:00Art pipeline: 01:37Mechs and actions: 03:53Action design: 07:28Turn and team management: 09:04Level editor: 10:21Level design: 11:59AI: 14:15Sound and music: 15:34Elemechs: theshaggydev.itch.io/elemechsText version: shaggydev.com/2022/08/16/mech-jam-iii
Kaiju Klash announcement The Shaggy Dev 2022-08-10 | In short, my third commercial game, and second Steam release, is now available to wishlist!Kaiju Klash is a turn-based fighter where you build your own giant monster and fight to climb the ranks of the arena against other perilous, and sometimes wacky, monster combinations. Each monster part offers unique stats and abilities so you can fight how you want!Steam page: store.steampowered.com/app/2112500?utm_source=homepage&utm_campaign=sdyt
5 more quick GDScript tips The Shaggy Dev 2022-08-03 | Let's look at five small tips for working with GDScript that you may find useful.Better float comparison: 00:00Wrapping values: 00:53Smoother interpolation: 01:14Custom errors and warnings: 01:32Mapping values to a range: 01:58Code snippets: shaggydev.com/2022/08/02/more-gdscript-tips-Documentation links-Floats in Godot: docs.godotengine.org/en/stable/classes/class_float.htmlis_equal_approx: docs.godotengine.org/en/stable/classes/class_%40gdscript.html#class-gdscript-method-is-equal-approxis_zero_approx: docs.godotengine.org/en/stable/classes/class_%40gdscript.html#class-gdscript-method-is-zero-approxwrapf: docs.godotengine.org/en/stable/classes/class_%40gdscript.html#class-gdscript-method-wrapfwrapi: docs.godotengine.org/en/stable/classes/class_%40gdscript.html#class-gdscript-method-wrapismoothstep: docs.godotengine.org/en/stable/classes/class_%40gdscript.html#class-gdscript-method-smoothsteppush_error: docs.godotengine.org/en/stable/classes/class_%40gdscript.html#class-gdscript-method-push-errorpush_warning: docs.godotengine.org/en/stable/classes/class_%40gdscript.html#class-gdscript-method-push-warningrange_lerp: docs.godotengine.org/en/stable/classes/class_%40gdscript.html#class-gdscript-method-range-lerp
How to use the microphone in Godot 3 The Shaggy Dev 2022-07-15 | Using the microphone is fairly straightforward in Godot, though you might not realize it since the information you need is scattered all over the web. This is my attempt to organize everything into one post. We'll look at how to record, play back, and save audio in addition to how we can performa real-time analysis of the volume and frequency of the microphone input.Project setup: 00:00Recording, playing, and saving audio: 00:52Real-time volume monitoring: 02:16Real-time frequency monitoring: 03:22Changing the recording device: 04:13Text version: shaggydev.com/2022/07/14/godot-microphoneSample project: github.com/theshaggydev/the-shaggy-dev-projects/tree/main/projects/godot-3/microphoneGodot docs on recording: docs.godotengine.org/en/stable/tutorials/audio/recording_with_microphone.htmlMiziziziz repo: github.com/Miziziziz/ScreamHorrorGameSpectrum analyzer devblog: godotengine.org/article/godot-32-will-get-new-audio-features
5 tips for better platformer controls The Shaggy Dev 2022-06-30 | Making a good, satisfying platformer is a lot harder and more involved than throwing a physics body on top of a tilemap and calling it a day, so here's a few tips for how you can make your platformer feel better to play, from the basics to some more advanced tricks.The most fundamental thing: 00:00Correcting player mistakes: 01:02Custom jump functions: 03:08Closing thoughts: 04:52Text version and full code snippets: shaggydev.com/2022/06/29/platformer-tipsMath for Game Programmers: Building a Better Jump - youtube.com/watch?v=hG9SzQxaCm8GMTK Platformer Toolkit - gmtk.itch.io/platformer-toolkitCorrection: 04:50 Unfortunately, this video is no longer available.How to Calculate the Perfect GRAVITY and JUMP FORCE - youtube.com/watch?v=K9g8TTFjIlY
Scene transition effects in Godot 3 The Shaggy Dev 2022-06-13 | Let's look at how we can use animations, shaders, and other effects to make better scene transitions in Godot than a simple call to `get_tree().change_scene`. We can do this by adding an autoloaded scene that can act as an intermediary when we want to let an effect play out during scene transition. This also makes it easy to introduce background loading if we want.Sample project: github.com/theshaggydev/the-shaggy-dev-projects/tree/main/projects/godot-3/scene-transitionsText version: shaggydev.com/2022/06/13/godot-scene-transitionsCorrection: 00:03 See the pinned comment for the equivalent syntax in Godot 4!
Communicating between game objects with the observer pattern The Shaggy Dev 2022-06-02 | One of the most common issues you'll run into in your game development journey is how to let two unrelated objects communicate with one another in a way that doesn't completely ruin the organization and flexibility of your code. The observer pattern is one potential solution to this problem, and makes it easy to let different game objects communicate with one another without coupling your entire application together. With native support in most languages and game engines, it really is something you should keep in your toolbox. We can also expand upon this concept further and introduce the event bus, a way of letting more distant objects connect to one another while still keeping the flexibility of your code intact.Text version of this video: shaggydev.com/2022/06/01/observer-patternMore info on the observer pattern: gameprogrammingpatterns.com/observer.htmlBackground and motivation: 00:00The observer pattern: 01:34Observables in practice: 02:52Global access via an event bus: 05:02The event bus in practice: 05:31Final thoughts and further reading: 06:04
Godots OS Class The Shaggy Dev 2022-05-19 | Godot's OS class offers you direct communication with the user's operating system, providing a lot of convenience for things like determining the screen resolution, moving and resizing the game window, and working with the system clipboard.Text version: shaggydev.com/2022/05/18/godot-os-classDocumentation: docs.godotengine.org/en/stable/classes/class_os.htmlSample project: github.com/theshaggydev/the-shaggy-dev-projects/tree/main/projects/godot-3/os-class
11 tips for writing cleaner code The Shaggy Dev 2022-05-05 | The subject of clean code is important for anyone doing any amount of coding, and games in particular can get messy fast. So let's talk about how to write cleaner, more readable, and more maintainable code.Text version of this video's contents: shaggydev.com/2022/05/04/clean-code
Pixel-perfect collisions on sprites in Godot The Shaggy Dev 2022-04-14 | Whether you want accurate collision bodies or pixel-perfect mouse detection, this video is for you. Let's look at our options using both the editor and GDScript to create collision polygons from sprites in Godot.Intro: 00:00Via the editor: 00:24Via code: 01:23Objects with holes: 03:25Text version: shaggydev.com/2022/04/13/sprite-collision-polygonsSample project: github.com/theshaggydev/the-shaggy-dev-projects/tree/main/projects/godot-3/sprite-collision-polygonsDocumentation for BitMap: docs.godotengine.org/en/latest/classes/class_bitmap.html
Configuring Godots built-in code editor The Shaggy Dev 2022-03-26 | Godot's default settings for its built-in code editor are intended to be both approachable for beginners and generally agreeable to the broader user-base, but if you have experience in software development outside of Godot or even have just been working with the engine for a while you'll be particular about how you like to do things, so here's a few items you may want to configure in the Editor Settings window to make your coding experience more agreeable.Text version of this video: shaggydev.com/2022/03/25/godot-code-editor-settingsGodot docs for external editors: docs.godotengine.org/en/stable/tutorials/editor/external_editor.html
Generative grammars as a form of procedural content generation The Shaggy Dev 2022-03-17 | At their core, generative grammars are all about the rules and replacements of a language. In our case, that language is game content. Let's look at how we can take the simple concept of word replacement and use it to create more thoughtful and interesting procedurally generated content.Definition and example: 00:00Other uses: 03:11Quest generation: 04:00The main limitation: 05:48Where's the code?: 06:41Text version of this video: shaggydev.com/2022/03/16/generative-grammars
How I do screen shake in Godot The Shaggy Dev 2022-02-24 | The basic way to do screen shake is to just apply a random offset each frame to the camera, but in this video I show how I use Godot's OpenSimplexNoise class to generate noise and get a more fluid and customizable screen shake. This can work great for both intense shakes and gentle sways.Sample source code to compare: github.com/theshaggydev/the-shaggy-dev-projects/tree/main/projects/godot-3/screen-shakeText version of this post: shaggydev.com/2022/02/23/screen-shake-godotGodot documentation: docs.godotengine.org/en/stable/classes/class_opensimplexnoise.html
Building a more advanced state machine in Godot 3 The Shaggy Dev 2022-02-13 | Hierarchical state machines and dependency injection are two great techniques to know about when building your state machines in Godot. Let's look at how these techniques can be used to build upon the simpler implementation from the previous video on state machines and make something more flexible and reusable.Intro: 00:00Hierarchical state machines: 01:46Dependency injection: 03:36More options: 05:22Source code: github.com/theshaggydev/the-shaggy-dev-projects/tree/main/projects/godot-3/advanced-state-machineText version of this video: shaggydev.com/2022/02/13/advanced-state-machines-godotVideo on FuncRefs: youtu.be/f5oE2cqxv3M
Making a customizable turn-based combat game in two weeks The Shaggy Dev 2022-02-10 | Kaiju Klash is a game my partner and I made in two weeks for the Kaiju Jam. It features monster customization and turn-based combat. In this video, I cover a few takeaways from the experience.Intro: 00:00Gameplay: 00:20Graphics: 01:25Audio: 02:14Polish: 02:56Misc Tech Stuff: 03:42Text version: shaggydev.com/2022/02/09/kaiju-klashCheck out Kaiju Klash: theshaggydev.itch.io/kaiju-klashCheck out all the submissions here: itch.io/jam/kaijujam
Using a Line2D node to create physics bodies in Godot The Shaggy Dev 2022-01-26 | Let's look at how we can use the Geometry class and the techniques demonstrated in the Polygon2D video to create static and rigid bodies in Godot from Line2D nodes. This is done using the offset_polyline_2d function, which let's us take a line and buffer it by a given amount to create one or more polygons.Intro: 00:00Static bodies: 00:30Rigid bodies: 01:32Running the sample: 02:42Godot 3 documentation: docs.godotengine.org/en/3.5/classes/class_geometry.html#class-geometry-method-offset-polyline-2dGodot 4 documentation (renamed but functions the same): docs.godotengine.org/en/stable/classes/class_geometry2d.html#class-geometry2d-method-offset-polylinePolygon2D video: youtu.be/-N-4hbGWeGoSource code: github.com/theshaggydev/the-shaggy-dev-projects/tree/main/projects/godot-3/line2d-physicsText version: shaggydev.com/2022/01/25/line2d-physicsDonut Roll (the game showed at the end): theshaggydev.itch.io/donut-roll
5 quick tips for GDScript The Shaggy Dev 2022-01-13 | Let's look at five useful things to know about coding in GDScript that are too small for their own video.Custom string casting: 00:00Fixed export options: 00:32Safe lines: 00:59Large number readability: 01:41Stepify: 01:51Code snippets and text version of this video: shaggydev.com/2022/01/13/gdscript-tipsLink to the Godot documentation on stepfiy: docs.godotengine.org/en/stable/classes/class_@gdscript.html#class-gdscript-method-stepify
Setter and getter functions in Godot 3 with setget The Shaggy Dev 2022-01-05 | Setter and getter functions allow you to write custom logic to be ran when a variable to written to or read from. In Godot, we can define setter and getter functions using the setget keyword, followed by the names of the setter and getter functions, respectively. This video demonstrates the technique along with providing some useful tips for when you're using setget in a project.Text version of this video: shaggydev.com/2022/01/04/setgetOfficial documentation: docs.godotengine.org/en/stable/getting_started/scripting/gdscript/gdscript_basics.html#setters-getters
An introduction to procedural lock and key dungeon generation The Shaggy Dev 2021-12-18 | Let's take an introductory look at lock-and-key procedural content generation. Using a lock-and-key framework to procedurally generate content, you specify paths of progression for the player in your games. Roguelikes, narrative games, and really any sort of game where you want the player to advance via a series of steps (whether linear or non-linear) can be modeled and created this way.Intro: 00:00Definition: 00:56Big key locks: 01:43Small key locks: 02:38Stateful locks: 03:49A sample technique for generating content: 04:36Limitations: 07:14Spatial methodologies: 09:09Conclusion: 10:57Video transcript and code snippets shown in the video available here: shaggydev.com/2021/12/17/lock-key-dungeon-generationMetazelda repo: bytten-studio.com/devlog//2012/11/30/lock-and-key-puzzle-generationIRDC 2014 - Roguey-Locks and the Three Graphs: youtube.com/watch?v=uP3horC38IEUnexplored's unique cyclic graph generation technique: aiandgames.com/2021/01/28/unexploreds-secret-cyclic-dungeon-generation
Implementing the state pattern in Godot 3 The Shaggy Dev 2021-11-15 | Let's take a look at how we can implement the state pattern in Godot. Using a simple platformer project, I'll show the basic technique using enumerators and a more fully featured state machine that uses Godot's node system to provide extra conveniences over a pure code solution.Intro: 00:00The enumerator method: 00:53Technique overview: 01:45Player and state manager breakdown: 03:33Individual states: 05:40Conclusion and running the project: 06:58Theory video: youtu.be/-ZP2Xm-mY4EPart three of this series: youtu.be/DPxIMVC0oZASource code: github.com/theshaggydev/the-shaggy-dev-projects/tree/main/projects/godot-3/the-state-patternTranscript: shaggydev.com/2021/11/15/state-machines-godot
An introduction to finite state machines and the state pattern for game development The Shaggy Dev 2021-11-02 | In this video, we'll discuss finite state machines and how they can be used to write cleaner, more maintainable, and more expandable code for your games. We'll look at the naive way of managing state in a game, how we can improve upon that method slightly with enumerators, and finally how to build a robust system using the state pattern.Intro: 00:00Life without state machines: 00:54Finite state machines: 02:38Using enumerators: 04:55The state pattern: 06:09Final thoughts and where to go next: 10:28Game Programming Patterns: gameprogrammingpatterns.com/state.htmlVideo transcript: shaggydev.com/2021/11/01/state-machines-introArtwork by Kenney: https://www.kenney.nl/
Static typing in Godot using the class_name keyword The Shaggy Dev 2021-10-20 | In this video, we'll look at how you can use the class_name keyword to enable static typing for your custom classes. We'll also look at some other uses for it, such as subclassing, and the common pain points people run into when using it (cyclic dependency anyone?)Source code: github.com/theshaggydev/the-shaggy-dev-projects/tree/main/projects/godot-3/class-name-introductionText version of this tutorial: shaggydev.com/2021/10/19/godot-class-nameArtwork provided by Kenney: kenney.nlIntro: 00:00Base usage: 00:29Other uses: 01:18Gotcha #1 - The global namespace 01:59Gotcha #2 - Cyclic dependencies 02:52
Using a Polygon2D node to create physics bodies in Godot The Shaggy Dev 2021-10-12 | In this video, I'll demonstrate how you can use the Polygon2D node to create both static and rigid physics bodies in Godot. This method allows us to create more custom level geometries than we could otherwise get out of a tilemap, but also let's us iterate on designs faster than making an object outside of the editor.Source code: github.com/theshaggydev/the-shaggy-dev-projects/tree/main/projects/godot-3/polygon2d-physics-bodyTranscript: shaggydev.com/2021/10/11/polygon2d-physics-bodyGodot Bordered Polygon2D Plugin: github.com/arypbatista/godot-bordered-polygon-2dIntro: 00:00The Polygon2D node: 00:51Project setup: 01:48The static body scene: 02:26The rigid body scene: 03:01Results: 05:00Final thoughts: 05:22
Animating a hardware cursor in Godot - An experiment The Shaggy Dev 2021-10-05 | In this video, we'll take a look an experiment I wanted to run: using the hardware cursor interface in Godot but animating it like a software cursor. Overall, the results are mixed, but there is some potential here.Last week's video on using a hardware cursor in Godot: youtube.com/watch?v=TLSg7qIUKQkSource code: github.com/theshaggydev/the-shaggy-dev-projects/tree/main/projects/godot-3/animating-hardware-cursorsText version of this video: shaggydev.com/2021/09/28/custom-cursorsProject motivation: 00:00Project setup: 00:40Code explanation: 01:15First experiment results: 02:22Lower framerate experiment: 02:55Final thoughts: 03:44
