Towards a Reactive Game Engine

Proceedings of the 2007 ACM symposium …, 2007

… of the “Virtuelle …, 2007

Functional Reactive Programing (FRP) is a new paradigm whose use has evolved in many different fields, such as robotics and user interface. FRP was originally developed as a programming paradigm to handle animation. It has since been used as a replacement for the Observer pattern in systems that require order and accuracy when handling large numbers of callbacks. Inaccuracy and ordering issues related to callbacks can negatively affect a user's experience when using a virtual environment (VE). This paper describes several implementations of FRP in order to determine the most suitable library for use with Unity for handling the dynamic interactions between the engine and the sensors and actuators that allow users to interact with the Virtual Environment. An assessment model determined from Bainomugisha et al [1] is used to compare language and then reach a conclusion. The implementation chosen is used on a test environment to confirm the theoretical benefits in practice.

2008

Abstract This paper presents a game-model of a gym training system, where the behavior of the system is specified using languages developed originally for reactive system design, which drive a game engine. The approach makes it possible to describe behaviors of different parts of the system using different reactive system design languages and tools. It thus provides a framework for integrating the model behavior to obtain an executable game-model of the entire system.

Sigplan Notices, 1997

Fran (Functional Reactive Animation) is a collection of data types and functions for composing richly interactive, multimedia animations. The key ideas in Fran are its notions of behaviors and events. Behaviors are time-varying, reactive values, while events are sets of arbitrarily complex conditions, carrying possibly rich information. Most traditional values can be treated as behaviors, and when images are thus treated, they become animations. Although these notions are captured as data types rather than a programming language, we provide them with a denotational semantics, including a proper treatment of real time, to guide reasoning and implementation. A method to e ectively and efciently perform event detection using interval analysis is also described, which relies on the partial information structure on the domain of event times. Fran has been implemented in Hugs, yielding surprisingly good performance for an interpreter-based system. Several examples are given, including the ability to describe physical phenomena involving gravity, springs, velocity, acceleration, etc. using ordinary di erential equations.

2004

We describe a new approach to the behaviour of 3D environments that supports the definition of physical processes and interactive phenomena. The work takes as a starting point the traditional event-based architecture that underlies most game engines. These systems discretise the environments' Physics by separating the objects' kinematics from the physical processes corresponding to objects interactions. This property has been used to insert a new behavioural layer, which implements AI-based simulation techniques.

Communications of the ACM, 1997

2004

System and method for generating reactive animation, providing a generic link between tools for graphic animation, by operatively linking the representation of an event driven system in conjunction with an event driven engine to an animation engine to generate reactive animation.

Eurographics, 1995

Behavioural models o er the ability to simulate autonomous entities like organisms and living beings. Such entities are able to perceive their environment, to communicate with other creatures and to execute some decided actions either on themselves or on their environment. Building such systems requires the design of a reactive system treating ows of data to and from its environment, in a complex way needing modularity, concurrency and hierarchy, and involving task control and preemption. Accordingly, in this paper we address the adequateness to the decisional part of the behavioural model of the following programming paradigms: reactivity, concurrency, data-ow and hierarchical preemption. The reactive languages provide users with complete design environments (including graphical tools for designing, simulating, implementing and formally verifying) for such systems. The speci cation of concurrent behaviours is naturally supported in the synchronous languages, and some of them are more suited for control-intensive applications (sequencing and preempting tasks), while others address computation-intensive applications (data-ow). SignalGT _ is an extension of the language Signal where data-ow processes can be composed into nested preemptive tasks. An application in the simulation of a transportation system shows how these programming paradigms can be of use, and how SignalGT _ can support their implementation.

2007

This technical report describes in detail a specific mechanism for linking any number of tools, including an animation tool and reactive system engines of different kinds. We illustrate the technique and the underlying principles by linking up the Rhapsody tool, which supports statecharts and object diagrams, and the Play-Engine, which supports live sequence charts (LSCs), to 3D Game Studio (3DGS) for animation and MATLAB for mathematical analysis.

ACM Computing Surveys, 2013

Reactive programming has recently gained popularity as a paradigm that is well-suited for developing event-driven and interactive applications. It facilitates the development of such applications by providing abstractions to express time-varying values and automatically managing dependencies between such values. A number of approaches have been recently proposed embedded in various languages such as Haskell, Scheme, JavaScript, Java, .NET, etc. This survey describes and provides a taxonomy of existing reactive programming approaches along six axes: representation of time-varying values, evaluation model, lifting operations, multidirectionality, glitch avoidance, and support for distribution. From this taxonomy, we observe that there are still open challenges in the field of reactive programming. For instance, multidirectionality is supported only by a small number of languages, which do not automatically track dependencies between time-varying values. Similarly, glitch avoidance, wh...

LiveWorld is a graphical environment designed to support research into programming with active objects. It offers novice users a world of manipulable objects, with graphical objects and elements of the programs that m,ake them move integrated into a single framework. LiveWorld is designed to support a style of programming based on rule-like agents that allow objects to be responsive to their environment. In order to make this style of programming accessible to novices, computatiomd objects such as behavior:il rules need to be just as concrete and accessible as the graphic objects. LiveWorld fills this need by using a novel object system, Framer, in which the usual structures of an objectoriented system (classes, objects, and slots) are replaced with a single one, the fratne, that has a simple and intuitive graphic representation. This unification enables the construction of an interface that achieves elegance, simplicity and power. Allowing graphic objects and internal computational objects to be manipulated through an integrated interface can provide a conceptual scaffolding for novices to enter into progmmming.

Mta, 1999

This paper explores the idea of reactivity in multimedia, and proposes systems which can react to continuously-evolving behaviours as well as to more traditional discrete events. The idea is presented in a scenario as well as in a number of small programming examples.

2003

Abstract. This paper explores the idea of reactivity in multimedia, and proposes systems which can react to continuously-evolving behaviors as well as to more traditional discrete events. The idea is presented in a scenario as well as in a number of small programming examples. The illustrative examples are written in the Fran system. Fran provides a high-level programming model for animations, built in the Haskell functional programming language.

Proceedings of the 16th International Symposium on Principles and Practice of Declarative Programming - PPDP '14, 2014

Video games are usually not programmed very declaratively. There are a number of reasons for this, from low-level efficiency concerns, via the nature of commonly employed programming languages, libraries, and frameworks, to the conceptual nature of such games, with state and effects being omnipresent. However, by structuring games in terms of time-varying values and transformations on such values, it is possible to design and implement video games in a more declarative way. This tutorial shows how this can be achieved through Functional Reactive Programming (FRP) by implementing the high-level parts of a 2D game akin to the classical game Breakout. The tutorial uses the Haskell-embedded FRP implementation Yampa and bindings to SDL (Simple DirectMedia Layer) to obtain game play and visual standards typical of the 2D genre; for example, as seen in many currently popular games for smartphones and tablets.