Posted on Leave a comment

Blog: Working on controversial shooter Six Days in Fallujah

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.


*All ideas mentioned are from my memory and shouldn’t be considered official statements.

When I joined Destineer in 2007, the Minneapolis-based company had opened a sister studio in North Carolina.  The Raleigh team I joined was gearing up to work on a CIA game experience while Six Days in Fallujah (SDIF) had been active in Minneapolis for a couple years using in-house technology.

Developing a proprietary engine with a variety of new and veteran developers is never an easy thing.  A year later it was decided the bulk of development for SDIF would be moved to North Carolina merging both teams into one. 

Tactical shooters hadn’t completely embraced modern battles yet, so the time period stood out. Plus, destruction hadn’t been done to the heavy degree SDIF was working on at the time, offering another fresh approach to the tiresome Call of Duty formula. The game market was ready for a title like this.  The general public wasn’t however.

The label of “Survival Horror” was a bit of a misnomer. It didn’t mean the typical survival horror formula, which involves low firepower, surrounded by gore. It was the closest familiar term to convey isolation beyond your immediate Fire Team when surrounded by unknown assailants. A psychological trial as a stranger in a strange land.

While we didn’t lock down the exact consequences of player death, it was going to be realistic. For awhile there was discussion on regenerating health. This wasn’t to make it like Gears of War or arcade style. It was an attempt to focus more on the conflict, strategy, and emotional impact instead of trivializing the connection you build with your character. The flip-side was to replace him with a new marine every time death occurred (which is an issue by itself since we wanted to use real marines).

The original advantage Destineer had was self-publishing the game. Because of technology reasons, some inexperienced members, and “death by demo” schedules, the company slowly lost its chance to self-publish. It’s possible a larger publisher was always considered in regards to world-wide distribution with Destineer responsible for USA only.

Atomic Games wasn’t part of the picture until 2009.  Atomic was a company brand under Destineer to separate AAA games from their budget and training simulator titles.

While courting Konami, other publishers were approached. EA was a strong candidate. Had it been with them, it would’ve been included under one of their existing franchises and called something like “Metal of Honor: Fallujah“. The project fast-tracked with Sony as well. Everyone in the US Sony division was 100% behind the game. Japan HQ felt differently though. They sold Sony products in the middle-east and didn’t want this game to affect that consumer base.

[embedded content]

Konami of course caved to backlash from a handful of loud voices against the idea it was going to disrespect the death of real Marines and make a flashy game out of the conflict. The previous idea about regenerating health fueled the belief SDIF would be a typical Call of Duty game.

That was far from the case. For several years the team was in direct communication with numerous Marines. Each one gave us presentations and recollections of their experiences. They were quick to correct any misinterpretations, as well as promoting what actual military personnel do, react to, and operate.

We recorded personal one-on-one interviews with them. These were to be presented in a bookend fashion before and after each chapter of the game. They would share their fears, strategy, and expectations at the time. Then they’d reflect on the experience, what went wrong, and what they learned. What other game out there puts a personal, real face to the conflict?

After Konami bailed, the studio survived for a few more months. Other publishers were approached, but none of them wanted to embrace the project. It was too hot in the media at the time. Everyone of the 75+ team except a dozen or so were laid off in August 2009. 

The remaining members started work on Breach as an intermediate project while efforts to find SDIF a new publisher continued. Despite rumors the project was complete and waiting for release, it was never completed. The technology, production pipeline, systems, and design were there for the most part. The game maps and scripting weren’t complete however. Several levels were made throughout SDIF’s lifetime in a showcase-demo fashion. Most of those were removed during development because of technology or story changes.

When the team was laid off, we had four out of eight levels in development. One of them was almost complete, but removed because it took place in Resala Cemetery. The media backlash prompted its removal for fear destroying gravestones would be culturally disrespectful. Mosques were also off limits to destruction. In the bigger picture, I thought the restriction was too extreme considering the subject matter.

Also, we weren’t consulting with insurgents. It was a journalist hired to interview residents. Producer James Cowgill has more details on the Insurgent controversy.

The part about consulting with insurgents was highly confusing and somewhat ironic. The reality is this: months after the game was announced publically and the rumor of Atomic consulting with insurgents started, I personally hired (as the documentary producer) a journalist to go to Fallujah and interview / tape people there with experiences centered around the time period of the battle. This included people who had fled the city, mothers who had lost sons and men who claimed to be insurgents.

The goal was to use this footage in the documentary part of the game (along with about 100 hours of Marine interviews from the 8th and 3rd Divisions) and to help us generally understand the people of Fallujah better and create an authentic experience.

The interviews were incredible – even now some of them very much stick out in my mind; a mom crying on her son’s grave, an insurgent looking straight into the camera and saying he tried his best to kill Americans, a father who fled with his children before his house was taken over by insurgents.

