Jagex

Finalised for 2016

Listening to a million voices

Earlier proposal

Listening to a million voices - visualizing player sentiment in Games Developers & publishers of online game services (such as RuneScape) value understanding what topics players are talking about, and how players feel about them, so that they can build better games. Your goal is build a solution which allows effective understanding of community sentiment from both forum-based & in-game free-text chat between players. You will create highly visual & intuitive near-real-time dashboards which utilize Natural Language Processing to provide an overview, alerts and drill-down visibility into the live sentiment of hundreds of thousands of players. You’ll need to think about how to disentangle multiple topics in free flowing conversational chat and how sentiment analysis can become adaptive and context aware, providing accurate analysis across multiple dynamic in-game scenarios. You’ll need to employ Machine Learning, Real-Time Big Data know-how and skillful UX design to deliver a product that will help us listen to our players and build better games.

Jagex would look to provide a sanitized, anonymized subset of chat data to give you a flavor for its nature. We could in theory annotate this with our own interpretation of sentiment, however we would prefer the IB team to approach this from afresh. In a final set-up, we would imagine the "live feed" of sentiment coming as an Apache Flume or Apache Kafka topic.

Further proposals

Sponsor: David Solari Email: david.solari@jagex.com

Full motion video adventure game engine and toolset:- This project is about creating an engine and tool set which allows video footage to be utilised for the production of adventure games. Film features would include cutting, arranging, linking, freezing, zooming, and digital items to be inserted in film, digital special effect insertion slow mo and time lapse. Game features would include, two way dialog, path selection, inventory, 360 camera control, nodal integration points and a quick time interaction system. Control interface features would include mouse and keyboard; mobile touch and VR gesture. A simple proof of concept demonstrating the engine and tools would be required.

Dynamic Narrative (Sponsor: Sean Storey, email: sean.storey@jagex.com)

In narrative lead games like Telltale’s The Walking Dead and The Wolf Amongst Us present the player with a multilinear narrative driven gaming experience driven by a decision based game engine.

Your goal is to take this to the next level, where the player can play several characters in any sequence which have all experienced the same event. Each decision made will have an impact on the game’s visuals, the positioning of props and dialogue options when playing with another character.

The focus should be on delivering a system architecture tool which allows you to track player decisions and alter the state of the game based on these. This allows an end user to plan their narrative structure during development and keep track on what knock-on effects the player’s decision have or do not have on the game itself.

Strategy Card Game Creator (Sponsor: Mark Killey, email: mark.killey@jagex.com)

Chronicle: RuneScape Legends is a new strategy card game based around an innovative core mechanic and experimental card systems. While The Strategy Card Game Creator would be the Super Mario Maker of the genre!

It would be a game in which someone can create their own collectable card game, either single or multiplayer and share it with their friends. A player needs to create their own ruleset, cards, card effects and obviously a name for the game itself, which is then submitted to a central server. Other people can then play the game, leave a rating and feedback. The creator of the game will be able to see this feedback plus other key metrics, such as how many people have played the game. Players will also need to be identifiable so there would need to be some form of account system. The key for success will be to provide an intuitive yet sophisticated system that allows people to easily create or modify rulesets and cards in which can sit innovative mechanics. On top of that there will need to a be an effective system to ensure there is a meritocracy where the best games are easy to find and play!

More appropriate to MPhil student: Flame charts

(Sponsor: Philip Bielby, email: philip.bielby@jagex.com)

Google Chrome and Mozilla FireFox have some excellent profiling frameworks that produce charts that show time on the X-axis, and what has been taking up that time against that. This is extremely useful when profiling games written in JavaScript. However, there is no readily available complete solution to do this for a game not written for the browser.

We would like to have a series of functions we can call from C++ to:

• Mark when a frame ends
• Record custom ‘method calls’ from game scripting languages
• Record other custom events

We would also like to record what is happening in our C++11 code without having to manually instrument everything (perhaps using a custom LLVM instrumentation pass or similar, although an idea that works on multiple compiler frameworks (e.g. MSBuild/VS2015, llvm, gcc) might be preferable (but tricky)). It might be wise to allow shorter running methods to be filtered out if the data-set is too large, however (which I imagine might require a buffering step).

This data could then be transferred to a web browser interface (perhaps using the trace-viewer framework from Google Chrome: https://github.com/catapult-project/catapult/tree/master/tracing), preferably using WebSockets or similar to allow online gathering of data in as simple a fashion as possible, so that you can simply press a ‘profile’ button in the game to start and a ‘stop’ button when you are done, and have the view update with the profiling data that was collected.

The display of data should

• Be as a ‘flame chart’, allowing the user to drill down to find exactly

what is happening and when

• Handle processing on different threads as separate charts, so

multithreaded behaviour can be seen clearly

• Highlight different types of event separately
• Show when frames end clearly

Possible extensions could involve adding events/instrumentation to track memory usage/allocation, or ideas regarding profiling of GPU utilisation.