Copyright (C) 2010-2011 celeron55, Perttu Ahola <celeron55@gmail.com>
This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation; either version 2.1 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-GNU General Public License for more details.
+GNU Lesser General Public License for more details.
-You should have received a copy of the GNU General Public License along
+You should have received a copy of the GNU Lesser General Public License along
with this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
#include "game.h"
-#include "common_irrlicht.h"
+#include "irrlichttypes_extrabloated.h"
#include <IGUICheckBox.h>
#include <IGUIEditBox.h>
#include <IGUIButton.h>
#include "server.h"
#include "guiPauseMenu.h"
#include "guiPasswordChange.h"
-#include "guiInventoryMenu.h"
+#include "guiFormSpecMenu.h"
#include "guiTextInputMenu.h"
#include "guiDeathScreen.h"
-#include "materials.h"
+#include "tool.h"
+#include "guiChatConsole.h"
#include "config.h"
#include "clouds.h"
#include "camera.h"
#include "gettext.h"
#include "log.h"
#include "filesys.h"
-// Needed for some special cases for CONTENT_TORCH and CONTENT_SIGN_WALL
-// TODO: A generic way for handling such should be created
-#include "content_mapnode.h"
-// Needed for sign text input
-// TODO: A generic way for handling such should be created
-#include "content_nodemeta.h"
// Needed for determining pointing to nodes
-#include "mapnode_contentfeatures.h"
-
-/*
- Setting this to 1 enables a special camera mode that forces
- the renderers to think that the camera statically points from
- the starting place to a static direction.
-
- This allows one to move around with the player and see what
- is actually drawn behind solid things and behind the player.
-*/
-#define FIELD_OF_VIEW_TEST 0
-
-
-// Chat data
-struct ChatLine
-{
- ChatLine():
- age(0.0)
- {
- }
- ChatLine(const std::wstring &a_text):
- age(0.0),
- text(a_text)
- {
- }
- float age;
- 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;
+#include "nodedef.h"
+#include "nodemetadata.h"
+#include "main.h" // For g_settings
+#include "itemdef.h"
+#include "tile.h" // For TextureSource
+#include "logoutputbuffer.h"
+#include "subgame.h"
+#include "quicktune_shortcutter.h"
+#include "clientmap.h"
+#include "sky.h"
+#include "sound.h"
+#if USE_SOUND
+ #include "sound_openal.h"
+#endif
+#include "event_manager.h"
+#include <list>
+#include "util/directiontables.h"
/*
Text input system
}
void gotText(std::wstring text)
{
- // Discard empty line
- if(text == L"")
- return;
-
- // Send to others
- m_client->sendChatMessage(text);
- // Show locally
- m_client->addChatMessage(text);
+ m_client->typeChatMessage(text);
+ }
+ void gotText(std::map<std::string, std::string> fields)
+ {
+ m_client->typeChatMessage(narrow_to_wide(fields["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;
}
+ // This is deprecated I guess? -celeron55
void gotText(std::wstring text)
{
std::string ntext = wide_to_narrow(text);
- infostream<<"Changing text of a sign node: "
- <<ntext<<std::endl;
- m_client->sendSignNodeText(m_p, ntext);
+ infostream<<"Submitting 'text' field of node at ("<<m_p.X<<","
+ <<m_p.Y<<","<<m_p.Z<<"): "<<ntext<<std::endl;
+ std::map<std::string, std::string> fields;
+ fields["text"] = ntext;
+ m_client->sendNodemetaFields(m_p, "", fields);
+ }
+ void gotText(std::map<std::string, std::string> fields)
+ {
+ m_client->sendNodemetaFields(m_p, "", fields);
}
v3s16 m_p;
Client *m_client;
};
+struct TextDestPlayerInventory : public TextDest
+{
+ TextDestPlayerInventory(Client *client)
+ {
+ m_client = client;
+ }
+ void gotText(std::map<std::string, std::string> fields)
+ {
+ m_client->sendInventoryFields("", fields);
+ }
+
+ Client *m_client;
+};
+
/* Respawn menu callback */
class MainRespawnInitiator: public IRespawnInitiator
Client *m_client;
};
+/* Form update callback */
+
+class NodeMetadataFormSource: public IFormSource
+{
+public:
+ NodeMetadataFormSource(ClientMap *map, v3s16 p):
+ m_map(map),
+ m_p(p)
+ {
+ }
+ std::string getForm()
+ {
+ NodeMetadata *meta = m_map->getNodeMetadata(m_p);
+ if(!meta)
+ return "";
+ return meta->getString("formspec");
+ }
+ std::string resolveText(std::string str)
+ {
+ NodeMetadata *meta = m_map->getNodeMetadata(m_p);
+ if(!meta)
+ return str;
+ return meta->resolveString(str);
+ }
+
+ ClientMap *m_map;
+ v3s16 m_p;
+};
+
+class PlayerInventoryFormSource: public IFormSource
+{
+public:
+ PlayerInventoryFormSource(Client *client):
+ m_client(client)
+ {
+ }
+ std::string getForm()
+ {
+ LocalPlayer* player = m_client->getEnv().getLocalPlayer();
+ return player->inventory_formspec;
+ }
+
+ 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)
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)
+ if(playeritem == i)
{
video::SColor c_outside(255,255,0,0);
//video::SColor c_outside(255,0,0,0);
video::SColor bgcolor2(128,0,0,0);
driver->draw2DRectangle(bgcolor2, rect, NULL);
-
- if(item != NULL)
- {
- drawInventoryItem(driver, font, item, 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,
+ std::vector<aabb3f> &hilightboxes,
+ ClientActiveObject *&selected_object)
{
+ PointedThing result;
+
+ hilightboxes.clear();
+ selected_object = NULL;
+
+ INodeDefManager *nodedef = client->getNodeDefManager();
+ ClientMap &map = client->getEnv().getClientMap();
+
+ // 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)
+ {
+ if(selected_object->doShowSelectionBox())
+ {
+ aabb3f *selection_box = selected_object->getSelectionBox();
+ // Box should exist because object was
+ // returned in the first place
+ assert(selection_box);
+
+ v3f pos = selected_object->getPosition();
+ hilightboxes.push_back(aabb3f(
+ selection_box->MinEdge + pos,
+ selection_box->MaxEdge + pos));
+ }
+
+
+ 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);
s16 zend = pos_i.Z + (camera_direction.Z>0 ? a : 1);
s16 xend = pos_i.X + (camera_direction.X>0 ? a : 1);
+ // Prevent signed number overflow
+ if(yend==32767)
+ yend=32766;
+ if(zend==32767)
+ zend=32766;
+ if(xend==32767)
+ xend=32766;
+
for(s16 y = ystart; y <= yend; y++)
for(s16 z = zstart; z <= zend; z++)
for(s16 x = xstart; x <= xend; x++)
MapNode n;
try
{
- n = client->getNode(v3s16(x,y,z));
- if(content_pointable(n.getContent()) == false)
- continue;
+ n = map.getNode(v3s16(x,y,z));
}
catch(InvalidPositionException &e)
{
continue;
}
+ if(!isPointableNode(n, client, liquids_pointable))
+ continue;
+
+ std::vector<aabb3f> boxes = n.getSelectionBoxes(nodedef);
v3s16 np(x,y,z);
v3f npf = intToFloat(np, BS);
-
- f32 d = 0.01;
-
- v3s16 dirs[6] = {
- v3s16(0,0,1), // back
- v3s16(0,1,0), // top
- v3s16(1,0,0), // right
- v3s16(0,0,-1), // front
- v3s16(0,-1,0), // bottom
- 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();
-
- 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)
- );
- }
-
- if(distance < mindistance)
- {
- if(box.intersectsWithLine(shootline))
- {
- nodefound = true;
- nodepos = np;
- neighbourpos = np;
- mindistance = distance;
- nodehilightbox = box;
- }
- }
- }
- else if(n.getContent() == CONTENT_SIGN_WALL)
- {
- 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();
-
- 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;
-
- box = core::aabbox3d<f32>(vertices[0]);
- box.addInternalPoint(vertices[1]);
-
- if(distance < mindistance)
- {
- if(box.intersectsWithLine(shootline))
- {
- nodefound = true;
- nodepos = np;
- neighbourpos = np;
- mindistance = distance;
- nodehilightbox = box;
- }
- }
- }
-
- else if(n.getContent() == CONTENT_LADDER)
- {
- 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();
-
- v3f vertices[4] =
- {
- v3f(BS*0.42,-BS/2,-BS/2),
- v3f(BS*0.49, BS/2, BS/2),
- };
-
- 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;
- box = core::aabbox3d<f32>(vertices[0]);
- box.addInternalPoint(vertices[1]);
-
- if(distance < mindistance)
- {
- if(box.intersectsWithLine(shootline))
- {
- nodefound = true;
- nodepos = np;
- neighbourpos = np;
- mindistance = distance;
- nodehilightbox = box;
- }
- }
- }
- else if(n.getContent() == CONTENT_RAIL)
+ for(std::vector<aabb3f>::const_iterator
+ i = boxes.begin();
+ i != boxes.end(); i++)
{
- 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),
- };
+ aabb3f box = *i;
+ box.MinEdge += npf;
+ box.MaxEdge += npf;
- for(s32 i=0; i<2; i++)
+ for(u16 j=0; j<6; j++)
{
- vertices[i] += npf;
- }
+ v3s16 facedir = g_6dirs[j];
+ aabb3f facebox = box;
+
+ f32 d = 0.001*BS;
+ if(facedir.X > 0)
+ facebox.MinEdge.X = facebox.MaxEdge.X-d;
+ else if(facedir.X < 0)
+ facebox.MaxEdge.X = facebox.MinEdge.X+d;
+ else if(facedir.Y > 0)
+ facebox.MinEdge.Y = facebox.MaxEdge.Y-d;
+ else if(facedir.Y < 0)
+ facebox.MaxEdge.Y = facebox.MinEdge.Y+d;
+ else if(facedir.Z > 0)
+ facebox.MinEdge.Z = facebox.MaxEdge.Z-d;
+ else if(facedir.Z < 0)
+ facebox.MaxEdge.Z = facebox.MinEdge.Z+d;
+
+ v3f centerpoint = facebox.getCenter();
+ f32 distance = (centerpoint - camera_position).getLength();
+ if(distance >= mindistance)
+ continue;
+ if(!facebox.intersectsWithLine(shootline))
+ continue;
- core::aabbox3d<f32> box;
+ v3s16 np_above = np + facedir;
- box = core::aabbox3d<f32>(vertices[0]);
- box.addInternalPoint(vertices[1]);
+ result.type = POINTEDTHING_NODE;
+ result.node_undersurface = np;
+ result.node_abovesurface = np_above;
+ mindistance = distance;
- if(distance < mindistance)
- {
- if(box.intersectsWithLine(shootline))
+ hilightboxes.clear();
+ for(std::vector<aabb3f>::const_iterator
+ i2 = boxes.begin();
+ i2 != boxes.end(); i2++)
{
- nodefound = true;
- nodepos = np;
- neighbourpos = np;
- mindistance = distance;
- nodehilightbox = box;
+ aabb3f box = *i2;
+ box.MinEdge += npf + v3f(-d,-d,-d);
+ box.MaxEdge += npf + v3f(d,d,d);
+ hilightboxes.push_back(box);
}
}
}
- /*
- Regular blocks
- */
- else
- {
- for(u16 i=0; i<6; i++)
- {
- v3f dir_f = v3f(dirs[i].X,
- dirs[i].Y, dirs[i].Z);
- v3f centerpoint = npf + dir_f * BS/2;
- f32 distance =
- (centerpoint - camera_position).getLength();
-
- if(distance < mindistance)
- {
- core::CMatrix4<f32> m;
- m.buildRotateFromTo(v3f(0,0,1), dir_f);
-
- // This is the back face
- v3f corners[2] = {
- v3f(BS/2, BS/2, BS/2),
- v3f(-BS/2, -BS/2, BS/2+d)
- };
-
- for(u16 j=0; j<2; j++)
- {
- m.rotateVect(corners[j]);
- corners[j] += npf;
- }
-
- core::aabbox3d<f32> facebox(corners[0]);
- facebox.addInternalPoint(corners[1]);
-
- if(facebox.intersectsWithLine(shootline))
- {
- nodefound = true;
- nodepos = np;
- neighbourpos = np + dirs[i];
- mindistance = distance;
-
- //nodehilightbox = 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);
- nodebox.MinEdge += nodepos_f;
- nodebox.MaxEdge += nodepos_f;
- nodehilightbox = nodebox;
- }
- } // if distance < mindistance
- } // for dirs
- } // regular block
} // for coords
-}
-void update_skybox(video::IVideoDriver* driver,
- scene::ISceneManager* smgr, scene::ISceneNode* &skybox,
- float brightness)
-{
- if(skybox)
- {
- skybox->remove();
- }
-
- /*// Disable skybox if FarMesh is enabled
- 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()));
- }
- 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()));
- }
- 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()));
- }
+ return result;
}
/*
//return guitext;
}
+/* Profiler display */
+
+void update_profiler_gui(gui::IGUIStaticText *guitext_profiler,
+ gui::IGUIFont *font, u32 text_height,
+ u32 show_profiler, u32 show_profiler_max)
+{
+ if(show_profiler == 0)
+ {
+ guitext_profiler->setVisible(false);
+ }
+ else
+ {
+
+ std::ostringstream os(std::ios_base::binary);
+ g_profiler->printPage(os, show_profiler, show_profiler_max);
+ std::wstring text = narrow_to_wide(os.str());
+ guitext_profiler->setText(text.c_str());
+ guitext_profiler->setVisible(true);
+
+ 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);
+ guitext_profiler->setVisible(true);
+ }
+}
+
+class ProfilerGraph
+{
+private:
+ struct Piece{
+ Profiler::GraphValues values;
+ };
+ struct Meta{
+ float min;
+ float max;
+ video::SColor color;
+ Meta(float initial=0, video::SColor color=
+ video::SColor(255,255,255,255)):
+ min(initial),
+ max(initial),
+ color(color)
+ {}
+ };
+ std::list<Piece> m_log;
+public:
+ u32 m_log_max_size;
+
+ ProfilerGraph():
+ m_log_max_size(200)
+ {}
+
+ void put(const Profiler::GraphValues &values)
+ {
+ Piece piece;
+ piece.values = values;
+ m_log.push_back(piece);
+ while(m_log.size() > m_log_max_size)
+ m_log.erase(m_log.begin());
+ }
+
+ void draw(s32 x_left, s32 y_bottom, video::IVideoDriver *driver,
+ gui::IGUIFont* font) const
+ {
+ std::map<std::string, Meta> m_meta;
+ for(std::list<Piece>::const_iterator k = m_log.begin();
+ k != m_log.end(); k++)
+ {
+ const Piece &piece = *k;
+ for(Profiler::GraphValues::const_iterator i = piece.values.begin();
+ i != piece.values.end(); i++){
+ const std::string &id = i->first;
+ const float &value = i->second;
+ std::map<std::string, Meta>::iterator j =
+ m_meta.find(id);
+ if(j == m_meta.end()){
+ m_meta[id] = Meta(value);
+ continue;
+ }
+ if(value < j->second.min)
+ j->second.min = value;
+ if(value > j->second.max)
+ j->second.max = value;
+ }
+ }
+
+ // Assign colors
+ static const video::SColor usable_colors[] = {
+ video::SColor(255,255,100,100),
+ video::SColor(255,90,225,90),
+ video::SColor(255,100,100,255),
+ video::SColor(255,255,150,50),
+ video::SColor(255,220,220,100)
+ };
+ static const u32 usable_colors_count =
+ sizeof(usable_colors) / sizeof(*usable_colors);
+ u32 next_color_i = 0;
+ for(std::map<std::string, Meta>::iterator i = m_meta.begin();
+ i != m_meta.end(); i++){
+ Meta &meta = i->second;
+ video::SColor color(255,200,200,200);
+ if(next_color_i < usable_colors_count)
+ color = usable_colors[next_color_i++];
+ meta.color = color;
+ }
+
+ s32 graphh = 50;
+ s32 textx = x_left + m_log_max_size + 15;
+ s32 textx2 = textx + 200 - 15;
+
+ // Draw background
+ /*{
+ u32 num_graphs = m_meta.size();
+ core::rect<s32> rect(x_left, y_bottom - num_graphs*graphh,
+ textx2, y_bottom);
+ video::SColor bgcolor(120,0,0,0);
+ driver->draw2DRectangle(bgcolor, rect, NULL);
+ }*/
+
+ s32 meta_i = 0;
+ for(std::map<std::string, Meta>::const_iterator i = m_meta.begin();
+ i != m_meta.end(); i++){
+ const std::string &id = i->first;
+ const Meta &meta = i->second;
+ s32 x = x_left;
+ s32 y = y_bottom - meta_i * 50;
+ float show_min = meta.min;
+ float show_max = meta.max;
+ if(show_min >= -0.0001 && show_max >= -0.0001){
+ if(show_min <= show_max * 0.5)
+ show_min = 0;
+ }
+ s32 texth = 15;
+ char buf[10];
+ snprintf(buf, 10, "%.3g", show_max);
+ font->draw(narrow_to_wide(buf).c_str(),
+ core::rect<s32>(textx, y - graphh,
+ textx2, y - graphh + texth),
+ meta.color);
+ snprintf(buf, 10, "%.3g", show_min);
+ font->draw(narrow_to_wide(buf).c_str(),
+ core::rect<s32>(textx, y - texth,
+ textx2, y),
+ meta.color);
+ font->draw(narrow_to_wide(id).c_str(),
+ core::rect<s32>(textx, y - graphh/2 - texth/2,
+ textx2, y - graphh/2 + texth/2),
+ meta.color);
+ s32 graph1y = y;
+ s32 graph1h = graphh;
+ bool relativegraph = (show_min != 0 && show_min != show_max);
+ float lastscaledvalue = 0.0;
+ bool lastscaledvalue_exists = false;
+ for(std::list<Piece>::const_iterator j = m_log.begin();
+ j != m_log.end(); j++)
+ {
+ const Piece &piece = *j;
+ float value = 0;
+ bool value_exists = false;
+ Profiler::GraphValues::const_iterator k =
+ piece.values.find(id);
+ if(k != piece.values.end()){
+ value = k->second;
+ value_exists = true;
+ }
+ if(!value_exists){
+ x++;
+ lastscaledvalue_exists = false;
+ continue;
+ }
+ float scaledvalue = 1.0;
+ if(show_max != show_min)
+ scaledvalue = (value - show_min) / (show_max - show_min);
+ if(scaledvalue == 1.0 && value == 0){
+ x++;
+ lastscaledvalue_exists = false;
+ continue;
+ }
+ if(relativegraph){
+ if(lastscaledvalue_exists){
+ s32 ivalue1 = lastscaledvalue * graph1h;
+ s32 ivalue2 = scaledvalue * graph1h;
+ driver->draw2DLine(v2s32(x-1, graph1y - ivalue1),
+ v2s32(x, graph1y - ivalue2), meta.color);
+ }
+ lastscaledvalue = scaledvalue;
+ lastscaledvalue_exists = true;
+ } else{
+ s32 ivalue = scaledvalue * graph1h;
+ driver->draw2DLine(v2s32(x, graph1y),
+ v2s32(x, graph1y - ivalue), meta.color);
+ }
+ x++;
+ }
+ meta_i++;
+ }
+ }
+};
+
+class NodeDugEvent: public MtEvent
+{
+public:
+ v3s16 p;
+ MapNode n;
+
+ NodeDugEvent(v3s16 p, MapNode n):
+ p(p),
+ n(n)
+ {}
+ const char* getType() const
+ {return "NodeDug";}
+};
+
+class SoundMaker
+{
+ ISoundManager *m_sound;
+ INodeDefManager *m_ndef;
+public:
+ float m_player_step_timer;
+
+ SimpleSoundSpec m_player_step_sound;
+ SimpleSoundSpec m_player_leftpunch_sound;
+ SimpleSoundSpec m_player_rightpunch_sound;
+
+ SoundMaker(ISoundManager *sound, INodeDefManager *ndef):
+ m_sound(sound),
+ m_ndef(ndef),
+ m_player_step_timer(0)
+ {
+ }
+
+ void playPlayerStep()
+ {
+ if(m_player_step_timer <= 0 && m_player_step_sound.exists()){
+ m_player_step_timer = 0.03;
+ m_sound->playSound(m_player_step_sound, false);
+ }
+ }
+
+ static void viewBobbingStep(MtEvent *e, void *data)
+ {
+ SoundMaker *sm = (SoundMaker*)data;
+ sm->playPlayerStep();
+ }
+
+ static void playerRegainGround(MtEvent *e, void *data)
+ {
+ SoundMaker *sm = (SoundMaker*)data;
+ sm->playPlayerStep();
+ }
+
+ static void playerJump(MtEvent *e, void *data)
+ {
+ //SoundMaker *sm = (SoundMaker*)data;
+ }
+
+ static void cameraPunchLeft(MtEvent *e, void *data)
+ {
+ SoundMaker *sm = (SoundMaker*)data;
+ sm->m_sound->playSound(sm->m_player_leftpunch_sound, false);
+ }
+
+ static void cameraPunchRight(MtEvent *e, void *data)
+ {
+ SoundMaker *sm = (SoundMaker*)data;
+ sm->m_sound->playSound(sm->m_player_rightpunch_sound, false);
+ }
+
+ static void nodeDug(MtEvent *e, void *data)
+ {
+ SoundMaker *sm = (SoundMaker*)data;
+ NodeDugEvent *nde = (NodeDugEvent*)e;
+ sm->m_sound->playSound(sm->m_ndef->get(nde->n).sound_dug, false);
+ }
+
+ void registerReceiver(MtEventManager *mgr)
+ {
+ mgr->reg("ViewBobbingStep", SoundMaker::viewBobbingStep, this);
+ mgr->reg("PlayerRegainGround", SoundMaker::playerRegainGround, this);
+ mgr->reg("PlayerJump", SoundMaker::playerJump, this);
+ mgr->reg("CameraPunchLeft", SoundMaker::cameraPunchLeft, this);
+ mgr->reg("CameraPunchRight", SoundMaker::cameraPunchRight, this);
+ mgr->reg("NodeDug", SoundMaker::nodeDug, this);
+ }
+
+ void step(float dtime)
+ {
+ m_player_step_timer -= dtime;
+ }
+};
+
+// Locally stored sounds don't need to be preloaded because of this
+class GameOnDemandSoundFetcher: public OnDemandSoundFetcher
+{
+ std::set<std::string> m_fetched;
+public:
+
+ void fetchSounds(const std::string &name,
+ std::set<std::string> &dst_paths,
+ std::set<std::string> &dst_datas)
+ {
+ if(m_fetched.count(name))
+ return;
+ m_fetched.insert(name);
+ std::string base = porting::path_share + DIR_DELIM + "testsounds";
+ dst_paths.insert(base + DIR_DELIM + name + ".ogg");
+ dst_paths.insert(base + DIR_DELIM + name + ".0.ogg");
+ dst_paths.insert(base + DIR_DELIM + name + ".1.ogg");
+ dst_paths.insert(base + DIR_DELIM + name + ".2.ogg");
+ dst_paths.insert(base + DIR_DELIM + name + ".3.ogg");
+ dst_paths.insert(base + DIR_DELIM + name + ".4.ogg");
+ dst_paths.insert(base + DIR_DELIM + name + ".5.ogg");
+ dst_paths.insert(base + DIR_DELIM + name + ".6.ogg");
+ dst_paths.insert(base + DIR_DELIM + name + ".7.ogg");
+ dst_paths.insert(base + DIR_DELIM + name + ".8.ogg");
+ dst_paths.insert(base + DIR_DELIM + name + ".9.ogg");
+ }
+};
+
void the_game(
bool &kill,
bool random_input,
std::string map_dir,
std::string playername,
std::string password,
- std::string address,
+ std::string address, // If "", local server is used
u16 port,
std::wstring &error_message,
- std::string configpath
+ std::string configpath,
+ ChatBackend &chat_backend,
+ const SubgameSpec &gamespec, // Used for local game,
+ bool simple_singleplayer_mode
)
{
video::IVideoDriver* driver = device->getVideoDriver();
//const s32 hotbar_imagesize = 64;
s32 hotbar_imagesize = 48;
- // The color of the sky
-
- //video::SColor skycolor = video::SColor(255,140,186,250);
-
- video::SColor bgcolor_bright = video::SColor(255,170,200,230);
-
/*
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();
+
+ // Sound fetcher (useful when testing)
+ GameOnDemandSoundFetcher soundfetcher;
+
+ // Sound manager
+ ISoundManager *sound = NULL;
+ bool sound_is_dummy = false;
+#if USE_SOUND
+ if(g_settings->getBool("enable_sound")){
+ infostream<<"Attempting to use OpenAL audio"<<std::endl;
+ sound = createOpenALSoundManager(&soundfetcher);
+ if(!sound)
+ infostream<<"Failed to initialize OpenAL audio"<<std::endl;
+ } else {
+ infostream<<"Sound disabled."<<std::endl;
+ }
+#endif
+ if(!sound){
+ infostream<<"Using dummy audio."<<std::endl;
+ sound = &dummySoundManager;
+ sound_is_dummy = true;
+ }
+
+ // Event manager
+ EventManager eventmgr;
+
+ // Sound maker
+ SoundMaker soundmaker(sound, nodedef);
+ soundmaker.registerReceiver(&eventmgr);
+
+ // Add chat log output for errors to be shown in chat
+ LogOutputBuffer chat_log_error_buf(LMT_ERROR);
+
+ // Create UI for modifying quicktune values
+ QuicktuneShortcutter quicktune;
+
/*
Create server.
SharedPtr will delete it when it goes out of scope.
if(address == ""){
draw_load_screen(L"Creating server...", driver, font);
infostream<<"Creating server"<<std::endl;
- server = new Server(map_dir, configpath);
+ server = new Server(map_dir, configpath, gamespec,
+ simple_singleplayer_mode);
server->start(port);
}
+
+ try{
+ do{ // Client scope (breakable do-while(0))
/*
Create client
draw_load_screen(L"Creating client...", driver, font);
infostream<<"Creating client"<<std::endl;
+
MapDrawControl draw_control;
- Client client(device, playername.c_str(), password, draw_control);
+
+ Client client(device, playername.c_str(), password, draw_control,
+ tsrc, itemdef, nodedef, sound, &eventmgr);
+
+ // 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)
{
- errorstream<<"Couldn't resolve address"<<std::endl;
- //return 0;
error_message = L"Couldn't resolve address";
- //gui_loadingtext->remove();
- return;
+ errorstream<<wide_to_narrow(error_message)<<std::endl;
+ // Break out of client scope
+ break;
}
/*
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;
+ bool connect_aborted = false;
try{
+ float frametime = 0.033;
float time_counter = 0.0;
- for(;;)
+ input->clear();
+ while(device->run())
{
- 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;
}
- if(client.accessDenied())
- {
+ // Break conditions
+ if(client.accessDenied()){
+ error_message = L"Access denied. Reason: "
+ +client.accessDeniedReason();
+ errorstream<<wide_to_narrow(error_message)<<std::endl;
+ break;
+ }
+ if(input->wasKeyDown(EscapeKey)){
+ connect_aborted = true;
+ infostream<<"Connect aborted [Escape]"<<std::endl;
+ break;
+ }
+
+ // Display status
+ std::wostringstream ss;
+ ss<<L"Connecting to server... (press Escape to cancel)\n";
+ std::wstring animation = L"/-\\|";
+ ss<<animation[(int)(time_counter/0.2)%4];
+ draw_load_screen(ss.str(), driver, font);
+
+ // Delay a bit
+ sleep_ms(1000*frametime);
+ time_counter += frametime;
+ }
+ }
+ catch(con::PeerNotFoundException &e)
+ {}
+
+ /*
+ Handle failure to connect
+ */
+ if(!could_connect){
+ if(error_message == L"" && !connect_aborted){
+ error_message = L"Connection failed";
+ errorstream<<wide_to_narrow(error_message)<<std::endl;
+ }
+ // Break out of client scope
+ break;
+ }
+
+ /*
+ Wait until content has been received
+ */
+ bool got_content = false;
+ bool content_aborted = false;
+ {
+ float frametime = 0.033;
+ float time_counter = 0.0;
+ input->clear();
+ while(device->run())
+ {
+ // 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()){
+ error_message = L"Client disconnected";
+ errorstream<<wide_to_narrow(error_message)<<std::endl;
break;
}
- // Wait for 10 seconds
- if(time_counter >= 10.0)
- {
+ if(input->wasKeyDown(EscapeKey)){
+ content_aborted = true;
+ infostream<<"Connect aborted [Escape]"<<std::endl;
break;
}
+ // Display status
std::wostringstream ss;
- ss<<L"Connecting to server... (timeout in ";
- ss<<(int)(10.0 - 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();*/
+ ss<<L"Waiting content... (press Escape to cancel)\n";
- // Update client and server
-
- client.step(0.1);
+ ss<<(client.itemdefReceived()?L"[X]":L"[ ]");
+ ss<<L" Item definitions\n";
+ ss<<(client.nodedefReceived()?L"[X]":L"[ ]");
+ ss<<L" Node definitions\n";
+ ss<<L"["<<(int)(client.mediaReceiveProgress()*100+0.5)<<L"%] ";
+ ss<<L" Media\n";
- if(server != NULL)
- server->step(0.1);
+ draw_load_screen(ss.str(), driver, font);
// Delay a bit
- sleep_ms(100);
- time_counter += 0.1;
+ sleep_ms(1000*frametime);
+ time_counter += frametime;
}
}
- catch(con::PeerNotFoundException &e)
- {}
- if(could_connect == false)
- {
- if(client.accessDenied())
- {
- error_message = L"Access denied. Reason: "
- +client.accessDeniedReason();
+ if(!got_content){
+ if(error_message == L"" && !content_aborted){
+ error_message = L"Something failed";
errorstream<<wide_to_narrow(error_message)<<std::endl;
}
- else
- {
- error_message = L"Connection timed out.";
- errorstream<<"Timed out."<<std::endl;
- }
- //gui_loadingtext->remove();
- return;
+ // Break out of client scope
+ break;
}
/*
- Create skybox
+ After all content has been received:
+ Update cached textures, meshes and materials
*/
- float old_brightness = 1.0;
- scene::ISceneNode* skybox = NULL;
- update_skybox(driver, smgr, skybox, 1.0);
-
+ client.afterContentReceived();
+
/*
Create the camera node
*/
- Camera camera(smgr, draw_control);
+ Camera camera(smgr, draw_control, gamedef);
if (!camera.successfullyCreated(error_message))
return;
Clouds
*/
- float cloud_height = BS*100;
Clouds *clouds = NULL;
if(g_settings->getBool("enable_clouds"))
{
- clouds = new Clouds(smgr->getRootSceneNode(), smgr, -1,
- cloud_height, time(0));
+ clouds = new Clouds(smgr->getRootSceneNode(), smgr, -1, time(0));
}
+
+ /*
+ Skybox thingy
+ */
+
+ Sky *sky = NULL;
+ sky = new Sky(smgr->getRootSceneNode(), smgr, -1);
/*
FarMesh
}
/*
- Move into game
+ A copy of the local inventory
*/
-
- //gui_loadingtext->remove();
+ Inventory local_inventory(itemdef);
+
+ /*
+ Find out size of crack animation
+ */
+ int crack_animation_length = 5;
+ {
+ video::ITexture *t = tsrc->getTextureRaw("crack_anylength.png");
+ v2u32 size = t->getOriginalSize();
+ crack_animation_length = size.Y / size.X;
+ }
/*
Add some gui stuff
// Object infos are shown in this
gui::IGUIStaticText *guitext_info = guienv->addStaticText(
L"",
- core::rect<s32>(0,0,400,text_height+5) + v2s32(100,200),
+ core::rect<s32>(0,0,400,text_height*5+5) + v2s32(100,200),
+ false, false);
+
+ // Status text (displays info when showing and hiding GUI stuff, etc.)
+ gui::IGUIStaticText *guitext_status = guienv->addStaticText(
+ L"<Status>",
+ core::rect<s32>(0,0,0,0),
false, false);
+ guitext_status->setVisible(false);
+
+ std::wstring statustext;
+ float statustext_time = 0;
// Chat text
gui::IGUIStaticText *guitext_chat = guienv->addStaticText(
core::rect<s32>(0,0,0,0),
//false, false); // Disable word wrap as of now
false, true);
- //guitext_chat->setBackgroundColor(video::SColor(96,0,0,0));
- core::list<ChatLine> chat_lines;
+ // Remove stale "recent" chat messages from previous connections
+ chat_backend.clearRecentChat();
+ // Chat backend and console
+ GUIChatConsole *gui_chat_console = new GUIChatConsole(guienv, guienv->getRootGUIElement(), -1, &chat_backend, &client);
// 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),
+ core::rect<s32>(0,0,0,0),
false, false);
- guitext_profiler->setBackgroundColor(video::SColor(80,0,0,0));
+ guitext_profiler->setBackgroundColor(video::SColor(120,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
- (guienv, NULL, v2s32(0, 0), quickinv_itemcount, &local_inventory);*/
-
- // Test the text input system
- /*(new GUITextInputMenu(guienv, guiroot, -1, &g_menumgr,
- NULL))->drop();*/
- /*GUIMessageMenu *menu =
- new GUIMessageMenu(guienv, guiroot, -1,
- &g_menumgr,
- L"Asd");
- menu->drop();*/
-
- // Launch pause menu
- (new GUIPauseMenu(guienv, guiroot, -1, g_gamecallback,
- &g_menumgr))->drop();
-
- // Enable texts
- /*guitext2->setVisible(true);
- guitext_info->setVisible(true);
- guitext_chat->setVisible(true);*/
-
- //s32 guitext_chat_pad_bottom = 70;
-
/*
Some statistics are collected in these
*/
u32 scenetime = 0;
u32 endscenetime = 0;
- // A test
- //throw con::PeerNotFoundException("lol");
-
- core::list<float> frametime_log;
+ float recent_turn_speed = 0.0;
+
+ ProfilerGraph graph;
+ // Initially clear the profiler
+ Profiler::GraphValues dummyvalues;
+ g_profiler->graphGet(dummyvalues);
- float nodig_delay_counter = 0.0;
+ float nodig_delay_timer = 0.0;
float dig_time = 0.0;
u16 dig_index = 0;
- v3s16 nodepos_old(-32768,-32768,-32768);
+ 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.5;
+ const float object_hit_delay = 0.2;
float object_hit_delay_timer = 0.0;
-
+ float time_from_last_punch = 10;
+
+ float update_draw_list_timer = 0.0;
+ v3f update_draw_list_last_cam_dir;
+
bool invert_mouse = g_settings->getBool("invert_mouse");
bool respawn_menu_active = false;
+ bool update_wielded_item_trigger = false;
- bool show_profiler = false;
+ bool show_hud = true;
+ bool show_chat = true;
bool force_fog_off = false;
bool disable_camera_update = false;
+ bool show_debug = g_settings->getBool("show_debug");
+ bool show_profiler_graph = false;
+ u32 show_profiler = 0;
+ u32 show_profiler_max = 3; // Number of pages
+
+ float time_of_day = 0;
+ float time_of_day_smooth = 0;
/*
Main loop
// NOTE: So we have to use getTime() and call run()s between them
u32 lasttime = device->getTimer()->getTime();
- while(device->run() && kill == false)
+ for(;;)
{
- //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;
+ if(device->run() == false || kill == true)
break;
- }
- if(g_gamecallback->changepassword_requested)
- {
- (new GUIPasswordChange(guienv, guiroot, -1,
- &g_menumgr, &client))->drop();
- g_gamecallback->changepassword_requested = false;
- }
-
- /*
- Process TextureSource's queue
- */
- ((TextureSource*)g_texturesource)->processQueue();
-
- /*
- Random calculations
- */
- last_screensize = screensize;
- screensize = driver->getScreenSize();
- v2s32 displaycenter(screensize.X/2,screensize.Y/2);
- //bool screensize_changed = screensize != last_screensize;
-
- // Resize hotbar
- if(screensize.Y <= 800)
- hotbar_imagesize = 32;
- else if(screensize.Y <= 1280)
- hotbar_imagesize = 48;
- else
- hotbar_imagesize = 64;
-
- // Hilight boxes collected during the loop and displayed
- core::list< core::aabbox3d<f32> > hilightboxes;
-
- // Info text
- std::wstring infotext;
-
- // When screen size changes, update positions and sizes of stuff
- /*if(screensize_changed)
- {
- v2s32 pos(displaycenter.X-((quickinv_itemcount-1)*quickinv_spacing+quickinv_size)/2, screensize.Y-quickinv_spacing);
- quick_inventory->updatePosition(pos);
- }*/
-
- //TimeTaker //timer1("//timer1");
-
// Time of frame without fps limit
float busytime;
u32 busytime_u32;
busytime_u32 = 0;
busytime = busytime_u32 / 1000.0;
}
+
+ g_profiler->graphAdd("mainloop_other", busytime - (float)drawtime/1000.0f);
- //infostream<<"busytime_u32="<<busytime_u32<<std::endl;
-
// Necessary for device->getTimer()->getTime()
device->run();
{
u32 sleeptime = frametime_min - busytime_u32;
device->sleep(sleeptime);
+ g_profiler->graphAdd("mainloop_sleep", (float)sleeptime/1000.0f);
}
}
dtime = 0;
lasttime = time;
- /* Run timers */
+ g_profiler->graphAdd("mainloop_dtime", dtime);
- object_hit_delay_timer -= dtime;
+ /* Run timers */
+ if(nodig_delay_timer >= 0)
+ nodig_delay_timer -= dtime;
+ if(object_hit_delay_timer >= 0)
+ object_hit_delay_timer -= dtime;
+ time_from_last_punch += dtime;
+
g_profiler->add("Elapsed time", dtime);
g_profiler->avg("FPS", 1./dtime);
- /*
- Log frametime for visualization
- */
- frametime_log.push_back(dtime);
- if(frametime_log.size() > 100)
- {
- core::list<float>::Iterator i = frametime_log.begin();
- frametime_log.erase(i);
- }
-
- /*
- Visualize frametime in terminal
- */
- /*for(u32 i=0; i<dtime*400; i++)
- infostream<<"X";
- infostream<<std::endl;*/
-
/*
Time average and jitter calculation
*/
jitter1_min = 0.0;
}
}
+
+ /*
+ Handle miscellaneous stuff
+ */
+
+ 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;
+ break;
+ }
+
+ if(g_gamecallback->changepassword_requested)
+ {
+ (new GUIPasswordChange(guienv, guiroot, -1,
+ &g_menumgr, &client))->drop();
+ g_gamecallback->changepassword_requested = false;
+ }
+
+ /*
+ Process TextureSource's queue
+ */
+ tsrc->processQueue();
+
+ /*
+ Random calculations
+ */
+ last_screensize = screensize;
+ screensize = driver->getScreenSize();
+ v2s32 displaycenter(screensize.X/2,screensize.Y/2);
+ //bool screensize_changed = screensize != last_screensize;
+
+ // Resize hotbar
+ if(screensize.Y <= 800)
+ hotbar_imagesize = 32;
+ else if(screensize.Y <= 1280)
+ hotbar_imagesize = 48;
+ else
+ hotbar_imagesize = 64;
+
+ // Hilight boxes collected during the loop and displayed
+ std::vector<aabb3f> hilightboxes;
+ // Info text
+ std::wstring infotext;
+
/*
Debug info for client
*/
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());
+ update_profiler_gui(guitext_profiler, font, text_height,
+ show_profiler, show_profiler_max);
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);
}
/*
*/
// Reset input if window not active or some menu is active
- if(device->isWindowActive() == false || noMenuActive() == false)
+ if(device->isWindowActive() == false
+ || noMenuActive() == false
+ || guienv->hasFocus(gui_chat_console))
{
input->clear();
}
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")))
+ {
+ // 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);
-
- core::array<GUIInventoryMenu::DrawSpec> draw_spec;
- draw_spec.push_back(GUIInventoryMenu::DrawSpec(
- "list", "current_player", "main",
- v2s32(0, 3), v2s32(8, 4)));
- draw_spec.push_back(GUIInventoryMenu::DrawSpec(
- "list", "current_player", "craft",
- v2s32(3, 0), v2s32(3, 3)));
- draw_spec.push_back(GUIInventoryMenu::DrawSpec(
- "list", "current_player", "craftresult",
- v2s32(7, 1), v2s32(1, 1)));
-
- menu->setDrawSpec(draw_spec);
-
+ GUIFormSpecMenu *menu =
+ new GUIFormSpecMenu(device, guiroot, -1,
+ &g_menumgr,
+ &client, gamedef);
+
+ InventoryLocation inventoryloc;
+ inventoryloc.setCurrentPlayer();
+
+ PlayerInventoryFormSource *src = new PlayerInventoryFormSource(&client);
+ assert(src);
+ menu->setFormSpec(src->getForm(), inventoryloc);
+ menu->setFormSource(src);
+ menu->setTextDest(new TextDestPlayerInventory(&client));
menu->drop();
}
else if(input->wasKeyDown(EscapeKey))
<<"Launching pause menu"<<std::endl;
// It will delete itself by itself
(new GUIPauseMenu(guienv, guiroot, -1, g_gamecallback,
- &g_menumgr))->drop();
+ &g_menumgr, simple_singleplayer_mode))->drop();
// Move mouse cursor on top of the disconnect button
- input->setMousePos(displaycenter.X, displaycenter.Y+25);
+ if(simple_singleplayer_mode)
+ input->setMousePos(displaycenter.X, displaycenter.Y+0);
+ else
+ input->setMousePos(displaycenter.X, displaycenter.Y+25);
}
else if(input->wasKeyDown(getKeySetting("keymap_chat")))
{
&g_menumgr, dest,
L"/"))->drop();
}
+ else if(input->wasKeyDown(getKeySetting("keymap_console")))
+ {
+ if (!gui_chat_console->isOpenInhibited())
+ {
+ // Open up to over half of the screen
+ gui_chat_console->openConsole(0.6);
+ guienv->setFocus(gui_chat_console);
+ }
+ }
else if(input->wasKeyDown(getKeySetting("keymap_freemove")))
{
if(g_settings->getBool("free_move"))
{
g_settings->set("free_move","false");
- chat_lines.push_back(ChatLine(L"free_move disabled"));
+ statustext = L"free_move disabled";
+ statustext_time = 0;
}
else
{
g_settings->set("free_move","true");
- chat_lines.push_back(ChatLine(L"free_move enabled"));
+ statustext = L"free_move enabled";
+ statustext_time = 0;
+ if(!client.checkPrivilege("fly"))
+ statustext += L" (note: no 'fly' privilege)";
}
}
else if(input->wasKeyDown(getKeySetting("keymap_fastmove")))
if(g_settings->getBool("fast_move"))
{
g_settings->set("fast_move","false");
- chat_lines.push_back(ChatLine(L"fast_move disabled"));
+ statustext = L"fast_move disabled";
+ statustext_time = 0;
}
else
{
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"))
- {
- g_settings->set("frametime_graph","false");
- chat_lines.push_back(ChatLine(L"frametime_graph disabled"));
- }
- else
- {
- g_settings->set("frametime_graph","true");
- chat_lines.push_back(ChatLine(L"frametime_graph enabled"));
+ statustext = L"fast_move enabled";
+ statustext_time = 0;
+ if(!client.checkPrivilege("fast"))
+ statustext += L" (note: no 'fast' privilege)";
}
}
else if(input->wasKeyDown(getKeySetting("keymap_screenshot")))
std::wstringstream sstr;
sstr<<"Saved screenshot to '"<<filename<<"'";
infostream<<"Saved screenshot to '"<<filename<<"'"<<std::endl;
- chat_lines.push_back(ChatLine(sstr.str()));
+ statustext = sstr.str();
+ statustext_time = 0;
} else{
infostream<<"Failed to save screenshot '"<<filename<<"'"<<std::endl;
}
image->drop();
}
}
- else if(input->wasKeyDown(getKeySetting("keymap_toggle_profiler")))
+ else if(input->wasKeyDown(getKeySetting("keymap_toggle_hud")))
+ {
+ show_hud = !show_hud;
+ if(show_hud)
+ statustext = L"HUD shown";
+ else
+ statustext = L"HUD hidden";
+ statustext_time = 0;
+ }
+ else if(input->wasKeyDown(getKeySetting("keymap_toggle_chat")))
{
- show_profiler = !show_profiler;
- guitext_profiler->setVisible(show_profiler);
- if(show_profiler)
- chat_lines.push_back(ChatLine(L"Profiler disabled"));
+ show_chat = !show_chat;
+ if(show_chat)
+ statustext = L"Chat shown";
else
- chat_lines.push_back(ChatLine(L"Profiler enabled"));
+ statustext = L"Chat hidden";
+ statustext_time = 0;
}
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"));
+ statustext = L"Fog disabled";
else
- chat_lines.push_back(ChatLine(L"Fog enabled"));
+ statustext = L"Fog enabled";
+ statustext_time = 0;
}
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"));
+ statustext = L"Camera update disabled";
+ else
+ statustext = L"Camera update enabled";
+ statustext_time = 0;
+ }
+ else if(input->wasKeyDown(getKeySetting("keymap_toggle_debug")))
+ {
+ // Initial / 3x toggle: Chat only
+ // 1x toggle: Debug text with chat
+ // 2x toggle: Debug text with profiler graph
+ if(!show_debug)
+ {
+ show_debug = true;
+ show_profiler_graph = false;
+ statustext = L"Debug info shown";
+ statustext_time = 0;
+ }
+ else if(show_profiler_graph)
+ {
+ show_debug = false;
+ show_profiler_graph = false;
+ statustext = L"Debug info and profiler graph hidden";
+ statustext_time = 0;
+ }
+ else
+ {
+ show_profiler_graph = true;
+ statustext = L"Profiler graph shown";
+ statustext_time = 0;
+ }
+ }
+ else if(input->wasKeyDown(getKeySetting("keymap_toggle_profiler")))
+ {
+ show_profiler = (show_profiler + 1) % (show_profiler_max + 1);
+
+ // FIXME: This updates the profiler with incomplete values
+ update_profiler_gui(guitext_profiler, font, text_height,
+ show_profiler, show_profiler_max);
+
+ if(show_profiler != 0)
+ {
+ std::wstringstream sstr;
+ sstr<<"Profiler shown (page "<<show_profiler
+ <<" of "<<show_profiler_max<<")";
+ statustext = sstr.str();
+ statustext_time = 0;
+ }
else
- chat_lines.push_back(ChatLine(L"Camera update enabled"));
+ {
+ statustext = L"Profiler hidden";
+ statustext_time = 0;
+ }
+ }
+ else if(input->wasKeyDown(getKeySetting("keymap_increase_viewing_range_min")))
+ {
+ s16 range = g_settings->getS16("viewing_range_nodes_min");
+ s16 range_new = range + 10;
+ g_settings->set("viewing_range_nodes_min", itos(range_new));
+ statustext = narrow_to_wide(
+ "Minimum viewing range changed to "
+ + itos(range_new));
+ statustext_time = 0;
+ }
+ else if(input->wasKeyDown(getKeySetting("keymap_decrease_viewing_range_min")))
+ {
+ s16 range = g_settings->getS16("viewing_range_nodes_min");
+ s16 range_new = range - 10;
+ if(range_new < 0)
+ range_new = range;
+ g_settings->set("viewing_range_nodes_min",
+ itos(range_new));
+ statustext = narrow_to_wide(
+ "Minimum viewing range changed to "
+ + itos(range_new));
+ statustext_time = 0;
+ }
+
+ // Handle QuicktuneShortcutter
+ if(input->wasKeyDown(getKeySetting("keymap_quicktune_next")))
+ quicktune.next();
+ if(input->wasKeyDown(getKeySetting("keymap_quicktune_prev")))
+ quicktune.prev();
+ if(input->wasKeyDown(getKeySetting("keymap_quicktune_inc")))
+ quicktune.inc();
+ if(input->wasKeyDown(getKeySetting("keymap_quicktune_dec")))
+ quicktune.dec();
+ {
+ std::string msg = quicktune.getMessage();
+ if(msg != ""){
+ statustext = narrow_to_wide(msg);
+ statustext_time = 0;
+ }
}
// 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;
}
}
{
if(i < PLAYER_INVENTORY_SIZE && i < hotbar_itemcount)
{
- g_selected_item = i;
+ new_playeritem = i;
infostream<<"Selected item: "
- <<g_selected_item<<std::endl;
+ <<new_playeritem<<std::endl;
}
}
}
// Viewing range selection
if(input->wasKeyDown(getKeySetting("keymap_rangeselect")))
{
+ draw_control.range_all = !draw_control.range_all;
if(draw_control.range_all)
{
- draw_control.range_all = false;
- infostream<<"Disabled full viewing range"<<std::endl;
+ infostream<<"Enabled full viewing range"<<std::endl;
+ statustext = L"Enabled full viewing range";
+ statustext_time = 0;
}
else
{
- draw_control.range_all = true;
- infostream<<"Enabled full viewing range"<<std::endl;
+ infostream<<"Disabled full viewing range"<<std::endl;
+ statustext = L"Disabled full viewing range";
+ statustext_time = 0;
}
}
NOTE: Do this before client.setPlayerControl() to not cause a camera lag of one frame
*/
+ float turn_amount = 0;
if((device->isWindowActive() && noMenuActive()) || random_input)
{
if(!random_input)
dx -= dtime * keyspeed;
if(input->isKeyDown(irr::KEY_RIGHT))
dx += dtime * keyspeed;*/
-
- camera_yaw -= dx*0.2;
- camera_pitch += dy*0.2;
+
+ float d = 0.2;
+ camera_yaw -= dx*d;
+ camera_pitch += dy*d;
if(camera_pitch < -89.5) camera_pitch = -89.5;
if(camera_pitch > 89.5) camera_pitch = 89.5;
+
+ turn_amount = v2f(dx, dy).getLength() * d;
}
input->setMousePos(displaycenter.X, displaycenter.Y);
}
//infostream<<"window inactive"<<std::endl;
first_loop_after_window_activation = true;
}
+ recent_turn_speed = recent_turn_speed * 0.9 + turn_amount * 0.1;
+ //std::cerr<<"recent_turn_speed = "<<recent_turn_speed<<std::endl;
/*
Player speed control
*/
-
- 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,
bool a_jump,
bool a_superspeed,
bool a_sneak,
+ bool a_LMB,
+ bool a_RMB,
float a_pitch,
float a_yaw*/
PlayerControl control(
input->isKeyDown(getKeySetting("keymap_jump")),
input->isKeyDown(getKeySetting("keymap_special1")),
input->isKeyDown(getKeySetting("keymap_sneak")),
+ input->getLeftState(),
+ input->getRightState(),
camera_pitch,
camera_yaw
);
client.setPlayerControl(control);
+ u32 keyPressed=
+ 1*(int)input->isKeyDown(getKeySetting("keymap_forward"))+
+ 2*(int)input->isKeyDown(getKeySetting("keymap_backward"))+
+ 4*(int)input->isKeyDown(getKeySetting("keymap_left"))+
+ 8*(int)input->isKeyDown(getKeySetting("keymap_right"))+
+ 16*(int)input->isKeyDown(getKeySetting("keymap_jump"))+
+ 32*(int)input->isKeyDown(getKeySetting("keymap_special1"))+
+ 64*(int)input->isKeyDown(getKeySetting("keymap_sneak"))+
+ 128*(int)input->getLeftState()+
+ 256*(int)input->getRightState();
+ LocalPlayer* player = client.getEnv().getLocalPlayer();
+ player->keyPressed=keyPressed;
}
/*
&g_menumgr, respawner);
menu->drop();
+ chat_backend.addMessage(L"", L"You died.");
+
/* Handle visualization */
damage_flash_timer = 0;
player->setPosition(player->getPosition() + v3f(0,-BS,0));
camera.update(player, busytime, screensize);*/
}
+ else if(event.type == CE_TEXTURES_UPDATED)
+ {
+ update_wielded_item_trigger = true;
+ }
}
}
//TimeTaker //timer2("//timer2");
- LocalPlayer* player = client.getLocalPlayer();
- camera.update(player, busytime, screensize);
+ /*
+ For interaction purposes, get info about the held item
+ - What item is it?
+ - Is it a usable item?
+ - Can it point to liquids?
+ */
+ ItemStack playeritem;
+ bool playeritem_usable = false;
+ bool playeritem_liquids_pointable = false;
+ {
+ InventoryList *mlist = local_inventory.getList("main");
+ if(mlist != NULL)
+ {
+ playeritem = mlist->getItem(client.getPlayerItem());
+ playeritem_usable = playeritem.getDefinition(itemdef).usable;
+ playeritem_liquids_pointable = playeritem.getDefinition(itemdef).liquids_pointable;
+ }
+ }
+ ToolCapabilities playeritem_toolcap =
+ playeritem.getToolCapabilities(itemdef);
+
+ /*
+ Update camera
+ */
+
+ LocalPlayer* player = client.getEnv().getLocalPlayer();
+ float full_punch_interval = playeritem_toolcap.full_punch_interval;
+ float tool_reload_ratio = time_from_last_punch / full_punch_interval;
+ tool_reload_ratio = MYMIN(tool_reload_ratio, 1.0);
+ camera.update(player, busytime, screensize, tool_reload_ratio);
camera.step(dtime);
v3f player_position = player->getPosition();
f32 camera_fov = camera.getFovMax();
if(!disable_camera_update){
- client.updateCamera(camera_position,
+ client.getEnv().getClientMap().updateCamera(camera_position,
camera_direction, camera_fov);
}
+
+ // Update sound listener
+ sound->updateListener(camera.getCameraNode()->getPosition(),
+ v3f(0,0,0), // velocity
+ camera.getDirection(),
+ camera.getCameraNode()->getUpVector());
+ sound->setListenerGain(g_settings->getFloat("sound_volume"));
- //timer2.stop();
- //TimeTaker //timer3("//timer3");
+ /*
+ Update sound maker
+ */
+ {
+ soundmaker.step(dtime);
+
+ ClientMap &map = client.getEnv().getClientMap();
+ MapNode n = map.getNodeNoEx(player->getStandingNodePos());
+ soundmaker.m_player_step_sound = nodedef->get(n).sound_footstep;
+ }
/*
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));
-
- ClientActiveObject *selected_active_object
- = client.getSelectedActiveObject
- (d*BS, camera_position, shootline);
-
- bool left_punch = false;
- bool left_punch_muted = false;
-
- if(selected_active_object != NULL)
- {
- /* Clear possible cracking animation */
- if(nodepos_old != v3s16(-32768,-32768,-32768))
- {
- client.clearTempMod(nodepos_old);
- dig_time = 0.0;
- nodepos_old = v3s16(-32768,-32768,-32768);
- }
-
- //infostream<<"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);
+
+ f32 d = 4; // max. distance
+ core::line3d<f32> shootline(camera_position,
+ camera_position + camera_direction * BS * (d+1));
- v3f pos = selected_active_object->getPosition();
+ ClientActiveObject *selected_object = NULL;
- core::aabbox3d<f32> box_on_map(
- selection_box->MinEdge + pos,
- selection_box->MaxEdge + pos
- );
-
- if(selected_active_object->doShowSelectionBox())
- hilightboxes.push_back(box_on_map);
+ PointedThing pointed = getPointedThing(
+ // input
+ &client, player_position, camera_direction,
+ camera_position, shootline, d,
+ playeritem_liquids_pointable, !ldown_for_dig,
+ // output
+ hilightboxes,
+ selected_object);
- //infotext = narrow_to_wide("A ClientActiveObject");
- infotext = narrow_to_wide(selected_active_object->infoText());
+ if(pointed != pointed_old)
+ {
+ infostream<<"Pointing at "<<pointed.dump()<<std::endl;
+ //dstream<<"Pointing at "<<pointed.dump()<<std::endl;
+ }
- //if(input->getLeftClicked())
- if(input->getLeftState())
+ /*
+ Stop digging when
+ - releasing left mouse button
+ - pointing away from node
+ */
+ if(digging)
+ {
+ if(input->getLeftReleased())
{
- 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;
+ infostream<<"Left button released"
+ <<" (stopped digging)"<<std::endl;
+ digging = false;
+ }
+ else if(pointed != pointed_old)
+ {
+ if (pointed.type == POINTEDTHING_NODE
+ && pointed_old.type == POINTEDTHING_NODE
+ && pointed.node_undersurface == pointed_old.node_undersurface)
+ {
+ // Still pointing to the same node,
+ // but a different face. Don't reset.
}
- if(do_punch_damage){
- client.clickActiveObject(0,
- selected_active_object->getId(), g_selected_item);
+ else
+ {
+ infostream<<"Pointing away from node"
+ <<" (stopped digging)"<<std::endl;
+ digging = false;
}
}
- else if(input->getRightClicked())
+ if(!digging)
{
- infostream<<"Right-clicked object"<<std::endl;
- client.clickActiveObject(1,
- selected_active_object->getId(), g_selected_item);
+ client.interact(1, pointed_old);
+ client.setCrack(-1, v3s16(0,0,0));
+ 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);
-
- if(!nodefound){
- if(nodepos_old != v3s16(-32768,-32768,-32768))
- {
- client.clearTempMod(nodepos_old);
- dig_time = 0.0;
- nodepos_old = v3s16(-32768,-32768,-32768);
- }
- } else {
- /*
- Visualize selection
- */
+ bool left_punch = false;
+ soundmaker.m_player_leftpunch_sound.name = "";
- hilightboxes.push_back(nodehilightbox);
+ if(playeritem_usable && input->getLeftState())
+ {
+ 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
*/
-
- NodeMetadata *meta = client.getNodeMetadata(nodepos);
- if(meta)
- {
- infotext = narrow_to_wide(meta->infoText());
+
+ ClientMap &map = client.getEnv().getClientMap();
+ NodeMetadata *meta = map.getNodeMetadata(nodepos);
+ if(meta){
+ infotext = narrow_to_wide(meta->getString("infotext"));
+ } else {
+ MapNode n = map.getNode(nodepos);
+ if(nodedef->get(n).tiledef[0].name == "unknown_block.png"){
+ infotext = L"Unknown node: ";
+ infotext += narrow_to_wide(nodedef->get(n).name);
+ }
}
- //MapNode node = client.getNode(nodepos);
-
+ // We can't actually know, but assume the sound of right-clicking
+ // to be the sound of placing a node
+ soundmaker.m_player_rightpunch_sound.gain = 0.5;
+ soundmaker.m_player_rightpunch_sound.name = "default_place_node";
+
/*
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)
{
- infostream<<"Pointing at ("<<nodepos.X<<","
- <<nodepos.Y<<","<<nodepos.Z<<")"<<std::endl;
-
- if(nodepos_old != v3s16(-32768,-32768,-32768))
- {
- client.clearTempMod(nodepos_old);
- dig_time = 0.0;
- nodepos_old = v3s16(-32768,-32768,-32768);
+ infostream<<"Started digging"<<std::endl;
+ client.interact(0, pointed);
+ digging = true;
+ ldown_for_dig = true;
+ }
+ MapNode n = client.getEnv().getClientMap().getNode(nodepos);
+
+ // NOTE: Similar piece of code exists on the server side for
+ // cheat detection.
+ // Get digging parameters
+ DigParams params = getDigParams(nodedef->get(n).groups,
+ &playeritem_toolcap);
+ // If can't dig, try hand
+ if(!params.diggable){
+ const ItemDefinition &hand = itemdef->get("");
+ const ToolCapabilities *tp = hand.tool_capabilities;
+ if(tp)
+ params = getDigParams(nodedef->get(n).groups, tp);
+ }
+
+ SimpleSoundSpec sound_dig = nodedef->get(n).sound_dig;
+ if(sound_dig.exists()){
+ if(sound_dig.name == "__group"){
+ if(params.main_group != ""){
+ soundmaker.m_player_leftpunch_sound.gain = 0.5;
+ soundmaker.m_player_leftpunch_sound.name =
+ std::string("default_dig_") +
+ params.main_group;
+ }
+ } else{
+ soundmaker.m_player_leftpunch_sound = sound_dig;
}
}
- if(input->getLeftClicked() ||
- (input->getLeftState() && nodepos != nodepos_old))
+ float dig_time_complete = 0.0;
+
+ if(params.diggable == false)
{
- infostream<<"Started digging"<<std::endl;
- client.groundAction(0, nodepos, neighbourpos, g_selected_item);
+ // I guess nobody will wait for this long
+ dig_time_complete = 10000000.0;
}
- if(input->getLeftClicked())
+ else
{
- client.setTempMod(nodepos, NodeMod(NODEMOD_CRACK, 0));
+ dig_time_complete = params.time;
}
- if(input->getLeftState())
+
+ if(dig_time_complete >= 0.001)
{
- 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();
- }
- }
+ dig_index = (u16)((float)crack_animation_length
+ * dig_time/dig_time_complete);
+ }
+ // This is for torches
+ else
+ {
+ dig_index = crack_animation_length;
+ }
- // Get digging properties for material and tool
- content_t material = n.getContent();
- DiggingProperties prop =
- getDiggingProperties(material, toolname);
-
- float dig_time_complete = 0.0;
-
- if(prop.diggable == false)
- {
- /*infostream<<"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;
- }
+ // Don't show cracks if not diggable
+ if(dig_time_complete >= 100000.0)
+ {
+ }
+ else if(dig_index < crack_animation_length)
+ {
+ //TimeTaker timer("client.setTempMod");
+ //infostream<<"dig_index="<<dig_index<<std::endl;
+ client.setCrack(dig_index, nodepos);
+ }
+ else
+ {
+ infostream<<"Digging completed"<<std::endl;
+ client.interact(2, pointed);
+ client.setCrack(-1, v3s16(0,0,0));
+ MapNode wasnode = map.getNode(nodepos);
+ client.removeNode(nodepos);
+
+ dig_time = 0;
+ digging = false;
+
+ nodig_delay_timer = dig_time_complete
+ / (float)crack_animation_length;
+
+ // We don't want a corresponding delay to
+ // very time consuming nodes
+ if(nodig_delay_timer > 0.3)
+ nodig_delay_timer = 0.3;
+ // We want a slight delay to very little
+ // time consuming nodes
+ float mindelay = 0.15;
+ if(nodig_delay_timer < mindelay)
+ nodig_delay_timer = mindelay;
- 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;
- }
-
- if(dig_index < CRACK_ANIMATION_LENGTH)
- {
- //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.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;
- }
- }
+ // Send event to trigger sound
+ MtEvent *e = new NodeDugEvent(nodepos, wasnode);
+ gamedef->event()->put(e);
+ }
- dig_time += dtime;
+ dig_time += dtime;
- camera.setDigging(0); // left click animation
- }
+ camera.setDigging(0); // left click animation
}
-
-
+
if(input->getRightClicked())
{
infostream<<"Ground right-clicked"<<std::endl;
- // If metadata provides an inventory view, activate it
- if(meta && meta->getInventoryDrawSpecString() != "" && !random_input)
+ // Sign special case, at least until formspec is properly implemented.
+ // Deprecated?
+ if(meta && meta->getString("formspec") == "hack:sign_text_input" && !random_input)
{
- infostream<<"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);
-
- /*
- Create menu
- */
-
- core::array<GUIInventoryMenu::DrawSpec> draw_spec;
- v2s16 invsize =
- GUIInventoryMenu::makeDrawSpecArrayFromString(
- draw_spec,
- meta->getInventoryDrawSpecString(),
- current_name);
-
- GUIInventoryMenu *menu =
- new GUIInventoryMenu(guienv, guiroot, -1,
- &g_menumgr, invsize,
- client.getInventoryContext(),
- &client);
- menu->setDrawSpec(draw_spec);
- menu->drop();
- }
- else if(meta && meta->typeId() == CONTENT_SIGN_WALL && !random_input)
- {
- infostream<<"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->getString("text"));
(new GUITextInputMenu(guienv, guiroot, -1,
&g_menumgr, dest,
wtext))->drop();
}
+ // If metadata provides an inventory view, activate it
+ else if(meta && meta->getString("formspec") != "" && !random_input)
+ {
+ infostream<<"Launching custom inventory view"<<std::endl;
+
+ InventoryLocation inventoryloc;
+ inventoryloc.setNodeMeta(nodepos);
+
+ /* Create menu */
+
+ GUIFormSpecMenu *menu =
+ new GUIFormSpecMenu(device, guiroot, -1,
+ &g_menumgr,
+ &client, gamedef);
+ menu->setFormSpec(meta->getString("formspec"),
+ inventoryloc);
+ menu->setFormSource(new NodeMetadataFormSource(
+ &client.getEnv().getClientMap(), nodepos));
+ menu->setTextDest(new TextDestNodeMetadata(nodepos, &client));
+ menu->drop();
+ }
+ // Otherwise report right click to server
else
{
- client.groundAction(1, nodepos, neighbourpos, g_selected_item);
+ // Report to server
+ client.interact(3, pointed);
camera.setDigging(1); // right click animation
+
+ // If the wielded item has node placement prediction,
+ // make that happen
+ const ItemDefinition &def =
+ playeritem.getDefinition(itemdef);
+ if(def.node_placement_prediction != "")
+ do{ // breakable
+ verbosestream<<"Node placement prediction for "
+ <<playeritem.name<<" is "
+ <<def.node_placement_prediction<<std::endl;
+ v3s16 p = neighbourpos;
+ // Place inside node itself if buildable_to
+ try{
+ MapNode n_under = map.getNode(nodepos);
+ if(nodedef->get(n_under).buildable_to)
+ p = nodepos;
+ }catch(InvalidPositionException &e){}
+ // Find id of predicted node
+ content_t id;
+ bool found =
+ nodedef->getId(def.node_placement_prediction, id);
+ if(!found){
+ errorstream<<"Node placement prediction failed for "
+ <<playeritem.name<<" (places "
+ <<def.node_placement_prediction
+ <<") - Name not known"<<std::endl;
+ break;
+ }
+ MapNode n(id);
+ try{
+ // This triggers the required mesh update too
+ client.addNode(p, n);
+ }catch(InvalidPositionException &e){
+ errorstream<<"Node placement prediction failed for "
+ <<playeritem.name<<" (places "
+ <<def.node_placement_prediction
+ <<") - Position not loaded"<<std::endl;
+ }
+ }while(0);
}
}
-
- nodepos_old = nodepos;
+ }
+ else if(pointed.type == POINTEDTHING_OBJECT)
+ {
+ infotext = narrow_to_wide(selected_object->infoText());
+
+ if(infotext == L"" && show_debug){
+ infotext = narrow_to_wide(selected_object->debugInfoText());
+ }
+
+ //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(
+ dir, &playeritem, time_from_last_punch);
+ time_from_last_punch = 0;
+ if(!disable_send)
+ client.interact(0, pointed);
+ }
+ }
+ else if(input->getRightClicked())
+ {
+ infostream<<"Right-clicked object"<<std::endl;
+ client.interact(3, pointed); // place
+ }
+ }
+ else if(input->getLeftState())
+ {
+ // When button is held down in air, show continuous animation
+ left_punch = true;
}
- } // selected_object == NULL
+ pointed_old = pointed;
- if(left_punch || (input->getLeftClicked() && !left_punch_muted))
+ if(left_punch || input->getLeftClicked())
{
camera.setDigging(0); // left click animation
}
input->resetLeftClicked();
input->resetRightClicked();
-
- if(input->getLeftReleased())
- {
- infostream<<"Left button released (stopped digging)"
- <<std::endl;
- client.groundAction(2, v3s16(0,0,0), v3s16(0,0,0), 0);
- }
- if(input->getRightReleased())
- {
- //inostream<<DTIME<<"Right released"<<std::endl;
- // Nothing here
- }
-
+
input->resetLeftReleased();
input->resetRightReleased();
Calculate stuff for drawing
*/
- u32 daynight_ratio = client.getDayNightRatio();
- u8 l = decode_light((daynight_ratio * LIGHT_SUN) / 1000);
- 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;
+ /*
+ Fog range
+ */
+
+ f32 fog_range;
+ if(farmesh)
+ {
+ fog_range = BS*farmesh_range;
+ }
+ else
+ {
+ fog_range = draw_control.wanted_range*BS + 0.0*MAP_BLOCKSIZE*BS;
+ fog_range *= 0.9;
+ if(draw_control.range_all)
+ fog_range = 100000*BS;
+ }
/*
- Update skybox
+ Calculate general brightness
*/
- if(fabs(brightness - old_brightness) > 0.01)
- update_skybox(driver, smgr, skybox, brightness);
+ u32 daynight_ratio = client.getEnv().getDayNightRatio();
+ float time_brightness = (float)decode_light(
+ (daynight_ratio * LIGHT_SUN) / 1000) / 255.0;
+ float direct_brightness = 0;
+ bool sunlight_seen = false;
+ if(g_settings->getBool("free_move")){
+ direct_brightness = time_brightness;
+ sunlight_seen = true;
+ } else {
+ ScopeProfiler sp(g_profiler, "Detecting background light", SPT_AVG);
+ float old_brightness = sky->getBrightness();
+ direct_brightness = (float)client.getEnv().getClientMap()
+ .getBackgroundBrightness(MYMIN(fog_range*1.2, 60*BS),
+ daynight_ratio, (int)(old_brightness*255.5), &sunlight_seen)
+ / 255.0;
+ }
+
+ time_of_day = client.getEnv().getTimeOfDayF();
+ float maxsm = 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;
+ 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;
+ else
+ time_of_day_smooth = time_of_day_smooth * (1.0-todsm)
+ + time_of_day * todsm;
+
+ sky->update(time_of_day_smooth, time_brightness, direct_brightness,
+ sunlight_seen);
+
+ float brightness = sky->getBrightness();
+ video::SColor bgcolor = sky->getBgColor();
+ video::SColor skycolor = sky->getSkyColor();
/*
Update clouds
*/
- if(clouds)
- {
- clouds->step(dtime);
- clouds->update(v2f(player_position.X, player_position.Z),
- 0.05+brightness*0.95);
+ if(clouds){
+ if(sky->getCloudsVisible()){
+ clouds->setVisible(true);
+ clouds->step(dtime);
+ clouds->update(v2f(player_position.X, player_position.Z),
+ sky->getCloudColor());
+ } else{
+ clouds->setVisible(false);
+ }
}
/*
farmesh->step(dtime);
farmesh->update(v2f(player_position.X, player_position.Z),
- 0.05+brightness*0.95, farmesh_range);
+ brightness, farmesh_range);
}
- // Store brightness value
- old_brightness = brightness;
-
/*
Fog
*/
if(g_settings->getBool("enable_fog") == true && !force_fog_off)
{
- f32 range;
- if(farmesh)
- {
- range = BS*farmesh_range;
- }
- 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;*/
- }
-
driver->setFog(
bgcolor,
video::EFT_FOG_LINEAR,
- range*0.4,
- range*1.0,
+ fog_range*0.4,
+ fog_range*1.0,
0.01,
false, // pixel fog
false // range fog
//TimeTaker guiupdatetimer("Gui updating");
+ const char program_name_and_version[] =
+ "Minetest-c55 " VERSION_STRING;
+
+ if(show_debug)
{
static float drawtime_avg = 0;
drawtime_avg = drawtime_avg * 0.95 + (float)drawtime*0.05;
- static float beginscenetime_avg = 0;
+ /*static float beginscenetime_avg = 0;
beginscenetime_avg = beginscenetime_avg * 0.95 + (float)beginscenetime*0.05;
static float scenetime_avg = 0;
scenetime_avg = scenetime_avg * 0.95 + (float)scenetime*0.05;
static float endscenetime_avg = 0;
- endscenetime_avg = endscenetime_avg * 0.95 + (float)endscenetime*0.05;
+ endscenetime_avg = endscenetime_avg * 0.95 + (float)endscenetime*0.05;*/
char temptext[300];
- snprintf(temptext, 300, "Minetest-c55 %s ("
+ snprintf(temptext, 300, "%s ("
"R: range_all=%i"
")"
- " drawtime=%.0f, beginscenetime=%.0f"
- ", scenetime=%.0f, endscenetime=%.0f",
- VERSION_STRING,
+ " drawtime=%.0f, dtime_jitter = % .1f %%"
+ ", v_range = %.1f, RTT = %.3f",
+ program_name_and_version,
draw_control.range_all,
drawtime_avg,
- beginscenetime_avg,
- scenetime_avg,
- endscenetime_avg
+ dtime_jitter1_max_fraction * 100.0,
+ draw_control.wanted_range,
+ client.getRTT()
);
guitext->setText(narrow_to_wide(temptext).c_str());
+ guitext->setVisible(true);
+ }
+ else if(show_hud || show_chat)
+ {
+ guitext->setText(narrow_to_wide(program_name_and_version).c_str());
+ guitext->setVisible(true);
+ }
+ else
+ {
+ guitext->setVisible(false);
}
+ if(show_debug)
{
char temptext[300];
snprintf(temptext, 300,
"(% .1f, % .1f, % .1f)"
- " (% .3f < btime_jitter < % .3f"
- ", dtime_jitter = % .1f %%"
- ", v_range = %.1f, RTT = %.3f)",
+ " (yaw = %.1f) (seed = %lli)",
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,
- client.getRTT()
- );
+ wrapDegrees_0_360(camera_yaw),
+ client.getMapSeed());
guitext2->setText(narrow_to_wide(temptext).c_str());
+ guitext2->setVisible(true);
+ }
+ else
+ {
+ guitext2->setVisible(false);
}
{
guitext_info->setText(infotext.c_str());
+ guitext_info->setVisible(show_hud && g_menumgr.menuCount() == 0);
+ }
+
+ {
+ float statustext_time_max = 1.5;
+ if(!statustext.empty())
+ {
+ statustext_time += dtime;
+ if(statustext_time >= statustext_time_max)
+ {
+ statustext = L"";
+ statustext_time = 0;
+ }
+ }
+ guitext_status->setText(statustext.c_str());
+ guitext_status->setVisible(!statustext.empty());
+
+ if(!statustext.empty())
+ {
+ s32 status_y = screensize.Y - 130;
+ core::rect<s32> rect(
+ 10,
+ status_y - guitext_status->getTextHeight(),
+ screensize.X - 10,
+ status_y
+ );
+ guitext_status->setRelativePosition(rect);
+
+ // Fade out
+ video::SColor initial_color(255,0,0,0);
+ if(guienv->getSkin())
+ initial_color = guienv->getSkin()->getColor(gui::EGDC_BUTTON_TEXT);
+ video::SColor final_color = initial_color;
+ final_color.setAlpha(0);
+ video::SColor fade_color =
+ initial_color.getInterpolated_quadratic(
+ initial_color,
+ final_color,
+ pow(statustext_time / (float)statustext_time_max, 2.0f));
+ guitext_status->setOverrideColor(fade_color);
+ guitext_status->enableOverrideColor(true);
+ }
}
/*
Get chat messages from client
*/
{
- // Get new messages
- std::wstring message;
- while(client.getChatMessage(message))
+ // Get new messages from error log buffer
+ while(!chat_log_error_buf.empty())
{
- chat_lines.push_back(ChatLine(message));
- /*if(chat_lines.size() > 6)
- {
- core::list<ChatLine>::Iterator
- i = chat_lines.begin();
- chat_lines.erase(i);
- }*/
- }
- // Append them to form the whole static text and throw
- // it to the gui element
- std::wstring whole;
- // This will correspond to the line number counted from
- // top to bottom, from size-1 to 0
- s16 line_number = chat_lines.size();
- // Count of messages to be removed from the top
- u16 to_be_removed_count = 0;
- for(core::list<ChatLine>::Iterator
- i = chat_lines.begin();
- i != chat_lines.end(); i++)
- {
- // After this, line number is valid for this loop
- line_number--;
- // Increment age
- (*i).age += dtime;
- /*
- This results in a maximum age of 60*6 to the
- lowermost line and a maximum of 6 lines
- */
- float allowed_age = (6-line_number) * 60.0;
-
- if((*i).age > allowed_age)
- {
- to_be_removed_count++;
- continue;
- }
- whole += (*i).text + L'\n';
+ chat_backend.addMessage(L"", narrow_to_wide(
+ chat_log_error_buf.get()));
}
- for(u16 i=0; i<to_be_removed_count; i++)
+ // Get new messages from client
+ std::wstring message;
+ while(client.getChatMessage(message))
{
- core::list<ChatLine>::Iterator
- it = chat_lines.begin();
- chat_lines.erase(it);
+ chat_backend.addUnparsedMessage(message);
}
- guitext_chat->setText(whole.c_str());
+ // Remove old messages
+ chat_backend.step(dtime);
- // Update gui element size and position
+ // Display all messages in a static text element
+ u32 recent_chat_count = chat_backend.getRecentBuffer().getLineCount();
+ std::wstring recent_chat = chat_backend.getRecentChat();
+ guitext_chat->setText(recent_chat.c_str());
- /*core::rect<s32> rect(
- 10,
- screensize.Y - guitext_chat_pad_bottom
- - text_height*chat_lines.size(),
- screensize.X - 10,
- screensize.Y - guitext_chat_pad_bottom
- );*/
+ // Update gui element size and position
+ s32 chat_y = 5+(text_height+5);
+ if(show_debug)
+ chat_y += (text_height+5);
core::rect<s32> rect(
- 10,
- 50,
- screensize.X - 10,
- 50 + guitext_chat->getTextHeight()
+ 10,
+ chat_y,
+ screensize.X - 10,
+ chat_y + guitext_chat->getTextHeight()
);
-
guitext_chat->setRelativePosition(rect);
- // 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);
+ // Don't show chat if disabled or empty or profiler is enabled
+ guitext_chat->setVisible(show_chat && recent_chat_count != 0
+ && !show_profiler);
}
/*
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())
{
- client.selectPlayerItem(g_selected_item);
- old_selected_item = g_selected_item;
//infostream<<"Updating local inventory"<<std::endl;
client.getLocalInventory(local_inventory);
-
+
+ update_wielded_item_trigger = true;
+ }
+ if(update_wielded_item_trigger)
+ {
+ update_wielded_item_trigger = false;
// Update wielded tool
InventoryList *mlist = local_inventory.getList("main");
- InventoryItem *item = NULL;
+ ItemStack item;
if(mlist != NULL)
- item = mlist->getItem(g_selected_item);
+ item = mlist->getItem(client.getPlayerItem());
camera.wield(item);
}
-
+
/*
- Send actions returned by the inventory menu
+ Update block draw list every 200ms or when camera direction has
+ changed much
*/
- while(inventory_action_queue.size() != 0)
- {
- InventoryAction *a = inventory_action_queue.pop_front();
-
- client.sendInventoryAction(a);
- // Eat it
- delete a;
+ update_draw_list_timer += dtime;
+ if(update_draw_list_timer >= 0.2 ||
+ update_draw_list_last_cam_dir.getDistanceFrom(camera_direction) > 0.2){
+ update_draw_list_timer = 0;
+ client.getEnv().getClientMap().updateDrawList(driver);
+ update_draw_list_last_cam_dir = camera_direction;
}
/*
Drawing begins
*/
- TimeTaker drawtimer("Drawing");
+ TimeTaker tt_draw("mainloop: draw");
{
TimeTaker timer("beginScene");
- driver->beginScene(true, true, bgcolor);
//driver->beginScene(false, true, bgcolor);
+ //driver->beginScene(true, true, bgcolor);
+ driver->beginScene(true, true, skycolor);
beginscenetime = timer.stop(true);
}
//timer3.stop();
-
+
//infostream<<"smgr->drawAll()"<<std::endl;
-
{
TimeTaker timer("smgr");
smgr->drawAll();
driver->setTransform(video::ETS_WORLD, core::IdentityMatrix);
- for(core::list< core::aabbox3d<f32> >::Iterator i=hilightboxes.begin();
- i != hilightboxes.end(); i++)
- {
- /*infostream<<"hilightbox min="
- <<"("<<i->MinEdge.X<<","<<i->MinEdge.Y<<","<<i->MinEdge.Z<<")"
- <<" max="
- <<"("<<i->MaxEdge.X<<","<<i->MaxEdge.Y<<","<<i->MaxEdge.Z<<")"
- <<std::endl;*/
- driver->draw3DBox(*i, video::SColor(255,0,0,0));
+ if(show_hud)
+ {
+ for(std::vector<aabb3f>::const_iterator
+ i = hilightboxes.begin();
+ i != hilightboxes.end(); i++)
+ {
+ /*infostream<<"hilightbox min="
+ <<"("<<i->MinEdge.X<<","<<i->MinEdge.Y<<","<<i->MinEdge.Z<<")"
+ <<" max="
+ <<"("<<i->MaxEdge.X<<","<<i->MaxEdge.Y<<","<<i->MaxEdge.Z<<")"
+ <<std::endl;*/
+ driver->draw3DBox(*i, video::SColor(255,0,0,0));
+ }
}
/*
Wielded tool
*/
+ if(show_hud)
{
// Warning: This clears the Z buffer.
camera.drawWieldedTool();
Post effects
*/
{
- client.renderPostFx();
+ client.getEnv().getClientMap().renderPostFx();
}
/*
- Frametime log
+ Profiler graph
*/
- if(g_settings->getBool("frametime_graph") == true)
+ if(show_profiler_graph)
{
- s32 x = 10;
- for(core::list<float>::Iterator
- i = frametime_log.begin();
- i != frametime_log.end();
- i++)
- {
- driver->draw2DLine(v2s32(x,50),
- v2s32(x,50+(*i)*1000),
- video::SColor(255,255,255,255));
- x++;
- }
+ graph.draw(10, screensize.Y - 10, driver, font);
}
/*
Draw crosshair
*/
- driver->draw2DLine(displaycenter - core::vector2d<s32>(10,0),
- displaycenter + core::vector2d<s32>(10,0),
- video::SColor(255,255,255,255));
- driver->draw2DLine(displaycenter - core::vector2d<s32>(0,10),
- displaycenter + core::vector2d<s32>(0,10),
- video::SColor(255,255,255,255));
+ if(show_hud)
+ {
+ driver->draw2DLine(displaycenter - core::vector2d<s32>(10,0),
+ displaycenter + core::vector2d<s32>(10,0),
+ video::SColor(255,255,255,255));
+ driver->draw2DLine(displaycenter - core::vector2d<s32>(0,10),
+ displaycenter + core::vector2d<s32>(0,10),
+ video::SColor(255,255,255,255));
+ }
} // timer
/*
Draw hotbar
*/
+ if(show_hud)
{
- 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());
}
/*
endscenetime = timer.stop(true);
}
- drawtime = drawtimer.stop(true);
+ drawtime = tt_draw.stop(true);
+ g_profiler->graphAdd("mainloop_draw", (float)drawtime/1000.0f);
/*
End of drawing
device->setWindowCaption(str.c_str());
lastFPS = fps;
}
+
+ /*
+ Log times and stuff for visualization
+ */
+ Profiler::GraphValues values;
+ g_profiler->graphGet(values);
+ graph.put(values);
}
/*
*/
if(clouds)
clouds->drop();
+ if(gui_chat_console)
+ gui_chat_console->drop();
/*
Draw a "shutting down" screen, which will be shown while the map
driver->endScene();
gui_shuttingdowntext->remove();*/
}
+
+ chat_backend.addMessage(L"", L"# Disconnected.");
+ chat_backend.addMessage(L"", L"");
+
+ // Client scope (client is destructed before destructing *def and tsrc)
+ }while(0);
+ } // try-catch
+ catch(SerializationError &e)
+ {
+ error_message = L"A serialization error occurred:\n"
+ + narrow_to_wide(e.what()) + L"\n\nThe server is probably "
+ L" running a different version of Minetest.";
+ errorstream<<wide_to_narrow(error_message)<<std::endl;
+ }
+
+ if(!sound_is_dummy)
+ delete sound;
+ delete nodedef;
+ delete itemdef;
+ delete tsrc;
}
projects / oweals / minetest.git / blobdiff