gosu 0.7.10.1

data/GosuImpl/RubyGosu_wrap.h

@@ -0,0 +1,31 @@
+/* ----------------------------------------------------------------------------
+ * This file was automatically generated by SWIG (http://www.swig.org).
+ * Version 1.3.31
+ * 
+ * This file is not intended to be easily readable and contains a number of 
+ * coding conventions designed to improve portability and efficiency. Do not make
+ * changes to this file unless you know what you are doing--modify the SWIG 
+ * interface file instead. 
+ * ----------------------------------------------------------------------------- */
+
+#ifndef SWIG_Gosu_WRAP_H_
+#define SWIG_Gosu_WRAP_H_
+
+namespace Swig {
+  class Director;
+}
+
+
+class SwigDirector_Window : public Gosu::Window, public Swig::Director {
+
+public:
+    SwigDirector_Window(VALUE self, unsigned int width, unsigned int height, bool fullscreen, double updateInterval = 16.666666);
+    virtual ~SwigDirector_Window();
+    virtual void update();
+    virtual void draw();
+    virtual void buttonDown(Gosu::Button arg0);
+    virtual void buttonUp(Gosu::Button arg0);
+};
+
+
+#endif

data/GosuImpl/Sockets/CommSocket.cpp

@@ -0,0 +1,304 @@
+#include <Gosu/Sockets.hpp>
+#include <GosuImpl/Sockets/Sockets.hpp>
+#include <cassert>
+#include <cstring>
+#include <stdexcept>
+#include <vector>
+
+struct Gosu::CommSocket::Impl
+{
+    Socket socket;
+    CommMode mode;
+
+    typedef std::vector<char> Buffer;
+    Buffer inbox, outbox;
+
+    void appendBuffer(const char* buffer, std::size_t size,
+        boost::function<void (const void*, std::size_t)>& event)
+    {
+        switch (mode)
+        {
+            case cmRaw:
+            {
+                // Raw = simple! Yay.
+                if (event)
+                    event(buffer, size);
+
+                break;
+            }
+
+            case cmManaged:
+            {
+                // Append new data to inbox.
+                inbox.insert(inbox.end(), buffer, buffer + size);
+
+                for (;;) // IMPR.
+                {
+                    const size_t sizeSize = sizeof(u_long);
+
+                    // Not even enough bytes there to determine the size of the
+                    // incoming message.
+                    if (inbox.size() < sizeSize)
+                        break;
+
+                    // Message size is already here, convert it.
+                    u_long msgSize = *reinterpret_cast<u_long*>(&inbox[0]);
+                    msgSize = ntohl(msgSize);
+
+                    // Can't really handle zero-size messages. IMPR?!
+                    if (msgSize == 0)
+                        throw std::logic_error("Cannot handle empty messages");
+
+                    // Has the current message arrived completely?
+                    if (inbox.size() < sizeSize + msgSize)
+                        break;
+
+                    // Current message is here: Call event...
+                    if (event)
+                        event(&inbox[sizeSize], msgSize);
+
+                    // ...and delete it from the inbox.
+                    inbox.erase(inbox.begin(),
+                        inbox.begin() + sizeSize + msgSize);
+                }
+
+                break;
+            }
+        }
+    }
+};
+
+Gosu::CommSocket::CommSocket(CommMode mode, SocketAddress targetAddress,
+    SocketPort targetPort)
+: pimpl(new Impl)
+{
+    pimpl->mode = mode;
+
+    sockaddr_in addr;
+    std::memset(&addr, 0, sizeof addr);
+    addr.sin_family = AF_INET;
+    addr.sin_addr.s_addr = htonl(targetAddress);
+    addr.sin_port = htons(targetPort);
+
+    pimpl->socket.setHandle(socketCheck(::socket(AF_INET, SOCK_STREAM, 0)));
+    pimpl->socket.setBlocking(true);
+    socketCheck(::connect(pimpl->socket.handle(), reinterpret_cast<sockaddr*>(&addr),
+        sizeof addr));
+    pimpl->socket.setBlocking(false);
+}
+
+Gosu::CommSocket::CommSocket(CommMode mode, Socket& socket)
+: pimpl(new Impl)
+{
+    pimpl->mode = mode;
+
+    pimpl->socket.swap(socket);
+    pimpl->socket.setBlocking(false);
+}
+
+Gosu::CommSocket::~CommSocket()
+{
+}
+
+Gosu::SocketAddress Gosu::CommSocket::address() const
+{
+    return pimpl->socket.address();
+}
+
+Gosu::SocketPort Gosu::CommSocket::port() const
+{
+    return pimpl->socket.port();
+}
+
+Gosu::SocketAddress Gosu::CommSocket::remoteAddress() const
+{
+    assert(connected());
+
+    sockaddr_in addr;
+    int size = sizeof addr;
+    socketCheck(::getpeername(pimpl->socket.handle(),
+        reinterpret_cast<sockaddr*>(&addr),
+        reinterpret_cast<socklen_t*>(&size)));
+
+    return ntohl(addr.sin_addr.s_addr);
+}
+
+Gosu::SocketPort Gosu::CommSocket::remotePort() const
+{
+    assert(connected());
+
+    sockaddr_in addr;
+    int size = sizeof addr;
+    socketCheck(::getpeername(pimpl->socket.handle(),
+        reinterpret_cast<sockaddr*>(&addr),
+        reinterpret_cast<socklen_t*>(&size)));
+    return ntohs(addr.sin_port);
+}
+
+Gosu::CommMode Gosu::CommSocket::mode() const
+{
+    return pimpl->mode;
+}
+
+bool Gosu::CommSocket::connected() const
+{
+    return pimpl->socket.handle() != INVALID_SOCKET;
+}
+
+void Gosu::CommSocket::disconnect()
+{
+    pimpl->socket.setHandle(INVALID_SOCKET);
+    // IMPR: Mmmmh. A full-blown sockets library should probably try to send
+    // the remaining contents of the outbox. This is annoying to implement,
+    // though...
+    pimpl->outbox.clear();
+    if (onDisconnection)
+        onDisconnection();
+}
+
+bool Gosu::CommSocket::keepAlive() const
+{
+    int buf;
+    int size = sizeof buf;
+    socketCheck(::getsockopt(pimpl->socket.handle(), SOL_SOCKET, SO_KEEPALIVE,
+        reinterpret_cast<char*>(&buf),
+        reinterpret_cast<socklen_t*>(&size)));
+    return buf != 0;
+}
+
+void Gosu::CommSocket::setKeepAlive(bool value)
+{
+    int buf = value;
+    socketCheck(::setsockopt(pimpl->socket.handle(), SOL_SOCKET, SO_KEEPALIVE,
+        reinterpret_cast<char*>(&buf), sizeof buf));
+}
+
+void Gosu::CommSocket::update()
+{
+    sendPendingData();
+
+    if (!connected())
+        return;
+
+    for (;;)
+    {
+        char buffer[1024];
+        int received = ::recv(pimpl->socket.handle(), buffer, sizeof buffer, 0);
+
+        if (received > 0 && received <= static_cast<int>(sizeof buffer))
+        {
+            // Data arrived and fit into the buffer.
+            pimpl->appendBuffer(buffer, received, onReceive);
+        }
+        else if (received == 0)
+        {
+            // The other side has gracefully closed the connection.
+            disconnect();
+            return;
+        }
+        else if (received == SOCKET_ERROR)
+        {
+            switch (lastSocketError())
+            {
+                // Arriving data didn't fit into the buffer.
+                case GOSU_SOCK_ERR(EMSGSIZE):
+                    pimpl->appendBuffer(buffer, sizeof buffer, onReceive);
+                    break;
+
+                // There simply was no data.
+                case GOSU_SOCK_ERR(EWOULDBLOCK):
+                    return;
+
+                // Connection was reset or is invalid.
+                case GOSU_SOCK_ERR(ENETDOWN):
+                case GOSU_SOCK_ERR(ENOTCONN):
+                case GOSU_SOCK_ERR(ENETRESET):
+                case GOSU_SOCK_ERR(ECONNABORTED):
+                case GOSU_SOCK_ERR(ETIMEDOUT):
+                case GOSU_SOCK_ERR(ECONNRESET):
+				#ifndef GOSU_IS_WIN
+				// UNIX specific, rare error
+                case GOSU_SOCK_ERR(EPIPE):
+				#endif
+                    disconnect();
+                    return;
+
+                // Everything else is unexpected.
+                default:
+                    throwLastSocketError();
+            }
+        }
+        else assert(false);
+    }
+}
+
+void Gosu::CommSocket::send(const void* buffer, std::size_t size)
+{
+    if (!connected())
+        return;
+
+    // In managed mode, also send the length of the buffer.
+    if (mode() == cmManaged)
+    {
+        u_long netSize = htonl(size);
+        const char* charBuf = reinterpret_cast<const char*>(&netSize);
+        pimpl->outbox.insert(pimpl->outbox.end(), charBuf,
+            charBuf + sizeof netSize);
+    }
+
+    const char* charBuf = reinterpret_cast<const char*>(buffer);
+    pimpl->outbox.insert(pimpl->outbox.end(), charBuf, charBuf + size);
+}
+
+void Gosu::CommSocket::sendPendingData()
+{
+    if (pendingBytes() == 0 || !connected())
+        return;
+
+    int sent = ::send(pimpl->socket.handle(), &pimpl->outbox.front(),
+        pendingBytes(), 0);
+
+    if (sent >= 0)
+    {
+        // Remove sent data from the outbox.
+        if (sent >= static_cast<int>(pendingBytes()))
+            pimpl->outbox.clear();
+        else
+            pimpl->outbox.erase(pimpl->outbox.begin(),
+                pimpl->outbox.begin() + sent);
+    }
+    else
+    {
+        switch (lastSocketError())
+        {
+            // These error codes basically mean "try again later".
+            case GOSU_SOCK_ERR(ENOBUFS):
+            case GOSU_SOCK_ERR(EWOULDBLOCK):
+            case GOSU_SOCK_ERR(EHOSTUNREACH):
+                break;
+
+            // And these tell us we're disconnected.
+            case GOSU_SOCK_ERR(ENETDOWN):
+            case GOSU_SOCK_ERR(ENETRESET):
+            case GOSU_SOCK_ERR(ENOTCONN):
+            case GOSU_SOCK_ERR(ECONNABORTED):
+            case GOSU_SOCK_ERR(ECONNRESET):
+            case GOSU_SOCK_ERR(ETIMEDOUT):
+			#ifndef GOSU_IS_WIN
+			// UNIX-specific, rare error
+            case GOSU_SOCK_ERR(EPIPE):
+			#endif
+                disconnect();
+                break;
+
+            // Everything else is unexpected.
+            default:
+                throwLastSocketError();
+        }
+    }
+}
+
+std::size_t Gosu::CommSocket::pendingBytes() const
+{
+    return pimpl->outbox.size();
+}

