MERTIS: Modifiable, Extensible, RealTime, Interactive Simulation

1
MERTIS Modifiable, Extensible, Real-Time,
Interactive Simulation Leandro Basallo ? Ryan
Leigh ? Sam Talaie ? Regan Snyderwith Dr. Sergiu
Dascalu and Dr. Fred Harris Department of
Computer Science, University of Nevada, Reno
ABSTRACT Game and simulation development is a
difficult process because it involves many low
level infrastructure concerns that need to be
addressed. This represents a barrier to
development for many inexperienced programmers
and distracts from pure game (and simulation)
design. MERTIS seeks to ease the development
process by reducing the design to the important
elements, removing software design from the
simulation design. This is achieved by using an
extensible scripting engine that allows all
elements of a simulation to be specified outside
the operation of the program and dynamically
loaded at run-time. The only foreseen limitation
at this time is that the graphics used in the
script will be two-dimensional.

• Future work
• An optimized resource handler for better
  management of objects in memory.
• An integrated development environment for
  creating and editing script files.
• Support for object inheritance.
• A library of Lua code for convenient reuse of
  common utilities and functions.
• Cross-platform compatibility so more users can
  create and run MERTIS simulations.
• Networking between clients in both peer-to-peer
  and client/server

FIGURE 1
FIGURE 2
FIGURE 3 -- LUA SCRIPT -- enemy
enemy.xPos 100 enemy.yPos 250 function
enemey.update() if( dist(player, enemy) lt 50 )
then move(enemy, player) else shoot(enemy,
player) end return xPos, yPos end /--- C CODE
---/ lua_pushstring(state, "enemy") lua_gettable
(state, GLOBALSINDEX) lua_pushstring(state,
"update") lua_gettable(state, -1) lua_pcall(stat
e, 0, 2, 0) int yPos lua_tointeger(state,
-1) int xPos lua_tointeger(state,
-2) lua_pop(state, 2)z
INTRODUCTION MERTIS is a tool that allows
development of games and simulations as quickly
as possible and as easily as possible. The user
can focus on game design and development, without
concerning himself or herself with the issues of
programming an entire game from scratch. MERTIS
is designed to handle all those issues
internally, and it serves as a palette for design
and creativity, rather than a palette for
technical skill and knowledge. Components such
as collision detection, AI, simple physics,
graphics rendering, and user input are all
accessible right from the MERTIS scripting
language. This is a simple, lightweight, and
friendly language that is as easy to learn as it
is to use. By removing all the burdens that lower
level languages have, there are fewer barriers to
creation.
FIGURE 1 Three main windows of MERTIS The code
tree, the display window, and the console FIGURE
2 MERTIS Use Case Diagram showing some of the
interactions FIGURE 3 A sample of Lua code and
accessing it with C code
Conclusion There is still much work to be done
in the development of MERTIS. The code that we
have generated in this semester required an
intense learning process. The first version of
MERTIS was strictly for proof of concept. It has
been shown that a fast, graphics engine for a
simple, lightweight scripting engine is possible
and that there is a lot of room for growth. The
first version has many errors and missed
opportunities for increased efficiency. Many of
the technologies and techniques used in the first
version were completely new to the members of the
team and with this newly gained experience these
technologies can be better utilized. For the next
version, the code will be rewritten with these
ideas in mind. The code will be better designed
to allow for future expansion, such as
networking. Also, we plan on writing an IDE that
will aid in the generation of scripts to take
even more of the load off of the user. As
development of scripts for MERTIS continues, a
library of functions and objects can be built
that could be shared to allow for reuse in code
design. Almost every game or simulation
designed re-invents the wheel in all the low
level design. MERTIS has proven that there can be
a unified low-end so only the actual game has to
be made. This should provide a gamut of new
material as now more people can create their
vision.
This project was developed in Spring 2004 as part
of the course CS 426 Senior Projects