Monologue

Today, Apple began using iBeacons in all of their retail stores across the United States. In this article, I’ll show you how C# developers can also take advantage of this exciting technology.

We’re going to take a look at iBeacons and Multipeer Connectivity, and show how they can be used in concert to create a unique in-store experience for customers with a coupon-serving iOS app.

For this app, when a customer enters the store, the iPhone version of the application will find an iBeacon in the store, and enable the customer to get a coupon for that store. In the store itself, an iPad will serve as the iBeacon, as well as handle sending the coupon information to the customer.

To advertise itself as an iBeacon, the app will:

1. Create a beacon region.
2. Get peripheral data from the beacon region.
3. Create a peripheral manager.
4. Use the peripheral manager to advertise the peripheral data.

Creating a beacon region is done by passing an NSUuid to a CLBeaconRegion instance:

// Create a beacon region
var storeUUID = new NSUuid (uuid);
var beaconRegion = new CLBeaconRegion (storeUUID, storeId) {
  NotifyEntryStateOnDisplay = true,
  NotifyOnEntry = true,
  NotifyOnExit = true
};

Then, we can use the CLBeaconRegion to get an NSMutableDictionary containing the peripheral data for a specified beacon power:

// Get peripheral data from the beacon region
NSMutableDictionary peripheralData = beaconRegion.GetPeripheralData (new NSNumber (-59));

With the CLBeaconRegion and peripheral data in place, we can create a CBPeripheralManager to advertise the beacon:

// Create a peripheral manager and start advertising
peripheralMgr = new CBPeripheralManager (peripheralDelegate, DispatchQueue.DefaultGlobalQueue);
peripheralMgr.StartAdvertising (peripheralData);

That’s all you need to do to advertise an iBeacon. Now let’s see how we can discover it from the iPhone app.

To discover when we enter the beacon region, we use the Core Location framework. In Xamarin.iOS we can take advantage of location manager delegate methods being wrapped in C# events. We need to handle the RegionEntered event for when the region is entered, in addition to the DidDetermineState event, for the case where the beacon is first discovered when already in the beacon region (such as the case where the iPad is turned on with the customer carrying the iPhone already being in the store). Note, we set NotifyEntryStateOnDisplay above to get this event in all cases.

locationMgr = new CLLocationManager ();
locationMgr.RegionEntered += (object sender, CLRegionEventArgs e) => {
  if (e.Region.Identifier == storeId) {
    WelcomeBackCustomer ();
  }
};
locationMgr.DidDetermineState += (object sender, CLRegionStateDeterminedEventArgs e) => {
  if(e.State == CLRegionState.Inside){
    if(!DealofDay.Enabled){
      WelcomeBackCustomer ();
    }
  }
};

The WelcomeBackCustomer method simply presents a notification and enables a button to allow the user to connect to the iPad to get a coupon.

In this case, we use the iPad to browse for peers (customers) using Multipeer Connectivity framework’s MCBrowserViewController, as shown below:

peer = new MCPeerID (storeId);
session = new MCSession (peer) {
  Delegate = sessionDel
};
browser = new MCBrowserViewController (serviceType, session) {
  Delegate = browserDel,
  ModalPresentationStyle = UIModalPresentationStyle.None
};

On the iPhone, the app uses an MCAdvertiserAssistant to advertise itself to peers:

peer = new MCPeerID (customer.ToString ());
session = new MCSession (peer) {
  Delegate = sessionDel
};
assistant = new MCAdvertiserAssistant (serviceType, dict, session);
assistant.Start ();

Then, in the MCSessionDelegate, we send a coupon when the customer has connected:

public override void DidChangeState (MCSession session, MCPeerID peerID, MCSessionState state)
{
  switch (state) {
  case MCSessionState.Connected:
    if (peerID.DisplayName != storeId) {
      vc.SendCoupon ("buy 1 widget, get a second for 1/2 price", peerID);
    }
    break;
  ...
  }
}

Finally SendCoupon uses the MCSession to send the coupon information in a string for simplicity.

void SendCoupon (string message, MCPeerID peer)
{
  NSError error;
  session.SendData (NSData.FromString (peer.DisplayName + ":" + message), new MCPeerID[]{peer}, MCSessionSendDataMode.Reliable, out error);
}

The coupon image is generated on the receiver using the CIQRCodeGenerator filter from Core Image:

var qrCode = new CIQRCodeGenerator {
  Message = NSData.FromString (text),
  CorrectionLevel = "Q"
}.OutputImage;

The code for this post is available in my github repo.

It has been a few busy weeks for both James Montemagno and myself, as we’ve been touring the East Coast of the USA with Richard Campbell and Carl Franklin on their latest .NET Rocks! Roadshow.

We kicked the tour off from our home turf in Boston, where Kris Lankford gave a wonderful presentation on Modern apps and the transformation of software development/the application lifecycle, and James told his story about the joy of devleoping iOS, Android, and Windows Store apps in Visual Studio. As luck would have it, I also got to sit down on stage with Richard and Carl to be interviewed about Visual Studio and Xamarin for The Table Show.

Before we headed out for the day we were able to sit down and talk with plenty of local developers from the Xamarin community including John Bubriski and R.T Carpenter. Then we were off for our next stop in Raleigh, NC.
When we arrived in beautiful Raleigh we were greeted by Aaron Bockover who was set to be interviewed for The Tablet Show on stage to talk about the Magic of Modern Apps later that day. Lines started to form as developers from all over came for our second stop on tour.

And we were ready to greet and chat and even do some live debugging sessions after the show! Before we knew, it the RV was pulling up and we were about to set off for the big drive down to Atlanta!

We hopped right in and hit the road to what was looking like a beautiful day in Atlanta, according to my Google Glass.

