In this paper, we present in-progress work that converts games made with Ceptre, a genre-agnostic game description language, into graphical games using the framework of operational logics. Our preliminary code targets the translation of tilemap-based dungeon crawlers, but we present strategies for generalizing this process to other Ceptre games and Asterism engines. We gesture at the potential of operational logics and Asterism as a tool to communicate across the many frameworks surrounding game development and playing.

Over the last few years, substantial progress has been made both in citation standards for interactive media and in technologies to support easy collection, reference, and sharing of citations of interactive works. We are developing a suite of software tools based on these emerging standards and are making them accessible to digital game scholars.

Video games are important cultural artifacts, but are made inaccessible to many people by aspects of their visual, audio, and mechanical design. Some game developers add accessibility features to new games, but without access to source code, accessibility supports cannot be added to existing games. In this work, we propose a general technique based on game object affordances and instantiate it for the specific case of supporting users with limited vision. Specifically, we show an example of a color modulation scheme for simplifying and increasing the clarity of in-game graphics based on user-provided annotations.

The Model AI Assignments session seeks to gather and disseminate the best assignment designs of the Artificial Intelligence (AI) Education community. Recognizing that assignments form the core of student learning experience, we here present abstracts of ten AI assignments from the 2019 session that are easily adoptable, playfully engaging, and flexible for a variety of instructor needs. Assignment specifications and supporting resources may be found at http: //modelai.gettysburg.edu.

We describe a new browser-based tool for analyzing the behavior of computational systems, with worked examples for the Atari 2600. Our tool, S4LVE (System State Sequence Search Language and Visualization Environment), consists of three main parts. First, we define a domain-specific visualization language tailored for understanding low-level memory operations. Second, we leverage a discrete time-series pattern matching language inspired by regular expressions to capture states and memory locations of interest. Third, we integrate these little languages with an intuitive, spreadsheet-based visual interface juxtaposed with a live emulator. This combined system supports both the incremental exploration of complex emergent systems and rapid iteration on new visualizations.

Design support tools benefit from rich information about games' emergent behavior. Inventing successful AI players for particular games can help producing some of this information, but this is both labor intensive and limited in that it can generally only reveal that a solution exists and not say that no solution exists or that certain classes of solution exist. We show a generic method for posing and answering feasible-path, optimal-path, and reachable-space queries in action games, and we devise a measure of game level difficulty. We accomplish all this by encoding action videogame characters as hybrid dynamical systems, using Flappy Bird and Super Mario as case studies.

While generative approaches to game design offer great promise, systems can only reliably generate what they can “understand,” which is often represented in a limited, implicit form in hand-crafted evaluation functions or constructive rules. Proceduralist readings, a semiformal approach for interpreting the meaning of a game based on its underlying processes and interactions in conjunction with aesthetic and cultural cues, offer a novel, systematic approach to game understanding. We formalize proceduralist argumentation as a logic program that performs static reasoning over game specifications to derive higher level meanings, as part of Gemini, a bidirectional game analysis and generation system.

Scholars who study games lack many resources and abilities taken for granted by scholars of other forms such as literature. To begin to address this deficiency, this paper presents a basic formalization for different classes of resources associated with game critical practices, and ties those resources to a prototypical system for their reference, generation, and use in game studies arguments. The formalization is focused on three forms of reference: objective reference to game objects, enacted reference to game performances, and internal reference to sub-structures within both. We operationalize our formalization with the Game and Interactive Software Scholarship Toolkit (GISST), a custom suite of tools that manage the reference and creation of game executable data, game performance video recordings, and game executable state from emulated programs. GISST provides tools for ingesting each class of reference and for the easy creation and citation of game play videos and emulated system states. For the last case, GISST allows for embedding citations to running game programs --- in emulation --- inside web browsers, and for their retrieval through URLs from a stable citation database. The goal is to point toward a new class of scholarly support tool for arguments about games and other interactive software that would benefit from the inclusion of audiovisual and executable references.

Game maps are useful for human players, general-game-playing agents, and data-driven procedural content generation. These maps are generally made by hand-assembling manually-created screen-shots of game levels. Besides being tedious and error-prone, this approach requires additional effort for each new game and level to be mapped. The results can still be hard for humans or computational systems to make use of, privileging visual appearance over semantic information. We describe a software system, Mappy, that produces a good approximation of a linked map of rooms given a Nintendo Entertainment System game program and a sequence of button inputs exploring its world. In addition to visual maps, Mappy outputs grids of tiles (and how they change over time), positions of non-tile objects, clusters of similar rooms that might in fact be the same room, and a set of links between these rooms. We believe this is a necessary step towards developing larger corpora of high-quality semantically-annotated maps for PCG via machine learning and other applications.

This paper expands on and refines the theoretical framework of operational logics, which simultaneously addresses how games operate at a procedural level and how games communicate these operations to players. In the years since their introduction, operational logics have been applied in domains ranging from game studies to game generation and game modeling languages. To support these uses and to enable new ones, we resolve some standing ambiguities and provide a catalog of key, fundamental operational logics.

Jumping has been an important mechanic since its introduction in Donkey Kong. It has taken a variety of forms and shown up in numerous games, with each jump having a different feel. In this paper, we use a modified Nintendo Entertainment System (NES) emulator to semi-automatically run experiments on a large subset (~30%) of NES platform games. We use these experiments to build models of jumps from different developers, series, and games across the history of the console. We then examine these models to gain insights into different forms of jumping and their associated feel.

All projects in AI begin by selecting or devising knowledge representations suitable for the project's functional requirements. Interactive systems (including games) have semiotic considerations on top of their functional requirements: they must be legible to users, players, and their own designers. AI working within or around interactive systems must acknowledge and support the concerns of human users. These concerns are generally phrased as inductive bias or domain knowledge and handled in an ad hoc way; I argue that it is possible and useful to represent them explicitly within a unifying approach. This work refines and extends operational logics, an interpretive framework describing how interactive systems communicate their own mechanisms to users. Making this move yields formal notations for interactive systems that are useful for humans and machines, with applications in modeling, verification, general game-playing, reverse-engineering, and automatic self-documentation.

We propose and evaluate a new technique for learning hybrid automata automatically by observing the runtime behavior of a dynamical system.Working from a sequence of continuous state values and predicates about the environment, CHARDA recovers the distinct dynamic modes, learns a model for each mode from a given set of templates, and postulates \textit{causal} guard conditions which trigger transitions between modes.Our main contribution is the use of information-theoretic measures (1)~as a cost function for data segmentation and model selction to penalize over-fitting and (2)~to determine the likely causes of each transition.CHARDA is easily extended with different classes of model templates, fitting methods, or predicates.In our experiments on a complex videogame character, CHARDA successfully discovers a reasonable over-approximation of the character's true behaviors.Our results also compare favorably against recent work in automatically learning probabilistic timed automata in an aircraft domain: CHARDA exactly learns the modes of these simpler automata.

Invariant discovery is one of the central problems in software verification. This paper reports on an approach that addresses this problem in a novel way; it crowdsources logical expressions for likely invariants by turning invariant discovery into a computer game. The game, called Binary Fission, employs a classification model. In it, players compose preconditions by separating program states that preserve or violate program assertions. The players have no special expertise in formal methods or programming, and are not specifically aware they are solving verification tasks. We show that Binary Fission players discover concise, general, novel, and human readable program preconditions. Our proof of concept suggests that crowdsourcing offers a feasible and promising path towards the practical application of verification technology.