Debugstacks is not useful, we don't really use it, the DebugStack is not pertinent, gdb and lldb are better if we really want to debug.
void Client::connect(Address address, bool is_local_server)
{
- DSTACK(FUNCTION_NAME);
-
initLocalMapSaving(address, m_address_name, is_local_server);
m_con->SetTimeoutMs(0);
void Client::step(float dtime)
{
- DSTACK(FUNCTION_NAME);
-
// Limit a bit
if(dtime > 2.0)
dtime = 2.0;
void Client::ReceiveAll()
{
- DSTACK(FUNCTION_NAME);
u64 start_ms = porting::getTimeMs();
for(;;)
{
void Client::Receive()
{
- DSTACK(FUNCTION_NAME);
NetworkPacket pkt;
m_con->Receive(&pkt);
ProcessData(&pkt);
*/
void Client::ProcessData(NetworkPacket *pkt)
{
- DSTACK(FUNCTION_NAME);
-
ToClientCommand command = (ToClientCommand) pkt->getCommand();
u32 sender_peer_id = pkt->getPeerId();
void Client::sendDamage(u8 damage)
{
- DSTACK(FUNCTION_NAME);
-
NetworkPacket pkt(TOSERVER_DAMAGE, sizeof(u8));
pkt << damage;
Send(&pkt);
void Client::sendBreath(u16 breath)
{
- DSTACK(FUNCTION_NAME);
-
// Protocol v29 make this obsolete
if (m_proto_ver >= 29)
return;
void Client::sendRespawn()
{
- DSTACK(FUNCTION_NAME);
-
NetworkPacket pkt(TOSERVER_RESPAWN, 0);
Send(&pkt);
}
void Client::sendReady()
{
- DSTACK(FUNCTION_NAME);
-
NetworkPacket pkt(TOSERVER_CLIENT_READY,
1 + 1 + 1 + 1 + 2 + sizeof(char) * strlen(g_version_hash));
QUICKTUNE_INC,
QUICKTUNE_DEC,
- DEBUG_STACKS,
-
// hotbar
SLOT_1,
SLOT_2,
void ClientEnvironment::setLocalPlayer(LocalPlayer *player)
{
- DSTACK(FUNCTION_NAME);
/*
It is a failure if already is a local player
*/
void ClientEnvironment::step(float dtime)
{
- DSTACK(FUNCTION_NAME);
-
/* Step time of day */
stepTimeOfDay(dtime);
float dtime,
std::vector<PrioritySortedBlockTransfer> &dest)
{
- DSTACK(FUNCTION_NAME);
-
-
// Increment timers
m_nothing_to_send_pause_timer -= dtime;
m_nearest_unsent_reset_timer += dtime;
MapSector * ClientMap::emergeSector(v2s16 p2d)
{
- DSTACK(FUNCTION_NAME);
// Check that it doesn't exist already
try {
return getSectorNoGenerate(p2d);
void ClientMap::renderMap(video::IVideoDriver* driver, s32 pass)
{
- DSTACK(FUNCTION_NAME);
-
bool is_transparent_pass = pass == scene::ESNRP_TRANSPARENT;
std::string prefix;
errorstream << file << ":" << line << ": " << function
<< ": An engine assumption '" << assertion << "' failed." << std::endl;
- debug_stacks_print_to(errorstream);
-
abort();
}
errorstream << file << ":" << line << ": " << function
<< ": A fatal error occured: " << msg << std::endl;
- debug_stacks_print_to(errorstream);
-
abort();
}
-/*
- DebugStack
-*/
-
-struct DebugStack
-{
- DebugStack(std::thread::id id);
- void print(FILE *file, bool everything);
- void print(std::ostream &os, bool everything);
-
- std::thread::id thread_id;
- char stack[DEBUG_STACK_SIZE][DEBUG_STACK_TEXT_SIZE];
- int stack_i; // Points to the lowest empty position
- int stack_max_i; // Highest i that was seen
-};
-
-DebugStack::DebugStack(std::thread::id id)
-{
- thread_id = id;
- stack_i = 0;
- stack_max_i = 0;
- memset(stack, 0, DEBUG_STACK_SIZE*DEBUG_STACK_TEXT_SIZE);
-}
-
-void DebugStack::print(FILE *file, bool everything)
-{
- std::ostringstream os;
- os << thread_id;
- fprintf(file, "DEBUG STACK FOR THREAD %s:\n",
- os.str().c_str());
-
- for (int i = 0; i < stack_max_i; i++) {
- if (i == stack_i && !everything)
- break;
-
- if (i < stack_i)
- fprintf(file, "#%d %s\n", i, stack[i]);
- else
- fprintf(file, "(Leftover data: #%d %s)\n", i, stack[i]);
- }
-
- if (stack_i == DEBUG_STACK_SIZE)
- fprintf(file, "Probably overflown.\n");
-}
-
-void DebugStack::print(std::ostream &os, bool everything)
-{
- os<<"DEBUG STACK FOR THREAD "<<thread_id<<": "<<std::endl;
-
- for(int i = 0; i < stack_max_i; i++) {
- if(i == stack_i && !everything)
- break;
-
- if (i < stack_i)
- os<<"#"<<i<<" "<<stack[i]<<std::endl;
- else
- os<<"(Leftover data: #"<<i<<" "<<stack[i]<<")"<<std::endl;
- }
-
- if (stack_i == DEBUG_STACK_SIZE)
- os<<"Probably overflown."<<std::endl;
-}
-
-std::map<std::thread::id, DebugStack*> g_debug_stacks;
-std::mutex g_debug_stacks_mutex;
-
-void debug_stacks_print_to(std::ostream &os)
-{
- MutexAutoLock lock(g_debug_stacks_mutex);
-
- os<<"Debug stacks:"<<std::endl;
-
- for (auto it : g_debug_stacks) {
- it.second->print(os, false);
- }
-}
-
-void debug_stacks_print()
-{
- debug_stacks_print_to(errorstream);
-}
-
-DebugStacker::DebugStacker(const char *text)
-{
- std::thread::id thread_id = std::this_thread::get_id();
-
- MutexAutoLock lock(g_debug_stacks_mutex);
-
- auto n = g_debug_stacks.find(thread_id);
- if (n != g_debug_stacks.end()) {
- m_stack = n->second;
- } else {
- /*DEBUGPRINT("Creating new debug stack for thread %x\n",
- (unsigned int)thread_id);*/
- m_stack = new DebugStack(thread_id);
- g_debug_stacks[thread_id] = m_stack;
- }
-
- if (m_stack->stack_i >= DEBUG_STACK_SIZE) {
- m_overflowed = true;
- } else {
- m_overflowed = false;
-
- snprintf(m_stack->stack[m_stack->stack_i],
- DEBUG_STACK_TEXT_SIZE, "%s", text);
- m_stack->stack_i++;
- if (m_stack->stack_i > m_stack->stack_max_i)
- m_stack->stack_max_i = m_stack->stack_i;
- }
-}
-
-DebugStacker::~DebugStacker()
-{
- MutexAutoLock lock(g_debug_stacks_mutex);
-
- if (m_overflowed)
- return;
-
- m_stack->stack_i--;
-
- if (m_stack->stack_i == 0) {
- std::thread::id thread_id = m_stack->thread_id;
- /*DEBUGPRINT("Deleting debug stack for thread %x\n",
- (unsigned int)thread_id);*/
- delete m_stack;
- g_debug_stacks.erase(thread_id);
- }
-}
-
#ifdef _MSC_VER
const char *Win32ExceptionCodeToString(DWORD exception_code)
void debug_set_exception_handler();
-/*
- DebugStack
-*/
-
-#define DEBUG_STACK_SIZE 50
-#define DEBUG_STACK_TEXT_SIZE 300
-
-extern void debug_stacks_print_to(std::ostream &os);
-extern void debug_stacks_print();
-
-struct DebugStack;
-class DebugStacker
-{
-public:
- DebugStacker(const char *text);
- ~DebugStacker();
-
-private:
- DebugStack *m_stack;
- bool m_overflowed;
-};
-
-#define DSTACK(msg) \
- DebugStacker __debug_stacker(msg);
-
-#define DSTACKF(...) \
- char __buf[DEBUG_STACK_TEXT_SIZE]; \
- snprintf(__buf, DEBUG_STACK_TEXT_SIZE, __VA_ARGS__); \
- DebugStacker __debug_stacker(__buf);
-
/*
These should be put into every thread
*/
void *EmergeThread::run()
{
- DSTACK(FUNCTION_NAME);
BEGIN_DEBUG_EXCEPTION_HANDLER
v3s16 pos;
key[KeyType::QUICKTUNE_INC] = getKeySetting("keymap_quicktune_inc");
key[KeyType::QUICKTUNE_DEC] = getKeySetting("keymap_quicktune_dec");
- key[KeyType::DEBUG_STACKS] = getKeySetting("keymap_print_debug_stacks");
-
for (int i = 0; i < 23; i++) {
std::string slot_key_name = "keymap_slot" + std::to_string(i + 1);
key[KeyType::SLOT_1 + i] = getKeySetting(slot_key_name.c_str());
quicktune->inc();
} else if (wasKeyDown(KeyType::QUICKTUNE_DEC)) {
quicktune->dec();
- } else if (wasKeyDown(KeyType::DEBUG_STACKS)) {
- // Print debug stacks
- dstream << "-----------------------------------------"
- << std::endl;
- dstream << "Printing debug stacks:" << std::endl;
- dstream << "-----------------------------------------"
- << std::endl;
- debug_stacks_print();
}
if (!isKeyDown(KeyType::JUMP) && runData.reset_jump_timer) {
GUI_ID_KEY_MUTE_BUTTON,
GUI_ID_KEY_DEC_VOLUME_BUTTON,
GUI_ID_KEY_INC_VOLUME_BUTTON,
- GUI_ID_KEY_DUMP_BUTTON,
GUI_ID_KEY_RANGE_BUTTON,
GUI_ID_KEY_ZOOM_BUTTON,
GUI_ID_KEY_CAMERA_BUTTON,
this->add_key(GUI_ID_KEY_HUD_BUTTON, wgettext("Toggle HUD"), "keymap_toggle_hud");
this->add_key(GUI_ID_KEY_CHATLOG_BUTTON, wgettext("Toggle chat log"), "keymap_toggle_chat");
this->add_key(GUI_ID_KEY_FOG_BUTTON, wgettext("Toggle fog"), "keymap_toggle_force_fog_off");
- this->add_key(GUI_ID_KEY_DUMP_BUTTON, wgettext("Print stacks"), "keymap_print_debug_stacks");
}
void *run()
{
- DSTACK(FUNCTION_NAME);
-
CurlHandlePool pool;
m_multi = curl_multi_init();
void ItemStack::serialize(std::ostream &os) const
{
- DSTACK(FUNCTION_NAME);
-
- if(empty())
+ if (empty())
return;
// Check how many parts of the itemstring are needed
void ItemStack::deSerialize(std::istream &is, IItemDefManager *itemdef)
{
- DSTACK(FUNCTION_NAME);
-
clear();
// Read name
std::vector<ItemStack> &output_replacements,
bool decrementInput, IGameDef *gamedef)
{
- DSTACK(FUNCTION_NAME);
-
result.clear();
// Get the InventoryList in which we will operate
return 1;
}
- // Initialize debug stacks
- DSTACK(FUNCTION_NAME);
-
// Debug handler
BEGIN_DEBUG_EXCEPTION_HANDLER
*****************************************************************************/
static bool run_dedicated_server(const GameParams &game_params, const Settings &cmd_args)
{
- DSTACK("Dedicated server branch");
-
verbosestream << _("Using world path") << " ["
<< game_params.world_path << "]" << std::endl;
verbosestream << _("Using gameid") << " ["
<<" while trying to replace \""
<<m_nodedef->get(block->getNodeNoCheck(relpos, &temp_bool)).name
<<"\" at "<<PP(p)<<" (block "<<PP(blockpos)<<")"<<std::endl;
- debug_stacks_print_to(infostream);
return;
}
block->setNodeNoCheck(relpos, n);
void Map::transformLiquids(std::map<v3s16, MapBlock*> &modified_blocks,
ServerEnvironment *env)
{
- DSTACK(FUNCTION_NAME);
- //TimeTaker timer("transformLiquids()");
-
u32 loopcount = 0;
u32 initial_size = m_transforming_liquid.size();
MapSector *ServerMap::createSector(v2s16 p2d)
{
- DSTACKF("%s: p2d=(%d,%d)",
- FUNCTION_NAME,
- p2d.X, p2d.Y);
-
/*
Check if it exists already in memory
*/
std::map<v3s16, MapBlock*> &modified_blocks
)
{
- DSTACKF("%s: p=(%d,%d,%d)", FUNCTION_NAME, p.X, p.Y, p.Z);
-
- /*infostream<<"generateBlock(): "
- <<"("<<p.X<<","<<p.Y<<","<<p.Z<<")"
- <<std::endl;*/
-
bool enable_mapgen_debug_info = g_settings->getBool("enable_mapgen_debug_info");
TimeTaker timer("generateBlock");
MapBlock * ServerMap::createBlock(v3s16 p)
{
- DSTACKF("%s: p=(%d,%d,%d)",
- FUNCTION_NAME, p.X, p.Y, p.Z);
-
/*
Do not create over max mapgen limit
*/
MapBlock * ServerMap::emergeBlock(v3s16 p, bool create_blank)
{
- DSTACKF("%s: p=(%d,%d,%d), create_blank=%d",
- FUNCTION_NAME,
- p.X, p.Y, p.Z, create_blank);
-
{
MapBlock *block = getBlockNoCreateNoEx(p);
if (block && !block->isDummy())
void ServerMap::save(ModifiedState save_level)
{
- DSTACK(FUNCTION_NAME);
if (!m_map_saving_enabled) {
warningstream<<"Not saving map, saving disabled."<<std::endl;
return;
void ServerMap::loadBlock(const std::string §ordir, const std::string &blockfile,
MapSector *sector, bool save_after_load)
{
- DSTACK(FUNCTION_NAME);
-
std::string fullpath = sectordir + DIR_DELIM + blockfile;
try {
std::ifstream is(fullpath.c_str(), std::ios_base::binary);
void ServerMap::loadBlock(std::string *blob, v3s16 p3d, MapSector *sector, bool save_after_load)
{
- DSTACK(FUNCTION_NAME);
-
try {
std::istringstream is(*blob, std::ios_base::binary);
MapBlock* ServerMap::loadBlock(v3s16 blockpos)
{
- DSTACK(FUNCTION_NAME);
-
bool created_new = (getBlockNoCreateNoEx(blockpos) == NULL);
v2s16 p2d(blockpos.X, blockpos.Z);
void MeshUpdateQueue::addBlock(Map *map, v3s16 p, bool ack_block_to_server, bool urgent)
{
- DSTACK(FUNCTION_NAME);
-
MutexAutoLock lock(m_mutex);
cleanupCache();
void *ServerThread::run()
{
- DSTACK(FUNCTION_NAME);
BEGIN_DEBUG_EXCEPTION_HANDLER
m_server->AsyncRunStep(true);
void Server::start(Address bind_addr)
{
- DSTACK(FUNCTION_NAME);
-
m_bind_addr = bind_addr;
infostream<<"Starting server on "
void Server::stop()
{
- DSTACK(FUNCTION_NAME);
-
infostream<<"Server: Stopping and waiting threads"<<std::endl;
// Stop threads (set run=false first so both start stopping)
void Server::step(float dtime)
{
- DSTACK(FUNCTION_NAME);
// Limit a bit
if (dtime > 2.0)
dtime = 2.0;
void Server::AsyncRunStep(bool initial_step)
{
- DSTACK(FUNCTION_NAME);
-
g_profiler->add("Server::AsyncRunStep (num)", 1);
float dtime;
void Server::Receive()
{
- DSTACK(FUNCTION_NAME);
u16 peer_id;
try {
NetworkPacket pkt;
void Server::ProcessData(NetworkPacket *pkt)
{
- DSTACK(FUNCTION_NAME);
// Environment is locked first.
MutexAutoLock envlock(m_env_mutex);
void Server::peerAdded(con::Peer *peer)
{
- DSTACK(FUNCTION_NAME);
verbosestream<<"Server::peerAdded(): peer->id="
<<peer->id<<std::endl;
void Server::deletingPeer(con::Peer *peer, bool timeout)
{
- DSTACK(FUNCTION_NAME);
verbosestream<<"Server::deletingPeer(): peer->id="
<<peer->id<<", timeout="<<timeout<<std::endl;
void Server::SendMovement(u16 peer_id)
{
- DSTACK(FUNCTION_NAME);
std::ostringstream os(std::ios_base::binary);
NetworkPacket pkt(TOCLIENT_MOVEMENT, 12 * sizeof(float), peer_id);
void Server::SendHP(u16 peer_id, u16 hp)
{
- DSTACK(FUNCTION_NAME);
-
NetworkPacket pkt(TOCLIENT_HP, 1, peer_id);
pkt << hp;
Send(&pkt);
void Server::SendBreath(u16 peer_id, u16 breath)
{
- DSTACK(FUNCTION_NAME);
-
NetworkPacket pkt(TOCLIENT_BREATH, 2, peer_id);
pkt << (u16) breath;
Send(&pkt);
void Server::SendAccessDenied_Legacy(u16 peer_id,const std::wstring &reason)
{
- DSTACK(FUNCTION_NAME);
-
NetworkPacket pkt(TOCLIENT_ACCESS_DENIED_LEGACY, 0, peer_id);
pkt << reason;
Send(&pkt);
void Server::SendDeathscreen(u16 peer_id,bool set_camera_point_target,
v3f camera_point_target)
{
- DSTACK(FUNCTION_NAME);
-
NetworkPacket pkt(TOCLIENT_DEATHSCREEN, 1 + sizeof(v3f), peer_id);
pkt << set_camera_point_target << camera_point_target;
Send(&pkt);
void Server::SendItemDef(u16 peer_id,
IItemDefManager *itemdef, u16 protocol_version)
{
- DSTACK(FUNCTION_NAME);
-
NetworkPacket pkt(TOCLIENT_ITEMDEF, 0, peer_id);
/*
void Server::SendNodeDef(u16 peer_id,
INodeDefManager *nodedef, u16 protocol_version)
{
- DSTACK(FUNCTION_NAME);
-
NetworkPacket pkt(TOCLIENT_NODEDEF, 0, peer_id);
/*
void Server::SendInventory(PlayerSAO* playerSAO)
{
- DSTACK(FUNCTION_NAME);
-
UpdateCrafting(playerSAO->getPlayer());
/*
void Server::SendChatMessage(u16 peer_id, const ChatMessage &message)
{
- DSTACK(FUNCTION_NAME);
-
NetworkPacket legacypkt(TOCLIENT_CHAT_MESSAGE_OLD, 0, peer_id);
legacypkt << message.message;
void Server::SendShowFormspecMessage(u16 peer_id, const std::string &formspec,
const std::string &formname)
{
- DSTACK(FUNCTION_NAME);
-
NetworkPacket pkt(TOCLIENT_SHOW_FORMSPEC, 0 , peer_id);
if (formspec.empty()){
//the client should close the formspec
bool vertical, const std::string &texture,
const struct TileAnimationParams &animation, u8 glow)
{
- DSTACK(FUNCTION_NAME);
static thread_local const float radius =
g_settings->getS16("max_block_send_distance") * MAP_BLOCKSIZE * BS;
u16 attached_id, bool vertical, const std::string &texture, u32 id,
const struct TileAnimationParams &animation, u8 glow)
{
- DSTACK(FUNCTION_NAME);
if (peer_id == PEER_ID_INEXISTENT) {
// This sucks and should be replaced:
std::vector<u16> clients = m_clients.getClientIDs();
void Server::SendDeleteParticleSpawner(u16 peer_id, u32 id)
{
- DSTACK(FUNCTION_NAME);
-
NetworkPacket pkt(TOCLIENT_DELETE_PARTICLESPAWNER_LEGACY, 2, peer_id);
// Ugly error in this packet
void Server::SendTimeOfDay(u16 peer_id, u16 time, f32 time_speed)
{
- DSTACK(FUNCTION_NAME);
-
NetworkPacket pkt(TOCLIENT_TIME_OF_DAY, 0, peer_id);
pkt << time << time_speed;
void Server::SendPlayerHP(u16 peer_id)
{
- DSTACK(FUNCTION_NAME);
PlayerSAO *playersao = getPlayerSAO(peer_id);
// In some rare case if the player is disconnected
// while Lua call l_punch, for example, this can be NULL
void Server::SendPlayerBreath(PlayerSAO *sao)
{
- DSTACK(FUNCTION_NAME);
assert(sao);
m_script->player_event(sao, "breath_changed");
void Server::SendMovePlayer(u16 peer_id)
{
- DSTACK(FUNCTION_NAME);
RemotePlayer *player = m_env->getPlayer(peer_id);
assert(player);
PlayerSAO *sao = player->getPlayerSAO();
void Server::SendBlockNoLock(u16 peer_id, MapBlock *block, u8 ver, u16 net_proto_version)
{
- DSTACK(FUNCTION_NAME);
-
v3s16 p = block->getPos();
/*
void Server::SendBlocks(float dtime)
{
- DSTACK(FUNCTION_NAME);
-
MutexAutoLock envlock(m_env_mutex);
//TODO check if one big lock could be faster then multiple small ones
void Server::fillMediaCache()
{
- DSTACK(FUNCTION_NAME);
-
infostream<<"Server: Calculating media file checksums"<<std::endl;
// Collect all media file paths
void Server::sendMediaAnnouncement(u16 peer_id, const std::string &lang_code)
{
- DSTACK(FUNCTION_NAME);
-
verbosestream << "Server: Announcing files to id(" << peer_id << ")"
<< std::endl;
void Server::sendRequestedMedia(u16 peer_id,
const std::vector<std::string> &tosend)
{
- DSTACK(FUNCTION_NAME);
-
verbosestream<<"Server::sendRequestedMedia(): "
<<"Sending files to client"<<std::endl;
void Server::sendDetachedInventories(u16 peer_id)
{
- DSTACK(FUNCTION_NAME);
-
for (const auto &detached_inventory : m_detached_inventories) {
const std::string &name = detached_inventory.first;
//Inventory *inv = i->second;
void Server::DiePlayer(u16 peer_id)
{
- DSTACK(FUNCTION_NAME);
PlayerSAO *playersao = getPlayerSAO(peer_id);
// In some rare cases this can be NULL -- if the player is disconnected
// when a Lua function modifies l_punch, for example
void Server::RespawnPlayer(u16 peer_id)
{
- DSTACK(FUNCTION_NAME);
-
PlayerSAO *playersao = getPlayerSAO(peer_id);
assert(playersao);
void Server::DenySudoAccess(u16 peer_id)
{
- DSTACK(FUNCTION_NAME);
-
NetworkPacket pkt(TOCLIENT_DENY_SUDO_MODE, 0, peer_id);
Send(&pkt);
}
void Server::DenyAccess(u16 peer_id, AccessDeniedCode reason, const std::string &custom_reason)
{
- DSTACK(FUNCTION_NAME);
-
SendAccessDenied(peer_id, reason, custom_reason);
m_clients.event(peer_id, CSE_SetDenied);
m_con->DisconnectPeer(peer_id);
// the minimum version for MT users, maybe in 1 year
void Server::DenyAccess_Legacy(u16 peer_id, const std::wstring &reason)
{
- DSTACK(FUNCTION_NAME);
-
SendAccessDenied_Legacy(peer_id, reason);
m_clients.event(peer_id, CSE_SetDenied);
m_con->DisconnectPeer(peer_id);
void Server::acceptAuth(u16 peer_id, bool forSudoMode)
{
- DSTACK(FUNCTION_NAME);
-
if (!forSudoMode) {
RemoteClient* client = getClient(peer_id, CS_Invalid);
void Server::DeleteClient(u16 peer_id, ClientDeletionReason reason)
{
- DSTACK(FUNCTION_NAME);
std::wstring message;
{
/*
void Server::UpdateCrafting(RemotePlayer *player)
{
- DSTACK(FUNCTION_NAME);
-
// Get a preview for crafting
ItemStack preview;
InventoryLocation loc;
void dedicated_server_loop(Server &server, bool &kill)
{
- DSTACK(FUNCTION_NAME);
-
verbosestream<<"dedicated_server_loop()"<<std::endl;
IntervalLimiter m_profiler_interval;
void ServerEnvironment::addPlayer(RemotePlayer *player)
{
- DSTACK(FUNCTION_NAME);
/*
Check that peer_ids are unique.
Also check that names are unique.
void ServerEnvironment::step(float dtime)
{
- DSTACK(FUNCTION_NAME);
-
- //TimeTaker timer("ServerEnv step");
-
/* Step time of day */
stepTimeOfDay(dtime);
gettext("Key for increasing the viewing range.\nSee http://irrlicht.sourceforge.net/docu/namespaceirr.html#a54da2a0e231901735e3da1b0edf72eb3");
gettext("View range decrease key");
gettext("Key for decreasing the viewing range.\nSee http://irrlicht.sourceforge.net/docu/namespaceirr.html#a54da2a0e231901735e3da1b0edf72eb3");
- gettext("Print stacks");
- gettext("Key for printing debug stacks. Used for development.\nSee http://irrlicht.sourceforge.net/docu/namespaceirr.html#a54da2a0e231901735e3da1b0edf72eb3");
gettext("Network");
gettext("Server address");
gettext("Address to connect to.\nLeave this blank to start a local server.\nNote that the address field in the main menu overrides this setting.");
bool run_tests()
{
- DSTACK(FUNCTION_NAME);
-
u64 t1 = porting::getTimeMs();
TestGameDef gamedef;
void TestConnection::testConnectSendReceive()
{
- DSTACK("TestConnection::Run");
-
/*
Test some real connections
void *run()
{
- DSTACK(FUNCTION_NAME);
BEGIN_DEBUG_EXCEPTION_HANDLER
while (!stopRequested()) {