It was real and it put a face on Fallujah that helped to give the project credibility as a historical document. We had enough footage (interviews and battlefield footage) to create an entire 2 hour documentary of the battle that put the Military Channel to shame.

I discovered later that people in Fallujah thought the journalist might be a CIA agent and his life was put in danger – so much so that he couldn’t return to Fallujah. One day, I hope this material is turned into a documentary – I strongly feel that the stories we collected from the Marines and people in Fallujah about this event are too important to be lost. This probably great tragedy of the project.

Other games have since approached similar modern topics and survived. SDIF would have risen above the typical shooter and given players more insight to what really happened. It was never intended to push a political agenda. It was about the men on the ground and their personal accounts during that week in November 2004. Six Days in Fallujah was going to be a game that presented history, knowledge, and tragedy during a serious world event. What a novel approach to the watered down and sensationalized gunplay games made these days.

Posted on Leave a comment

Daily Deal – Full Metal Furies, 15% Off

Add Crusader Kings II to your account for FREE starting now until Saturday at 10AM Pacific*! Once you add the game, it will remain in your account permanently, so don’t miss out on this opportunity to own this great title!
Additionally, save up to 50% on DLC’s and Expansions for Crusader Kings II as part of the Weekend Deal**!

*After Saturday, Crusader Kings II will be available for 75% off for the rest of the weekend.
**Discount offer ends Monday at 10AM Pacific Time

Posted on Leave a comment

Blog: Building a fully-managed game analytics pipeline

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.


Gathering usage data such as player progress in games is invaluable for teams. Typically, entire teams have been dedicated to building and maintaining data pipelines for collecting and storing tracking data for games. However, with many new serverless tools available, the barriers to building an analytics pipeline for collecting game data have been significantly reduced. Managed tools such as Google’s PubSub, DataFlow, and BigQuery have made it possible for a small team to set up analytics pipelines that can scale to a huge volume of events, while requiring minimal operational overhead. This post describes how to build a lightweight game analytics pipeline on the Google Cloud platform (GCP) that is fully-managed (serverless) and auto scales to meet demand. 

I was inspired by Google’s reference architecture for mobile game analytics. The goal of this post is to show that it’s possible for a small team to build and maintain a data pipeline that scales to large event volumes, provides a data lake for data science tasks, provides a query environment for analytics teams, and has extensibility for additional components such as an experiment framework for applications. 

The core piece of technology I’m using to implement this data pipeline is Google’s DataFlow, which is now integrated with the Apache Beam library. DataFlow tasks define a graph of operations to perform on a collection of events, which can be streaming data sources. This post presents a DataFlow task implemented in Java that streams tracking events from a PubSub topic to a data lake and to BigQuery. An introduction to DataFlow and it’s concepts is available in Google’s documentation. While DataFlow tasks are portable, since they are now based on Apache Beam, this post focuses on how to use DataFlow in conjunction with additional managed services on GCP to build a simple, serverless, and scalable data pipeline for storing game events.

My lightweight implementation of the GCP Reference Architecture for Analytics.

The data pipeline that performs all of this functionality is relatively simple. The pipeline reads messages from PubSub and then transforms the events for persistence: the BigQuery portion of the pipeline converts messages to TableRow objects and streams directly to BigQuery, while the AVRO portion of the pipeline batches events into discrete windows and then saves the events to Google Storage. The graph of operations is shown in the figure below.

The streaming pipeline deployed to Google Cloud

Setting up the Environment

The first step in building a game data pipeline is setting up the dependencies necessary to compile and deploy the project. I used the following maven dependencies to set up environments for the tracking API that sends events to the pipeline, and the data pipeline that processes events. 
 

Dependencies for the Tracking API ->
  com.google.cloud
  google-cloud-pubsub
  0.32.0-beta
 

​<!– Dependencies for the data pipeline ->
<dependency>
  <groupId>com.google.cloud.dataflow</groupId>
  <artifactId>google-cloud-dataflow-java-sdk-all</artifactId>
  <version>2.2.0</version>
</dependency>

I used Eclipse to author and compile the code for this tutorial, since it is open source. However, other IDEs such as IntelliJ provide additional features for deploying and monitoring DataFlow tasks. Before you can deploy jobs to Google Cloud, you’ll need to set up a service account for both PubSub and DataFlow. Setting up these credentials is outside the scope of this post, and more details are available in the Google documentation.

An additional prerequisite for running this data pipeline is setting up a PubSub topic on GCP. I defined a raw-events topic that is used for publishing and consuming messages for the data pipeline. Additional details on creating a PubSub topic are available here.

To deploy this data pipeline, you’ll need to set up a java environment with the maven dependencies listed above, set up a GCP project and enable billing, enable billing on the storage and BigQuery services, and create a PubSub topic for sending and receiving messages. All of these managed services do cost money, but there is a free tier that can be used for prototyping a data pipeline. 

