Complete C# Unity Game Developer 2D
This course guides you through creating real games using Unity 2021.1 and Visual Studio Code, starting with the basics and gradually advancing to more complex projects.
You’ll begin by setting up your development environment, followed by building a “Delivery Driver” game to grasp game mechanics, methods, and Unity’s physics engine.
The course then transitions to a “Snow Boarder” game, introducing sprite shapes, effectors, and Cinemachine for dynamic camera movements, enriching your game development skills.
The “Quiz Master” section focuses on UI development, teaching you to work with canvases, TextMeshPro, and scriptable objects for data management.
In the “TileVania” project, you’ll dive into 2D sidescrolling platformers, exploring level design with Unity’s Tilemap and creating engaging animations and AI for a lively game experience.
Finally, the “Laser Defender” chapter covers building an arcade-style shooter game, where you’ll learn about the new Unity input system, scene management, and adding game polish with particle effects and sound.
This chapter ensures you understand game balance and preparation for publishing.
Throughout the course, you’ll have access to a supportive community and resources, keeping you engaged and overcoming any challenges.
C# Basics for Beginners: Learn C# Fundamentals by Coding
You’ll start by understanding the difference between C# and .NET, as well as the role of the Common Language Runtime (CLR) in executing .NET applications.
The course guides you through installing Visual Studio, Microsoft’s integrated development environment (IDE) for C#, and even introduces ReSharper, a popular plug-in that can boost your productivity.
The core concepts covered include variables, data types, operators, control flow statements (if/else, switch, loops), arrays, lists, strings, and working with dates and times using the DateTime and TimeSpan structures.
You’ll learn how to work with files and directories using the System.IO namespace, a crucial skill for any programmer.
One of the course’s strengths is its emphasis on writing clean, maintainable code.
You’ll learn about procedural programming, extracting reusable code into methods, and techniques like defensive programming and removing side effects to improve code reliability.
The course also covers debugging, a vital skill for any developer.
You’ll learn how to use Visual Studio’s debugging tools, set breakpoints, step through code, and inspect variable values using the call stack, locals, and autos windows.
Throughout the course, you’ll find numerous demos and live coding sessions that reinforce the concepts being taught.
The instructor also provides exercises with solutions, allowing you to practice and solidify your understanding.
Complete C# Unity Game Developer 3D
The course starts by walking you through setting up your development environment with Unity and Visual Studio Code.
You’ll learn core programming concepts like variables, methods, classes, and data structures through simple examples before diving into your first project - creating an obstacle course game.
This project teaches you how to use Unity’s physics system, handle user input, implement basic AI, and create visual effects like particle systems.
As you progress, you’ll build increasingly complex games like a rocket flying game, a rail shooter, and a tower defense game.
With each project, you’ll learn new skills such as using Unity’s animation system, pathfinding algorithms, creating UIs, handling audio, and optimizing performance.
The instructor does an excellent job of explaining concepts clearly and providing enough practice to solidify your understanding.
One of the highlights is the final project where you create a first-person shooter game complete with weapon switching, ammo pickups, enemy AI, and level design using ProBuilder.
You’ll even learn how to add post-processing effects and create decaying flashlight mechanics.
The course uses Unity’s latest version (2020.1 at the time of writing) and covers modern programming practices.
The instructor’s teaching style is clear, concise and direct, making it easy to follow along.
You’ll get plenty of hands-on coding experience as you build fun and engaging games from scratch.
C# Intermediate: Classes, Interfaces and OOP
You will start by learning about classes, the building blocks of OOP.
The course covers constructors, object initializers, methods, fields, access modifiers, properties, and indexers.
Next, you’ll explore the relationships between classes, including class coupling, inheritance, and composition.
The instructor emphasizes favoring composition over inheritance, a best practice in OOP.
Inheritance, the second pillar of OOP, is covered in-depth.
You’ll learn about access modifiers, constructors in inheritance, upcasting, downcasting, boxing, and unboxing.
The third pillar, polymorphism, is explained through method overriding, abstract classes and members, and sealed classes and members.
Interfaces, a crucial concept in OOP, are thoroughly discussed.
You’ll understand what interfaces are, how they promote testability and extensibility, and their role in polymorphism.
The course clarifies that interfaces are not for multiple inheritance.
Throughout the course, you’ll have access to source code and exercises to reinforce your learning.
The instructor, an experienced developer, will guide you through each topic.
After completing the course, you’ll be well-equipped to write maintainable, scalable, and robust C# code using OOP principles.
The course concludes with student code reviews for real-world examples like a stopwatch, stack, and workflow engine.
Complete C# Masterclass
You’ll start by learning the fundamentals, including data types, variables, and basic programming constructs like functions and decision-making statements.
The course then dives into object-oriented programming (OOP) concepts, covering classes, objects, inheritance, interfaces, and polymorphism.
You’ll gain hands-on experience working with collections, arrays, lists, dictionaries, and other data structures.
The course also covers essential topics like debugging, file handling, and regular expressions.
As you progress, you’ll explore advanced C# features such as delegates, events, lambda expressions, and LINQ for querying data.
The course introduces you to Windows Presentation Foundation (WPF) for building desktop applications with graphical user interfaces (GUIs).
You’ll learn about XAML, data binding, and various WPF controls like ListBox, ComboBox, and PasswordBox.
Additionally, you’ll work with databases, integrating SQL Server and implementing CRUD operations.
Moving forward, you’ll delve into multithreading and asynchronous programming with threads and tasks.
The course emphasizes test-driven development (TDD) and unit testing, equipping you with essential skills for writing robust and maintainable code.
Towards the end, you’ll embark on an exciting journey with Unity, a popular game development engine.
You’ll learn the basics of Unity, including player movement, physics, colliders, and prefabs.
You’ll then build games like Pong, a Zig Zag clone, and a Fruit Ninja clone, incorporating features like scoring systems, particle effects, and background music.
Throughout the course, you’ll work on practical projects, reinforcing your understanding of C# and its applications.
C# Advanced Topics: Prepare for Technical Interviews
You will start by learning about the instructor and how the course is organized, ensuring you have a clear understanding of the structure.
Moving on, you will dive into generics, delegates, lambda expressions, and events, which are fundamental concepts in C#.
The course also covers extension methods, LINQ, nullable types, and dynamic programming, equipping you with powerful tools for writing efficient and maintainable code.
Exception handling and asynchronous programming with async/await are covered in-depth, enabling you to write robust and responsive applications.
Throughout the course, you will encounter quizzes and exercises to reinforce your understanding of the concepts.
The course keeps you up-to-date by introducing the new features in C# 6, ensuring you stay ahead of the curve.
Additionally, you will receive guidance on what to learn next and access to additional resources to further enhance your skills as a developer.
The instructor provides access to the source code used in the course, allowing you to explore and experiment with the examples.
Design Patterns in C# and .NET
This course goes from the fundamental SOLID principles to specific patterns like Singleton, Builder, Factory, Adapter, and many more.
The course starts by laying the groundwork with SOLID design principles that promote good software design practices.
It then dives into creational patterns like Builder, Factory methods, Singleton, and Prototype to learn how to properly instantiate objects.
Next, you’ll explore structural patterns like Adapter, Bridge, Composite, Decorator, and Facade that help you compose objects into larger structures.
The syllabus also covers behavioral patterns such as Chain of Responsibility, Command, Iterator, Mediator, Observer, and State, which are useful for managing object behavior and control flow.
What stands out is the hands-on approach with coding exercises for each pattern, ensuring you get practical experience.
The lectures also cover advanced topics like the Interpreter pattern, dynamic proxies, and even functional patterns in F#.
While being technically in-depth, the course prioritizes clarity and simplicity.
The instructor avoids unnecessary jargon and explains concepts using concrete examples you can relate to.
You’ll learn not just how to implement patterns, but also when to use them and potential pitfalls to watch out for.
Unit Testing for C# Developers
You will start by learning the fundamentals of automated testing, including the benefits, types of tests, and the test pyramid.
Next, you’ll dive into the core unit testing techniques, covering how to test strings, arrays, collections, return types, void methods, exceptions, and events.
You’ll also learn best practices for naming and organizing tests, as well as writing trustworthy tests.
One of the key aspects of the course is breaking external dependencies.
You’ll learn how to write loosely-coupled and testable code, refactor towards a loosely-coupled design, and implement dependency injection via method parameters, properties, and constructors.
Additionally, you’ll explore mocking frameworks like Moq and learn state-based and interaction testing techniques.
The course includes several hands-on exercises to reinforce your learning, such as implementing FizzBuzz, DemeritPointsCalculator, and Stack.
You’ll also work on real-world projects like testing VideoService, InstallerHelper, EmployeeController, BookingHelper, and HouseKeeperHelper, where you’ll apply the concepts you’ve learned to refactor code for testability and write comprehensive unit tests.
Throughout the course, you’ll use tools like NUnit in Visual Studio and Rider for writing and running your tests.
You’ll also learn about Test-Driven Development (TDD) and its benefits.
RPG Core Combat Creator: Learn Intermediate Unity C# Coding
Right from the start, you’ll set up your development environment with the correct versions of Unity and Visual Studio Code.
The course wastes no time diving into the basics of moving a character using raycasting and the nav mesh system.
You’ll then implement basic combat mechanics like attacking enemies, taking damage, and animating the fighter.
The course deftly covers important programming concepts like the observer pattern, coroutines, and public interfaces along the way.
You’ll learn to separate concerns with a control layer and use namespaces to manage dependencies.
As you progress, you’ll design the high-level gameplay, fleshing out details in a game design document.
You’ll create intelligent enemy AI with patrol paths, chase behavior, and suspicion timers - all visualized with handy gizmos.
The course then guides you through crafting an engaging gameplay moment, leveraging Unity’s Cinemachine and Timeline to create a cinematic cut scene sequence.
You’ll explore scene management, asynchronous level loading, and fading transitions.
Leveling up your character’s stats becomes a core mechanic, introducing you to scriptable objects, serialization, and YAML data files.
You’ll implement a flexible modifier system for stats like damage and health.
The course even dives into multithreading concerns like race conditions and data hazards.
As you approach the finale, you’ll add polish with configurable cursors, damage text popups, and in-game UI like health bars.
You’ll integrate particle effects, sound, and refine the visual environment.
The course concludes by squashing bugs, tuning combat, and pushing your game’s overall quality.
Throughout, the examples are clear and concise, walking you through each step with helpful visuals and code samples.
The course maintains a conversational yet technical tone, effectively teaching Unity fundamentals while building a compelling RPG experience.
Xamarin Forms: Build Native Cross-platform Apps with C#
You’ll start by learning the fundamentals of Xamarin Forms, including setting up your development environment and creating your first app.
From there, you’ll dive into XAML essentials like data binding, dealing with device differences, and XAML compilation.
The course covers various layouts like StackLayout, Grid, AbsoluteLayout, and RelativeLayout, both in XAML and code.
You’ll learn how to work with images, from different sources like downloaded and embedded images, to handling sizes and creating rounded images.
The course also covers lists in depth, including populating basic lists, customizing cell appearance, grouping items, handling selections, and implementing features like pull-to-refresh and search bars.
Navigation is a crucial aspect covered, including hierarchical navigation, modal pages, master-detail pages, tabbed pages, carousel pages, and displaying popups.
You’ll also learn about forms and setting pages, covering controls like switches, sliders, steppers, entries, pickers, date/time pickers, and table views.
Data access is another important topic, covering application properties, file systems, SQLite integration, consuming RESTful services, and the INotifyPropertyChanged interface.
The course introduces the Model-View-ViewModel (MVVM) architectural pattern, explaining its benefits, extracting view models, handling dependencies, and implementing commands.
Beyond the basics, you’ll explore resource dictionaries, dynamic resources, styles, messaging centers, and managing events.
The course also touches on accessing common device functionality like contacts, camera, and geolocation.