LC Exclusive: The Game Developer Dream Bundle Featuring Unity

3 Reviews
152 Enrolled
4 Courses & 154 Hours
$29.00$779.96
You save 96% -

What's Included

The Unreal Engine Developer Course: Learn C++ & Make Games
  • Certification included
  • Experience level required: All levels
  • Access 337 lectures & 59 hours of content 24/7
  • Length of time users can access this course: Lifetime

Course Curriculum

337 Lessons (59h)

  • First Section
    00. Promo Video1:46
    02. Welcome to the Course3:00
    03. A Note On Unreal Versions1:50
    04. Setup Visual Studio or XCode4:07
    05. Unreal Development Environment7:25
    06. Intro to Visual Studio 2015 on PC7:34
    07. Intro to Xcode on MacOS5:12
    08. How to Ask Good Questions10:58
    09. A Quick Tour of Unreal Editor9:46
    10. Section 1 Wrap-Up2:43
    11. Instructor Hangout5:19
  • Section 2
    01. Intro, Notes & Section 2 Assets3:03
    02. Bull Cow Game Overview5:33
    03. S02 Game Design Document (GDD)6:56
    04. How Solutions & Projects Relate11:09
    05. C++ Function Syntax7:53
    06. Using, #include and Namespaces11:34
    07. Magic Numbers and Constants7:21
    08. Variables and cin for Input10:00
    09. Using getline()5:03
    10. Simplifying With Functions11:42
    11. Iterating With For & While Loops8:08
    12. Mid Section Quiz4:52
    13. Clarity is Worth Fighting For10:19
    14. Booleans and comparisons11:33
    15. Using do and while in C++6:44
    16. Introducing Classes2:59
    17. Using Header Files as Contracts11:35
    18. Including Our Own Header File9:37
    19. Instantiating Your Class7:00
    20. Writing & Using Getter Methods9:00
    21. Introducing the Const Keyword6:20
    22. Constructors For Initialisation7:50
    23. Pseudocode Programming9:07
    24. Using using for Type Aliases9:41
    25. Using struct for Simple Types10:01
    26. Using if Statements in C++13:49
    27. Debugging 1017:39
    28. A Place for Everything7:06
    29. Introducing enumerations9:55
    30. Writing Error Checking Code9:17
    31. Using switch Statements11:57
    32. Warm Fuzzy Feelings6:31
    33. Handling Game Win Condition - Part 17:58
    34. Win or Lose "Screen"6:07
    35. Introducing Big O Notation11:49
    36. TMap and map Data Structures11:09
    37. Range-Based for Loop8:58
    38. Design a Helper Function8:47
    39. Playtesting Your Game7:59
    40. Difficulty & Play Tuning9:35
    41. Polishing & Packaging8:35
    42. Section 2 Wrap-Up1:17
  • Section 3
    01. Intro, Notes & Section 3 Assets2:12
    02. S03 Game Design Document (GDD)2:50
    03. Building Escape Overview4:35
    04. Version Control 1016:42
    05. Ignoring Unreal Derived Files8:45
    06. Your First .gitignore for Unreal11:27
    07. Getting to Know Unreal’s Editor8:23
    08. A Pointers Primer5:40
    09. Unreal’s Class System13:04
    10. Cloning and Building Our Code17:25
    11. Runtime Messages for Feedback7:18
    12. Accessing Object Names10:45
    13. Include What You Use For 4.17+16:37
    14. Getting Transforms in C++12:59
    15. Moving Objects With C++12:00
    16. Laying Out Geometry14:27
    17. Applying Materials8:38
    18. Macros Starting with UPROPERTY9:53
    19. Using Trigger Volumes10:14
    20. Unreal’s PlayerController10:27
    21. Using Collision Volumes9:41
    22. Using GetTimeSeconds()11:27
    23. Grabbing System Overview5:32
    24. Modifying the Default Pawn Actor7:28
    25. Inherit Game Mode Blueprint7:05
    26. Getting Player Viewpoint12:42
    27. Using DrawDebugLine12:10
    28. Line Tracing AKA Ray-Casting10:15
    29. LineTraceSingleByObjectType()12:03
    30. REFERENCES & POINTERS14:34
    31. Resetting Your Unreal Project6:40
    32. Using FindComponentByClass()8:59
    33. Introducing Input Binding12:08
    34. Accessors & Memory Layout9:25
    35. Reducing Code in “Hot Loops”13:50
    36. Using Physics Handles12:30
    37. Refactoring Rules12:25
    38. Introducing Unreal’s TArray12:07
    39. Iterating over TArray with for8:27
    40. Debugging Game Issues7:58
    41. Managing Texture Tiling8:49
    42. Pointer Protection Process11:34
    43. Exposing Events to Blueprint11:36
    44. Using Blueprint Timeline10:27
    45. Everything in its Place11:25
    46. Using Variables in Blueprint8:35
    47. SFX & Audio Clips6:30
    48. Section 3 Wrap-Up2:01
  • Section 4
    01. Intro, Notes & Section 4 Assets1:05
    02. Battle Tank Overview3:42
    03. Game Design Document (GDD)6:09
    04. Setting Up a GitHub “Repo”10:40
    05. Creating & Deleting Landscapes10:03
    06. Landscape Setup & Scaling12:15
    07. A Landscaping Process10:16
    08. Upgrading Engine Version5:48
    09. Using Landscape Layers12:11
    10. Flat Shading Low Poly Landscapes12:38
    11. More Landscaping Tools12:10
    12. Tank Control System7:32
    13. Actors from Multiple Meshes13:42
    14. Configuring a Tank9:13
    15. 3rd Person Camera Control14:16
    16. Fixing 3rd Person Camera Rotation8:06
    17. User Interface (UI) in Unreal9:18
    18. Main Menu Screens9:02
    19. UI Scale Box, Buttons & Mouse11:13
    20. Controller Ready Navigation8:25
    21. Trial Packaging Your Game7:08
    22. Delegating to Components11:20
    23. Using Virtual And Override14:04
    24. Overloading and Polymorphism14:27
    25. Virtual Functions and Vtables11:20
    26. Creating an AI Controller Class10:56
    27. Get the Player Controller with C++9:35
    28. Add Tick() to PlayerController11:50
    29. Creating an Out Parameter Method12:09
    30. Finding Screen Pixel Coordinates13:48
    31. Using DeprojectScreenToWorld12:49
    32. Using LineTraceSingleByChannel()15:24
    33. Unify Player & AI Aiming10:36
    34. Create Default Sub Objects in C++12:07
    35. BlueprintCallable()13:04
    36. SuggestProjectileVelocity()11:53
    37. Predict Projectile Landing Point12:16
    38. Using FRotators in Unreal10:58
    39. The C++ Compilation Process7:26
    40. Using Forward Declarations12:37
    41. BlueprintSpawnableComponent()10:56
    42. Review Our Execution Flow13:35
    43. How to Report Bugs10:47
    44. Using Clamp() to Limit Values14:18
    45. CHALLENGE - Turret Rotation12:44
    46. CHALLENGE - Turret Rotation Pt.2
    47. Setting Up Projectiles10:34
    48. Upgrading to Unreal 4.1211:04
    49. Working Round Awkward Bugs13:56
    50. Using SpawnActor() to Spawn11:36
    51. Projectile Movement Components11:10
    52. Making AI Tanks Fire10:30
    53. EditAnywhere vs EditDefaultsOnly8:37
    54. Adding a Quit Button11:05
    55. Setup Track Throttles12:31
    56. ApplyForceAtLocation() in Action12:03
    57. Physics Materials & Friction14:16
    58. Fly-by-Wire Control System8:50
    59. Using BlueprintReadOnly12:46
    60. A Better Component Architecture12:04
    61. Completing Manual Tank Movement11:09
    62. Introducing AI Pathfinding12:03
    63. Dissecting RequestDirectMove()12:29
    64. DotProduct() Vector Operator12:30
    65. CrossProduct() Vector Operator13:42
    66. Finalising Your Class Code9:28
    67. How to Use Blueprint Variables10:10
    68. Using Enum(erations) in UE412:06
    69. Refactoring our Aiming Component14:52
    70. Attaching a Debugger to Unreal7:22
    71. Constructor & Begin Play Timing11:58
    72. Decoupling Your Architecture9:01
    73. BlueprintImplementableEvent11:57
    74. Using the ensure Assertion9:32
    75. Dependency Mapping9:53
    76. Talking Head - Real World Skills2:29
    77. Starting From Green11:10
    78. Aiming Without the Tank13:57
    79. Finishing our Refactoring14:04
    80. Adding TickComponent() Back13:06
    81. Are Two Floats Equal?11:39
    82. Programmatic Sideways Friction15:18
    83. OnComponentHit Event in 4.128:36
    84. Avoiding Boolean Flags13:18
    85. Improving Tank Aiming11:23
    86. Tweaking Tank AI12:14
    87. Making an Ammo Display14:23
    88. Making an AutoMortar14:10
    89. Using the Reference Viewer14:10
    90. Preparing for Particles13:22
    91. Introducing Particle Systems15:54
    92. Particle Bounding Boxes6:37
    93. Using FAttachmentTransformRules16:26
    94. Radial Forces & Caching14:20
    95. Using GetTimerManager()10:15
    96. Using TakeDamage() on Actors15:47
    97. BlueprintPure & Health Bars14:09
    98. The Observer Pattern14:19
    99. Finishing Off - Part 114:35
    100. Finishing Off - Part 215:47
    101. Section 4 Wrap-Up3:14
    102. Bonus - Switching Cameras6:35
    103. Fixing The Tank Suspension2:21
    104. Upgrade to 4.19 And Bug Fixes13:07
    105. Real-world Vehicle Physics8:51
    106. Creating Physics Constraints15:45
    107. Making Springs15:32
    108. Converting The Spring To C++11:55
    109. Attachment, Actors and Components13:31
    110. SpawnActorDeferred and BeginPlay7:14
    111. Attaching Constraints In C++13:09
    112. Chaining Physics Constraints15:42
    113. Applying Wheel Driving Force11:29
    114. Solution: Implement GetWheels()10:26
    115. Tick Groups And Physics18:20
    116. Tweaking Linear & Angular Damping11:56
    117. BONUS: Fixing Collider Issues3:21
    New Lecture
  • Section 5
    01. Testing Grounds Introduction2:21
    02. Testing Grounds GDD5:24
    03. Using Git LFS (Large File Support)15:46
    04. Marketing & Markdown13:39
    05. Use git clean to Revert Project11:27
    06. The First Person Character7:33
    07. The Third Person Character9:35
    08. Introducing AI Behaviour Trees8:54
    09. Introducing AI Blackboard Data10:14
    10. Target Points and Patrol Routes9:14
    11. Using Any Actor for Waypoints12:42
    12. Options for Grouping Actors8:57
    13. Blueprint Behaviour Tree Tasks14:31
    14. Modular Arithmetic & Cycles12:45
    15. Performance Profiling 1019:22
    16. C++ AI Behaviour Tree Tasks12:19
    17. Reading Blackboard Data in C++9:35
    18. The Consequences of Inheritance8:36
    19. Converting Blueprint to C++12:52
    20. Composition over Inheritance13:41
    21. Talking Head: What We've Covered So Far1:34
    22. How to Delete a C++ Class5:06
    23. Instanced Materials10:52
    24. Introducing AI Perception10:50
    25. OnTargetPerceptionUpdated Event9:47
    26. Setting Up Hearing8:38
    27. The Animation Starter Pack12:06
    28. Changing a Character’s Animation11:16
    29. Customising a Character Blueprint8:27
    30. Sub Behaviour Trees8:47
    31. Talking Head - Introducing Sam0:35
    32. Talking Head - Refactoring Superpowers1:43
    33. Simplifying Our Project17:34
    34. Renaming & Moving CPP13:37
    35. Solution: Renaming & Moving CPP9:44
    36. Holding a Gun with Skeletal Sockets14:25
    37. Understanding Animation Blueprints11:03
    38. Creating Animation State Machines14:04
    39. Movement Blend Spaces16:11
    40. Offset Animations18:04
    41. Aiming Blend Spaces Offsets6:19
    42. Rotating with SetFocalPoint()9:47
    43. Character Movement vs Rotation16:19
    44. Control Rotation for Aim11:59
    45. Behaviour Tree Decorators11:32
    46. Behaviour Tree Services12:56
    47. Tweaking AI Behaviour5:21
    48. Debugging AI Behaviour14:39
    49. Refactoring to a Gun Actor15:29
    50. Attaching Actors to Components13:03
    51. Configuring the Gun9:48
    52. Moving Files from LFS to Git13:50
    53. To LFS or Not to LFS?13:42
    54. Child Actor Components8:18
    55. IIntroduction to Inverse Kinematics6:50
    56. Inverse Kinematics with Animations10:21
    57. Comparing Blueprints with Diffs10:50
    58. Boolean Blending for Aim States10:47
    59. Adding Firing Animations7:57
    60. Animation Notify Events10:24
    61. Taking Damage in Blueprint6:44
    62. Death Animations and Refactors9:55
    63. Switching 1st and 3rd Person8:13
    64. Owner Invisible Meshes9:18
    65. Separating Firing from Gun Meshes9:42
    66. Aiming Our 1st Person Camera5:44
    67. Architecture of Infinite Runners11:09
    68. Spawning Terrain in the GameMode10:09
    69. Level Gating for Testing Grounds13:13
    70. Swapping Materials in Blueprint9:31
    71. Garbage Collecting Previous Tiles8:10
    72. Merging Our TP and FP Files17:30
    73. Hit vs Overlap Events11:12
    74. Dynamically Calculating NavMesh12:56
    75. Keep It Simple Stupid10:59
    76. Parallel Behaviour Tree Tasks17:47
    77. Custom BT Tasks and Decorators16:40
    78. External Build Data in 4.14+9:43
    79. Physical Gun Architecture18:43
    80. Converting a Character BP to C++17:36
    81. Who’s Pulled the Trigger?17:18
    82. Cooldown Nodes & Gameplay Tags16:25
    83. Animation Montages and Slots18:06
    84. Reattaching the Gun20:01
    85. Procedural Level Generation20:33
    86. Generating Random Numbers19:00
    87. Spawning Actors in the Tile15:47
    88. Tempelate Specilization15:51
    89. Post Processing for Tunnel Vision11:32
    90. Spawning into Free Space16:35
    91. Randomising Rotation & Scale17:21
    92. Possessing and the View Target18:03
    93. Choosing Waypoint with EQS14:17
    94. Find Actors of Type from C++19:33
    95. Plumbing an Actor Pool Setup19:13
    96. Using the Pool API19:00
    97. Using TArray for Pools10:53
    98. Rebuilding Navigation Meshes15:30
    99. Structs to Simplify Function Args18:20
    100. Spawning AI from C++14:10
    101. Understanding Function Templates10:39
    102. Template Specialization9:55
    103. Spawning Actors in The Tile12:40
    104. Fixing Double Spawning17:18
    105. Using the HUD Class12:39
    106. Post Processing For tunnel Vision10:39
    107. Recruiting Play Testers14:41
    108. Smooth Blending the Camera11:25
    109. Processing and The View Target10:36
    110. Choosing Waypoint with EQS17:52
    111. Testing Grounds Wrap-up1:46

