Game writer Susan O’Connor has a long history of collaborating with great game designers to tell incredible stories in video games.

Now she wants to help you tell better tales with her December 4th GDC Masterclass.

We’ve previously given you a look at what O’Connor will be teaching in her advanced seminar. But what if you could get a taste of her teaching style for herself?

For a better understanding of how O’Connor will be handling her lessons, we reached out to do a quick Q&A from the perspective of a hypothetical student. We wanted to know how she’d help out a game developer working in a particularly unusual genre that doesn’t see a lot of success in narrative: the world of free-to-play. It turned out she had a lot to offer.

Take a look:

Hey Susan, I’m a writer working at a free-to-play game company. We make a lot of games where you collect unique characters from randomized drops and use them to solve puzzles. For our next game, we’ve been given the green light to build out a LOT of original narrative. We’re in the early stages, and want to figure out how to do it right. We want to keep our audience interested and make sure we don’t overscope.
 
What are some of the practices we can do now with our design team so that we can start working on story and characters that can make it into the game?

Hi! Great question, thanks for asking. The best place to start (and end!) is with the player – deciding who your target audience is, and why they are going to like playing this game, and then figuring out how story/characters can make that gameplay experience even more fun. No game is for everybody. Knowing who is going to be drawn to YOUR game – and who isn’t – will make your life a whole lot easier.

So as weird as it sounds, you start figuring out your story & characters by not thinking about story & characters at all. You start by thinking about the game. In this case, we’d need more gameplay details. For example, is it a match 3, or a mobile RPG,  or an invest-express game like Homescapes? Those different genres deliver different types of fun. For example, in an invest-express kind of game, self-expression is really important.

So you know you want to create story & characters that allow the player to express themselves. Great! You’ve got your narrative guardrails/measuring stick, and you can go from there.

Thanks Susan! This is kind of an invest-express type game. We anticipate that players will want to align themselves with certain factions, so the collectible characters are a means to that end.

OK great! So then the next thing to think about is, “What kind of relationship will the player have with the characters?” Which seems weird, I know, because the characters aren’t real! But what I mean is, How do you want the player to FEEL about the characters? Do you want the player to think of them as little green army men? If so, then you wouldn’t want to give them too much personality – gets in the way of the gameplay experience.

Or maybe the player is just separate from the characters, just watching their dramas play out. In which case you could create intense conflict between characters that never actually leads to anything happening (soap operas are great at this). Or maybe players could be in charge of creating dramas, like little girls do when they play with Barbies. (I’m pretty psyched to put army men and Barbies in the same paragraph.)
 
One concern that our designers have brought up is players being frustrated by repetitive line firing—every time they tap on a character,  we want something interesting to happen. What else do you think players in the invest-express genre are looking for that can help us build out content for them?

Your designers are right! There’s nothing more annoying than hearing the same lines over and over again. To figure out a good solution, we can think about the player. (You can see a pattern here – it all comes back to the player.) I’d be curious to know WHY they are tapping on a character. Are they trying to accomplish a goal, or are they just doing it to see what happens? Players love feedback loops, it’s all about figuring out what they expect, and then meeting that expectation in a smart way.

Years ago, I heard an Uncharted talk about how the designers were stressed about what to do with Nathan Drake when he reached the Tibetan village. Up until that point in the game, when player hit X, Nathan would throw a punch or take a shot – and they didn’t want Nathan to punch monks!

So they changed the mechanic, just for this level. In the Tibetan village, when the player hit X, Nathan holds out his hand for a shake. The team was REALLY worried that players would hate this change. But they loved it! It still gave the player a satisfying feedback loop, and it kept Nathan in character.

So to get back to your question – players in an invest-express game want to be entertained. So you want to create interesting characters – people with personalities, and goals, and relationships with each other, and SECRETS – and then once you’ve got those interesting characters, you can combine that with “what player expects” and then create a narrative design that gives the player what they want, when they want it.

