Crafting game-models using reactive system design
Minh Thong Tran2008
Sign up for access to the world's latest research
checkGet notified about relevant papers
checkSave papers to use in your research
checkJoin the discussion with peers
checkTrack your impact
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. Among the advantages of this approach is the ability to use existing analysis tools to understand the game behavior at design time and run time, the ability to easily modify the behavior, and the use of visual languages to allow various stakeholders to be involved in early stages of building the game. Finally, we suggest integrating future games and game design methods into the emerging field of biological modeling, to which reactive system design has recently been successfully applied.
Related papers
Towards a Reactive Game Engine
Proceedings of the IEEE SoutheastCon 2019, Huntsville, Alabama, USA,, 2019
Developing new ways to improve game engines and enabling the creation of more accurate experiences is an important issue, especially for real-time applications such as Virtual Reality. As this technology has evolved, the gap between rendered frames has become smaller and environments have become more complex. As a result, mistakes can arise with regard to order-dependent events. Often these mistakes result in a temporarily unstable state in the environment, and may not be visible because of the time lapse between rendered frames. These errors are compounded by events which are not directly driven by the game engine, such as user movement and input. There is a continuous interaction between the user and the environment and the precise actions that user may take often cannot be predicted a priori.Reactive programming is a still evolving paradigm that has been employed in many different applications such as robotics and user interfaces. Our research presents a reactive, dependency-base...
An educational tool for implementing reactive systems following a goal-driven approach
Computer Applications in Engineering Education, 2012
This article presents a novel computer-based tool that has proven useful for students to both implement and validate the design of reactive systems using the Teleo-Reactive approach. The design and implementation of the tool and the proposed laboratory exercises are described. The tool, then, is a useful framework for tackling the synthesis of control systems for reactive systems. The results of the tests on efficiency with undergraduate students are also discussed.
Author's personal copy A formal approach for the development of reactive systems
This article appeared in a journal published by Elsevier. The attached copy is furnished to the author for internal non-commercial research and education use, including for instruction at the authors institution and sharing with colleagues. Other uses, including reproduction and distribution, or selling or licensing copies, or posting to personal, institutional or third party websites are prohibited. In most cases authors are permitted to post their version of the article (e.g. in Word or Tex form) to their personal website or institutional repository. Authors requiring further information regarding Elsevier's archiving and manuscript policies are
A novel paradigm for programming reactive systems centered on naturally specified modular behavior
sPeLLing oUT The requirements for a software system under development is not an easy task, and translating captured requirements into correct operational software can be even harder. Many technologies (languages, modeling tools, programming paradigms) and methodologies (agile, test-driven, model-driven) were designed, among other things, to help address these challenges. One widely accepted practice is to formalize requirements in the form of use cases and scenarios. Our work extends this approach into using scenarios for actual programming. Specifically, we propose scenario-coding techniques and design approaches for constructing reactive systems 28 incrementally from their expected behaviors. The work on behavioral programming began with scenario-based programming, a way to create executable specifications of reactive systems, introduced through the language of live sequence charts (LSC) and its Play-Engine implementation. The initial purpose was to enable testing and refining spe...
Modeling Biology using Generic Reactive Animation
2010
Complex biological systems involve incorporated behaviors of numerous processes, mechanisms and objects. However, experimental analysis, by its nature, divides biological systems into static interactions with little dynamics. To bridge the gap between experimental data and the underlying behavior, our group has been formalizing biological findings into mathematically and algorithmically rigorous specifications, which are then compiled into reactive models.
Reactive animation: From piecemeal experimentation to reactive biological systems
2011
Over the past decade, multi-level complex behavior and reactive nature of biological systems, has been a focus point for the biomedical community. We have developed a computational approach, termed Reactive Animation (RA) for simulating such complex biological systems. RA is an approach for describing the dynamic characteristics of biological systems based on facts collected from experiments.
BPjs - a framework for modeling reactive systems using a scripting language and BP
ArXiv, 2018
We describe some progress towards a new common framework for model driven engineering, based on behavioral programming. The tool we have developed unifies almost all of the work done in behavioral programming so far, under a common set of interfaces. Its architecture supports pluggable event selection strategies, which can make models more intuitive and compact. Program state space can be traversed using various algorithms, such as DFS and A*. Furthermore, program state is represented in a way that enables scanning a state space using parallel and distributed algorithms. Executable models created with this tool can be directly embedded in Java applications, enabling a model-first approach to system engineering, where initially a model is created and verified, and then a working application is gradually built around the model. The model itself consists of a collection of small scripts written in JavaScript (hence "BPjs"). Using a variety of case-studies, this paper shows ho...
Modeling Games for the 21st Century
A scientific framework is described in which scientists are cast as problem-solvers, and problems as solved when data are mapped to models. This endeavor is limited by finite attentional capacity which keeps depth of understanding complementary to breadth of vision; and which distinguishes the process of science from its products, scientists from scholars. All four aspects of explanation described by Aristotle--trigger, function, substrate, and model--are required for comprehension. Various modeling languages are described, ...
Specifying Reactive Systems through the Object-Process Methodology
1998
There is general consensus in the software and control systems literature that real-time systems are difficult to model, specify, and design. This is due to the fact that issues such as concurrency, synchronization between processes, and real-time constraints must be expressed. Since real time systems play a central role in many technological advents, it is an important and challenging task to develop an intuitive and easy-to-use, yet coherent and concise method for specifying such systems. The Object-Process Methodology (OPM) graphically specifies systems in a single unified model that describes the static-structural and behavioralprocedural aspects of a system. OPM/T is an extension of OPM for specification of reactive and real-time systems, which is capable of expressing temporal constraints, referencing events, and handling exceptions. In this paper, OPM/T is presented and demonstrated through the specification of a home heating system.
A formal approach for the development of reactive systems
Information and Software Technology, 2011
ContextThis paper deals with the development and verification of liveness properties on reactive systems using the Event-B method. By considering the limitation of the Event-B method to invariance properties, we propose to apply the language TLA+ to verify liveness properties on Event-B models.
Graphical Design of Reactive Systems
B'98: Recent Advances in the Development and Use of the B Method, 1998
Reactive systems can be designed graphically using Statecharts. This paper presents a scheme for the translation of Statecharts into the Abstract Machine Notation (AMN) of the B method. By an example of a conveyor system, we illustrate how the design can be initially expressed graphically with Statecharts, then translated to AMN and analysed in AMN, and then further refined to executable code.
Reactive Systems
2007
Formal methods is the term used to describe the specification and verification of software and software systems using mathematical logic. Various methodologies have been developed and incorporated into software tools. An important subclass is distributed systems. There are many books that look at particular methodologies for such systems, e.g. CSP, process algebra. This book offers a more balanced introduction for graduate students that describes the various approaches, their strengths and weaknesses, and when they are best used. Milner's CCS and its operational semantics are introduced, together with notions of behavioural equivalence based on bisimulation techniques and with variants of Hennessy-Milner modal logics. Later in the book, the presented theories are extended to take timing issues into account. The book has arisen from various courses taught in Iceland and Denmark and is designed to give students a broad introduction to the area, with exercises throughout.
Declarative Game Programming
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.
An object-oriented dual language for specifying reactive systems
1994
Descriptive software specification techniques are based on mathematical formalism and produce precise, rigorous specifications which are in general to be preferred for the design of reactive systems with respect to operational techniques. Recently, dual languages which tend to integrate these aspects have been investigated. An object-oriented specification dual language, named TROL is presented, it consists in an executable formal specification model which can be used for validation of reactive systems. TROL has the capability to describe the system behavior, its functionality and structural aspects. It allows one to describe the system at different levels of structural abstractions and specification details without boundaries among the specification steps. At each specification level, TROL helps the user in the verification of consistency, thus allowing incremental specification. TROL has a visual representation which has been supported by a CASE tool named TOOMS
Modeling reactive systems in Java
ACM Transactions on Design Automation of Electronic Systems, 1998
We present an application of the Java™ programming language to specify and implement reactive real-time systems. We have developed and tested a collection of classes and methods to describe concurrent modules and their asynchronous communication by means of signals. The control structures are closely patterned after those of the synchronous language Esterel, succinctly describing concurrency, sequencing and preemption. We show the user-friendliness and efficiency of the proposed technique by using an example from the automotive domain.
A reactive architecture for RoboCup competition
Lecture Notes in Computer Science, 1998
We illustrate PaSo-Team (The University of Padua Simulated Robot Soccer Team), a Multi-Agent System able to play soccer game for participating to the Simulator League of RoboCup competition. PaSo-Team looks like a partially reactive system built upon a number of specialized behaviors, just designed for a soccer play game and generating actions accordingly with environmental changes. A general description of the architecture and a guideline of main ideas is presented in the paper, whereas a more detailed description of actual implementation is given in the appendix.
Specifying control programs for reactive systems
… of the 1998 International Conference on Parallel …, 1998
BDL, a language of distributed reactive objects
Proceedings First International Symposium on Object-Oriented Real-Time Distributed Computing (ISORC '98), 1998
We introduce the de nition of a language of distributed reactive objects, a Behaviour Description Language (Bdl), as a uni ed medium for specifying, verifying, compiling and validating object-oriented, distributed reactive systems. One of the novelties in Bdl is its seamless integration into the Uni ed Modeling Language approach (Uml). Bdl supports a description of objects interaction which respects both the functional architecture of system designs and the declarative style of diagram descriptions. This support is implemented by means of a partial-order theoretical framework. This framework allows to specify both the causality and the control models of object interactions independently of any hypothesis on the actual con guration of the system. Given the description of such a con guration, the use of Bdl offers new perspectives for a exible veri cation of systems by modeling them as an asynchronous network of synchronous components. It allows an optimized code generation by using compilation techniques developed for synchronous languages. It permits an accurate validation and test of applications by supporting the manipulation of both causal and control dependencies. Bdl aims at maximizing the re-usability of high-level speci cations while minimizing programming e ort and test-case based validation of distributed systems. (R sum : tsvp)
Unimod: Method and tool for development of reactive object-oriented programs with explicit states emphasis
Modern software development processes usually outline phases of requirements gathering, design, coding and testing. Design phase outgoing artefact is system model, described with a help of diagrams and text. On coding phase, developers, using system model, implement system for target platform. There is a semantic gap between design and coding phases, because there's no formal relationship between system model and resulting program code. This paper describes method for development of reactive object-oriented programs, which resolves described problem. Method is based on SWITCH-technology and UML. For visual modelling purposes, UML editor was created as plug-in for Eclipse platform. Editor implements interactive model validation, errors highlighting, errors quick fixes, auto-completion of labels on diagrams, model execution in one click and model visual debugging,.
Loading Preview
Sorry, preview is currently unavailable. You can download the paper by clicking the button above.