void c_rpc_server::c_session::read_handler_hmac(const boost::system::error_code &error, std::size_t bytes_transferred) {
_dbg("readed " << bytes_transferred << " bytes of hmac authenticator");
_dbg("authenticate message");
if (error) {
_dbg("asio error " << error.message());
delete_me();
return;
}
int ret = crypto_auth_hmacsha512_verify(m_hmac_authenticator.data(),
reinterpret_cast<const unsigned char *>(m_received_data.data()),
m_received_data.size(),
m_hmac_key.data()
);
if (ret == -1) {
_warn("hmac authentication error");
delete_me();
return;
}
assert(ret == 0);
try {
execute_rpc_command(m_received_data);
} catch (const std::exception &e) {
_erro( "exception read_handler " << e.what());
_erro( "close connection\n" );
delete_me();
return;
}
}
void wrap_thread::join() {
if(!m_future.valid())
return;
if (m_destroy_timeout == std::chrono::seconds(0)) {
_erro("wrap_thread with not set time should be joined manualy using try_join()!");
std::abort();
}
else {
std::future_status status = m_future.wait_for(m_destroy_timeout);
if (status != std::future_status::ready) {
_erro("can not end thread in given time");
std::abort();
}
m_future.get();
}
}
string_as_bin::string_as_bin(const string_as_hex & encoded) {
try {
// "ff020a" = ff , 02 , 0a
// "020a" = 02 , 0a
// "20a" = 02 , 0a
_info("Processing string: ["<< (encoded.data) << "]");
const auto es = encoded.data.size();
if (!es) return; // empty string encoded --> empty binary string
size_t retsize = es/2; // size of finall string of bytes data
if (0 != (es % 2)) retsize++;
assert(retsize > 0); // the binary string will be not-empty (empty case is covered already)
assert( (retsize < es) || ((retsize==1)&&(es==1)) ); // binary string is smaller -or- both are ==1 for e.g. encoded "a" means "0a" so it should result in ---> a 1-byte binary string
bytes.resize(retsize);
size_t pos=0, out=0; // position of input, and output
for( ; pos<es ; pos+=2, ++out) {
// _info("pos="<<pos<<" out="<<out<<" encoded="<<encoded.data);
// "02" -> cl="2" ch="0"
// "2" -> cl="2" ch="0"
char cl,ch;
if (pos+1 < es) { // pos and pos+1 are valid positions in string
ch = encoded.data.at(pos);
cl = encoded.data.at(pos+1);
} else {
ch = '0';
cl = encoded.data.at(pos);
}
unsigned char octet = hexchar2int(ch)*16 + hexchar2int(cl);
bytes.at(out) = octet;
}
assert( out == retsize ); // all expected positions of data allocated above in .resize() were written
} catch(std::exception &e) { _erro("Failed to parse string [" << encoded.data <<"]"); throw ; }
}
void c_rpc_server::c_session::execute_rpc_command(const std::string &input_message) {
try {
nlohmann::json j = nlohmann::json::parse(input_message);
const std::string cmd_name = j.begin().value();
_dbg("cmd name " << cmd_name);
// calling rpc function
const std::string response = m_rpc_server_ptr->m_rpc_functions_map.at(cmd_name)(input_message);
// serialize response
assert(response.size() <= std::numeric_limits<uint16_t>::max());
uint16_t size = static_cast<uint16_t>(response.size());
m_write_data.resize(size + 2); ///< 2 first bytes for size
m_write_data.at(0) = static_cast<char>(size >> 8);
m_write_data.at(1) = static_cast<char>(size & 0xFF);
for (size_t i = 0; i < response.size(); ++i)
m_write_data.at(i + 2) = response.at(i);
// send response
_dbg("send packet");
_dbg(m_write_data);
std::array<unsigned char, crypto_auth_hmacsha512_BYTES> hash;
int ret = crypto_auth_hmacsha512(hash.data(), reinterpret_cast<unsigned char *>(&m_write_data.at(2)), size, m_rpc_server_ptr->m_hmac_key.data());
if (ret != 0) _throw_error(std::runtime_error("crypto_auth_hmacsha512 error"));
_dbg("hmac");
//for (const auto & byte : hash) std::cout << std::hex << "0x" << static_cast<int>(byte) << " ";
//std::cout << std::dec << std::endl;
std::array<boost::asio::const_buffer, 2> buffers = {
{boost::asio::buffer(m_write_data.data(), m_write_data.size()),
boost::asio::buffer(hash.data(), hash.size())}
};
m_socket.async_write_some(buffers,
[this](const boost::system::error_code& error, std::size_t bytes_transferred) {
write_handler(error, bytes_transferred);
});
}
catch (const std::exception &e) {
_erro( "exception in execute_rpc_command " << e.what() );
_erro( "close connection\n" );
delete_me();
return;
}
}
void c_rpc_server::c_session::write_handler(const boost::system::error_code &error, std::size_t bytes_transferred) {
UNUSED(bytes_transferred);
try {
if (error) {
_dbg("asio error " << error.message());
delete_me();
return;
}
// continue reading
async_read(m_socket, boost::asio::buffer(&m_data_size.at(0), m_data_size.size()),
[this](const boost::system::error_code &error, std::size_t bytes_transferred) {
read_handler_size(error, bytes_transferred);
});
}
catch (const std::exception &e) {
_erro( "exception in write_handler " << e.what() );
_erro( "close connection\n" );
delete_me();
return;
}
}
wrap_thread::~wrap_thread() {
m_time_stopped = t_sysclock::now();
_info("wrap_thread destructor." + info());
if(!m_future.valid()) {
_info("wrap_thread destructor - nothing to do (it was joined already?)"); // XXX more comments
return;
}
if (m_destroy_timeout != std::chrono::seconds(0)) {
_info("wrap_thread destructor - will try to join it automatically, for time: " << m_destroy_timeout.count());
std::future_status status = m_future.wait_for(m_destroy_timeout);
if (status != std::future_status::ready) {
_erro("can not end thread in given time. Will abort now.");
std::abort();
}
_info("thread was correctly joined it seems");
m_future.get(); // why? XXX
} else {
_erro("This thread was not joined, and you set to not wait for joining. Will abort.");
std::abort();
}
}
void c_the_program::startup_locales() {
setlocale(LC_ALL,"");
/* boost::locale::generator gen;
// Specify location of dictionaries
gen.add_messages_path(m_install_dir_share_locale);
gen.add_messages_domain("galaxy42_main");
std::string locale_name;
try {
locale_name = std::use_facet<boost::locale::info>(gen("")).name();
std::cerr << "Locale: " << locale_name << endl;
} catch (const std::exception &e) {
std::cerr << "Can not detect language, set default language" << "\n";
locale_name = "en_US.UTF-8";
}
std::locale::global(gen(locale_name));
//std::locale::global(gen("pl_PL.UTF-8")); // OK
//std::locale::global(gen("Polish_Poland.UTF-8")); // not works
std::cout.imbue(std::locale());
std::cerr.imbue(std::locale());
// Using mo_file_reader::gettext:
std::cerr << std::string(80,'=') << std::endl << mo_file_reader::gettext("L_warning_work_in_progres") << std::endl << std::endl;
std::cerr << mo_file_reader::gettext("L_program_is_pre_pre_alpha") << std::endl;
std::cerr << mo_file_reader::gettext("L_program_is_copyrighted") << std::endl;
std::cerr << std::endl;
*/
try {
mo_file_reader mo_reader;
_fact("Adding MO for" << m_install_dir_share_locale);
mo_reader.add_messages_dir(m_install_dir_share_locale);
mo_reader.add_mo_filename(std::string("galaxy42_main"));
mo_reader.read_file();
} catch (const std::exception &e) {
_erro( "mo file open error: " << e.what() );
}
_fact( std::string(80,'=') << std::endl << mo_file_reader::gettext("L_warning_work_in_progres") << std::endl );
_fact( mo_file_reader::gettext("L_program_is_pre_pre_alpha") );
_fact( mo_file_reader::gettext("L_program_is_copyrighted") );
_fact( "" );
// const std::string m_install_dir_share_locale="share/locale"; // for now, for running in place
// setlocale(LC_ALL,"");
// string used_domain = bindtextdomain ("galaxy42_main", m_install_dir_share_locale.c_str() );
// textdomain("galaxy42_main");
// Using mo_file_reader::gettext:
// std::cerr << mo_reader::mo_file_reader::gettext("L_program_is_pre_pre_alpha") << std::endl;
// std::cerr << mo_reader::mo_file_reader::gettext("L_program_is_copyrighted") << std::endl;
}
TEST(utils_wrap_thread, thread_at_throws_in_middle_of_move) {
std::vector<wrap_thread> vec;
vec.resize(1);
vec.at(0) = wrap_thread();
// with normal thread, it would continue to run because it was spawned
// in the temporary - we would have created std::thread( {some..work..in..lanbda} )
// and the thread would keep running since the exception would end function before thread is joined
std::atomic<bool> endflag{false};
_info("Thread will start now");
auto example_function_causing_abort = [&]() {
_info("Starting the bad function that should crash (abort)");
try {
auto mythread =
wrap_thread(std::chrono::seconds(2), [&](){
while(!endflag) {
int volatile x=1,y=2; x=y; // to not have thread that never makes progress
if (x==y) { }
}
} );
vec.at(1) = std::move(mythread) ;
_erro("This code should not be reached (above the function at() should throw");
bool joined = vec.at(1).try_join( std::chrono::seconds(5) ); // trying to join for few seconds
_erro("This unreachable code, has joined=" << joined);
}
catch(const std::out_of_range &) {
_erro("As expected, the code thrown... though we will not reach this place here, since the destructor of now detached thread will abort program.");
FAIL(); // unreachable
}
_erro("Should not reach this place");
FAIL(); // unreachable
};
EXPECT_DEATH( { example_function_causing_abort(); } , ""); // catch std::abort
void c_rpc_server::c_session::execute_rpc_command(const std::string &input_message) {
try {
nlohmann::json j = nlohmann::json::parse(input_message);
const std::string cmd_name = j["cmd"];//.begin().value();
dbg("cmd name " << cmd_name);
// calling rpc function
nlohmann::json json_response;
{
LockGuard<Mutex> lg(m_rpc_server_ptr->m_rpc_functions_map_mutex);
json_response = m_rpc_server_ptr->m_rpc_functions_map.at(cmd_name)(input_message);
}
json_response["id"] = get_command_id();
if (j.find("id")!= j.end()) {
json_response["re"] = j["id"];
}
send_response(json_response);
}
catch (const std::exception &e) {
_erro( "exception in execute_rpc_command " << e.what() );
_erro( "close connection\n" );
delete_me();
return;
}
}
size_t c_udp_wrapper_linux::receive_data(void *data_buf, const size_t data_buf_size, c_ip46_addr &from_address) {
sockaddr_in6 from_addr_raw; // peering address of peer (socket sender), raw format
socklen_t from_addr_raw_size = sizeof(from_addr_raw); // ^ size of it
auto size_read = recvfrom(m_socket, data_buf, data_buf_size, 0, reinterpret_cast<sockaddr*>( & from_addr_raw), & from_addr_raw_size);
if (from_addr_raw_size == sizeof(sockaddr_in6)) { // the message arrive from IP pasted into sockaddr_in6 format
_erro("NOT IMPLEMENTED yet - recognizing IP of ipv6 peer"); // peeripv6-TODO(r)(easy)
// trivial
}
else if (from_addr_raw_size == sizeof(sockaddr_in)) { // the message arrive from IP pasted into sockaddr_in (ipv4) format
sockaddr_in addr = * reinterpret_cast<sockaddr_in*>(& from_addr_raw); // mem-cast-TODO(p) confirm reinterpret
from_address.set_ip4(addr);
} else {
_throw_error( std::runtime_error("Data arrived from unknown socket address type") );
}
return size_read;
}
bool t_command_parser_executor::out_peers(const std::vector<std::string>& args)
{
if (args.empty()) return false;
unsigned int limit;
try {
limit = std::stoi(args[0]);
}
catch(std::invalid_argument& ex) {
_erro("stoi exception");
return false;
}
return m_executor.out_peers(limit);
}
void c_tun_device_windows::handle_read(const boost::system::error_code& error, std::size_t length) {
try {
if (length < 1) throw std::runtime_error("Readed 0 bytes from tun");
if (error) throw std::runtime_error(error.message());
if (length < 54) throw std::runtime_error("tun data length < 54"); // 54 == sum of header sizes
m_readed_bytes = length;
if (c_ndp::is_packet_neighbor_solicitation(m_buffer)) {
std::array<uint8_t, 94> neighbor_advertisement_packet = c_ndp::generate_neighbor_advertisement(m_buffer);
boost::system::error_code ec;
boost::asio::write(*m_stream_handle_ptr.get(), boost::asio::buffer(neighbor_advertisement_packet), ec); // prepares: blocks (but TUN is fast)
if (ec) throw std::runtime_error("write neighbor advertisement packet to TUN error: " + ec.message());
}
}
catch (const std::runtime_error &e) {
m_readed_bytes = 0;
_erro("Problem with the TUN/TAP parser" << e.what());
_throw_error_sub( tuntap_error_devtun, "Problem with TUN/TAP device");
}
// continue reading
m_stream_handle_ptr->async_read_some(boost::asio::buffer(m_buffer),
boost::bind(&c_tun_device_windows::handle_read, this, boost::asio::placeholders::error, boost::asio::placeholders::bytes_transferred));
}
std::wstring c_tun_device_windows::get_device_guid() {
const std::wstring adapterKey = L"SYSTEM\\CurrentControlSet\\Control\\Class\\{4D36E972-E325-11CE-BFC1-08002BE10318}";
_fact("Looking for device guid" << to_string(adapterKey));
LONG status = 1;
HKEY key = nullptr;
status = RegOpenKeyExW(HKEY_LOCAL_MACHINE, adapterKey.c_str(), 0, KEY_READ, &key);
if (status != ERROR_SUCCESS) throw std::runtime_error("RegOpenKeyEx error, error code " + std::to_string(status));
hkey_wrapper key_wrapped(key);
std::vector<std::wstring> subkeys_vector;
try {
subkeys_vector = get_subkeys(key_wrapped.get());
} catch (const std::exception &e) {
key_wrapped.close();
throw e;
}
_dbg1("found " << subkeys_vector.size() << " reg keys");
key_wrapped.close();
for (const auto & subkey : subkeys_vector) { // foreach sub key
if (subkey == L"Properties") continue;
std::wstring subkey_reg_path = adapterKey + L"\\" + subkey;
_fact(to_string(subkey_reg_path));
status = RegOpenKeyExW(HKEY_LOCAL_MACHINE, subkey_reg_path.c_str(), 0, KEY_QUERY_VALUE, &key);
if (status != ERROR_SUCCESS) throw std::runtime_error("RegOpenKeyEx error, error code " + std::to_string(status));
// get ComponentId field
DWORD size = 256;
std::wstring componentId(size, '\0');
// this reinterpret_cast is not UB(3.10.10) because LPBYTE == unsigned char *
// https://msdn.microsoft.com/en-us/library/windows/desktop/aa383751(v=vs.85).aspx
status = RegQueryValueExW(key, L"ComponentId", nullptr, nullptr, reinterpret_cast<LPBYTE>(&componentId[0]), &size);
if (status != ERROR_SUCCESS) {
RegCloseKey(key);
continue;
}
key_wrapped.set(key);
std::wstring netCfgInstanceId;
try {
if (componentId.substr(0, 8) == L"root\\tap" || componentId.substr(0, 3) == L"tap") { // found TAP
_note(to_string(subkey_reg_path));
size = 256;
netCfgInstanceId.resize(size, '\0');
// this reinterpret_cast is not UB(3.10.10) because LPBYTE == unsigned char *
// https://msdn.microsoft.com/en-us/library/windows/desktop/aa383751(v=vs.85).aspx
status = RegQueryValueExW(key_wrapped.get(), L"NetCfgInstanceId", nullptr, nullptr, reinterpret_cast<LPBYTE>(&netCfgInstanceId[0]), &size);
if (status != ERROR_SUCCESS) throw std::runtime_error("RegQueryValueEx error, error code " + std::to_string(GetLastError()));
netCfgInstanceId.erase(size / sizeof(wchar_t) - 1); // remove '\0'
_note(to_string(netCfgInstanceId));
key_wrapped.close();
HANDLE handle = open_tun_device(netCfgInstanceId);
if (handle == INVALID_HANDLE_VALUE) continue;
else {
BOOL ret = CloseHandle(handle);
if (ret == 0) throw std::runtime_error("CloseHandle error, " + std::to_string(GetLastError()));
}
return netCfgInstanceId;
}
} catch (const std::out_of_range &e) {
_warn(std::string("register value processing error ") + e.what());
_note("componentId = " + to_string(componentId));
_note("netCfgInstanceId " + to_string(netCfgInstanceId));
}
key_wrapped.close();
}
_erro("Can not find device in windows registry");
throw std::runtime_error("Device not found");
}
void c_simulation::main_loop () {
// PALETTE palette;
//BITMAP *img_bgr = load_bitmap("dat/bgr-bright.tga", NULL); // TODO:
s_font_allegl.reset (allegro_gl_convert_allegro_font(font,AGL_FONT_TYPE_TEXTURED,500.0), [](FONT *f){allegro_gl_destroy_font(f);});
for(auto &obj : m_world->m_objects) {
obj->set_font(s_font_allegl);
}
int viewport_x = 0, viewport_y = 0;
//show_mouse(m_screen);
set_close_button_callback(c_close_button_handler);
bool print_connect_line = false;
bool start_simulation = false;
bool simulation_pause = true;
shared_ptr<c_cjddev> connect_node;
std::chrono::steady_clock::time_point last_click_time =
std::chrono::steady_clock::now() - std::chrono::milliseconds(1000);
m_gui = make_shared<c_gui>();
// prepare drawtarget surface to draw to
switch (m_drawtarget_type) {
case e_drawtarget_type_allegro:
m_drawtarget = make_shared<c_drawtarget_allegro>(m_frame);
break;
case e_drawtarget_type_opengl:
m_drawtarget = make_shared<c_drawtarget_opengl>();
break;
default:
_erro("Warning: unsupported drawtarget");
}
m_drawtarget->m_gui = m_gui;
// bool allegro_keys_any_was=false; // is any key pressed right now (for key press/release)
long loop_miliseconds = 0;
long unsigned int frame_checkpoint = 0; /// needed for speed control (without world_draw manipulate in spacetime!)
_UNUSED(frame_checkpoint);
bool use_input_allegro = true; // always for now. input from Allegro
bool use_draw_allegro = m_drawtarget_type == e_drawtarget_type_allegro; // draw in allegro
bool use_draw_opengl = m_drawtarget_type == e_drawtarget_type_opengl; // draw in opengl
_note("Entering main simulation loop");
// The main drawing is done inside this loop.
///@see rendering.txt/[[drawing_main]]
float view_angle = 0.0;
//float camera_offset = 1.0;
float zoom = 1.0;
float camera_step_z=-11.0;
// === main loop ===
while (!m_goodbye && !close_button_pressed) {
auto start_time = std::chrono::high_resolution_clock::now();
// --- process the keyboard/inputs ---
if (use_input_allegro) {
// TODO move this code here, but leave the variables in higher scope
}
poll_keyboard();
auto allegro_keys = key;
auto allegro_shifts = key_shifts;
// bool allegro_keys_any_is=false;
// for (size_t i=0; i<sizeof(allegro_keys)/sizeof(allegro_keys[0]); ++i) allegro_keys_any_is=true;
// the direct raw position
const int allegro_mouse_x = mouse_x;
const int allegro_mouse_y = mouse_y;
const int allegro_mouse_b = mouse_b; // buttons
// the position in display port GUI
const int gui_mouse_x = allegro_mouse_x;
const int gui_mouse_y = allegro_mouse_y;
const int gui_mouse_b = allegro_mouse_b; // buttons
// the position in the world coordinates
const int gui_cursor_x = m_gui->view_x_rev(gui_mouse_x);
const int gui_cursor_y = m_gui->view_y_rev(gui_mouse_y);
const int gui_cursor_z = 0; // m_gui->view_z_rev(gui_mouse_z);
_UNUSED(gui_mouse_b);
_UNUSED(gui_cursor_x);
_UNUSED(gui_cursor_y);
_UNUSED(gui_cursor_z);
//_dbg1("mouse_x mouse_y: " << gui_mouse_x << " " << gui_mouse_y);
int allegro_char = 0;
if (keypressed()) {
allegro_char = readkey();
}
// end of input
// draw background of frame
if (use_draw_allegro) {
clear_to_color(m_frame, makecol(0, 128, 0));
blit(c_bitmaps::get_instance().m_background, m_frame, 0, 0, viewport_x, viewport_y, c_bitmaps::get_instance().m_background->w, c_bitmaps::get_instance().m_background->h);
}
if (use_draw_opengl) {
glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
//glDisable(GL_DEPTH_TEST); // ??? Enables Depth Testing
//glEnable(GL_DEPTH_TEST);
//glDepthFunc(GL_LEQUAL); // The Type Of Depth Testing To Do
//glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
//glLoadIdentity();
// glTranslatef(m_gui->camera_x, m_gui->camera_y,camera_offset);
// minimum and maximum value for zoom in/out and rotate the scene
// if (camera_offset >= 10.0) camera_offset = 10.0;
// if (camera_offset <= 0.5) camera_offset = 0.5;
if (view_angle >= 70) view_angle = 70;
if(view_angle <= 0) view_angle = 0;
if( zoom <= 0.1 ) zoom = 0.1; //because of glFrustum -> when left=right, or bottom=top there's error GL_INVALID_VALUE, so we can't multiply e.g left,right by 0
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glFrustum(-1.0*zoom, 1.0*zoom, -1.0*zoom, 1.0*zoom, 1.0,60.0);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
//glTranslatef(0.0f,0.0f,-11.0);
glTranslatef(0.0f,0.0f,camera_step_z);
glRotatef(-view_angle, 1,0,0);
glScalef(10,10,10);
// drawing backgound
glPushMatrix();
//glScalef(1,1,1);
glBindTexture(GL_TEXTURE_2D,c_bitmaps::get_instance().m_background_opengl);
glEnable(GL_BLEND);
//float q=1.0/zoom;
float q=1.0;
glBegin(GL_QUADS);
glTexCoord2f(0,q); glVertex3f(-1.0f,1.0f, 0.0f);
glTexCoord2f(q,q); glVertex3f(1.0f,1.0f, 0.0f);
glTexCoord2f(q,0); glVertex3f(1.0f,-1.0f,0.0f);
glTexCoord2f(0,0); glVertex3f(-1.0f,-1.0f,0.0f);
glEnd();
glDisable(GL_BLEND);
glBindTexture(GL_TEXTURE_2D, 0); // texture
glPopMatrix();
}
// clear additional things
if (use_draw_allegro) {
clear_to_color(smallWindow, makecol(128, 128, 128));
}
// main controll keys
if (allegro_keys[KEY_ESC]) {
_note("User exits the simulation from user interface");
m_goodbye = true;
}
if ((allegro_char & 0xff) == 'n' && !start_simulation) {
std::cout << "ADD " << std::endl;
_warn("THIS CODE IS NOT IMPLEMENTED NOW");
/*
m_world->m_objects.push_back(
make_shared<c_cjddev>(
cjddev_detail_random_name(),
// gui_mouse_x, gui_mouse_y,
gui_cursor_x, gui_cursor_y,
cjddev_detail_random_addr()));
*/
}
if(allegro_keys[KEY_F1]){
//auto ptr = get_move_object(gui_mouse_x,gui_mouse_y);
// TODO -in allegro? -not entire screen?
/*
try{
if(ptr != NULL){
int col_num =0;
textout_ex(smallWindow, font, ptr->get_name().c_str(), 0, 0, makecol(0, 0, 255), -1);
if(c_cjddev* tmp = dynamic_cast<c_cjddev *>(ptr.get()) ){
char* addr =(char *) malloc(45);
sprintf(addr,"address: %ld",tmp->get_address());
textout_ex(smallWindow, font,addr , 10, col_num+=10, makecol(0, 0, 255), -1);
sprintf(addr,"neighbors: %d",(int)tmp->get_neighbors().size());
textout_ex(smallWindow, font,addr , 10, col_num+=10, makecol(0, 0, 255), -1);
sprintf(addr,"waitng: %d",(int)tmp->num_of_wating());
textout_ex(smallWindow, font,addr , 10, col_num+=10, makecol(0, 0, 255), -1);
// textout_ex(smallWindow, font, ptr->get_name().c_str(), 0, 0, makecol(0, 0, 255), -1);{
free (addr);
}
if (use_draw_allegro) {
// draw the information window
blit (smallWindow,m_frame,0,0,m_frame->w-200,m_frame->h-200,screen->w/8, screen->h/4);
}
}
}
catch(...) {}
*/
// std::cout<<ptr->get_name().c_str()<<std::endl;
}
if(allegro_keys[KEY_F2]){
// BITMAP* screen = gui_get_screen();
int m_x =0;
int m_y =0;
static unsigned int num =0;
if(num>=m_world->m_objects.size()){
num=0;
}
try{
// auto obj = m_world->m_objects.at(0);
// m_x = m_world->m_objects.at(num)->get_x() - (screen->w/2);
// m_y = m_world->m_objects.at(num)->get_y() - (screen->h/2);
m_x = m_world->m_objects.at(num)->get_x()*m_gui->camera_zoom - (allegro_mouse_x);
m_y = m_world->m_objects.at(num)->get_y()*m_gui->camera_zoom - (allegro_mouse_y);
// std::cout<< screen->w<<" "<<screen->h<<" "<<screen->x_ofs<<" "<<screen->y_ofs<<std::endl;
m_gui->camera_x = m_x ;
m_gui->camera_y = m_y;
std::this_thread::sleep_for(std::chrono::milliseconds(100));
num++;
}catch(...)
{
}
}
// animation & tick
if (m_frame_number % g_max_anim_frame == 0 && !simulation_pause) {
frame_checkpoint = m_frame_number;
m_world->tick(); // <===
}
// === main user interface ===
// the mode
typedef enum { e_mode_node, e_mode_camera } t_mode;
t_mode mode;
mode = e_mode_node; // by default we will move/edit etc the node (or entityt)
if (allegro_shifts & KB_SHIFT_FLAG) mode = e_mode_camera; // with key SHIFT we move camera instea
// mode: camera movement etc
if (mode == e_mode_camera) {
if (allegro_keys[KEY_LEFT]) m_gui->camera_x -= 10;
if (allegro_keys[KEY_RIGHT]) m_gui->camera_x += 10;
if (allegro_keys[KEY_UP]) m_gui->camera_y -= 10;
if (allegro_keys[KEY_DOWN]) m_gui->camera_y += 10;
const double zoom_speed = 1.1;
if (allegro_keys[KEY_PGUP]) m_gui->camera_zoom *= zoom_speed;
if (allegro_keys[KEY_PGDN]) m_gui->camera_zoom /= zoom_speed;
}
// rotate and zoom in/out the scene
if(allegro_keys[KEY_Z]) {
//camera_offset+=0.1;
zoom+=0.1;
_dbg1("zoom: " << zoom);
}
if(allegro_keys[KEY_X]) {
//camera_offset-=0.1;
zoom-=0.1;
_dbg1("zoom: " << zoom);
}
if(allegro_keys[KEY_C]) {
view_angle+=1.0;
//farVal+=10;
_dbg1("view_angle: " << view_angle);
}
if(allegro_keys[KEY_V]) {
view_angle-=1.0;
_dbg1("view_angle: " << view_angle);
}
if(allegro_keys[KEY_Q]) {
camera_step_z+=0.1;
}
if(allegro_keys[KEY_W]) {
camera_step_z -= 0.1;
if(camera_step_z <= -11.0) camera_step_z=-11.0;
}
// === text debug on screen ===
string mouse_pos_str = std::to_string(gui_mouse_x) + " " + std::to_string(gui_mouse_y);
string fps_str = "fps ???";
if (loop_miliseconds != 0) {
fps_str = "fps: " + std::to_string(1000 / loop_miliseconds);
}
const int txt_h = 12; // line height (separation between lines)
int txt_x = 10, txt_y = 10; // starting position of text
if (use_draw_allegro) {
string pck_speed_str = "sending packets speed - " + std::to_string(450 - g_max_anim_frame);
textout_ex(m_frame, font, mouse_pos_str.c_str(), txt_x, txt_y += txt_h, makecol(0, 0, 255), -1);
textout_ex(m_frame, font, fps_str.c_str(), txt_x, txt_y += txt_h, makecol(0, 0, 255), -1);
textout_ex(m_frame, font, ("Frame nr.: " +
std::to_string(m_frame_number)).c_str(), txt_x, txt_y += txt_h, makecol(0, 0, 255), -1);
textout_ex(m_frame, font, pck_speed_str.c_str(), 100, 10, makecol(0, 0, 255), -1);
if(allegro_keys[KEY_H])
{
int tex_y = 10;
int lineh = 10;
textout_ex(m_frame, font, "s - start", 1140, tex_y+=lineh, makecol(0, 0, 255), -1);
textout_ex(m_frame, font, "p - pause", 1140, tex_y+=lineh, makecol(0, 0, 255), -1);
textout_ex(m_frame, font, "f - send FTP", 1140, tex_y+=lineh, makecol(0, 0, 255), -1);
textout_ex(m_frame, font, "t - select target", 1140, tex_y+=lineh, makecol(0, 0, 255), -1);
textout_ex(m_frame, font, "r - select source", 1140, tex_y+=lineh, makecol(0, 0, 255), -1);
textout_ex(m_frame, font, "d - remove node", 1140, tex_y+=lineh, makecol(0, 0, 255), -1);
textout_ex(m_frame, font, "n - add node", 1140, tex_y+=lineh, makecol(0, 0, 255), -1);
textout_ex(m_frame, font, "enter/esc - exit", 1140, tex_y+=lineh, makecol(0, 0, 255), -1);
textout_ex(m_frame, font, "Arrows: move selected node", 1140, tex_y+=lineh, makecol(0, 0, 255), -1);
textout_ex(m_frame, font, "SHIFT-Arrows: move the camera", 1140, tex_y+=lineh, makecol(0, 0, 255), -1);
textout_ex(m_frame, font, "SHIFT-PageUp/Down: zimm in/out", 1140, tex_y+=lineh, makecol(0, 0, 255), -1);
textout_ex(m_frame, font, "F1: info about node", 1140, tex_y+=lineh, makecol(0, 0, 255), -1);
textout_ex(m_frame, font, "F2: next node", 1140, tex_y+=lineh, makecol(0, 0, 255), -1);
} else{
textout_ex(m_frame, font, "h - help", 1140, 30, makecol(0, 0, 255), -1);
}
}
if (use_draw_opengl) {
// TODO @opengl
//textout_ex(m_frame, font, mouse_pos_str.c_str(), txt_x, txt_y += txt_h, makecol(0, 0, 255), -1);
float offset = 0.03;
float tex_y = 0.9;
float tex_x = 0.7;
string pck_speed_str = "sending packets speed - " + std::to_string(450 - g_max_anim_frame);
glColor4f(0.0,0.0,1.0,0.0);
//glScalef(0.2f,0.2f,0.2f);
//glLoadIdentity();
glPushMatrix();
glEnable(GL_BLEND);
allegro_gl_printf_ex(s_font_allegl.get(), -0.9, tex_y, 0.0, mouse_pos_str.c_str());
allegro_gl_printf_ex(s_font_allegl.get(), -0.9, tex_y-=offset, 0.0, fps_str.c_str());
allegro_gl_printf_ex(s_font_allegl.get(), -0.9, tex_y-=offset, 0.0, ("Frame nr.: " + std::to_string(m_frame_number)).c_str());
allegro_gl_printf_ex(s_font_allegl.get(), -0.7, 0.97, 0.0, pck_speed_str.c_str());
glDisable(GL_BLEND);
glPopMatrix();
if(allegro_keys[KEY_H]) {
_dbg1("KEY_H - opengl");
//glLoadIdentity();
glPushMatrix();
glEnable(GL_BLEND);
allegro_gl_printf_ex(s_font_allegl.get(), tex_x, tex_y, 0.0,"s - start");
allegro_gl_printf_ex(s_font_allegl.get(), tex_x, tex_y-=offset, 0.0,"p - pause");
allegro_gl_printf_ex(s_font_allegl.get(), tex_x, tex_y-=offset, 0.0,"f - send FTP");
allegro_gl_printf_ex(s_font_allegl.get(), tex_x, tex_y-=offset, 0.0,"t - select target");
allegro_gl_printf_ex(s_font_allegl.get(), tex_x, tex_y-=offset, 0.0,"r - select source");
allegro_gl_printf_ex(s_font_allegl.get(), tex_x, tex_y-=offset, 0.0,"d - remove node");
allegro_gl_printf_ex(s_font_allegl.get(), tex_x, tex_y-=offset, 0.0,"n - add node");
allegro_gl_printf_ex(s_font_allegl.get(), tex_x, tex_y-=offset, 0.0,"enter/esc - exit");
allegro_gl_printf_ex(s_font_allegl.get(), tex_x, tex_y-=offset, 0.0,"Arrows: move selected node");
allegro_gl_printf_ex(s_font_allegl.get(), tex_x, tex_y-=offset, 0.0,"SHIFT-Arrows: move the camera");
allegro_gl_printf_ex(s_font_allegl.get(), tex_x, tex_y-=offset, 0.0,"SHIFT-PageUp/Down: zoom in/out");
allegro_gl_printf_ex(s_font_allegl.get(), tex_x, tex_y-=offset, 0.0,"F1: info about node");
allegro_gl_printf_ex(s_font_allegl.get(), tex_x, tex_y-=offset, 0.0,"F2: next node");
glDisable(GL_BLEND);
glPopMatrix();
} else {
//glLoadIdentity();
glPushMatrix();
glEnable(GL_BLEND);
//allegro_gl_printf(s_font_allegl.get(), 0.8, 0.9, 0.0,0xFF0000,"h - help");
allegro_gl_printf_ex(s_font_allegl.get(), tex_x, tex_y, 0.0,"h - help");
//glBlendFunc(GL_ONE, GL_ZERO);
glDisable(GL_BLEND);
glPopMatrix();
}
}
//_dbg3("m_world->m_objects.size(): " << m_world->m_objects.size());
//_dbg3("get_move_object ret: " << get_move_object(gui_mouse_x, gui_mouse_y));
int move_object_index = get_move_object(gui_mouse_x, gui_mouse_y); ///< -1 if 'empty'
if (move_object_index != -1) { // working with selected object
m_gui->m_selected_object = m_world->m_objects.begin();
std::advance(m_gui->m_selected_object, move_object_index);
auto selected_object = m_gui->m_selected_object;
(*selected_object)->m_selected = true;
c_entity *selected_object_raw = dynamic_cast<c_entity *>((*selected_object).get());
c_osi2_switch *selected_switch = dynamic_cast<c_osi2_switch *>((*selected_object).get());
// selected_switch->send_hello_to_neighbors(); // TODO
//shared_ptr<c_cjddev> selected_device = std::dynamic_pointer_cast<c_cjddev>(selected_object);
if (selected_object != m_world->m_objects.end()) { // editing the selected object
// TODO: add connect
/*if (gui_mouse_b == 1 && !print_connect_line) {
print_connect_line = true;
connect_node = std::dynamic_pointer_cast<c_cjddev>(selected_object);
last_click_time = std::chrono::steady_clock::now();
}
if (gui_mouse_b == 1 && print_connect_line &&
std::chrono::steady_clock::now() - last_click_time > std::chrono::milliseconds(500)) {
// assert( connect_node && selected_object );
connect_node->add_neighbor(std::dynamic_pointer_cast<c_cjddev>(selected_object));
(std::dynamic_pointer_cast<c_cjddev>(selected_object))->add_neighbor(std::dynamic_pointer_cast<c_cjddev>(connect_node));
print_connect_line = false;
}*/
if (mode == e_mode_node) { // working with selected object - moving
if (!print_connect_line) {
int speed = 5;
if (allegro_keys[KEY_LEFT])
selected_object_raw->m_x += -speed;
if (allegro_keys[KEY_RIGHT])
selected_object_raw->m_x += speed;
if (allegro_keys[KEY_DOWN])
selected_object_raw->m_y += speed;
if (allegro_keys[KEY_UP])
selected_object_raw->m_y += -speed;
}
} // moving selected object
}
/*
if ((allegro_char & 0xff) == 's' && !start_simulation) {
if (!m_gui->m_source || !m_gui->m_target) {
std::cout << "please choose target and source node\n";
} else {
m_gui->m_source->buy_net(m_gui->m_target->get_address());
start_simulation = true;
simulation_pause = false;
}
}
if ((allegro_char & 0xff) == 'd' && selected_device && !start_simulation) {
for (shared_ptr<c_cjddev> &it : selected_device->get_neighbors()) {
selected_device->remove_neighbor(it);
it->remove_neighbor(selected_device);
}
for (auto it = m_world->m_objects.begin(); it != m_world->m_objects.end(); ++it) {
if (it->get() == selected_device.get()) {
m_world->m_objects.erase(it);
break;
}
}
}
if ((allegro_char & 0xff) == 't' && selected_device && !start_simulation) {
m_gui->m_target = selected_device;
}
if ((allegro_char & 0xff) == 'r' && selected_device && !start_simulation) {
m_gui->m_source = selected_device;
}
if ((allegro_char & 0xff) == 'f') {
if (!m_gui->m_source || !m_gui->m_target)
std::cout << "please choose target and source node\n";
else {
m_gui->m_source->send_ftp_packet(m_gui->m_target->get_address(), "FTP data");
last_click_time = std::chrono::steady_clock::now();
}
}
*/
// === animation clock controll ===
if ((allegro_char & 0xff) == 'p') {
simulation_pause = !simulation_pause;
last_click_time = std::chrono::steady_clock::now();
}
if (allegro_keys[KEY_MINUS_PAD] && g_max_anim_frame < 400 &&
std::chrono::steady_clock::now() - last_click_time > std::chrono::milliseconds(loop_miliseconds)) {
//std::cout << m_frame_number-frame_checkpoint << " - " << g_max_anim_frame << " mod: " << (m_frame_number-frame_checkpoint) % g_max_anim_frame << std::endl;
g_max_anim_frame += 1;
last_click_time = std::chrono::steady_clock::now();
}
if (allegro_keys[KEY_PLUS_PAD] && g_max_anim_frame > 10 &&
std::chrono::steady_clock::now() - last_click_time > std::chrono::milliseconds(loop_miliseconds)) {
//std::cout << m_frame_number-frame_checkpoint << " + " << g_max_anim_frame << " mod: " << (m_frame_number-frame_checkpoint) % g_max_anim_frame << std::endl;
g_max_anim_frame -= 1;
last_click_time = std::chrono::steady_clock::now();
}
}
// === animation clock operations ===
m_world->draw(*m_drawtarget.get()); // <===== DRAW THE WORLD
/*
if ((m_frame_number - frame_checkpoint) < g_max_anim_frame) {
m_world->draw(*m_drawtarget.get(), (m_frame_number - frame_checkpoint) % g_max_anim_frame); // <==
} else {
m_world->draw(*m_drawtarget.get(), g_max_anim_frame);
}
*/
if (print_connect_line) { // the line the creates new connections
if (use_draw_allegro) {
line(m_frame, connect_node->m_x, connect_node->m_y, allegro_mouse_x, allegro_mouse_y, makecol(0, 255, 255));
}
// TODO @opengl
if (use_draw_opengl) {
glColor3f(0.0f,1.0f,1.0f);
glLineWidth(1.0);
glScalef(1.0f,1.0f,1.0f);
const int vx = m_gui->view_x(connect_node->m_x), vy = m_gui->view_y(connect_node->m_y); // position in viewport - because camera position
//float start_line_x = ((connect_node->m_x)-0.5*SCREEN_W)/(0.5*SCREEN_W);
//float start_line_y = -((connect_node->m_y)-0.5*SCREEN_H)/(0.5*SCREEN_H);
float start_line_x = (vx-0.5*SCREEN_W)/(0.5*SCREEN_W);
float start_line_y = -(vy-0.5*SCREEN_H)/(0.5*SCREEN_H);
float end_line_x = (allegro_mouse_x-0.5*SCREEN_W)/(0.5*SCREEN_W);
float end_line_y = -(allegro_mouse_y-0.5*SCREEN_H)/(0.5*SCREEN_H);
//_dbg1("connect_node: " << connect_node->m_x << " " << connect_node->m_y);
//_dbg1("allegro_mouse: " << allegro_mouse_x << " " << allegro_mouse_y);
//_dbg1("start_line: " << start_line_x << " " << start_line_y);
//_dbg1("end_line: " << end_line_x << " " << end_line_y);
//glLoadIdentity();
glPushMatrix();
glBegin(GL_LINES);
glVertex3f(start_line_x,start_line_y,0.0f);
glVertex3f(end_line_x,end_line_y,0.0f);
glEnd();
glPopMatrix();
}
}
if (allegro_mouse_b == 2) { // end/stop the line that creates new connections
print_connect_line = false;
}
{
auto x = allegro_mouse_x, y = allegro_mouse_y;
int r = 5, rr = 4;
if (use_draw_allegro) {
line(m_frame, x - rr, y, x + rr, y, makecol(0, 0, 0));
line(m_frame, x, y - rr, x, y + rr, makecol(0, 0, 0));
circle(m_frame, x, y, r, makecol(255, 255, 255));
}
// TODO @opengl
if(use_draw_opengl) {
float opengl_mouse_x = (x-SCREEN_W*0.5)/(0.5*SCREEN_W);
float opengl_mouse_y = -(y-SCREEN_H*0.5)/(0.5*SCREEN_H);
float cursor_size=0.01;
//_dbg1("mouse_x mouse_y: " << mouse_x << " " << mouse_y);
//_dbg1("screenW screenH: " << SCREEN_W << " " << SCREEN_H);
//glLoadIdentity();
//glScalef(1/camera_offset, 1/camera_offset, 1.0);
//glScalef(1.0*zoom, 1.0*zoom, 1.0*zoom);
glPushMatrix();
glScalef(1.0f,1.0f,1.0f);
glTranslatef(opengl_mouse_x,opengl_mouse_y,0.0f);
//glTranslatef(m_gui->view_x_rev(mouse_x),m_gui->view_y_rev(mouse_y),0.0f);
glColor3f(0.0, 0.0, 0.0);
// draw cursor
glBegin(GL_LINES);
glVertex2f(-1.0f*cursor_size,0.0f);
glVertex2f(1.0f*cursor_size,0.0f);
glVertex2f(0.0f,-1.0f*cursor_size);
glVertex2f(0.0f,1.0f*cursor_size);
glEnd();
glPopMatrix();
}
}
// === show frame ===
if (use_draw_allegro) {
//_dbg1("Allegro: frame done. fps = " << fps_str);
scare_mouse();
blit(m_frame, m_screen, 0, 0, 0, 0, m_frame->w, m_frame->h);
unscare_mouse();
if (!simulation_pause) {
++m_frame_number;
}
}
if (use_draw_opengl) {
//_dbg1("OpenGL: frame flip. fps = " << fps_str);
allegro_gl_flip();
}
for (auto &object : m_world->m_objects) {
object->m_selected = false;
}
// std::this_thread::sleep_for(std::chrono::milliseconds(10));
auto stop_time = std::chrono::high_resolution_clock::now();
auto diff = stop_time - start_time;
loop_miliseconds = std::chrono::duration_cast<std::chrono::milliseconds>(diff).count();
}
std::ofstream out_file("../layout/current/out.map.txt");
out_file << *m_world << std::endl;
}
void c_the_program::startup_data_dir() {
bool found=false;
try
{
namespace b_fs = boost::filesystem;
// find path to my main data dir (to my data "in share").
// e.g. /home/rafalcode/work/galaxy42/ - because it contains:
// /home/rafalcode/work/galaxy42/share/locale/en/LC_MESSAGES/galaxy42_main.mo
// we could normalize the path... but this could trigger more problems maybe with encoding of string.
auto dir_normalize = [](std::string path) -> std::string {
return path; // nothing for now. TODO (would be nicer to not display "//home/.." in this tests below
};
b_fs::path cwd_full_boost( b_fs::current_path() );
string cwd_full = dir_normalize( b_fs::absolute( cwd_full_boost ) .string() );
// string cwd_full = b_fs::lexically_norma( b_fs::absolute( cwd_full_boost ) ).string();
b_fs::path selfpath = "";
// += cwd_full_boost;
// selfpath += "/";
selfpath += argt_exec; // hmm, what? --rafal
b_fs::path selfdir_boost = selfpath.remove_filename();
string selfdir = dir_normalize( b_fs::absolute( selfdir_boost ) .string() );
// cerr << "Start... [" << cwd_full << "] (cwd) " << endl;
// cerr << "Start... [" << selfdir << "] (exec) " << endl;
vector<string> data_dir_possible;
data_dir_possible.push_back(cwd_full);
data_dir_possible.push_back(selfdir);
#if defined(__MACH__)
// TODO when macosx .dmg fully works (when Gitian on macosx works)
#elif defined(_WIN32) || defined(__CYGWIN__) || defined(__MINGW32__) || defined(_MSC_VER)
// data files should be next to .exe
#else
data_dir_possible.push_back("/usr");
data_dir_possible.push_back("/usr/local");
data_dir_possible.push_back("/usr/opt");
#endif
for (auto && dir : data_dir_possible) {
string testname = dir;
testname += "/share/locale/en/LC_MESSAGES/galaxy42_main.mo";
_fact( "Test: [" << testname << "]... " << std::flush );
ifstream filetest( testname.c_str() );
if (filetest.good()) {
m_install_dir_base = dir;
found=true;
_fact(" OK! " );
break;
} else _fact( "" );
}
} catch(std::exception & ex) {
_erro( "Error while looking for data directory ("<<ex.what()<<")" << std::endl );
}
if (!found) _fact( "Can not find language data files." );
_fact( "Data: [" << m_install_dir_base << "]" );
m_install_dir_share_locale = m_install_dir_base + "/share/locale";
_fact( "Lang: [" << m_install_dir_share_locale << "]" );
}
