Shusuke Okamoto

This letter proposes a prototyping tool for Web-based Multiuser Online Role-Playing Game (MORPG). The design goal is to make this tool simple and powerful. The tool is comprised of a GUI editor, a translator and a runtime environment. The GUI editor is used to edit state-transition diagrams, each of which defines the behavior of the fictional characters. The state-transition diagrams are translated into C program codes, which plays the role of a game engine in RPG system. The runtime environment includes PHP, JavaScript with Ajax and HTML. So the prototype system can be played on the usual Web browser, such as Firefox, Safari and IE. On a click or key press by a player, the Web browser sends it to the Web server to reflect its consequence on the screens which other players are looking at. Prospected users of this tool include programming novices and schoolchildren. The knowledge or skill of any specific programming languages is not required to create state-transition diagrams. Its structure is not only suitable for the definition of a character behavior but also intuitive to help novices understand. Therefore, the users can easily create Web-based MORPG system with the tool.

Over the last few years a great deal of interest has focused on a major paradigm shift in World Wide Web-based services referred to as Web 2.0. In marked contrast to the earlier Web, in Web 2.0 sites become sources of information and functionality that enable users to create new content of their own. Consequently, users are now looking for more versatile browsers that will let them edit and display content based on their own preferences. This motivated us to develop a state diagram-based Web browser programming scheme that supports the close interaction between the end-user and Web content. Using state diagrams to represent browser behavior is easier for end-users with little or no programming experience to grasp than text-based programming systems.

Assuming time-stamp servers that we can trust exist everywhere in the Internet, we propose a cheat-proof protocol for real-time gaming that has the minimum latency. The assumptions are: 1) Time-stamp servers are available near each player that issue serially numbered time stamps. 2) There is no communication break down between the player and the nearest time-stamp server. By this protocol, each player sends its own action to the other player and also sends its hash to the nearest time-stamp server. The time-stamp server sends back to the player the signed hash with time and a serial number involved. The signature is an undeniable evidence of the action. The actions are checked if they are compatible with the hashes and the signed hashes are checked if they have the correct time and if the serial numbers are contiguous. This verification can be done as a batch after the game is finished. The latency in this protocol is only the packet traveling time from a player to another.

A tool for authoring dynamical animations and video games is presented. The logical behavior of characters such as its internal feeling and icon images representing its appearance is described as finite state machines in terms of the state-transition diagrams. The physical behavior is controlled by plug-in modules that can be optionally incorporated into the main body. An example video game is also presented. Copyright 2006 ACM.

A tool for authoring interactive Flash movies is presented. Characters that play in a movie are modeled as object definitions in terms of state-transition diagrams. Each state has a picture and activities. The picture represents appearance of the character in that state. The activities can be selected out of a set of performances such as relocation of the character and generation of other characters. A transition is conditioned in terms of events such as mouse click and collision with other characters. The graphical editor of state-transition diagrams built in this tool is so easy to manipulate that even children can compose interactive Flash animations including video games. Copyright 2006 ACM.

A compromising technique is proposed for deterring clients from cheating by robot players in skill-based real-time network games. This technique is to inject a fair random noise into the manual input for a real-time game modeled as a chaotic dynamical system. The fair random noise is determined by means of the bit commitment protocol so that neither host nor client can control the noise in their favor. A scenario possibly plotted by a robot player for its victory may be spoiled by slight noise injection because of the sensitivity of chaotic systems to the input. The noise injection brings a luck-based factor into a skill-based game. In this sense, the technique proposed in this paper is not a solution but a compromise for the inherent problem of robot players with the skill-based network games. An example implementation of pinball is presented.

A compromising technique is proposed for deterring clients from cheating by robot players in skill-based real-time network games. This technique is to inject a fair random noise into the manual input for a real-time game modeled as a chaotic dynamical system. The fair random noise is determined by means of the bit commitment protocol so that neither host nor client can control the noise in their favor. A scenario possibly plotted by a robot player for its victory may be spoiled by slight noise injection because of the sensitivity of chaotic systems to the input. The noise injection brings a luck-based factor into a skill-based game. In this sense, the technique proposed in this paper is not a solution but a compromise for the inherent problem of robot players with the skill-based network games. An example implementation of pinball is presented. Copyright © 2005 The Institute of Electronics, Information and Communication Engineers.

This paper describes an implementation of our tool for authoring network-based interactive animations. The toot is named Islay. The interactive animation addressed in this paper is one of computer animations whose scenario is varied according to key and mouse inputs by viewers. An animation made by the tool is constructed as a collection of characters. The behavior of a character is defined by a state-transition diagram. The GUI editor makes it possible to create a simple animation by mouse manipulation within half a minute, if the prepared pictures are used. The animation interpreter in the tool serves multi viewers who operate each network-connected computer. The core routine of the interpreter runs on each viewer's computer in this case. The communication between the computers is implemented using our software DSM (Distributed Shared Memory) library. This paper shows the implementation details of the interpreter, as well as the brief overview of the rest of the tool.

