Maria-Virginia Aponte

Measuring the level of difficulty in single player video games

Abstract In this paper, we discuss the interest and the need to evaluate the difficulty of single player video games. We first show the importance of difficulty, drawing from semiotics to explain the link between tension-resolution cycles and challenge with the player’s enjoyment. Then, we report related work on automatic gameplay analysis. We show through a simple experimentation that automatic video game analysis is both practicable and can lead to interesting results. We argue that automatic analysis tools are limited if they do not consider difficulty from the player point of view. The last two sections provide a player and Game Design oriented definition of the challenge and difficulty notions in games. As a consequence we derive the property that must fulfil a measurable definition of difficulty.

Scaling the Level of Difficulty in Single Player Video Games

In this this paper, we discuss the interest and the need to evaluate the difficulty of single player video games. We first show the importance of difficulty, drawing from semiotics to explain the link between tension-resolution cycles, and challenge with the players enjoyment. Then, we report related work on automatic gameplay analysis. We show through a simple experimentation that automatic video game analysis is both practicable and can lead to interesting results. We argue that automatic analysis tools are limited if they do not consider difficulty from the player point of view. The last section provides a player and Game Design oriented definition of the challenge and difficulty notions in games. As a consequence we derive the property that must fulfill a measurable definition of difficulty.

Type Isomorphisms for Module Signatures

This work focuses on software reuse for languages equipped with a module system. To retrieve modules from a library, it is quite reasonable to use module signatures as a search key, up to a suitable notion of signature isomorphism.

Extending record typing to type parametric modules with sharing

We extend term unification techniques used to type extensible records in order to solve the two main typing problems for modules in Standard ML: matching and sharing. We obtain a type system for modules based only on well known unification problems, modulo some equational theories we define. Our formalization is simple and has the elegance of polymorphic type disciplines based on unification. It can be seen as a synthesis of previous work on module and record typing.

Difficulty in videogames: an experimental validation of a formal definition

This paper synthetically presents a reliable and generic way to evaluate the difficulty of video games, and an experiment testing its accuracy and concordance with subjective assessments of difficulty. We propose a way to split the gameplay into measurable items, and to take into account the players apprenticeship to statistically evaluate the games difficulty. We then present the experiment, based on a standard FPS gameplay. First, we verify that our constructive approach can be applied to this gameplay. Then, we test the accuracy of our method. Finally, we compare subjective assessments of the games difficulty, both from the designers and the players, to the values predicted by our model. Results show that a very simple version of our model can predict the probability to the player has to lose with enough accuracy to be useful as a game design tool. However, the study points out that the subjective feeling of difficulty seems to be complex, and not only based on a short term estimate of the chances of success.

Une approche formelle de la reconfiguration dynamique

Self-adapting software adapts its behavior in an autonomic way, by dynamically adding, suppressing and recomposing components, and by the use of computational reflection. One way to enforce software robustness while adding adaptative behavior is disposing of a formal support allowing these programs to be modeled, and their properties specified and verified. We propose FracL, a formal framework for specifying and reasoning about dynamic reconfiguration programs being written in a Fractal-like programming style. FracL is founded on first order logic, and allows the specification and proof of properties concerning either functional concerns or control concerns. Its encoding using the Focal proof framework, enabled us to prove FracL coherence and to obtain a mechanized framework for reasoning on concrete architectures.

Towards the formalization of SPARK 2014 semantics with explicit run-time checks using coq

We present the first steps of a broad effort to develop a formal representation of SPARK 2014 suitable for supporting machine-verified static analyses and translations. In our initial work, we have developed technology for translating the GNAT compilers abstract syntax trees into the Coq proof assistant, and we have formalized in Coq the dynamic semantics for a toy subset of the SPARK 2014 language. SPARK 2014 programs must ensure the absence of certain run-time errors (for example, those arising while performing division by zero, accessing non existing array cells, overflow on integer computation). The main novelty in our semantics is the encoding of (a small part of) the run-time checks performed by the compiler to ensure that any well-formed terminating SPARK programs do not lead to erroneous execution. This and other results are mechanically proved using the Coq proof assistant. The modeling of on-the-fly run-time checks within the semantics lays the foundation for future work on mechanical reasoning about SPARK 2014 program correctness (in the particular area of robustness) and for studying the correctness of compiler optimizations concerning run-time checks, among others.