If you were curious about checking out the intense beat ’em up action of Ape Out when it launched on Switch earlier this year but never got around to giving it a go, this could be the perfect opportunity.

The game has been treated to a temporary 30% discount on the Nintendo eShop, taking its price down from £13.49 to £9.44, and a free demo is also available so you can give it a try before you buy. We really enjoyed this one when we played it for review – here’s a snippet of what we had to say:

The Nintendo eShop would be a considerably more exciting and interesting place if it were packed full of games like Ape Out, it’s a refreshingly original experience that more than deserves a place in any Switch owner’s library. Difficult, frenetic gameplay, a strong art direction, and an even stronger jazz drum soundtrack make this the sort of memorable game that you’ll likely keep coming back to over and over for another few runs at the arcade mode.

Have you played the game? Would you recommend it to other Nintendo Life readers? Share your thoughts in the comments below.

Today’s post was written by Les Ottolenghi, executive vice president and chief information officer at Caesars Entertainment.

The gaming and entertainment industry is at a pivotal moment in its history, as traditional forms of entertainment face wholesale disruption in a hyper-connected world. I joined Caesars Entertainment in January 2016 to help navigate our way to becoming a purely digital business so that we can enhance the guest experience across our enterprise, which includes 55 destinations. Customers—habituated to mobile devices and omnichannel experiences—now expect their entertainment to be digital, real-time, and reliable. Caesars is using Microsoft cloud technologies, from the Office 365 suite of products to Azure and Dynamics 365, as a key part of its strategy to apply digital technology to the casino gaming industry.

Microsoft cloud technologies accelerate our business, from delivering new entertainment options to mobilizing and taking care of customers and our team members. Agility is a key benefit as we strive to stay ahead in a connected world that’s always evolving. With Office 365, we gained a modern workplace that improves efficiency in intelligent ways that map to our business strategies. For example, the dissemination of information and real-time connections among employees who are using Office 365 facilitates the teamwork that’s required to deliver exceptional customer experiences. Our IT team can also use Microsoft technologies to deploy these capabilities to the enterprise more seamlessly than ever. As part of our Microsoft cloud rollout, we deployed a text message bot that was built on the Microsoft Azure Bot Service framework to answer users’ questions about the rollout to aid in change management. Thanks to the pilot, the IT team not only gained experience in the design and development of the bots, but overall, the rollout was more successful across the enterprise.

Office 365 business productivity tools are exceptional, up to date, compliant, highly secure, and resilient so that IT can invest in exploring new technology opportunities. With built-in security services and other integrations, IT is free to focus on customer-facing initiatives—more than 60 percent of IT projects are now aimed at delivering value for customers and our team members, which is a huge increase from past years. And as we build digital technology into everything we do, we transform from a brick and mortar to a platform business that delivers what our customers want—before our competitors.

Recently, Caesars launched an interactive and immersive gaming and entertainment environment inside The LINQ Hotel + Experience on the Las Vegas Strip. At the RE:MATCH bar inside The LINQ screens around the bar offer interactive digital experiences, including games on the bar top and one-of-a-kind, immersive digital art installations. Across the casino floor at The Book, customers can fire up an Xbox and play casual games, and they can compete in e-sports events next door. All this translates into a unique experience for our guests that is available all day, every day. To facilitate coordination among the more than 200 people who worked on the project, we used Office 365 to connect the teams and share the information they needed to deliver the experience. It’s a great example of how we’re taking advantage of Microsoft technology to optimize our resources and focus on the customer engagement model.

We are also testing artificial intelligence (AI) capabilities in Azure to explore real-time, machine learning–based content creation and a deployment model to help us provide customers with what they need, when they need it, whether that be on a screen on a wall or in the palm of their hands. In the future, if a problem at a Los Angeles airport delays a guest’s arrival, we could proactively alleviate their anxiety by sending them an email to reassure them about their reservations or to confirm that we’ll hold their tickets for a big headliner show.