Animations provide an efficient means for presenting information as practiced on modern Web pages. Interactive animations are especially attractive, because these can show variable scenarios according to key and mouse inputs by viewers. Author of an interactive animation is required of two different abilities. 0ne is the artistic imagination as ahy artistic work requires. The other is highly advanced knowledge and skill in programming and graphics. The latter requirement is a strong barrier for potential authors who have good imagination and no programming skills. In this paper, design and implementation of a tool for authoring interactive animations are reported. To make it intuitively comprehensible for non-programmers, the modern paradigm of object-oriented modeling and the classical state-transition diagram are employed. An animation is constructed as a collection of characters. Behavior of each character is specified by a state-transition diagram and pictures to express its appearance. The tool consists of GUI editors for diagrams and pictures, a built-in interpreter to test the animation, and a translator into target codes including Java and JavaScript. The translation mechanism keeps the coherency between diagrams and target codes, by utilizing inner classes in Java and function pointers in JavaScript. As a side effect, the present tool works also as an educational material for enlightening children on computer science. They may learn how to define dynamical objects while having fun with animations.

This paper describes a new moving home method for home-based software Distributed Shared Memory systems and its evaluations. In our system, a home node uses records for access to the shared page to determine the moving its role of home. Each time a home node receives a service request for the shared page from a non-home node, it records the node ID and the type of access. If the number of the access records exceeds the threshold of request counts, the home node decides whether the non-home node which sends the request is suitable for a new home node of the page. To evaluate our moving method, we have implemented a, prototype of DSM system from scratch. The result of our performance evaluation, using SPLASH2 benchmark programs shows that our method improved the performance of the system by 2.25 times over the fixed home node method.

This paper describes a moving home method for home-based software Distributed Shared Memory systems. In our system, a home node uses records for access to the shared page to determine the moving its role of home. Each time a home node receives a service request for the shared page from a non-home node, it records the node ID and the type of access. If the number of the access records exceeds the threshold of request counts, the home node decides whether the non-home node which sends the request is suitable for a new home node of the page. To evaluate our moving method, we have implemented a prototype of DSM system from scratch. The result of our performance evaluation using SPLASH2 benchmark programs shows that our method improved the performance of the system over the fixed home node methods.

Requirement for fast database accesses has been larger and larger. Although great efforts have been made to process database operations, these attempts seem. not to be efficient. Parallel data transmission is a critical factor for achieving high performance of database systems. Program, controlled cache level memory has powerful parallel data transfer mechanism, and it can help parallel data transmission efficiently. This paper describes the algorithm for join operation on relational database for multi-processor with program. controlled cache level memory.

This paper describes a program controlled instruction fetching mechanism, which is called the Fetch Instruction Method. In this mechanism, the special instruction to control instruction fetching are inserted into programs. They are processed in parallel with the other types of instructions. The results of performance evaluations show that many of branches are processed in parallel, and the performance is more improved by only increasing the number of fetched instructions per clock cycle.

We previously proposed a Program Controlled Cache Level Memory on Parallel Computer. It can migrate data between high speed memory as fast as cache memory and NUMA-type shared memory by data transfer program. Program Controlled Cache Memory is composed by a word-addressable high speed memory (Cache Level Memory) and a hardware mechanism which executes instructions to migrate variable sized data. Program Controlled Cache Memory can reduce the processor stall time by network busy. Because cache line sized data, transfer brings unnecessary network traffic and waste of cache. But variable sized data transfer, instead of cache line sized, makes network traffic minimize, and injecting indispensable data into Cache Level Memory brings no waste of Cache Level Memory. To work Program Controlled Cache Level Memory efficiently, programmers and compiler writers mast transform the application so that its memory referencing behavior better exploits the memory hierarchy. This paper describes how programmer can improve memory performance through three well known communication optimizations, such as communication. pipelining, communication combination, and communication overlapping, on Program Controlled Cache Level Memory. We also provide an optimizing example which has data distribution buys. The statistics of Mem-Spy produce useful information to optimize program for Program Controlled Cache Level Memory.

Instruction fetching is usually the default action related to the program counter, and it is affected by the execution of a branch instruction. However, the processor does not know about the timing of branch until it fetches a branch instruction. And it must start processing the branch just after fetching a branch instruction. Hence this situation causes control hazards. To solve this problem, we are engaged in studies on the controlling the instruction fetching. And we have developed a new mechanism as the first solution. In this mechanism, instructions to control instruction fetching are inserted into programs. The processor can identify these without decoding, and it processes in parallel with the other instructions. This paper describes the instruction set architecture of this mechanism, and describes its performance evaluation using software simulator.

PN processor is the one of small parallelism computing processor which executes a parallel program scheduled statically. A program for PN processor consists of a few threads whose instructions are arranged with its function. And the possibility of parallel execution is presented explicitly by specifying all of data dependencies. In the early design, the instruction fetch mechanism of the PN processor was idealized. So we have introduced a new instruction fetch mechanism into PN processor. This paper describes the basic design of this new instruction fetch mechanism as well as an execution trace example.

We propose a new hierarchical memory system. In this memory system, two extra programs transfer the data among any hierarchical memories by one word. This System makes cache like memory utilization better than conventional cache memory systems, because the data which application programs just need are transfered to upper level memory. Simple bench-marks show that this system can execute the application programs 1.76 times faster than conventional cache memory systems.