Designing Metro style apps on Windows 8 can be challenging just like any other new platform.  It is especially challenging on a platform that’s so radically different than its predecessors. The most fundamental part about abiding by Metro standards is to not lose your brand’s personality and unique elements in the process.  Metro as a design style should never replace your brand as a whole.

Using Metro as a foundation along with your brand’s style guide is key.  It’s a common misconception that every app will look the same if you’re using Metro properly.

Beyond the squares and tiles there is a well-established grid.  Beyond Segoe there’s the concept of a well-designed typographical-based layout.  Utilize your brand’s rhetorical elements and unique shapes.  Although Metro standards emphasize ‘content over chrome’ it doesn’t mean to throw out chrome altogether.  It means to use it sparingly and only when it makes sense.

A brand creates valuable emotional connection between a customer and a product or service.  The components of a brand will leave lasting impressions on its customers and this is what makes the product unique.  These components shouldn’t be thrown out to make room for Metro standards; they should simply be re-considered.  Brand elements such as messaging and voice, typography, rhetorical elements, logo usage and placement, color schemes make up the personality and identity of the brand.  They should be leveraged to differentiate the company in the marketplace.

So how do you find the perfect marriage between Metro and your brand? The answer is to revisit your brand’s core fundamentals.  Very few brands have “iPhone style app bar” as a core brand principle. Most brands focus on emotion through color and photography, typographical hierarchy, and a mission statement of their intended user perception. Returning to these key elements is the best way to adapt to the new Windows platform and will produce extremely compelling apps. So where do you begin when thinking about returning to the basics?

TYPOGRAPHY

First of all, you don’t HAVE to use Segoe for everything.  Segoe is ideal for large bodies of text or for captions in the same way you would use a web safe font (pre CSS3) on a web page.  Use brand specific fonts in areas that will showcase your brand, like for headings.

Metro favors the use of typography over buttons with gradients and strokes. The list view is a common Metro section layout that features typography really well. This could also be a place to feature your brand’s unique typefaces.  Although brand fonts may be used, it’s a good idea to abide by the metro type ramp.  It’s flexible and helps keep the integrity of Metro while providing options.

PLAY WITH THE GRID

Don’t get stuck on the simple square grid layouts.  If you are using the hub and spoke navigation model and developing a panorama view as your hub, make it interesting. Use different sizes to indicate importance or what ever is relevant to what you’re trying to convey.  Use compelling imagery in your tiles; think about weight, proximity and color usage.

You don’t even have to use the hub and spoke model if your experience doesn’t require it. Explore other navigation models.

Hub and Spoke Navigation Model

KNOW WHEN ‘CHROME’ HELPS

I LOVE the concept of content over chrome.  Sometimes designers (myself included) will over design things to the point where there are too many bells and whistles, even if strategically placed.  These additional elements often get in the way of what the designer is actually trying to convey.  The first rule of Metro standards is content over chrome; it is meant to embody the concept that less is more. Be selective of what needs extra visual treatment to support your end goal. Unfortunately some of the apps that have early adopted this platform have a sea of black text that could be easily broken up by supporting visual elements or compelling imagery.

It is especially evident on displays with higher resolutions or different aspect ratios.

This is why it takes a skilled designer to work on a Windows 8 app.  How do you find the perfect balance between too much chrome and too little? Chrome should be used sparingly and only when it makes sense.

A great place to use a small amount of chrome is to differentiate between list items that have multiple data types. A simple background shift between each item could help the user identify each item better.

Is this adding a little bit of chrome? Yes. Is it still keeping the content king? Yes. “Content OVER chrome”…not “Content ONLY.” The key is to eliminate the problem where people get frustrated by all the unnecessary UI that smothers the content they are looking for.

If your brand is recognizable through unique forms, patterns, and rhetorical elements, use them appropriately.  Don’t get stuck on squares.  Introduce diagonals or circles in the background or within a content tile to indicate fresh content or to distinguish one element from another.

There will be times when a simple square will be enough but if you’re trying to create a unique experience, your layouts and applications should not be templates.

These methods of retaining brand voice through layout design are key for having a successful and memorable app. Metro standards guide the design to be grid centric, have beautiful type and keep the content front and center.  The same can be said about designing for any platform.  Remembering this eliminates the theory of: Metro = squares and lists.

Despite some criticism, Windows 8 is an excellent playground for designers looking to create unique and functional experiences.  It also is a great place for a brand to shine.  As long as Metro is used as a foundation rather than a template to just swap in text and background images, a designer has the opportunity to create unique brand experiences that are both compelling and easily digestible.  Metro is rooted in some of the best design principles in history and emphasizes good guidelines to keep in mind during the design process.

To view this sample project and to learn more about building great Metro apps please visit: design.windows.com

This is the second part of my impressions of Windows 8. You can read the previous part here.

The Impressions

1. Windows 8 and the Cloud
2. Using Windows 8 on a Slate
3. Using Windows 8 on a Laptop
4. Using Windows 8 on a Desktop
5. Desktop IE vs. Metro IE
6. Frustrations of Being an Early Adopter

Windows 8 and the Cloud

© Filip Skakun 2012

Metro style apps are limited in their ability to access system resources such as files in arbitrary locations on the disk. This though has been mostly true for a while now, since Windows Vista introduced user access control. This is a good thing and makes managing your files easier, but it is also a stepping stone to the future in which we will increasingly rely on the cloud to store our files. Local disks will be used as application storage and local cache of the data we currently use or might need when offline, but what we already see in online backup and file sharing solutions like Carbonite, iCloud, the rumored Google Drive, Dropbox and SkyDrive — is bound to slowly become the primary copy of our data — secured from accidents, hardware failures and hackers better than our own devices while allowing to conveniently access our data from any device.

Windows 8 adds built-in user and developer support for SkyDrive integration. You can sign into Windows with your (Windows) Live account, which then automatically syncs your profile settings across all Windows 8 devices. Apps can easily use roaming settings that are synchronized between all the devices. Internet Explorer shows the same bookmarks for — again — all your devices. Your data travels with you everywhere taking away the pain of having to micromanage your documents, settings and any other data, and copying it back and forth. I can’t wait to dump all my backup drives, thumb drives and stop worrying about backing up and creating many copies of the same data on my phone, slate, laptop, desktop and XBOX, at home, in the office and on the road.

Using Windows 8 on a Slate

© Filip Skakun 2012

The tablet I use is a custom version of the Samsung Series 7 Slate that was given out to developers by Microsoft at the Build conference. This is my work machine and I mostly use it with an external 24-inch monitor and a basic full size keyboard. It is slightly bigger than the iPad — at 11.6-inch vs. 9.7-inch and also a bit heavier and featuring a built-in fan. Not exactly an iPad competitor since it is about twice the price, but with my setup I can use it for developing apps on a big screen with all the peripherals I want to connect to it, and when needed I can just pick it up from the dock and use it the same way I would use an iPad. With smaller devices getting more powerful while the computing tasks have not become much more demanding since the popularization of video or HD video especially — I can easily imagine many people in the future might choose to use a Windows tablet that they can carry with them to do some lightweight computing or consumption and dock it anywhere when they need to do something more demanding like programming. This is not something that you can do today with an iPad and this popular photo shows best how an iPad relates to a PC — being just an accessory. Windows tablets might get a lot better appeal as something that is not only a cool expensive gadget, but also a tool to be used for more serious tasks such as making money.

I have not had a chance to use the tablet much in slate scenarios that iPad rules today — mostly because this is a work machine and it sees majority of its use in developing and prototyping new Windows 8 apps but also because I am not a heavy iPad user. I really prefer to have a mouse and keyboard, ideally a full-sized one to use a computer comfortably. I use an iPad occasionally to play a game, check mail, or look at some other app when I am lying in bed or sitting on a couch and the iPad happens to be within reach. My iPad is mostly used by my kids and I can see great educational potential of such devices having seen my daughter who is beginning to read before turning four year old. I do not think the iPad is the main reason she is doing well, but I am sure it helps and similar devices will continue to help kids learn more quickly than was common when I was a kid. Windows 8 has great potential here. I think the user experience on the Windows tablet is better. The current selection of apps available is limited compared to iPad which had a head start, but this will change very quickly. There are thousands of apps available on iOS, but not so many of them are great and it is certain that most of the great apps will also come out for Windows 8 soon, possibly with improvements over their iOS or Android counterparts while new great apps will often start appearing on Windows first, since this is reportedly also an easier platform to develop for.

One area where Apple has ruled without much successful competition is hardware design. The iPad at prices starting at $399 and being most fashionable gadget today seems hard to beat having resisted the offensive of various crops of Android slates and only losing in lack of a cheap version under $200 where Android-based devices rule, but just as the iPhone seeing strong competition from Android-based phones, the iPad will not last forever as the only contender in the slate game. Just as we are beginning to see emergence of great Windows Phone devices such as the HTC Titan II or the ($99!) Nokia Lumia 900, I think we might see competitive Windows 8 slate devices from Samsung or Nokia that might compete in price as well as design with the iPad while potentially also being full-featured desktop PC replacements, which cannot be said of the iPad.

Using Windows 8 on a Laptop

© Filip Skakun 2012

My laptop is a now 1.5 year old Lenovo T410s with multi-touch screen, a 160GB SSD drive and 8GB RAM. Perhaps not a typical laptop due to the touch support, although possibly a much more common setup in the future when the touch-friendly Windows 8 gets released (I am keeping an eye out for the Lenovo Yoga, an ultrabook with a touchscreen that also converts to a tablet!). Installation of Windows 8 Consumer Preview on the laptop took around 10-15 minutes, so does upgrade from an older version which I am happy to see also kept all my installed applications and settings, which is great, since it usually takes me hours if not days to install all the software I use on a fresh install of Windows and I believe older versions of Windows were not able to port these over during upgrade.

Except for the previously mentioned 8s cold boot time, the system also resumes from sleep in under 2s, seems to manage battery better and run more quietly. There are no driver problems except for the missing touch input driver I talk about later that should not be common since this is an uncommon type of device. Also, I expect Windows 8 to mostly be used on new devices while I also recommend trying to install it on older ones, since it brings so many improvements over Windows 7. Have I forgotten to mention Windows 8 also uses less memory? This means leaving more of it to applications, and practically lower hardware requirements than Windows 8 or Vista.

I do not use the touch screen much right now since without the proper driver it does not work too well, although I can vouch for the convenience of having a touch screen on a laptop. Any time I can’t find a mouse I can just touch the screen. Scrolling web pages with fingers is much more natural than scrolling with a mouse, so is browsing and consuming a lot of other types of documents and content. Drawing is easier with a finger than a mouse, so is navigating maps and… well, developing multi-touch software. It might also help reduce the risk of repetitive stress injuries if you often switch between different input devices depending on which one feels most comfortable at a particular time. With Windows 8 using the OS with touch is also easier than with any other OS out there.

Using Windows 8 on a Desktop

© Filip Skakun 2012

For some reason installing Windows 8 on my desktop was quite a bit harder than on my laptop or the tablet. Possibly a driver issue caused the screen to go black during the installation multiple times and while I believe it was only a problem of display — I had to restart installing the OS multiple times before I managed to reach the point where the installation would progress without my input, so even when the screen went black, restarting half an hour later showed it booting to Windows 8.

I have no touch screen display on my desktop, although I cannot wait to start seeing affordable 24″ or bigger true multi-touch screens which I hope will start showing up soon when Windows 8 comes out. Using touch on a desktop screen is not as natural as on a slate and not even as convenient as on a laptop, but I keep getting into situations when I touch the screen and I am surprised it does not work. Touch input really becomes a natural (even if only alternative) way to interact with a computer once you have used it for a while. It is not the best way to input text or event to play most types of games I like, but it is as natural as mouse and keyboard in some scenarios.

Overall having installed all the applications I used to use in Windows 7 to Windows 8 — my desktop is now mostly used from Windows 8, although I have it installed in dual boot mode just in case. The machine was put together with my very own hands and as far as I remember is an Intel Core i5-powered, 4GB RAM, 2+2+1+1TB HDD with 3-4 year old AMD/ATI Radeon graphics and since installation functions mostly without issues. It does sometimes refuse to shut down when I tell it too, but on the other hand, it has leverage over Windows 7 in that it turns of unused hard drives reducing the jet-like noise that the machine used to continuously generate before turning it into a quiet PC.

Desktop IE vs. Metro IE

© Filip Skakun 2012

