Use Console as Stream everywhere

ChangeLog.md

     * Console is now using std::string instead of char *
     * Added utf8-cpp dependency to allow Console to delete multi-byte chars
     * Added stream-style printing to Console
+    * Using Console like Stream everywhere, removed old print method
 
     [ 20140809 ]
     * Script Unit Test brings it’s own scripts to test

include/Console.h

     bool isVisible();
 
     template<typename T>
-    Console &operator<<(T t);
-
-    // Deprecated!
-    void print(const char *s, ...) __attribute__((format(printf, 2, 3)));
+    Console &operator<<(const T t) {
+        printBuffer << t;
+        if (printBuffer.str().back() == '\n') {
+            mHistory.push_back(printBuffer.str().substr(0, printBuffer.str().length() - 1));
+#ifdef DEBUG
+            std::cout << printBuffer.str().substr(0, printBuffer.str().length() - 1) << std::endl;
+#endif
+            printBuffer.str("");
+        }
+        return (*this);
+    }
 
     void display();
 

include/OpenRaider.h

      */
     int loadConfig(const char *config);
 
-    int command(std::string &command);
-    int command(const char *command);
+    int command(std::string command);
 
     void run();
     void frame();
 OpenRaider &getOpenRaider();
 
 #endif
+

src/Command.cpp

     assert(config[0] != '\0');
 
     char *configFile = fullPath(config, 0);
-    getConsole().print("Loading config from \"%s\"...", configFile);
+    getConsole() << "Loading config from \"" << configFile << "\"..." << Console::endl;
 
     std::ifstream file(configFile);
     if (!file) {
-        getConsole().print("Could not open file!");
+        getConsole() << "Could not open file!" << Console::endl;
         return -1;
     }
 
 
         int error = command(line);
         if (error != 0)
-            getConsole().print("Error Code: %d", error);
+            getConsole() << "Error Code: " << error << Console::endl;
     }
 
     file.close();
     return 0;
 }
 
