Disclaimer: this is an automatic aggregator which pulls feeds and comments from many blogs of contributors that have contributed to the Mono project. The contents of these blog entries do not necessarily reflect Xamarin's position.

October 24

Mono for Unreal Engine

Earlier this year, both Epic Games and CryTech made their Unreal Engine and CryEngine available under an affordable subscription model. These are both very sophisticated game engines that power some high end and popular games.

We had previously helped Unity bring Mono as the scripting language used in their engine and we now had a chance to do this over again.

Today I am happy to introduce Mono for Unreal Engine.

This is a project that allows Unreal Engine users to build their game code in C# or F#.

Take a look at this video for a quick overview of what we did:

This is a taste of what you get out of the box:

  • Create game projects purely in C#
  • Add C# to an existing project that uses C++ or Blueprints.
  • Access any API surfaced by Blueprint to C++, and easily surface C# classes to Blueprint.
  • Quick iteration: we fully support UnrealEngine's hot reloading, with the added twist that we support it from C#. This means that you hit "Build" in your IDE and the code is automatically reloaded into the editor (with live updates!)
  • Complete support for the .NET 4.5/Mobile Profile API. This means, all the APIs you love are available for you to use.
  • Async-based programming: we have added special game schedulers that allow you to use C# async naturally in any of your game logic. Beautiful and transparent.
  • Comprehensive API coverage of the Unreal Engine Blueprint API.

This is not a supported product by Xamarin. It is currently delivered as a source code package with patches that must be applied to a precise version of Unreal Engine before you can use it. If you want to use higher versions, or lower versions, you will likely need to adjust the patches on your own.

We have set up a mailing list that you can use to join the conversation about this project.

Visit the site for Mono for Unreal Engine to learn more.

October 22

Leading Unity into the Future

Hello everyone! As you all know, we’ve been making some big moves at Unity lately. We’ve partnered with some amazing companies and begun putting a lot more energy and resources into developing technologies that will help you be more efficient when you create games and then help you connect your games with an awesome audience when you’re ready for it.

This is a lot to take on as a company and building it right is going to take a huge effort. We keep our eyes out for the best talent and help wherever we feel we can use it at every level. That’s why today, I’m pleased to welcome John Riccitiello onto the Unity team as our new CEO. Sure, that sounds odd, as it also means I’m stepping down from the role, but this is an amazing win for Unity and the community.

He’s the right person to help guide the company to the mission that we set out for ourselves over a decade ago: democratize game development!

Many of you are likely familiar with John. He’s been in the games industry for a long time, both as COO and later CEO of Electronic Arts. He’s also helped fund and guide some notable startups like Oculus and Syntertainment among many others, and is a heartfelt believer in the indie scene and its importance to the overall well-being of the industry.

I’ve had the pleasure of working with John closely over the last year after I convinced him to join our board. It’s been a delight to see his passion for Unity and what we’re doing here grow as he got to know the Unity community better and better.

So, what does this mean for me? It means I get to get back to doing what I love the most about working at Unity: strategy, and connecting with developers. I will be heavily involved with the company’s direction, and will focus my efforts on finding the best ways to serve all of you amazing developers, all while working with some insanely talented people here at Unity.

What does this mean for Unity? Not too much, since John completely agrees with our vision and our strategy. If anything it means that we’ll be more focused than ever about making sure everyone has access to the best technology and services. We want all of you to have the best tools and opportunities, and we’re going to do everything we can to make that happen across the board.

So, welcome John to the Unity family! Great things are ahead!

Much love,

David

Directory Notifications to find changes

Pending Changes is now faster than ever because it doesn’t need to traverse the workspace anymore. We have implemented a new mechanism based on Windows Directory Notifications to detect workspace changes faster than ever.

It is available only on Windows but we’ll eventually implement it for Linux and Mac (based on their corresponding notification mechanisms).

What does it mean for you? Well, as soon as you install 5.0.44.608 or 5.4.15.604 (or higher) Pending Changes will be faster. You’ll clearly notice the speed up with really large workspaces (in number of files) and with slow disks. The slower the disk is, the clearer the speed up will be.

How Pending Changes works? (without directory notifications)

Whenever you click on “refresh” on Pending Changes Plastic triggers a search to find the files that have been modified on your workspace.

