#include "nodedef.h"
#include "nodemetadata.h"
#include "main.h" // For g_settings
-#include "content_mapnode.h" // For content_mapnode_init
-#include "tooldef.h"
-#include "content_tool.h" // Default tools
-#include "content_mapnode.h" // Default nodes
+#include "itemdef.h"
+#include "tile.h" // For TextureSource
+#include "logoutputbuffer.h"
/*
Setting this to 1 enables a special camera mode that forces
std::wstring text;
};
-/*
- Inventory stuff
-*/
-
-// Inventory actions from the menu are buffered here before sending
-Queue<InventoryAction*> inventory_action_queue;
-// This is a copy of the inventory that the client's environment has
-Inventory local_inventory;
-
-u16 g_selected_item = 0;
-
/*
Text input system
*/
Hotbar draw routine
*/
void draw_hotbar(video::IVideoDriver *driver, gui::IGUIFont *font,
- ITextureSource *tsrc,
+ IGameDef *gamedef,
v2s32 centerlowerpos, s32 imgsize, s32 itemcount,
- Inventory *inventory, s32 halfheartcount)
+ Inventory *inventory, s32 halfheartcount, u16 playeritem)
{
InventoryList *mainlist = inventory->getList("main");
if(mainlist == NULL)
for(s32 i=0; i<itemcount; i++)
{
- InventoryItem *item = mainlist->getItem(i);
+ const ItemStack &item = mainlist->getItem(i);
core::rect<s32> rect = imgrect + pos
+ v2s32(padding+i*(imgsize+padding*2), padding);
- if(g_selected_item == i)
+ if(playeritem == i)
{
video::SColor c_outside(255,255,0,0);
//video::SColor c_outside(255,0,0,0);
video::SColor bgcolor2(128,0,0,0);
driver->draw2DRectangle(bgcolor2, rect, NULL);
-
- if(item != NULL)
- {
- drawInventoryItem(driver, font, item, rect, NULL, tsrc);
- }
+ drawItemStack(driver, font, item, rect, NULL, gamedef);
}
/*
Draw hearts
*/
+ video::ITexture *heart_texture =
+ gamedef->getTextureSource()->getTextureRaw("heart.png");
+ if(heart_texture)
{
- video::ITexture *heart_texture =
- driver->getTexture(getTexturePath("heart.png").c_str());
v2s32 p = pos + v2s32(0, -20);
for(s32 i=0; i<halfheartcount/2; i++)
{
}
}
+/*
+ Check if a node is pointable
+*/
+inline bool isPointableNode(const MapNode& n,
+ Client *client, bool liquids_pointable)
+{
+ const ContentFeatures &features = client->getNodeDefManager()->get(n);
+ return features.pointable ||
+ (liquids_pointable && features.isLiquid());
+}
+
/*
Find what the player is pointing at
*/
-void getPointedNode(Client *client, v3f player_position,
+PointedThing getPointedThing(Client *client, v3f player_position,
v3f camera_direction, v3f camera_position,
- bool &nodefound, core::line3d<f32> shootline,
- v3s16 &nodepos, v3s16 &neighbourpos,
- core::aabbox3d<f32> &nodehilightbox,
- f32 d)
+ core::line3d<f32> shootline, f32 d,
+ bool liquids_pointable,
+ bool look_for_object,
+ core::aabbox3d<f32> &hilightbox,
+ bool &should_show_hilightbox,
+ ClientActiveObject *&selected_object)
{
+ PointedThing result;
+
+ hilightbox = core::aabbox3d<f32>(0,0,0,0,0,0);
+ should_show_hilightbox = false;
+ selected_object = NULL;
+
+ INodeDefManager *nodedef = client->getNodeDefManager();
+
+ // 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
+
f32 mindistance = BS * 1001;
v3s16 pos_i = floatToInt(player_position, BS);
try
{
n = client->getNode(v3s16(x,y,z));
- if(client->getNodeDefManager()->get(n).pointable == false)
- continue;
}
catch(InvalidPositionException &e)
{
continue;
}
+ if(!isPointableNode(n, client, liquids_pointable))
+ continue;
v3s16 np(x,y,z);
v3f npf = intToFloat(np, BS);
v3s16(-1,0,0), // left
};
- const ContentFeatures &f = client->getNodeDefManager()->get(n);
+ const ContentFeatures &f = nodedef->get(n);
if(f.selection_box.type == NODEBOX_FIXED)
{
- f32 distance = (npf - camera_position).getLength();
-
core::aabbox3d<f32> box = f.selection_box.fixed;
box.MinEdge += npf;
box.MaxEdge += npf;
- if(distance < mindistance)
+ 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++)
{
- if(box.intersectsWithLine(shootline))
- {
- nodefound = true;
- nodepos = np;
- neighbourpos = np;
- mindistance = distance;
- nodehilightbox = box;
- }
+ 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;
+ result.type = POINTEDTHING_NODE;
+ result.node_undersurface = np;
+ result.node_abovesurface = np+facedirs[i];
+ mindistance = distance;
+ hilightbox = box;
+ should_show_hilightbox = true;
}
}
else if(f.selection_box.type == NODEBOX_WALLMOUNTED)
{
- v3s16 dir = unpackDir(n.param2);
+ v3s16 dir = n.getWallMountedDir(nodedef);
v3f dir_f = v3f(dir.X, dir.Y, dir.Z);
dir_f *= BS/2 - BS/6 - BS/20;
v3f cpf = npf + dir_f;
{
if(box.intersectsWithLine(shootline))
{
- nodefound = true;
- nodepos = np;
- neighbourpos = np;
+ result.type = POINTEDTHING_NODE;
+ result.node_undersurface = np;
+ result.node_abovesurface = np;
mindistance = distance;
- nodehilightbox = box;
+ hilightbox = box;
+ should_show_hilightbox = true;
}
}
}
if(facebox.intersectsWithLine(shootline))
{
- nodefound = true;
- nodepos = np;
- neighbourpos = np + dirs[i];
+ result.type = POINTEDTHING_NODE;
+ result.node_undersurface = np;
+ result.node_abovesurface = np + dirs[i];
mindistance = distance;
- //nodehilightbox = facebox;
+ //hilightbox = facebox;
const float d = 0.502;
core::aabbox3d<f32> nodebox
(-BS*d, -BS*d, -BS*d, BS*d, BS*d, BS*d);
- v3f nodepos_f = intToFloat(nodepos, BS);
+ v3f nodepos_f = intToFloat(np, BS);
nodebox.MinEdge += nodepos_f;
nodebox.MaxEdge += nodepos_f;
- nodehilightbox = nodebox;
+ hilightbox = nodebox;
+ should_show_hilightbox = true;
}
} // if distance < mindistance
} // for dirs
} // regular block
} // for coords
+
+ return result;
}
-void update_skybox(video::IVideoDriver* driver,
+void update_skybox(video::IVideoDriver* driver, ITextureSource *tsrc,
scene::ISceneManager* smgr, scene::ISceneNode* &skybox,
float brightness)
{
if(brightness >= 0.5)
{
skybox = smgr->addSkyBoxSceneNode(
- driver->getTexture(getTexturePath("skybox2.png").c_str()),
- driver->getTexture(getTexturePath("skybox3.png").c_str()),
- driver->getTexture(getTexturePath("skybox1.png").c_str()),
- driver->getTexture(getTexturePath("skybox1.png").c_str()),
- driver->getTexture(getTexturePath("skybox1.png").c_str()),
- driver->getTexture(getTexturePath("skybox1.png").c_str()));
+ tsrc->getTextureRaw("skybox2.png"),
+ tsrc->getTextureRaw("skybox3.png"),
+ tsrc->getTextureRaw("skybox1.png"),
+ tsrc->getTextureRaw("skybox1.png"),
+ tsrc->getTextureRaw("skybox1.png"),
+ tsrc->getTextureRaw("skybox1.png"));
}
else if(brightness >= 0.2)
{
skybox = smgr->addSkyBoxSceneNode(
- driver->getTexture(getTexturePath("skybox2_dawn.png").c_str()),
- driver->getTexture(getTexturePath("skybox3_dawn.png").c_str()),
- driver->getTexture(getTexturePath("skybox1_dawn.png").c_str()),
- driver->getTexture(getTexturePath("skybox1_dawn.png").c_str()),
- driver->getTexture(getTexturePath("skybox1_dawn.png").c_str()),
- driver->getTexture(getTexturePath("skybox1_dawn.png").c_str()));
+ 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"));
}
else
{
skybox = smgr->addSkyBoxSceneNode(
- driver->getTexture(getTexturePath("skybox2_night.png").c_str()),
- driver->getTexture(getTexturePath("skybox3_night.png").c_str()),
- driver->getTexture(getTexturePath("skybox1_night.png").c_str()),
- driver->getTexture(getTexturePath("skybox1_night.png").c_str()),
- driver->getTexture(getTexturePath("skybox1_night.png").c_str()),
- driver->getTexture(getTexturePath("skybox1_night.png").c_str()));
+ 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"));
}
}
/*
Draw "Loading" screen
*/
- /*gui::IGUIStaticText *gui_loadingtext = */
- //draw_load_screen(L"Loading and connecting...", driver, font);
draw_load_screen(L"Loading...", driver, font);
- // Create tool definition manager
- IWritableToolDefManager *tooldef = createToolDefManager();
// Create texture source
IWritableTextureSource *tsrc = createTextureSource(device);
+
+ // These will be filled by data received from the server
+ // Create item definition manager
+ IWritableItemDefManager *itemdef = createItemDefManager();
// Create node definition manager
- IWritableNodeDefManager *nodedef = createNodeDefManager(tsrc);
+ IWritableNodeDefManager *nodedef = createNodeDefManager();
- // Fill node feature table with default definitions
- content_mapnode_init(tsrc, nodedef);
- // Set default tool definitions
- content_tool_init(tooldef);
+ // Add chat log output for errors to be shown in chat
+ LogOutputBuffer chat_log_error_buf(LMT_ERROR);
/*
Create server.
server = new Server(map_dir, configpath);
server->start(port);
}
+
+ { // Client scope
/*
Create client
MapDrawControl draw_control;
Client client(device, playername.c_str(), password, draw_control,
- tsrc, tooldef, nodedef);
+ tsrc, itemdef, nodedef);
// Client acts as our GameDef
IGameDef *gamedef = &client;
connect_address.print(&infostream);
infostream<<std::endl;
client.connect(connect_address);
-
- bool could_connect = false;
+ /*
+ Wait for server to accept connection
+ */
+ bool could_connect = false;
try{
+ float frametime = 0.033;
+ const float timeout = 10.0;
float time_counter = 0.0;
for(;;)
{
- if(client.connectedAndInitialized())
- {
+ // Update client and server
+ client.step(frametime);
+ if(server != NULL)
+ server->step(frametime);
+
+ // End condition
+ if(client.connectedAndInitialized()){
could_connect = true;
break;
}
+ // Break conditions
if(client.accessDenied())
- {
break;
- }
- // Wait for 10 seconds
- if(time_counter >= 10.0)
- {
+ if(time_counter >= timeout)
break;
- }
+ // Display status
std::wostringstream ss;
ss<<L"Connecting to server... (timeout in ";
- ss<<(int)(10.0 - time_counter + 1.0);
+ ss<<(int)(timeout - time_counter + 1.0);
ss<<L" seconds)";
draw_load_screen(ss.str(), driver, font);
-
- /*// Update screen
- driver->beginScene(true, true, video::SColor(255,0,0,0));
- guienv->drawAll();
- driver->endScene();*/
-
- // Update client and server
-
- client.step(0.1);
-
- if(server != NULL)
- server->step(0.1);
// Delay a bit
- sleep_ms(100);
- time_counter += 0.1;
+ sleep_ms(1000*frametime);
+ time_counter += frametime;
}
}
catch(con::PeerNotFoundException &e)
{}
-
+
+ /*
+ Handle failure to connect
+ */
if(could_connect == false)
{
if(client.accessDenied())
//gui_loadingtext->remove();
return;
}
+
+ /*
+ Wait until content has been received
+ */
+ bool got_content = false;
+ {
+ float frametime = 0.033;
+ const float timeout = 30.0;
+ float time_counter = 0.0;
+ for(;;)
+ {
+ // Update client and server
+ client.step(frametime);
+ if(server != NULL)
+ server->step(frametime);
+
+ // End condition
+ if(client.texturesReceived() &&
+ client.itemdefReceived() &&
+ client.nodedefReceived()){
+ got_content = true;
+ break;
+ }
+ // Break conditions
+ if(!client.connectedAndInitialized())
+ 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";
+
+ ss<<(client.itemdefReceived()?L"[X]":L"[ ]");
+ ss<<L" Item definitions\n";
+ ss<<(client.nodedefReceived()?L"[X]":L"[ ]");
+ ss<<L" Node definitions\n";
+ //ss<<(client.texturesReceived()?L"[X]":L"[ ]");
+ ss<<L"["<<(int)(client.textureReceiveProgress()*100+0.5)<<L"%] ";
+ ss<<L" Textures\n";
+
+ draw_load_screen(ss.str(), driver, font);
+
+ // Delay a bit
+ sleep_ms(1000*frametime);
+ time_counter += frametime;
+ }
+ }
+
+ /*
+ After all content has been received:
+ Update cached textures, meshes and materials
+ */
+ client.afterContentReceived();
/*
Create skybox
*/
float old_brightness = 1.0;
scene::ISceneNode* skybox = NULL;
- update_skybox(driver, smgr, skybox, 1.0);
+ update_skybox(driver, tsrc, smgr, skybox, 1.0);
/*
Create the camera node
farmesh = new FarMesh(smgr->getRootSceneNode(), smgr, -1, client.getMapSeed(), &client);
}
+ /*
+ A copy of the local inventory
+ */
+ Inventory local_inventory(itemdef);
+
/*
Move into game
*/
// A test
//throw con::PeerNotFoundException("lol");
+ float brightness = 1.0;
+
core::list<float> frametime_log;
- float nodig_delay_counter = 0.0;
+ float nodig_delay_timer = 0.0;
float dig_time = 0.0;
u16 dig_index = 0;
- v3s16 nodepos_old(-32768,-32768,-32768);
+ PointedThing pointed_old;
+ bool digging = false;
+ bool ldown_for_dig = false;
float damage_flash_timer = 0;
s16 farmesh_range = 20*MAP_BLOCKSIZE;
- const float object_hit_delay = 0.5;
+ const float object_hit_delay = 0.2;
float object_hit_delay_timer = 0.0;
bool invert_mouse = g_settings->getBool("invert_mouse");
bool respawn_menu_active = false;
+ bool update_wielded_item_trigger = false;
bool show_profiler = false;
bool force_fog_off = false;
/* Run timers */
- object_hit_delay_timer -= dtime;
+ if(nodig_delay_timer >= 0)
+ nodig_delay_timer -= dtime;
+ if(object_hit_delay_timer >= 0)
+ object_hit_delay_timer -= dtime;
g_profiler->add("Elapsed time", dtime);
g_profiler->avg("FPS", 1./dtime);
input->step(dtime);
/*
- Launch menus according to keys
+ Launch menus and trigger stuff according to keys
*/
- if(input->wasKeyDown(getKeySetting("keymap_inventory")))
+ if(input->wasKeyDown(getKeySetting("keymap_drop")))
+ {
+ // drop selected item
+ IDropAction *a = new IDropAction();
+ a->count = 0;
+ a->from_inv.setCurrentPlayer();
+ a->from_list = "main";
+ a->from_i = client.getPlayerItem();
+ client.inventoryAction(a);
+ }
+ else if(input->wasKeyDown(getKeySetting("keymap_inventory")))
{
infostream<<"the_game: "
<<"Launching inventory"<<std::endl;
GUIInventoryMenu *menu =
new GUIInventoryMenu(guienv, guiroot, -1,
&g_menumgr, v2s16(8,7),
- client.getInventoryContext(),
- &client, tsrc);
+ &client, gamedef);
+
+ InventoryLocation inventoryloc;
+ inventoryloc.setCurrentPlayer();
core::array<GUIInventoryMenu::DrawSpec> draw_spec;
draw_spec.push_back(GUIInventoryMenu::DrawSpec(
- "list", "current_player", "main",
+ "list", inventoryloc, "main",
v2s32(0, 3), v2s32(8, 4)));
draw_spec.push_back(GUIInventoryMenu::DrawSpec(
- "list", "current_player", "craft",
+ "list", inventoryloc, "craft",
v2s32(3, 0), v2s32(3, 3)));
draw_spec.push_back(GUIInventoryMenu::DrawSpec(
- "list", "current_player", "craftresult",
+ "list", inventoryloc, "craftpreview",
v2s32(7, 1), v2s32(1, 1)));
menu->setDrawSpec(draw_spec);
}
// Item selection with mouse wheel
+ u16 new_playeritem = client.getPlayerItem();
{
s32 wheel = input->getMouseWheel();
u16 max_item = MYMIN(PLAYER_INVENTORY_SIZE-1,
if(wheel < 0)
{
- if(g_selected_item < max_item)
- g_selected_item++;
+ if(new_playeritem < max_item)
+ new_playeritem++;
else
- g_selected_item = 0;
+ new_playeritem = 0;
}
else if(wheel > 0)
{
- if(g_selected_item > 0)
- g_selected_item--;
+ if(new_playeritem > 0)
+ new_playeritem--;
else
- g_selected_item = max_item;
+ new_playeritem = max_item;
}
}
{
if(i < PLAYER_INVENTORY_SIZE && i < hotbar_itemcount)
{
- g_selected_item = i;
+ new_playeritem = i;
infostream<<"Selected item: "
- <<g_selected_item<<std::endl;
+ <<new_playeritem<<std::endl;
}
}
}
player->setPosition(player->getPosition() + v3f(0,-BS,0));
camera.update(player, busytime, screensize);*/
}
+ else if(event.type == CE_TEXTURES_UPDATED)
+ {
+ update_skybox(driver, tsrc, smgr, skybox, brightness);
+
+ update_wielded_item_trigger = true;
+ }
}
}
//timer2.stop();
//TimeTaker //timer3("//timer3");
+ /*
+ For interaction purposes, get info about the held item
+ - What item is it?
+ - Is it a usable item?
+ - Can it point to liquids?
+ */
+ ItemStack playeritem;
+ bool playeritem_usable = false;
+ bool playeritem_liquids_pointable = false;
+ {
+ InventoryList *mlist = local_inventory.getList("main");
+ if(mlist != NULL)
+ {
+ playeritem = mlist->getItem(client.getPlayerItem());
+ playeritem_usable = playeritem.getDefinition(itemdef).usable;
+ playeritem_liquids_pointable = playeritem.getDefinition(itemdef).liquids_pointable;
+ }
+ }
+
/*
Calculate what block is the crosshair pointing to
*/
//u32 t1 = device->getTimer()->getRealTime();
- //f32 d = 4; // max. distance
f32 d = 4; // max. distance
core::line3d<f32> shootline(camera_position,
camera_position + camera_direction * BS * (d+1));
- ClientActiveObject *selected_active_object
- = client.getSelectedActiveObject
- (d*BS, camera_position, shootline);
-
- bool left_punch = false;
- bool left_punch_muted = false;
+ core::aabbox3d<f32> hilightbox;
+ bool should_show_hilightbox = false;
+ ClientActiveObject *selected_object = NULL;
- if(selected_active_object != NULL)
- {
- /* Clear possible cracking animation */
- if(nodepos_old != v3s16(-32768,-32768,-32768))
- {
- client.clearTempMod(nodepos_old);
- dig_time = 0.0;
- nodepos_old = v3s16(-32768,-32768,-32768);
- }
-
- //infostream<<"Client returned selected_active_object != NULL"<<std::endl;
-
- core::aabbox3d<f32> *selection_box
- = selected_active_object->getSelectionBox();
- // Box should exist because object was returned in the
- // first place
- assert(selection_box);
+ 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);
- v3f pos = selected_active_object->getPosition();
-
- core::aabbox3d<f32> box_on_map(
- selection_box->MinEdge + pos,
- selection_box->MaxEdge + pos
- );
-
- if(selected_active_object->doShowSelectionBox())
- hilightboxes.push_back(box_on_map);
+ if(pointed != pointed_old)
+ {
+ infostream<<"Pointing at "<<pointed.dump()<<std::endl;
+ //dstream<<"Pointing at "<<pointed.dump()<<std::endl;
+ }
- //infotext = narrow_to_wide("A ClientActiveObject");
- infotext = narrow_to_wide(selected_active_object->infoText());
+ /*
+ Visualize selection
+ */
+ if(should_show_hilightbox)
+ hilightboxes.push_back(hilightbox);
- //if(input->getLeftClicked())
- if(input->getLeftState())
+ /*
+ Stop digging when
+ - releasing left mouse button
+ - pointing away from node
+ */
+ if(digging)
+ {
+ if(input->getLeftReleased())
{
- bool do_punch = false;
- bool do_punch_damage = false;
- if(object_hit_delay_timer <= 0.0){
- do_punch = true;
- do_punch_damage = true;
- object_hit_delay_timer = object_hit_delay;
- }
- if(input->getLeftClicked()){
- do_punch = true;
- }
- if(do_punch){
- infostream<<"Left-clicked object"<<std::endl;
- left_punch = true;
+ infostream<<"Left button released"
+ <<" (stopped digging)"<<std::endl;
+ digging = false;
+ }
+ else if(pointed != pointed_old)
+ {
+ if (pointed.type == POINTEDTHING_NODE
+ && pointed_old.type == POINTEDTHING_NODE
+ && pointed.node_undersurface == pointed_old.node_undersurface)
+ {
+ // Still pointing to the same node,
+ // but a different face. Don't reset.
}
- if(do_punch_damage){
- client.clickActiveObject(0,
- selected_active_object->getId(), g_selected_item);
+ else
+ {
+ infostream<<"Pointing away from node"
+ <<" (stopped digging)"<<std::endl;
+ digging = false;
}
}
- else if(input->getRightClicked())
+ if(!digging)
{
- infostream<<"Right-clicked object"<<std::endl;
- client.clickActiveObject(1,
- selected_active_object->getId(), g_selected_item);
+ client.interact(1, pointed_old);
+ client.clearTempMod(pointed_old.node_undersurface);
+ dig_time = 0.0;
}
}
- else // selected_object == NULL
+ if(!digging && ldown_for_dig && !input->getLeftState())
{
+ ldown_for_dig = false;
+ }
- /*
- Find out which node we are pointing at
- */
-
- bool nodefound = false;
- v3s16 nodepos;
- v3s16 neighbourpos;
- core::aabbox3d<f32> nodehilightbox;
-
- getPointedNode(&client, player_position,
- camera_direction, camera_position,
- nodefound, shootline,
- nodepos, neighbourpos,
- nodehilightbox, d);
-
- if(!nodefound){
- if(nodepos_old != v3s16(-32768,-32768,-32768))
- {
- client.clearTempMod(nodepos_old);
- dig_time = 0.0;
- nodepos_old = v3s16(-32768,-32768,-32768);
- }
- } else {
- /*
- Visualize selection
- */
+ bool left_punch = false;
+ bool left_punch_muted = false;
- hilightboxes.push_back(nodehilightbox);
+ if(playeritem_usable && input->getLeftState())
+ {
+ if(input->getLeftClicked())
+ client.interact(4, pointed);
+ }
+ else if(pointed.type == POINTEDTHING_NODE)
+ {
+ v3s16 nodepos = pointed.node_undersurface;
+ v3s16 neighbourpos = pointed.node_abovesurface;
/*
Check information text of node
{
infotext = narrow_to_wide(meta->infoText());
}
+ 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);
+ }
+ }
- //MapNode node = client.getNode(nodepos);
-
/*
Handle digging
*/
- if(input->getLeftReleased())
- {
- client.clearTempMod(nodepos);
- dig_time = 0.0;
- }
- if(nodig_delay_counter > 0.0)
+ if(nodig_delay_timer <= 0.0 && input->getLeftState())
{
- nodig_delay_counter -= dtime;
- }
- else
- {
- if(nodepos != nodepos_old)
+ if(!digging)
{
- infostream<<"Pointing at ("<<nodepos.X<<","
- <<nodepos.Y<<","<<nodepos.Z<<")"<<std::endl;
+ infostream<<"Started digging"<<std::endl;
+ client.interact(0, pointed);
+ digging = true;
+ ldown_for_dig = true;
+ }
+ MapNode n = client.getNode(nodepos);
- if(nodepos_old != v3s16(-32768,-32768,-32768))
- {
- client.clearTempMod(nodepos_old);
- dig_time = 0.0;
- nodepos_old = v3s16(-32768,-32768,-32768);
- }
+ // Get digging properties for material and tool
+ MaterialProperties mp = nodedef->get(n.getContent()).material;
+ ToolDiggingProperties tp =
+ playeritem.getToolDiggingProperties(itemdef);
+ DiggingProperties prop = getDiggingProperties(&mp, &tp);
+
+ float dig_time_complete = 0.0;
+
+ if(prop.diggable == false)
+ {
+ // I guess nobody will wait for this long
+ dig_time_complete = 10000000.0;
+ }
+ else
+ {
+ dig_time_complete = prop.time;
}
- if(input->getLeftClicked() ||
- (input->getLeftState() && nodepos != nodepos_old))
+ if(dig_time_complete >= 0.001)
{
- infostream<<"Started digging"<<std::endl;
- client.groundAction(0, nodepos, neighbourpos, g_selected_item);
+ dig_index = (u16)((float)CRACK_ANIMATION_LENGTH
+ * dig_time/dig_time_complete);
}
- if(input->getLeftClicked())
+ // This is for torches
+ else
{
- client.setTempMod(nodepos, NodeMod(NODEMOD_CRACK, 0));
+ dig_index = CRACK_ANIMATION_LENGTH;
}
- if(input->getLeftState())
+
+ if(dig_index < CRACK_ANIMATION_LENGTH)
{
- MapNode n = client.getNode(nodepos);
-
- // Get tool name. Default is "" = bare hands
- std::string toolname = "";
- InventoryList *mlist = local_inventory.getList("main");
- if(mlist != NULL)
- {
- InventoryItem *item = mlist->getItem(g_selected_item);
- if(item && (std::string)item->getName() == "ToolItem")
- {
- ToolItem *titem = (ToolItem*)item;
- toolname = titem->getToolName();
- }
- }
+ //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);
- // Get digging properties for material and tool
- content_t material = n.getContent();
- ToolDiggingProperties tp =
- tooldef->getDiggingProperties(toolname);
- DiggingProperties prop =
- getDiggingProperties(material, &tp, nodedef);
-
- float dig_time_complete = 0.0;
+ dig_time = 0;
+ digging = false;
- if(prop.diggable == false)
- {
- /*infostream<<"Material "<<(int)material
- <<" not diggable with \""
- <<toolname<<"\""<<std::endl;*/
- // I guess nobody will wait for this long
- dig_time_complete = 10000000.0;
- }
- else
- {
- dig_time_complete = prop.time;
- }
-
- if(dig_time_complete >= 0.001)
- {
- dig_index = (u16)((float)CRACK_ANIMATION_LENGTH
- * dig_time/dig_time_complete);
- }
- // This is for torches
- else
- {
- dig_index = CRACK_ANIMATION_LENGTH;
- }
+ nodig_delay_timer = dig_time_complete
+ / (float)CRACK_ANIMATION_LENGTH;
- if(dig_index < CRACK_ANIMATION_LENGTH)
+ // We don't want a corresponding delay to
+ // very time consuming nodes
+ if(nodig_delay_timer > 0.5)
{
- //TimeTaker timer("client.setTempMod");
- //infostream<<"dig_index="<<dig_index<<std::endl;
- client.setTempMod(nodepos, NodeMod(NODEMOD_CRACK, dig_index));
+ nodig_delay_timer = 0.5;
}
- else
+ // We want a slight delay to very little
+ // time consuming nodes
+ float mindelay = 0.15;
+ if(nodig_delay_timer < mindelay)
{
- infostream<<"Digging completed"<<std::endl;
- client.groundAction(3, nodepos, neighbourpos, g_selected_item);
- client.clearTempMod(nodepos);
- client.removeNode(nodepos);
-
- dig_time = 0;
-
- nodig_delay_counter = dig_time_complete
- / (float)CRACK_ANIMATION_LENGTH;
-
- // We don't want a corresponding delay to
- // very time consuming nodes
- if(nodig_delay_counter > 0.5)
- {
- nodig_delay_counter = 0.5;
- }
- // We want a slight delay to very little
- // time consuming nodes
- float mindelay = 0.15;
- if(nodig_delay_counter < mindelay)
- {
- nodig_delay_counter = mindelay;
- }
+ nodig_delay_timer = mindelay;
}
+ }
- dig_time += dtime;
+ dig_time += dtime;
- camera.setDigging(0); // left click animation
- }
+ camera.setDigging(0); // left click animation
}
-
-
+
if(input->getRightClicked())
{
infostream<<"Ground right-clicked"<<std::endl;
if(meta && meta->getInventoryDrawSpecString() != "" && !random_input)
{
infostream<<"Launching custom inventory view"<<std::endl;
- /*
- Construct the unique identification string of the node
- */
- std::string current_name;
- current_name += "nodemeta:";
- current_name += itos(nodepos.X);
- current_name += ",";
- current_name += itos(nodepos.Y);
- current_name += ",";
- current_name += itos(nodepos.Z);
+
+ InventoryLocation inventoryloc;
+ inventoryloc.setNodeMeta(nodepos);
+
/*
Create menu
*/
GUIInventoryMenu::makeDrawSpecArrayFromString(
draw_spec,
meta->getInventoryDrawSpecString(),
- current_name);
+ inventoryloc);
GUIInventoryMenu *menu =
new GUIInventoryMenu(guienv, guiroot, -1,
&g_menumgr, invsize,
- client.getInventoryContext(),
- &client, tsrc);
+ &client, gamedef);
menu->setDrawSpec(draw_spec);
menu->drop();
}
// Otherwise report right click to server
else
{
- client.groundAction(1, nodepos, neighbourpos, g_selected_item);
+ client.interact(3, pointed);
camera.setDigging(1); // right click animation
}
}
-
- nodepos_old = nodepos;
+ }
+ else if(pointed.type == POINTEDTHING_OBJECT)
+ {
+ infotext = narrow_to_wide(selected_object->infoText());
+
+ //if(input->getLeftClicked())
+ if(input->getLeftState())
+ {
+ bool do_punch = false;
+ bool do_punch_damage = false;
+ if(object_hit_delay_timer <= 0.0){
+ do_punch = true;
+ do_punch_damage = true;
+ object_hit_delay_timer = object_hit_delay;
+ }
+ if(input->getLeftClicked()){
+ do_punch = true;
+ }
+ if(do_punch){
+ infostream<<"Left-clicked object"<<std::endl;
+ left_punch = true;
+ }
+ if(do_punch_damage){
+ // Report direct punch
+ v3f objpos = selected_object->getPosition();
+ v3f dir = (objpos - player_position).normalize();
+
+ bool disable_send = selected_object->directReportPunch(playeritem.name, dir);
+ if(!disable_send)
+ client.interact(0, pointed);
+ }
+ }
+ else if(input->getRightClicked())
+ {
+ infostream<<"Right-clicked object"<<std::endl;
+ client.interact(3, pointed); // place
+ }
}
- } // selected_object == NULL
+ pointed_old = pointed;
if(left_punch || (input->getLeftClicked() && !left_punch_muted))
{
input->resetLeftClicked();
input->resetRightClicked();
-
- if(input->getLeftReleased())
- {
- infostream<<"Left button released (stopped digging)"
- <<std::endl;
- client.groundAction(2, v3s16(0,0,0), v3s16(0,0,0), 0);
- }
- if(input->getRightReleased())
- {
- //inostream<<DTIME<<"Right released"<<std::endl;
- // Nothing here
- }
-
+
input->resetLeftReleased();
input->resetRightReleased();
/*
Calculate stuff for drawing
*/
-
+
+ /*
+ Calculate general brightness
+ */
u32 daynight_ratio = client.getDayNightRatio();
- u8 l = decode_light((daynight_ratio * LIGHT_SUN) / 1000);
+ u8 light8 = decode_light((daynight_ratio * LIGHT_SUN) / 1000);
+ brightness = (float)light8/255.0;
video::SColor bgcolor = video::SColor(
255,
- bgcolor_bright.getRed() * l / 255,
- bgcolor_bright.getGreen() * l / 255,
- bgcolor_bright.getBlue() * l / 255);
- /*skycolor.getRed() * l / 255,
- skycolor.getGreen() * l / 255,
- skycolor.getBlue() * l / 255);*/
-
- float brightness = (float)l/255.0;
+ bgcolor_bright.getRed() * brightness,
+ bgcolor_bright.getGreen() * brightness,
+ bgcolor_bright.getBlue() * brightness);
+ /*skycolor.getRed() * brightness,
+ skycolor.getGreen() * brightness,
+ skycolor.getBlue() * brightness);*/
/*
Update skybox
*/
if(fabs(brightness - old_brightness) > 0.01)
- update_skybox(driver, smgr, skybox, brightness);
+ update_skybox(driver, tsrc, smgr, skybox, brightness);
/*
Update clouds
Get chat messages from client
*/
{
- // Get new messages
+ // 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
std::wstring message;
while(client.getChatMessage(message))
{
Inventory
*/
- static u16 old_selected_item = 65535;
- if(client.getLocalInventoryUpdated()
- || g_selected_item != old_selected_item)
+ if(client.getPlayerItem() != new_playeritem)
+ {
+ client.selectPlayerItem(new_playeritem);
+ }
+ if(client.getLocalInventoryUpdated())
{
- client.selectPlayerItem(g_selected_item);
- old_selected_item = g_selected_item;
//infostream<<"Updating local inventory"<<std::endl;
client.getLocalInventory(local_inventory);
-
+
+ update_wielded_item_trigger = true;
+ }
+ if(update_wielded_item_trigger)
+ {
+ update_wielded_item_trigger = false;
// Update wielded tool
InventoryList *mlist = local_inventory.getList("main");
- InventoryItem *item = NULL;
+ ItemStack item;
if(mlist != NULL)
- item = mlist->getItem(g_selected_item);
+ item = mlist->getItem(client.getPlayerItem());
camera.wield(item, gamedef);
}
- /*
- Send actions returned by the inventory menu
- */
- while(inventory_action_queue.size() != 0)
- {
- InventoryAction *a = inventory_action_queue.pop_front();
-
- client.sendInventoryAction(a);
- // Eat it
- delete a;
- }
-
/*
Drawing begins
*/
Draw hotbar
*/
{
- draw_hotbar(driver, font, tsrc,
+ draw_hotbar(driver, font, gamedef,
v2s32(displaycenter.X, screensize.Y),
hotbar_imagesize, hotbar_itemcount, &local_inventory,
- client.getHP());
+ client.getHP(), client.getPlayerItem());
}
/*
gui_shuttingdowntext->remove();*/
}
- delete tooldef;
+ } // Client scope (must be destructed before destructing *def and tsrc
+
delete tsrc;
+ delete nodedef;
+ delete itemdef;
}
projects / minetest.git / blobdiff