Unreal Ultimate 2D Topdown Udemy Course – Section 4 – Monster World Project

March 13, 2026

The Ultimate 2D Top Down Unreal Engine Course

Title:
The Ultimate 2D Top Down Unreal Engine Course
By:
Cobra Code

https://www.udemy.com/course/unreal-2d-top-down/
Udemy Course Link

Description:
Section 4 focuses on creating a small project similar to an old school Pokemon game using Paper 2D.

Overview:
This section really gets you started on using Paper2D within Unreal. Everything from handling Sprite assets to tile maps to basic animations and layer sorting are covered.

My Notes Breakdown by Sub-Sections:

16. Monster World Overview

Overview of what is covered in this section.
Shows it’s similar to an older Pokemon style game.
Sprite importing and asset management, tiles, layering.
Text box setup.

================================

17. Setting Up the Project and Importing Assets

Starting with Blank project:

  • Blueprint
  • Target Platform: Desktop

Created “New Level”

  • Empty level option

Saved this new level as its own Level asset in a folder named “Maps”

  • like Unity’s Scene assets somewhat

Project assets’ license is: CC0

  • free to use in your own games

Asset Type Conversion Rundown

  1. Characters > Flipbook
  2. Environment Tiles > Tilemap
  3. Environment Flowers > Flipbook
  4. Environment Other > Static Sprites

Creating Static Sprites

Example:
On Chest sprite:
– RMB
– Sprite Actions > Create Sprite

  • this creates a Sprite asset from the Texture asset

Importing Sprite Assets

By default, sprite assets usually look off on initial import.
After importing:

  1. Right click and select: Sprite Action > Apply Paper2D Texture Settings

This changes some of the direct art asset settings:

  1. Mip Gen Setting: NoMipmaps
  2. Texture Group: 2D Pixels (unfiltered)
  3. Editor Show Final Encode: TRUE
  4. Compression Settings: UserInterface2D (RGBA)
  5. Filter: Default (from Texture Group)
    • NOT Bilinear or Trilinear

UI:

  • also applied the Paper2D Texture Settings since it is pixel art.

================================

18. Making a Tile Set and Tile Map

Tile Set is like a palette of brushes you can use to create a Tile Map.

After placing the Tile Map into the Viewport, they rotated it 270 along the x-axis to lay it “flat” in the world.

  • They mentioned this is helpful with having the NavMesh setup work properly.

To prevent tearing between tiles, they generated a padded version of the Tile Set asset.

  • this creates another Texture asset with some padding effect to prevent them from bleeding into each other.
  • it looks like this just very literally duplicates the edge pixel all around the border of each tile a couple times and expands the tiles outward to fit them.
    • so assume this is to prevent those weird super tiny “gaps” you can get between exact sized tiles sometimes?

Creating Tile Set

Select Texture Asset
RMB
Sprite Actions > Create Tile Set


Tile Set Settings

Modify Tile Size to fit your individual tile sprite dimensions:
i.e. 16 px x 16 px

Setting Collision

  • Select Tile
  • Click “Add Box”

Removing Collider:

  • Under Single Tile Editor, click Reset next to Index [0] – 2 members.
    • * This is not very intuitive, seems very complex for section handling collider.

Tile Map

Create Tile Map:

  1. Select Tile Set asset
  2. RMB
  3. Create Tile Map

Active Tile Set:

  • Tile Set assets to select tiles from.
  • Can add multiple Tile Set assets at once.

Can “stamp” an area of selected tiles by holding Shift to create a selection for the stamp.

Tile Layer List:

  • allows for layering of tile layers

Setup:

  • where you set the full width and height of the map (in tiles)

================================

19. Preparing the Character Sprites


General

Modifying parameters of several assets at once.

  1. Shift select all the assets.
  2. RMB
  3. Asset Actions > Edit Selection in Property Matrix

Converting a Sprite Sheet to Flipbook

Select sprite Texture Asset and:

  • Sprite Actions > Extract Sprites

Extract Sprites generally defaults to Sprite Extract Mode : Auto.

  • but you generally change it to Sprite Extract Mode : Grid.
    • because you want the sprites to fit a general grid size, and not the smallest space possible.

Creating Flipbook Asset:

  1. Select multiple Sprite Asset
  2. RMB
  3. Create Flipbook

Working with Flipbook

Flipbook asset has a Frames Per Second parameter that can be modified to change the speed the Flipbook is played.

  • controls the general speed the animation is played

Making Character Flipbooks

They made separate Flipbook assets for each direction of the walking animation.
They also made separate Flipbook assets for the Idle of each direction.

  • each of these was just a single Spirte asset converted into a Flipbook

Folder Organization

Example for Character sprite assets:
PaperAssets > Characters > Red

  • this is the parent path to all sprite assets for this single character, Red.
  • this is also used to contain assets used directly by the game as they described.
    • so it contains all the Paper Flipbook assets (the animation assets)

PaperAssets > Characters > Red > Frames

  • placed all the individual extracted Sprite assets here.
  • (after extracting them from the Sprite sheet)

PaperAssets > Characters > Red > Textures

  • Sprite sheet placed in here (Since it is a Texture asset)

Naming Conventions

Flipbook Assets examples:
FB_Red_Walk_D

  • FB for Flipbook
  • Red is the character
  • Walk describes the animation
  • D is for down, which is the specific walking animation of that Flipbook.

FB_Red_Idle_R

  • FB for Flipbook
  • Red is the character.
  • Idle describes the animation.
  • R is for right.