The diagram below describes the process in detail:

  • The process checks the “pending changes options” first: if only checkouts are requested, then there’s nothing to look for, just print the list. That’s why working with checkouts makes sense for huge workspaces (>400k files).
  • If the options to find changed files on disk are set, the directory walk will start.
  • For each directory starting on the root of the workspace Plastic will try to find changed files. It will compare the timestamp on disk with the stored timestamp on the wktree file: the plastic.wktree file (inside .plastic) stores the metadata of the file. It know “how it was” after the last update or checkin. So if the timestamp and size doesn’t match, the file was changed. If timestamp doesn’t match and size does, Plastic hashes the file. It is slower but it makes sure the file is different. Alternatively there’s an option to force Plastic to always find changes based on file contents (ignoring the timestamp) which is definitely slower but required on some scenarios.
  • At the end of the disk walk, Plastic has a list of all the modified files on your workspace.

The diagram doesn’t show the last step (if the option is set): find “moved and renamed files” by matching potential added and deleted files.

What I want to explain with the diagram is that there is at least one IO operation by directory. If you keep pressing “refresh” on the Pending Changes view, chances are the list will be filled quickly: after the first traversal the workspace will be loaded in the file system cache so the next reads will be blazing fast. But if your disk is not very fast, or your computer is performing a lot of IO, or using a lot of RAM, chances are that your workspace won’t be entirely loaded in the file system cache, and then walking it will take longer.

You probably noticed it when after some coding you go back to Plastic, click refresh, and it takes longer than usual. This is exactly what we wanted to improve with this feature.

How Pending Changes with Directory Notifications works?

It is rather simple: we use Windows directory notifications to listen to events on the workspace directory. Each time a file is written, deleted, added, moved or renamed inside the workspace, Plastic gets a notification.

So, while we perform an initial directory traversal the first time the Pending Changes view loads, no other full directory walk will be needed later, greatly speeding up the operation.

What we do is the following: after the first traversal we keep a tree with the metadata of what is on disk, and we invalidate parts of it (on a directory basis) each time a change happens inside it. This way Pending Changes only has to reload parts of the tree instead of walking the workspace entirely. It saves precious time while still being a robust solution.

One of the issues with Directory Notifications on Windows is that it can’t really notify file or directory moves, so you have to match pairs of added/deleted. Instead of trying to pair the notifications we just invalidate parts of the tree and let the regular Pending Changes code to do the rest.

So, there’s still room for improvement but our initial tests probed that the extra complexity of doing a more precise event tracking didn’t pay off compared to just invalidating parts of the tree.

Availability

Chances are you are already using it :-)

If you’re using 5.0.44.608 or higher or 5.4.15.604 or higher, you’re already enjoying the Directory Notifications powered Pending Changes view.

October 21

Xamarin Evolve 2014 Session Recordings Now Available

At Xamarin Evolve 2014, we were excited to be joined by industry experts and Xamarin engineers delivering sessions on diverse mobile developer topics ranging from the latest in native mobile technologies, to enterprise development, to gaming and more. We are now pleased to make these great Xamarin Evolve 2014 conference sessions available on evolve.xamarin.com for your viewing pleasure.

Xamarin CTO Miguel de Icaza gives a session at Xamarin Evolve 2014

Head over to the Xamarin Evolve 2014 site now to kick back and enjoy the topics you find most interesting. With so many sessions, there’s plenty to choose from and something for everybody.

Enjoy!

App Spotlight: OBD Fusion Car Diagnostics Video

Evolve 2014 was an eye-opening event. It was an amazing opportunity to see some of the innovative mobile apps people are creating with the Xamarin platform. We’ll be featuring several of these over the coming weeks. Today we’re highlighting an automotive diagnostic app called OBD Fusion.

Matt O’Connor from OCTech, and creator of OBD Fusion, shared his app that wirelessly reads onboard vehicle diagnostics from a car. The app enables car enthusiasts to create their own dashboards and access much of the same diagnostic information a master mechanic would use with specialized automotive equipment to diagnose and tune an automobile. With OBD Fusion, users can calculate fuel economy, graph data, and also test emissions in real-time.

To really appreciate how this works, we got a car and took a drive around Atlanta. Watch it in full-screen to see it in action.

What really impresses me is how polished OBD Fusion is and how cleanly it presents useful information to the user. With sensor data coming in at up to 100 times a second, the app works flawlessly, utilizing multi-threading to process a large amount of data and update the dashboards and graphs in real-time – something only a native app can effectively do.

Matt originally created his app in C# as a desktop application. Utilizing Xamarin, he was able to convert it to iOS and Android with over 90% code-reuse, and by using app templates he’s created native smartphone and tablet user experiences. In addition to the automobile’s sensor data, he’s also integrated sensors on the mobile device, including the GPS and accelerometer to measure position and vehicle acceleration.

Congratulations to Matt for creating an outstanding app!

Learn More

OBD Fusion is available in the iTunes and Google Play app stores.

To get started developing with the Xamarin platform, check out our developer documentation, or get live online training with Xamarin University.

October 20

Xamarin.Forms Book Preview Edition Available Now

The Petzold engine has been churning through the Xamarin.Forms API, and we’re pleased to announce that the first preview edition of Creating Mobile Apps with Xamarin.Forms is now available. It was distributed in print to all Xamarin Evolve 2014 attendees last week and is now available as a free download in a number of formats:

Creating-Mobile-Apps-with-Xamarin-Forms

The six chapters available in the preview edition cover the history of Xamarin.Forms, solution structure, the basics of the view system and building your first Xamarin.Forms app. The extensive samples are also available for download from GitHub.

Charles also presented two talks at Evolve: XAML for Xamarin.Forms and Xamarin.Forms is Cooler Than You Think, both of which will be available shortly as videos of the sessions are published at evolve.xamarin.com.

Evolve-Xamarin-Forms-talk

Work continues on both Xamarin.Forms and the book!

Traktor Pro .tsi file format reverse-engineered – docs on GitHub

I’ve reverse-engineered the .tsi binary file format specification, which Traktor Pro by Native Instruments uses to store its Controller Mappings. I am hoping this should open the gates to new power tooling for MIDI controller mapping power tools (Traktor’s own being rather sub-optimal).

The project, documentation and instructions are here: https://github.com/ivanz/TraktorMappingFileFormat/wiki

Can’t sing enough praises of 010 Editor by SweetScape which enabled me to write scripts and define data structures incrementally on top of a binary blob.

2014-10-20_01-53-45

October 16

The Wait Is Over: MimeKit and MailKit Reach 1.0

After about a year in the making for MimeKit and nearly 8 months for MailKit, they've finally reached 1.0 status.

I started really working on MimeKit about a year ago wanting to give the .NET community a top-notch MIME parser that could handle anything the real world could throw at it. I wanted it to run on any platform that can run .NET (including mobile) and do it with remarkable speed and grace. I wanted to make it such that re-serializing the message would be a byte-for-byte copy of the original so that no data would ever be lost. This was also very important for my last goal, which was to support S/MIME and PGP out of the box.

All of these goals for MimeKit have been reached (partly thanks to the BouncyCastle project for the crypto support).

At the start of December last year, I began working on MailKit to aid in the adoption of MimeKit. It became clear that without a way to inter-operate with the various types of mail servers, .NET developers would be unlikely to adopt it.

I started off implementing an SmtpClient with support for SASL authentication, STARTTLS, and PIPELINING support.

Soon after, I began working on a Pop3Client that was designed such that I could use MimeKit to parse messages on the fly, directly from the socket, without needing to read the message data line-by-line looking for a ".\r\n" sequence, concatenating the lines into a massive memory buffer before I could start to parse the message. This fact, combined with the fact that MimeKit's message parser is orders of magnitude faster than any other .NET parser I could find, makes MailKit the fastest POP3 library the world has ever seen.

After a month or so of avoiding the inevitable, I finally began working on an ImapClient which took me roughly two weeks to produce the initial prototype (compared to a single weekend for each of the other protocols). After many months of implementing dozens of the more widely used IMAP4 extensions (including the GMail extensions) and tweaking the APIs (along with bug fixing) thanks to feedback from some of the early adopters, I believe that it is finally complete enough to call 1.0.

In July, at the request of someone involved with a number of the IETF email-related specifications, I also implemented support for the new Internationalized Email standards, making MimeKit and MailKit the first - and only - .NET email libraries to support these standards.

If you want to do anything at all related to email in .NET, take a look at MimeKit and MailKit. I guarantee that you will not be disappointed.

Xamarin Evolve 2014 Re-Cap and Videos

We had an incredible time at Xamarin Evolve 2014, and we hope that you did too!  It was amazing to have 1,200 mobile developers all in one place to learn and celebrate mobile development.  And we hope that those of you who joined from 99 countries to watch the live stream found the sessions educational and inspiring.

Miguel de Icaza on stage during the Xamarin Evolve 2014 Keynote

If you missed the Keynote, or if you just want to re-live the excitement of the incredible announcements made there, the Evolve 2014 Keynote video is now available.

Watch Evolve 2014 Keynote

The Big Announcements

Our mission is to make it fast, easy and fun to deliver incredible mobile apps, and with these Xamarin Evolve 2014 announcements, we are bringing to you the world’s best solution to build, test and monitor your mobile apps:

  • Xamarin Insights: In the Keynote, we announced the release of Xamarin Insights, a real-time monitoring service that helps
  • Xamarin CEO Nat Friedman on stage during the Xamarin Evolve 2014 Keynoteyou improve your apps by tracking crashes and exceptions, and by providing insights into what is happening with your live users.

  • Xamarin Platform Previews: We announced 3 very exciting platform previews that we are making available immediately.
    • Xamarin Android Player: We tackled the single greatest pain point in Android development - the outdated, clunky, slow experience provided by the standard Android emulator. Our new Xamarin Android Player gives your apps the shortest startup time and best possible performance through hardware-virtualization and hardware-accelerated graphics.
    • Xamarin CTO Miguel de Icaza on stage at the Xamarin Evolve 2014 Keynote

    • Sketches: Sketches is a lightweight environment to explore the immediate effects of the code you write. Sketches are ideal to learn new APIs, prototype ideas, and quickly iterate on designs. When you are happy with your code in a Sketch, you can easily copy it into your app. You can also take snippets from your open solution and study them in this isolated live coding environment, making Sketches an incredibly powerful tool for debugging.
    • Profiler: The Xamarin Profiler helps you dissect, analyze, and polish your C# mobile applications. The profiler collects information about the managed side of your Xamarin iOS and Android applications and helps you to figure out where to spend the most time making improvements. You can use it to find memory leaks, resolve performance bottlenecks, and add polish to your applications before getting them out the door.

    Xamarin CEO Nat Friedman on stage at Xamarin Evolve 2014

  • Xamarin Test Cloud Updates: We announced some exciting new features for Xamarin Test Cloud:
    • Xamarin.UITest: Our new automated UI testing framework that harnesses the power of the C# language to create beautiful, readable, first-class test code with all the power of the .NET framework.
    • Improved Capture Tools: Screen recording in Xamarin Test Cloud enables developers to see video playback of an app running through its test cases, capturing the full testing flow, including animations.
    • Test Execution Enhancements: One of the most exciting announcements for Xamarin Test Cloud is hyper-parallel test execution. Currently, when you submit a test run to 10 unique devices, those tests happen at the same time across the devices, but the individual tests run one after the other. Hyper-parallel test execution takes this to the next level by splitting a test suite into chunks and executing the chunks in parallel on equivalent devices. We have seen this drop execution time from around 2.5 hours to just 12 minutes for our own tests.
  • IBM and Xamarin Partnership: Enterprise apps must have a consumer-grade front-end, an enterprise-grade back-end, and a comprehensive mobile software development lifecycle. In order to support the developers in our community building enterprise apps, we’ve partnered with IBM on two initial integrations, available now:
    • IBM MobileFirst SDK for Xamarin: pre-built software library that Xamarin and IBM developers can embed in their mobile apps to connect, secure and manage the apps using IBM Worklight, a part of the IBM MobileFirst portfolio.
    • IBM MobileFirst Add-Ons for Xamarin Studio and Visual Studio: Extensions that enable developers to configure and access the IBM Worklight server from a single environment.
  • Xamarin.Forms Components Ecosystem: Six major .NET component vendors have transformed over 140 existing charts, graphs, gauges, and grids into Xamarin.Forms-compatible, cross-platform mobile controls. Our component vendor partners have created beautiful UI controls that enable mobile developers to create native user experiences that meet the increasing demands of mobile enterprise apps, while saving countless hours developing these views for multiple platforms.

The rest of the conference session videos will be rolled out over the next few weeks, so stay tuned for more great Xamarin Evolve 2014 content!

October 15

The student and the Asset Store extension

Not every publisher sets out with a clear plan to make an Asset Store product. If you have a half-finished extension lying around, or some code or models you think others could benefit from using, consider doing what Copenhagen student Lasse Knudsen did: Polish and publish to the Asset Store.

Programmer Lasse first became familiar with Unity four years ago as part of his Mediaology studies at Aalborg University. “It was the standard game engine they used out there, and, of course, back then, there wasn’t an Asset Store.”

Later, after transferring to IT University of Copenhagen, Lasse wanted to write a pathfinding extension for his own use, and just to challenge himself generally. At the time, Navmesh was a Unity Pro feature, and Lasse wanted the functionality for a commercial project (meaning he couldn’t take advantage of Unity’s discounted educational licenses). So he set out to write his own pathfinding system, initially just as a coursework project.

“It worked pretty well, but I wasn’t really satisfied. So, after the course, I extended it to make it better, and I got it to a state where I was actually pretty happy with it. So I thought: ‘Hey, maybe other people will like it too.’”

And so the Simply A* pathfinding Asset Store tool was born. Lasse’s original plan was to make the extension available free of charge, but, by this time he’d invested a lot of time and effort in it. So, he decided to charge a small amount. A week after it was submitted to the Asset Store, Simply A* was on sale.

“I didn’t really expect people to buy it, but they started to very quickly. What with support requests and added functionalities I suddenly found myself pretty busy. Soon I was making so much money that I didn’t need to take a job to support my studies.”

Fast forward to the present, and Lasse’s working on two games: Gunjitsu which he and five student colleagues are aiming to publish as an early access Steam release in December, and some contract work for a retail client. Plus, he still has his studies to keep him busy.

“Now I’m busy with school and other game projects, so a month ago I made Simply A* available free of charge, with a reduced commitment to support it. The source code is there, so, obviously, people can fix things themselves if they want to.”

“It was a great way to improve my skills, do something I liked and make money. It helped me when it came to making editor extensions for my own use, and it helped me understand other assets on the Asset Store. That’s important because I use a lot of assets!”

October 14

.NET Foundation: Forums and Advisory Council

Today, I want to share some news from the .NET Foundation.

Forums: We are launching the official .NET Foundation forums to engage with the larger .NET community and to start the flow of ideas on the future of .NET, the community of users of .NET, and the community of contributors to the .NET ecosystem.

Please join us at forums.dotnetfoundation.org. We are using the powerful Discourse platform. Come join us!

Advisory Council: We want to make the .NET Foundation open and transparent. To achieve that goal, we decided to create an advisory council. But we need your help in shaping the advisory council: its role, its reach, its obligations and its influence on the foundation itself.

To bootstrap the discussion, we have a baseline proposal that was contributed by Shaun Walker. We want to invite the larger .NET community to a conversation about this proposal and help us shape the advisory council.

Check out the Call for Public Comments which has a link to the baseline proposal and come join the discussion at the .NET Forums.

First Unity game in WebGL: Owlchemy Labs’ conversion of Aaaaa! to asm.js

Starting today, Aaaaa! for the Awesome is the first commercially available Unity WebGL game! It’s been a long ride for Unity WebGL tools and Owlchemy Labs have been along for a fairly sizable chunk of it. You can get the fruits of their collaboration with Dejobaan Games along with other exciting new WebGL games in the Humble Mozilla Bundle.

“Working with super early versions of the Unity WebGL exporter was a surprisingly smooth experience overall!,” writes Alex Schwartz, the CEO of Owlchemy Labs, on the Mozilla blog.

“Jonas Echterhoff, Ralph Hauwert and the rest of the team over at Unity did such an incredible job getting the core engine running with asm.js and playing Unity content in the browser at incredible speeds, it’s pretty staggering. When you look at the scope of the problem and what technical magic was needed to go all the way from C# scripting down to the final 1-million-plus-line js file, it’s mind boggling”.

But getting the game to compile in this new build target wasn’t as easy as hitting the big WebGL export button and sitting back. While Unity did they care of a lot of the heavy lifting under the hood, there were some significant challenges that we worked together with Owlchemy to overcome.

The porting process began in June 2014  when Owlchemy gained access to the WIP WebGL exporter available to the alpha group. Was a complex game like Aaaaa! for the Awesome going to be portable within the limited time frame and using such an early framework?

