An Architecture For Domain-Independent Collaborative Virtual Environments Ahmed BinSubaih Steve Maddock Daniela Romano Department of Computer Science Regent Court, 211 Portobello Street Sheffield, S1 4DP, UK Email: a.binsubaih, s.maddock, d.romano@sheff.ac.uk ABSTRACT The increase of computing power and its wide availability has raised interest in the use of Collaborative Virtual Environments for training purposes. Nevertheless, many of the currently developed training simulations are inflexible and support only a limited number of scenarios, often limited to a single domain. This work aims to investigate the challenges of separating the domain logic from the system using it. The work presented in this paper proposes to achieve the above by separating the architecture into three parts: domain knowledge, simulation environment and events space which links the previous two. The domain knowledge holds the scenario logic or behaviour which dictates how the scenario should run. The simulation environment is where participants meet and interact. The events space links the two parts by using the domain knowledge to control the scenario running in the simulation environment. By formulating our system in this manner we attempt to achieve the flexibility pursued and identify and tackle the challenges involved. Keywords Collaborative virtual environment (CVE), knowledge-base systems (KB), architecture, events INTRODUCTION A number of virtual environments (VEs) and collaborative virtual environments (CVEs) have been developed over the years, looking at such things as training firefighters (Romano 2001), police officers (Williams 1995) and navy personnel (Hamman et al 2001a), and the reconstruction of traffic accidents from textual reports (Akerberg et al 2003). The main issue with such systems is that they are domain dependent, which makes it difficult to reuse their simulation systems on different domains without extensive work. However, this is an expensive and time-consuming process. As identified in (Dachselt 2001) domain specificity in system development leads to highly inflexible applications. Our work investigates how the disciplines of distributed environments and expert systems can be combined in an attempt to achieve the separation required which we believe leads to a domain-independent architecture. From distributed environments we investigate the suitability of events as a communication mechanism between the simulation environment and the events space. From expert systems we examine the applicability of using knowledge-base systems (KB) to store and inference the domain knowledge which is used to control the scenario. One of the major contributions of this paper is introducing an events space which is an intermediary between the scenario logic and the simulation environment. Using such an intermediary should result in decoupling the scenario logic from the simulation environment which confers several advantages: The logic and the simulation environment can be modified entirely independently allowing iterative development cycles. The decoupling encourages encapsulation and other good object- oriented coding practices. It enables interoperability between distinct simulation environments, a practice promoted by the High Level Architecture (HLA) (Smith 1998). Although HLA promotes interoperability, its object management allows the subscription and discovering of remote objects thus violating the space decoupling 1 . Further concerns of the HLA are covered in (Davis and Moeller 1999) The three different parts (KB, events space, and simulation environment) can be individually tailored to the expertise and computer literacy of their users (domain experts, trainer, and trainees). Furthermore, the events space attempts to achieve the following goals: Automatic generation and control of scenarios for training purposes. Use the ability of KB systems to provide explanation of solutions to guide trainees during simulation sessions. The inherent distributed nature of a CVE and the existence of many different techniques for communication, such as the events mechanism with its decoupling ability (Drew et al, Eugster et al 2003), have encouraged us to attempt the separation on a collaborative virtual environment rather than on a VE. In this paper, we first describe the related work, followed by a detailed presentation of the proposed architecture where we show the different structures and how they communicate to achieve the independence sought. Finally, we illustrate the first prototype developed by showing its ability to run two distinct scenarios: investigating the aftermath of a vehicle accident situation and virtual lecturing. RELATED WORK In this section we describe the methods used to structure simulation environments and categorize them with regards to the relationship between them and the scenario logic. Such categorization examines this relationship in terms of the communication approaches employed to control the scenario logic and the flow of the scenario logic from its source to the simulation environment. We can consider the following different categories based on the relationship between the scenario logic and the simulation environment: applications, virtual development environments, commercial software environments, and KB systems. Certain applications (Romano 2001) tend to embed the scenario logic inside the simulation environment code and most likely changes to the logic require recompiling the simulation system. Other applications (Akerberg 2003, Hamman et al 2001a, Williams 1995) attempt to give some ability to modify the logic without recompiling, thus eliminating the developers involvement in the scenario creation cycle. This is accomplished by providing ways for the domain experts or trainers to insert the logic into the simulation environment. However, these applications are usually very domain dependent. 1 Space decoupling (Davis and Moeller 1999)