brianfeaster / worldtm Goto Github PK

The terminal and window class needs to support resizing and repositioning
functions.  Once done, resizing the actual terminal, addressed in r2,
should result in World windows resizing and repositioning themselves to
match the new real terminal constraints.

When drawing to windows, the same character/attribute should not be drawn on 
top of itself.

The map agent agent directly evaluates all incoming messages.  This is insecure 
and vestigial behavior originates from the initial IPC prototype.

The user agent's IPC dispatcher validates all incoming messages first.  This 
behavior should be applied to the map agent as well.

Implement lighting in the World renderer.

All World entities are currently modeled as a single cell.  Entities will 
initially be enhanced to allow statically arranged multi-celled objects.  
Eventually mutable cell count and random cell arrangements will be implemented.

An implementation of Pong will require paddles implemented as a multi-cell 
avatar in the shape of a long movable block.  Movement, collision, and 
rendering details will be addressed during Pong development.

There is an issue with World Scheme that is triggered randomly when World 
starts up.  It occurs during the initial map loading and rendering.

The bug needs to be identified and a regtest created which will trigger the 
issue.

No user state is stored beyond the immediate world process.  Users will be 
allowed to register themselves which will keep track of at least the following:
 * login/password
 * chat color
 * last avatar location
 * window layout
 * flags

The following state will be experimental:
 * chat history
 * not-chat messages or logs
 * items (World objects cell based or logical [unimplemented])

Map data from the past ten years should be migrated.

The current IPC topology implements a tree structure.  For each node in the 
tree, messages are received then rebroadcast to the other connected nodes.

If a World instance hangs, it's port remains used but not released.  Further 
World instances are no longer able to communicate with nodes on ports below the 
unreleased port.  A star topology should alleviate this issue for now.

comp.c::compVectorVectorRef needs argument count checks.


Evaluating (make-vector-vector 20) halts with a cryptic message ERROR::(9a30b 
9a30b).


The following class definition has semantic errors which, when cause an 
exception as column defaults to null.  The error reported should report the 
variable along with its environment hierarchy in a useful manner.
(define (Class)
  (define (column) ...)
  (define (fun)
    ; Since letrec, call to column is really a
    ; call to undefined letrec var.
    (letrec ((column (column)))...)))

To replicate create an interrupt handler, call sleep then send the interrupt:

(vector-set! SIGNALHANDLERS 2 (lambda () (display 'interrupt) (unthread)))
(signal 2)
(begin (sleep 10000) (display 'DONE))

Hitting ctrl-c will result in "^CinterruptDONE" being displayed.

World Scheme lacks unbounded signed integers.

World Scheme is heavily dependent on the Linux 32 GCC environment. 
Supporting Linux 64 is necessary now as World now resides on a virtual
64bit Linux server.

World is strongly coupled with map data and other files used to create the 
current environment on the development server.  Once the code base stabilizes, 
a minimal configuration and set of data files should be created and included 
with the distribution.

The goal of this issue to facilitate distribution and configuration of the 
World project to other servers.  A "Moon[tm]" environment will be created, 
configured and run independently from the current World[tm] server.  This 
process will be streamlined over time.

Implement a movie or play in World where actors will perform a play or movie.

No design document exists save for brief descriptions in the initial comments 
in each module.

There should be an overall design document as well as sub documents for each 
module.

The window objects do not support a buffer larger than the window size nor does 
the window keep state after resizing.  A history buffer needs to be implemented 
facilitating a scrollable message window.

Currently avatars can be positioned anywhere by moving in one of 8 planar 
directions and two vertical.  Since World is supposed to be a simulation of 
reality, I need to implement gravity along with a few other related actions:

Step climbing
Slope scaling
Jumping
Falling
Floating?

Accelerated terminal scrolling is not occurring in some windows due to an 
incorrect 'VisibleCount' member variable in the window object which tracks the 
number of visible characters.  It is used in the "hardwareScrollable?" method.  
The following cases must be considered when updating this variable:

 * Dominate window movement and order shift
 * Movement within and beyond the terminal boundaires
 * Shifting window order (not yet implemented)

A subordinate window motion or shifting will not affect a dominate window's 
VisibleCount.

World crashes a lot.  When it does little information is given to the user
besides a cryptic shell error message and line number.  World Scheme should
handle graceful exceptions or runtime errors by printing, at least, the
following information:

* The current running thread's call stack which includes the pre-compiled
expression string of each frame.

* Active threads and their pre-compiled expression strings.

* Virtual machine register values and current heap dump. This might be
overkill as it may be very large and so may be written to a local file instead.

World entities are mainly controlled by connected users.  A richer environment 
requires more autonomous entities.  An Scheme environment to facilitate the 
development of independent entities is required.

What steps will reproduce the problem?
1. There
2. aren't
3. cats

What is the expected output? What do you see instead?
cats.                        no cats!

What version of the product are you using? On what operating system?
meow?

Please provide any additional information below.
*hisss*

There are many control characters in the source like raw escape and tab 
characters.  These should be converted to their portable ASCII equivalent.

A new compiler stage will be added that translates an s-expression into a 
tagable s-expression.  Initially this will be used to include sub expression 
type info.

The first benefit will be used to determine if a combination expression should 
be compiled generically or completely inlined.  A let expression gets compiled 
to a lambda expression plus arguments.  The code emitted can be a single block 
that evaluates the arguments, extends the environment, and evaluates the body.  
Currently all procedure applications are compiled into two blocks:  The 
separate generic closure block and the inlined application code.

When an avatar walks beneath a cell or area of cells, the avatar and cells 
below the "ceiling" height should be visible.

This should solve rendering of multilevel structures or subterranean areas.  A 
building's roof will be visible unless the avatar walks inside revealing the 
contest of the room instead of the top most ceiling cells.

This will be implemented in two stage.

(1) The initial algorithm will be to determine the height, if any, of the 
closest cell directly above the avatar and to use that starting height when 
scanning down each column for the visible canvas cell.  The entire canvas 
region will be affected.

(2) The next algorithm will do this but only for cell related to the local 
region or enclosure.

Create an IRC interface.

File I/O is not entirely implemented. It is possible to open and read/write an 
existing file but a new file can't be opened.

I/O based on local file descriptors as well as standard I/O file pointers are 
used.  I/O related code needs to be cleaned up and homogenized.

File and socket I/O unit tests need to be created.

Often a scheme error will crash during the error handler while it dumps the 
environment and stack.  The atom serializer overuses the stack.  World Scheme 
should catch this and increase the stack count during runtime or a garbage 
collection.

The terminal class, which models the overall character terminal as well as
one or more separate windows, contains many synchronization and race
condition issues.

I did not develop it with a multi-threaded environment in mind.  It was
originally just a proof of concept.  The concept has been proven and a more
robust implementation is now in order.

This needs to be done soon because World[tm] is not stable.

Semaphores in World Scheme are simple integers returned by open-semaphore.
 The kernel resource must be explicitly freed with close-semaphore.  A
semaphore object should be created instead so the World Scheme kernel can
better keep track of their use and removed when no longer needed.

A recent bug in World's text window module was caused by window semaphores
not being explicitly deleted when the window was destroyed.  Scheme's
inherit methodology is for the programmer to be burdened as little as
possible with resource allocation.  Just as memory used by scheme objects,
files and sockets are claimed by the garbage collector, so should semaphores.

Run-time debugging of World Scheme code is difficult and error messages
don't reveal much.  Internal virtual machine instruction blocks should keep
track of the original pre-compiled scheme expressions.  This will allow
run-time error messages to reveal the compiled code as well as the original
scheme.

What steps will reproduce the problem?
1. Resize the terminal used to connect to World[tm].

What is the expected output? What do you see instead?

The talk and map windows render incorrectly from now on.  Only until you 
resize the terminal to the original connection size do things render 
properly.

Please use labels and text to provide additional information.

Originally World assumed 16 color terminals.  256 color escape sequences are 
supported now but fail to render correctly on 16 color terminals.  The default 
escape sequences to change color should initially be set to the 16 color 
variety.  256 color codes can be enabled on a per-client basis.

World map development will assume 256 color.  A mapping from 256 to 16 will be 
created.  The 256 color palette should require no change.

Results of a cursory code review by dcoker:

(1) Verify World Scheme runs clean under valgrind
(2) Spaces on either side of every binary operator
(3) Remove dead code
(4) Unit tests with 90% or better test coverage
(5) Line length should be limited to 80 or 120 cols

Unit tests should be implemented for the following modules:

scanner
mem
obj
vm
comp
asm

World requires a 3d engine.  Simple dungeon rendering will be used initially so 
a non-scrolling ray-casting will suffice.  Features timeline:
 * Terminal rendering device
 * 2.5D
 * Smooth scrolling
 * Z-buffer
 * Sprites
 * 3D

Implement a quick and dirty mouse even handler.

When a mouse click is detected, walk avatar in a straight line to the mouse 
click in the map.

The current compiler, which translates Scheme at runtime into the virtual 
machine's RTL ,is very basic and non expandable.  It will be replaced by a 
proper compiler module and optimizing infrastructure.

Optimized code blocks could become invalidated after expression or variable 
mutation should be handled by recompiling at runtime.  Example:
(define fn +)
(define (fun x y) (fn x y))
(set! fn -) ; Cause fun's code block to be recompiled if fn was inlined
(fun 5 3)
=> 2