I see a good reason for having two different browsing experiences. Web applications look beautiful in a browser without chrome. Using a computer without a keyboard and mouse is very limiting in the number of things you can do at a time, so looking at one website at a time makes most sense and seeing all the tabs that are open at the same time is not as useful. In desktop view I expect more power, a HUD of sorts that will allow me to orient myself better in the dozens of tabs that I tend to keep open in a browser at the same time, switching between different apps and so on. The Metro experience is more focused on one thing. Not allowing for browser plugins in the metro experience makes sense if it saves battery and helps push the web technologies forward, although might be annoying sometimes if you know there is a version of IE that can run on desktop that does run both Flash and Silverlight. I really do like the sharing of bookmarks between all my machines. Perhaps the desktop version could actually look and work more like the Metro version does and I believe it was left alone mostly so that the team could focus on the Metro version. I think maybe by the time Windows 8 is released or soon after — we might see the desktop version of IE modified to show no chrome by default until the user right clicks needing to type in a new address or switch a tab with a mouse. The web truly looks better with no chrome.

In fact the web looks so good without chrome that future web applications will likely become more powerful not unlike today’s desktop applications and will replace them in many scenarios while users will not see a difference. Currently you can develop applications for Windows 8 using HTML and JavaScript which are the same tools you use for developing web pages and web apps. Microsoft augments the framework allowing developers to create good looking and nicely animated Metro style apps with full access to the OS fairly easily but it also means that these applications will not run on any other platform and will not be easy to port either — it merely uses some of the familiar skills that today’s web developers can use to develop Windows 8 applications. As the tools continue to improve, doing similar applications should become as feasible for other platforms too. This in turn will allow for creation of a single application for all platforms having to only take into account the screen size, resolution, input methods and system features when creating different versions of the experience, but that I believe is still in the future farther off.

Frustrations of Being an Early Adopter

© Filip Skakun 2012

Not everything is rosy if you are trying out a new operating system early. The list of things I had to suffer contains the following:

1. The old N-Trig touch input drivers for my laptop do not work on the current build of Windows 8. There was a workaround to use them in Developer Preview, but it does not work anymore. Windows 8 class drivers for touch seem to work at first — I can see touch input visualizations for my fingers, but they are very shaky and I can’t tap on buttons, etc. Using touch to scroll or unlock the screen still works though. The new drivers only showed up on N-Trig’s website moments ago today.
2. TurboTax complained for a moment that my operating system was not supported even when I used it in Chrome. It seems to have accepted it now though.
3. The VPN client I use does not work with Windows 8 yet and it seems like there might be a workaround using a generic VPN client application, but I have not been able to get it to work yet, so when I need to work from home — I am a bit disconnected since I can’t access some internal company resources, although I am sure if I really had to, I could get it to work even now with the workaround.
4. The WinKey+S shortcut that used to work with OneNote to grab a screenshot of a selected piece of the screen did not work at first. I used to use it quite a lot, so I was unhappy when I saw it not working. Fortunately it came back – possibly after a reboot which is an uncommon event in Windows 8…

These problems and a few others have been minor annoyances, but I am sure they will be resolved by the time Windows 8 is released and overall even now are outweighed by the improvements you get from the new OS.

I have been using the Windows 8 Preview For six months now – the Developer Preview since its public release in September and more recently, the Consumer Preview that was made available in February.

I have used Windows 8 on a tablet, a touch screen laptop and an old desktop and the experience has been good on all of these platforms. I have used it for anything from developing Windows 8 Metro style apps, through typical Office applications scenarios, browsing the internet, playing games, listening to Spotify, instant messaging etc. What I have not used it much for actually is to run Metro style apps, except for the ones I was developing myself, since there are not so many available yet (around 100) and the ones available do not fit into my daily use of a tablet or computer.

I have been using most versions of Windows available in the past 20 years or so. I have also been using an iPad for a few months now. I think Windows 8 is going to be huge…

The Impressions

1. The Desktop
2. The (Missing) Start Button
3. The Start Screen
4. Metro Style Apps
5. Windows Marketplace
6. Next Up

The Desktop

© Screenshot by Filip Skakun 2012

I am a developer and I spend most of my time using keyboard Visual Studio, Chrome & Internet Explorer, Paint, Total Commander, Notepad, Windows Explorer, etc. Desktop is my world. It has not changed…

Well, it has changed in some ways — now Windows boots up in eight seconds instead of 8 minutes, the Start button is a lot smaller and completely transparent and all the corners of the desktop are now buttons of sort even though they are invisible. The Windows Explorer uses a Ribbon interface now, if you use two or more monitors — you now get the taskbar on all of them without the need for third party add-ons, the file copy menu looks nicer now and so does the task manager. There are some more advanced features I have not used yet, and I am sure thousands of imperceptible minor changes but overall, nothing has changed in the way I use Windows since I switched from Windows 7 to Windows 8. I only get a feeling like here and there, this thing or the other works better — IE 10 is a bit better than IE 9, Windows installs in like 10 minutes. Opening an ISO file in Windows Explorer displays its contents as if it was a folder while also mounting it as a virtual drive — possibly opening us up to the future with no CDs or DVDs required to install any (even legacy) desktop applications or games with no need for third-party tools. There is a built-in viewer for PDF files, so you don’t need to install the 50MB beast from Adobe that requires a new update every day. There are things like these scattered all over the place.

One very minor issue that sometimes hits me in the desktop is that Chrome displays tabs starting from the top left corner of the screen, so sometimes instead of switching to the first tab, I switch to another app. Maybe one more reason to switch back to IE?

The (Missing) Start Button

© Screenshot by Filip Skakun 2012

There is no visible start button now. There is a popular video that is making rounds on the internet that is trying to prove that this is a big usability problem, but is it a problem really? When I first saw the desktop without the button I felt like there was a disconcerting void where something familiar used to exist for almost 20 years now. Personally, I see no benefit in getting rid of the button — the space savings are really minor compared to potential problems with usability, but once you start using it — you get used to it missing really quickly. You can still click the bottom left corner to bring up the Start Menu — the difference being you now have to move your mouse cursor to the very corner of the screen. In terms of everyday usability, it is just as easy if not marginally easier than what you might have been doing before — if you were like me, trying to point at somewhere near the center of the old start button before clicking. The problem might be if you are one of the few people who move their taskbar somewhere else than the bottom of the screen, which in previous versions of Windows also moved the start button. (I would argue though that in these cases you moved the taskbar to rearrange your space and having the start button move with it was not as crucial for you.)

Coming back to casual Windows users confused about the lack of the button — I am sure Microsoft will at least introduce some cues to indicate where to move the mouse when you first switch to desktop, the same way they have done before to educate users on the Start button in Windows or the glowing Microsoft Office Button that was introduced with the Ribbon in Office 2007 to open the Backstage. I am sure people will first be surprised when they do not see the button there, but many will be happy to get rid of an unnecessary ornament on the screen, especially if they are like me and already use the start button on their keyboards instead of fiddling with the mouse.

I would speculate that Microsoft might give in and bring back the start button to address the critical comments. Perhaps the only reason it is gone now is as an experiment and due to lack of time to switch to a design with a new logo. It is also possible that they will get rid of Aero Glass and make the desktop chrome more flat and Metro when they finally release Windows 8. Also — since they make corners and borders of the screen such important UI elements — they could also make the taskbar auto-hide by default to reduce unnecessary chrome.

The Start Screen

© Filip Skakun 2012

There is no Start Menu as we know it in Windows 8. It was replaced with the Start Screen, which is the most visible change in Windows 8. It takes design ideas from Windows Phone, introducing large active tiles instead of a grid of dead small icons with tiny labels seen on other phones or desktop UIs. Instead of a small menu in the corner of the screen that you had to squint at, you have the whole screen to fill with easily readable tiles that serve the same purpose — to launch applications, but also display additional information that allows you to get information you might be looking for without even starting an app. I think this is a good idea. Gone is a multi-level-nested hierarchy of app folders that made things discoverable if you went on exploring the menu, but not really useful for starting applications. You can still access all installed applications in the Start Screen by searching or clicking on the “All apps” menu.

Since Windows 7 I would usually only start applications I pinned to the taskbar or less frequently used ones that I had pinned inside of the Start Menu. This still works, but now instead of having them pinned in the Start Menu, I have them pinned on the Start Screen with some more options to rearrange them. If I had to launch an application only once — I used to just type its name in the Start Menu and a link would show up. It still works on the Start Screen, only it is easier to read. There is no important scenario where having a Start Menu showing up in a corner of the screen would work better than having the big Start Screen that grabs your entire attention on the task of finding an application to run.

Will the old Start Menu be available as an option? I think it is possible but not likely. It seems like the Start Screen has already made it to Windows Server 8 too now, so although its design was possibly driven by the consumer version of Windows, it works just as well on the server. The often repeated comment that this could be an option for enterprise deployments to save on the costs of user education does have some sense, but I do not think it is correct. Changing an OS is always a change and users will always need to learn something new. If you let enterprises upgrade to Windows 8 while keeping the old Start Menu — how about users who get into Windows 8 at home, use the Start Screen and then go to work and see the Start Menu? That would also require education I am sure. Also — live tiles would not work inside of the start menu, so how about disabling Metro style apps altogether? Well, but about the case when some applications start becoming available only in Metro Style? Also — I am sure it is Microsoft’s goal to have as many people using Metro style apps as possible, since it brings Microsoft money, so they would not pass on that. Then there is also the problem of maintaining two parallel versions of an interface serving the same purpose. It has been historically possible to switch some things in Windows to how they were — e.g. in Windows 7 you can disable combining the tab buttons in the taskbar and switch to small buttons & labels — the same way it had worked since Windows 95. I do not really recommend doing that though since the new Windows 7 version is better. I am sure few people know about it being possible and I believe it has happened under different management. Now with Windows being ruled by Steven Sinofsky and his team who forced the world to use Office with the Ribbon and did away with the old toolbars — I don’t think it is likely to leave two competing versions of quite complicated UI — that would be just too difficult to maintain.

There is one valid criticism I have heard about the Start Screen — if you press spacebar once — you select a tile, if you press it again — you unpin it. This seems like a dangerously simple way to accidentally get rid of your pinned tiles and for millions of support calls to Microsoft if this does not change before release.

Metro Style Apps

© Screenshot by Filip Skakun 2012

With Windows 8 Microsoft is adding a completely new technology for developing software. The new framework is called Windows Runtime and while the old WinAPI and related technologies layered on top of it are still available for developing desktop applications, Windows Runtime (or WinRT in short) is required for developing the new Metro style apps. The new framework and applications are sandboxed which means they have limited access to system resources and other applications installed on the computer which is a requirement to allow for a trustworthy app store where developers can easily publish apps and users can easily buy them at very reasonable prices.

The new technology limits applications developed for Windows from causing harm, but it does not really limit them from using the full processing power of the machine and Microsoft has learned their lesson from Windows Phone where — especially initially — developers had very limited access to the features of the devices making a lot of the more interesting applications that were available for iOS or Android devices impossible to implement on Windows Phone. Developers can create these new applications using lowest level, close-to-the-metal native technologies like DirectX while also having access to very popular and productive languages like C#, Visual Basic and JavaScript. The more liberal access to the features of the device compared to Windows Phone allows for a wide range of new classes of applications to be developed. Based on the rumors of the next Windows Phone sharing the core components with Windows 8, I am also expecting the next crop of Windows Phone applications to have access to many of these features and languages giving Windows Phone a bigger chance at growth and competitiveness against iOS and Android ecosystems.

Metro style apps on Windows 8 can be developed using C# and XAML, the same technologies used in most Windows Phone applications — the difference being that they use WinRT instead of Silverlight. Although from a developer’s view there is very little difference between these two platforms and WinRT being a lower level platform than Silverlight has potential for better performance as was shown in an article by Jose Fajardo (who is one of the more known experts writing about WinRT).

Metro style apps have features that are already familiar to Windows Phone users — such as live tiles and Metro design language. These things are evolving though, and becoming more powerful in Windows 8. Live tiles can be made even richer than in Windows Phone 7 and controls in the Metro user interface are evolving to be more usable in both mouse & keyboard and touch scenarios. Implementation of fluid transitions is now easier than ever before with built-in animation and transition libraries making it a lot easier to create a Metro style app that shines.

The XAML Disciples – a group of expert XAML developers that is made up of the early adopters and experts of WPF and Silverlight — seem to have mostly negative thoughts or no interest ([1], [2]) in the new technology. It seems like this comes mostly from lack of trust in the future of Windows or lack of applicability for the typical types of enterprise projects they are used to working on, or weariness after having experienced small changes between a series of similar frameworks coupled with limited interest expressed from Microsoft’s side in further development of WPF and Silverlight. Microsoft instead seems to focus on developing a new development framework for every new scenario that comes up, i.e. WPF – being the first framework for developing rich applications for Windows, Silverlight being its version with a promise of being cross platform compatible or a Flash killer, Silverlight for Windows Phone being its yet another flavor and WinRT’s XAML framework being yet another take on it that is being rewritten for Windows 8.