As we pulled into Atlanta we got to sit down and chat with Joel Semeniuk, CTO of Imaginet set to be interviewed later that day. Both Pierce Boggan and Andrew Ditmer were on there chatting and enjoying all of the Xamarin fun. Of course, the Xamarin monkeys were there hanging out as well!

Before we knew it, we were off to VS Live in beautiful, if not a little humid, Orlando. As developers poured in to chat with us about Xamarin, Nick Landry was also there presenting on iOS development in .NET along with Marcel de Vries and his talk on how to share 80% of code using Xamarin. James started the day of at VS Live giving a session on Hybrid Mobile apps in C# and Razor. Before the main event we sat down and chatted with a plethora of developers including Shayne Boyer, Joel Martinez, and Patrick Davis, just to name a few. James hit the center stage in front of 300+ developers to talk about Xamarin, Visual Studio 2013, and Windows Azure and response was outstanding!

Before ending the East Coast leg, James joined the .NET Rocks! guys on their trip back up to Philadelphia to attend and chat with developers at the Philly Code Camp. Brent Schooley was there and gave a wonderful on Cross Platform Development with Xamarin. While in the Hackathon room James got to sit down with Michael Heydt and Angel Rivera to talk all things Xamarin and mobile development.

And with that, the first leg of the VS 2013 Modern Apps Roadshow was complete, but we are now set to kick of the Central leg starting next week on December 9th. If you’re in the mid-west, be sure to join us:

• Chicago, IL – where I’ll be kicking off the Central leg and Stephen Forte will be interviewed.
• Columbus, OH – where I’ll also be speaking, and Billy Hollis MSDN Regional Director for Tennessee will be interviewed.
• St. Louis, MO – my last presentation, and Kathleen Dollard .NET Coach and Microsoft MVP will be interviewed.
• Dallas, TX – where James talks about Xamarin and Chris Love 5 time ASP.NET MVP will be interviewed. We are also throwing a Drink Up!
• Austin, TX – James will be speaking and Phil Japikse international speaker & Microsoft MVP will be interviewed.
• Houston, TX – James gives his final talk in the Central leg!

If you’re on the west coast, check out our January dates to see if we are stopping in your town. And, of course, there are Xamarin meetups happening everywhere in the month of December.

At a recent Google developer event, they unveiled a sneak peek for the long awaited Glass Developer Kit (GDK), which enables Android developers to build native applications using the Android SDK. For Xamarin.Android developers that have access to the Google Glass SDK, the new APIs (and a sample app) from this sneak peek are only a Xamarin Component Store visit away.

Up until this sneak peek, the only API available for Google Glass developers was the Mirror API – a set of web based applications that could send out messages to the device to display on a user’s timeline. This API is rather limited: It requires the Google Glass to be connected to the internet and does not allow for any deep integration with the device. With the release of the GDK, a plethora of new applications can now be written. Better yet, you can take advantage of all of this with C# and Xamarin.Android. The secret to this is that Google Glass is behind the scenes just running Android 4.0.4 (Ice Cream Sandwich).

Google have done a great job of putting together documentation for this sneak peek (although it’s not even a developer preview, so be prepared for things to change/move in the future). You can find their full developer guide on their website: https://developers.google.com/glass/develop/gdk/index

Note: You will need to be part of the Google Glass Explorer Program to run this application as a Google Glass application, you can use this form to sign up.

This featured guest article by Christian Thurau on game metrics, from essential to advanced, and their value in game development. Christian has a PhD in data mining and machine learning, and he is the CTO of GameAnalytics, one of the latest Unity official Asset Store Service Partners.

Facts about Christian:

Favorite games: Old-school shooters, mostly Quake 1, Team Fortress, and Bioshock

Favorite GA tool: Heatmaps

Favorite metric: Playtime

Analytics has become a much-discussed topic in game development in recent years, not only for F2P but across the entire industry. While it is still creativity, intuition, and experience that matter most in creating successful games, statistics on games and players have become an integral part of game development.

Unfortunately, analytics have become somewhat notorious as tools for monetization, used to influence player behavior to maximize revenue. What is less known is that metrics are just as useful in increasing fun and engagement. Hopefully, with this article, I can shed some light on the true nature of game analytics and break through the shadow of corporate greed that clouds its horizon.

It’s all About Engagement

The first and most important question with any analytics tool is what exactly you should track. While you would need to see into the future to know every metric you’ll ever need, there are some clear must-have measures that will provide a very solid starting point. Generally, these basic metrics can be placed in three broad categories: Acquisition, Monetization, and Engagement.

You may have already figured it out from the introduction, but of these three categories, I believe engagement is the most important, mainly for two reasons:

• Some engagement metrics sit at the base of player lifetime value calculations, a metric that is used exclusively to ensure user acquisition with a positive return on investment.

• Engagement relates closely to the game’s “funness.” It is a measure of the degree to which your game fulfils, so to speak, its destiny. There’s no reason to attempt to improve on other metrics if engagement is low.

Of course, the priority of these metrics might change according to individual game needs.

If you have never tackled analytics before, this might be a lot to take in. The good news is that the free GameAnalytics’s SDK for Unity automatically takes care of all the basic tracking needs I mentioned. All you have to do is interpret the results.

For example, we estimate engagement by generating both retention and session metrics.

• Day 1, day 3, day 7, day 14, day 28 retention: “Day X Retention” refers to the percentage of users who return to the game X days after installing it. This metric can be used to track how new builds or features of your game perform. The more often people return to the game, the more satisfied they are with the experience and the more likely they are to spend. On the other hand, low retention, depending on when it manifests itself, can indicate anything from a weak core loop to low production value or an endgame that offers insufficient content.

• Daily active users (DAU), monthly active users (MAU), and the DAU/MAU ratio: The number of people who use your game on a given day and in a given month can give you key insights into its popularity, as well as allowing you to plan for growth and server loads.