-int OpenRaider::command(const char *command) {
-    std::string tmp(command);
-    return this->command(tmp);
-}
-
-int OpenRaider::command(std::string &c) {
+int OpenRaider::command(std::string c) {
     // Remove comment, if any
     size_t comment = c.find_first_of('#');
     if (comment != std::string::npos)
     } else if (cmd.compare("bind") == 0) {
         std::string a, b;
         if (!(command >> a >> b)) {
-            getConsole().print("Invalid use of bind-command");
+            getConsole() << "Invalid use of bind-command" << Console::endl;
             return -1;
         } else {
             return bind(a.c_str(), b.c_str());
         exit(0);
     } else if (cmd.compare("load") == 0) {
         if (!mRunning) {
-            getConsole().print("Use load command interactively!");
+            getConsole() << "Use load command interactively!" << Console::endl;
             return -999;
         }
         std::string temp;
     } else if (cmd.compare("help") == 0) {
         std::string tmp;
         if (!(command >> tmp)) {
-            getConsole().print("Available commands:");
-            getConsole().print("  load      - load a level");
-            getConsole().print("  set       - set a parameter");
-            getConsole().print("  bind      - bind a keyboard/mouse action");
-            getConsole().print("  animate   - [BOOL|n|p] - Animate models");
-            getConsole().print("  move      - [walk|fly|noclip]");
+            getConsole() << "Available commands:" << Console::endl;
+            getConsole() << "  load      - load a level" << Console::endl;
+            getConsole() << "  set       - set a parameter" << Console::endl;
+            getConsole() << "  bind      - bind a keyboard/mouse action" << Console::endl;
+            getConsole() << "  animate   - [BOOL|n|p] - Animate models" << Console::endl;
+            getConsole() << "  move      - [walk|fly|noclip]" << Console::endl;
 /*
-            getConsole().print("  sshot     - make a screenshot");
-            getConsole().print("  sound     - INT - Test play sound");
-            getConsole().print("  mode      - MODE - Render mode");
-            getConsole().print("  light     - BOOL - GL Lights");
-            getConsole().print("  fog       - BOOL - GL Fog");
-            getConsole().print("  viewmodel - INT - Change Laras model");
-            getConsole().print("  pos       - Print position info");
-            getConsole().print("  ralpha    - BOOL - Room Alpha");
-            getConsole().print("  upf       - BOOL - Update Room List Per Frame");
-            getConsole().print("  entmodel  - BOOL");
-            getConsole().print("  ponytail  - BOOL");
-            getConsole().print("  pigtail   - BOOL");
-            getConsole().print("  ponypos   - FLOAT FLOAT FLOAT FLOAT - x y z angle");
+            getConsole() << "  sshot     - make a screenshot" << Console::endl;
+            getConsole() << "  sound     - INT - Test play sound" << Console::endl;
+            getConsole() << "  mode      - MODE - Render mode" << Console::endl;
+            getConsole() << "  light     - BOOL - GL Lights" << Console::endl;
+            getConsole() << "  fog       - BOOL - GL Fog" << Console::endl;
+            getConsole() << "  viewmodel - INT - Change Laras model" << Console::endl;
+            getConsole() << "  pos       - Print position info" << Console::endl;
+            getConsole() << "  ralpha    - BOOL - Room Alpha" << Console::endl;
+            getConsole() << "  upf       - BOOL - Update Room List Per Frame" << Console::endl;
+            getConsole() << "  entmodel  - BOOL" << Console::endl;
+            getConsole() << "  ponytail  - BOOL" << Console::endl;
+            getConsole() << "  pigtail   - BOOL" << Console::endl;
+            getConsole() << "  ponypos   - FLOAT FLOAT FLOAT FLOAT - x y z angle" << Console::endl;
 */
-            getConsole().print("  help      - print command help");
-            getConsole().print("  quit      - exit OpenRaider");
-            getConsole().print("Use help COMMAND to get additional info");
-            getConsole().print("Pass BOOLs as true or false");
+            getConsole() << "  help      - print command help" << Console::endl;
+            getConsole() << "  quit      - exit OpenRaider" << Console::endl;
+            getConsole() << "Use help COMMAND to get additional info" << Console::endl;
+            getConsole() << "Pass BOOLs as true or false" << Console::endl;
         } else {
             return help(tmp);
         }
     } else if (cmd.compare("animate") == 0) {
         if ((!mRunning) || (!getGame().isLoaded())) {
-            getConsole().print("Use animate command interactively!");
+            getConsole() << "Use animate command interactively!" << Console::endl;
             return -999;
         }
         if (command.peek() == 'n') {
                         e.setAnimation(0);
                 }
             } else {
-                getConsole().print("Animations need to be enabled!");
+                getConsole() << "Animations need to be enabled!" << Console::endl;
             }
         } else if (command.peek() == 'p') {
             // Step all skeletal models to their previous animation
                             e.setAnimation(m.size() - 1);
                 }
             } else {
-                getConsole().print("Animations need to be enabled!");
+                getConsole() << "Animations need to be enabled!" << Console::endl;
             }
         } else {
             // Enable or disable animating all skeletal models
             bool b = false;
             if (!(command >> b)) {
-                getConsole().print("Pass BOOL to animate command!");
+                getConsole() << "Pass BOOL to animate command!" << Console::endl;
                 return -2;
             }
             if (b)
                 getRender().setFlags(Render::fAnimateAllModels);
             else
                 getRender().clearFlags(Render::fAnimateAllModels);
-            getConsole().print(b ? "Animating all models" : "No longer animating all models");
+            getConsole() << (b ? "Animating all models" : "No longer animating all models") << Console::endl;
         }
     } else if (cmd.compare("move") == 0) {
         if ((!mRunning) || (!getGame().isLoaded())) {
-            getConsole().print("Use move command interactively!");
+            getConsole() << "Use move command interactively!" << Console::endl;
             return -999;
         }
         std::string temp;
         } else if (temp.compare("noclip") == 0) {
             getGame().getLara().setMoveType(Entity::MoveTypeNoClipping);
         } else {
-            getConsole().print("Invalid use of move command (%s)!", temp.c_str());
+            getConsole() << "Invalid use of move command (" << temp.c_str() << ")!" << Console::endl;
             return -9;
         }
