Adapt > Engage > Dominate

This is it.  The big one.  The one we’ve all been waiting for.

You win a cookie if you know what that’s from.  There are a lot of courses in this section–big surprise, right?

  • CA 101 – Computer Applications:  You learn Office.  Unless you just IM on your computer, you’ll roflstomp this course.
  • CS 105 – UNIX Operating Systems:  This course was pretty interesting.  You use VMware Workstation and learn the basics of and some intermediate stuff about Linux (SuSE).  Getting used to virtual machine software was useful by itself and although I had played around with Linux before, I did pick up a few new things.  I’m not 100% sure how this applies directly to us, but it helps to be familiar with multiple OSs.  I say that because we might indeed be doing network stuff via Linux computers/servers, but on the other hand, just doing basic familiarity with the OS wouldn’t be enough.  Also, to be fair however, there is so much to learn with Linux that it’s hard to pack even a fraction of it into one course.  Still, not bad, especially if you’ve never touched anything but Windows.
  • CS 106 – Fundamentals of Programming:  Yup, here we go.  The beast.  C++.  You start learning the basics of the language.  It was easy for me because I’d taken three (I think) pretty extensive courses in high school (yes, they still taught C++, woot!).  It might be hard for newcomers, but you have to start somewhere.
  • CS 210 – Intermediate Programming:  More C++.  You make a simple text-based game at the end of the course to pull together what you’ve learned.
  • CS 215 – Advanced Programming:  This CS course exposes you to the beginnings of C#.  It it not enough for you to be a master at C#, but it does make you familiar with the general syntax and UI basics of the language.  More study on your own is necessary if you want to add it to your arsenal.  Again, you’ll make a simple game, this time with a simple GUI.
  • CS 220 – Data Structures:  Arrays, vectors, linked lists, binary trees, queues, stacks, etc.  Some people find this topic pretty boring, but I don’t.  Plus you will be drowning in data structures pretty soon, so you might as well hunker down and learn as much as you can from this course.  Students have to implement the most common data structures on their own, which seems to be standard practice in most CS data structure classes.
  • SG 110 – Introduction to Game Development:  Light history of gaming, audience analysis, study of the video game development process (preproduction, beta, alpha, etc.).  If you’re an interested gamer, you probably know most of what is here.
  • SG 120 – Operating Systems:  Ok, I sort of disliked my professor…but that aside, if you never wondered or studied how OSs work, this should be interesting for you.  The course looked at how the popular OSs (Win, Mac, Linux) do things like save data, handle networking, etc.  This is more a “you don’t have to know how to do it, but you should know how it’s done” type of course. I don’t think is nearly comparable to a traditional CS OS course, however.  If you want to really learn about these OSs, do research on your own and dual- (or triple-) boot them on your computer and get hands-on experience by attempting a little systems programming and reading documentation.
  • SG 140 – Game Analysis and Playability:  Now this was a pretty neat course.  You’ll study what makes a game fun.  That’s right, an entire course built around fun lol.  The book for this course was very interesting and learning to pick apart games was a bonus.  Once you see the depth of planning that goes into every part of the game, you’ll appreciate them a lot more.  Those aiming to become designers should look forward to the topics discussed in here (in-game economics, game challenges, balancing, etc.).
  • SG 150 – Software Development Lifecycle:  A pretty good introduction to the different techniques used to development software: SCRUM, agile methodologies, waterfall, and more.  The book was, I’m sorry to say, deadly dull–however, taken as a whole, the knowledge of how software teams operate was (and will be) useful to learn.  There is an especially large project at the end where you have to come up with complete documentation for a small game.  I chose to do mine on a small, slightly altered version of Pong and it was over 20 pages, I believe–just a friendly heads up, don’t wait to do it at the last minute.
  • SG 200 – Team Product Development:  Another interesting course.  You learn, in detail, all about the production process of game development.  Outsourcing, music, localization, preproduction, and more is covered.  Basically, it’s an accelerated intro to what a producer does (which is a lot, in case you didn’t know).  You will be paired in teams at the beginning of the semester and have to deliver complete documentation for a game you and your team dream up.
  • SG 210 – Fundamentals of Game Engine Development:  You’ll finally get to make your own DirectX/C++ game!  Starting at about week four or five, you’ll spend the rest of the term working on your 2D game.  You must finish it or you won’t pass the class.  It doesn’t have to be a huge 2D platformer, but it should be something you can finish.  Between learning DirectX and doing a lot of coding, you will be spending a great deal of time working on your game.  This course is a lot of fun, however, and at the end you’ll have the basics of DirectX/Win32 under your belt.  Keep up your C++ skills, you’ll need them here.
  • SG 220 – 3D Game Engine Architecture:  SG 220 introduces you to some of the fundamental concepts used when working in 3d game worlds and with 3d engines.  You do not write your own engine (that would be a huge undertaking).  Instead, you write small demos to learn about things like lighting and vertex buffers.  You also slightly modify the existing code for a game/engine found in the textbook.  Beware, the code in there is very messy and hard to understand and modifying it will take extra effort on your part.
  • SG 300 – Game Software Project: Here you get your hands dirty with the popular Torque Game Engine.  You perform all kinds of tasks like making skyboxes, creating audio emitters, adding foliage, and writing scripts to control Torque.  The final project was a small, simple game that had to include various elements such as animated objects, water, particle effects, etc.  While it is very cool to be working in 3D and with tools designed to create those awesome worlds we all love, the course didn’t appeal to me as much as I thought it might.  Coming into the Torque arena with no experience, I have to say that the documentation was abysmal, some tools seemed broken, and the TorqueScript syntax drove me up the wall; my classmates had similar opinions.  I think it would beneficial if, in the future, this course switched to Unity, which I hear has awesome tools, a large community, and better documentation.
  • SG 310 – Algorithm Analysis and Design:  A cool class–definitely a little math required, but if you’re taking this you should breeze through the math portions easy.  You study classic algorithms like merge-sort and analyzing them with Big-O notation.  You’re also given several programming assignments to solve problems like the Towers of Hanoi and the traveling salesman problem.  They’re usually those it-sounds-easy-but-it-can-get-confusing-and-complicated problems.  Once you solve them, you see that they’re easy, but getting there can take some time depending on  your skill level and thought process.  This is an important class (both in this program and regular CS courses) because a) you’ll be working with algorithms day and night and b) programming interviewers love giving these type of problems to prospective employees to see how they think.
  • SG 350 – Networking Fundamentals:  Oddly, this course was similar to the OS course.  You learn a great deal about backbones, network types, cables, subnets, security, all that good stuff, but you don’t learn how to actually write code to make a multiplayer game.  If you don’t know how networking works, this will be useful.  Note, however, that there is a game network programming class being added to the curriculum (although I’m not sure if it actually teaches networking programming–I had my first introduction to it in SG460).
  • SG 360 – Computer Organization and Assembly Language: Awesome class, you learn about registers in the CPU, how stuff moves back and forth, WORD, DWORD, QWORD, mov, push, pop, etc.  You’ll definitely gain new appreciation for what languages like C++ actually do for you.  You know those guys who wrote assembly programs for TI calculators in high school (like me, lol)?  This is what they were doing.  A small game is due at the end, written either entirely in asm or in asm/C++ (and yes, you learn how to link them).
  • SG 400 – Compiler and Interpreter Design:  Another very neat class.  The textbook is pretty hardcore, but by now you should be able to handle at least the higher level stuff in it.  The stuff you learn in here is important because at some point you may need to write your own compiler/interpreter for a custom language used in a game.  On top of that, it’s just good to know what is going on in your compiler every time you hit the build button; if you ever find a bug in a compiler (very, very rare), the knowledge picked up here may help you figure out what’s going on.  The final project is a (very) small compiler that uses a grammar supplied by the teacher.
  • SG 410 – Software Requirements Analysis and Design: Ahh, the OOP class.  Well, I don’t want to be too harsh, because it could have been much worse, but…yeah, this one is kind of meh.  The book was OK, had light humor in it so the read wasn’t completely mind-numbing.  Basically this class is about proper OO programming and design, UML, and software engineering techniques.  It’s not really a practical, hands-on class, but more of a theory class.  If you’ve learned OO on your own time or been paying attention during the OO design portions included in the other programming classes, this should be pretty easy.  I would have much preferred learning about design patterns, instead of rehashing OOP yet again.  I wouldn’t even have minded this so much if we had discussed other styles as well (functional programming anyone?).
  • SG 420 – Game Software Testing and Debugging:  In this class you learn about the different techniques used to test games (not so much debugging), as the name suggests.  It goes through ways to catch all possible cases with the least amount of testing (very useful) as well as how bugs are reported and handled in studios, among many other topics.  There was quite a bit of writing in here, be ready for it.
  • SG 430 – Game Porting Basics:  Team project time!  A small game written in SDL that is cross-platform is due at the end of the semester.  SDL is very easily learned by newcomers and has many extensions which are equally easy to use.  The two platforms used are Windows and Fedora Linux.  All kinds of issues encountered during cross-platform development are discussed (file system differences, NTSC vs PAL, compiler behavior, screen sizes, serialization, etc.).
  • SG 440 – Artificial Intelligence for Games:  This class is a survey course of game AI techniques.  The book used when I took this class was very, very bad.  The code included in it made my eyes bleed, among other problems.  Needless to say, you don’t go very in-depth into any of the techniques discussed in this class, save for chasing/evading and finite state machines.  One of the projects is to implement Pacman with different behaviors for each of the AI ghosts.  Neural networks and fuzzy logic are briefly discussed at the end, although you don’t implement them for any assignments (but you can include it in the Pacman assignment if you want).  This could have been done quite a bit better and to be honest should probably have been split into two classes because there is so much material to cover.  You’ll need to read some books on your own to learn game AI–there just isn’t enough material presented to do the topic justice in this class.
  • SG 450 – Game Development:  Although SG450 contains even more OOP propaganda, the main focus is on creating documentation (design doc, tech spec, uml diagrams, etc.) for a game that you want to create in SG490 (the capstone class).  For the most part, it’s pretty dull, just rehashing OOP (again) and going over UML (again.  Does anyone use UML?  That’s what I thought.).  Creating the docs for your game sounds cool until you realize that you could probably do the same thing on a few napkins and whiteboards.  Creating it for a larger game would be great, but since the games you make in the course are very small, it’s overkill (and we’ve had practice making them before anyway).
  • SG 460 – Augmentation Strategies for Games:  Another excellent class–think of it like a survey of topics which you only lightly touched on (theory-wise) in other classes.  Apart from having a great teacher, we actually got to code something.  I say this because many of the classes in this program are not coding-oriented, but theory-oriented.  Topics included networking via sockets (client-server architecture), shader introduction (HLSL), and archiving.  We then had mini-projects for each of these topics.  For example, we created a simple text-based game using sockets, did a demo of cartoon shading in HLSL, and created an archive format and a small tool to pack and extract files.  Our teacher let us do this in any language we wanted; I used C++ for all my programs, but others used C# as well.
  • SG 490 – Game Software Senior Project:  This is the capstone class for the program, in which you can work singly or in teams to create (and finish) a game.  Each week you have to turn in progress reports and mid-way through the course you need to submit a milestone build with certain elements already functional.  There’s also a planning report at the beginning.  I ended up making my game with a team (which ended up being larger than expected); we used various tools to talk about and work on the project (weekly MSN meetings, Mercurial, Google Code, Google Groups, etc.).  Not everyone contributed equally, I’d say, but those who weren’t as good code-wise hopefully learned a lot from studying the code that others wrote.  Everyone else in the class created their games solo (and bits of the code I say frightened me).  All in all, a very fun class since the teacher basically gets out of your way and lets you get on with making a game.  At the end, everyone shares their projects and gets to see what everyone else did and each person has to create a presentation of their game and the development process.

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s

%d bloggers like this: