const bool& Stage::host_change_flag() const
{
return host_change_flag_;
-}
\ No newline at end of file
+}
+
+void Stage::set_perspective(int value) {
+ perspective_ = value;
+}
+
+int Stage::perspective() const {
+ return perspective_;
+}
const ModelHandle& map_handle() const;
float map_scale() const;
float min_height() const;
+ void set_perspective(int value);
+ int perspective() const;
const std::vector<VECTOR>& start_points() const;
const std::vector<VECTOR>& warp_points() const;
std::vector<VECTOR> warp_points_;
bool host_change_flag_;
+ int perspective_;
};
typedef std::shared_ptr<Stage> StagePtr;
const auto target_pos = myself_->current_stat().pos +
VGet(0, myself_->model_height() * camera.target_height + 0.2f, 0) * stage_->map_scale();
- auto camera_pos = target_pos +
+
+ auto camera_pos = target_pos +
VGet(cos(camera.phi) * sin(camera.theta),
sin(camera.phi >= TORADIAN(180.0f) ? camera.phi + TORADIAN(90.0f) : camera.phi ),
cos(camera.phi) * cos(camera.theta)) * (camera.radius * stage_->map_scale());
- const auto coll_info = MV1CollCheck_Line(stage_->map_handle().handle(), -1, target_pos, camera_pos);
- static int wallcamera_cnt = 0;
+ const auto coll_info = MV1CollCheck_Line(stage_->map_handle().handle(), -1, target_pos, camera_pos);
+ static int wallcamera_cnt = 0;
auto model_coll_size = (myself_->model_height() * (camera.target_height < 0.5f ? 1.0f - camera.target_height : camera.target_height) + 0.25f) * stage_->map_scale();
if (coll_info.HitFlag &&
VSize(camera_pos - myself_->current_stat().pos) > CAMERA_MIN_RADIUS + 2.0)
- {
- wallcamera_cnt++;
+ {
+ wallcamera_cnt++;
if (wallcamera_cnt > 15 && VSize(camera_pos - myself_->current_stat().pos) < CAMERA_MIN_RADIUS + 4.0f + 1.0f) {
camera_pos.x = coll_info.HitPosition.x;
camera_pos.z = coll_info.HitPosition.z;
- }else{
+ }else{
camera_pos = coll_info.HitPosition - VScale(coll_info.HitPosition - target_pos,0.2f);
}
- } else {
- wallcamera_cnt = 0;
- }
+ } else {
+ wallcamera_cnt = 0;
+ }
if(VSize(camera_pos - target_pos) <= model_coll_size)
{
camera_pos = target_pos + VScale(camera_pos - target_pos,(model_coll_size)/(VSize(camera_pos - target_pos) <= 0 ? 0.000001f : VSize(camera_pos - target_pos)));
}
auto camera_pos_delta = VScale(camera_pos - GetCameraPosition(),(float)0.3);
- // if (VSize(camera_pos_delta) > 10) {
- // camera_pos_delta = VNorm(camera_pos_delta) * 10;
- //}
+ // if (VSize(camera_pos_delta) > 10) {
+ // camera_pos_delta = VNorm(camera_pos_delta) * 10;
+ //}
SetCameraPositionAndTarget_UpVecY(
GetCameraPosition() + camera_pos_delta, target_pos);
#include "ManagerHeader.hpp"
#include <string>
#include <stdint.h>
+#include <boost/property_tree/xml_parser.hpp>
class AccountManager {
public:
AccountManager(const ManagerAccessorPtr& manager_accessor);
void Load(const std::string& filename);
- void Save(const std::string& filename) const;
+ void Save(const std::string& filename);
+
+ boost::property_tree::ptree Get(const std::string& name) const;
+ void Set(const std::string& name, const boost::property_tree::ptree& value);
std::string GetSerializedData() const;
std::string host() const;
void set_host(const std::string& host);
+
+ int show_nametag() const;
+ int perspective() const;
private:
ManagerAccessorPtr manager_accessor_;
std::string model_name_;
std::string host_;
-
uint16_t udp_port_;
+
+ boost::property_tree::ptree pt_;
};
typedef std::shared_ptr<AccountManager> AccountManagerPtr;
case ClientReceiveAccountRevisionUpdateNotify:
{
- uint32_t user_id;
- uint32_t server_revision;
- network::Utils::Deserialize(command.body(), &user_id, &server_revision);
+ if (player_manager) {
+ uint32_t user_id;
+ uint32_t server_revision;
+ network::Utils::Deserialize(command.body(), &user_id, &server_revision);
- auto current_revision = player_manager->GetCurrentUserRevision(user_id);
+ auto current_revision = player_manager->GetCurrentUserRevision(user_id);
- Logger::Info(_T("Receive account database update notify %d %d [%d]"), user_id, server_revision, current_revision);
+ Logger::Info(_T("Receive account database update notify %d %d [%d]"), user_id, server_revision, current_revision);
- if (server_revision > current_revision) {
- client_->Write(network::ServerRequestedAccountRevisionPatch(user_id, current_revision));
+ if (server_revision > current_revision) {
+ client_->Write(network::ServerRequestedAccountRevisionPatch(user_id, current_revision));
+ }
}
}
break;
std::string CommandManager::stage() const
{
return stage_;
+}
+
+double CommandManager::GetReadByteAverage() const
+{
+ if (client_) {
+ return client_->GetReadByteAverage();
+ } else {
+ return 0;
+ }
+}
+
+double CommandManager::GetWriteByteAverage() const
+{
+ if (client_) {
+ return client_->GetWriteByteAverage();
+ } else {
+ return 0;
+ }
}
\ No newline at end of file
void Update();
void Write(const network::Command& command);
void WriteUDP(const network::Command& command);
-
void SendJSON(const std::string&);
+ double GetReadByteAverage() const;
+ double GetWriteByteAverage() const;
+
void set_client(ClientUniqPtr client);
unsigned int user_id();
std::string stage() const;
#include "ConfigManager.hpp"
#include "../common/Logger.hpp"
-#include <boost/property_tree/json_parser.hpp>
#include <stdint.h>
const int ConfigManager::MIN_SCREEN_WIDTH = 800;
void ConfigManager::Load(const std::string& filename)
{
- using boost::property_tree::ptree;
- ptree pt;
- read_json(filename, pt);
-
- fullscreen_ = pt.get<bool>("fullscreen", false);
- screen_width_ = pt.get<int>("screen_width", 800);
- screen_height_ = pt.get<int>("screen_height", 600);
- antialias_ = pt.get<bool>("antialias", false);
- host_ = pt.get<std::string>("host", "127.0.0.1");
- port_ = pt.get<uint16_t>("port", 39390);
- max_script_execution_time_ = pt.get<int>("max_script_execution_time", 5000);
- max_local_storage_size_ = pt.get<int>("max_local_storage_size", 512000);
- upnp_ = pt.get<bool>("upnp", false);
- udp_port_ = pt.get<uint16_t>("udp_port", 39391);
- model_edge_size_ = pt.get<float>("edge_size",1.0f);
- stage_ = pt.get<std::string>("stage","\83P\83\8d\83\8a\83\93\92¬");
+ read_json(filename, pt_);
+
+ fullscreen_ = pt_.get<bool>("fullscreen", false);
+ screen_width_ = pt_.get<int>("screen_width", 800);
+ screen_height_ = pt_.get<int>("screen_height", 600);
+ antialias_ = pt_.get<bool>("antialias", false);
+ host_ = pt_.get<std::string>("host", "127.0.0.1");
+ port_ = pt_.get<uint16_t>("port", 39390);
+ max_script_execution_time_ = pt_.get<int>("max_script__execution_time", 5000);
+ max_local_storage_size_ = pt_.get<int>("max_local_storage_size", 512000);
+ upnp_ = pt_.get<bool>("upnp", false);
+ udp_port_ = pt_.get<uint16_t>("udp_port", 39391);
+ model_edge_size_ = pt_.get<float>("edge_size",1.0f);
+ stage_ = pt_.get<std::string>("stage","\83P\83\8d\83\8a\83\93\92¬");
screen_width_ = std::max(screen_width_, MIN_SCREEN_WIDTH);
screen_height_ = std::max(screen_height_, MIN_SCREEN_HEIGHT);
#include <fstream>
#include <string>
#include <iostream>
+#include <boost/property_tree/json_parser.hpp>
#include "../common/unicode.hpp"
#include "ManagerAccessor.hpp"
+using namespace boost::property_tree;
+
class ConfigManager
{
public:
std::string stage_;
public:
+
bool fullscreen() const;
int screen_width() const;
int screen_height() const;
private:
ManagerAccessorPtr manager_accessor_;
+ ptree pt_;
static const int MIN_SCREEN_WIDTH;
static const int MIN_SCREEN_HEIGHT;
text: model_name.substring(5),\r
bgcolor: ((even_line = !even_line) ? "#EEAFEECC" : "#FFFFFFCC"),\r
onclick: function() {\r
+ Player.stopMotion();\r
Account.updateModelName(model_name)\r
}\r
})\r
#include "../../common/Logger.hpp"
namespace scene {
-Connect::Connect(const ManagerAccessorPtr& manager_accesor) :
- manager_accesor_(manager_accesor),
- card_manager_(manager_accesor->card_manager().lock()),
- account_manager_(manager_accesor->account_manager().lock()),
- config_manager_(manager_accesor->config_manager().lock()),
- command_manager_(std::make_shared<CommandManager>(manager_accesor_)),
+Connect::Connect(const ManagerAccessorPtr& manager_accessor) :
+ manager_accessor_(manager_accessor),
+ card_manager_(manager_accessor->card_manager().lock()),
+ account_manager_(manager_accessor->account_manager().lock()),
+ config_manager_(manager_accessor->config_manager().lock()),
+ command_manager_(std::make_shared<CommandManager>(manager_accessor_)),
return_flag_(false)
{
- manager_accesor_->set_command_manager(command_manager_);
+ manager_accessor_->set_command_manager(command_manager_);
}
Connect::~Connect()
{
InputManager input;
if (command_manager_->status() == CommandManager::STATUS_READY) {
- return BasePtr(new scene::MainLoop(manager_accesor_));
+ return BasePtr(new scene::MainLoop(manager_accessor_));
} else if (return_flag_) {
- return BasePtr(new scene::Title(manager_accesor_));
+ return BasePtr(new scene::Title(manager_accessor_));
} else {
return BasePtr();
}
void AsyncInitialize();
private:
- ManagerAccessorPtr manager_accesor_;
+ ManagerAccessorPtr manager_accessor_;
CardManagerPtr card_manager_;
AccountManagerPtr account_manager_;
ConfigManagerPtr config_manager_;
{
//account_manager_->set_host(world_manager_->stage()->host_change_flag().second);
return BasePtr(new scene::ServerChange(manager_accessor_));
- }else{
+ } else if (input.GetKeyCount(KEY_INPUT_F1) == 1) {
+ inputbox_.Inactivate();
+ return BasePtr(new scene::Option(manager_accessor_, shared_from_this()));
+ } else{
return nullptr;
}
}
//
#include "Option.hpp"
+#include "../ManagerAccessor.hpp"
+#include "../AccountManager.hpp"
+#include "../CommandManager.hpp"
+#include "../PlayerManager.hpp"
+#include "../AccountManager.hpp"
namespace scene {
+const int Option::TAB_BLOCK_HEIGHT = 32;
+const int Option::TAB_BLOCK_WIDTH = 128;
+
+int Option::selecting_tab_index;
+
Option::Option(const ManagerAccessorPtr& manager_accessor,
const BasePtr& background_scene) :
- manager_accesor_(manager_accessor),
+ manager_accessor_(manager_accessor),
config_manager_(manager_accessor->config_manager().lock()),
card_manager_(manager_accessor->card_manager().lock()),
account_manager_(manager_accessor->account_manager().lock()),
background_scene_(background_scene),
- start_count_(0)
+ start_count_(0),
+ end_count_(0)
{
- manager_accesor_->set_config_manager(config_manager_);
- manager_accesor_->set_card_manager(card_manager_);
- manager_accesor_->set_account_manager(account_manager_);
+ manager_accessor_->set_config_manager(config_manager_);
+ manager_accessor_->set_card_manager(card_manager_);
+ manager_accessor_->set_account_manager(account_manager_);
+
+ base_image_handle_ = ResourceManager::LoadCachedDivGraph<4>(
+ _T("resources/images/gui/gui_option_base.png"), 2, 2, 96, 96);
+
+ tab_base_image_handle_ = ResourceManager::LoadCachedDivGraph<3>(
+ _T("resources/images/gui/gui_option_tab_base.png"), 1, 3, 128, 32);
}
void Option::Begin()
{
-
+ tabs_.push_back(std::make_shared<StatusTab>(manager_accessor_));
+ tabs_.push_back(std::make_shared<CameraTab>(manager_accessor_));
}
void Option::Update()
{
- start_count_++;
+ if (end_count_ > 0) {
+ end_count_++;
+ } else {
+ start_count_++;
+ }
+
if (background_scene_) {
background_scene_->Update();
}
+
+ int screen_width, screen_height;
+ GetScreenState(&screen_width, &screen_height, nullptr);
+
+ if (end_count_ > 0) {
+ bg_alpha_ = 150 * ((10 - end_count_) / 10.0);
+ } else {
+ bg_alpha_ = 150 * (start_count_ / 10.0);
+ }
+ bg_alpha_ = std::min(150, bg_alpha_);
+
+ base_rect_.width = 800;
+ base_rect_.height = 480;
+ base_rect_.x = (screen_width - base_rect_.width) / 2;
+
+ if (end_count_ > 0) {
+ base_rect_.y = -72 - base_rect_.height * (end_count_ / 10.0);
+ } else {
+ base_rect_.y = -72 - base_rect_.height * ((10 - start_count_) / 10.0);
+ }
+ base_rect_.y = std::min(-72, base_rect_.y);
+
+ tabs_[selecting_tab_index]->set_base_rect(base_rect_);
+ tabs_[selecting_tab_index]->Update();
}
void Option::ProcessInput(InputManager* input)
{
+ bool hover = (base_rect_.x <= input->GetMouseX() && input->GetMouseX() <= base_rect_.x + base_rect_.width
+ && base_rect_.y <= input->GetMouseY() && input->GetMouseY() <= base_rect_.y + base_rect_.height);
+
+ if (input->GetKeyCount(KEY_INPUT_F1) == 1 ||
+ input->GetKeyCount(KEY_INPUT_ESCAPE) == 1 ||
+ (!hover && input->GetMouseLeftCount() == 1)) {
+ end_count_++;
+ }
+
+ int tab_index = 0;
+ BOOST_FOREACH(const auto& tab, tabs_) {
+
+ int x = base_rect_.x - 32;
+ int y = base_rect_.y;
+
+ int tab_x = x + 64 - 16;
+ int tab_y = y + 80 + tab_index * TAB_BLOCK_HEIGHT + TAB_BLOCK_HEIGHT - 8;
+ int tab_width = TAB_BLOCK_WIDTH;
+ int tab_height = TAB_BLOCK_HEIGHT;
+
+ bool tab_hover = (tab_x <= input->GetMouseX() && input->GetMouseX() <= tab_x + tab_width
+ && tab_y <= input->GetMouseY() && input->GetMouseY() <= tab_y + tab_height);
+
+ if (tab_hover && input->GetMouseLeftCount() == 1) {
+ selecting_tab_index = tab_index;
+ }
+ tab_index++;
+ }
+
+ tabs_[selecting_tab_index]->ProcessInput(input);
}
void Option::Draw()
background_scene_->Draw();
}
- int width, height;
- GetScreenState(&width, &height, nullptr);
- SetDrawBlendMode(DX_BLENDMODE_ALPHA, 200);
- DrawBox(0, 0, width, height, GetColor(157, 212, 187), TRUE);
+ int screen_width, screen_height;
+ GetScreenState(&screen_width, &screen_height, nullptr);
+
+ SetDrawBlendMode(DX_BLENDMODE_ALPHA, bg_alpha_);
+
+ DrawBox(0, 0, screen_width, screen_height, GetColor(0, 0, 0), TRUE);
SetDrawBlendMode(DX_BLENDMODE_NOBLEND, 0);
+
+ int BASE_BLOCK_SIZE = 96;
+
+ int x = base_rect_.x - 32;
+ int y = base_rect_.y;
+ int width = base_rect_.width + 64;
+ int height = base_rect_.height + 32;
+
+ DrawGraph(x, y, *base_image_handle_[0], TRUE);
+ DrawGraph(x + width - BASE_BLOCK_SIZE, y, *base_image_handle_[1], TRUE);
+ DrawGraph(x, y + height - BASE_BLOCK_SIZE, *base_image_handle_[2], TRUE);
+ DrawGraph(x + width - BASE_BLOCK_SIZE, y + height - BASE_BLOCK_SIZE, *base_image_handle_[3], TRUE);
+
+ DrawRectExtendGraphF(x + BASE_BLOCK_SIZE, y,
+ x + width - BASE_BLOCK_SIZE, y + BASE_BLOCK_SIZE,
+ 0, 0, 1, BASE_BLOCK_SIZE, *base_image_handle_[1], TRUE);
+
+ DrawRectExtendGraphF(x + BASE_BLOCK_SIZE, y + height - BASE_BLOCK_SIZE,
+ x + width - BASE_BLOCK_SIZE, y + height,
+ 0, 0, 1, BASE_BLOCK_SIZE, *base_image_handle_[3], TRUE);
+
+ DrawRectExtendGraphF(x, y + BASE_BLOCK_SIZE,
+ x + BASE_BLOCK_SIZE, y + height - BASE_BLOCK_SIZE,
+ 0, 0, BASE_BLOCK_SIZE, 1, *base_image_handle_[2], TRUE);
+
+ DrawRectExtendGraphF(x + width - BASE_BLOCK_SIZE, y + BASE_BLOCK_SIZE,
+ x + width, y + height - BASE_BLOCK_SIZE,
+ 0, 0, BASE_BLOCK_SIZE, 1, *base_image_handle_[3], TRUE);
+
+ DrawRectExtendGraphF(x + BASE_BLOCK_SIZE, y + BASE_BLOCK_SIZE,
+ x + width - BASE_BLOCK_SIZE, y + height - BASE_BLOCK_SIZE,
+ 0, 0, 1, 1, *base_image_handle_[3], TRUE);
+
+
+ DrawGraph(x + 64 - 16, y + 80 - 8, *tab_base_image_handle_[0], TRUE);
+ DrawGraph(x + 64 - 16, y + height - 80 - 8, *tab_base_image_handle_[2], TRUE);
+
+ int tab_index = 0;
+ BOOST_FOREACH(const auto& tab, tabs_) {
+
+ int tab_x = x + 64;
+ int tab_y = y + 80 + tab_index * TAB_BLOCK_HEIGHT + TAB_BLOCK_HEIGHT;
+
+ if (selecting_tab_index == tab_index) {
+
+ DrawRectExtendGraphF(tab_x - 16, y + 80 - 8 + TAB_BLOCK_HEIGHT,
+ tab_x - 16 + TAB_BLOCK_WIDTH, tab_y - 8,
+ 0, TAB_BLOCK_HEIGHT - 1, TAB_BLOCK_WIDTH, 1,
+ *tab_base_image_handle_[0], TRUE);
+
+ DrawGraph(tab_x - 16, tab_y - 8, *tab_base_image_handle_[1], TRUE);
+
+ DrawRectExtendGraphF(tab_x - 16, tab_y - 8 + TAB_BLOCK_HEIGHT,
+ tab_x - 16 + TAB_BLOCK_WIDTH, y + height - 80 - 8,
+ 0, 0, TAB_BLOCK_WIDTH, 1, *tab_base_image_handle_[2], TRUE);
+
+ } else {
+ SetDrawBlendMode(DX_BLENDMODE_ALPHA, 150);
+ }
+
+ DrawStringToHandle(tab_x, tab_y, tab->name().c_str(),
+ GetColor(0, 0, 0), ResourceManager::default_font_handle());
+
+ SetDrawBlendMode(DX_BLENDMODE_NOBLEND, 0);
+
+ tab_index++;
+ }
+
+ tabs_[selecting_tab_index]->Draw();
}
void Option::End()
BasePtr Option::NextScene()
{
- InputManager input;
- if (input.GetKeyCount(KEY_INPUT_F1) == 1) {
+ if (end_count_ > 10) {
return background_scene_;
} else {
return BasePtr();
}
}
+OptionTabBase::OptionTabBase(const tstring name, const ManagerAccessorPtr& manager_accessor) :
+ name_(name),
+ manager_accessor_(manager_accessor)
+{
+
+}
+
+tstring OptionTabBase::name() const
+{
+ return name_;
+}
+
+void OptionTabBase::set_base_rect(const Rect& rect)
+{
+ base_rect_ = rect;
+}
+
+// \83X\83e\81[\83^\83X\83^\83u
+
+StatusTab::StatusTab(const ManagerAccessorPtr& manager_accessor) :
+ OptionTabBase(_T("\83X\83e\81[\83^\83X"), manager_accessor)
+{
+ auto account_manager = manager_accessor_->account_manager().lock();
+ auto command_manager = manager_accessor_->command_manager().lock();
+ auto player_manager = manager_accessor_->player_manager().lock();
+
+ items_.push_back(std::make_shared<TextItem>(_T("\83j\83b\83N\83l\81[\83\80"),
+ std::make_shared<std::function<tstring(void)>>(
+ [account_manager](){
+ return unicode::ToTString(account_manager->name());
+ }), manager_accessor_));
+
+ items_.push_back(std::make_shared<TextItem>(_T("\83\82\83f\83\8b\96¼"),
+ std::make_shared<std::function<tstring(void)>>(
+ [account_manager](){
+ return unicode::ToTString(account_manager->model_name());
+ }), manager_accessor_));
+
+ items_.push_back(std::make_shared<TextItem>(_T("\83\86\81[\83U\81[ID"),
+ std::make_shared<std::function<tstring(void)>>(
+ [command_manager](){
+ return (tformat(_T("%d")) % command_manager->user_id()).str();
+ }), manager_accessor_));
+
+ items_.push_back(std::make_shared<TextItem>(_T("\83X\83e\81[\83W"),
+ std::make_shared<std::function<tstring(void)>>(
+ [command_manager](){
+ return unicode::ToTString(command_manager->stage());
+ }), manager_accessor_));
+
+ items_.push_back(std::make_shared<TextItem>(_T("\8dÀ\95W"),
+ std::make_shared<std::function<tstring(void)>>(
+ [player_manager]() -> tstring {
+ const auto& pos = player_manager->GetMyself()->position();
+ return (tformat(_T("X: %d Y: %d Z: %d")) % pos.x % pos.y % pos.z).str();
+ }), manager_accessor_));
+
+ items_.push_back(std::make_shared<TextItem>(_T("\95½\8bÏ\8eó\90M\97Ê"),
+ std::make_shared<std::function<tstring(void)>>(
+ [command_manager]() -> tstring {
+ return (tformat(_T("%.1lf byte/s")) % command_manager->GetReadByteAverage()).str();
+ }), manager_accessor_));
+
+ items_.push_back(std::make_shared<TextItem>(_T("\95½\8bÏ\91\97\90M\97Ê"),
+ std::make_shared<std::function<tstring(void)>>(
+ [command_manager]() -> tstring {
+ return (tformat(_T("%.1lf byte/s")) % command_manager->GetWriteByteAverage()).str();
+ }), manager_accessor_));
+}
+
+void StatusTab::Update()
+{
+ int left = base_rect_.x + 128 + 64;
+ int top = base_rect_.y + 80 + 32;
+
+ BOOST_FOREACH(const auto& item, items_) {
+ item->set_base_rect(Rect(left, top));
+ top += item->height();
+ }
+}
+
+void StatusTab::ProcessInput(InputManager* input)
+{
+ BOOST_FOREACH(const auto& item, items_) {
+ item->ProcessInput(input);
+ }
+}
+
+void StatusTab::Draw()
+{
+ BOOST_FOREACH(const auto& item, items_) {
+ item->Draw();
+ }
+}
+
+
+// \83J\83\81\83\89\83^\83u
+
+CameraTab::CameraTab(const ManagerAccessorPtr& manager_accessor) :
+ OptionTabBase(_T("\95\\8e¦\90Ý\92è"), manager_accessor)
+{
+ items_.push_back(std::make_shared<RadioButtonItem>(_T("\83l\81[\83\80\83^\83O\82Æ\90\81\82«\8fo\82µ"),
+ "show_nametag", _T("{\"\95\\8e¦\82·\82é\":1, \"\95\\8e¦\82µ\82È\82¢\":0}"), manager_accessor_));
+}
+
+void CameraTab::Update()
+{
+ int left = base_rect_.x + 128 + 64;
+ int top = base_rect_.y + 80 + 32;
+
+ BOOST_FOREACH(const auto& item, items_) {
+ item->set_base_rect(Rect(left, top));
+ top += item->height();
+ }
+}
+
+void CameraTab::ProcessInput(InputManager* input)
+{
+ BOOST_FOREACH(const auto& item, items_) {
+ item->ProcessInput(input);
+ }
+}
+
+void CameraTab::Draw()
+{
+ BOOST_FOREACH(const auto& item, items_) {
+ item->Draw();
+ }
+}
+
+
+OptionItemBase::OptionItemBase(const ManagerAccessorPtr& manager_accessor) :
+ manager_accessor_(manager_accessor)
+{
+
+}
+
+void OptionItemBase::set_base_rect(const Rect& rect)
+{
+ base_rect_ = rect;
+}
+
+TextItem::TextItem(const tstring& name,
+ const TextItemCallbackPtr& callback,
+ const ManagerAccessorPtr& manager_accessor) :
+ OptionItemBase(manager_accessor),
+ name_(name),
+ callback_(callback)
+{
+
+}
+
+void TextItem::Update()
+{
+
+}
+
+void TextItem::ProcessInput(InputManager* input)
+{
+
+}
+
+void TextItem::Draw()
+{
+ DrawStringToHandle(base_rect_.x, base_rect_.y,
+ name_.c_str(), GetColor(58, 133, 86), ResourceManager::default_font_handle());
+
+ if (callback_) {
+ DrawStringToHandle(base_rect_.x + 192, base_rect_.y,
+ (*callback_)().c_str(),
+ GetColor(0, 0, 0), ResourceManager::default_font_handle());
+ }
+}
+
+int TextItem::height() const
+{
+ return 24;
+}
+
+RadioButtonItem::RadioButtonItem(const tstring& name,
+ const std::string& path,
+ const tstring& items,
+ const ManagerAccessorPtr& manager_accessor) :
+ OptionItemBase(manager_accessor),
+ name_(name),
+ path_(path),
+ selecting_index_(0)
+{
+ selecting_bg_image_handle_ = ResourceManager::LoadCachedDivGraph<3>(
+ _T("resources/images/gui/gui_option_selecting_bg.png"), 3, 1, 16, 20);
+
+ ptree item_array;
+ read_json(std::stringstream(unicode::ToString(items)), item_array);
+
+ auto account_manager = manager_accessor_->account_manager().lock();
+ auto value = account_manager->Get(path_);
+
+ int index = 0;
+ BOOST_FOREACH(const auto& item, item_array) {
+ auto text = unicode::ToTString(item.first);
+ int width = GetDrawStringWidthToHandle(
+ text.c_str(), text.size(), ResourceManager::default_font_handle());
+ items_.push_back(Item(text, item.second, width));
+
+ if (value == item.second) {
+ selecting_index_ = index;
+ }
+
+ index++;
+ }
+}
+
+void RadioButtonItem::Update()
+{
+
+}
+
+void RadioButtonItem::ProcessInput(InputManager* input)
+{
+ int item_left = base_rect_.x + 192;
+ int index = 0;
+ BOOST_FOREACH(const auto& item, items_) {
+ int left = item_left;
+ int right = left + item.width;
+
+ bool hover = (left <= input->GetMouseX() && input->GetMouseX() <= right
+ && base_rect_.y <= input->GetMouseY() && input->GetMouseY() <= base_rect_.y + height());
+
+ if (hover && input->GetMouseLeftCount() == 1) {
+ auto account_manager = manager_accessor_->account_manager().lock();
+ account_manager->Set(path_, item.value);
+ selecting_index_ = index;
+ }
+
+ item_left += item.width + 20;
+ index++;
+ }
+}
+
+void RadioButtonItem::Draw()
+{
+ DrawStringToHandle(base_rect_.x, base_rect_.y,
+ name_.c_str(), GetColor(58, 133, 86), ResourceManager::default_font_handle());
+
+ int item_left = base_rect_.x + 192;
+ int index = 0;
+ BOOST_FOREACH(const auto& item, items_) {
+
+ int left = item_left;
+ int right = left + item.width;
+
+ if (index != selecting_index_) {
+ SetDrawBlendMode(DX_BLENDMODE_SUB, 40);
+ }
+
+ DrawGraph(left - 8, base_rect_.y - 2, *selecting_bg_image_handle_[0], TRUE);
+ DrawRectExtendGraphF(left - 8 + 16, base_rect_.y - 2,
+ right - 16 + 8, base_rect_.y - 2 + 20,
+ 0, 0, 1, 20, *selecting_bg_image_handle_[2], TRUE);
+ DrawGraph(right - 16 + 8, base_rect_.y - 2, *selecting_bg_image_handle_[2], TRUE);
+
+ SetDrawBlendMode(DX_BLENDMODE_NOBLEND, 0);
+
+ DrawStringToHandle(left, base_rect_.y,
+ item.name.c_str(),
+ GetColor(0, 0, 0), ResourceManager::default_font_handle());
+
+
+ item_left += item.width + 20;
+
+ index++;
+ }
+}
+
+int RadioButtonItem::height() const
+{
+ return 24;
+}
+
}
\ No newline at end of file
#pragma once
+#include <boost/property_tree/json_parser.hpp>
#include "Base.hpp"
#include "../ManagerHeader.hpp"
#include "../ManagerAccessor.hpp"
+#include "../ResourceManager.hpp"
+#include "../ui/UISuper.hpp"
+
+using namespace boost::property_tree;
namespace scene {
-class Option : public Base {
+class OptionTabBase;
+typedef std::shared_ptr<OptionTabBase> OptionTabPtr;
+
+class OptionItemBase;
+typedef std::shared_ptr<OptionItemBase> OptionItemPtr;
+
+class Option : public Base {
public:
Option(const ManagerAccessorPtr& manager_accessor,
const BasePtr& background_scene);
void AsyncInitialize();
private:
- ManagerAccessorPtr manager_accesor_;
+ ManagerAccessorPtr manager_accessor_;
ConfigManagerPtr config_manager_;
CardManagerPtr card_manager_;
AccountManagerPtr account_manager_;
BasePtr background_scene_;
int start_count_;
+ int end_count_;
+
+ int bg_alpha_;
+ Rect base_rect_;
+ std::array<ImageHandlePtr,4> base_image_handle_;
+ std::array<ImageHandlePtr,3> tab_base_image_handle_;
+
+ std::vector<OptionTabPtr> tabs_;
+ static int selecting_tab_index;
+
+ private:
+ static const int TAB_BLOCK_HEIGHT;
+ static const int TAB_BLOCK_WIDTH;
+};
+
+class OptionTabBase {
+ public:
+ OptionTabBase(const tstring name,
+ const ManagerAccessorPtr& manager_accessor);
+
+ virtual void Update() = 0;
+ virtual void ProcessInput(InputManager*) = 0;
+ virtual void Draw() = 0;
+
+ tstring name() const;
+ void set_base_rect(const Rect& rect);
+
+ protected:
+ ManagerAccessorPtr manager_accessor_;
+
+ Rect base_rect_;
+ tstring name_;
+
+ std::vector<OptionItemPtr> items_;
+};
+
+// \83X\83e\81[\83^\83X\83^\83u
+class StatusTab : public OptionTabBase {
+ public:
+ StatusTab(const ManagerAccessorPtr& manager_accessor);
+
+ void Update();
+ void ProcessInput(InputManager*);
+ void Draw();
+};
+
+// \83J\83\81\83\89
+class CameraTab : public OptionTabBase {
+ public:
+ CameraTab(const ManagerAccessorPtr& manager_accessor);
+
+ void Update();
+ void ProcessInput(InputManager*);
+ void Draw();
+};
+
+class OptionItemBase {
+ public:
+ OptionItemBase(const ManagerAccessorPtr& manager_accessor);
+
+ virtual void Update() = 0;
+ virtual void ProcessInput(InputManager*) = 0;
+ virtual void Draw() = 0;
+
+ virtual int height() const = 0;
+ void set_base_rect(const Rect& rect);
+
+ protected:
+ ManagerAccessorPtr manager_accessor_;
+ Rect base_rect_;
+
+};
+
+typedef std::shared_ptr<std::function<tstring(void)>> TextItemCallbackPtr;
+class TextItem : public OptionItemBase {
+ public:
+ TextItem(const tstring& name,
+ const TextItemCallbackPtr& callback,
+ const ManagerAccessorPtr& manager_accessor);
+
+ void Update();
+ void ProcessInput(InputManager*);
+ void Draw();
+ int height() const;
+
+ private:
+ tstring name_;
+ TextItemCallbackPtr callback_;
};
+
+class RadioButtonItem : public OptionItemBase {
+ public:
+ RadioButtonItem(const tstring& name,
+ const std::string& path,
+ const tstring& items,
+ const ManagerAccessorPtr& manager_accessor);
+
+ void Update();
+ void ProcessInput(InputManager*);
+ void Draw();
+ int height() const;
+
+ private:
+ struct Item{
+ Item(tstring _name, ptree _value, int _width) :
+ name(_name), value(_value), width(_width) {}
+ tstring name;
+ ptree value;
+ int width;
+ };
+
+ private:
+ tstring name_;
+ std::string path_;
+ std::vector<Item> items_;
+ int selecting_index_;
+
+ std::array<ImageHandlePtr,3> selecting_bg_image_handle_;
+};
+
+
+
}
\ No newline at end of file
#include "../../common/Logger.hpp"
namespace scene {
-ServerChange::ServerChange(const ManagerAccessorPtr& manager_accesor) :
- manager_accessor_(manager_accesor),
- card_manager_(manager_accesor->card_manager().lock()),
- account_manager_(manager_accesor->account_manager().lock()),
- config_manager_(manager_accesor->config_manager().lock()),
- world_manager_(manager_accesor->world_manager().lock())
+ServerChange::ServerChange(const ManagerAccessorPtr& manager_accessor) :
+ manager_accessor_(manager_accessor),
+ card_manager_(manager_accessor->card_manager().lock()),
+ account_manager_(manager_accessor->account_manager().lock()),
+ config_manager_(manager_accessor->config_manager().lock()),
+ world_manager_(manager_accessor->world_manager().lock())
{
}
void AsyncInitialize();
private:
- ManagerAccessorPtr manager_accesor_;
+ ManagerAccessorPtr manager_accessor_;
CardManagerPtr card_manager_;
AccountManagerPtr account_manager_;
ConfigManagerPtr config_manager_;
#pragma once
+#include "UISuper.hpp"
#include "UIBoard.hpp"
#include "UIButton.hpp"
#include "UILabel.hpp"
#define MMO_VERSION_MAJOR 0
#define MMO_VERSION_MINOR 3
-#define MMO_VERSION_REVISION 9
+#define MMO_VERSION_REVISION 10
#define MMO_PROTOCOL_VERSION 2
base_dir = os.path.dirname(__file__)
subprocess.call('Devenv "' + os.path.join(base_dir, 'mmo.sln') + '" /build release', shell=True)
-version_header = open(os.path.join(base_dir, 'client/version.hpp')).read()
-ver_major = re.search("#define MMO_VERSION_MAJOR\s+(\d+)", version_header).group(1)
-ver_minor = re.search("#define MMO_VERSION_MINOR\s+(\d+)", version_header).group(1)
-ver_revision = re.search("#define MMO_VERSION_REVISION\s+(\d+)", version_header).group(1)
+def make_full_package():
+ version_header = open(os.path.join(base_dir, 'client/version.hpp')).read()
+ ver_major = re.search("#define MMO_VERSION_MAJOR\s+(\d+)", version_header).group(1)
+ ver_minor = re.search("#define MMO_VERSION_MINOR\s+(\d+)", version_header).group(1)
+ ver_revision = re.search("#define MMO_VERSION_REVISION\s+(\d+)", version_header).group(1)
-ver_text = ver_major + "." + ver_minor + "." + ver_revision
+ ver_text = ver_major + "." + ver_minor + "." + ver_revision
-build_version_path = os.path.join(base_dir, 'client/buildversion.hpp')
+ build_version_path = os.path.join(base_dir, 'client/buildversion.hpp')
-if os.path.exists(build_version_path):
- build_version_header = open(build_version_path).read()
- ver_build = re.search("#define MMO_VERSION_BUILD\s+(\d+)", build_version_header).group(1)
- ver_text += "_" + ver_build
+ if os.path.exists(build_version_path):
+ build_version_header = open(build_version_path).read()
+ ver_build = re.search("#define MMO_VERSION_BUILD\s+(\d+)", build_version_header).group(1)
+ ver_text += "_" + ver_build
-zip_path = os.path.join(base_dir, "mmo-" + ver_text + ".zip")
-zip = zipfile.ZipFile(zip_path, 'w', zipfile.ZIP_DEFLATED)
+ zip_path = os.path.join(base_dir, "mmo-" + ver_text + ".zip")
+ zip = zipfile.ZipFile(zip_path, 'w', zipfile.ZIP_DEFLATED)
-bin_path = os.path.join(base_dir, 'client/bin/')
+ bin_path = os.path.join(base_dir, 'client/bin/')
+ zip.write(os.path.join(base_dir, 'release/client.exe'), 'client.exe')
+ zip.write(os.path.join(base_dir, 'readme.txt'), 'readme.txt')
+ zip.write(os.path.join(base_dir, 'license.txt'), 'license.txt')
+ zip.write(os.path.join(base_dir, 'mmd.txt'), 'mmd.txt')
-zip.write(os.path.join(base_dir, 'release/client.exe'), 'client.exe')
+ zip.write(os.path.join(base_dir, 'server/config.json'), 'server/config.json')
-zip.write(os.path.join(base_dir, 'readme.txt'), 'readme.txt')
-zip.write(os.path.join(base_dir, 'license.txt'), 'license.txt')
-zip.write(os.path.join(base_dir, 'mmd.txt'), 'mmd.txt')
+ zip.write(os.path.join(bin_path, 'config.json'), 'config.json')
+ zip.write(os.path.join(bin_path, 'server/server.exe'), 'server/server.exe')
-zip.write(os.path.join(base_dir, 'server/config.json'), 'server/config.json')
+ for root, dirs, files in os.walk(os.path.join(bin_path, 'cards')):
+ for file in files:
+ absolute_path = os.path.join(root, file)
+ relative_path = os.path.relpath(absolute_path, bin_path)
+ zip.write(absolute_path, relative_path)
+
+ for root, dirs, files in os.walk(os.path.join(bin_path, 'resources')):
+ for file in files:
+ absolute_path = os.path.join(root, file)
+ relative_path = os.path.relpath(absolute_path, bin_path)
+ zip.write(absolute_path, relative_path)
+
+ zip.close()
+
+def make_server_package():
+ version_header = open(os.path.join(base_dir, 'server/version.hpp')).read()
+ ver_major = re.search("#define MMO_VERSION_MAJOR\s+(\d+)", version_header).group(1)
+ ver_minor = re.search("#define MMO_VERSION_MINOR\s+(\d+)", version_header).group(1)
+ ver_revision = re.search("#define MMO_VERSION_REVISION\s+(\d+)", version_header).group(1)
-zip.write(os.path.join(bin_path, 'config.json'), 'config.json')
-zip.write(os.path.join(bin_path, 'server/server.exe'), 'server/server.exe')
+ ver_text = ver_major + "." + ver_minor + "." + ver_revision
-for root, dirs, files in os.walk(os.path.join(bin_path, 'cards')):
- for file in files:
- absolute_path = os.path.join(root, file)
- relative_path = os.path.relpath(absolute_path, bin_path)
- zip.write(absolute_path, relative_path)
-
-for root, dirs, files in os.walk(os.path.join(bin_path, 'resources')):
- for file in files:
- absolute_path = os.path.join(root, file)
- relative_path = os.path.relpath(absolute_path, bin_path)
- zip.write(absolute_path, relative_path)
-
-zip.close()
\ No newline at end of file
+ build_version_path = os.path.join(base_dir, 'server/buildversion.hpp')
+
+ if os.path.exists(build_version_path):
+ build_version_header = open(build_version_path).read()
+ ver_build = re.search("#define MMO_VERSION_BUILD\s+(\d+)", build_version_header).group(1)
+ ver_text += "_" + ver_build
+
+ zip_path = os.path.join(base_dir, "mmo-server-" + ver_text + ".zip")
+ zip = zipfile.ZipFile(zip_path, 'w', zipfile.ZIP_DEFLATED)
+
+ zip.write(os.path.join(base_dir, 'license.txt'), 'license.txt')
+ zip.write(os.path.join(base_dir, 'server/config.json'), 'config.json')
+ zip.write(os.path.join(base_dir, 'server/readme.txt'), 'readme.txt')
+
+ bin_path = os.path.join(base_dir, 'client/bin/')
+ zip.write(os.path.join(bin_path, 'server/server.exe'), 'server.exe')
+
+ zip.close()
+
+make_full_package();
+make_server_package();
\ No newline at end of file
OSDN Git Service