-        getConsole().print("%sing", temp.c_str());
+        getConsole() << temp.c_str()  << "ing" << Console::endl;
 
 /*
     } else if (cmd.compare("mode") == 0) {
         }
 */
     } else {
-        getConsole().print("Unknown command: %s", cmd.c_str());
+        getConsole() << "Unknown command: " << cmd.c_str() << Console::endl;
         return -50;
     }
 
 
 int OpenRaider::help(std::string &cmd) {
     if (cmd.compare("set") == 0) {
-        getConsole().print("set-Command Usage:");
-        getConsole().print("  set VAR VAL");
-        getConsole().print("Available Variables:");
-        getConsole().print("  basedir    STRING");
-        getConsole().print("  pakdir     STRING");
-        getConsole().print("  audiodir   STRING");
-        getConsole().print("  datadir    STRING");
-        getConsole().print("  font       STRING");
-        getConsole().print("  size       INT INT");
-        getConsole().print("  fullscreen BOOL");
-        getConsole().print("  audio      BOOL");
-        getConsole().print("  volume     BOOL");
-        getConsole().print("  mouse_x    FLOAT");
-        getConsole().print("  mouse_y    FLOAT");
-        getConsole().print("  fps        BOOL");
-        getConsole().print("Enclose STRINGs with \"\"!");
+        getConsole() << "set-Command Usage:" << Console::endl;
+        getConsole() << "  set VAR VAL" << Console::endl;
+        getConsole() << "Available Variables:" << Console::endl;
+        getConsole() << "  basedir    STRING" << Console::endl;
+        getConsole() << "  pakdir     STRING" << Console::endl;
+        getConsole() << "  audiodir   STRING" << Console::endl;
+        getConsole() << "  datadir    STRING" << Console::endl;
+        getConsole() << "  font       STRING" << Console::endl;
+        getConsole() << "  size       INT INT" << Console::endl;
+        getConsole() << "  fullscreen BOOL" << Console::endl;
+        getConsole() << "  audio      BOOL" << Console::endl;
+        getConsole() << "  volume     BOOL" << Console::endl;
+        getConsole() << "  mouse_x    FLOAT" << Console::endl;
+        getConsole() << "  mouse_y    FLOAT" << Console::endl;
+        getConsole() << "  fps        BOOL" << Console::endl;
+        getConsole() << "Enclose STRINGs with \"\"!" << Console::endl;
     } else if (cmd.compare("bind") == 0) {
-        getConsole().print("bind-Command Usage:");
-        getConsole().print("  bind ACTION KEY");
-        getConsole().print("Available Actions:");
-        getConsole().print("  menu");
-        getConsole().print("  console");
-        getConsole().print("  forward");
-        getConsole().print("  backward");
-        getConsole().print("  left");
-        getConsole().print("  right");
-        getConsole().print("  jump");
-        getConsole().print("  crouch");
-        getConsole().print("  use");
-        getConsole().print("  holster");
-        getConsole().print("  walk");
-        getConsole().print("Key-Format:");
-        getConsole().print("  'a' or '1'    for character/number keys");
-        getConsole().print("  \"leftctrl\"  for symbols and special keys");
+        getConsole() << "bind-Command Usage:" << Console::endl;
+        getConsole() << "  bind ACTION KEY" << Console::endl;
+        getConsole() << "Available Actions:" << Console::endl;
+        getConsole() << "  menu" << Console::endl;
+        getConsole() << "  console" << Console::endl;
+        getConsole() << "  forward" << Console::endl;
+        getConsole() << "  backward" << Console::endl;
+        getConsole() << "  left" << Console::endl;
+        getConsole() << "  right" << Console::endl;
+        getConsole() << "  jump" << Console::endl;
+        getConsole() << "  crouch" << Console::endl;
+        getConsole() << "  use" << Console::endl;
+        getConsole() << "  holster" << Console::endl;
+        getConsole() << "  walk" << Console::endl;
+        getConsole() << "Key-Format:" << Console::endl;
+        getConsole() << "  'a' or '1'    for character/number keys" << Console::endl;
+        getConsole() << "  \"leftctrl\"  for symbols and special keys" << Console::endl;
     } else if (cmd.compare("load") == 0) {
-        getConsole().print("load-Command Usage:");
-        getConsole().print("  load /path/to/level");
+        getConsole() << "load-Command Usage:" << Console::endl;
+        getConsole() << "  load /path/to/level" << Console::endl;
 /*
     } else if (cmd.compare("sshot") == 0) {
         getConsole().print("sshot-Command Usage:");
         getConsole().print("  titlescreen");
 */
     } else if (cmd.compare("animate") == 0) {
-        getConsole().print("animate-Command Usage:");
-        getConsole().print("  animate [n|p|BOOL]");
-        getConsole().print("Where the commands have the following meaning:");
-        getConsole().print("  BOOL to (de)activate animating all models");
-        getConsole().print("  n to step all models to their next animation");
-        getConsole().print("  p to step all models to their previous animation");
+        getConsole() << "animate-Command Usage:" << Console::endl;
+        getConsole() << "  animate [n|p|BOOL]" << Console::endl;
+        getConsole() << "Where the commands have the following meaning:" << Console::endl;
+        getConsole() << "  BOOL to (de)activate animating all models" << Console::endl;
+        getConsole() << "  n to step all models to their next animation" << Console::endl;
+        getConsole() << "  p to step all models to their previous animation" << Console::endl;
     } else {
-        getConsole().print("No help available for %s", cmd.c_str());
+        getConsole() << "No help available for " << cmd.c_str() << Console::endl;
         return -1;
     }
 
     if (var.compare("size") == 0) {
         unsigned int w = DEFAULT_WIDTH, h = DEFAULT_HEIGHT;
         if (!(command >> w >> h)) {
-            getConsole().print("set-size-Error: Invalid value(s)");
+            getConsole() << "set-size-Error: Invalid value(s)" << Console::endl;
             return -2;
         }
         getWindow().setSize(w, h);
     } else if (var.compare("fullscreen") == 0) {
         bool fullscreen = false;
         if (!(command >> fullscreen)) {
-            getConsole().print("set-fullscreen-Error: Invalid value");
+            getConsole() << "set-fullscreen-Error: Invalid value" << Console::endl;
             return -3;
         }
         getWindow().setFullscreen(fullscreen);
     } else if (var.compare("audio") == 0) {
         bool audio = false;
         if (!(command >> audio)) {
-            getConsole().print("set-audio-Error: Invalid value");
+            getConsole() << "set-audio-Error: Invalid value" << Console::endl;
             return -4;
         }
         getSound().setEnabled(audio);
     } else if (var.compare("volume") == 0) {
         float vol = 1.0f;
         if (!(command >> vol)) {
-            getConsole().print("set-volume-Error: Invalid value");
+            getConsole() << "set-volume-Error: Invalid value" << Console::endl;
             return -5;
         }
         getSound().setVolume(vol);
     } else if (var.compare("mouse_x") == 0) {
         float sense = 1.0f;
         if (!(command >> sense)) {
-            getConsole().print("set-mouse_x-Error: Invalid value");
+            getConsole() << "set-mouse_x-Error: Invalid value" << Console::endl;
             return -6;
         }
         getCamera().setSensitivityX(OR_DEG_TO_RAD(sense));
     } else if (var.compare("mouse_y") == 0) {
         float sense = 1.0f;
         if (!(command >> sense)) {
-            getConsole().print("set-mouse_y-Error: Invalid value");
+            getConsole() << "set-mouse_y-Error: Invalid value" << Console::endl;
             return -7;
         }
         getCamera().setSensitivityY(OR_DEG_TO_RAD(sense));
     } else if (var.compare("fps") == 0) {
         bool fps = false;
         if (!(command >> fps)) {
-            getConsole().print("set-fps-Error: Invalid value");
+            getConsole() << "set-fps-Error: Invalid value" << Console::endl;
             return -8;
         }
         mFPS = fps;
         delete [] tmp;
         delete [] quotes;
     } else {
-        getConsole().print("set-Error: Unknown variable (%s)", var.c_str());
+        getConsole() << "set-Error: Unknown variable (" << var.c_str() << ")" << Console::endl;
         return -1;
     }
 
 
     ActionEvents e = stringToActionEvent(action);
     if (e == ActionEventCount) {
-        getConsole().print("bind-Error: Unknown action (%s --> %s)", key, action);
+        getConsole() << "bind-Error: Unknown action (" << key << " --> " << action << ")" << Console::endl;
         return -1;
     }
 
     KeyboardButton c = stringToKeyboardButton(key);
     if (c == unknownKey) {
-        getConsole().print("bind-Error: Unknown key (%s)", key);
+        getConsole() << "bind-Error: Unknown key (" << key << ")" << Console::endl;
         return -2;
     }
 

src/Console.cpp

     return mVisible;
 }
 