data/GosuImpl/Sockets/ListenerSocket.cpp

@@ -0,0 +1,60 @@
+#include <Gosu/Sockets.hpp>
+#include <GosuImpl/Sockets/Sockets.hpp>
+#include <cassert>
+#include <cstring>
+
+struct Gosu::ListenerSocket::Impl
+{
+    Socket socket;
+};
+
+Gosu::ListenerSocket::ListenerSocket(SocketPort port)
+: pimpl(new Impl)
+{
+    pimpl->socket.setHandle(socketCheck(::socket(AF_INET, SOCK_STREAM, 0)));
+    pimpl->socket.setBlocking(false);
+
+    int enable = 1;
+    socketCheck(::setsockopt(pimpl->socket.handle(), SOL_SOCKET, SO_REUSEADDR,
+        reinterpret_cast<char*>(&enable), sizeof enable));
+
+    sockaddr_in addr;
+    std::memset(&addr, 0, sizeof addr);
+    addr.sin_family = AF_INET;
+//    addr.sin_addr.S_un.S_addr = ::htonl(INADDR_ANY);
+    addr.sin_addr.s_addr = htonl(INADDR_ANY);
+    addr.sin_port = htons(port);
+    socketCheck(::bind(pimpl->socket.handle(),
+        reinterpret_cast<sockaddr*>(&addr), sizeof addr));
+    socketCheck(::listen(pimpl->socket.handle(), 10));
+}
+
+Gosu::ListenerSocket::~ListenerSocket()
+{
+}
+
+Gosu::SocketAddress Gosu::ListenerSocket::address() const
+{
+    return pimpl->socket.address();
+}
+
+Gosu::SocketPort Gosu::ListenerSocket::port() const
+{
+    return pimpl->socket.port();
+}
+
+void Gosu::ListenerSocket::update()
+{
+    while (onConnection)
+    {
+        SocketHandle newHandle =
+            socketCheck(::accept(pimpl->socket.handle(), 0, 0));
+
+        if (newHandle == INVALID_SOCKET)
+            break;
+
+        Socket newSocket;
+        newSocket.setHandle(newHandle);
+        onConnection(newSocket);
+    }
+}