While I understand these pains, I disagree with the criticism. Each new platform is a bit different and requires a different approach, i.e. sandboxed environment required for running apps on the web or hosting in app stores is not really available in WPF. WPF is also too heavy to run on the web. The interoperability of WinRT and improvements in implementation in Silverlight and then WinRT are also important reasons for rewriting the framework. Also you have to appreciate how little you need to learn to switch to a new XAML-based technology after you have already mastered one. WPF and Silverlight are also in most ways feature complete and Microsoft has likely reached diminished returns on investments in these technologies, while a new one will benefit its customers more. The fact that WinRT might not be applicable for many enterprise applications might hold true for a while, but as with Windows Phone — the main target of Windows 8 is not enterprise customers. Microsoft is trying to fight a battle for minds of consumers already learning to live with Apple’s and Google’s competing technologies — the fact that could cost Microsoft its dominance in OS in the future if not addressed with something exciting and superior. I believe Windows 8 is such thing. Enterprises are now used to switching the OS every two years and have mostly last done so with Windows 7, so it won’t harm Microsoft much if they wait till Windows 9 before getting ready and realizing WinRT is already a very valid platform for many scenarios and will surely improve to become a great one for developing business software too.

The Store

© Screenshot by Filip Skakun 2012

A billion Windows users, even if only slowly upgrading to Windows 8, make Windows Store a very attractive platform for growing an app development business. Most of the excitement and business opportunities for developers in recent years have been in web development with a switch to mobile development in recent years. Microsoft is far behind in this game, but I would not ignore the sleeping dragon. Windows will continue to be the most popular platform for desktops and laptops and Windows Store will fill a void finally enabling Windows developers to easily access the wallets of its gigantic user base. It will compete in the mobile space with established platforms from Apple and Google, but PC users have not had access to such a store until Windows 8. This is bound to breed a lot of innovation and rejuvenate the Windows ecosystem. Big development houses and brands like Adobe or Electronic Arts have achieved a level of familiarity and trustworthiness to be able to sell their software through their own online storefronts or could sell games through Steam, but Windows Store will allow millions of individual developers and small companies to share their ideas with hundreds of millions of users willing to pay for them or sell their attention to ad networks. I can easily see all future Windows games becoming available through the Windows Store. Is it the end of software on DVDs and GameStop? Not in the immediate future, since desktop applications will not be sold in the store except for perhaps one coming from the big software houses and it will take some years for most users to upgrade to Windows 8 and later versions of Windows, but especially for games — it is bound to happen soon. PC games are already increasingly being sold online through existing channels and another major one will surely accelerate this process.

Next Up

This was the first part of my impressions of Windows 8. The second part comes tomorrow and I will talk about the following:

1. Windows 8 and the Cloud
2. Using Windows 8 on a Slate
3. Using Windows 8 on a Laptop
4. Using Windows 8 on a Desktop
5. Desktop IE vs. Metro IE
6. Frustrations of Being an Early Adopter

Finally, the long awaited Part 2 for Making a Game Out of Tower Defense.  Good thing too, considering we went gold at the end of last week!  Please grab the game here.

A brief recap follows, in case you didn’t get to check out our first post located here.   Our team at Vectorform was tasked with revamping our chart-topping iPad game Galactic Alliance.  We were asked to create new enemies, new towers, new levels, and to round out the game with some of the more common features seen in other tower defense games.  Our first post discussed what tower defense is, the new towers seen in the game, and how the towers are introduced across our levels.  In this post I’d like to discuss our new enemies and some of the strategies involved in taking them down.

Galactic Alliance is an open map style of tower defense.  Players can place turrets wherever they would like on the grid and creeps (the bad guys) will travel the shortest path between their position and their goal.  The only rule is that you can’t completely block off the creeps’ path.

Many tower defense games have the grunt (the standard enemy), the fast ones, the tanks, and flyers (enemies that don’t have to follow the path you laid out for them).  Galactic Alliance 2 has all of those and a few other creative mechanics that our enemies execute as well.

Flyers can really throw a wrench in the game, especially when they b-line straight down the middle of the field and avoid half of your strongest towers.  However, once you know they’re coming, you can build your strongest towers where you need and destroy them every time.  In order to keep players guessing we’ve introduced creeps that “phase” through space.  They are still bound to your path, but will periodically disappear and re-appear further down the grid.  The goal of these were to encourage the player to leave some money for urgent tower building, and to build a flexible path instead of, for example, building all their heaviest hitters around a single booster tower.

Galactic Alliance 2, like its predecessor, is a four player cooperative game.  We wanted to take advantage of that unique characteristic by introducing an enemy which would be periodically immune to each player.  These are lovingly referred to as “camo creeps” and will cycle through the four player colors as they travel down the map.  In this way, camo creeps are very similar to phasers in a single player game, but playing with friends makes them next to no trouble.  (Play with friends!  It’s a lot of fun!)

The phasing and camo creeps are two unique types that we’ve introduced.  We’ve also riffed on some of our previous types, pushing the bounds of what is considered “an upgrade”.  In many tower defense games, an upgrade entails a new piece of artwork on an enemy that has more health and moves faster.  Our enemies are already constantly gaining health through-out the game, so this mechanic didn’t seem to serve much of a purpose other than to introduce new artwork.  We did something slightly different with the upgrades instead.

GA2 explores the variety of groups of enemies more than its predecessor.  Each enemy has a faster version as well as a version that is often seen in tight packs.  While these variations maintain the same base characteristic as the core creep, they challenge the most tried and true strategies.  One of the most prominent examples is the super fast scouts, those guys are brutal.  They aren’t a typical upgrade because they have much less health than other scouts, but if you aren’t watching the game these scouts will punch through your defenses quickly.  Keep an eye open for these new varieties of enemies!

Hopefully you enjoyed our overview on creeps, the new types we’ve introduced and some of the strategies to take them out.  Please comment with any questions, thoughts, or encouragements, they are always appreciated.

Thank you!

C# 5.0 comes with the new async/await keywords that make asynchronous code easier to write, read and maintain. This is very nice if you have properly declared methods that support this pattern and Windows Runtime (or WinRT – the API for Windows 8 Metro Style Apps) comes with a lot of these methods for long running tasks or ones of nondeterministic duration – especially in I/O or web calls. It is however completely lacking in support for asynchronous UI development, even though one of the main goals of these new keywords was support for responsive UI.

Interactive coding often introduces the need to start an operation, like an animation or a dialog box and then wait for an event before switching the state of the UI, for example: running another animation or removing a dialog. Reading this article you will learn how to do it better using the upcoming features of C# 5.0, regardless of whether you develop in WinRT, Silverlight, WPF, Windows Forms or even Web Forms. The source code that comes with this article contains a library you can use to cut the amount of code you need to write by half!

UI development of today and the past

If you develop applications using .NET Framework  you probably have to deal with a lot of events, event handlers, event subscriptions, state machines, flag fields, helper types, etc. If you want to sequence a series of state transitions that depend on events you have no choice but to break up the logic of your code into separate methods and event handlers, subsequently your code quickly gets a bit ugly and hard to follow.

For example, if you want to run some code after an animation completes you would have to add an event handler to the “Completed” event first, then start the animation in one method and finally execute the rest of the code from the event handler a bit like here:

public void RunAnimationThenDoSomething()
{
    storyboard.Begin();
}

private void storyboard_Completed(object sender, object e)
{
    DoSomething();
}

It seems fairly straightforward unless you have to remove the event handlers or have five other similar actions in a sequence – timer delays, waiting for button clicks, conditional blocks etc.

You can keep the code a bit more compact if you use lambda expressions, reactive extensions or iterator blocks, but they also make it more complicated. How about wrapping all the plumbing in #region blocks and collapsing them to leave only the logic visible in sequence? That would kind of work, but no.

In come async and await keywords…

How about getting rid of half of the event handlers, event subscriptions etc.? Let’s take a look at what you can do today if you develop for WinRT/Windows 8 or if you install the Async CTP or what you will be able to do in the near future.

WinRT does not help you much in terms of support awaitables in the UI classes, although you can wait for web requests, basic dialogs or just use Task.Delay() to delay execution:

await new HttpClient().GetAsync(uri);
await new MessageDialog("Done!").ShowAsync();
await Task.Delay(1000);

How about a single method call to wait for your UI to load, one to wait for a second, one to run and wait for a storyboard to complete, one to wait for a button click and even check which button was clicked?

public async void InteractWithUser()
{
    await this.WaitForLoaded();
    await showMessageStoryboard.BeginAsync();
    await Task.Delay(1000);
    await hideMessageStoryboard.BeginAsync();
    var button = await buttons.WaitForClickAsync();
    if (button == OKButton)
        Disk.Format("C:");
    else
        InteractWithUser();
}

The concept isn’t new – it seems like Daniel Earwicker in his C# 5.0 async/await and GUI events article mentioned having a “button as a task”. This here though is the implementation of the concept.

Awaitable extension methods

To add the new functionality to existing classes I am using extension methods. To make them awaitable, I am creating a task from a TaskCompletionSource that completes when the expected event occurs. I created a helper class based on Stephen Cleary’s post on MSDN forums, but modified to work with WinRT. Here are the extensions and helper code I came up with:

public static class StoryboardExtensions
{
    /// <summary>
    /// Begins a storyboard and waits for it to complete.
    /// </summary>
    public static async Task BeginAsync(this Storyboard storyboard)
    {
        await EventAsync.FromEvent(
            eh => storyboard.Completed += eh,
            eh => storyboard.Completed -= eh,
            storyboard.Begin);
    }
}

public static class ButtonExtensions
{
    /// <summary>
    /// Waits for the button Click event.
    /// </summary>
    public static async Task<RoutedEventArgs> WaitForClickAsync(this ButtonBase button)
    {
        return await EventAsync.FromRoutedEvent(
            eh => button.Click += eh,
            eh => button.Click -= eh);
    }
}

// Based on: http://social.msdn.microsoft.com/Forums/sk/async/thread/30f3339c-5e04-4aa8-9a09-9be72d9d9a1b
public static class EventAsync
{
    /// <summary>
    /// Creates a <see cref="System.Threading.Tasks.Task"/>
    /// that waits for an event to occur.
    /// </summary>
    /// <example>
    /// <![CDATA[
    /// await EventAsync.FromEvent(
    ///     eh => storyboard.Completed += eh,
    ///     eh => storyboard.Completed -= eh,
    ///     storyboard.Begin);
    /// ]]>
    /// </example>
    /// <param name="addEventHandler">
    /// The action that subscribes to the event.
    /// </param>
    /// <param name="removeEventHandler">
    /// The action that unsubscribes from the event when it first occurs.
    /// </param>
    /// <param name="beginAction">
    /// The action to call after subscribing to the event.
    /// </param>
    /// <returns>
    /// The <see cref="System.Threading.Tasks.Task"/> that
    /// completes when the event registered in
    /// <paramref name="addEventHandler"/> occurs.
    /// </returns>
    public static Task<object> FromEvent(
        Action<EventHandler> addEventHandler,
        Action<EventHandler> removeEventHandler,
        Action beginAction = null)
    {
        return new EventHandlerTaskSource(
            addEventHandler,
            removeEventHandler,
            beginAction).Task;
    }

    /// <summary>
    /// Creates a <see cref="System.Threading.Tasks.Task"/>
    /// that waits for an event to occur.
    /// </summary>
    /// <example>
    /// <![CDATA[
    /// await EventAsync.FromEvent(
    ///     eh => button.Click += eh,
    ///     eh => button.Click -= eh);
    /// ]]>
    /// </example>
    /// <param name="addEventHandler">
    /// The action that subscribes to the event.
    /// </param>
    /// <param name="removeEventHandler">
    /// The action that unsubscribes from the event when it first occurs.
    /// </param>
    /// <param name="beginAction">
    /// The action to call after subscribing to the event.
    /// </param>
    /// <returns>
    /// The <see cref="System.Threading.Tasks.Task"/> that
    /// completes when the event registered in
    /// <paramref name="addEventHandler"/> occurs.
    /// </returns>
    public static Task<RoutedEventArgs> FromRoutedEvent(
        Action<RoutedEventHandler> addEventHandler,
        Action<RoutedEventHandler> removeEventHandler,
        Action beginAction = null)
    {
        return new RoutedEventHandlerTaskSource(
            addEventHandler,
            removeEventHandler,
            beginAction).Task;
    }

    private sealed class EventHandlerTaskSource
    {
        private readonly TaskCompletionSource<object> tcs;
        private readonly Action<EventHandler> removeEventHandler;

        public EventHandlerTaskSource(
            Action<EventHandler> addEventHandler,
            Action<EventHandler> removeEventHandler,
            Action beginAction = null)
        {
            if (addEventHandler == null)
            {
                throw new ArgumentNullException("addEventHandler");
            }

            if (removeEventHandler == null)
            {
                throw new ArgumentNullException("removeEventHandler");
            }

            this.tcs = new TaskCompletionSource<object>();
            this.removeEventHandler = removeEventHandler;
            addEventHandler.Invoke(EventCompleted);

            if (beginAction != null)
            {
                beginAction.Invoke();
            }
        }

