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.

Format:

Book

Author/Creator:

Ferrone, Harrison, author.

Language:

English

Subjects (All):

Video games--Development.

Video games.

Video games--Programming.

Physical Description:

1 online resource (459 pages)

Edition:

7th ed.

Distribution:

London : Bloomsbury Publishing (UK), 2024.

Place of Publication:

Birmingham : Packt Publishing, 2022.

System Details:

text file HTML

Summary:

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!

Contents:

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

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

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

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

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

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

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

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

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

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

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

Pop Quiz Answers.

Other Books You May Enjoy

Index.

Other Format:

Print version: Ferrone, Harrison Learning C# by Developing Games with Unity

ISBN:

9781837637379

OCLC:

1419204710