It may involve zero dialogue, if it turns out that’s not what the player wants to hear! If the goal is to “make something interesting happen,” that could mean a lot of things. Could be animations, could be a musical stinger, could be a thought bubble with images from the character’s last dream…This is a great thing to brainstorm with your designers!

That’s really helpful Susan! I can’t wait for your class next month.

If this seemed like the kind of insight you’d like for your next narrative game, make sure to sign up for Susan O’Connor’s Masterclass before it fills up!

For more information on the GDC Masterclass program, be sure to visit our website or subscribe to regular updates via Facebook, Twitter, or RSS.

Gamasutra and GDC are sibling organizations under parent company Informa Tech

In Godot 3.2 FBX support was improved by implementing the open source AssImp library. In the upcoming release of Godot 3.2.4 we are getting an all new FBX importer. While based on AssImp initially, this project took over a year to developed, removed over 50K lines of non-FBX related code and made improvements across the board.

Developer Gordon MacPherson recently wrote about the experience on the Godot blog and detailed the following changes:

• We rewrote all the mesh code to support all formats of FBX meshes correctly.
• We built an entire abstraction for the FBX transform information, which was a very complex and convoluted undertaking to get working properly.
• We designed a better handler for the animations which can compensate for the complex transform information, which means that we can handle animations correctly.

The project is ready for use but there are some plans in the pipeline:

• Finish porting the rewrite to Godot 4.0 (we use the 3.2 branch in production, so that’s where this was developed and quality controlled by many users).
• Locator bones. Right now, you need to bake your animation before exporting.
• Improve material mappings (most are supported, some need mapping).
• Fix bugs in the beta phase, we expect them.

Be sure to check out the blog post for details on the project, why they did it and why you should care. In the video below we put Godot 3.2.4 through the paces with a couple FBX tests, including this scene from Sketchfab. Unfortunately until Godot 3.2.4 is released, you will have to build Godot from source, just be sure to checkout the 3.2 branch from GitHub. Special thanks to IMVU for sponsoring the project.

Daniel

.NET 5 is now released! .NET 5 is the next version of .NET Core and the future of the .NET platform. With .NET 5 you have everything you need to build rich, interactive front end web UI and powerful backend services.

ASP.NET Core in .NET 5 is loaded with lots of great new features and improvements. Here’s a sampling:

For a full list of everything that’s new in ASP.NET Core in this release, check out the ASP.NET Core in .NET 5 release notes. See also the .NET 5 release notes for additional details and known issues.

Get started

To get started with ASP.NET Core in .NET 5, install the .NET 5 SDK. .NET 5 is also included with the latest updates to Visual Studio and Visual Studio for Mac, so if you’ve already updated your IDE, then you should be good to go.

Visual Studio 2019 16.8 or later is required to use .NET 5 from Visual Studio. .NET 5 is also supported with Visual Studio for Mac. To use .NET 5 with Visual Studio Code, install the latest version of the C# extension.

Upgrade an existing project

To upgrade an existing ASP.NET Core app from .NET Core 3.1 to .NET 5:

To upgrade an existing ASP.NET Core app from .NET 5 RC2 to .NET 5:

• Update all Microsoft.AspNetCore.*, Microsoft.Extensions.*, and System.* package references to 5.0.0.

That’s it! You should be all set to enjoy the benefits of .NET 5.

See also the full list of breaking changes in ASP.NET Core for .NET 5.

Performance improvements

With every .NET release a special effort is made to improve all aspects of the performance in ASP.NET Core applications. ASP.NET Core in .NET 5 is the fastest .NET web framework we’ve ever shipped!

.NET 5 contains great performance improvements in the runtime and libraries and for the gRPC components. These improvements, when applied to ASP.NET Core, result in some significant wins in throughput (RPS) and latency. The performance results below are taken from the TechEmpower benchmarks for ASP.NET Core with .NET Core 3.1 and from the latest results for ASP.NET Core with .NET 5.

Troughput (max, in RPS)

Latency (mean, in ms)

The “platform” tests represent highly optimized benchmark implementations, while the non-platform tests use more typical framework components.