================================

20. Best Project Settings for 2D Games

Common Problems:

  • motion blur and anti-aliasing can cause visual problems.

Link for “Best 2D Settings for Unreal Engine 5”:
https://cobracode.notion.site/Best-2D-Settings-for-Unreal-Engine-5-0895133a56924f1ca7f2149cf111983b

  • They just go through this list and set these settings any time they do a new 2D project.

Selecting All Assets in Project of a certain Type:

  • can use the Filter in the Content Drawer.
  • After selecting the Filter, can just enter the asset type you are interested in, and it’ll display all assets of that type in the project.

** They created Project Templates that just have all these settings set for 2D games immediately.


Project Settings

Turn OFF Auto Exposure.

  • having this can cause dark scenes to get brighter over time.
    • I saw this happening when I was tinkering with settings before and thought something was broken!

Motion Blur = OFF


Post Processing Settings

Access through Quick Add Menu.

PostProcessVolume default only applies if camera is within the volume.
Can make the PostProcessVolume affect everything by setting Infinite Extent (Unbound) to TRUE.


Texture Settings

  • For some reason for 2D Sprite Texture assets, if you set the Filter to Default (from Texture Group), it can look correct in editor but reverts to an option like Bilinear in builds which makes them blurry again.
  • to solve this, they select the Filter: Nearest.

================================

21. Character Blueprint and Pixels Per Unit

Blueprint for character:

  • created as Paper Character Blueprint

With a discrepancy between the Sprite asset and the Paper Character Blueprint size, they recommend making the Sprite larger.

  • the Paper Character makes assumptions about the general size of the character, which is what it is approximately sized at by default, so better to get closer to that instead of the other way around.

*** 1 Unreal Engine Unit = 1 cm
– this is DIFFERENT from Unity, which generally considers 1 unit as 1 m.
– this technically isn’t “real” but is a universally accepted approximation.

** There is a project wide setting to have a default Pixels per Unit set for all imported assets.


Pixels Per Unit

Sets scaling of pixels to 1 Unreal Engine Unit.

  • This is their recommended way of scaling pixel art assets.
    • this is similar to Unity.
    • this is done on the Sprite assets

They changed all their Sprite assets across the board to the same Pixels per Unit value.

  • I think this might be the ideal practice, but not positive.

Also need to change Tile Map assets Pixels per Unit values.

================================

22. Setting up the Camera and Possessing the Character

Added Player Start actor to Viewport.

  • appears to be a sort of spawn point that connects to a Game Mode (like a Game Manager)

Created new Game Mode Blueprint

  • think this is like a manager class in Unity?

*** FIXED EDITOR CAMERA ROTATION PROBLEM:
– Somehow my camera in Editor started rotating abnormally (directions were very backwards).
– You can fully reset the Editor camera by entering this command in the Console Commands:
BUGITGO 0 0 0 0 0 0

Settings Cameras to Orthographic helps ignore “height” differences along the z-axis.

  • including preventing character from “falling” into place at game start if it spawns above the ground.
  • They disabled Do Collision Test on SpringArm.
    • not needed for 2D games.

Character Blueprint

Added a Spring Arm.

  • with a Camera.

Setting the Default Game Mode

Go to:

  • Edit > Project Settings… > Project > Maps & Modes
    • set Default GameMode to the newly created one: GM_TopDown
  • Here you can also set the Map that opens on Editor Startup and the Game Default.
    • This feels like setting Scenes in the Build Settings for Unity.

================================

23. Enhanced Input and Character Movement

Uses new Enhanced Input Actions setup from Unreal Engine 5.1 on.

Input Actions setup requires two main parts:

  1. Input Actions
    • seems to be individual inputs.
  2. Input Mapping Context
    • the full mapping of all the inputs to their output game behaviors.
  • They noted in the character controller Blueprint Event Graph setup that using Get Controller and casting to Player Controller is nicer for multiplayer setup.
  • Directly getting the Player Controller requires setting a player index for multiplayer.

Input Actions

Created a single Input Action, Move.
Set its Value Type to: Axis2D (Vector 2D)


Input Mapping Context

This is where you associate an input (i.e. a keyboard key press of “A”) with a specific Input Action.
Can also apply Modifiers to these values based on different inputs.

  • i.e. Lets you use a single Input Action but different inputs (i.e. W and S) to go different directions based on the Modifiers.

For the IMC_TopDown (primary player controller for this project):

  • set W, A, S, and D as 4 separate input mappings all under the single IA_Move Input Action.
  • used modifiers to apply this in the different directions
    • combinations of Negate and Swizzle
    • Negate reverses direction.
    • Swizzle changes axis.

Folder Organization

Content > Input

  • main folder for all input assets
  • Input Mapping Context assets at this level

Content > Input > Actions

  • put Input Action assets here.

Player Blueprint Event Graph Setup

Need to initialize Input Mapping Context.

  • Get Controller > Cast to PlayerController > Enhanced Input Local Player Subsystem > Add Mapping Context

Created an Enhanced Action Event from our Input Action asset, IA_Move.

  • Triggered: occurs constantly multiple times as this input as held down.
    • like Unity Input.GetKey
  • Started: occurs once right when input is entered.
    • like Unity Input.GetKeyDown
  • Action Value: the return value of this input.

In this case, the Action Value would return a Vector2D based on our Input Mapping Context, including the Negates and Swizzles.

  • used this with a Break Vector2D node to separate out the X and Y values.