-template<typename T>
-Console &Console::operator<<(T t) {
-    printBuffer << t;
-
-    if (printBuffer.str().back() == '\n') {
-        mHistory.push_back(printBuffer.str().substr(0, printBuffer.str().length() - 1));
-#ifdef DEBUG
-        std::cout << printBuffer.str().substr(0, printBuffer.str().length() - 1) << std::endl;
-#endif
-        printBuffer.str("");
-    }
-
-    return (*this);
-}
-
-// Deprecated!
-void Console::print(const char *s, ...) {
-    va_list args;
-    va_start(args, s);
-    char *tmp = bufferString(s, args);
-    va_end(args);
-
-    if (tmp != nullptr)
-        (*this) << tmp << endl;
-
-    delete [] tmp;
-}
-
 #define LINE_GEOMETRY(window) \
     unsigned int firstLine = 35; \
     unsigned int lastLine = (window.getHeight() / 2) - 55; \
     if (pressed && (key == enterKey)) {
         // Execute entered command
         if (mInputBuffer.length() > 0) {
-            print("> %s", mInputBuffer.c_str());
+            (*this) << "> " << mInputBuffer.c_str() << endl;
             mCommandHistory.push_back(mInputBuffer.c_str());
             int error = getOpenRaider().command(mInputBuffer);
             if (error != 0) {
-                print("Error Code: %d", error);
+                (*this) << "Error Code: " << error << endl;
             }
         } else {
-            print("> ");
+            (*this) << "> " << endl;
         }
 
         // Clear partial and input buffer

src/Entity.cpp

                 x, y, z);
 
         if (roomNew > -1)
