My Favorite iPhone Apps (So Far)

Why I have an iPhone

So I recently won a free iPhone 3GS 16GB because I entered my name into some kind of online contest. Amazingly, the day after I submitted my name I actually won, and about a month later my iPhone came in the mail. Being a cheap bastard, and afraid of signing a 2-year contract with AT&T, I declined to get a data plan but I kept the phone anyway so that I could play with it like a shiny new toy.

Anyway, I thought I’d go ahead and share my favorite iPhone apps so far:

Facebook – Free

This one is a no brainer. It’s just like Facebook.com, except with a more intuitive interface for the iPhone. Not all of the functionality is there yet, but still, this is the fastest and easiest way use Facebook on the iPhone without doing some kind of weird zooming dance with your fingers in a Safari browser.

Twitterific – Free

I haven’t tried any other Twitter apps, but this one works pretty well. Since I don’t spend a huge amount of time on Twitter this is good enough for me. Your mileage may vary.

Skype – Free

Thanks to Skype, I can use my iPhone like a phone, without paying AT&T a dime. I still have to pay Skype of course but hey, it’s pretty cheap and it works internationally. As long as I have wifi access.

Pandora – Free

Internet radio for free on your iPhone. This is for when I get bored of listening to all of the music I already have. Of course it would also be nice if my iPhone supported actual AM/FM radio but this is the next best thing.

SpanishDict – $1

I had a hard time finding an English-Spanish dictionary that works without Internet access, and this one does. It actually also has several other features, like a word game, some key phrases, a daily word, etc., but mostly I use it for the dictionary. This came in super handy in Colombia a couple of times actually.

Spanish! – $1

Yes, another Spanish app. This one is a pretty awesome flashcard application, with 1000 Spanish words built in. It somewhat reminds me of SuperMemo, in the way that it introduces new words to you slowly and as you master words you see them less often, whereas words you miss a lot show up more often. You can try to remember the English definition of Spanish words or vice versa, and it will even pronounce all 1000 Spanish words if you touch them. This app is a really awesome way to build your vocabulary, and much easier than making your own set of real-life flash cards.

Fling! – $1

Fling is an addictive puzzle game where you basically try to fling a set of furballs in a grid toward each other in order to knock them off the board, until only one furball remains. The gameplay is simple, but the puzzles get increasingly more difficult to sequence. This one is definitely a good way to waste some time if you need to do so, for example on a long bus ride or while waiting for the waiter to finally take your order.

Cube Runner – Free

A simple “racer” type game where you steer by tilting the iPhone itself, and the object of the game is to make it through a random field of cubes without hitting any at increasing speeds. There are three difficulty levels, but even on Easy you’ll be challenged to beat your own high score.

Flight Control – $1

This game is my latest obsession, and several of my friends’ as well. Basically a random sequence of different planes enter an airfield and your job is to touch and drag them into a path that will land them onto a runway, or in the case of helicopters, a landing pad. The object is to land as many aircraft as possible without any of them hitting each other. Add in some tricky things like planes of different speeds and this game becomes a really challenging multitasking clusterfield, if you will. You can also send planes to a buddy while playing multiplayer mode on wifi or Bluetooth. Definitely check this one out.

Your Favorite Apps?

Go ahead and leave a comment and tell me what your favorite iPhone apps are. What am I missing?

HexarViz: An XNA Music Visualizer

Media Player Visualization Data

Recently, at a local Microsoft GameDevz meeting that I attended, we had a short 45-minute contest to see which 2-3 person team could come up with the coolest visualization given a relatively simple XNA project that retrieves visualization data from the song currently playing in the Media Center. HexarViz is an evolution of the project that my partner Daniel Taylor and I came up with during this competition.

The way to retrieve music visualization data from XNA is very simple. Call the MediaPlayer.GetVisualizationData method in XNA 3.0 or later, and you will retrieve an object of type VisualizationData. The VisualizationData class provides only two properties, Samples and Frequencies. The former is an array of 256 float values from -1.0 to 1.0 indicating the raw amplitude of the currently playing sound sample. The latter is an array of 256 float values from 0 to 1.0 indicating the logarithmic scaled power value of each frequency band in the currently playing sound sample – essentially the result of a FFT on the sound data. The frequency distribution seemed like a more obvious choice to use in a visualizer, so that’s what we used.