Add Movement Input node:

  • inherited from Pawn class
  • could take broken down x and y values as input in Scale Value along with appropriate directional World Direction values to move player in correct directions based on input.

================================

24. Directional Character Animations from Scratch

Promoted Action Value of Enhanced Action Event to Variable.

  • makes it a variable in the Blueprint you have access to.

Renamed the Action Value variable to Directionality.

  • used the values of this Vector2D to determine the direction of the player to update the sprite accordingly (with many bool checks).
  • changed Sprite by using Set Flipbook node, with the Blueprint Sprite dragged in as reference.
    • Set Flipbook seems to work somewhat like Unity when playing an animation, if using sprite assets.

Creating a Function:

  • collapsed a bunch of added nodes into a single function.
    1. Select all nodes.
    2. RMB
    3. Collapse to Function
  • then just renamed the Function to UpdateAnimation.

Enhanced Input Event > Completed

  • happens a single time when input is released.
  • like Unity Input.GetKeyUp

Branch node:

  • if else statement node

================================

25. Adjusting the map and collisions

Removed all the individual tile colliders from our Tile Set asset.
Replaced those with a single Plane in our Map with a single collider.

  • still using a collider to keep player from falling through floor.

Game is still using 3D collision for collision detection.
Changed CharacterMovement component’s Max Step Height from 45 to 10.

  • ** They recommend not using 0 because even as a 2D game where that could make sense, it can cause weird issues even walking over flat terrain and doesn’t even work for collision well anyway.

Modified the Sprite assets to make their colliders thicker.

  • thickened from 10 to 100 on the sign and tree Sprites.

================================

26. Foreground and Background sorting

  • They don’t include the individual Sprite assets in the environment Tile Map because it restricts your options for layer sorting this way with Unreal Paper.

Keys:

  1. Made all Sprites use Material: TranslucentUnlitSpriteMaterial
  2. Edited colliders of all Sprite assets we wanted to be able to walk behind to about 1/3 their full height.
  3. Moved Sprite privots to Bottom Center.
  4. In Unreal Project Settings > Engine – Rendering
    • set Translucent Sort Policy to: Sort Along Axis
    • the default axis to sort along was correct (0, -1, 0)

Shrunk player collider radius so top doesn’t have as much collision area.
Make sure Material changes apply to Sprites in Blueprints.

  • Blueprint Material settings will override base Sprite settings, so have to go into them individually to check and update if needed.

================================

27. Project files with layer sorting

  • Just a checkpoint to download a new project file if you messed up earlier steps.

================================

28. Creating a simple message UI with custom fonts

2 main parts:

  1. Widget for entire screen
  2. Modular part for message box

Widgets = UI elements in Unreal Engine

** Want to minimize use of Canvases in Unreal for optimization purposes.

Created two new Widget Blueprints:

  1. WBP_MessageBox
    • simple text containing message box.
    • Modified: padding, Screen Size – Desired, font, Auto Wrap Text to TRUE.
  2. WBP_MainHUD
    • has our singular Canvas.
    • contains the Message Box.
      • anchored and positioned to bottom center of screen

In BP_Red (Player Blueprint) we generate the WBP_MainHUD on start, and set it as a variable reference useable later.

================================

29. Making a pickup

  • They recommend creating a separate collider for interactions.
    • like separating the trigger / interactive collider from the physicsl obstacle layer collider.

Created a Blueprint for the item itself, BP_Pickup.

  • in this Blueprint, created a GetPicked function.

In the player Blueprint (BP_Red):

  • added new Input Action event for Interact
  • on Started of this action, do check
    • so it only happens a single time on input
  • when interacting, do a Overlapping Actors collision check to find in range colliders.
  • check by cast if any are BP_Pickup
  • if so, invoke GetPicked function

Blueprints

Events cannot have a return type.

================================

30. Showing the item message

Shortcuts:
Ctrl + P = brings up search window for assets

Created function within the WBP_MainHUD to change visibility.
BP_Red (player controller) invokes control of message display using collision detection with interact Input Action.
Setup simple Retriggerable Delay to have message go away after some time.
Made BP_Pickup ItemName string and ItemID int Instance Editable so we could have different BP_Pickup actors in Viewport with different ItemName and ItemID.

================================

31. NPC Dialogue and Interfaces


Technical

Casts are a hard reference.

  • So if you load a Blueprint with a cast, it must also load any casted Blueprint types.
  • increases load times.

** Can use Reference Viewer to see dependency chains.

They setup a Blueprint Interface.

  • reduces hard references.
  • more scalable Blueprint setup in BP_Red (player controller).

Unreal Ultimate 2D Topdown Udemy Course – Section 2 – Unreal Engine 5 Crash Course

March 6, 2026

The Ultimate 2D Top Down Unreal Engine Course

Title:
The Ultimate 2D Top Down Unreal Engine Course
By:
Cobra Code

https://www.udemy.com/course/unreal-2d-top-down/
Udemy Course Link

Description:
Section 2 is focused on covering the basic fundamentals of using the Unreal Engine (specifically Unreal Engine 5).

Overview:
I make a lot of personal comparisons to Unity since I’m much more familiar with it. That helps me envision how the different parts of the project connect since I already have a mental image of how it flows in Unity.

My Notes Breakdown by Sub-Sections:

7. How to Install Unreal Engine 5

Download Epic Games Launcher.
Get Unreal Engine 5.4