        /// <summary>
        /// Returns a task that waits for the event to occur.
        /// </summary>
        public Task<object> Task
        {
            get { return tcs.Task; }
        }

        private void EventCompleted(object sender, object args)
        {
            this.removeEventHandler.Invoke(EventCompleted);
            this.tcs.SetResult(args);
        }
    }

    private sealed class RoutedEventHandlerTaskSource
    {
        private readonly TaskCompletionSource<RoutedEventArgs> tcs;
        private readonly Action<RoutedEventHandler> removeEventHandler;

        public RoutedEventHandlerTaskSource(
            Action<RoutedEventHandler> addEventHandler,
            Action<RoutedEventHandler> removeEventHandler,
            Action beginAction = null)
        {
            if (addEventHandler == null)
            {
                throw new ArgumentNullException("addEventHandler");
            }

            if (removeEventHandler == null)
            {
                throw new ArgumentNullException("removeEventHandler");
            }

            this.tcs = new TaskCompletionSource<RoutedEventArgs>();
            this.removeEventHandler = removeEventHandler;
            addEventHandler.Invoke(EventCompleted);

            if (beginAction != null)
            {
                beginAction.Invoke();
            }
        }

        /// <summary>
        /// Returns a task that waits for the routed to occur.
        /// </summary>
        public Task<RoutedEventArgs> Task
        {
            get { return tcs.Task; }
        }

        private void EventCompleted(object sender, RoutedEventArgs args)
        {
            this.removeEventHandler.Invoke(EventCompleted);
            this.tcs.SetResult(args);
        }
    }
}

How do I use it today?

The source code is available on CodePlex. It comes with a library that works on Windows 8 Developer Preview and a sample project that has a custom dialog class for WinRT implemented, both using the classic event driven approach as well as using the extension methods for comparison. It also has versions of the library and samples for Silverlight 4.0, Windows Phone 7.1 (Mango) and WPF – all of which require Visual Studio 2010 with Async CTP 3 installed.

Such a cool experience needed a unique intro screen and loading animation, something that was a bit more specialised than just a simple bar. Working on two rotating pieces that would lock together at 100%, I knew the style would need to remain consistent with the established look of the graphic novel, ink strokes and all. Instead of trying to illustrate each animation frame by hand, I turned to Lightwave.

When developing shaders, be they photoreal or painterly, it’s always helpful to break the desired look down into easily replicable components. Using the cover illustration of the Tron graphic novel as a guide, we can see layers of base painting (smooth gradations), highlight brushing (smudgier daubs), and ink strokes (shading lines that follow the curves of the object).

The base object is a simple donut shape with strong backlighting. Specialised surface development will almost always require a specific lighting setup to work well, and this is no exception. The style is of course flexible enough to be adapted elsewhere, but for tight control over the results we need to keep the lighting unchanged.

Ink strokes

At first glance this seems a little odd to try and replicate in 3D, but it’s easier than you might think. Using the crust procedural texture, we’ll stretch out the X and Y to give long strokes against the side of the object, then connect a Lambert shading node to the spot size input to control the thickness of the strokes.

With the addition of incidence and gradient nodes, we’ll adjust some of the shading subtleties, especially around the edges of objects where we want more of an outline. In simple cases like this, using an incidence gradient to outline an object can give smoother and more reliable results than Lightwave’s line renderer, plus allows us to add a thin white edge between the outline and the shading to help add a bit more definition. In more organic or complex models an incidence stroke is quite variable, which can either be good or bad depending on the desired style.

This works great for such a circular shape, but if an object is more organic or has lines that are harder to follow with a procedural texture, you’ll want to explore more options, including variations on the type of procedural, direction, or even other mapping setups. Cross-hatched techniques were demoed a few years ago on the Newtek Ligthwave forums by William Vaughan, and I’ve used variations on other projects as well. It’s surprising how well some pen and ink styles can be adapted to a Lightwave surface style using basic node setups.

Base coloration

Hues rarely remain constant through gradations of shading and light; not in real life, not in photography, not in illustrations, and, I hope, not in our 3D renders! We’ll take the same Lambert diffuse shading node used for the ink strokes, and add a gradient to create the base coloration. From deeper purple-blues to bright cyans, the hue shifts create life and depth in the surface. Mixing the Lambert diffuse shading with Phong specularity helps make the lighting falloff feel more metallic. Plus, what better way to pay homage to Tron than with an historic shading method? Always warms my heart to find unique ways of mixing in stuff like that.

The colours work well enough, but it doesn’t feel particularly painterly without more surface variation. With cross-hatched crust nodes, we’ll use Denis Pontonnier’s DPkit Bump Normal node to convert the resulting bump values into normals that can be plugged into the Lambert and Phong shaders. Directly controlling normals like this is a great way to mix varied effects in the same surface, without being limited to a single global bump.

Highlight painting

Just about complete, the only thing left to add is the highlights. Using multiple Phong shaders allows us to mix both painterly and shiny surface properties easily. Using the cross hatched crust nodes already set up for the diffuse normals, we’ll modulate the shininess of the second one to give more brush stroke style shapes. Rather like a two-coat surface process, but with more organic results.

With the combination of normals, procedural stroke widths, and highlight modulations, the surface can react much like an illustration, but the patterns are essentially attached to the surface and completely stable during animation.

You can visit the Tron HTML5 website to see the loading animation in action!

Download

The .zip file contains the final sample scene, object, and an exported surface file for easy addition to a presets collection. There are a fair number of nodes that weren’t described in detail, so reviewing the setup by playing around with the pieces is the best way to really tear things apart. Enjoy!

Download Files: final Lightwave assets

This surface requires the Bump Normal node found in Denis Pontonnier’s excellent (and free!) DPkit.

Disney and Tron are either registered trademarks or trademarks of Disney in the United States and/or other countries.

Newtek and Lightwave 3D are either registered trademarks or trademarks of Newtek Incorporated in the United States and/or other countries.

I wanted to find a way to introduce others to UDK in a way that is fun and simple. I discovered some notes I took while prototyping a simple UDK side-scroller, and turned them into this little guide. This guide attempts to lay out the groundwork for developing a simple game with the Unreal Development Kit. It will help readers understand the structure of a basic UDK game, its elements and the relationship between them. It does not, however, detail creating levels or assets. For that, please refer to the excellent 3D Buzz video tutorials available on the UDK website.

Update:
The complete source code and level file created during this guide is available here: http://labs.vectorform.com/files/Tomato.zip

• Introduction to the UDK environment
  • UDK, Unreal Script and Unreal Ed
  • Getting UDK
  • The Directory Structure
  • The Code Base
• Creating a Side-scroller
  • Creating a New Game Type
  • Creating 2D Player Controls
  • Compiling Your Game
  • Creating A Level and Running The Game
  • Adding Coin Pickups
  • Adding a Coin Mesh and Making Coins Disappear When Collected
  • Creating Custom Actions
  • Enabling Debug Output
  • Using Actions from Unreal Kismet
  • Creating a Custom HUD
  • Creating Bots
    • Creating Bot Behavior in UnrealScript
    • Configuring, and Adding Bots to the Level
  • Game Over!

UDK, Unreal Script and Unreal Ed

Development with UDK consists of two parts:

1. Writing Unreal Script code to create game objects and low-level game logic — such as AI, multiplayer behavior, game rules, and so on.
2. Using Unreal Ed to design the game visually, using the Unreal Script objects you wrote. Unreal Ed is a powerful tool for designing levels and UI, managing assets, adding level-specific logic (switches, portals), and much more.

I highly recommend that you learn Unreal Ed before jumping into code — it will help you understand the terminology used throughout UDK. I recommend watching the 3DBuzz video tutorials on using the level editor and Kismet (a visual editor for high-level gameplay logic), which can be found here: http://udn.epicgames.com/Three/VideoTutorials.html. You will even learn to create a 3rd person game as you follow along!

UDK comes with the Unreal Engine codebase and the full source code for the Unreal Tournament 3 demo game. If you have experience with C++, C#, Objective C, Java or similar, I find that reading the codebase is the fastest way to learn Unreal Script.

Getting UDK

Head over to http://www.udk.com/download and grab the latest release. I have the September 2011 beta but yours may be newer. Install UDK.

Additionally, you will need the following:

1. A text editor. Unreal Script (.uc) source files can be edited with any text editor. I recommend ConTEXT with the UnrealScript language file, or jEdit because you will get the benefit of syntax highlighting right out of the box.
2. UnCodeX. It is a stand-alone project navigator for UDK source files — it scans all the Unreal Script files you have, and presents you with a well-organized class tree. You get a major benefit of having an IDE for free. Get it here: http://udn.epicgames.com/Three/UnCodeX.html (make sure you carefully follow the instructions under the “Installation” heading)

Third-party IDEs are also available for Unreal Script development, but will not be covered here.

The Directory Structure

Now that you have UDK installed, let’s look at the various files and directories that make up UDK. Open up the UDK install directory (usually something like C:/UDK/UDK-2011-09). The two directories that are important for us are Development and UDKGame:

[UDK install directory]/Development/Src contains the Unreal Script files that make up the UDK code base (more on this below).

[UDK install directory]/UDKGame contains the game’s levels, textures, meshes, sounds and scripts — all compiled into packages. Levels have a .udk extension, assets are .upk and the script packages are .u.

More details about the directory structure can be found on Epic’s Unreal Development Network website: http://udn.epicgames.com/Three/DevelopmentKitFirstScriptProject.html#UDK directory layout

The Code Base

This code base is a large and complex hierarchy of Unreal Script classes. Networking, vehicles, AI behavior, lights, UI elements — are just some of the examples of classes available to you. Each script in the code base (file with .uc extension) bears the name of the class it defines.  Each class derives from another class, and eventually from the base class Object. The scripts are organized into directories bearing the name of the package to which they belong (Engine, Core, UTGame, etc). A package is an assembly created when you compile your scripts.

It is important to note at this point that all objects in the game world are derived from the class Actor.  Actors include light sources, players, weapons, rocks, switches, waypoints. Actors do not need to be visible. In a typical game, most of your development time will be spent on creating Actor classes.

Creating a New Game Type

I will name the game Total Maximum Torque, or “Tomato” for short. Create the following directories for your source files:

We will create a custom game type by defining our own GameInfo subclass.  GameInfo is just an Actor that is created once when we load a map, and handles the game rules (spawning players, time limits, scoring, etc). You might think of it as an entry point to your game, because it determines what other objects will be used in the game. How does UDK know which GameInfo class to load? We have to tell it either in the URL or in the game’s .ini file (more on all this later).

To save some work, we will reuse Unreal Tournament 3′s GameInfo class. It is called UTGame, and it eventually extends GameInfo. If the game were drastically different from UT, we would subclass GameInfo directly, but our game will use a lot of Unreal Tournament’s existing functionality. Create and open [UDK install directory]/Development/Src/Tomato/Classes/TomatoGameInfo.uc. Add the following code:

class TomatoGameInfo extends UTGame;

DefaultProperties
{
	MapPrefixes(0)="TMT"
	DefaultPawnClass=Class'Tomato.TomatoPawn'
	PlayerControllerClass=Class'Tomato.TomatoPlayerController'
	BotClass=class'Tomato.TomatoBot'
	HUDType=class'Tomato.TomatoHUD'

	bUseClassicHUD = true

	DefaultInventory(0)=none
	DefaultInventory(1)=none
}

First, we declared our class name, and the name of the class it’s extending.

The DefaultProperties block contains default/initial values for class properties. We are subclassing, and these class properties already exist — we are just changing their default values. Our game will have its own HUD, bot class, controls, and pawn class — in GameInfo we specify that we want to use our classes instead of the classes defined in UTGame.

• • A Pawn is an actor that can be controlled by players or AI. Typically, it is some kind of a mesh that can collide with the world, pick up items, take damage, and use weapons.  We want to have our own pawn that can only move in two dimensions, so we tell our GameInfo to use it as the standard pawn class.
• • The PlayerController provides a way for human players to control pawns. We want to define our own 2D controls, so we will have GameInfo use our class.
• • The Bot class is similar to the PlayerController in that it controls pawns. However, bot use AI instead of player input.
• • A custom HUD is needed to display our score

Creating 2D Player Controls

We’re going to take a little shortcut. Epic provided us with excellent code for a side-scrolling camera on the UDN website.

http://udn.epicgames.com/Three/CameraTechnicalGuide.html#Example Side-Scrolling Camera

Go ahead and copy the side-scrolling camera code Epic provided, and put it into the respective files (UDNPawn.uc and UDNPlayerController.uc in the Tomato source directory).

