ahn?

CMakeLists.txt

@@ -59,7 +59,7 @@ SET(SOURCES
     src/teststate.cpp
 
 # game net
-    src/net/protocoltibia87.cpp
+    src/protocollogin.cpp
 
 # framework core
     src/framework/core/dispatcher.cpp
@@ -108,7 +108,6 @@ SET(SOURCES
 
 # framework net
     src/framework/net/connection.cpp
-    src/framework/net/connections.cpp
     src/framework/net/protocol.cpp
     src/framework/net/networkmessage.cpp
 )

src/framework/core/configs.cpp

@@ -22,8 +22,9 @@
  */
 
 
-#include "configs.h"
-#include "resources.h"
+#include <prerequisites.h>
+#include <core/configs.h>
+#include <core/resources.h>
 
 Configs g_configs;
 

src/framework/core/configs.h

@@ -25,7 +25,7 @@
 #ifndef CONFIGS_H
 #define CONFIGS_H
 
-#include "prerequisites.h"
+#include <prerequisites.h>
 
 class Configs
 {

src/framework/core/dispatcher.cpp

@@ -22,9 +22,9 @@
  */
 
 
-#include "dispatcher.h"
-#include "platform.h"
-#include "engine.h"
+#include <prerequisites.h>
+#include <core/dispatcher.h>
+#include <core/engine.h>
 
 Dispatcher g_dispatcher;
 
@@ -32,7 +32,7 @@ void Dispatcher::poll()
 {
     while(!m_taskList.empty()) {
         Task *task = m_taskList.top();
-        if(g_engine.getLastFrameTicks() < task->ticks)
+        if(g_engine.getCurrentFrameTicks() < task->ticks)
             break;
 
         task->callback();
@@ -43,7 +43,7 @@ void Dispatcher::poll()
 
 void Dispatcher::scheduleTask(const Callback& callback, int delay)
 {
-    m_taskList.push(new Task(Platform::getTicks() + delay, callback));
+    m_taskList.push(new Task(g_engine.getCurrentFrameTicks() + delay, callback));
 }
 
 void Dispatcher::addTask(const Callback& callback)

src/framework/core/dispatcher.h

@@ -25,9 +25,7 @@
 #ifndef DISPATCHER_H
 #define DISPATCHER_H
 
-#include "prerequisites.h"
-
-#include <queue>
+#include <prerequisites.h>
 
 class Task {
 public:

src/framework/core/engine.cpp

@@ -22,15 +22,14 @@
  */
 
 
-#include "engine.h"
-#include "graphics/fonts.h"
-#include "platform.h"
-#include "graphics/graphics.h"
-#include "configs.h"
-#include "dispatcher.h"
-#include "net/connections.h"
-#include "ui/uicontainer.h"
-#include "graphics/fonts.h"
+#include <prerequisites.h>
+#include <core/engine.h>
+#include <core/platform.h>
+#include <core/dispatcher.h>
+#include <graphics/graphics.h>
+#include <graphics/fonts.h>
+#include <ui/uicontainer.h>
+//#include <net/connection.h>
 
 Engine g_engine;
 
@@ -70,7 +69,7 @@ void Engine::run()
         Platform::poll();
 
         // poll network events
-        g_connections.poll();
+        //Connection::poll();
 
         // poll diaptcher tasks
         g_dispatcher.poll();

src/framework/core/engine.h

@@ -25,8 +25,8 @@
 #ifndef ENGINE_H
 #define ENGINE_H
 
-#include "prerequisites.h"
-#include "gamestate.h"
+#include <prerequisites.h>
+#include <core/gamestate.h>
 
 class Engine
 {
@@ -61,7 +61,7 @@ public:
     /// Enable FPS counter on screen
     void enableFpsCounter(bool enable = true) { m_calculateFps = enable; };
 
-    int getLastFrameTicks() const { return m_lastFrameTicks; }
+    int getCurrentFrameTicks() const { return m_lastFrameTicks; }
 
 private:
     /// Called to render every frame

src/framework/core/gamestate.h

@@ -25,8 +25,8 @@
 #ifndef GAMESTATE_H
 #define GAMESTATE_H
 
-#include "prerequisites.h"
-#include "input.h"
+#include <prerequisites.h>
+#include <core/input.h>
 
 struct InputEvent;
 

src/framework/core/input.h

@@ -25,7 +25,7 @@
 #ifndef INPUT_H
 #define INPUT_H
 
-#include "prerequisites.h"
+#include <prerequisites.h>
 
 enum EKeyCode {
     KC_UNKNOWN     = 0x00,

src/framework/core/platform.h

@@ -25,7 +25,7 @@
 #ifndef PLATFORM_H
 #define PLATFORM_H
 
-#include "prerequisites.h"
+#include <prerequisites.h>
 
 namespace Platform
 {

src/framework/core/resources.cpp

@@ -22,7 +22,8 @@
  */
 
 
-#include "resources.h"
+#include <prerequisites.h>
+#include <core/resources.h>
 
 #include <physfs.h>
 

src/framework/core/resources.h

@@ -25,7 +25,7 @@
 #ifndef RESOURCES_H
 #define RESOURCES_H
 
-#include "prerequisites.h"
+#include <prerequisites.h>
 
 class Resources
 {

src/framework/graphics/borderedimage.cpp

@@ -22,9 +22,10 @@
  */
 
 
-#include "borderedimage.h"
-#include "graphics.h"
-#include "textures.h"
+#include <prerequisites.h>
+#include <graphics/borderedimage.h>
+#include <graphics/graphics.h>
+#include <graphics/textures.h>
 
 BorderedImage::BorderedImage(TexturePtr texture,
                              const Rect& left,

src/framework/graphics/borderedimage.h

@@ -25,9 +25,9 @@
 #ifndef BORDEREDIMAGE_H
 #define BORDEREDIMAGE_H
 
-#include "prerequisites.h"
-#include "image.h"
-#include "texture.h"
+#include <prerequisites.h>
+#include <graphics/image.h>
+#include <graphics/texture.h>
 
 class BorderedImage : public Image
 {

src/framework/graphics/font.cpp

@@ -22,10 +22,11 @@
  */
 
 
-#include "font.h"
-#include "core/resources.h"
-#include "textures.h"
-#include "graphics.h"
+#include <prerequisites.h>
+#include <core/resources.h>
+#include <graphics/font.h>
+#include <graphics/textures.h>
+#include <graphics/graphics.h>
 
 void Font::calculateGlyphsWidthsAutomatically(const Size& glyphSize)
 {

src/framework/graphics/font.h

@@ -25,8 +25,8 @@
 #ifndef FONT_H
 #define FONT_H
 
-#include "prerequisites.h"
-#include "texture.h"
+#include <prerequisites.h>
+#include <graphics/texture.h>
 
 enum EAlign {
     ALIGN_TOP = 1 << 0,

src/framework/graphics/fonts.cpp

@@ -22,8 +22,9 @@
  */
 
 
-#include "fonts.h"
-#include "core/resources.h"
+#include <prerequisites.h>
+#include <core/resources.h>
+#include <graphics/fonts.h>
 
 Fonts g_fonts;
 

src/framework/graphics/fonts.h

@@ -25,8 +25,8 @@
 #ifndef FONTS_H
 #define FONTS_H
 
-#include "prerequisites.h"
-#include "font.h"
+#include <prerequisites.h>
+#include <graphics/font.h>
 
 class Fonts
 {

src/framework/graphics/framebuffer.cpp

@@ -21,9 +21,10 @@
  * THE SOFTWARE.
  */
 
-#include "framebuffer.h"
-#include "core/platform.h"
-#include "graphics.h"
+#include <prerequisites.h>
+#include <core/platform.h>
+#include <graphics/framebuffer.h>
+#include <graphics/graphics.h>
 
 #include <GL/gl.h>
 #include <GL/glu.h>

src/framework/graphics/framebuffer.h

@@ -25,7 +25,7 @@
 #ifndef FRAMEBUFFER_H
 #define FRAMEBUFFER_H
 
-#include "prerequisites.h"
+#include <prerequisites.h>
 
 class FrameBuffer
 {

src/framework/graphics/graphics.cpp

@@ -22,8 +22,8 @@
  */
 
 
-#include "graphics.h"
-#include "texture.h"
+#include <prerequisites.h>
+#include <graphics/graphics.h>
 
 #include <GL/gl.h>
 #include <GL/glu.h>

src/framework/graphics/graphics.h

@@ -25,8 +25,8 @@
 #ifndef GRAPHICS_H
 #define GRAPHICS_H
 
-#include "prerequisites.h"
-#include "texture.h"
+#include <prerequisites.h>
+#include <graphics/texture.h>
 
 class Graphics
 {

src/framework/graphics/image.cpp

@@ -22,9 +22,10 @@
  */
 
 
-#include "image.h"
-#include "graphics.h"
-#include "textures.h"
+#include <prerequisites.h>
+#include <graphics/image.h>
+#include <graphics/graphics.h>
+#include <graphics/textures.h>
 
 Image::Image(const std::string& texture)
 {

src/framework/graphics/image.h

@@ -25,8 +25,8 @@
 #ifndef IMAGE_H
 #define IMAGE_H
 
-#include "prerequisites.h"
-#include "texture.h"
+#include <prerequisites.h>
+#include <graphics/texture.h>
 
 class Image
 {

src/framework/graphics/textarea.cpp

@@ -22,9 +22,10 @@
  */
 
 
-#include "textarea.h"
-#include "graphics.h"
-#include "core/engine.h"
+#include <prerequisites.h>
+#include <core/engine.h>
+#include <graphics/textarea.h>
+#include <graphics/graphics.h>
 
 TextArea::TextArea() :
         m_font(0),
@@ -65,7 +66,7 @@ void TextArea::draw()
     if(m_cursorVisible && m_cursorPos >= 0) {
         assert(m_cursorPos <= textLength);
         const int delay = 500;
-        int ticks = g_engine.getLastFrameTicks();
+        int ticks = g_engine.getCurrentFrameTicks();
         // draw every 500ms
         if(ticks - m_cursorTicks <= delay) {
             Rect cursorRect;
@@ -76,7 +77,7 @@ void TextArea::draw()
                 cursorRect = Rect(m_glyphsCoords[m_cursorPos-1].right(), m_glyphsCoords[m_cursorPos-1].top(), 1, m_font->getGlyphHeight());
             g_graphics.drawFilledRect(cursorRect, m_color);
         } else if(ticks - m_cursorTicks >= 2*delay) {
-            m_cursorTicks = g_engine.getLastFrameTicks();
+            m_cursorTicks = g_engine.getCurrentFrameTicks();
         }
     }
 }
@@ -234,7 +235,7 @@ void TextArea::setText(const std::string& text)
         m_text = text;
         if(m_cursorPos >= 0) {
             m_cursorPos = 0;
-            m_cursorTicks = g_engine.getLastFrameTicks();
+            m_cursorTicks = g_engine.getCurrentFrameTicks();
         }
         recalculate();
     }
@@ -273,7 +274,7 @@ void TextArea::enableCursor(bool enable)
 {
     if(enable) {
         m_cursorPos = 0;
-        m_cursorTicks = g_engine.getLastFrameTicks();
+        m_cursorTicks = g_engine.getCurrentFrameTicks();
     } else
         m_cursorPos = -1;
     recalculate();
@@ -286,7 +287,7 @@ void TextArea::appendCharacter(char c)
         tmp = c;
         m_text.insert(m_cursorPos, tmp);
         m_cursorPos++;
-        m_cursorTicks = g_engine.getLastFrameTicks();
+        m_cursorTicks = g_engine.getCurrentFrameTicks();
         recalculate();
     }
 }
@@ -298,7 +299,7 @@ void TextArea::removeCharacter(bool right)
             m_text.erase(m_text.begin() + m_cursorPos);
         else if((uint)m_cursorPos == m_text.length()) {
             m_text.erase(m_text.begin() + (--m_cursorPos));
-            m_cursorTicks = g_engine.getLastFrameTicks();
+            m_cursorTicks = g_engine.getCurrentFrameTicks();
         }
         recalculate();
     }
@@ -309,12 +310,12 @@ void TextArea::moveCursor(bool right)
     if(right) {
         if((uint)m_cursorPos+1 <= m_text.length()) {
             m_cursorPos++;
-            m_cursorTicks = g_engine.getLastFrameTicks();
+            m_cursorTicks = g_engine.getCurrentFrameTicks();
         }
     } else {
         if(m_cursorPos-1 >= 0) {
             m_cursorPos--;
-            m_cursorTicks = g_engine.getLastFrameTicks();
+            m_cursorTicks = g_engine.getCurrentFrameTicks();
         }
     }
     recalculate();

src/framework/graphics/textarea.h

@@ -25,7 +25,7 @@
 #ifndef TEXTAREA_H
 #define TEXTAREA_H
 
-#include "prerequisites.h"
+#include <prerequisites.h>
 #include "font.h"
 
 class TextArea
@@ -77,6 +77,4 @@ private:
     std::vector<Rect> m_glyphsTexCoords;
 };
 
-typedef boost::shared_ptr<TextArea> TextAreaPtr;
-
 #endif // TEXTAREA_H

src/framework/graphics/texture.cpp

@@ -22,7 +22,8 @@
  */
 
 
-#include "texture.h"
+#include <prerequisites.h>
+#include <graphics/texture.h>
 
 #include <GL/gl.h>
 #include <GL/glext.h>

src/framework/graphics/texture.h

@@ -25,9 +25,7 @@
 #ifndef TEXTURE_H
 #define TEXTURE_H
 
-#include "prerequisites.h"
-
-class Textures;
+#include <prerequisites.h>
 
 class Texture
 {
@@ -53,5 +51,6 @@ private:
 };
 
 typedef boost::shared_ptr<Texture> TexturePtr;
+typedef boost::weak_ptr<Texture> TextureWeakPtr;
 
 #endif // TEXTURE_H

src/framework/graphics/textureloader.cpp

@@ -22,8 +22,9 @@
  */
 
 
-#include "textureloader.h"
-#include "texture.h"
+#include <prerequisites.h>
+#include <graphics/textureloader.h>
+#include <graphics/texture.h>
 
 #include <png.h>
 

src/framework/graphics/textureloader.h

@@ -25,7 +25,7 @@
 #ifndef TEXTURELOADER_H
 #define TEXTURELOADER_H
 
-#include "prerequisites.h"
+#include <prerequisites.h>
 
 class Texture;
 

src/framework/graphics/textures.cpp

@@ -22,9 +22,10 @@
  */
 
 
-#include "textures.h"
-#include "core/resources.h"
-#include "textureloader.h"
+#include <prerequisites.h>
+#include <core/resources.h>
+#include <graphics/textures.h>
+#include <graphics/textureloader.h>
 
 Textures g_textures;
 

src/framework/graphics/textures.h

@@ -25,10 +25,8 @@
 #ifndef TEXTURES_H
 #define TEXTURES_H
 
-#include "prerequisites.h"
-#include "texture.h"
-
-typedef boost::weak_ptr<Texture> TextureWeakPtr;
+#include <prerequisites.h>
+#include <graphics/texture.h>
 
 class Textures
 {

src/framework/net/connection.cpp

@@ -21,160 +21,250 @@
  * THE SOFTWARE.
  */
 
-#include "connection.h"
 
-#include <boost/bind.hpp>
+#include <prerequisites.h>
+#include <core/dispatcher.h>
+#include <net/connection.h>
 
-Connection::Connection(boost::asio::io_service& ioService) 
-    : m_socket(ioService), m_resolver(ioService)
+static boost::asio::io_service ioService;
+
+Connection::Connection() :
+    m_socket(ioService),
+    m_resolver(ioService),
+    m_writeError(false),
+    m_readError(false),
+    m_readTimer(ioService),
+    m_writeTimer(ioService),
+    m_state(STATE_CLOSED)
 {
-    m_connected = false;
-    m_connecting = false;
-    m_port = 0;
+    logTrace();
 }
 
-void Connection::stop()
+Connection::~Connection()
 {
-    if(m_connecting){
+    logTrace();
+}
+
+void Connection::poll()
+{
+    ioService.poll();
+    ioService.reset();
+}
+
+void Connection::close()
+{
+    logTrace();
+    ioService.post(boost::bind(&Connection::internalCloseConnection, shared_from_this()));
+}
+
+void Connection::internalCloseConnection()
+{
+    if(m_state != STATE_CLOSED) {
+        m_pendingRead = 0;
+        m_pendingWrite = 0;
+
         m_resolver.cancel();
-        m_socket.cancel();
+        m_readTimer.cancel();
+        m_writeTimer.cancel();
 
-        m_connecting = false;
+        g_dispatcher.addTask(m_closeCallback);
+
+        if(m_socket.is_open()) {
+            boost::system::error_code error;
+            m_socket->shutdown(boost::asio::ip::tcp::socket::shutdown_both, error);
+
+            if(error) {
+                if(error == boost::asio::error::not_connected) {
+                    //Transport endpoint is not connected.
+                } else {
+                    logError("shutdown socket error = %s", error.message());
+                }
+            }
+
+            m_socket->close(error);
+
+            if(error) {
+                logError("close socket error = %s", error.message());
+            }
+        }
+        m_state = STATE_CLOSED;
     }
 }
 
-bool Connection::connect(const std::string& ip, uint16 port, ConnectionCallback onConnect)
+bool Connection::connect(const std::string& host, uint16 port, const Callback& callback)
 {
-    if(m_connecting){
-        logError("Already is connecting.");
+    logTrace();
+
+    if(m_state != STATE_CLOSED) {
+        logTraceError("connection not closed");
         return false;
     }
 
-    if(m_connected){
-        logError("Already is connected.");
-        return false;
-    }
-
-    m_connectCallback = onConnect;
-    m_connecting = true;
-    m_ip = ip;
-    m_port = port;
-
-    //first resolve dns
-    boost::asio::ip::tcp::resolver::query query(ip, convertType<std::string, uint16>(port));
-    m_resolver.async_resolve(query, boost::bind(&Connection::onResolveDns, this, boost::asio::placeholders::error, boost::asio::placeholders::iterator));
-
+    m_connectCallback = callback;
+    boost::asio::ip::tcp::resolver::query query(ip, convertType<std::string>(port));
+    m_resolver.async_resolve(query, boost::bind(&Connection::onResolveDns, shared_from_this(), boost::asio::placeholders::error, boost::asio::placeholders::iterator));
     return true;
 }
 
 void Connection::onResolveDns(const boost::system::error_code& error, boost::asio::ip::tcp::resolver::iterator endpointIt)
 {
-    if(error){
-        m_connecting = false;
-        m_errorCallback(error, __FUNCTION__);
+    logTrace();
+    if(error) {
+        handleError(error);
         return;
-    }
+    } else {
 
-    //lets connect
-    m_socket.async_connect(*endpointIt, boost::bind(&Connection::onConnect, this, boost::asio::placeholders::error));
+    m_socket.async_connect(*endpointIt, boost::bind(&Connection::onConnect, shared_from_this(), boost::asio::placeholders::error));
 }
 
 void Connection::onConnect(const boost::system::error_code& error)
 {
-    if(error){
-        m_connecting = false;
-        m_errorCallback(error, __FUNCTION__);
+    logTrace();
+    if(error) {
+        handleError(error);
         return;
     }
 
-    m_connected = true;
+    m_state = STATE_OPEN;
 
-    m_connectCallback();
+    if(m_connectCallback)
+        g_dispatcher.addTask(m_connectCallback);
+
+    recvNext();
+}
+
+void Connection::recvNext()
+{
+    logTrace();
+    ++m_pendingRead;
+    m_readTimer.expires_from_now(boost::posix_time::seconds(READ_TIMEOUT));
+    m_readTimer.async_wait(boost::bind(&Connection::handleReadTimeout,
+                                        boost::weak_ptr<Connection>(shared_from_this()),
+                                        boost::asio::placeholders::error));
+
+    static InputMessage inputMessage;
+    boost::asio::async_read(*m_socket,
+        boost::asio::buffer(inputMessage->getBuffer(), InputMessage::HEADER_LENGTH),
+        boost::bind(&Connection::parseHeader, shared_from_this(), inputMessage, boost::asio::placeholders::error));
+}
+
+void Connection::parseHeader(const InputMessage& inputMessage, const boost::system::error_code& error)
+{
+    logTrace();
+
+    --m_pendingRead;
+    m_readTimer.cancel();
+
+    if(error && !handleReadError(error))
+        return;
+
+    uint16_t size = inputMessage->decodeHeader();
+    if(size <= 0 || size + 2 > InputMessage::INPUTMESSAGE_MAXSIZE) {
+        internalCloseConnection();
+        return;
+    }
+
+    try {
+        ++m_pendingRead;
+        m_readTimer.expires_from_now(boost::posix_time::seconds(Connection::read_timeout));
+        m_readTimer.async_wait(boost::bind(&Connection::handleReadTimeout, boost::weak_ptr<Connection>(shared_from_this()),
+            boost::asio::placeholders::error));
+
+        inputMessage->setMessageLength(size + InputMessage::HEADER_LENGTH);
+        boost::asio::async_read(*m_socket, boost::asio::buffer(inputMessage->getBuffer() + InputMessage::HEADER_LENGTH, size),
+            boost::bind(&Connection::parsePacket, shared_from_this(), inputMessage, boost::asio::placeholders::error));
+    } catch(boost::system::system_error& e) {
+        logError("async read error = " << e.what());
+        internalCloseConnection();
+    }
+}
+
+void Connection::parsePacket(const InputMessage& inputMessage, const boost::system::error_code& error)
+{
+    logTrace();
+
+    --m_pendingRead;
+    m_readTimer.cancel();
+
+    if(error && !handleReadError(error))
+        return;
+
+    //g_dispatcher.addTask(boost);
 }
 
 void Connection::handleError(const boost::system::error_code& error)
 {
-    stop();
+    logTrace();
 
-    if(isConnected()){
-        closeSocket();
-    }
+    internalCloseConnection();
+    m_errorCallback(error);
 }
 
-void Connection::closeSocket()
+void Connection::send(const NetworkMessage& networkMessage, const ConnectionCallback& onSend)
 {
-    boost::system::error_code error;
-    m_socket.shutdown(boost::asio::ip::tcp::socket::shutdown_both, error);
+    logTrace();
 
-    if(error) {
-        logError("Connection::closeSocket(): %s", error.message().c_str());
-    }
-
-    m_socket.close(error);
-
-    if(error) {
-        logError("Connection::closeSocket(): %s", error.message().c_str());
-    }
-}
-
-void Connection::send(NetworkMessagePtr networkMessage, ConnectionCallback onSend)
-{
     boost::asio::async_write(m_socket,
-        boost::asio::buffer(networkMessage->getBuffer(), NetworkMessage::header_length),
+        boost::asio::buffer(networkMessage.getBuffer(), NetworkMessage::header_length),
         boost::bind(&Connection::onSendHeader, shared_from_this(), networkMessage, onSend, boost::asio::placeholders::error));
 }
 
-void Connection::recv(RecvCallback onRecv)
+void Connection::recv(const RecvCallback& onRecv)
 {
-    NetworkMessagePtr networkMessage(new NetworkMessage);
+    logTrace();
 
+    static NetworkMessage networkMessage;
     boost::asio::async_read(m_socket,
-        boost::asio::buffer(networkMessage->getBuffer(), NetworkMessage::header_length),
+        boost::asio::buffer(networkMessage.getBuffer(), NetworkMessage::header_length),
         boost::bind(&Connection::onRecvHeader, shared_from_this(), networkMessage, onRecv, boost::asio::placeholders::error));
 }
 
-void Connection::onRecvHeader(ConnectionPtr connection, NetworkMessagePtr networkMessage, RecvCallback onRecv, const boost::system::error_code& error)
+void Connection::onRecvHeader(const NetworkMessage& networkMessage, const RecvCallback& onRecv, const boost::system::error_code& error)
 {
-    if(error){
-        connection->handleError(error);
-        connection->onError(error, __FUNCTION__);
+    logTrace();
+
+    if(error) {
+        handleError(error);
         return;
     }
 
-    boost::asio::async_read(connection->getSocket(),
-        boost::asio::buffer(networkMessage->getBodyBuffer(), networkMessage->getMessageLength()),
-        boost::bind(&Connection::onRecvBody, connection, networkMessage, onRecv, boost::asio::placeholders::error));
+    boost::asio::async_read(m_socket,
+        boost::asio::buffer(networkMessage.getBodyBuffer(), networkMessage.getMessageLength()),
+        boost::bind(&Connection::onRecvBody, shared_from_this(), networkMessage, onRecv, boost::asio::placeholders::error));
 }
 
-void Connection::onRecvBody(ConnectionPtr connection, NetworkMessagePtr networkMessage, RecvCallback onRecv, const boost::system::error_code& error)
+void Connection::onRecvBody(const NetworkMessage& networkMessage, const RecvCallback& onRecv, const boost::system::error_code& error)
 {
+    logTrace();
+
     if(error){
-        connection->handleError(error);
-        connection->onError(error, __FUNCTION__);
+        handleError(error);
         return;
     }
 
     onRecv(networkMessage);
 }
 
-void Connection::onSendHeader(ConnectionPtr connection, NetworkMessagePtr networkMessage, ConnectionCallback onSend, const boost::system::error_code& error)
+void Connection::onSendHeader(const NetworkMessage& networkMessage, const ConnectionCallback& onSend, const boost::system::error_code& error)
 {
+    logTrace();
+
     if(error){
-        connection->handleError(error);
-        connection->onError(error, __FUNCTION__);
+        handleError(error);
         return;
     }
 
-    boost::asio::async_write(connection->getSocket(),
-        boost::asio::buffer(networkMessage->getBodyBuffer(), networkMessage->getMessageLength()),
-        boost::bind(&Connection::onSendBody, connection, networkMessage, onSend, boost::asio::placeholders::error));
+    boost::asio::async_write(m_socket,
+        boost::asio::buffer(networkMessage.getBodyBuffer(), networkMessage.getMessageLength()),
+        boost::bind(&Connection::onSendBody, shared_from_this(), networkMessage, onSend, boost::asio::placeholders::error));
 }
 
-void Connection::onSendBody(ConnectionPtr connection, NetworkMessagePtr networkMessage, ConnectionCallback onSend, const boost::system::error_code& error)
+void Connection::onSendBody(const NetworkMessage& networkMessage, const ConnectionCallback& onSend, const boost::system::error_code& error)
 {
-    if(error){
-        connection->handleError(error);
-        connection->onError(error, __FUNCTION__);
+    logTrace();
+
+    if(error) {
+        handleError(error);
         return;
     }
 

src/framework/net/connection.h

@@ -21,80 +21,85 @@
  * THE SOFTWARE.
  */
 
+
 #ifndef CONNECTION_H
 #define CONNECTION_H
 
-#include "prerequisites.h"
+#include <prerequisites.h>
+#include <net/networkmessage.h>
 
 #include <boost/asio.hpp>
 
-#include "networkmessage.h"
-
-class TestState;
 class Protocol;
-class Connections;
 class Connection;
+typedef boost::shared_ptr<Connection> ConnectionPtr;
+
+typedef boost::function<void()> ConnectionCallback;
+typedef boost::function<void(const NetworkMessage&)> RecvCallback;
+typedef boost::function<void(const boost::system::error_code&)> ErrorCallback;
 
 class Connection : public boost::enable_shared_from_this<Connection>
 {
 public:
-    typedef boost::function<void()> ConnectionCallback;
-    typedef boost::function<void(NetworkMessagePtr)> RecvCallback;
-    typedef boost::function<void(const boost::system::error_code&, const std::string&)> ErrorCallback;
+    enum {
+        WRITE_TIMEOUT = 10,
+        READ_TIMEOUT = 10
+    };
 
-    typedef boost::shared_ptr<Connection> ConnectionPtr;
+    enum EConnectionState {
+        STATE_CONNECTING,
+        STATE_OPEN,
+        STATE_CLOSED
+    }
 
-private:
-    Connection(boost::asio::io_service& ioService);
+    Connection();
+    ~Connection();
 
-    bool connect(const std::string& ip, uint16 port, ConnectionCallback onConnect);
-    void stop();
+    bool connect(const std::string& host, uint16 port, const Callback& callback);
+    void close();
 
-    void setErrorCallback(ErrorCallback c) { m_errorCallback = c; }
+    void setOnError(const ErrorCallback& callback) { m_errorCallback = callback; }
+    void setOnRecv(const RecvCallback& callback) { m_recvCallback = callback; }
 
-    void recv(RecvCallback onSend);
-    void send(NetworkMessagePtr networkMessage, ConnectionCallback onRecv);
+    void send(const OutputMessage& networkMessage);
 
-    bool isConnecting() const { return m_connecting; }
-    bool isConnected() const { return m_connected; }
+    bool isConnecting() const { return m_state == STATE_CONNECTING; }
+    bool isConnected() const { return m_state == STATE_OPEN; }
 
-    boost::asio::ip::tcp::socket& getSocket() { return m_socket; }
-
-    void onError(const boost::system::error_code& error, const std::string& msg) { m_errorCallback(error, msg); }
-    
-private:
-    static void onSendHeader(ConnectionPtr connection, NetworkMessagePtr networkMessage, ConnectionCallback onSend, const boost::system::error_code& error);
-    static void onSendBody(ConnectionPtr connection, NetworkMessagePtr networkMessage, ConnectionCallback onSend, const boost::system::error_code& error);
-
-    static void onRecvHeader(ConnectionPtr connection, NetworkMessagePtr networkMessage, RecvCallback onRecv, const boost::system::error_code& error);
-    static void onRecvBody(ConnectionPtr connection, NetworkMessagePtr networkMessage, RecvCallback onRecv, const boost::system::error_code& error);
+    static void poll();
 
 private:
     void onResolveDns(const boost::system::error_code& error, boost::asio::ip::tcp::resolver::iterator endpointIt);
     void onConnect(const boost::system::error_code& error);
 
-private:
-    void closeSocket();
+    void recvNext();
+
+    void onRecvBody(const NetworkMessage& networkMessage, const RecvCallback& onRecv, const boost::system::error_code& error);
+
+    void onSendHeader(const NetworkMessage& networkMessage, const ConnectionCallback& onSend, const boost::system::error_code& error);
+    void onSendBody(const NetworkMessage& networkMessage, const ConnectionCallback& onSend, const boost::system::error_code& error);
+
+    void onRecvHeader(const NetworkMessage& networkMessage, const RecvCallback& onRecv, const boost::system::error_code& error);
 
-private:
     void handleError(const boost::system::error_code& error);
+    void internalCloseConnection();
 
-    boost::asio::ip::tcp::socket m_socket;
     boost::asio::ip::tcp::resolver m_resolver;
+    boost::asio::ip::tcp::socket m_socket;
 
-    bool m_connecting;
-    bool m_connected;
+    int32_t m_pendingWrite;
+    int32_t m_pendingRead;
+    bool m_writeError;
+    bool m_readError;
+    boost::asio::deadline_timer m_readTimer;
+    boost::asio::deadline_timer m_writeTimer;
 
-    std::string m_ip;
-    uint16_t m_port;
+    EConnectionState m_state;
 
-    ConnectionCallback m_connectCallback;
+    Callback m_connectCallback;
+    Callback m_closeCallback;
     ErrorCallback m_errorCallback;
-
-    friend class Protocol;
-    friend class Connections;
+    RecvCallback m_recvCallback;
 };
 
-typedef boost::shared_ptr<Connection> ConnectionPtr;
-
 #endif //CONNECTION_h

src/framework/net/networkmessage.cpp

@@ -21,158 +21,6 @@
  * THE SOFTWARE.
  */
 
-#include "networkmessage.h"
 
-void NetworkMessage::updateHeaderLength()
-{
-    uint16 size = m_msgSize;
-    memcpy(m_msgBuf, &size, 2);
-}
-
-bool NetworkMessage::canAdd(int size) {
-    return (size + m_readPos < NETWORKMESSAGE_MAXSIZE - 16);
-}
-
-std::string NetworkMessage::getString()
-{
-    uint16 stringlen = getU16();
-    if(stringlen >= (16384 - m_readPos))
-        return std::string();
-
-    char* v = (char*)(m_msgBuf + m_readPos);
-    m_readPos += stringlen;
-    return std::string(v, stringlen);
-}
-
-std::string NetworkMessage::getRaw()
-{
-    uint16 stringlen = m_msgSize - m_readPos;
-    if(stringlen >= (16384 - m_readPos))
-        return std::string();
-
-    char* v = (char*)(m_msgBuf + m_readPos);
-    m_readPos += stringlen;
-    return std::string(v, stringlen);
-}
-
-void NetworkMessage::addString(const char* value)
-{
-    uint32 stringlen = (uint32)strlen(value);
-    if(!canAdd(stringlen + 2) || stringlen > 8192)
-        return;
-
-    addU16(stringlen);
-    strcpy((char*)(m_msgBuf + m_readPos), value);
-    m_readPos += stringlen;
-    m_msgSize += stringlen;
-}
-
-void NetworkMessage::addBytes(const char* bytes, uint32 size)
-{
-    if(!canAdd(size) || size > 8192)
-        return;
-
-    memcpy(m_msgBuf + m_readPos, bytes, size);
-    m_readPos += size;
-    m_msgSize += size;
-}
-
-void NetworkMessage::addPaddingBytes(uint32 n)
-{
-    if(!canAdd(n))
-        return;
-
-    memset((void*)&m_msgBuf[m_readPos], 0x33, n);
-    m_msgSize = m_msgSize + n;
-}
-
-void NetworkMessage::skipBytes(int count) {
-    m_readPos += count;
-}
-
-// simply write functions for outgoing message
-void NetworkMessage::addByte(uint8 value) {
-    if(!canAdd(1))
-        return;
-
-    m_msgBuf[m_readPos++] = value;
-    m_msgSize++;
-}
-
-void NetworkMessage::addU16(uint16 value) {
-    if(!canAdd(2))
-        return;
-
-    *(uint16*)(m_msgBuf + m_readPos) = value;
-    m_readPos += 2;
-    m_msgSize += 2;
-}
-
-void NetworkMessage::addU32(uint32 value) {
-    if(!canAdd(4))
-        return;
-
-    *(uint32*)(m_msgBuf + m_readPos) = value;
-    m_readPos += 4;
-    m_msgSize += 4;
-}
-
-void NetworkMessage::addU64(uint64 value) {
-    if(!canAdd(8))
-        return;
-
-    *(uint64*)(m_msgBuf + m_readPos) = value;
-    m_readPos += 8;
-    m_msgSize += 8;
-}
-
-void NetworkMessage::addString(const std::string &value) {
-    addString(value.c_str());
-}
-
-int32 NetworkMessage::getMessageLength() const {
-    return m_msgSize;
-}
-
-void NetworkMessage::setMessageLength(int32 newSize) {
-    m_msgSize = newSize;
-}
-
-int32 NetworkMessage::getReadPos() const {
-    return m_readPos;
-}
-
-uint8 NetworkMessage::getByte()
-{
-    return m_msgBuf[m_readPos++];
-}
-
-uint16 NetworkMessage::getU16()
-{
-    uint16 v = *(uint16*)(m_msgBuf + m_readPos);
-    m_readPos += 2;
-    return v;
-}
-
-uint32 NetworkMessage::getU32()
-{
-    uint32 v = *(uint32*)(m_msgBuf + m_readPos);
-    m_readPos += 4;
-    return v;
-}
-
-uint64 NetworkMessage::getU64()
-{
-    uint64 v = *(uint64*)(m_msgBuf + m_readPos);
-    m_readPos += 8;
-    return v;
-}
-
-char* NetworkMessage::getBuffer() {
-    return (char*)&m_msgBuf[0];
-}
-
-char* NetworkMessage::getBodyBuffer() {
-    m_readPos = 2;
-    return (char*)&m_msgBuf[header_length];
-}
+#include <prerequisites.h>
+#include <net/networkmessage.h>

src/framework/net/networkmessage.h

@@ -21,77 +21,190 @@
  * THE SOFTWARE.
  */
 
+
 #ifndef NETWORKMESSAGE_H
 #define NETWORKMESSAGE_H
 
-#include "prerequisites.h"
+#include <prerequisites.h>
 
-class Rsa;
-
-class NetworkMessage
+class InputMessage
 {
 public:
     enum {
-        header_length = 2,
-        NETWORKMESSAGE_MAXSIZE = 1500
+        INPUTMESSAGE_MAXSIZE = 16834,
+        HEADER_LENGTH = 2
     };
 
-    enum {
-        max_body_length = NETWORKMESSAGE_MAXSIZE - header_length
-    };
+    InputMessage() : m_messageSize(0), m_readPos(HEADER_LENGTH) { }
+    ~InputMessage() { }
 
-    // constructor/destructor
-    NetworkMessage() {
-        reset();
+    inline void reset() {
+        m_messageSize = 0;
+        m_readPos = HEADER_LENGTH;
     }
 
-    // resets the internal buffer to an empty message
-protected:
-    void reset() {
-        m_msgSize = 0;
-        m_readPos = 2;
+    uint16_t decodeHeader() {
+        return (int32_t)(m_buffer[0] | m_buffer[1] << 8);
     }
-public:
-    // simply read functions for incoming message
-    uint8 getByte();
-    uint16 getU16();
-    uint32 getU32();
-    uint64 getU64();
 
-    std::string getString();
-    std::string getRaw();
+    uint8_t getByte() {
+        return m_buffer[m_readPos++];
+    }
 
-    // skips count unknown/unused bytes in an incoming message
-    void skipBytes(int count);
+    uint16_t getU16() {
+        uint16_t v = *(uint16_t*)(m_buffer + m_readPos);
+        m_readPos += 2;
+        return v;
+    }
 
-    // simply write functions for outgoing message
-    void addByte(uint8 value);
-    void addU16(uint16 value);
-    void addU32(uint32 value);
-    void addU64(uint64 value);
-    void addBytes(const char* bytes, uint32_t size);
-    void addPaddingBytes(uint32 n);
-    void addString(const std::string &value);
-    void addString(const char* value);
-    int32 getMessageLength() const;
+    uint32_t getU32() {
+        uint32_t v = *(uint32_t*)(m_buffer + m_readPos);
+        m_readPos += 4;
+        return v;
+    }
 
-    void setMessageLength(int32 newSize);
-    int32 getReadPos() const;
-    int32 getHeaderSize();
-    char* getBuffer();
-    char* getBodyBuffer();
+    uint64_t getU64() {
+        uint64_t v = *(uint64_t*)(m_buffer + m_readPos);
+        m_readPos += 8;
+        return v;
+    }
 
-    void updateHeaderLength();
+    std::string getString() {
+        uint16_t stringlen = getU16();
+        if(stringlen >= (INPUTMESSAGE_MAXSIZE - m_readPos))
+            return std::string();
 
-protected:
-    inline bool canAdd(int size);
+        char* v = (char*)(m_buffer + m_readPos);
+        m_readPos += stringlen;
+        return std::string(v, stringlen);
+    }
 
-    int32 m_msgSize;
-    int32 m_readPos;
+    void skipBytes(int count) { m_readPos += count; }
 
-    uint8 m_msgBuf[NETWORKMESSAGE_MAXSIZE];
+    int32_t getMessageLength() const {return m_messageSize; }
+    void setMessageLength(int32_t newSize) { m_messageSize = newSize; }
+
+    int32_t getReadPos() const { return m_readPos; }
+    const char *getBuffer() const { return (char*)&m_buffer[0]; }
+
+private:
+    uint16_t m_messageSize;
+    uint16_t m_readPos;
+    uint8_t m_buffer[INPUTMESSAGE_MAXSIZE];
 };
 
-typedef boost::shared_ptr<NetworkMessage> NetworkMessagePtr;
+class OutputMessage
+{
+public:
+    enum {
+        OUTPUTMESSAGE_MAXSIZE = 1460
+    };
+
+    OutputMessage() : m_outputBufferStart(4), m_messageSize(0), m_writePos(4) { }
+    ~OutputMessage() { }
+
+    void reset() {
+        m_messageSize = 0;
+        m_writePos = 4;
+        m_outputBufferStart = 4;
+    }
+
+    void addByte(uint8_t value)
+    {
+        if(!canAdd(1))
+            return;
+        m_buffer[m_writePos++] = value;
+        m_messageSize++;
+    }
+
+    void addU16(uint16_t value)
+    {
+        if(!canAdd(2))
+            return;
+        *(uint16_t*)(m_buffer + m_writePos) = value;
+        m_writePos += 2;
+        m_messageSize += 2;
+    }
+
+    void addU32(uint32_t value)
+    {
+        if(!canAdd(4))
+            return;
+        *(uint32_t*)(m_buffer + m_writePos) = value;
+        m_writePos += 4;
+        m_messageSize += 4;
+    }
+
+    void addU64(uint64_t value)
+    {
+        if(!canAdd(8))
+            return;
+        *(uint64_t*)(m_buffer + m_writePos) = value;
+        m_writePos += 8;
+        m_messageSize += 8;
+    }
+
+    void addBytes(const char* bytes, uint32_t size)
+    {
+        if(!canAdd(size) || size > 8192)
+            return;
+
+        memcpy(m_buffer + m_writePos, bytes, size);
+        m_writePos += size;
+        m_messageSize += size;
+    }
+
+    void addPaddingBytes(uint32_t n)    {
+        if(!canAdd(n))
+            return;
+
+        memset((void*)&m_buffer[m_writePos], 0x33, n);
+        m_messageSize = m_messageSize + n;
+    }
+
+    void addString(const char* value)
+    {
+        uint32_t stringlen = (uint32_t)strlen(value);
+        if(!canAdd(stringlen + 2) || stringlen > 8192)
+            return;
+
+        addU16(stringlen);
+        strcpy((char*)(m_buffer + m_writePos), value);
+        m_writePos += stringlen;
+        m_messageSize += stringlen;
+    }
+
+    void addString(const std::string &value) {
+        addString(value.c_str());
+    }
+
+    void writeMessageLength() {
+        *(uint16_t*)(m_buffer + 2) = m_messageSize;
+        m_messageSize += 2;
+        m_outputBufferStart = 2;
+    }
+
+    void writeCryptoHeader() {
+        *(uint16_t*)(m_buffer) = m_messageSize;
+        m_messageSize += 2;
+        m_outputBufferStart = 0;
+    }
+
+    int32_t getMessageLength() const { return m_messageSize; }
+    void setMessageLength(int32_t newSize) { m_messageSize = newSize; }
+
+    const char *getBuffer() const { return (char*)&m_buffer[0]; }
+    const char *getOutputBuffer() const { return (char*)&m_buffer[m_outputBufferStart]; }
+
+private:
+    inline bool canAdd(int size) {
+        return (size + m_writePos < OUTPUTMESSAGE_MAXSIZE);
+    }
+
+    uint16_t m_outputBufferStart;
+    uint16_t m_messageSize;
+    uint16_t m_writePos;
+    uint8_t m_buffer[OUTPUTMESSAGE_MAXSIZE];
+};
 
 #endif //NETWORKMESSAGE_H 

src/framework/net/protocol.cpp

@@ -21,30 +21,33 @@
  * THE SOFTWARE.
  */
 
-#include "protocol.h"
-#include "connections.h"
 
-Protocol::Protocol()
+#include <prerequisites.h>
+#include <net/protocol.h>
+
+Protocol::Protocol() :
+    m_connection(new Connection)
 {
-    m_connection = g_connections.createConnection();
-    /*m_connection->setErrorCallback(
-        [this](const boost::system::error_code& error, const std::string& msg){
-            this->onError(error, msg);
-        }
-    );*/
+    logTrace();
+    m_connection->setOnError(boost::bind(&Protocol::onError, this, boost::asio::placeholders::error));
 }
 
-void Protocol::send(NetworkMessagePtr networkMessage, Connection::ConnectionCallback onSend)
+Protocol::~Protocol()
+{
+    logTrace();
+}
+
+void Protocol::send(const NetworkMessage& networkMessage, const ConnectionCallback& onSend)
 {
     m_connection->send(networkMessage, onSend);
 }
 
-bool Protocol::connect(const std::string& ip, uint16 port, Connection::ConnectionCallback onConnect)
+bool Protocol::connect(const std::string& ip, uint16 port, const Callback& callback)
 {
-    return m_connection->connect(ip, port, onConnect);
+    return m_connection->connect(ip, port, callback);
 }
 
-void Protocol::recv(Connection::RecvCallback onRecv)
+void Protocol::recv(const RecvCallback& onRecv)
 {
     m_connection->recv(onRecv);
 }

src/framework/net/protocol.h

@@ -21,26 +21,24 @@
  * THE SOFTWARE.
  */
 
+
 #ifndef PROTOCOL_H
 #define PROTOCOL_H
 
-#include "prerequisites.h"
-#include "connection.h"
+#include <prerequisites.h>
+#include <net/connection.h>
 
 class Protocol
 {
 public:
     Protocol();
-
-    virtual void begin() = 0;
+    virtual ~Protocol();
 
 protected:
-    void send(NetworkMessagePtr networkMessage, Connection::ConnectionCallback onSend);
-    void recv(Connection::RecvCallback onRecv);
-
-    bool connect(const std::string& ip, uint16 port, Connection::ConnectionCallback onConnect);
-
-    virtual void onError(const boost::system::error_code& error, const std::string& msg) = 0;
+    void send(const NetworkMessage& networkMessage, const ConnectionCallback& onSend);
+    void recv(const RecvCallback& onRecv);
+    bool connect(const std::string& ip, uint16 port, const Callback& callback);
+    virtual void onError(const boost::system::error_code& error) = 0;
 
     ConnectionPtr m_connection;
 };

src/framework/platform/win32platform.cpp

@@ -21,12 +21,15 @@
  * THE SOFTWARE.
  */
 
-#include "core/platform.h"
-#include "core/engine.h"
 
-#include <dir.h>
-#include <physfs.h>
+#include <prerequisites.h>
+#include <core/platform.h>
+#include <core/engine.h>
+
 #include <windows.h>
+#include <dir.h>
+
+#include <physfs.h>
 
 #include <GL/gl.h>
 #include <GL/glext.h>

src/framework/platform/x11platform.cpp

@@ -22,17 +22,20 @@
  */
 
 
-#include "core/platform.h"
-#include "core/engine.h"
+#include <prerequisites.h>
+#include <core/platform.h>
+#include <core/engine.h>
 
 #include <sys/time.h>
 #include <sys/stat.h>
 #include <errno.h>
 
+#include <physfs.h>
+
+#include <GL/glx.h>
+
 #include <X11/Xlib.h>
 #include <X11/Xatom.h>
-#include <GL/glx.h>
-#include <physfs.h>
 
 struct X11PlatformPrivate {
     Display *display;

src/framework/prerequisites.h

@@ -58,6 +58,7 @@ typedef int8_t int8;
 #include <map>
 #include <string>
 #include <list>
+#include <queue>
 
 // boost utilities
 #include <boost/algorithm/string.hpp>
@@ -66,6 +67,7 @@ typedef int8_t int8;
 #include <boost/bind.hpp>
 #include <boost/function.hpp>
 #include <boost/shared_ptr.hpp>
+#include <boost/scoped_ptr.hpp>
 #include <boost/enable_shared_from_this.hpp>
 #define foreach BOOST_FOREACH
 
@@ -75,11 +77,11 @@ typedef boost::function<void()> Callback;
 #include <yaml-cpp/yaml.h>
 
 // common utilities
-#include "util/util.h"
-#include "util/logger.h"
-#include "util/color.h"
-#include "util/point.h"
-#include "util/size.h"
-#include "util/rect.h"
+#include <util/util.h>
+#include <util/logger.h>
+#include <util/color.h>
+#include <util/point.h>
+#include <util/size.h>
+#include <util/rect.h>
 
 #endif // PREREQUISITES_H

src/framework/ui/ui.h

@@ -25,19 +25,20 @@
 #ifndef UI_H
 #define UI_H
 
-#include "prerequisites.h"
+#include <prerequisites.h>
+#include <ui/uiconstants.h>
 
-#include "uiconstants.h"
-#include "uielement.h"
-#include "uicontainer.h"
-#include "uipanel.h"
-#include "uibutton.h"
-#include "uilabel.h"
-#include "uiskins.h"
-#include "uiwindow.h"
-#include "uitextedit.h"
-#include "uiloader.h"
-#include "uilinedecoration.h"
-#include "uicheckbox.h"
+#include <ui/uiskins.h>
+#include <ui/uiloader.h>
+
+#include <ui/uielement.h>
+#include <ui/uielementskin.h>
+
+#include <ui/uicontainer.h>
+#include <ui/uibutton.h>
+#include <ui/uilabel.h>
+#include <ui/uiwindow.h>
+#include <ui/uitextedit.h>
+#include <ui/uicheckbox.h>
 
 #endif // UI_H

src/framework/ui/uibutton.cpp

@@ -22,8 +22,9 @@
  */
 
 
-#include "uibutton.h"
-#include "core/dispatcher.h"
+#include <prerequisites.h>
+#include <core/dispatcher.h>
+#include <ui/uibutton.h>
 
 void UIButton::onInputEvent(const InputEvent& event)
 {

src/framework/ui/uibutton.h

@@ -25,9 +25,9 @@
 #ifndef UIBUTTON_H
 #define UIBUTTON_H
 
-#include "prerequisites.h"
-#include "uielement.h"
-#include "graphics/borderedimage.h"
+#include <prerequisites.h>
+#include <ui/uielement.h>
+#include <graphics/borderedimage.h>
 
 class UIButton : public UIElement
 {

src/framework/ui/uibuttonskin.cpp

@@ -22,9 +22,10 @@
  */
 
 
-#include "uibuttonskin.h"
-#include "uibutton.h"
-#include "graphics/fonts.h"
+#include <prerequisites.h>
+#include <graphics/fonts.h>
+#include <ui/uibuttonskin.h>
+#include <ui/uibutton.h>
 
 void UIButtonSkin::load(const YAML::Node& node)
 {

src/framework/ui/uibuttonskin.h

@@ -25,9 +25,9 @@
 #ifndef UIBUTTONSKIN_H
 #define UIBUTTONSKIN_H
 
-#include "prerequisites.h"
-#include "uiconstants.h"
-#include "uielementskin.h"
+#include <prerequisites.h>
+#include <ui/uiconstants.h>
+#include <ui/uielementskin.h>
 
 class Font;
 

src/framework/ui/uicheckbox.cpp

@@ -1,4 +1,29 @@
-#include "uicheckbox.h"
+/* The MIT License
+ *
+ * Copyright (c) 2010 OTClient, https://github.com/edubart/otclient
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+
+#include <prerequisites.h>
+#include <ui/uicheckbox.h>
 
 UICheckBox::UICheckBox(UI::EElementType type): UIElement(type)
 {

src/framework/ui/uicheckbox.h

@@ -1,9 +1,33 @@
+/* The MIT License
+ *
+ * Copyright (c) 2010 OTClient, https://github.com/edubart/otclient
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+
 #ifndef UICHECKBOX_H
 #define UICHECKBOX_H
 
+#include <prerequisites.h>
 #include <ui/uielement.h>
 
-
 class UICheckBox : public UIElement
 {
 

src/framework/ui/uicheckboxskin.cpp

@@ -1,2 +1,27 @@
-#include "uicheckboxskin.h"
+/* The MIT License
+ *
+ * Copyright (c) 2010 OTClient, https://github.com/edubart/otclient
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+
+#include <prerequisites.h>
+#include <ui/uicheckboxskin.h>
 

src/framework/ui/uicheckboxskin.h

@@ -1,6 +1,32 @@
+/* The MIT License
+ *
+ * Copyright (c) 2010 OTClient, https://github.com/edubart/otclient
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+
 #ifndef UICHECKBOXSKIN_H
 #define UICHECKBOXSKIN_H
 
+#include <prerequisites.h>
+
 class UICheckBoxSkin
 {
 };

src/framework/ui/uicontainer.cpp

@@ -22,13 +22,9 @@
  */
 
 
-#include "uicontainer.h"
-#include "core/resources.h"
-#include "uibutton.h"
-#include "uipanel.h"
-#include "uilabel.h"
-#include "uitextedit.h"
-#include "uiwindow.h"
+#include <prerequisites.h>
+#include <core/resources.h>
+#include <ui/uicontainer.h>
 
 UIContainerPtr rootContainer(new UIContainer);
 

src/framework/ui/uicontainer.h

@@ -25,8 +25,8 @@
 #ifndef UICONTAINER_H
 #define UICONTAINER_H
 
-#include "prerequisites.h"
-#include "uielement.h"
+#include <prerequisites.h>
+#include <ui/uielement.h>
 
 class UIContainer : public UIElement
 {

src/framework/ui/uielement.cpp

@@ -22,16 +22,17 @@
  */
 
 
-#include "uielement.h"
-#include "uiskins.h"
-#include "uielementskin.h"
-#include "graphics/graphics.h"
+#include <prerequisites.h>
 #include <core/dispatcher.h>
+#include <graphics/graphics.h>
+#include <ui/uielement.h>
+#include <ui/uiskins.h>
+#include <ui/uielementskin.h>
+#include <ui/uicontainer.h>
 
 UIElement::UIElement(UI::EElementType type) :
     UILayout(),
     m_type(type),
-    m_skin(NULL),
     m_visible(true),
     m_enabled(true),
     m_focused(false)
@@ -49,7 +50,7 @@ void UIElement::destroy()
     assert(asUIElement().use_count() == 4);
 }
 
-void UIElement::setSkin(UIElementSkin* skin)
+void UIElement::setSkin(const UIElementSkinPtr& skin)
 {
     m_skin = skin;
     if(skin)

src/framework/ui/uielement.h

@@ -25,10 +25,11 @@
 #ifndef UIELEMENT_H
 #define UIELEMENT_H
 
-#include "prerequisites.h"
-#include "core/input.h"
-#include "uiconstants.h"
-#include "uilayout.h"
+#include <prerequisites.h>
+#include <core/input.h>
+#include <ui/uiconstants.h>
+#include <ui/uilayout.h>
+#include <ui/uielementskin.h>
 
 class UIElementSkin;
 
@@ -60,8 +61,8 @@ public:
 
     void moveTo(Point pos);
 
-    void setSkin(UIElementSkin *skin);
-    UIElementSkin *getSkin() { return m_skin; }
+    void setSkin(const UIElementSkinPtr& skin);
+    const UIElementSkinPtr& getSkin() const { return m_skin; }
 
     void setParent(UIContainerPtr parent) { m_parent = parent; }
     UIContainerPtr getParent() const { return m_parent.lock(); }
@@ -89,7 +90,7 @@ public:
 private:
     UI::EElementType m_type;
     UIContainerWeakPtr m_parent;
-    UIElementSkin *m_skin;
+    UIElementSkinPtr m_skin;
     std::string m_id;
     bool m_visible;
     bool m_enabled;

src/framework/ui/uielementskin.cpp

@@ -22,11 +22,12 @@
  */
 
 
-#include "uielementskin.h"
-#include "uielement.h"
-#include "graphics/borderedimage.h"
-#include "graphics/textures.h"
-#include "uiskins.h"
+#include <prerequisites.h>
+#include <ui/uiskins.h>
+#include <ui/uielement.h>
+#include <ui/uielementskin.h>
+#include <graphics/borderedimage.h>
+#include <graphics/textures.h>
 
 void UIElementSkin::load(const YAML::Node& node)
 {

src/framework/ui/uielementskin.h

@@ -25,9 +25,9 @@
 #ifndef UIELEMENTSKIN_H
 #define UIELEMENTSKIN_H
 
-#include "prerequisites.h"
-#include "uiconstants.h"
-#include "graphics/image.h"
+#include <prerequisites.h>
+#include <graphics/image.h>
+#include <ui/uiconstants.h>
 
 class UIElement;
 
@@ -58,4 +58,6 @@ private:
     ImagePtr m_defaultImage;
 };
 
+typedef boost::shared_ptr<UIElementSkin> UIElementSkinPtr;
+
 #endif // UIELEMENTSKIN_H

src/framework/ui/uilabel.cpp

@@ -22,4 +22,5 @@
  */
 
 
-#include "uilabel.h"
+#include <prerequisites.h>
+#include <ui/uilabel.h>

src/framework/ui/uilabel.h

@@ -25,9 +25,9 @@
 #ifndef UILABEL_H
 #define UILABEL_H
 
-#include "prerequisites.h"
-#include "uielement.h"
-#include "graphics/font.h"
+#include <prerequisites.h>
+#include <ui/uielement.h>
+#include <graphics/font.h>
 
 class UILabel : public UIElement
 {

src/framework/ui/uilabelskin.cpp

@@ -22,9 +22,10 @@
  */
 
 
-#include "uilabelskin.h"
-#include "uilabel.h"
-#include "graphics/fonts.h"
+#include <prerequisites.h>
+#include <graphics/fonts.h>
+#include <ui/uilabelskin.h>
+#include <ui/uilabel.h>
 
 void UILabelSkin::load(const YAML::Node& node)
 {

src/framework/ui/uilabelskin.h

@@ -25,9 +25,9 @@
 #ifndef UILABELSKIN_H
 #define UILABELSKIN_H
 
-#include "prerequisites.h"
-#include "uielementskin.h"
-#include "graphics/font.h"
+#include <prerequisites.h>
+#include <graphics/font.h>
+#include <ui/uielementskin.h>
 
 class UILabelSkin : public UIElementSkin
 {

src/framework/ui/uilayout.cpp

@@ -22,8 +22,9 @@
  */
 
 
-#include "uilayout.h"
-#include "uielement.h"
+#include <prerequisites.h>
+#include <ui/uielement.h>
+#include <ui/uilayout.h>
 
 int AnchorLine::getPos() const
 {

src/framework/ui/uilayout.h

@@ -25,8 +25,8 @@
 #ifndef UILAYOUT_H
 #define UILAYOUT_H
 
-#include "prerequisites.h"
-#include "uiconstants.h"
+#include <prerequisites.h>
+#include <ui/uiconstants.h>
 
 enum EAnchorType {
     ANCHOR_LEFT = 0,

src/framework/ui/uiloader.cpp

@@ -22,9 +22,10 @@
  */
 
 
-#include "uiloader.h"
-#include "core/resources.h"
-#include "ui.h"
+#include <prerequisites.h>
+#include <core/resources.h>
+#include <ui/ui.h>
+#include <ui/uiloader.h>
 
 UIElementPtr UILoader::createElementFromId(const std::string& id)
 {
@@ -39,7 +40,7 @@ UIElementPtr UILoader::createElementFromId(const std::string& id)
     std::string elementId = split[1];
 
     if(elementType == "panel") {
-        element = UIElementPtr(new UIPanel);
+        element = UIElementPtr(new UIContainer(UI::Panel));
     } else if(elementType == "button") {
         element = UIElementPtr(new UIButton);
     } else if(elementType == "label") {
@@ -49,7 +50,7 @@ UIElementPtr UILoader::createElementFromId(const std::string& id)
     } else if(elementType == "textEdit") {
         element = UIElementPtr(new UITextEdit);
     } else if(elementType == "lineDecoration") {
-        element = UIElementPtr(new UILineDecoration);
+        element = UIElementPtr(new UIElement(UI::LineDecoration));
     } else if(elementType == "checkBox") {
         element = UIElementPtr(new UICheckBox);
     }

src/framework/ui/uiloader.h

@@ -25,9 +25,9 @@
 #ifndef UILOADER_H
 #define UILOADER_H
 
-#include "prerequisites.h"
-#include "uiconstants.h"
-#include "uicontainer.h"
+#include <prerequisites.h>
+#include <ui/uiconstants.h>
+#include <ui/uicontainer.h>
 
 namespace UILoader
 {

src/framework/ui/uiskins.cpp

@@ -22,15 +22,15 @@
  */
 
 
-#include "uiskins.h"
-#include "core/resources.h"
-#include "graphics/textures.h"
-#include "uielementskin.h"
-#include "uibuttonskin.h"
-#include "uiwindowskin.h"
-#include "uitexteditskin.h"
-#include "uilabelskin.h"
-#include "uilinedecorationskin.h"
+#include <prerequisites.h>
+#include <core/resources.h>
+#include <graphics/textures.h>
+#include <ui/uiskins.h>
+#include <ui/uielementskin.h>
+#include <ui/uibuttonskin.h>
+#include <ui/uiwindowskin.h>
+#include <ui/uitexteditskin.h>
+#include <ui/uilabelskin.h>
 
 UISkins g_uiSkins;
 
@@ -58,7 +58,7 @@ void UISkins::load(const std::string& skinsFile)
                 std::string name;
                 it.first() >> name;
 
-                UIElementSkin *skin = new UIButtonSkin(name);
+                UIElementSkinPtr skin = UIElementSkinPtr(new UIButtonSkin(name));
                 skin->load(it.second());
                 m_elementSkins.push_back(skin);
             }
@@ -70,7 +70,7 @@ void UISkins::load(const std::string& skinsFile)
                 std::string name;
                 it.first() >> name;
 
-                UIElementSkin *skin = new UIElementSkin(name, UI::Panel);
+                UIElementSkinPtr skin = UIElementSkinPtr(new UIElementSkin(name, UI::Panel));
                 skin->load(it.second());
                 m_elementSkins.push_back(skin);
             }
@@ -82,7 +82,7 @@ void UISkins::load(const std::string& skinsFile)
                 std::string name;
                 it.first() >> name;
 
-                UIElementSkin *skin = new UIWindowSkin(name);
+                UIElementSkinPtr skin = UIElementSkinPtr(new UIWindowSkin(name));
                 skin->load(it.second());
                 m_elementSkins.push_back(skin);
             }
@@ -94,7 +94,7 @@ void UISkins::load(const std::string& skinsFile)
                 std::string name;
                 it.first() >> name;
 
-                UIElementSkin *skin = new UILabelSkin(name);
+                UIElementSkinPtr skin = UIElementSkinPtr(new UILabelSkin(name));
                 skin->load(it.second());
                 m_elementSkins.push_back(skin);
             }
@@ -107,7 +107,7 @@ void UISkins::load(const std::string& skinsFile)
                 std::string name;
                 it.first() >> name;
 
-                UIElementSkin *skin = new UITextEditSkin(name);
+                UIElementSkinPtr skin = UIElementSkinPtr(new UITextEditSkin(name));
                 skin->load(it.second());
                 m_elementSkins.push_back(skin);
             }
@@ -120,7 +120,7 @@ void UISkins::load(const std::string& skinsFile)
                 std::string name;
                 it.first() >> name;
 
-                UIElementSkin *skin = new UILineDecorationSkin(name);
+                UIElementSkinPtr skin = UIElementSkinPtr(new UIElementSkin(name, UI::LineDecoration));
                 skin->load(it.second());
                 m_elementSkins.push_back(skin);
             }
@@ -132,20 +132,17 @@ void UISkins::load(const std::string& skinsFile)
 
 void UISkins::terminate()
 {
-    for(auto it = m_elementSkins.begin(); it != m_elementSkins.end(); ++it)
-        delete (*it);
-    m_elementSkins.clear();
+
 }
 
 
-UIElementSkin* UISkins::getElementSkin(UI::EElementType elementType, const std::string& name)
+UIElementSkinPtr UISkins::getElementSkin(UI::EElementType elementType, const std::string& name)
 {
     for(auto it = m_elementSkins.begin(); it != m_elementSkins.end(); ++it) {
-        UIElementSkin *skin = (*it);
-        if(elementType == skin->getElementType() && name == skin->getName()) {
+        const UIElementSkinPtr& skin = (*it);
+        if(elementType == skin->getElementType() && name == skin->getName())
             return skin;
-        }
     }
     logWarning("Element skin '%s' not found", name.c_str());
-    return NULL;
+    return UIElementSkinPtr();
 }

src/framework/ui/uiskins.h

@@ -25,11 +25,9 @@
 #ifndef UISKIN_H
 #define UISKIN_H
 
-#include "prerequisites.h"
-#include "uicontainer.h"
-#include "graphics/texture.h"
-
-class UIElementSkin;
+#include <prerequisites.h>
+#include <graphics/texture.h>
+#include <ui/uielementskin.h>
 
 class UISkins
 {
@@ -39,13 +37,13 @@ public:
     void load(const std::string& skinsFile);
     void terminate();
 
-    UIElementSkin *getElementSkin(UI::EElementType elementType, const std::string& name = "default");
+    UIElementSkinPtr getElementSkin(UI::EElementType elementType, const std::string& name = "default");
     TexturePtr getDefaultTexture() { return m_defaultTexture; }
 
 private:
     TexturePtr m_defaultTexture;
 
-    std::vector<UIElementSkin *> m_elementSkins;
+    std::vector<UIElementSkinPtr> m_elementSkins;
 };
 
 extern UISkins g_uiSkins;

src/framework/ui/uitextedit.cpp

@@ -22,10 +22,11 @@
  */
 
 
-#include "uitextedit.h"
-#include "uitexteditskin.h"
-#include "graphics/fonts.h"
-#include "uicontainer.h"
+#include <prerequisites.h>
+#include <graphics/fonts.h>
+#include <ui/uitextedit.h>
+#include <ui/uitexteditskin.h>
+#include <ui/uicontainer.h>
 
 UITextEdit::UITextEdit() :
     UIElement(UI::TextEdit)
@@ -61,7 +62,7 @@ void UITextEdit::onInputEvent(const InputEvent& event)
 
 void UITextEdit::onLayoutRectChange(const Rect& rect)
 {
-    UITextEditSkin *skin = static_cast<UITextEditSkin*>(getSkin());
+    UITextEditSkin *skin = static_cast<UITextEditSkin*>(getSkin().get());
     Rect textRect = rect;
     int margin = skin->getTextMargin();
     textRect.setLeft(textRect.left()+margin);

src/framework/ui/uitextedit.h

@@ -25,9 +25,9 @@
 #ifndef UITEXTEDIT_H
 #define UITEXTEDIT_H
 
-#include "prerequisites.h"
-#include "uielement.h"
-#include "graphics/textarea.h"
+#include <prerequisites.h>
+#include <graphics/textarea.h>
+#include <ui/uielement.h>
 
 class Font;
 

src/framework/ui/uitexteditskin.cpp

@@ -22,9 +22,10 @@
  */
 
 
-#include "uitexteditskin.h"
-#include "uitextedit.h"
-#include "graphics/fonts.h"
+#include <prerequisites.h>
+#include <graphics/fonts.h>
+#include <ui/uitexteditskin.h>
+#include <ui/uitextedit.h>
 
 void UITextEditSkin::load(const YAML::Node& node)
 {

src/framework/ui/uitexteditskin.h

@@ -25,9 +25,8 @@
 #ifndef UITEXTEDITSKIN_H
 #define UITEXTEDITSKIN_H
 
-#include "prerequisites.h"
-#include "uiconstants.h"
-#include "uielementskin.h"
+#include <prerequisites.h>
+#include <ui/uielementskin.h>
 
 class Font;
 

src/framework/ui/uiwindow.cpp

@@ -22,14 +22,15 @@
  */
 
 
-#include "uiwindow.h"
-#include "uiwindowskin.h"
+#include <prerequisites.h>
+#include <ui/uiwindow.h>
+#include <ui/uiwindowskin.h>
 
 void UIWindow::onInputEvent(const InputEvent& event)
 {
     UIContainer::onInputEvent(event);
     if(event.type == EV_MOUSE_LDOWN) {
-        UIWindowSkin *skin = static_cast<UIWindowSkin*>(getSkin());
+        UIWindowSkin *skin = static_cast<UIWindowSkin*>(getSkin().get());
         Rect headRect = getRect();
         headRect.setHeight(skin->getHeadHeight());
         if(headRect.contains(event.mousePos)) {

src/framework/ui/uiwindow.h

@@ -25,8 +25,8 @@
 #ifndef UIWINDOW_H
 #define UIWINDOW_H
 
-#include "prerequisites.h"
-#include "uicontainer.h"
+#include <prerequisites.h>
+#include <ui/uicontainer.h>
 
 class UIWindow : public UIContainer
 {

src/framework/ui/uiwindowskin.cpp

@@ -21,9 +21,10 @@
  * THE SOFTWARE.
  */
 
-#include "uiwindowskin.h"
-#include "uiwindow.h"
-#include "graphics/fonts.h"
+#include <prerequisites.h>
+#include <graphics/fonts.h>
+#include <ui/uiwindowskin.h>
+#include <ui/uiwindow.h>
 
 void UIWindowSkin::load(const YAML::Node& node)
 {

src/framework/ui/uiwindowskin.h

@@ -24,10 +24,9 @@
 #ifndef UIWINDOWSKIN_H
 #define UIWINDOWSKIN_H
 
-#include "prerequisites.h"
-#include "uiconstants.h"
-#include "uielementskin.h"
-#include "graphics/font.h"
+#include <prerequisites.h>
+#include <graphics/font.h>
+#include <ui/uielementskin.h>
 
 class UIWindowSkin : public UIElementSkin
 {

src/framework/util/color.cpp

@@ -22,7 +22,8 @@
  */
 
 
-#include "color.h"
+#include <prerequisites.h>
+#include <util/color.h>
 
 Color Color::white(0xFF, 0xFF, 0xFF, 0xFF);
 Color Color::black(0x00, 0x00, 0x00, 0xFF);

src/framework/util/color.h

@@ -25,7 +25,7 @@
 #ifndef COLOR_H
 #define COLOR_H
 
-#include "prerequisites.h"
+#include <prerequisites.h>
 
 typedef uint32 RGBA;
 

src/framework/util/logger.cpp

@@ -21,8 +21,8 @@
  * THE SOFTWARE.
  */
 
-#include "logger.h"
-#include "util.h"
+#include <util/logger.h>
+#include <util/util.h>
 
 #include <iostream>
 #include <cstdlib>

src/framework/util/point.h

@@ -25,7 +25,7 @@
 #ifndef POINT_H
 #define POINT_H
 
-#include "prerequisites.h"
+#include <prerequisites.h>
 
 template <class T>
 class TSize;

src/framework/util/rect.h

@@ -25,7 +25,7 @@
 #ifndef RECT_H
 #define RECT_H
 
-#include "prerequisites.h"
+#include <prerequisites.h>
 
 template <class T>
 class TPoint;

src/framework/util/rsa.cpp

@@ -21,7 +21,8 @@
  * THE SOFTWARE.
  */
 
-#include "rsa.h"
+#include <prerequisites.h>
+#include <util/rsa.h>
 
 Rsa::Rsa()
 {

src/framework/util/rsa.h

@@ -24,7 +24,7 @@
 #ifndef RSA_H
 #define RSA_H
 
-#include "prerequisites.h"
+#include <prerequisites.h>
 
 #include <gmp.h>
 

src/framework/util/size.h

@@ -25,8 +25,8 @@
 #ifndef SIZE_H
 #define SIZE_H
 
-#include "prerequisites.h"
-#include "point.h"
+#include <prerequisites.h>
+#include <util/point.h>
 
 enum ESizeScaleMode {
     IGNORE_ASPECT_RATIO,

src/framework/util/util.cpp

@@ -21,7 +21,7 @@
  * THE SOFTWARE.
  */
 
-#include "util.h"
+#include <util/util.h>
 #include <cstdio>
 
 std::string vformat(const char *format, va_list args)

src/framework/util/util.h

@@ -25,7 +25,7 @@
 #ifndef UTIL_H
 #define UTIL_H
 
-#include "logger.h"
+#include <util/logger.h>
 #include <stdarg.h>
 #include <boost/lexical_cast.hpp>
 

src/main.cpp

@@ -22,14 +22,15 @@
  */
 
 
-#include "core/engine.h"
-#include "core/configs.h"
-#include "core/resources.h"
-#include "core/platform.h"
-#include "core/dispatcher.h"
+#include <prerequisites.h>
+#include <core/engine.h>
+#include <core/configs.h>
+#include <core/resources.h>
+#include <core/platform.h>
+#include <core/dispatcher.h>
+#include <ui/uiskins.h>
 #include "menustate.h"
 #include "teststate.h"
-#include "ui/uiskins.h"
 
 /// Catches signals so we can exit nicely
 void signal_handler(int sig)

src/menustate.cpp

@@ -22,17 +22,16 @@
  */
 
 
+#include <prerequisites.h>
+#include <core/engine.h>
+#include <core/dispatcher.h>
+#include <graphics/framebuffer.h>
+#include <graphics/graphics.h>
+#include <graphics/textures.h>
+#include <graphics/borderedimage.h>
+#include <graphics/fonts.h>
+#include <ui/ui.h>
 #include "menustate.h"
-#include "graphics/framebuffer.h"
-#include "graphics/graphics.h"
-#include "graphics/textures.h"
-#include "core/engine.h"
-#include "graphics/fonts.h"
-#include "core/dispatcher.h"
-#include "ui/ui.h"
-#include "net/connections.h"
-#include "graphics/borderedimage.h"
-
 
 void MenuState::onEnter()
 {
@@ -97,6 +96,9 @@ void MenuState::enterGameButton_clicked()
         window->getParent()->unlockElement();
         window->destroy();
     });
+
+    button = boost::static_pointer_cast<UIButton>(window->getChildById("okButton"));
+    button->setOnClick(boost::bind(&MenuState::enterGameWindowOkButton_clicked, this));
 }
 
 void MenuState::infoButton_clicked()
@@ -111,3 +113,14 @@ void MenuState::infoButton_clicked()
     });
 }
 
+void MenuState::enterGameWindowOkButton_clicked()
+{
+    UIContainerPtr enterGameWindow = boost::static_pointer_cast<UIContainer>(UIContainer::getRootContainer()->getChildById("enterGameWindow"));
+
+    std::string accountName = boost::static_pointer_cast<UITextEdit>(enterGameWindow->getChildById("accountNameTextEdit"))->getText();
+    std::string password = boost::static_pointer_cast<UITextEdit>(enterGameWindow->getChildById("passwordTextEdit"))->getText();
+
+    //m_protocolLogin = ProtocolLoginPtr(new ProtocolLogin);
+    //m_protocolLogin->login(accountName, password);
+}
+

src/menustate.h

@@ -25,10 +25,10 @@
 #ifndef MENUSTATE_H
 #define MENUSTATE_H
 
-#include "core/gamestate.h"
-#include "graphics/texture.h"
-#include "net/connection.h"
-#include "ui/uipanel.h"
+#include <prerequisites.h>
+#include <core/gamestate.h>
+#include <graphics/texture.h>
+//#include "protocollogin.h"
 
 class MenuState : public GameState
 {
@@ -49,8 +49,10 @@ private:
     void enterGameButton_clicked();
     void infoButton_clicked();
 
-    UIPanelPtr m_menuPanel;
+    void enterGameWindowOkButton_clicked();
+
     TexturePtr m_background;
+    //ProtocolLoginPtr m_protocolLogin;
 };
 
 #endif // MENUSTATE_H

src/net/protocoltibia87.cpp

@@ -1,112 +0,0 @@
-/* The MIT License
- *
- * Copyright (c) 2010 OTClient, https://github.com/edubart/otclient
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
- * THE SOFTWARE.
- */
-
-#include "protocoltibia87.h"
-#include "util/rsa.h"
-
-const char* ProtocolTibia87::rsa = "4673033022358411862216018001503683214873298680851934467521055526294025873980576"
-                                   "6860224610646919605860206328024326703361630109888417839241959507572247284807035"
-                                   "2355696191737922927869078457919049551036016528225191219083671878855092700253886"
-                                   "41700821735345222087940578381210879116823013776808975766851829020659073";
-
-ProtocolTibia87::ProtocolTibia87()
-{
-
-}
-
-void ProtocolTibia87::begin()
-{
-    /*
-    connect("icechaw.otland.net", 7171,
-        [this](){
-            this->afterConnect();
-        }
-    );
-    */
-}
-
-void ProtocolTibia87::login(const std::string& account, const std::string& password)
-{
-    sendAccount(account, password);
-}
-
-void ProtocolTibia87::sendAccount(const std::string& account, const std::string& password)
-{
-    NetworkMessagePtr networkMessage(new NetworkMessage);
-
-    networkMessage->addByte(0x01);//login Server
-    networkMessage->addU16(0x00);//OS
-    networkMessage->addU16(0x00);//VERSION
-    networkMessage->addPaddingBytes(12);//
-
-    int32 m_notEncriptedLen = networkMessage->getMessageLength();
-
-    //begin RSA encrypt
-    networkMessage->addU32(1); //xtea
-    networkMessage->addU32(2); //xtea
-    networkMessage->addU32(3); //xtea
-    networkMessage->addU32(4); //xtea
-
-    networkMessage->addString(account);
-    networkMessage->addString(password);
-
-    Rsa::encrypt(networkMessage->getBodyBuffer() + m_notEncriptedLen, networkMessage->getMessageLength() - m_notEncriptedLen, ProtocolTibia87::rsa);
-
-    networkMessage->setMessageLength(m_notEncriptedLen + 128);
-    networkMessage->updateHeaderLength();
-
-    /*
-    send(networkMessage,
-        [this](){
-            this->afterSendAccount();
-        }
-    );
-    */
-}
-
-void ProtocolTibia87::afterConnect()
-{
-    login("9418347", "lollol");
-}
-
-void ProtocolTibia87::afterSendAccount()
-{
-    /*
-    recv(
-        [this](NetworkMessagePtr networkMessage){
-            this->parseCharacterList(networkMessage);
-        }
-    );
-    */
-}
-
-void ProtocolTibia87::onError(const boost::system::error_code& error, const std::string& msg)
-{
-    logError("%s; %s", error.message().c_str(), msg.c_str());
-}
-
-void ProtocolTibia87::parseCharacterList(NetworkMessagePtr networkMessage)
-{
-    logInfo("Parsing characters. msglen: %d", networkMessage->getMessageLength());
-
-}

src/net/protocoltibia87.h

@@ -1,55 +0,0 @@
-/* The MIT License
- *
- * Copyright (c) 2010 OTClient, https://github.com/edubart/otclient
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
- * THE SOFTWARE.
- */
-
-#ifndef PROTOCOLTIBIA87_H
-#define PROTOCOLTIBIA87_H
-
-#include "prerequisites.h"
-#include "net/protocol.h"
-
-class ProtocolTibia87 : public Protocol
-{
-public:
-    ProtocolTibia87();
-
-    virtual void begin();
-
-protected:
-    void login(const std::string& account, const std::string& password);
-    void sendAccount(const std::string& account, const std::string& password);
-    void parseCharacterList(NetworkMessagePtr networkMessage);
-
-    void readCharacterList();
-
-    void afterConnect();
-    void afterSendAccount();
-
-    virtual void onError(const boost::system::error_code& error, const std::string& msg);
-
-private:
-    static const char* rsa;
-};
-
-typedef boost::shared_ptr<ProtocolTibia87> ProtocolTibia87Ptr;
-
-#endif //PROTOCOLTIBIA87_H

src/protocollogin.cpp

@@ -21,19 +21,39 @@
  * THE SOFTWARE.
  */
 
-#include "connections.h"
 
-Connections g_connections;
+#include <prerequisites.h>
+#include <util/rsa.h>
+#include "protocollogin.h"
 
-size_t Connections::poll()
+ProtocolLogin::ProtocolLogin()
 {
-    return m_ioService.poll();
+    logTrace();
 }
 
-ConnectionPtr Connections::createConnection()
+ProtocolLogin::~ProtocolLogin()
 {
-    ConnectionPtr connection(new Connection(m_ioService));
-    m_connections.push_back(connection);
-
-    return connection;
+    logTrace();
 }
+
+void ProtocolLogin::login(const std::string& account, const std::string& password)
+{
+    logTrace();
+    m_connection = ConnectionPtr(new Connection);
+    m_connection->connect("www.google.com", 80, boost::bind(&ProtocolLogin::afterConnect, this));
+}
+
+void ProtocolLogin::afterConnect()
+{
+    logTrace();
+
+}
+
+void ProtocolLogin::onError(const boost::system::error_code& error, const std::string& msg)
+{
+    logTrace();
+    logError("Connection error: %s", error.message().c_str());
+}
+
+
+

src/protocollogin.h

@@ -21,27 +21,28 @@
  * THE SOFTWARE.
  */
 
-#ifndef CONNECTIONS_H
-#define CONNECTIONS_H
 
-#include "prerequisites.h"
+#ifndef PROTOCOLLOGIN_H
+#define PROTOCOLLOGIN_H
 
-#include "connection.h"
+#include <prerequisites.h>
+#include <net/connection.h>
 
-class Connections
+class ProtocolLogin
 {
 public:
-    size_t poll();
-    
-    ConnectionPtr createConnection();
-    
+    ProtocolLogin();
+    ~ProtocolLogin();
+
+    void login(const std::string& account, const std::string& password);
+    void afterConnect();
+    void sendAccount();
+    void onError(const boost::system::error_code& error, const std::string& msg);
+
 private:
-    boost::asio::io_service m_ioService;
-    
-    typedef std::vector<ConnectionPtr> ConnectionVector;
-    ConnectionVector m_connections;
+    ConnectionPtr m_connection;
 };
 
-extern Connections g_connections;
+typedef boost::shared_ptr<ProtocolLogin> ProtocolLoginPtr;
 
-#endif //CONNECTIONS_H
+#endif // PROTOCOLLOGIN_H

src/teststate.cpp

@@ -22,16 +22,13 @@
  */
 
 
+#include <core/engine.h>
+#include <graphics/graphics.h>
 #include "teststate.h"
-#include "graphics/graphics.h"
-#include "core/engine.h"
-#include "net/connections.h"
-#include "net/protocoltibia87.h"
 
 void TestState::onEnter()
 {
-    m_protocol = ProtocolTibia87Ptr(new ProtocolTibia87);
-    m_protocol->begin();
+
 }
 
 void TestState::onLeave()

src/teststate.h

@@ -25,8 +25,8 @@
 #ifndef TESTSTATE_H
 #define TESTSTATE_H
 
-#include "core/gamestate.h"
-#include "net/protocoltibia87.h"
+#include <prerequisites.h>
+#include <core/gamestate.h>
 
 class TestState : public GameState
 {
@@ -42,9 +42,6 @@ public:
 
     virtual void render();
     virtual void update(int ticks, int elapsedTicks);
-
-private:
-    ProtocolTibia87Ptr m_protocol;
 };
 
 #endif // TESTSTATE_H