product iamge

Learning C# by Developing Games with Unity: Get to grips with coding in C# and build simple 3D games in Unity 2022 from the ground up, 7th Edition

This document was uploaded by one of our users. The uploader already confirmed that they had the permission to publish it. If you are author/publisher or own the copyright of this documents, please report to us by using this DMCA report form.

Download
Search on Amazon

Simply click on the Download Book button.

Yes, Book downloads on Ebookily are 100% Free.

Sometimes the book is free on Amazon As well, so go ahead and hit "Search on Amazon"

Learn C# programming from scratch using Unity as a fun and accessible entry point with this updated edition of the bestselling series.

Includes invitation to join the online Unity Game Development community to read the book alongside peers, Unity developers/C# programmers and Harrison Ferrone.

Key Features

  • Develop a strong foundation of programming concepts and the C# language
  • Become confident with Unity fundamentals and features in line with Unity 2022
  • Build a playable game prototype in Unity―a working first-person shooter game prototype

Book Description

It's the ability to write custom C# scripts for behaviors and game mechanics that really takes Unity the extra mile. That's where this book can help you as a new programmer!

Harrison Ferrone, in this seventh edition of the bestselling series, will take you through the building blocks of programming and the C# language from scratch while building a fun and playable game prototype in Unity.

This book will teach you the fundamentals of OOPs, basic concepts of C#, and Unity engine with lots of code samples, exercises and tips to go beyond the book with your work.

You will write C# scripts for simple game mechanics, perform procedural programming, and add complexity to your games by introducing intelligent enemies and damage-dealing projectiles. You will explore the fundamentals of Unity game development, including game design, lighting basics, player movement, camera controls, collisions, and more with every passing chapter.

What you will learn

  • Understanding programming fundamentals by breaking them down into their basic parts
  • Comprehensive explanations with sample codes of object-oriented programming and how it applies to C#
  • Follow simple steps and examples to create and implement C# scripts in Unity
  • Divide your code into pluggable building blocks using interfaces, abstract classes, and class extensions
  • Grasp the basics of a game design document and then move on to blocking out your level geometry, adding lighting and a simple object animation
  • Create basic game mechanics such as player controllers and shooting projectiles using C#
  • Become familiar with stacks, queues, exceptions, error handling, and other core C# concepts
  • Learn how to handle text, XML, and JSON data to save and load your game data

Who this book is for

If you're a developer, programmer, hobbyist, or anyone who wants to get started with Unity and C# programming in a fun and engaging manner, this book is for you. You'll still be able to follow along if you don't have programming experience, but knowing the basics will help you get the most out of this book.

Table of Contents

  1. Getting to Know Your Environment
  2. The Building Blocks of Programming
  3. Diving into Variables, Types, and Methods
  4. Control Flow and Collection Types
  5. Working with Classes, Structs, and OOP
  6. Getting Your Hands Dirty with Unity
  7. Movement, Camera Controls, and Collisions
  8. Scripting Game Mechanics
  9. Basic AI and Enemy Behavior
  10. Revisiting Types, Methods, and Classes
  11. Specialized Collection Types and LINQ
  12. Saving, Loading, and Serializing Data
  13. Exploring Generics, Delegates, and Beyond
  14. The Journey Continues

Author(s): Harrison Ferrone
Edition: 7
Publisher: Packt Publishing
Year: 2022

Language: English
Pages: 458

