/*
-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"
#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;
+ 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
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;
}
};
+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();
MapDrawControl draw_control;
Client client(device, playername.c_str(), password, draw_control,
- tsrc, itemdef, nodedef, sound, &eventmgr);
+ tsrc, shsrc, itemdef, nodedef, sound, &eventmgr);
// Client acts as our GameDef
IGameDef *gamedef = &client;
*/
Inventory local_inventory(itemdef);
+ /*
+ Find out size of crack animation
+ */
+ int crack_animation_length = 5;
+ {
+ video::ITexture *t = tsrc->getTextureRaw("crack_anylength.png");
+ v2u32 size = t->getOriginalSize();
+ crack_animation_length = size.Y / size.X;
+ }
+
/*
Add some gui stuff
*/
// 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(
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(;;)
{
if(device->run() == false || kill == true)
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 TextureSource's queue
+ Process ShaderSource's queue
*/
- tsrc->processQueue();
+ shsrc->processQueue();
/*
Random calculations
hotbar_imagesize = 64;
// Hilight boxes collected during the loop and displayed
- core::list< core::aabbox3d<f32> > hilightboxes;
+ std::vector<aabb3f> hilightboxes;
// Info text
std::wstring infotext;
// 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,
+ GUIFormSpecMenu *menu =
+ new GUIFormSpecMenu(device, guiroot, -1,
&g_menumgr,
&client, gamedef);
InventoryLocation inventoryloc;
inventoryloc.setCurrentPlayer();
- menu->setFormSpec(
- "invsize[8,7.5;]"
- //"image[1,0.6;1,2;player.png]"
- "list[current_player;main;0,3.5;8,4;]"
- "list[current_player;craft;3,0;3,3;]"
- "list[current_player;craftpreview;7,1;1,1;]"
- , inventoryloc);
-
+ 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))
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"))
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();
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;
}
+ else if(event.type == CE_SPAWN_PARTICLE)
+ {
+ LocalPlayer* player = client.getEnv().getLocalPlayer();
+ AtlasPointer ap =
+ 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, ap);
+ }
+ else if(event.type == CE_ADD_PARTICLESPAWNER)
+ {
+ LocalPlayer* player = client.getEnv().getLocalPlayer();
+ AtlasPointer ap =
+ 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,
+ ap,
+ event.add_particlespawner.id);
+ }
+ else if(event.type == CE_DELETE_PARTICLESPAWNER)
+ {
+ delete_particlespawner (event.delete_particlespawner.id);
+ }
}
}
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())
{
if(input->getLeftClicked())
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);
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;
}
-
+
// 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
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;
- // sign special case, at least until formspec is properly implemented
- if(meta && meta->getString("formspec") == "hack:sign_text_input" && !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;
wtext))->drop();
}
// If metadata provides an inventory view, activate it
- else if(meta && meta->getString("formspec") != "" && !random_input)
+ else if(meta && meta->getString("formspec") != "" && !random_input
+ && !input->isKeyDown(getKeySetting("keymap_sneak")))
{
infostream<<"Launching custom inventory view"<<std::endl;
/* Create menu */
- GUIInventoryMenu *menu =
- new GUIInventoryMenu(guienv, guiroot, -1,
+ 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);
+
+ // Read the sound
+ soundmaker.m_player_rightpunch_sound = def.sound_place;
}
}
}
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());
+ allparticlespawners_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) (seed = %lli)",
+ " (yaw = %.1f) (seed = %llu)",
player_position.X/BS,
player_position.Y/BS,
player_position.Z/BS,
wrapDegrees_0_360(camera_yaw),
- client.getMapSeed());
+ (unsigned long long)client.getMapSeed());
guitext2->setText(narrow_to_wide(temptext).c_str());
guitext2->setVisible(true);
item = mlist->getItem(client.getPlayerItem());
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;
+ }
+
+ /*
+ 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
*/
clouds->drop();
if(gui_chat_console)
gui_chat_console->drop();
+ clear_particles ();
/*
Draw a "shutting down" screen, which will be shown while the map
if(!sound_is_dummy)
delete sound;
+
+ delete tsrc;
+ delete shsrc;
delete nodedef;
delete itemdef;
- delete tsrc;
}
projects / minetest.git / blobdiff