/*
-Minetest-c55
-Copyright (C) 2010-2011 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2010-2013 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 <IGUIStaticText.h>
#include <IGUIFont.h>
+#include <IMaterialRendererServices.h>
+#include "IMeshCache.h"
#include "client.h"
#include "server.h"
-#include "guiPauseMenu.h"
#include "guiPasswordChange.h"
-#include "guiInventoryMenu.h"
-#include "guiTextInputMenu.h"
-#include "guiDeathScreen.h"
+#include "guiVolumeChange.h"
+#include "guiFormSpecMenu.h"
#include "tool.h"
#include "guiChatConsole.h"
#include "config.h"
+#include "version.h"
#include "clouds.h"
+#include "particles.h"
#include "camera.h"
-#include "farmesh.h"
#include "mapblock.h"
#include "settings.h"
#include "profiler.h"
#include "main.h" // For g_settings
#include "itemdef.h"
#include "tile.h" // For TextureSource
+#include "shader.h" // For ShaderSource
#include "logoutputbuffer.h"
#include "subgame.h"
#include "quicktune_shortcutter.h"
#include "clientmap.h"
+#include "hud.h"
#include "sky.h"
#include "sound.h"
#if USE_SOUND
#include "sound_openal.h"
#endif
#include "event_manager.h"
+#include <iomanip>
#include <list>
+#include "util/directiontables.h"
+#include "util/pointedthing.h"
+#include "drawscene.h"
+#include "content_cao.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
-
+#ifdef HAVE_TOUCHSCREENGUI
+#include "touchscreengui.h"
+#endif
/*
Text input system
*/
-struct TextDestChat : public TextDest
+struct TextDestNodeMetadata : public TextDest
{
- TextDestChat(Client *client)
+ TextDestNodeMetadata(v3s16 p, Client *client)
{
+ m_p = p;
m_client = client;
}
+ // This is deprecated I guess? -celeron55
void gotText(std::wstring text)
{
- m_client->typeChatMessage(text);
+ std::string ntext = wide_to_narrow(text);
+ 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 TextDestNodeMetadata : public TextDest
+struct TextDestPlayerInventory : public TextDest
{
- TextDestNodeMetadata(v3s16 p, Client *client)
+ TextDestPlayerInventory(Client *client)
{
- m_p = p;
m_client = client;
+ m_formname = "";
}
- void gotText(std::wstring text)
+ TextDestPlayerInventory(Client *client, std::string formname)
{
- std::string ntext = wide_to_narrow(text);
- infostream<<"Changing text of a sign node: "
- <<ntext<<std::endl;
- m_client->sendSignNodeText(m_p, ntext);
+ m_client = client;
+ m_formname = formname;
+ }
+ void gotText(std::map<std::string, std::string> fields)
+ {
+ m_client->sendInventoryFields(m_formname, fields);
}
- v3s16 m_p;
Client *m_client;
};
-/* Respawn menu callback */
-
-class MainRespawnInitiator: public IRespawnInitiator
+struct LocalFormspecHandler : public TextDest
{
-public:
- MainRespawnInitiator(bool *active, Client *client):
- m_active(active), m_client(client)
+ LocalFormspecHandler();
+ LocalFormspecHandler(std::string formname) :
+ m_client(0)
{
- *m_active = true;
+ m_formname = formname;
}
- void respawn()
+
+ LocalFormspecHandler(std::string formname, Client *client) :
+ m_client(client)
{
- *m_active = false;
- m_client->sendRespawn();
+ m_formname = formname;
}
-private:
- bool *m_active;
+
+ void gotText(std::wstring message) {
+ errorstream << "LocalFormspecHandler::gotText old style message received" << std::endl;
+ }
+
+ void gotText(std::map<std::string, std::string> fields)
+ {
+ if (m_formname == "MT_PAUSE_MENU") {
+ if (fields.find("btn_sound") != fields.end()) {
+ g_gamecallback->changeVolume();
+ return;
+ }
+
+ if (fields.find("btn_exit_menu") != fields.end()) {
+ g_gamecallback->disconnect();
+ return;
+ }
+
+ if (fields.find("btn_exit_os") != fields.end()) {
+ g_gamecallback->exitToOS();
+ return;
+ }
+
+ if (fields.find("btn_change_password") != fields.end()) {
+ g_gamecallback->changePassword();
+ return;
+ }
+
+ if (fields.find("quit") != fields.end()) {
+ return;
+ }
+
+ if (fields.find("btn_continue") != fields.end()) {
+ return;
+ }
+ }
+ if (m_formname == "MT_CHAT_MENU") {
+ assert(m_client != 0);
+ if ((fields.find("btn_send") != fields.end()) ||
+ (fields.find("quit") != fields.end())) {
+ if (fields.find("f_text") != fields.end()) {
+ m_client->typeChatMessage(narrow_to_wide(fields["f_text"]));
+ }
+ return;
+ }
+ }
+
+ if (m_formname == "MT_DEATH_SCREEN") {
+ assert(m_client != 0);
+ if ((fields.find("btn_respawn") != fields.end())) {
+ m_client->sendRespawn();
+ return;
+ }
+
+ if (fields.find("quit") != fields.end()) {
+ m_client->sendRespawn();
+ return;
+ }
+ }
+
+ // don't show error message for unhandled cursor keys
+ if ( (fields.find("key_up") != fields.end()) ||
+ (fields.find("key_down") != fields.end()) ||
+ (fields.find("key_left") != fields.end()) ||
+ (fields.find("key_right") != fields.end())) {
+ return;
+ }
+
+ errorstream << "LocalFormspecHandler::gotText unhandled >" << m_formname << "< event" << std::endl;
+ int i = 0;
+ for (std::map<std::string,std::string>::iterator iter = fields.begin();
+ iter != fields.end(); iter++) {
+ errorstream << "\t"<< i << ": " << iter->first << "=" << iter->second << std::endl;
+ i++;
+ }
+ }
+
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, u16 playeritem)
+/* Form update callback */
+
+class NodeMetadataFormSource: public IFormSource
{
- InventoryList *mainlist = inventory->getList("main");
- if(mainlist == NULL)
+public:
+ NodeMetadataFormSource(ClientMap *map, v3s16 p):
+ m_map(map),
+ m_p(p)
{
- errorstream<<"draw_hotbar(): mainlist == NULL"<<std::endl;
- return;
}
-
- s32 padding = imgsize/12;
- //s32 height = imgsize + padding*2;
- s32 width = itemcount*(imgsize+padding*2);
-
- // Position of upper left corner of bar
- v2s32 pos = centerlowerpos - v2s32(width/2, imgsize+padding*2);
-
- // Draw background color
- /*core::rect<s32> barrect(0,0,width,height);
- barrect += pos;
- video::SColor bgcolor(255,128,128,128);
- driver->draw2DRectangle(bgcolor, barrect, NULL);*/
-
- core::rect<s32> imgrect(0,0,imgsize,imgsize);
-
- for(s32 i=0; i<itemcount; i++)
+ std::string getForm()
{
- const ItemStack &item = mainlist->getItem(i);
-
- core::rect<s32> rect = imgrect + pos
- + v2s32(padding+i*(imgsize+padding*2), padding);
-
- 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);
- */
- }
+ 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);
+ }
- video::SColor bgcolor2(128,0,0,0);
- driver->draw2DRectangle(bgcolor2, rect, NULL);
- drawItemStack(driver, font, item, rect, NULL, gamedef);
+ ClientMap *m_map;
+ v3s16 m_p;
+};
+
+class PlayerInventoryFormSource: public IFormSource
+{
+public:
+ PlayerInventoryFormSource(Client *client):
+ m_client(client)
+ {
}
-
- /*
- Draw hearts
- */
- video::ITexture *heart_texture =
- gamedef->getTextureSource()->getTextureRaw("heart.png");
- if(heart_texture)
+ std::string getForm()
{
- v2s32 p = pos + v2s32(0, -20);
- for(s32 i=0; i<halfheartcount/2; i++)
- {
- const video::SColor color(255,255,255,255);
- const video::SColor colors[] = {color,color,color,color};
- core::rect<s32> rect(0,0,16,16);
- rect += p;
- driver->draw2DImage(heart_texture, rect,
- core::rect<s32>(core::position2d<s32>(0,0),
- core::dimension2di(heart_texture->getOriginalSize())),
- NULL, colors, true);
- p += v2s32(16,0);
- }
- if(halfheartcount % 2 == 1)
- {
- const video::SColor color(255,255,255,255);
- const video::SColor colors[] = {color,color,color,color};
- core::rect<s32> rect(0,0,16/2,16);
- rect += p;
- core::dimension2di srcd(heart_texture->getOriginalSize());
- srcd.Width /= 2;
- driver->draw2DImage(heart_texture, rect,
- core::rect<s32>(core::position2d<s32>(0,0), srcd),
- NULL, colors, true);
- p += v2s32(16,0);
- }
+ LocalPlayer* player = m_client->getEnv().getLocalPlayer();
+ return player->inventory_formspec;
}
-}
+
+ Client *m_client;
+};
/*
Check if a node is pointable
Find what the player is pointing at
*/
PointedThing getPointedThing(Client *client, v3f player_position,
- v3f camera_direction, v3f camera_position,
- core::line3d<f32> shootline, f32 d,
- bool liquids_pointable,
- bool look_for_object,
- core::aabbox3d<f32> &hilightbox,
- bool &should_show_hilightbox,
- ClientActiveObject *&selected_object)
+ v3f camera_direction, v3f camera_position, core::line3d<f32> shootline,
+ f32 d, bool liquids_pointable, bool look_for_object, v3s16 camera_offset,
+ std::vector<aabb3f> &hilightboxes, ClientActiveObject *&selected_object)
{
PointedThing result;
- hilightbox = core::aabbox3d<f32>(0,0,0,0,0,0);
- should_show_hilightbox = false;
+ hilightboxes.clear();
selected_object = NULL;
INodeDefManager *nodedef = client->getNodeDefManager();
ClientMap &map = client->getEnv().getClientMap();
+ f32 mindistance = BS * 1001;
+
// 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
- );
+ 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 - intToFloat(camera_offset, BS),
+ selection_box->MaxEdge + pos - intToFloat(camera_offset, BS)));
+ }
- should_show_hilightbox = selected_object->doShowSelectionBox();
+ mindistance = (selected_object->getPosition() - camera_position).getLength();
- result.type = POINTEDTHING_OBJECT;
- result.object_id = selected_object->getId();
- return result;
+ result.type = POINTEDTHING_OBJECT;
+ result.object_id = selected_object->getId();
+ }
}
// That didn't work, try to find a pointed at node
- f32 mindistance = BS * 1001;
-
+
v3s16 pos_i = floatToInt(player_position, BS);
/*infostream<<"pos_i=("<<pos_i.X<<","<<pos_i.Y<<","<<pos_i.Z<<")"
s16 yend = pos_i.Y + 1 + (camera_direction.Y>0 ? a : 1);
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++)
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
- };
-
- const ContentFeatures &f = nodedef->get(n);
-
- if(f.selection_box.type == NODEBOX_FIXED)
+
+ for(std::vector<aabb3f>::const_iterator
+ i = boxes.begin();
+ i != boxes.end(); i++)
{
- core::aabbox3d<f32> box = f.selection_box.fixed;
+ aabb3f box = *i;
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> 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
- ),
- };
-
- for(u16 i=0; i<6; i++)
+ for(u16 j=0; j<6; j++)
{
- v3f facedir_f(facedirs[i].X, facedirs[i].Y, facedirs[i].Z);
- v3f centerpoint = npf + facedir_f * BS/2;
+ 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(!faceboxes[i].intersectsWithLine(shootline))
+ if(!facebox.intersectsWithLine(shootline))
continue;
+
+ v3s16 np_above = np + facedir;
+
result.type = POINTEDTHING_NODE;
result.node_undersurface = np;
- result.node_abovesurface = np+facedirs[i];
+ result.node_abovesurface = np_above;
mindistance = distance;
- hilightbox = box;
- should_show_hilightbox = true;
- }
- }
- else if(f.selection_box.type == NODEBOX_WALLMOUNTED)
- {
- 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();
-
- 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
- };
-
- 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);
- }
-
- box = core::aabbox3d<f32>(vertices[0]);
- box.addInternalPoint(vertices[1]);
- }
- box.MinEdge += npf;
- box.MaxEdge += npf;
-
- if(distance < mindistance)
- {
- if(box.intersectsWithLine(shootline))
- {
- result.type = POINTEDTHING_NODE;
- result.node_undersurface = np;
- result.node_abovesurface = np;
- mindistance = distance;
- hilightbox = box;
- should_show_hilightbox = true;
+ hilightboxes.clear();
+ if (!g_settings->getBool("enable_node_highlighting")) {
+ for(std::vector<aabb3f>::const_iterator
+ i2 = boxes.begin();
+ i2 != boxes.end(); i2++)
+ {
+ aabb3f box = *i2;
+ box.MinEdge += npf + v3f(-d,-d,-d) - intToFloat(camera_offset, BS);
+ box.MaxEdge += npf + v3f(d,d,d) - intToFloat(camera_offset, BS);
+ hilightboxes.push_back(box);
+ }
}
}
}
- else // NODEBOX_REGULAR
- {
- 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))
- {
- result.type = POINTEDTHING_NODE;
- result.node_undersurface = np;
- result.node_abovesurface = np + dirs[i];
- mindistance = distance;
-
- //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(np, BS);
- nodebox.MinEdge += nodepos_f;
- nodebox.MaxEdge += nodepos_f;
- hilightbox = nodebox;
- should_show_hilightbox = true;
- }
- } // if distance < mindistance
- } // for dirs
- } // regular block
} // for coords
return result;
}
-/*
- Draws a screen with a single text on it.
- Text will be removed when the screen is drawn the next time.
-*/
-/*gui::IGUIStaticText **/
-void draw_load_screen(const std::wstring &text,
- video::IVideoDriver* driver, gui::IGUIFont* font)
-{
- v2u32 screensize = driver->getScreenSize();
- const wchar_t *loadingtext = text.c_str();
- core::vector2d<u32> textsize_u = font->getDimension(loadingtext);
- core::vector2d<s32> textsize(textsize_u.X,textsize_u.Y);
- core::vector2d<s32> center(screensize.X/2, screensize.Y/2);
- core::rect<s32> textrect(center - textsize/2, center + textsize/2);
-
- gui::IGUIStaticText *guitext = guienv->addStaticText(
- loadingtext, textrect, false, false);
- guitext->setTextAlignment(gui::EGUIA_CENTER, gui::EGUIA_UPPERLEFT);
-
- driver->beginScene(true, true, video::SColor(255,0,0,0));
- guienv->drawAll();
- driver->endScene();
-
- guitext->remove();
-
- //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)
+ gui::IGUIFont *font, u32 text_height, u32 show_profiler,
+ u32 show_profiler_max)
{
if(show_profiler == 0)
{
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
{
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();
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++){
public:
v3s16 p;
MapNode n;
-
+
NodeDugEvent(v3s16 p, MapNode n):
p(p),
n(n)
sm->m_sound->playSound(sm->m_ndef->get(nde->n).sound_dug, false);
}
+ static void playerDamage(MtEvent *e, void *data)
+ {
+ SoundMaker *sm = (SoundMaker*)data;
+ sm->m_sound->playSound(SimpleSoundSpec("player_damage", 0.5), false);
+ }
+
+ static void playerFallingDamage(MtEvent *e, void *data)
+ {
+ SoundMaker *sm = (SoundMaker*)data;
+ sm->m_sound->playSound(SimpleSoundSpec("player_falling_damage", 0.5), false);
+ }
+
void registerReceiver(MtEventManager *mgr)
{
mgr->reg("ViewBobbingStep", SoundMaker::viewBobbingStep, this);
mgr->reg("CameraPunchLeft", SoundMaker::cameraPunchLeft, this);
mgr->reg("CameraPunchRight", SoundMaker::cameraPunchRight, this);
mgr->reg("NodeDug", SoundMaker::nodeDug, this);
+ mgr->reg("PlayerDamage", SoundMaker::playerDamage, this);
+ mgr->reg("PlayerFallingDamage", SoundMaker::playerFallingDamage, this);
}
void step(float dtime)
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 + "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");
+ 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");
+ }
+};
+
+class GameGlobalShaderConstantSetter : public IShaderConstantSetter
+{
+ Sky *m_sky;
+ bool *m_force_fog_off;
+ f32 *m_fog_range;
+ Client *m_client;
+
+public:
+ GameGlobalShaderConstantSetter(Sky *sky, bool *force_fog_off,
+ f32 *fog_range, Client *client):
+ m_sky(sky),
+ m_force_fog_off(force_fog_off),
+ m_fog_range(fog_range),
+ m_client(client)
+ {}
+ ~GameGlobalShaderConstantSetter() {}
+
+ virtual void onSetConstants(video::IMaterialRendererServices *services,
+ bool is_highlevel)
+ {
+ if(!is_highlevel)
+ return;
+
+ // Background color
+ video::SColor bgcolor = m_sky->getBgColor();
+ video::SColorf bgcolorf(bgcolor);
+ float bgcolorfa[4] = {
+ bgcolorf.r,
+ bgcolorf.g,
+ bgcolorf.b,
+ bgcolorf.a,
+ };
+ services->setPixelShaderConstant("skyBgColor", bgcolorfa, 4);
+
+ // Fog distance
+ float fog_distance = 10000*BS;
+ if(g_settings->getBool("enable_fog") && !*m_force_fog_off)
+ fog_distance = *m_fog_range;
+ services->setPixelShaderConstant("fogDistance", &fog_distance, 1);
+
+ // Day-night ratio
+ u32 daynight_ratio = m_client->getEnv().getDayNightRatio();
+ float daynight_ratio_f = (float)daynight_ratio / 1000.0;
+ services->setPixelShaderConstant("dayNightRatio", &daynight_ratio_f, 1);
+
+ u32 animation_timer = porting::getTimeMs() % 100000;
+ float animation_timer_f = (float)animation_timer / 100000.0;
+ services->setPixelShaderConstant("animationTimer", &animation_timer_f, 1);
+ services->setVertexShaderConstant("animationTimer", &animation_timer_f, 1);
+
+ LocalPlayer* player = m_client->getEnv().getLocalPlayer();
+ v3f eye_position = player->getEyePosition();
+ services->setPixelShaderConstant("eyePosition", (irr::f32*)&eye_position, 3);
+ services->setVertexShaderConstant("eyePosition", (irr::f32*)&eye_position, 3);
+
+ // Uniform sampler layers
+ int layer0 = 0;
+ int layer1 = 1;
+ int layer2 = 2;
+ // before 1.8 there isn't a "integer interface", only float
+#if (IRRLICHT_VERSION_MAJOR == 1 && IRRLICHT_VERSION_MINOR < 8)
+ services->setPixelShaderConstant("baseTexture" , (irr::f32*)&layer0, 1);
+ services->setPixelShaderConstant("normalTexture" , (irr::f32*)&layer1, 1);
+ services->setPixelShaderConstant("useNormalmap" , (irr::f32*)&layer2, 1);
+#else
+ services->setPixelShaderConstant("baseTexture" , (irr::s32*)&layer0, 1);
+ services->setPixelShaderConstant("normalTexture" , (irr::s32*)&layer1, 1);
+ services->setPixelShaderConstant("useNormalmap" , (irr::s32*)&layer2, 1);
+#endif
}
};
-void the_game(
- bool &kill,
- bool random_input,
- InputHandler *input,
- IrrlichtDevice *device,
- gui::IGUIFont* font,
- std::string map_dir,
- std::string playername,
- std::string password,
- std::string address, // If "", local server is used
- u16 port,
- std::wstring &error_message,
- std::string configpath,
- ChatBackend &chat_backend,
- const SubgameSpec &gamespec, // Used for local game,
- bool simple_singleplayer_mode
-)
+bool nodePlacementPrediction(Client &client,
+ const ItemDefinition &playeritem_def, v3s16 nodepos, v3s16 neighbourpos)
+{
+ std::string prediction = playeritem_def.node_placement_prediction;
+ INodeDefManager *nodedef = client.ndef();
+ ClientMap &map = client.getEnv().getClientMap();
+
+ if(prediction != "" && !nodedef->get(map.getNode(nodepos)).rightclickable)
+ {
+ verbosestream<<"Node placement prediction for "
+ <<playeritem_def.name<<" is "
+ <<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;
+ else if (!nodedef->get(map.getNode(p)).buildable_to)
+ return false;
+ }catch(InvalidPositionException &e){}
+ // Find id of predicted node
+ content_t id;
+ bool found = nodedef->getId(prediction, id);
+ if(!found){
+ errorstream<<"Node placement prediction failed for "
+ <<playeritem_def.name<<" (places "
+ <<prediction
+ <<") - Name not known"<<std::endl;
+ return false;
+ }
+ // Predict param2 for facedir and wallmounted nodes
+ u8 param2 = 0;
+ if(nodedef->get(id).param_type_2 == CPT2_WALLMOUNTED){
+ v3s16 dir = nodepos - neighbourpos;
+ if(abs(dir.Y) > MYMAX(abs(dir.X), abs(dir.Z))){
+ param2 = dir.Y < 0 ? 1 : 0;
+ } else if(abs(dir.X) > abs(dir.Z)){
+ param2 = dir.X < 0 ? 3 : 2;
+ } else {
+ param2 = dir.Z < 0 ? 5 : 4;
+ }
+ }
+ if(nodedef->get(id).param_type_2 == CPT2_FACEDIR){
+ v3s16 dir = nodepos - floatToInt(client.getEnv().getLocalPlayer()->getPosition(), BS);
+ if(abs(dir.X) > abs(dir.Z)){
+ param2 = dir.X < 0 ? 3 : 1;
+ } else {
+ param2 = dir.Z < 0 ? 2 : 0;
+ }
+ }
+ assert(param2 >= 0 && param2 <= 5);
+ //Check attachment if node is in group attached_node
+ if(((ItemGroupList) nodedef->get(id).groups)["attached_node"] != 0){
+ static v3s16 wallmounted_dirs[8] = {
+ v3s16(0,1,0),
+ v3s16(0,-1,0),
+ v3s16(1,0,0),
+ v3s16(-1,0,0),
+ v3s16(0,0,1),
+ v3s16(0,0,-1),
+ };
+ v3s16 pp;
+ if(nodedef->get(id).param_type_2 == CPT2_WALLMOUNTED)
+ pp = p + wallmounted_dirs[param2];
+ else
+ pp = p + v3s16(0,-1,0);
+ if(!nodedef->get(map.getNode(pp)).walkable)
+ return false;
+ }
+ // Add node to client map
+ MapNode n(id, 0, param2);
+ try{
+ LocalPlayer* player = client.getEnv().getLocalPlayer();
+
+ // Dont place node when player would be inside new node
+ // NOTE: This is to be eventually implemented by a mod as client-side Lua
+ if (!nodedef->get(n).walkable ||
+ (client.checkPrivilege("noclip") && g_settings->getBool("noclip")) ||
+ (nodedef->get(n).walkable &&
+ neighbourpos != player->getStandingNodePos() + v3s16(0,1,0) &&
+ neighbourpos != player->getStandingNodePos() + v3s16(0,2,0))) {
+
+ // This triggers the required mesh update too
+ client.addNode(p, n);
+ return true;
+ }
+ }catch(InvalidPositionException &e){
+ errorstream<<"Node placement prediction failed for "
+ <<playeritem_def.name<<" (places "
+ <<prediction
+ <<") - Position not loaded"<<std::endl;
+ }
+ }
+ return false;
+}
+
+static inline void create_formspec_menu(GUIFormSpecMenu** cur_formspec,
+ InventoryManager *invmgr, IGameDef *gamedef,
+ IWritableTextureSource* tsrc, IrrlichtDevice * device,
+ IFormSource* fs_src, TextDest* txt_dest
+ ) {
+
+ if (*cur_formspec == 0) {
+ *cur_formspec = new GUIFormSpecMenu(device, guiroot, -1, &g_menumgr,
+ invmgr, gamedef, tsrc, fs_src, txt_dest, cur_formspec );
+ (*cur_formspec)->doPause = false;
+ (*cur_formspec)->drop();
+ }
+ else {
+ (*cur_formspec)->setFormSource(fs_src);
+ (*cur_formspec)->setTextDest(txt_dest);
+ }
+}
+
+#ifdef __ANDROID__
+#define SIZE_TAG "size[11,5.5]"
+#else
+#define SIZE_TAG "size[11,5.5,true]"
+#endif
+
+static void show_chat_menu(GUIFormSpecMenu** cur_formspec,
+ InventoryManager *invmgr, IGameDef *gamedef,
+ IWritableTextureSource* tsrc, IrrlichtDevice * device,
+ Client* client, std::string text)
+{
+ std::string formspec =
+ FORMSPEC_VERSION_STRING
+ SIZE_TAG
+ "field[3,2.35;6,0.5;f_text;;" + text + "]"
+ "button_exit[4,3;3,0.5;btn_send;" + wide_to_narrow(wstrgettext("Proceed")) + "]"
+ ;
+
+ /* Create menu */
+ /* Note: FormspecFormSource and LocalFormspecHandler
+ * are deleted by guiFormSpecMenu */
+ FormspecFormSource* fs_src = new FormspecFormSource(formspec);
+ LocalFormspecHandler* txt_dst = new LocalFormspecHandler("MT_CHAT_MENU", client);
+
+ create_formspec_menu(cur_formspec, invmgr, gamedef, tsrc, device, fs_src, txt_dst);
+}
+
+static void show_deathscreen(GUIFormSpecMenu** cur_formspec,
+ InventoryManager *invmgr, IGameDef *gamedef,
+ IWritableTextureSource* tsrc, IrrlichtDevice * device, Client* client)
{
+ std::string formspec =
+ std::string(FORMSPEC_VERSION_STRING) +
+ SIZE_TAG
+ "bgcolor[#320000b4;true]"
+ "label[4.85,1.35;You died.]"
+ "button_exit[4,3;3,0.5;btn_respawn;" + gettext("Respawn") + "]"
+ ;
+
+ /* Create menu */
+ /* Note: FormspecFormSource and LocalFormspecHandler
+ * are deleted by guiFormSpecMenu */
+ FormspecFormSource* fs_src = new FormspecFormSource(formspec);
+ LocalFormspecHandler* txt_dst = new LocalFormspecHandler("MT_DEATH_SCREEN", client);
+
+ create_formspec_menu(cur_formspec, invmgr, gamedef, tsrc, device, fs_src, txt_dst);
+}
+
+/******************************************************************************/
+static void show_pause_menu(GUIFormSpecMenu** cur_formspec,
+ InventoryManager *invmgr, IGameDef *gamedef,
+ IWritableTextureSource* tsrc, IrrlichtDevice * device,
+ bool singleplayermode)
+{
+#ifdef __ANDROID__
+ std::string control_text = wide_to_narrow(wstrgettext("Default Controls:\n"
+ "No menu visible:\n"
+ "- single tap: button activate\n"
+ "- double tap: place/use\n"
+ "- slide finger: look around\n"
+ "Menu/Inventory visible:\n"
+ "- double tap (outside):\n"
+ " -->close\n"
+ "- touch stack, touch slot:\n"
+ " --> move stack\n"
+ "- touch&drag, tap 2nd finger\n"
+ " --> place single item to slot\n"
+ ));
+#else
+ std::string control_text = wide_to_narrow(wstrgettext("Default Controls:\n"
+ "- WASD: move\n"
+ "- Space: jump/climb\n"
+ "- Shift: sneak/go down\n"
+ "- Q: drop item\n"
+ "- I: inventory\n"
+ "- Mouse: turn/look\n"
+ "- Mouse left: dig/punch\n"
+ "- Mouse right: place/use\n"
+ "- Mouse wheel: select item\n"
+ "- T: chat\n"
+ ));
+#endif
+ float ypos = singleplayermode ? 1.0 : 0.5;
+ std::ostringstream os;
+
+ os << FORMSPEC_VERSION_STRING << SIZE_TAG
+ << "button_exit[4," << (ypos++) << ";3,0.5;btn_continue;"
+ << wide_to_narrow(wstrgettext("Continue")) << "]";
+
+ if (!singleplayermode) {
+ os << "button_exit[4," << (ypos++) << ";3,0.5;btn_change_password;"
+ << wide_to_narrow(wstrgettext("Change Password")) << "]";
+ }
+
+ os << "button_exit[4," << (ypos++) << ";3,0.5;btn_sound;"
+ << wide_to_narrow(wstrgettext("Sound Volume")) << "]";
+ os << "button_exit[4," << (ypos++) << ";3,0.5;btn_exit_menu;"
+ << wide_to_narrow(wstrgettext("Exit to Menu")) << "]";
+ os << "button_exit[4," << (ypos++) << ";3,0.5;btn_exit_os;"
+ << wide_to_narrow(wstrgettext("Exit to OS")) << "]"
+ << "textarea[7.5,0.25;3.9,6.25;;" << control_text << ";]"
+ << "textarea[0.4,0.25;3.5,6;;" << "Minetest\n"
+ << minetest_build_info << "\n"
+ << "path_user = " << wrap_rows(porting::path_user, 20)
+ << "\n;]";
+
+ /* Create menu */
+ /* Note: FormspecFormSource and LocalFormspecHandler *
+ * are deleted by guiFormSpecMenu */
+ FormspecFormSource* fs_src = new FormspecFormSource(os.str());
+ LocalFormspecHandler* txt_dst = new LocalFormspecHandler("MT_PAUSE_MENU");
+
+ create_formspec_menu(cur_formspec, invmgr, gamedef, tsrc, device, fs_src, txt_dst);
+
+ (*cur_formspec)->doPause = true;
+}
+
+/******************************************************************************/
+static void updateChat(Client& client, f32 dtime, bool show_debug,
+ const v2u32& screensize, bool show_chat, u32 show_profiler,
+ ChatBackend& chat_backend, gui::IGUIStaticText* guitext_chat,
+ gui::IGUIFont* font)
+{
+ // Add chat log output for errors to be shown in chat
+ static LogOutputBuffer chat_log_error_buf(LMT_ERROR);
+
+ // Get new messages from error log buffer
+ while(!chat_log_error_buf.empty()) {
+ chat_backend.addMessage(L"", narrow_to_wide(chat_log_error_buf.get()));
+ }
+
+ // Get new messages from client
+ std::wstring message;
+ while (client.getChatMessage(message)) {
+ chat_backend.addUnparsedMessage(message);
+ }
+
+ // Remove old messages
+ chat_backend.step(dtime);
+
+ // Display all messages in a static text element
+ unsigned int recent_chat_count = chat_backend.getRecentBuffer().getLineCount();
+ std::wstring recent_chat = chat_backend.getRecentChat();
+
+ // TODO replace by fontengine fcts
+ unsigned int line_height = font->getDimension(L"Ay").Height + font->getKerningHeight();
+
+ guitext_chat->setText(recent_chat.c_str());
+
+ // Update gui element size and position
+ s32 chat_y = 5 + line_height;
+ if (show_debug)
+ chat_y += line_height;
+
+ core::rect<s32> rect(10, chat_y, font->getDimension(recent_chat.c_str()).Width +10,
+ chat_y + (recent_chat_count * line_height));
+
+ guitext_chat->setRelativePosition(rect);
+ // Don't show chat if disabled or empty or profiler is enabled
+ guitext_chat->setVisible(
+ show_chat && recent_chat_count != 0 && !show_profiler);
+}
+
+/******************************************************************************/
+void the_game(bool &kill, bool random_input, InputHandler *input,
+ IrrlichtDevice *device, gui::IGUIFont* font, std::string map_dir,
+ std::string playername, std::string password,
+ std::string address /* If "", local server is used */,
+ u16 port, std::wstring &error_message, ChatBackend &chat_backend,
+ const SubgameSpec &gamespec /* Used for local game */,
+ bool simple_singleplayer_mode)
+{
+ GUIFormSpecMenu* current_formspec = 0;
video::IVideoDriver* driver = device->getVideoDriver();
scene::ISceneManager* smgr = device->getSceneManager();
-
+
// Calculate text height using the font
u32 text_height = font->getDimension(L"Random test string").Height;
- v2u32 screensize(0,0);
- v2u32 last_screensize(0,0);
- screensize = driver->getScreenSize();
-
- const s32 hotbar_itemcount = 8;
- //const s32 hotbar_imagesize = 36;
- //const s32 hotbar_imagesize = 64;
- s32 hotbar_imagesize = 48;
-
/*
Draw "Loading" screen
*/
- draw_load_screen(L"Loading...", driver, font);
-
+ {
+ wchar_t* text = wgettext("Loading...");
+ draw_load_screen(text, device, guienv, font, 0, 0);
+ delete[] text;
+ }
+
// Create texture source
IWritableTextureSource *tsrc = createTextureSource(device);
-
+
+ // Create shader source
+ IWritableShaderSource *shsrc = createShaderSource(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;
ISoundManager *sound = NULL;
bool sound_is_dummy = false;
#if USE_SOUND
- infostream<<"Attempting to use OpenAL audio"<<std::endl;
- sound = createOpenALSoundManager(&soundfetcher);
- if(!sound)
- infostream<<"Failed to initialize OpenAL audio"<<std::endl;
+ 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_is_dummy = true;
}
+ Server *server = NULL;
+
+ try{
// 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.
*/
- SharedPtr<Server> server;
+
if(address == ""){
- draw_load_screen(L"Creating server...", driver, font);
+ wchar_t* text = wgettext("Creating server....");
+ draw_load_screen(text, device, guienv, font, 0, 25);
+ delete[] text;
infostream<<"Creating server"<<std::endl;
- server = new Server(map_dir, configpath, gamespec,
- simple_singleplayer_mode);
- server->start(port);
+
+ std::string bind_str = g_settings->get("bind_address");
+ Address bind_addr(0,0,0,0, port);
+
+ if (g_settings->getBool("ipv6_server")) {
+ bind_addr.setAddress((IPv6AddressBytes*) NULL);
+ }
+ try {
+ bind_addr.Resolve(bind_str.c_str());
+ address = bind_str;
+ } catch (ResolveError &e) {
+ infostream << "Resolving bind address \"" << bind_str
+ << "\" failed: " << e.what()
+ << " -- Listening on all addresses." << std::endl;
+ }
+
+ if(bind_addr.isIPv6() && !g_settings->getBool("enable_ipv6")) {
+ error_message = L"Unable to listen on " +
+ narrow_to_wide(bind_addr.serializeString()) +
+ L" because IPv6 is disabled";
+ errorstream<<wide_to_narrow(error_message)<<std::endl;
+ // Break out of client scope
+ return;
+ }
+
+ server = new Server(map_dir, gamespec,
+ simple_singleplayer_mode,
+ bind_addr.isIPv6());
+
+ server->start(bind_addr);
}
- try{
do{ // Client scope (breakable do-while(0))
-
+
/*
Create client
*/
- draw_load_screen(L"Creating client...", driver, font);
+ {
+ wchar_t* text = wgettext("Creating client...");
+ draw_load_screen(text, device, guienv, font, 0, 50);
+ delete[] text;
+ }
infostream<<"Creating client"<<std::endl;
-
+
MapDrawControl 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);
+ {
+ wchar_t* text = wgettext("Resolving address...");
+ draw_load_screen(text, device, guienv, font, 0, 75);
+ delete[] text;
+ }
Address connect_address(0,0,0,0, port);
- try{
- if(address == "")
+ try {
+ connect_address.Resolve(address.c_str());
+ if (connect_address.isZero()) { // i.e. INADDR_ANY, IN6ADDR_ANY
//connect_address.Resolve("localhost");
- connect_address.setAddress(127,0,0,1);
- else
- connect_address.Resolve(address.c_str());
+ if (connect_address.isIPv6()) {
+ IPv6AddressBytes addr_bytes;
+ addr_bytes.bytes[15] = 1;
+ connect_address.setAddress(&addr_bytes);
+ } else {
+ connect_address.setAddress(127,0,0,1);
+ }
+ }
}
- catch(ResolveError &e)
- {
- error_message = L"Couldn't resolve address";
+ catch(ResolveError &e) {
+ error_message = L"Couldn't resolve address: " + narrow_to_wide(e.what());
+ errorstream<<wide_to_narrow(error_message)<<std::endl;
+ // Break out of client scope
+ break;
+ }
+ if(connect_address.isIPv6() && !g_settings->getBool("enable_ipv6")) {
+ error_message = L"Unable to connect to " +
+ narrow_to_wide(connect_address.serializeString()) +
+ L" because IPv6 is disabled";
errorstream<<wide_to_narrow(error_message)<<std::endl;
// Break out of client scope
break;
}
+ /*
+ Create client
+ */
+ Client client(device, playername.c_str(), password, draw_control,
+ tsrc, shsrc, itemdef, nodedef, sound, &eventmgr,
+ connect_address.isIPv6());
+
+ // Client acts as our GameDef
+ IGameDef *gamedef = &client;
+
/*
Attempt to connect to the server
*/
-
+
infostream<<"Connecting to server at ";
connect_address.print(&infostream);
infostream<<std::endl;
client.connect(connect_address);
-
+
/*
Wait for server to accept connection
*/
bool could_connect = false;
bool connect_aborted = false;
try{
- float frametime = 0.033;
float time_counter = 0.0;
input->clear();
+ float fps_max = g_settings->getFloat("fps_max");
+ bool cloud_menu_background = g_settings->getBool("menu_clouds");
+ u32 lasttime = device->getTimer()->getTime();
while(device->run())
{
+ f32 dtime = 0.033; // in seconds
+ if (cloud_menu_background) {
+ u32 time = device->getTimer()->getTime();
+ if(time > lasttime)
+ dtime = (time - lasttime) / 1000.0;
+ else
+ dtime = 0;
+ lasttime = time;
+ }
// Update client and server
- client.step(frametime);
+ client.step(dtime);
if(server != NULL)
- server->step(frametime);
-
+ server->step(dtime);
+
// End condition
- if(client.connectedAndInitialized()){
+ if(client.getState() == LC_Init) {
could_connect = true;
break;
}
// Break conditions
- if(client.accessDenied()){
+ if(client.accessDenied()) {
error_message = L"Access denied. Reason: "
+client.accessDeniedReason();
errorstream<<wide_to_narrow(error_message)<<std::endl;
break;
}
- if(input->wasKeyDown(EscapeKey)){
+ if(input->wasKeyDown(EscapeKey) || input->wasKeyDown(CancelKey)) {
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;
+ {
+ wchar_t* text = wgettext("Connecting to server...");
+ draw_load_screen(text, device, guienv, font, dtime, 100);
+ delete[] text;
+ }
+
+ // On some computers framerate doesn't seem to be
+ // automatically limited
+ if (cloud_menu_background) {
+ // Time of frame without fps limit
+ float busytime;
+ u32 busytime_u32;
+ // not using getRealTime is necessary for wine
+ u32 time = device->getTimer()->getTime();
+ if(time > lasttime)
+ busytime_u32 = time - lasttime;
+ else
+ busytime_u32 = 0;
+ busytime = busytime_u32 / 1000.0;
+
+ // FPS limiter
+ u32 frametime_min = 1000./fps_max;
+
+ if(busytime_u32 < frametime_min) {
+ u32 sleeptime = frametime_min - busytime_u32;
+ device->sleep(sleeptime);
+ }
+ } else {
+ sleep_ms(25);
+ }
+ time_counter += dtime;
}
}
catch(con::PeerNotFoundException &e)
{}
-
+
/*
Handle failure to connect
*/
- if(!could_connect){
- if(error_message == L"" && !connect_aborted){
+ 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())
- {
+ float fps_max = g_settings->getFloat("fps_max");
+ bool cloud_menu_background = g_settings->getBool("menu_clouds");
+ u32 lasttime = device->getTimer()->getTime();
+ while (device->run()) {
+ f32 dtime = 0.033; // in seconds
+ if (cloud_menu_background) {
+ u32 time = device->getTimer()->getTime();
+ if(time > lasttime)
+ dtime = (time - lasttime) / 1000.0;
+ else
+ dtime = 0;
+ lasttime = time;
+ }
// Update client and server
- client.step(frametime);
- if(server != NULL)
- server->step(frametime);
-
+ client.step(dtime);
+ if (server != NULL)
+ server->step(dtime);
+
// End condition
- if(client.texturesReceived() &&
+ if (client.mediaReceived() &&
client.itemdefReceived() &&
- client.nodedefReceived()){
+ client.nodedefReceived()) {
got_content = true;
break;
}
// Break conditions
- if(!client.connectedAndInitialized()){
+ if (client.accessDenied()) {
+ error_message = L"Access denied. Reason: "
+ +client.accessDeniedReason();
+ errorstream<<wide_to_narrow(error_message)<<std::endl;
+ break;
+ }
+ if (client.getState() < LC_Init) {
error_message = L"Client disconnected";
errorstream<<wide_to_narrow(error_message)<<std::endl;
break;
}
- if(input->wasKeyDown(EscapeKey)){
+ if (input->wasKeyDown(EscapeKey) || input->wasKeyDown(CancelKey)) {
content_aborted = true;
infostream<<"Connect aborted [Escape]"<<std::endl;
break;
}
-
+
// Display status
- std::wostringstream ss;
- ss<<L"Waiting content... (press Escape to cancel)\n";
-
- 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";
-
- draw_load_screen(ss.str(), driver, font);
-
- // Delay a bit
- sleep_ms(1000*frametime);
- time_counter += frametime;
+ int progress=0;
+ if (!client.itemdefReceived())
+ {
+ wchar_t* text = wgettext("Item definitions...");
+ progress = 0;
+ draw_load_screen(text, device, guienv, font, dtime, progress);
+ delete[] text;
+ }
+ else if (!client.nodedefReceived())
+ {
+ wchar_t* text = wgettext("Node definitions...");
+ progress = 25;
+ draw_load_screen(text, device, guienv, font, dtime, progress);
+ delete[] text;
+ }
+ else
+ {
+
+ std::stringstream message;
+ message.precision(3);
+ message << gettext("Media...");
+
+ if ( ( USE_CURL == 0) ||
+ (!g_settings->getBool("enable_remote_media_server"))) {
+ float cur = client.getCurRate();
+ std::string cur_unit = gettext(" KB/s");
+
+ if (cur > 900) {
+ cur /= 1024.0;
+ cur_unit = gettext(" MB/s");
+ }
+ message << " ( " << cur << cur_unit << " )";
+ }
+ progress = 50+client.mediaReceiveProgress()*50+0.5;
+ draw_load_screen(narrow_to_wide(message.str().c_str()), device,
+ guienv, font, dtime, progress);
+ }
+
+ // On some computers framerate doesn't seem to be
+ // automatically limited
+ if (cloud_menu_background) {
+ // Time of frame without fps limit
+ float busytime;
+ u32 busytime_u32;
+ // not using getRealTime is necessary for wine
+ u32 time = device->getTimer()->getTime();
+ if(time > lasttime)
+ busytime_u32 = time - lasttime;
+ else
+ busytime_u32 = 0;
+ busytime = busytime_u32 / 1000.0;
+
+ // FPS limiter
+ u32 frametime_min = 1000./fps_max;
+
+ if(busytime_u32 < frametime_min) {
+ u32 sleeptime = frametime_min - busytime_u32;
+ device->sleep(sleeptime);
+ }
+ } else {
+ sleep_ms(25);
+ }
+ time_counter += dtime;
}
}
After all content has been received:
Update cached textures, meshes and materials
*/
- client.afterContentReceived();
+ client.afterContentReceived(device,font);
/*
Create the camera node
/*
Clouds
*/
-
+
Clouds *clouds = NULL;
if(g_settings->getBool("enable_clouds"))
{
Sky *sky = NULL;
sky = new Sky(smgr->getRootSceneNode(), smgr, -1);
-
- /*
- FarMesh
- */
- FarMesh *farmesh = NULL;
- if(g_settings->getBool("enable_farmesh"))
- {
- farmesh = new FarMesh(smgr->getRootSceneNode(), smgr, -1, client.getMapSeed(), &client);
- }
+ scene::ISceneNode* skybox = NULL;
/*
A copy of the local inventory
*/
Inventory local_inventory(itemdef);
+ /*
+ Find out size of crack animation
+ */
+ int crack_animation_length = 5;
+ {
+ video::ITexture *t = tsrc->getTexture("crack_anylength.png");
+ v2u32 size = t->getOriginalSize();
+ crack_animation_length = size.Y / size.X;
+ }
+
/*
Add some gui stuff
*/
// First line of debug text
gui::IGUIStaticText *guitext = guienv->addStaticText(
- L"Minetest-c55",
- core::rect<s32>(5, 5, 795, 5+text_height),
- false, false);
+ L"Minetest",
+ core::rect<s32>(0, 0, 0, 0),
+ false, false, guiroot);
// Second line of debug text
gui::IGUIStaticText *guitext2 = guienv->addStaticText(
L"",
- core::rect<s32>(5, 5+(text_height+5)*1, 795, (5+text_height)*2),
- false, false);
+ core::rect<s32>(0, 0, 0, 0),
+ false, false, guiroot);
// At the middle of the screen
// Object infos are shown in this
gui::IGUIStaticText *guitext_info = guienv->addStaticText(
L"",
core::rect<s32>(0,0,400,text_height*5+5) + v2s32(100,200),
- false, false);
-
+ false, true, guiroot);
+
// 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);
+ false, false, guiroot);
guitext_status->setVisible(false);
-
+
std::wstring statustext;
float statustext_time = 0;
-
+
// Chat text
gui::IGUIStaticText *guitext_chat = guienv->addStaticText(
L"",
core::rect<s32>(0,0,0,0),
//false, false); // Disable word wrap as of now
- false, true);
+ false, true, guiroot);
// 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>(0,0,0,0),
- false, false);
+ false, false, guiroot);
guitext_profiler->setBackgroundColor(video::SColor(120,0,0,0));
guitext_profiler->setVisible(false);
-
+ guitext_profiler->setWordWrap(true);
+
+#ifdef HAVE_TOUCHSCREENGUI
+ if (g_touchscreengui)
+ g_touchscreengui->init(tsrc,porting::getDisplayDensity());
+#endif
+
/*
Some statistics are collected in these
*/
u32 drawtime = 0;
u32 beginscenetime = 0;
- u32 scenetime = 0;
u32 endscenetime = 0;
-
+
float recent_turn_speed = 0.0;
-
+
ProfilerGraph graph;
// Initially clear the profiler
Profiler::GraphValues dummyvalues;
bool digging = false;
bool ldown_for_dig = false;
- float damage_flash_timer = 0;
- s16 farmesh_range = 20*MAP_BLOCKSIZE;
+ float damage_flash = 0;
+
+ float jump_timer = 0;
+ bool reset_jump_timer = false;
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 update_wielded_item_trigger = true;
bool show_hud = true;
bool show_chat = true;
bool force_fog_off = false;
+ f32 fog_range = 100*BS;
bool disable_camera_update = false;
bool show_debug = g_settings->getBool("show_debug");
bool show_profiler_graph = false;
float time_of_day = 0;
float time_of_day_smooth = 0;
+ float repeat_rightclick_timer = 0;
+
+ /*
+ Shader constants
+ */
+ shsrc->addGlobalConstantSetter(new GameGlobalShaderConstantSetter(
+ sky, &force_fog_off, &fog_range, &client));
+
/*
Main loop
*/
// NOTE: So we have to use getTime() and call run()s between them
u32 lasttime = device->getTimer()->getTime();
+ LocalPlayer* player = client.getEnv().getLocalPlayer();
+ player->hurt_tilt_timer = 0;
+ player->hurt_tilt_strength = 0;
+
+ /*
+ HUD object
+ */
+ Hud hud(driver, smgr, guienv, font, text_height,
+ gamedef, player, &local_inventory);
+
+ core::stringw str = L"Minetest [";
+ str += driver->getName();
+ str += "]";
+ device->setWindowCaption(str.c_str());
+
+ // Info text
+ std::wstring infotext;
+
for(;;)
{
- if(device->run() == false || kill == true)
+ if(device->run() == false || kill == true ||
+ g_gamecallback->shutdown_requested)
break;
+ v2u32 screensize = driver->getScreenSize();
+
// 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);
// Necessary for device->getTimer()->getTime()
*/
{
- float fps_max = g_settings->getFloat("fps_max");
+ float fps_max = g_menumgr.pausesGame() ?
+ g_settings->getFloat("pause_fps_max") :
+ g_settings->getFloat("fps_max");
u32 frametime_min = 1000./fps_max;
-
+
if(busytime_u32 < frametime_min)
{
u32 sleeptime = frametime_min - busytime_u32;
Time difference calculation
*/
f32 dtime; // in seconds
-
+
u32 time = device->getTimer()->getTime();
if(time > lasttime)
dtime = (time - lasttime) / 1000.0;
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);
jitter1_max = 0.0;
}
}
-
+
/*
Busytime average and jitter calculation
*/
static f32 busytime_avg1 = 0.0;
busytime_avg1 = busytime_avg1 * 0.98 + busytime * 0.02;
f32 busytime_jitter1 = busytime - busytime_avg1;
-
+
static f32 busytime_jitter1_max_sample = 0.0;
static f32 busytime_jitter1_min_sample = 0.0;
{
/*
Handle miscellaneous stuff
*/
-
+
if(client.accessDenied())
{
error_message = L"Access denied. Reason: "
g_gamecallback->changepassword_requested = false;
}
- /*
- Process TextureSource's queue
- */
+ if(g_gamecallback->changevolume_requested)
+ {
+ (new GUIVolumeChange(guienv, guiroot, -1,
+ &g_menumgr, &client))->drop();
+ g_gamecallback->changevolume_requested = false;
+ }
+
+ /* Process TextureSource's queue */
tsrc->processQueue();
+ /* Process ItemDefManager's queue */
+ itemdef->processQueue(gamedef);
+
/*
- Random calculations
+ Process ShaderSource's queue
*/
- 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;
+ shsrc->processQueue();
/*
- Debug info for client
+ Random calculations
*/
- {
- static float counter = 0.0;
- counter -= dtime;
- if(counter < 0)
- {
- counter = 30.0;
- client.printDebugInfo(infostream);
- }
- }
+ hud.resizeHotbar();
+ // Hilight boxes collected during the loop and displayed
+ std::vector<aabb3f> hilightboxes;
+
+ /* reset infotext */
+ infotext = L"";
/*
Profiler
*/
/*
Direct handling of user input
*/
-
+
// Reset input if window not active or some menu is active
if(device->isWindowActive() == false
|| noMenuActive() == false
{
input->clear();
}
+ if (!guienv->hasFocus(gui_chat_console) && gui_chat_console->isOpen())
+ {
+ gui_chat_console->closeConsoleAtOnce();
+ }
// Input handler step() (used by the random input generator)
input->step(dtime);
+#ifdef HAVE_TOUCHSCREENGUI
+ if (g_touchscreengui) {
+ g_touchscreengui->step(dtime);
+ }
+#endif
+#ifdef __ANDROID__
+ if (current_formspec != 0)
+ current_formspec->getAndroidUIInput();
+#endif
+
+ // Increase timer for doubleclick of "jump"
+ if(g_settings->getBool("doubletap_jump") && jump_timer <= 0.2)
+ jump_timer += dtime;
/*
Launch menus and trigger stuff according to keys
{
infostream<<"the_game: "
<<"Launching inventory"<<std::endl;
-
- GUIInventoryMenu *menu =
- new GUIInventoryMenu(guienv, guiroot, -1,
- &g_menumgr, v2s16(8,7),
- &client, gamedef);
- InventoryLocation inventoryloc;
- inventoryloc.setCurrentPlayer();
-
- core::array<GUIInventoryMenu::DrawSpec> draw_spec;
- draw_spec.push_back(GUIInventoryMenu::DrawSpec(
- "list", inventoryloc, "main",
- v2s32(0, 3), v2s32(8, 4)));
- draw_spec.push_back(GUIInventoryMenu::DrawSpec(
- "list", inventoryloc, "craft",
- v2s32(3, 0), v2s32(3, 3)));
- draw_spec.push_back(GUIInventoryMenu::DrawSpec(
- "list", inventoryloc, "craftpreview",
- v2s32(7, 1), v2s32(1, 1)));
+ PlayerInventoryFormSource* fs_src = new PlayerInventoryFormSource(&client);
+ TextDest* txt_dst = new TextDestPlayerInventory(&client);
- menu->setDrawSpec(draw_spec);
+ create_formspec_menu(¤t_formspec, &client, gamedef, tsrc, device, fs_src, txt_dst);
- menu->drop();
+ InventoryLocation inventoryloc;
+ inventoryloc.setCurrentPlayer();
+ current_formspec->setFormSpec(fs_src->getForm(), inventoryloc);
}
- else if(input->wasKeyDown(EscapeKey))
+ else if(input->wasKeyDown(EscapeKey) || input->wasKeyDown(CancelKey))
{
- infostream<<"the_game: "
- <<"Launching pause menu"<<std::endl;
- // It will delete itself by itself
- (new GUIPauseMenu(guienv, guiroot, -1, g_gamecallback,
- &g_menumgr, simple_singleplayer_mode))->drop();
-
- // Move mouse cursor on top of the disconnect button
- if(simple_singleplayer_mode)
- input->setMousePos(displaycenter.X, displaycenter.Y+0);
- else
- input->setMousePos(displaycenter.X, displaycenter.Y+25);
+ show_pause_menu(¤t_formspec, &client, gamedef, tsrc, device,
+ simple_singleplayer_mode);
}
else if(input->wasKeyDown(getKeySetting("keymap_chat")))
{
- TextDest *dest = new TextDestChat(&client);
-
- (new GUITextInputMenu(guienv, guiroot, -1,
- &g_menumgr, dest,
- L""))->drop();
+ show_chat_menu(¤t_formspec, &client, gamedef, tsrc, device,
+ &client,"");
}
else if(input->wasKeyDown(getKeySetting("keymap_cmd")))
{
- TextDest *dest = new TextDestChat(&client);
-
- (new GUITextInputMenu(guienv, guiroot, -1,
- &g_menumgr, dest,
- L"/"))->drop();
+ show_chat_menu(¤t_formspec, &client, gamedef, tsrc, device,
+ &client,"/");
}
else if(input->wasKeyDown(getKeySetting("keymap_console")))
{
g_settings->set("free_move","true");
statustext = L"free_move enabled";
statustext_time = 0;
+ if(!client.checkPrivilege("fly"))
+ statustext += L" (note: no 'fly' privilege)";
+ }
+ }
+ else if(input->wasKeyDown(getKeySetting("keymap_jump")))
+ {
+ if(g_settings->getBool("doubletap_jump") && jump_timer < 0.2)
+ {
+ if(g_settings->getBool("free_move"))
+ {
+ g_settings->set("free_move","false");
+ statustext = L"free_move disabled";
+ statustext_time = 0;
+ }
+ else
+ {
+ g_settings->set("free_move","true");
+ statustext = L"free_move enabled";
+ statustext_time = 0;
+ if(!client.checkPrivilege("fly"))
+ statustext += L" (note: no 'fly' privilege)";
+ }
}
+ reset_jump_timer = true;
}
else if(input->wasKeyDown(getKeySetting("keymap_fastmove")))
{
g_settings->set("fast_move","true");
statustext = L"fast_move enabled";
statustext_time = 0;
+ if(!client.checkPrivilege("fast"))
+ statustext += L" (note: no 'fast' privilege)";
+ }
+ }
+ else if(input->wasKeyDown(getKeySetting("keymap_noclip")))
+ {
+ if(g_settings->getBool("noclip"))
+ {
+ g_settings->set("noclip","false");
+ statustext = L"noclip disabled";
+ statustext_time = 0;
+ }
+ else
+ {
+ g_settings->set("noclip","true");
+ statustext = L"noclip enabled";
+ statustext_time = 0;
+ if(!client.checkPrivilege("noclip"))
+ statustext += L" (note: no 'noclip' privilege)";
}
}
else if(input->wasKeyDown(getKeySetting("keymap_screenshot")))
{
- irr::video::IImage* const image = driver->createScreenShot();
- if (image) {
- irr::c8 filename[256];
- 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<<"'";
- infostream<<"Saved screenshot to '"<<filename<<"'"<<std::endl;
- statustext = sstr.str();
- statustext_time = 0;
- } else{
- infostream<<"Failed to save screenshot '"<<filename<<"'"<<std::endl;
+ irr::video::IImage* const raw_image = driver->createScreenShot();
+ if (raw_image) {
+ irr::video::IImage* const image = driver->createImage(video::ECF_R8G8B8,
+ raw_image->getDimension());
+
+ if (image) {
+ raw_image->copyTo(image);
+ irr::c8 filename[256];
+ snprintf(filename, sizeof(filename), "%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 << "'";
+ infostream << "Saved screenshot to '" << filename << "'" << std::endl;
+ statustext = sstr.str();
+ statustext_time = 0;
+ } else {
+ infostream << "Failed to save screenshot '" << filename << "'" << std::endl;
+ }
+ image->drop();
}
- image->drop();
- }
+ raw_image->drop();
+ }
}
else if(input->wasKeyDown(getKeySetting("keymap_toggle_hud")))
{
show_hud = !show_hud;
- if(show_hud)
+ if(show_hud) {
statustext = L"HUD shown";
- else
+ client.setHighlighted(client.getHighlighted(), true);
+ } else {
statustext = L"HUD hidden";
+ client.setHighlighted(client.getHighlighted(), false);
+ }
statustext_time = 0;
}
else if(input->wasKeyDown(getKeySetting("keymap_toggle_chat")))
+ itos(range_new));
statustext_time = 0;
}
-
+
+ // Reset jump_timer
+ if(!input->isKeyDown(getKeySetting("keymap_jump")) && reset_jump_timer)
+ {
+ reset_jump_timer = false;
+ jump_timer = 0.0;
+ }
+
// Handle QuicktuneShortcutter
if(input->wasKeyDown(getKeySetting("keymap_quicktune_next")))
quicktune.next();
{
s32 wheel = input->getMouseWheel();
u16 max_item = MYMIN(PLAYER_INVENTORY_SIZE-1,
- hotbar_itemcount-1);
+ player->hud_hotbar_itemcount-1);
if(wheel < 0)
{
new_playeritem = max_item;
}
}
-
+
// Item selection
for(u16 i=0; i<10; i++)
{
const KeyPress *kp = NumberKey + (i + 1) % 10;
if(input->wasKeyDown(*kp))
{
- if(i < PLAYER_INVENTORY_SIZE && i < hotbar_itemcount)
+ if(i < PLAYER_INVENTORY_SIZE && i < player->hud_hotbar_itemcount)
{
new_playeritem = i;
Mouse and camera control
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)
{
+#ifndef __ANDROID__
if(!random_input)
{
// Mac OSX gets upset if this is set every frame
if(device->getCursorControl()->isVisible())
device->getCursorControl()->setVisible(false);
}
+#endif
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)
+ } else {
+#ifdef HAVE_TOUCHSCREENGUI
+ if (g_touchscreengui) {
+ camera_yaw = g_touchscreengui->getYaw();
+ camera_pitch = g_touchscreengui->getPitch();
+ } else {
+#endif
+ s32 dx = input->getMousePos().X - (driver->getScreenSize().Width/2);
+ s32 dy = input->getMousePos().Y - (driver->getScreenSize().Height/2);
+ if ((invert_mouse)
+ || (camera.getCameraMode() == CAMERA_MODE_THIRD_FRONT)) {
dy = -dy;
+ }
//infostream<<"window active, pos difference "<<dx<<","<<dy<<std::endl;
-
+
/*const float keyspeed = 500;
if(input->isKeyDown(irr::KEY_UP))
dy -= dtime * keyspeed;
dx -= dtime * keyspeed;
if(input->isKeyDown(irr::KEY_RIGHT))
dx += dtime * keyspeed;*/
-
- float d = 0.2;
+
+ float d = g_settings->getFloat("mouse_sensitivity");
+ d = rangelim(d, 0.01, 100.0);
camera_yaw -= dx*d;
camera_pitch += dy*d;
+ turn_amount = v2f(dx, dy).getLength() * d;
+
+#ifdef HAVE_TOUCHSCREENGUI
+ }
+#endif
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);
+ input->setMousePos((driver->getScreenSize().Width/2),
+ (driver->getScreenSize().Height/2));
}
else{
+#ifndef ANDROID
// Mac OSX gets upset if this is set every frame
if(device->getCursorControl()->isVisible() == false)
device->getCursorControl()->setVisible(true);
+#endif
//infostream<<"window inactive"<<std::endl;
first_loop_after_window_activation = true;
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);
+ LocalPlayer* player = client.getEnv().getLocalPlayer();
+ player->keyPressed=
+ (((int)input->isKeyDown(getKeySetting("keymap_forward")) & 0x1) << 0) |
+ (((int)input->isKeyDown(getKeySetting("keymap_backward")) & 0x1) << 1) |
+ (((int)input->isKeyDown(getKeySetting("keymap_left")) & 0x1) << 2) |
+ (((int)input->isKeyDown(getKeySetting("keymap_right")) & 0x1) << 3) |
+ (((int)input->isKeyDown(getKeySetting("keymap_jump")) & 0x1) << 4) |
+ (((int)input->isKeyDown(getKeySetting("keymap_special1")) & 0x1) << 5) |
+ (((int)input->isKeyDown(getKeySetting("keymap_sneak")) & 0x1) << 6) |
+ (((int)input->getLeftState() & 0x1) << 7) |
+ (((int)input->getRightState() & 0x1) << 8);
}
-
+
/*
- Run server
+ Run server, client (and process environments)
*/
-
- if(server != NULL)
+ bool can_be_and_is_paused =
+ (simple_singleplayer_mode && g_menumgr.pausesGame());
+ if(can_be_and_is_paused)
{
- //TimeTaker timer("server->step(dtime)");
- server->step(dtime);
+ // No time passes
+ dtime = 0;
}
-
- /*
- Process environment
- */
-
+ else
{
- //TimeTaker timer("client.step(dtime)");
- client.step(dtime);
- //client.step(dtime_avg1);
+ if(server != NULL)
+ {
+ //TimeTaker timer("server->step(dtime)");
+ server->step(dtime);
+ }
+ {
+ //TimeTaker timer("client.step(dtime)");
+ client.step(dtime);
+ }
}
{
// Read client events
- for(;;)
- {
+ for(;;) {
ClientEvent event = client.getClientEvent();
- if(event.type == CE_NONE)
- {
+ if(event.type == CE_NONE) {
break;
}
- else if(event.type == CE_PLAYER_DAMAGE)
- {
+ else if(event.type == CE_PLAYER_DAMAGE &&
+ client.getHP() != 0) {
//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;
- }
+
+ damage_flash += 100.0;
+ damage_flash += 8.0 * event.player_damage.amount;
+
+ player->hurt_tilt_timer = 1.5;
+ player->hurt_tilt_strength = event.player_damage.amount/4;
+ player->hurt_tilt_strength = rangelim(player->hurt_tilt_strength, 1.0, 4.0);
+
+ MtEvent *e = new SimpleTriggerEvent("PlayerDamage");
+ gamedef->event()->put(e);
}
- else if(event.type == CE_PLAYER_FORCE_MOVE)
- {
+ 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;
+ else if(event.type == CE_DEATHSCREEN) {
+ show_deathscreen(¤t_formspec, &client, gamedef, tsrc,
+ device, &client);
- /*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();
-
chat_backend.addMessage(L"", L"You died.");
/* Handle visualization */
+ damage_flash = 0;
- damage_flash_timer = 0;
+ LocalPlayer* player = client.getEnv().getLocalPlayer();
+ player->hurt_tilt_timer = 0;
+ player->hurt_tilt_strength = 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_wielded_item_trigger = true;
+ else if (event.type == CE_SHOW_FORMSPEC) {
+ FormspecFormSource* fs_src =
+ new FormspecFormSource(*(event.show_formspec.formspec));
+ TextDestPlayerInventory* txt_dst =
+ new TextDestPlayerInventory(&client,*(event.show_formspec.formname));
+
+ create_formspec_menu(¤t_formspec, &client, gamedef,
+ tsrc, device, fs_src, txt_dst);
+
+ delete(event.show_formspec.formspec);
+ delete(event.show_formspec.formname);
+ }
+ else if(event.type == CE_SPAWN_PARTICLE) {
+ LocalPlayer* player = client.getEnv().getLocalPlayer();
+ video::ITexture *texture =
+ gamedef->tsrc()->getTexture(*(event.spawn_particle.texture));
+
+ new Particle(gamedef, smgr, player, client.getEnv(),
+ *event.spawn_particle.pos,
+ *event.spawn_particle.vel,
+ *event.spawn_particle.acc,
+ event.spawn_particle.expirationtime,
+ event.spawn_particle.size,
+ event.spawn_particle.collisiondetection,
+ event.spawn_particle.vertical,
+ texture,
+ v2f(0.0, 0.0),
+ v2f(1.0, 1.0));
+ }
+ else if(event.type == CE_ADD_PARTICLESPAWNER) {
+ LocalPlayer* player = client.getEnv().getLocalPlayer();
+ video::ITexture *texture =
+ gamedef->tsrc()->getTexture(*(event.add_particlespawner.texture));
+
+ new ParticleSpawner(gamedef, smgr, player,
+ event.add_particlespawner.amount,
+ event.add_particlespawner.spawntime,
+ *event.add_particlespawner.minpos,
+ *event.add_particlespawner.maxpos,
+ *event.add_particlespawner.minvel,
+ *event.add_particlespawner.maxvel,
+ *event.add_particlespawner.minacc,
+ *event.add_particlespawner.maxacc,
+ event.add_particlespawner.minexptime,
+ event.add_particlespawner.maxexptime,
+ event.add_particlespawner.minsize,
+ event.add_particlespawner.maxsize,
+ event.add_particlespawner.collisiondetection,
+ event.add_particlespawner.vertical,
+ texture,
+ event.add_particlespawner.id);
+ }
+ else if(event.type == CE_DELETE_PARTICLESPAWNER) {
+ delete_particlespawner (event.delete_particlespawner.id);
+ }
+ else if (event.type == CE_HUDADD) {
+ u32 id = event.hudadd.id;
+
+ HudElement *e = player->getHud(id);
+
+ if (e != NULL) {
+ delete event.hudadd.pos;
+ delete event.hudadd.name;
+ delete event.hudadd.scale;
+ delete event.hudadd.text;
+ delete event.hudadd.align;
+ delete event.hudadd.offset;
+ delete event.hudadd.world_pos;
+ delete event.hudadd.size;
+ continue;
+ }
+
+ e = new HudElement;
+ e->type = (HudElementType)event.hudadd.type;
+ e->pos = *event.hudadd.pos;
+ e->name = *event.hudadd.name;
+ e->scale = *event.hudadd.scale;
+ e->text = *event.hudadd.text;
+ e->number = event.hudadd.number;
+ e->item = event.hudadd.item;
+ e->dir = event.hudadd.dir;
+ e->align = *event.hudadd.align;
+ e->offset = *event.hudadd.offset;
+ e->world_pos = *event.hudadd.world_pos;
+ e->size = *event.hudadd.size;
+
+ u32 new_id = player->addHud(e);
+ //if this isn't true our huds aren't consistent
+ assert(new_id == id);
+
+ delete event.hudadd.pos;
+ delete event.hudadd.name;
+ delete event.hudadd.scale;
+ delete event.hudadd.text;
+ delete event.hudadd.align;
+ delete event.hudadd.offset;
+ delete event.hudadd.world_pos;
+ delete event.hudadd.size;
+ }
+ else if (event.type == CE_HUDRM) {
+ HudElement* e = player->removeHud(event.hudrm.id);
+
+ if (e != NULL)
+ delete (e);
+ }
+ else if (event.type == CE_HUDCHANGE) {
+ u32 id = event.hudchange.id;
+ HudElement* e = player->getHud(id);
+ if (e == NULL)
+ {
+ delete event.hudchange.v3fdata;
+ delete event.hudchange.v2fdata;
+ delete event.hudchange.sdata;
+ delete event.hudchange.v2s32data;
+ continue;
+ }
+
+ switch (event.hudchange.stat) {
+ case HUD_STAT_POS:
+ e->pos = *event.hudchange.v2fdata;
+ break;
+ case HUD_STAT_NAME:
+ e->name = *event.hudchange.sdata;
+ break;
+ case HUD_STAT_SCALE:
+ e->scale = *event.hudchange.v2fdata;
+ break;
+ case HUD_STAT_TEXT:
+ e->text = *event.hudchange.sdata;
+ break;
+ case HUD_STAT_NUMBER:
+ e->number = event.hudchange.data;
+ break;
+ case HUD_STAT_ITEM:
+ e->item = event.hudchange.data;
+ break;
+ case HUD_STAT_DIR:
+ e->dir = event.hudchange.data;
+ break;
+ case HUD_STAT_ALIGN:
+ e->align = *event.hudchange.v2fdata;
+ break;
+ case HUD_STAT_OFFSET:
+ e->offset = *event.hudchange.v2fdata;
+ break;
+ case HUD_STAT_WORLD_POS:
+ e->world_pos = *event.hudchange.v3fdata;
+ break;
+ case HUD_STAT_SIZE:
+ e->size = *event.hudchange.v2s32data;
+ break;
+ }
+
+ delete event.hudchange.v3fdata;
+ delete event.hudchange.v2fdata;
+ delete event.hudchange.sdata;
+ delete event.hudchange.v2s32data;
+ }
+ else if (event.type == CE_SET_SKY) {
+ sky->setVisible(false);
+ if(skybox){
+ skybox->remove();
+ skybox = NULL;
+ }
+ // Handle according to type
+ if(*event.set_sky.type == "regular") {
+ sky->setVisible(true);
+ }
+ else if(*event.set_sky.type == "skybox" &&
+ event.set_sky.params->size() == 6) {
+ sky->setFallbackBgColor(*event.set_sky.bgcolor);
+ skybox = smgr->addSkyBoxSceneNode(
+ tsrc->getTexture((*event.set_sky.params)[0]),
+ tsrc->getTexture((*event.set_sky.params)[1]),
+ tsrc->getTexture((*event.set_sky.params)[2]),
+ tsrc->getTexture((*event.set_sky.params)[3]),
+ tsrc->getTexture((*event.set_sky.params)[4]),
+ tsrc->getTexture((*event.set_sky.params)[5]));
+ }
+ // Handle everything else as plain color
+ else {
+ if(*event.set_sky.type != "plain")
+ infostream<<"Unknown sky type: "
+ <<(*event.set_sky.type)<<std::endl;
+ sky->setFallbackBgColor(*event.set_sky.bgcolor);
+ }
+
+ delete event.set_sky.bgcolor;
+ delete event.set_sky.type;
+ delete event.set_sky.params;
+ }
+ else if (event.type == CE_OVERRIDE_DAY_NIGHT_RATIO) {
+ bool enable = event.override_day_night_ratio.do_override;
+ u32 value = event.override_day_night_ratio.ratio_f * 1000;
+ client.getEnv().setDayNightRatioOverride(enable, value);
}
}
}
-
+
//TimeTaker //timer2("//timer2");
/*
- 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)
- {
+ if((mlist != NULL) && (client.getPlayerItem() < mlist->getSize()))
playeritem = mlist->getItem(client.getPlayerItem());
- playeritem_usable = playeritem.getDefinition(itemdef).usable;
- playeritem_liquids_pointable = playeritem.getDefinition(itemdef).liquids_pointable;
- }
}
+ const ItemDefinition &playeritem_def =
+ playeritem.getDefinition(itemdef);
ToolCapabilities playeritem_toolcap =
playeritem.getToolCapabilities(itemdef);
-
+
/*
Update camera
*/
+ v3s16 old_camera_offset = camera.getOffset();
+
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;
+
+ if(input->wasKeyDown(getKeySetting("keymap_camera_mode"))) {
+ camera.toggleCameraMode();
+ GenericCAO* playercao = player->getCAO();
+
+ assert( playercao != NULL );
+ if (camera.getCameraMode() > CAMERA_MODE_FIRST) {
+ playercao->setVisible(true);
+ }
+ else {
+ playercao->setVisible(false);
+ }
+ }
tool_reload_ratio = MYMIN(tool_reload_ratio, 1.0);
- camera.update(player, busytime, screensize, tool_reload_ratio);
+ camera.update(player, dtime, busytime, tool_reload_ratio,
+ client.getEnv());
camera.step(dtime);
v3f player_position = player->getPosition();
v3f camera_position = camera.getPosition();
v3f camera_direction = camera.getDirection();
f32 camera_fov = camera.getFovMax();
-
+ v3s16 camera_offset = camera.getOffset();
+
+ bool camera_offset_changed = (camera_offset != old_camera_offset);
+
if(!disable_camera_update){
client.getEnv().getClientMap().updateCamera(camera_position,
- camera_direction, camera_fov);
+ camera_direction, camera_fov, camera_offset);
+ if (camera_offset_changed){
+ client.updateCameraOffset(camera_offset);
+ client.getEnv().updateCameraOffset(camera_offset);
+ if (clouds)
+ clouds->updateCameraOffset(camera_offset);
+ }
}
-
+
// Update sound listener
- sound->updateListener(camera.getCameraNode()->getPosition(),
+ sound->updateListener(camera.getCameraNode()->getPosition()+intToFloat(camera_offset, BS),
v3f(0,0,0), // velocity
- camera.getCameraNode()->getTarget(),
+ camera.getDirection(),
camera.getCameraNode()->getUpVector());
+ sound->setListenerGain(g_settings->getFloat("sound_volume"));
/*
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 = playeritem_def.range; // max. distance
+ f32 d_hand = itemdef->get("").range;
+ if(d < 0 && d_hand >= 0)
+ d = d_hand;
+ else if(d < 0)
+ d = 4.0;
core::line3d<f32> shootline(camera_position,
camera_position + camera_direction * BS * (d+1));
- core::aabbox3d<f32> hilightbox;
- bool should_show_hilightbox = false;
+
+ // prevent player pointing anything in front-view
+ if (camera.getCameraMode() == CAMERA_MODE_THIRD_FRONT)
+ shootline = core::line3d<f32>(0,0,0,0,0,0);
+
+#ifdef HAVE_TOUCHSCREENGUI
+ if ((g_settings->getBool("touchtarget")) && (g_touchscreengui)) {
+ shootline = g_touchscreengui->getShootline();
+ shootline.start += intToFloat(camera_offset,BS);
+ shootline.end += intToFloat(camera_offset,BS);
+ }
+#endif
+
ClientActiveObject *selected_object = NULL;
PointedThing pointed = getPointedThing(
// input
&client, player_position, camera_direction,
camera_position, shootline, d,
- playeritem_liquids_pointable, !ldown_for_dig,
+ playeritem_def.liquids_pointable, !ldown_for_dig,
+ camera_offset,
// output
- hilightbox, should_show_hilightbox,
+ hilightboxes,
selected_object);
if(pointed != pointed_old)
{
infostream<<"Pointing at "<<pointed.dump()<<std::endl;
- //dstream<<"Pointing at "<<pointed.dump()<<std::endl;
+ if (g_settings->getBool("enable_node_highlighting"))
+ client.setHighlighted(pointed.node_undersurface, show_hud);
}
- /*
- Visualize selection
- */
- if(should_show_hilightbox)
- hilightboxes.push_back(hilightbox);
-
/*
Stop digging when
- releasing left mouse button
bool left_punch = false;
soundmaker.m_player_leftpunch_sound.name = "";
- if(playeritem_usable && input->getLeftState())
+ if(input->getRightState())
+ repeat_rightclick_timer += dtime;
+ else
+ repeat_rightclick_timer = 0;
+
+ if(playeritem_def.usable && input->getLeftState())
{
if(input->getLeftClicked())
client.interact(4, pointed);
/*
Check information text of node
*/
-
+
ClientMap &map = client.getEnv().getClientMap();
NodeMetadata *meta = map.getNodeMetadata(nodepos);
if(meta){
- infotext = narrow_to_wide(meta->infoText());
+ infotext = narrow_to_wide(meta->getString("infotext"));
} else {
MapNode n = map.getNode(nodepos);
- if(nodedef->get(n).tname_tiles[0] == "unknown_block.png"){
+ if(nodedef->get(n).tiledef[0].name == "unknown_node.png"){
infotext = L"Unknown node: ";
infotext += narrow_to_wide(nodedef->get(n).name);
}
}
-
- // 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(nodig_delay_timer <= 0.0 && input->getLeftState())
+
+ if(nodig_delay_timer <= 0.0 && input->getLeftState()
+ && client.checkPrivilege("interact"))
{
if(!digging)
{
}
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(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;
- }
- }
float dig_time_complete = 0.0;
else
{
dig_time_complete = params.time;
+ if (g_settings->getBool("enable_particles"))
+ {
+ const ContentFeatures &features =
+ client.getNodeDefManager()->get(n);
+ addPunchingParticles
+ (gamedef, smgr, player, client.getEnv(),
+ nodepos, features.tiles);
+ }
}
if(dig_time_complete >= 0.001)
{
- dig_index = (u16)((float)CRACK_ANIMATION_LENGTH
+ dig_index = (u16)((float)crack_animation_length
* dig_time/dig_time_complete);
}
// This is for torches
else
{
- dig_index = CRACK_ANIMATION_LENGTH;
+ dig_index = crack_animation_length;
+ }
+
+ SimpleSoundSpec sound_dig = nodedef->get(n).sound_dig;
+ if(sound_dig.exists() && params.diggable){
+ 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;
+ }
}
-
+
// Don't show cracks if not diggable
if(dig_time_complete >= 100000.0)
{
}
- else if(dig_index < CRACK_ANIMATION_LENGTH)
+ else if(dig_index < crack_animation_length)
{
//TimeTaker timer("client.setTempMod");
//infostream<<"dig_index="<<dig_index<<std::endl;
MapNode wasnode = map.getNode(nodepos);
client.removeNode(nodepos);
+ if (g_settings->getBool("enable_particles"))
+ {
+ const ContentFeatures &features =
+ client.getNodeDefManager()->get(wasnode);
+ addDiggingParticles
+ (gamedef, smgr, player, client.getEnv(),
+ nodepos, features.tiles);
+ }
+
dig_time = 0;
digging = false;
nodig_delay_timer = dig_time_complete
- / (float)CRACK_ANIMATION_LENGTH;
+ / (float)crack_animation_length;
// We don't want a corresponding delay to
// very time consuming nodes
float mindelay = 0.15;
if(nodig_delay_timer < mindelay)
nodig_delay_timer = mindelay;
-
+
// Send event to trigger sound
MtEvent *e = new NodeDugEvent(nodepos, wasnode);
gamedef->event()->put(e);
}
- dig_time += dtime;
+ if(dig_time_complete < 100000.0)
+ dig_time += dtime;
+ else {
+ dig_time = 0;
+ client.setCrack(-1, nodepos);
+ }
camera.setDigging(0); // left click animation
}
- if(input->getRightClicked())
+ if((input->getRightClicked() ||
+ repeat_rightclick_timer >=
+ g_settings->getFloat("repeat_rightclick_time")) &&
+ client.checkPrivilege("interact"))
{
+ repeat_rightclick_timer = 0;
infostream<<"Ground right-clicked"<<std::endl;
-
- // If metadata provides an inventory view, activate it
- if(meta && meta->getInventoryDrawSpecString() != "" && !random_input)
+
+ if(meta && meta->getString("formspec") != "" && !random_input
+ && !input->isKeyDown(getKeySetting("keymap_sneak")))
{
infostream<<"Launching custom inventory view"<<std::endl;
InventoryLocation inventoryloc;
inventoryloc.setNodeMeta(nodepos);
-
-
- /*
- Create menu
- */
-
- core::array<GUIInventoryMenu::DrawSpec> draw_spec;
- v2s16 invsize =
- GUIInventoryMenu::makeDrawSpecArrayFromString(
- draw_spec,
- meta->getInventoryDrawSpecString(),
- inventoryloc);
-
- GUIInventoryMenu *menu =
- new GUIInventoryMenu(guienv, guiroot, -1,
- &g_menumgr, invsize,
- &client, gamedef);
- menu->setDrawSpec(draw_spec);
- menu->drop();
- }
- // If metadata provides text input, activate text input
- else if(meta && meta->allowsTextInput() && !random_input)
- {
- infostream<<"Launching metadata text input"<<std::endl;
-
- // Get a new text for it
- TextDest *dest = new TextDestNodeMetadata(nodepos, &client);
+ NodeMetadataFormSource* fs_src = new NodeMetadataFormSource(
+ &client.getEnv().getClientMap(), nodepos);
+ TextDest* txt_dst = new TextDestNodeMetadata(nodepos, &client);
- std::wstring wtext = narrow_to_wide(meta->getText());
+ create_formspec_menu(¤t_formspec, &client, gamedef,
+ tsrc, device, fs_src, txt_dst);
- (new GUITextInputMenu(guienv, guiroot, -1,
- &g_menumgr, dest,
- wtext))->drop();
+ current_formspec->setFormSpec(meta->getString("formspec"), inventoryloc);
}
// Otherwise report right click to server
else
{
- client.interact(3, pointed);
- camera.setDigging(1); // right click animation
+ camera.setDigging(1); // right click animation (always shown for feedback)
+
+ // If the wielded item has node placement prediction,
+ // make that happen
+ bool placed = nodePlacementPrediction(client,
+ playeritem_def,
+ nodepos, neighbourpos);
+
+ if(placed) {
+ // Report to server
+ client.interact(3, pointed);
+ // Read the sound
+ soundmaker.m_player_rightpunch_sound =
+ playeritem_def.sound_place;
+ } else {
+ soundmaker.m_player_rightpunch_sound =
+ SimpleSoundSpec();
+ }
+
+ if (playeritem_def.node_placement_prediction == "" ||
+ nodedef->get(map.getNode(nodepos)).rightclickable)
+ client.interact(3, pointed); // Report to server
}
}
}
// 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;
}
pointed_old = pointed;
-
+
if(left_punch || input->getLeftClicked())
{
camera.setDigging(0); // left click animation
input->resetLeftReleased();
input->resetRightReleased();
-
+
/*
Calculate stuff for drawing
*/
/*
Fog range
*/
-
- f32 fog_range;
- if(farmesh)
- {
- fog_range = BS*farmesh_range;
- }
- else
- {
+
+ if(draw_control.range_all)
+ fog_range = 100000*BS;
+ else {
fog_range = draw_control.wanted_range*BS + 0.0*MAP_BLOCKSIZE*BS;
+ fog_range = MYMIN(fog_range, (draw_control.farthest_drawn+20)*BS);
fog_range *= 0.9;
- if(draw_control.range_all)
- fog_range = 100000*BS;
}
/*
Calculate general brightness
*/
u32 daynight_ratio = client.getEnv().getDayNightRatio();
- float time_brightness = (float)decode_light(
- (daynight_ratio * LIGHT_SUN) / 1000) / 255.0;
+ float time_brightness = decode_light_f((float)daynight_ratio/1000.0);
float direct_brightness = 0;
bool sunlight_seen = false;
if(g_settings->getBool("free_move")){
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 &&
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();
+ sunlight_seen,camera.getCameraMode(), player->getYaw(),
+ player->getPitch());
+
video::SColor bgcolor = sky->getBgColor();
video::SColor skycolor = sky->getSkyColor();
clouds->setVisible(false);
}
}
-
+
/*
- Update farmesh
+ Update particles
*/
- 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),
- brightness, farmesh_range);
- }
-
+ allparticles_step(dtime);
+ allparticlespawners_step(dtime, client.getEnv());
+
/*
Fog
*/
-
- if(g_settings->getBool("enable_fog") == true && !force_fog_off)
+
+ if(g_settings->getBool("enable_fog") && !force_fog_off)
{
driver->setFog(
bgcolor,
*/
//TimeTaker guiupdatetimer("Gui updating");
-
- const char program_name_and_version[] =
- "Minetest-c55 " VERSION_STRING;
if(show_debug)
{
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;*/
-
- char temptext[300];
- snprintf(temptext, 300, "%s ("
- "R: range_all=%i"
- ")"
- " drawtime=%.0f, dtime_jitter = % .1f %%"
- ", v_range = %.1f, RTT = %.3f",
- program_name_and_version,
- draw_control.range_all,
- drawtime_avg,
- dtime_jitter1_max_fraction * 100.0,
- draw_control.wanted_range,
- client.getRTT()
- );
-
- guitext->setText(narrow_to_wide(temptext).c_str());
+
+ u16 fps = (1.0/dtime_avg1);
+
+ std::ostringstream os(std::ios_base::binary);
+ os<<std::fixed
+ <<"Minetest "<<minetest_version_hash
+ <<" FPS = "<<fps
+ <<" (R: range_all="<<draw_control.range_all<<")"
+ <<std::setprecision(0)
+ <<" drawtime = "<<drawtime_avg
+ <<std::setprecision(1)
+ <<", dtime_jitter = "
+ <<(dtime_jitter1_max_fraction * 100.0)<<" %"
+ <<std::setprecision(1)
+ <<", v_range = "<<draw_control.wanted_range
+ <<std::setprecision(3)
+ <<", RTT = "<<client.getRTT();
+ guitext->setText(narrow_to_wide(os.str()).c_str());
guitext->setVisible(true);
}
else if(show_hud || show_chat)
{
- guitext->setText(narrow_to_wide(program_name_and_version).c_str());
+ std::ostringstream os(std::ios_base::binary);
+ os<<"Minetest "<<minetest_version_hash;
+ guitext->setText(narrow_to_wide(os.str()).c_str());
guitext->setVisible(true);
}
else
{
guitext->setVisible(false);
}
-
- if(show_debug)
+
+ if (guitext->isVisible())
{
- char temptext[300];
- snprintf(temptext, 300,
- "(% .1f, % .1f, % .1f)"
- " (yaw = %.1f)",
- player_position.X/BS,
- player_position.Y/BS,
- player_position.Z/BS,
- wrapDegrees_0_360(camera_yaw));
+ core::rect<s32> rect(
+ 5,
+ 5,
+ screensize.X,
+ 5 + text_height
+ );
+ guitext->setRelativePosition(rect);
+ }
- guitext2->setText(narrow_to_wide(temptext).c_str());
+ if(show_debug)
+ {
+ std::ostringstream os(std::ios_base::binary);
+ os<<std::setprecision(1)<<std::fixed
+ <<"(" <<(player_position.X/BS)
+ <<", "<<(player_position.Y/BS)
+ <<", "<<(player_position.Z/BS)
+ <<") (yaw="<<(wrapDegrees_0_360(camera_yaw))
+ <<") (seed = "<<((u64)client.getMapSeed())
+ <<")";
+ guitext2->setText(narrow_to_wide(os.str()).c_str());
guitext2->setVisible(true);
+
+ core::rect<s32> rect(
+ 5,
+ 5 + text_height,
+ screensize.X,
+ 5 + (text_height * 2)
+ );
+ guitext2->setRelativePosition(rect);
}
else
{
guitext2->setVisible(false);
}
-
+
{
guitext_info->setText(infotext.c_str());
guitext_info->setVisible(show_hud && g_menumgr.menuCount() == 0);
core::rect<s32> rect(
10,
status_y - guitext_status->getTextHeight(),
- screensize.X - 10,
+ 10 + guitext_status->getTextWidth(),
status_y
);
guitext_status->setRelativePosition(rect);
guitext_status->enableOverrideColor(true);
}
}
-
+
/*
Get chat messages from client
*/
- {
- // Get new messages from error log buffer
- while(!chat_log_error_buf.empty())
- {
- chat_backend.addMessage(L"", narrow_to_wide(
- chat_log_error_buf.get()));
- }
- // Get new messages from client
- std::wstring message;
- while(client.getChatMessage(message))
- {
- chat_backend.addUnparsedMessage(message);
- }
- // Remove old messages
- chat_backend.step(dtime);
-
- // 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());
-
- // 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,
- chat_y,
- screensize.X - 10,
- chat_y + guitext_chat->getTextHeight()
- );
- guitext_chat->setRelativePosition(rect);
-
- // Don't show chat if disabled or empty or profiler is enabled
- guitext_chat->setVisible(show_chat && recent_chat_count != 0
- && !show_profiler);
- }
+ updateChat(client, dtime, show_debug, screensize, show_chat,
+ show_profiler, chat_backend, guitext_chat, font);
/*
Inventory
*/
-
+
if(client.getPlayerItem() != new_playeritem)
{
client.selectPlayerItem(new_playeritem);
{
//infostream<<"Updating local inventory"<<std::endl;
client.getLocalInventory(local_inventory);
-
+
update_wielded_item_trigger = true;
}
if(update_wielded_item_trigger)
// Update wielded tool
InventoryList *mlist = local_inventory.getList("main");
ItemStack item;
- if(mlist != NULL)
+ if((mlist != NULL) && (client.getPlayerItem() < mlist->getSize()))
item = mlist->getItem(client.getPlayerItem());
- camera.wield(item);
+ camera.wield(item, client.getPlayerItem());
}
-
+
/*
- Drawing begins
+ Update block draw list every 200ms or when camera direction has
+ changed much
*/
-
- TimeTaker tt_draw("mainloop: draw");
-
-
- {
- TimeTaker timer("beginScene");
- //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();
- scenetime = timer.stop(true);
- }
-
- {
- //TimeTaker timer9("auxiliary drawings");
- // 0ms
-
- //timer9.stop();
- //TimeTaker //timer10("//timer10");
-
- video::SMaterial m;
- //m.Thickness = 10;
- m.Thickness = 3;
- m.Lighting = false;
- driver->setMaterial(m);
-
- driver->setTransform(video::ETS_WORLD, core::IdentityMatrix);
-
- if(show_hud)
- {
- for(core::list<aabb3f>::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));
- }
+ update_draw_list_timer += dtime;
+ if(update_draw_list_timer >= 0.2 ||
+ update_draw_list_last_cam_dir.getDistanceFrom(camera_direction) > 0.2 ||
+ camera_offset_changed){
+ update_draw_list_timer = 0;
+ client.getEnv().getClientMap().updateDrawList(driver);
+ update_draw_list_last_cam_dir = camera_direction;
}
/*
- Wielded tool
+ make sure menu is on top
*/
- if(show_hud)
- {
- // Warning: This clears the Z buffer.
- camera.drawWieldedTool();
+ if ((!noMenuActive()) && (current_formspec)) {
+ guiroot->bringToFront(current_formspec);
}
/*
- Post effects
+ Drawing begins
*/
+ TimeTaker tt_draw("mainloop: draw");
{
- client.getEnv().getClientMap().renderPostFx();
+ TimeTaker timer("beginScene");
+ driver->beginScene(true, true, skycolor);
+ beginscenetime = timer.stop(true);
}
+
+ draw_scene(driver, smgr, camera, client, player, hud, guienv,
+ hilightboxes, screensize, skycolor, show_hud);
+
/*
Profiler graph
*/
}
/*
- Draw crosshair
+ Damage flash
*/
- if(show_hud)
+ if(damage_flash > 0.0)
{
- 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
-
- //timer10.stop();
- //TimeTaker //timer11("//timer11");
-
- /*
- Draw gui
- */
- // 0-1ms
- guienv->drawAll();
+ video::SColor color(std::min(damage_flash, 180.0f),180,0,0);
+ driver->draw2DRectangle(color,
+ core::rect<s32>(0,0,screensize.X,screensize.Y),
+ NULL);
- /*
- Draw hotbar
- */
- if(show_hud)
- {
- draw_hotbar(driver, font, gamedef,
- v2s32(displaycenter.X, screensize.Y),
- hotbar_imagesize, hotbar_itemcount, &local_inventory,
- client.getHP(), client.getPlayerItem());
+ damage_flash -= 100.0*dtime;
}
/*
- Damage flash
+ Damage camera tilt
*/
- if(damage_flash_timer > 0.0)
+ if(player->hurt_tilt_timer > 0.0)
{
- damage_flash_timer -= dtime;
-
- video::SColor color(128,255,0,0);
- driver->draw2DRectangle(color,
- core::rect<s32>(0,0,screensize.X,screensize.Y),
- NULL);
+ player->hurt_tilt_timer -= dtime*5;
+ if(player->hurt_tilt_timer < 0)
+ player->hurt_tilt_strength = 0;
}
/*
*/
{
TimeTaker timer("endScene");
- endSceneX(driver);
+ driver->endScene();
endscenetime = timer.stop(true);
}
End of drawing
*/
- static s16 lastFPS = 0;
- //u16 fps = driver->getFPS();
- u16 fps = (1.0/dtime_avg1);
-
- if (lastFPS != fps)
- {
- core::stringw str = L"Minetest [";
- str += driver->getName();
- str += "] FPS=";
- str += fps;
-
- device->setWindowCaption(str.c_str());
- lastFPS = fps;
- }
-
/*
Log times and stuff for visualization
*/
/*
Drop stuff
*/
- if(clouds)
+ if (clouds)
clouds->drop();
- if(gui_chat_console)
+ if (gui_chat_console)
gui_chat_console->drop();
-
+ if (sky)
+ sky->drop();
+ clear_particles();
+
+ /* cleanup menus */
+ while (g_menumgr.menuCount() > 0)
+ {
+ g_menumgr.m_stack.front()->setVisible(false);
+ g_menumgr.deletingMenu(g_menumgr.m_stack.front());
+ }
/*
Draw a "shutting down" screen, which will be shown while the map
generator and other stuff quits
*/
{
- /*gui::IGUIStaticText *gui_shuttingdowntext = */
- draw_load_screen(L"Shutting down stuff...", driver, font);
- /*driver->beginScene(true, true, video::SColor(255,0,0,0));
- guienv->drawAll();
- driver->endScene();
- gui_shuttingdowntext->remove();*/
+ wchar_t* text = wgettext("Shutting down stuff...");
+ draw_load_screen(text, device, guienv, font, 0, -1, false);
+ delete[] text;
}
chat_backend.addMessage(L"", L"# Disconnected.");
chat_backend.addMessage(L"", L"");
+ client.Stop();
+
+ //force answer all texture and shader jobs (TODO return empty values)
+
+ while(!client.isShutdown()) {
+ tsrc->processQueue();
+ shsrc->processQueue();
+ sleep_ms(100);
+ }
+
// Client scope (client is destructed before destructing *def and tsrc)
}while(0);
} // try-catch
L" running a different version of Minetest.";
errorstream<<wide_to_narrow(error_message)<<std::endl;
}
-
+ catch(ServerError &e) {
+ error_message = narrow_to_wide(e.what());
+ errorstream << "ServerError: " << e.what() << std::endl;
+ }
+ catch(ModError &e) {
+ errorstream << "ModError: " << e.what() << std::endl;
+ error_message = narrow_to_wide(e.what()) + wgettext("\nCheck debug.txt for details.");
+ }
+
+
+
if(!sound_is_dummy)
delete sound;
+
+ //has to be deleted first to stop all server threads
+ delete server;
+
+ delete tsrc;
+ delete shsrc;
delete nodedef;
delete itemdef;
- delete tsrc;
-}
-
+ //extended resource accounting
+ infostream << "Irrlicht resources after cleanup:" << std::endl;
+ infostream << "\tRemaining meshes : "
+ << device->getSceneManager()->getMeshCache()->getMeshCount() << std::endl;
+ infostream << "\tRemaining textures : "
+ << driver->getTextureCount() << std::endl;
+ for (unsigned int i = 0; i < driver->getTextureCount(); i++ ) {
+ irr::video::ITexture* texture = driver->getTextureByIndex(i);
+ infostream << "\t\t" << i << ":" << texture->getName().getPath().c_str()
+ << std::endl;
+ }
+ clearTextureNameCache();
+ infostream << "\tRemaining materials: "
+ << driver-> getMaterialRendererCount ()
+ << " (note: irrlicht doesn't support removing renderers)"<< std::endl;
+}
projects / oweals / minetest.git / blobdiff