================================

8. How to create a new Project

Created a new Third Person Template project named “CrashCourse”

================================

9. How to navigate the Editor

Main Window = Viewport
Has similar translate, rotate, and scale gizmos to Unity when selecting(left-click) objects.

Undo:
Ctrl + Z

Redo:
Ctrl + Y

Selection Shortcuts:
W = translate
E = rotate
R = scale

Can change translate, rotate, and scale snap increments in top right of Viewport.


Camera Movements

Hold Right-Click and drag = rotate view
Hold Middle MB = pan view
Hold Right-Click + WASD = translate camera like 3rd person floating camera
Hold Right-Click + scroll scroll wheel = increase/decrease movement sensitivity (move camera faster or slower)
Scroll scroll wheel = zoom in/out


View Modes

Basic is Lit.
Has options like: Unlit, Wireframe.

Show button:

  1. Navigation used sometimes to check Unreal NavMesh.
  2. Collision used to check actual collision of meshes in testing/debugging.

World Outliner

  • Unreal equivalent of Unity’s Inspector.

Can press “F” with something highlighted in the Outliner to focus on it.

  • * Also like Unity

Play Mode

Start by:

  1. Pressing Play button at top of Viewport.
  2. Alt + P

ESC = exit play mode
Shift + F1 = get mouse controls back to interact with editor
Shift + F1 + click Eject = get mouse controls back, and be able to click in Viewport to edit

Can make changes during play mode, but they will not be saved upon leaving play mode.

  • * Also like Unity

Viewport seems to act as both the Scene and Game view from Unity.

================================

10. Content Drawer and Blueprints

Content Drawer appears to be like the Assets section from Unity.


Content Drawer

Ctrl + Space = shortcut to pop open this drawer


Blueprints

Common naming convention:
prefix with “BP_”

Event Graph
The Event Graph portion of a Blueprint is the visual scripting aspect that houses a lot of the logic building.

Viewport
Shows the full structure of the Blueprint in more of a game space view.

They are much more than just the “code” or logic of something.
They are the full makeup of an entire object.

  • * Closer to a fully built out Unity prefab.

================================

11. How to make a simple Blueprint

When creating a new Blueprint, there are many options to base them off of.

  1. There are a few main options, with Actor being the simplest.
    • Actor seems comparable to GameObject from Unity.
  2. Then there are hundreds of other more specific case options.

Naming Conventions for Unreal Assets

Recommended Unreal Asset Naming Convention Link:
https://dev.epicgames.com/documentation/en-us/unreal-engine/recommended-asset-naming-conventions-in-unreal-engine-projects

[AssetTypePrefix][AssetName][Descriptor]_[OptionalVariantLetterOrNumber]

  • AssetTypePrefix identifies the type of Asset, refer to the table below for details.
  • AssetName is the Asset’s name.
  • Descriptor provides additional context for the Asset, to help identify how it is used. For example, whether a texture is a normal map or an opacity map.
  • OptionalVariantLetterOrNumber is optionally used to differentiate between multiple versions or variations of an asset.

================================

12. Adding functionality to our Blueprint

Event BeginPlay:

  • similar to Unity Start

Event Tick:

  • like Unity Update

Event ActionBeginOverlap:

  • they just don’t like it there at the highest level of the Blueprint because it’s ambiguous
  • they prefer adding it more directly on component it relates to

They basically setup a speed increasing pickup in this section.

  • very similar practices to Unity, just done with Blueprints and slightly different jargon.
  • Remember to connect Exec pins properly.
  • Ensures they even run.
  • Determines the logic order.
    • basically how lines of code would be structured

Events:

  • found when selecting a component in a Blueprint, shows up in the Details panel.
  • this example focused on OnComponentBeginOverlap
  • USE Print String like Debug.Log!

Pickup Edits

OnComponentBeginOverlap

  • like Unity OnColliderEnter

Destroy Actor

  • like Unity GameObject.Destroy

Used “Cast To BP_ThirdPersonCharacter” with OnComponentBeginOverlap to ensure collision logic only occurred when colliding with the player.

  • like checking GetComponent against something only player has to check what collided.

Collision Parameters

Changed Collision Presets of the pickup spheres from BlockAllDynamic to OverlapAllDynamic.

  • goes from being a solid obstacle to something that can just be passed through.
  • like Unity trigger vs. non-trigger colliders.

Event Graph

In My Blueprint panel, you can add variables.

  • these can then be drag ‘n dropped into Event Graph to utilize them.
  • first step to having a variable at higher level instead of coding it in line.

Can set variables to “Instance Editable” in Details panel.

  • makes them viewable and editable on an instance by instance basis.
  • viewable in Outliner
  • like Unity accessible variables in Inspector at this point.

In My Blueprint panel, you can add new Functions.

  • literally exactly like adding a method to a class.

Can add input parameters to the function.

  • Select the original function node.
  • In Details panel, add new Inputs.
  • adds a new corresponding output pin to the function node.
    • since that value will be coming IN to the function when it’s actually used.

Event Graph Shortcuts

Alt + LMB (on graph line) = deletes graph line
Double Click LMB (on graph line) = generates extra reroute node


Viewport Shortcuts

Alt + LMB Drag on gizmos = duplicates an object

================================

13. Useful Keyboard Shortcuts and Tips

Undo = Ctrl + Z
Redo = Ctrl + Y
Multi-select = Ctrl + LMB OR Shift + LMB
– works in both the Viewport and the Content Drawer
Save ALL = Ctrl + Shift + S
Alt + LMB drag gizmo = Duplicate object


