book

Learning C# Programming with Unity 3D, second edition, 2nd Edition

Name: Learning C# Programming with Unity 3D, second edition, 2nd Edition
Author: Alex Okita
ISBN: 9780429810268

by Alex Okita

September 2019

Intermediate to advanced

690 pages

23h 12m

English

A K Peters/CRC Press

Read now

Unlock full access

Cover
Half Title
Title Page
Copyright Page
Table of Contents
1. Introduction: What This Book Is About
1.1 Why Read a Book: Why This Book May or May Not Be for You1.1.1 Do I Need to Know Math?1.1.2 Programming as a Form of Expression1.1.3 Games as a Stage with Lights1.2 Personal Information1.3 A Brief History of Computer Programming: How Programming Came to Be1.3.1 Mechanical Computers1.3.2 Logic1.3.3 Computer Science 1.3.4 The Origin of Software1.3.5 Modern Computer Language1.3.6 The Future of Computer Languages1.4 C#: A Flexible Programming Language1.4.1 C# Paradigm1.4.2 Unity 3D: A Brief History of Game Engines1.4.3 Why Use Unity 3D to Learn?1.4.4 How Does Unity 3D Use C#? 1.4.4.1 How to Tell Unity 3D What to Do1.5 What Is Programming?1.5.1 What Does C# Look Like? 1.5.2 Learning to Copy and Paste1.5.3 Iteration1.6 Compiling: Turning Words into Computer Instruction 1.7 What We’ve Learned1.8 Leveling Up: The Path Ahead
2. Before You Begin
2.1 What Will Be Covered in This Chapter2.2 Unity 3D Installation 2.2.1 Visual Studio Installation2.2.2 Unity Version Numbering2.3 Git SCM Installation2.3.1 Git-SCM.com Git Software (Optional)2.3.2 GitHub.com Sign Up! (Also Optional)2.3.3 Git: The Basics2.3.4 Your First Repo 2.3.5 Before Moving On 2.4 Unity General Overview 2.4.1 The Main Window2.4.1.1 Toolbar 2.4.1.2 Scene, Game View, and Asset Store2.4.1.3 Hierarchy Panel 2.4.1.4 Inspector Panel 2.4.1.5 Project and Console Panel2.4.1.6 Assets Directory 2.4.1.7 Project Settings Directory 2.4.1.8 Packages Directory2.4.2 Git Ignore 2.4.3 What We’ve Learned 2.5 Sample Code 2.5.1 Code Fragments 2.5.2 Are Errors Bad? 2.5.2.1 Compile-Time and Run-Time Errors2.5.3 How to Follow Along 2.5.4 Comments: A First Look 2.5.5 What We’ve Learned 2.6 Working with C#: Game Engines2.6.1 Creating and Assigning a New C# File: Now It’s Your Turn 2.6.2 Naming Your New File 2.6.3 Using Your New File2.6.4 Additional Unity 3D Tools 2.6.5 Working in a Live Scene 2.6.6 Saving a Scene 2.6.7 Opening a Scene 2.6.8 What We’ve Learned 2.7 Leveling Up: The Journey Has Just Begun
3. First Steps: Just Getting Started
3.1 What Will Be Covered in This Chapter3.2 Review3.2.1 Submitting Changes to Git3.3 Let’s Build a Game—Part 13.3.1 Movement Experiments 3.3.2 Reading Programmer Documentation 3.4 Tokens 3.4.1 Writing C#3.4.2 Comments a First Look3.4.3 Separator Tokens 3.4.4 Operator Tokens3.4.5 Literals 3.4.6 Transitive and Non-Transitive Operations 3.4.7 Putting It All Together3.4.8 What We’ve Learned3.5 Statements and Expressions 3.5.1 Expressions 3.5.2 How Unity 3D Executes Your Code3.5.3 Thinking in Algorithms3.5.3.1 Wash, Rinse, Repeat 3.5.4 What We’ve Learned 3.6 Keywords 3.6.1 The Class Keyword 3.6.2 What We’ve Learned 3.7 White Space 3.7.1 Code Style3.7.2 What We’ve Learned 3.8 Code Blocks3.8.1 What We’ve Learned 3.9 Classes: A First Look3.9.1 Objects3.9.2 What We’ve Learned 3.10 Variables3.10.1 Identifiers3.10.2 Data 3.10.3 Variable Manipulation 3.10.3.1 Declaration Placement Examples 3.10.4 Dynamic Initialization3.10.5 What We’ve Learned 3.11 Variable Names3.11.1 Useful Variables in Unity 3D3.11.2 Variable Assignment 3.11.3 Putting It Together: Using the Variables3.11.4 What We’ve Learned 3.12 Types: A First Look 3.12.1 Value and Reference Types 3.12.2 What We’ve Learned 3.13 Strong Typing3.13.1 Dynamic Typing 3.13.2 What We’ve Learned 3.14 Type Casting, Numbers 3.14.1 Explicit versus Implicit Casting 3.14.1.1 A Basic Example 3.14.2 What We’ve Learned 3.15 Comments 3.15.1 Line Numbers3.15.2 Code Folding 3.15.3 Summary Comments 3.15.4 Navigating in Code 3.15.5 What We’ve Learned 3.16 Leveling Up: Moving on to Basics 3.16.1 Git Revision History
4. Basics: The Building Blocks of Code
4.1 What Will Be Covered in This Chapter4.2 Review 4.3 Building a Game—Part 1 4.3.1 Mouse Point 4.3.2 Move to Point 4.3.3 What We’ve Learned 4.4 Class Construction 4.4.1 Class Declaration4.4.1.1 A Basic Example 4.4.1.2 Value and Reference Types 4.4.2 Adding Data Fields 4.4.3 Access Modifiers and the Dot Operator4.4.4 Class Scope 4.4.5 Class Members4.4.6 What We’ve Learned 4.5 Directives 4.5.1 Libraries4.5.2 Ambiguous NameSpaces4.5.3 What We’ve Learned 4.6 Functions4.6.1 What Are Functions? 4.6.2 Unity 3D Entry Points 4.6.3 Writing a Function 4.6.4 More on White Space and Tabs4.6.5 What We’ve Learned 4.7 Order of Operation: What Is Calculated and When 4.7.1 Evaluating Numbers 4.7.1.1 Math4.7.1.2 Operator Evaluation4.7.2 What We’ve Learned 4.8 Scope: A First Look 4.8.1 Class Scope4.8.2 Function Scope 4.8.3 Blank Scope4.8.4 What We’ve Learned 4.9 This 4.9.1 A Basic Example 4.9.2 When This Is Necessary4.9.3 What We’ve Learned4.10 Building a Game—Part 2 4.10.1 Additional Components4.10.2 The Projectile4.10.3 The Target4.10.4 What We’ve Learned 4.11 Logic and Operators 4.11.1 Booleans 4.11.2 Equality Operators4.11.3 Logical Not!4.11.4 Greater and Less than Operators4.11.5 Logical And and Or Operators4.11.6 If and Branching 4.11.7 What We’ve Learned 4.12 Loops 4.12.1 Unary Operators 4.12.2 While 4.12.3 For4.12.4 Do-While 4.12.5 Postfix and Prefix Notation4.12.6 Using Loops4.12.7 Loops within Loops4.12.8 Runaway Loops 4.12.9 Breakpoints: A First Look4.12.10 What We’ve Learned4.13 Scope\Again4.13.1 Visibility or Accessibility 4.13.1.1 A Basic Example 4.13.2 Global Scope4.13.3 What We’ve Learned 4.14 Warnings versus Errors 4.14.1 Warnings 4.14.2 Errors 4.14.3 Understanding the Debugger 4.14.4 What We’ve Learned 4.15 Leveling Up: Fundamentals4.15.1 Style Guides
5. Fundamentals: Building a Foundation
5.1 What Will Be Covered in This Chapter5.2 Review5.2.1 Modular Code5.3 Inheritance: A First Look 5.3.1 Class Members5.3.1.1 Inheriting Members 5.3.1.2 Is-A and Has-A 5.3.2 Instancing5.3.3 Parent Child 5.3.4 Object 5.3.4.1 A Type Is Not an Object5.3.5 != null5.3.6 What We’ve Learned 5.4 Instancing5.4.1 Class Initialization 5.4.2 New 5.4.3 Constructors 5.4.4 What We’ve Learned 5.5 Static 5.5.1 A Basic Example5.5.2 Static Variables 5.5.2.1 A Basic Example5.5.3 Static Functions5.5.4 Putting It All Together 5.5.5 What We’ve Learned 5.6 Building A Game—Part 3 5.6.1 The Player 5.6.2 The Mover 5.6.3 The Shooter 5.6.4 Physics Settings5.6.5 What We’ve Learned 5.7 Jump Statements and Return 5.7.1 Return5.7.1.1 A Basic Example5.7.2 Returning Objects 5.7.3 A Class Is a Type 5.7.4 Tuples 5.7.5 Null Is Not Void 5.7.6 What We’ve Learned 5.8 Arrays: A First Look5.8.1 Fixed-Sized Arrays 5.8.1.1 A Basic Example5.8.2 Foreach5.8.2.1 A Basic Example5.8.3 Dynamic Initialization5.8.4 Using the While Loop with Arrays5.8.4.1 Setting Array Values5.8.4.2 Getting Array Values5.8.5 What We’ve Learned 5.9 Jump Statements: Break and Continue 5.9.1 A Basic Example5.9.1.1 Continue 5.9.2 ZombieData5.9.3 Foreach Again 5.9.4 What We’ve Learned 5.10 Multidimensional Arrays 5.10.1 Columns and Rows5.10.1.1 A Basic Example 5.10.2 A Puzzle Board 5.10.3 Camera and Screen Setup 5.10.4 Checking Range 5.10.5 What We’ve Learned 5.11 Array List5.11.1 A Basic Example5.11.2 ArrayList.Contains() 5.11.3 Remove5.11.4 Sort and Reverse 5.11.5 What We’ve Learned 5.12 Strings 5.12.1 Declaring a String 5.12.1.1 A Basic Example 5.12.2 Escape Sequences 5.12.3 Verbatim Strings: @5.12.4 What We’ve Learned 5.13 Combining What We’ve Learned 5.13.1 Timers 5.13.2 What We’ve Learned 5.14 Leveling Up: On to the Cool Stuff