-            getConsole().print("Crossing from room %li to %li", room, roomNew);
+            getConsole() << "Crossing from room " << room << " to " << roomNew << Console::endl;
         else
             //! \fixme mRooms, sectors, ... are now std::vector, but often upper bound checks are missing
             return;
 }
 
 void Entity::print() {
-    getConsole().print("Entity %d:", objectId);
-    getConsole().print("  Room %li (0x%X)", room, getWorld().getRoom(room).getFlags());
-    getConsole().print("  %.1fx %.1fy %.1fz", pos[0], pos[1], pos[2]);
-    getConsole().print("  %.1f Yaw", OR_RAD_TO_DEG(angles[1]));
+    getConsole() << "Entity " << objectId << ":" << Console::endl
+        << "  Room " << room << " (" << getWorld().getRoom(room).getFlags()
+        << ")" << Console::endl
+        << "  " << pos[0] << "x " << pos[1] << "y " << pos[2] << "z"
+        << Console::endl
+        << "  " << OR_RAD_TO_DEG(angles[1]) << " Yaw" << Console::endl;
 }
 
 SkeletalModel &Entity::getModel() {

src/Game.cpp

 
     mName = bufferString("%s", level);
 
-    getConsole().print("Loading %s", mName);
+    getConsole() << "Loading " << mName << Console::endl;
     int error = mTombRaider.Load(mName);
     if (error != 0)
         return error;
         tmp[dir + 8] = '\0';
         error = mTombRaider.loadSFX(tmp);
         if (error != 0)
-            getConsole().print("Could not load %s", tmp);
+            getConsole() << "Could not load " << tmp << Console::endl;
         delete [] tmp;
     }
 
     mTombRaider.reset();
 
     if (mLara == -1) {
-        getConsole().print("Can't find Lara entity in level pak!");
+        getConsole() << "Can't find Lara entity in level pak!" << Console::endl;
         destroy();
         return -1;
     } else {
         }
     }
 
-    getConsole().print("Found %d sprites.", mTombRaider.NumSpriteSequences());
+    getConsole() << "Found " << mTombRaider.NumSpriteSequences() << " sprites." << Console::endl;
 }
 
 void Game::processRooms() {
     for (int index = 0; index < mTombRaider.NumRooms(); index++)
         getWorld().addRoom(*new Room(mTombRaider, index));
 
-    getConsole().print("Found %d rooms.", mTombRaider.NumRooms());
+    getConsole() << "Found " << mTombRaider.NumRooms() << " rooms." << Console::endl;
 }
 
 void Game::processModels() {
     for (int index = 0; index < mTombRaider.getMeshCount(); index++)
         getWorld().addStaticMesh(*new StaticMesh(mTombRaider, index));
 
-    getConsole().print("Found %d meshes.", mTombRaider.getMeshCount());
+    getConsole() << "Found " << mTombRaider.getMeshCount() << " meshes." << Console::endl;
 }
 
 void Game::processPakSounds()
         //getSound().SourceAt(id, pos);
     }
 
-    getConsole().print("Found %u sound samples.", mTombRaider.getSoundSamplesCount());
+    getConsole() << "Found " << mTombRaider.getSoundSamplesCount() << " sound samples." << Console::endl;
 }
 
 void Game::processTextures()
 
     mTextureOffset = (mTextureStart - 1) + mTombRaider.NumTextures();
 
-    getConsole().print("Found %d textures.", mTombRaider.NumTextures());
+    getConsole() << "Found " << mTombRaider.NumTextures() << " textures." << Console::endl;
 }
 
 void Game::processMoveables()
     }
     */
 
-    getConsole().print("Found %d moveables.", mTombRaider.NumMoveables() + statCount);
+    getConsole() << "Found " << mTombRaider.NumMoveables() + statCount << " moveables." << Console::endl;
 }
 
 // index moveable, i item, sometimes both moveable

src/Menu.cpp

         // Check maps for validity
         int error = TombRaider::checkMime(f.getPath().c_str());
         if (error != 0) {
-            getConsole().print("Error: pak file '%s' %s",
-                    f.getName().c_str(), (error == -1) ? "not found" : "invalid");
+            getConsole() << "Error: pak file '" << f.getName().c_str()
+                << "' " << ((error == -1) ? "not found" : "invalid") << Console::endl;
             return true; // delete file from list
         }
 