“After two days of mucking about with the exporter, we knew it would be doable (and had content actually running in-browser!) but as with all tech endeavors like this, we were walking in blind as to the scope of the entire port that was ahead of us. Would we hit one or two bugs? Hundreds? Could it be completed in the short timespan we were given? Thankfully we made it out alive and dozens of bug reports and fixes later, we have a working game!”

Thanks to all those bug reports, developers using the current and future version of the tools will get all of these fixes built in from the start and can benefit from a better pipeline from Unity to WebGL.

Alex sees the web as a very good place for ambitious Unity projects. “You can expect Owlchemy Labs to bring more of their games to the web in the near future, so keep an eye out for those! ;) With our content running at almost the same speed as native desktop builds, we definitely have a revolution on our hands when it comes to portability of content, empowering game developers with another outlet for their creative content, which is always a good thing.”

More than two years have passed since the initial WebGL experiments at our HackWeek in Copenhagen. We’re extremely happy about the journey so far, the collaboration with our alpha and beta groups and our partners including Mozilla. We’re having loads of fun playing Aaaaa! for the Awesome and everybody’s looking forward to other upcoming Unity WebGL games. But we absolutely can’t wait to see what you all make with our Unity WebGL tools once Unity 5 is out!

October 13

Ada Lovelace Day 2014

Today is Ada Lovelace day, a special occasion to recognize women in our community. I want to take this opportunity to also highlight someone exceptional I have known for a while.

Her name is Andrea Magnorsky.

Andrea Magnorsky

Andrea is an Irish .NET programmer. She’s currently following one of her passion – game development – and is closing production with her studio Digital Furnace (ex-BatCat) on their next title Onikira.

To say that Andrea is a community person is an understatement. In the span of a few years she has not only created popular event/group like Global Gamecraft (game jam contest) or Dublin ALT.NET but she is also continously looking for new ways to teach people through numerous talks and meetups like Functional Kats.

She is curious of everything and always avid to learn. These days you can see her sailing along with F# and functional programming for instance.

It’s no surprise that she was recognized several times in Ireland as a top person in her field. Microsoft also recently awarded her an MVP award.

It’s thanks to people like Andrea that I’m happy to be part of the community that is software development.

Muncho

Muncho would have loved to conclude this but he had another emergency

The Players Journey

We all want to be heroes (or villains). To be the leading character in our own stories is an important aspect of playing the games we love, even if the story is abstract or apparently absent there is an inherent power in the sense of competence, esteem and autonomy we gain from play.

Most of the best games designers I know think this a lot although there are some inherent. For a start are we really playing the hero or in fact the side-kick. In Destiny we spend a lot of time waiting for our Ghost to do something obscure we don’t quite understand whilst we are fending off hordes of Vex or some such. Are we really the heroes?

More than that we usually lack some important knowledge that our hero should by rights already know. Then there is the trouble with choice; something The Stanley Parable explores brilliantly, what if we don’t want to do something the plot requires us to do? However. I’m not looking to restart the debate of Ludo-narrative dissonance. Instead I want us to consider something else.

Players are not the heroes of the game. Not just because of the issues I’ve mentioned already but because of something more obvious. They are real people. That means they have lives and they can’t spend every waking moment playing your game.

When we design a game, especially now in this Games-As-A-Service age, we can’t just invest in the story arch for the hero, or whatever abstract purpose our game has. We have to take into account the Player Journey too.