The TechEmpower performance composite score, an index based on all of the TechEmpower benchmarks aggregated together, increased from 5,659 to 6,626 with .NET 5, which represents a 17% increase.

Deploy .NET 5 Web Apps to Azure App Service Today

The ASP.NET and Azure App Service teams have worked tirelessly together throughout the .NET 5 timeline to make sure ASP.NET developers have access to the latest bits of the .NET 5 runtime on day zero. This means that, as soon as you can download .NET 5 and get started building apps with it, you can deploy those .NET 5 apps to App Service using Visual Studio and Visual Studio Code, and you’ll have full support for deploying .NET 5 apps to App Service using GitHub Actions.

This day-zero availability of .NET 5 on App Service will be made possible by their new Early Access Runtime feature, which will enable not only .NET 5 apps, but every subsequent release of .NET from now on. This means no more waiting for the platform to support the runtime – it’ll “just be there” as soon as the runtime is available. You can learn more about the Azure App Service Early Access Runtime technology on the App Service team’s blog.

Whilst Early Access will give you a supported path to deploying your .NET 5 apps to Azure App Service immediately, there are some slight nuances to how Early Access works with which you can familiarize yourself on the App Service Early Access .NET page.

Join us for the .NET 5 release at .NET Conf 2020

Come celebrate with us and learn all about the .NET 5 release at .NET Conf 2020, a FREE, three day virtual developer event co-organized by the .NET community and Microsoft. This year marks the 10th anniversary of the conference, and it will be better than ever with over 80 live sessions from speakers in the community and from the Microsoft product teams. The conference starts today and goes from November 10-12. We hope you can join us!

Thank you!

Thank you to everyone in the community who helped make this release of .NET 5 possible! This release represents the culmination of many GitHub issues, pull requests, design feedback comments and documentation updates contributed by many members of the .NET community. We couldn’t have made it to this point without you!

We hope you enjoy this release of ASP.NET Core in .NET 5. We are eager to hear about your experiences with this latest release. Let us know what you think on GitHub by filing new issues and by commenting on or expressing your support (?) for existing ones.

Thanks again for trying out ASP.NET Core!

If you’re like me, you may find yourself running Windows for a variety of reasons from work to gaming. Sure you could run Fedora in a virtual machine or as a container, but those don’t blend into a common windows experience as easily as the Windows Subsystem for Linux (WSL). Using Fedora via WSL will let you blend the two environments together for a fantastic development environment.

Prerequisites

There are a few basics you’ll need in order to make this all work. You should be running Windows 10, and have WSL2 installed already. If not, check out the Microsoft documentation for instructions, and come back here when you’re finished. Microsoft recommends setting wsl2 as the distro default for simplicity. This guide assumes you’ve done that.

Next, you’re going to need some means of unpacking xz compressed files. You can do this with another WSL-based distribution, or use 7zip.

Download a Fedora 33 rootfs

Since Fedora doesn’t ship an actual rootfs archive, we’re going to abuse the one used to generate the container image for dockerhub. You will want to download the tar.xz file from the fedora-cloud GitHub repository. Once you have the tar.xz, uncompress it, but don’t unpack it. You want to end up with something like fedora-33-datestamp.tar. Once you have that, you’re ready to build the image.

Composing the WSL Fedora build

I prefer to use c:\distros, but you can choose nearly whatever location you want. Whatever you choose, make sure the top level path exists before you import the build. Now open a cmd or powershell prompt, because it’s time to import:

 
wsl.exe --import Fedora-33 c:\distros\Fedora-33 $HOME\Downloads\fedora-33.tar
 

You will see Fedora-33 show up in wsl’s list

 
PS C:\Users\jperrin> wsl.exe -l -v

  NAME                   STATE           VERSION

  Fedora-33                 Stopped         2
 

From here, you can start to play around with Fedora in wsl, but we have a few things we need to do to make it actually useful as a wsl distro.

 
wsl -d Fedora-33
 