Event Graph

Ctrl + LMB Drag Variable = Getter Node
Alt + LMB Drag Variable = Setter Node
LMB Drag Variable = displays option for Getter or Setter Node

================================

14. How to debug your Games

Print String

  • like Debug.Log in Unity

Unreal Ultimate 2D Topdown Udemy Course – Overview

March 3, 2026

The Ultimate 2D Top Down Unreal Engine Course

Title:

The Ultimate 2D Top Down Unreal Engine Course


By:
Cobra Code

Udemy Course Link

Description:
Comprehensive course of learning the basics of Unreal and creating 2D projects with it, with a focus on Paper2D.

Overview:
I wanted to get some general Unreal experience, and was recommended this interesting tutorial, so figured this would be a good place to start. While Unreal is primarily an engine for 3D projects, this course specifically targets how to create a 2D project using it. I thought this would actually be a good starting point because it still covers all the general Unreal basics, while exploring something a bit off the conventional path seemed like it’d also help teach me some of the more niche aspects of the engine thereby making it wider than a lot of other intro courses.

This course also has you create several entirely separate 2D projects, covering a lot of types of games I am interested in. The first is a fully topdown adventure demo in the lines of a Pokemon type game. The second is another fully topdown game that resembles older 2D Zelda titles, with combat. The third is what they call a 2D/3D hybrid, resembling an Octopath Traveler, which combines 2D and 3D assets, and is something I could see Unreal being particularly good to use to build.

Unity Using Events and Building Effective UI Systems

September 7, 2021

Unity Events

UI Systems


Title:
C# Events in Unity! – Intermediate Scripting Tutorial

By:
Unity


Youtube Link – Tutorial #1

Description:
Brief introduction to using Events in Unity.


Title:
How To Build An Event System in Unity

By:
Game Dev Guide


Youtube Link – Tutorial #2

Description:
Quick showing of implementing a basic Event system in Unity for gameplay reasons.