6. Intermediate: The Tricks of the Trade
6.1 What Will Be Covered in This Chapter6.2 Review 6.2.1 Class Members6.2.1.1 A Basic Example6.2.1.2 Thinking Like a Programmer 6.2.2 Return6.2.2.1 A Basic Example 6.2.3 Arguments aka “Args” (Not Related to Pirates)6.2.3.1 The Basic Example 6.2.3.2 Multiple Args6.2.3.3 Using Args 6.2.4 Assignment Operators6.2.4.1 A Basic Example 6.2.5 What We’ve Learned6.3 Building a Game—Part 4 6.3.1 ChaseCamera 6.3.2 Tile Floor Generator 6.3.3 What We’ve Learned 6.4 Class Constructors 6.4.1 A Basic Example6.4.2 What We’ve Learned 6.5 Arrays Revisited 6.5.1 Using Arrays in Unity 3D 6.5.1.1 Starting with 06.5.1.2 Mathf6.5.1.3 Time 6.5.2 Instancing with AddComponent();6.5.3 Type Casting Unity 3D Objects 6.5.4 What We’ve Learned 6.6 Enums 6.6.1 Using Enums 6.6.2 Combining What We’ve Learned 6.6.3 What We’ve Learned 6.7 Switch 6.7.1 A Basic Example6.7.2 Default6.7.3 More On Cases6.7.4 Fall Through 6.7.5 goto Case6.7.6 Finite State Machine 6.7.7 What We’ve Learned6.8 Structs6.8.1 Structs 6.8.2 Struct versus Class6.8.3 Without Structs 6.8.4 Handling Structs6.8.5 Accessing Structs6.8.6 Global Access 6.8.7 What We’ve Learned 6.9 Class Data 6.9.1 Character Base Class 6.9.2 Const 6.9.3 Readonly 6.9.4 What We’ve Learned 6.10 Namespaces 6.10.1 A Basic Example6.10.2 Directives in Namespaces6.10.3 Ambiguous References6.10.4 Alias Directives6.10.5 What We’ve Learned 6.11 Functions Again6.11.1 Parameter Lists 6.11.2 Side Effects6.11.3 Multiple Arguments 6.11.4 Useful Parameters6.11.4.1 The Rule of Three6.11.5 Foreach versus For6.11.6 What We’ve Learned6.12 Unity 3D Execution Order 6.12.1 A Basic Example6.12.2 Component Execution Order 6.12.3 What We’ve Learned 6.13 Inheritance Again 6.13.1 Function Overrides 6.13.1.1 A Basic Example 6.13.2 Class Inheritance6.13.2.1 Sharing Common Attributes 6.13.3 Object 6.13.4 What We’ve Learned 6.14 Type Casting Again 6.14.1 (<Type>) versus “as” 6.14.2 User-Defined Type Conversion6.14.3 Implicit versus Explicit Type Conversion6.14.4 What We’ve Learned
6.15 Working with Vectors
6.15.1 Vectors Are Objects6.15.2 Stepping through MonsterGenerator6.15.3 Gizmos6.15.3.1 A Basic Example6.15.3.2 DrawRay6.15.4 Using Gizmos6.15.5 What We’ve Learned 6.16 goto Labels6.16.1 Skipping Down 6.16.2 Zombie State Machine 6.16.3 This as a Reference to Yourself 6.16.4 Just for Zombies 6.16.5 What We’ve Learned 6.17 More on Arrays 6.17.1 Length and Count6.17.1.1 A Basic Example 6.17.2 Foreach: A Reminder 6.17.3 Discovery 6.17.4 Putting It Together 6.17.4.1 Breakpoint, Observing Inheritance6.17.5 What We’ve Learned6.18 Out Parameter6.18.1 A Basic Example6.18.2 Simple Sort (Bubble Sort)6.18.3 Simple Sort Proof6.18.4 What We’ve Learned6.19 Ref Parameter 6.19.1 A Basic Example6.19.2 Code Portability Side Effects6.19.3 What We’ve Learned6.20 Type Casting Numbers 6.20.1 Number Types 6.20.2 Integers6.20.2.1 Signed Numbers 6.20.3 Floating Point 6.20.4 What We’ve Learned 6.21 Types and Operators 6.21.1 GetType() 6.21.2 More Type Casting6.21.3 Type Aliasing 6.21.4 Boxing and Unboxing 6.22 Operator Overloading 6.22.1 A Basic Example6.22.2 Overloading*6.22.3 Overloading < and > 6.22.4 What We’ve Learned 6.23 Controlling Inheritance 6.23.1 Sealed 6.23.1.1 A Basic Example 6.23.2 Extension Functions 6.23.3 Abstract 6.23.3.1 A Basic Example 6.23.4 Abstract: Abstract 6.23.5 Putting This to Use 6.23.6 What We’ve Learned 6.24 Building A Game—Part 56.24.1 Generating Rooms 6.24.2 What We’ve Learned 6.25 Leveling Up
7. Advanced
7.1 What Will Be Covered in This Chapter7.2 Review 7.2.1 Moving Forward 7.3 Visual Studio 7.3.1 The Debugger7.3.2 Mono History 7.4 Function Overloading 7.4.1 A Closer Look at Functions7.4.1.1 A Basic Example7.4.2 Function Signature 7.4.3 Different Signatures7.4.4 Putting It Together7.4.5 Not Quite Recursion7.4.6 DrawWords7.4.7 What We’ve Learned7.5 Accessors (or Properties) 7.5.1 Value 7.5.1.1 A Basic Example7.5.2 Set Event7.5.3 Read-Only Accessor 7.5.4 Simplification7.5.5 What We’ve Learned 7.6 Base Classes: Another Look7.6.1 Generalization—Base Classes7.6.2 Specialization7.6.3 Base7.6.4 Partial7.6.5 Protected, Private, and Public7.6.6 What We’ve Learned7.7 Optional Parameters7.7.1 Using Optionals7.7.1.1 A Basic Example7.7.2 Optional Arguments 7.7.3 Named Parameters7.7.3.1 A Basic Example 7.7.4 Combining What We’ve Learned 7.7.5 What We’ve Learned 7.8 Delegate Functions7.8.1 Delegates7.8.1.1 A Basic Example7.8.2 Delegate Signatures7.8.3 Stacking Delegates 7.8.4 Using Delegates7.8.5 Updating Delegates 7.8.6 What We’ve Learned 7.9 Interface 7.9.1 Early Planning7.9.1.1 A Basic Example7.9.1.2 Using Accessors 7.9.2 Multiple Interfaces7.9.3 IComparer 7.9.4 Using IComparer 7.9.5 What We’ve Learned 7.10 Class Constructors Revisited7.10.1 A Basic Example7.10.2 When to Create a New Class7.10.3 What We’ve Learned7.11 Preprocessor Directives7.11.1 A Basic Example7.11.2 UNITY_EDITOR7.11.3 Mobile Development 7.11.4 Warning7.11.5 Organizing 7.11.6 What We’ve Learned 7.12 Try Catch Finally 7.12.1 A Basic Example7.12.2 Exception Messages 7.12.3 Custom Exceptions 7.12.4 Finally 7.12.5 Try-Catch and Finally in Use7.12.6 What We’ve Learned7.13 IEnumerator 7.13.1 Enumeration7.13.1.1 A Basic Example7.13.1.2 What Doesn’t Work 7.13.2 Implementing IEnumerator7.13.3 What We’ve Learned7.14 Generics 7.14.1 Generic Functions 7.14.1.1 A Basic Example 7.14.1.2 Why T?7.14.2 Making Use of Generic Functions 7.14.3 Generic Types 7.14.4 Var 7.14.5 Multiple Generic Values 7.14.6 Anonymous Objects 7.14.7 What We’ve Learned 7.15 Events 7.15.1 A Basic Example7.15.2 A Proper Event 7.15.3 EventArgs7.15.4 Generic EventArgs 7.15.5 What We’ve Learned 7.16 Extension Functions7.16.1 Extensions 7.16.2 A Basic Example7.16.3 Overloading with Extensions 7.16.4 Magic Mirror 7.16.5 What We’ve Learned 7.17 Destructors7.17.1 A Basic Example7.17.2 Clearing Events or Delegates 7.17.3 OnDestroy 7.17.4 The Ugly Truth7.17.5 What We’ve Learned 7.18 Concurrency or Co-Routines 7.18.1 Yield7.18.1.1 A Basic Example 7.18.2 Setting Up Timers 7.18.3 Arrays of Delegates7.18.4 Stopping a Co-Routine7.18.5 What We’ve Learned 7.19 Dictionary, Stacks, and Queues 7.19.1 A Basic Example7.19.2 ContainsKey7.19.3 Stacks 7.19.3.1 A Basic Example 7.19.4 Movement Stack7.19.5 Queues7.19.6 What We’ve Learned 7.20 Lambda Expressions 7.20.1 Anonymous Expressions 7.20.1.1 A Basic Example—Action Func and Expression 7.20.2 Lambda Expressions 7.20.3 A Queue of Lambdas 7.20.4 What We’ve Learned 7.21 Leveling Up
8. Extended
8.1 What We’ll Be Covering in This Chapter 8.2 Review 8.3 Readability 8.3.1 ?: Notation 8.3.2 If 8.3.3 Smell 8.3.3.1 Comments 8.3.3.2 One Responsibility Rule 8.3.3.3 Duplicated Code8.3.3.4 Naming 8.3.4 What We’ve Learned 8.4 Git Revisited 8.4.1 Git Branch and Merge8.4.2 Merge Conflicts8.4.3 What We’ve Learned8.5 Recursion8.5.1 A Basic Example8.5.2 Understanding Recursion8.5.3 In Practice8.5.4 What We’ve Learned8.6 LINQ 8.6.1 Lambdas and Arrays8.6.1.1 A Basic Example8.6.2 Var 8.6.3 LINQ From 8.6.4 Strange Behaviors in LINQ 8.6.5 LINQ on Lists 8.6.6 Monsters Linq8.6.7 What We’ve Learned 8.7 Reflection8.7.1 A Basic Example8.7.2 Reflection MethodInfo8.7.3 What We’ve Learned 8.8 Dynamic8.8.1 ExpandoObject8.8.2 Expando Reader 8.8.3 What We’ve Learned 8.9 Bitwise Operators 8.9.1 Big Endian and Little Endian 8.9.2 Signed or Unsigned 8.9.3 Bitwise Or |8.9.4 Enums and Numbers 8.9.5 Bitwise And &8.9.6 Bitwise Exclusive Or ^ (xor)8.9.7 Setting Bitwise Flags 8.9.8 Bitwise Shortcuts | = and ^ =8.9.9 Bits in Numbers 8.9.10 Bit Shifting ≫ and ≪8.9.11 What We’ve Learned 8.10 Attributes 8.10.1 A Basic Example8.10.2 Custom Attributes 8.10.3 Custom Attributes for Default Values8.10.4 Multiple Attributes8.10.5 Putting Attributes to Work8.10.6 Attribute Flags8.10.7 What We’ve Learned8.11 Bitwise Math8.11.1 Two’s Complement Unary Operator ~8.11.2 Bitwise Addition and Subtraction8.11.3 Bitwise Multiplication8.11.4 Bitwise Tricks8.11.5 What We’ve Learned8.12 Architectures and Organization8.12.1 Planning Structure: Namespaces and Directories8.12.2 Divide and Conquer8.12.3 Refactoring8.12.4 What We’ve Learned8.13 Design Patterns8.13.1 Creational Design Patterns8.13.1.1 Singleton Pattern8.13.2 Structural Design Patterns8.13.3 Behavioral Design Patterns8.13.4 What We’ve Learned 8.14 Continuing on Your Own
9. Stuff We Couldn’t Cover
9.1 The Extern Keyword
10. Good Luck
Index

