ReMooD Mercurial

338 lines (263 with data), 12.5 kB

        :oCCCCOCoc.
    .cCO8OOOOOOOOO8Oo:
  .oOO8OOOOOOOOOOOOOOOCc
 cO8888:         .:oOOOOC.                                                  TM
:888888:   :CCCc   .oOOOOC.     ###      ###                    #########
C888888:   .ooo:   .C########   #####  #####  ######    ######  ##########
O888888:         .oO###    ###  #####  ##### ########  ######## ####    ###
C888888:   :8O.   .C##########  ### #### ### ##    ##  ##    ## ####    ###
:8@@@@8:   :888c   o###         ### #### ### ########  ######## ##########
 :8@@@@C   C@@@@   oo########   ###  ##  ###  ######    ######  #########
   cO@@@@@@@@@@@@@@@@@Oc0
     :oO8@@@@@@@@@@Oo.                               1.0a "Stuffed Cabbage"
        .oCOOOOOCc.                                      http://remood.org/

 ReMooD is a source port of Doom Legacy 1.42. It aims to provide the classic
 Legacy Experience with new features and more stability.
 
 Copyright (C) 2011-2013 GhostlyDeath <ghostlydeath@remood.org>
 
 This program is free software; you can redistribute it and/or
 modify it under the terms of the GNU General Public License
 as published by the Free Software Foundation; either version 3
 of the License, or (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
-------------------------------------------------------------------------------

#### BEGIN ACTUAL TODO LIST ###################################################

These are the following things that need to be done to progress: When done
mark as completed, too bad there is no ASCII checkmark.

 * p_saveg.c:	Implement dependency based savegames with save chunk
 				registration. Basically, in initialization functions, a handler
 				will be registered which will write the specific chunk. That
 				chunk will then depend on other chunks. Dependencies will be
 				calculated, and during a game save the chunks will be in any
 				dependent order, and the handler passed at registration will be
 				called. This way, save games can have slightly out of order
 				chunks along with leaner save game code (as it can be placed
 				else where in the source code) along with easier version
 				handling.

 * d_main.c:	Do major cleanup of this, this is just a gigantic unorganized
 				mess of code that does everything.

 * console.c:	Split UI Console related functions (drawing) away from this into
 				a new file which handles all the drawing operations.

 * i_utlnet:	Rewrite native socket code to be a bit more OO and to handle
 				multi-cast better rather than the current hack.
 				Also remove the forests of #ifs

 * f_finale:	RMODize the code or use another special proprietary format to
				define the finale cast.

 * v_widget:	Rework the widget code, it sucks. Although it can be expanded it
 				has just turned into a huge contorted mess of object oriented
 				C. Would still have to do OO C but it can be done alot cleaner
 				than what is already here.
 
 * v_video:		Add back support for characters with accents and such along with
 				other international characters.
 
 * v_video:		Add support for tall patches to be drawn.

 * remootex:	Rewrite the old crusty program that was basically a proof of
 				concept into something much more reliable and better.
 
 * t_*:			Implement the ReMooD Virtual Machine (big undertaking).
 
 * sounds:		Fix the sound code for WL and add support for SNDINFO or another
 				similar format. (Needed for Hexen anyway)
 
 * p_info:		Remove the old info interface and use the new one, which is
 				much better and more dynamic. Also, implement the remaining
 				stuff needed to parse info on a level.
 
 * m_cheat:		Rewrite the cheat subsystem and possibly RMOD it so that any
 				cheats done are not a huge mess. Could also add a single cheat
 				command that can access all cheats ("cheats list" anyone?).
 
 * m_menu:		Rewrite the drawing stuff so it is much better, with the super
 				new widget code.
 
 * g_*,p_*:		Make game settings semi-console bound but not exactly console
 				bound, this way demos and such along with network environments
 				will work without much trouble here.
 
 * g_state:		Merge this file into something else, it virtually has nothing
 				here and just holds game state defines for some reason.
 
 * p_mobj:		Make per object P_Random() and possibly map based P_Random().
 				Fully synced for synced games and per object/thinker for async
 				games.
 
 * p_chex:		Make this an internal DeHackEd Patch and put it in remood.wad.
 
 * dehacked:	RMODize this to make it fit with RMOD and not be so constant.
 
 * p_???:		Make P_CheckSight() stop at 3D floors.
 
 * p_???:		Fixup Vanilla and older Legacy Demo suports so the ancient
 				demos play.
 
 * p_*:			Merge all the door, specials, plats, etc. code into a single
 				RMOD possibly source and make it event based so that less code
 				does more things.
 
 * w_*,z_,*:	For any WL_ data use special allocation tags for anything that
 				creates "ordered" data, this way it can also be freed after the
 				initial free in case there was any misses.
 				
 * *:			Switch from the WL_StreamXXX() to something a bit more generic
 				similar to the block layer. This way networks, files, etc.
 				will use the same code.
 				A single streaming API that can handle a single interface with
 				just streams and datagrams (so network streams work) and have
 				wrapped addresses.
 
 * v_video:		How about implementing compressed textures to conserve memory,
 				although this would come at a speed loss, it could benefit as
 				less memory would be used.
 
 * z_zone:		Make a version of Z_Malloc() that does not I_Error() in case we
 				don't care if we cannot allocate something.
 
 * tables:		Put this in a lump, no need to have gigantic lookup tables in C.
 
 * p_inter:		Reimplement player weapon order.
 
 * d_items:		Merge into info.
 
 * p_*:			Merge the ceilinglist and platlist code into a single function
 				set. They both perform the same thing.

 * r_*:			Rewrite the renderer and allow forked renders.

###############################################################################
 END ACTUAL TODO LIST

COMPLETED TODOS:
 
 * d_prof:		Rewrite the profile subsystem and make it so it isn't a giant
 				old console code hack. It should be better and independent along
 				with the ability to be placed in new config files and to have it
 				transferrable over the net. Also, make per player configs and
 				key binds along with alternative configs (such as when playing
 				with someone else) and if two players share the same keys, then
 				show a list of conflicts so they don't screw each other over.
 
 * command:		Remove all this junk.
 
 * console:		Move all the variables to the new system.
 
 * md5:			Use a better algorithm?
 
 * p_fab:		Remove this file and put the stuff elsewhere.
 
 * p_pspr:		Put RMOD related stuff into info (weapons, ammo, etc.)
 
 * w_wad:		Remove the old W_ and WX_ code, it is very old.
 
 * w_wad:		Rewrite the WL_ interface to something a bit better and less
 				ugly. Use the new streaming interface I am writing for it also.
 				And since the new streamer will use memory mappings, it will be
 				more efficient.

 * p_spec/intr:	Make line triggers and sector specials dynamic in RMOD so that
 				pages and pages of switch statements are removed.
 				
 				-- They are in RMD_EGLL and RMD_EGLM, although not REMOODAT,
 				it would have been overkill so I went for a basic way to do it.

 * info:		RMODize everything.
 
 * d_block:		Implement more of the block layer, and in fact make it much
 				better, lighter, and faster.

 * *:			Remove all that demoversion < > <= >= junk and just make them
 				all game varaibles (so one could easily support old demos or
 				possibly even record older demos -complevel).
 
 * makefile:	Add back WAD building to the makefile and make it mandatory and
 				dependable so you don't have to wad/makewad.sh. Would also have
 				to make it work on MSVC too.
 
 * v_video:		Make the patch drawing functions in the image code actually
 				secure so someone won't crash the game with a badly malformed
 				patch.

 * g_input:		Delete the way normal input is done and do it a profile way so
 				that there are no more console variables that define keys.
 
 * d_eng/frn:	Remove these language files, will be replaced by the stuff in
 				dstrings for internationalization.

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

in r_splats.c, make wallsplats a dynamic array instead of a static one of size
MAXLEVELSPLATS. This way, global memory space is reduced potentially and the
game memory can be managed better.

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

Game Stats (for intermission screen and global profile score keeping)
* Frags (Count, All)
* Deaths (Count, All)
* Suicides (Count)
* Friendly Frags (Count)
* Enemy Frags (Count)
* Frags to Specific Player (Count, for all other players)
* Deaths from Specific Player (Count, for all other players)
* Deaths from Friendlies (Count)
* Deaths from Enemies (Count)
* Greatest Successive Frags (Count, Most frags within 1 second window)
* Spawn Kills Dealt (Count, Frags within 3 seconds of player spawn)
* Spawn Kills Recieved (Count, Frags within 3 seconds of player spawn)
* Telefrags Dealt (Count, Frags done via telefrag)
* Telefrags Recieved (Count, times killed by a telefrag)
* Total Damage Dealt (Percentage)
* Total Damage Taken (Percentage)
* Highest Damage Dealt (Percentage, The highest damage done in a single tic)
* Highest Damage Taken (Percentage, The highest damage recieved in a single tic)
* Friendly Armor Damage Dealt (Percentage)
* Friendly Armor Damage Taken (Percentage)
* Total Time Played (Time)
* Games Won (Count)
* Games Lost (Count)
* Grand Accuracy (Average of all Accuracies)
* Accuracy (Percentage, Per weapon)
* Grand Ammo Used (Count, Total of all ammos)
* Ammo Used (Count, Per ammo type)
* Maximum Speed (In SR50s format)
* Average Speed (In SR50s format)
* Distance Traveled (In Map Units)
* Longest Life (Time)
* Shortest Life (Time)
* Average Life (Time)
* Longest Death (Time)
* Shortest Death (Time)
* Average Death (Time)
* Monster Kills (Count, Per monster)
* Deaths from Monster (Count, Per monster)
* Flags Picked Up (Count, Enemy)
* Flags Recovered (Count, Friendly)
* Flags Returned (Count, Friendly)
* Flags Captured (Count, Enemy)
* Flags Tossed (Count, Flag thrown away)
* Flags Dropped (Count, From death)
* Fastest Capture Time (Time)
* Slowest Capture Time (Time)
* Average Capture Time (Time)
* Items Picked Up (Count, for all item types)
* Inventory Items Used (Count, for all inventory items)

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

ReMooD Doom Script Virtual Machine, for execution of virtual code.

Use extended Legacy Script syntax, but mostly syntactically compatible. First
tokenize an entire script with includes into a structure element as followed:

struct
{
	TokenType_t TokenType;				// Type of token (ident., number, etc.)
	uint8_t* TokenPtr;					// Pointer to token
	size_t TokenSize;					// Size of token
};

Then after that, create scope zones for scopes and paranthesis. So essentially

script 10 { print ( "Hello world!" ) ; playeraddfrag ( player ( trigger ) ) ;
if ( playergetfrag ( player ( trigger ) ) == 2 + 2 ) { print (
"You now have 4 frags!" ) ; } } 

Would become

script 10
	__BEGIN_SCOPE
	print
		__BEGIN_PAR
		"Hello world!"
		__END_STATEMENT
		__END_PAR
	__END_STATEMENT
	playeraddfrag
		__BEGIN_PAR
		player
			__BEGIN_PAR
				trigger
				__END_STATEMENT
			__END_PAR
		__END_PAR
		__END_STATEMENT
	__END_STATEMENT
	if
		__BEGIN_PAR
		playergetfrag
			__BEGIN_PAR
			player
				__BEGIN_PAR
				trigger
				__END_PAR
				__END_STATEMENT
			__END_PAR
			__END_STATEMENT
		==
		2
		+
		2
		__END_PAR
		__END_STATEMENT
	__END_STATEMENT
		__BEGIN_SCOPE
			print
				__BEGIN_PAR
				"You now have 4 frags!"
				__END_PAR
				__END_STATEMENT
			__END_STATEMENT
		__END_SCOPE
	__END_SCOPE

Statements contain actual code. When a statement executes it returns something
logically speaking. The deepest statements and scopes are done first, then it
branches out to the lower ones.

For all case and purposes, { and } are treated as if they were ; on statement
boundaries.