C- Game Programming For The Absolute Beginner

395 Pages·2003·14.97 MB·English

Microsoft C# Programming for the Absolute Beginner
Table of Contents
Microsoft C# Programming for the Absolute Beginner.................................................................1
Introduction........................................................................................................................................4
Overview..................................................................................................................................4
Chapter 1: Basic Input and Output: A Mini Adventure...................................................................5
Project: The Mini Adventure.....................................................................................................5
Reviewing Basic C# Concepts.................................................................................................6
Namespaces......................................................................................................................7
Classes..............................................................................................................................7
Methods.............................................................................................................................7
Statements.........................................................................................................................7
The Console Object...........................................................................................................8
.NET Documentation..........................................................................................................8
Saying “Hello, World!”............................................................................................................12
Getting into the Visual Studio .Net Environment..............................................................13
Examining the Default Code............................................................................................16
Creating a Custom Namespace.......................................................................................16
Adding Summary Comments...........................................................................................17
Creating the Class............................................................................................................17
Moving from Code to a Program............................................................................................19
Compiling Your Program..................................................................................................20
Looking for Bugs..............................................................................................................21
Getting Input from the User....................................................................................................22
Creating a String Variable................................................................................................24
Getting a Value with the Console.ReadLine() Method.....................................................24
Incorporating a Variable in Output...................................................................................25
Combining String Values.......................................................................................................26
Combining Strings with Concatenation............................................................................27
Adding a Tab Character...................................................................................................27
Using the Newline Sequence...........................................................................................27
Displaying a Backslash....................................................................................................27
Displaying Quotation Marks.............................................................................................27
Launching the Mini Adventure...............................................................................................28
Planning the Story............................................................................................................28
Creating the Variables......................................................................................................28
Getting Values from the User...........................................................................................29
Writing the Output............................................................................................................29
Finishing the Program......................................................................................................30
Summary................................................................................................................................31
Chapter 2: Branching and Operators: The Math Game................................................................32
The Math Game.....................................................................................................................32
Using Numeric Variables.......................................................................................................33
The Simple Math Game...................................................................................................33
Numeric Variable Types...................................................................................................34
Integer Variables..............................................................................................................35
Long Integers...................................................................................................................36
Floating−Point Variables..................................................................................................36
Data Type Problems........................................................................................................37
i
Table of Contents
Chapter 2: Branching and Operators: The Math Game
Math Operators................................................................................................................37
Converting Variables..............................................................................................................37
Explicit Casting.................................................................................................................39
The Convert Object..........................................................................................................39
Creating a Branch in Program Logic......................................................................................41
The Hi Bill Game..............................................................................................................41
Condition Testing.............................................................................................................43
The If Statement...............................................................................................................44
The Else Clause...............................................................................................................44
Multiple Conditions...........................................................................................................44
Working with The Switch Statement......................................................................................45
The Switch Demo Program..............................................................................................45
Examining How Switch Statements Work........................................................................46
Creating a Random Number..................................................................................................47
Introducing the Die Roller.................................................................................................47
Exploring the Random Object..........................................................................................48
Creating a Random Double with the .NextDouble() Method............................................48
Getting the Values of Dice...............................................................................................49
Creating the Math Game........................................................................................................50
Designing the Game........................................................................................................50
Creating the Variables......................................................................................................50
Managing Addition...........................................................................................................51
Managing Subtraction......................................................................................................52
Managing Multiplication and Division...............................................................................52
Checking the Answers.....................................................................................................53
Waiting for the Carriage Return.......................................................................................53
Summary................................................................................................................................54
Chapter 3: Loops and Strings: The Pig Latin Program................................................................55
Project: The Pig Latin Program..............................................................................................55
Investigating The String Object..............................................................................................56
The String Mangler Program............................................................................................56
A Closer Look at Strings..................................................................................................56
Using the Object Browser................................................................................................57
Experimenting with String Methods..................................................................................58
Performing Common String Manipulations......................................................................59
Using a For Loop...................................................................................................................60
Examining The Bean Counter Program...........................................................................60
Creating a Sentry Variable...............................................................................................61
Checking for an Upper Limit.............................................................................................61
Incrementing the Variable................................................................................................61
Examining the Behavior of the For Loop..........................................................................61
Varying the For Loop’s Behavior............................................................................................62
The Fancy Beans Program..............................................................................................63
Skipping Numbers............................................................................................................64
Counting Backwards........................................................................................................64
Using a Foreach Loop to Break Up a Sentence...............................................................65
Using a While Loop................................................................................................................65
The Magic Word Program................................................................................................66
ii
Table of Contents
Chapter 3: Loops and Strings: The Pig Latin Program
Writing an Effective While Loop.......................................................................................68
Planning Your Program with the STAIR Process...................................................................70
S: State the Problem........................................................................................................70
T: Tool Identification.........................................................................................................70
A: Algorithm......................................................................................................................71
I: Implementation..............................................................................................................71
R: Refinement..................................................................................................................72
Applying STAIR to the Pig Latin Program..............................................................................72
Stating the Problem..........................................................................................................73
Identifying the Tools.........................................................................................................73
Creating the Algorithm.....................................................................................................73
Implementing and Refining..............................................................................................74
Writing the Pig Latin Program................................................................................................74
Setting Up the Variables..................................................................................................74
Creating the Outside Loop...............................................................................................75
Dividing the Phrase into Words........................................................................................75
Extracting the First Character..........................................................................................76
Checking for a Vowel.......................................................................................................76
Adding Debugging Code..................................................................................................76
Closing Up the code.........................................................................................................77
Summary................................................................................................................................77
Chapter 4: Objects and Encapsulation: The Critter Program......................................................78
Introducing the Critter Program..............................................................................................78
Creating Methods to Reuse Code..........................................................................................80
The Song Program...........................................................................................................80
Building the Main() Method..............................................................................................81
Creating a Simple Method................................................................................................82
Adding a Parameter.........................................................................................................83
Returning a Value............................................................................................................84
Creating a Menu....................................................................................................................85
Creating a Main Loop.......................................................................................................85
Creating the Sentry Variable............................................................................................86
Calling a Method..............................................................................................................86
Working with the Results..................................................................................................87
Writing the showMenu() Method......................................................................................87
Getting Input from the User..............................................................................................87
Handling Exceptions........................................................................................................88
Returning a Value............................................................................................................89
Creating a New Object with the CritterName Program..........................................................89
Creating the Basic Critter.................................................................................................89
Using Scope Modifiers.....................................................................................................90
Using a Public Instance Variable.....................................................................................90
Creating an Instance of the Critter...................................................................................91
Referring to the Critter’s Members...................................................................................91
Adding a Method....................................................................................................................91
Creating the talk() Method for the CritterTalk Program....................................................92
Changing the Menu to Use the talk() Method..................................................................92
Creating a Property in the CritterProp Program.....................................................................92
iii
Table of Contents
Chapter 4: Objects and Encapsulation: The Critter Program
Examining the Critter Prop Program................................................................................93
Creating the Critter with a Name Property.......................................................................93
Using Properties as Filters...............................................................................................95
Making the Critter More Lifelike.............................................................................................96
Adding More Private Variables.........................................................................................96
Adding the Age() Method.................................................................................................97
Adding the Eat() Method..................................................................................................97
Adding the Play() Method.................................................................................................98
Modifying the Talk() Method.............................................................................................98
Making Changes in the Main Class..................................................................................98
Summary................................................................................................................................99
Chapter 5: Constructors, Inheritance, and Polymorphism: The Snowball Fight.....................101
Introducing the Snowball Fight.............................................................................................101
Inheritance and Encapsulation.............................................................................................102
Creating a Constructor.........................................................................................................102
Adding a Constructor to the Critter Class.......................................................................103
Creating the CritViewer Class........................................................................................104
Reviewing the Static Keyword........................................................................................105
Calling a Constructor from the Main() Method...............................................................106
Examining CritViewer’s Constructor...............................................................................106
Working with Multiple Files.............................................................................................107
Overloading Constructors....................................................................................................108
Viewing the Improved Critter Class................................................................................108
Adding Polymorphism to Your Objects..........................................................................109
Modifying the Critter Viewer in CritOver to Demonstrate Overloaded Constructors......110
Using Inheritance to Make New Classes.............................................................................111
Creating a Class to View the Clone...............................................................................112
Creating the Critter Class...............................................................................................113
Improving an Existing Class.................................................................................................113
Introducing the Glitter Critter..........................................................................................114
Calling the Base Class’s Constructors...........................................................................115
Adding Methods to a New Class....................................................................................116
Changing the Critter Viewer Again.................................................................................116
Using Polymorphism to Alter a Class’s Behavior.................................................................116
Creating the Snowball Fight.................................................................................................117
Building the Fighter........................................................................................................118
Building the Robot Fighter..............................................................................................120
Creating the Main Menu Class.......................................................................................122
Summary..............................................................................................................................125
Chapter 6: Creating a Windows Program: The Visual Critter....................................................127
Overview..............................................................................................................................127
Introducing the Visual Critter................................................................................................127
Creating a Windows−Style Program with a GUI..................................................................134
Thinking Like a GUI Programmer...................................................................................135
Creating a Graphical User Interface (GUI).....................................................................136
Examining the Code of a Windows Program.......................................................................139
Adding New Namespaces..............................................................................................140
iv
Table of Contents
Chapter 6: Creating a Windows Program: The Visual Critter
Creating the Form Object...............................................................................................142
Creating a Destructor.....................................................................................................143
Creating the Components..............................................................................................144
Setting Component Properties.......................................................................................145
Setting Up the Form.......................................................................................................145
Writing the Main() Method..............................................................................................146
Creating an Interactive Program..........................................................................................147
Responding to a Simple Event.......................................................................................147
Creating and Adding the Components...........................................................................148
Adding an Event to the Program....................................................................................148
Creating an Event Handler.............................................................................................149
Allowing for Multiple Selections...........................................................................................150
Choosing a Font with Selection Controls.......................................................................150
Creating the User Interface............................................................................................151
Examining Selection Tools.............................................................................................153
Creating Instance Variables in the Font Chooser..........................................................154
Writing the AssignFont() Method....................................................................................155
Writing the Event Handlers............................................................................................157
Working with Images and Scroll Bars..................................................................................157
Changing an Image’s Size.............................................................................................158
Setting Up the Picture Box.............................................................................................159
Adding a Scroll Bar........................................................................................................161
Writing the Event−Handling Code..................................................................................161
Revisiting the Visual Critter..................................................................................................161
Designing the Program..................................................................................................162
Determining the Necessary Tools..................................................................................163
Designing the Form........................................................................................................163
Writing the Code............................................................................................................164
Summary..............................................................................................................................167
Chapter 7: Timers and Animation: The Lunar Lander................................................................168
Introducing the Lunar Lander...............................................................................................168
Reading Values from the Keyboard.....................................................................................169
Introducing the Key Reader Program.............................................................................169
Setting Up the Key Reader Program..............................................................................171
Coding the KeyPress Event...........................................................................................171
Coding the KeyDown Event...........................................................................................173
Determining Which Key Was Pressed...........................................................................175
Animating Images................................................................................................................175
Introducing the ImageList Control..................................................................................176
Setting Up an Image List................................................................................................177
Looking at the Image Collection.....................................................................................178
Displaying an Image from the Image List.......................................................................179
Using a Timer to Automate Animation.................................................................................180
Introducing the Timer Contro.l........................................................................................180
Configuring the Timer.....................................................................................................181
Adding Motion......................................................................................................................182
Checking for Keyboard Input..........................................................................................184
Working with the Location Property...............................................................................184
v
Table of Contents
Chapter 7: Timers and Animation: The Lunar Lander
Detecting Collisions between Objects..................................................................................186
Coding the Crasher Program.........................................................................................188
Getting Values for newX and newY...............................................................................189
Bouncing the Ball off the Sides......................................................................................189
Checking for Collisions...................................................................................................189
Extracting a Rectangle from a Component....................................................................189
Getting More from the MessageBox Object.........................................................................190
Introducing the MsgDemo Program...............................................................................190
Retrieving Values from the MessageBox.......................................................................192
Coding the Lunar Lander.....................................................................................................192
The Visual Design..........................................................................................................192
The Designer−Generated Code.....................................................................................193
Class−Level Variables...................................................................................................194
The Constructor.............................................................................................................195
The timer1_Tick() Method..............................................................................................195
The moveShip() Method.................................................................................................196
The checkLanding() Method..........................................................................................197
The theForm_KeyDown() Method..................................................................................199
The showStats() Method................................................................................................200
The killShip() Method.....................................................................................................200
The initGame() Method..................................................................................................201
Summary..............................................................................................................................202
Chapter 8: Arrays: The Soccer Game..........................................................................................203
The Soccer Game................................................................................................................203
Introducing Arrays................................................................................................................204
Exploring the Counter Program......................................................................................205
Creating an Array of Strings...........................................................................................207
Referring to Elements in an Array..................................................................................208
Working with Arrays.............................................................................................................208
Using the Array Demo Program to Explore Arrays........................................................208
Building the Languages Array........................................................................................209
Sorting the Array............................................................................................................209
Creating Tables with Two−Dimensional Arrays.............................................................214
Designing the Soccer Game................................................................................................214
Solving a Subset of the Problem....................................................................................215
Adding Percentages for the Other Players.....................................................................216
Setting Up the Shot Demo Program...............................................................................216
Setting Up the List Boxes...............................................................................................217
Using a Custom Event Handler......................................................................................218
Writing the changeStatus() Method................................................................................219
Kicking the Bal.l..............................................................................................................219
Designing Programs by Hand..............................................................................................220
Examining the Form by Hand Program..........................................................................220
Adding Components in the Constructor.........................................................................221
Responding to the Button Event....................................................................................222
Building the Soccer Program...............................................................................................222
Setting Up the Variables................................................................................................222
Examining the Constructor.............................................................................................225
vi
Table of Contents
Chapter 8: Arrays: The Soccer Game
Setting Up the Players...................................................................................................225
Setting Up the Opponents..............................................................................................227
Setting Up the Goalies...................................................................................................228
Responding to Player Clicks..........................................................................................228
Handling Good Shots.....................................................................................................229
Handling Bad Shots.......................................................................................................230
Setting a New Current Player.........................................................................................230
Handling the Passage of Time.......................................................................................231
Updating the Score........................................................................................................234
Summary..............................................................................................................................235
Chapter 9: File Handling: The Adventure Kit..............................................................................236
Introducing the Adventure Kit...............................................................................................236
Viewing the Main Screen...............................................................................................236
Loading an Adventure....................................................................................................237
Playing an Adventure.....................................................................................................238
Creating an Adventure...................................................................................................240
Reading and Writing Text Files............................................................................................241
Exploring the File IO Program........................................................................................242
Importing the IO Namespace.........................................................................................242
Writing to a Stream........................................................................................................243
Reading from a Stream..................................................................................................244
Creating Menus....................................................................................................................245
Exploring the Menu Demo Program...............................................................................245
Adding a MainMenu Object............................................................................................246
Adding a Submenu.........................................................................................................247
Setting Up the Properties of Menu Items.......................................................................248
Writing Event Code for Menus.......................................................................................249
Using Dialog Boxes to Enhance Your Programs.................................................................250
Exploring the Dialog Demo Program..............................................................................250
Adding Standard Dialogs to Your Form.........................................................................253
Using the File Dialog Controls........................................................................................253
Responding to File Dialog Events..................................................................................254
Using the Font Dialog Control........................................................................................255
Using the Color Dialog Contro.l......................................................................................256
Storing Entire Objects with Serialization..............................................................................256
Exploring the Serialization Demo Program....................................................................256
Creating the Contact Class............................................................................................257
Referencing the Serializable Namespace......................................................................258
Storing a Class...............................................................................................................258
Retrieving a Class..........................................................................................................259
Returning to the Adventure Kit Program..............................................................................259
Examining the Room Class............................................................................................260
Creating the Dungeon Class..........................................................................................263
Writing the Game Class.................................................................................................264
Writing the Editor Class..................................................................................................269
Writing the MainForm Class...........................................................................................274
Summary..............................................................................................................................276
vii
Table of Contents
Chapter 10: Chapter Basic XML: The Quiz Maker......................................................................277
Introducing the Quiz Maker Game.......................................................................................277
Taking a Quiz.................................................................................................................277
Creating and Editing Quizzes.........................................................................................278
Investigating XML................................................................................................................278
Defining XML..................................................................................................................279
Creating an XML Document in .NET..............................................................................283
Creating an XML Schema for Your Language...............................................................284
Investigating the .NET View of XML...............................................................................285
Exploring the XmlNode Class........................................................................................285
Exploring the XmlDocument Class.................................................................................286
Reading an Existing XML Document...................................................................................287
Creating the XML Viewer Program................................................................................293
Writing New Values to an XML Document...........................................................................298
Designating the Class−Level Variables.........................................................................298
Building the Document Structure...................................................................................299
Adding an Element to the Document.............................................................................300
Displaying the XML Code...............................................................................................301
Examining the Quizzer Program..........................................................................................302
Building the Main Form..................................................................................................303
Writing the Quiz Form....................................................................................................304
Writing the Editor Form..................................................................................................310
Summary..............................................................................................................................317
Chapter 11: Databases and ADO.NET: The Spy Database........................................................318
Overview..............................................................................................................................318
Introducing the SpyMaster Program....................................................................................318
Creating a Simple Database................................................................................................321
Accessing the Data Server.............................................................................................321
Accessing the Data in a Program...................................................................................326
Using Queries to Modify Data Results.................................................................................333
Limiting Data with the SELECT Statement....................................................................333
Using an Existing Database...........................................................................................338
Adding the Capability to Display Queries.......................................................................339
Creating a Visual Query Builder.....................................................................................340
Working with Relational Databases.....................................................................................345
Improving Your Data with Normalization........................................................................346
Using a Join to Connect Two Tables.............................................................................347
Creating a View..............................................................................................................350
Referring to a View in a Program...................................................................................353
Incorporating the Agent Specialty Attribute....................................................................353
Working with Other Databases............................................................................................355
Creating a New Connection...........................................................................................355
Converting a Data Set to XML.......................................................................................359
Reading from XML to a Data Source.............................................................................360
Creating the SpyMaster Database.......................................................................................361
Building the Main Form..................................................................................................361
Editing the Assignments.................................................................................................362
Editing the Specialties....................................................................................................363
Viewing the Agents........................................................................................................364
viii