f32 camera_pitch; // "up/down"
};
-//TODO: Needs a better name because fog_range etc are included
-struct InteractParams {
+struct GameRunData {
u16 dig_index;
u16 new_playeritem;
PointedThing pointed_old;
bool digging;
bool ldown_for_dig;
bool left_punch;
+ bool update_wielded_item_trigger;
float nodig_delay_timer;
float dig_time;
float dig_time_complete;
u32 profiler_current_page;
u32 profiler_max_page; // Number of pages
+
+ float time_of_day;
+ float time_of_day_smooth;
};
struct Jitter {
* hides most of the stuff in this class (nothing in this class is required
* by any other file) but exposes the public methods/data only.
*/
-class MinetestApp
+class Game
{
public:
- MinetestApp();
- ~MinetestApp();
+ Game();
+ ~Game();
bool startup(bool *kill,
bool random_input,
// Main loop
- void updateInteractTimers(InteractParams *args, f32 dtime);
+ void updateInteractTimers(GameRunData *args, f32 dtime);
bool checkConnection();
bool handleCallbacks();
void processQueues();
f32 dtime);
void updateStats(RunStats *stats, const FpsControl &draw_times, f32 dtime);
- void processUserInput(VolatileRunFlags *flags, InteractParams *interact_args,
+ void processUserInput(VolatileRunFlags *flags, GameRunData *interact_args,
f32 dtime);
void processKeyboardInput(VolatileRunFlags *flags,
float *statustext_time,
float time_from_last_punch);
void updateSound(f32 dtime);
void processPlayerInteraction(std::vector<aabb3f> &highlight_boxes,
- InteractParams *interactArgs, f32 dtime, bool show_hud,
+ GameRunData *runData, f32 dtime, bool show_hud,
bool show_debug);
- void handlePointingAtNode(InteractParams *interactArgs,
+ void handlePointingAtNode(GameRunData *runData,
const PointedThing &pointed, const ItemDefinition &playeritem_def,
const ToolCapabilities &playeritem_toolcap, f32 dtime);
- void handlePointingAtObject(InteractParams *interactArgs,
+ void handlePointingAtObject(GameRunData *runData,
const PointedThing &pointed, const ItemStack &playeritem,
const v3f &player_position, bool show_debug);
- void handleDigging(InteractParams *interactArgs, const PointedThing &pointed,
+ void handleDigging(GameRunData *runData, const PointedThing &pointed,
const v3s16 &nodepos, const ToolCapabilities &playeritem_toolcap,
f32 dtime);
void updateFrame(std::vector<aabb3f> &highlight_boxes, ProfilerGraph *graph,
- RunStats *stats, InteractParams *interactArgs,
+ RunStats *stats, GameRunData *runData,
f32 dtime, const VolatileRunFlags &flags, const CameraOrientation &cam);
void updateGui(float *statustext_time, const RunStats &stats, f32 dtime,
const VolatileRunFlags &flags, const CameraOrientation &cam);
void updateProfilerGraphs(ProfilerGraph *graph);
// Misc
- void limitFps(FpsControl *params, f32 *dtime);
+ void limitFps(FpsControl *fps_timings, f32 *dtime);
void showOverlayMessage(const char *msg, float dtime, int percent,
bool draw_clouds = true);
std::wstring statustext;
};
-MinetestApp::MinetestApp() :
+Game::Game() :
client(NULL),
server(NULL),
font(NULL),
MinetestApp Public
****************************************************************************/
-MinetestApp::~MinetestApp()
+Game::~Game()
{
delete client;
delete soundmaker;
extendedResourceCleanup();
}
-bool MinetestApp::startup(bool *kill,
+bool Game::startup(bool *kill,
bool random_input,
InputHandler *input,
IrrlichtDevice *device,
}
-void MinetestApp::run()
+void Game::run()
{
ProfilerGraph graph;
RunStats stats = { 0 };
CameraOrientation cam_view = { 0 };
- InteractParams interactArgs = { 0 };
+ GameRunData runData = { 0 };
FpsControl draw_times = { 0 };
VolatileRunFlags flags = { 0 };
f32 dtime; // in seconds
- interactArgs.time_from_last_punch = 10.0;
- interactArgs.profiler_max_page = 3;
+ runData.time_from_last_punch = 10.0;
+ runData.profiler_max_page = 3;
+ runData.update_wielded_item_trigger = true;
flags.show_chat = true;
flags.show_hud = true;
shader_src->addGlobalConstantSetter(new GameGlobalShaderConstantSetter(
sky,
&flags.force_fog_off,
- &interactArgs.fog_range,
+ &runData.fog_range,
client));
while (device->run() && !(*kill || g_gamecallback->shutdown_requested)) {
limitFps(&draw_times, &dtime);
updateStats(&stats, draw_times, dtime);
- updateInteractTimers(&interactArgs, dtime);
+ updateInteractTimers(&runData, dtime);
if (!checkConnection())
break;
infotext = L"";
hud->resizeHotbar();
addProfilerGraphs(stats, draw_times, dtime);
- processUserInput(&flags, &interactArgs, dtime);
+ processUserInput(&flags, &runData, dtime);
// Update camera before player movement to avoid camera lag of one frame
updateCameraDirection(&cam_view, &flags);
updatePlayerControl(cam_view);
step(&dtime);
- processClientEvents(&cam_view, &interactArgs.damage_flash);
+ processClientEvents(&cam_view, &runData.damage_flash);
updateCamera(&flags, draw_times.busy_time, dtime,
- interactArgs.time_from_last_punch);
+ runData.time_from_last_punch);
updateSound(dtime);
- processPlayerInteraction(highlight_boxes, &interactArgs, dtime,
+ processPlayerInteraction(highlight_boxes, &runData, dtime,
flags.show_hud, flags.show_debug);
- updateFrame(highlight_boxes, &graph, &stats, &interactArgs, dtime,
+ updateFrame(highlight_boxes, &graph, &stats, &runData, dtime,
flags, cam_view);
updateProfilerGraphs(&graph);
}
}
-void MinetestApp::shutdown()
+void Game::shutdown()
{
showOverlayMessage("Shutting down...", 0, 0, false);
Startup
****************************************************************************/
-bool MinetestApp::init(
+bool Game::init(
const std::string &map_dir,
std::string *address,
u16 port,
return true;
}
-bool MinetestApp::initSound()
+bool Game::initSound()
{
#if USE_SOUND
if (g_settings->getBool("enable_sound")) {
return true;
}
-bool MinetestApp::createSingleplayerServer(const std::string map_dir,
+bool Game::createSingleplayerServer(const std::string map_dir,
const SubgameSpec &gamespec, u16 port, std::string *address)
{
showOverlayMessage("Creating server...", 0, 25);
return true;
}
-bool MinetestApp::createClient(const std::string &playername,
+bool Game::createClient(const std::string &playername,
const std::string &password, std::string *address, u16 port,
std::wstring *error_message)
{
return true;
}
-bool MinetestApp::initGui(std::wstring *error_message)
+bool Game::initGui(std::wstring *error_message)
{
// First line of debug text
guitext = guienv->addStaticText(
return true;
}
-bool MinetestApp::connectToServer(const std::string &playername,
+bool Game::connectToServer(const std::string &playername,
const std::string &password, std::string *address, u16 port,
bool *connect_ok, bool *aborted)
{
return true;
}
-bool MinetestApp::getServerContent(bool *aborted)
+bool Game::getServerContent(bool *aborted)
{
input->clear();
Run
****************************************************************************/
-inline void MinetestApp::updateInteractTimers(InteractParams *args, f32 dtime)
+inline void Game::updateInteractTimers(GameRunData *args, f32 dtime)
{
if (args->nodig_delay_timer >= 0)
args->nodig_delay_timer -= dtime;
}
-/* returns false if app should exit, otherwise true
+/* returns false if game should exit, otherwise true
*/
-inline bool MinetestApp::checkConnection()
+inline bool Game::checkConnection()
{
if (client->accessDenied()) {
*error_message = L"Access denied. Reason: "
}
-/* returns false if app should exit, otherwise true
+/* returns false if game should exit, otherwise true
*/
-inline bool MinetestApp::handleCallbacks()
+inline bool Game::handleCallbacks()
{
if (g_gamecallback->disconnect_requested) {
g_gamecallback->disconnect_requested = false;
}
-void MinetestApp::processQueues()
+void Game::processQueues()
{
texture_src->processQueue();
itemdef_manager->processQueue(gamedef);
}
-void MinetestApp::addProfilerGraphs(const RunStats &stats,
+void Game::addProfilerGraphs(const RunStats &stats,
const FpsControl &draw_times, f32 dtime)
{
g_profiler->graphAdd("mainloop_other",
}
-void MinetestApp::updateStats(RunStats *stats, const FpsControl &draw_times,
+void Game::updateStats(RunStats *stats, const FpsControl &draw_times,
f32 dtime)
{
Input handling
****************************************************************************/
-void MinetestApp::processUserInput(VolatileRunFlags *flags,
- InteractParams *interact_args, f32 dtime)
+void Game::processUserInput(VolatileRunFlags *flags,
+ GameRunData *interact_args, f32 dtime)
{
// Reset input if window not active or some menu is active
if (device->isWindowActive() == false
}
-void MinetestApp::processKeyboardInput(VolatileRunFlags *flags,
+void Game::processKeyboardInput(VolatileRunFlags *flags,
float *statustext_time,
float *jump_timer,
u32 *profiler_current_page,
}
-void MinetestApp::processItemSelection(u16 *new_playeritem)
+void Game::processItemSelection(u16 *new_playeritem)
{
LocalPlayer *player = client->getEnv().getLocalPlayer();
}
-void MinetestApp::dropSelectedItem()
+void Game::dropSelectedItem()
{
IDropAction *a = new IDropAction();
a->count = 0;
}
-void MinetestApp::openInventory()
+void Game::openInventory()
{
infostream << "the_game: " << "Launching inventory" << std::endl;
}
-void MinetestApp::openConsole()
+void Game::openConsole()
{
if (!gui_chat_console->isOpenInhibited()) {
// Open up to over half of the screen
}
-void MinetestApp::toggleFreeMove(float *statustext_time)
+void Game::toggleFreeMove(float *statustext_time)
{
static const wchar_t *msg[] = { L"free_move disabled", L"free_move enabled" };
}
-void MinetestApp::toggleFreeMoveAlt(float *statustext_time, float *jump_timer)
+void Game::toggleFreeMoveAlt(float *statustext_time, float *jump_timer)
{
if (g_settings->getBool("doubletap_jump") && *jump_timer < 0.2f) {
toggleFreeMove(statustext_time);
}
-void MinetestApp::toggleFast(float *statustext_time)
+void Game::toggleFast(float *statustext_time)
{
static const wchar_t *msg[] = { L"fast_move disabled", L"fast_move enabled" };
bool fast_move = !g_settings->getBool("fast_move");
}
-void MinetestApp::toggleNoClip(float *statustext_time)
+void Game::toggleNoClip(float *statustext_time)
{
static const wchar_t *msg[] = { L"noclip disabled", L"noclip enabled" };
bool noclip = !g_settings->getBool("noclip");
}
-void MinetestApp::toggleChat(float *statustext_time, bool *flag)
+void Game::toggleChat(float *statustext_time, bool *flag)
{
static const wchar_t *msg[] = { L"Chat hidden", L"Chat shown" };
}
-void MinetestApp::toggleHud(float *statustext_time, bool *flag)
+void Game::toggleHud(float *statustext_time, bool *flag)
{
static const wchar_t *msg[] = { L"HUD hidden", L"HUD shown" };
}
-void MinetestApp::toggleFog(float *statustext_time, bool *flag)
+void Game::toggleFog(float *statustext_time, bool *flag)
{
static const wchar_t *msg[] = { L"Fog enabled", L"Fog disabled" };
}
-void MinetestApp::toggleDebug(float *statustext_time, bool *show_debug,
+void Game::toggleDebug(float *statustext_time, bool *show_debug,
bool *show_profiler_graph)
{
// Initial / 3x toggle: Chat only
}
-void MinetestApp::toggleUpdateCamera(float *statustext_time, bool *flag)
+void Game::toggleUpdateCamera(float *statustext_time, bool *flag)
{
static const wchar_t *msg[] = {
L"Camera update enabled",
}
-void MinetestApp::toggleProfiler(float *statustext_time, u32 *profiler_current_page,
+void Game::toggleProfiler(float *statustext_time, u32 *profiler_current_page,
u32 profiler_max_page)
{
*profiler_current_page = (*profiler_current_page + 1) % (profiler_max_page + 1);
}
-void MinetestApp::increaseViewRange(float *statustext_time)
+void Game::increaseViewRange(float *statustext_time)
{
s16 range = g_settings->getS16("viewing_range_nodes_min");
s16 range_new = range + 10;
}
-void MinetestApp::decreaseViewRange(float *statustext_time)
+void Game::decreaseViewRange(float *statustext_time)
{
s16 range = g_settings->getS16("viewing_range_nodes_min");
s16 range_new = range - 10;
}
-void MinetestApp::toggleFullViewRange(float *statustext_time)
+void Game::toggleFullViewRange(float *statustext_time)
{
static const wchar_t *msg[] = {
L"Disabled full viewing range",
}
-void MinetestApp::updateCameraDirection(CameraOrientation *cam,
+void Game::updateCameraDirection(CameraOrientation *cam,
VolatileRunFlags *flags)
{
// float turn_amount = 0; // Deprecated?
}
-void MinetestApp::updatePlayerControl(const CameraOrientation &cam)
+void Game::updatePlayerControl(const CameraOrientation &cam)
{
PlayerControl control(
input->isKeyDown(getKeySetting("keymap_forward")),
}
-inline void MinetestApp::step(f32 *dtime)
+inline void Game::step(f32 *dtime)
{
bool can_be_and_is_paused =
(simple_singleplayer_mode && g_menumgr.pausesGame());
}
-void MinetestApp::processClientEvents(CameraOrientation *cam, float *damage_flash)
+void Game::processClientEvents(CameraOrientation *cam, float *damage_flash)
{
ClientEvent event = client->getClientEvent();
}
-void MinetestApp::updateCamera(VolatileRunFlags *flags, u32 busy_time,
+void Game::updateCamera(VolatileRunFlags *flags, u32 busy_time,
f32 dtime, float time_from_last_punch)
{
LocalPlayer *player = client->getEnv().getLocalPlayer();
}
-void MinetestApp::updateSound(f32 dtime)
+void Game::updateSound(f32 dtime)
{
// Update sound listener
v3s16 camera_offset = camera->getOffset();
}
-void
MinetestApp::processPlayerInteraction(std::vector<aabb3f> &highlight_boxes,
- InteractParams *interactArgs, f32 dtime, bool show_hud, bool show_debug)
+void
Game::processPlayerInteraction(std::vector<aabb3f> &highlight_boxes,
+ GameRunData *runData, f32 dtime, bool show_hud, bool show_debug)
{
LocalPlayer *player = client->getEnv().getLocalPlayer();
client, player_position, camera_direction,
camera_position, shootline, d,
playeritem_def.liquids_pointable,
- !interactArgs->ldown_for_dig,
+ !runData->ldown_for_dig,
camera_offset,
// output
highlight_boxes,
- interactArgs->selected_object);
+ runData->selected_object);
- if (pointed != interactArgs->pointed_old) {
+ if (pointed != runData->pointed_old) {
infostream << "Pointing at " << pointed.dump() << std::endl;
if (g_settings->getBool("enable_node_highlighting")) {
- releasing left mouse button
- pointing away from node
*/
- if (interactArgs->digging) {
+ if (runData->digging) {
if (input->getLeftReleased()) {
infostream << "Left button released"
<< " (stopped digging)" << std::endl;
- interactArgs->digging = false;
- } else if (pointed != interactArgs->pointed_old) {
+ runData->digging = false;
+ } else if (pointed != runData->pointed_old) {
if (pointed.type == POINTEDTHING_NODE
- && interactArgs->pointed_old.type == POINTEDTHING_NODE
+ && runData->pointed_old.type == POINTEDTHING_NODE
&& pointed.node_undersurface
- == interactArgs->pointed_old.node_undersurface) {
+ == runData->pointed_old.node_undersurface) {
// Still pointing to the same node, but a different face.
// Don't reset.
} else {
infostream << "Pointing away from node"
<< " (stopped digging)" << std::endl;
- interactArgs->digging = false;
+ runData->digging = false;
}
}
- if (!interactArgs->digging) {
- client->interact(1, interactArgs->pointed_old);
+ if (!runData->digging) {
+ client->interact(1, runData->pointed_old);
client->setCrack(-1, v3s16(0, 0, 0));
- interactArgs->dig_time = 0.0;
+ runData->dig_time = 0.0;
}
}
- if (!interactArgs->digging && interactArgs->ldown_for_dig && !input->getLeftState()) {
- interactArgs->ldown_for_dig = false;
+ if (!runData->digging && runData->ldown_for_dig && !input->getLeftState()) {
+ runData->ldown_for_dig = false;
}
- interactArgs->left_punch = false;
+ runData->left_punch = false;
soundmaker->m_player_leftpunch_sound.name = "";
if (input->getRightState())
- interactArgs->repeat_rightclick_timer += dtime;
+ runData->repeat_rightclick_timer += dtime;
else
- interactArgs->repeat_rightclick_timer = 0;
+ runData->repeat_rightclick_timer = 0;
if (playeritem_def.usable && input->getLeftState()) {
if (input->getLeftClicked())
} else if (pointed.type == POINTEDTHING_NODE) {
ToolCapabilities playeritem_toolcap =
playeritem.getToolCapabilities(itemdef_manager);
- handlePointingAtNode(interactArgs, pointed, playeritem_def,
+ handlePointingAtNode(runData, pointed, playeritem_def,
playeritem_toolcap, dtime);
} else if (pointed.type == POINTEDTHING_OBJECT) {
- handlePointingAtObject(interactArgs, pointed, playeritem,
+ handlePointingAtObject(runData, pointed, playeritem,
player_position, show_debug);
} else if (input->getLeftState()) {
// When button is held down in air, show continuous animation
- interactArgs->left_punch = true;
+ runData->left_punch = true;
}
- interactArgs->pointed_old = pointed;
+ runData->pointed_old = pointed;
- if (interactArgs->left_punch || input->getLeftClicked())
+ if (runData->left_punch || input->getLeftClicked())
camera->setDigging(0); // left click animation
input->resetLeftClicked();
}
-void MinetestApp::handlePointingAtNode(InteractParams *interactArgs,
+void Game::handlePointingAtNode(GameRunData *runData,
const PointedThing &pointed, const ItemDefinition &playeritem_def,
const ToolCapabilities &playeritem_toolcap, f32 dtime)
{
}
}
- if (interactArgs->nodig_delay_timer <= 0.0 && input->getLeftState()
+ if (runData->nodig_delay_timer <= 0.0 && input->getLeftState()
&& client->checkPrivilege("interact")) {
- handleDigging(interactArgs, pointed, nodepos, playeritem_toolcap, dtime);
+ handleDigging(runData, pointed, nodepos, playeritem_toolcap, dtime);
}
if ((input->getRightClicked() ||
- interactArgs->repeat_rightclick_timer >=
+ runData->repeat_rightclick_timer >=
g_settings->getFloat("repeat_rightclick_time")) &&
client->checkPrivilege("interact")) {
- interactArgs->repeat_rightclick_timer = 0;
+ runData->repeat_rightclick_timer = 0;
infostream << "Ground right-clicked" << std::endl;
if (meta && meta->getString("formspec") != "" && !random_input
}
-void MinetestApp::handlePointingAtObject(InteractParams *interactArgs,
+void Game::handlePointingAtObject(GameRunData *runData,
const PointedThing &pointed,
const ItemStack &playeritem,
const v3f &player_position,
bool show_debug)
{
- infotext = narrow_to_wide(interactArgs->selected_object->infoText());
+ infotext = narrow_to_wide(runData->selected_object->infoText());
if (infotext == L"" && show_debug) {
- infotext = narrow_to_wide(interactArgs->selected_object->debugInfoText());
+ infotext = narrow_to_wide(runData->selected_object->debugInfoText());
}
if (input->getLeftState()) {
bool do_punch = false;
bool do_punch_damage = false;
- if (interactArgs->object_hit_delay_timer <= 0.0) {
+ if (runData->object_hit_delay_timer <= 0.0) {
do_punch = true;
do_punch_damage = true;
- interactArgs->object_hit_delay_timer = object_hit_delay;
+ runData->object_hit_delay_timer = object_hit_delay;
}
if (input->getLeftClicked())
if (do_punch) {
infostream << "Left-clicked object" << std::endl;
- interactArgs->left_punch = true;
+ runData->left_punch = true;
}
if (do_punch_damage) {
// Report direct punch
- v3f objpos = interactArgs->selected_object->getPosition();
+ v3f objpos = runData->selected_object->getPosition();
v3f dir = (objpos - player_position).normalize();
- bool disable_send = interactArgs->selected_object->directReportPunch(
- dir, &playeritem, interactArgs->time_from_last_punch);
- interactArgs->time_from_last_punch = 0;
+ bool disable_send = runData->selected_object->directReportPunch(
+ dir, &playeritem, runData->time_from_last_punch);
+ runData->time_from_last_punch = 0;
if (!disable_send)
client->interact(0, pointed);
}
-void MinetestApp::handleDigging(InteractParams *interactArgs,
+void Game::handleDigging(GameRunData *runData,
const PointedThing &pointed, const v3s16 &nodepos,
const ToolCapabilities &playeritem_toolcap, f32 dtime)
{
- if (!interactArgs->digging) {
+ if (!runData->digging) {
infostream << "Started digging" << std::endl;
client->interact(0, pointed);
- interactArgs->digging = true;
- interactArgs->ldown_for_dig = true;
+ runData->digging = true;
+ runData->ldown_for_dig = true;
}
LocalPlayer *player = client->getEnv().getLocalPlayer();
if (params.diggable == false) {
// I guess nobody will wait for this long
- interactArgs->dig_time_complete = 10000000.0;
+ runData->dig_time_complete = 10000000.0;
} else {
- interactArgs->dig_time_complete = params.time;
+ runData->dig_time_complete = params.time;
if (g_settings->getBool("enable_particles")) {
const ContentFeatures &features =
}
}
- if (interactArgs->dig_time_complete >= 0.001) {
- interactArgs->dig_index = (float)crack_animation_length
- * interactArgs->dig_time
- / interactArgs->dig_time_complete;
+ if (runData->dig_time_complete >= 0.001) {
+ runData->dig_index = (float)crack_animation_length
+ * runData->dig_time
+ / runData->dig_time_complete;
} else {
// This is for torches
- interactArgs->dig_index = crack_animation_length;
+ runData->dig_index = crack_animation_length;
}
SimpleSoundSpec sound_dig = nodedef_manager->get(n).sound_dig;
}
// Don't show cracks if not diggable
- if (interactArgs->dig_time_complete >= 100000.0) {
- } else if (interactArgs->dig_index < crack_animation_length) {
+ if (runData->dig_time_complete >= 100000.0) {
+ } else if (runData->dig_index < crack_animation_length) {
//TimeTaker timer("client.setTempMod");
//infostream<<"dig_index="<<dig_index<<std::endl;
- client->setCrack(interactArgs->dig_index, nodepos);
+ client->setCrack(runData->dig_index, nodepos);
} else {
infostream << "Digging completed" << std::endl;
client->interact(2, pointed);
nodepos, features.tiles);
}
- interactArgs->dig_time = 0;
- interactArgs->digging = false;
+ runData->dig_time = 0;
+ runData->digging = false;
- interactArgs->nodig_delay_timer =
- interactArgs->dig_time_complete / (float)crack_animation_length;
+ runData->nodig_delay_timer =
+ runData->dig_time_complete / (float)crack_animation_length;
// We don't want a corresponding delay to
// very time consuming nodes
- if (interactArgs->nodig_delay_timer > 0.3)
- interactArgs->nodig_delay_timer = 0.3;
+ if (runData->nodig_delay_timer > 0.3)
+ runData->nodig_delay_timer = 0.3;
// We want a slight delay to very little
// time consuming nodes
const float mindelay = 0.15;
- if (interactArgs->nodig_delay_timer < mindelay)
- interactArgs->nodig_delay_timer = mindelay;
+ if (runData->nodig_delay_timer < mindelay)
+ runData->nodig_delay_timer = mindelay;
// Send event to trigger sound
MtEvent *e = new NodeDugEvent(nodepos, wasnode);
gamedef->event()->put(e);
}
- if (interactArgs->dig_time_complete < 100000.0) {
- interactArgs->dig_time += dtime;
+ if (runData->dig_time_complete < 100000.0) {
+ runData->dig_time += dtime;
} else {
- interactArgs->dig_time = 0;
+ runData->dig_time = 0;
client->setCrack(-1, nodepos);
}
}
-void
MinetestApp::updateFrame(std::vector<aabb3f> &highlight_boxes,
- ProfilerGraph *graph, RunStats *stats, InteractParams *interactArgs,
+void
Game::updateFrame(std::vector<aabb3f> &highlight_boxes,
+ ProfilerGraph *graph, RunStats *stats, GameRunData *runData,
f32 dtime, const VolatileRunFlags &flags, const CameraOrientation &cam)
{
LocalPlayer *player = client->getEnv().getLocalPlayer();
*/
if (draw_control->range_all) {
- interactArgs->fog_range = 100000 * BS;
+ runData->fog_range = 100000 * BS;
} else {
- interactArgs->fog_range = draw_control->wanted_range * BS
+ runData->fog_range = draw_control->wanted_range * BS
+ 0.0 * MAP_BLOCKSIZE * BS;
- interactArgs->fog_range = MYMIN(
- interactArgs->fog_range,
+ runData->fog_range = MYMIN(
+ runData->fog_range,
(draw_control->farthest_drawn + 20) * BS);
- interactArgs->fog_range *= 0.9;
+ runData->fog_range *= 0.9;
}
/*
*/
u32 daynight_ratio = client->getEnv().getDayNightRatio();
float time_brightness = decode_light_f((float)daynight_ratio / 1000.0);
- float direct_brightness = 0;
- bool sunlight_seen = false;
+ float direct_brightness;
+ bool sunlight_seen;
if (g_settings->getBool("free_move")) {
direct_brightness = time_brightness;
ScopeProfiler sp(g_profiler, "Detecting background light", SPT_AVG);
float old_brightness = sky->getBrightness();
direct_brightness = client->getEnv().getClientMap()
- .getBackgroundBrightness(MYMIN(interactArgs->fog_range * 1.2, 60 * BS),
+ .getBackgroundBrightness(MYMIN(runData->fog_range * 1.2, 60 * BS),
daynight_ratio, (int)(old_brightness * 255.5), &sunlight_seen)
/ 255.0;
}
- float time_of_day = 0;
- float time_of_day_smooth = 0;
+ float time_of_day = runData->time_of_day;
+ float time_of_day_smooth = runData->time_of_day_smooth;
time_of_day = client->getEnv().getTimeOfDayF();
const float maxsm = 0.05;
+ const float todsm = 0.05;
if (fabs(time_of_day - time_of_day_smooth) > maxsm &&
fabs(time_of_day - time_of_day_smooth + 1.0) > maxsm &&
fabs(time_of_day - time_of_day_smooth - 1.0) > maxsm)
time_of_day_smooth = time_of_day;
- const float todsm = 0.05;
-
if (time_of_day_smooth > 0.8 && time_of_day < 0.2)
time_of_day_smooth = time_of_day_smooth * (1.0 - todsm)
+ (time_of_day + 1.0) * todsm;
time_of_day_smooth = time_of_day_smooth * (1.0 - todsm)
+ time_of_day * todsm;
+ runData->time_of_day = time_of_day;
+ runData->time_of_day_smooth = time_of_day_smooth;
+
sky->update(time_of_day_smooth, time_brightness, direct_brightness,
sunlight_seen, camera->getCameraMode(), player->getYaw(),
player->getPitch());
driver->setFog(
sky->getBgColor(),
video::EFT_FOG_LINEAR,
- interactArgs->fog_range * 0.4,
- interactArgs->fog_range * 1.0,
+ runData->fog_range * 0.4,
+ runData->fog_range * 1.0,
0.01,
false, // pixel fog
false // range fog
v2u32 screensize = driver->getScreenSize();
updateChat(*client, dtime, flags.show_debug, screensize,
- flags.show_chat, interactArgs->profiler_current_page,
+ flags.show_chat, runData->profiler_current_page,
*chat_backend, guitext_chat, font);
/*
Inventory
*/
- bool update_wielded_item_trigger = true;
-
- if (client->getPlayerItem() != interactArgs->new_playeritem) {
- client->selectPlayerItem(interactArgs->new_playeritem);
- }
+ if (client->getPlayerItem() != runData->new_playeritem)
+ client->selectPlayerItem(runData->new_playeritem);
+ // Update local inventory if it has changed
if (client->getLocalInventoryUpdated()) {
//infostream<<"Updating local inventory"<<std::endl;
client->getLocalInventory(*local_inventory);
-
- update_wielded_item_trigger = true;
+ runData->update_wielded_item_trigger = true;
}
- if (update_wielded_item_trigger) {
- update_wielded_item_trigger = false;
+ if (runData->update_wielded_item_trigger) {
// Update wielded tool
InventoryList *mlist = local_inventory->getList("main");
- ItemStack item;
-
- if (mlist && (client->getPlayerItem() < mlist->getSize()))
- item = mlist->getItem(client->getPlayerItem());
- camera->wield(item, client->getPlayerItem());
+ if (mlist && (client->getPlayerItem() < mlist->getSize())) {
+ ItemStack item = mlist->getItem(client->getPlayerItem());
+ camera->wield(item, client->getPlayerItem());
+ }
+ runData->update_wielded_item_trigger = false;
}
/*
Update block draw list every 200ms or when camera direction has
changed much
*/
- interactArgs->update_draw_list_timer += dtime;
+ runData->update_draw_list_timer += dtime;
v3f camera_direction = camera->getDirection();
- if (interactArgs->update_draw_list_timer >= 0.2
- || interactArgs->update_draw_list_last_cam_dir.getDistanceFrom(camera_direction) > 0.2
+ if (runData->update_draw_list_timer >= 0.2
+ || runData->update_draw_list_last_cam_dir.getDistanceFrom(camera_direction) > 0.2
|| flags.camera_offset_changed) {
- interactArgs->update_draw_list_timer = 0;
+ runData->update_draw_list_timer = 0;
client->getEnv().getClientMap().updateDrawList(driver);
- interactArgs->update_draw_list_last_cam_dir = camera_direction;
+ runData->update_draw_list_last_cam_dir = camera_direction;
}
- updateGui(&interactArgs->statustext_time, *stats, dtime, flags, cam);
+ updateGui(&runData->statustext_time, *stats, dtime, flags, cam);
/*
make sure menu is on top
/*
Damage flash
*/
- if (interactArgs->damage_flash > 0.0) {
- video::SColor color(std::min(interactArgs->damage_flash, 180.0f),
+ if (runData->damage_flash > 0.0) {
+ video::SColor color(std::min(runData->damage_flash, 180.0f),
180,
0,
0);
core::rect<s32>(0, 0, screensize.X, screensize.Y),
NULL);
- interactArgs->damage_flash -= 100.0 * dtime;
+ runData->damage_flash -= 100.0 * dtime;
}
/*
}
-void MinetestApp::updateGui(float *statustext_time, const RunStats& stats,
+void Game::updateGui(float *statustext_time, const RunStats& stats,
f32 dtime, const VolatileRunFlags &flags, const CameraOrientation &cam)
{
v2u32 screensize = driver->getScreenSize();
/* Log times and stuff for visualization */
-inline void MinetestApp::updateProfilerGraphs(ProfilerGraph *graph)
+inline void Game::updateProfilerGraphs(ProfilerGraph *graph)
{
Profiler::GraphValues values;
g_profiler->graphGet(values);
* *Must* be called after device->run() so that device->getTimer()->getTime();
* is correct
*/
-inline void MinetestApp::limitFps(FpsControl *params, f32 *dtime)
+inline void Game::limitFps(FpsControl *fps_timings, f32 *dtime)
{
// not using getRealTime is necessary for wine
u32 time = device->getTimer()->getTime();
- u32 last_time = params->last_time;
+ u32 last_time = fps_timings->last_time;
if (time > last_time) // Make sure time hasn't overflowed
- params->busy_time = time - last_time;
+ fps_timings->busy_time = time - last_time;
else
- params->busy_time = 0;
+ fps_timings->busy_time = 0;
u32 frametime_min = 1000 / (g_menumgr.pausesGame()
? g_settings->getFloat("pause_fps_max")
: g_settings->getFloat("fps_max"));
- if (params->busy_time < frametime_min) {
- params->sleep_time = frametime_min - params->busy_time;
- device->sleep(params->sleep_time);
- time += params->sleep_time;
+ if (fps_timings->busy_time < frametime_min) {
+ fps_timings->sleep_time = frametime_min - fps_timings->busy_time;
+ device->sleep(fps_timings->sleep_time);
+ time += fps_timings->sleep_time;
} else {
- params->sleep_time = 0;
+ fps_timings->sleep_time = 0;
}
if (time > last_time) // Checking for overflow
else
*dtime = 0.03; // Choose 30fps as fallback in overflow case
- params->last_time = time;
+ fps_timings->last_time = time;
#if 0
}
-void MinetestApp::showOverlayMessage(const char *msg, float dtime,
+void Game::showOverlayMessage(const char *msg, float dtime,
int percent, bool draw_clouds)
{
wchar_t *text = wgettext(msg);
}
-
/****************************************************************************
Shutdown / cleanup
****************************************************************************/
-void MinetestApp::extendedResourceCleanup()
+void Game::extendedResourceCleanup()
{
// Extended resource accounting
infostream << "Irrlicht resources after cleanup:" << std::endl;
const SubgameSpec &gamespec, // Used for local game
bool simple_singleplayer_mode)
{
- MinetestApp app;
+ Game game;
/* Make a copy of the server address because if a local singleplayer server
* is created then this is updated and we don't want to change the value
try {
- if (app.startup(kill, random_input, input, device, font, map_dir,
+ if (game.startup(kill, random_input, input, device, font, map_dir,
playername, password, &server_address, port,
&error_message, &chat_backend, gamespec,
simple_singleplayer_mode)) {
- //std::cout << "App started" << std::endl;
- app.run();
- app.shutdown();
+ game.run();
+ game.shutdown();
}
} catch (SerializationError &e) {
projects / oweals / minetest.git / commitdiff