• Session length, average session length, and number of sessions per user: Sessions describe when and how long players engage with your game. Average session statistics can paint a clear picture of how your game fits in the player’s lifestyle—whether it’s played in short bursts on the bus or train, for example, or the player really likes to allocate a lot of time to get into the experience. Using session lengths, you can tweak the game experience to match the most popular (and natural) play styles. If you are using in-game advertisements, you can also look at sessions to estimate ad exposure and thus ad revenue.

Money (and Where It Comes From) Matters

Once you achieve solid engagement numbers, monetization and acquisition metrics come into play. GameAnalytics generates a number of fundamental metrics to allow you to estimate your income:

• Revenue: the amount of currency, converted to USD, collected on a daily basis. You should always display revenues segmented by acquisition campaigns to identify your best-performing acquisition channels. Also, it is recommended that revenue from in-game purchases be distinguished from advertising revenue through custom event hierarchies.

• Average revenue per daily active user (ARPDAU) and average revenue per paying user (ARPPU): how much users actually spend, both in absolute terms and compared to the total number of users. The bigger the ARPDAU, the better the chances your game will be self-sustaining.

• Conversion rate: the percentage of users who make an in-game purchase for the first time on a given day. You can use conversion rates to assess the effectiveness of different special offers, for example.

• Number of paying users and number of transactions: how many users and transactions occur in a given period. Flat numbers can sometimes be misleading; it’s helpful to look at the trend lines for the number of paying users versus the number of transactions in order to determine if you need to adjust the in-game product prices

Acquisition metrics have only recently been introduced into the GameAnalytics tool, so they are a bit on the basic side:

• Paid vs organic users: comparison of the number of users who came to the game in a natural manner (word of mouth, friend invite, or stumbling upon it in the Game Store) to the number of users acquired via an advertising campaign. This basic metric can point to what is known as the K-factor, or the number of additional users that each user introduces to the game. This is very difficult to calculate without tracking all in-game invites, but the paid vs. organic users metric can at least give you a rough estimate. The K-factor is essential to determine whether your user acquisition campaigns pay off.

• Number of installs by country, build, acquisition campaign, or other factor: the number of times your game is installed. The installs metric can show what iteration of your game is most popular and where the game performs best. The number of installs also gives you a rough overview of where your game is in its life cycle.

Remember, though, that you can segment all of the other predefined metrics by acquisition campaign parameters, as well. This ultimately allows you to make the best decisions when it comes to user acquisition.

Advancing to the Next Level

The more you get the feel for using analytics as part of game development, the more you’ll find the need to track data that is unique to your game. This is easily done with GameAnalytics, which is centered around the concept of abstract events. An event is simply anything that could happen inside of your game; this can be a rocket that gets fired, an item that is picked up, or a banner that gets clicked. No matter what is important to your game, you can track it using GameAnalytics events.

Note, however, that while the old mantra of “there’s no data like more data” is certainly true, selecting which custom events you should track is crucial. You should always design the desired metrics in advance; otherwise, you’ll risk wasting a lot of time to get your head around what is basically clutter.

As nothing beats solid statistics when it comes to optimizing in-game economies, you could start with tracking specific item purchases. Then, you can easily gather statistics on your best-selling virtual goods, find out what works and what doesn’t, and ultimately get rid of useless items and optimize item pricing.

For even more advanced uses, combine user progression events with the funnel tool to open up a new world of tracking possibilities:

• New user flow: Having a perfect first-time flow greatly improves the retention of your game. Data on where users drop out is essential for tweaking the learning curve.

• First purchase: Identifying what item is being purchased first by players can help you understand what motivates players to spend money. This ultimately allows you to maximize conversion rates.

• Missions and achievements completion: Since achievements and missions are optional in most games, their completion rate is a good indicator of what type of content is most popular among players.

• Level progression: The players’ progression through the game is a good indicator of how much of the original game content has been consumed, allowing you to time your content updates perfectly.

There are a ton of other useful analyses you can do with the free GameAnalytics tool, and we are continuously working on new, exciting features to help you build better games.

Our Gift to the Unity Community: 3D Heatmaps

Last but not least, I want to mention that there’s one GameAnalytics feature that is exclusively available inside Unity: 3D heatmaps. Heatmaps visually depict the frequency of events, directly over the game-level architecture. Let’s assume that you are already tracking players’ death events. With the 3D heatmap visualization, you can determine exactly where in the game players are dying. You may notice bottlenecks, such as narrow bridges where players tend to bump into each other or where they are simply more exposed. If you also track killer positions, you may also notice exploits, points where players camp out to ambush their enemies. Heatmaps are not only a great tool for fine tuning game balance; they also help in verifying that your game is played as intended.

I’ve barely scratched the surface of heatmaps with this short example, but you can read a lot more about them on the GameAnalytics blog. There are some nice visual examples there, as well. Maybe we’ll be able to delve into the details in a future article.

You can read our blog for many kinds of insights into data analysis in games, from in-depth introductions to the basics to real-world case studies. We invite leading industry experts and researchers to contribute to our blog on a regular basis.

Get the GameAnalytics SDK—it’s all free, with no data limits!

The GameAnalytics SDK for Unity is right here in the Asset Store: https://www.assetstore.unity3d.com/#/content/6755

Included in the latest releases of Xamarin Studio 4.2 and Xamarin.Android 4.10 in Visual Studio is an exciting new feature in the Android designer, multi-view editing.

Android layout management brings a unique approach to optimizing for different screen layouts and sizes by using different resource folder names. You will commonly see layout folder names such as:

Managing the various layout xml files inside each folder can be an extremely tedious chore. However, with multi-view editing in Xamarin.Android, this has all been simplified to make layout file management a breeze for developers. With multi-view editing you can easily create new layouts specifying a wide range of options, view all of your layouts at once, add new controls to all layouts at once, and even update properties on controls in one place and have the designer update all layout files.