This will launch Fedora’s wsl instance as the root user. From here, you’re going to install a few core packages and set a new default user. You’re also going to need to configure sudo, otherwise you won’t be able to easily elevate privileges if you need to install something else later.

 
dnf update

dnf install wget curl sudo ncurses dnf-plugins-core dnf-utils passwd findutils
 

wslutilites uses curl and wget for things like VS Code integration, so they’re useful to have around. Since you need to use a Copr repo for this, you want the added dnf functionality.

Add your user

Now it’s time to add your user, and set it as the default.

 
useradd -G wheel yourusername

passwd yourusername
 

Now that you’ve created your username and added a password, make sure they work. Exit the wsl instance, and launch it again, this time specifying the username. You’re also going to test sudo, and check your uid.

 
wsl -d Fedora-33 -u yourusername

$id -u

1000

$ sudo cat /etc/shadow
 

Assuming everything worked fine, you’re now ready to set the default user for your Fedora setup in Windows. To do this, exit the wsl instance and get back into Powershell. This Powershell one-liner configures your user properly:

 
Get-ItemProperty Registry::HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Lxss\*\ DistributionName | Where-Object -Property DistributionName -eq Fedora-33  | Set-ItemProperty -Name DefaultUid -Value 1000
 

Now you should be able to launch WSL again without specifying a user, and be yourself instead of root.

Customize!

From here, you’re done getting the basic Fedora 33 setup running in wsl, but it doesn’t have the Windows integration piece yet. If this is something you want, there’s a Copr repo to enable. If you choose to add this piece, you’ll be able to run Windows apps directly from inside your shell, as well as integrate your Linux environment easily with VS Code. Note that Copr is not officially supported by Fedora infrastructure. Use packages at your own risk

 
dnf copr enable trustywolf/wslu
 

Now you can go configure your terminal, setup a Python development environment, or however else you want to use Fedora 33. Enjoy!

Update: As shown in this tweet from Shinesparkers, the very same image has been used in the past to show off different games theoretically being played on a Switch, all shared by the same manufacturer behind the Metroid skin. This essentially proves that the image is photoshopped, rather than a photograph of any game running on the console.

Rather than a leak, then, this suggests that the whole situation is something of an oversight from Nintendo, which didn’t think to remove this third-party mock-up before hosting the images on its site.

Original Article: Nintendo’s official website may have accidentally leaked an upcoming Metroid title for the Nintendo Switch.

As spotted by YouTube user PapaGenos, an image displaying what appears to be a Metroid game being played on a Switch console has been uploaded to Nintendo’s site. It can be found on a product listing page for the ‘Super Metroid Skin & Screen Protector Set’.

The image appears to show Metroid: Samus Returns, a reimagining of Metroid II: Return Of Samus which launched on 3DS back in 2017. The scene on display (Samus Returns’ opening cutscene) appears to have been recreated to fit on the Switch’s larger, differently-proportioned screen, although it has been pointed out that this particular scene has been released in high resolution like this before.

Earlier this year, Nintendo accidentally leaked Kirby Fighters 2 on its website ahead of any official announcement. While you wouldn’t usually expect Nintendo to leak its own games, perhaps this is yet another oversight?

Of course, it’s worth noting that the image could well be an edit created purely to sell this screen protector product, and until Nintendo officially confirms the existence of any other Metroid games on Switch, we should all keep any hopes we might have in check. Still, it’s weird that the product’s manufacturer would choose to use a screen from a 3DS game, right?

At least we have Metroid Prime 4 on the way. At some point…

The most Pythonic way to convert a list of floats fs to a list of integers is to use the one-liner fs = [int(x) for x in fs]. It iterates over all elements in the list fs using list comprehension and converts each list element x to an integer value using the int(x) constructor.

This article shows you the simplest ways to convert a one-dimensional list consisting only of floats to a list of int.

Problem: Given a list of floats [1.0, 2.0, 3.0]. How to convert it to a list of ints [1, 2, 3]?

The methods are not applicable to lists of lists, they contain rounding errors that are different in each method. If necessary, you can add cycles or define custom functions to check, account for and minimize errors.

