/*
-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 "client.h"
#include "server.h"
#include "guiPauseMenu.h"
#include "guiPasswordChange.h"
-#include "guiInventoryMenu.h"
+#include "guiVolumeChange.h"
+#include "guiFormSpecMenu.h"
#include "guiTextInputMenu.h"
#include "guiDeathScreen.h"
#include "tool.h"
#include "guiChatConsole.h"
#include "config.h"
#include "clouds.h"
+#include "particles.h"
#include "camera.h"
#include "farmesh.h"
#include "mapblock.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 "sky.h"
+#include "sound.h"
+#if USE_SOUND
+ #include "sound_openal.h"
+#endif
+#include "event_manager.h"
#include <list>
-
-/*
- 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
-
+#include "util/directiontables.h"
/*
Text input system
{
m_client->typeChatMessage(text);
}
+ void gotText(std::map<std::string, std::string> fields)
+ {
+ m_client->typeChatMessage(narrow_to_wide(fields["text"]));
+ }
Client *m_client;
};
m_p = p;
m_client = client;
}
+ // This is deprecated I guess? -celeron55
void gotText(std::wstring text)
{
std::string ntext = wide_to_narrow(text);
- infostream<<"Changing text of a sign node: "
- <<ntext<<std::endl;
- m_client->sendSignNodeText(m_p, ntext);
+ infostream<<"Submitting 'text' field of node at ("<<m_p.X<<","
+ <<m_p.Y<<","<<m_p.Z<<"): "<<ntext<<std::endl;
+ std::map<std::string, std::string> fields;
+ fields["text"] = ntext;
+ m_client->sendNodemetaFields(m_p, "", fields);
+ }
+ void gotText(std::map<std::string, std::string> fields)
+ {
+ m_client->sendNodemetaFields(m_p, "", fields);
}
v3s16 m_p;
Client *m_client;
};
+struct TextDestPlayerInventory : public TextDest
+{
+ TextDestPlayerInventory(Client *client)
+ {
+ m_client = client;
+ m_formname = "";
+ }
+ TextDestPlayerInventory(Client *client, std::string formname)
+ {
+ m_client = client;
+ m_formname = formname;
+ }
+ void gotText(std::map<std::string, std::string> fields)
+ {
+ m_client->sendInventoryFields(m_formname, fields);
+ }
+
+ Client *m_client;
+ std::string m_formname;
+};
+
/* Respawn menu callback */
class MainRespawnInitiator: public IRespawnInitiator
Client *m_client;
};
+/* Form update callback */
+
+class NodeMetadataFormSource: public IFormSource
+{
+public:
+ NodeMetadataFormSource(ClientMap *map, v3s16 p):
+ m_map(map),
+ m_p(p)
+ {
+ }
+ std::string getForm()
+ {
+ NodeMetadata *meta = m_map->getNodeMetadata(m_p);
+ if(!meta)
+ return "";
+ return meta->getString("formspec");
+ }
+ std::string resolveText(std::string str)
+ {
+ NodeMetadata *meta = m_map->getNodeMetadata(m_p);
+ if(!meta)
+ return str;
+ return meta->resolveString(str);
+ }
+
+ ClientMap *m_map;
+ v3s16 m_p;
+};
+
+class PlayerInventoryFormSource: public IFormSource
+{
+public:
+ PlayerInventoryFormSource(Client *client):
+ m_client(client)
+ {
+ }
+ std::string getForm()
+ {
+ LocalPlayer* player = m_client->getEnv().getLocalPlayer();
+ return player->inventory_formspec;
+ }
+
+ Client *m_client;
+};
+
+class FormspecFormSource: public IFormSource
+{
+public:
+ FormspecFormSource(std::string formspec,FormspecFormSource** game_formspec)
+ {
+ m_formspec = formspec;
+ m_game_formspec = game_formspec;
+ }
+
+ ~FormspecFormSource()
+ {
+ *m_game_formspec = 0;
+ }
+
+ void setForm(std::string formspec) {
+ m_formspec = formspec;
+ }
+
+ std::string getForm()
+ {
+ return m_formspec;
+ }
+
+ std::string m_formspec;
+ FormspecFormSource** m_game_formspec;
+};
/*
Hotbar draw routine
*/
core::line3d<f32> shootline, f32 d,
bool liquids_pointable,
bool look_for_object,
- core::aabbox3d<f32> &hilightbox,
- bool &should_show_hilightbox,
+ 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();
{
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,
+ selection_box->MaxEdge + pos));
+ }
- should_show_hilightbox = selected_object->doShowSelectionBox();
- result.type = POINTEDTHING_OBJECT;
- result.object_id = selected_object->getId();
- return result;
+ result.type = POINTEDTHING_OBJECT;
+ result.object_id = selected_object->getId();
+ return result;
+ }
}
// That didn't work, try to find a pointed at node
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++)
+ hilightboxes.clear();
+ for(std::vector<aabb3f>::const_iterator
+ i2 = boxes.begin();
+ i2 != boxes.end(); i2++)
{
- 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;
+ aabb3f box = *i2;
+ box.MinEdge += npf + v3f(-d,-d,-d);
+ box.MaxEdge += npf + v3f(d,d,d);
+ 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;
static const video::SColor usable_colors[] = {
video::SColor(255,255,100,100),
video::SColor(255,90,225,90),
- video::SColor(255,100,100,255)
+ video::SColor(255,100,100,255),
+ video::SColor(255,255,150,50),
+ video::SColor(255,220,220,100)
};
static const u32 usable_colors_count =
sizeof(usable_colors) / sizeof(*usable_colors);
s32 y = y_bottom - meta_i * 50;
float show_min = meta.min;
float show_max = meta.max;
- if(show_min >= 0 && show_max >= 0){
+ if(show_min >= -0.0001 && show_max >= -0.0001){
if(show_min <= show_max * 0.5)
show_min = 0;
}
core::rect<s32>(textx, y - graphh/2 - texth/2,
textx2, y - graphh/2 + texth/2),
meta.color);
+ s32 graph1y = y;
+ s32 graph1h = graphh;
+ bool relativegraph = (show_min != 0 && show_min != show_max);
+ float lastscaledvalue = 0.0;
+ bool lastscaledvalue_exists = false;
for(std::list<Piece>::const_iterator j = m_log.begin();
j != m_log.end(); j++)
{
}
if(!value_exists){
x++;
+ lastscaledvalue_exists = false;
continue;
}
float scaledvalue = 1.0;
scaledvalue = (value - show_min) / (show_max - show_min);
if(scaledvalue == 1.0 && value == 0){
x++;
+ lastscaledvalue_exists = false;
continue;
}
- s32 ivalue = scaledvalue * graphh;
- driver->draw2DLine(v2s32(x, y),
- v2s32(x, y - ivalue),
- meta.color);
+ if(relativegraph){
+ if(lastscaledvalue_exists){
+ s32 ivalue1 = lastscaledvalue * graph1h;
+ s32 ivalue2 = scaledvalue * graph1h;
+ driver->draw2DLine(v2s32(x-1, graph1y - ivalue1),
+ v2s32(x, graph1y - ivalue2), meta.color);
+ }
+ lastscaledvalue = scaledvalue;
+ lastscaledvalue_exists = true;
+ } else{
+ s32 ivalue = scaledvalue * graph1h;
+ driver->draw2DLine(v2s32(x, graph1y),
+ v2s32(x, graph1y - ivalue), meta.color);
+ }
x++;
}
meta_i++;
}
};
+class NodeDugEvent: public MtEvent
+{
+public:
+ v3s16 p;
+ MapNode n;
+
+ NodeDugEvent(v3s16 p, MapNode n):
+ p(p),
+ n(n)
+ {}
+ const char* getType() const
+ {return "NodeDug";}
+};
+
+class SoundMaker
+{
+ ISoundManager *m_sound;
+ INodeDefManager *m_ndef;
+public:
+ float m_player_step_timer;
+
+ SimpleSoundSpec m_player_step_sound;
+ SimpleSoundSpec m_player_leftpunch_sound;
+ SimpleSoundSpec m_player_rightpunch_sound;
+
+ SoundMaker(ISoundManager *sound, INodeDefManager *ndef):
+ m_sound(sound),
+ m_ndef(ndef),
+ m_player_step_timer(0)
+ {
+ }
+
+ void playPlayerStep()
+ {
+ if(m_player_step_timer <= 0 && m_player_step_sound.exists()){
+ m_player_step_timer = 0.03;
+ m_sound->playSound(m_player_step_sound, false);
+ }
+ }
+
+ static void viewBobbingStep(MtEvent *e, void *data)
+ {
+ SoundMaker *sm = (SoundMaker*)data;
+ sm->playPlayerStep();
+ }
+
+ static void playerRegainGround(MtEvent *e, void *data)
+ {
+ SoundMaker *sm = (SoundMaker*)data;
+ sm->playPlayerStep();
+ }
+
+ static void playerJump(MtEvent *e, void *data)
+ {
+ //SoundMaker *sm = (SoundMaker*)data;
+ }
+
+ static void cameraPunchLeft(MtEvent *e, void *data)
+ {
+ SoundMaker *sm = (SoundMaker*)data;
+ sm->m_sound->playSound(sm->m_player_leftpunch_sound, false);
+ }
+
+ static void cameraPunchRight(MtEvent *e, void *data)
+ {
+ SoundMaker *sm = (SoundMaker*)data;
+ sm->m_sound->playSound(sm->m_player_rightpunch_sound, false);
+ }
+
+ static void nodeDug(MtEvent *e, void *data)
+ {
+ SoundMaker *sm = (SoundMaker*)data;
+ NodeDugEvent *nde = (NodeDugEvent*)e;
+ sm->m_sound->playSound(sm->m_ndef->get(nde->n).sound_dug, false);
+ }
+
+ void registerReceiver(MtEventManager *mgr)
+ {
+ mgr->reg("ViewBobbingStep", SoundMaker::viewBobbingStep, this);
+ mgr->reg("PlayerRegainGround", SoundMaker::playerRegainGround, this);
+ mgr->reg("PlayerJump", SoundMaker::playerJump, this);
+ mgr->reg("CameraPunchLeft", SoundMaker::cameraPunchLeft, this);
+ mgr->reg("CameraPunchRight", SoundMaker::cameraPunchRight, this);
+ mgr->reg("NodeDug", SoundMaker::nodeDug, this);
+ }
+
+ void step(float dtime)
+ {
+ m_player_step_timer -= dtime;
+ }
+};
+
+// Locally stored sounds don't need to be preloaded because of this
+class GameOnDemandSoundFetcher: public OnDemandSoundFetcher
+{
+ std::set<std::string> m_fetched;
+public:
+
+ void fetchSounds(const std::string &name,
+ std::set<std::string> &dst_paths,
+ std::set<std::string> &dst_datas)
+ {
+ if(m_fetched.count(name))
+ return;
+ m_fetched.insert(name);
+ std::string base = porting::path_share + DIR_DELIM + "testsounds";
+ dst_paths.insert(base + DIR_DELIM + name + ".ogg");
+ dst_paths.insert(base + DIR_DELIM + name + ".0.ogg");
+ dst_paths.insert(base + DIR_DELIM + name + ".1.ogg");
+ dst_paths.insert(base + DIR_DELIM + name + ".2.ogg");
+ dst_paths.insert(base + DIR_DELIM + name + ".3.ogg");
+ dst_paths.insert(base + DIR_DELIM + name + ".4.ogg");
+ dst_paths.insert(base + DIR_DELIM + name + ".5.ogg");
+ dst_paths.insert(base + DIR_DELIM + name + ".6.ogg");
+ dst_paths.insert(base + DIR_DELIM + name + ".7.ogg");
+ dst_paths.insert(base + DIR_DELIM + name + ".8.ogg");
+ dst_paths.insert(base + DIR_DELIM + name + ".9.ogg");
+ }
+};
+
+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 = *m_fog_range;
+ if(*m_force_fog_off)
+ fog_distance = 10000*BS;
+ 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);
+ }
+};
+
void the_game(
bool &kill,
bool random_input,
bool simple_singleplayer_mode
)
{
+ FormspecFormSource* current_formspec = 0;
video::IVideoDriver* driver = device->getVideoDriver();
scene::ISceneManager* smgr = device->getSceneManager();
// 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;
+
+ // Sound manager
+ ISoundManager *sound = NULL;
+ bool sound_is_dummy = false;
+#if USE_SOUND
+ if(g_settings->getBool("enable_sound")){
+ infostream<<"Attempting to use OpenAL audio"<<std::endl;
+ sound = createOpenALSoundManager(&soundfetcher);
+ if(!sound)
+ infostream<<"Failed to initialize OpenAL audio"<<std::endl;
+ } else {
+ infostream<<"Sound disabled."<<std::endl;
+ }
+#endif
+ if(!sound){
+ infostream<<"Using dummy audio."<<std::endl;
+ sound = &dummySoundManager;
+ sound_is_dummy = true;
+ }
+
+ // Event manager
+ EventManager eventmgr;
+ // Sound maker
+ SoundMaker soundmaker(sound, nodedef);
+ soundmaker.registerReceiver(&eventmgr);
+
// Add chat log output for errors to be shown in chat
LogOutputBuffer chat_log_error_buf(LMT_ERROR);
server->start(port);
}
+ try{
do{ // Client scope (breakable do-while(0))
/*
MapDrawControl draw_control;
Client client(device, playername.c_str(), password, draw_control,
- tsrc, itemdef, nodedef);
+ tsrc, shsrc, itemdef, nodedef, sound, &eventmgr);
// Client acts as our GameDef
IGameDef *gamedef = &client;
ss<<L" Item definitions\n";
ss<<(client.nodedefReceived()?L"[X]":L"[ ]");
ss<<L" Node definitions\n";
- //ss<<(client.texturesReceived()?L"[X]":L"[ ]");
- ss<<L"["<<(int)(client.textureReceiveProgress()*100+0.5)<<L"%] ";
- ss<<L" Textures\n";
+ ss<<L"["<<(int)(client.mediaReceiveProgress()*100+0.5)<<L"%] ";
+ ss<<L" Media\n";
draw_load_screen(ss.str(), driver, font);
/*
Create the camera node
*/
- Camera camera(smgr, draw_control);
+ Camera camera(smgr, draw_control, gamedef);
if (!camera.successfullyCreated(error_message))
return;
Inventory local_inventory(itemdef);
/*
- Move into game
+ Find out size of crack animation
*/
-
- //gui_loadingtext->remove();
+ int crack_animation_length = 5;
+ {
+ video::ITexture *t = tsrc->getTextureRaw("crack_anylength.png");
+ v2u32 size = t->getOriginalSize();
+ crack_animation_length = size.Y / size.X;
+ }
/*
Add some gui stuff
// First line of debug text
gui::IGUIStaticText *guitext = guienv->addStaticText(
- L"Minetest-c55",
+ L"Minetest",
core::rect<s32>(5, 5, 795, 5+text_height),
false, false);
// Second line of debug text
gui::IGUIStaticText *guitext_info = guienv->addStaticText(
L"",
core::rect<s32>(0,0,400,text_height*5+5) + v2s32(100,200),
- false, false);
+ false, true);
// Status text (displays info when showing and hiding GUI stuff, etc.)
gui::IGUIStaticText *guitext_status = guienv->addStaticText(
guitext_profiler->setBackgroundColor(video::SColor(120,0,0,0));
guitext_profiler->setVisible(false);
- /*GUIQuickInventory *quick_inventory = new GUIQuickInventory
- (guienv, NULL, v2s32(10, 70), 5, &local_inventory);*/
- /*GUIQuickInventory *quick_inventory = new GUIQuickInventory
- (guienv, NULL, v2s32(0, 0), quickinv_itemcount, &local_inventory);*/
-
- // Test the text input system
- /*(new GUITextInputMenu(guienv, guiroot, -1, &g_menumgr,
- NULL))->drop();*/
- /*GUIMessageMenu *menu =
- new GUIMessageMenu(guienv, guiroot, -1,
- &g_menumgr,
- L"Asd");
- menu->drop();*/
-
- // Launch pause menu
- /*(new GUIPauseMenu(guienv, guiroot, -1, g_gamecallback,
- &g_menumgr))->drop();*/
-
- //s32 guitext_chat_pad_bottom = 70;
-
/*
Some statistics are collected in these
*/
u32 beginscenetime = 0;
u32 scenetime = 0;
u32 endscenetime = 0;
- u32 alltime = 0;
- // A test
- //throw con::PeerNotFoundException("lol");
-
float recent_turn_speed = 0.0;
ProfilerGraph graph;
+ // Initially clear the profiler
+ Profiler::GraphValues dummyvalues;
+ g_profiler->graphGet(dummyvalues);
float nodig_delay_timer = 0.0;
float dig_time = 0.0;
bool digging = false;
bool ldown_for_dig = false;
- float damage_flash_timer = 0;
+ float damage_flash = 0;
s16 farmesh_range = 20*MAP_BLOCKSIZE;
+ 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 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;
+
for(;;)
{
- TimeTaker tt_all("mainloop: all");
-
if(device->run() == false || kill == true)
break;
- if(client.accessDenied())
- {
- error_message = L"Access denied. Reason: "
- +client.accessDeniedReason();
- errorstream<<wide_to_narrow(error_message)<<std::endl;
- break;
- }
-
- if(g_gamecallback->disconnect_requested)
- {
- g_gamecallback->disconnect_requested = false;
- break;
- }
-
- if(g_gamecallback->changepassword_requested)
- {
- (new GUIPasswordChange(guienv, guiroot, -1,
- &g_menumgr, &client))->drop();
- g_gamecallback->changepassword_requested = false;
- }
-
- /*
- Process TextureSource's queue
- */
- tsrc->processQueue();
-
- /*
- Random calculations
- */
- last_screensize = screensize;
- screensize = driver->getScreenSize();
- v2s32 displaycenter(screensize.X/2,screensize.Y/2);
- //bool screensize_changed = screensize != last_screensize;
-
- // Resize hotbar
- if(screensize.Y <= 800)
- hotbar_imagesize = 32;
- else if(screensize.Y <= 1280)
- hotbar_imagesize = 48;
- else
- hotbar_imagesize = 64;
-
- // Hilight boxes collected during the loop and displayed
- core::list< core::aabbox3d<f32> > hilightboxes;
-
- // Info text
- std::wstring infotext;
-
- // When screen size changes, update positions and sizes of stuff
- /*if(screensize_changed)
- {
- v2s32 pos(displaycenter.X-((quickinv_itemcount-1)*quickinv_spacing+quickinv_size)/2, screensize.Y-quickinv_spacing);
- quick_inventory->updatePosition(pos);
- }*/
-
- //TimeTaker //timer1("//timer1");
-
// Time of frame without fps limit
float busytime;
u32 busytime_u32;
busytime_u32 = 0;
busytime = busytime_u32 / 1000.0;
}
+
+ g_profiler->graphAdd("mainloop_other", busytime - (float)drawtime/1000.0f);
- //infostream<<"busytime_u32="<<busytime_u32<<std::endl;
-
// Necessary for device->getTimer()->getTime()
device->run();
{
u32 sleeptime = frametime_min - busytime_u32;
device->sleep(sleeptime);
+ g_profiler->graphAdd("mainloop_sleep", (float)sleeptime/1000.0f);
}
}
dtime = 0;
lasttime = time;
+ g_profiler->graphAdd("mainloop_dtime", dtime);
+
/* Run timers */
if(nodig_delay_timer >= 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);
- /*
- Visualize frametime in terminal
- */
- /*for(u32 i=0; i<dtime*400; i++)
- infostream<<"X";
- infostream<<std::endl;*/
-
/*
Time average and jitter calculation
*/
jitter1_min = 0.0;
}
}
+
+ /*
+ Handle miscellaneous stuff
+ */
+ if(client.accessDenied())
+ {
+ error_message = L"Access denied. Reason: "
+ +client.accessDeniedReason();
+ errorstream<<wide_to_narrow(error_message)<<std::endl;
+ break;
+ }
+
+ if(g_gamecallback->disconnect_requested)
+ {
+ g_gamecallback->disconnect_requested = false;
+ break;
+ }
+
+ if(g_gamecallback->changepassword_requested)
+ {
+ (new GUIPasswordChange(guienv, guiroot, -1,
+ &g_menumgr, &client))->drop();
+ g_gamecallback->changepassword_requested = false;
+ }
+
+ 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);
+
+ /*
+ Process ShaderSource's queue
+ */
+ shsrc->processQueue();
+
+ /*
+ Random calculations
+ */
+ last_screensize = screensize;
+ screensize = driver->getScreenSize();
+ v2s32 displaycenter(screensize.X/2,screensize.Y/2);
+ //bool screensize_changed = screensize != last_screensize;
+
+ // Resize hotbar
+ if(screensize.Y <= 800)
+ hotbar_imagesize = 32;
+ else if(screensize.Y <= 1280)
+ hotbar_imagesize = 48;
+ else
+ hotbar_imagesize = 64;
+
+ // Hilight boxes collected during the loop and displayed
+ std::vector<aabb3f> hilightboxes;
+
+ // Info text
+ std::wstring infotext;
+
/*
Debug info for client
*/
// Input handler step() (used by the random input generator)
input->step(dtime);
+ // 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),
+ GUIFormSpecMenu *menu =
+ new GUIFormSpecMenu(device, guiroot, -1,
+ &g_menumgr,
&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)));
-
- menu->setDrawSpec(draw_spec);
-
+ PlayerInventoryFormSource *src = new PlayerInventoryFormSource(&client);
+ assert(src);
+ menu->setFormSpec(src->getForm(), inventoryloc);
+ menu->setFormSource(src);
+ menu->setTextDest(new TextDestPlayerInventory(&client));
menu->drop();
}
else if(input->wasKeyDown(EscapeKey))
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")))
{
if(g_settings->getBool("fast_move"))
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")))
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();
bool a_jump,
bool a_superspeed,
bool a_sneak,
+ bool a_LMB,
+ bool a_RMB,
float a_pitch,
float a_yaw*/
PlayerControl control(
input->isKeyDown(getKeySetting("keymap_jump")),
input->isKeyDown(getKeySetting("keymap_special1")),
input->isKeyDown(getKeySetting("keymap_sneak")),
+ input->getLeftState(),
+ input->getRightState(),
camera_pitch,
camera_yaw
);
client.setPlayerControl(control);
+ u32 keyPressed=
+ 1*(int)input->isKeyDown(getKeySetting("keymap_forward"))+
+ 2*(int)input->isKeyDown(getKeySetting("keymap_backward"))+
+ 4*(int)input->isKeyDown(getKeySetting("keymap_left"))+
+ 8*(int)input->isKeyDown(getKeySetting("keymap_right"))+
+ 16*(int)input->isKeyDown(getKeySetting("keymap_jump"))+
+ 32*(int)input->isKeyDown(getKeySetting("keymap_special1"))+
+ 64*(int)input->isKeyDown(getKeySetting("keymap_sneak"))+
+ 128*(int)input->getLeftState()+
+ 256*(int)input->getRightState();
+ LocalPlayer* player = client.getEnv().getLocalPlayer();
+ player->keyPressed=keyPressed;
}
/*
{
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/2;
+ player->hurt_tilt_strength = rangelim(player->hurt_tilt_strength, 2.0, 10.0);
}
else if(event.type == CE_PLAYER_FORCE_MOVE)
{
/* Handle visualization */
- damage_flash_timer = 0;
+ damage_flash = 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_SHOW_FORMSPEC)
+ {
+ if (current_formspec == 0)
+ {
+ /* Create menu */
+ current_formspec = new FormspecFormSource(*(event.show_formspec.formspec),¤t_formspec);
+
+ GUIFormSpecMenu *menu =
+ new GUIFormSpecMenu(device, guiroot, -1,
+ &g_menumgr,
+ &client, gamedef);
+ menu->setFormSource(current_formspec);
+ menu->setTextDest(new TextDestPlayerInventory(&client,*(event.show_formspec.formname)));
+ menu->drop();
+ }
+ else
+ {
+ /* update menu */
+ current_formspec->setForm(*(event.show_formspec.formspec));
+ }
+ delete(event.show_formspec.formspec);
+ delete(event.show_formspec.formname);
+ }
else if(event.type == CE_TEXTURES_UPDATED)
{
update_wielded_item_trigger = true;
client.getEnv().getClientMap().updateCamera(camera_position,
camera_direction, camera_fov);
}
+
+ // Update sound listener
+ sound->updateListener(camera.getCameraNode()->getPosition(),
+ v3f(0,0,0), // velocity
+ camera.getDirection(),
+ camera.getCameraNode()->getUpVector());
+ sound->setListenerGain(g_settings->getFloat("sound_volume"));
- //timer2.stop();
- //TimeTaker //timer3("//timer3");
+ /*
+ Update sound maker
+ */
+ {
+ soundmaker.step(dtime);
+
+ ClientMap &map = client.getEnv().getClientMap();
+ MapNode n = map.getNodeNoEx(player->getStandingNodePos());
+ soundmaker.m_player_step_sound = nodedef->get(n).sound_footstep;
+ }
/*
Calculate what block is the crosshair pointing to
core::line3d<f32> shootline(camera_position,
camera_position + camera_direction * BS * (d+1));
- core::aabbox3d<f32> hilightbox;
- bool should_show_hilightbox = false;
ClientActiveObject *selected_object = NULL;
PointedThing pointed = getPointedThing(
camera_position, shootline, d,
playeritem_liquids_pointable, !ldown_for_dig,
// output
- hilightbox, should_show_hilightbox,
+ hilightboxes,
selected_object);
if(pointed != pointed_old)
//dstream<<"Pointing at "<<pointed.dump()<<std::endl;
}
- /*
- 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(input->getRightState())
+ repeat_rightclick_timer += dtime;
+ else
+ repeat_rightclick_timer = 0;
if(playeritem_usable && input->getLeftState())
{
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_block.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
*/
ldown_for_dig = true;
}
MapNode n = client.getEnv().getClientMap().getNode(nodepos);
-
+
+ // NOTE: Similar piece of code exists on the server side for
+ // cheat detection.
// Get digging parameters
DigParams params = getDigParams(nodedef->get(n).groups,
&playeritem_toolcap);
if(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, 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;
}
-
+
// 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;
infostream<<"Digging completed"<<std::endl;
client.interact(2, pointed);
client.setCrack(-1, v3s16(0,0,0));
+ 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, 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
- if(nodig_delay_timer > 0.5)
- {
- nodig_delay_timer = 0.5;
- }
+ if(nodig_delay_timer > 0.3)
+ nodig_delay_timer = 0.3;
// We want a slight delay to very little
// time consuming nodes
float mindelay = 0.15;
if(nodig_delay_timer < mindelay)
- {
nodig_delay_timer = mindelay;
- }
+
+ // Send event to trigger sound
+ MtEvent *e = new NodeDugEvent(nodepos, wasnode);
+ gamedef->event()->put(e);
}
dig_time += dtime;
camera.setDigging(0); // left click animation
}
- if(input->getRightClicked())
+ if(input->getRightClicked() ||
+ repeat_rightclick_timer >= g_settings->getFloat("repeat_rightclick_time"))
{
+ repeat_rightclick_timer = 0;
infostream<<"Ground right-clicked"<<std::endl;
- // If metadata provides an inventory view, activate it
- if(meta && meta->getInventoryDrawSpecString() != "" && !random_input)
- {
- 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)
+ // Sign special case, at least until formspec is properly implemented.
+ // Deprecated?
+ if(meta && meta->getString("formspec") == "hack:sign_text_input"
+ && !random_input
+ && !input->isKeyDown(getKeySetting("keymap_sneak")))
{
infostream<<"Launching metadata text input"<<std::endl;
TextDest *dest = new TextDestNodeMetadata(nodepos, &client);
- std::wstring wtext = narrow_to_wide(meta->getText());
+ std::wstring wtext = narrow_to_wide(meta->getString("text"));
(new GUITextInputMenu(guienv, guiroot, -1,
&g_menumgr, dest,
wtext))->drop();
}
+ // If metadata provides an inventory view, activate it
+ else if(meta && meta->getString("formspec") != "" && !random_input
+ && !input->isKeyDown(getKeySetting("keymap_sneak")))
+ {
+ infostream<<"Launching custom inventory view"<<std::endl;
+
+ InventoryLocation inventoryloc;
+ inventoryloc.setNodeMeta(nodepos);
+
+ /* Create menu */
+
+ GUIFormSpecMenu *menu =
+ new GUIFormSpecMenu(device, guiroot, -1,
+ &g_menumgr,
+ &client, gamedef);
+ menu->setFormSpec(meta->getString("formspec"),
+ inventoryloc);
+ menu->setFormSource(new NodeMetadataFormSource(
+ &client.getEnv().getClientMap(), nodepos));
+ menu->setTextDest(new TextDestNodeMetadata(nodepos, &client));
+ menu->drop();
+ }
// Otherwise report right click to server
else
{
+ // Report to server
client.interact(3, pointed);
camera.setDigging(1); // right click animation
+
+ // If the wielded item has node placement prediction,
+ // make that happen
+ const ItemDefinition &def =
+ playeritem.getDefinition(itemdef);
+ if(def.node_placement_prediction != ""
+ && !nodedef->get(map.getNode(nodepos)).rightclickable)
+ do{ // breakable
+ verbosestream<<"Node placement prediction for "
+ <<playeritem.name<<" is "
+ <<def.node_placement_prediction<<std::endl;
+ v3s16 p = neighbourpos;
+ // Place inside node itself if buildable_to
+ try{
+ MapNode n_under = map.getNode(nodepos);
+ if(nodedef->get(n_under).buildable_to)
+ p = nodepos;
+ }catch(InvalidPositionException &e){}
+ // Find id of predicted node
+ content_t id;
+ bool found =
+ nodedef->getId(def.node_placement_prediction, id);
+ if(!found){
+ errorstream<<"Node placement prediction failed for "
+ <<playeritem.name<<" (places "
+ <<def.node_placement_prediction
+ <<") - Name not known"<<std::endl;
+ break;
+ }
+ MapNode n(id);
+ try{
+ // This triggers the required mesh update too
+ client.addNode(p, n);
+ }catch(InvalidPositionException &e){
+ errorstream<<"Node placement prediction failed for "
+ <<playeritem.name<<" (places "
+ <<def.node_placement_prediction
+ <<") - Position not loaded"<<std::endl;
+ }
+ }while(0);
}
}
}
Fog range
*/
- f32 fog_range;
if(farmesh)
{
fog_range = BS*farmesh_range;
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")){
farmesh->update(v2f(player_position.X, player_position.Z),
brightness, farmesh_range);
}
+
+ /*
+ Update particles
+ */
+
+ allparticles_step(dtime, client.getEnv());
/*
Fog
//TimeTaker guiupdatetimer("Gui updating");
const char program_name_and_version[] =
- "Minetest-c55 " VERSION_STRING;
+ "Minetest " VERSION_STRING;
if(show_debug)
{
char temptext[300];
snprintf(temptext, 300,
"(% .1f, % .1f, % .1f)"
- " (yaw = %.1f)",
+ " (yaw = %.1f) (seed = %lli)",
player_position.X/BS,
player_position.Y/BS,
player_position.Z/BS,
- wrapDegrees_0_360(camera_yaw));
+ wrapDegrees_0_360(camera_yaw),
+ client.getMapSeed());
guitext2->setText(narrow_to_wide(temptext).c_str());
guitext2->setVisible(true);
}
{
- float statustext_time_max = 3.0;
+ float statustext_time_max = 1.5;
if(!statustext.empty())
{
statustext_time += dtime;
initial_color.getInterpolated_quadratic(
initial_color,
final_color,
- statustext_time / (float) statustext_time_max);
+ pow(statustext_time / (float)statustext_time_max, 2.0f));
guitext_status->setOverrideColor(fade_color);
guitext_status->enableOverrideColor(true);
}
ItemStack item;
if(mlist != NULL)
item = mlist->getItem(client.getPlayerItem());
- camera.wield(item, gamedef);
+ camera.wield(item);
}
-
+
+ /*
+ Update block draw list every 200ms or when camera direction has
+ changed much
+ */
+ update_draw_list_timer += dtime;
+ if(update_draw_list_timer >= 0.2 ||
+ update_draw_list_last_cam_dir.getDistanceFrom(camera_direction) > 0.2){
+ update_draw_list_timer = 0;
+ client.getEnv().getClientMap().updateDrawList(driver);
+ update_draw_list_last_cam_dir = camera_direction;
+ }
+
/*
Drawing begins
*/
{
TimeTaker timer("smgr");
smgr->drawAll();
+
+ if(g_settings->getBool("anaglyph"))
+ {
+ irr::core::vector3df oldPosition = camera.getCameraNode()->getPosition();
+ irr::core::vector3df oldTarget = camera.getCameraNode()->getTarget();
+
+ irr::core::matrix4 startMatrix = camera.getCameraNode()->getAbsoluteTransformation();
+
+ irr::core::vector3df focusPoint = (camera.getCameraNode()->getTarget() -
+ camera.getCameraNode()->getAbsolutePosition()).setLength(1) +
+ camera.getCameraNode()->getAbsolutePosition() ;
+
+ //Left eye...
+ irr::core::vector3df leftEye;
+ irr::core::matrix4 leftMove;
+
+ leftMove.setTranslation( irr::core::vector3df(-g_settings->getFloat("anaglyph_strength"),0.0f,0.0f) );
+ leftEye=(startMatrix*leftMove).getTranslation();
+
+ //clear the depth buffer, and color
+ driver->beginScene( true, true, irr::video::SColor(0,200,200,255) );
+
+ driver->getOverrideMaterial().Material.ColorMask = irr::video::ECP_RED;
+ driver->getOverrideMaterial().EnableFlags = irr::video::EMF_COLOR_MASK;
+ driver->getOverrideMaterial().EnablePasses = irr::scene::ESNRP_SKY_BOX +
+ irr::scene::ESNRP_SOLID +
+ irr::scene::ESNRP_TRANSPARENT +
+ irr::scene::ESNRP_TRANSPARENT_EFFECT +
+ irr::scene::ESNRP_SHADOW;
+
+ camera.getCameraNode()->setPosition( leftEye );
+ camera.getCameraNode()->setTarget( focusPoint );
+
+ smgr->drawAll(); // 'smgr->drawAll();' may go here
+
+
+ //Right eye...
+ irr::core::vector3df rightEye;
+ irr::core::matrix4 rightMove;
+
+ rightMove.setTranslation( irr::core::vector3df(g_settings->getFloat("anaglyph_strength"),0.0f,0.0f) );
+ rightEye=(startMatrix*rightMove).getTranslation();
+
+ //clear the depth buffer
+ driver->clearZBuffer();
+
+ driver->getOverrideMaterial().Material.ColorMask = irr::video::ECP_GREEN + irr::video::ECP_BLUE;
+ driver->getOverrideMaterial().EnableFlags = irr::video::EMF_COLOR_MASK;
+ driver->getOverrideMaterial().EnablePasses = irr::scene::ESNRP_SKY_BOX +
+ irr::scene::ESNRP_SOLID +
+ irr::scene::ESNRP_TRANSPARENT +
+ irr::scene::ESNRP_TRANSPARENT_EFFECT +
+ irr::scene::ESNRP_SHADOW;
+
+ camera.getCameraNode()->setPosition( rightEye );
+ camera.getCameraNode()->setTarget( focusPoint );
+
+ smgr->drawAll(); // 'smgr->drawAll();' may go here
+
+
+ //driver->endScene();
+
+ driver->getOverrideMaterial().Material.ColorMask=irr::video::ECP_ALL;
+ driver->getOverrideMaterial().EnableFlags=0;
+ driver->getOverrideMaterial().EnablePasses=0;
+
+ camera.getCameraNode()->setPosition( oldPosition );
+ camera.getCameraNode()->setTarget( oldTarget );
+ }
+
scenetime = timer.stop(true);
}
if(show_hud)
{
- for(core::list<aabb3f>::Iterator i=hilightboxes.begin();
- i != hilightboxes.end(); i++)
- {
+ v3f selectionbox_color = g_settings->getV3F("selectionbox_color");
+ u32 selectionbox_color_r = rangelim(myround(selectionbox_color.X), 0, 255);
+ u32 selectionbox_color_g = rangelim(myround(selectionbox_color.Y), 0, 255);
+ u32 selectionbox_color_b = rangelim(myround(selectionbox_color.Z), 0, 255);
+
+ for(std::vector<aabb3f>::const_iterator
+ i = hilightboxes.begin();
+ i != hilightboxes.end(); i++)
+ {
/*infostream<<"hilightbox min="
<<"("<<i->MinEdge.X<<","<<i->MinEdge.Y<<","<<i->MinEdge.Z<<")"
<<" max="
<<"("<<i->MaxEdge.X<<","<<i->MaxEdge.Y<<","<<i->MaxEdge.Z<<")"
<<std::endl;*/
- driver->draw3DBox(*i, video::SColor(255,0,0,0));
+ driver->draw3DBox(*i, video::SColor(255,selectionbox_color_r,selectionbox_color_g,selectionbox_color_b));
}
}
*/
if(show_hud)
{
+ v3f crosshair_color = g_settings->getV3F("crosshair_color");
+ u32 crosshair_color_r = rangelim(myround(crosshair_color.X), 0, 255);
+ u32 crosshair_color_g = rangelim(myround(crosshair_color.Y), 0, 255);
+ u32 crosshair_color_b = rangelim(myround(crosshair_color.Z), 0, 255);
+ u32 crosshair_alpha = rangelim(g_settings->getS32("crosshair_alpha"), 0, 255);
+
driver->draw2DLine(displaycenter - core::vector2d<s32>(10,0),
displaycenter + core::vector2d<s32>(10,0),
- video::SColor(255,255,255,255));
+ video::SColor(crosshair_alpha,crosshair_color_r,crosshair_color_g,crosshair_color_b));
driver->draw2DLine(displaycenter - core::vector2d<s32>(0,10),
displaycenter + core::vector2d<s32>(0,10),
- video::SColor(255,255,255,255));
+ video::SColor(crosshair_alpha,crosshair_color_r,crosshair_color_g,crosshair_color_b));
}
} // timer
//timer10.stop();
//TimeTaker //timer11("//timer11");
- /*
- Draw gui
- */
- // 0-1ms
- guienv->drawAll();
/*
Draw hotbar
/*
Damage flash
*/
- if(damage_flash_timer > 0.0)
+ if(damage_flash > 0.0)
{
- damage_flash_timer -= dtime;
-
- video::SColor color(128,255,0,0);
+ 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);
+
+ damage_flash -= 100.0*dtime;
}
- // Clear Z buffer
- driver->clearZBuffer();
- // Draw some sky things
- //draw_horizon(driver, camera.getCameraNode());
-
+ /*
+ Damage camera tilt
+ */
+ if(player->hurt_tilt_timer > 0.0)
+ {
+ player->hurt_tilt_timer -= dtime*5;
+ if(player->hurt_tilt_timer < 0)
+ player->hurt_tilt_strength = 0;
+ }
+
+ /*
+ Draw gui
+ */
+ // 0-1ms
+ guienv->drawAll();
+
/*
End scene
*/
lastFPS = fps;
}
- alltime = tt_all.stop(true);
- g_profiler->graphAdd("mainloop_other", (float)(alltime-drawtime)/1000.0f);
-
/*
Log times and stuff for visualization
*/
// Client scope (client is destructed before destructing *def and tsrc)
}while(0);
+ } // try-catch
+ catch(SerializationError &e)
+ {
+ error_message = L"A serialization error occurred:\n"
+ + narrow_to_wide(e.what()) + L"\n\nThe server is probably "
+ L" running a different version of Minetest.";
+ errorstream<<wide_to_narrow(error_message)<<std::endl;
+ }
+
+ if(!sound_is_dummy)
+ delete sound;
delete tsrc;
+ delete shsrc;
delete nodedef;
delete itemdef;
}