Caesars Entertainment is in the early stages of a global Windows 10 deployment. The continuous release cycles with Windows 10 will satisfy employees who have come to expect constant upgrades on their digital platforms. We’re also focused on making sure that we deliver the right technology into our team members’ hands. Surface Pro has been such a strong product that it has become the device of choice for our executives. And this is where employee satisfaction, which is so important to our culture, comes in. Our team members are more engaged and satisfied with work because they have modern, cloud-powered tools to create connections and improve their productivity. And in a networked world where individuals are vulnerable to cyberattacks and fake information, they know they can still get their work done safely. This is because we use Office 365 with services such as Azure Active Directory and other Microsoft security services, in concert with our security platform and controls, allowing us to geofence sign-in alerts, for example.

As Caesars progresses with its digital transformation, we’re poised to embrace new opportunities in the gaming and hospitality business. Ensuring that our team members are happy and productive with a modern workplace and Microsoft cloud technology is our best bet on getting there.

Sharing data between organizations can help address some of society’s biggest challenges.  There is no question that working with data in any fashion requires careful consideration of privacy and security risks, but there are clear benefits to be gained when done appropriately.

For example, a group of research institutions and medical clinics recently came together to create a central data repository of information about patients suffering from amyotrophic lateral sclerosis (ALS), a progressive neurodegenerative disease that affects nerve cells in the brain and the spinal cord, as part of a project called Answer ALS.  That dataset can now be used by the same organizations to improve their artificial intelligence research to advance treatments for ALS – more rapidly and with greater efficacy than they could have achieved on their own.

And yet, much of the potential that can be realized through data sharing in similar scenarios remains untapped – in part because the tools for collaboration are often immature or non-existent. Organizations that wish to share data often have to confront the reality of having to spend months or even years negotiating and drawing up contracts to govern data sharing arrangements, for example, which can be a time consuming, expensive and laborious process.

Many people and organizations are doing great work to tackle this problem.  There are many data use agreements and resources readily available through an Internet search. We’ve created a set of links to many of them here.

At the same time, we think there is an opportunity to do more.  We want to help make it easier for individuals and organizations that want to share data to do so.  Often, agreements for broad data sharing scenarios are unnecessarily long and complex. We also think there is an important role for agreements that limit rights to computational use for AI.  Further, we think the state of the art on data sharing for proprietary and private data sets is changing rapidly and the terms available publicly could be improved and better explained.

We’ve developed three data use agreements for community review and input. We have drawn from precursors, but are also advancing some new thinking drawn from our own experiences in working on data sharing projects.  Hopefully you will see some of this experience come through, particularly in the annotations.

Going forward, our aim is to work with interested stakeholders to improve these agreements and to offer additional ones that cover a wide range of data sharing scenarios.  Please take a look at the initial drafts and let us know what you think!

Data innovation is a complex topic, but we should work together to make the terms used more streamlined and defined. We hope these drafts are a step in this direction.

#opendata #AI #responsibleAI

.NET Core 3.0 Preview 4 is now available and it includes a bunch of new updates to ASP.NET Core.

Here’s the list of what’s new in this preview:

• Razor Components renamed back to server-side Blazor
• Client-side Blazor on WebAssembly now in official preview
• Resolve components based on @using
• _Imports.razor
• New component item template
• Reconnection to the same server
• Stateful reconnection after prerendering
• Render stateful interactive components from Razor pages and views
• Detect when the app is prerendering
• Configure the SignalR client for server-side Blazor apps
• Improved SignalR reconnect features
• Configure SignalR client for server-side Blazor apps
• Additional options for MVC service registration
• Endpoint routing updates
• New template for gRPC
• Design-time build for gRPC
• New Worker SDK

Please see the release notes for additional details and known issues.

Get started

To get started with ASP.NET Core in .NET Core 3.0 Preview 4 install the .NET Core 3.0 Preview 4 SDK

