Thoughts on a proxy-based bot-making API?

/* auto_reply_bot.cpp
 This is the primary code file you'll be editing to fit in your packet events and sending packets.
*/

#include "auto_reply_bot.hpp"

#include <string>

namespace auto_reply_bot
{
    std::string* auto_reply; //var to hold our auto reply message
    bool auto_reply_on=false;

    client_packet_event::client_packet_event()
    {
        // the register_event() function is required to overide the internal handle for these packets.
        // you must register each packet you use for code to work, everything else will be forwarded by the api.
        register_event(CHAT_PACKET);
    }

    void client_packet_event::on_chat_packet(chat_packet* chat)
    {
        if (chat->is_command()) // is_command() returns true if the chat message begins with "/"
        {
            if (strcmp((const char*)chat->strip_command(),"autoreply")) // strip_command() returns the string that follows a "/"
            {
                auto_reply = chat->strip_args();  // strip_args() returns the rest of message after the command.
                auto_reply_on = true;
            }
            if (strcmp((const char*)chat->strip_command(),"noreply"))
            {
                auto_reply_on = false;
            }
        }
        else send_to_server((packet*)chat);
    }


    server_packet_event::server_packet_event()
    {
        register_event(CHAT_PACKET);
    }

    void server_packet_event::on_chat_packet(chat_packet* chat)
    {
        if (auto_reply_on)
        {
            if (chat->chat_type()==WHISPER)
            {
                chat_packet reply;
                reply.msg_from(my_hero->name);
                reply.send_to(chat->msg_from());
                reply.chat_type(WHISPER);
                reply.message(auto_reply);

                send_to_server((packet*)&reply);
            }
        }
        send_to_client((packet*)chat);
    }
}

/* auto_reply_bot.hpp
 Header file for the bot, you can add to this, but needn't worry about
 what is already written here, it will be auto-generated from a template.
*/

#include <blacknull.hpp>

namespace auto_reply_bot
{
    using namespace blacknull;

    class client_packet_event : public packet_event
    {
        public:
            client_packet_event();
            virtual ~client_packet_event();
        private:
            void on_chat_packet(chat_packet*);
            void on_hero_info_packet(hero_info_packet*);
            void on_create_character_packet(create_character_packet*);
            //.. on_other_packets_etc(...)
            //... Will contain a full list of client packets eventually

    };

    class server_packet_event : public packet_event
    {
        public:
            server_packet_event();
            virtual ~server_packet_event();
        private:
            void on_chat_packet(chat_packet*);
            void on_spawn_packet(spawn_packet*);
            //.. Will also contain a completed list

    };
}

/* main.cpp
 Auto generated file to start up the basic proxy.
*/

#include <blacknull.hpp>
#include "auto_reply_bot.hpp"

using namespace blacknull;
using namespace auto_reply_bot;

int main(int argc, char* argv[])
{
    proxy_config* config = new proxy_config();
    config->local_auth_ip("127.0.0.1");   //This is uneccessary since localhost is the default in the api
    config->local_game_ip("127.0.0.1");   //Just to demonstrate other IPs can be used instead.

    packet_event* client_events = new server_packet_event();
    packet_event* server_events = new client_packet_event();

    proxy* co_proxy = new proxy(config, client_events, server_events);
    co_proxy->run();
}

#ifndef LOGIN_PACKET_HPP
#define LOGIN_PACKET_HPP

#include "base_packet.hpp"
#include "packets.hpp"
#include "../crypto/password_encryption.hpp"

class login_packet : public packet
{
    public:
        login_packet() : packet(LOGIN_PACKET, 52);
        virtual ~login_packet() {};

        void username(std::string username)
        {
            write<const char*>(username.c_str(), 4, 16);
        }
        std::string username(void)
        {
            return = read<const char*>(4);
        }
        void password(std::string password)
        {
            write<const char*>(password_crypto.encrypt(password.c_str(),16), 20, 16);
        }
        std::string password(void)
        {
            return password_crypto.decrypt(read<const char*>(20)),16);
        }
        void server(std::string server)
        {
            write<const char*>(server.c_str(), 36, 16);
        }
        std::string server(void)
        {
            return read<const char*>(36);
        }
    protected:
    private:
};

#endif // LOGIN_PACKET_HPP