Sending events from a game server to a PubSub topic

Publishing Events

In order to build a usable data pipeline, it’s useful to build APIs that encapsulate the details of sending game events. The Tracking API class provides this functionality, and can be used to send generated event data to the data pipeline. The code below shows the method signature for sending game events, and shows how to generate sample data. 
 

/** Event Signature for the Tracking API */
// sendEvent(String eventType, String eventVersion, HashMap attributes);

// send a batch of events   
for (int i=0; i<10000; i++) {

  // generate event names     
  String eventType = Math.random() < 0.5 ?
      “Session” : (Math.random() < 0.5 ? “Login” : “MatchStart”);

  // create attributes to send     
  HashMap<String, String> attributes = new HashMap<String,String>();
  attributes.put(“userID”, “” + (int)(Math.random()*10000));
  attributes.put(“deviceType”, Math.random() < 0.5 ?
      “Android” : (Math.random() < 0.5 ? “iOS” : “Web”));

  // send the event     
  tracking.sendEvent(eventType, “V1”, attributes);     
}

The tracking API establishes a connection to a PubSub topic, passes game events as a JSON format, and implements a callback for notification of delivery failures. The code used to send events is provided below, and is based on Google’s PubSub example provided here.
 

// Setup a PubSub connection
TopicName topicName = TopicName.of(projectID, topicID);
Publisher publisher = Publisher.newBuilder(topicName).build();

// Specify an event to send
String event = {\”eventType\”:\”session\”,\”eventVersion\”:\”1\”}”;

// Convert the event to bytes   
ByteString data = ByteString.copyFromUtf8(event.toString());

//schedule a message to be published   
PubsubMessage pubsubMessage =
  PubsubMessage.newBuilder().setData(data).build();

​// publish the message, and add this class as a callback listener
ApiFuture<String> future = publisher.publish(pubsubMessage);   
ApiFutures.addCallback(future, this);

The code above enables games to send events to a PubSub topic. The next step is to process this events in a fully-managed environment that can scale as necessary to meet demand.

Storing Events

One of the key functions of a game data pipeline is to make instrumented events available to data science and analytics teams for analysis. The data sources used as endpoints should have low latency and be able to scale up to a massive volume of events. The data pipeline defined in this tutorial shows how to output events to both BigQuery and a data lake that can be used to support a large number of analytics business users. 

Streaming event data from PubSub to DataFlow

The first step in this data pipeline is reading events from a PubSub topic and passing ingested messages to the DataFlow process. DataFlow provides a PubSub connector that enables streaming of PubSub messages to other DataFlow components. The code below shows how to instantiate the data pipeline, specify streaming mode, and to consume messages from a specific PubSub topic. The output of this process is a collection of PubSub messages that can be stored for later analysis.
 

// set up pipeline options   
Options options = PipelineOptionsFactory.fromArgs(args).withValidation().as(Options.class);   
options.setStreaming(true);   
Pipeline pipeline = Pipeline.create(options);

​// read game events from PubSub   
PCollection<PubsubMessage> events = pipeline
  .apply(PubsubIO.readMessages().fromTopic(topic));

The first way we want to store game events is in a columnar format that can be used to build a data lake. While this post doesn’t show how to utilize these files in downstream ETLs, having a data lake is a great way to maintain a copy of your data set in case you need to make changes to your database. The data lake provides a way to backload your data if necessary due to changes in schemas or data ingestion issues. The portion of the data pipeline allocated to this process is shown below.

Batching events to AVRO format and saving to Google Storage

For AVRO, we can’t use a direct streaming approach. We need to group events into batches before we can save to flat files. The way this can be accomplished in DataFlow is by applying a windowing function that groups events into fixed batches. The code below applies transformations that convert the PubSub messages into String objects, group the messages into 5 minute intervals, and output the resulting batches to AVRO files on Google Storage.
 

// AVRO output portion of the pipeline   
events.apply(“To String”, ParDo.of(new DoFn() {
  @ProcessElement       
  public void processElement(ProcessContext c) throws Exception {
    String message = new String(c.element().getPayload());
    c.output(message);       
  }     
}))

// Batch events into 5 minute windows     
.apply(“Batch Events”, Window.<String>into(   
    FixedWindows.of(Duration.standardMinutes(5)))      
  .triggering(AfterWatermark.pastEndOfWindow())    
  .discardingFiredPanes()             
  .withAllowedLateness(Duration.standardMinutes(5)))

