#include <streambuf>

struct setchan
{
    setchan(msg_channel_type chan);
    msg_channel_type m_chan;
};
struct setparam
{
    setparam(int param);
    int m_param;
};
std::ostream& operator<<(std::ostream& os, const setchan& sc);
std::ostream& operator<<(std::ostream& os, const setparam& sp);

class mpr_stream_buf : public std::streambuf
{
public:
    mpr_stream_buf();
protected:
    int overflow(int c);
private:
    static const int INTERNAL_LENGTH = 500;
    char internal_buf[500]; // if your terminal is wider than this, too bad
    int internal_count;
};
extern std::ostream mpr_stream;

// globals controlling message output
// there must be a better way to do this!
static bool mpr_stream_silent = false;
static msg_channel_type mpr_stream_channel = MSGCH_PLAIN;
static int mpr_stream_param = 0;
std::ostream mpr_stream(new mpr_stream_buf);
setchan::setchan(msg_channel_type chan)
{
    m_chan = chan;
}
setparam::setparam(int param)
{
    m_param = param;
}
std::ostream& operator<<(std::ostream& os, const setchan& sc)
{
    mpr_stream_channel = sc.m_chan;
    return os;
}
std::ostream& operator<<(std::ostream& os, const setparam& sp)
{
    mpr_stream_param = sp.m_param;
    return os;
}
mpr_stream_buf::mpr_stream_buf()
{
    for ( int i = 0; i < INTERNAL_LENGTH; ++i )
        internal_buf[0] = 0;
    internal_count = 0;
}
// again, can be improved
int mpr_stream_buf::overflow(int c)
{
    if ( c == '\n' )
    {
        // null-terminate the string
        internal_buf[internal_count] = 0;
        if ( !mpr_stream_silent )
            mpr(internal_buf, mpr_stream_channel, mpr_stream_param);
        internal_count = 0;
        // reset to defaults (channel changing isn't sticky)
        mpr_stream_channel = MSGCH_PLAIN;
        mpr_stream_param = 0;
    }
    else
        internal_buf[internal_count++] = c;

    if ( internal_count + 3 > INTERNAL_LENGTH )
    {
        mpr("oops, hit overflow", MSGCH_DANGER);
        internal_count = 0;
        return std::streambuf::traits_type::eof();
    }
    return 0;
}

    mpr_stream_silent = true;

    mpr_stream_silent = msuppressed;

#include <iostream>

#include "message.h"

    bool game_start = initialise();

    const bool game_start = initialise();

        mprf( "Welcome, %s the %s %s.", 
              you.your_name,
              species_name( you.species,you.experience_level ),
              you.class_name );

        mpr_stream << "Welcome, " << you.your_name << " the "
                   << species_name( you.species,you.experience_level )
                   << " " << you.class_name << "."
                   << std::endl;

            int ch = 'x';    
            mpr("Press any key to start the tutorial intro, "
                "or Escape to skip it.", MSGCH_TUTORIAL);

            int ch = 'x';
            mpr_stream << setchan(MSGCH_TUTORIAL)
                       << "Press any key to start the tutorial intro, "
                       << "or Escape to skip it."
                       << std::endl;

    bool ret;
    int i = 0, j = 0;           // counter variables {dlb}

    // Ensure no buffering on the mpr() stream.
    mpr_stream << std::nounitbuf;

    for (i = 0; i < MAX_ITEMS; i++)

    for (int i = 0; i < MAX_ITEMS; i++)

    for (i = 0; i < MAX_MONSTERS; i++)

    for (int i = 0; i < MAX_MONSTERS; i++)

    for (i = 0; i < GXM; i++)
    {
        for (j = 0; j < GYM; j++)
        {
            igrd[i][j] = NON_ITEM;
            mgrd[i][j] = NON_MONSTER;
            env.map[i][j] = 0;

    igrd.init(NON_ITEM);
    mgrd.init(NON_MONSTER);
    env.map.init(0);
    for (int i = 0; i < GXM; i++)
        for (int j = 0; j < GYM; j++)

        }
    }

    bool newc = new_game();
    ret = newc;  // newc will be mangled later so we'll take a copy --bwr

    const bool newc = new_game();

    clua.runhook("chk_startgame", "%b", ret);

    clua.runhook("chk_startgame", "%b", newc);

    return (ret);

    return (newc);