UDNPawn derives from UTPawn. It overrides CalcCamera to fix camera position to the plane Y=CamOffsetDistance (0 by default), and to restrict camera rotation to face in the direction of the positive Y-axis. It also overrides GetBaseAimRotation to restrict the direction of aiming. UDNPlayerController modifies the player controls to only rotate and move the player’s pawn within the 2D plane.

UDNPawn.uc:

class UDNPawn extends UTPawn;

var float CamOffsetDistance; //Position on Y-axis to lock camera to

//override to make player mesh visible by default
simulated event BecomeViewTarget( PlayerController PC )
{
   local UTPlayerController UTPC;

   Super.BecomeViewTarget(PC);

   if (LocalPlayer(PC.Player) != None)
   {
      UTPC = UTPlayerController(PC);
      if (UTPC != None)
      {
         //set player controller to behind view and make mesh visible
         UTPC.SetBehindView(true);
         SetMeshVisibility(UTPC.bBehindView);
         UTPC.bNoCrosshair = true;
      }
   }
}

simulated function bool CalcCamera( float fDeltaTime, out vector out_CamLoc, out rotator out_CamRot, out float out_FOV )
{
   out_CamLoc = Location;
   out_CamLoc.Y = CamOffsetDistance;

   out_CamRot.Pitch = 0;
   out_CamRot.Yaw = 16384;
   out_CamRot.Roll = 0;
   return true;
}

simulated singular event Rotator GetBaseAimRotation()
{
   local rotator   POVRot;

   POVRot = Rotation;
   if( (Rotation.Yaw % 65535 > 16384 && Rotation.Yaw % 65535 < 49560) ||
      (Rotation.Yaw % 65535 < -16384 && Rotation.Yaw % 65535 > -49560) )
   {
      POVRot.Yaw = 32768;
   }
   else
   {
      POVRot.Yaw = 0;
   }

   if( POVRot.Pitch == 0 )
   {
      POVRot.Pitch = RemoteViewPitch << 8;
   }

   return POVRot;
}   

defaultproperties
{
   CamOffsetDistance=0.0
}

UDNPlayerController.uc:

class UDNPlayerController extends UTPlayerController;

state PlayerWalking
{
ignores SeePlayer, HearNoise, Bump;

   function ProcessMove(float DeltaTime, vector NewAccel, eDoubleClickDir DoubleClickMove, rotator DeltaRot)
   {
      local Rotator tempRot;

      if( Pawn == None )
      {
         return;
      }

      if (Role == ROLE_Authority)
      {
         // Update ViewPitch for remote clients
         Pawn.SetRemoteViewPitch( Rotation.Pitch );
      }

      Pawn.Acceleration.X = -1 * PlayerInput.aStrafe * DeltaTime * 100 * PlayerInput.MoveForwardSpeed;
      Pawn.Acceleration.Y = 0;
      Pawn.Acceleration.Z = 0;

      tempRot.Pitch = Pawn.Rotation.Pitch;
      tempRot.Roll = 0;
      if(Normal(Pawn.Acceleration) Dot Vect(1,0,0) > 0)
      {
         tempRot.Yaw = 0;
         Pawn.SetRotation(tempRot);
      }
      else if(Normal(Pawn.Acceleration) Dot Vect(1,0,0) < 0)
      {
         tempRot.Yaw = 32768;
         Pawn.SetRotation(tempRot);
      }

      CheckJumpOrDuck();
   }
}

function UpdateRotation( float DeltaTime )
{
   local Rotator   DeltaRot, ViewRotation;

   ViewRotation = Rotation;

   // Calculate Delta to be applied on ViewRotation
   DeltaRot.Yaw = Pawn.Rotation.Yaw;
   DeltaRot.Pitch   = PlayerInput.aLookUp;

   ProcessViewRotation( DeltaTime, ViewRotation, DeltaRot );
   SetRotation(ViewRotation);
}   

defaultproperties
{
}

We now have UDNPlayerController, UDNPawn and TomatoGameInfo classes. In TomatoGameInfo we specified that our player controller will be TomatoPlayerController and the pawn class will be TomatoPawn. Let’s create those classes, and base them on the UDN classes we created — this will later allow us to add our own functionality without becoming distracted by Epic’s sidescroller camera code.

Create the file TomatoPlayerController.uc with the following code:

class TomatoPlayerController extends UDNPlayerController
	dependson(UDNPlayerController);

Likewise, create TomatoPawn.uc with the following:

class TomatoPawn extends UDNPawn
	dependson(UDNPawn);

simulated function Tick(float DeltaTime)
{
        local vector tmpLocation;
	super.Tick(DeltaTime);
        tmpLocation = Location;
        tmpLocation.Y = 500;
        SetLocation(tmpLocation);
}

function bool Dodge(eDoubleClickDir DoubleClickMove)
{
  return false;
}

defaultproperties
{
 ControllerClass=class'Tomato.TomatoBot'
 bCanStrafe=false
 MaxStepHeight=50.0
 MaxJumpHeight=96
 JumpZ=550
}

In the code above, we are forcing any of our pawns in the game (players and bots) to be on the Y=500 plane. We are also increasing the jump and step heights to make terrain easier to navigate and more similar to a platformer.

Create TomatoBot.uc with this code:

class TomatoBot extends UTBot;

We will leave TomatoBot empty for now. We will create bot AI at a later time.

Create TomatoHUD.uc with this code:

class TomatoHUD extends UTHUD;

We’ve now added all the classes that TomatoGameInfo references. Let’s compile them!

Compiling Your Game

We must compile our UnrealScript classes into a package in order to use them in the game. UDK maintains a list of all packages that need to be compiled in an .ini file — so we must add our package to that list. Open [UDK install directory]/UDKGame/Config/DefaultEngine.ini. In the section [UnrealEd.EditorEngine], add the following line, and save the file:

+ModEditPackages=Tomato

Run the Unreal Frontend tool ([UDK install directory]/Binaries/UnrealFrontend.exe). We will be using this tool to invoke the compiler. Ensure that all your Unreal Script files are saved, and close UDK Editor if it is open. Select “Compile Scripts” from the ”Scripts” menu.

You should not receive any errors or warnings related to the Tomato scripts.

See the Compiling section on the UDN website if you need additional details.

Creating A Level and Running The Game

Save your level as TMT-Zone1.udk

Adding Coin Pickups

Now that we have movement and camera controls working, it’s time to give the player something to do. We will add some coins that can be collected. Once all coins are collected, the game is won.

Adding a Coin Mesh and Making Coins Disappear When Collected

Save your level (File->Save All)

We need to add the ability to track the number of coins collected, and to set the total number of coins needed to win the level. This can all be done in Unreal Kismet, but we would have to re-create this logic for each level in our game. Additionally, it does not serve as a good demonstration of a flexible architecture for a complete game. I am going to show you how to create communication between your level and your Unreal Script code.

What should be the responsibilities of the level (or level designer) in our game?

1. The level should tell our script how many coins the player needs to complete this level.
2. The level should notify our script when a player collected a coin.
3. The level should tell our script if a player earned points.

In the previous section we used Unreal Kismet to call the Destroy action when a coin was touched. Essentially, we want to do the same thing, but instead of Destroy we want to create our own actions.  When the action is performed, we’d like to call some function in our Unreal Script. To accomplish this, we will use SequenceActions.

Create a new Unreal Script file named SeqAct_TMTCollectCoin.uc  in our source directory. The code is very simple:

class SeqAct_TMTCollectCoin extends SequenceAction;

DefaultProperties
 {
 	ObjName="Collect Coin"
        ObjCategory="Tomato"
 	HandlerName="CollectCoin"
 }

We are creating an action with the readable name “Collect Coin” in the category “Tomato” (defining a category allows us to group together all “Tomato” actions in Kismet’s context menus). We are also defining the name of the handler function for this action.

Let’s create the rest of the actions first, and then move on to creating handlers for them. Create SeqAct_TMTSetCoinsNeeded.uc with the following:

class SeqAct_TMTSetCoinsNeeded extends SequenceAction;

var() int NumCoins;

DefaultProperties
 {
 	ObjName="Set Coins Needed"
        ObjCategory="Tomato"
 	HandlerName="SetCoinsNeeded"
 	NumCoins = 0
 	VariableLinks(1)=(ExpectedType=class'SeqVar_Int', LinkDesc="NumCoins", bWriteable=true, PropertyName=NumCoins)
 }

The above-action is an action that takes a parameter. We first declare a local variable NumCoins. We then set a VariableLink for the NumCoins variable — this creates a writable node in Kismet to which an integer value can be attached. You will see how to pass values later.

Create  SeqAct_TMTGivePoints.uc with the following code:

class SeqAct_TMTGivePoints extends SequenceAction;

var() int NumPoints;
DefaultProperties
 {
 	ObjName="Add Points"
        ObjCategory="Tomato"
 	HandlerName="AddPoints"
 	NumPoints = 0
 	VariableLinks(1)=(ExpectedType=class'SeqVar_Int', LinkDesc="NumPoints", bWriteable=true, PropertyName=NumPoints)
 }

The “Add Points” action also takes an integer parameter — we use it to specify the number of points to add.

Time to create handlers for our new actions. In TomatoPlayerController.uc, modify the class definition in the beginning of the file to add three dependson directives for our actions. This will ensure that the actions are compiled before our player controller, so our player controller can use them. Modify TomatoPlayerController as follows:

class TomatoPlayerController extends UDNPlayerController
	dependson(UDNPlayerController)
        dependson(SeqAct_TMTGivePoints)
        dependson(SeqAct_TMTSetCoinsNeeded)
        dependson(SeqAct_TMTCollectCoin);

Next, we want to keep track of the number of points, the number of coins collected and the required number of coins — so we need some local variables. Right below, declare the following three integer variables:

var() int TMTPoints;
var() int TMTCoinsCollected;
var() int TMTCoinsNeededThisLevel;

Before we jump into creating the handlers, let’s create a function to test if the player has enough coins to win the game:

exec function TestWinningConditions()
{
  `log("TestWinningConditions() : Checking winning conditions");
  `log("TestWinningConditions() : Collected: "$TMTCoinsCollected);
  `log("TestWinningConditions() : Needed: "$TMTCoinsNeededThisLevel);

  if(TMTCoinsCollected > 0 && TMTCoinsNeededThisLevel > 0 && TMTCoinsCollected >= TMTCoinsNeededThisLevel)
  {
       `log("TestWinningConditions() : Victory!");
  }
  else
  {
       `log("TestWinningConditions() : Go collect more coins!");
  }
}

The above-code should be self-explanatory, with the exception of exec function. An exec function can be invoked by typing its name in the console. Executing the function directly from console will make debugging winning conditions a bit easier.

Time to create handlers. To create a handler for an action, we must declare a method named with the value of the action’s HandlerName property. Also, the method will take the action as a parameter. Create the following handler functions in TomatoPlayerController:

function CollectCoin(SeqAct_TMTCollectCoin MyAction)
{
  `log("CollectCoin() : Collected coin");
  TMTCoinsCollected += 1;
  TestWinningConditions();
}
function SetCoinsNeeded(SeqAct_TMTSetCoinsNeeded MyAction)
{
  `log("SetCoinsNeeded() : Set needed coins to "$MyAction.NumCoins);
  TMTCoinsNeededThisLevel = MyAction.NumCoins;
}
function AddPoints(SeqAct_TMTGivePoints MyAction)
{
  `log("AddPoints() : Adding points: "$MyAction.NumPoints);
  TMTPoints += MyAction.NumPoints;
}

Finally, let’s properly initialize our properties:

defaultproperties
{
  TMTPoints = 0
  TMTCoinsCollected = 0
  TMTCoinsNeededThisLevel = 1
}

Expand to see the complete TomatoPlayerController.uc file:

class TomatoPlayerController extends UDNPlayerController
	dependson(UDNPlayerController)
        dependson(SeqAct_TMTGivePoints)
        dependson(SeqAct_TMTSetCoinsNeeded)
        dependson(SeqAct_TMTCollectCoin);

var() int TMTPoints;
var() int TMTCoinsCollected;
var() int TMTCoinsNeededThisLevel;

exec function TestWinningConditions()
{
  `log("TestWinningConditions() : Checking winning conditions");
  `log("TestWinningConditions() : Collected: "$TMTCoinsCollected);
  `log("TestWinningConditions() : Needed: "$TMTCoinsNeededThisLevel);

  if(TMTCoinsCollected > 0 && TMTCoinsNeededThisLevel > 0 && TMTCoinsCollected >= TMTCoinsNeededThisLevel)
  {
       `log("TestWinningConditions() : Victory!");
  }
  else
  {
       `log("TestWinningConditions() : Go collect more coins!");
  }
}

function CollectCoin(SeqAct_TMTCollectCoin MyAction)
{
  `log("CollectCoin(): Collected coin");
  self.TMTCoinsCollected += 1;
  TestWinningConditions();
}
function SetCoinsNeeded(SeqAct_TMTSetCoinsNeeded MyAction)
{
  `log("SetCoinsNeeded() : Set needed coins to "$MyAction.NumCoins);
  TMTCoinsNeededThisLevel = MyAction.NumCoins;

}
function AddPoints(SeqAct_TMTGivePoints MyAction)
{
  `log("AddPoints() : Adding points: "$MyAction.NumPoints);

  TMTPoints += MyAction.NumPoints;

}