src/Room.cpp

     Matrix transform;
 
     if (!tr.isRoomValid(index)) {
-        getConsole().print("WARNING: Handling invalid vertex array in room");
-        //printf("x");
-        //fflush(stdout);
+        getConsole() << "WARNING: Handling invalid vertex array in room" << Console::endl;
         return;
     }
 
 
         if (texture > (int)TextureLimit)
         {
-            getConsole().print("Handling bad room[%i].tris[%i].texture = %i",
-                    index, t, texture);
+            getConsole() << "Handling bad room[" << index << "].tris["
+                << t << "].texture = " << texture << Console::endl;
             texture = TextureLimit - 1;
         }
 
 
         if (texture > (int)TextureLimit)
         {
-            getConsole().print("Handling bad room[%i].quad[%i].texture = %i",
-                    index, r, texture);
+            getConsole() << "Handling bad room[" << index << "].quad["
+                << r << "].texture = " << texture << Console::endl;
             texture = TextureLimit - 1;
         }
 

src/SkeletalModel.cpp

         }
 
         if (*frame_offset > tr.NumFrames()) {
-            getConsole().print("WARNING: Bad animation frame %i > %i (%u.%d)",
-                    *frame_offset, tr.NumFrames(), index, a);
+            getConsole() << "WARNING: Bad animation frame " << *frame_offset
+                << " > " << tr.NumFrames() << " (" << index << "." << a << ")"
+                << Console::endl;
             return;
         }
 
                 }
 
                 getRender().setFlags(Render::fRenderPonytail);
-                getConsole().print("Found known ponytail");
+                getConsole() << "Found known ponytail" << Console::endl;
             }
             break;
 
                 ponyOff2 = 0;
 
                 getRender().setFlags(Render::fRenderPonytail);
-                getConsole().print("Found ponytail?");
+                getConsole() << "Found ponytail?" << Console::endl;
             }
             break;
     }
         frame_offset += frame_step * (frame_cycle % a);
 
     if (a < 0) {
-        getConsole().print("Invalid animation data for model %d. Skip!", index);
+        getConsole() << "Invalid animation data for model " << index << ". Skip!" << Console::endl;
         return;
     } else {
         for (; a < tr.getNumAnimsForMoveable(index); a++) {

src/TextureManager.cpp

     } else if (stringEndsWith(filename, ".tga") || stringEndsWith(filename, ".TGA")) {
         return loadTGA(filename);
     } else {
-        getConsole().print("No known image file type? (%s)", filename);
+        getConsole() << "No known image file type? (" << filename << ")" << Console::endl;
     }
 
     return -1;
 
     return id;
 #else
-    getConsole().print("No PNG support available (%s)", filename);
+    getConsole() << "No PNG support available (" << filename << ")" << Console::endl;
     return -1;
 #endif
 }

src/main.cpp

     }
 
 #ifdef DEBUG
-    getConsole().print("Initializing %s", VERSION);
+    getConsole() << "Initializing " << VERSION << Console::endl;
 #endif
 
     atexit(cleanupHandler);
 
     command_free(&cmd);
 
-    getConsole().print("Starting %s", VERSION);
+    getConsole() << "Starting " << VERSION << Console::endl;
     getOpenRaider().run();
 
     return 0;
     } else if (strcmp(action, "walk") == 0) {
         return walkAction;
     } else {
-        getConsole().print("Unknown action: \"%s\"", action);
         return ActionEventCount;
     }
 }
         delete [] tmp;
     }
 
-    getConsole().print("Unknown key: %s", key);
     return unknownKey;
 }
 

src/utils/pcx.cpp

  */
 
 #include <fstream>
+#include <iostream>
 
 #include "global.h"
 #include "utils/pcx.h"
 
