TODO

Here is a list of things we consider doing in the future. Note that we don't promise to do any of these, nor when we will do them. It's just a list of what we hope to be able to do one day, and some items on the list really are more like ideas than real proposals, so take it with a grain of salt.

If you want to dig in, this is the stuff where you might make the most useful contribution. Note that this list is never complete, and may be partially outdated, so just because you don't see something here doesn't mean it is not important.

Before you start work on something, you should first talk to the team! Ideally ask on scummvm-devel, our mailing list. This will help us to prevent double work, i.e. several people working on the same stuff at once without knowing about each other. Furthermore, sometimes entries on our list are actually obsolete (because the feature has been implemented, or because for some reason we no longer think it to be desirable). Special caution should be taken for TODO entries that say "we may want to" or similar things; that usually means that we aren't sure whether we really want to implement that feature.

So, to repeat it: Always talk to the team before implementing a change on this list, or else risk having your patch rejected :-/.

Finally, always make sure to check out our bug tracker and our feature request tracker for things that need work.

Docs, Web site

See also the Documentation/TODO page.

General

• Add port specific user documentation (dreamcast/palm especially). That would include things like:
  • How to use ScummVM on system XYZ
  • Which Palm / WinCE devices will run ScummVM, which definitely will not run it (or with which limitations)?
• Update/enhance man page
• Write a high level overview of how ScummVM and its engines work?

README / Manual