Campbell’s Heroes Journey is a well-trodden path and I’m going to help illustrate The Players Journey, of course it’s not the only Storytelling form, but it’s still quite a useful one. I’m also going to take a few very slight liberties with the specific stages, but all within the principles of the original.

  1. The Ordinary World – Players often already have games they are playing, and even if they are between games they are being bombarded on all sides with messages. Why should they play your game?
  2. The Call To Adventure – Discovery is not a passive act. You have to create the conditions for players to find and desire your within your design through art, narrative, social interactions as well as through the other media and of course partners including the platform holders.
  3. The Refusal of the Call – don’t assume downloading a game means it will be played. The reality of a game before we learn the controls is always poorer than our imagination. Get your players playing fast and feeling good about their competence fast. Additionally, we have to consider the physical devices and the moments in time they choose to play this game. Are they interruptible? How much time can they spare? What is their mode of use? This is particularly noticeable on mobile where Games with a shorter incidence of play seem to attract more frequent play, even if playing sessions end up longer.
  4. The Threshold – After the first play we need to think about why our players would want to come back and play again, and again. We want to create a sense of anticipation for their return to play. We can afford to be generous after all we want them to learn the value of continuing to play and if this is a free2play game to create a desire to spend money later.
  5. The Belly Of The Whale – There always comes a point where players fail, but this is a necessary step for us to be able to commit to playing, otherwise where is the challenge? How does your game make me want to get back up and play again? Longevity in games is linked to an innate sense of ‘unfinished business’ after play not just the rewards of success. There is some evidence that Whale players don’t start spending till after 8-12 days. That requires us to sustain their interest a long time.
  6. The Road Of Trials – Once we have passed the danger zone of the Learning Stage and they are still playing then we know they now properly engaged. It’s here that the repeatability of the core mechanic becomes essential; and has to remain fun. Why would we want to play again, and again? There has to be a sustainable delight!
  7. The Temptation – Engaged players don’t just keep playing without an expectation of reward for their effort. Games needs to have a sense of purpose and progression to retain the players’ interest but we need a trigger if we are to get a player to spend money on DLC or In-App items. Players (according to research by Park & Lee) don’t spend money because they are happy. They do so in anticipation of future value. We need to create reasons to want to spend money in the game. That even more the case if we have a F2P game which is hoping to attract Whales (big spenders). These spenders aren’t born, they only emerge from deep engagement with your game.
  8. The Epic Battle – Having a sense of purpose is all well and good, but without an attainable goal or ‘sense of impending doom’ to drive us forward we can easily lose momentum. The Boss Battle isn’t just about a bigger fight; it’s as much about creating a target to aim for which is within reach. If it seems too far away, or we can’t relate to the goals we quickly get bored. There is danger here however, if we create ways for the player to pay their way past the Epic Battle (indeed to pay to avoid playing any aspect of the game) we break the game. That’s what ‘Pay To Win’ means – a broken experience!
  9. The Ultimate Boon – The lure of short term goals and ultimate conflicts is all very good, but in the end we eventually seek something more meaningful. A long term payoff we can anticipate and predict, but where the conditions of that reward can’t quite be pinned down – leaving scope for anticipation and ideally with enough unfinished business that will keep our attention for a long time to come. In the end we need to be able to look back on our playing (and paying) experience and see the utility we gained from this investment.
  10. Rescue From Without – Social factors are essential for long term engagement. Just as the Hero often needs an external helping hand we, as social creatures, need some contact with other players to sustain our interest in the games over time. There is great power in shared experiences and the power to discuss our own magical moments. It’s the heart of storytelling. One of the keys to success in service-based based is the realisation that we need interaction with the Free-Players in order to create the conditions to keep the paying players playing (and paying). Social experiences aren’t binary, we can have shared moments with strangers as well as deep connections exemplified by guilds where the social interaction becomes more important than the game itself.
  11. The Return? – Whilst we can work hard to create ongoing experiences we have to acknowledge that in the end players will churn, they will return to their Ordinary World and perhaps even seek out other adventures. If we have done our work well they will have been changed by their experience and their expectations from other games will be permanently affected.
  12. Master of Two Worlds – Players who leave a game feeling that their investment in terms of money and time was worthwhile will continue to be positive influences for other potential players and may even be ripe to return for the sequel or an extension of the original game. This has to be treated as a new journey, but one with new dangers to face and new treasures to uncover.

These 12 Steps aren’t a fool-proof formula, but they hopefully will help you set your sights further than just the first playing session. We have to consider our players as real people with real lives who want what you have to offer them in terms of entertainment and perhaps, just perhaps this will help us create more sustainable experiences and dare I say… better games?

If you’d like to know more, Oscar will be discussing this topic at the IGDA Webinar on Wednesday 15th October – if you want to join that register at https://www2.gotomeeting.com/register/158293626

p.s. You don’t have to be an IGDA member to join in.

October 12

A Tale of Connected Dots

This past week, we organized Evolve 2014 in Atlanta to talk about all things mobile with Xamarin.

Being a mobile conference, we of course made our own app so that attendees could track out the sessions and the geography of the event.

We also launched something a bit different in the form of a treasure hunt app. Thanks to Estimote, we used a combination of iBeacon and QR codes spread throughout the conference intertwined with challenges along the way until you reach the end of the quest and a special prize.

The main interface of that quest app is a serie of connected dots:

Evolve Quest screenshot