HexarViz

The idea for this visualizer was inspired by the standard horizontal bar UI that is typically used to display the currently playing frequency bands. It looks like this:

And in fact, this is the first part we implemented, by using a simple 10×10 white square as a texture, and drawing one red rectangle per frequency band, from the left side of the screen to the right. But, let’s be honest, that’s boring, because it’s been done a million times.

We wanted something more interesting, so I thought maybe it would be cool to make the frequency band values rotate around a center point, kinda like a circle. Except since each rectangle drawn rotationally this way will have a different length depending on its power value – so the shape of this sound circle will change drastically over time. Here’s basically what that looks like:

This image depicts pretty closely what we ended up with for the competition, in about 45 minutes. We also had a few rudimentary features:

  • Previous Song / Next Song
  • Sound Circle Rotation

But like I said, HexarViz is an evolved version of the results of that competition, meaning that after the competition I added a lot of features, namely:

  • Pause
  • Volume Up / Volume Down
  • Displaying the currently playing playlist, album, artist, and song name
  • Playlist change support
  • Toggle individual Red/Green/Blue components of the target color
  • Color Cycling
  • Change the current texture

Color Cycling was probably the most difficult part to implement. In order to effect a smooth transition of target colors, I calculate the HSB (Hue/Saturation/Brightness) of the current target color, increment the hue, and then convert back to an RGB value. The color of each individual rectangle is also a linear interpolation between black and the target color, based on the frequency band’s percentage of maximum power.

Changing the current texture, from a 10×10 white square to something else, also has some very interesting effects on the way that the sound circle looks. Give that a try.

Source and Windows Installer

[HexarVizSource]

[HexarVizInstaller]

Controls

Change Playlist – P
Previous Song – Left Arrow
Next Song – Right Arrow
Pause – Spacebar
Increase Volume – Up Arrow
Decrease Volume – Down Arrow
Toggle Spin – S
Toggle Red – R
Toggle Green – G
Toggle Blue – B
Cycle Colors – C
Change Texture – T
Quit – Escape

HexShooter: An XNA 2D Tutorial Upgrade

XNA Game Studio 3.1

XNA Game Studio, if you haven’t heard of it, is an integrated development environment for the development of Windows and Xbox 360 games using either C# Express 2008 or Visual Studio 2008. It is essentially a Visual Studio Package which includes a set of XNA assemblies, as well as new project types to create Windows and Xbox 360 games. The latest version, 3.1, was released earlier this year and its newest features include video playback, an updated audio API, avatar support, and use of the XBox Live Party system.

In addition, budding game developers with a Premium Creators Club account can submit their game to the XNA Creators Club for peer review; if passed, these games can be sold on Xbox Live Indie Games for $1, $3, or $5. Developers receive 70% of all sales revenue for copies of their game that are purchased via Xbox Live. Not too bad a deal, though creating an independent game with mass market appeal and a decent purchase rate is no small task.

Creators Club Website

The epicenter of all things XNA is located at the XNA Creators Club Website. This is where you obtain a Premium account, submit your game for review, playtest others’ creations, and access a multitude of resources including forums and tutorials.

The 2D Tutorial

The Beginner’s 2D Tutorial uses video to demonstrate how to create a simple 2D shooter starting from a blank Windows Game project, given a couple of pre-created images. The videos walk you through creation of the game project, adding assets, drawing the background, creating cannons, firing cannonballs, adding enemies, and destroying enemies. It’s actually a very handy tutorial, and you end up with something like this (skip to 4:17)

HexShooter

As you can see in the video above, there are three enemy ships moving from right to left at all times, and you can shoot them to earn points. It’s pretty smooth, but there’s something important missing. Because there’s no inherent challenge, no sense of danger, and no real goal, this project is unfortunately little more than a toy, and the fun factor is completely missing. HexShooter is my attempt to take this project and change it in ways that will make it challenging and fun.