-#include "Console.h"
-#define pcxPrint getConsole().print
-
 int pcxCheck(const char *filename) {
     assert(filename != NULL);
     assert(filename[0] != '\0');
 
     // Basic validation
     if (!file.read((char *)(&header[0]), 128)) {
-        pcxPrint("File not big enough for valid PCX header!");
+        std::cout << "File not big enough for valid PCX header!" << std::endl;
         delete [] header;
         return -1;
     }
 
     if (header[0] != 0x0A) {
-        pcxPrint("Magic number at file start is wrong (0x%X != 0x0A)", header[0]);
+        std::cout << "Magic number at file start is wrong (" << header[0] << " != 0x0A)" << std::endl;
         delete [] header;
         return -2;
     }
 
     if ((header[1] != 0) && ((header[1] < 2) || (header[1] > 5))) {
         // Valid: 0, 2, 3, 4, 5
-        pcxPrint("Unknown PCX file format version (%d)", header[1]);
+        std::cout << "Unknown PCX file format version (" << header[1] << ")" << std::endl;
         delete [] header;
         return -3;
     }
 
     if ((header[2] != 0) && (header[2] != 1)) {
-        pcxPrint("Unknown PCX file encoding (%d)", header[2]);
+        std::cout << "Unknown PCX file encoding (" << header[2] << ")" << std::endl;
         delete [] header;
         return -4;
     }
 
     if (header[3] != 8) {
-        pcxPrint("Only supporting 8bit (%dbit)", header[3]);
+        std::cout << "Only supporting 8bit (" << header[3] << "bit)" << std::endl;
         delete [] header;
         return -5;
     }
 
     if (header[64] != 0) {
-        pcxPrint("Reserved field is  used (%d != 0)", header[64]);
+        std::cout << "Reserved field is  used (" << header[64] << " != 0)" << std::endl;
         delete [] header;
         return -6;
     }
 
     // Basic validation
     if (!file.read((char *)(&header[0]), 128)) {
-        pcxPrint("File not big enough for valid PCX header!");
+        std::cout << "File not big enough for valid PCX header!" << std::endl;
         delete [] header;
         return -1;
     }
 
     if (header[0] != 0x0A) {
-        pcxPrint("Magic number at file start is wrong (0x%X != 0x0A)", header[0]);
+        std::cout << "Magic number at file start is wrong (" << header[0] << " != 0x0A)" << std::endl;
         delete [] header;
         return -2;
     }
 
     if ((header[1] != 0) && ((header[1] < 2) || (header[1] > 5))) {
         // Valid: 0, 2, 3, 4, 5
-        pcxPrint("Unknown PCX file format version (%d)", header[1]);
+        std::cout << "Unknown PCX file format version (" << header[1] << ")" << std::endl;
         delete [] header;
         return -3;
     }
 
     if ((header[2] != 0) && (header[2] != 1)) {
-        pcxPrint("Unknown PCX file encoding (%d)", header[2]);
+        std::cout << "Unknown PCX file encoding (" << header[2] << ")" << std::endl;
         delete [] header;
         return -4;
     }
 
     if (header[3] != 8) {
-        pcxPrint("Only supporting 8bit (%dbit)", header[3]);
+        std::cout << "Only supporting 8bit (" << header[3] << "bit)" << std::endl;
         delete [] header;
         return -5;
     }
 
     if (header[64] != 0) {
-        pcxPrint("Reserved field is  used (%d != 0)", header[64]);
+        std::cout << "Reserved field is  used (" << header[64] << " != 0)" << std::endl;
         delete [] header;
         return -6;
     }
         unsigned int n = 1; // Run-length-encoding assumes 1
         int c = file.get();
         if (!file) {
-            pcxPrint("Could not read data (%lu%s)", i, (file.eof() ? " EOF" : ""));
+            std::cout << "Could not read data (" << i
+                << (file.eof() ? " EOF" : "") << ")" << std::endl;
             delete [] buffer;
             return -7;
         }
                 n = c & 0x3F;
                 c = file.get();
                 if (!file) {
-                    pcxPrint("Could not read data rle (%lu%s)", i, (file.eof() ? " EOF" : ""));
+                    std::cout << "Could not read data rle (" << i
+                        << (file.eof() ? " EOF" : "") << ")" << std::endl;
                     delete [] buffer;
                     return -8;
                 }
             for (unsigned int i = 0; i < 768; i++) {
                 palette[i] = (unsigned char)file.get();
                 if (!file) {
-                    pcxPrint("Could not read 256 color palette (%d)", i);
+                    std::cout << "Could not read 256 color palette (" << i << ")" << std::endl;
                     delete [] buffer;
                     delete [] palette;
                     return -9;
                     green = palette[(buffer[(y * totalBytes) + x] * 3) + 1];
                     blue = palette[(buffer[(y * totalBytes) + x] * 3) + 2];
                 } else {
-                    pcxPrint("Unsupported number of planes (%d)", nPlanes);
+                    std::cout << "Unsupported number of planes (" << nPlanes << ")" << std::endl;
                     delete [] buffer;
                     delete [] palette;
                     delete [] *image;
                 } else if (nPlanes == 1) {
                     red = green = blue = buffer[(y * totalBytes) + x];
                 } else {
-                    pcxPrint("Unsupported number of planes (%d)", nPlanes);
+                    std::cout << "Unsupported number of planes (" << nPlanes << ")" << std::endl;
                     delete [] buffer;
                     delete [] palette;
                     delete [] *image;

src/utils/png.cpp

 
 #include <png.h>
 #include <cstdio>
+#include <iostream>
 
 #include "global.h"
 #include "utils/pixel.h"
 #include "utils/png.h"
 
-#include "Console.h"
-#define pngPrint getConsole().print
-
 int pngCheck(const char *filename) {
     png_byte header[8];
 
 
     FILE *fp = fopen(filename, "rb");
     if (fp == NULL) {
-        pngPrint("Could not open %s", filename);
+        std::cout << "Could not open " << filename << std::endl;
         return -1;
     }
 
     fclose(fp);
 
     if (png_sig_cmp(header, 0, 8)) {
-        pngPrint("File %s is not a PNG.", filename);
+        std::cout << "File " << filename << " is not a PNG." << std::endl;
         return -2;
     }
 
 
     FILE *fp = fopen(filename, "rb");
     if (fp == NULL) {
-        pngPrint("Could not open %s", filename);
+        std::cout << "Could not open " << filename << std::endl;
         return -1;
     }
 
     fread(header, 1, 8, fp);
 
     if (png_sig_cmp(header, 0, 8)) {
-        pngPrint("File %s is not a PNG.", filename);
+        std::cout << "File " << filename << " is not a PNG." << std::endl;
         fclose(fp);
         return -2;
     }
 
     png_structp png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
     if (!png_ptr) {
-        pngPrint("png_create_read_struct returned 0.");
+        std::cout << "png_create_read_struct returned 0." << std::endl;
         fclose(fp);
         return -3;
     }
 
     png_infop info_ptr = png_create_info_struct(png_ptr);
     if (!info_ptr) {
-        pngPrint("png_create_info_struct returned 0.");
+        std::cout << "png_create_info_struct returned 0." << std::endl;
         png_destroy_read_struct(&png_ptr, (png_infopp)NULL, (png_infopp)NULL);
         fclose(fp);
         return -4;
 
     png_infop end_info = png_create_info_struct(png_ptr);
     if (!end_info) {
-        pngPrint("png_create_info_struct returned 0.");
+        std::cout << "png_create_info_struct returned 0." << std::endl;
         png_destroy_read_struct(&png_ptr, &info_ptr, (png_infopp) NULL);
         fclose(fp);
         return -5;
     }
 
     if (setjmp(png_jmpbuf(png_ptr))) {
-        pngPrint("Error from libpng");
+        std::cout << "Error from libpng" << std::endl;
         png_destroy_read_struct(&png_ptr, &info_ptr, &end_info);
         fclose(fp);
         return -6;
     *height = tmpHeight;
 
     if (bit_depth != 8) {
-        pngPrint("%s: Unsupported bit depth %d.  Must be 8.", filename, bit_depth);
+        std::cout << filename << ": Unsupported bit depth " << bit_depth << ".  Must be 8." << std::endl;
         return -7;
     }
 
         *mode = RGBA;
         *bpp = 32;
     } else {
-        pngPrint("%s: Unknown libpng color type %d.", filename, color_type);
+        std::cout << filename << ": Unknown libpng color type " << color_type << std::endl;
         delete [] image_data;
         return -8;
     }
 
     FILE *fp = fopen(filename, "wb");
     if (!fp) {
-        pngPrint("File %s could not be opened for writing", filename);
+        std::cout << "File " << filename << " could not be opened for writing" << std::endl;
         return -1;
     }
 
     png_structp png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
 
     if (!png_ptr) {
-        pngPrint("png_create_write_struct failed");
+        std::cout << "png_create_write_struct failed" << std::endl;
         fclose(fp);
         return -2;
     }
 
     png_infop info_ptr = png_create_info_struct(png_ptr);
     if (!info_ptr) {
-        pngPrint("png_create_info_struct failed");
+        std::cout << "png_create_info_struct failed" << std::endl;
         fclose(fp);
         return -3;
     }
 
     if (setjmp(png_jmpbuf(png_ptr))) {
-        pngPrint("Error during init_io");
+        std::cout << "Error during init_io" << std::endl;
         fclose(fp);
         return -4;
     }
     png_init_io(png_ptr, fp);
 
     if (setjmp(png_jmpbuf(png_ptr))) {
-        pngPrint("Error during writing header");
+        std::cout << "Error during writing header" << std::endl;
         fclose(fp);
         return -5;
     }
         }
         color_type = PNG_COLOR_TYPE_RGB_ALPHA;
     } else {
-        pngPrint("Error invalid color mode");
+        std::cout << "Error invalid color mode" << std::endl;
         fclose(fp);
         return -6;
     }
         row_pointers[height - 1 - i] = image + (i * width * 4);
 
     if (setjmp(png_jmpbuf(png_ptr))) {
-        pngPrint("Error during writing bytes");
+        std::cout << "Error during writing bytes" << std::endl;
         delete [] row_pointers;
         fclose(fp);
         return -7;
     png_write_image(png_ptr, row_pointers);
 
     if (setjmp(png_jmpbuf(png_ptr))) {
-        pngPrint("Error during end of write");
+        std::cout << "Error during end of write" << std::endl;
         delete [] row_pointers;
         fclose(fp);
         return -8;