The program is designed to be a First or Third Person
3D environment simulation. The overall design of the
program is to start the user at a login screen which at
the least takes the users desired "handle" for in game
use and possibly has a list of valid username/password
combinations. After logon the program enters the
simulation mode.
During simulation mode the user needs to be shown the
world environment. Player information/statistics needs
to be readily seen. Deeper options for the simulation
can be hidden in a menu.
Most of the user interface in simulation mode needs to
be pictorial. The user does not need gobs of text to try
to explain the current important simulations states.
Initial functionality should mainly include multiple
persons in the same environment. Secondary
functionality should perhaps include objects that
interacts with the environment and/or players.
There should be a method to change the system from a
first person perspective to a third person camera that
is directly above the person. The first person mode is
for inspecting buildings and looking at more distant
objects. The third person mode is to look at terrain in
detail and for positional information (Idea Ref.: Radar
in BZFlag).
The terrain I have in mind is an open ended terrain
that is contain in a two dimensional array. Each index
in the array contains an altitude for the spot, and RGB
values for the color. There might be additional
information included if we want to take advantage of
OpenGL's ability to add specular, diffusion, ambient,
and shininess values to points. There should be other
structures that can be built on top of the height
terrain. The height terrain values can be built as a
level or real topographical and color data can be used
(See Hue McCoy for topographical data. Other sources
for satellite imagery? Is this looking like a FPS set
in Google earth?). The world drawing times should be
able to be kept quick by only asking the graphics card
to only process visible and near objects.
The system should have a server mode to facilitate the
use of multiple users in the environment. The client
should also be able to run in a single user mode for
demonstrations of the software. The server needs to
keep track of all movable objects (players, environment
objects) and broadcast the coordinates too all the
other players.
The application is a first or third person world
simulator. The user interface can be broken up into
either a separate menu/sim system or we can devise
methods of immediately putting the user in simulation
mode and letting them interact with the world to make
their preferences known.
Network system designed (Mid February)
Initial Networking working (client/server working) (late February, early March)
Final Networking support working (Early April
Graphics system designed (mid February)
Initial graphics working (rough world, not the final world) (early March)
Final Graphics interacting with the World (Mid April)
World interaction system design (Mid February)
World interaction system (mid April)
World interaction system tied to networking and graphics (late April)
The networking needs to support both a client server
and a standalone system for the world. The system
should have no inherent limitations to the number of
users. The final version of the networking should tie
to the World system to keep all the clients at the same spot
The graphics system needs to get directions from the
World system as to what should be drawn. There should
be a helper class that keeps track of the known objects
and how to draw them. The graphics for the early
release should only deal with solid objects with no
complicated lighting effects.
The World interaction system needs to take input from
both the user and the network section and keep track of
where all the pieces and the events that are happening.
As such this part may be the most complicated.
The world interaction system should be keeping track of
the items to be drawn and their positions and actions
so that the Graphics system know what to draw
The World system should communicate user motions and
user initiated actions (use items) to the networking
system so that it can tell the server and the other users.
The world needs to keep track of forces applied to
objects from both world forces (gravity) as well as
user forces (use items).
A networking class
Networking up and working
Authorization
Update of objects
Send our status
A graphics class
drawing static objects
drawing moving objects
A world class
Object positions
A physics class that helps determining positions
Summery: A user start the program and needs to register
a name for use while running the simulation. After the
program registers the user, the simulation starts
Steps:
User enters meaningful words into a box as a name while in the simulation.
User enters a starting point in the simulation
System authenticates/registers the user.
System starts the simulation
Preconditions: The user needs to be in simulation mode
Summery: The user needs a method of moving around in
the simulation. Keyboard input should give the user
control over their lateral movement.
Steps:
User presses desired key
System moves avatar in desired direction screen updates
Network system sends new character position
Preconditions: The user needs to be in simulation mode.
Summery: The user needs a method of looking in
different directions. Either a keyboard and/or a mouse
system needs to be used to change the direction of look.
Steps:
User moves mouse
System changes view screen updates
Network system sends new character position.
Preconditions: The system needs to be in simulation mode
Summery: The user needs items to interact and express
himself in the simulation. In this case the user needs
an ability to express himself at a distance to other
players and objects.
Preconditions: The system needs to be in simulation mode
Summery: The user needs to be able to manipulate
objects next to himself. There are two methods of
interaction. One is colliding with a movable object.
The second is using a modify key which applies an
action to the object.
Steps:
User runs into an object
System detects collision and determines if the object can move
System either moves the item of not,
Update positions if needed