If you’re on Windows using Visual Studio, you also need to install the latest preview of Visual Studio 2019.

If you’re using Visual Studio Code, check out the improved Razor tooling and Blazor support in the C# extension.

Upgrade an existing project

To upgrade an existing an ASP.NET Core app to .NET Core 3.0 Preview 4, follow the migrations steps in the ASP.NET Core docs.

Please also see the full list of breaking changes in ASP.NET Core 3.0.

To upgrade an existing ASP.NET Core 3.0 Preview 3 project to Preview 4:

• Update Microsoft.AspNetCore.* package references to 3.0.0-preview4-19216-03
• In Razor Components apps (i.e. server-side Blazor apps) rename _ViewImports.cshtml to _Imports.razor for Razor imports that should apply to Razor components.
• In Razor Component apps, in your Index.cshtml file, change the tag that references components.server.js so that it references blazor.server.js instead.
• Remove any use of the _RazorComponentInclude property in your project file and rename and component files using the .cshtml file extension to use the .razor file extension instead.
• Remove package references to Microsoft.AspNetCore.Components.Server.
• Replace calls to AddRazorComponents in Startup.ConfigureServices with AddServerSideBlazor.
• Replace calls to MapComponentHub with MapBlazorHub.
• Remove any use of the Microsoft.AspNetCore.Components.Services namespace and replace with Microsoft.AspNetCore.Components as required.
• In Razor Component apps, replace the {*clientPath} route in the host Razor Page with “/” and add a call to MapFallbackToPage in UseEndpoints.
• Update any call to UseRouting in your Startup.Configure method to move the route mapping logic into a call to UseEndpoints at the point where you want the endpoints to be executed.

Before:

app.UseRouting(routes =>

{ routes.MapRazorPages();

}); app.UseCookiePolicy(); app.UseAuthorization();

After:

app.UseRouting(); app.UseCookiePolicy(); app.UseAuthorization(); app.UseEndpoints(routes =>

{ routes.MapRazorPages(); routes.MapFallbackToPage();

});

Razor Components renamed back to server-side Blazor

For a while, we’ve used the terminology Razor Components in some cases, and Blazor in other cases. This has proven to be confusing, so following a lot of community feedback, we’ve decided to drop the name ASP.NET Core Razor Components, and return to the name Server-side Blazor instead.

This emphasizes that Blazor is a single client app model with multiple hosting models:

• Server-side Blazor runs on the server via SignalR
• Client-side Blazor runs client-side on WebAssembly

… but either way, it’s the same programming model. The same Blazor components can be hosted in both environments.

In this preview of the .NET Core SDK we renamed the “Razor Components” template back to “Blazor (server-side)” and updated the related APIs accordingly. In Visual Studio the template will still show up as “Razor Components” when using Visual Studio 2019 16.1.0 Preview 1, but it will start showing up as “Blazor (server-side)” in a subsequent preview. We’ve also updated the template to use the new super cool flaming purple Blazor icon.

Client-side Blazor on WebAssembly now in official preview

We’re also thrilled to announce that client-side Blazor on WebAssembly is now in official preview! Blazor is no longer experimental and we are committing to ship it as a supported web UI framework including support for running client-side in the browser on WebAssembly.

• Server-side Blazor will ship as part of .NET Core 3.0. This was already announced last October.
• Client-side Blazor won’t ship as part of the initial .NET Core 3.0 release, but we are now announcing it is committed to ship as part of a future .NET Core release (and hence is no longer an “experiment”).

With each preview release of .NET Core 3.0, we will continue to ship preview releases of both server and client-side Blazor.

Resolve components based on @using

Components in referenced assemblies are now always in scope and can be specified using their full type name including the namespace. You no longer need to import components from component libraries using the @addTagHelper directive.

For example, you can add a Counter component to the Index page like this:

Use the @using directive to bring component namespaces into scope just like you would in C# code:

@using BlazorWebApp1.Pages 

_Imports.razor

