From shikadi.net

Latest news - September 2015

The Camoto libraries are currently undergoing a significant rewrite. If you are intending to work with the source code, please use the git master branch for contributions. However note that this branch is incomplete, so if you wish to compile the (now defunct) GUI, you'll need to use the older v1.x branch for all the libraries. See #Build instructions below for details on where things are at.

The reasons for this major change are:

C++11 is now widely used, so I wanted to start taking advantage of it as it makes parts of the code much simpler.

Having worked on the libraries for a few years now, I could see ways of improving the architecture, so rather than hack away piecemeal over time, I thought it would be easier to make all the changes at once. Smart pointers are now used more efficiently (i.e. only when needed instead of everywhere.)

It was a good excuse to audit the code, fixing some obscure bugs and ensuring there was test code for every single file format.

Using wxWidgets was becoming painful, so the GUI is being rewritten in GTK. Why? Because: wxWidgets is supposed to be a cross-platform library, but quite a few things don't work on all platforms, so you still have to use #ifdefs for platform-specific code. There are also heaps of strange bugs, apparently due to the way that it tries to emulate the MS-Windows way of doing things on non-Windows platforms. You have to design your GUI by writing code, which is a huge time sink. GTK comes with Glade, which lets you draw your GUI instead, saving huge amounts of time and producing significantly better-looking interfaces. wxWidgets does come with wxGlade, but this program locks up as soon as you try to do anything with it. If you have proper driver support, the whole GTK GUI is hardware accelerated thanks to the Cairo API. I am hoping that by using Cairo for things like the map editor, these will work much more smoothly than before. The map editor was hardware accelerated under wx because OpenGL was used for drawing, but lots of problem arose from having multiple GL windows and tabs. A number of people also couldn't run the program at all due to unexplainable OpenGL errors. Hopefully Cairo will resolve all these issues.







Camoto is intended to be a collection of integrated utilities for editing (modding) "classic DOS games", those running under MS-DOS on the PC from the early to mid 1990s.

Main features

Map editor for 2D tile-based/grid maps (most platform games, some early FPS games)

Export and import images and tilesets as .png files with transparency

Listen to Ad Lib music via software OPL synth (borrowed from DOSBox)

Edits files directly inside group/archive files, no need to extract them first or merge them later

Works with files in their native format, no need to distribute images of tilesets, and when changes are saved they are immediately visible if the game is launched

Consistent user interface for editing many different games

See the list of supported games.

Future expansion

These features have not yet been implemented, but are considered most important for future versions:

Automatically decompress .exe files (e.g. with unlzexe). This must be done manually at present.

Package up a modified game into a single .exe that can be placed into a game's folder, and run without disturbing the original game files.

Opening standalone songs and allowing conversion to all supported formats (to replace DRO2MIDI.)

See also the to-do list

Help / Discussion

If you're new to Camoto, see Getting Started with Camoto Studio.

The 'official' help forum for Camoto is the RGB Classic Games modding forum. If you run into problems or have questions about Camoto, please ask them there.

You can watch development progress by following @CamotoModding on Twitter.

Contributing

Camoto is open source - please contribute! There are many ways in which you can help:

Download

Windows

camoto-install-20150221.exe (Windows 32-bit, 9.8 MB, git) - released 2015-02-21