Creating New Layouts

One issue I have always had when creating layout folders is trying to remember all of the available qualifiers and what order they need to go in when naming the folder. The Android designer now handles all of this for you. Simply click on “New version” when viewing a layout and the “Create Layout Variation” dialog will appear allowing you to fully customize the new layout to your specific needs. It even gives you a preview of what the layout will look like based on the qualifiers set.

Multi-view Editing

After setting up the layouts you want for a specific view, you can start editing multiple layouts at once by turning on “Multi-edit”. Once this is enabled you can turn on and off which views you want to edit by selecting the “edit” dot next to the layout preview:

When you add new controls to the designer, it will automatically add it to all of the selected layouts. You can even adjust individual properties of those controls, such as in the following screenshot showing a few TextViews with the text adjusted to 100dp:

Get started today and speed up your Android layout development and download latest version of Xamarin.Android, available in both Xamarin Studio and Visual Studio.

You have a website, right? Or a blog? When posting about the Asset Store, it’s good to show which one of all the amazing assets are you talking about. Keigo Ando from Unity’s office in Japan found out how to do this the easy way!

After embedding this code, all the necessary info like name, category, price and rating shows up, together with a picture and a link. When somebody’s done reading your post, they can hurry up and buy the asset. Needless to say, this is especially useful if you’re a publisher!

For example, if you paste this in (in the text view, if you’re using WordPress):

<script src=”http://assetstore-content.unity3d.co.jp/11228″ type=”application/javascript”></script>

and you’ll get this:

To embed other assets, simply find their Content ID at the end of the URL of their asset store page. 11228 is the Content ID of our 2D platformer:

This is the general script:

<script src=”http://assetstore-content.unity3d.co.jp/{CONTENT_ID}” type=”application/javascript”></script>

It’s just a little convenience feature, but it can save a lot of time.
This should work with most content management systems for websites. The only condition is that you should be able to embed a <script> tag.

You can choose between different preview sizes and even embed multiple items. For a complete list of possibilities, head over to Keigo’s demo page.

With our most recent release, Xamarin Studio 4.2 introduced several significant improvements to the development experience across the board, as well as some new features for developers targeting iOS.

iOS Improvements

When it comes to iOS and Xamarin Studio 4.2 there have been sweeping improvements in both development and account management. Brand new is the ability to log directly into your iOS Developer Account from inside Xamarin Studio. This allows Xamarin Studio to automatically synchronize your signing identities and provisioning profiles. All you have to do is log in to your iOS Developer Account from Xamarin Studio -> Preferences -> Developer Accounts:

Account Management:

Account Details:

Protocols in Xamarin.iOS 7
Historically, Xamarin.iOS has bound Objective-C protocols to abstract classes. This is advantageous in that it provides type safety and code completion, while allowing for the optional method feature of protocols. The typical pattern was to subclass the abstract class bound to the protocol and link this to your container class.

With Xamarin.iOS 7 however, we now can have our cake and eat it too. We get all the benefits of type safety and discoverability and no longer require users to subclass and link, now developers can merely implement a C# interface.   How is this possible?

Xamarin.iOS 7 still binds every protocol to a class containing both required and optional methods. However, the class now implements an interface with just the required methods. Therefore, to adopt a protocol, you simply implement the interface. Xamarin.iOS will take care of telling Objective-C that your class adopts the protocol.  To support optional methods, Xamarin Studio’s code completion has been enhanced, so whenever you type “override”, in addition to the required methods from the interface, you will be offered the optional methods that are not part of the interface.   This will insert the method with the proper signature and the corresponding Export attribute.

This simplifies adopting new APIs introduced with iOS 7. For example, UIKit Dynamics uses the UIDynamicItem protocol to allows objects to participate in the physics simulator (currently UIView and UICollectionViewLayoutAttributes). In Xamarin.iOS this protocol is exposed via the IUIDynamicItem interface. Since it’s an interface, Xamarin.iOS simply applies it to the UIView and UICollectionViewLayoutAttributes classes respectively, so that you can use it to create an array of dynamic items, which can be passed to various behaviors to capture physics attributes as follows:

var gravity = new UIGravityBehavior (aView);
var collision = new UICollisionBehavior (aView) {
  TranslatesReferenceBoundsIntoBoundary = true
};
var behavior = new UIDynamicItemBehavior (aView) {
  Elasticity = 0.5f
};

For more information on the new protocol support see the Objective-C binding documentation.

Asset Catalogs
Every iOS application includes several images for items such as various icons and launch screens. As new resolutions and devices have been created, the number of images an application needs to provide to accomodate every scenario has grown. To both make it easier to manage these images as well as to reduce application size, Apple created asset catalogs, which are generated into a size-optimized binary format during compilation. Working with asset catalogs in Xamarin Studio is easy. Simply right click on the *.xcassets directory, to bring up the context menu with the option to add your assets:

Xamarin Studio

With the announcement of full Portable Class Library support you will now find an improved PCL profile panel in the project settings of Xamarin Studio 4.2. In addition to this, there have also been several optimizations and fixes centered around PCL projects.

Account Management
With version 4.2 of Xamarin Studio we have overhauled the developer login experience. You no longer have to leave Xamarin Studio to log into your developer account. Simply enter your credential and you are on your way.

So much more!

Several more optimizations for version control with Git and Subversion, multi-edit Android Designer, debugging improvements, on-the-fly formatting, source analysis, and so much more have been added in Xamarin Studio 4.2. Be sure to read the full release notes for all the details.

Hello everybody! I’d like to tell you about Super BR Jam, an amazing and unique game jam in Brazil supported by Unity that was held November 22nd-24th. 