data/GosuImpl/Sockets/MessageSocket.cpp

@@ -0,0 +1,136 @@
+#include <Gosu/Sockets.hpp>
+#include <GosuImpl/Sockets/Sockets.hpp>
+#include <cassert>
+#include <cstring>
+#include <vector>
+
+struct Gosu::MessageSocket::Impl
+{
+    Socket socket;
+    std::size_t maxMessageSize;
+};
+
+Gosu::MessageSocket::MessageSocket(SocketPort port)
+: pimpl(new Impl)
+{
+    pimpl->socket.setHandle(socketCheck(::socket(AF_INET, SOCK_DGRAM, 0)));
+    pimpl->socket.setBlocking(false);
+    sockaddr_in addr;
+    std::memset(&addr, 0, sizeof addr);
+    addr.sin_family = AF_INET;
+//    addr.sin_addr.S_un.S_addr = ::htonl(INADDR_ANY);
+    addr.sin_addr.s_addr = htonl(INADDR_ANY);
+    addr.sin_port = htons(port);
+    socketCheck(::bind(pimpl->socket.handle(),
+        reinterpret_cast<sockaddr*>(&addr), sizeof addr));
+
+//FIXME: Unix: implement this. SO_MAX_MSG_SIZE not defined.
+#ifdef WIN32
+    unsigned maxMessageSize;
+    int size = sizeof maxMessageSize;
+    socketCheck(::getsockopt(pimpl->socket.handle(), SOL_SOCKET, SO_MAX_MSG_SIZE,
+        reinterpret_cast<char*>(&maxMessageSize), &size));
+    pimpl->maxMessageSize = maxMessageSize;
+#endif
+}
+
+Gosu::MessageSocket::~MessageSocket()
+{
+}
+
+Gosu::SocketAddress Gosu::MessageSocket::address() const
+{
+    return pimpl->socket.address();
+}
+
+Gosu::SocketPort Gosu::MessageSocket::port() const
+{
+    return pimpl->socket.port();
+}
+
+std::size_t Gosu::MessageSocket::maxMessageSize() const
+{
+    return pimpl->maxMessageSize;
+}
+
+void Gosu::MessageSocket::update()
+{
+    std::vector<char> buffer(maxMessageSize());
+
+    sockaddr_in addr;
+    int size = sizeof addr;
+
+    for (;;)
+    {
+        int received = ::recvfrom(pimpl->socket.handle(), &buffer.front(),
+            buffer.size(), 0, reinterpret_cast<sockaddr*>(&addr),
+            reinterpret_cast<socklen_t*>(&size));
+
+        if (received != SOCKET_ERROR && onReceive)
+        {
+//            onReceive(::ntohl(addr.sin_addr.S_un.S_addr),
+            onReceive(ntohl(addr.sin_addr.s_addr),
+                ntohs(addr.sin_port), &buffer.front(), received);
+        }
+        else switch (lastSocketError())
+        {
+            // Ignore some of the errors.
+            case GOSU_SOCK_ERR(EWOULDBLOCK):
+            case GOSU_SOCK_ERR(ENETDOWN):
+            case GOSU_SOCK_ERR(ENETRESET):
+            case GOSU_SOCK_ERR(ETIMEDOUT):
+            // IMPR: "The application should close the socket..."??
+            case GOSU_SOCK_ERR(ECONNRESET):
+                return;
+
+            // Everything else is unexpected.
+            default:
+                throwLastSocketError();
+        }
+    }
+}
+
+void Gosu::MessageSocket::send(SocketAddress address, SocketPort port,
+    const void* buffer, std::size_t size)
+{
+    sockaddr_in addr;
+    std::memset(&addr, 0, sizeof addr);
+    addr.sin_family = AF_INET;
+//    addr.sin_addr.S_un.S_addr = ::htonl(address);
+    addr.sin_addr.s_addr = htonl(address);
+    addr.sin_port = htons(port);
+
+    int sent = ::sendto(pimpl->socket.handle(),
+        reinterpret_cast<const char*>(buffer), size, 0,
+        reinterpret_cast<sockaddr*>(&addr), sizeof addr);
+
+    if (sent == static_cast<int>(size))
+        return; // Yay, did it!
+
+    assert(sent == SOCKET_ERROR); // Don't expect partial sends.
+
+    switch (lastSocketError())
+    {
+        // Just ignore a lot of errors... this is UDP, right?
+        case GOSU_SOCK_ERR(ENETDOWN):
+        case GOSU_SOCK_ERR(ENETRESET):
+        case GOSU_SOCK_ERR(ENOBUFS):
+        case GOSU_SOCK_ERR(EWOULDBLOCK):
+        case GOSU_SOCK_ERR(EHOSTUNREACH):
+        case GOSU_SOCK_ERR(ECONNABORTED):
+        case GOSU_SOCK_ERR(ECONNRESET):
+        case GOSU_SOCK_ERR(ENETUNREACH):
+        case GOSU_SOCK_ERR(ETIMEDOUT):
+            break;
+
+        // Everything else means more than just another lost packet, though.
+        default:
+            throwLastSocketError();
+    }
+}
+
+/*void Gosu::MessageSocket::broadcast(SocketPort port,
+    const void* buffer, std::size_t size)
+{
+    assert(false);
+}*/