The Unreal Engine Developer Course: Learn C++ & Make Games

BT
Ben Tristem

Instructor

GameDev.tv was created by best-selling instructor Ben Tristem to help anyone learn how to develop, design, and sell indie games. Its team supports Ben in making and maintaining high quality courses that are engaging and entertaining for its students. GameDev.tv offers comprehensive courses on Unity, Blender, Unreal and coding in C#, C++ and more.

Description

If you're keen on becoming a bona fide game developer, you'll want to get familiar with Unreal Engine, the free-to-use development platform behind some of gaming's biggest hits, like Fortnite Battle Royale. Led by renowned game dev instructor Ben Tristem, this course will help you make your first 4 video games in Unreal Engine. You'll start by learning C++ from scratch, explore essential coding and design principles, and work toward creating several projects, including a tank game and first-person shooter!

  • Access 337 lectures & 59 hours of content 24/7
  • Learn how to create & mod video games using Unreal Engine 4
  • Walk through building several game projects
  • Take on the basics of coding & game development
  • Learn C++ from scratch
  • Access a free community site to share games & 3D models and connect w/ other students

Specs

Important Details

  • Length of time users can access this course: lifetime
  • Access options: web and mobile streaming
  • Certification of completion included
  • Redemption deadline: redeem your code within 30 days of purchase
  • Experience level required: all levels

Requirements

  • Internet required

Terms

  • Unredeemed licenses can be returned for store credit within 30 days of purchase. Once your license is redeemed, all sales are final.