​// Save the events in ARVO format     
.apply(“To AVRO”, AvroIO.write(String.class)
  .to(“gs://your_gs_bucket/avro/raw-events.avro”)
  .withWindowedWrites()
  .withNumShards(8)
  .withSuffix(“.avro”));

To summarize, the above code batches game events into 5 minute windows and then exports the events to AVRO files on Google Storage. 

The result of this portion of the data pipeline is a collection of AVRO files on google storage that can be used to build a data lake. A new AVRO output is generated every 5 minutes, and downstream ETLs can parse the raw events into processed event-specific table schemas. The image below shows a sample output of AVRO files.

AVRO files saved to Google Storage

In addition to creating a data lake, we want the events to be immediately accessible in a query environment. DataFlow provides a BigQuery connector which serves this functionality, and data streamed to this endpoint is available for analysis after a short duration. This portion of the data pipeline is shown in the figure below. 

Streaming events from DataFlow to BigQuery

The data pipeline converts the PubSub messages into TableRow objects, which can be directly inserted into BigQuery. The code below consists of two apply methods: a data transformation and a IO writer. The transform step reads the message payloads from PubSub, parses the message as a JSON object, extracts the eventType and eventVersion attributes, and creates a TableRow object with these attributes in addition to a timestamp and the message payload. The second apply method tells the pipeline to write the records to BigQuery and to append the events to an existing table. 
 

// parse the PubSub events and create rows to insert into BigQuery   
events.apply(“To Table Rows”, new
  PTransform, PCollection>() {
    public PCollection expand(
        PCollection input) {   
          return input.apply(“To Predictions”, ParDo.of(new 
            DoFn() {  

    @ProcessElement         
    public void processElement(ProcessContext c) throws Exception {
      String message = new String(c.element().getPayload());

      // parse the json message for attributes
      JsonObject jsonObject =
          new JsonParser().parse(message).getAsJsonObject();
      String eventType = jsonObject.get(“eventType”).getAsString();
      String eventVersion = jsonObject.
              get(“eventVersion”).getAsString();         
      String serverTime = dateFormat.format(new Date());

     // create and output the table row           
     TableRow record = new TableRow();           
     record.set(“eventType”, eventType);              
     record.set(“eventVersion”, eventVersion);         
     record.set(“serverTime”, serverTime);
     record.set(“message”, message);           
     c.output(record);         
  }}));     
}})

//stream the events to Big Query   
.apply(“To BigQuery”,BigQueryIO.writeTableRows()  
  .to(table)          
  .withSchema(schema)
  .withCreateDisposition(CreateDisposition.CREATE_IF_NEEDED)
  .withWriteDisposition(WriteDisposition.WRITE_APPEND));

To summarize the above code, each game event that is consumed from PubSub is converted into a TableRow object with a timestamp and then streamed to BigQuery for storage. 

The result of this portion of the data pipeline is that game events will be streamed to BigQuery and will be available for analysis in the output table specified by the DataFlow task. In order to effectively use these events for queries, you’ll need to build additional ETLs for creating processed event tables with schematized records, but you now have a data collection mechanism in place for storing events. 

Game event records queried from the raw-events table in BigQuery

Deploying and Auto Scaling

With DataFlow you can test the data pipeline locally or deploy to the cloud. If you run the code samples without specifying additional attributes, then the data pipeline will execute on your local machine. In order to deploy to the cloud and take advantage of the auto scaling capabilities of this data pipeline, you need to specify a new runner class as part of your runtime arguments. In order to run the data pipeline, I used the following runtime arguments:

–runner=org.apache.beam.runners.dataflow.DataflowRunner
–jobName=game-analytics
–project=your_project_id
–tempLocation=gs://temp-bucket

Once the job is deployed, you should see a message that the job has been submitted. You can then click on the DataFlow console to see the task: 

The steaming data pipeline running on Google Cloud

The runtime configuration specified above will not default to an auto scaling configuration. In order to deploy a job that scales up based on demand, you’ll need to specify additional attributes, such as:
 

–autoscalingAlgorithm=THROUGHPUT_BASED
–maxNumWorkers=30

Additional details on setting up a DataFlow task to scale to heavy workload conditions are available in this Google article and this post from Spotify. The image below shows how DataFlow can scale up to meet demand as necessary.

An example of Dataflow auto scaling

Conclusion 

There is now a variety of tools available that make it possible to set up an analytics pipeline for a game or web application with minimal effort. Using managed resources enables small teams to take advantage of serverless and autoscaling infrastructure to scale up to massive event volumes with minimal infrastructure management. Rather than using a data vendor’s off-the-shelf solution for collecting data, you can record all relevant data for your app. 

The goal of this post was to show how a data lake and query environment can be set up using the GCP stack. While the approach presented here isn’t directly portable to other clouds, the Apache Beam library used to implement the core functionality of this data pipeline is portable and similar tools can be leveraged to build scalable data pipelines on other cloud providers.

This architecture is a minimal implementation of an event collection system that is useful for analytics and data science teams. In order to meet the demands of most analytics teams, the raw events will need to be transformed into processed and cooked events in order to meet business needs. This discussion is outside the scope of this post, but the analytics foundation should now be in place for building out a highly effective data platform. 

The full source code for this sample pipeline is available on GithubBen Weber is the lead data scientist at Windfall Data, where our mission is to build the most accurate and comprehensive model of net worth.

Posted on Leave a comment

Ni No Kuni developer Level-5 bringing all future main titles to Switch

Japanese developer Level-5 intends to release all of its upcoming main titles on Switch. 

It’s a notable move given the studio’s portfolio contains a raft of big-name franchises like Professor Layton, Ni No Kuni, and Yo-kai Watch

Level-5 president and CEO Akihiro Hino broke the news in an interview with Nikkei Trendy (translated by Gematsu), suggesting he wants to emulate the company’s 3DS successes on the Switch. 

“Basically, in the future our main titles will all be released on Nintendo Switch,” commented Hino. “The idea is that what we have created for 3DS will move over to Switch.”

The studio will be making its Switch debut this month with the Japanese launch of The Snack World: Trejarers, before following up with the Switch release of Inazuma Eleven Ares later this year.

Posted on Leave a comment

Shadow of War is being completely stripped of microtransactions

Middle-earth: Shadow of War developer Monolith has decided to completely remove microtranscations from the game. 

Explaining the decision in a post on the WB Games website, the studio claims the monetization method compromises “the core promise of the Nemisis System,” which allows players to build personal relationships with allies and enemies through dynamic, ever-evolving encounters. 

As it stands, Shadow of War lets players purchase Orcs using real-world cash, letting them circumvent the system altogether, but that’s about to change. 

“While purchasing Orcs in the Market is more immediate and provides additional player options, we have come to realize that providing this choice risked undermining the heart of our game, the Nemesis System,” reads the post.

“It allows you to miss out on the awesome player stories you would have otherwise created, and it compromises those same stories even if you don’t buy anything. 

“Simply being aware that they are available for purchase reduces the immersion in the world and takes away from the challenge of building your personal army and your fortresses. In order to fully restore the core promise of the Nemesis System, we’ll be permanently removing Gold, War Chests and the Market from Shadow of War.”

Gold will no longer be purchasable as of May 8, giving those clamoring to spend around a month to trade their real-world dollars for in-game cash. 

The in-game market will stay open until July 17, at which point it’ll be closed for good. Any remaining gold will then be converted into Gold Loot Chests.

Posted on Leave a comment

Blog: A postmortem on my game design degree

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.


After 4 long years, I’m almost graduating with a Bachelors of Game Design degree from Sheridan College in Ontario, Canada.

 

Go me!

 

Over the last 4 years I’ve been to MIGS, had my writing published here and there on the internet and even been to GDC twice which is impressive to me since I knew next to nothing about game development when I started all this.

 

It’s been a long journey, but I thought the best way I could commemorate the event would be to reflect on my past 4 years in this program; what I wish I knew, what I learned and a little bit of philosophy on post-secondary schooling in general.

 

Be aware not all of this will be about Game Design programs (or post-secondary education, even!) and can apply to many different fields as well. Additionally, this is all just my personal opinion and everything below can be taken with a grain of salt!

Learning Is Hard

Before spending 4 years on Game Design, I spent 1 in a general arts program. My time in general arts mostly taught me I didn’t really want to do art for a living – I like it as a hobby, not as work. That helped usher me into Game Design.

 

But it wasn’t until a year in Game Design did it kick in just how much more work college was than high school; in part because I was in an actual degree program now, but also because I was now doing something that I started to feel like I actually wanted to do with my life. The difference between high school and college to me was that college felt a billion times more relevant to my future. Not to mention that I was paying thousands of dollars for my education I needed to make it really count.

 

For my first year in Game Design I struggled with programming, not really understanding what I was doing and riding off the help of others. One day I had a group assignment where I couldn’t contribute anything and I realized how poorly prepared I was – and I didn’t want to keep that up for 3 more years!

 

Over the summer I was working full time, but I dedicated every weekend to programming my own little side projects which helped me build up my skills to where I felt confident enough in a group setting. I don’t remember doing anything aside from coding, working fast food and rollerblading that whole summer.

 

Before I knew it, I was coding almost every group project I was in for the next two years, mostly because no one else wanted to.

 

It was a good kick in the butt and the point where I realized this was the chance I had been waiting for my whole life – the chance to finally do something with my life and dedicate myself to something.

 

I’m not saying everyone will have an “a-HA!” moment, but try to remember that college is long, hard and you’re in it for the long haul. The industry is competitive – don’t hope to just sail through like I did and hope everything will work itself out in the end.

 

Don’t Procrastinate

The single most frustrating thing about school was watching my classmates – people who I knew to be very skilled, hardworking and capable – put things off again and again until the last minute and then panic and crunch when their work wasn’t finished a few hours before the deadline.

 

This happened for almost every single assignment.

 

Early on I noticed I have pretty intense mental health troubles when I didn’t have something to work on. By necessity I always keep busy and try to get work in as early as possible since it makes me feel more comfortable about the homework process. A bonus was it gave me time to take breaks, work on portfolio pieces and I don’t have to crunch!

 

Unfortunately, humans have dumb biases which make them think procrastination is preferential to getting things over with early. Time management is one of the more important skills you can wrangle in your time at school – learn it early and apply it hard and you can save yourself a world of stress!

Network Early, Network Often

Lately I feel like I need to practice this more, but it helped me immensely.

 

In our third year we were required to find a co-op placement. While our school helped us do this, studios in the Toronto area weren’t exactly hiring at the time, so the onus was on us to do look for opportunities as well. On the suggestion of my professors, I started building my portfolio a year before our school gave us a class to help with it – just in case.

 

I had heard the year above us had trouble with finding placements, so I really wanted to get a jump on it while I still had time. Just like my previous coding misadventure, I spent the following summer developing my portfolio and media presence. On the advice of my professor Andrew Carvalho I started using Twitter (even though I didn’t much care for it) and started my awkward first foray into the world of networking.

 

Twitter was immensely helpful for me to get informed with the local game development scene since I knew almost no developers in my area. I started sharing the work I did regularly and kept tabs on what the folks around me were up to which helped me find chances to interact with local developers in person and strike up a conversation with then online before meeting them in person. This was extra helpful for me since I’m much more confident online than I am IRL!

 

I also started networking at events months before I really needed to find a co-op, which I think was important for me because it gave me time to build up my network online and practice networking skills before I was in a place of really having to rely on them. It definitely took me a few months to get used to the idea of handing a business card to someone after talking to them. All too often I see students in a similar position, just starting to learn the networking process when they realize they’re in need of opportunities and not beforehand, which has the unintended side effect of coming across as very awkward.

 

It was only after going to events for eight months did I meet someone who was looking for a designer and landed my first contract job – just by being in the right place at the right time. A lot of opportunities are based entirely on luck and sometimes networking is more about giving yourself more opportunities to be in the right place at the right time than it is about going around probing people for work.

Recognize The Privilege Of Having An Education

This is a big one too.

 

Through my schooling I’ve heard a handful of people from my own program and otherwise complain about post-secondary schooling. Things to the effect of “Why am I doing [insert really boring assignment here]? It’s a waste of my time!”

 

I won’t deny that there’s always going to be work that feels like it doesn’t apply to your skillset or feels like a waste. A lot of the time even if the work doesn’t feel worthwhile it can be if you’re willing to look at it that way: group assignments will always teach you how to work with people better, developing game will always give you new problems to solve, heck, even taking a physics class helped me brush up on my math skills which had been lying dormant for months on end.

 

But the biggest complaint I’ve heard from people is “I don’t need school to teach me [code, art, etc], I could learn all this online!”.

 

It’s true and on some level I agree, every hard skill I’ve learned in classes I’ve seen online in some form or another. I could take a masterclass online and learn art, or read an article on design to teach myself principles, or skim Unity’s forums to learn how to develop something.

 

However, the most valuable skills I’ve learned from school have been soft ones – working with people day in and day out, learning effective ways to communicate problems to other people, practicing taking and giving feedback in a kind and respectful manner, listening to and parsing feedback.

 

A lot of the time it’s even just the structure of schooling that gives you what you need – you develop a routine of learning and content fed directly to you in a distraction-free environment which most people likely aren’t able to replicate outside of school. You would have to be a very specific self-motivated personality type to put yourself through a learning regime as effective as school can be – meanwhile some people have trouble even getting out of bed in the morning.

 

There are shadow benefits to schooling as well: if you’re fortunate enough to live in a country which offers student loans (like me) there’s a financial stability you likely wouldn’t have elsewhere. I can learn while having a roof over my head and food to eat, which I’m incredibly grateful for.

 

Some students I’ve spoken to viewed it as a chance to see more of the world they would have seen in their home country. A degree alone can qualify people for employment overseas which self-guided learning probably can’t do. I’ve even spoken to someone in the past who came to the country to escape a politically unstable and dangerous home country – the education was more of a side-benefit to their own safety and sanity. They worried for their family at home but were glad to be somewhere they could feel safe.

 

That’s why it breaks my heart to hear students complain about post-secondary education and tell people they “don’t need school”. It’s important to remember that while some of us don’t need school, other people need it more than anything in the world.

 

Pay It Forward

I consider myself – a white male with government-provided student loans – incredibly privileged to be able to attend a postsecondary school for five years of my adult life studying a field I love. I don’t deny for a second that my ability to do the things listed in this article and the opportunities I’ve received are directly related to this.

 

Being able to learn as I have for the last few years is not something I intend to take for-granted either because, as mentioned above, lots of people would love to do what I’m doing too.

 

In November of 2016 a local student showcase called Eat Play Mingle (organized by the awesome Meagan Budgell) was held at George Brown College, another local post-secondary institution in the area. A friend and I signed up to demo our game there for the evening alongside other local Toronto developers.

 

At one point in the night there was a series of micro-talks by local devs called “Bonus Stage” where people would give a little talk on a topic of their choice. I watched a few of them (including some great ones from folks at 13AM Games) and they were a couple speakers short. I hated public speaking, but on a total impulse I decided to volunteer and improvised a (very nervous and excited) talk on Emergent Roleplay in Guild Wars 2 since it seemed like a great chance to express my passion on the subject. I actually enjoyed it and felt like I could use my experience to help others learn something for once!

 

From that point on I started trying to sharing my knowledge and experiences wherever I could; I wrote advocacy articles and blog posts (just like this one!), gave talks at multiple conventions and offered advice for other devs and students who were curious about getting into development. Over the last couple years I’ve ended up talking at over a dozen or so more Bonus Stages and was absolutely overjoyed when I saw my fellow students follow suit.

 

I try to use my position of privilege to give back to the game development community however I can, because I know there are tons of people out there who deserve this knowledge more than me. If I can be a conduit to pass it on to others, then so be it!

 

If you’re in a position to share your knowledge and help other developers try and do what you can where you can. Not only will you feel better for doing it, you’ll help make strong connections and help others grow in the process.

Conclusion

Woah, that got pretty heavy.

 

Obviously, there’s only so much I can fit into this blog. I didn’t even mention how I think school systems should model themselves as services and not businesses, or how students should be aware if they’re being exploited and not be afraid to use their voices to defend their rights where they can.

 

Ultimately, I’m of the opinion there’s good to be had in a Game Design education and equal parts bad. Just remember that at the end of the day, no amount of schooling or hard work is worth your well-being. Always remember to care for yourself as much as you possibly can.

 

If you’re a student and want to connect and chat about school or advice or game development or anything else under the sun you can always find me on Twitter with my DMs open.

 

Thanks for reading!

Posted on Leave a comment

Making a civilization-scale crafting system for Jason Rohrer’s One Hour One Life

There’s no inventory in One Hour One Life. And yet this online survival game features grand total of 463 craftable objects.

At least, that’s how many there are on the day this is being written. Developer Jason Rohrer is aiming to add another 9,500 over the next two years.

No inventory and a culture-spanning number of objects: these two facts seem entirely incompatible and yet they’re deeply related, resulting from Rohrer attempting to reconcile the realities of being a lone developer with his ambition to create a game that features a crafting system on the scale of human civilization. 

One Hour One Life is a multiplayer survival game in which players live a lifetime over the course of one hour, if they don’t starve first. They’re born as helpless babies which, for the first few years (minutes) of their lives, must be fed by other players who have lived to adult age.

Once they’re old enough they can start contributing to communal life, farming carrots, tending fires, feeding babies, and steadily building up a sustainable village, if everyone manages to work together.

Squeezing the history of human tool-making into a game

“The user interface, part of it is me figuring out as a solo developer, how to make a game that’s as big as all the content that’s in the real world, right?” Rohrer says. “All the things people made, all the doohickies you have in your house that thousands of people around the world have collaborated to make. That means the game has to have 10,000 things in it eventually. How do I have people craft those things, how can I design and implement it?”

“The user interface, part of it is me figuring out as a solo developer, how to make a game that’s as big as all the content that’s in the real world, right?”

His answer was a carefully simplified crafting system that’s based on combining one object with another to make a third object. Aiming to produce 100 objects a week, he has stripped down their creation to the bare minimum. He draws each one, creates a sound, if necessary, by recording his own voice, and plugs it into his editor in order to draw relationships between them and other objects. No programming is required. 

Thus, when Rohrer wanted to add the ability for walls to be broken into rubble, he simply drew a pile of rubble, scanned it, recorded himself making appropriate ‘krrbbbghhfff’ sound with his mouth, and plugged it into his editor so that ‘mining pick’ plus ’wall’ equals ‘rubble’.

What’s interesting about this system, which is extremely wide and very shallow, is the way it enables cultures to form in the game. Anxious to survive, players naturally form communities, passing on their knowledge of how their village runs to a new generation, knowing that at the end of their 60-minute life they’ll respawn as a baby near an adult player somewhere else in the world, dependent on them for food. 

While this behavior largely emerges from One Hour One Life’s survival design, the way in which communities form is informed by subtler cues. One of the most important is the way the game makes crafting visible. When a player is carrying and using objects, everyone can see what they’re doing. ”You lay out your ingredients on the ground and combine them, and you don’t have to explain it,” says Rohrer. “All someone has to do is watch you and they’ll learn what you’re doing.” He contrasts his approach with that of Minecraft, which presents its crafting menu as a grid which is invisible to other players and requires remembering precise configurations of resources. 

“It also feels to me more aesthetically like what it feels like to make something,” Rohrer continues. “I lay out the ingredients on the counter or I lay out my tools when I’m making a trellis for my tomato plants, and I’m carrying one tool at a time. I don’t have this huge armful of them. Dealing with clutter is something I really wanted in the game.”

The size of the crafting list also imposed the need to make each recipe memorable. But Rohrer argues that his system is naturally memorable because it’s inherently step-by-step, with the player combining one object with another, and then another. He has put a lot of thought into making these steps logical, so to make a fire, the player starts with combining an ember leaf with tinder to make smouldering tinder, and then waits a few seconds until it turns to burning tinder before combining it with kindling to make a fire.

“I’ve broken interactivity into this very coarse simulation of what it’s like to use one thing on another thing,” Rohrer says, explaining that it enables many ways of making similar things, such as the game’s 18 different flavours of pie and the fundamental differences between what it takes to make a sealskin coat to a rabbit fur coat. 

“Clubbing a seal is very different to snaring a rabbit,” he says. “That deep and multifaceted interactivity is possible when you simplify crafting down. If you think about Minecraft’s crafting grids they’re hard to remember, and Don’t Starve shows you a menu but it’s kind of arbitrary. It takes three stones plus two wood to make a hatchet and I always have to check the list again, even though I’ve been playing for hours. There’s something about step-by-step crafting that’s easy to remember.”

Still, Rohrer implemented an official wiki for One Hour One Life, which lists all its crafting recipes. “I don’t necessarily want-want-want there to be a wiki but at the same time I know it’s going to happen,” he says, recognising that players will need guidance on the game’s peculiarities. “I don’t see it as antithetical to what the game is about because once you know how to do something you don’t forget it, and knowledge is spreading inside the game.”

The way knowledge spreads is fascinating, partly down to the crafting system’s visual nature, partly to One Hour One Life’s chat system, and partly down to the challenges Rohrer has designed into the game. Players can simply watch a village’s customs and copy them, but they’re also able to send messages to each other. The amount a player can say depends on how old they are. Newborns can say only one letter (“F” is the established form for indicating hunger), while elderly characters can type out entire sentences.

“Some of the more successful villages are very organized,” says Rohrer. “As soon as you’re born they take you to a corner where there’s a fire and all these other babies. One woman is in charge of nursing them and there’s another elderly player there who’s in charge of teaching the babies the rules of the village. She asks, ’Do you know the three tenets of life in the village?’ There’s this system of only eating picked carrots, never from the field because the farmer is charge of that, and you’d be assigned a task when you’re of age. They pass down the mantle of responsibilities.”

“It’s much more interesting if there’s a hard failure, it’s a very dramatic turning point for the community if the well ‘done gone dry!’ That’s interesting, and if there isn’t a good way to recover from it players have to come together and have a culture around well usage.”

While they’re enabled by text and the game’s visual nature, these cultures are shaped by wrinkles Rohrer has placed in the game’s design to govern its survival systems and present challenges to sustaining civilization. Early on, he figured that the game couldn’t have limited food resources, since he couldn’t know how many players would be coming into any given area. But he soon saw playtesters relying entirely on the infinite berry bushes he’d added to prevent starvation, and never developing farming systems. Why bother when you have an easy source of food? So he limited many resources, such as milkweed plants, which die off if they’re harvested outside of their fruiting season, and wells, which are exhausted when they’re emptied.

“A lot of people ask to be able to repair or refill the well, but that’s not interesting to me,” Rohrer says. “It’s one weird trick you can use to recover from catastrophe and it becomes busywork. It’s much more interesting if there’s a hard failure, it’s a very dramatic turning point for the community if the well” – he puts on a hillbilly accent – “done gone dry! That’s interesting, and if there isn’t a good way to recover from it players have to come together and have a culture around well usage.”

He began noticing players starting to come up with ways of managing their wells, having someone keep track of them or using rocks to record how much had been extracted. The same went for an exploit players used to grow infinite carrots, and which led to a village surviving for 22 generations, which was the then longest-surviving. So he changed it, having carrots deplete soil fertility and introducing ways of restoring it.

“I want mistakes to accumulate over time to the point where the village can’t keep going. If you let a few too many carrots go to seed, which burns up fertile soil, you get too many seeds and run out of soil to seed them into and the village is on this road to ruin, eventually. I know it’s possible to have a village live forever, but it’s really hard and that’s what makes it interesting.”