A huge group of experienced Brazilian game developers including companies such as Critical (Dungeonland), Behold Studios (Knights of Pen and Paper, Chroma Squad) and Swordtales (Toren) pulled the brakes on their internal projects and came together for the entire weekend to make brand new games.

And here’s where things start to get interesting: All games developed during the Super BR Jam will be made available for purchase at a “pay what you want” model. However if you pay above 5 USD you’ll also get:

- Dungeonland All-Access Pass

- Magicka

- Magicka: Wizard Wars

- The Showdown Effect

- Knights of Pen and Paper +1 Edition

- Project Tilt

- Out There Somewhere

- Qasir Al-Wasat: A night in between

The best part: all proceedings from the bundle sales will go to charity! The chosen charity was Solar Meninos de Luz, a private philanthropic organization which supports formal and complementary education and basic health care to 400 children in impoverished communities in Rio de Janeiro, Brazil.

This is what Mark Venturelli, former Game Designer at Critical Studios said about the event: “Wow. I was completely blown away by how amazing the people were. We wanted to show the world how strong our indie scene is here in Brazil, and how we are working together and helping each other. This is a very different game jam: we are selling the games and 100% of the profits will go to a school for poor children in Rio. I think this noble cause really gave everyone an extra incentive to come together and create things that are absolutely bursting with love and care. We still have a few days to go, so we are all still working together – this time to boost the publicity on the event and try to raise as much money as we can.”

Saulo Camarotti, CEO and Founder of Behold Studios said, “At first we thought this would be just another game jam, where we would get some friends together to make a game in very few hours. We decided to make a game that would force us to stretch our skills, to go beyond what we did before, and when we were done (after a lot of sweating) we realised that all that hard work that we put into proving ourselves was directly connected to the help that we would be providing to the children and volunteers at Solar. It was an incredible experience! We are definitely interested in participating again and helping other charities.”

After the event I was really glad to find out that 18 out of the 24 games were made with Unity and the results are very impressive!

You cand find out more about Super BR Jam and purchase the bundle at the website www.superbrjam.com.

So wait no further! The bundle will be available only until December 4.
It’s a great way to buy some cool games at a ridiculously low price and have a nice, warm feeling in your heart at the same time!

Link to site: http://www.universa.la/en/

 More about the games made during the game jam:

Alien Kingdom by Behold Studios (PC + Mac)
A massively cooperative online strategy game in a beautiful alien world. This game cannot be described in words, just go play it!

Previous games from this developer: Knights of Pen and Paper, Chroma Squad

Kureizy Japanese TV Show by Swordtales
Like a Nintendo game if everyone at Nintendo had a stroke at the same time

Previous games from this developer: Toren

Legend of HUErule by BitCake Studio (PC + Mac)
A simple online RPG with adorable low-poly visuals where your party must work together to defeat increasingly difficulty waves of bouncy monsters

Previous games from this developer: Project Tilt

Cinerea by Otus  (PC + Mac)
A lone woman wandering through alleyways is the theme of yet another mysterious and atmospheric game from Otus.

Previous games from this developer: Niveus

Dinomancer by Critical Studio

Previous games from this developer: Dungeonland

Thunderstruck by Pocket Trap
Defend your castle using the power of lightning! A challenging but rewarding game that looks absolutely adorable

Previous games from this developer: Ninjin, Hell Broker

Final da Zuera by Hoplon

As the crowd of a soccer game, choose wisely how you will cheer for your team

Previous games from this developer: Taikodom, Heavy Metal Machines

Gory Creatures from Across the Yard by Pigasus

You are a crafty pig defending your yard in this polished 3D tower defense game

Previous games from this developer: Adventurezator

Seal League Gravity Ball by Critical Studio

Space seals play football with no gravity. Do not worry, they all have magnetic suits to hover around. And lasers. Can be played with 2 or 4 players locally.

Previous games from this developer: Dungeonland

2013 is coming to a close, but there is still time to go to an awesome Xamarin user group meetup near you. User groups are not only a great way to learn about exciting advancements in mobile development, but are also an great venue to link up with other mobile developers in your community and share ideas. This month is full of great topics such as Intro to Xamarin Development, MVVM deep dive, iOS 7 multitasking, and many more, so you are sure to find something perfect for you.

Here is just a few upcoming Xamarin user group meetups for December:

Seattle Mobile .NET Developers Group

• Seattle, WA: Tuesday Dec. 3rd 6:00PM
• Cross Platform Mobile Development in C# – James Montemagno & Frank Krueger

Cape Town Xamarin Users Group

• Cape Town, South Africa: Thursday Dec. 5th 5:30PM
• Xamarin User Group Event: MVVMCross & iOS Bindings – Kevin Knoop & Chris van Wyk

Boston Mobile C# Developers’ Group

• Cambridge, MA: Thursday Dec. 5th 6:00PM
• Cross-Platform Mobile Development In C# – Dan Hermes

Atlanta Xamarin Users Group

• Atlanta, GA: Wednesday Dec. 11th 6:30PM
• Xamarin Development Life Cycle – Taking an app from IA to Implementation
• How to build Cross-Platform Apps with Visual Studio 2013 – Wally McClure

North Florida Xamarin User Group

• Fort Lauderdale, FL: Thursday Dec. 12th 1:00PM

• ROADTRIP to ITPalooza – Xamarin Mobile Developer sessions – Mir Majeed

NYC Mobile .NET Developers

• New York, NY: Monday Dec. 16th 6:45PM

• Making Fetch Happen: An Introduction to iOS 7 Multitasking - Nina Vyedin, Xamarin

Nashville Xamarin Mobile C# User Group

• Nashville, TN: Tuesday Dec. 17th 6:00PM
• “Mvx-ember”­­ Part 2: Share Your MvvmCross Experiences

The Munich Windows Phone App Creators