Method 1: List Comprehension

Suppose we have a list:

a = [1.1, 1.2, 1.8, 0.5, 5.9, -2.3]

Now, check the type of the list numbers:

print(type(a[0]))

# <class 'float'>

Let’s apply the built-in function int, and get a list of integers:

print([int(a) for a in a])

# [1, 1, 1, 0, 5, -2]

Check the type of numbers in the new list:

A = [int(a) for a in a]

print(type(A[0]))

# <class ‘int’>

Thus, using the built-in function int, which converts a real number rounds towards zero, or rather, it discards the fractional part, we can get a new list of integers with a one-line code.

Method 2: Map Function

The built-in function map is well optimized and efficient, when it is called, the elements of the list are retrieved upon access. Therefore, one element is stored and processed in memory, which allows the program not to store the entire list of elements in the system memory.

Apply to the same list a the following code:

print(list(map(int, a)))

# [1, 1, 1, 0, 5, -2]

It makes no sense to check the type of the elements of the resulting list, since when we called the map function, we passed the int function already described in method 1 as an argument, and wrapped the result in a list using the list function.

The quality of this transformation of the list, or rather the rounding error, is the same as in the first method.

Method 3: Round & List Comprehension

It is very similar to the first, but unlike int, it doesn’t just discard the fractional part but rounds to the nearest even integer if the fractional part is 0.5. You can also pass as the second argument the number of decimal places to which rounding is required, by default it is 0, this is what we will use:

print([round(a) for a in a])

Check the type of numbers in the new list:

D = [round(a) for a in a]

print(type(D[0]))

# <class ‘int’>

As you can see from this example, there are different built-in functions to achieve our goal, the difference is in the method and the magnitude of the rounding error.

Method 4: Math Module

In this way, I suggest using the imported module math, in which we will use the three functions ceil(), floor(), and trunc(). let’s take a closer look at each. They have the same syntax, the difference is in the way of rounding.

Let’s apply to the original list:

a = [1.1, 1.2, 1.8, 0.5, 5.9, -2.3]

print([math.ceil(a) for a in a])

# [2, 2, 2, 1, 6, -2]

‘Ceil’ rounds to the next largest integer, respecting the sign(-2.3 < -2 which is True).

Check the type of numbers in the new list:

C = [math.ceil(a) for a in a]

print(type(C[0]))

# <class ‘int’>

Consider the following function in the ‘math’ – ‘floor’ module, which is the opposite of ‘ceil’ – rounding down to the nearest integer:

print([math.floor(a) for a in a])

# [1, 1, 1, 0, 5, -3]

Check the type:

F = [math.floor(a) for a in a]

print(type(F[0]))

# <class ‘int’>

The next function, trunc(), is analogous to the built-in function int() — it simply discards the fractional part whatever it is:

print([math.trunc(a) for a in a])

# [1, 1, 1, 0, 5, -2]

And check the type:

T = [math.trunc(a) for a in a]

print(type(T[0]))

# <class ‘int’>

Method 5: NumPy

Here’s a look at converting a list from an int to an array using the NumPy module. The difference between an array and a list is that all elements of an array must be of the same type, like “float” and “int”. Numeric operations with large amounts of data can be performed with arrays much faster and more efficiently than with lists.

Let’s turn our first list a into an array:

import numpy as np

N = np.array(a, int)

We pass two arguments to the array function, the name of the list to convert to an array and the type for each element.

# [ 1 1 1 0 5 -2]

Сheck the type of elements:

print(type(N[0]))

# <class 'numpy.int32'>

Unlike the int number type in Python, the NumPy module defines them slightly differently and is divided into several subgroups. For example, 'int32' are integers ranging from -2147483648 to 2147483647 (4-byte numbers), 'int64' are numbers from -9223372036854775808 to 9223372036854775807 (8-byte numbers), there are also different types of 'int' for 32- and 64-bit operating systems, this must be taken into account when calculating with arrays.

The post How to Convert a Float List to an Integer List in Python first appeared on Finxter.