Monster Hunter publisher Capcom reported Friday a year on year decline in annual sales, but a jump in profits for its full fiscal year.

The company said the past year is the seventh consecutive year of operating income growth and the fourth year in a row of record-high profits.

Sales for the fiscal year ended March 31 were 82 billion yen ($770 million), down 18 percent compared to the previous year, while operating income was up 26 percent to 23 billion yen.

The company attributed the profit increase to high-margin digital sales. Games including Monster Hunter World: Iceborne, and catalog sales of Resident Evil 2 and Devil May Cry 5 helped drive sales during the year. Capcom’s new pachislot game Shin Onimusha also experienced better than expected sales.

For the current fiscal year, Capcom expects net sales of 85 billion yen and operating income of 26 billion yen.

The following blog post, unless otherwise noted, was written by a member of Gamasutra’s community.
The thoughts and opinions expressed are those of the writer and not Gamasutra or its parent company.

Open world games: They attract players with their promise of freedom and immersion and arouse the interest of publishers because of their business prospects.

These games feature a very specific characteristic: Their level design is more important than their game system. The vast majority of open world games offer very classic game mechanics and it is not they who seduce, it is the open world itself, hence the level design.

In most games, the design team first defines the core gameplay, then tackles the level design; the latter serving as a field of application for the game system. But in an open world game, the opposite is desirable: First, define the main characteristics of the open world, then select the most suitable game mechanisms.

Level design is one of my specialties and I had the chance to work on several open world games: The Black Death, Cabela’s African Adventures, Duck Dynasty, etc. The purpose of this 5-parts publication is to give good foundations to a studio that would engage in such a development but also to a publisher who would have to make editorial choices regarding an upcoming open world game.

The “why” must precede the “how”

When attacking reflections on the design of an open world game, there is a fundamental question that must be asked: Why? Why do we want an open world?

This question deserves a minimum of thoughts because the answer will have a major impact on the content of the open world and therefore, its game mechanics.

Schematically, there are three strategies for using level design in an open world game:

Strategy # 1, conquering players’ game time.

This strategy is at work in several Ubisoft franchises such as Far Cry, Ghost Recon and The Division. Its objective is to offer a huge lifespan to the game. It is achieved by increasing the number of quests, renewing the content of the open world constantly and supporting “farming” mechanisms. As a reminder, “farming” consists, in a game, to encourage players to collect or gain large amounts of resources so that they improve the attributes of their characters, their equipment, etc.

What are the benefits of this strategy?

• The longer players play a given game, the more chance there is of selling them additional content (DLC, cosmetic items, etc.). The latter has become a significant complement to the income generated by the sales of the game itself.

• A game that offers an “infinite” gaming experience is much less likely to fuel the second-hand market because players keep them. This is less the case with a game that offers a linear and limited playing experience, either by its scenario or by the number of levels it offers.

• When a game is played for a long time and its lifespan is fueled by additional, paid or free content, it remains present in the media and the minds of players. Its publisher can thus maintain the visibility of its intellectual property.

• Finally, it is easier to sell a game that offers a long life at a high price, as buyers feel that they are getting their money’s worth.

On the other hand, the systemic dimension of the game mechanisms can make the open world repetitive and weaken its gameplay. In addition, it is more difficult to integrate a convincing narrative into it.

I will come back in more detail in a later part on the game mechanisms and good practices in terms of level design for open world games seeking to implement such a strategy.

Strategy # 2, priority to immersion.

Red Dead Redemption 2 or the first titles in the Assassin’s Creed series are good examples of this strategy. It attracts players by transporting them to a universe that is credible and that interests them. The high level of credibility is obtained thanks to the attention to detail, the historical references and the behaviors of the NPCs (non-player characters) who populate these worlds. Finally, it is the choice of theme that makes these universes interesting: Florence in the Renaissance, America in the late 19th century, etc.

The advantages of this strategy are as follows:

• Its first strong point is the attractiveness of the chosen theme. Players interested in their themes become potential buyers.

• Another advantage is that this strategy facilitates the implementation of quality storytelling. Indeed, if the game world is credible, it is easier to build characters and scenarios that are also credible, two characteristics of good storytelling. The latter attracts some players and has shown that it can bring real added value to many games. As proof, the excellent The Last Of Us, which perfectly combines efficient gameplay and high-quality storytelling.

On the side of the weak points, this concern for details complicates the development, and therefore the cost of development. In addition, the need to make the game environment credible has an impact on the density of actions offered to the player but also on the evolution of skills, powers, and equipment of the character controlled by the players, thus running the risk of weakening the gameplay.