Title:
Delegates, Events, Actions and Funcs – The Observer Pattern (Unity & C#)

By:
One Wheel Studio


Youtube Link – Tutorial #3

Description:
Covers Events, as well as Delegates, Actions, and Funcs specifically through the Observer Pattern in Unity.


Title:
Game Architecture Tips – Event Driven UI – Unity

By:
Dapper Dino


Youtube Link – Tutorial #4

Description:
An Event system built in Unity specifically with a focus on UI.


Title:
Building Unity UI that scales for a real game – Prefabs/Scenes?

By:
Jason Weimann


Youtube Link – Tutorial #5

Description:
General coverage of building effective UI systems in Unity.


Overview

I wanted to delve further into using Event systems in Unity specifically when building UI systems, so I collected a few resources I thought would help with researching that. These tutorials cover everything from the basic foundations of Events themselves to fully fledged UI system tutorials near the end implementing those tools and concepts covered in the earlier tutorials.

I think Event heavy systems are very effective ways to build out UI in games, so I want to get a better grasp of setting that up. I especially think the final tutorial by Jason Weimann will help bring those topics together as well as cover other important factors for building larger scale UI systems.

via Blogger http://stevelilleyschool.blogspot.com/2021/09/unity-using-events-and-building.html

Adobe Photoshop – Introductory Tutorials – Game Art Focus – Part 1

August 12, 2021

Adobe Photoshop

Game Art Tutorial List


Title:
Total BEGINNERS guide to drawing in photoshop 2021

By:
Trent Kaniuga


Youtube – Tutorial #1

Description:
Quicker coverage of just a lot of general tools and what they do in Photoshop.


Title:
Learning the basics of drawing in Photoshop

By:
Michael Clarida Arts


Youtube – Tutorial #2

Description:
Shows a drawing example within Photoshop to show some of the tools at work to create a piece.


Title:
HOW TO PAINT 2D GAME ART IN PS – STEP BY STEP TUTORIAL

By:
Blackthornprod


Youtube – Tutorial #3

Description:
Very quick example on some tips for drawing 2D game assets.


Title:
How To BLEND COLORS Like A Pro (For Beginners) | Photoshop Digital Painting Tutorial

By:

The Geek Artist


Youtube – Tutorial #4

Description:
Quick example of how to blend colors in Photoshop.


Title:
Lava Potion Game Asset Tutorial in Photoshop – full game design tutorial

By:
Jaysen Batchelor


Youtube – Tutorial #5

Description:
Tutorial for creating a 2D potion game asset in Photoshop.


Title:
Game Design Character in Photoshop – full character design art in Photoshop

By:
Jaysen Batchelor


Youtube – Tutorial #6

Description:
Tutorial for creating a 2D shadow creature game asset exploring character design in Photoshop.


Title:
Creature Game Design in Photoshop – Cute turtle creature tutorial

By:
Jaysen Batchelor


Youtube – Tutorial #7

Description:
Tutorial for creating a 2D turtle creature game asset exploring creature design in Photoshop.


Overview

Photoshop being one of the most used artistic softwares seemed like a good point to start exploring tutorial to use with my new Wacom tablet, so I compiled a lot of tutorials that seem good for getting me started. I’ve used it before, but not to the extent of actually drawing full assets, and I want to be able to draw out decent characters and creatures. I figure I will cover the basics again just to get comfortable with all the tools available, and I hope these tutorials are a good starting step for that as well as transitioning into learning how to actually apply these tools to get started making some solid sketches.

Tutorial #1 covers a lot of the tool basics, and Tutorial #4 with color blending was a good example of something I believe will be something I will like to explore extensively while getting started making creatures and characters, so those seem like strong basics coverage. The rest generally cover examples of making some kind of 2D art asset, and I will be using those as guides to show me how to use some of those tools to actually create the assets. Getting those examples from a few different sources can help show different approaches, but the final 3 are all from the same creator since they do just appear to be nice quick examples that I can grasp fairly quickly.

via Blogger http://stevelilleyschool.blogspot.com/2021/08/adobe-photoshop-introductory-tutorials.html

Coroutine Fundamentals in Unity

May 20, 2021

Coroutines

Unity


Title:
Introduction to Game Development (E21: coroutines)

By:
Sebastian Lague


Youtube – Tutorial #1

Description:
Covers the basics of coroutines in Unity.


Title:
Coroutines In Unity – What Are Coroutines And How To Use Them – Coroutines Unity Tutorial

By:
Awesome Tuts


Youtube – Tutorial #2

Description:
Covers some intermediate complexity uses of coroutines as well as tying them in with Invoke calls.


Title:
Coroutines – Unity Official Tutorials

By:
Unity


Youtube – Tutorial #3

Description:
Old official Unity tutorial on the fundamentals of coroutines in their system.


Overview

Coroutines appear to be a strong tool within Unity that I still am looking for ways to implement better in my systems. While understanding the basic uses for them with timing related events, I feel like they offer a lot more that I am not utilizing, so I wanted to further my understanding of them by following up on one of my older tutorial blogs and going through the tutorials it offers.

Tutorial #1 Notes

Coroutines are part of the Unity engine, and are not native to C#. They also belong to the Monobehaviour base class, so they class they are used in must inherit from Monobehaviour.

The coroutine return type is IEnumerator. Because of this, coroutines can also be stored in IEnumerator variables. This also allows them to be passed in as a paramter for the yield return statement within a Coroutine.

Use a reference to properly control the starting and stopping of a specific coroutine instance.

Tutorial #2 Notes

You can call a Coroutine from within itself (the same Coroutine). This is one way to cycle a Coroutine continously.

WaitForSecondsRealtime is similar to WaitForSeconds, except that WaitForSecondsRealtime is independent of Unity’s timescale. WaitForSeconds however is affected by the timescale. WaitUntil suspends the coroutine until the given delegate returns true.

Invoke Notes

  • Invoke – call a method after a given amount of time
  • InvokeRepeating – call a method every given amount of time, after a starting given time
  • CancleInvoke – stops an InvokeRepeating call

Tutorial #3 Notes

Coroutines are functions which execute in intervals. They work with special yield statements which return the code execution out of the function. Then, when the function continues, execution begins from where it left off.

Combining coroutines with properties can allow for efficient code which produces execution only when a value is changed, without the need to check for variable changes every frame with the Update() method or something similar.

Coroutine Return Statements

A substantial part of using and controlling coroutines is the various return statements you can use within them to determine when they should run and when they should pause execution. As such I listed several of these options and how they work within the coroutines.

yield return null

waits a frame before progressing to the next step

seems similar to the rate of the Update() method

yield return new WaitForSeconds(float time)

waits the given amount of seconds between each run of the process

yield return WaitForSecondsRealtime(float time)

waits the given amount of seconds, regardless of Unity’s timescale

yield return StartCoroutine(DoSomething())

waits until the given Coroutine “DoSomething” is finished running

yield return new WaitUntil(bool test)

suspends coroutine until the given parameter is true (opposite of WaitWhile)

yield return new WaitWhile(bool test)

suspends coroutine until the given paramter is false (opposite of WaitUntil)

Summary

Coroutines are starting to become a bit more clear to me, and this helped me learn a few more ways to incorporate them into my projects. Just seeing that they are specifically a Unity native concept was helpful to me as I did not think about that before, and that makes their somewhat strange nature make more sense in my head. This made it more clear that Unity is doing a lot of work behind the scenes to accomplish their main goals of determining when to start, pause, resume execution based on their yield values. Also the Unity note on tying them in with properties is very interesting and something I want to experiment with more myself for more efficient code.

via Blogger http://stevelilleyschool.blogspot.com/2021/05/coroutine-fundamentals-in-unity.html

Linear Algebra and Vector Math – Basics and Dot Product – by Looking Glass Universe

April 8, 2021

Linear Algebra

Vectors and Dot Product


Title:
Vector addition and basis vectors | Linear algebra makes sense


Youtube – Link #1

Description:
Introduction to this series and the basics of linear algebra and vectors.


Title:
The meaning of the dot product | Linear algebra makes sense


Youtube – Link #2

Description:
Deep dive into the dot product and what it represents and how to determine it.


Overview

I wanted to brush up on my vector math fundamentals, particularly with my understanding of the dot product and its geometric implications as it is something that comes up often in my game development path. While I am able to understand it when reading it and coding it for various projects, I wanted to build a more solid foundational understanding so that I could apply it more appropriately on my own. This video series has been very nice for refreshing my learning on these topics, as well as actually providing me a new way of looking at vector math that I think will really further my understanding in the future.

Video #1 – Vector addition and basis vectors

This was the introductory video to the series, and starts with vector addition. They then move on to linear combinations as an extension of basic vector addition. Next they show for 2D vectors that as long as you have two independent vectors, you can calculate any other vector using those two in some linear combination. This then relates to how vectors are normally written out, but they are simply using linear combinations of the standard orthonormal basis of something like x and y, or x, y, and z in 3D space.

This means a vector is simply 2 or 3 vectors created with the unit vector in the x, y, or z direction multiplied by some scalar and then summed up to create the resulting vector. This was actually a new way for me to look at vectors, as this is more intuitive when you are looking to create a new vector set to base vectors off of different from the standard x, y, z, but I never really thought to also apply it in the standard case. The x, y, z, or even i, j, k, became some standardized to me that I generally ignored them, but I think looking at them in this way will help make much more of linear algebra more consistent in my thinking space.

They then continue on to explain spans, spaces, and the term basis a bit more. A set of vectors can be called a span. If that span is all independent vectors, this indicates it is the smallest amount of vectors which can fully describe a space, and this is known as a basis. The number of basis elements is fixed, and this is the dimension of the space (like 2D or 3D). And for a given basis, any vector can only uniquely be defined in one linear combination of the basis vectors.

Video #2 – The meaning of the dot product

Dot Product

A really simple way of describing the dot product is that it shows “how much one vector is pointing in the same direction of another vector”. If those two vectors are unit vectors, the dot product of two vectors pointing the same direction is 1, two vectors that are perpendicular would have a dot product of 0, and two vectors pointing directly opposite directions would have a dot product of -1. This is directly calculated as the cosine of the angle between the two vectors.

However, the dot product also factors in the magnitude of the two vectors. This is important because it makes the dot product a linear function. This also ends up being more useful when dealing with orthonormal basis vectors, which are unit vectors (vectors of length 1) that define the basis of a space and are all orthogonal to each other.

They cover a question where a vector u is given in the space of the orthonormal vectors v1 (horizontal) and v2 (vertical) and ask to show what the x value of the u vector is (which is the scalar component of the v1 vector part of the linear combination making up the vector u) with the dot product and vectors u and v1. Since v1 is a unit vector, this can be done directly by just the dot product (u . v1). They then show that similarly the y component would just be the dot product (u . v2). They explain this shows the ease of use of using the dot product along with an orthonormal basis, as it directly shows the amount of each basis vector used in the linear combination to create any vector. This can also be explained as “how much of u is pointing in each of the basis directions”.

Since the dot product is linear, performing the dot product function on two vectors is the same whether done directly with those two vectors, or even if you break up one of the vectors before hand into a linear combination of other vectors and distribute it.



Example:

a . b = (x*v1 + y*v2) . b = x*v1 . b + y*v2 . b

Projecting a Vector onto Another Vector

They then cover the example I was very interested in, which is what is the length of the vector resulting in projecting vector A onto vector B in a general sense. The length, or magnitude, of this vector is the dot product divided by the magnitude of vector B. This is similar to the logic in the earlier example showing how vectors project onto an orthonormal basis, but since they had magnitudes of 1 they were effectively canceled out originally.

This then helped me understand to further this information to actually generate the vector which is the projection of vector A onto vector B, you then have to take that one step more by multiplying that result (which is a scalar) with the unit vector of B to get a vector result that factors in the proper direction. This final result ends up being the dot product of A and B, divided by the magnitude of B, then multiplied by the unit vector of B.



Example:

Projection vector C

C = (A . B) * ^B / ||B|| = (A . B) * B / ||B||^2

Dot Product Equations

They have generally stuck with the dot product equation which is:

a . b = ||a|| ||b|| cos (theta)



They finally show the other equation, which is:

a . b = a1b1 + a2b2 + a3b3 + …

But they explain this is a special case which is only true sometimes. It requires that the basis you are using is orthonormal. So this will generally be true in many standard cases, but it is important to note that it does require conditions to be met. This is because the orthonormal basis causes many of the terms to cancel out, giving this clean result.

via Blogger http://stevelilleyschool.blogspot.com/2021/04/linear-algebra-and-vector-math-basics.html

Intro to Unreal: Basics and Intro to Blue Prints

March 17, 2021

Intro and Blue Prints

Unreal


Title:
Unreal Engine 4 Complete Beginners Guide [UE4 Basics Ep. 1]

By:
Smart Poly


Youtube – Tutorial

Description:
A quick introduction to using the Unreal engine and just getting acquainted with the main editor window.


Title:
Unreal Engine 4 – Blueprint Basics [UE4 Basics Ep. 2]

By:
Smart Poly


Youtube – Tutorial

Description:
Quick introduction to using Unreal’s blueprints.


Title:
Unreal Gameplay Framework

By:
Unreal


Unreal – Link

Description:
Unreal Gameplay Framework, the official Unreal documentation.


Learning the Basics

It has been a while since I have used Unreal in any significant capacity, so I am going back to the basics to try and make sure I have all the fundamentals covered.

Tutorial #1

Moving/Positioning Objects

By default, Unreal has all the transformation functions snap. So moving an object, rotating it, and scaling it all occur in steps as opposed to smooth transforms. This can easily be changed in the top right of the viewport at any time.

Extra Camera Controls

F: focuses on object (like Unity)

Shift + move an object: Camera follows the moving object

You can directly change the camera speed in the top right of the viewport.

Adding Content Pack Later

If you find that you want to add the starter content to a project later than the start, this can easily be done through “Content” in the “Content Browser” window, then “Add New”, and choosing “Add Feature or Content Pack”. The starter content options will be one of the first to show up by default under the “Content Packs”.

Lighting Basics

“LIGHTING NEEDS REBUILT” Error Message

The static meshes want the lighting to be rebuilt when added so they are accounted for. Fixed with:

Go to: Build -> Build Lighting Only

Light Mobility Options

Lights by default have 3 mobility options: Static, Station, Movable

  • Static: can’t be changed in game; fully baked lighting
  • Station (Default): only shadowing and bounced lighting from static objects baked from Lightmass; all other lighting dynamic; movable objects have dynamic shadows
  • Movable: fully dynamic lighting, but slowest rendering speed

Tutorial #2

General Structure of Blue Prints

Components:

area where different components can be added

what allows you to place objects into the viewport of the blue print

this is where colliders are shaped to the proper size/shape


Details:

all the different details for this particular blue print


Event Graph:

this is the tab where visual scripting is majorly done


Function:

effectively contained event graphs with more specialized functionality


Variables:

representation of fields as you’d expect

Events

These are events which call the given functions when something in particular occurs. These functions are created within the blue print Event Graph.

Actions (Examples)

On Component Begin Overlap: occurs when something initially enters a collider
– Similar to Unity’s OnTriggerEnter

On Component End Overlap: occurs when something initially leaves a collider
– similar to Unity’s OnTriggerExit

E: occurs when the “E” key is pressed

Action: Timeline

Timeline:

allows you to visually create a graph of how a variable changes over a particular set of time

By default, the x-axis is the time and the y-axis is the variable value.
Points can be added as wanted to act as key frames for the variable.
Also allows for easy modifications to the interpolation between points, such as changing it from a line to a cubic interpolation by selecting multiple points.

Make sure to pay attention to the time Length set in the time line. Even if you didn’t put points somewhere in particular, if that is way longer than where your points are, you can get strange results since it will perform the action over the entire length of time.

Debugging Blue Prints

If you select Play from within the blue print, you can get a separate play window while leaving the blue print window visible. This can be helpful for example with the Event Graph, as you can actually see when different events occur according to the system and when inputs are read. This also shows the variables changing in some nodes, such as Timeline.

Classes (as covered by the Gameplay Framework Quick Reference)

Agents

Pawn

Pawns are Actors which can be possessed by a controller to receive input to perform actions.

Character

Characters are just more humanoid Pawns. They come with a few more common components, such as a CapsuleComponent for collision and a CharacterMovementComponent by default.

Controllers/Input

Controllers are Actors which direct Pawns. These are generally AIController (for NPC Pawns) and PlayerController (for player controlled Pawns). A Controller can “possess” a Pawn to control it.

PlayerController

the interface between a Pawn and the human player

AIController

simulated AI control of a Pawn

Display Information

HUD

Focused on the 2D UI on-screen display

Camera

The “eye” of a player. Each PlayerController typically has one.

Game Rules

GameMode

This defines the game, including things such as game rules and win conditions. It only exists on the server. It typically should not have much data that changes during play, and definitely should not have transient data the client needs to know about.

GameState

Contains the state of the game.
Some examples include: list of connected players, score, where pieces in a chess game are.
This exists on the server and all clients replicate this data to keep machines up to date with the current state.

PlayerState

This is the state of a participant in the game (which can be a player or a bot simulating a player). However, an NPC AI that exists as part of the game would NOT have a PlayerState.
Some examples include: player name, score, in-match level for a MOBA, if player has flag in a CTF game.
PlayerStates for all players exist on all machines (unlike PlayerControllers) and can replicate freely to keep machines in sync.

via Blogger http://stevelilleyschool.blogspot.com/2021/03/intro-to-unreal-basics-and-intro-to.html

Intro to Unreal: Basics Tutorial Compilation

March 16, 2021

Intro and Basics

Unreal


Title:
Unreal Engine 4 Complete Beginners Guide [UE4 Basics Ep. 1]

By:
Smart Poly


Youtube – Tutorial

Description:
A quick introduction to using the Unreal engine and just getting acquainted with the main editor window.


Title:
Unreal Engine 4 – Blueprint Basics [UE4 Basics Ep. 2]

By:
Smart Poly


Youtube – Tutorial

Description:
Quick introduction to using Unreal’s blueprints.


Title:
Unreal Engine 4 Beginner Tutorial: Getting Started

By:
DevAddict


Youtube – Tutorial

Description:
A more in depth intro to getting through the Unreal editor and starting to apply it to some general case uses.


Title:
Unreal Engine Beginner Tutorial: Building Your First Game

By:
Devslopes


Youtube – Tutorial

Description:
A good introduction focusing on building more of your own assets instead of using the Unreal given assets.


Title:
Unreal Engine 4.26 Beginner’s Tutorial: Make a Platformer Game

By:
DevAddict


Youtube – Tutorial

Description:
A large tutorial focusing on fleshing out the functionality of a given project and assets in Unreal.

Summary

This is a quick list of some Unreal tutorials just to get familiar with the engine. I listed them in order of a progression that I believe makes sense, where the first couple simply introduce the main Unreal editor and some of the tools it gives you, and the later tutorials start to implement those individual components to varying degrees. Some of these focus on using blue prints, while some focus on applying parameters to assets just through the Unreal editor directly. Finally, some of the tutorials near the end beging to show these tools making more complete systems and projects.

via Blogger http://stevelilleyschool.blogspot.com/2021/03/intro-to-unreal-basics-tutorial.html