• Munich, Germany: Tuesday Dec. 17th 7:00PM
• How to target multiple platforms (iOS, Android, Windows Phone) – Steve Behrendt & Ralph Waldenmaier

We are excited to see rapid growth in the user group community, as you might have noticed some new locations this month. If you don’t see your city this month don’t worry as you can browse a full list of user groups at xamarin.meetup.com. New events and user groups are being added often so be sure to check throughout the month for updates.

If you are looking to start a user group in your city we are here to help. Check out the Speaking and Events Forums, where you can collaborate with other user group leaders to get tips and announce your first meetup. We encourage you to send us an email or tweet @XamarinHQ and we will do our best to spread the word and continue to grow user groups and Xamarin community.

As we make our way across the country on our road show with Microsoft and  .NET Rocks!, we’re making Dallas an extended stop so we can spend more time with our Dallas-based community.

Join us on Thursday, December 12th for an evening filled with all things mobile! Meet fellow mobile developers, show off your apps, and enjoy great beer and delicious food.

7pm – 10pm
Thursday, December 12th 2013

Champps Americana
855 West John W. Carpenter FRWY
Irving, TX 75039

We can’t wait to see you there!

RSVP

The following blog post was written by Jasin Bushnaief of Umbra Software to explain the updates to occlusion culling in Unity Pro 4.3.

Unity 4.3 includes a plethora of improvements. One of the completely re-implemented subsystems is occlusion culling. Not only has the interface been simplified and the culling runtime itself revamped, a number of new features have also been added.

In this series of three posts, I’m going to go over how the new occlusion culling system works in Unity 4.3. This first post goes through the basics of how occlusion culling is done and what the basic usage is like with the user interface. The second post focuses on best practices to get the most out of occlusion culling. The third and final post focuses on some common problem scenarios and how to resolve them.

But let’s start with some basics. Occlusion culling refers to eliminating all objects that are hidden behind other objects. This means that resources will not be wasted on hidden stuff, resulting in faster and better-looking games. In Unity, occlusion culling is performed by a middleware component called Umbra, developed by Umbra Software. The UI, from which Umbra is controlled in Unity, can be found in Window -> Occlusion Culling, under the Bake tab.

How Umbra Works

Umbra’s occlusion culling process can be roughly divided into two distinct stages. In the editor, Umbra processes the game scene so that visibility queries can be performed in the game runtime, in the player. So first, Umbra needs to take the game scene as its input and bake it into a lightweight data structure. During the bake, Umbra first voxelizes the scene, then groups the voxels into cells and combines these cells with portals. This data, in addition to a few other important bits is referred to as occlusion data in Unity.

In the runtime, Umbra then performs software portal rasterization into a depth buffer, against which object visibility can be tested. In practice, Unity gives Umbra a camera position, and Umbra gives back a list of visible objects. The visibility queries are always conservative, which means that false negatives are never returned. On the other hand, some objects may be deemed visible by Umbra even though in reality they appear not to be.
It’s important to realize that, while this system appears similar to what was shipped with previous Unity versions, the entire system has been basically rewritten. A lot has changed for the better, both internally and externally!

How to Use Umbra
There are obviously a few considerations in getting the best out of occlusion culling. Ideally, you’d want the least conservative result as fast as possible. There are, however, tradeoffs involved. The more accurate (i.e. the least conservative) results you want, the higher-resolution data you need to generate. However, higher-resolution data is slower to traverse in the runtime, yielding slower occlusion culling. If occlusion culling requires more frame time than it saves by culling, it obviously doesn’t make a whole lot of sense. On the other hand, very quick culling isn’t of much help if only a few objects are culled. So it’s a balancing act.

The way Umbra lets you control this balance is by having you define a couple of bake parameters. The parameters determine what type of input the bake process should expect and what type of data is generated. In the runtime, using Umbra is as simple as it gets. If you’ve baked occlusion data and the camera has occlusion culling enabled in the Inspector, Unity will use Umbra automatically.

Smallest Hole
The input is controlled using the smallest hole parameter. When voxelizing the occluder geometry, smallest hole maps almost directly to the voxel size. This means that if your geometry contains intentional holes, gaps or cracks that you wish to see through, using a smallest hole smaller than these is a good idea. On the other hand, a lot of the time the geometry contains lots of unintentional cracks that you do not wish to see through. A reasonable voxel resolution will patch these up. It may help to think about smallest hole as the “input resolution” of the bake.

Note that setting smallest hole into a ridiculously small value means that baking will be unacceptably slow and/or take up a monumental amount of memory in the editor. In some rare cases, it may even cause the bake to fail due to insufficient memory. Then again, while using a larger value will be faster and more memory-friendly, it may cause Umbra to not see through things like grates or fences. So bigger isn’t always better either. In general, a smallest hole as large as possible without visible errors is desirable. In practice, we’ve found that values between 5 cm to 50 cm work fairly well for most games where the scale is “human-like”. The default value in Unity is 25 cm, and it’s a good starting point.

Smallest Occluder
While smallest hole mostly deals with what type of input geometry you have, smallest occluder determines what kind of output data is produced. In essence, you can think about smallest occluder as the output resolution of the data. The larger the value, the faster it is to perform occlusion culling in the runtime, but at the cost of increased conservativity (false positives). The smaller the value, the more accurate results are generated, but at the cost of more CPU time. Obviously higher-resolution data will mean a larger occlusion data size as well.

So as the name implies, a small value means that very fine features are captured in the occlusion data. Under the hood, this directly maps to how large cells Umbra creates. Lots of small cells mean lots of small portals between them, and naturally it’s more expensive to rasterize a large amount of small portals than vice versa.
The effects of changing smallest occluder can be seen in the picture below. Note how the depth buffer, which is essentially what Umbra sees, loses detail as smallest occluder increases.