So here’s a list of some of the features I added:

  • Explosions and Smoke (from Joshua Foss’ excellent Adding 2D Particles and Explosions videos.
  • The ability to move the cannon from left to right with the left thumstick, aiming now with the right.
  • Enemies now spawn from either the left or right sides of the screen, and they bounce off the edges and come back with the same height and speed.
  • Player cannonballs are now very fast, but you can only have one on screen at once.
  • Enemies now fire green cannons back at you, and if they hit the center circle of your cannon, you lose.
  • For every ten enemies killed, a new enemy is added.

There are several reasons why I think this upgrade is a lot more fun to play than the original. First, there is the very real possibility of losing, and there is a challenge. Namely, kill as many aliens as you can while avoiding enemy fire for as long as possible. Because of the way that enemies are added, the game starts out easy but becomes increasingly challenging the more enemies you kill. Eventually you will find yourself spending most of your attention on dodging enemy fire, which reminds me of the fun and challenge of Galaga.

The choice to change the cannon to only fire one fast cannonball at once was also intentional. In the tutorial version, you can fire three cannonballs at once, but they are very slow. This makes aiming and firing tedious and somewhat pointless. With only one cannonball, you have to make your shots matter, so your aim counts.

For a while I considered creating a complete mesh-based collision detection system for the cannon, including not just the circle but the barrel too. But I realized that not only would that be a lot of extra work, but it would probably detract from the gameplay. Having to worry about your cannon aim in order to dodge enemy cannonballs is silly, and would make evasion nearly impossible in the late game.

Source and Executable

I am offering both the source code and executable for inspection and playtesting. If you want to compile and run the source you must have XNA Game Studio 3.1 installed.

[HexShooter Source]

If you just want to play the game, you need to have the Microsoft XNA Framework Redistributable 3.1 installed, and either:

Or, you could just use the keyboard.

[HexShooter Installer]

Using the keyboard isn’t too bad, but if you’d like to use an Xbox controller, I’d recommend the cheaper USB wired controller, unless you already have some Xbox 360 controllers lying around and you absolutely must have wireless controllers.

Controls

Move – Left thumbstick or A/D keys
Aim – Right thumbstick or Left/Right arrow keys
Shoot – Right trigger or Spacebar
New Game – Start or Enter

Visual Studio 2010 Beta 2 Now Available on MSDN

Visual Studio 2010 Beta 2 is now available for download on MSDN for MSDN subscribers, and will be available to the general public on October 21st. In addition, the new .NET Framework 4.0 is now available as well.

New Features in Visual Studio 2010 Beta 2

  • Team Foundation Server – Track and manage work items for your entire development team
  • Application Modeling – Create code dependency graphs, sequence diagrams, layer diagrams, and UML diagrams
  • Version Control – View source merges, branch hierarchies, and file history
  • Historical Debugger – Tracks system state as your application is running, so that you can backtrack to the source of any errors that occur
  • Performance Profiler – Measure, evaluate, and target performance issues in your .NET application
  • Editor Enhancements – Better docking control, code zoom, box selection, call hierarchy, and more
  • Brand New Start Page – Redesigned UI and new customization features
  • C# and VB.NET 4.0 – Late binding to dynamic types, covariance/contravariance, type equivalence

There are of course many other new features in this release. For a full list of new features in Visual Studio 2010 Beta 2, refer to What’s New in Beta 2 for Visual Studio Team System 2010.

New Features in the .NET Framework 4.0

  • Application Compatibility and Deployment – Applications developed on previous versions of the .NET Framework should still work smoothly in most cases. Also, the framework now supports in-process side-by-side execution of different framework versions
  • Parallel Computing – A new Task Parallel Library and Parallel LINQ
  • Improved Security Model
  • Core New Features and Improvements – Changes to diagnostics, garbage collection, code contracts, dynamic language runtime, tuples, and much more
  • Networking – Enhancements to the functionality in the System.Net namespace
  • Web – ASP.NET 4 provides many new web forms features
  • Client – New features in WPF and the Managed Extensibility Framework
  • Data – Improvements to ADO.NET
  • Communications and Workflow – Improvements in the Windows Communication Foundation

For more information, see What’s New in the .NET Framework 4.

Completely Redesigned MSDN

MSDN, the Microsoft Developer Network website, has been completely redesigned to coincide with Visual Studio 2010 Beta 2. Check it out!

Converting Managed C++ to C++/CLI

What is Managed C++?

Managed C++, also known as Managed Extensions for C++, was a set of syntactic extensions and keywords released with Visual Studio .NET in 2002 which allows you to target the .NET Framework in C++. In other words, with the release of Managed C++, it became possible to write .NET programs in C++. This is particularly interesting because unlike pure managed languages like C# and Visual Basic .NET, Managed C++ is also directly compatible with native C++ code, without having to use PInvoke or COM. In fact you can write code that mixes both unmanaged and managed C++ in the same assembly, and even within the same function! This kind of “mixed mode” interop is what makes Managed C++ so interesting.

So how does it work? Basically in addition to the standard C++ built-in types, references, and pointers, you can now declare what is known as a garbage-collected pointer to point to a managed .NET object that has been allocated with a managed new operation. As long as you keep your regular unmanaged classes and pointers separate from your managed, garbage-collected ones, you’re good to go. Here’s an example:

__gc class G { public: int i; }
G __gc* pG = new G;
pG->i = 5;
int i = pG->i;

The __gc keyword is by far the most ubiquitous in Managed C++, but there are a number of other ones:

  • __abstract: for declaring a class as abstract
  • __box: for “boxing” value types
  • __delegate: for declaring a .NET delegate
  • __event: for declaring a .NET event
  • __identifier: for using a C++ keyword as an identifier
  • __interface: for declaring a .NET interface
  • __nogc: for explicitly declaring an unmanaged type
  • __pin: for declaring a “pinning pointer”
  • __property: for declaring a .NET property
  • __sealed: protects a class or method from derivation
  • __try_cast: for a dynamic cast that throws an exception on failure
  • __typeof: for determining the .NET type of an object
  • __value: for declaring a value class

Used correctly, these keywords are all you need to write code in Managed C++.

What is C++/CLI?

Sometime after introducing Managed C++ to the world via Visual Studio .NET, Microsoft started working on a newer revision of the language specification in an attempt to supersede Managed C++. Why did they decide to revise the language? For one thing, although Microsoft chose the common extension prefix “__” for its managed keywords, developers generally thought that the syntax was ugly. Really ugly. Additionally, the code was often difficult to read and understand in ambiguous situations. So for Visual Studio 2005, Microsoft created a new language specification called C++/CLI which completely revised the language both for the aesthetics of prettier code and the clarity of unambiguous syntax.

How did the syntax change?

Handles: Where before you had to refer to managed classes using gc pointers (__gc*), now when you use a managed type you use the syntax ClassName^, to clearly differentiate managed and unmanaged objects.

Contextal and Spaced Keywords: Instead of introducing a slew of new .NET keywords, and marking them as off limits for identifiers, Microsoft chose only three new keywords (gcnew, generic, and nullptr), and the rest are either spaced keywords (for each, enum class, interface class, ref class, value class) or contextual keywords which only appear where an identifier would never appear. This was a great decision because it means that the syntax is prettier but you break very few existing programs, unless they call their variables nullptr and gcnew. Contextual keywords include abstract, finally, in, override, sealed, and where.

Tracking Reference to No Object: The keyword nullptr was introduced to represent the managed equivalent of null. Because of this change, the integral value zero no can no longer be used as a tracking reference; nullptr must be used instead.

Garbage-Collected New: To differentiate the standard C++ new keyword from a managed allocation which will automatically be garbage collected, the keyword gcnew was introduced. Anytime you allocate a new .NET object you must use this gcnew keyword.

Generics: Just as C# 2.0 added support for generics, so too did C++/CLI add support for .NET generics in C++ using the generic keyword.

Dispose and Finalize: The changes to destructor semantics in C++/CLI are complicated; destructors now go to Dispose instead of Finalize, but you can still declare an explicit finalizer if necessary. See the MSDN translation guide for more details.

There are other changes that are too numerous to list here; consult my References for more information.

Quick and Dirty Translation Guide

Managed Class Declaration
=========================
Old: public __gc class MyClass
New: public ref class MyClass

Property Declaration
====================
Old: __property String *get_Name();
New: property String^ Name { String^ get(); }

Old: __property System::String __gc* get_Description();
Old: __property void set_Description(System::String __gc* value);
New: property String^ Description { String^ get(); void set(String^); }

Dispose
=======
Old: void Dispose();
New: ~MyClass();

Note: The Dispose/Finalize pattern has some tricky changes. See Translation Guide: Moving Your Programs from Managed Extensions for C++ to C++/CLI.

Handles
=======
Old: String* ToString();
New: String^ ToString();

Pin Ptr
=======
Old: std::list* __pin *pinner = &m_stringList;
New: pin_ptr<std::list > pinner = m_stringList;

Property Definition
===================
Old: String *MyClass::get_Name() { }
New: String^ MyClass::Name::get() { }

Old: System::Double MyClass::get_Values() __gc[] { }
New: Array^ MyClass::Values::get() { }

Old: double MyReader::EndRead(IAsyncResult* asyncResult) __gc [,] { }
New: Array MyReader::EndRead(IAsyncResult^ asyncResult) { }

Array Declaration
=================
Old: Object* args[] = { GetType()->Name, this->VirtualName };
New: array^ args = { GetType()->Name, this->VirtualName };

Managed Memory Allocation
=========================
Old: throw new ObjectDisposedException(S"MyClass");
New: throw gcnew ObjectDisposedException("MyClass");

Boxing
======
Old: Object* myObjArray __gc[] = { __box(1), __box(2), __box(3) };
New: array^ myObjArray = {1, 2, 3}; // Now implicit

Unboxing
========
Old: System::Object* o = __box(123);
Old: int a = *(dynamic_cast(o));
New: Object^ o = z; // implicit boxing
New: int y = *reinterpret_cast(o); // unboxing

Dereferencing a GC Pointer / Handle
===================================
Old: this->Name
New: this->Name // no change

Public Inheritance
==================
Old: public __gc class SubClass : public MyClass {
New: public ref class SubClass : MyClass { // Public inheritance by default

Implementing ICollection (New Syntax Only)
==========================================
ref class MyCollection : ICollection
{
public:
virtual IEnumerator^ GetEnumerator() = IEnumerable::GetEnumerator { return nullptr; }
virtual property int Count { int get() = ICollection::Count::get { return 0; } }
virtual property Object^ SyncRoot { Object^ get() = ICollection::SyncRoot::get { return nullptr; } }
virtual property bool IsSynchronized { bool get() = ICollection::IsSynchronized::get { return false; } }
virtual void CopyTo(Array^, int) = ICollection::CopyTo { return; }
};

For Each (New Syntax Only)
=========================
array^ classes = { gcnew MyClass() };
for each (MyClass^ c in classes)
{
MessageBox::Show(c->Name);
}

String Literals
===============
Old: S"Managed String"
New: "Managed String"

Try-Cast -> Safe-Cast
TypeOf -> TypeID
=====================
Old: m_bigFloat = *__try_cast(info->GetValue(S"_bigFloat",__typeof(f64)));
New: m_bigFloat = safe_cast(info->GetValue("_bigFloat", f64::typeid));

CLI Types
=========
Old: __int64
New: Int64

Delegates / Events
==================
Old: public __delegate void MyEventHandler(Object *sender, MyEventArgs *e);
Old: __gc class Task {
__event void add(MyEventHandler *eh);
__event void remove(MyEventHandler *eh);
}

New: public delegate void MyEventHandler(Object^ sender, MyEventArgs^ e);
New: ref class Task {
event MyEventHandler^ MyEvent { void add(MyEventHandler^ eh); void remove(MyEventHandler^ eh); }
}

Private Public
==============
Old: private public:
New: internal:

Operator Overloading
====================
Old: static bool op_Equality(DataFrequency d1, DataFrequency d2);
New: static bool operator ==(DataFrequency d1, DataFrequency d2);

Conversion Operators
====================
Old: static double op_Implicit(int i);
Old: static float op_Explicit(int i);
New: static implicit operator double(int i);
New: static explicit operator float(int i);

CLI Enums
=========
Old: __value enum Result { Pass, Fail };
Old: Result r = Pass;
New: enum class Result { Pass, Fail };
New: Result r = Result::Pass;

NullPtr
=======
Old: Object* obj = 0;
New: Object^ obj = nullptr;

Visual Studio Search & Replace Strings

Use these in order, using Visual Studio 2005 with Regular Expressions, per .h file. Voila.

String RegExp
=============
Find: String __gc\*
Replace: String^

Property RegExp
===============
Find: __property
Replace: property

Get Property RegExp
===================
Find: property {[^ ]*} get_{[^\(]*}\(\);
Replace: property \1 \2 { \1 get(); }

Set Property RegExp
===================
Find: property void set_{[^\(]*}\({[^ ]*} value\);
Replace: property \1 { void set(\2 value); }

Get Array
=========
Find: property {[^ ]*} get_{[^\(]*}\(\) __gc\[\];
Replace: property array^ \2 { array^ get(); }

Set Array
=========
Find: property void set_{[^\(]*}\({[^ ]*} value __gc\[\]\);
Replace: property \1 { void set(array^ value); }

Combine RegExp
==============
Find: property {[^ ]*} {[^ ]*} \{ [^ ]* get\(\); \}\n[^p]*property \2 \{ void set\(\1 value\); \}
Replace: property \1 \2 { \1 get(); void set(\1 value); }

Use the following in order per .cpp file:

Get
===
Find: get_{[^(]*}\(\)
Replace: \1::get()

Set
===
Find: set_{[^(]*}\({[^)]*}\)
Replace: \1::set(\2)

References

MSDN Translation Guide

Herb Sutter’s Blog

Wikipedia

Internetizing My Ethernet-wired Townhouse

Sweet Panels

When I first moved into a new townhouse, one thing I was very excited about was that nearly every room in the house had a panel with not only a cable port and a phone jack, but an RJ-45 jack as well. In other words, it’s wired with Ethernet ports all over the ‘house.

So the first thing I did, naturally, after connecting my cablemodem on the main floor to my wireless router, was make sure my wireless internet was working. It was, but the signal wasn’t so great on the bottom floor, where my desktop is located. In fact it was a bit flaky, giving me a hard time connecting initially and also having random disconnects. Not so great. In order for me to get reliable internet, I’d have to either run my 50-foot ethernet cable from the main floor to the basement, or I could get these ports to work.

Maybe it will just work?

Ever optimistic, I plugged in my desktop into the wall, and then I plugged in an ethernet cable between my wireless router and the wall. Maybe there’s a switch or something somewhere! Maybe it will just work!

Well, it didn’t. My computer was complaining about a network cable being disconnected. I assured my computer that I really did connect an ethernet cable from it to the wall but it still wasn’t happy.

Internets to the rescue

I did a quick search, and I can’t remember what I searched for, but the forum responses mentioned something about opening up the patch panel in the master closet. After removing the panel with the help of my trusty screwdriver, I found this inside:

At first I was a little confused. It looked to me like all these ethernet wires were already connected in that circuit thing. But what were the ports for then? That’s when I realized, these ports are just wired up to the cables, and are not connected to each other in any way. They just happen to be in the same junction box. To connect them, I’d need my own separate switch; ideally the internet connection from the wireless router would be able to connect via the switch to all other clients and give them IP addresses and internet access. That was my theory. So I rounded up my switch and as many cables as I could find and here’s what it looked like:

The Test

Anyway, I went back down to my computer, disabled/enabled my ethernet card, and prayed for mercy (and an IP address). Sure enough, I got 192.168.34.5. Good news! Now for the real test:

It works! Yay! And just in case you were confused, here’s a diagram:

Hope this helps anyone else who found themselves in possession or rental of a home with pre-wired Ethernet ports.

Musings on PAX 2009

Having recently moved to Seattle, this year was the first time I was able to attend the Penny Arcade Expo, despite having heard quite a bit about it during my frequent trips to penny-arcade.com. Unfortunately I only managed to secure tickets for Friday and Sunday, because the 3-day and Saturday passes sold out before I finally got around to buying tickets.

Panels – Friday

Game Design 101: I attended this panel thinking it might have some insight on some basics on how to design a game that would be interesting and fun. But the panel focused more on giving advice to aspiring game designers, some discussion on the difference between game writers and designers, and anecdotes from the game designers’ careers. I was a bit disappointed with this one.

Breaking into the Game Industry the Educated Way: I really enjoyed this panel; several panelists from gaming universities and businesses offered their opinions on the value of pursuing a degree in a games program, such as the ones offered by Digipen and Guildhall SMU. For one, attending a multi-year game development program shows that the student is willing and able to make a commitment to making games, and offers the opportunity to make lots of games and develop lots of contacts. But of course you have to weigh that against the tuition and opportunity cost as well. Ultimately, the consensus opinion was that a successful applicant to the highly competitive games industry needs to demonstrate their experience with game programming with as many high-quality game projects as possible, whether created in an academic setting or on your off-hours.

Penny Arcade Q&A #1: I don’t remember too much from this Q&A panel where Gabe and Tycho fielded questions from the audience, but I do remember that I was laughing almost the entire time.

Panels – Sunday

Penny Arcade Q&A #2: Also hilarious. This was the first panel I attended on Sunday.

Retronauts – The Secret Best History of Gaming: This was a humorous and interesting panel where the members of 1Up’s Retronauts Podcast showed their favorite old-school Penny Arcade comics and how they demonstrate a historical perspective of gamer sentiment over the years, including topics such as Dreamcast and Daikatana. Very amusing.

I also missed several panels that I would have liked to see, including Wil Wheaton’s Awesome Hour, The Guild Season 2 Screening, and of course all of the panels on Saturday.

Expo Hall

It took me a while to find the expo hall, because it was so far away and hidden from the rest of PAX. However, this was definitely the most interesting way to waste time between panels and events. I got to play 20 minutes of Starcraft 2 and 10 minutes of the new WoW: Cataclysm starting zones, played a quick team battle of Global Agenda, and got lots of swag. I also watched some other players play Diablo3, and saw a demo / Q&A of the new DotA “killer”, League of Legends.

PC Freeplay

This was the other main way that I wasted time inbetween panels and events. It was strangely fun playing Team Fortress 2 and Counter-Strike: Source with some other random PAX attendees on the LAN. I also had enough time to check out the game that Tycho and Gabe produced, On The Rain Slick Precipice of Darkness. It was actually pretty fun. The free play area was sectioned off from the Bring Your Own Computer area, and during all three days there were game contests going on for various games.

Game Rooms and Console Freeplay

I was blown away by what was going on in the Console Freeplay room, where basically you get assigned a TV and a console, and can borrow games to play as if it was a library. They also had high score contests on some classic games like Mike Tyson’s Punch Out and Mega Man 2, but unfortunately I didn’t get to spend much time in there. They also had a number of game rooms for Magic the Gathering and various board games, such as Settlers of Catan, which I also missed out on.

Concerts

I missed the Friday night concert because I had some friends who were hanging out in the bar at GameWorks. I heard it was pretty good, but so is grabbing a pint with some friends.

Signatures

I waited in a strangely short line to get Jeff Lewis and Sandeep Parikh’s autographs. You know, those hilarious guys from The Guild? I also spotted a short line of people standing in front of Tycho as I was finishing up my Taco del Mar, and got him to sign my Instruction Book. He seemed like a real nice guy and I only had to wait like ten minutes.

Summary

All in all, it was a very fun event, and I only wish I had had more time and more friends who had come. Next year I will probably get my ticket much earlier and convince my friends to come with me.