2011-04-23 11:31:31 -04:00
|
|
|
/*
|
|
|
|
Minetest-c55
|
2011-04-29 19:12:32 -04:00
|
|
|
Copyright (C) 2010-2011 celeron55, Perttu Ahola <celeron55@gmail.com>
|
2011-04-23 11:31:31 -04:00
|
|
|
|
|
|
|
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
|
|
|
|
(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.
|
|
|
|
|
|
|
|
You should have received a copy of the GNU 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"
|
2011-10-12 06:53:38 -04:00
|
|
|
#include "common_irrlicht.h"
|
|
|
|
#include <IGUICheckBox.h>
|
|
|
|
#include <IGUIEditBox.h>
|
|
|
|
#include <IGUIButton.h>
|
|
|
|
#include <IGUIStaticText.h>
|
|
|
|
#include <IGUIFont.h>
|
2011-04-23 11:31:31 -04:00
|
|
|
#include "client.h"
|
|
|
|
#include "server.h"
|
|
|
|
#include "guiPauseMenu.h"
|
2011-05-22 16:09:12 -04:00
|
|
|
#include "guiPasswordChange.h"
|
2011-04-23 11:31:31 -04:00
|
|
|
#include "guiInventoryMenu.h"
|
|
|
|
#include "guiTextInputMenu.h"
|
2011-10-15 07:46:59 -04:00
|
|
|
#include "guiDeathScreen.h"
|
2012-02-28 12:45:23 -05:00
|
|
|
#include "tool.h"
|
2011-04-24 04:41:33 -04:00
|
|
|
#include "config.h"
|
2011-04-29 08:34:26 -04:00
|
|
|
#include "clouds.h"
|
2011-09-07 19:08:47 -04:00
|
|
|
#include "camera.h"
|
2011-06-07 15:08:16 -04:00
|
|
|
#include "farmesh.h"
|
2011-06-25 19:34:36 -04:00
|
|
|
#include "mapblock.h"
|
2011-10-12 06:53:38 -04:00
|
|
|
#include "settings.h"
|
|
|
|
#include "profiler.h"
|
|
|
|
#include "mainmenumanager.h"
|
2011-10-15 07:46:59 -04:00
|
|
|
#include "gettext.h"
|
2011-10-16 07:57:53 -04:00
|
|
|
#include "log.h"
|
2011-10-16 09:16:47 -04:00
|
|
|
#include "filesys.h"
|
2011-11-13 03:57:55 -05:00
|
|
|
// Needed for determining pointing to nodes
|
2011-11-14 14:41:30 -05:00
|
|
|
#include "nodedef.h"
|
2011-11-13 05:54:33 -05:00
|
|
|
#include "nodemetadata.h"
|
2011-11-13 17:19:48 -05:00
|
|
|
#include "main.h" // For g_settings
|
2012-01-12 00:10:39 -05:00
|
|
|
#include "itemdef.h"
|
2011-11-15 06:13:18 -05:00
|
|
|
#include "tile.h" // For TextureSource
|
2011-11-27 07:29:48 -05:00
|
|
|
#include "logoutputbuffer.h"
|
2011-06-17 15:20:15 -04:00
|
|
|
|
2011-04-23 11:31:31 -04:00
|
|
|
/*
|
|
|
|
Setting this to 1 enables a special camera mode that forces
|
|
|
|
the renderers to think that the camera statically points from
|
|
|
|
the starting place to a static direction.
|
|
|
|
|
|
|
|
This allows one to move around with the player and see what
|
|
|
|
is actually drawn behind solid things and behind the player.
|
|
|
|
*/
|
|
|
|
#define FIELD_OF_VIEW_TEST 0
|
|
|
|
|
|
|
|
|
|
|
|
// Chat data
|
|
|
|
struct ChatLine
|
|
|
|
{
|
|
|
|
ChatLine():
|
|
|
|
age(0.0)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
ChatLine(const std::wstring &a_text):
|
|
|
|
age(0.0),
|
|
|
|
text(a_text)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
float age;
|
|
|
|
std::wstring text;
|
|
|
|
};
|
|
|
|
|
|
|
|
/*
|
|
|
|
Text input system
|
|
|
|
*/
|
|
|
|
|
|
|
|
struct TextDestChat : public TextDest
|
|
|
|
{
|
|
|
|
TextDestChat(Client *client)
|
|
|
|
{
|
|
|
|
m_client = client;
|
|
|
|
}
|
|
|
|
void gotText(std::wstring text)
|
|
|
|
{
|
|
|
|
// Discard empty line
|
|
|
|
if(text == L"")
|
|
|
|
return;
|
|
|
|
|
|
|
|
// Send to others
|
|
|
|
m_client->sendChatMessage(text);
|
|
|
|
// Show locally
|
|
|
|
m_client->addChatMessage(text);
|
|
|
|
}
|
|
|
|
|
|
|
|
Client *m_client;
|
|
|
|
};
|
|
|
|
|
2011-11-13 05:48:05 -05:00
|
|
|
struct TextDestNodeMetadata : public TextDest
|
2011-04-23 11:31:31 -04:00
|
|
|
{
|
2011-11-13 05:48:05 -05:00
|
|
|
TextDestNodeMetadata(v3s16 p, Client *client)
|
2011-04-23 11:31:31 -04:00
|
|
|
{
|
|
|
|
m_p = p;
|
|
|
|
m_client = client;
|
|
|
|
}
|
|
|
|
void gotText(std::wstring text)
|
|
|
|
{
|
|
|
|
std::string ntext = wide_to_narrow(text);
|
2011-10-16 07:57:53 -04:00
|
|
|
infostream<<"Changing text of a sign node: "
|
2011-04-23 11:31:31 -04:00
|
|
|
<<ntext<<std::endl;
|
|
|
|
m_client->sendSignNodeText(m_p, ntext);
|
|
|
|
}
|
|
|
|
|
|
|
|
v3s16 m_p;
|
|
|
|
Client *m_client;
|
|
|
|
};
|
|
|
|
|
2011-10-15 07:46:59 -04:00
|
|
|
/* Respawn menu callback */
|
|
|
|
|
|
|
|
class MainRespawnInitiator: public IRespawnInitiator
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
MainRespawnInitiator(bool *active, Client *client):
|
|
|
|
m_active(active), m_client(client)
|
|
|
|
{
|
|
|
|
*m_active = true;
|
|
|
|
}
|
|
|
|
void respawn()
|
|
|
|
{
|
|
|
|
*m_active = false;
|
|
|
|
m_client->sendRespawn();
|
|
|
|
}
|
|
|
|
private:
|
|
|
|
bool *m_active;
|
|
|
|
Client *m_client;
|
|
|
|
};
|
|
|
|
|
2011-04-23 11:31:31 -04:00
|
|
|
/*
|
|
|
|
Hotbar draw routine
|
|
|
|
*/
|
|
|
|
void draw_hotbar(video::IVideoDriver *driver, gui::IGUIFont *font,
|
2012-01-12 00:10:39 -05:00
|
|
|
IGameDef *gamedef,
|
2011-04-23 11:31:31 -04:00
|
|
|
v2s32 centerlowerpos, s32 imgsize, s32 itemcount,
|
2011-11-29 10:15:18 -05:00
|
|
|
Inventory *inventory, s32 halfheartcount, u16 playeritem)
|
2011-04-23 11:31:31 -04:00
|
|
|
{
|
|
|
|
InventoryList *mainlist = inventory->getList("main");
|
|
|
|
if(mainlist == NULL)
|
|
|
|
{
|
2011-10-16 07:57:53 -04:00
|
|
|
errorstream<<"draw_hotbar(): mainlist == NULL"<<std::endl;
|
2011-04-23 11:31:31 -04:00
|
|
|
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++)
|
|
|
|
{
|
2012-01-12 00:10:39 -05:00
|
|
|
const ItemStack &item = mainlist->getItem(i);
|
2011-04-23 11:31:31 -04:00
|
|
|
|
|
|
|
core::rect<s32> rect = imgrect + pos
|
|
|
|
+ v2s32(padding+i*(imgsize+padding*2), padding);
|
|
|
|
|
2011-11-29 10:15:18 -05:00
|
|
|
if(playeritem == i)
|
2011-04-23 11:31:31 -04:00
|
|
|
{
|
2011-08-22 17:31:18 -04:00
|
|
|
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);
|
|
|
|
*/
|
2011-04-23 11:31:31 -04:00
|
|
|
}
|
|
|
|
|
2011-08-22 17:31:18 -04:00
|
|
|
video::SColor bgcolor2(128,0,0,0);
|
|
|
|
driver->draw2DRectangle(bgcolor2, rect, NULL);
|
2012-01-12 00:10:39 -05:00
|
|
|
drawItemStack(driver, font, item, rect, NULL, gamedef);
|
2011-04-23 11:31:31 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
Draw hearts
|
|
|
|
*/
|
2012-01-12 00:10:39 -05:00
|
|
|
video::ITexture *heart_texture =
|
|
|
|
gamedef->getTextureSource()->getTextureRaw("heart.png");
|
2011-11-15 01:48:24 -05:00
|
|
|
if(heart_texture)
|
2011-04-23 11:31:31 -04:00
|
|
|
{
|
|
|
|
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);
|
2011-06-18 02:04:31 -04:00
|
|
|
p += v2s32(16,0);
|
2011-04-23 11:31:31 -04:00
|
|
|
}
|
|
|
|
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);
|
2011-06-18 02:04:31 -04:00
|
|
|
p += v2s32(16,0);
|
2011-04-23 11:31:31 -04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-11-29 10:15:18 -05:00
|
|
|
/*
|
|
|
|
Check if a node is pointable
|
|
|
|
*/
|
|
|
|
inline bool isPointableNode(const MapNode& n,
|
|
|
|
Client *client, bool liquids_pointable)
|
|
|
|
{
|
|
|
|
const ContentFeatures &features = client->getNodeDefManager()->get(n);
|
|
|
|
return features.pointable ||
|
|
|
|
(liquids_pointable && features.isLiquid());
|
|
|
|
}
|
|
|
|
|
2011-04-23 11:31:31 -04:00
|
|
|
/*
|
|
|
|
Find what the player is pointing at
|
|
|
|
*/
|
2011-11-29 10:15:18 -05:00
|
|
|
PointedThing getPointedThing(Client *client, v3f player_position,
|
2011-04-23 11:31:31 -04:00
|
|
|
v3f camera_direction, v3f camera_position,
|
2011-11-29 10:15:18 -05:00
|
|
|
core::line3d<f32> shootline, f32 d,
|
|
|
|
bool liquids_pointable,
|
|
|
|
bool look_for_object,
|
|
|
|
core::aabbox3d<f32> &hilightbox,
|
|
|
|
bool &should_show_hilightbox,
|
|
|
|
ClientActiveObject *&selected_object)
|
2011-04-23 11:31:31 -04:00
|
|
|
{
|
2011-11-29 10:15:18 -05:00
|
|
|
PointedThing result;
|
|
|
|
|
|
|
|
hilightbox = core::aabbox3d<f32>(0,0,0,0,0,0);
|
|
|
|
should_show_hilightbox = false;
|
|
|
|
selected_object = NULL;
|
|
|
|
|
2012-01-20 18:11:44 -05:00
|
|
|
INodeDefManager *nodedef = client->getNodeDefManager();
|
|
|
|
|
2011-11-29 10:15:18 -05:00
|
|
|
// First try to find a pointed at active object
|
|
|
|
if(look_for_object)
|
|
|
|
{
|
|
|
|
selected_object = client->getSelectedActiveObject(d*BS,
|
|
|
|
camera_position, shootline);
|
|
|
|
}
|
|
|
|
if(selected_object != NULL)
|
|
|
|
{
|
|
|
|
core::aabbox3d<f32> *selection_box
|
|
|
|
= selected_object->getSelectionBox();
|
|
|
|
// Box should exist because object was returned in the
|
|
|
|
// first place
|
|
|
|
assert(selection_box);
|
|
|
|
|
|
|
|
v3f pos = selected_object->getPosition();
|
|
|
|
|
|
|
|
hilightbox = core::aabbox3d<f32>(
|
|
|
|
selection_box->MinEdge + pos,
|
|
|
|
selection_box->MaxEdge + pos
|
|
|
|
);
|
|
|
|
|
|
|
|
should_show_hilightbox = selected_object->doShowSelectionBox();
|
|
|
|
|
|
|
|
result.type = POINTEDTHING_OBJECT;
|
|
|
|
result.object_id = selected_object->getId();
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
// That didn't work, try to find a pointed at node
|
|
|
|
|
2011-04-23 11:31:31 -04:00
|
|
|
f32 mindistance = BS * 1001;
|
|
|
|
|
|
|
|
v3s16 pos_i = floatToInt(player_position, BS);
|
|
|
|
|
2011-10-16 07:57:53 -04:00
|
|
|
/*infostream<<"pos_i=("<<pos_i.X<<","<<pos_i.Y<<","<<pos_i.Z<<")"
|
2011-04-23 11:31:31 -04:00
|
|
|
<<std::endl;*/
|
|
|
|
|
|
|
|
s16 a = d;
|
|
|
|
s16 ystart = pos_i.Y + 0 - (camera_direction.Y<0 ? a : 1);
|
|
|
|
s16 zstart = pos_i.Z - (camera_direction.Z<0 ? a : 1);
|
|
|
|
s16 xstart = pos_i.X - (camera_direction.X<0 ? a : 1);
|
|
|
|
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);
|
|
|
|
|
|
|
|
for(s16 y = ystart; y <= yend; y++)
|
|
|
|
for(s16 z = zstart; z <= zend; z++)
|
|
|
|
for(s16 x = xstart; x <= xend; x++)
|
|
|
|
{
|
|
|
|
MapNode n;
|
|
|
|
try
|
|
|
|
{
|
|
|
|
n = client->getNode(v3s16(x,y,z));
|
|
|
|
}
|
|
|
|
catch(InvalidPositionException &e)
|
|
|
|
{
|
|
|
|
continue;
|
|
|
|
}
|
2011-11-29 10:15:18 -05:00
|
|
|
if(!isPointableNode(n, client, liquids_pointable))
|
|
|
|
continue;
|
2011-04-23 11:31:31 -04:00
|
|
|
|
|
|
|
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
|
|
|
|
};
|
|
|
|
|
2012-01-20 18:11:44 -05:00
|
|
|
const ContentFeatures &f = nodedef->get(n);
|
2011-11-13 05:31:05 -05:00
|
|
|
|
|
|
|
if(f.selection_box.type == NODEBOX_FIXED)
|
2011-04-23 11:31:31 -04:00
|
|
|
{
|
2011-11-13 05:31:05 -05:00
|
|
|
core::aabbox3d<f32> box = f.selection_box.fixed;
|
|
|
|
box.MinEdge += npf;
|
|
|
|
box.MaxEdge += npf;
|
2011-04-23 11:31:31 -04:00
|
|
|
|
2011-11-14 15:57:58 -05:00
|
|
|
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++)
|
2011-04-23 11:31:31 -04:00
|
|
|
{
|
2011-11-14 15:57:58 -05:00
|
|
|
v3f facedir_f(facedirs[i].X, facedirs[i].Y, facedirs[i].Z);
|
|
|
|
v3f centerpoint = npf + facedir_f * BS/2;
|
|
|
|
f32 distance = (centerpoint - camera_position).getLength();
|
|
|
|
if(distance >= mindistance)
|
|
|
|
continue;
|
|
|
|
if(!faceboxes[i].intersectsWithLine(shootline))
|
|
|
|
continue;
|
2011-11-29 10:15:18 -05:00
|
|
|
result.type = POINTEDTHING_NODE;
|
|
|
|
result.node_undersurface = np;
|
|
|
|
result.node_abovesurface = np+facedirs[i];
|
2011-11-14 15:57:58 -05:00
|
|
|
mindistance = distance;
|
2011-11-29 10:15:18 -05:00
|
|
|
hilightbox = box;
|
|
|
|
should_show_hilightbox = true;
|
2011-04-23 11:31:31 -04:00
|
|
|
}
|
|
|
|
}
|
2011-11-13 05:31:05 -05:00
|
|
|
else if(f.selection_box.type == NODEBOX_WALLMOUNTED)
|
2011-04-23 11:31:31 -04:00
|
|
|
{
|
2012-01-20 18:11:44 -05:00
|
|
|
v3s16 dir = n.getWallMountedDir(nodedef);
|
2011-04-23 11:31:31 -04:00
|
|
|
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;
|
2011-11-13 05:31:05 -05:00
|
|
|
|
|
|
|
// top
|
|
|
|
if(dir == v3s16(0,1,0)){
|
|
|
|
box = f.selection_box.wall_top;
|
2011-07-27 13:18:09 -04:00
|
|
|
}
|
2011-11-13 05:31:05 -05:00
|
|
|
// bottom
|
|
|
|
else if(dir == v3s16(0,-1,0)){
|
|
|
|
box = f.selection_box.wall_bottom;
|
2011-07-27 13:18:09 -04:00
|
|
|
}
|
2011-11-13 05:31:05 -05:00
|
|
|
// side
|
|
|
|
else{
|
|
|
|
v3f vertices[2] =
|
|
|
|
{
|
|
|
|
f.selection_box.wall_side.MinEdge,
|
|
|
|
f.selection_box.wall_side.MaxEdge
|
|
|
|
};
|
2011-07-27 13:18:09 -04:00
|
|
|
|
2011-11-13 05:31:05 -05:00
|
|
|
for(s32 i=0; i<2; i++)
|
2011-04-23 11:31:31 -04:00
|
|
|
{
|
2011-11-13 05:31:05 -05:00
|
|
|
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);
|
2011-04-23 11:31:31 -04:00
|
|
|
}
|
2011-06-07 23:27:51 -04:00
|
|
|
|
2011-11-13 05:31:05 -05:00
|
|
|
box = core::aabbox3d<f32>(vertices[0]);
|
|
|
|
box.addInternalPoint(vertices[1]);
|
2011-06-07 23:27:51 -04:00
|
|
|
}
|
|
|
|
|
2011-11-13 05:31:05 -05:00
|
|
|
box.MinEdge += npf;
|
|
|
|
box.MaxEdge += npf;
|
|
|
|
|
2011-06-07 23:27:51 -04:00
|
|
|
if(distance < mindistance)
|
|
|
|
{
|
|
|
|
if(box.intersectsWithLine(shootline))
|
2011-04-23 11:31:31 -04:00
|
|
|
{
|
2011-11-29 10:15:18 -05:00
|
|
|
result.type = POINTEDTHING_NODE;
|
|
|
|
result.node_undersurface = np;
|
|
|
|
result.node_abovesurface = np;
|
2011-04-23 11:31:31 -04:00
|
|
|
mindistance = distance;
|
2011-11-29 10:15:18 -05:00
|
|
|
hilightbox = box;
|
|
|
|
should_show_hilightbox = true;
|
2011-04-23 11:31:31 -04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2011-11-13 05:31:05 -05:00
|
|
|
else // NODEBOX_REGULAR
|
2011-04-23 11:31:31 -04:00
|
|
|
{
|
|
|
|
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))
|
|
|
|
{
|
2011-11-29 10:15:18 -05:00
|
|
|
result.type = POINTEDTHING_NODE;
|
|
|
|
result.node_undersurface = np;
|
|
|
|
result.node_abovesurface = np + dirs[i];
|
2011-04-23 11:31:31 -04:00
|
|
|
mindistance = distance;
|
|
|
|
|
2011-11-29 10:15:18 -05:00
|
|
|
//hilightbox = facebox;
|
2011-04-23 11:31:31 -04:00
|
|
|
|
|
|
|
const float d = 0.502;
|
|
|
|
core::aabbox3d<f32> nodebox
|
|
|
|
(-BS*d, -BS*d, -BS*d, BS*d, BS*d, BS*d);
|
2011-11-29 10:15:18 -05:00
|
|
|
v3f nodepos_f = intToFloat(np, BS);
|
2011-04-23 11:31:31 -04:00
|
|
|
nodebox.MinEdge += nodepos_f;
|
|
|
|
nodebox.MaxEdge += nodepos_f;
|
2011-11-29 10:15:18 -05:00
|
|
|
hilightbox = nodebox;
|
|
|
|
should_show_hilightbox = true;
|
2011-04-23 11:31:31 -04:00
|
|
|
}
|
|
|
|
} // if distance < mindistance
|
|
|
|
} // for dirs
|
|
|
|
} // regular block
|
|
|
|
} // for coords
|
2011-11-29 10:15:18 -05:00
|
|
|
|
|
|
|
return result;
|
2011-04-23 11:31:31 -04:00
|
|
|
}
|
|
|
|
|
2011-11-15 06:13:18 -05:00
|
|
|
void update_skybox(video::IVideoDriver* driver, ITextureSource *tsrc,
|
2011-04-29 10:53:07 -04:00
|
|
|
scene::ISceneManager* smgr, scene::ISceneNode* &skybox,
|
|
|
|
float brightness)
|
|
|
|
{
|
|
|
|
if(skybox)
|
|
|
|
{
|
|
|
|
skybox->remove();
|
|
|
|
}
|
|
|
|
|
2011-06-18 05:42:17 -04:00
|
|
|
/*// Disable skybox if FarMesh is enabled
|
2011-10-12 06:53:38 -04:00
|
|
|
if(g_settings->getBool("enable_farmesh"))
|
2011-06-18 05:42:17 -04:00
|
|
|
return;*/
|
2011-06-07 15:08:16 -04:00
|
|
|
|
2012-02-03 07:50:49 -05:00
|
|
|
if(brightness >= 0.7)
|
2011-04-29 10:53:07 -04:00
|
|
|
{
|
|
|
|
skybox = smgr->addSkyBoxSceneNode(
|
2011-11-15 06:13:18 -05:00
|
|
|
tsrc->getTextureRaw("skybox2.png"),
|
|
|
|
tsrc->getTextureRaw("skybox3.png"),
|
|
|
|
tsrc->getTextureRaw("skybox1.png"),
|
|
|
|
tsrc->getTextureRaw("skybox1.png"),
|
|
|
|
tsrc->getTextureRaw("skybox1.png"),
|
|
|
|
tsrc->getTextureRaw("skybox1.png"));
|
2011-04-29 10:53:07 -04:00
|
|
|
}
|
|
|
|
else if(brightness >= 0.2)
|
|
|
|
{
|
|
|
|
skybox = smgr->addSkyBoxSceneNode(
|
2011-11-15 06:13:18 -05:00
|
|
|
tsrc->getTextureRaw("skybox2_dawn.png"),
|
|
|
|
tsrc->getTextureRaw("skybox3_dawn.png"),
|
|
|
|
tsrc->getTextureRaw("skybox1_dawn.png"),
|
|
|
|
tsrc->getTextureRaw("skybox1_dawn.png"),
|
|
|
|
tsrc->getTextureRaw("skybox1_dawn.png"),
|
|
|
|
tsrc->getTextureRaw("skybox1_dawn.png"));
|
2011-04-29 10:53:07 -04:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
skybox = smgr->addSkyBoxSceneNode(
|
2011-11-15 06:13:18 -05:00
|
|
|
tsrc->getTextureRaw("skybox2_night.png"),
|
|
|
|
tsrc->getTextureRaw("skybox3_night.png"),
|
|
|
|
tsrc->getTextureRaw("skybox1_night.png"),
|
|
|
|
tsrc->getTextureRaw("skybox1_night.png"),
|
|
|
|
tsrc->getTextureRaw("skybox1_night.png"),
|
|
|
|
tsrc->getTextureRaw("skybox1_night.png"));
|
2011-04-29 10:53:07 -04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-06-26 13:00:04 -04:00
|
|
|
/*
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2012-01-31 18:56:30 -05:00
|
|
|
/* Profiler display */
|
|
|
|
|
|
|
|
void update_profiler_gui(gui::IGUIStaticText *guitext_profiler,
|
|
|
|
gui::IGUIFont *font, u32 text_height,
|
|
|
|
u32 show_profiler, u32 show_profiler_max)
|
|
|
|
{
|
|
|
|
if(show_profiler == 0)
|
|
|
|
{
|
|
|
|
guitext_profiler->setVisible(false);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
|
|
|
|
std::ostringstream os(std::ios_base::binary);
|
|
|
|
g_profiler->printPage(os, show_profiler, show_profiler_max);
|
|
|
|
std::wstring text = narrow_to_wide(os.str());
|
|
|
|
guitext_profiler->setText(text.c_str());
|
|
|
|
guitext_profiler->setVisible(true);
|
|
|
|
|
|
|
|
s32 w = font->getDimension(text.c_str()).Width;
|
|
|
|
if(w < 400)
|
|
|
|
w = 400;
|
|
|
|
core::rect<s32> rect(6, 4+(text_height+5)*2, 12+w,
|
|
|
|
8+(text_height+5)*2 +
|
|
|
|
font->getDimension(text.c_str()).Height);
|
|
|
|
guitext_profiler->setRelativePosition(rect);
|
|
|
|
guitext_profiler->setVisible(true);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-04-23 11:31:31 -04:00
|
|
|
void the_game(
|
|
|
|
bool &kill,
|
|
|
|
bool random_input,
|
|
|
|
InputHandler *input,
|
|
|
|
IrrlichtDevice *device,
|
|
|
|
gui::IGUIFont* font,
|
|
|
|
std::string map_dir,
|
|
|
|
std::string playername,
|
2011-05-20 15:28:03 -04:00
|
|
|
std::string password,
|
2011-04-23 11:31:31 -04:00
|
|
|
std::string address,
|
|
|
|
u16 port,
|
2011-07-30 12:49:42 -04:00
|
|
|
std::wstring &error_message,
|
|
|
|
std::string configpath
|
2011-04-23 11:31:31 -04:00
|
|
|
)
|
|
|
|
{
|
|
|
|
video::IVideoDriver* driver = device->getVideoDriver();
|
|
|
|
scene::ISceneManager* smgr = device->getSceneManager();
|
2011-06-26 13:00:04 -04:00
|
|
|
|
|
|
|
// Calculate text height using the font
|
|
|
|
u32 text_height = font->getDimension(L"Random test string").Height;
|
2011-04-23 11:31:31 -04:00
|
|
|
|
|
|
|
v2u32 screensize(0,0);
|
|
|
|
v2u32 last_screensize(0,0);
|
|
|
|
screensize = driver->getScreenSize();
|
|
|
|
|
|
|
|
const s32 hotbar_itemcount = 8;
|
2011-06-26 08:48:56 -04:00
|
|
|
//const s32 hotbar_imagesize = 36;
|
|
|
|
//const s32 hotbar_imagesize = 64;
|
|
|
|
s32 hotbar_imagesize = 48;
|
2011-04-23 11:31:31 -04:00
|
|
|
|
2011-04-29 08:34:26 -04:00
|
|
|
// The color of the sky
|
|
|
|
|
2011-04-29 09:00:36 -04:00
|
|
|
//video::SColor skycolor = video::SColor(255,140,186,250);
|
|
|
|
|
|
|
|
video::SColor bgcolor_bright = video::SColor(255,170,200,230);
|
2011-04-29 08:34:26 -04:00
|
|
|
|
2011-04-23 11:31:31 -04:00
|
|
|
/*
|
|
|
|
Draw "Loading" screen
|
|
|
|
*/
|
|
|
|
|
2011-06-26 13:00:04 -04:00
|
|
|
draw_load_screen(L"Loading...", driver, font);
|
2011-04-23 11:31:31 -04:00
|
|
|
|
2011-11-13 17:19:48 -05:00
|
|
|
// Create texture source
|
2011-11-14 14:41:30 -05:00
|
|
|
IWritableTextureSource *tsrc = createTextureSource(device);
|
2011-11-15 16:58:56 -05:00
|
|
|
|
|
|
|
// These will be filled by data received from the server
|
2012-01-12 00:10:39 -05:00
|
|
|
// Create item definition manager
|
|
|
|
IWritableItemDefManager *itemdef = createItemDefManager();
|
2011-11-14 14:41:30 -05:00
|
|
|
// Create node definition manager
|
2011-11-15 07:43:15 -05:00
|
|
|
IWritableNodeDefManager *nodedef = createNodeDefManager();
|
2011-11-13 17:19:48 -05:00
|
|
|
|
2011-11-27 07:29:48 -05:00
|
|
|
// Add chat log output for errors to be shown in chat
|
|
|
|
LogOutputBuffer chat_log_error_buf(LMT_ERROR);
|
|
|
|
|
2011-04-23 11:31:31 -04:00
|
|
|
/*
|
|
|
|
Create server.
|
|
|
|
SharedPtr will delete it when it goes out of scope.
|
|
|
|
*/
|
|
|
|
SharedPtr<Server> server;
|
|
|
|
if(address == ""){
|
2011-06-26 13:00:04 -04:00
|
|
|
draw_load_screen(L"Creating server...", driver, font);
|
2011-10-16 07:57:53 -04:00
|
|
|
infostream<<"Creating server"<<std::endl;
|
2012-03-10 08:56:24 -05:00
|
|
|
server = new Server(map_dir, configpath, "mesetint");
|
2011-04-23 11:31:31 -04:00
|
|
|
server->start(port);
|
|
|
|
}
|
2011-11-14 18:00:16 -05:00
|
|
|
|
|
|
|
{ // Client scope
|
2011-04-23 11:31:31 -04:00
|
|
|
|
|
|
|
/*
|
|
|
|
Create client
|
|
|
|
*/
|
|
|
|
|
2011-06-26 13:00:04 -04:00
|
|
|
draw_load_screen(L"Creating client...", driver, font);
|
2011-10-16 07:57:53 -04:00
|
|
|
infostream<<"Creating client"<<std::endl;
|
2011-11-14 14:41:30 -05:00
|
|
|
|
2011-09-07 19:08:47 -04:00
|
|
|
MapDrawControl draw_control;
|
2011-11-14 14:41:30 -05:00
|
|
|
|
2011-11-13 17:19:48 -05:00
|
|
|
Client client(device, playername.c_str(), password, draw_control,
|
2012-01-12 00:10:39 -05:00
|
|
|
tsrc, itemdef, nodedef);
|
2011-11-14 14:41:30 -05:00
|
|
|
|
|
|
|
// Client acts as our GameDef
|
|
|
|
IGameDef *gamedef = &client;
|
2011-04-23 11:31:31 -04:00
|
|
|
|
2011-06-26 13:00:04 -04:00
|
|
|
draw_load_screen(L"Resolving address...", driver, font);
|
2011-04-23 11:31:31 -04:00
|
|
|
Address connect_address(0,0,0,0, port);
|
|
|
|
try{
|
|
|
|
if(address == "")
|
|
|
|
//connect_address.Resolve("localhost");
|
|
|
|
connect_address.setAddress(127,0,0,1);
|
|
|
|
else
|
|
|
|
connect_address.Resolve(address.c_str());
|
|
|
|
}
|
|
|
|
catch(ResolveError &e)
|
|
|
|
{
|
2011-10-16 07:57:53 -04:00
|
|
|
errorstream<<"Couldn't resolve address"<<std::endl;
|
2011-04-23 11:31:31 -04:00
|
|
|
//return 0;
|
|
|
|
error_message = L"Couldn't resolve address";
|
2011-06-26 13:00:04 -04:00
|
|
|
//gui_loadingtext->remove();
|
2011-04-23 11:31:31 -04:00
|
|
|
return;
|
|
|
|
}
|
2011-04-23 17:11:23 -04:00
|
|
|
|
|
|
|
/*
|
|
|
|
Attempt to connect to the server
|
|
|
|
*/
|
2011-04-23 11:31:31 -04:00
|
|
|
|
2011-10-16 07:57:53 -04:00
|
|
|
infostream<<"Connecting to server at ";
|
|
|
|
connect_address.print(&infostream);
|
|
|
|
infostream<<std::endl;
|
2011-04-23 11:31:31 -04:00
|
|
|
client.connect(connect_address);
|
|
|
|
|
2011-11-15 16:58:56 -05:00
|
|
|
/*
|
|
|
|
Wait for server to accept connection
|
|
|
|
*/
|
|
|
|
bool could_connect = false;
|
2011-04-23 11:31:31 -04:00
|
|
|
try{
|
2011-11-15 16:58:56 -05:00
|
|
|
float frametime = 0.033;
|
|
|
|
const float timeout = 10.0;
|
2011-04-23 17:11:23 -04:00
|
|
|
float time_counter = 0.0;
|
|
|
|
for(;;)
|
2011-04-23 11:31:31 -04:00
|
|
|
{
|
2011-11-15 16:58:56 -05:00
|
|
|
// Update client and server
|
|
|
|
client.step(frametime);
|
|
|
|
if(server != NULL)
|
|
|
|
server->step(frametime);
|
|
|
|
|
|
|
|
// End condition
|
|
|
|
if(client.connectedAndInitialized()){
|
2011-04-23 17:11:23 -04:00
|
|
|
could_connect = true;
|
|
|
|
break;
|
|
|
|
}
|
2011-11-15 16:58:56 -05:00
|
|
|
// Break conditions
|
2011-05-20 15:28:03 -04:00
|
|
|
if(client.accessDenied())
|
|
|
|
break;
|
2011-11-15 16:58:56 -05:00
|
|
|
if(time_counter >= timeout)
|
2011-04-23 17:11:23 -04:00
|
|
|
break;
|
2011-06-26 13:00:04 -04:00
|
|
|
|
2011-11-15 16:58:56 -05:00
|
|
|
// Display status
|
2011-06-26 13:00:04 -04:00
|
|
|
std::wostringstream ss;
|
|
|
|
ss<<L"Connecting to server... (timeout in ";
|
2011-11-15 16:58:56 -05:00
|
|
|
ss<<(int)(timeout - time_counter + 1.0);
|
2011-06-26 13:00:04 -04:00
|
|
|
ss<<L" seconds)";
|
|
|
|
draw_load_screen(ss.str(), driver, font);
|
2011-04-23 11:31:31 -04:00
|
|
|
|
|
|
|
// Delay a bit
|
2011-11-15 16:58:56 -05:00
|
|
|
sleep_ms(1000*frametime);
|
|
|
|
time_counter += frametime;
|
2011-04-23 11:31:31 -04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
catch(con::PeerNotFoundException &e)
|
2011-04-23 17:11:23 -04:00
|
|
|
{}
|
2011-11-15 16:58:56 -05:00
|
|
|
|
|
|
|
/*
|
|
|
|
Handle failure to connect
|
|
|
|
*/
|
2011-04-23 17:11:23 -04:00
|
|
|
if(could_connect == false)
|
2011-04-23 11:31:31 -04:00
|
|
|
{
|
2011-05-20 15:28:03 -04:00
|
|
|
if(client.accessDenied())
|
|
|
|
{
|
2011-05-29 14:11:16 -04:00
|
|
|
error_message = L"Access denied. Reason: "
|
|
|
|
+client.accessDeniedReason();
|
2011-10-16 07:57:53 -04:00
|
|
|
errorstream<<wide_to_narrow(error_message)<<std::endl;
|
2011-05-20 15:28:03 -04:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
error_message = L"Connection timed out.";
|
2011-10-16 07:57:53 -04:00
|
|
|
errorstream<<"Timed out."<<std::endl;
|
2011-05-20 15:28:03 -04:00
|
|
|
}
|
2011-06-26 13:00:04 -04:00
|
|
|
//gui_loadingtext->remove();
|
2011-04-23 11:31:31 -04:00
|
|
|
return;
|
|
|
|
}
|
2011-11-15 16:58:56 -05:00
|
|
|
|
|
|
|
/*
|
|
|
|
Wait until content has been received
|
|
|
|
*/
|
|
|
|
bool got_content = false;
|
|
|
|
{
|
|
|
|
float frametime = 0.033;
|
2011-12-11 09:52:19 -05:00
|
|
|
const float timeout = 30.0;
|
2011-11-15 16:58:56 -05:00
|
|
|
float time_counter = 0.0;
|
|
|
|
for(;;)
|
|
|
|
{
|
|
|
|
// Update client and server
|
|
|
|
client.step(frametime);
|
|
|
|
if(server != NULL)
|
|
|
|
server->step(frametime);
|
|
|
|
|
|
|
|
// End condition
|
|
|
|
if(client.texturesReceived() &&
|
2012-01-12 00:10:39 -05:00
|
|
|
client.itemdefReceived() &&
|
|
|
|
client.nodedefReceived()){
|
2011-11-15 16:58:56 -05:00
|
|
|
got_content = true;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
// Break conditions
|
|
|
|
if(!client.connectedAndInitialized())
|
|
|
|
break;
|
|
|
|
if(time_counter >= timeout)
|
|
|
|
break;
|
|
|
|
|
|
|
|
// Display status
|
|
|
|
std::wostringstream ss;
|
|
|
|
ss<<L"Waiting content... (continuing anyway in ";
|
|
|
|
ss<<(int)(timeout - time_counter + 1.0);
|
|
|
|
ss<<L" seconds)\n";
|
|
|
|
|
2012-01-12 00:10:39 -05:00
|
|
|
ss<<(client.itemdefReceived()?L"[X]":L"[ ]");
|
|
|
|
ss<<L" Item definitions\n";
|
2011-11-15 16:58:56 -05:00
|
|
|
ss<<(client.nodedefReceived()?L"[X]":L"[ ]");
|
|
|
|
ss<<L" Node definitions\n";
|
|
|
|
//ss<<(client.texturesReceived()?L"[X]":L"[ ]");
|
|
|
|
ss<<L"["<<(int)(client.textureReceiveProgress()*100+0.5)<<L"%] ";
|
|
|
|
ss<<L" Textures\n";
|
|
|
|
|
|
|
|
draw_load_screen(ss.str(), driver, font);
|
|
|
|
|
|
|
|
// Delay a bit
|
|
|
|
sleep_ms(1000*frametime);
|
|
|
|
time_counter += frametime;
|
|
|
|
}
|
|
|
|
}
|
2011-04-23 11:31:31 -04:00
|
|
|
|
2012-01-12 00:10:39 -05:00
|
|
|
/*
|
|
|
|
After all content has been received:
|
|
|
|
Update cached textures, meshes and materials
|
|
|
|
*/
|
|
|
|
client.afterContentReceived();
|
|
|
|
|
2011-04-23 11:31:31 -04:00
|
|
|
/*
|
|
|
|
Create skybox
|
|
|
|
*/
|
2011-04-29 10:53:07 -04:00
|
|
|
float old_brightness = 1.0;
|
|
|
|
scene::ISceneNode* skybox = NULL;
|
2011-11-15 06:13:18 -05:00
|
|
|
update_skybox(driver, tsrc, smgr, skybox, 1.0);
|
2011-04-23 11:31:31 -04:00
|
|
|
|
|
|
|
/*
|
|
|
|
Create the camera node
|
|
|
|
*/
|
2011-09-07 19:08:47 -04:00
|
|
|
Camera camera(smgr, draw_control);
|
2011-09-14 18:32:11 -04:00
|
|
|
if (!camera.successfullyCreated(error_message))
|
2011-09-07 19:08:47 -04:00
|
|
|
return;
|
2011-04-23 11:31:31 -04:00
|
|
|
|
|
|
|
f32 camera_yaw = 0; // "right/left"
|
|
|
|
f32 camera_pitch = 0; // "up/down"
|
|
|
|
|
2011-04-29 08:34:26 -04:00
|
|
|
/*
|
|
|
|
Clouds
|
|
|
|
*/
|
|
|
|
|
|
|
|
float cloud_height = BS*100;
|
2011-05-06 09:58:06 -04:00
|
|
|
Clouds *clouds = NULL;
|
2011-10-12 06:53:38 -04:00
|
|
|
if(g_settings->getBool("enable_clouds"))
|
2011-06-07 15:08:16 -04:00
|
|
|
{
|
|
|
|
clouds = new Clouds(smgr->getRootSceneNode(), smgr, -1,
|
|
|
|
cloud_height, time(0));
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
FarMesh
|
|
|
|
*/
|
|
|
|
|
|
|
|
FarMesh *farmesh = NULL;
|
2011-10-12 06:53:38 -04:00
|
|
|
if(g_settings->getBool("enable_farmesh"))
|
2011-06-07 15:08:16 -04:00
|
|
|
{
|
2011-06-18 05:42:17 -04:00
|
|
|
farmesh = new FarMesh(smgr->getRootSceneNode(), smgr, -1, client.getMapSeed(), &client);
|
2011-06-07 15:08:16 -04:00
|
|
|
}
|
2011-04-29 08:34:26 -04:00
|
|
|
|
2012-01-12 00:10:39 -05:00
|
|
|
/*
|
|
|
|
A copy of the local inventory
|
|
|
|
*/
|
|
|
|
Inventory local_inventory(itemdef);
|
|
|
|
|
2011-04-23 11:31:31 -04:00
|
|
|
/*
|
|
|
|
Move into game
|
|
|
|
*/
|
|
|
|
|
2011-06-26 13:00:04 -04:00
|
|
|
//gui_loadingtext->remove();
|
2011-04-23 11:31:31 -04:00
|
|
|
|
|
|
|
/*
|
|
|
|
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);
|
|
|
|
// 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);
|
|
|
|
// At the middle of the screen
|
|
|
|
// Object infos are shown in this
|
|
|
|
gui::IGUIStaticText *guitext_info = guienv->addStaticText(
|
|
|
|
L"",
|
2012-03-09 13:28:55 -05:00
|
|
|
core::rect<s32>(0,0,400,text_height*5+5) + v2s32(100,200),
|
2011-04-23 11:31:31 -04:00
|
|
|
false, false);
|
|
|
|
|
2012-01-31 18:56:30 -05:00
|
|
|
// Status text (displays info when showing and hiding GUI stuff, etc.)
|
|
|
|
gui::IGUIStaticText *guitext_status = guienv->addStaticText(
|
|
|
|
L"<Status>",
|
|
|
|
core::rect<s32>(0,0,0,0),
|
|
|
|
false, false);
|
|
|
|
guitext_status->setVisible(false);
|
|
|
|
|
|
|
|
std::wstring statustext;
|
|
|
|
float statustext_time = 0;
|
|
|
|
|
2011-04-23 11:31:31 -04:00
|
|
|
// Chat text
|
|
|
|
gui::IGUIStaticText *guitext_chat = guienv->addStaticText(
|
|
|
|
L"",
|
|
|
|
core::rect<s32>(0,0,0,0),
|
2011-06-18 01:50:14 -04:00
|
|
|
//false, false); // Disable word wrap as of now
|
|
|
|
false, true);
|
2011-04-23 11:31:31 -04:00
|
|
|
//guitext_chat->setBackgroundColor(video::SColor(96,0,0,0));
|
|
|
|
core::list<ChatLine> chat_lines;
|
|
|
|
|
2011-11-02 12:13:56 -04:00
|
|
|
// Profiler text (size is updated when text is updated)
|
2011-10-17 13:40:55 -04:00
|
|
|
gui::IGUIStaticText *guitext_profiler = guienv->addStaticText(
|
|
|
|
L"<Profiler>",
|
2012-01-31 18:56:30 -05:00
|
|
|
core::rect<s32>(0,0,0,0),
|
2011-10-17 13:40:55 -04:00
|
|
|
false, false);
|
|
|
|
guitext_profiler->setBackgroundColor(video::SColor(80,0,0,0));
|
|
|
|
guitext_profiler->setVisible(false);
|
|
|
|
|
2011-04-23 11:31:31 -04:00
|
|
|
/*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 drawtime = 0;
|
|
|
|
u32 beginscenetime = 0;
|
|
|
|
u32 scenetime = 0;
|
|
|
|
u32 endscenetime = 0;
|
|
|
|
|
|
|
|
// A test
|
|
|
|
//throw con::PeerNotFoundException("lol");
|
|
|
|
|
2011-11-15 06:13:18 -05:00
|
|
|
float brightness = 1.0;
|
|
|
|
|
2011-04-23 11:31:31 -04:00
|
|
|
core::list<float> frametime_log;
|
|
|
|
|
2011-11-29 10:15:18 -05:00
|
|
|
float nodig_delay_timer = 0.0;
|
2011-10-14 19:28:57 -04:00
|
|
|
float dig_time = 0.0;
|
|
|
|
u16 dig_index = 0;
|
2011-11-29 10:15:18 -05:00
|
|
|
PointedThing pointed_old;
|
|
|
|
bool digging = false;
|
2011-11-21 07:34:43 -05:00
|
|
|
bool ldown_for_dig = false;
|
2011-10-14 19:28:57 -04:00
|
|
|
|
2011-04-23 11:31:31 -04:00
|
|
|
float damage_flash_timer = 0;
|
2011-06-18 06:43:49 -04:00
|
|
|
s16 farmesh_range = 20*MAP_BLOCKSIZE;
|
2011-10-14 19:28:57 -04:00
|
|
|
|
2011-11-21 07:40:16 -05:00
|
|
|
const float object_hit_delay = 0.2;
|
2011-10-14 19:28:57 -04:00
|
|
|
float object_hit_delay_timer = 0.0;
|
2012-03-09 16:53:25 -05:00
|
|
|
float time_from_last_punch = 10;
|
2011-05-29 14:13:29 -04:00
|
|
|
|
2011-10-12 06:53:38 -04:00
|
|
|
bool invert_mouse = g_settings->getBool("invert_mouse");
|
2011-04-23 11:31:31 -04:00
|
|
|
|
2011-10-15 07:46:59 -04:00
|
|
|
bool respawn_menu_active = false;
|
2012-01-02 10:44:00 -05:00
|
|
|
bool update_wielded_item_trigger = false;
|
2011-10-15 07:46:59 -04:00
|
|
|
|
2012-01-31 18:56:30 -05:00
|
|
|
bool show_hud = true;
|
|
|
|
bool show_chat = true;
|
2011-10-18 14:08:31 -04:00
|
|
|
bool force_fog_off = false;
|
2011-11-02 12:13:56 -04:00
|
|
|
bool disable_camera_update = false;
|
2012-01-31 18:56:30 -05:00
|
|
|
bool show_debug = g_settings->getBool("show_debug");
|
|
|
|
bool show_debug_frametime = false;
|
|
|
|
u32 show_profiler = 0;
|
|
|
|
u32 show_profiler_max = 3; // Number of pages
|
2011-10-18 14:08:31 -04:00
|
|
|
|
2011-04-23 11:31:31 -04:00
|
|
|
/*
|
|
|
|
Main loop
|
|
|
|
*/
|
|
|
|
|
|
|
|
bool first_loop_after_window_activation = true;
|
|
|
|
|
2011-05-30 17:15:43 -04:00
|
|
|
// TODO: Convert the static interval timers to these
|
|
|
|
// Interval limiter for profiler
|
|
|
|
IntervalLimiter m_profiler_interval;
|
|
|
|
|
2011-04-23 11:31:31 -04:00
|
|
|
// Time is in milliseconds
|
|
|
|
// NOTE: getRealTime() causes strange problems in wine (imprecision?)
|
|
|
|
// NOTE: So we have to use getTime() and call run()s between them
|
|
|
|
u32 lasttime = device->getTimer()->getTime();
|
|
|
|
|
|
|
|
while(device->run() && kill == false)
|
|
|
|
{
|
2011-06-25 20:14:52 -04:00
|
|
|
//std::cerr<<"frame"<<std::endl;
|
|
|
|
|
2011-08-11 19:13:42 -04:00
|
|
|
if(client.accessDenied())
|
|
|
|
{
|
|
|
|
error_message = L"Access denied. Reason: "
|
|
|
|
+client.accessDeniedReason();
|
2011-10-16 07:57:53 -04:00
|
|
|
errorstream<<wide_to_narrow(error_message)<<std::endl;
|
2011-08-11 19:13:42 -04:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2011-04-23 11:31:31 -04:00
|
|
|
if(g_gamecallback->disconnect_requested)
|
|
|
|
{
|
|
|
|
g_gamecallback->disconnect_requested = false;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2011-05-22 16:09:12 -04:00
|
|
|
if(g_gamecallback->changepassword_requested)
|
|
|
|
{
|
|
|
|
(new GUIPasswordChange(guienv, guiroot, -1,
|
|
|
|
&g_menumgr, &client))->drop();
|
|
|
|
g_gamecallback->changepassword_requested = false;
|
|
|
|
}
|
|
|
|
|
2011-04-23 11:31:31 -04:00
|
|
|
/*
|
|
|
|
Process TextureSource's queue
|
|
|
|
*/
|
2011-11-13 17:19:48 -05:00
|
|
|
tsrc->processQueue();
|
2011-04-23 11:31:31 -04:00
|
|
|
|
|
|
|
/*
|
|
|
|
Random calculations
|
|
|
|
*/
|
|
|
|
last_screensize = screensize;
|
|
|
|
screensize = driver->getScreenSize();
|
|
|
|
v2s32 displaycenter(screensize.X/2,screensize.Y/2);
|
|
|
|
//bool screensize_changed = screensize != last_screensize;
|
2011-06-26 08:48:56 -04:00
|
|
|
|
|
|
|
// Resize hotbar
|
2011-07-23 13:22:04 -04:00
|
|
|
if(screensize.Y <= 800)
|
2011-06-26 08:48:56 -04:00
|
|
|
hotbar_imagesize = 32;
|
2011-07-23 13:22:04 -04:00
|
|
|
else if(screensize.Y <= 1280)
|
2011-06-26 08:48:56 -04:00
|
|
|
hotbar_imagesize = 48;
|
|
|
|
else
|
|
|
|
hotbar_imagesize = 64;
|
2011-04-23 11:31:31 -04:00
|
|
|
|
|
|
|
// 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;
|
|
|
|
{
|
|
|
|
// 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;
|
|
|
|
}
|
|
|
|
|
2011-10-16 07:57:53 -04:00
|
|
|
//infostream<<"busytime_u32="<<busytime_u32<<std::endl;
|
2011-04-23 11:31:31 -04:00
|
|
|
|
|
|
|
// Necessary for device->getTimer()->getTime()
|
|
|
|
device->run();
|
|
|
|
|
|
|
|
/*
|
|
|
|
FPS limiter
|
|
|
|
*/
|
|
|
|
|
|
|
|
{
|
2011-10-12 06:53:38 -04:00
|
|
|
float fps_max = g_settings->getFloat("fps_max");
|
2011-04-23 11:31:31 -04:00
|
|
|
u32 frametime_min = 1000./fps_max;
|
|
|
|
|
|
|
|
if(busytime_u32 < frametime_min)
|
|
|
|
{
|
|
|
|
u32 sleeptime = frametime_min - busytime_u32;
|
|
|
|
device->sleep(sleeptime);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Necessary for device->getTimer()->getTime()
|
|
|
|
device->run();
|
|
|
|
|
|
|
|
/*
|
|
|
|
Time difference calculation
|
|
|
|
*/
|
|
|
|
f32 dtime; // in seconds
|
|
|
|
|
|
|
|
u32 time = device->getTimer()->getTime();
|
|
|
|
if(time > lasttime)
|
|
|
|
dtime = (time - lasttime) / 1000.0;
|
|
|
|
else
|
|
|
|
dtime = 0;
|
|
|
|
lasttime = time;
|
|
|
|
|
2011-10-14 19:28:57 -04:00
|
|
|
/* Run timers */
|
|
|
|
|
2011-11-29 10:15:18 -05:00
|
|
|
if(nodig_delay_timer >= 0)
|
|
|
|
nodig_delay_timer -= dtime;
|
|
|
|
if(object_hit_delay_timer >= 0)
|
|
|
|
object_hit_delay_timer -= dtime;
|
2012-03-09 16:53:25 -05:00
|
|
|
time_from_last_punch += dtime;
|
2011-10-14 19:28:57 -04:00
|
|
|
|
2011-10-16 15:39:35 -04:00
|
|
|
g_profiler->add("Elapsed time", dtime);
|
2011-10-17 10:06:28 -04:00
|
|
|
g_profiler->avg("FPS", 1./dtime);
|
2011-10-16 14:16:44 -04:00
|
|
|
|
2011-04-23 11:31:31 -04:00
|
|
|
/*
|
|
|
|
Log frametime for visualization
|
|
|
|
*/
|
|
|
|
frametime_log.push_back(dtime);
|
|
|
|
if(frametime_log.size() > 100)
|
|
|
|
{
|
|
|
|
core::list<float>::Iterator i = frametime_log.begin();
|
|
|
|
frametime_log.erase(i);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
Visualize frametime in terminal
|
|
|
|
*/
|
|
|
|
/*for(u32 i=0; i<dtime*400; i++)
|
2011-10-16 07:57:53 -04:00
|
|
|
infostream<<"X";
|
|
|
|
infostream<<std::endl;*/
|
2011-04-23 11:31:31 -04:00
|
|
|
|
|
|
|
/*
|
|
|
|
Time average and jitter calculation
|
|
|
|
*/
|
|
|
|
|
|
|
|
static f32 dtime_avg1 = 0.0;
|
2011-06-26 17:29:17 -04:00
|
|
|
dtime_avg1 = dtime_avg1 * 0.96 + dtime * 0.04;
|
2011-04-23 11:31:31 -04:00
|
|
|
f32 dtime_jitter1 = dtime - dtime_avg1;
|
|
|
|
|
|
|
|
static f32 dtime_jitter1_max_sample = 0.0;
|
|
|
|
static f32 dtime_jitter1_max_fraction = 0.0;
|
|
|
|
{
|
|
|
|
static f32 jitter1_max = 0.0;
|
|
|
|
static f32 counter = 0.0;
|
|
|
|
if(dtime_jitter1 > jitter1_max)
|
|
|
|
jitter1_max = dtime_jitter1;
|
|
|
|
counter += dtime;
|
|
|
|
if(counter > 0.0)
|
|
|
|
{
|
|
|
|
counter -= 3.0;
|
|
|
|
dtime_jitter1_max_sample = jitter1_max;
|
|
|
|
dtime_jitter1_max_fraction
|
|
|
|
= dtime_jitter1_max_sample / (dtime_avg1+0.001);
|
|
|
|
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;
|
|
|
|
{
|
|
|
|
static f32 jitter1_max = 0.0;
|
|
|
|
static f32 jitter1_min = 0.0;
|
|
|
|
static f32 counter = 0.0;
|
|
|
|
if(busytime_jitter1 > jitter1_max)
|
|
|
|
jitter1_max = busytime_jitter1;
|
|
|
|
if(busytime_jitter1 < jitter1_min)
|
|
|
|
jitter1_min = busytime_jitter1;
|
|
|
|
counter += dtime;
|
|
|
|
if(counter > 0.0){
|
|
|
|
counter -= 3.0;
|
|
|
|
busytime_jitter1_max_sample = jitter1_max;
|
|
|
|
busytime_jitter1_min_sample = jitter1_min;
|
|
|
|
jitter1_max = 0.0;
|
|
|
|
jitter1_min = 0.0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
Debug info for client
|
|
|
|
*/
|
|
|
|
{
|
|
|
|
static float counter = 0.0;
|
|
|
|
counter -= dtime;
|
|
|
|
if(counter < 0)
|
|
|
|
{
|
|
|
|
counter = 30.0;
|
2011-10-16 07:57:53 -04:00
|
|
|
client.printDebugInfo(infostream);
|
2011-04-23 11:31:31 -04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-05-30 17:15:43 -04:00
|
|
|
/*
|
|
|
|
Profiler
|
|
|
|
*/
|
|
|
|
float profiler_print_interval =
|
2011-10-12 06:53:38 -04:00
|
|
|
g_settings->getFloat("profiler_print_interval");
|
2011-10-17 13:40:55 -04:00
|
|
|
bool print_to_log = true;
|
|
|
|
if(profiler_print_interval == 0){
|
|
|
|
print_to_log = false;
|
|
|
|
profiler_print_interval = 5;
|
|
|
|
}
|
2011-10-18 03:36:52 -04:00
|
|
|
if(m_profiler_interval.step(dtime, profiler_print_interval))
|
2011-05-30 17:15:43 -04:00
|
|
|
{
|
2011-10-17 13:40:55 -04:00
|
|
|
if(print_to_log){
|
2011-10-16 07:57:53 -04:00
|
|
|
infostream<<"Profiler:"<<std::endl;
|
|
|
|
g_profiler->print(infostream);
|
2011-05-30 17:15:43 -04:00
|
|
|
}
|
2011-10-17 13:40:55 -04:00
|
|
|
|
2012-01-31 18:56:30 -05:00
|
|
|
update_profiler_gui(guitext_profiler, font, text_height,
|
|
|
|
show_profiler, show_profiler_max);
|
2011-10-17 13:40:55 -04:00
|
|
|
|
|
|
|
g_profiler->clear();
|
2011-05-30 17:15:43 -04:00
|
|
|
}
|
|
|
|
|
2011-04-23 11:31:31 -04:00
|
|
|
/*
|
|
|
|
Direct handling of user input
|
|
|
|
*/
|
|
|
|
|
|
|
|
// Reset input if window not active or some menu is active
|
|
|
|
if(device->isWindowActive() == false || noMenuActive() == false)
|
|
|
|
{
|
|
|
|
input->clear();
|
|
|
|
}
|
|
|
|
|
|
|
|
// Input handler step() (used by the random input generator)
|
|
|
|
input->step(dtime);
|
|
|
|
|
|
|
|
/*
|
2011-11-26 22:01:38 -05:00
|
|
|
Launch menus and trigger stuff according to keys
|
2011-04-23 11:31:31 -04:00
|
|
|
*/
|
2011-11-26 22:01:38 -05:00
|
|
|
if(input->wasKeyDown(getKeySetting("keymap_drop")))
|
|
|
|
{
|
|
|
|
// drop selected item
|
|
|
|
IDropAction *a = new IDropAction();
|
|
|
|
a->count = 0;
|
2012-01-12 00:10:39 -05:00
|
|
|
a->from_inv.setCurrentPlayer();
|
2011-11-26 22:01:38 -05:00
|
|
|
a->from_list = "main";
|
2011-11-29 10:15:18 -05:00
|
|
|
a->from_i = client.getPlayerItem();
|
2011-11-26 22:01:38 -05:00
|
|
|
client.inventoryAction(a);
|
|
|
|
}
|
|
|
|
else if(input->wasKeyDown(getKeySetting("keymap_inventory")))
|
2011-04-23 11:31:31 -04:00
|
|
|
{
|
2011-10-16 07:57:53 -04:00
|
|
|
infostream<<"the_game: "
|
2011-04-23 11:31:31 -04:00
|
|
|
<<"Launching inventory"<<std::endl;
|
|
|
|
|
|
|
|
GUIInventoryMenu *menu =
|
|
|
|
new GUIInventoryMenu(guienv, guiroot, -1,
|
|
|
|
&g_menumgr, v2s16(8,7),
|
2012-01-12 00:10:39 -05:00
|
|
|
&client, gamedef);
|
|
|
|
|
|
|
|
InventoryLocation inventoryloc;
|
|
|
|
inventoryloc.setCurrentPlayer();
|
2011-04-23 11:31:31 -04:00
|
|
|
|
|
|
|
core::array<GUIInventoryMenu::DrawSpec> draw_spec;
|
|
|
|
draw_spec.push_back(GUIInventoryMenu::DrawSpec(
|
2012-01-12 00:10:39 -05:00
|
|
|
"list", inventoryloc, "main",
|
2011-04-23 11:31:31 -04:00
|
|
|
v2s32(0, 3), v2s32(8, 4)));
|
|
|
|
draw_spec.push_back(GUIInventoryMenu::DrawSpec(
|
2012-01-12 00:10:39 -05:00
|
|
|
"list", inventoryloc, "craft",
|
2011-04-23 11:31:31 -04:00
|
|
|
v2s32(3, 0), v2s32(3, 3)));
|
|
|
|
draw_spec.push_back(GUIInventoryMenu::DrawSpec(
|
2012-01-21 15:21:41 -05:00
|
|
|
"list", inventoryloc, "craftpreview",
|
2011-04-23 11:31:31 -04:00
|
|
|
v2s32(7, 1), v2s32(1, 1)));
|
|
|
|
|
|
|
|
menu->setDrawSpec(draw_spec);
|
|
|
|
|
|
|
|
menu->drop();
|
|
|
|
}
|
2011-08-13 16:44:31 -04:00
|
|
|
else if(input->wasKeyDown(EscapeKey))
|
2011-04-23 11:31:31 -04:00
|
|
|
{
|
2011-10-16 07:57:53 -04:00
|
|
|
infostream<<"the_game: "
|
2011-04-23 11:31:31 -04:00
|
|
|
<<"Launching pause menu"<<std::endl;
|
|
|
|
// It will delete itself by itself
|
|
|
|
(new GUIPauseMenu(guienv, guiroot, -1, g_gamecallback,
|
|
|
|
&g_menumgr))->drop();
|
2011-05-24 14:04:22 -04:00
|
|
|
|
|
|
|
// Move mouse cursor on top of the disconnect button
|
|
|
|
input->setMousePos(displaycenter.X, displaycenter.Y+25);
|
2011-04-23 11:31:31 -04:00
|
|
|
}
|
2011-05-14 08:43:26 -04:00
|
|
|
else if(input->wasKeyDown(getKeySetting("keymap_chat")))
|
2011-04-23 11:31:31 -04:00
|
|
|
{
|
|
|
|
TextDest *dest = new TextDestChat(&client);
|
|
|
|
|
|
|
|
(new GUITextInputMenu(guienv, guiroot, -1,
|
|
|
|
&g_menumgr, dest,
|
|
|
|
L""))->drop();
|
|
|
|
}
|
2011-08-13 12:16:49 -04:00
|
|
|
else if(input->wasKeyDown(getKeySetting("keymap_cmd")))
|
|
|
|
{
|
|
|
|
TextDest *dest = new TextDestChat(&client);
|
|
|
|
|
|
|
|
(new GUITextInputMenu(guienv, guiroot, -1,
|
|
|
|
&g_menumgr, dest,
|
|
|
|
L"/"))->drop();
|
|
|
|
}
|
2011-06-17 16:55:21 -04:00
|
|
|
else if(input->wasKeyDown(getKeySetting("keymap_freemove")))
|
|
|
|
{
|
2011-10-12 06:53:38 -04:00
|
|
|
if(g_settings->getBool("free_move"))
|
2011-06-17 16:55:21 -04:00
|
|
|
{
|
2011-10-12 06:53:38 -04:00
|
|
|
g_settings->set("free_move","false");
|
2012-01-31 18:56:30 -05:00
|
|
|
statustext = L"free_move disabled";
|
|
|
|
statustext_time = 0;
|
2011-06-17 16:55:21 -04:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2011-10-12 06:53:38 -04:00
|
|
|
g_settings->set("free_move","true");
|
2012-01-31 18:56:30 -05:00
|
|
|
statustext = L"free_move enabled";
|
|
|
|
statustext_time = 0;
|
2011-06-17 16:55:21 -04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
else if(input->wasKeyDown(getKeySetting("keymap_fastmove")))
|
|
|
|
{
|
2011-10-12 06:53:38 -04:00
|
|
|
if(g_settings->getBool("fast_move"))
|
2011-06-17 16:55:21 -04:00
|
|
|
{
|
2011-10-12 06:53:38 -04:00
|
|
|
g_settings->set("fast_move","false");
|
2012-01-31 18:56:30 -05:00
|
|
|
statustext = L"fast_move disabled";
|
|
|
|
statustext_time = 0;
|
2011-06-17 16:55:21 -04:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2011-10-12 06:53:38 -04:00
|
|
|
g_settings->set("fast_move","true");
|
2012-01-31 18:56:30 -05:00
|
|
|
statustext = L"fast_move enabled";
|
|
|
|
statustext_time = 0;
|
2011-06-25 20:14:52 -04:00
|
|
|
}
|
|
|
|
}
|
2011-06-26 12:33:40 -04:00
|
|
|
else if(input->wasKeyDown(getKeySetting("keymap_screenshot")))
|
|
|
|
{
|
|
|
|
irr::video::IImage* const image = driver->createScreenShot();
|
|
|
|
if (image) {
|
|
|
|
irr::c8 filename[256];
|
2011-10-16 09:16:47 -04:00
|
|
|
snprintf(filename, 256, "%s" DIR_DELIM "screenshot_%u.png",
|
2011-10-12 06:53:38 -04:00
|
|
|
g_settings->get("screenshot_path").c_str(),
|
2011-06-26 12:33:40 -04:00
|
|
|
device->getTimer()->getRealTime());
|
|
|
|
if (driver->writeImageToFile(image, filename)) {
|
|
|
|
std::wstringstream sstr;
|
|
|
|
sstr<<"Saved screenshot to '"<<filename<<"'";
|
2011-10-16 07:57:53 -04:00
|
|
|
infostream<<"Saved screenshot to '"<<filename<<"'"<<std::endl;
|
2012-01-31 18:56:30 -05:00
|
|
|
statustext = sstr.str();
|
|
|
|
statustext_time = 0;
|
2011-06-26 12:33:40 -04:00
|
|
|
} else{
|
2011-10-16 07:57:53 -04:00
|
|
|
infostream<<"Failed to save screenshot '"<<filename<<"'"<<std::endl;
|
2011-06-26 12:33:40 -04:00
|
|
|
}
|
|
|
|
image->drop();
|
|
|
|
}
|
|
|
|
}
|
2012-01-31 18:56:30 -05:00
|
|
|
else if(input->wasKeyDown(getKeySetting("keymap_toggle_hud")))
|
2011-10-17 13:40:55 -04:00
|
|
|
{
|
2012-01-31 18:56:30 -05:00
|
|
|
show_hud = !show_hud;
|
|
|
|
if(show_hud)
|
|
|
|
statustext = L"HUD shown";
|
2011-11-02 12:13:56 -04:00
|
|
|
else
|
2012-01-31 18:56:30 -05:00
|
|
|
statustext = L"HUD hidden";
|
|
|
|
statustext_time = 0;
|
|
|
|
}
|
|
|
|
else if(input->wasKeyDown(getKeySetting("keymap_toggle_chat")))
|
|
|
|
{
|
|
|
|
show_chat = !show_chat;
|
|
|
|
if(show_chat)
|
|
|
|
statustext = L"Chat shown";
|
|
|
|
else
|
|
|
|
statustext = L"Chat hidden";
|
|
|
|
statustext_time = 0;
|
2011-10-17 13:40:55 -04:00
|
|
|
}
|
2011-10-18 14:08:31 -04:00
|
|
|
else if(input->wasKeyDown(getKeySetting("keymap_toggle_force_fog_off")))
|
|
|
|
{
|
|
|
|
force_fog_off = !force_fog_off;
|
2011-11-02 12:13:56 -04:00
|
|
|
if(force_fog_off)
|
2012-01-31 18:56:30 -05:00
|
|
|
statustext = L"Fog disabled";
|
2011-11-02 12:13:56 -04:00
|
|
|
else
|
2012-01-31 18:56:30 -05:00
|
|
|
statustext = L"Fog enabled";
|
|
|
|
statustext_time = 0;
|
2011-11-02 12:13:56 -04:00
|
|
|
}
|
|
|
|
else if(input->wasKeyDown(getKeySetting("keymap_toggle_update_camera")))
|
|
|
|
{
|
|
|
|
disable_camera_update = !disable_camera_update;
|
|
|
|
if(disable_camera_update)
|
2012-01-31 18:56:30 -05:00
|
|
|
statustext = L"Camera update disabled";
|
2011-11-02 12:13:56 -04:00
|
|
|
else
|
2012-01-31 18:56:30 -05:00
|
|
|
statustext = L"Camera update enabled";
|
|
|
|
statustext_time = 0;
|
|
|
|
}
|
|
|
|
else if(input->wasKeyDown(getKeySetting("keymap_toggle_debug")))
|
|
|
|
{
|
|
|
|
// Initial / 3x toggle: Chat only
|
|
|
|
// 1x toggle: Debug text with chat
|
|
|
|
// 2x toggle: Debug text with frametime
|
|
|
|
if(!show_debug)
|
|
|
|
{
|
|
|
|
show_debug = true;
|
|
|
|
show_debug_frametime = false;
|
|
|
|
statustext = L"Debug info shown";
|
|
|
|
statustext_time = 0;
|
|
|
|
}
|
|
|
|
else if(show_debug_frametime)
|
|
|
|
{
|
|
|
|
show_debug = false;
|
|
|
|
show_debug_frametime = false;
|
|
|
|
statustext = L"Debug info and frametime graph hidden";
|
|
|
|
statustext_time = 0;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
show_debug_frametime = true;
|
|
|
|
statustext = L"Frametime graph shown";
|
|
|
|
statustext_time = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else if(input->wasKeyDown(getKeySetting("keymap_toggle_profiler")))
|
|
|
|
{
|
|
|
|
show_profiler = (show_profiler + 1) % (show_profiler_max + 1);
|
|
|
|
|
|
|
|
// FIXME: This updates the profiler with incomplete values
|
|
|
|
update_profiler_gui(guitext_profiler, font, text_height,
|
|
|
|
show_profiler, show_profiler_max);
|
|
|
|
|
|
|
|
if(show_profiler != 0)
|
|
|
|
{
|
|
|
|
std::wstringstream sstr;
|
|
|
|
sstr<<"Profiler shown (page "<<show_profiler
|
|
|
|
<<" of "<<show_profiler_max<<")";
|
|
|
|
statustext = sstr.str();
|
|
|
|
statustext_time = 0;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
statustext = L"Profiler hidden";
|
|
|
|
statustext_time = 0;
|
|
|
|
}
|
2011-10-18 14:08:31 -04:00
|
|
|
}
|
2012-01-31 20:24:55 -05:00
|
|
|
else if(input->wasKeyDown(getKeySetting("keymap_increase_viewing_range_min")))
|
|
|
|
{
|
|
|
|
s16 range = g_settings->getS16("viewing_range_nodes_min");
|
|
|
|
s16 range_new = range + 10;
|
|
|
|
g_settings->set("viewing_range_nodes_min", itos(range_new));
|
|
|
|
statustext = narrow_to_wide(
|
2012-01-31 20:37:01 -05:00
|
|
|
"Minimum viewing range changed to "
|
|
|
|
+ itos(range_new));
|
2012-01-31 20:24:55 -05:00
|
|
|
statustext_time = 0;
|
|
|
|
}
|
|
|
|
else if(input->wasKeyDown(getKeySetting("keymap_decrease_viewing_range_min")))
|
|
|
|
{
|
|
|
|
s16 range = g_settings->getS16("viewing_range_nodes_min");
|
|
|
|
s16 range_new = range - 10;
|
2012-01-31 20:37:01 -05:00
|
|
|
if(range_new < 0)
|
|
|
|
range_new = range;
|
|
|
|
g_settings->set("viewing_range_nodes_min",
|
|
|
|
itos(range_new));
|
|
|
|
statustext = narrow_to_wide(
|
|
|
|
"Minimum viewing range changed to "
|
|
|
|
+ itos(range_new));
|
|
|
|
statustext_time = 0;
|
2012-01-31 20:24:55 -05:00
|
|
|
}
|
2011-04-23 11:31:31 -04:00
|
|
|
|
|
|
|
// Item selection with mouse wheel
|
2011-11-29 10:15:18 -05:00
|
|
|
u16 new_playeritem = client.getPlayerItem();
|
2011-04-23 11:31:31 -04:00
|
|
|
{
|
|
|
|
s32 wheel = input->getMouseWheel();
|
|
|
|
u16 max_item = MYMIN(PLAYER_INVENTORY_SIZE-1,
|
|
|
|
hotbar_itemcount-1);
|
|
|
|
|
|
|
|
if(wheel < 0)
|
|
|
|
{
|
2011-11-29 10:15:18 -05:00
|
|
|
if(new_playeritem < max_item)
|
|
|
|
new_playeritem++;
|
2011-04-23 11:31:31 -04:00
|
|
|
else
|
2011-11-29 10:15:18 -05:00
|
|
|
new_playeritem = 0;
|
2011-04-23 11:31:31 -04:00
|
|
|
}
|
|
|
|
else if(wheel > 0)
|
|
|
|
{
|
2011-11-29 10:15:18 -05:00
|
|
|
if(new_playeritem > 0)
|
|
|
|
new_playeritem--;
|
2011-04-23 11:31:31 -04:00
|
|
|
else
|
2011-11-29 10:15:18 -05:00
|
|
|
new_playeritem = max_item;
|
2011-04-23 11:31:31 -04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Item selection
|
|
|
|
for(u16 i=0; i<10; i++)
|
|
|
|
{
|
2011-08-13 16:44:31 -04:00
|
|
|
const KeyPress *kp = NumberKey + (i + 1) % 10;
|
|
|
|
if(input->wasKeyDown(*kp))
|
2011-04-23 11:31:31 -04:00
|
|
|
{
|
|
|
|
if(i < PLAYER_INVENTORY_SIZE && i < hotbar_itemcount)
|
|
|
|
{
|
2011-11-29 10:15:18 -05:00
|
|
|
new_playeritem = i;
|
2011-04-23 11:31:31 -04:00
|
|
|
|
2011-10-16 07:57:53 -04:00
|
|
|
infostream<<"Selected item: "
|
2011-11-29 10:15:18 -05:00
|
|
|
<<new_playeritem<<std::endl;
|
2011-04-23 11:31:31 -04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Viewing range selection
|
2011-05-14 08:43:26 -04:00
|
|
|
if(input->wasKeyDown(getKeySetting("keymap_rangeselect")))
|
2011-04-23 11:31:31 -04:00
|
|
|
{
|
2012-01-31 18:56:30 -05:00
|
|
|
draw_control.range_all = !draw_control.range_all;
|
2011-04-23 11:31:31 -04:00
|
|
|
if(draw_control.range_all)
|
|
|
|
{
|
2012-01-31 18:56:30 -05:00
|
|
|
infostream<<"Enabled full viewing range"<<std::endl;
|
|
|
|
statustext = L"Enabled full viewing range";
|
|
|
|
statustext_time = 0;
|
2011-04-23 11:31:31 -04:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2012-01-31 18:56:30 -05:00
|
|
|
infostream<<"Disabled full viewing range"<<std::endl;
|
|
|
|
statustext = L"Disabled full viewing range";
|
|
|
|
statustext_time = 0;
|
2011-04-23 11:31:31 -04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Print debug stacks
|
2011-05-14 08:43:26 -04:00
|
|
|
if(input->wasKeyDown(getKeySetting("keymap_print_debug_stacks")))
|
2011-04-23 11:31:31 -04:00
|
|
|
{
|
|
|
|
dstream<<"-----------------------------------------"
|
|
|
|
<<std::endl;
|
|
|
|
dstream<<DTIME<<"Printing debug stacks:"<<std::endl;
|
|
|
|
dstream<<"-----------------------------------------"
|
|
|
|
<<std::endl;
|
|
|
|
debug_stacks_print();
|
|
|
|
}
|
|
|
|
|
2011-09-26 08:09:04 -04:00
|
|
|
/*
|
|
|
|
Mouse and camera control
|
|
|
|
NOTE: Do this before client.setPlayerControl() to not cause a camera lag of one frame
|
|
|
|
*/
|
|
|
|
|
|
|
|
if((device->isWindowActive() && noMenuActive()) || random_input)
|
|
|
|
{
|
|
|
|
if(!random_input)
|
|
|
|
{
|
|
|
|
// Mac OSX gets upset if this is set every frame
|
|
|
|
if(device->getCursorControl()->isVisible())
|
|
|
|
device->getCursorControl()->setVisible(false);
|
|
|
|
}
|
|
|
|
|
|
|
|
if(first_loop_after_window_activation){
|
2011-10-16 07:57:53 -04:00
|
|
|
//infostream<<"window active, first loop"<<std::endl;
|
2011-09-26 08:09:04 -04:00
|
|
|
first_loop_after_window_activation = false;
|
|
|
|
}
|
|
|
|
else{
|
|
|
|
s32 dx = input->getMousePos().X - displaycenter.X;
|
|
|
|
s32 dy = input->getMousePos().Y - displaycenter.Y;
|
|
|
|
if(invert_mouse)
|
|
|
|
dy = -dy;
|
2011-10-16 07:57:53 -04:00
|
|
|
//infostream<<"window active, pos difference "<<dx<<","<<dy<<std::endl;
|
2011-09-26 08:09:04 -04:00
|
|
|
|
|
|
|
/*const float keyspeed = 500;
|
|
|
|
if(input->isKeyDown(irr::KEY_UP))
|
|
|
|
dy -= dtime * keyspeed;
|
|
|
|
if(input->isKeyDown(irr::KEY_DOWN))
|
|
|
|
dy += dtime * keyspeed;
|
|
|
|
if(input->isKeyDown(irr::KEY_LEFT))
|
|
|
|
dx -= dtime * keyspeed;
|
|
|
|
if(input->isKeyDown(irr::KEY_RIGHT))
|
|
|
|
dx += dtime * keyspeed;*/
|
|
|
|
|
|
|
|
camera_yaw -= dx*0.2;
|
|
|
|
camera_pitch += dy*0.2;
|
|
|
|
if(camera_pitch < -89.5) camera_pitch = -89.5;
|
|
|
|
if(camera_pitch > 89.5) camera_pitch = 89.5;
|
|
|
|
}
|
|
|
|
input->setMousePos(displaycenter.X, displaycenter.Y);
|
|
|
|
}
|
|
|
|
else{
|
|
|
|
// Mac OSX gets upset if this is set every frame
|
|
|
|
if(device->getCursorControl()->isVisible() == false)
|
|
|
|
device->getCursorControl()->setVisible(true);
|
|
|
|
|
2011-10-16 07:57:53 -04:00
|
|
|
//infostream<<"window inactive"<<std::endl;
|
2011-09-26 08:09:04 -04:00
|
|
|
first_loop_after_window_activation = true;
|
|
|
|
}
|
|
|
|
|
2011-04-23 11:31:31 -04:00
|
|
|
/*
|
|
|
|
Player speed control
|
|
|
|
*/
|
|
|
|
|
2011-10-15 07:46:59 -04:00
|
|
|
if(!noMenuActive() || !device->isWindowActive())
|
|
|
|
{
|
|
|
|
PlayerControl control(
|
|
|
|
false,
|
|
|
|
false,
|
|
|
|
false,
|
|
|
|
false,
|
|
|
|
false,
|
|
|
|
false,
|
|
|
|
false,
|
|
|
|
camera_pitch,
|
|
|
|
camera_yaw
|
|
|
|
);
|
|
|
|
client.setPlayerControl(control);
|
|
|
|
}
|
|
|
|
else
|
2011-04-23 11:31:31 -04:00
|
|
|
{
|
|
|
|
/*bool a_up,
|
|
|
|
bool a_down,
|
|
|
|
bool a_left,
|
|
|
|
bool a_right,
|
|
|
|
bool a_jump,
|
|
|
|
bool a_superspeed,
|
|
|
|
bool a_sneak,
|
|
|
|
float a_pitch,
|
|
|
|
float a_yaw*/
|
|
|
|
PlayerControl control(
|
2011-05-14 08:43:26 -04:00
|
|
|
input->isKeyDown(getKeySetting("keymap_forward")),
|
|
|
|
input->isKeyDown(getKeySetting("keymap_backward")),
|
|
|
|
input->isKeyDown(getKeySetting("keymap_left")),
|
|
|
|
input->isKeyDown(getKeySetting("keymap_right")),
|
|
|
|
input->isKeyDown(getKeySetting("keymap_jump")),
|
|
|
|
input->isKeyDown(getKeySetting("keymap_special1")),
|
|
|
|
input->isKeyDown(getKeySetting("keymap_sneak")),
|
2011-04-23 11:31:31 -04:00
|
|
|
camera_pitch,
|
|
|
|
camera_yaw
|
|
|
|
);
|
|
|
|
client.setPlayerControl(control);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
Run server
|
|
|
|
*/
|
|
|
|
|
|
|
|
if(server != NULL)
|
|
|
|
{
|
|
|
|
//TimeTaker timer("server->step(dtime)");
|
|
|
|
server->step(dtime);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
Process environment
|
|
|
|
*/
|
|
|
|
|
|
|
|
{
|
|
|
|
//TimeTaker timer("client.step(dtime)");
|
|
|
|
client.step(dtime);
|
|
|
|
//client.step(dtime_avg1);
|
|
|
|
}
|
|
|
|
|
|
|
|
{
|
2011-10-15 07:46:59 -04:00
|
|
|
// Read client events
|
|
|
|
for(;;)
|
2011-04-23 11:31:31 -04:00
|
|
|
{
|
2011-10-15 07:46:59 -04:00
|
|
|
ClientEvent event = client.getClientEvent();
|
|
|
|
if(event.type == CE_NONE)
|
|
|
|
{
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
else if(event.type == CE_PLAYER_DAMAGE)
|
|
|
|
{
|
|
|
|
//u16 damage = event.player_damage.amount;
|
2011-10-16 07:57:53 -04:00
|
|
|
//infostream<<"Player damage: "<<damage<<std::endl;
|
2011-10-15 07:46:59 -04:00
|
|
|
damage_flash_timer = 0.05;
|
|
|
|
if(event.player_damage.amount >= 2){
|
|
|
|
damage_flash_timer += 0.05 * event.player_damage.amount;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else if(event.type == CE_PLAYER_FORCE_MOVE)
|
|
|
|
{
|
|
|
|
camera_yaw = event.player_force_move.yaw;
|
|
|
|
camera_pitch = event.player_force_move.pitch;
|
|
|
|
}
|
|
|
|
else if(event.type == CE_DEATHSCREEN)
|
|
|
|
{
|
|
|
|
if(respawn_menu_active)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
/*bool set_camera_point_target =
|
|
|
|
event.deathscreen.set_camera_point_target;
|
|
|
|
v3f camera_point_target;
|
|
|
|
camera_point_target.X = event.deathscreen.camera_point_target_x;
|
|
|
|
camera_point_target.Y = event.deathscreen.camera_point_target_y;
|
|
|
|
camera_point_target.Z = event.deathscreen.camera_point_target_z;*/
|
|
|
|
MainRespawnInitiator *respawner =
|
|
|
|
new MainRespawnInitiator(
|
|
|
|
&respawn_menu_active, &client);
|
|
|
|
GUIDeathScreen *menu =
|
|
|
|
new GUIDeathScreen(guienv, guiroot, -1,
|
|
|
|
&g_menumgr, respawner);
|
|
|
|
menu->drop();
|
|
|
|
|
|
|
|
/* Handle visualization */
|
|
|
|
|
|
|
|
damage_flash_timer = 0;
|
|
|
|
|
|
|
|
/*LocalPlayer* player = client.getLocalPlayer();
|
|
|
|
player->setPosition(player->getPosition() + v3f(0,-BS,0));
|
|
|
|
camera.update(player, busytime, screensize);*/
|
|
|
|
}
|
2011-11-15 06:13:18 -05:00
|
|
|
else if(event.type == CE_TEXTURES_UPDATED)
|
|
|
|
{
|
|
|
|
update_skybox(driver, tsrc, smgr, skybox, brightness);
|
2012-01-02 10:44:00 -05:00
|
|
|
|
|
|
|
update_wielded_item_trigger = true;
|
2011-11-15 06:13:18 -05:00
|
|
|
}
|
2011-04-23 11:31:31 -04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
//TimeTaker //timer2("//timer2");
|
|
|
|
|
2011-11-29 10:15:18 -05:00
|
|
|
/*
|
|
|
|
For interaction purposes, get info about the held item
|
2012-01-12 00:10:39 -05:00
|
|
|
- What item is it?
|
2011-11-29 10:15:18 -05:00
|
|
|
- Is it a usable item?
|
|
|
|
- Can it point to liquids?
|
|
|
|
*/
|
2012-01-12 00:10:39 -05:00
|
|
|
ItemStack playeritem;
|
2011-11-29 10:15:18 -05:00
|
|
|
bool playeritem_usable = false;
|
|
|
|
bool playeritem_liquids_pointable = false;
|
|
|
|
{
|
|
|
|
InventoryList *mlist = local_inventory.getList("main");
|
|
|
|
if(mlist != NULL)
|
|
|
|
{
|
2012-01-12 00:10:39 -05:00
|
|
|
playeritem = mlist->getItem(client.getPlayerItem());
|
|
|
|
playeritem_usable = playeritem.getDefinition(itemdef).usable;
|
|
|
|
playeritem_liquids_pointable = playeritem.getDefinition(itemdef).liquids_pointable;
|
2011-11-29 10:15:18 -05:00
|
|
|
}
|
|
|
|
}
|
2012-03-09 16:53:25 -05:00
|
|
|
ToolCapabilities playeritem_toolcap =
|
|
|
|
playeritem.getToolCapabilities(itemdef);
|
|
|
|
|
|
|
|
/*
|
|
|
|
Update camera
|
|
|
|
*/
|
|
|
|
|
|
|
|
LocalPlayer* player = client.getLocalPlayer();
|
|
|
|
float full_punch_interval = playeritem_toolcap.full_punch_interval;
|
|
|
|
float tool_reload_ratio = time_from_last_punch / full_punch_interval;
|
|
|
|
tool_reload_ratio = MYMIN(tool_reload_ratio, 1.0);
|
|
|
|
camera.update(player, busytime, screensize, tool_reload_ratio);
|
|
|
|
camera.step(dtime);
|
|
|
|
|
|
|
|
v3f player_position = player->getPosition();
|
|
|
|
v3f camera_position = camera.getPosition();
|
|
|
|
v3f camera_direction = camera.getDirection();
|
|
|
|
f32 camera_fov = camera.getFovMax();
|
|
|
|
|
|
|
|
if(!disable_camera_update){
|
|
|
|
client.updateCamera(camera_position,
|
|
|
|
camera_direction, camera_fov);
|
|
|
|
}
|
|
|
|
|
|
|
|
//timer2.stop();
|
|
|
|
//TimeTaker //timer3("//timer3");
|
2011-11-29 10:15:18 -05:00
|
|
|
|
2011-04-23 11:31:31 -04:00
|
|
|
/*
|
|
|
|
Calculate what block is the crosshair pointing to
|
|
|
|
*/
|
|
|
|
|
|
|
|
//u32 t1 = device->getTimer()->getRealTime();
|
|
|
|
|
|
|
|
f32 d = 4; // max. distance
|
|
|
|
core::line3d<f32> shootline(camera_position,
|
|
|
|
camera_position + camera_direction * BS * (d+1));
|
|
|
|
|
2011-11-29 10:15:18 -05:00
|
|
|
core::aabbox3d<f32> hilightbox;
|
|
|
|
bool should_show_hilightbox = false;
|
|
|
|
ClientActiveObject *selected_object = NULL;
|
2011-04-23 11:31:31 -04:00
|
|
|
|
2011-11-29 10:15:18 -05:00
|
|
|
PointedThing pointed = getPointedThing(
|
|
|
|
// input
|
|
|
|
&client, player_position, camera_direction,
|
|
|
|
camera_position, shootline, d,
|
|
|
|
playeritem_liquids_pointable, !ldown_for_dig,
|
|
|
|
// output
|
|
|
|
hilightbox, should_show_hilightbox,
|
|
|
|
selected_object);
|
2011-04-23 11:31:31 -04:00
|
|
|
|
2011-11-29 10:15:18 -05:00
|
|
|
if(pointed != pointed_old)
|
|
|
|
{
|
|
|
|
infostream<<"Pointing at "<<pointed.dump()<<std::endl;
|
|
|
|
//dstream<<"Pointing at "<<pointed.dump()<<std::endl;
|
|
|
|
}
|
2011-04-23 11:31:31 -04:00
|
|
|
|
2011-11-29 10:15:18 -05:00
|
|
|
/*
|
|
|
|
Visualize selection
|
|
|
|
*/
|
|
|
|
if(should_show_hilightbox)
|
|
|
|
hilightboxes.push_back(hilightbox);
|
2011-04-23 11:31:31 -04:00
|
|
|
|
2011-11-29 10:15:18 -05:00
|
|
|
/*
|
|
|
|
Stop digging when
|
|
|
|
- releasing left mouse button
|
|
|
|
- pointing away from node
|
|
|
|
*/
|
|
|
|
if(digging)
|
|
|
|
{
|
|
|
|
if(input->getLeftReleased())
|
2011-04-23 11:31:31 -04:00
|
|
|
{
|
2011-11-29 10:15:18 -05:00
|
|
|
infostream<<"Left button released"
|
|
|
|
<<" (stopped digging)"<<std::endl;
|
|
|
|
digging = false;
|
|
|
|
}
|
|
|
|
else if(pointed != pointed_old)
|
|
|
|
{
|
|
|
|
if (pointed.type == POINTEDTHING_NODE
|
|
|
|
&& pointed_old.type == POINTEDTHING_NODE
|
|
|
|
&& pointed.node_undersurface == pointed_old.node_undersurface)
|
|
|
|
{
|
|
|
|
// Still pointing to the same node,
|
|
|
|
// but a different face. Don't reset.
|
2011-10-15 05:17:21 -04:00
|
|
|
}
|
2011-11-29 10:15:18 -05:00
|
|
|
else
|
|
|
|
{
|
|
|
|
infostream<<"Pointing away from node"
|
|
|
|
<<" (stopped digging)"<<std::endl;
|
|
|
|
digging = false;
|
2011-10-14 19:28:57 -04:00
|
|
|
}
|
2011-04-23 11:31:31 -04:00
|
|
|
}
|
2011-11-29 10:15:18 -05:00
|
|
|
if(!digging)
|
2011-04-23 11:31:31 -04:00
|
|
|
{
|
2011-11-29 10:15:18 -05:00
|
|
|
client.interact(1, pointed_old);
|
|
|
|
client.clearTempMod(pointed_old.node_undersurface);
|
|
|
|
dig_time = 0.0;
|
2011-04-23 11:31:31 -04:00
|
|
|
}
|
|
|
|
}
|
2011-11-29 10:15:18 -05:00
|
|
|
if(!digging && ldown_for_dig && !input->getLeftState())
|
2011-04-23 11:31:31 -04:00
|
|
|
{
|
2011-11-29 10:15:18 -05:00
|
|
|
ldown_for_dig = false;
|
|
|
|
}
|
2011-04-23 11:31:31 -04:00
|
|
|
|
2011-11-29 10:15:18 -05:00
|
|
|
bool left_punch = false;
|
|
|
|
bool left_punch_muted = false;
|
2011-04-23 11:31:31 -04:00
|
|
|
|
2011-11-29 10:15:18 -05:00
|
|
|
if(playeritem_usable && input->getLeftState())
|
|
|
|
{
|
|
|
|
if(input->getLeftClicked())
|
|
|
|
client.interact(4, pointed);
|
|
|
|
}
|
|
|
|
else if(pointed.type == POINTEDTHING_NODE)
|
|
|
|
{
|
|
|
|
v3s16 nodepos = pointed.node_undersurface;
|
|
|
|
v3s16 neighbourpos = pointed.node_abovesurface;
|
2011-04-23 11:31:31 -04:00
|
|
|
|
|
|
|
/*
|
|
|
|
Check information text of node
|
|
|
|
*/
|
|
|
|
|
|
|
|
NodeMetadata *meta = client.getNodeMetadata(nodepos);
|
|
|
|
if(meta)
|
|
|
|
{
|
|
|
|
infotext = narrow_to_wide(meta->infoText());
|
|
|
|
}
|
2011-12-03 06:51:16 -05:00
|
|
|
else
|
|
|
|
{
|
|
|
|
MapNode n = client.getNode(nodepos);
|
|
|
|
if(nodedef->get(n).tname_tiles[0] == "unknown_block.png"){
|
|
|
|
infotext = L"Unknown node: ";
|
|
|
|
infotext += narrow_to_wide(nodedef->get(n).name);
|
|
|
|
}
|
|
|
|
}
|
2011-04-23 11:31:31 -04:00
|
|
|
|
|
|
|
/*
|
|
|
|
Handle digging
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
2011-11-29 10:15:18 -05:00
|
|
|
if(nodig_delay_timer <= 0.0 && input->getLeftState())
|
2011-04-23 11:31:31 -04:00
|
|
|
{
|
2011-11-29 10:15:18 -05:00
|
|
|
if(!digging)
|
2011-04-23 11:31:31 -04:00
|
|
|
{
|
2011-11-29 10:15:18 -05:00
|
|
|
infostream<<"Started digging"<<std::endl;
|
|
|
|
client.interact(0, pointed);
|
|
|
|
digging = true;
|
|
|
|
ldown_for_dig = true;
|
|
|
|
}
|
|
|
|
MapNode n = client.getNode(nodepos);
|
2011-04-23 11:31:31 -04:00
|
|
|
|
2012-03-09 16:53:25 -05:00
|
|
|
// Get digging parameters
|
|
|
|
DigParams params = getDigParams(nodedef->get(n).groups,
|
|
|
|
&playeritem_toolcap);
|
2012-02-28 12:45:23 -05:00
|
|
|
// If can't dig, try hand
|
|
|
|
if(!params.diggable){
|
|
|
|
const ItemDefinition &hand = itemdef->get("");
|
|
|
|
const ToolCapabilities *tp = hand.tool_capabilities;
|
|
|
|
if(tp)
|
|
|
|
params = getDigParams(nodedef->get(n).groups, tp);
|
|
|
|
}
|
2011-11-29 10:15:18 -05:00
|
|
|
|
|
|
|
float dig_time_complete = 0.0;
|
|
|
|
|
2012-02-28 12:45:23 -05:00
|
|
|
if(params.diggable == false)
|
2011-11-29 10:15:18 -05:00
|
|
|
{
|
|
|
|
// I guess nobody will wait for this long
|
|
|
|
dig_time_complete = 10000000.0;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2012-02-28 12:45:23 -05:00
|
|
|
dig_time_complete = params.time;
|
2011-04-23 11:31:31 -04:00
|
|
|
}
|
|
|
|
|
2011-11-29 10:15:18 -05:00
|
|
|
if(dig_time_complete >= 0.001)
|
2011-04-23 11:31:31 -04:00
|
|
|
{
|
2011-11-29 10:15:18 -05:00
|
|
|
dig_index = (u16)((float)CRACK_ANIMATION_LENGTH
|
|
|
|
* dig_time/dig_time_complete);
|
2011-04-23 11:31:31 -04:00
|
|
|
}
|
2011-11-29 10:15:18 -05:00
|
|
|
// This is for torches
|
|
|
|
else
|
2011-04-23 11:31:31 -04:00
|
|
|
{
|
2011-11-29 10:15:18 -05:00
|
|
|
dig_index = CRACK_ANIMATION_LENGTH;
|
2011-04-23 11:31:31 -04:00
|
|
|
}
|
2012-03-04 09:21:35 -05:00
|
|
|
|
|
|
|
// Don't show cracks if not diggable
|
|
|
|
if(dig_time_complete >= 100000.0)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
else if(dig_index < CRACK_ANIMATION_LENGTH)
|
2011-04-23 11:31:31 -04:00
|
|
|
{
|
2011-11-29 10:15:18 -05:00
|
|
|
//TimeTaker timer("client.setTempMod");
|
|
|
|
//infostream<<"dig_index="<<dig_index<<std::endl;
|
|
|
|
client.setTempMod(nodepos, NodeMod(NODEMOD_CRACK, dig_index));
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
infostream<<"Digging completed"<<std::endl;
|
|
|
|
client.interact(2, pointed);
|
|
|
|
client.clearTempMod(nodepos);
|
|
|
|
client.removeNode(nodepos);
|
2011-04-23 11:31:31 -04:00
|
|
|
|
2011-11-29 10:15:18 -05:00
|
|
|
dig_time = 0;
|
|
|
|
digging = false;
|
2011-04-23 11:31:31 -04:00
|
|
|
|
2011-11-29 10:15:18 -05:00
|
|
|
nodig_delay_timer = dig_time_complete
|
|
|
|
/ (float)CRACK_ANIMATION_LENGTH;
|
2011-04-23 11:31:31 -04:00
|
|
|
|
2011-11-29 10:15:18 -05:00
|
|
|
// We don't want a corresponding delay to
|
|
|
|
// very time consuming nodes
|
|
|
|
if(nodig_delay_timer > 0.5)
|
2011-04-23 11:31:31 -04:00
|
|
|
{
|
2011-11-29 10:15:18 -05:00
|
|
|
nodig_delay_timer = 0.5;
|
2011-04-23 11:31:31 -04:00
|
|
|
}
|
2011-11-29 10:15:18 -05:00
|
|
|
// We want a slight delay to very little
|
|
|
|
// time consuming nodes
|
|
|
|
float mindelay = 0.15;
|
|
|
|
if(nodig_delay_timer < mindelay)
|
2011-04-23 11:31:31 -04:00
|
|
|
{
|
2011-11-29 10:15:18 -05:00
|
|
|
nodig_delay_timer = mindelay;
|
2011-04-23 11:31:31 -04:00
|
|
|
}
|
2011-11-29 10:15:18 -05:00
|
|
|
}
|
2011-04-23 11:31:31 -04:00
|
|
|
|
2011-11-29 10:15:18 -05:00
|
|
|
dig_time += dtime;
|
2011-09-18 21:01:11 -04:00
|
|
|
|
2011-11-29 10:15:18 -05:00
|
|
|
camera.setDigging(0); // left click animation
|
2011-04-23 11:31:31 -04:00
|
|
|
}
|
2011-11-29 10:15:18 -05:00
|
|
|
|
2011-04-23 11:31:31 -04:00
|
|
|
if(input->getRightClicked())
|
|
|
|
{
|
2011-10-16 07:57:53 -04:00
|
|
|
infostream<<"Ground right-clicked"<<std::endl;
|
2011-04-23 11:31:31 -04:00
|
|
|
|
2011-06-17 19:00:01 -04:00
|
|
|
// If metadata provides an inventory view, activate it
|
|
|
|
if(meta && meta->getInventoryDrawSpecString() != "" && !random_input)
|
2011-04-23 11:31:31 -04:00
|
|
|
{
|
2011-10-16 07:57:53 -04:00
|
|
|
infostream<<"Launching custom inventory view"<<std::endl;
|
2012-01-12 00:10:39 -05:00
|
|
|
|
|
|
|
InventoryLocation inventoryloc;
|
|
|
|
inventoryloc.setNodeMeta(nodepos);
|
2011-06-17 19:00:01 -04:00
|
|
|
|
2012-01-12 00:10:39 -05:00
|
|
|
|
2011-06-17 17:46:50 -04:00
|
|
|
/*
|
2011-06-17 19:00:01 -04:00
|
|
|
Create menu
|
2011-06-17 17:46:50 -04:00
|
|
|
*/
|
2011-06-17 19:00:01 -04:00
|
|
|
|
|
|
|
core::array<GUIInventoryMenu::DrawSpec> draw_spec;
|
|
|
|
v2s16 invsize =
|
|
|
|
GUIInventoryMenu::makeDrawSpecArrayFromString(
|
|
|
|
draw_spec,
|
|
|
|
meta->getInventoryDrawSpecString(),
|
2012-01-12 00:10:39 -05:00
|
|
|
inventoryloc);
|
2011-06-17 19:00:01 -04:00
|
|
|
|
2011-04-23 11:31:31 -04:00
|
|
|
GUIInventoryMenu *menu =
|
|
|
|
new GUIInventoryMenu(guienv, guiroot, -1,
|
2011-06-17 19:00:01 -04:00
|
|
|
&g_menumgr, invsize,
|
2012-01-12 00:10:39 -05:00
|
|
|
&client, gamedef);
|
2011-04-23 11:31:31 -04:00
|
|
|
menu->setDrawSpec(draw_spec);
|
|
|
|
menu->drop();
|
|
|
|
}
|
2011-11-13 05:48:05 -05:00
|
|
|
// If metadata provides text input, activate text input
|
|
|
|
else if(meta && meta->allowsTextInput() && !random_input)
|
2011-04-23 11:31:31 -04:00
|
|
|
{
|
2011-11-13 05:48:05 -05:00
|
|
|
infostream<<"Launching metadata text input"<<std::endl;
|
2011-04-23 11:31:31 -04:00
|
|
|
|
2011-06-17 19:00:01 -04:00
|
|
|
// Get a new text for it
|
2011-04-23 11:31:31 -04:00
|
|
|
|
2011-11-13 05:48:05 -05:00
|
|
|
TextDest *dest = new TextDestNodeMetadata(nodepos, &client);
|
2011-06-17 19:00:01 -04:00
|
|
|
|
2011-11-13 05:48:05 -05:00
|
|
|
std::wstring wtext = narrow_to_wide(meta->getText());
|
2011-04-23 11:31:31 -04:00
|
|
|
|
2011-06-17 19:00:01 -04:00
|
|
|
(new GUITextInputMenu(guienv, guiroot, -1,
|
|
|
|
&g_menumgr, dest,
|
|
|
|
wtext))->drop();
|
2011-04-23 11:31:31 -04:00
|
|
|
}
|
2011-11-13 05:48:05 -05:00
|
|
|
// Otherwise report right click to server
|
2011-04-23 11:31:31 -04:00
|
|
|
else
|
|
|
|
{
|
2011-11-29 10:15:18 -05:00
|
|
|
client.interact(3, pointed);
|
2011-09-20 05:06:16 -04:00
|
|
|
camera.setDigging(1); // right click animation
|
2011-04-23 11:31:31 -04:00
|
|
|
}
|
|
|
|
}
|
2011-11-29 10:15:18 -05:00
|
|
|
}
|
|
|
|
else if(pointed.type == POINTEDTHING_OBJECT)
|
|
|
|
{
|
|
|
|
infotext = narrow_to_wide(selected_object->infoText());
|
|
|
|
|
2012-03-09 13:28:55 -05:00
|
|
|
if(infotext == L"" && show_debug){
|
|
|
|
infotext = narrow_to_wide(selected_object->debugInfoText());
|
|
|
|
}
|
|
|
|
|
2011-11-29 10:15:18 -05:00
|
|
|
//if(input->getLeftClicked())
|
|
|
|
if(input->getLeftState())
|
|
|
|
{
|
|
|
|
bool do_punch = false;
|
|
|
|
bool do_punch_damage = false;
|
|
|
|
if(object_hit_delay_timer <= 0.0){
|
|
|
|
do_punch = true;
|
|
|
|
do_punch_damage = true;
|
|
|
|
object_hit_delay_timer = object_hit_delay;
|
|
|
|
}
|
|
|
|
if(input->getLeftClicked()){
|
|
|
|
do_punch = true;
|
|
|
|
}
|
|
|
|
if(do_punch){
|
|
|
|
infostream<<"Left-clicked object"<<std::endl;
|
|
|
|
left_punch = true;
|
|
|
|
}
|
|
|
|
if(do_punch_damage){
|
|
|
|
// Report direct punch
|
2012-03-04 18:30:55 -05:00
|
|
|
v3f objpos = selected_object->getPosition();
|
|
|
|
v3f dir = (objpos - player_position).normalize();
|
|
|
|
|
|
|
|
bool disable_send = selected_object->directReportPunch(
|
|
|
|
dir, &playeritem, time_from_last_punch);
|
2012-03-09 16:53:25 -05:00
|
|
|
time_from_last_punch = 0;
|
2011-11-29 10:15:18 -05:00
|
|
|
if(!disable_send)
|
|
|
|
client.interact(0, pointed);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else if(input->getRightClicked())
|
|
|
|
{
|
|
|
|
infostream<<"Right-clicked object"<<std::endl;
|
|
|
|
client.interact(3, pointed); // place
|
|
|
|
}
|
2011-04-23 11:31:31 -04:00
|
|
|
}
|
2011-09-07 10:56:04 -04:00
|
|
|
|
2011-11-29 10:15:18 -05:00
|
|
|
pointed_old = pointed;
|
2011-04-23 11:31:31 -04:00
|
|
|
|
2011-10-14 19:28:57 -04:00
|
|
|
if(left_punch || (input->getLeftClicked() && !left_punch_muted))
|
2011-09-20 05:06:16 -04:00
|
|
|
{
|
|
|
|
camera.setDigging(0); // left click animation
|
|
|
|
}
|
|
|
|
|
2011-04-23 11:31:31 -04:00
|
|
|
input->resetLeftClicked();
|
|
|
|
input->resetRightClicked();
|
2011-11-29 10:15:18 -05:00
|
|
|
|
2011-04-23 11:31:31 -04:00
|
|
|
input->resetLeftReleased();
|
|
|
|
input->resetRightReleased();
|
|
|
|
|
|
|
|
/*
|
|
|
|
Calculate stuff for drawing
|
|
|
|
*/
|
2011-11-15 06:13:18 -05:00
|
|
|
|
|
|
|
/*
|
|
|
|
Calculate general brightness
|
|
|
|
*/
|
2011-04-23 11:31:31 -04:00
|
|
|
u32 daynight_ratio = client.getDayNightRatio();
|
2011-11-15 06:13:18 -05:00
|
|
|
u8 light8 = decode_light((daynight_ratio * LIGHT_SUN) / 1000);
|
|
|
|
brightness = (float)light8/255.0;
|
2012-02-03 07:50:49 -05:00
|
|
|
// Make night look good
|
|
|
|
brightness = brightness * 1.15 - 0.15;
|
|
|
|
video::SColor bgcolor;
|
|
|
|
if(brightness >= 0.2 && brightness < 0.7)
|
|
|
|
bgcolor = video::SColor(
|
|
|
|
255,
|
|
|
|
bgcolor_bright.getRed() * brightness,
|
|
|
|
bgcolor_bright.getGreen() * brightness*0.7,
|
|
|
|
bgcolor_bright.getBlue() * brightness*0.5);
|
|
|
|
else
|
|
|
|
bgcolor = video::SColor(
|
|
|
|
255,
|
|
|
|
bgcolor_bright.getRed() * brightness,
|
|
|
|
bgcolor_bright.getGreen() * brightness,
|
|
|
|
bgcolor_bright.getBlue() * brightness);
|
2011-04-29 10:53:07 -04:00
|
|
|
|
|
|
|
/*
|
|
|
|
Update skybox
|
|
|
|
*/
|
|
|
|
if(fabs(brightness - old_brightness) > 0.01)
|
2011-11-15 06:13:18 -05:00
|
|
|
update_skybox(driver, tsrc, smgr, skybox, brightness);
|
2011-04-29 10:53:07 -04:00
|
|
|
|
2011-04-29 08:34:26 -04:00
|
|
|
/*
|
2011-09-07 13:21:28 -04:00
|
|
|
Update clouds
|
2011-04-29 08:34:26 -04:00
|
|
|
*/
|
2011-05-06 09:58:06 -04:00
|
|
|
if(clouds)
|
|
|
|
{
|
|
|
|
clouds->step(dtime);
|
|
|
|
clouds->update(v2f(player_position.X, player_position.Z),
|
2012-02-03 07:50:49 -05:00
|
|
|
brightness);
|
2011-05-06 09:58:06 -04:00
|
|
|
}
|
2011-04-29 08:34:26 -04:00
|
|
|
|
2011-06-07 15:08:16 -04:00
|
|
|
/*
|
2011-06-18 06:43:49 -04:00
|
|
|
Update farmesh
|
2011-06-07 15:08:16 -04:00
|
|
|
*/
|
|
|
|
if(farmesh)
|
|
|
|
{
|
2011-08-03 06:03:30 -04:00
|
|
|
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;
|
|
|
|
|
2011-06-07 15:08:16 -04:00
|
|
|
farmesh->step(dtime);
|
|
|
|
farmesh->update(v2f(player_position.X, player_position.Z),
|
2012-02-03 07:50:49 -05:00
|
|
|
brightness, farmesh_range);
|
2011-06-07 15:08:16 -04:00
|
|
|
}
|
|
|
|
|
2011-04-29 10:53:07 -04:00
|
|
|
// Store brightness value
|
|
|
|
old_brightness = brightness;
|
|
|
|
|
2011-04-23 11:31:31 -04:00
|
|
|
/*
|
|
|
|
Fog
|
|
|
|
*/
|
|
|
|
|
2011-10-18 14:08:31 -04:00
|
|
|
if(g_settings->getBool("enable_fog") == true && !force_fog_off)
|
2011-04-23 11:31:31 -04:00
|
|
|
{
|
2011-06-18 05:42:17 -04:00
|
|
|
f32 range;
|
|
|
|
if(farmesh)
|
|
|
|
{
|
2011-06-18 06:43:49 -04:00
|
|
|
range = BS*farmesh_range;
|
2011-06-18 05:42:17 -04:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2012-02-06 10:26:48 -05:00
|
|
|
range = draw_control.wanted_range*BS + 0.0*MAP_BLOCKSIZE*BS;
|
2011-10-18 14:08:31 -04:00
|
|
|
range *= 0.9;
|
2011-06-18 05:42:17 -04:00
|
|
|
if(draw_control.range_all)
|
|
|
|
range = 100000*BS;
|
2011-10-18 12:18:01 -04:00
|
|
|
/*if(range < 50*BS)
|
|
|
|
range = range * 0.5 + 25*BS;*/
|
2011-06-18 05:42:17 -04:00
|
|
|
}
|
2011-04-23 11:31:31 -04:00
|
|
|
|
|
|
|
driver->setFog(
|
|
|
|
bgcolor,
|
|
|
|
video::EFT_FOG_LINEAR,
|
|
|
|
range*0.4,
|
|
|
|
range*1.0,
|
|
|
|
0.01,
|
|
|
|
false, // pixel fog
|
|
|
|
false // range fog
|
|
|
|
);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
driver->setFog(
|
|
|
|
bgcolor,
|
|
|
|
video::EFT_FOG_LINEAR,
|
|
|
|
100000*BS,
|
|
|
|
110000*BS,
|
|
|
|
0.01,
|
|
|
|
false, // pixel fog
|
|
|
|
false // range fog
|
|
|
|
);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
Update gui stuff (0ms)
|
|
|
|
*/
|
|
|
|
|
|
|
|
//TimeTaker guiupdatetimer("Gui updating");
|
|
|
|
|
2012-01-31 18:56:30 -05:00
|
|
|
const char program_name_and_version[] =
|
|
|
|
"Minetest-c55 " VERSION_STRING;
|
|
|
|
|
|
|
|
if(show_debug)
|
2011-04-23 11:31:31 -04:00
|
|
|
{
|
|
|
|
static float drawtime_avg = 0;
|
|
|
|
drawtime_avg = drawtime_avg * 0.95 + (float)drawtime*0.05;
|
2012-01-31 18:56:30 -05:00
|
|
|
/*static float beginscenetime_avg = 0;
|
2011-04-23 11:31:31 -04:00
|
|
|
beginscenetime_avg = beginscenetime_avg * 0.95 + (float)beginscenetime*0.05;
|
|
|
|
static float scenetime_avg = 0;
|
|
|
|
scenetime_avg = scenetime_avg * 0.95 + (float)scenetime*0.05;
|
|
|
|
static float endscenetime_avg = 0;
|
2012-01-31 18:56:30 -05:00
|
|
|
endscenetime_avg = endscenetime_avg * 0.95 + (float)endscenetime*0.05;*/
|
2011-04-23 11:31:31 -04:00
|
|
|
|
|
|
|
char temptext[300];
|
2012-01-31 18:56:30 -05:00
|
|
|
snprintf(temptext, 300, "%s ("
|
2011-04-24 04:41:33 -04:00
|
|
|
"R: range_all=%i"
|
2011-04-23 11:31:31 -04:00
|
|
|
")"
|
2012-01-31 18:56:30 -05:00
|
|
|
" drawtime=%.0f, dtime_jitter = % .1f %%"
|
|
|
|
", v_range = %.1f, RTT = %.3f",
|
|
|
|
program_name_and_version,
|
2011-04-23 11:31:31 -04:00
|
|
|
draw_control.range_all,
|
|
|
|
drawtime_avg,
|
2012-01-31 18:56:30 -05:00
|
|
|
dtime_jitter1_max_fraction * 100.0,
|
|
|
|
draw_control.wanted_range,
|
|
|
|
client.getRTT()
|
2011-04-23 11:31:31 -04:00
|
|
|
);
|
|
|
|
|
|
|
|
guitext->setText(narrow_to_wide(temptext).c_str());
|
2012-01-31 18:56:30 -05:00
|
|
|
guitext->setVisible(true);
|
|
|
|
}
|
2012-01-31 19:36:59 -05:00
|
|
|
else if(show_hud || show_chat)
|
2012-01-31 18:56:30 -05:00
|
|
|
{
|
|
|
|
guitext->setText(narrow_to_wide(program_name_and_version).c_str());
|
|
|
|
guitext->setVisible(true);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
guitext->setVisible(false);
|
2011-04-23 11:31:31 -04:00
|
|
|
}
|
|
|
|
|
2012-01-31 18:56:30 -05:00
|
|
|
if(show_debug)
|
2011-04-23 11:31:31 -04:00
|
|
|
{
|
|
|
|
char temptext[300];
|
|
|
|
snprintf(temptext, 300,
|
|
|
|
"(% .1f, % .1f, % .1f)"
|
2012-01-31 18:56:30 -05:00
|
|
|
" (yaw = %.1f)",
|
2011-04-23 11:31:31 -04:00
|
|
|
player_position.X/BS,
|
|
|
|
player_position.Y/BS,
|
|
|
|
player_position.Z/BS,
|
2012-01-31 18:56:30 -05:00
|
|
|
wrapDegrees_0_360(camera_yaw));
|
2011-04-23 11:31:31 -04:00
|
|
|
|
|
|
|
guitext2->setText(narrow_to_wide(temptext).c_str());
|
2012-01-31 18:56:30 -05:00
|
|
|
guitext2->setVisible(true);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
guitext2->setVisible(false);
|
2011-04-23 11:31:31 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
{
|
|
|
|
guitext_info->setText(infotext.c_str());
|
2012-03-09 13:28:55 -05:00
|
|
|
guitext_info->setVisible(show_hud && g_menumgr.menuCount() == 0);
|
2012-01-31 18:56:30 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
{
|
|
|
|
float statustext_time_max = 3.0;
|
|
|
|
if(!statustext.empty())
|
|
|
|
{
|
|
|
|
statustext_time += dtime;
|
|
|
|
if(statustext_time >= statustext_time_max)
|
|
|
|
{
|
|
|
|
statustext = L"";
|
|
|
|
statustext_time = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
guitext_status->setText(statustext.c_str());
|
|
|
|
guitext_status->setVisible(!statustext.empty());
|
|
|
|
|
|
|
|
if(!statustext.empty())
|
|
|
|
{
|
|
|
|
s32 status_y = screensize.Y - 130;
|
|
|
|
core::rect<s32> rect(
|
|
|
|
10,
|
|
|
|
status_y - guitext_status->getTextHeight(),
|
|
|
|
screensize.X - 10,
|
|
|
|
status_y
|
|
|
|
);
|
|
|
|
guitext_status->setRelativePosition(rect);
|
|
|
|
|
|
|
|
// Fade out
|
|
|
|
video::SColor initial_color(255,0,0,0);
|
|
|
|
if(guienv->getSkin())
|
|
|
|
initial_color = guienv->getSkin()->getColor(gui::EGDC_BUTTON_TEXT);
|
|
|
|
video::SColor final_color = initial_color;
|
|
|
|
final_color.setAlpha(0);
|
|
|
|
video::SColor fade_color =
|
|
|
|
initial_color.getInterpolated_quadratic(
|
|
|
|
initial_color,
|
|
|
|
final_color,
|
|
|
|
statustext_time / (float) statustext_time_max);
|
|
|
|
guitext_status->setOverrideColor(fade_color);
|
|
|
|
guitext_status->enableOverrideColor(true);
|
|
|
|
}
|
2011-04-23 11:31:31 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
Get chat messages from client
|
|
|
|
*/
|
|
|
|
{
|
2011-11-27 07:29:48 -05:00
|
|
|
// Get new messages from error log buffer
|
|
|
|
while(!chat_log_error_buf.empty())
|
|
|
|
{
|
|
|
|
chat_lines.push_back(ChatLine(narrow_to_wide(
|
|
|
|
chat_log_error_buf.get())));
|
|
|
|
}
|
|
|
|
// Get new messages from client
|
2011-04-23 11:31:31 -04:00
|
|
|
std::wstring message;
|
|
|
|
while(client.getChatMessage(message))
|
|
|
|
{
|
|
|
|
chat_lines.push_back(ChatLine(message));
|
|
|
|
/*if(chat_lines.size() > 6)
|
|
|
|
{
|
|
|
|
core::list<ChatLine>::Iterator
|
|
|
|
i = chat_lines.begin();
|
|
|
|
chat_lines.erase(i);
|
|
|
|
}*/
|
|
|
|
}
|
|
|
|
// Append them to form the whole static text and throw
|
|
|
|
// it to the gui element
|
|
|
|
std::wstring whole;
|
|
|
|
// This will correspond to the line number counted from
|
|
|
|
// top to bottom, from size-1 to 0
|
|
|
|
s16 line_number = chat_lines.size();
|
|
|
|
// Count of messages to be removed from the top
|
|
|
|
u16 to_be_removed_count = 0;
|
|
|
|
for(core::list<ChatLine>::Iterator
|
|
|
|
i = chat_lines.begin();
|
|
|
|
i != chat_lines.end(); i++)
|
|
|
|
{
|
|
|
|
// After this, line number is valid for this loop
|
|
|
|
line_number--;
|
|
|
|
// Increment age
|
|
|
|
(*i).age += dtime;
|
|
|
|
/*
|
|
|
|
This results in a maximum age of 60*6 to the
|
|
|
|
lowermost line and a maximum of 6 lines
|
|
|
|
*/
|
|
|
|
float allowed_age = (6-line_number) * 60.0;
|
|
|
|
|
|
|
|
if((*i).age > allowed_age)
|
|
|
|
{
|
|
|
|
to_be_removed_count++;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
whole += (*i).text + L'\n';
|
|
|
|
}
|
|
|
|
for(u16 i=0; i<to_be_removed_count; i++)
|
|
|
|
{
|
|
|
|
core::list<ChatLine>::Iterator
|
|
|
|
it = chat_lines.begin();
|
|
|
|
chat_lines.erase(it);
|
|
|
|
}
|
|
|
|
guitext_chat->setText(whole.c_str());
|
|
|
|
|
|
|
|
// Update gui element size and position
|
|
|
|
|
|
|
|
/*core::rect<s32> rect(
|
|
|
|
10,
|
|
|
|
screensize.Y - guitext_chat_pad_bottom
|
|
|
|
- text_height*chat_lines.size(),
|
|
|
|
screensize.X - 10,
|
|
|
|
screensize.Y - guitext_chat_pad_bottom
|
|
|
|
);*/
|
2012-01-31 18:56:30 -05:00
|
|
|
|
|
|
|
s32 chat_y = 5+(text_height+5);
|
|
|
|
if(show_debug)
|
|
|
|
chat_y += (text_height+5);
|
2011-04-23 11:31:31 -04:00
|
|
|
core::rect<s32> rect(
|
|
|
|
10,
|
2012-01-31 18:56:30 -05:00
|
|
|
chat_y,
|
2011-04-23 11:31:31 -04:00
|
|
|
screensize.X - 10,
|
2012-01-31 18:56:30 -05:00
|
|
|
chat_y + guitext_chat->getTextHeight()
|
2011-04-23 11:31:31 -04:00
|
|
|
);
|
|
|
|
|
|
|
|
guitext_chat->setRelativePosition(rect);
|
|
|
|
|
2012-01-31 18:56:30 -05:00
|
|
|
// Don't show chat if empty or profiler or debug is enabled
|
|
|
|
guitext_chat->setVisible(chat_lines.size() != 0
|
|
|
|
&& show_chat && show_profiler == 0);
|
2011-04-23 11:31:31 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
Inventory
|
|
|
|
*/
|
|
|
|
|
2011-11-29 10:15:18 -05:00
|
|
|
if(client.getPlayerItem() != new_playeritem)
|
|
|
|
{
|
|
|
|
client.selectPlayerItem(new_playeritem);
|
|
|
|
}
|
|
|
|
if(client.getLocalInventoryUpdated())
|
2011-04-23 11:31:31 -04:00
|
|
|
{
|
2011-10-16 07:57:53 -04:00
|
|
|
//infostream<<"Updating local inventory"<<std::endl;
|
2011-04-23 11:31:31 -04:00
|
|
|
client.getLocalInventory(local_inventory);
|
2012-01-02 10:44:00 -05:00
|
|
|
|
|
|
|
update_wielded_item_trigger = true;
|
|
|
|
}
|
|
|
|
if(update_wielded_item_trigger)
|
|
|
|
{
|
|
|
|
update_wielded_item_trigger = false;
|
2011-09-18 21:01:11 -04:00
|
|
|
// Update wielded tool
|
|
|
|
InventoryList *mlist = local_inventory.getList("main");
|
2012-01-12 00:10:39 -05:00
|
|
|
ItemStack item;
|
2011-09-18 21:01:11 -04:00
|
|
|
if(mlist != NULL)
|
2011-11-29 10:15:18 -05:00
|
|
|
item = mlist->getItem(client.getPlayerItem());
|
2011-11-14 14:41:30 -05:00
|
|
|
camera.wield(item, gamedef);
|
2011-04-23 11:31:31 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
Drawing begins
|
|
|
|
*/
|
|
|
|
|
|
|
|
TimeTaker drawtimer("Drawing");
|
|
|
|
|
|
|
|
|
|
|
|
{
|
|
|
|
TimeTaker timer("beginScene");
|
2012-01-31 18:56:30 -05:00
|
|
|
driver->beginScene(false, true, bgcolor);
|
2011-04-23 11:31:31 -04:00
|
|
|
//driver->beginScene(false, true, bgcolor);
|
|
|
|
beginscenetime = timer.stop(true);
|
|
|
|
}
|
2011-06-07 15:08:16 -04:00
|
|
|
|
2011-04-23 11:31:31 -04:00
|
|
|
//timer3.stop();
|
|
|
|
|
2011-10-16 07:57:53 -04:00
|
|
|
//infostream<<"smgr->drawAll()"<<std::endl;
|
2011-04-23 11:31:31 -04:00
|
|
|
|
|
|
|
{
|
|
|
|
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);
|
|
|
|
|
2012-01-31 18:56:30 -05:00
|
|
|
if(show_hud)
|
2011-04-23 11:31:31 -04:00
|
|
|
{
|
2012-01-31 18:56:30 -05:00
|
|
|
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));
|
|
|
|
}
|
2011-04-23 11:31:31 -04:00
|
|
|
}
|
|
|
|
|
2011-09-20 19:42:52 -04:00
|
|
|
/*
|
|
|
|
Wielded tool
|
|
|
|
*/
|
2012-01-31 18:56:30 -05:00
|
|
|
if(show_hud)
|
2011-09-20 19:42:52 -04:00
|
|
|
{
|
|
|
|
// Warning: This clears the Z buffer.
|
|
|
|
camera.drawWieldedTool();
|
|
|
|
}
|
|
|
|
|
2011-09-07 13:21:28 -04:00
|
|
|
/*
|
|
|
|
Post effects
|
|
|
|
*/
|
|
|
|
{
|
|
|
|
client.renderPostFx();
|
|
|
|
}
|
|
|
|
|
2011-04-23 11:31:31 -04:00
|
|
|
/*
|
|
|
|
Frametime log
|
|
|
|
*/
|
2012-01-31 18:56:30 -05:00
|
|
|
if(show_debug_frametime)
|
2011-04-23 11:31:31 -04:00
|
|
|
{
|
|
|
|
s32 x = 10;
|
2012-01-31 18:56:30 -05:00
|
|
|
s32 y = screensize.Y - 10;
|
2011-04-23 11:31:31 -04:00
|
|
|
for(core::list<float>::Iterator
|
|
|
|
i = frametime_log.begin();
|
|
|
|
i != frametime_log.end();
|
|
|
|
i++)
|
|
|
|
{
|
2012-01-31 18:56:30 -05:00
|
|
|
driver->draw2DLine(v2s32(x,y),
|
|
|
|
v2s32(x,y-(*i)*1000),
|
2011-04-23 11:31:31 -04:00
|
|
|
video::SColor(255,255,255,255));
|
|
|
|
x++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
Draw crosshair
|
|
|
|
*/
|
2012-01-31 18:56:30 -05:00
|
|
|
if(show_hud)
|
|
|
|
{
|
|
|
|
driver->draw2DLine(displaycenter - core::vector2d<s32>(10,0),
|
|
|
|
displaycenter + core::vector2d<s32>(10,0),
|
|
|
|
video::SColor(255,255,255,255));
|
|
|
|
driver->draw2DLine(displaycenter - core::vector2d<s32>(0,10),
|
|
|
|
displaycenter + core::vector2d<s32>(0,10),
|
|
|
|
video::SColor(255,255,255,255));
|
|
|
|
}
|
2011-04-23 11:31:31 -04:00
|
|
|
|
|
|
|
} // timer
|
|
|
|
|
|
|
|
//timer10.stop();
|
|
|
|
//TimeTaker //timer11("//timer11");
|
|
|
|
|
|
|
|
/*
|
|
|
|
Draw gui
|
|
|
|
*/
|
|
|
|
// 0-1ms
|
|
|
|
guienv->drawAll();
|
|
|
|
|
|
|
|
/*
|
|
|
|
Draw hotbar
|
|
|
|
*/
|
2012-01-31 18:56:30 -05:00
|
|
|
if(show_hud)
|
2011-04-23 11:31:31 -04:00
|
|
|
{
|
2012-01-12 00:10:39 -05:00
|
|
|
draw_hotbar(driver, font, gamedef,
|
2011-11-13 17:19:48 -05:00
|
|
|
v2s32(displaycenter.X, screensize.Y),
|
2011-04-23 11:31:31 -04:00
|
|
|
hotbar_imagesize, hotbar_itemcount, &local_inventory,
|
2011-11-29 10:15:18 -05:00
|
|
|
client.getHP(), client.getPlayerItem());
|
2011-04-23 11:31:31 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
Damage flash
|
|
|
|
*/
|
|
|
|
if(damage_flash_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);
|
|
|
|
}
|
2011-07-01 14:25:31 -04:00
|
|
|
|
2011-04-23 11:31:31 -04:00
|
|
|
/*
|
|
|
|
End scene
|
|
|
|
*/
|
|
|
|
{
|
|
|
|
TimeTaker timer("endScene");
|
2011-04-29 19:12:32 -04:00
|
|
|
endSceneX(driver);
|
2011-04-23 11:31:31 -04:00
|
|
|
endscenetime = timer.stop(true);
|
|
|
|
}
|
|
|
|
|
|
|
|
drawtime = drawtimer.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();
|
2011-04-29 19:12:32 -04:00
|
|
|
str += "] FPS=";
|
2011-04-23 11:31:31 -04:00
|
|
|
str += fps;
|
|
|
|
|
|
|
|
device->setWindowCaption(str.c_str());
|
|
|
|
lastFPS = fps;
|
|
|
|
}
|
|
|
|
}
|
2011-05-21 07:28:28 -04:00
|
|
|
|
|
|
|
/*
|
|
|
|
Drop stuff
|
|
|
|
*/
|
2011-06-07 15:08:16 -04:00
|
|
|
if(clouds)
|
|
|
|
clouds->drop();
|
2011-05-06 09:58:06 -04:00
|
|
|
|
|
|
|
/*
|
|
|
|
Draw a "shutting down" screen, which will be shown while the map
|
|
|
|
generator and other stuff quits
|
|
|
|
*/
|
|
|
|
{
|
2011-06-26 13:00:04 -04:00
|
|
|
/*gui::IGUIStaticText *gui_shuttingdowntext = */
|
|
|
|
draw_load_screen(L"Shutting down stuff...", driver, font);
|
|
|
|
/*driver->beginScene(true, true, video::SColor(255,0,0,0));
|
2011-05-06 09:58:06 -04:00
|
|
|
guienv->drawAll();
|
|
|
|
driver->endScene();
|
2011-06-26 13:00:04 -04:00
|
|
|
gui_shuttingdowntext->remove();*/
|
2011-05-06 09:58:06 -04:00
|
|
|
}
|
2011-11-13 17:19:48 -05:00
|
|
|
|
2011-11-14 18:00:16 -05:00
|
|
|
} // Client scope (must be destructed before destructing *def and tsrc
|
|
|
|
|
2011-11-13 17:19:48 -05:00
|
|
|
delete tsrc;
|
2011-11-14 18:00:16 -05:00
|
|
|
delete nodedef;
|
2012-01-12 00:10:39 -05:00
|
|
|
delete itemdef;
|
2011-04-23 11:31:31 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
|