defaultproperties
{
  TMTPoints = 0
  TMTCoinsCollected = 0
  TMTCoinsNeededThisLevel = 1
}

How does the engine know to call the handlers for each action in the Player Controller class, and not in some other class? We will later need to specify, in Kismet, that the Target of the action is the Player Controller — just like we set the coin as a target of the Destroy action.

Things seem to finally be coming together. Ensure that UDK Editor is closed, save all files, and compile the scripts using Unreal Frontend (select Script->Compile scripts).

Enabling Debug Output

Before we fire up UDK, we need to enable the debug console. This will allow us to see the `log() output. The idea is to add a “-log” command-line parameter when launching the UDK editor. I set it up this way:

1. Right-click UDKLift.exe (it’s in C:\UDK\UDK-2011-09\Binaries) and choose “Create shortcut”.
2. In the Properties of the short-cut, modify the “Target” as follows:

   C:\UDK\UDK-2011-09\Binaries\UDKLift.exe editor -log

You can now use this shortcut to launch the UDK editor with a debug log window.

Using Actions from Unreal Kismet

Once all scripts have compiled successfully, run UDK Editor with the debug log window enabled. Open up the level we worked on previously, TMT-Zone1.udk.

Take your time and design a level to your liking (if you haven’t already done so). Have a look at the 3D Buzz video tutorials for information on the various level design features available in UDK — things like destructible objects, switches, doors and terrain can be a great addition to your game! And add some more coins while you’re at it.

Creating a Custom HUD

We will be creating a very basic HUD. Modify TomatoHUD.uc as follows:

class TomatoHUD extends UTHUD;

function DrawHealthBar(float percentFull)
 {
 	local int currentBarWidth;
 	local int maxBarWidth;
 	local int barHeight;
 	local int barPositionX;
 	local int barPositionY;
 	local int healthPct;

 	maxBarWidth = 300;
 	barHeight = 20;
 	barPositionX = 20;
 	barPositionY = 20;
 	healthPct = percentFull * 100;

 	currentBarWidth = maxBarWidth * percentFull;

        // Draw the "filled" part of the bar
 	Canvas.SetPos(barPositionX, barPositionY);        // X, Y position
 	Canvas.SetDrawColor(80, 200, 80, 200);    // R, G, B, A for bar rectangle
 	Canvas.DrawRect(currentBarWidth, barHeight);

        // Draw the empty part of the bar
 	Canvas.SetPos(barPositionX + currentBarWidth, barPositionY);
 	Canvas.SetDrawColor(200, 255, 200, 110);
 	Canvas.DrawRect(maxBarWidth - currentBarWidth, barHeight);

        // Draw some text next to the bar
	Canvas.SetPos(barPositionX + maxBarWidth + 10, barPositionY);
 	Canvas.SetDrawColor(0, 200, 0, 200);
 	Canvas.Font = class'Engine'.static.GetMediumFont();
 	Canvas.DrawText("Health: "$healthPct$"%");
 }

 function DrawString(string text, int X, int Y, int R, int G, int B, int A)
 {
        Canvas.SetPos(X, Y);
 	Canvas.SetDrawColor(R, G, B, A);
 	Canvas.Font = class'Engine'.static.GetMediumFont();
 	Canvas.DrawText(text);
 }

 function DrawGameHud()
 {
 	local TomatoPlayerController PC;

 	// Type cast the PlayerOwner property of the HUD to TomatoPlayerController
 	PC = TomatoPlayerController(PlayerOwner);

 	if (!PlayerOwner.IsDead())
 	{
           // Display health bar only when the player hasn't died
           if(PlayerOwner.Pawn.HealthMax > 0)
           {
             DrawHealthBar(float(PlayerOwner.Pawn.Health) / float(PlayerOwner.Pawn.HealthMax));
           }
 	}

        // Always display other information
 	DrawString("Coins: "$PC.TMTCoinsCollected$"/"$PC.TMTCoinsNeededThisLevel,20,40,140,80,0,200);
 	DrawString("Score: "$PC.TMTPoints,20,60,0,80,160,200);
 }

 defaultproperties
 {
   bCrosshairShow=false
 }

For this basic HUD, we are using Canvas to draw text, and rectangles to represent our health bar. For a description of what each Canvas method does,  refer to this tutorial at UDK Central. Ensure that UDK is closed, and compile your scripts. When you load and play TMT-Zone1.udk, you should have a fancy new HUD!

If you wish to create an advanced HUD, refer to this complete series of video tutorials on using Scaleform GFx to create a HUD.

Creating Bots

Creating Bot Behavior in UnrealScript

Bots are Controllers of Pawns, just like a Player Controller. We will modify the Unreal Tournament bots to make them better side-scroller opponents. The bots should begin attacking when they are very close to the player, since AI designed for 3D has a large sight radius. Additionally, they should patrol between two nodes (just like in the 3DBuzz video tutorials, but we will use Unreal Script instead of just Kismet to achieve this).

The way in which I designed the bots is probably not ideal, but it works and is really easy. Essentially, the bot will patrol between two nodes (these are just Actors). While that is happening, the bot will constantly check if the player is nearby and if there is a line of sight to the player. If there is, the bot will begin to attack until the target dies. I started creating this behavior by copy-pasting the Defending state from UTBot.uc, and modifying it. This is always a great starting point for learn the code base and creating your own behavior.

Since the bots require two path nodes, we need a way to tell the bot script what path nodes to use through Kismet. To achieve this, we will create a sequence action to configure our bot.

Create the file SeqAct_TMTConfigureBot.uc with the following code:

class SeqAct_TMTConfigureBot extends SequenceAction;

var() object Target;
var() float MaxFireRange;
var() object PatrolStart;
var() object PatrolEnd;

defaultproperties
{
  ObjName="Configure a TomatoBot"
  ObjCategory="Tomato"
  HandlerName = "TMTConfigureBot"

  target = None
  MaxFireRange = 256
  PatrolStart = None
  PatrolEnd = None

  VariableLinks(1)=(ExpectedType=class'SeqVar_Object', LinkDesc="Firing Target", bWriteable=true, PropertyName=Target)
  VariableLinks(2)=(ExpectedType=class'SeqVar_Float', LinkDesc="Max. Fire Range", bWriteable=true, PropertyName=MaxFireRange)
  VariableLinks(3)=(ExpectedType=class'SeqVar_Object', LinkDesc="Patrol Start", bWriteable=true, PropertyName=PatrolStart)
  VariableLinks(4)=(ExpectedType=class'SeqVar_Object', LinkDesc="Patrol End", bWriteable=true, PropertyName=PatrolEnd)
}

The Target variable link is the target that the bot will attack (this will be the player). MaxFireRange is how close to the player the bot needs to be to start attacking. PatrolStart and PatrolEnd are the patrol path nodes, the bot will walk between them.

Open the file TomatoBot.uc and edit it as follows:

class TomatoBot extends UTBot;

var() actor TMTPatrolStart;
var() actor TMTPatrolEnd;
var() actor TMTTarget;
var() float TMTMaxFireRange;

function TMTConfigureBot(SeqAct_TMTConfigureBot MyAction)
{
  TMTPatrolStart = actor(MyAction.PatrolStart);
  TMTPatrolEnd = actor(MyAction.PatrolEnd);
  TMTTarget = actor(MyAction.Target);
  TMTMaxFireRange = MyAction.MaxFireRange;
  SetTimer(0.3, true, 'ScanForPlayers');
}

function bool ShouldStrafeTo(Actor WayPoint)
{
	return false;
}

function ScanForPlayers()
{
	if(TMTTarget != none && VSize(Controller(TMTTarget).Pawn.Location - Pawn.Location) < TMTMaxFireRange && FastTrace(Controller(TMTTarget).Pawn.Location, Pawn.Location,, true))
	{
		Focus = TMTTarget;
		Enemy = Controller(TMTTarget).Pawn;

		VisibleEnemy = Enemy;
		EnemyVisibilityTime = WorldInfo.TimeSeconds;
		bEnemyIsVisible = true;

		`log("TomatoBot::ScanForPlayers() : I see the player!");

                if(!IsInState('ChargingNoStrafe'))
                {
		 `log("TomatoBot::ScanForPlayers() : Going to CharginNoStrafe state");
                 GotoState('ChargingNoStrafe');
                }
	}
}

state Defending
{
	ignores EnemyNotVisible;

	function Restart( bool bVehicleTransition ) {}

	function bool IsDefending()
	{
		return true;
	}

	function EnableBumps()
	{
		enable('NotifyBump');
	}

	event MonitoredPawnAlert()
	{
		WhatToDoNext();
	}

	function ClearPathFor(Controller C)
	{
	}

	function SetRouteGoal()
	{
		local Actor NextMoveTarget;
		local bool bCanDetour;

		bCanDetour = (Vehicle(Pawn) == None) || (UTVehicle_Hoverboard(Pawn) != None);

		if ( ActorReachable(RouteGoal) )
			NextMovetarget = RouteGoal;
		else
			NextMoveTarget = FindPathToward(RouteGoal, bCanDetour);

		if ( NextMoveTarget == None )
		{
			NextMoveTarget = FindPathToward(RouteGoal, bCanDetour);
		}

		if ( NextMoveTarget == None )
		{
			CampTime = 3;
			// No target
			GotoState('Defending','Pausing');
		}

		Focus = NextMoveTarget;
		MoveTarget = NextMoveTarget;
	}

	function EndState(Name NextStateName)
	{
		MonitoredPawn = None;
		SetCombatTimer();
		bShortCamp = false;
	}

	function BeginState(Name PreviousStateName) { }
Begin:

	`log("BEGIN DEFENDING");

	WaitForLanding();
	CampTime = bShortCamp ? 0.3 : 3.0;
	bShortCamp = false;

	SetRouteGoal();

	if (Pawn.ReachedDestination(RouteGoal) )
	{
		Goto('Pausing');
	}
	else
	{
Moving:

		`log("MOVE DEFENDING");

		Pawn.bWantsToCrouch = false;

		MoveToward(MoveTarget, MoveTarget, 20, false, true);

		if (Pawn.ReachedDestination(RouteGoal))
		{
			goto('Pausing');
		}
	}
	LatentWhatToDoNext();

Pausing:
	`log("PAUSE DEFENDING");

	StopMovement();

	Pawn.bWantsToCrouch = IsSniping() && !WorldInfo.bUseConsoleInput;

	SetFocalPoint( Pawn.Location + vector(MoveTarget.Rotation) * 10.0 );

	SwitchToBestWeapon();

	Sleep(0.5);

	if (UTWeapon(Pawn.Weapon) != None && UTWeapon(Pawn.Weapon).ShouldFireWithoutTarget())
		Pawn.BotFire(false);

	Sleep(FMax(0.1,CampTime - 0.5));

	// Paused at one destination, select the other destination
	if(RouteGoal != none && RouteGoal == TMTPatrolEnd)
	{
		RouteGoal = TMTPatrolStart;
	}
	else
	{
		RouteGoal = TMTPatrolEnd;
	}

	LatentWhatToDoNext();
}

state ChargingNoStrafe extends Charging
{
	function bool StrafeFromDamage(float Damage, class<DamageType> DamageType, bool bFindDest)
	{
        	return false;
	}

	function bool TryStrafe(vector sideDir)
	{
		return false;
	}
}

defaultproperties
{
  TMTMaxFireRange = 500
  TMTPatrolEnd = None
  TMTPatrolStart = None
  TMTTarget = None
}

When the bot is configured using our action, it begins calling ScanForPlayers on a timer, which checks if the TMTTarget (our player) is in close enough. If that’s the case, it enters the ChargingNoStrafe state, which is almost entirely defined in UTBot.uc. If it does not find anything, it will be in a Defending state, walking between two path nodes defined by TMTPatrolStart and TMTPatrolEnd.

Save both files and re-compile the scripts.

Configuring, and Adding Bots to the Level

Game Over!

The last element to add to our game will be a “game over” screen. Ideally, you would use Scaleform to create such UI screens, but it is beyond the scope of this guide. We will simply use Kismet to create a sequence of actions that display an existing Scaleform GFx movie. To begin this sequence, we will need an event. This event will be triggered by our TestWinningConditions() method when the game is won. To begin, create a new class file named SeqEvent_TMTGameWon.uc with the following code:

class SeqEvent_TMTGameWon extends SequenceEvent;

event Activated(){
       `log("IN SeqEvent_TMTGameWon Activated()");
}

defaultproperties
{
	ObjName="Tomato Game Won"
	ObjCategory="Tomato"
        bPlayerOnly = false
}

Next, let’s modify TestWinningConditions() in TomatoPlayerController.uc, to activate this event. Update the method as follows:

exec function TestWinningConditions()
{
   local int i;
   local Sequence GameSeq;
   local array<SequenceObject> AllSeqEvents;

  `log("TestWinningConditions() : Checking winning conditions");
  `log("TestWinningConditions() : Collected: "$TMTCoinsCollected);
  `log("TestWinningConditions() : Needed: "$TMTCoinsNeededThisLevel);

  if(TMTCoinsCollected > 0 && TMTCoinsNeededThisLevel > 0 && TMTCoinsCollected >= TMTCoinsNeededThisLevel)
  {
       `log("TestWinningConditions() : Victory!");
       GameSeq = WorldInfo.GetGameSequence();

       if(GameSeq != None)
       {
               GameSeq.FindSeqObjectsByClass(class'SeqEvent_TMTGameWon', true, AllSeqEvents);
               for(i=0; i<AllSeqEvents.Length; i++)
                       SeqEvent_TMTGameWon(AllSeqEvents[i]).CheckActivate(WorldInfo, None);
       }
  }
  else
  {
       `log("TestWinningConditions() : Go collect more coins!");
  }
}

In the code above, we are simply getting and activating all sequence events of type SeqEvent_TMTGameWon.

Save and compile all scripts.

Open up UDK, and load TMT-Zone1.udk.

The complete source code and level file created during this guide is available here: http://labs.vectorform.com/files/Tomato.zip

In January of 2010 the hot water heating system of my family’s lake house failed with catastrophic consequences. Many of the copper pipes in the home froze and burst. By the time we found out about the problem the damage had been done, and done well. The basement had several inches of water in it and we were also treated to beautiful ice sculptures such as this one, formed on our deck.

Is this the Hoth system?

Needless to say, once the insurance work was complete and things were as good as new, I did not want to repeat this again the following winter or any thereafter. The problem is that the home is roughly an hour away from our primary residence. Driving out to the house every day to check the temperature is obviously out of the question. But because frozen pipes can occur in as as little as 24 hours after a heating system failure during frigidly cold Michigan winters, knowing the state of the heating system at all times is vitally important. And no heating system is 100% reliable, so without knowledge of the temperatures and state of the heating system in the home it was going to be hard to sleep at night during the looming winter months.Faced with this dilemma I decided it would be a great opportunity for an embedded systems project. The result is a little box which sends temperature data in the home to my phone via SMS messages. Links to information and resources concerning almost every part/library/service used in this project may be found at the end of the post. The project ended up being a rather good investment as you will see in the exciting conclusion.

Design

The goal of the project was to remotely acquire and deliver temperature data measured from points in the heating system and home with the following design objectives in mind (in order of importance)

1. Reliability
2. Low cost of operation (month to month variable costs)
3. Ease of construction, time to build
4. Relatively low up front cost

After considering some designs using a pc/linux-based solution using some parts I had lying around I ended up deciding to base the project on the Arduino. I felt this would most satisfy all the design objectives except perhaps #4. #1 (less moving parts), #2 (extremely low power consumption vs. the pentium 4 board I had lying around) #3 (designed for rapid prototyping with excellent libraries available to reduce the amount of code). Thus, I based the project on the Arduino Uno.

Arduino Uno

To sample the temperatures I chose to use some Dallas Semiconductor DS18B20 One-wire sensors. I chose this over a regular thermistor because I wanted to be able to add or remove extra temperature sensors without having to rewire the box internally. If I want to add another sensor with this system I can just daisy-chain it to the existing wiring. I also believe that these sensors are a bit more precise and accurate.

For communication I considered using a full-time internet connection but this ended up being too expensive and my experiences with the provider in that area in terms of reliability made me abandon this option. Using cellular data seemed like the only other possibility. Because of the extremely low bandwidth requirements of the application I found that I could rely on just using SMS messages to send the temperature data to my phone. Although the SM5100B cellular modem I picked for the job supports a GPRS/TCP connection, it was certainly overkill for this project.

SM5100B & Evaluation Board

The idea for the unit was to send temperature data once every four hours, if there were no critically low temperatures. This let me know that the system was functional. If messages did not arrive on time then there was still time for the system to recover or for me to go out and fix any problems with it. In the event that the unit measured a critically low temperature a message would be sent immediately.

AT&T Pay as You Go

To keep the monthly costs low I found a “pay as you go” plan from AT&T that requires no up front contract and only costs $4.99/month for 200 text messages. This was enough for the messaging frequency of the project with some room left for testing and mistakes.

I ordered a new SIM card for the SM5100B on Amazon for a few dollars (3G sim card required for the service) and installed it into the card slot on the eval board. After signing up on the AT&T website, providing the IEMI number and SIM card info, I was ready to test the SM5100B.

Setting up the SM5100B

The SM5100B requires some configuration to get it running on the network. I mounted it in the eval board, connected it to power, plugged in the USB port and connected it to my Mac. I used the built in screen command from the OS X terminal to connect to the SM5100B’s UART0. The default baud rate of the unit is 115200 so I invoked screen as follows:

(The #’s imply that the exact name of the device, once plugged into your computer, will vary). Type CTRL-A then CTRL-\ to exit. If you have a PC then you can just use a terminal emulation program like Hyper Terminal to achieve the same result.

Once connected, you will see some status messages as the SM5100B starts up. There will be a status message indicating that the booting is complete and at that point you can start typing in “AT” commands to set things up and experiment. The first thing I did was issue ATE1 to turn on local echo. After that, I set up the module to work on the GSM band appropriate for the AT&T network in North America AT+SBAND=7. I rebooted the unit and then ran AT+CMFG=1 to put the unit into the appropriate (text-based) SMS mode. I sent a few messages manually to verify things were working.

Adding a Second “soft” Serial Port

I wanted to be able to easily interact with SM5100B and get diagnostic information from the running system by plugging the unit into my computer. Because the Arduino only has one hardware UART I am using the NewSoftSerial library to add another “soft” UART by utilizing two of the Arduino’s digital I/O ports (pins 6-rx and 7-tx). This extra serial port is used to communicate with the SM5100B module on its UART0 while the regular hardware UART on the Arduino is used to hook up to an external terminal via its USB port.

In order to do this I needed to clear the RX, DTR, RTS, TX, and CTS jumpers on the eval board per the SM5100B documentation. I removed these with desoldering wick and then soldered two wires for UART0 onto the eval board. These wires connect to pins 6 and 7 on the Arduino.

The code for the project provides communication between the terminal on the hardware UART and the “soft” serial port connected to the SM5100B. The code also recognizes the CTRL-Z character from the terminal as a request to sample and print out the temperature sensor data for testing purposes.

Finding an Antenna

I found this antenna while looking around on Digi-Key’s site.

It provides 3dB gain, which is enough for this application. One nice thing about it is the inclusion of adhesive backing on one side of the antenna for mounting purposes. I ended up mounting the antenna on a large window after finding the best signal there. You can get the SM5100B’s current signal strength with the AT+CSQ=? command. I have not had any signal strength issues while using this antenna to date.

Wiring & Communicating With the Temperature Sensors

This project makes use of the helpful Dallas Temperature Control and OneWire libraries for the purposes of communication with the temperature sensors on the one-wire bus. I wired the sensors using the “parasitic power” configuration to simplify things. The 4.7k pull-up resistor is not visible in the pictures because it is soldered into the 5v and Pin 3 wires right before exiting the project enclosure, covered by shrink tube.

In the source code you will find that I have hard coded the addresses of the sensors. I needed to know which sensor was which in order to identify the particular thing being measured. I found the addresses of the sensors by connecting them and then loading some of the example code that comes with the Dallas Temperature Control library.

I installed two sensors onto the bus. One to measure ambient temperature in the home and the other to measure the temperature of one of the pipes carrying hot water from the heating system’s boiler. The thermostat in the home is set to 55 degrees F and fluctuates very little. The temperature of the pipe can be anywhere from 190 to around 55 (ambient target for thermostat) as the heating system cycles.

Supplying Power

To supply power to the Arduino and SM5100B I am using a plain old 9v wall wart. Keep in mind that the SM5100B has some substantial current requirements and it will not function properly unless these requirements are met. When the cellular radio is active the unit can use up to 2A (350mA average). Powering the unit from the usb port is not an option. The 9v supply connects to the Arduino and then power is distributed to the SM5100B from the 5v source on the Arduino using a barrel jack connector. I wanted to be able to disconnect the two components easily so I am taking advantage of the pre-existing connector on the SM5100B eval board.

Providing a Home for the Arduino & SM5100B

The Arduino and SMB100B board are living comfortably in a spacious project box from Radio Shack. The box features a floor made from PCB board scrap that is raised about a quarter inch off the bottom of the box with risers. The Arduino mounts to the raised floor and two holes provide access to both the USB and power connectors. The wires for the temperature sensor bus run out the other side of the enclosure through a rubber grommet. The SM5100B board mounts to the lid of the box with industrial strength padded / double-sided tape. Had the unit been pre-drilled with mounting holes I would have used those. Finally, I am employing the coaxial connector that comes with the SM5100B to run the antenna connection through the lid. The tenants are currently complaining about the ugly USB port window, which is horribly cut. I didn’t have a Dremel tool yet so please do not point and laugh.

The Code

The logic of the main control loop is essentially:

loop
        if temps have not been sampled recently (check configured period)
  		sample temp sensors

	if request was made for temps via main serial port
		print current temps to terminal

	check temperature values for alarm condition

	if alarm exists (one or more temps below threshold)
		if alarm message has not been sent
			send alarm message

	else if it is time to send a report (once every four hours)
		send a report message with current temps

	if an alarm message was previously sent but there is no longer an alarm (temps above threshold again)
		send an alarm cleared message

	send bytes to terminal from the SM5100B and vice-versa

end loop

The interesting parts of the code that deal with sending the SMS messages and getting temperature data from the sensors are found in the sendSMS(), sampleTemps() and setup() functions.

Here is a complete listing of the source

#include <OneWire.h>
#include <DallasTemperature.h>
#include <NewSoftSerial.h>

/*
  Assumes the following of the SM5100B that is connected:

  - Baud rate is set to 9600, the default for the unit is 115200 (AT+IPR=9600)
  - North American band/frequencies GSM 850, PCS 1900 selected (AT+SBAND=7)
  - SMS Mode is 'Text' (AT+CMGF=1)
  - Local echo is on (ATE1)

  Before running this sketch, run the above commands and save the config to non-volatile memory with: AT&W
*/

// Data wire is pin 3 on the Arduino
#define ONE_WIRE_BUS 3

// 9 bit precision corresponds to 0.5 degrees C resolution
#define TEMPERATURE_PRECISION 9

// The number to send reports to
#define SMS_NUMBER "12485555555"

// The period in milliseconds to wait in between reports. 4 hours = 1000 * 60 * 60 * 4
#define SMS_REPORT_INTERVAL 14400000

// The period in milliseconds in between samples of the temp sensors. If we sample continually the serial ports
// will not have enough time to relay characters without being choppy
#define TEMP_SAMPLE_INTERVAL 1000

// The period in milliseconds to wait after an alarm clears to send a report. This will ensure that
// we do not send reports over and over if a temperature is hovering around a threshold. 30 minutes = 1000 * 60 * 30
#define ALARM_CLEAR_REPORT_INTERVAL 1800000

// The low temperature thresholds for each sensor in degrees Fahrenheit
#define PIPE_THRESHOLD_F 50.0
#define AMBIENT_THRESHOLD_F 40.0

// The most recently measured temperatures in degrees Celcius
float pipeTemp;
float ambientTemp;

// Create a 1-Wire bus for the temp sensors to use
OneWire oneWire(ONE_WIRE_BUS);

// Use the DallasTemperature library to simplify working with the OneWire sensors
DallasTemperature sensors(&oneWire);

// These device addresses were determined in advance by running some of the DallasTemperature library example code
DeviceAddress pipeSensor =    {0x28, 0xA7, 0x96, 0x8E, 0x02, 0x00, 0x00, 0x6F};
DeviceAddress ambientSensor = {0x28, 0xFE, 0x8F, 0x8E, 0x02, 0x00, 0x00, 0x58};

// Used to save the last point in time that a report was sent
unsigned long lastReportTime;

// Used to save the last point in time we took a temperature reading
unsigned long lastTempSampleTime;

// Create a "soft" serial port on pins 6(RX) and 7(TX)
NewSoftSerial modem(6,7);

// Keep track of if we have sent an SMS for a newly triggered alarm
boolean alarmSent = false;

// A flag used to determine if we should print the current temp to the terminal for inspection
boolean printTempsToTerminal = false;

char incoming_char = 0;

void printCurrentTemps(Print *p)
{
  p->print("Pipe Temp: ");
  printTemp(pipeSensor, p);
  p->print(" - ");
  p->print("Ambient Temp: ");
  printTemp(ambientSensor, p);
}

void printTemp(DeviceAddress deviceAddress, Print *p)
{
  float tempC = sensors.getTempC(deviceAddress);
  if (tempC != DEVICE_DISCONNECTED)
  {
    p->print(DallasTemperature::toFahrenheit(tempC), 1);
    p->print(" F");
  }
  else p->print("?");
}

void printResolution(DeviceAddress sensor)
{
  Serial.print(sensors.getResolution(sensor), DEC);
  Serial.println("-bit");
}

void sendSMS(char *msg)
{
  modem.print("AT+CMGS=");
  modem.print(34, BYTE);
  modem.print(SMS_NUMBER);
  modem.println(34, BYTE);
  modem.print(msg);
  modem.print(" ");
  printCurrentTemps(&modem);
  delay(500);                // Wait for ">" prompt
  modem.print(0x1A, BYTE);   // CTRL-Z
}

void setup(void)
{
  // Start the serial ports
  Serial.begin(9600);
  modem.begin(9600);
  Serial.println("Starting SM5100B Communication...");

  lastReportTime = lastTempSampleTime = millis();

  // Start up the temperature sensors
  sensors.begin();

  // We should see our two 2 devices
  Serial.print("Found ");
  Serial.print(sensors.getDeviceCount(), DEC);
  Serial.println(" sensors");

  // Set the resolution to use for measurement
  sensors.setResolution(pipeSensor, TEMPERATURE_PRECISION);
  sensors.setResolution(ambientSensor, TEMPERATURE_PRECISION);

  // Show the resolution to make sure it is what we expected
  Serial.print("Pipe Sensor Resolution: ");
  printResolution(pipeSensor);
  Serial.print("Ambient Sensor Resolution: ");
  printResolution(ambientSensor); 

  sampleTemps();
  printCurrentTemps(&Serial);
  Serial.println();
}

void sampleTemps(void)
{
  // Get the temperatures from both sensors
  sensors.requestTemperatures();

  pipeTemp = sensors.getTempC(pipeSensor);
  ambientTemp = sensors.getTempC(ambientSensor);
}

boolean checkForAlarm(void)
{
  return (ambientTemp == DEVICE_DISCONNECTED || pipeTemp == DEVICE_DISCONNECTED ||
          DallasTemperature::toFahrenheit(pipeTemp) <= PIPE_THRESHOLD_F ||
          DallasTemperature::toFahrenheit(ambientTemp) <= AMBIENT_THRESHOLD_F);
}

void loop(void)
{
  unsigned long newTime = millis();

  // Take a temperature sample if it is time
  if ((newTime - lastTempSampleTime) > TEMP_SAMPLE_INTERVAL)
  {
    sampleTemps();
    lastTempSampleTime = newTime;
  } 

  if (printTempsToTerminal)
  {
    printCurrentTemps(&Serial);
    Serial.println();
    printTempsToTerminal = false;
  }

  boolean alarmActive = checkForAlarm();

  // If we have an unsent alarm send a message
  if (alarmActive && !alarmSent)
  {
    sendSMS("(Alarm)");
    alarmSent = true;
    lastReportTime = newTime;    // This will reset the report interval
  }

  // Or send a message if we have reached the report interval
  else if ((newTime - lastReportTime) > SMS_REPORT_INTERVAL)
  {
    lastReportTime = newTime;
    sendSMS("(Report)");
  }

  // Reset the alarmSent flag if an alarm clears and the interval has passed
  if (!alarmActive && alarmSent &&
     ((newTime - lastReportTime) > ALARM_CLEAR_REPORT_INTERVAL))
  {
    alarmSent = false;
    lastReportTime = newTime;
    sendSMS("(Alarm Clear)");
  } 

  while (modem.available() > 0)
  {
    // Take any incoming data from the SM5100B modem and send it to the terminal
    incoming_char = modem.read();
    Serial.print(incoming_char);
  }
  // Relay input from the terminal to the SM5100B modem
  while (Serial.available() > 0)
  {
    // If the character is CTRL-Z then set a flag we will check later to print the current temps to the terminal
    incoming_char = Serial.read();
    if (incoming_char == 0x1A)
    {
      printTempsToTerminal = true;
    }
    else
    {
      modem.print(incoming_char);
    }
  }
}

The Finished Product

Here is the completed project, ready to install at the home.

Did it Work?

After some testing I installed the system in late November. A couple of weeks later I saw some status messages come in at one of the four hour intervals that showed an unusually high reading for the ambient temperature (around 70). I called my neighbor at the house and had him go over to investigate. He called me and said the boiler in the basement was shooting flames out of the bottom. Apparently, something had fallen into and blocked the chimney, forcing the boiler flame to backdraft. High temperature explained and disaster averted.

The aforementioned malfunction caused irreparable damage to the boiler (some 30 years old) so I had to invest in a new one. This made me feel like the utility of my project was basically moot because this new boiler would be so reliable that I wouldn’t need to monitor it. Interestingly enough, two days after the new boiler was installed I started getting alert messages. I called the company who installed it and requested they go out and look at it. Sure enough, it was not running. They made some adjustments and left with it running fine. A couple of days later I started getting alerts again. The call and service trip was repeated. Additional tweaks were made. This routine actually occurred two more times before the company who installed the boiler replaced a faulty igniter. After replacing the igniter the system ran flawlessly the rest of the winter. And the temperature data continued to show up every four hours on my phone without a hiccup.

The total project cost was about $175 plus some materials and tools I had to buy and took about a month of here-and-there free time to research, assemble, code and test. Additionally, there was the $4.99 a month to provide cellular service for the messaging during the cold months. Considering how it saved me from burning down the house and then again after investing in the new heating system, I think it was definitely worth it

Links / Resources

Arduino Related

• Arduino
• Dallas Temperature Control Library
• OneWire Library
• NewSoftSerial Library

Parts

• Arduino Uno
• SM5100B Eval Board
• SM5100B Cell Module
• Dallas DS18B20 Sensor
• Coaxial adhesive backed antenna

Service

• AT&T Pay As You Go

The Siri application released with the iPhone 4s has the potential to radically impact how we interact with technology. Ed Wrenbeck, former lead developer from Siri, talks through his history with the app…

On March 24th, 2008 I first talked with my friend Darren about a new venture he was involved with which was simply called “Stealth Company” at the time. (try http://stealth-company.com) This was four months before the iPhone app store would officially launch.

We left off at that point with the general thought that we’d like to work together, but we didn’t come back to the project again until mid July of 2008. I officially started working on the Siri application in early August 2008. I was the only iPhone/Objective-C developer on the team. The work I was doing with the native iPhone application was really treated as an R&D exercise. The go to market strategy was based mostly on a web experience.

When the iPhone application started to come together, aggressively utilizing the full capabilities of the device, it quickly became apparent that Siri was meant to be a first class mobile experience that could take advantage of the power and features available to a native application. Siri never really left its web roots behind though. From the earliest days right up until the last version offered on the app store, the user interface has been almost entirely an HTML web view with native elements tightly integrated around it. Siri stretched to the very limit what was possible to do with an integrated web interface on a mobile device.

The Siri application was first shown publicly at D7, the “All Things D” conference in May 2009. (http://allthingsd.com/20111004/in-depth-with-siri-the-full-demo-from-the-d7-conference-plus-an-old-school-bonus/) It was the first time I really got the sense that I was involved with a product that would be used by millions of people.  Impressing a veteran technology writer such as Walt Mossberg is not an easy task.

Voice Recognition – the first piece
Today Siri is closely associated with the voice recognition capabilities from Nuance, but VLingo was the first voice recognition system used in the app. Nuance would not come into play until just a few months before the application went onto the app store in early 2010. The team was almost fanatical about getting the voice recognition just right, and we went through endless tests trying to tune these platforms to ultimately maximize the results.

Commercials for digital assistants always seem more natural than the reality, and there’s a reason. State of the art voice recognition systems will rarely, if at all, return results with 100% confidence in the translated string. You can expect a 60-70% return on average. Siri cannot change that limitation; however the team was able to find ways to enhance it.

Natural Language Processing – what Apple saw in Siri
Often times reviews on iTunes would comment on how the Siri app seems to do a better job than the Nuance app or Dragon dictate. The iPhone application is just the portal to the brains of Siri running on a bunch of servers. There, it can take a sentence and dissect it naturally. An example might be “Book a table at Il Fornaio in Novi for 7PM” and it determines that “Il Fornaio” is likely the name of a place and “Novi” is likely a location. This is referred to as natural language processing, and it is incredibly difficult to get right.

Many users and technology pundits are wondering what’s different from other voice recognition apps on other platforms. Platforms such as Android and Windows Phone 7 offer their own voice interaction capabilities. Don’t forget, iOS offered its own voice control interface prior to the introduction of Siri on the 4S. But they are missing the point of Siri itself, which is about what happens after the voice command has been turned into text.

Tell another system to “Book a table at Il Fornaio at 7:00 with my mom;” the system can no doubt create a calendar entry at 7:00 and might even know who your mom is. It might even be possible for that device to figure out the closest Il Fornaio restaurant. What differentiates the NLP logic in Siri is that it will maintain context so you could say: “Also send her an email reminder.” Siri will understand ‘her’ and compose the email accordingly.

This comprehension of context requires a great deal of logic and processing behind the scenes. The media commonly refers to this as “Artificial Intelligence” but in reality…

It’s not really AI
With Natural language processing in the mix it feels more human, like it understands you. This in itself adds to the mystique surrounding Artificial Intelligence. But real AI can’t fit on a phone in our world…yet.

Siri is basically a contextual, semantic, personalized search engine. We affectionately called it a “Do” engine. A search engine can evaluate text strings and look for matching results. A “Do” engine maintains awareness of the user, everything it knows about that user and processes strings in the context of the user.

One interesting part of Siri is its ability to utilize five or six translations of a voice command to determine what the user is trying to say. When trying to recognize the name of a restaurant such as “Il Fornaio” or a city named “Novi” the voice recognition engine will typically return several possible matches, as these are not simple words in the dictionary. The recognition engine might see these as lower confidence scores in a direct voice translation, but in the context of a user, his surroundings and behavior, they may change their rank.

Sometimes, Siri’s uncanny ability to understand the environment and the user even surprised me. One of my common test requests would be something like “Find a Tigers’ game”. One time I happened to be in San Jose and, not thinking, tested Siri with this request and was delightfully pleased when it offered to help me get tickets to an upcoming game in San Francisco when the Tigers came to town in a couple of weeks.

That last item, behavior, is a biggie. It requires trust – which Siri got with Apple.

Big Brother factor – why Siri needed Apple
For Siri to be really effective, it has to learn a great deal about the user. If it knows where you work, where you live and what kind of places you like to go, it can really start to tailor itself as it becomes an expert on you individually. This requires a great deal of trust in the institution collecting this data. Siri didn’t have this, but Apple has earned their street cred.

Developers are realizing that they can deliver amazing experiences when they understand more about the user. However, users today are careful to not give away too much of that information. With Apple’s strong reputation behind it, there’s a massive potential for success here.

The formula is there, the market is perfect.
At Vectorform, I’m dealing with all sorts of exploratory technology, things that are pushing boundaries even further than my work with Siri. We are constantly looking at the digital landscape, mapping out current innovations and how they impact future trends.

The release of Siri to the masses has massive shockwave potential in our book.

What we’re looking for on the horizon:

An open SDK – Intelligence needs to come from many sources. Siri will need to mine collective input from as many data sources as possible in order to grow and stay relevant. Siri can’t be a marketing engine for select partners. True digital assistants have to put the user first, just as the user would do when making a decision on their own. There is enormous potential for Siri to integrate with data sources of many different types. Opening Siri up while ensuring the quality of the data will be a challenge for Apple. However, the recent success with the iOS and Mac App Stores has given Apple an effective way to influence its third part developers.

A single voice – The original vision for Siri was a personal assistant available to you from any device, anywhere, at any time. Apple has pulled back on that vision a bit and made Siri an accessory to your iPhone. Siri needs to start growing again and become your advocate across all your digital platforms. Long term, Vectorform is interested in determining what kind of role Siri can play in a vehicle or… 

Ed Wrenbeck is an iOS Architect at Vectorform. In a previous life, he was the lead iPhone developer of Siri.  “While I do know the intimate details of the Siri Application, I have no inside knowledge of the new Siri released by Apple.”