Content preview from Learning C# Programming with Unity 3D, second edition, 2nd Edition

Basics: The Building Blocks of Code

After covering the small parts that make up code, it’s time to start learning how all the parts come together to create a behavior. Creating data is easy; keeping the data organized is harder. Adding logic to do something with the data is harder still. That said, it’s not impossible; otherwise, no one would write code.

This chapter covers how a statement of code works and where the power that drives the code originates. Programming is much less enigmatic when you understand the mechanisms that drive it. To understand why code behaves the way it does, it’s important to know your way around the language.

4.1 What Will Be Covered in This Chapter

This chapter is about getting past the simple details and ...

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.

Read now

Unlock full access

More than 5,000 organizations count on O’Reilly

O’Reilly covers everything we've got, with content to help us build a world-class technology community, upgrade the capabilities and competencies of our teams, and improve overall team performance as well as their engagement.

Julian F.

Head of Cybersecurity

I wanted to learn C and C++, but it didn't click for me until I picked up an O'Reilly book. When I went on the O’Reilly platform, I was astonished to find all the books there, plus live events and sandboxes so you could play around with the technology.

Addison B.

Field Engineer

I’ve been on the O’Reilly platform for more than eight years. I use a couple of learning platforms, but I'm on O'Reilly more than anybody else. When you're there, you start learning. I'm never disappointed.

Amir M.

Data Platform Tech Lead

I'm always learning. So when I got on to O'Reilly, I was like a kid in a candy store. There are playlists. There are answers. There's on-demand training. It's worth its weight in gold, in terms of what it allows me to do.

Mark W.

Embedded Software Engineer

Publisher Resources

ISBN: 9780429810268

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills

Learning C# Programming with Unity 3D, second edition, 2nd Edition

by Alex Okita

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.