In most games, keeping smallest occluder slightly larger than the player, so around a few meters, is a good default. So anywhere between 2 and 6 meters may make sense if your game’s scale isn’t microscopic or galactic. The default value in Unity is 5 meters.

Backface threshold
Perhaps the most difficult parameter to grasp is called backface threshold. While in many cases you don’t really need to change it, there are some situations in which it may come in handy to understand how it affects the generated data.

First, it’s important to note that the parameter exists only for a single purpose: occlusion data size optimization. This means that if your occlusion data size is OK, you should probably just disregard backface threshold altogether. Second, the value is interpreted as a percentage, so a value of 90 means 90% and so on.

OK so what does backface threshold actually do then? Well, imagine a typical scene that consists mostly of solid objects. Furthermore, there may be a terrain mesh whose normal points upwards. Given such a scene, where do you want your camera to be? Well, certainly not underneath the terrain, that’s for sure. Also, you probably don’t want your camera to be inside solid objects either. (Your collision detection normally takes care of that.) These invalid locations are also ones from which you tend to “see” mostly back-facing triangles (although they may of course get backface-culled). So in many cases it’s safe to assume that any location in the scene, from which the camera sees a lot of back-facing triangles, is an “invalid” one, meaning that the in-game camera will never end up in those locations.

The backface threshold parameter helps you take advantage of this fact. By defining a limit of how much back-facing geometry can be seen from any valid camera location, Umbra is able to strip away all locations from the data that exceed this threshold. How this works in practice is that Umbra will simply do random-sampling in all cells (see the previous post) by shooting out rays, then see how many of those rays hit back-facing triangles. If the threshold is exceeded, the cell can be dropped from the data. It’s important to note that only occluders contribute to the backface test, and the facing of occludees doesn’t bear any relevance to it. A value of 100 disables the backface test altogether.

So, if you define the backface threshold as 70, for instance, to Umbra this means that all locations in the scene, from which over 70% of the visible occluder geometry doesn’t face the camera, can be stripped away from the occlusion data, because the camera will never end up there in reality. There’s naturally no need to be able to perform occlusion culling correctly from underneath the terrain, for instance, as the camera won’t be there anyway. In some cases, this may yield pretty significant savings in data size.

It’s important to stress that stripping away these locations from the occlusion data means that occlusion culling is undefined in these locations. “Undefined”, in this context, means that the results may be correct, incorrect (pretty much random) or return an error. In the case of an error, all objects are simply frustum culled.

Of course in some cases, there just happens to be some amount of back-facing geometry in valid camera locations too. There may be a one-sided mesh that has been, possibly erroneously, tagged as an occluder. If it’s a large one, it may cause the backface test trigger in nearby areas, resulting in culling artifacts (=errors). This is why the default value of backface threshold in Unity is 100, meaning the feature is disabled by default.

Feel free to experiment with the parameter. Try reducing the value to 90, which should drop a lot of data underneath terrains for example. See how it has any noticeable effect on the occlusion data size. You can go even lower if you want. Just remember to do so at your own risk. If you start popping into rendering artifacts, increase the value back to 100 and see if it fixes the problems.

To be continued…
In the next post, I’ll go into some best practices and recommendations for how to get optimal results out of occlusion culling. In the meantime, please visit www.umbrasoftware.com for more information about Umbra.

I’m happy to announce a new release of Plastic SCM 5.0, this time 5.0.44.509 with a bunch of new features.

You can download the new release from the download area as usual.

The new features are:

• Client changelists: a way to group changes in the pending changes view, making it easier to organize your workspace.
• Improved graphical annotate/blame: line age, new look & feel, added stats and more. It is also available inside Visual Studio.
• Improved cloaked rules: we’ve greatly improved the way in which cloaked rules are written so that it is easier to cloak directories, add exceptions and so on.
• Branch Explorer adds kinetic scrolling: now you can drag the diagram as in a tactile screen and it will continue moving with inertia.
• Leap Motion support in Branch Explorer: if you have one of the cool Leap Motion devices you can now use it to control the Branch Explorer. Cool for team meetings...
• While it was released back in release 504, it is worth noting that we now have Unity support!! http://plasticscm.com/unity-plugin.html
• Also, new look and feel for Visual Studio 2013 was out on 505 and of course available here.

Let me now describe each of the features in detail.

Client changelists

Now it is possible to group the changes on the pending changes view (the checkouts) on different groups called changelists. It is just a way to help you dealing with your own changes on your workspace (and it will sound familiar to the developers coming from Perforce).

As you can see in the following picture, there are some ‘built-in’ changelists and also some user-defined ones:

In the example you can see:

• The ‘default changelist’: grouping the changes that are not into any other group.
• A ‘nuget changes’ changelist: user defined. The user can move checkouts to any user-defined changelist from the ‘default’ or from other changelist.
• A ‘merge changelist’: each in-progress merge on your workspace will be displayed as a changelist, greatly simplifying the view.
• A ‘hidden changes’ changelist: ‘hidden changes’ are files that are were added to the ‘hidden changes list’ which means they won’t show up if they’re only modified but only if they’re also checkedout.

We expect this new feature to be useful to many users and especially for the ones migrating away from Perforce. While our implementation is not the same as P4’s if you’re used to clists you’ll probably feel at home here.

In order to enable the client changelists just go to pending changes, then to options and click on the following option:

Creating a new changelist is also rather simple as you will see below:

User defined changelists can be of two types: persistent, meaning they’ll stay even if they do not content any more, and non-persistent which means they’re automatically removed as soon as they get empty.

New annotate/blame GUI

After improving the annotate/blame internal mechanism a few releases ago, now it was the turn for the look and feel. We’ve done some clean up and also added some useful features.