• Fingolfin has started a DocBook based manual (and FAQ, and Developer's Guide). You can find it in the SVN module "docs". It's a starting place, but very unfinished.
• Everybody is welcome to start helping out with the public manual project in the "docs" SVN module. You can either reuse content from the README, or replace it with new, better written stuff. Contact Fingolfin or our mailing list, scummvm-devel, if you are interested in helping out.
• Maybe move all/most of the compression related stuff from our README completely to the tools README, and only leave a pointer to that in the main README. This would be beneficial because this way, it's only documented in one place; it's *completly* documented (currently, the main README doesn't mention compress_scumm_bun, for example); and people who want to use the compression tools need to download the tools package anyway.
• It would be greate to have a "Developer's Guide to ScummVM" which explains the ScummVM framework, and also the engines, i.e.
  • stuff in common/, like the config manager etc.
  • the backend API, and how to create new backends
  • the sound system
  • how to create a new engine
  • a chapter for each engine, with as many/little details as the resp. engine teams deem appropriate...
  • ...

Code

• Add more Doxygen comments. However, quality is preferable over quantity
• Document the OSystem overlay API, it badly needs it...

Web site

• Add the "Manual" / README to the site

Wiki

• Add content for the Wanted Pages
• Add some content to the Help:Editing link you see when editing a page.
• Create visual theme which will loosely fit our forum and website

Common code, infrastructure

General

• Revise the way "quit" is handled. Maybe add a global variable "g_quit" which we set when the application should be quit (e.g. when an EVENT_QUIT is received). This is useful if multiple levels of event loops have to be ended
• Make some generic "EventLoop" API/class which all backends and the GUI use. Initially this would just call the backend poll_event() etc. methods. But eventually the EventLoop object(s) could be made by the backend. This may allow for more efficient CPU usage etc. The current event handling model essentially is polling: the engines run some kind of main loop, which, besides many other things, also polls and dispatches events. The idea is to turn this around: the event loop frequently gives the engine time to do these "other things".
• Maybe add ways to modify the game configs via the command line. E.g. allow

   ./scummvm --add new_target --path=/foo monkey2
   ./scummvm --remove new_target

• Maybe allow launching games even if no target is specified? I.e. the user only has to specify a path (or run ScummVM from the right directory), and ScummVM auto-detects the game in that location

   ./scummvm --auto-detect

• The following things should be put into namespaces:
  • MIDI related classes either to Audio, or a new "MIDI" namespace
  • backend specific stuff into ??? (maybe new namespace "Backends" ?) not sure about this one.
• Get rid of getenv in as many places as possible. Ideally, we'd only use it to query HOME on Unix systems.

Iterator handling

• Our implementation of begin(/end) returning (const_)iterator is bugged, i.e. the current implementation for iterators of Common::List will not work with code like:

   Common::List<int> list;
   Common::List<int>::const_iterator x = list.begin();

It will fail with (i.e. gcc 4.2.3):

   error: conversion from ‘Common::List<int>::Iterator<int>’ to non-scalar type ‘Common::List<int>::Iterator<const int>’ requested

To understand what is wrong you have to know that C++ does not support function overloading by return value, so it picks 'iterator Common::List<T>::begin' (NOT the implementation for constant instances of the type, since 'list' is not const in this example) instead of 'const_iterator Common::List<T>::begin' (the one for constant instances of the type). This is no problem at all for the STL, but since our 'Common::List::Iterator' implementation does not supply a copy constructor from 'Common::List<T>::Iterator<t_T2>' to 'Common::List<T>::Iterator<const t_T2>', it will fail. Check for example Common::HashMap::Iterator for a (rather hacky) implementation of it, or the GNU libstdc++ implementation (example for std::map iterators).

• Implement proper reverse_iterators for Common::List. Our current implementation is the same as forward iterators, just that rbegin will return the last element instead of the first and there is no rend. Check SGI Documentation for proper description of revese_iterator in the STL.

Event recorder

Currently there is an implementation based on patch #1738058 but it needs more work

• Try to avoid warpMouse() calls at playback, so the system will be useable
• Perhaps we need to indicate recording mode. May be draw triangle/circle in some corner. Use OSD overlay for that
• Still it is possible that time will drift away even with current implementation. Do something about it, at least try to detect
• Remove temporary file
• Perhaps autogenerate record file name based on target name
• Perhaps combine 2 files which get created currently into one
• We should store unique game ID in the record files. I.e. ideally it should be engine name and some game MD5 or anything else which could be re-generated on game start. Then when this method is called in playback mode, recorder matches this against values stored in the record and refuses to play if they do not match.

 registerGame("scumm", "60ba818dc3bede86d40357e3913f8505");

• Perhaps add special flag when game started from a save, i.e. not from the very beginning but with -x command line switch.
• getMillis() currently is hacked into SDL. It has to be moved one level up
• delayMillis() perhaps has to be wrapped too, so time drift could be avoided

Build System

• Add test(s) for backend usability in the configure script.
• Add an install target to the Makefile - Copy binary, install manpage, add menu items, install README. See also patch #891909 (Gnome/KDE .desktop file)

Audio

Mixer

• Get the high quality resample code to work
• Consider changing the mixer volume to use range 0-255, for sake of consistency (but at a slight loss of efficiency). Note that this requires changes in at least rate.cpp and mixer.cpp.
• Some of our engines support the speech_mute / sfx_mute / music_mute options, but most don't. Almost all support the corresponding FOO_volume config keys. All engines use Mixer::setVolumeForSoundType to push those through to the mixer. I am wondering: Maybe it would make sense to remove Mixer::setVolumeForSoundType, and instead leave it up to the mixer to query the ConfigManager for the corresponding FOO_volume/_mute values? That way we'd ensure 100% identical behavior in all engines and actually simplify the code a bit... ? Not sure if this would work smoothly, it needs to be investigated.
• change the way the mixer is instantiated by the backend. In particular, it would be nice if the sample rate could be passed in via the constructor
• the "isReady" code is irritating. Most engines ignore it anyway. It's primary purpose is to allow ScummVM to run even if not digitial audio out is available. A better solution would likely be to implement a fake mixer class, which simply discards audio data which is passed to it immediately. This means that the normal mixer will always consider itself to be "ready", and that it will be up to the backend to use the "fake mixer" if it can't provide audio out for some reason.

Audio streams

• Add a "SeekableAudioStream" class, which would allow seeking in an audiostream: Forward / backward; offset is specified in milliseconds. Then, convert at least the MP3/FLAC/Vorbis audiostream classes to subclass that, and also adapt the corresponding factory functions. Converting more would obviously be nice, too.

CD

• Consider extending the Audio CD Manager with WAV or VOC support (essentially, the WAV/VOC code would need to be enhanced by adding a factory function similar to that provided for the FLAC/Vorbis/MP3 streams).

MIDI

• MIDI: Add API to OSystem which allows client code to query for "native" MIDI drivers (like Windows, ALSA, Zodiac, CoreAudio). Then change the MIDI interfacing code (GUI, command line, config file, etc.) and also MidiDriver::createMidi() to use both that list and the list of 'emulated' MIDI devices (Adlib, MT-32, PC Speaker, etc.) in an appropriate way.
• Make it possible to pass options to the midi/music drivers. This would allow us to get rid of the getenv hacks in the alsa & seq drivers.
  • A simple approach would be to allow the user to specify "extended" driver descriptions. E.g. "alsa:1234" could indicate the alsa driver with port 1234; alternatively, "alsa:port=1234".
  • This doesn't allow for easy tweaking of those settings via the GUI.... to achieve that, one approach would be to invent a 'parameter description language' which allows a driver to specify which options with which kind of values it supports... very flexible, but possibly overkill.
  • Instead, one could add a hook method to MIDI drivers that let's them add a few controls of their own to the options dialog. This is probably a lot easier to implement, though not quite as "clean"...
• Our XMIDI parser seems to have a couple of missing features, but it's unclear which ones are actually needed. For instance, Kyrandia 1 (and probably 2) uses the XMIDI mechanism for looping, which we currently implement through a very simple hack. The Exult project may have a good reference implementation.

Config Manager

• Add a 'notification' system. E.g. the SoundMixer could request to be notified whenever the value of the "volume" config option changes. In other words, instead of a "pull" approach (where each subsystem has to check whether any config option relevant to it has been changed) we use a "push" approach. Of course the current approach is "push", too: whenever e.g. the volume setting is changed, the code doing so has to updated the SoundMixer etc. That's cumbersome, and error prone. Would be much nicer if updating the volume config value automatically notifies the SoundMixer, iMuse etc.
• Modify the ConfigManager to make use of the ConfigFile class.
• Maybe even follow the pentagram (http://pentagram.sf.net) approach and have three classes:
  • SettingsManager (like our current ConfigManager)
  • ConfigFileManager (manages a set of config files, possibly merging the data from multiple config files)
  • ConfigFile (a simple .ini file accessor).

  This makes it easy to add additional config sources (e.g. XMLConfigFile); makes it possible to treat the command line data like another config file (CommandLineConfig); and simply follows the good old MVC approach, which is always a good idea.

Files

• Don't rely on the existence of SEEK_CUR, SEEK_END, SEEK_SET -- rather, define our own enum for this and convert all client code to use it.
• Try to replace all usages of paths by FilesystemNode. In particular, Engine::_gameDataPath and File::addDefaultDirectory() will have to be adjusted. The idea behind this is to ease portability.
• Consider removing write support from class File completely. After all, we do not support writing to data files on many platforms anyway. There are only three things for which we need writable files:
  1. Savegames -- but for those we already have the SavefileManage, so no problem
  2. Resources dumps -- useful for debugging. To support those, we could add a new DumpFile class, which simply does nothing on systems which don't support this
  3. Config file -- this one is the trickiest. The best approach is probably to make the actual reading/writing of the config file adjustable by the backend. This would also help to reduce the #ifdef hell in config-manager.cpp (see also the Modular Backends plans).

GUI

• GUI TODO

Plugins

• On OSX: Support a plugin build in the bundle target: *.plugin files should be put into ScummVM.app/Contents/PlugIns/; this also means that the loader needs to search in the plugin dir of the active bundle. So use the CF bundle API, inside a #ifdef MACOSX block.
• Make DetectedGame::updateDesc a normal function, not a member function.

Launcher

• Enhance the Mass detector to show a list with the results (and optionally, allow the user to edit/cull that list before adding it).

Engines / frontends

General

• Fix engines so they clean up after themselves, to allow proper re-entry to the launcher. See "FIXME: LAUNCHERHACK" in base/main.cpp.

SCUMM

• Make it possible to restart games properly
• Possibly implement a new resource manager, which then also could be shared by ScummEX. [Jamieson has some ideas about this].
• Figure out the resource types in the Turbografx/PC Engine version of Loom
• Add support for music and sound effects in the Apple II version of Maniac Mansion
• Add support for music and sound effects in the Commodore 64 versions of Maniac Mansion and Zak McKracken
• Add support for music and sound effects in the Macintosh version of Loom
• Add support for TFMX music format in Amiga version of Monkey Island 1 Check http://www.wotsit.org/search.asp?s=TFMX and http://freshmeat.net/projects/tfmx-play/ for music format details
• Add support for handling Kanji in FM-Towns games (foreground is rendered on a second plane at 640x480), text uses Shift_JIS encoding [implementation now that currently depends on font rom, not needing the rom would be preferable]
• Clean up class Gdi. This class right now mostly is about decoding various graphic formats. However some other functionality has crept into it, too. It would be nice if class Gdi would only contain the GFX decoding code, and nothing else (assuming that is feasible w/o too much trouble). OTOH, the code which is responsible for managing virtual screens, rendering virtual screens to the real display etc. could be grouped into a new class (e.g. VSManager or so).
• Reduce kMD5FileSizeLimit from 1MB to e.g. 80 kb (this will force us to recompute the MD5 for the mac bundles, but hopefully nothing else)
• ADLIB: There seems to be some loop/repeat mechanism in old Adlib sound effects that we do not handle. This thread has some discussion, and recordings. Two good examples are the door opening sound in Indy 3 and Monkey Island 1 (floppy), and the typewriter sound in Indy 3.
• ADLIB: We don't handle (global) music volume changes for adlib sounds in older SCUMM games. See bug #1159581.
• Add support for non-interactive demo of Monkey Island 2. This can be done either by hacking the SCUMM loop and adding code to parse the existing 'demo.rec' file and re-injecting events in the event loop. Another possible approach would be to "specialize" the (future) events recording/playback code to deal with the original SPUTM .rec files.

SCUMM V0

• see SCUMM V0 TODO list

SCUMM NES

• see SCUMM NES TODO list

HE games

• see HE Progress status
• see HE 16bits Support

AGI

• see AGI TODO list

AGOS

• see AGOS Bugs list
• see AGOS TODO list

Cine

• see Cine TODO list

Gob

• see Gob TODO list

Kyra

• see Kyra TODO list

MADE

• see MADE TODO list

Parallaction

• see Parallaction TODO list

SAGA

• see SAGA TODO list

Broken Sword 1

• Modify MoviePlayer class to use ManagedArray for _movieTexts.

Broken Sword 2

• Fix the credits so they look more like the original. (Did we ever get the source code for that?)
• Maybe work around script bug which causes the mop to disappear briefly when trying to pick it up from the top of the boat at the London docks. (The event to hide the mop is sent too early.) See bug #1214168.
• Unify some of the code with Broken Sword 1 (e.g. in router.cpp).

Touche

• see Touche TODO list

Backends

General

• Add API to query backend for a list of available music engines. Useful for Options dialog
• Right now gBitFormat is part of common/scaler.cpp; we might want to move it to common/system.cpp, or replace it with something better. No hasty changes here, please, make sure you understand how it is used right now before messing with it ;-)
• OSystem::RGBToColor and OSystem::colorToRGB are very flexible, but cause a bottleneck: Using these virtual methods to convert lots of pixels in one go is sloooooow. Hence consider removing these and related function in favor of a new API with which client code can query the backend for a description of the pixel format (maybe similar in spirt to SDL_PixelFormat, but maybe we can also reuse / extend a variant of gBitFormat). This is in particular useful for the new GUI code which wants to do things like color fading, and has to process a huge number of pixels. Of course, we must still accomodate for backends that only offer palette mode!

Potential ports

• MS DOS port using Allegro and DJGPP ?
• Intent port (already done by David Given, merge?)
• Digita OS port? (play games on a select few digital cameras...)
• XBox port(s) exist, but can not be legally distributed, since the use the XDK, which is incompatible with the GPL. OpenXDK lacks C++ support, though has SDL.

X11 backend

• Add frills used by SDL backend like graphic filters usage and CD audio

SDL backend

• Right now, the WinCE and the Symbian backend subclasses the regular SDL backend. They both overload a lot of methods (mostly the graphics stuff). Since graphics.cpp uses the scalers (e.g. hq3x), these derived backends carry that baggage around, too, even though they don't need that code. Idea: split the SDL backend into two classes, one base class which only has the code which is used by all subclasses; and a "desktop" subclass, which implements the rest. Then WinCE/Symbian would only subclass the "base" SDL class.
• We implemented GFX transactions & commits some time ago -- but they are only half the story. We are still missing a rollback system -- that is, check whether the requested video mode works, if it doesn't, revert to the current settings -- at least "if it makes sense". That is, if the transaction only modified the scaler or aspect ratio, we can safely revert. Of course if the screen size changed (e.g. from 320x200 -> 640x480) we can't just revert to the old screen size -- unless we augment the API accordingly, and update all engines to deal with this possibility.
• The kFeatureAutoComputeDirtyRects feature is not entirely reliable, and perhaps it cannot ever be. It is currently known to cause glitches in The Feeble Files.

WinCE backend

• Improve the code in backends/platform/wince/CEScaler.cpp, it could be a lot faster with some simple changes.
• Cleanup missing.cpp, see Patch #1882942.

Tools

General

• Try to unify the usage of the compression tools, where possible / necessary.
• Make compress_san use the common encoder "API" in compress.c
• Make compress_queen use the common encoder "API" in compress.c
• Consider using library APIs to encode data, instead of invoking the lame/oggenc/flac binaries.

  Pro

  Tighter integration, no need to create temporary files.

  Con

  Requires the resp. libs/headers to be compiled in, and the resulting binary would only run if all needed shared libs are present (unless we static link), whereas the current binary will work even if lame/oggenc/flac are missing

Descumm

• Turn it into a library, to be used by a command line frontend (like now), ScummVM debugger, and ScummEX. Basically, the API could consist of a single function, which takes a pointer to a memory buffer, its length, the Scumm version and optionally a game id. Also, it would get a pointer to a print function (in the case of the CLI tool, print to stdout; for ScummVM, print to our GUI console; for ScummEX, append to some window/widget)
• Rewrite code to use 2 passes; first pass builds an intermediate graph, the second pass then tries to detect loops, break/continue statements etc.
• Proper implementation of o6_startObjectQuick decompilation (see comment in descumm6.c). May requre rewrite of core program logic