Strategy # 3, the map is the challenge.

This strategy is at the heart of survival games such as The Long Dark, DayZ or The Forest. In most open world games, the map is mainly used to support quests. Apart from the farming of resources and some ambushes, the map has no gameplay function.

But in survival games, this is not the case. It’s the knowledge of the world around them that allows players to survive and even thrive. The players’ challenge consists, in part, in knowing how to get around and find the resources essential to their survival. The map is, therefore, a central component in the game system, not a simple decoration intended to link quests or action scenes.

This strategy offers several benefits:

• It offers more original and more complex gameplays than those found in other action games. In addition, this gameplay does not necessarily favor combat and can, therefore, seduce players tired by it or those who favor cooperative gaming experiences.

• The mechanisms of survival games can be complex. They offer a more hardcore positioning of the game. Indeed, the gameplay of this type of game requires mastery of many aspects of the game: Understanding the environment, the use of resources that are found, good survival and development strategies. In addition, any self-respecting survival game does not offer saves. When players’ character dies, they have to start over from the beginning. This brutal feature can be softened but remains at the heart of the gaming experience.

• Finally, this strategy is compatible with many game modes: Solo, co-op, etc.. Co-op modes are particularly interesting because they appeal to a majority of players of all skill levels.

But this strategy also has weaknesses. The mechanisms associated with this genre are complex and can put off the least seasoned players. They also tend to repeat themselves from game to game, weakening their attractiveness.

When the time comes to choose

Few games choose a unique strategy. Thus, DayZ focuses exclusively on strategy # 3 and The Witcher 3 develops strategy # 2 because it is above all an action-adventure game based on strong storytelling; the open world is relatively little exploited.

But many others build their gaming experience by combining these strategies. Red Dead Redemption 2 skillfully mixes strategies 1 and 2. The long Dark develops strategies # 2 and # 3 in an original way: By offering different game modes. The Survival mode offers a real gameplay of… survival while the Wintermute mode is built around a linear story while offering more “affordable” survival gameplay.

Mixing these three strategies to a different degree is a valid choice. When designing an open world game, the mistake one should not make is to add features without asking the question of the game experience one wants to create. Knowing the existence of these three strategies makes it possible to define, in a clear manner for the whole team, the pillars of the game and to make the right choices in terms of features.

In the next part…

Now that we have defined the use of our open world, we need to define how we are going to fill it to achieve this goal. In the second part of this column dedicated to the level design of open world games, I will touch on an essential aspect of these, the player’s progression mechanisms.

Pascal Luban

Creative director & game designer, freelance

www.gamedesignstudio.com

This tutorial shows you how to group the inner lists of a Python list of lists by common element. There are three basic methods:

1. Group the inner lists together by common element.
2. Group the inner lists together by common element AND aggregating them (e.g. averaging).
3. Group the inner lists together by common element AND aggregating them (e.g. averaging) using the Pandas external library.

Before we explore these three options in more detail, let’s give you the quick solution first using the Pandas library in our interactive shell:

You can run this code in your browser. If you want to learn about the Pythonic alternatives or you need a few more explanations, then read on!

Method 1: Group List of Lists By Common Element in Dictionary

Problem: Given a list of lists. Group the elements by common element and store the result in a dictionary (key = common element).

Example: Say, you’ve got a database with multiple rows (the list of lists) where each row consists of three attributes: Name, Age, and Income. You want to group by Name and store the result in a dictionary. The dictionary keys are given by the Name attribute. The dictionary values are a list of rows that have this exact Name attribute.

Solution: Here’s the data and how you can group by a common attribute (e.g., Name).

# Database:

# row = [Name, Age, Income]

rows = [['Alice', 19, 45000], ['Bob', 18, 22000], ['Ann', 26, 88000], ['Alice', 33, 118000]] # Create a dictionary grouped by Name

d = {}

for row in rows: # Add name to dict if not exists if row[0] not in d: d[row[0]] = [] # Add all non-Name attributes as a new list d[row[0]].append(row[1:]) print(d)

# {'Alice': [[19, 45000], [33, 118000]],

# 'Bob': [[18, 22000]],

# 'Ann': [[26, 88000]]}

You can see that the result is a dictionary with one key per name ('Alice', 'Bob', and 'Ann'). Alice appears in two rows of the original database (list of lists). Thus, you associate two rows to her name—maintaining only the Age and Income attributes per row.

The strategy how you accomplish this is simple:

• Create the empty dictionary.
• Go over each row in the list of lists. The first value of the row list is the Name attribute.
• Add the Name attribute row[0] to the dictionary if it doesn’t exist, yet—initializing the dictionary to the empty list. Now, you can be sure that the key exist in the dictionary.
• Append the sublist slice [Age, Income] to the dictionary value so that this becomes a list of lists as well—one list per database row.
• You’ve now grouped all database entries by a common attribute (=Name).

So far, so good. But what if you want to perform some aggregation on the grouped database rows?

Method 2: Group List of Lists By Common Element and Aggregate Grouped Elements

Problem: In the previous example, you’ve seen that each dictionary value is a list of lists because you store each row as a separate list. But what if you want to aggregate all grouped rows?

Example: The dictionary entry for the key 'Alice' may be [[19, 45000], [33, 118000]] but you want to average the age and income values: [(19+33)/2, (45000+118000)/2]. How do you do that?

Solution: The solution is simply to add one post-processing step after the above code to aggregate all attributes using the zip() function as follows. Note that this is the exact same code as before (without aggregation) with three lines added at the end to aggregate the list of lists for each grouped Name into a single average value.

# Database:

# row = [Name, Age, Income]

rows = [['Alice', 19, 45000], ['Bob', 18, 22000], ['Ann', 26, 88000], ['Alice', 33, 118000]] # Create a dictionary grouped by Name

d = {}

for row in rows: # Add name to dict if not exists if row[0] not in d: d[row[0]] = [] # Add all non-Name attributes as a new list d[row[0]].append(row[1:]) print(d)

# {'Alice': [[19, 45000], [33, 118000]],

# 'Bob': [[18, 22000]],

# 'Ann': [[26, 88000]]} # AGGREGATION FUNCTION:

for key in d: d[key] = [sum(x) / len(x) for x in zip(*d[key])] print(d)

# {'Alice': [26.0, 81500.0], 'Bob': [18.0, 22000.0], 'Ann': [26.0, 88000.0]}

In the code, you use the aggregation function sum(x) / len(x) to calculate the average value for each attribute of the grouped rows. But you can replace this part with your own aggregation function such as average, variance, length, minimum, maximum, etc.

Explanation:

• You go over each key in the dictionary (the Name attribute) and aggregate the list of lists into a flat list of averaged attributes.
• You zip the attributes together. For example, zip(*d['Alice']) becomes [[19, 33], [45000, 118000]] (conceptually).
• You iterate over each list x of this list of lists in the list comprehension statement.
• You aggregate the grouped attributes using your own custom function (e.g. sum(x) / len(x) to average the attribute values).

See what happens in this code snippet in this interactive memory visualization tool (by clicking “Next”):

Method 3: Pandas GroupBy

The Pandas library has its own powerful implementation of the groupby() function. Have a look at the code first:

# Database:

# row = [Name, Age, Income]

rows = [['Alice', 19, 45000], ['Bob', 18, 22000], ['Ann', 26, 88000], ['Alice', 33, 118000]] import pandas as pd

df = pd.DataFrame(rows) print(df) ''' 0 1 2

0 Alice 19 45000

1 Bob 18 22000

2 Ann 26 88000

3 Alice 33 118000 ''' print(df.groupby([0]).mean()) ''' 1 2

0 Alice 26 81500

Ann 26 88000

Bob 18 22000 '''

Explanation:

• Import the pandas library. Find your quick refresher cheat sheets here.
• Create a DataFrame object from the rows—think of it as an Excel spreadsheet in your code (with numbered rows and columns).
• Call the groupby() function on your DataFrame. Use the column index [0] (which is the Name attribute) to group your data. This creates a DataFrameGroupBy object.
• On the DataFrameGroupBy object call the mean() function or any other aggregator function you want.
• The result is the “spreadsheet” with grouped Name attributes where multiple rows with the same Name attributes are averaged (element-wise).

Where to Go From Here?

Enough theory, let’s get some practice!

To become successful in coding, you need to get out there and solve real problems for real people. That’s how you can become a six-figure earner easily. And that’s how you polish the skills you really need in practice. After all, what’s the use of learning theory that nobody ever needs?

Practice projects is how you sharpen your saw in coding!

Do you want to become a code master by focusing on practical code projects that actually earn you money and solve problems for people?

Then become a Python freelance developer! It’s the best way of approaching the task of improving your Python skills—even if you are a complete beginner.

Join my free webinar “How to Build Your High-Income Skill Python” and watch how I grew my coding business online and how you can, too—from the comfort of your own home.

Join the free webinar now!