As you can see in the picture below we’ve added new fields to the annotate view (now you can choose to select the author, changeset, branch, date and line age in days), also a way to color the lines by developer or date, and a new statistics panel showing the number of total lines, the average file age in days and finally displaying the number of changes done per developer.

We believe all this new information is going to make the annotate more useful when you’re reviewing a file and need to better understand its history.

We’ve also added the same info to the blame inside Visual Studio. In the screenshot below you can also check the look and feel of the ‘dark theme’ :-).

Improved cloaked/ignore/hidden rules

This is one of the key improvements on the new release. We’ve basically improved all the filter engine used by ignore.conf, cloaked.conf, hidden_changes.conf and writable.conf.

All the ‘old rules’ are still valid since we decided to keep it backwards compatible but we have introduced much powerful and simpler new rules.

Notes about the old syntax (still supported)

• */dir_name will cloak all directories named "dir_name", but not their contents.
• */dir_name/* will cloak the contents of all directories named "dir_name", but not the directories themselves.
• */filename.extension is the preferred syntax to cloak all files named "filename.extension". Just typing "filename.extension" will work as well.
• *.extension will cloak every file having ".extension" as its extension.
• Workspace-relative paths are allowed by prepending the text "$workspace/" before a dir name or file name.
• Inserted regular expressions will be automatically surrounded by characters '^' and '$' (start and end of line).

Main flaws

The main issues we had were:

• Cloaking a directory requires two different rules. It leads to really cumbersome cloaked.conf files for advanced scenarios (we found some in the gaming industry).
• Generic rules have to begin with a superfluous "*/" sequence.
• Having "$workspace" as a keyword feels cumbersome.
• A difference is being made between directories and files, overcomplicating the path resolution.
• Regular expressions don't support features that others version controls do.
  • For instance, typing "*lib" will be translated into "^.*lib$", which will match with directory C:\lib but not with its contents, C:\lib\foo.c . This leads to inconsistency.
  • Other VCS match '*' as 'any string of non path separator characters' and '**' as 'any string of characters', whereas we interpret '*' as 'any string of characters'. This prevent us from allowing fine expression tuning.

New syntax

• Remove the distinction between file names and directory names.
• Match each element by its name first, and then by the one of its parent or ancestors.
• Indicating a directory name will cloak all of its contained items.
• Workspace-relative paths will begin by "/", no need to specify $workspace. This could introduce a conflict if working on UNIX systems, where "/" is also the root element of the filesystem. This way, we've introduced the symbol "//" to represent the actual root of the filesystem.
• Suppress the restriction for regular expressions to be whole-line matches. It will mean that:
  • Users will have to explicitly indicate the start/end of line characters on their cloaked.conf files.
  • PlasticSCM will have support for basic scenarios where it isn't working at this time (see examples below).
• 'name' will match file names and directories. If a directory is matched, all its descendants will be matched, too.
• /'path' will match a path relative to the current workspace.
• It won't be required to write */ to start a rule nor /* to finish it. It will be treated as a regular expression if done, though.

Examples

A 'obj' rule will the following items:

- /obj
- /obj/code.o
- /obj/Debug
- /obj/Debug/code.o
- /project/obj/
- /project/obj/code.o
- /project/obj/Debug
- /project/obj/Debug/code.o

‘/obj' rule will cloak the following items:

- /obj
- /obj/code.o
- /obj/Debug
- /obj/Debug/code.o
But it won't cloak the following items:
- /project/obj/
- /project/obj/code.o
- /project/obj/Debug
- /project/obj/Debug/code.o

A '/lib/*.dll' rule will cloak the following items:

- /lib
- /lib/new.dll
But it won't cloak these:
- /lib/new.exe
- /lib/Debug [this is a directory]
- /lib/Debug/new.dll

A '/lib/**.dll' rule will cloak the following items (note it matches any subdirectory inside /lib):

- /lib/new.dll
- /lib/Debug/new.dll
- /lib/Debug/old/new.dll
But it won't cloak these:
- /lib/new.exe
- /lib/Debug/new.c
- /lib/Debug/old/new.h

Leap Motion support for the Branch Explorer

You’ve probably heard of LeapMotion, the cool device to interact with your computer using your hands.

And you've probably seen how Elon Musk himself explained how to shape the future of design. It was actually our inspiration to come up with the following video :-D

Let’s watch the intro video recorded by Manu Lucio @mrcatacroquer (Miguel acting as director :P):

In case you already have a Leap Motion or feel the urgent need to order one now to plug it to Plastic, what do you need to configure it?

• Make sure you install the Plastic SCM .NET 4 release (otherwise it won’t work). It is easy to find the .NET 4 release on our downloads page, it is clearly labeled.
• Install the Leap Motion software: https://www.leapmotion.com/setup
• Create an empty leapmotion.conf file in your plastic config path (tipically c:\users\xxx\appdata\local\plastic4\leapmotion.conf). This is what the Branch Explorer needs to start up the Leap Motion engine and look for a connected device.
• Plug your Leap Motion to the USB.
• The Branch Explorer will render a Leap Motion icon.

Then, in order to control the Branch Explorer, the following gestures are supported:

• Pan horizontally: place you hand over the Leap Motion controller with your fingers slightly apart from each other. Move hand left and right to move the diagram horizontally.
• Pan vertically: use the 'key tap' gesture (like pressing a button with your finger) to change the displacement mode from horizontal to vertical. Then, move your hand up and down to move the diagram vertically.
• Zooming: place both hands around the Leap Motion controller, like holding a ball. Then move both hands, towards or away from each other (like compressing or expanding the ball).

Set it up on a big screen and your team meetings won’t be the same :-P

Branch Explorer dragging improvements

While implementing Leap Motion support we’ve added the ability to drag the diagram and it will have inertia like we’re used to on tactile devices (smartphones and tablets).

As you can see, we’ve added quite a good number of features to this new release, hope you enjoy it!