master
Eduardo Bart 13 years ago
commit c0fce81238

@ -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
)

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

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

@ -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)

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

@ -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();

@ -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

@ -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;

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

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

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

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

@ -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,

@ -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
{

@ -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)
{

@ -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,

@ -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;

@ -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
{

@ -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>

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

@ -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>

@ -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
{

@ -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)
{

@ -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
{

@ -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();

@ -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

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

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

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

@ -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;

@ -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
{

@ -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){
m_resolver.cancel();
m_socket.cancel();
logTrace();
}
m_connecting = false;
}
void Connection::poll()
{
ioService.poll();
ioService.reset();
}
bool Connection::connect(const std::string& ip, uint16 port, ConnectionCallback onConnect)
void Connection::close()
{
if(m_connecting){
logError("Already is connecting.");
return false;
}
logTrace();
ioService.post(boost::bind(&Connection::internalCloseConnection, shared_from_this()));
}
if(m_connected){
logError("Already is connected.");
return false;
void Connection::internalCloseConnection()
{
if(m_state != STATE_CLOSED) {
m_pendingRead = 0;
m_pendingWrite = 0;
m_resolver.cancel();
m_readTimer.cancel();
m_writeTimer.cancel();
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;
}
}
m_connectCallback = onConnect;
m_connecting = true;
m_ip = ip;
m_port = port;
bool Connection::connect(const std::string& host, uint16 port, const Callback& callback)
{
logTrace();
//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));
if(m_state != STATE_CLOSED) {
logTraceError("connection not closed");
return false;
}
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::handleError(const boost::system::error_code& error)
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)
{
stop();
logTrace();
--m_pendingRead;
m_readTimer.cancel();
if(isConnected()){
closeSocket();
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::closeSocket()
void Connection::parsePacket(const InputMessage& inputMessage, const boost::system::error_code& error)
{
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_pendingRead;
m_readTimer.cancel();
m_socket.close(error);
if(error && !handleReadError(error))
return;
if(error) {
logError("Connection::closeSocket(): %s", error.message().c_str());
}
//g_dispatcher.addTask(boost);
}
void Connection::handleError(const boost::system::error_code& error)
{
logTrace();
internalCloseConnection();
m_errorCallback(error);
}
void Connection::send(NetworkMessagePtr networkMessage, ConnectionCallback onSend)
void Connection::send(const NetworkMessage& networkMessage, const ConnectionCallback& onSend)
{
logTrace();
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;
}

@ -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

@ -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>

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

@ -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)
{
logTrace();
m_connection->setOnError(boost::bind(&Protocol::onError, this, boost::asio::placeholders::error));
}
Protocol::~Protocol()
{
m_connection = g_connections.createConnection();
/*m_connection->setErrorCallback(
[this](const boost::system::error_code& error, const std::string& msg){
this->onError(error, msg);
}
);*/
logTrace();
}
void Protocol::send(NetworkMessagePtr networkMessage, Connection::ConnectionCallback onSend)
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);
}

@ -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;
};

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

@ -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;

@ -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

@ -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

@ -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)
{

@ -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
{

@ -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)
{

@ -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;

@ -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)
{

@ -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
{

@ -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>

@ -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
{
};

@ -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);

@ -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
{

@ -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)

@ -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;

@ -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)
{

@ -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

@ -22,4 +22,5 @@
*/
#include "uilabel.h"
#include <prerequisites.h>
#include <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
{

@ -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)
{

@ -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
{

@ -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
{

@ -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,

@ -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);
}

@ -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
{

@ -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();
}

@ -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;

@ -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);

@ -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;

@ -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)
{

@ -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;

@ -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)) {

@ -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
{

@ -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)
{

@ -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
{

@ -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);

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

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

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

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

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

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

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

@ -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>

@ -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)

@ -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);
}

@ -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

@ -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());
}

@ -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

@ -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);
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();
return connection;
}
void ProtocolLogin::onError(const boost::system::error_code& error, const std::string& msg)
{
logTrace();
logError("Connection error: %s", error.message().c_str());
}

@ -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

@ -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()

@ -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

Loading…
Cancel
Save