• Microsoft UK Faculty Connection

    Adding Ads to your games and apps a introduction from AdRotator

    • 1 Comments

     

    One of the most common questions I get is.. what is the best way to monetise my app?

    Well as a quick indication the following Image is how I generally advise people how to approach monetisation on the Windows Phone and Windows 8 Platform

    ad sucess on windows

    As the image above clearly indicates, one of the best ways of monetising your game or app is via Ads within your App or Game.

    To help you get started on Ads within Apps I had a chat with AdRotator developer and Unity Author, Simon (Darkside) Jackson and asked him to share his view on the opportunity of Ads in Apps and Games using AdRotator

    clip_image010

    So what is AdRotator?

    image image

    AdRotator is a premium advertising solution that is able to integrate with several Ad Providers for windows platforms, take the Ads for those providers and then rotate or flip through them in a controlled and configured way. It also provides a fall back capability where if any Ad Provider fails to deliver an ad, it will intelligently move on to the next, ensuring that the app or game is always displaying ads.

    What really makes AdRotator stand out is that it’s configuration can also be hosted externally to the app on a website or hosting area so that it can be updated without rebuilding or redistributing your application, you can change the ad configuration to match the best paying advertisers at any time and all apps will then be updated to use the new configuration on next use. (A by-product of this, is that you can also use this facility to deliver messages / notices to your apps and keep users informed)

    AdRotator primarily targets the major Windows platforms including Windows Phone (7 & 8) and Windows 8, however there are plans to incorporate web based solutions through WinJS and Mono support.

    With the release of the V2 solution for AdRotator we have now achieved parity with the aging V1 solution. This also brings several key improvements over V1 including:

    · Multiple Ad Unit support from the same Ad Supplier (previously you could only support a single AdUnit per provider)

    [Ad Units are individual ad configurations for Ad Providers which usually target ages, cultures, market segments, etc. These need to be monitored as different Ad Units have different payouts]

    · Reduced dependency on provider DLL’s (previously you had to have all Ad Providers controls in your solution, now you ned only those you use)

    · Improvements in the Ad Selection logic and probability (now 20x more random J)

    · Many internal improvements to improve performance and scalability

    There are many more features which can be discovered on the AdRotator site (http://getadrotator.com) or the GitHub Site (https://github.com/Adrotator/AdrotatorV2)

    Additionally, if you want to see the roadmap or request future features, then check out the VoteIt page for AdRotator - http://www.voteit.com/v/HiHC8jq1MV8wxEW

    Find the example app here

    What Ad Providers does AdRotator support?

    AdRotator has always supported a core set of Ad Providers but we are always willing to increase and add more providers with sufficient interest. We do our best to include as many as possible on all platforms (provided the Ad Providers support those platforms)

    Currently, AdRotator supports the following AdProviders:

    · Microsoft PubCenter

    · AdDuplex

    · Smaato

    · Google AdMob (Windows Phone 8 only)

    · MobFox (windows Phone 7 only)

    · Inneractive (formally Nokia Ad-Exchange)

    · Inmobi

    · House Ads

    (Platform support is only limited by Ad Provider SDK’s and their supported platforms)

    Have a provider you would like to see supported, then check the VoteIt page (http://www.voteit.com/v/HiHC8jq1MV8wxEW) and submit it as a suggestion.

    Configuring AdRotator

    Part of the power of AdRotator is the configuration file that controls its operation and what ads to display and when, this configuration gives you several levels of configuration:

    · Target specific Ad Providers

    · Target specific cultures / regions

    · Define a probability or order that Ad Providers are displayed

    · Deliver individual AdUnits or multiples per provider

    · Host your own ads both online and offline

    For example here’s a basic multi-cultural configuration file for AdRotator:

       1: <?xml version="1.0" encoding="utf-8"?>
       2:  
       3: <AdSettings xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema">
       4:  
       5:   <CultureDescriptors CultureName="en-us">
       6:  
       7:     <AdDuplex AppId="<ID>" Probability="10"/>
       8:  
       9:     <PubCenter AppId="<publisherID>" SecondaryId="<AdUnitID>" Probability="80"/>
      10:  
      11:     <Inmobi AppId="<ID>" Probability="10"/>
      12:  
      13:   </CultureDescriptors>
      14:  
      15:   <CultureDescriptors CultureName="fr-fr">
      16:  
      17:     <AdDuplex AppId="<ID>" Probability="10"/>
      18:  
      19:     <PubCenter AppId="<publisherID>" SecondaryId="<AdUnitID>" Probability="30"/>
      20:  
      21:     <Inmobi AppId="<ID>" Probability="60"/>
      22:  
      23:   </CultureDescriptors>
      24:  
      25:   <CultureDescriptors CultureName="">
      26:  
      27:     <AdDuplex AppId="<ID>" Probability="33"/>
      28:  
      29:     <PubCenter AppId="<publisherID>" SecondaryId="<AdUnitID>" Probability="33"/>
      30:  
      31:     <Inmobi AppId="<ID>" Probability="33"/>
      32:  
      33:   </CultureDescriptors>
      34:  
      35: </AdSettings>

    Breaking down this configuration we can see:

    Provider sections

       1: <AdDuplex AppId="<ID>" Probability="10"/>

    Each provider has its own configuration block which you can have within a culture block as many times as you wish. In here you configure the ID’s required for that provider to deliver ads (most have only one ID, some have multiple, like PubCentre). You can also then set a probability that AdRotator will pick that provider to display its ads, the higher the probability, the more likely it will try and display an ad from that provider. (setting a probability of 0 or no probability means that ad won’t be displayed)

    Culture Settings

       1: <CultureDescriptors CultureName="">

    These blocks allow you to target several cultures / regions within a single configuration file. This uses the devices native culture to determine which configuration to use for that region.

    AdProviders all have their own home regions (PubCentre - US, Smaato - central Europe) where they have a higher likelihood of delivering ads to your customers

    [Note, AdProviders won’t deliver ads if they do not have any suitable ads for your demographic, region or culture. Ad delivery is never guaranteed]

    By providing different sections you can selectively configure each provider differently, using either different priorities (probabilities) or even if you use that provider in that region. (Providers are optional, you don’t have to use all of your available providers for all cultures, only those that are likely to give you the most impressions and deliver the best pay-out rates

    [Ad Providers pay different rates by market or type of Ad. Impressions are when an ad is delivered by the provider and displayed in your app, which gives a minimal pay-out. Clicks are also monitored by providers which offer higher pay-out rates for user clicks]

    Additionally to specifying cultures, there is the default culture (as highlighted above) where no culture is provided. This is the fall back position if the region the users device is set to is not available in your configuration. However it is also just as valid to ship a configuration file with only the default culture. This simplifies your configuration but obviously won’t pay as well as customising it per culture.

    Once you’ve configured your file you need to host it in your solution or make it available to AdRotator

    Hosting configuration externally

    One of the biggest features of AdRotator is that you can put your configuration file on an external site (even use the same config for all your apps) and AdRotator will attempt to load it on each launch. If for some reason it can’t it will used a cached version of your configuration until it can update it again.

    [Even with hosted configuration, we also recommend deploying a default configuration file with your app, this ensures ads will start from day one even if it cannot contact your external web host for some reason]

    Nothing special is required for the file hosting, so long as it is available from the internet and isn’t blocked by firewalls and such.

    Several free solutions exist for hosting your file if you don’t have your own web server.

    · Azure Websites (https://azure.microsoft.com/en-us/) – Azure offer 10 websites free under their basic free plan. Sign up, setup a basic page, upload your configuration file and you are good to go.

    · AppHarbour (https://appharbor.com/) offer free hosting, it’s a bit more tricky to setup but you cannot argue with free.

    Adding AdRotator to your solution

    They have worked hard over the years to improve the installation of AdRotator and these day’s it’s easier than ever thanks to NuGet.

    [If you are not aware of NuGet (where have you been?), then NuGet is a dependency manager able to install and manage external references and dll’s for your solution. It has a vast library of opensource libraries you can access, just check out http://NuGet.Org for more details. Also install the NuGet extension in to Visual Studio or MonoDevelop]

    If you open your solution and then Right-Click on References in the Solution Explorer you should see the following dialog:

    clip_image006

    Clicking on the Manage NuGet Packages option will open the following NuGet package manager (I’ve highlighted some important bits):

    clip_image008

    Feel free to have a browse through the packages available if you wish. When you’re ready, enter AdRotator in to the search window in the top-right hand corner of the window, ensuring that Stable Only packages are selected in the drop down (NuGet also includes the ability to host dev / alpha / beta backages, to get in progress versions of dependencies). Once you search you should see AdRotator listed in the results. Looking on the right hand side you can see this is the Stable V2 release.

    [AdRotator also uses some other dependencies from NuGet itself (Microsoft.bcl references which are portable extensions for .NET), when you see a license prompt appear, simply accept it to continue the installation. The Microsoft.BCL libs use a standard OpenSource license that is free to use.]

    On clicking Install, NuGet will download the package and install it directly into your project, adding references and copying important files, including a sample “defaultAdSettings.xml” configuration file for you to modify or replace. Close the NuGet window and when you return to Visual Studio you will also see the implementation instructions for the AdRotator control, these instructions walk you through the rest of the journey to get up and running, here they are in short.

    1. Open the XAML page you want to display ad’s on

    2. Add the xmlns:adRotator="clr-namespace:AdRotator;assembly=AdRotator" XAML using/namespace reference to the top of the XAML page, in line with the other XAML using/namespace references (note there are different examples for Windows Phone and Windows 8 because the using/namespace references are subtly different

    3. Add the following XAML code to the page where you want it displayed, which is an example implementation for the AdRotator control:

       1: <adRotator:AdRotatorControl 
       2:                      x:Name="MyAdRotator"
       3:                      AdHeight="90"
       4:                      AdWidth="728"
       5:                      LocalSettingsLocation="defaultAdSettings.xml"
       6:                      RemoteSettingsLocation="http://<your site here>/defaultAdSettings.xml"
       7:                      AutoStartAds="True" />

    4. If you are hosting your configuration externally as well, replace the website reference in the RemoteSettingsLocation property, also you can rename your configuration file in your project if you wish, if you do so also update the LocalSettingsLocation property

    [If you wish you can also add the AdRotator control through the designer, we support whichever way you want to do it]

    5. Finally, return to the Solution Explorer and add references to all the AdProviders you wish to support. PubCenter is available direct from Visual Studio, AdDuplex and Inneractive are now available through NuGet. For other providers you’ll likely need to visit their websites and download their SDK’s

    [If an Ad Provider does not exist or is not referenced in your solution, then AdRotator will handle it by ignoring that Ad Providers configuration. Can’t use it if it doesn’t exist!]

    And you are done. Just run the project and provided the Ad Dll’s are in place and the configuration in your config XML is correct, you should start seeing Ads in your page.

    Special considerations for Ad Providers who use WinRT components

    Now life would be simple if all providers were just DLL’s like they used to be, however that is not the world of today, now we also have WinRT components.

    Because we cannot use standard techniques to discover WinRT components (COM is alive and breathing) we need to do a bit extra for AdRotator to be able to use them, just one line mind.

    At present two providers we support have upgraded to use WinRT components, these are:

    · Microsoft PubCenter (well, that makes sense)

    · AdDuplex

    When you use these providers, we need to pass the references for these WinRT components to AdRotator on startup, to do this we simple add an extra line to the Code behind (the .cs files) for the Pages you implement Adrotator on which looks like this:

       1: MyAdRotator.PlatformAdProviderComponents.Add(AdRotator.Model.AdType.PubCenter, typeof(Microsoft.Advertising.Mobile.UI.AdControl));

    The readme that comes with AdRotator gives you all the details and code for each provider that does this.

    [Just check the namespace for the AdControl itself as some providers use different namespaces for different platforms]

    Multi-page scenarios

    A lots of developers want AdRotator on multiple pages in their app or in several locations on a page. Now it’s fine to use several controls throughout your app but unless you are using different configurations then it is better to build a user control and then re-use that throughout your app. It is simply more efficient.

    To set up AdRotator in a user control, simply:

    1. Create a new User control in your project

    2. Set it’s width and height to your desired ad placement size (this will largely depend on the size of ads you have configured with your Ad Provider)

    3. Repeat the instructions above within the user control.

    4. Save and close it.

    5. Now just Add the user control to each page you wish to display ads on, e.g.

       1: Using: xmlns:local="clr-namespace:PhoneApp3"
       2: Control: <local:AdRotatorUserControl />
    This way is more efficient and also means you only need to update the User Control if you wish to change any of the 
    AdRotator properties.

    House Ad’s

    Another very useful feature of AdRotator is that you can setup your very own Ads, in fact we’ve talked to some implementation that only do their own ads.

    [In fact we know if at least one implementation where the developer uses AdRotator to sell ad space in their app, they just host the Ad remotely and rotate each ad in]

    Implementing a House ad is very easy, in effect it is just another User control in your project.

    1. Create your UserControl Ad

    2. Note the full namespace identity of the user control (in the example app it is PhoneApp3.MyHouseAd.MyHouseAd1)

    3. Add a DefaultHouseAd entry in to your configuration xml, for example:

       1: <DefaultHouseAd SecondaryId="PhoneApp3.MyHouseAd.MyHouseAd1" Probability="90"/>

    [The probability setting is completely optional, if you set a probability it will be included in the ad rotation, if you do not set a probability, then it will only be shown if no other ads could be fetched (fallback)]

    If you wish to also then place the HouseAd online, they you just need to host it online and then add the Url to the AppID property for the DefaultHouseAd, for example:

       1: <DefaultHouseAd AppId="http://adrotator.apphb.com/SampleRemoteHouseAd.xaml" SecondaryId=" PhoneApp3.MyHouseAd.MyHouseAd1"/>

    For an example online House Ad, check the one we include with our example projects here: http://adrotator.apphb.com/SampleRemoteHouseAd.xaml

    Unity support

    At the time this blog was posted, our Unity editor integration is currently broken, something changed in Unity of late and it no longer works. We are working on it with some help from our community and as soon as it’s working again we’ll update the main site.

    That’s NOT to say you cannot use AdRotator in Unity projects, it just means you need to follow the instructions above for adding AdRotator in to the exported Windows Phone or Windows 8 project manually (if you count 5 mins as manual)

    So AdRotator still works, it is just our editor integration and build process that isn’t working, meaning you cannot just configure it from Unity itself.

    The AdRotator team are working hard to remedy this with the time we have, so keep checking.

    Onwards

    This article has been a brief run through the setup of AdRotator. Ignoring the time it takes you to register on all the ad providers and work out the Ad configuration that works for you, you should be up and running in 5 mins.

    There are more features currently in the framework and many more planned for the more advanced edge cases for Ad Configuration and rotation, so feel free to check out the voting page for what people are asking for.

    If you have any suggestions / improvements or other AdProviders you want us to support, then please use the Voting page for AdRotator users here: http://www.voteit.com/v/HiHC8jq1MV8wxEW

    If you have any issues or want to get in touch with the AdRotator team, then log an issue on the GitHub site and either we or one of our growing community will be there to help you: https://github.com/Adrotator/AdrotatorV2/issues

    Finally, if you are so inclined and want to get involved with this amazing project, then put your hand up, race out and let the AdRotator team know. Simon and other are always willing to encourage developers to join in, fork our the repo and send/contribute some interesting code!

    Some Examples

    Find the example app here

  • Microsoft UK Faculty Connection

    Building a Game with a Cloud Backend

    • 3 Comments

    You need to think about what the cloud can do for you, whether it's something small like sharing save states or something larger like monitoring data and making quick iterations while your product is live. Then you can think about whether your use aligns with your players' perceptions, and whether you need to surface any information about your usage to show that your cloud offering is significant enough to give you an advantage.

    The cloud can give you more than technology

    If you decide to move to a cloud service, you may find that it offers your more benefits than you might think. An example can be seen in the indie development studio Gateway Interactive, who ditched their server stack in favour of moving to the cloud. While this resulted in faster transaction speeds and other improvements The savings they made from moving off a local server stack to a cloud-based model allowed them to hire an extra team member, increasing productivity and the quality of their upcoming games.

    A platform agnostic approach is a powerful approach

    One of the greatest benefits of game developers using the cloud is the fact that it's completely platform agnostic. If you were to create an app for the iOS platform using your own engine, you'd then have to make numerous changes and alterations to get it working on Windows and Android.

    Pick your Middleware

    This is why middleware solutions like Unity have thrived, as they allow for easy porting between different devices. However, these apps are never going to be connected without the use of the cloud. For example, do you want players to be able to move from one device to another and continue where they left off? Do you want players to be able to compete with each other, irrespective of what device they are using?

    Agility is essential

    Game development has come a long way in the past decade. Internet connectivity on devices has allowed for developers to create additional content and patch out previously undiscovered errors after the initial release, something that was once impossible.

    Embrace big data

    If you truly want to understand your users and how they play, then big data is the way to go. Not only will you be able to see information such as playing habits and playtime length, but you can also see details that'll help you with your next iteration, such as making improvements to a level if most people are getting stuck. Even if you're not planning to use the full capabilities of the cloud.

    Example of Cloud Services

    To give you some idea of how we are using cloud please watch the following video from Microsoft Studio Zoo Tycoon Friends. Zoo Tycoon Friends, a free-to-play title for Windows 8 PCs and tablets, plus Windows Phones. It was developed by Doritos Crash Course studio Behaviour Interactive and looks similar to the Xbox 360 and Xbox One versions of Zoo Tycoon that launched in November last year.

    Like the Xbox versions of Zoo Tycoon, gameplay revolves around interacting with the animals themselves, as well as building your park. Instead of Kinect controls, you'll now be clicking or tapping on your animals to care for their needs.

    See the game trailer below:

    http://www.youtube.com/embed/nBS39Up1ByQ

    Here is a nice technical overview of how the team has implemented Microsoft Azure Cloud Services

    http://www.youtube.com/embed/iNT0NpqeBos
  • Microsoft UK Faculty Connection

    Win2D

    • 3 Comments

     

    Welcome to the Win2D Github Open Source project.  

    Win2D is an open source project which as developed a Windows Runtime API to expose the power of hardware accelerated Direct2D graphics to Windows Universal App developers who are targeting Windows 8 and Windows Phone. 

    Win2D is available to both C# and C++ developers writing Windows 8.1 and Windows Phone 8.1 apps. 

    Getting Started

    Win2D is an easy-to-use Windows Runtime API for immediate mode 2D graphics rendering with GPU acceleration. It is available to C# and C++ developers writing Windows Store apps for Windows 8.1 and Windows Phone 8.1. It utilizes the power of Direct2D, and integrates seamlessly with XAML and ICoreWindow.

    Win2D is work in progress and evolving rapidly. The goal of releasing this code in an early, incomplete state is to solicit early developer feedback. The project backlog shows what we plan to add in the future, and the order in which we plan to add it.

    Source code and issue tracking are available at http://github.com/Microsoft/Win2D

    Getting Started

    To get started using Win2D:

    • Clone the source code from github
    • Run build.cmd to compile it
    • Point Visual Studio at the resulting NuGet packages
    • Add a CanvasControl to your XAML page
    See the readme for more detailed instructions.

    To find out more, check out the following links:

    blog post:            http://blogs.msdn.com/b/win2d

    code:                    https://github.com/Microsoft/Win2D

    clip_image001

    documentation: http://microsoft.github.io/Win2D/html/Introduction.htm

    Below is an example of what you can do using Win2D. And it is not a “bitmap”, but a vectorized image.

    clip_image002clip_image003

  • Microsoft UK Faculty Connection

    Visual Studio Online – Now allow you to share your projects with stakeholders

    • 0 Comments

     

    Last night I was attending the mentors and advisors sessions at the Launch of our latest Microsoft Ventures UK cohort.

    I was speaking with the new cohort and was NOT surprised to hear that they had or were facing issues which sharing of content with third parties..

    On of the key aspects of the accelerator is the availability of sharing materials with the teams mentors and advisors who is all purposes are a  third parties. We have made this possible for the team via Visual Studio Online.

    Visual Studio Online now provides an easy to services allowing the the teams to share content and enable unlimited numbers of stakeholders to easily work with their Visual Studio Online projects.

    So what is the Visual Studio Online Stakeholder License

    Within any development project their are number of stakeholders additionally these may not be core members of the project.  Whether it’s management who periodically wants to see the status of a project, business leads defining user stories for a project, or occasional contributors reporting bugs during development.

    With Visual Studio Online Stakeholders now have access to the project home page and most of the “work” related functionality. This includes the ability to view the backlog, add and edit items, run work item queries and more and more importantly any number of users in an account can be assigned a stakeholder license at no charge.

    The stakeholder license enables a much broader set of users within the organization to participate in your projects.  You can learn more about the stakeholder license here.

    Conclusion

    The stakeholder license is another key step to enabling everyone in the organization to participate in software development projects through access to Visual Studio Online services.  If you haven’t tried out Visual Studio Online yet, I encourage you to sign up and take a look today.

  • Microsoft UK Faculty Connection

    Getting Started with Unity3d/Construct2 – Using a Game Template

    • 0 Comments


    We all love gamejams or hackathons but sometimes not all the participants have any prior knowledge of middleware or where to start with a game.

    Over the past year we have done lots of work with unity3d and construct2 would like to share some game templates to help you get started building amazing gamejam games on Windows Phone and Windows 8.

    Windows Game Starter Kitsunity c2

    Windows Game Starter Kits

    Here a selection of Unity3D game templates:

    https://github.com/jasonrwalters/Unity-3DRunner Game reference here:  http://aka.ms/hypernaut

    C2_Trivia_Template Construct 2 Trivia Template

    TopDown2D_UnityKit Unity 2D Starter Kit. Top down adventure kit. Use the skeleton to destroy all the spiders invading your dungeon. Use this kit to add more levels, powers, characters etc.

    C2GameWorkbooks Workbooks and Slides for Construct 2 Windows Game Workshop
    MatchNBAEdition Construct 2 Game Starter kit
    JumbleArtEdition Construct 2 Starter Kit
    ISpySuperheroEdition Construct 2 Game Starter Kit

    SteamLandsUnity Unity Game Starter Kit for Windows 8 and Windows Phone

    SoundBoard Construct 2 Starter Kit

    EightFacts Construct 2 Starter Kit

    MatchGame Construct 2 Starter Kit
    FeedTheCritter Construct 2 Starter Kit
    Construct2Win8Templates Construct 2 Project Templates updated to support Widows 8 Features

    More resources

    http://github.com/wingamekits Full set of ImpactJS, JavaScript Unity and Construct2

  • Microsoft UK Faculty Connection

    Debugging Crashes of your apps and games on Windows Phone 8

    • 4 Comments

     

    One of the questions I get from game developers  is around debugging of a App/Game after they see reported crashes

    Here is a quick guide to how to debug the crash logs from the WP8 dev center

    Firstly you need to download and analysis the crash logs

    Login to https://dev.windowsphone.com
    Click Dashboard
    Click Reports
    Select Crash Count
    Click Export Strack Traces
    This will download a .cab

    If you then look up specific error numbers at https://dev.windowsphone.com/ and http://msdn.microsoft.com a specific link to Debugging on Windows Phone http://dev.windowsphone.com/en-US/OEM/docs/Debugging/Debugging_Windows_Phone

    To Analyse the log

    You need to save the .cab then right click and extract it.

    Then double click on the mini dump file and open into VS.

    They will see something similar to below.

    clip_image002

    This gives limited info because the debug symbols are missing.

    Getting symbols

    The symbols are located in two places. To install all available symbols, do the following two steps:

    1. Run the provided symbols installers from the WDK download on the Windows Connect site http://msdn.microsoft.com/en-us/library/windows/hardware/ff557573(v=vs.85).aspx.

    2. Run setup.exe from the Windows Phone download on the Connect site. Check the desired boxes for Debugger Symbols, and click the Next button.

      Add the paths of the symbols to the symbol path. For example, you can use .sympath inside the debugger to add folder locations. For more information, see Symbol path.

      For a large workgroup, consider creating a symbol server. For more information, see Symbol stores and symbol servers.

    You can then load them in using the links on the right.

    If you don't install the symbols “Debugging with native only “ gives the limited call stack:

    clip_image004

  • Microsoft UK Faculty Connection

    Getting Started with Marmalade and Building Windows Phone Games

    • 0 Comments

    Marmalade

    Marmalade is a popular C++ toolkit and gaming engine for 2D and 3D games that is used by a wide range of pro and indie developers to build games such as Lara Croft and the Guardian of Light, Godus, Vector, and Draw Something. In this hands on lab, you will learn how to create a basic game framework, add and use 3D resources, interact with objects and deploy the game to Windows Phone and Store devices.

    Instructions

    Download the source code

  • Microsoft UK Faculty Connection

    Building Cloud Based Games – A look into how they did it with Wordament

    • 0 Comments

    word1

    Wordament is a multiplayer, original word puzzle game and is available cross platform Xbox Live title with over 1,000,000 players which was developed by two indie developers.

    To help you understand the opportunity of cloud connected games we have developed a three part series on MSDN,

    The series goes into all the details on how the Wordament developers made this happen, using Azure as a backend, and Xamarin to take their native C# projects to other platforms.

    Part I. Anywhere, anytime, any device: Wordament’s cloud architecture
    Part II. Developing a cross platform app
    Part III. Running a business

  • Microsoft UK Faculty Connection

    Capturing and analysing your Graphics with Visual Studio 2013 Graphics Diagnostic tools now available in Visual Studio 2013 Update 3 and DXCap.exe

    • 0 Comments

    Command line tool for capturing and playing back frames

    As game developers were looking a providing the best experience across all our devices and many of you want to get results from devices which do not have Visual Studio installed.

    To enable this we are  now shipping a command line tool called DXcap which is a great tool for  capturing and playback which is included in the Windows SDK.

    If your a Visual Studio user Windows SDK comes with Visual Studio.

    You can use this tool to capture frames from desktop apps, store apps, and phone apps.

    Once you installed Visual Studio 2013 Update 3 RC (Download) or standalone Windows SDK (Download). You can find dxcap.exe in C:\Windows\System32 and C:\Windows\SysWOW64. Simply pass in -c and the name of the exe to capture and –p to playback the most recent captured log.

    A quick example:

    DXCap.exe is a command-line tool for graphics diagnostics capture and playback. It supports Direct3D 10 through Direct3D 11.2 across all feature levels.

    DXCap.exe [-file filename] [-frame frames | -period periods | -manual] -c app [args...]
    DXCap.exe -p [filename] [-debug | -warp | -hw] [-config] [-rawmode]
    DXCap.exe –p [filename] –screenshot [-frame frames]
    DXCap.exe –p [filename] –toXML [xml_filename]
    DXCap.exe –v [–file filename] [-examine events] [-haltonfail | -exitonfail] [-showprogress]
    DXCap.exe -e [search_string]
    DXCap.exe -info
    

    So to capture frame 100 from a desktop app: dxcap.exe –frame 100 -c "C:\TestProjects\MyApp.exe"

    To playback: dxcap.exe -p

    You can find details in DXCap's help information (Dxcap /?) or MSDN document Command-Line Capture Tool .

    Using Visual Studio 2013 – simply Configure capture options in TOOLS->Options->Graphics Diagnostics

    We are now exposing a number of options for capture which you can find by opening TOOLS->Options->Graphics Diagnostics page in Visual Studio 2013 Update 3.

    2500_070214_1657_GraphicsDia4
  • Microsoft UK Faculty Connection

    Checking the impact of Shader code without having re run your games – Visual Studio 2013 Update 3 enhancements PixelShader

    • 0 Comments

     

    Visual Studio 2013 Update 3 has made significant cnages to the shader editing experience.

    One of the great new features is that ability to Edit and Apply a new shader  as well as a side by side view of shader source code and compiler output.

    You can access the new features by simply clicking on the shader file name in the Pipeline Stages window or the Pixel History window.

    This will open the shader editor what is cool, is that the pixel shader shows both the source code and disassembly code generated by HLSL Shader Compiler.

    This allows you to directly make changes in the source code, and once the tool detects differences in output, the Apply button at the will be enabled.

    You simply need to click Apply to apply the changes to the current vsglog file and you can view how the changes impact the rendering result immediately, including..

    1. Render Target view
    2.  Pipeline Stages
    3. Pixel History windows

    Some additional great resources/features

    The source code which you edit will be keep it in a temporary location (the path is underneath the window) and changes are only applied to the vsglog file and does not affect your original source.

    Therefore you can use the vsglog file as a "playground" to try out different shader effects and view their impacts.

    If your not keen on the changes or they have a detrimental impact to performance the changes can be easily reverted back to when the frame was captured by clicking the Reset button.

    However if you like the changes and want to move the changes to the original source, you can use the Copy to… button which brings up a dialog where you can specify the location of the source file we should copy these changes to.

    Ability to make live changes during debug

    During shader debugging, you can make changes to the shader code, but the Apply button will only be enabled after debugging is stopped which is another nice feature.

    7752_070214_1657_GraphicsDia3

Page 1 of 93 (923 items) 12345»