Cover
Copyright
Contributors
Table of Contents
Preface
Chapter 1: Getting to Know Your Environment
Technical requirements
Getting started with Unity 2022
Using macOS
Creating a new project
Navigating the editor
Using C# with Unity
Working with C# scripts
Introducing the Visual Studio editor
Opening a C# file
Beware of naming mismatches
Syncing C# files
Exploring the documentation
Accessing Unity’s documentation
Locating C# resources
Summary
Pop quiz—dealing with scripts
Chapter 2: The Building Blocks of Programming
Defining variables
Names are important
Variables act as placeholders
Understanding methods
Methods drive actions
Methods are placeholders too
Introducing classes
A common Unity class
Classes are blueprints
Communication among classes
Working with comments
Single-line comments
Multi-line comments
Adding comments
Putting the building blocks together
Scripts become components
A helping hand from MonoBehaviour
Hero’s trial—MonoBehaviour in the Scripting API
Summary
Pop quiz—C# building blocks
Chapter 3: Diving into Variables, Types, and Methods
Writing proper C#
Debugging your code
Understanding variables
Declaring variables
Type and value declarations
Type-only declarations
Using access modifiers
Working with types
Common built-in types
Type conversions
Inferred declarations
Custom types
Naming variables
Understanding variable scope
Introducing operators
Arithmetic and assignments
Defining methods
Declaring methods
Naming conventions
Methods as logic detours
Specifying parameters
Specifying return values
Using return values
Hero’s trial—methods as arguments
Dissecting common Unity methods
The Start() method
The Update() method
Summary
Pop quiz—variables and methods
Chapter 4: Control Flow and Collection Types
Selection statements
The if-else statement
Using the NOT operator
Nesting statements
Evaluating multiple conditions
The switch statement
Pattern matching
Fall-through cases
Pop Quiz 1—if, and, or but
Collections at a glance
Arrays
Indexing and subscripts
Multidimensional arrays
Range exceptions
Lists
Accessing and modifying lists
Dictionaries
Working with dictionary pairs
Pop Quiz 2—all about collections
Iteration statements
for loops
foreach loops
Looping through key-value pairs
while loops
To infinity and beyond
Summary
Chapter 5: Working with Classes, Structs, and OOP
Introducing OOP
Defining classes
Instantiating class objects
Adding class fields
Using constructors
Declaring class methods
Declaring structs
Understanding reference and value types
Reference types
Value types
Integrating the object-oriented mindset
Encapsulation
Inheritance
Base constructors
Composition
Polymorphism
Applying OOP in Unity
Objects are a class act
Accessing components
Accessing components in code
Drag and drop
Summary
Pop quiz—all things OOP
Chapter 6: Getting Your Hands Dirty with Unity
A game design primer
Game design documents
The Hero Born one-pager
Building a level
Creating primitives
Thinking in 3D
Materials
White-boxing
Editor tools
Hero’s trial—putting up drywall
Keeping the hierarchy clean
Working with Prefabs
Lighting basics
Creating lights
Light component properties
Animating in Unity
Creating animations in code
Creating animations in the Unity Animation window
Recording keyframes
Curves and tangents
Summary
Pop quiz—basic Unity features
Chapter 7: Movement, Camera Controls, and Collisions
Managing player movement
Moving the player with the Transform component
Understanding vectors
Getting player input
Moving the player
Scripting camera behavior
Working with the Unity physics system
Rigidbody components in motion
Colliders and collisions
Picking up an item
Using Collider triggers
Creating an enemy
Hero’s trial—all the Prefabs!
Physics roundup
Summary
Pop quiz—player controls and physics
Chapter 8: Scripting Game Mechanics
Adding jumps
Introducing enumerations
Underlying types
Working with layer masks
Shooting projectiles
Instantiating objects
Adding the shooting mechanic
Managing object build-up
Creating a game manager
Tracking player properties
The get and set properties
Updating item collection
Creating a GUI
Displaying player stats
Win and loss conditions
Pausing and restarting the game with using directives and namespaces
Summary
Pop quiz – working with mechanics
Chapter 9: Basic AI and Enemy Behavior
Navigating 3D space in Unity
Navigation components
Setting up enemy agents
Moving enemy agents
Procedural programming
Referencing the patrol locations
Moving the enemy
Enemy game mechanics
Seek and destroy: changing the agent’s destination
Lowering player health
Detecting bullet collisions
Updating the game manager
Refactoring and keeping it DRY
Summary
Pop quiz—AI and navigation
Chapter 10: Revisiting Types, Methods, and Classes
Access modifiers
Constant and read-only properties
Using the static keyword
Revisiting methods
Overloading methods
ref parameters
out parameters
Intermediate OOP
Interfaces
Abstract classes
Class extensions
Namespace conflicts and type aliasing
Summary
Pop quiz—leveling up
Chapter 11: Specialized Collection Types and LINQ
Introducing stacks
Popping and peeking
Common methods
Working with queues
Adding, removing, and peeking
Using HashSets
Performing operations
Intermediate collections roundup
Querying data with LINQ
LINQ basics
Lambda expressions
Chaining queries
Transforming data into new types
Simplifying with optional syntax
Summary
Pop quiz—intermediate collections
Chapter 12: Saving, Loading, and Serializing Data
Introducing data formats
Breaking down XML
Breaking down JSON
Understanding the filesystem
Working with asset paths
Creating and deleting directories
Creating, updating, and deleting files
Working with streams
Managing your Stream resources
Using StreamWriter and StreamReader
Creating an XMLWriter
Automatically closing streams
Serializing data
Serializing and deserializing XML
Serializing and deserializing JSON
Data roundup
Summary
Pop quiz—data management
Chapter 13: Exploring Generics, Delegates, and Beyond
Introducing generics
Generic classes
Generic methods
Constraint type parameters
Adding generics to Unity objects
Delegating actions
Creating a debug delegate
Delegates as parameter types
Firing events
Creating and invoking events
Handling event subscriptions
Cleaning up event subscriptions
Handling exceptions
Throwing exceptions
Using try-catch
Summary
Pop quiz—intermediate C#
Chapter 14: The Journey Continues
Diving deeper
Remembering your object-oriented programming
Design patterns primer
Approaching Unity projects
Unity features we didn’t cover
Next steps
C# resources
Unity resources
Unity certifications
Hero’s trial—putting something out into the world
Summary
Pop Quiz Answers
Other Books You May Enjoy
Index