Use _Imports.razor files to import Razor directives across multiple Razor component files (.razor) in a hierarchical fashion.

For example, the following _Imports.razor file applies a layout and adds using statements for all Razor components in a the same folder and in any sub folders:

@layout MainLayout
@using Microsoft.AspNetCore.Components.
@using BlazorApp1.Data

This is similar to how you can use _ViewImports.cshtml with Razor views and pages, but applied specifically to Razor component files.

New component item template

You can now add components to Blazor apps using the new Razor Component item template:

dotnet new razorcomponent -n MyComponent1

Reconnection to the same server

Server-side Blazor apps require an active SignalR connection to the server to function. In this preview, the app will now attempt to reconnect to the server. As long as the state for that client is still in memory, the client session will resume without losing any state.

When the client detects that the connection has been lost a default UI is displayed to the user while the client attempts to reconnect:

If reconnection failed the user is given the option to retry:

To customize this UI define an element with components-reconnect-modal as its ID. The client will update this element with one of the following CSS classes based on the state of the connection:

• components-reconnect-show: Show the UI to indicate the connection was lost and the client is attempting to reconnect.
• components-reconnect-hide: The client has an active connection – hide the UI.
• components-reconnect-failed: Reconnection failed. To attempt reconnection again call window.Blazor.reconnect().

Stateful reconnection after prerendering

Server-side Blazor apps are setup by default to prerender the UI on the server before client connection back to the server is established. This is setup in the _Host.cshtml Razor page:

 @(await Html.RenderComponentAsync()) 

</body>

In this preview the client will now reconnect back to the server to the same state that was used to prerender the app. If the app state is still in memory it doesn’t need to be rerendered once the SignalR connection is established.

Render stateful interactive components from Razor pages and views

You can now add stateful interactive components to a Razor page or View. When the page or view renders the component will be prerendered with it. The app will then reconnect to the component state once the client connection has been established as long as it is still in memory.

For example, the following Razor page renders a Counter component with an initial count that is specified using a form:

<h1>My Razor Page</h1>

<form> <input type="number" asp-for="InitialCount" /> <button type="submit">Set initial count</button>

</form> @(await Html.RenderComponentAsync<Counter>(new { InitialCount = InitialCount })) @functions { [BindProperty(SupportsGet=true)] public int InitialCount { get; set; }

}

Detect when the app is prerendering

While a Blazor app is prerendering, certain actions (like calling into JavaScript) are not possible because a connection with the browser has not yet been established. Components may need to render differently when being prerendered.

To delay JavaScript interop calls until after the connection with the browser has been established you can now use the OnAfterRenderAsync component lifecycle event. This event will only be called after the app has been fully rendered and the client connection established.

To conditionally render different content based on whether the app is currently being prerendered or not use IsConnected property on the IComponentContext service. This property will only return true if there is an active connection with the client.

Configure the SignalR client for server-side Blazor apps

Sometimes you need to configure the SignalR client used by server-side Blazor apps. For example, you might want to configure logging on the SignalR client to diagnose a connection issue.

To configure the SignalR client for server-side Blazor apps, add an autostart="false" attribute on the script tag for the blazor.server.js script, and then call Blazor.start passing in a config object that specifies the SignalR builder:

http://_framework/blazor.server.js

 Blazor.start({ configureSignalR: function (builder) { builder.configureLogging(2); // LogLevel.Information } });

Improved SignalR connection lifetime handling

Preview 4 will improve the developer experience for handling SignalR disconnection and reconnection. Automatic reconnects can be enabled by calling the withAutomaticReconnect method on HubConnectionBuilder:

const connection = new signalR.HubConnectionBuilder() .withUrl("/chatHub") .withAutomaticReconnect() .build();

Without any parameters, withAutomaticReconnect() will cause the configure the client to try to reconnect, waiting 0, 2, 10 and 30 seconds respectively before between each attempt.

In order to configure a non-default number of reconnect attempts before failure, or to change the reconnect timing, withAutomaticReconnect accepts an array of numbers representing the delay in milliseconds to wait before starting each reconnect attempt.

const connection = new signalR.HubConnectionBuilder() .withUrl("/chatHub") .withAutomaticReconnect([0, 0, 2000, 5000]) // defaults to [0, 2000, 10000, 30000] .build();

Improved disconnect & reconnect handling opportunities

Before starting any reconnect attempts, the HubConnection will transition to the Reconnecting state and fire its onreconnecting callback. This provides an opportunity to warn users that the connection has been lost, disable UI elements, and mitigate confusing user scenarios that might occur due to the disconnected state.

connection.onreconnecting((error) => { console.assert(connection.state === signalR.HubConnectionState.Reconnecting); document.getElementById("messageInput").disabled = true; const li = document.createElement("li"); li.textContent = `Connection lost due to error "${error}". Reconnecting.`; document.getElementById("messagesList").appendChild(li);

});

If the client successfully reconnects within its first four attempts, the HubConnection will transition back to the Connected state and fire onreconnected callbacks. This gives developers a good opportunity to inform users the connection has been reestablished.

connection.onreconnected((connectionId) => { console.assert(connection.state === signalR.HubConnectionState.Connected); document.getElementById("messageInput").disabled = false; const li = document.createElement("li"); li.textContent = `Connection reestablished. Connected with connectionId "${connectionId}".`; document.getElementById("messagesList").appendChild(li);

});

If the client doesn’t successfully reconnect within its first four attempts, the HubConnection will transition to the Disconnected state and fire its onclosed callbacks. This is a good opportunity to inform users the connection has been permanently lost and recommend refreshing the page.

connection.onclose((error) => { console.assert(connection.state === signalR.HubConnectionState.Disconnected); document.getElementById("messageInput").disabled = true; const li = document.createElement("li"); li.textContent = `Connection closed due to error "${error}". Try refreshing this page to restart the connection.`; document.getElementById("messagesList").appendChild(li);

})

Additional options for MVC service registration

We’re adding some new options for registering MVC’s various features inside ConfigureServices.

What’s changing

We’re adding three new top level extension methods related to MVC features on IServiceCollection. Along with this change we are updating our templates to use these new methods instead of AddMvc().

AddMvc() is not being removed and will continue to behave as it does today.

public void ConfigureServices(IServiceCollection services)

{ // Adds support for controllers and API-related features - but not views or pages. // // Used by the API template. services.AddControllers();

}

public void ConfigureServices(IServiceCollection services)

{ // Adds support for controllers, API-related features, and views - but not pages. // // Used by the Web Application (MVC) template. services.AddControllersWithViews();

}

public void ConfigureServices(IServiceCollection services)

{ // Adds support for Razor Pages and minimal controller support. // // Used by the Web Application template. services.AddRazorPages();

}

These new methods can also be combined. This example is equivalent to the current AddMvc().

public void ConfigureServices(IServiceCollection services)

{ services.AddControllers(); services.AddRazorPages();

}

These methods return an IMvcBuilder that can be chained to access any of the methods that are available today from the builder returned by AddMvc().

We recommend using whichever option feels best based on your needs.

Motivations

We wanted to provide some more options that represent how users use the product. In particular we’ve received strong feedback from users that want an API-focused flavor of MVC without the overhead for having the ability to serve views and pages. We tried to provide an experience for this in the past through the AddMvcCore() method, but that approach hasn’t been very successful. Users who tried using AddMvcCore() have been surprised by how much they need to know to use it successfully, and as a result we haven’t promoted its usage. We hope that AddControllers() will better satisfy this scenario.

In addition to the AddControllers() experience, we’re also attempting to create options that feel right for other scenarios. We’ve heard requests for this in the past, but not as strongly as the requests for an API-focused profile. Your feedback about whether AddMvc() could be improved upon, and how will be valuable.

What’s in AddControllers()

AddControllers() includes support for:

• Controllers
• Model Binding
• API Explorer (OpenAPI integration)
• Authorization [Authorize]
• CORS [EnableCors]
• Data Annotations validation [Required]
• Formatter Mappings (translate a file-extension to a content-type)

All of these features are included because they fit under the API-focused banner, and they are very much pay-for-play. None of these features proactively interact with the request pipeline, these are activated by attributes on your controller or model class. API Explorer is an slight exception, it is a piece of infrastructure used by OpenAPI libraries and will do nothing without Swashbuckle or NSwag.

Some notable features AddMvc() includes but AddControllers() does not:

• Antiforgery
• Temp Data
• Views
• Pages
• Tag Helpers
• Memory Cache

These features are view-related and aren’t necessary in an API-focused profile of MVC.

What’s in AddControllersWithViews()

AddControllersWithViews() includes support for:

• Controllers
• Model Binding
• API Explorer (OpenAPI integration)
• Authorization [Authorize]
• CORS [EnableCors]
• Data Annotations validation [Required]
• Formatter Mappings (translate a file-extension to a content-type)
• Antiforgery
• Temp Data
• Views
• Tag Helpers
• Memory Cache

We wanted to position AddControllersWithViews() as a superset of AddControllers() for simplicity in explaining it. This features set also happens to align with the ASP.NET Core 1.X release (before Razor Pages).

Some notable features AddMvc() includes but AddControllersWithViews() does not:
– Pages

What’s in AddRazorPages()

AddRazorPages() includes support for:

• Pages
• Controllers
• Model Binding
• Authorization [Authorize]
• Data Annotations validation [Required]
• Antiforgery
• Temp Data
• Views
• Tag Helpers
• Memory Cache

For now this profile includes basic support for controllers, but excludes many of the API-focused features listed below. We’re interested in your feedback about what should be included by default in AddRazorPages().

Some notable features AddMvc() includes but AddRazorPages() does not:

• API Explorer (OpenAPI integration)
• CORS [EnableCors]
• Formatter Mappings (translate a file-extension to a content-type)

Endpoint Routing updates

In ASP.NET Core 2.2 we introduced a new routing implementation called Endpoint Routing which replaces IRouter-based routing for ASP.NET Core MVC. In the upcoming 3.0 release Endpoint Routing will become central to the ASP.NET Core middleware programming model. Endpoint Routing is designed to support greater interoperability between frameworks that need routing (MVC, gRPC, SignalR, and more …) and middleware that want to understand the decisions made by routing (localization, authorization, CORS, and more …).

While it’s still possible to use the old UseMvc() or UseRouter() middleware in a 3.0 application, we recommend that every application migrate to Endpoint Routing if possible. We are taking steps to address compatibility bugs and fill in previously unsupported scenarios. We welcome your feedback about what features are missing or anything else that’s not great about routing in this preview release.

We’ll be uploading another post soon with a conceptual overview and cookbook for Endpoint Routing in 3.0.

Endpoint Routing overview

Endpoint Routing is made up of the pair of middleware created by app.UseRouting() and app.UseEndpoints(). app.UseRouting() marks the position in the middleware pipeline where a routing decision is made – where an endpoint is selected. app.UseEndpoints() marks the position in the middleware pipeline where the selected endpoint is executed. Middleware that run in between these can see the selected endpoint (if any) or can select a different endpoint.

If you’re familiar with routing from using MVC then most of what you have experienced so far will behave the same way. Endpoint Routing understands the same route template syntax and processes URLs in a very similar way to the in-the-box implementations of IRouter. Endpoint routing supports the [Route] and similar attributes inside MVC.

We expect most applications will only require changes to the Startup.cs file.

A typical Configure() method using Endpoint Routing has the following high-level structure:

public void Configure(IApplicationBuilder app, IWebHostEnvironment env)

{ // Middleware that run before routing. Usually the following appear here: if (env.IsDevelopment()) { app.UseDeveloperExceptionPage(); app.UseDatabaseErrorPage(); } else { app.UseExceptionHandler("/Error"); } app.UseStaticFiles() // Runs matching. An endpoint is selected and set on the HttpContext if a match is found. app.UseRouting(); // Middleware that run after routing occurs. Usually the following appear here: app.UseAuthentication() app.UseAuthorization() app.UseCors() // These middleware can take different actions based on the endpoint. // Executes the endpoint that was selected by routing. app.UseEndpoints(endpoints => { // Mapping of endpoints goes here: endpoints.MapControllers() endpoints.MapRazorPages() endpoints.MapHub<MyChatHub>() endpoints.MapGrpcService<MyCalculatorService>() }); // Middleware here will only run if nothing was matched.

}

MVC Controllers, Razor Pages, SignalR, gRPC, and more are added inside UseEndpoints() – they are now part of the same routing system.

New template for gRPC

The gRPC template has been simplified to a single project template. We no longer include a gRPC client as part of the template.
For instructions on how to create a gRPC client, refer to the docs.

.
├── appsettings.Development.json
├── appsettings.json
├── grpc.csproj
├── Program.cs
├── Properties
│   └── launchSettings.json
├── Protos
│   └── greet.proto
├── Services
│   └── GreeterService.cs
└── Startup.cs 3 directories, 8 files

Design-time build for gRPC

Design-time build support for gRPC code-generation makes it easier to rapidly iterate on your gRPC services. Changes to your *.proto files no longer require you to build your project to re-run code generation.

Worker SDK

In Preview 3 we introduced the new Worker Service template. In Preview 4 we’ve further decoupled that template from Web by introducing its own SDK. If you create a new Worker Service your csproj will now look like the following:

<Project Sdk="Microsoft.NET.Sdk.Worker"> <PropertyGroup> <TargetFramework>netcoreapp3.0</TargetFramework> <UserSecretsId>dotnet-WebApplication59-A2B1DB8D-0408-4583-80BA-1B32DAE36B97</UserSecretsId> </PropertyGroup> <ItemGroup> <PackageReference Include="Microsoft.Extensions.Hosting" Version="3.0.0-preview4.19216.2" /> </ItemGroup>

</Project>

We’ll have more to share on the new Worker SDK in a future post.

Give feedback

We hope you enjoy the new features in this preview release of ASP.NET Core! Please let us know what you think by filing issues on GitHub.

On paper, Graveyard Keeper sounds like a fun concept. It’s a management/simulation game of a medieval graveyard, with a sense of humor perfectly encapsulated in its wacky braying-donkey app icon. (I choose to believe this is intended to make fun of the endless screaming-angry-man icons found on Clash of Clans-clones.) Unfortunately, Graveyard Keeper will probably not win many new players to the genre thanks to its confusing tone and fixture on arcane busywork.

The first question for a mobile adaptation is: how are the controls? In menus, you get to tap and scroll through interface elements directly, but in the game world you use basic on-screen buttons and a static d-stick instead of swipe-anywhere controls. The d-stick is better than many, especially as it features an animated bounce back when released that visually reminds you to replace your thumb in the center.

It’s fiddly, though, and perhaps a little too sensitive, and I often found myself stuck on scenery or walking around objects I just wanted to approach. It seems to me a system where movement were locked to a grid might work better. There also seem to be a few too many buttons. The ‘work’ and ‘select’ actions could be combined into one control, since work is always held down for several seconds and select is always merely tapped. With a swipe for the rarely-used attack command, the devs could reduce the on-screen controls to a mere menu button.

Unlike similar management games like Stardew Valley, Graveyard Keeper doesn’t have daily tasks to give rhythm to march of time. Certain events, like meeting important characters that only happen on particular days, are about as far as it goes. Compounding this problem, the game uses a weird alchemical-symbol system to track its six-day week, making it impossible to hold in your mind when things need to get done. Is the bishop free on male-symbol day or on sun-day?

Instead, Graveyard Keeper‘s tasks are long multi-step processes that inevitably require a lot of time grinding for experience or materials and building one of seemingly dozens of crafting stations. I played for days and only buried one body, occupied as I was with making every part of every tool out of logs, rocks, and raw iron. Then there are tech trees for gardening, preaching, and writing books among others, three different kinds of skill points, and “faith” and “science” are resources in themselves. There’s a certain zen to it at times, but at other times it feels like a lot of busywork. That said, there’s a great deal of freedom and an awful lot to do, so if planning out long multi-stage tasks is your jam, you’ll love it.

Tonally, the game is strange. It wants to be both goofy and morbid and it works sometimes, especially when the game uses its medieval setting to satirize modern life. The funniest part to me was the unending bureaucracy of stamps and permissions required to get anything done in this supposedly-medieval town. A good joke, but also one that’s frustrating to deal with from a gameplay perspective. I can’t sell this bit of meat I took from a cadaver unless I bribe a thief for the right stamp? Are we just going to gloss over the cannibalism aspect of this situation first? Part of the problem is that NPCs don’t have strongly-defined personalities beyond one-note jokes. (The skull is a drunk. The donkey is a communist.)

There’s clearly a bit of Monty Python and the Holy Grail influence here, but the Pythons had the good sense to satirize the ignorance and bloodlust of a witch trial but then cut away before the actual execution. Not so in Graveyard Keeper, where your protagonist watches a burning without comment and is then tasked with putting up flyers for the next one. It’s darkness for its own sake, and rather off-putting.

Graveyard Keeper is a full-featured, PC-quality indie game, which is enough of a rarity on mobile to make it worth a glance. Fans of crafting will probably find a lot to like in Graveyard Keeper‘s incredibly baroque skills tree and endless tasks. It would be a good game for zoning out and listening to podcasts on a long plane trip. Players who are not on board the crafting bandwagon should probably try something like Stardew Valley.

Click Here!

If you would like to try out a new Square Enix RPG prior to its release, now is your perfect chance. The company has just released a demo for Oninaki on the Switch eShop in Japan, Australia and Europe, and it is expected to go live in North America very soon as well.

Here’s a bit more about what you can expect, courtesy of Gematsu:

The Oninaki demo includes a “Story Mode” that lets you experience the opening part of an epic tale about life, death and reincarnation, and “Battle Mode” where you can enjoy thrilling combat using an upgraded character possessed by four daemons that perform different job roles. You can also carry your progress from Story Mode over to the full game.

As noted, you’ll be able to transfer your progress across to the final game, which will require a total of 2.7GB of free space on your system. Lastly is a new trailer:

Will you be trying out this game ahead of its release next month? Leave a comment below.

After its May launch on Google Play and Android devices in May, the free-to-play title Pokémon Rumble Rush is now available to download from the Apple Store.

If you haven’t paid any attention to this game, now might be the time. It’s the fifth entry in the Rumble series and the first to enter the mobile fray. This particular title takes the mechanics of the series to new levels by providing another Pokémon “Game as a Service” experience. You’ll be sent out to various islands, where you must defeat bosses. Here’s a bit more about it, directly from our review:

Pokémon Rumble Rush is a charming game, and fun for those who like collecting things. However, the awkward map feature and the requirement of refining ore to get gears to boost the Pokémon mean it can be a needlessly frustrating grind, and the inclusion of a two-week deadline between area swaps, there’s the perhaps some unwelcome added pressure thrown into the mix as well. As we all perhaps expected, this free-to-play Pokémon outing doesn’t set the world on fire, but the truly dedicated fans who have followed the Rumble series this far will enjoy it all the same.

As the game has taken two months to make its way across to iOS devices, since then, there’s been additional in-game events rolled out, in the form of new islands.

Have you tried out this game yet? Are you a fan of the Pokémon Rumble series? Leave a comment below.