51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
-#include "common_irrlicht.h"
#include "game.h"
+#include "common_irrlicht.h"
+#include <IGUICheckBox.h>
+#include <IGUIEditBox.h>
+#include <IGUIButton.h>
+#include <IGUIStaticText.h>
+#include <IGUIFont.h>
#include "client.h"
#include "server.h"
#include "guiPauseMenu.h"
#include "guiPasswordChange.h"
#include "guiInventoryMenu.h"
#include "guiTextInputMenu.h"
+#include "guiDeathScreen.h"
#include "materials.h"
#include "config.h"
#include "clouds.h"
-#include "keycode.h"
+#include "camera.h"
#include "farmesh.h"
#include "mapblock.h"
-
-/*
- TODO: Move content-aware stuff to separate file by adding properties
- and virtual interfaces
-*/
-#include "content_mapnode.h"
-#include "content_nodemeta.h"
+#include "settings.h"
+#include "profiler.h"
+#include "mainmenumanager.h"
+#include "gettext.h"
+#include "log.h"
+#include "filesys.h"
+// Needed for determining pointing to nodes
+#include "nodedef.h"
+#include "nodemetadata.h"
+#include "main.h" // For g_settings
+#include "itemdef.h"
+#include "tile.h" // For TextureSource
+#include "logoutputbuffer.h"
/*
Setting this to 1 enables a special camera mode that forces
#define FIELD_OF_VIEW_TEST 0
-MapDrawControl draw_control;
-
// Chat data
struct ChatLine
{
std::wstring text;
};
-/*
- Inventory stuff
-*/
-
-// Inventory actions from the menu are buffered here before sending
-Queue<InventoryAction*> inventory_action_queue;
-// This is a copy of the inventory that the client's environment has
-Inventory local_inventory;
-
-u16 g_selected_item = 0;
-
/*
Text input system
*/
-struct TextDestSign : public TextDest
-{
- TextDestSign(v3s16 blockpos, s16 id, Client *client)
- {
- m_blockpos = blockpos;
- m_id = id;
- m_client = client;
- }
- void gotText(std::wstring text)
- {
- std::string ntext = wide_to_narrow(text);
- dstream<<"Changing text of a sign object: "
- <<ntext<<std::endl;
- m_client->sendSignText(m_blockpos, m_id, ntext);
- }
-
- v3s16 m_blockpos;
- s16 m_id;
- Client *m_client;
-};
-
struct TextDestChat : public TextDest
{
TextDestChat(Client *client)
// Discard empty line
if(text == L"")
return;
-
- // Parse command (server command starts with "/#")
- if(text[0] == L'/' && text[1] != L'#')
- {
- std::wstring reply = L"Local: ";
-
- reply += L"Local commands not yet supported. "
- L"Server prefix is \"/#\".";
-
- m_client->addChatMessage(reply);
- return;
- }
// Send to others
m_client->sendChatMessage(text);
Client *m_client;
};
-struct TextDestSignNode : public TextDest
+struct TextDestNodeMetadata : public TextDest
{
- TextDestSignNode(v3s16 p, Client *client)
+ TextDestNodeMetadata(v3s16 p, Client *client)
{
m_p = p;
m_client = client;
void gotText(std::wstring text)
{
std::string ntext = wide_to_narrow(text);
- dstream<<"Changing text of a sign node: "
+ infostream<<"Changing text of a sign node: "
<<ntext<<std::endl;
m_client->sendSignNodeText(m_p, ntext);
}
Client *m_client;
};
-/*
- Render distance feedback loop
-*/
-void updateViewingRange(f32 frametime_in, Client *client)
-{
- if(draw_control.range_all == true)
- return;
-
- static f32 added_frametime = 0;
- static s16 added_frames = 0;
-
- added_frametime += frametime_in;
- added_frames += 1;
-
- // Actually this counter kind of sucks because frametime is busytime
- static f32 counter = 0;
- counter -= frametime_in;
- if(counter > 0)
- return;
- //counter = 0.1;
- counter = 0.2;
-
- /*dstream<<__FUNCTION_NAME
- <<": Collected "<<added_frames<<" frames, total of "
- <<added_frametime<<"s."<<std::endl;*/
-
- /*dstream<<"draw_control.blocks_drawn="
- <<draw_control.blocks_drawn
- <<", draw_control.blocks_would_have_drawn="
- <<draw_control.blocks_would_have_drawn
- <<std::endl;*/
-
- float range_min = g_settings.getS16("viewing_range_nodes_min");
- float range_max = g_settings.getS16("viewing_range_nodes_max");
-
- // Limit minimum to keep the feedback loop stable
- if(range_min < 5)
- range_min = 5;
-
- draw_control.wanted_min_range = range_min;
- //draw_control.wanted_max_blocks = (1.5*draw_control.blocks_drawn)+1;
- draw_control.wanted_max_blocks = (1.5*draw_control.blocks_would_have_drawn)+1;
- if(draw_control.wanted_max_blocks < 10)
- draw_control.wanted_max_blocks = 10;
-
- float block_draw_ratio = 1.0;
- if(draw_control.blocks_would_have_drawn != 0)
- {
- block_draw_ratio = (float)draw_control.blocks_drawn
- / (float)draw_control.blocks_would_have_drawn;
- }
-
- // Calculate the average frametime in the case that all wanted
- // blocks had been drawn
- f32 frametime = added_frametime / added_frames / block_draw_ratio;
-
- added_frametime = 0.0;
- added_frames = 0;
-
- float wanted_fps = g_settings.getFloat("wanted_fps");
- float wanted_frametime = 1.0 / wanted_fps;
-
- f32 wanted_frametime_change = wanted_frametime - frametime;
- //dstream<<"wanted_frametime_change="<<wanted_frametime_change<<std::endl;
-
- // If needed frametime change is small, just return
- if(fabs(wanted_frametime_change) < wanted_frametime*0.4)
- {
- //dstream<<"ignoring small wanted_frametime_change"<<std::endl;
- return;
- }
-
- float range = draw_control.wanted_range;
- float new_range = range;
+/* Respawn menu callback */
- static s16 range_old = 0;
- static f32 frametime_old = 0;
-
- float d_range = range - range_old;
- f32 d_frametime = frametime - frametime_old;
- // A sane default of 30ms per 50 nodes of range
- static f32 time_per_range = 30. / 50;
- if(d_range != 0)
- {
- time_per_range = d_frametime / d_range;
- }
-
- // The minimum allowed calculated frametime-range derivative:
- // Practically this sets the maximum speed of changing the range.
- // The lower this value, the higher the maximum changing speed.
- // A low value here results in wobbly range (0.001)
- // A high value here results in slow changing range (0.0025)
- // SUGG: This could be dynamically adjusted so that when
- // the camera is turning, this is lower
- //float min_time_per_range = 0.0015;
- float min_time_per_range = 0.0010;
- //float min_time_per_range = 0.05 / range;
- if(time_per_range < min_time_per_range)
- {
- time_per_range = min_time_per_range;
- //dstream<<"time_per_range="<<time_per_range<<" (min)"<<std::endl;
- }
- else
+class MainRespawnInitiator: public IRespawnInitiator
+{
+public:
+ MainRespawnInitiator(bool *active, Client *client):
+ m_active(active), m_client(client)
{
- //dstream<<"time_per_range="<<time_per_range<<std::endl;
+ *m_active = true;
}
-
- f32 wanted_range_change = wanted_frametime_change / time_per_range;
- // Dampen the change a bit to kill oscillations
- //wanted_range_change *= 0.9;
- //wanted_range_change *= 0.75;
- wanted_range_change *= 0.5;
- //dstream<<"wanted_range_change="<<wanted_range_change<<std::endl;
-
- // If needed range change is very small, just return
- if(fabs(wanted_range_change) < 0.001)
+ void respawn()
{
- //dstream<<"ignoring small wanted_range_change"<<std::endl;
- return;
+ *m_active = false;
+ m_client->sendRespawn();
}
-
- new_range += wanted_range_change;
-
- //float new_range_unclamped = new_range;
- if(new_range < range_min)
- new_range = range_min;
- if(new_range > range_max)
- new_range = range_max;
-
- /*dstream<<"new_range="<<new_range_unclamped
- <<", clamped to "<<new_range<<std::endl;*/
-
- draw_control.wanted_range = new_range;
-
- range_old = new_range;
- frametime_old = frametime;
-}
+private:
+ bool *m_active;
+ Client *m_client;
+};
/*
Hotbar draw routine
*/
void draw_hotbar(video::IVideoDriver *driver, gui::IGUIFont *font,
+ IGameDef *gamedef,
v2s32 centerlowerpos, s32 imgsize, s32 itemcount,
- Inventory *inventory, s32 halfheartcount)
+ Inventory *inventory, s32 halfheartcount, u16 playeritem)
{
InventoryList *mainlist = inventory->getList("main");
if(mainlist == NULL)
{
- dstream<<"WARNING: draw_hotbar(): mainlist == NULL"<<std::endl;
+ errorstream<<"draw_hotbar(): mainlist == NULL"<<std::endl;
return;
}
for(s32 i=0; i<itemcount; i++)
{
- InventoryItem *item = mainlist->getItem(i);
+ const ItemStack &item = mainlist->getItem(i);
core::rect<s32> rect = imgrect + pos
+ v2s32(padding+i*(imgsize+padding*2), padding);
- if(g_selected_item == i)
- {
- driver->draw2DRectangle(video::SColor(255,255,0,0),
- core::rect<s32>(rect.UpperLeftCorner - v2s32(1,1)*padding,
- rect.LowerRightCorner + v2s32(1,1)*padding),
- NULL);
- }
- else
- {
- video::SColor bgcolor2(128,0,0,0);
- driver->draw2DRectangle(bgcolor2, rect, NULL);
+ if(playeritem == i)
+ {
+ video::SColor c_outside(255,255,0,0);
+ //video::SColor c_outside(255,0,0,0);
+ //video::SColor c_inside(255,192,192,192);
+ s32 x1 = rect.UpperLeftCorner.X;
+ s32 y1 = rect.UpperLeftCorner.Y;
+ s32 x2 = rect.LowerRightCorner.X;
+ s32 y2 = rect.LowerRightCorner.Y;
+ // Black base borders
+ driver->draw2DRectangle(c_outside,
+ core::rect<s32>(
+ v2s32(x1 - padding, y1 - padding),
+ v2s32(x2 + padding, y1)
+ ), NULL);
+ driver->draw2DRectangle(c_outside,
+ core::rect<s32>(
+ v2s32(x1 - padding, y2),
+ v2s32(x2 + padding, y2 + padding)
+ ), NULL);
+ driver->draw2DRectangle(c_outside,
+ core::rect<s32>(
+ v2s32(x1 - padding, y1),
+ v2s32(x1, y2)
+ ), NULL);
+ driver->draw2DRectangle(c_outside,
+ core::rect<s32>(
+ v2s32(x2, y1),
+ v2s32(x2 + padding, y2)
+ ), NULL);
+ /*// Light inside borders
+ driver->draw2DRectangle(c_inside,
+ core::rect<s32>(
+ v2s32(x1 - padding/2, y1 - padding/2),
+ v2s32(x2 + padding/2, y1)
+ ), NULL);
+ driver->draw2DRectangle(c_inside,
+ core::rect<s32>(
+ v2s32(x1 - padding/2, y2),
+ v2s32(x2 + padding/2, y2 + padding/2)
+ ), NULL);
+ driver->draw2DRectangle(c_inside,
+ core::rect<s32>(
+ v2s32(x1 - padding/2, y1),
+ v2s32(x1, y2)
+ ), NULL);
+ driver->draw2DRectangle(c_inside,
+ core::rect<s32>(
+ v2s32(x2, y1),
+ v2s32(x2 + padding/2, y2)
+ ), NULL);
+ */
}
- if(item != NULL)
- {
- drawInventoryItem(driver, font, item, rect, NULL);
- }
+ video::SColor bgcolor2(128,0,0,0);
+ driver->draw2DRectangle(bgcolor2, rect, NULL);
+ drawItemStack(driver, font, item, rect, NULL, gamedef);
}
/*
Draw hearts
*/
+ video::ITexture *heart_texture =
+ gamedef->getTextureSource()->getTextureRaw("heart.png");
+ if(heart_texture)
{
- video::ITexture *heart_texture =
- driver->getTexture(getTexturePath("heart.png").c_str());
v2s32 p = pos + v2s32(0, -20);
for(s32 i=0; i<halfheartcount/2; i++)
{
}
}
+/*
+ Check if a node is pointable
+*/
+inline bool isPointableNode(const MapNode& n,
+ Client *client, bool liquids_pointable)
+{
+ const ContentFeatures &features = client->getNodeDefManager()->get(n);
+ return features.pointable ||
+ (liquids_pointable && features.isLiquid());
+}
+
/*
Find what the player is pointing at
*/
-void getPointedNode(Client *client, v3f player_position,
+PointedThing getPointedThing(Client *client, v3f player_position,
v3f camera_direction, v3f camera_position,
- bool &nodefound, core::line3d<f32> shootline,
- v3s16 &nodepos, v3s16 &neighbourpos,
- core::aabbox3d<f32> &nodehilightbox,
- f32 d)
+ core::line3d<f32> shootline, f32 d,
+ bool liquids_pointable,
+ bool look_for_object,
+ core::aabbox3d<f32> &hilightbox,
+ bool &should_show_hilightbox,
+ ClientActiveObject *&selected_object)
{
+ PointedThing result;
+
+ hilightbox = core::aabbox3d<f32>(0,0,0,0,0,0);
+ should_show_hilightbox = false;
+ selected_object = NULL;
+
+ INodeDefManager *nodedef = client->getNodeDefManager();
+
+ // First try to find a pointed at active object
+ if(look_for_object)
+ {
+ selected_object = client->getSelectedActiveObject(d*BS,
+ camera_position, shootline);
+ }
+ if(selected_object != NULL)
+ {
+ core::aabbox3d<f32> *selection_box
+ = selected_object->getSelectionBox();
+ // Box should exist because object was returned in the
+ // first place
+ assert(selection_box);
+
+ v3f pos = selected_object->getPosition();
+
+ hilightbox = core::aabbox3d<f32>(
+ selection_box->MinEdge + pos,
+ selection_box->MaxEdge + pos
+ );
+
+ should_show_hilightbox = selected_object->doShowSelectionBox();
+
+ result.type = POINTEDTHING_OBJECT;
+ result.object_id = selected_object->getId();
+ return result;
+ }
+
+ // That didn't work, try to find a pointed at node
+
f32 mindistance = BS * 1001;
v3s16 pos_i = floatToInt(player_position, BS);
- /*std::cout<<"pos_i=("<<pos_i.X<<","<<pos_i.Y<<","<<pos_i.Z<<")"
+ /*infostream<<"pos_i=("<<pos_i.X<<","<<pos_i.Y<<","<<pos_i.Z<<")"
<<std::endl;*/
s16 a = d;
try
{
n = client->getNode(v3s16(x,y,z));
- if(content_pointable(n.getContent()) == false)
- continue;
}
catch(InvalidPositionException &e)
{
continue;
}
+ if(!isPointableNode(n, client, liquids_pointable))
+ continue;
v3s16 np(x,y,z);
v3f npf = intToFloat(np, BS);
v3s16(-1,0,0), // left
};
- /*
- Meta-objects
- */
- if(n.getContent() == CONTENT_TORCH)
- {
- v3s16 dir = unpackDir(n.param2);
- v3f dir_f = v3f(dir.X, dir.Y, dir.Z);
- dir_f *= BS/2 - BS/6 - BS/20;
- v3f cpf = npf + dir_f;
- f32 distance = (cpf - camera_position).getLength();
+ const ContentFeatures &f = nodedef->get(n);
+
+ if(f.selection_box.type == NODEBOX_FIXED)
+ {
+ core::aabbox3d<f32> box = f.selection_box.fixed;
+ box.MinEdge += npf;
+ box.MaxEdge += npf;
+
+ v3s16 facedirs[6] = {
+ v3s16(-1,0,0),
+ v3s16(1,0,0),
+ v3s16(0,-1,0),
+ v3s16(0,1,0),
+ v3s16(0,0,-1),
+ v3s16(0,0,1),
+ };
- core::aabbox3d<f32> box;
-
- // bottom
- if(dir == v3s16(0,-1,0))
- {
- box = core::aabbox3d<f32>(
- npf - v3f(BS/6, BS/2, BS/6),
- npf + v3f(BS/6, -BS/2+BS/3*2, BS/6)
- );
- }
- // top
- else if(dir == v3s16(0,1,0))
- {
- box = core::aabbox3d<f32>(
- npf - v3f(BS/6, -BS/2+BS/3*2, BS/6),
- npf + v3f(BS/6, BS/2, BS/6)
- );
- }
- // side
- else
- {
- box = core::aabbox3d<f32>(
- cpf - v3f(BS/6, BS/3, BS/6),
- cpf + v3f(BS/6, BS/3, BS/6)
- );
- }
+ core::aabbox3d<f32> faceboxes[6] = {
+ // X-
+ core::aabbox3d<f32>(
+ box.MinEdge.X, box.MinEdge.Y, box.MinEdge.Z,
+ box.MinEdge.X+d, box.MaxEdge.Y, box.MaxEdge.Z
+ ),
+ // X+
+ core::aabbox3d<f32>(
+ box.MaxEdge.X-d, box.MinEdge.Y, box.MinEdge.Z,
+ box.MaxEdge.X, box.MaxEdge.Y, box.MaxEdge.Z
+ ),
+ // Y-
+ core::aabbox3d<f32>(
+ box.MinEdge.X, box.MinEdge.Y, box.MinEdge.Z,
+ box.MaxEdge.X, box.MinEdge.Y+d, box.MaxEdge.Z
+ ),
+ // Y+
+ core::aabbox3d<f32>(
+ box.MinEdge.X, box.MaxEdge.Y-d, box.MinEdge.Z,
+ box.MaxEdge.X, box.MaxEdge.Y, box.MaxEdge.Z
+ ),
+ // Z-
+ core::aabbox3d<f32>(
+ box.MinEdge.X, box.MinEdge.Y, box.MinEdge.Z,
+ box.MaxEdge.X, box.MaxEdge.Y, box.MinEdge.Z+d
+ ),
+ // Z+
+ core::aabbox3d<f32>(
+ box.MinEdge.X, box.MinEdge.Y, box.MaxEdge.Z-d,
+ box.MaxEdge.X, box.MaxEdge.Y, box.MaxEdge.Z
+ ),
+ };
- if(distance < mindistance)
+ for(u16 i=0; i<6; i++)
{
- if(box.intersectsWithLine(shootline))
- {
- nodefound = true;
- nodepos = np;
- neighbourpos = np;
- mindistance = distance;
- nodehilightbox = box;
- }
+ v3f facedir_f(facedirs[i].X, facedirs[i].Y, facedirs[i].Z);
+ v3f centerpoint = npf + facedir_f * BS/2;
+ f32 distance = (centerpoint - camera_position).getLength();
+ if(distance >= mindistance)
+ continue;
+ if(!faceboxes[i].intersectsWithLine(shootline))
+ continue;
+ result.type = POINTEDTHING_NODE;
+ result.node_undersurface = np;
+ result.node_abovesurface = np+facedirs[i];
+ mindistance = distance;
+ hilightbox = box;
+ should_show_hilightbox = true;
}
}
- else if(n.getContent() == CONTENT_SIGN_WALL)
+ else if(f.selection_box.type == NODEBOX_WALLMOUNTED)
{
- v3s16 dir = unpackDir(n.param2);
+ v3s16 dir = n.getWallMountedDir(nodedef);
v3f dir_f = v3f(dir.X, dir.Y, dir.Z);
dir_f *= BS/2 - BS/6 - BS/20;
v3f cpf = npf + dir_f;
f32 distance = (cpf - camera_position).getLength();
- v3f vertices[4] =
- {
- v3f(BS*0.42,-BS*0.35,-BS*0.4),
- v3f(BS*0.49, BS*0.35, BS*0.4),
- };
-
- for(s32 i=0; i<2; i++)
- {
- if(dir == v3s16(1,0,0))
- vertices[i].rotateXZBy(0);
- if(dir == v3s16(-1,0,0))
- vertices[i].rotateXZBy(180);
- if(dir == v3s16(0,0,1))
- vertices[i].rotateXZBy(90);
- if(dir == v3s16(0,0,-1))
- vertices[i].rotateXZBy(-90);
- if(dir == v3s16(0,-1,0))
- vertices[i].rotateXYBy(-90);
- if(dir == v3s16(0,1,0))
- vertices[i].rotateXYBy(90);
-
- vertices[i] += npf;
- }
-
core::aabbox3d<f32> box;
+
+ // top
+ if(dir == v3s16(0,1,0)){
+ box = f.selection_box.wall_top;
+ }
+ // bottom
+ else if(dir == v3s16(0,-1,0)){
+ box = f.selection_box.wall_bottom;
+ }
+ // side
+ else{
+ v3f vertices[2] =
+ {
+ f.selection_box.wall_side.MinEdge,
+ f.selection_box.wall_side.MaxEdge
+ };
- box = core::aabbox3d<f32>(vertices[0]);
- box.addInternalPoint(vertices[1]);
-
- if(distance < mindistance)
- {
- if(box.intersectsWithLine(shootline))
+ for(s32 i=0; i<2; i++)
{
- nodefound = true;
- nodepos = np;
- neighbourpos = np;
- mindistance = distance;
- nodehilightbox = box;
+ if(dir == v3s16(-1,0,0))
+ vertices[i].rotateXZBy(0);
+ if(dir == v3s16(1,0,0))
+ vertices[i].rotateXZBy(180);
+ if(dir == v3s16(0,0,-1))
+ vertices[i].rotateXZBy(90);
+ if(dir == v3s16(0,0,1))
+ vertices[i].rotateXZBy(-90);
}
- }
- }
- else if(n.getContent() == CONTENT_RAIL)
- {
- v3s16 dir = unpackDir(n.param0);
- v3f dir_f = v3f(dir.X, dir.Y, dir.Z);
- dir_f *= BS/2 - BS/6 - BS/20;
- v3f cpf = npf + dir_f;
- f32 distance = (cpf - camera_position).getLength();
-
- float d = (float)BS/16;
- v3f vertices[4] =
- {
- v3f(BS/2, -BS/2+d, -BS/2),
- v3f(-BS/2, -BS/2, BS/2),
- };
- for(s32 i=0; i<2; i++)
- {
- vertices[i] += npf;
+ box = core::aabbox3d<f32>(vertices[0]);
+ box.addInternalPoint(vertices[1]);
}
- core::aabbox3d<f32> box;
-
- box = core::aabbox3d<f32>(vertices[0]);
- box.addInternalPoint(vertices[1]);
-
+ box.MinEdge += npf;
+ box.MaxEdge += npf;
+
if(distance < mindistance)
{
if(box.intersectsWithLine(shootline))
{
- nodefound = true;
- nodepos = np;
- neighbourpos = np;
+ result.type = POINTEDTHING_NODE;
+ result.node_undersurface = np;
+ result.node_abovesurface = np;
mindistance = distance;
- nodehilightbox = box;
+ hilightbox = box;
+ should_show_hilightbox = true;
}
}
}
- /*
- Regular blocks
- */
- else
+ else // NODEBOX_REGULAR
{
for(u16 i=0; i<6; i++)
{
if(facebox.intersectsWithLine(shootline))
{
- nodefound = true;
- nodepos = np;
- neighbourpos = np + dirs[i];
+ result.type = POINTEDTHING_NODE;
+ result.node_undersurface = np;
+ result.node_abovesurface = np + dirs[i];
mindistance = distance;
- //nodehilightbox = facebox;
+ //hilightbox = facebox;
const float d = 0.502;
core::aabbox3d<f32> nodebox
(-BS*d, -BS*d, -BS*d, BS*d, BS*d, BS*d);
- v3f nodepos_f = intToFloat(nodepos, BS);
+ v3f nodepos_f = intToFloat(np, BS);
nodebox.MinEdge += nodepos_f;
nodebox.MaxEdge += nodepos_f;
- nodehilightbox = nodebox;
+ hilightbox = nodebox;
+ should_show_hilightbox = true;
}
} // if distance < mindistance
} // for dirs
} // regular block
} // for coords
+
+ return result;
}
-void update_skybox(video::IVideoDriver* driver,
+void update_skybox(video::IVideoDriver* driver, ITextureSource *tsrc,
scene::ISceneManager* smgr, scene::ISceneNode* &skybox,
float brightness)
{
}
/*// Disable skybox if FarMesh is enabled
- if(g_settings.getBool("enable_farmesh"))
+ if(g_settings->getBool("enable_farmesh"))
return;*/
if(brightness >= 0.5)
{
skybox = smgr->addSkyBoxSceneNode(
- driver->getTexture(getTexturePath("skybox2.png").c_str()),
- driver->getTexture(getTexturePath("skybox3.png").c_str()),
- driver->getTexture(getTexturePath("skybox1.png").c_str()),
- driver->getTexture(getTexturePath("skybox1.png").c_str()),
- driver->getTexture(getTexturePath("skybox1.png").c_str()),
- driver->getTexture(getTexturePath("skybox1.png").c_str()));
+ tsrc->getTextureRaw("skybox2.png"),
+ tsrc->getTextureRaw("skybox3.png"),
+ tsrc->getTextureRaw("skybox1.png"),
+ tsrc->getTextureRaw("skybox1.png"),
+ tsrc->getTextureRaw("skybox1.png"),
+ tsrc->getTextureRaw("skybox1.png"));
}
else if(brightness >= 0.2)
{
skybox = smgr->addSkyBoxSceneNode(
- driver->getTexture(getTexturePath("skybox2_dawn.png").c_str()),
- driver->getTexture(getTexturePath("skybox3_dawn.png").c_str()),
- driver->getTexture(getTexturePath("skybox1_dawn.png").c_str()),
- driver->getTexture(getTexturePath("skybox1_dawn.png").c_str()),
- driver->getTexture(getTexturePath("skybox1_dawn.png").c_str()),
- driver->getTexture(getTexturePath("skybox1_dawn.png").c_str()));
+ tsrc->getTextureRaw("skybox2_dawn.png"),
+ tsrc->getTextureRaw("skybox3_dawn.png"),
+ tsrc->getTextureRaw("skybox1_dawn.png"),
+ tsrc->getTextureRaw("skybox1_dawn.png"),
+ tsrc->getTextureRaw("skybox1_dawn.png"),
+ tsrc->getTextureRaw("skybox1_dawn.png"));
}
else
{
skybox = smgr->addSkyBoxSceneNode(
- driver->getTexture(getTexturePath("skybox2_night.png").c_str()),
- driver->getTexture(getTexturePath("skybox3_night.png").c_str()),
- driver->getTexture(getTexturePath("skybox1_night.png").c_str()),
- driver->getTexture(getTexturePath("skybox1_night.png").c_str()),
- driver->getTexture(getTexturePath("skybox1_night.png").c_str()),
- driver->getTexture(getTexturePath("skybox1_night.png").c_str()));
+ tsrc->getTextureRaw("skybox2_night.png"),
+ tsrc->getTextureRaw("skybox3_night.png"),
+ tsrc->getTextureRaw("skybox1_night.png"),
+ tsrc->getTextureRaw("skybox1_night.png"),
+ tsrc->getTextureRaw("skybox1_night.png"),
+ tsrc->getTextureRaw("skybox1_night.png"));
}
}
std::string password,
std::string address,
u16 port,
- std::wstring &error_message
+ std::wstring &error_message,
+ std::string configpath
)
{
video::IVideoDriver* driver = device->getVideoDriver();
/*
Draw "Loading" screen
*/
- /*gui::IGUIStaticText *gui_loadingtext = */
- //draw_load_screen(L"Loading and connecting...", driver, font);
draw_load_screen(L"Loading...", driver, font);
+ // Create texture source
+ IWritableTextureSource *tsrc = createTextureSource(device);
+
+ // These will be filled by data received from the server
+ // Create item definition manager
+ IWritableItemDefManager *itemdef = createItemDefManager();
+ // Create node definition manager
+ IWritableNodeDefManager *nodedef = createNodeDefManager();
+
+ // Add chat log output for errors to be shown in chat
+ LogOutputBuffer chat_log_error_buf(LMT_ERROR);
+
/*
Create server.
SharedPtr will delete it when it goes out of scope.
SharedPtr<Server> server;
if(address == ""){
draw_load_screen(L"Creating server...", driver, font);
- std::cout<<DTIME<<"Creating server"<<std::endl;
- server = new Server(map_dir);
+ infostream<<"Creating server"<<std::endl;
+ server = new Server(map_dir, configpath);
server->start(port);
}
+
+ { // Client scope
/*
Create client
*/
draw_load_screen(L"Creating client...", driver, font);
- std::cout<<DTIME<<"Creating client"<<std::endl;
- Client client(device, playername.c_str(), password, draw_control);
+ infostream<<"Creating client"<<std::endl;
+
+ MapDrawControl draw_control;
+
+ Client client(device, playername.c_str(), password, draw_control,
+ tsrc, itemdef, nodedef);
+
+ // Client acts as our GameDef
+ IGameDef *gamedef = &client;
draw_load_screen(L"Resolving address...", driver, font);
Address connect_address(0,0,0,0, port);
}
catch(ResolveError &e)
{
- std::cout<<DTIME<<"Couldn't resolve address"<<std::endl;
+ errorstream<<"Couldn't resolve address"<<std::endl;
//return 0;
error_message = L"Couldn't resolve address";
//gui_loadingtext->remove();
Attempt to connect to the server
*/
- dstream<<DTIME<<"Connecting to server at ";
- connect_address.print(&dstream);
- dstream<<std::endl;
+ infostream<<"Connecting to server at ";
+ connect_address.print(&infostream);
+ infostream<<std::endl;
client.connect(connect_address);
-
- bool could_connect = false;
+ /*
+ Wait for server to accept connection
+ */
+ bool could_connect = false;
try{
+ float frametime = 0.033;
+ const float timeout = 10.0;
float time_counter = 0.0;
for(;;)
{
- if(client.connectedAndInitialized())
- {
+ // Update client and server
+ client.step(frametime);
+ if(server != NULL)
+ server->step(frametime);
+
+ // End condition
+ if(client.connectedAndInitialized()){
could_connect = true;
break;
}
+ // Break conditions
if(client.accessDenied())
- {
break;
- }
- // Wait for 10 seconds
- if(time_counter >= 10.0)
- {
+ if(time_counter >= timeout)
break;
- }
+ // Display status
std::wostringstream ss;
ss<<L"Connecting to server... (timeout in ";
- ss<<(int)(10.0 - time_counter + 1.0);
+ ss<<(int)(timeout - time_counter + 1.0);
ss<<L" seconds)";
draw_load_screen(ss.str(), driver, font);
-
- /*// Update screen
- driver->beginScene(true, true, video::SColor(255,0,0,0));
- guienv->drawAll();
- driver->endScene();*/
-
- // Update client and server
-
- client.step(0.1);
-
- if(server != NULL)
- server->step(0.1);
// Delay a bit
- sleep_ms(100);
- time_counter += 0.1;
+ sleep_ms(1000*frametime);
+ time_counter += frametime;
}
}
catch(con::PeerNotFoundException &e)
{}
-
+
+ /*
+ Handle failure to connect
+ */
if(could_connect == false)
{
if(client.accessDenied())
{
error_message = L"Access denied. Reason: "
+client.accessDeniedReason();
- std::cout<<DTIME<<wide_to_narrow(error_message)<<std::endl;
+ errorstream<<wide_to_narrow(error_message)<<std::endl;
}
else
{
error_message = L"Connection timed out.";
- std::cout<<DTIME<<"Timed out."<<std::endl;
+ errorstream<<"Timed out."<<std::endl;
}
//gui_loadingtext->remove();
return;
}
+
+ /*
+ Wait until content has been received
+ */
+ bool got_content = false;
+ {
+ float frametime = 0.033;
+ const float timeout = 30.0;
+ float time_counter = 0.0;
+ for(;;)
+ {
+ // Update client and server
+ client.step(frametime);
+ if(server != NULL)
+ server->step(frametime);
+
+ // End condition
+ if(client.texturesReceived() &&
+ client.itemdefReceived() &&
+ client.nodedefReceived()){
+ got_content = true;
+ break;
+ }
+ // Break conditions
+ if(!client.connectedAndInitialized())
+ break;
+ if(time_counter >= timeout)
+ break;
+
+ // Display status
+ std::wostringstream ss;
+ ss<<L"Waiting content... (continuing anyway in ";
+ ss<<(int)(timeout - time_counter + 1.0);
+ ss<<L" seconds)\n";
+
+ ss<<(client.itemdefReceived()?L"[X]":L"[ ]");
+ ss<<L" Item definitions\n";
+ ss<<(client.nodedefReceived()?L"[X]":L"[ ]");
+ ss<<L" Node definitions\n";
+ //ss<<(client.texturesReceived()?L"[X]":L"[ ]");
+ ss<<L"["<<(int)(client.textureReceiveProgress()*100+0.5)<<L"%] ";
+ ss<<L" Textures\n";
+
+ draw_load_screen(ss.str(), driver, font);
+
+ // Delay a bit
+ sleep_ms(1000*frametime);
+ time_counter += frametime;
+ }
+ }
+
+ /*
+ After all content has been received:
+ Update cached textures, meshes and materials
+ */
+ client.afterContentReceived();
/*
Create skybox
*/
float old_brightness = 1.0;
scene::ISceneNode* skybox = NULL;
- update_skybox(driver, smgr, skybox, 1.0);
+ update_skybox(driver, tsrc, smgr, skybox, 1.0);
/*
Create the camera node
*/
-
- scene::ICameraSceneNode* camera = smgr->addCameraSceneNode(
- 0, // Camera parent
- v3f(BS*100, BS*2, BS*100), // Look from
- v3f(BS*100+1, BS*2, BS*100), // Look to
- -1 // Camera ID
- );
-
- if(camera == NULL)
- {
- error_message = L"Failed to create the camera node";
+ Camera camera(smgr, draw_control);
+ if (!camera.successfullyCreated(error_message))
return;
- }
-
- camera->setFOV(FOV_ANGLE);
- // Just so big a value that everything rendered is visible
- camera->setFarValue(100000*BS);
-
f32 camera_yaw = 0; // "right/left"
f32 camera_pitch = 0; // "up/down"
float cloud_height = BS*100;
Clouds *clouds = NULL;
- if(g_settings.getBool("enable_clouds"))
+ if(g_settings->getBool("enable_clouds"))
{
clouds = new Clouds(smgr->getRootSceneNode(), smgr, -1,
cloud_height, time(0));
*/
FarMesh *farmesh = NULL;
- if(g_settings.getBool("enable_farmesh"))
+ if(g_settings->getBool("enable_farmesh"))
{
farmesh = new FarMesh(smgr->getRootSceneNode(), smgr, -1, client.getMapSeed(), &client);
}
+ /*
+ A copy of the local inventory
+ */
+ Inventory local_inventory(itemdef);
+
/*
Move into game
*/
L"",
core::rect<s32>(5, 5+(text_height+5)*1, 795, (5+text_height)*2),
false, false);
-
// At the middle of the screen
// Object infos are shown in this
gui::IGUIStaticText *guitext_info = guienv->addStaticText(
//guitext_chat->setBackgroundColor(video::SColor(96,0,0,0));
core::list<ChatLine> chat_lines;
+ // Profiler text (size is updated when text is updated)
+ gui::IGUIStaticText *guitext_profiler = guienv->addStaticText(
+ L"<Profiler>",
+ core::rect<s32>(6, 4+(text_height+5)*2, 400,
+ (text_height+5)*2 + text_height*35),
+ false, false);
+ guitext_profiler->setBackgroundColor(video::SColor(80,0,0,0));
+ guitext_profiler->setVisible(false);
+
/*GUIQuickInventory *quick_inventory = new GUIQuickInventory
(guienv, NULL, v2s32(10, 70), 5, &local_inventory);*/
/*GUIQuickInventory *quick_inventory = new GUIQuickInventory
// A test
//throw con::PeerNotFoundException("lol");
+ float brightness = 1.0;
+
core::list<float> frametime_log;
+ float nodig_delay_timer = 0.0;
+ float dig_time = 0.0;
+ u16 dig_index = 0;
+ PointedThing pointed_old;
+ bool digging = false;
+ bool ldown_for_dig = false;
+
float damage_flash_timer = 0;
s16 farmesh_range = 20*MAP_BLOCKSIZE;
+
+ const float object_hit_delay = 0.2;
+ float object_hit_delay_timer = 0.0;
- bool invert_mouse = g_settings.getBool("invert_mouse");
+ bool invert_mouse = g_settings->getBool("invert_mouse");
+
+ bool respawn_menu_active = false;
+ bool update_wielded_item_trigger = false;
+
+ bool show_profiler = false;
+ bool force_fog_off = false;
+ bool disable_camera_update = false;
/*
Main loop
{
//std::cerr<<"frame"<<std::endl;
+ if(client.accessDenied())
+ {
+ error_message = L"Access denied. Reason: "
+ +client.accessDeniedReason();
+ errorstream<<wide_to_narrow(error_message)<<std::endl;
+ break;
+ }
+
if(g_gamecallback->disconnect_requested)
{
g_gamecallback->disconnect_requested = false;
/*
Process TextureSource's queue
*/
- ((TextureSource*)g_texturesource)->processQueue();
+ tsrc->processQueue();
/*
Random calculations
busytime = busytime_u32 / 1000.0;
}
- //std::cout<<"busytime_u32="<<busytime_u32<<std::endl;
+ //infostream<<"busytime_u32="<<busytime_u32<<std::endl;
// Necessary for device->getTimer()->getTime()
device->run();
- /*
- Viewing range
- */
-
- updateViewingRange(busytime, &client);
-
/*
FPS limiter
*/
{
- float fps_max = g_settings.getFloat("fps_max");
+ float fps_max = g_settings->getFloat("fps_max");
u32 frametime_min = 1000./fps_max;
if(busytime_u32 < frametime_min)
dtime = 0;
lasttime = time;
+ /* Run timers */
+
+ if(nodig_delay_timer >= 0)
+ nodig_delay_timer -= dtime;
+ if(object_hit_delay_timer >= 0)
+ object_hit_delay_timer -= dtime;
+
+ g_profiler->add("Elapsed time", dtime);
+ g_profiler->avg("FPS", 1./dtime);
+
/*
Log frametime for visualization
*/
Visualize frametime in terminal
*/
/*for(u32 i=0; i<dtime*400; i++)
- std::cout<<"X";
- std::cout<<std::endl;*/
+ infostream<<"X";
+ infostream<<std::endl;*/
/*
Time average and jitter calculation
if(counter < 0)
{
counter = 30.0;
- client.printDebugInfo(std::cout);
+ client.printDebugInfo(infostream);
}
}
Profiler
*/
float profiler_print_interval =
- g_settings.getFloat("profiler_print_interval");
- if(profiler_print_interval != 0)
+ g_settings->getFloat("profiler_print_interval");
+ bool print_to_log = true;
+ if(profiler_print_interval == 0){
+ print_to_log = false;
+ profiler_print_interval = 5;
+ }
+ if(m_profiler_interval.step(dtime, profiler_print_interval))
{
- if(m_profiler_interval.step(0.030, profiler_print_interval))
- {
- dstream<<"Profiler:"<<std::endl;
- g_profiler.print(dstream);
- g_profiler.clear();
+ if(print_to_log){
+ infostream<<"Profiler:"<<std::endl;
+ g_profiler->print(infostream);
}
+
+ std::ostringstream os(std::ios_base::binary);
+ g_profiler->print(os);
+ std::wstring text = narrow_to_wide(os.str());
+ guitext_profiler->setText(text.c_str());
+
+ g_profiler->clear();
+
+ s32 w = font->getDimension(text.c_str()).Width;
+ if(w < 400)
+ w = 400;
+ core::rect<s32> rect(6, 4+(text_height+5)*2, 12+w,
+ 8+(text_height+5)*2 +
+ font->getDimension(text.c_str()).Height);
+ guitext_profiler->setRelativePosition(rect);
}
/*
input->step(dtime);
/*
- Launch menus according to keys
+ Launch menus and trigger stuff according to keys
*/
- if(input->wasKeyDown(getKeySetting("keymap_inventory")))
+ if(input->wasKeyDown(getKeySetting("keymap_drop")))
{
- dstream<<DTIME<<"the_game: "
+ // drop selected item
+ IDropAction *a = new IDropAction();
+ a->count = 0;
+ a->from_inv.setCurrentPlayer();
+ a->from_list = "main";
+ a->from_i = client.getPlayerItem();
+ client.inventoryAction(a);
+ }
+ else if(input->wasKeyDown(getKeySetting("keymap_inventory")))
+ {
+ infostream<<"the_game: "
<<"Launching inventory"<<std::endl;
GUIInventoryMenu *menu =
new GUIInventoryMenu(guienv, guiroot, -1,
&g_menumgr, v2s16(8,7),
- client.getInventoryContext(),
- &client);
+ &client, gamedef);
+
+ InventoryLocation inventoryloc;
+ inventoryloc.setCurrentPlayer();
core::array<GUIInventoryMenu::DrawSpec> draw_spec;
draw_spec.push_back(GUIInventoryMenu::DrawSpec(
- "list", "current_player", "main",
+ "list", inventoryloc, "main",
v2s32(0, 3), v2s32(8, 4)));
draw_spec.push_back(GUIInventoryMenu::DrawSpec(
- "list", "current_player", "craft",
+ "list", inventoryloc, "craft",
v2s32(3, 0), v2s32(3, 3)));
draw_spec.push_back(GUIInventoryMenu::DrawSpec(
- "list", "current_player", "craftresult",
+ "list", inventoryloc, "craftpreview",
v2s32(7, 1), v2s32(1, 1)));
menu->setDrawSpec(draw_spec);
menu->drop();
}
- else if(input->wasKeyDown(KEY_ESCAPE))
+ else if(input->wasKeyDown(EscapeKey))
{
- dstream<<DTIME<<"the_game: "
+ infostream<<"the_game: "
<<"Launching pause menu"<<std::endl;
// It will delete itself by itself
(new GUIPauseMenu(guienv, guiroot, -1, g_gamecallback,
&g_menumgr, dest,
L""))->drop();
}
+ else if(input->wasKeyDown(getKeySetting("keymap_cmd")))
+ {
+ TextDest *dest = new TextDestChat(&client);
+
+ (new GUITextInputMenu(guienv, guiroot, -1,
+ &g_menumgr, dest,
+ L"/"))->drop();
+ }
else if(input->wasKeyDown(getKeySetting("keymap_freemove")))
{
- if(g_settings.getBool("free_move"))
+ if(g_settings->getBool("free_move"))
{
- g_settings.set("free_move","false");
+ g_settings->set("free_move","false");
chat_lines.push_back(ChatLine(L"free_move disabled"));
}
else
{
- g_settings.set("free_move","true");
+ g_settings->set("free_move","true");
chat_lines.push_back(ChatLine(L"free_move enabled"));
}
}
else if(input->wasKeyDown(getKeySetting("keymap_fastmove")))
{
- if(g_settings.getBool("fast_move"))
+ if(g_settings->getBool("fast_move"))
{
- g_settings.set("fast_move","false");
+ g_settings->set("fast_move","false");
chat_lines.push_back(ChatLine(L"fast_move disabled"));
}
else
{
- g_settings.set("fast_move","true");
+ g_settings->set("fast_move","true");
chat_lines.push_back(ChatLine(L"fast_move enabled"));
}
}
else if(input->wasKeyDown(getKeySetting("keymap_frametime_graph")))
{
- if(g_settings.getBool("frametime_graph"))
+ if(g_settings->getBool("frametime_graph"))
{
- g_settings.set("frametime_graph","false");
+ g_settings->set("frametime_graph","false");
chat_lines.push_back(ChatLine(L"frametime_graph disabled"));
}
else
{
- g_settings.set("frametime_graph","true");
+ g_settings->set("frametime_graph","true");
chat_lines.push_back(ChatLine(L"frametime_graph enabled"));
}
}
irr::video::IImage* const image = driver->createScreenShot();
if (image) {
irr::c8 filename[256];
- snprintf(filename, 256, "%s/screenshot_%u.png",
- g_settings.get("screenshot_path").c_str(),
+ snprintf(filename, 256, "%s" DIR_DELIM "screenshot_%u.png",
+ g_settings->get("screenshot_path").c_str(),
device->getTimer()->getRealTime());
if (driver->writeImageToFile(image, filename)) {
std::wstringstream sstr;
sstr<<"Saved screenshot to '"<<filename<<"'";
- dstream<<"Saved screenshot to '"<<filename<<"'"<<std::endl;
+ infostream<<"Saved screenshot to '"<<filename<<"'"<<std::endl;
chat_lines.push_back(ChatLine(sstr.str()));
} else{
- dstream<<"Failed to save screenshot '"<<filename<<"'"<<std::endl;
+ infostream<<"Failed to save screenshot '"<<filename<<"'"<<std::endl;
}
image->drop();
}
}
+ else if(input->wasKeyDown(getKeySetting("keymap_toggle_profiler")))
+ {
+ show_profiler = !show_profiler;
+ guitext_profiler->setVisible(show_profiler);
+ if(show_profiler)
+ chat_lines.push_back(ChatLine(L"Profiler disabled"));
+ else
+ chat_lines.push_back(ChatLine(L"Profiler enabled"));
+ }
+ else if(input->wasKeyDown(getKeySetting("keymap_toggle_force_fog_off")))
+ {
+ force_fog_off = !force_fog_off;
+ if(force_fog_off)
+ chat_lines.push_back(ChatLine(L"Fog disabled"));
+ else
+ chat_lines.push_back(ChatLine(L"Fog enabled"));
+ }
+ else if(input->wasKeyDown(getKeySetting("keymap_toggle_update_camera")))
+ {
+ disable_camera_update = !disable_camera_update;
+ if(disable_camera_update)
+ chat_lines.push_back(ChatLine(L"Camera update disabled"));
+ else
+ chat_lines.push_back(ChatLine(L"Camera update enabled"));
+ }
// Item selection with mouse wheel
+ u16 new_playeritem = client.getPlayerItem();
{
s32 wheel = input->getMouseWheel();
u16 max_item = MYMIN(PLAYER_INVENTORY_SIZE-1,
if(wheel < 0)
{
- if(g_selected_item < max_item)
- g_selected_item++;
+ if(new_playeritem < max_item)
+ new_playeritem++;
else
- g_selected_item = 0;
+ new_playeritem = 0;
}
else if(wheel > 0)
{
- if(g_selected_item > 0)
- g_selected_item--;
+ if(new_playeritem > 0)
+ new_playeritem--;
else
- g_selected_item = max_item;
+ new_playeritem = max_item;
}
}
// Item selection
for(u16 i=0; i<10; i++)
{
- s32 keycode = irr::KEY_KEY_1 + i;
- if(i == 9)
- keycode = irr::KEY_KEY_0;
- if(input->wasKeyDown((irr::EKEY_CODE)keycode))
+ const KeyPress *kp = NumberKey + (i + 1) % 10;
+ if(input->wasKeyDown(*kp))
{
if(i < PLAYER_INVENTORY_SIZE && i < hotbar_itemcount)
{
- g_selected_item = i;
+ new_playeritem = i;
- dstream<<DTIME<<"Selected item: "
- <<g_selected_item<<std::endl;
+ infostream<<"Selected item: "
+ <<new_playeritem<<std::endl;
}
}
}
if(draw_control.range_all)
{
draw_control.range_all = false;
- dstream<<DTIME<<"Disabled full viewing range"<<std::endl;
+ infostream<<"Disabled full viewing range"<<std::endl;
}
else
{
draw_control.range_all = true;
- dstream<<DTIME<<"Enabled full viewing range"<<std::endl;
+ infostream<<"Enabled full viewing range"<<std::endl;
}
}
debug_stacks_print();
}
+ /*
+ Mouse and camera control
+ NOTE: Do this before client.setPlayerControl() to not cause a camera lag of one frame
+ */
+
+ if((device->isWindowActive() && noMenuActive()) || random_input)
+ {
+ if(!random_input)
+ {
+ // Mac OSX gets upset if this is set every frame
+ if(device->getCursorControl()->isVisible())
+ device->getCursorControl()->setVisible(false);
+ }
+
+ if(first_loop_after_window_activation){
+ //infostream<<"window active, first loop"<<std::endl;
+ first_loop_after_window_activation = false;
+ }
+ else{
+ s32 dx = input->getMousePos().X - displaycenter.X;
+ s32 dy = input->getMousePos().Y - displaycenter.Y;
+ if(invert_mouse)
+ dy = -dy;
+ //infostream<<"window active, pos difference "<<dx<<","<<dy<<std::endl;
+
+ /*const float keyspeed = 500;
+ if(input->isKeyDown(irr::KEY_UP))
+ dy -= dtime * keyspeed;
+ if(input->isKeyDown(irr::KEY_DOWN))
+ dy += dtime * keyspeed;
+ if(input->isKeyDown(irr::KEY_LEFT))
+ dx -= dtime * keyspeed;
+ if(input->isKeyDown(irr::KEY_RIGHT))
+ dx += dtime * keyspeed;*/
+
+ camera_yaw -= dx*0.2;
+ camera_pitch += dy*0.2;
+ if(camera_pitch < -89.5) camera_pitch = -89.5;
+ if(camera_pitch > 89.5) camera_pitch = 89.5;
+ }
+ input->setMousePos(displaycenter.X, displaycenter.Y);
+ }
+ else{
+ // Mac OSX gets upset if this is set every frame
+ if(device->getCursorControl()->isVisible() == false)
+ device->getCursorControl()->setVisible(true);
+
+ //infostream<<"window inactive"<<std::endl;
+ first_loop_after_window_activation = true;
+ }
+
/*
Player speed control
- TODO: Cache the keycodes from getKeySetting
*/
+ if(!noMenuActive() || !device->isWindowActive())
+ {
+ PlayerControl control(
+ false,
+ false,
+ false,
+ false,
+ false,
+ false,
+ false,
+ camera_pitch,
+ camera_yaw
+ );
+ client.setPlayerControl(control);
+ }
+ else
{
/*bool a_up,
bool a_down,
//client.step(dtime_avg1);
}
- // Read client events
- for(;;)
{
- ClientEvent event = client.getClientEvent();
- if(event.type == CE_NONE)
+ // Read client events
+ for(;;)
{
- break;
- }
- else if(event.type == CE_PLAYER_DAMAGE)
- {
- //u16 damage = event.player_damage.amount;
- //dstream<<"Player damage: "<<damage<<std::endl;
- damage_flash_timer = 0.05;
- }
- else if(event.type == CE_PLAYER_FORCE_MOVE)
- {
- camera_yaw = event.player_force_move.yaw;
- camera_pitch = event.player_force_move.pitch;
+ ClientEvent event = client.getClientEvent();
+ if(event.type == CE_NONE)
+ {
+ break;
+ }
+ else if(event.type == CE_PLAYER_DAMAGE)
+ {
+ //u16 damage = event.player_damage.amount;
+ //infostream<<"Player damage: "<<damage<<std::endl;
+ damage_flash_timer = 0.05;
+ if(event.player_damage.amount >= 2){
+ damage_flash_timer += 0.05 * event.player_damage.amount;
+ }
+ }
+ else if(event.type == CE_PLAYER_FORCE_MOVE)
+ {
+ camera_yaw = event.player_force_move.yaw;
+ camera_pitch = event.player_force_move.pitch;
+ }
+ else if(event.type == CE_DEATHSCREEN)
+ {
+ if(respawn_menu_active)
+ continue;
+
+ /*bool set_camera_point_target =
+ event.deathscreen.set_camera_point_target;
+ v3f camera_point_target;
+ camera_point_target.X = event.deathscreen.camera_point_target_x;
+ camera_point_target.Y = event.deathscreen.camera_point_target_y;
+ camera_point_target.Z = event.deathscreen.camera_point_target_z;*/
+ MainRespawnInitiator *respawner =
+ new MainRespawnInitiator(
+ &respawn_menu_active, &client);
+ GUIDeathScreen *menu =
+ new GUIDeathScreen(guienv, guiroot, -1,
+ &g_menumgr, respawner);
+ menu->drop();
+
+ /* Handle visualization */
+
+ damage_flash_timer = 0;
+
+ /*LocalPlayer* player = client.getLocalPlayer();
+ player->setPosition(player->getPosition() + v3f(0,-BS,0));
+ camera.update(player, busytime, screensize);*/
+ }
+ else if(event.type == CE_TEXTURES_UPDATED)
+ {
+ update_skybox(driver, tsrc, smgr, skybox, brightness);
+
+ update_wielded_item_trigger = true;
+ }
}
}
- // Get player position
- v3f player_position = client.getPlayerPosition();
-
//TimeTaker //timer2("//timer2");
+ LocalPlayer* player = client.getLocalPlayer();
+ camera.update(player, busytime, screensize);
+ camera.step(dtime);
+
+ v3f player_position = player->getPosition();
+ v3f camera_position = camera.getPosition();
+ v3f camera_direction = camera.getDirection();
+ f32 camera_fov = camera.getFovMax();
+
+ if(!disable_camera_update){
+ client.updateCamera(camera_position,
+ camera_direction, camera_fov);
+ }
+
+ //timer2.stop();
+ //TimeTaker //timer3("//timer3");
+
/*
- Mouse and camera control
+ For interaction purposes, get info about the held item
+ - What item is it?
+ - Is it a usable item?
+ - Can it point to liquids?
*/
-
- if((device->isWindowActive() && noMenuActive()) || random_input)
+ ItemStack playeritem;
+ bool playeritem_usable = false;
+ bool playeritem_liquids_pointable = false;
{
- if(!random_input)
+ InventoryList *mlist = local_inventory.getList("main");
+ if(mlist != NULL)
{
- // Mac OSX gets upset if this is set every frame
- if(device->getCursorControl()->isVisible())
- device->getCursorControl()->setVisible(false);
+ playeritem = mlist->getItem(client.getPlayerItem());
+ playeritem_usable = playeritem.getDefinition(itemdef).usable;
+ playeritem_liquids_pointable = playeritem.getDefinition(itemdef).liquids_pointable;
}
-
- if(first_loop_after_window_activation){
- //std::cout<<"window active, first loop"<<std::endl;
- first_loop_after_window_activation = false;
- }
- else{
- s32 dx = input->getMousePos().X - displaycenter.X;
- s32 dy = input->getMousePos().Y - displaycenter.Y;
- if(invert_mouse)
- dy = -dy;
- //std::cout<<"window active, pos difference "<<dx<<","<<dy<<std::endl;
-
- /*const float keyspeed = 500;
- if(input->isKeyDown(irr::KEY_UP))
- dy -= dtime * keyspeed;
- if(input->isKeyDown(irr::KEY_DOWN))
- dy += dtime * keyspeed;
- if(input->isKeyDown(irr::KEY_LEFT))
- dx -= dtime * keyspeed;
- if(input->isKeyDown(irr::KEY_RIGHT))
- dx += dtime * keyspeed;*/
-
- camera_yaw -= dx*0.2;
- camera_pitch += dy*0.2;
- if(camera_pitch < -89.5) camera_pitch = -89.5;
- if(camera_pitch > 89.5) camera_pitch = 89.5;
- }
- input->setMousePos(displaycenter.X, displaycenter.Y);
- }
- else{
- // Mac OSX gets upset if this is set every frame
- if(device->getCursorControl()->isVisible() == false)
- device->getCursorControl()->setVisible(true);
-
- //std::cout<<"window inactive"<<std::endl;
- first_loop_after_window_activation = true;
}
- camera_yaw = wrapDegrees(camera_yaw);
- camera_pitch = wrapDegrees(camera_pitch);
-
- v3f camera_direction = v3f(0,0,1);
- camera_direction.rotateYZBy(camera_pitch);
- camera_direction.rotateXZBy(camera_yaw);
-
- // This is at the height of the eyes of the current figure
- //v3f camera_position = player_position + v3f(0, BS+BS/2, 0);
- // This is more like in minecraft
- v3f camera_position = player_position + v3f(0, BS+BS*0.625, 0);
-
- camera->setPosition(camera_position);
- // *100.0 helps in large map coordinates
- camera->setTarget(camera_position + camera_direction * 100.0);
-
- if(FIELD_OF_VIEW_TEST){
- client.updateCamera(v3f(0,0,0), v3f(0,0,1));
- }
- else{
- //TimeTaker timer("client.updateCamera");
- client.updateCamera(camera_position, camera_direction);
- }
-
- //timer2.stop();
- //TimeTaker //timer3("//timer3");
-
/*
Calculate what block is the crosshair pointing to
*/
//u32 t1 = device->getTimer()->getRealTime();
- //f32 d = 4; // max. distance
f32 d = 4; // max. distance
core::line3d<f32> shootline(camera_position,
camera_position + camera_direction * BS * (d+1));
- MapBlockObject *selected_object = client.getSelectedObject
- (d*BS, camera_position, shootline);
+ core::aabbox3d<f32> hilightbox;
+ bool should_show_hilightbox = false;
+ ClientActiveObject *selected_object = NULL;
- ClientActiveObject *selected_active_object
- = client.getSelectedActiveObject
- (d*BS, camera_position, shootline);
+ PointedThing pointed = getPointedThing(
+ // input
+ &client, player_position, camera_direction,
+ camera_position, shootline, d,
+ playeritem_liquids_pointable, !ldown_for_dig,
+ // output
+ hilightbox, should_show_hilightbox,
+ selected_object);
- if(selected_object != NULL)
+ if(pointed != pointed_old)
{
- //dstream<<"Client returned selected_object != NULL"<<std::endl;
-
- core::aabbox3d<f32> box_on_map
- = selected_object->getSelectionBoxOnMap();
-
- hilightboxes.push_back(box_on_map);
+ infostream<<"Pointing at "<<pointed.dump()<<std::endl;
+ //dstream<<"Pointing at "<<pointed.dump()<<std::endl;
+ }
- infotext = narrow_to_wide(selected_object->infoText());
+ /*
+ Visualize selection
+ */
+ if(should_show_hilightbox)
+ hilightboxes.push_back(hilightbox);
- if(input->getLeftClicked())
+ /*
+ Stop digging when
+ - releasing left mouse button
+ - pointing away from node
+ */
+ if(digging)
+ {
+ if(input->getLeftReleased())
{
- std::cout<<DTIME<<"Left-clicked object"<<std::endl;
- client.clickObject(0, selected_object->getBlock()->getPos(),
- selected_object->getId(), g_selected_item);
+ infostream<<"Left button released"
+ <<" (stopped digging)"<<std::endl;
+ digging = false;
}
- else if(input->getRightClicked())
+ else if(pointed != pointed_old)
{
- std::cout<<DTIME<<"Right-clicked object"<<std::endl;
- /*
- Check if we want to modify the object ourselves
- */
- if(selected_object->getTypeId() == MAPBLOCKOBJECT_TYPE_SIGN)
+ if (pointed.type == POINTEDTHING_NODE
+ && pointed_old.type == POINTEDTHING_NODE
+ && pointed.node_undersurface == pointed_old.node_undersurface)
{
- dstream<<"Sign object right-clicked"<<std::endl;
-
- if(random_input == false)
- {
- // Get a new text for it
-
- TextDest *dest = new TextDestSign(
- selected_object->getBlock()->getPos(),
- selected_object->getId(),
- &client);
-
- SignObject *sign_object = (SignObject*)selected_object;
-
- std::wstring wtext =
- narrow_to_wide(sign_object->getText());
-
- (new GUITextInputMenu(guienv, guiroot, -1,
- &g_menumgr, dest,
- wtext))->drop();
- }
+ // Still pointing to the same node,
+ // but a different face. Don't reset.
}
- /*
- Otherwise pass the event to the server as-is
- */
else
{
- client.clickObject(1, selected_object->getBlock()->getPos(),
- selected_object->getId(), g_selected_item);
+ infostream<<"Pointing away from node"
+ <<" (stopped digging)"<<std::endl;
+ digging = false;
}
}
- }
- else if(selected_active_object != NULL)
- {
- //dstream<<"Client returned selected_active_object != NULL"<<std::endl;
-
- core::aabbox3d<f32> *selection_box
- = selected_active_object->getSelectionBox();
- // Box should exist because object was returned in the
- // first place
- assert(selection_box);
-
- v3f pos = selected_active_object->getPosition();
-
- core::aabbox3d<f32> box_on_map(
- selection_box->MinEdge + pos,
- selection_box->MaxEdge + pos
- );
-
- hilightboxes.push_back(box_on_map);
-
- //infotext = narrow_to_wide("A ClientActiveObject");
- infotext = narrow_to_wide(selected_active_object->infoText());
-
- if(input->getLeftClicked())
- {
- std::cout<<DTIME<<"Left-clicked object"<<std::endl;
- client.clickActiveObject(0,
- selected_active_object->getId(), g_selected_item);
- }
- else if(input->getRightClicked())
+ if(!digging)
{
- std::cout<<DTIME<<"Right-clicked object"<<std::endl;
- client.clickActiveObject(1,
- selected_active_object->getId(), g_selected_item);
+ client.interact(1, pointed_old);
+ client.clearTempMod(pointed_old.node_undersurface);
+ dig_time = 0.0;
}
}
- else // selected_object == NULL
+ if(!digging && ldown_for_dig && !input->getLeftState())
{
+ ldown_for_dig = false;
+ }
- /*
- Find out which node we are pointing at
- */
-
- bool nodefound = false;
- v3s16 nodepos;
- v3s16 neighbourpos;
- core::aabbox3d<f32> nodehilightbox;
-
- getPointedNode(&client, player_position,
- camera_direction, camera_position,
- nodefound, shootline,
- nodepos, neighbourpos,
- nodehilightbox, d);
-
- static float nodig_delay_counter = 0.0;
+ bool left_punch = false;
+ bool left_punch_muted = false;
- if(nodefound)
+ if(playeritem_usable && input->getLeftState())
{
- static v3s16 nodepos_old(-32768,-32768,-32768);
-
- static float dig_time = 0.0;
- static u16 dig_index = 0;
-
- /*
- Visualize selection
- */
-
- hilightboxes.push_back(nodehilightbox);
+ if(input->getLeftClicked())
+ client.interact(4, pointed);
+ }
+ else if(pointed.type == POINTEDTHING_NODE)
+ {
+ v3s16 nodepos = pointed.node_undersurface;
+ v3s16 neighbourpos = pointed.node_abovesurface;
/*
Check information text of node
{
infotext = narrow_to_wide(meta->infoText());
}
+ else
+ {
+ MapNode n = client.getNode(nodepos);
+ if(nodedef->get(n).tname_tiles[0] == "unknown_block.png"){
+ infotext = L"Unknown node: ";
+ infotext += narrow_to_wide(nodedef->get(n).name);
+ }
+ }
- //MapNode node = client.getNode(nodepos);
-
/*
Handle digging
*/
- if(input->getLeftReleased())
- {
- client.clearTempMod(nodepos);
- dig_time = 0.0;
- }
- if(nodig_delay_counter > 0.0)
- {
- nodig_delay_counter -= dtime;
- }
- else
+ if(nodig_delay_timer <= 0.0 && input->getLeftState())
{
- if(nodepos != nodepos_old)
+ if(!digging)
{
- std::cout<<DTIME<<"Pointing at ("<<nodepos.X<<","
- <<nodepos.Y<<","<<nodepos.Z<<")"<<std::endl;
+ infostream<<"Started digging"<<std::endl;
+ client.interact(0, pointed);
+ digging = true;
+ ldown_for_dig = true;
+ }
+ MapNode n = client.getNode(nodepos);
- if(nodepos_old != v3s16(-32768,-32768,-32768))
- {
- client.clearTempMod(nodepos_old);
- dig_time = 0.0;
- }
+ // Get digging properties for material and tool
+ MaterialProperties mp = nodedef->get(n.getContent()).material;
+ ToolDiggingProperties tp =
+ playeritem.getToolDiggingProperties(itemdef);
+ DiggingProperties prop = getDiggingProperties(&mp, &tp);
+
+ float dig_time_complete = 0.0;
+
+ if(prop.diggable == false)
+ {
+ // I guess nobody will wait for this long
+ dig_time_complete = 10000000.0;
+ }
+ else
+ {
+ dig_time_complete = prop.time;
}
- if(input->getLeftClicked() ||
- (input->getLeftState() && nodepos != nodepos_old))
+ if(dig_time_complete >= 0.001)
{
- dstream<<DTIME<<"Started digging"<<std::endl;
- client.groundAction(0, nodepos, neighbourpos, g_selected_item);
+ dig_index = (u16)((float)CRACK_ANIMATION_LENGTH
+ * dig_time/dig_time_complete);
}
- if(input->getLeftClicked())
+ // This is for torches
+ else
{
- client.setTempMod(nodepos, NodeMod(NODEMOD_CRACK, 0));
+ dig_index = CRACK_ANIMATION_LENGTH;
}
- if(input->getLeftState())
+
+ if(dig_index < CRACK_ANIMATION_LENGTH)
{
- MapNode n = client.getNode(nodepos);
-
- // Get tool name. Default is "" = bare hands
- std::string toolname = "";
- InventoryList *mlist = local_inventory.getList("main");
- if(mlist != NULL)
- {
- InventoryItem *item = mlist->getItem(g_selected_item);
- if(item && (std::string)item->getName() == "ToolItem")
- {
- ToolItem *titem = (ToolItem*)item;
- toolname = titem->getToolName();
- }
- }
+ //TimeTaker timer("client.setTempMod");
+ //infostream<<"dig_index="<<dig_index<<std::endl;
+ client.setTempMod(nodepos, NodeMod(NODEMOD_CRACK, dig_index));
+ }
+ else
+ {
+ infostream<<"Digging completed"<<std::endl;
+ client.interact(2, pointed);
+ client.clearTempMod(nodepos);
+ client.removeNode(nodepos);
- // Get digging properties for material and tool
- content_t material = n.getContent();
- DiggingProperties prop =
- getDiggingProperties(material, toolname);
-
- float dig_time_complete = 0.0;
+ dig_time = 0;
+ digging = false;
- if(prop.diggable == false)
- {
- /*dstream<<"Material "<<(int)material
- <<" not diggable with \""
- <<toolname<<"\""<<std::endl;*/
- // I guess nobody will wait for this long
- dig_time_complete = 10000000.0;
- }
- else
- {
- dig_time_complete = prop.time;
- }
-
- if(dig_time_complete >= 0.001)
- {
- dig_index = (u16)((float)CRACK_ANIMATION_LENGTH
- * dig_time/dig_time_complete);
- }
- // This is for torches
- else
- {
- dig_index = CRACK_ANIMATION_LENGTH;
- }
+ nodig_delay_timer = dig_time_complete
+ / (float)CRACK_ANIMATION_LENGTH;
- if(dig_index < CRACK_ANIMATION_LENGTH)
+ // We don't want a corresponding delay to
+ // very time consuming nodes
+ if(nodig_delay_timer > 0.5)
{
- //TimeTaker timer("client.setTempMod");
- //dstream<<"dig_index="<<dig_index<<std::endl;
- client.setTempMod(nodepos, NodeMod(NODEMOD_CRACK, dig_index));
+ nodig_delay_timer = 0.5;
}
- else
+ // We want a slight delay to very little
+ // time consuming nodes
+ float mindelay = 0.15;
+ if(nodig_delay_timer < mindelay)
{
- dstream<<DTIME<<"Digging completed"<<std::endl;
- client.groundAction(3, nodepos, neighbourpos, g_selected_item);
- client.clearTempMod(nodepos);
- client.removeNode(nodepos);
-
- dig_time = 0;
-
- nodig_delay_counter = dig_time_complete
- / (float)CRACK_ANIMATION_LENGTH;
-
- // We don't want a corresponding delay to
- // very time consuming nodes
- if(nodig_delay_counter > 0.5)
- {
- nodig_delay_counter = 0.5;
- }
- // We want a slight delay to very little
- // time consuming nodes
- float mindelay = 0.15;
- if(nodig_delay_counter < mindelay)
- {
- nodig_delay_counter = mindelay;
- }
+ nodig_delay_timer = mindelay;
}
-
- dig_time += dtime;
}
+
+ dig_time += dtime;
+
+ camera.setDigging(0); // left click animation
}
-
+
if(input->getRightClicked())
{
- std::cout<<DTIME<<"Ground right-clicked"<<std::endl;
+ infostream<<"Ground right-clicked"<<std::endl;
// If metadata provides an inventory view, activate it
if(meta && meta->getInventoryDrawSpecString() != "" && !random_input)
{
- dstream<<DTIME<<"Launching custom inventory view"<<std::endl;
- /*
- Construct the unique identification string of the node
- */
- std::string current_name;
- current_name += "nodemeta:";
- current_name += itos(nodepos.X);
- current_name += ",";
- current_name += itos(nodepos.Y);
- current_name += ",";
- current_name += itos(nodepos.Z);
+ infostream<<"Launching custom inventory view"<<std::endl;
+
+ InventoryLocation inventoryloc;
+ inventoryloc.setNodeMeta(nodepos);
+
/*
Create menu
*/
GUIInventoryMenu::makeDrawSpecArrayFromString(
draw_spec,
meta->getInventoryDrawSpecString(),
- current_name);
+ inventoryloc);
GUIInventoryMenu *menu =
new GUIInventoryMenu(guienv, guiroot, -1,
&g_menumgr, invsize,
- client.getInventoryContext(),
- &client);
+ &client, gamedef);
menu->setDrawSpec(draw_spec);
menu->drop();
}
- else if(meta && meta->typeId() == CONTENT_SIGN_WALL && !random_input)
+ // If metadata provides text input, activate text input
+ else if(meta && meta->allowsTextInput() && !random_input)
{
- dstream<<"Sign node right-clicked"<<std::endl;
-
- SignNodeMetadata *signmeta = (SignNodeMetadata*)meta;
+ infostream<<"Launching metadata text input"<<std::endl;
// Get a new text for it
- TextDest *dest = new TextDestSignNode(nodepos, &client);
+ TextDest *dest = new TextDestNodeMetadata(nodepos, &client);
- std::wstring wtext =
- narrow_to_wide(signmeta->getText());
+ std::wstring wtext = narrow_to_wide(meta->getText());
(new GUITextInputMenu(guienv, guiroot, -1,
&g_menumgr, dest,
wtext))->drop();
}
+ // Otherwise report right click to server
else
{
- client.groundAction(1, nodepos, neighbourpos, g_selected_item);
+ client.interact(3, pointed);
+ camera.setDigging(1); // right click animation
}
}
-
- nodepos_old = nodepos;
}
- else{
+ else if(pointed.type == POINTEDTHING_OBJECT)
+ {
+ infotext = narrow_to_wide(selected_object->infoText());
+
+ //if(input->getLeftClicked())
+ if(input->getLeftState())
+ {
+ bool do_punch = false;
+ bool do_punch_damage = false;
+ if(object_hit_delay_timer <= 0.0){
+ do_punch = true;
+ do_punch_damage = true;
+ object_hit_delay_timer = object_hit_delay;
+ }
+ if(input->getLeftClicked()){
+ do_punch = true;
+ }
+ if(do_punch){
+ infostream<<"Left-clicked object"<<std::endl;
+ left_punch = true;
+ }
+ if(do_punch_damage){
+ // Report direct punch
+ v3f objpos = selected_object->getPosition();
+ v3f dir = (objpos - player_position).normalize();
+
+ bool disable_send = selected_object->directReportPunch(playeritem.name, dir);
+ if(!disable_send)
+ client.interact(0, pointed);
+ }
+ }
+ else if(input->getRightClicked())
+ {
+ infostream<<"Right-clicked object"<<std::endl;
+ client.interact(3, pointed); // place
+ }
}
- } // selected_object == NULL
-
- input->resetLeftClicked();
- input->resetRightClicked();
+ pointed_old = pointed;
- if(input->getLeftReleased())
+ if(left_punch || (input->getLeftClicked() && !left_punch_muted))
{
- std::cout<<DTIME<<"Left button released (stopped digging)"
- <<std::endl;
- client.groundAction(2, v3s16(0,0,0), v3s16(0,0,0), 0);
+ camera.setDigging(0); // left click animation
}
- if(input->getRightReleased())
- {
- //std::cout<<DTIME<<"Right released"<<std::endl;
- // Nothing here
- }
-
+
+ input->resetLeftClicked();
+ input->resetRightClicked();
+
input->resetLeftReleased();
input->resetRightReleased();
/*
Calculate stuff for drawing
*/
-
- camera->setAspectRatio((f32)screensize.X / (f32)screensize.Y);
+ /*
+ Calculate general brightness
+ */
u32 daynight_ratio = client.getDayNightRatio();
- u8 l = decode_light((daynight_ratio * LIGHT_SUN) / 1000);
+ u8 light8 = decode_light((daynight_ratio * LIGHT_SUN) / 1000);
+ brightness = (float)light8/255.0;
video::SColor bgcolor = video::SColor(
255,
- bgcolor_bright.getRed() * l / 255,
- bgcolor_bright.getGreen() * l / 255,
- bgcolor_bright.getBlue() * l / 255);
- /*skycolor.getRed() * l / 255,
- skycolor.getGreen() * l / 255,
- skycolor.getBlue() * l / 255);*/
-
- float brightness = (float)l/255.0;
+ bgcolor_bright.getRed() * brightness,
+ bgcolor_bright.getGreen() * brightness,
+ bgcolor_bright.getBlue() * brightness);
+ /*skycolor.getRed() * brightness,
+ skycolor.getGreen() * brightness,
+ skycolor.getBlue() * brightness);*/
/*
Update skybox
*/
if(fabs(brightness - old_brightness) > 0.01)
- update_skybox(driver, smgr, skybox, brightness);
+ update_skybox(driver, tsrc, smgr, skybox, brightness);
/*
- Update coulds
+ Update clouds
*/
if(clouds)
{
*/
if(farmesh)
{
+ farmesh_range = draw_control.wanted_range * 10;
+ if(draw_control.range_all && farmesh_range < 500)
+ farmesh_range = 500;
+ if(farmesh_range > 1000)
+ farmesh_range = 1000;
+
farmesh->step(dtime);
farmesh->update(v2f(player_position.X, player_position.Z),
- 0.05+brightness*0.95);
+ 0.05+brightness*0.95, farmesh_range);
}
// Store brightness value
Fog
*/
- if(g_settings.getBool("enable_fog") == true)
+ if(g_settings->getBool("enable_fog") == true && !force_fog_off)
{
f32 range;
if(farmesh)
else
{
range = draw_control.wanted_range*BS + MAP_BLOCKSIZE*BS*1.5;
+ range *= 0.9;
if(draw_control.range_all)
range = 100000*BS;
- if(range < 50*BS)
- range = range * 0.5 + 25*BS;
+ /*if(range < 50*BS)
+ range = range * 0.5 + 25*BS;*/
}
driver->setFog(
);
}
-
/*
Update gui stuff (0ms)
*/
"(% .1f, % .1f, % .1f)"
" (% .3f < btime_jitter < % .3f"
", dtime_jitter = % .1f %%"
- ", v_range = %.1f)",
+ ", v_range = %.1f, RTT = %.3f)",
player_position.X/BS,
player_position.Y/BS,
player_position.Z/BS,
busytime_jitter1_min_sample,
busytime_jitter1_max_sample,
dtime_jitter1_max_fraction * 100.0,
- draw_control.wanted_range
+ draw_control.wanted_range,
+ client.getRTT()
);
guitext2->setText(narrow_to_wide(temptext).c_str());
Get chat messages from client
*/
{
- // Get new messages
+ // Get new messages from error log buffer
+ while(!chat_log_error_buf.empty())
+ {
+ chat_lines.push_back(ChatLine(narrow_to_wide(
+ chat_log_error_buf.get())));
+ }
+ // Get new messages from client
std::wstring message;
while(client.getChatMessage(message))
{
guitext_chat->setRelativePosition(rect);
- if(chat_lines.size() == 0)
+ // Don't show chat if empty or profiler is enabled
+ if(chat_lines.size() == 0 || show_profiler)
guitext_chat->setVisible(false);
else
guitext_chat->setVisible(true);
Inventory
*/
- static u16 old_selected_item = 65535;
- if(client.getLocalInventoryUpdated()
- || g_selected_item != old_selected_item)
+ if(client.getPlayerItem() != new_playeritem)
+ {
+ client.selectPlayerItem(new_playeritem);
+ }
+ if(client.getLocalInventoryUpdated())
{
- old_selected_item = g_selected_item;
- //std::cout<<"Updating local inventory"<<std::endl;
+ //infostream<<"Updating local inventory"<<std::endl;
client.getLocalInventory(local_inventory);
+
+ update_wielded_item_trigger = true;
}
-
- /*
- Send actions returned by the inventory menu
- */
- while(inventory_action_queue.size() != 0)
+ if(update_wielded_item_trigger)
{
- InventoryAction *a = inventory_action_queue.pop_front();
-
- client.sendInventoryAction(a);
- // Eat it
- delete a;
+ update_wielded_item_trigger = false;
+ // Update wielded tool
+ InventoryList *mlist = local_inventory.getList("main");
+ ItemStack item;
+ if(mlist != NULL)
+ item = mlist->getItem(client.getPlayerItem());
+ camera.wield(item, gamedef);
}
-
+
/*
Drawing begins
*/
//timer3.stop();
- //std::cout<<DTIME<<"smgr->drawAll()"<<std::endl;
+ //infostream<<"smgr->drawAll()"<<std::endl;
{
TimeTaker timer("smgr");
for(core::list< core::aabbox3d<f32> >::Iterator i=hilightboxes.begin();
i != hilightboxes.end(); i++)
{
- /*std::cout<<"hilightbox min="
+ /*infostream<<"hilightbox min="
<<"("<<i->MinEdge.X<<","<<i->MinEdge.Y<<","<<i->MinEdge.Z<<")"
<<" max="
<<"("<<i->MaxEdge.X<<","<<i->MaxEdge.Y<<","<<i->MaxEdge.Z<<")"
driver->draw3DBox(*i, video::SColor(255,0,0,0));
}
+ /*
+ Wielded tool
+ */
+ {
+ // Warning: This clears the Z buffer.
+ camera.drawWieldedTool();
+ }
+
+ /*
+ Post effects
+ */
+ {
+ client.renderPostFx();
+ }
+
/*
Frametime log
*/
- if(g_settings.getBool("frametime_graph") == true)
+ if(g_settings->getBool("frametime_graph") == true)
{
s32 x = 10;
for(core::list<float>::Iterator
Draw hotbar
*/
{
- draw_hotbar(driver, font, v2s32(displaycenter.X, screensize.Y),
+ draw_hotbar(driver, font, gamedef,
+ v2s32(displaycenter.X, screensize.Y),
hotbar_imagesize, hotbar_itemcount, &local_inventory,
- client.getHP());
+ client.getHP(), client.getPlayerItem());
}
/*
NULL);
}
- /*
- Environment post fx
- */
- {
- client.getEnv()->drawPostFx(driver, camera_position);
- }
-
/*
End scene
*/
driver->endScene();
gui_shuttingdowntext->remove();*/
}
+
+ } // Client scope (must be destructed before destructing *def and tsrc
+
+ delete tsrc;
+ delete nodedef;
+ delete itemdef;
}