Previous version: camoto-install-20140115.exe (Windows 32-bit, 4.3 MB - released 2014-01-15

Linux / Source code

libgamecommon-1.2.tar.bz2 (source only, 342 kB, git) - released 2015-02-21

libgamearchive-1.2.tar.bz2 (source only, 437 kB, git) - released 2015-02-21

libgamegraphics-1.2.tar.bz2 (source only, 423 kB, git) - released 2015-02-21

libgamemaps-1.2.tar.bz2 (source only, 402 kB, git) - released 2015-02-21

libgamemusic-1.2.tar.bz2 (source only, 475 kB, git) - released 2015-02-21

camoto-studio-1.2.tar.bz2 (source only, 719 kB, git) - released 2015-02-21

Build instructions

The Camoto libraries are currently (July 2016) undergoing a significant rewrite. Please ensure you use the v1.x git branch for all components if you want to compile the GUI. But if you want to contribute, please use the master branch as this is where all work is being done. The wxWidgets v1.x GUI has been discontinued, and a new GTK-based GUI is being written to replace it. The table at the right illustrates progress on the rewrite - those components with a tick are fully functional, while those with a cross have not yet reached a stage where they are usable (and may not even compile.)

Component v1.x master libgamecommon libgamearchive libgamegraphics libgamemaps libgamemusic camoto-studio

For Windows, see compile How to compile Camoto with Visual Studio.

Under Linux, the code is compiled in the usual way:

$ git clone git://github.com/Malvineous/libgamecommon.git $ cd libgamecommon $ ./autogen.sh $ ./configure && make && sudo make install

Repeat for each of the Camoto support libraries. The order of the libraries is important:

libgamecommon must be first libgamearchive, libgamegraphics, libgamemusic can be done next, in any order libgamemaps must be done after libgamegraphics camoto-studio must be done last of all

Dependencies

Here is a full the list of dependencies:

libgamecommon: boost (test)

libgamearchive: boost (filesystem, program options, test), libgamecommon

libgamegraphics: boost (program options, test), libpng, pngpp, libgamecommon

libgamemaps: boost (filesystem, program options, test), libpng, pngpp, libgamegraphics, libgamecommon

libgamemusic: boost (filesystem, program options, threads, test), portaudio (optional), libgamecommon

camoto-studio: boost (filesystem, threads), libpng, pngpp, wxwidgets >= 2.9.4 w/ GL support, libxml2, portaudio, glew, all libgame* libraries

boost means boost >= 1.60

pngpp means png++ >= 0.2.7

portaudio means portaudio >= 2.0

User interfaces

The Camoto suite has a number of command-line interfaces to its functionality, as well as a single GUI that combines everything into one IDE-like environment.

Camoto Studio (GUI) (report bug) Cross-platform GUI combining the entire Camoto suite into a single integrated application gamearch (libgamearchive, command-line) View and edit group/archive files (like zip/unzip) gamecomp (libgamearchive, command-line) Encrypt/decrypt and compress/decompress individual files gametls (libgamegraphics, command-line) Extract (as .png), view (in ANSI/ASCII) and replace images within a tileset (a tileset is a single file containing many images) gameimg (libgamegraphics, command-line) View (in ANSI/ASCII) and replace single-image graphics files gamemap (libgamemaps, command-line) Examine game levels (hex dump, print metadata) gamemus (libgamemusic, command-line) Import, export and basic conversion of game music files dro2txt (libgamemusic, command-line) Dump events in DOSBox .dro captures as text. Events are handled so that OPL register writes in a different order won't change the output, providing the audio would sound the same, making it useful to use with a diff utility to compare two .dro files. Very useful to compare your own Adlib player with another one to ensure playback accuracy. dumppal (libgamegraphics, command-line) Read a .png image and dump the palette in a supported file format. dumpb800 (libgamegraphics, command-line) Read a 4000-byte B800 text screen on stdin, and write it to stdout, using ANSI colour escape codes so it is readable in a terminal. (You may still have to pass it through iconv -f cp437 to convert the glyphs, if you have a UTF8 terminal.)

Developers

The Camoto codebase is broken up into the following libraries. Each library name is a link to the Doxygen documentation for that library.

libgamecommon (report bug) Common functionality shared by multiple libraries. Endian independent stream functions, methods for reading and writing streams in units other than 8-bit bytes, and helper functions for various common tasks. libgamearchive (report bug) Interface to game archives (like .zip files where lots of game data is stored in one big file.) Allows full editing of supported file types. libgamegraphics (report bug) Examine, convert and modify game graphics in all their multitude of formats. This includes tilesets, sprites, backgrounds, animations, etc. libgamemaps (report bug) Provide a standard method of level editing. This will (initially) only support 2D grid-based maps, which means platform games and some early 3D games. libgamemusic (report bug) Play and convert music from supported games. The UI for this component will include real-time OPL/Adlib conversion to MIDI (to replace DRO2MIDI.) libgamesfx Proposed library, not yet started. Listen to and replace sound effects - digitised (PCM), synthesised (Adlib) and PC speaker. Possibly this functionality will end up in libgamemusic as so much code is common between music and sound effects, and there is little technical difference between an instrument and a sound effect.

Further Reading

While developing Camoto I discovered that Every Game Has a New Feature.

More Screenshots