As you progress through the game, the content scrolls naturally to reveal more odd-shaped arrangement of those dots.

Originally, this screen was just a big tall image containing everything. This is suboptimal on Android for a couple of reason like some graphic chip not supporting big “texture” or simply the need to rescale at runtime on most screen.

Ultimately it’s also not fun because there is really nothing you can do with a big image.

Hint: this is NOT what we shipped (on Android at least).

Rather, what attendees could see on their Android phone at the conference was this:

A much more satisfying, softly animated, connected system of dots. The current game position is also highlighted with a discrete pulse.

We will open-source the entire Quest application at some point but I wanted to share how we did that specific bit that is entirely exclusive to Android.

View Source Code

Since this is a really custom animation, it’s a bit different than the other type of animation samples I have already shown.

For this type of thing, I usually rely on a very simple animator that gives me a floating value between 0 and 1 so that I can do my own tweening in code. I also manage to pass this value by hijacking one of the standard view animatable property so that I don’t need to expose more information to the Java bridge:

1
2
3
4
5
6
7
8
9
10
11
12
13
// Interpolator instantiation
shiverAnimator = ObjectAnimator.OfFloat (this, "scaleX", 0, 1);
shiverAnimator.RepeatCount = ValueAnimator.Infinite;
shiverAnimator.AnimationRepeat += (sender, e) => shiverIndex++;

// Property hijack
public override float ScaleX {
	get { return currentShiverInterpolation; }
	set {
		currentShiverInterpolation = value;
		Invalidate ();
	}
}

In our case, I then use this value to compute for each drawing pass an offset that is added to the base position of every dots:

1
2
3
4
5
6
7
8
9
10
11
// Expressed in dp units
int[] shiverOffsets = new[] { 9, 3, -8, 4, -7, 6 };

// Extra applied offset code
int ApplyShivering (int dotIndex, int value)
{
	var off = shiverOffsets [(dotIndex + shiverIndex) % shiverOffsets.Length]
		* currentShiverInterpolation;
	value += (int)Math.Round (off);
	return value;
}

The wave that you see on the highlighted pin comes from a GradientDrawable that I create from a shape drawable XML definition as follow:

1
2
3
4
5
6
7
<?xml version="1.0" encoding="utf-8"?>
<shape xmlns:android="http://schemas.android.com/apk/res/android"
	android:shape="ring"
	android:useLevel="false"
	android:innerRadiusRatio="2">
	<solid android:color="#99ffffff" />
</shape>

The reason for using a drawable like this is to avoid redoing common drawing code and also taking advantage of the ring shape type automatic radius scaling (notice the innerRadiusRatio attribute) to create a nice spreading effect as the ring grows larger.

The ring size and color is dynamically computed from a slightly interpolated (quadratic or accelerated) value coming from our shared shiver interpolator:

1
2
3
4
5
6
7
8
9
10
11
var dur = shiverAnimator.Duration / 4;
var fraction = (float)(shiverAnimator.CurrentPlayTime % dur) / dur;
// Cheap interpolation
fraction *= fraction;

var rippleRad = (int)(radius * (5 * fraction + 1)) - 8;
ripple.SetBounds (x - rippleRad, y - rippleRad, x + rippleRad, y + rippleRad);

var color = Color.Argb ((int)Math.Round (0x99 * (1 - fraction)),
                        0xFF, 0xFF, 0xFF);
((GradientDrawable)ripple).SetColor (color.ToArgb ());

If you have been to my Mastering Time and Space session, you’ll likely also have detected the presence of a custom interpolator in there that is set on the shared shivering animator. The code is following:

1
2
3
4
5
6
7
8
class TriangleWave : Java.Lang.Object, ITimeInterpolator
{
	public float GetInterpolation (float input)
	{
		var t = input * 2;
		return (float)(2 * Math.Abs (t - Math.Floor (t + 0.5)) * (1 - 2 * Math.Floor (t)));
	}
}

This interpolator generates a triangle pattern that is repeatable (i.e. it both starts and ends at the same position for the dot) so that the animation can run continuously:

Triangle curve

Monologue

Monologue is a window into the world, work, and lives of the community members and developers that make up the Mono Project, which is a free cross-platform development environment used primarily on Linux.

If you would rather follow Monologue using a newsreader, we provide the following feed:

RSS 2.0 Feed

Monologue is powered by Mono and the Monologue software.

Bloggers