jni/src/cavegen.cpp \
jni/src/chat.cpp \
jni/src/client.cpp \
+ jni/src/clientenvironment.cpp \
jni/src/clientiface.cpp \
jni/src/clientmap.cpp \
jni/src/clientmedia.cpp \
jni/src/rollback_interface.cpp \
jni/src/serialization.cpp \
jni/src/server.cpp \
+ jni/src/serverenvironment.cpp \
jni/src/serverlist.cpp \
jni/src/serverobject.cpp \
jni/src/shader.cpp \
#include "settings.h"
#include "wieldmesh.h"
#include "noise.h" // easeCurve
-#include "gamedef.h"
#include "sound.h"
#include "event.h"
#include "profiler.h"
#include "nodedef.h"
Camera::Camera(scene::ISceneManager* smgr, MapDrawControl& draw_control,
- IGameDef *gamedef):
+ Client *client):
m_playernode(NULL),
m_headnode(NULL),
m_cameranode(NULL),
m_wieldnode(NULL),
m_draw_control(draw_control),
- m_gamedef(gamedef),
+ m_client(client),
m_camera_position(0,0,0),
m_camera_direction(0,0,0),
m_wieldmgr = smgr->createNewSceneManager();
m_wieldmgr->addCameraSceneNode();
m_wieldnode = new WieldMeshSceneNode(m_wieldmgr->getRootSceneNode(), m_wieldmgr, -1, false);
- m_wieldnode->setItem(ItemStack(), m_gamedef);
+ m_wieldnode->setItem(ItemStack(), m_client);
m_wieldnode->drop(); // m_wieldmgr grabbed it
/* TODO: Add a callback function so these can be updated when a setting
m_wield_change_timer = MYMIN(m_wield_change_timer + dtime, 0.125);
if (m_wield_change_timer >= 0 && was_under_zero)
- m_wieldnode->setItem(m_wield_item_next, m_gamedef);
+ m_wieldnode->setItem(m_wield_item_next, m_client);
if (m_view_bobbing_state != 0)
{
(was > 0.5f && m_view_bobbing_anim <= 0.5f));
if(step) {
MtEvent *e = new SimpleTriggerEvent("ViewBobbingStep");
- m_gamedef->event()->put(e);
+ m_client->event()->put(e);
}
}
}
if(m_digging_button == 0)
{
MtEvent *e = new SimpleTriggerEvent("CameraPunchLeft");
- m_gamedef->event()->put(e);
+ m_client->event()->put(e);
} else if(m_digging_button == 1) {
MtEvent *e = new SimpleTriggerEvent("CameraPunchRight");
- m_gamedef->event()->put(e);
+ m_client->event()->put(e);
}
}
}
my_cp.Y = m_camera_position.Y + (m_camera_direction.Y*-i);
// Prevent camera positioned inside nodes
- INodeDefManager *nodemgr = m_gamedef->ndef();
+ INodeDefManager *nodemgr = m_client->ndef();
MapNode n = c_env.getClientMap().getNodeNoEx(floatToInt(my_cp, BS));
const ContentFeatures& features = nodemgr->get(n);
if(features.walkable)
// Get FOV
f32 fov_degrees;
- if (player->getPlayerControl().zoom && m_gamedef->checkLocalPrivilege("zoom")) {
+ if (player->getPlayerControl().zoom && m_client->checkLocalPrivilege("zoom")) {
fov_degrees = m_cache_zoom_fov;
} else {
fov_degrees = m_cache_fov;
const bool climbing = movement_Y && player->is_climbing;
if ((walking || swimming || climbing) &&
m_cache_view_bobbing &&
- (!g_settings->getBool("free_move") || !m_gamedef->checkLocalPrivilege("fly")))
+ (!g_settings->getBool("free_move") || !m_client->checkLocalPrivilege("fly")))
{
// Start animation
m_view_bobbing_state = 1;
class LocalPlayer;
struct MapDrawControl;
-class IGameDef;
+class Client;
class WieldMeshSceneNode;
struct Nametag {
{
public:
Camera(scene::ISceneManager* smgr, MapDrawControl& draw_control,
- IGameDef *gamedef);
+ Client *client);
~Camera();
// Get player scene node.
// draw control
MapDrawControl& m_draw_control;
- IGameDef *m_gamedef;
+ Client *m_client;
video::IVideoDriver *m_driver;
// Absolute camera position
m_event(event),
m_mesh_update_thread(),
m_env(
- new ClientMap(this, this, control,
+ new ClientMap(this, control,
device->getSceneManager()->getRootSceneNode(),
device->getSceneManager(), 666),
device->getSceneManager(),
#include "localplayer.h"
#include "hud.h"
#include "particles.h"
-#include "network/networkpacket.h"
struct MeshMakeData;
class MapBlockMesh;
class Mapper;
struct MinimapMapblock;
class Camera;
+class NetworkPacket;
struct QueuedMeshUpdate
{
void ProcessData(NetworkPacket *pkt);
- // Returns true if something was received
- bool AsyncProcessPacket();
- bool AsyncProcessData();
void Send(NetworkPacket* pkt);
void interact(u8 action, const PointedThing& pointed);
void sendRespawn();
void sendReady();
- ClientEnvironment& getEnv()
- { return m_env; }
+ ClientEnvironment& getEnv() { return m_env; }
+ ITextureSource *tsrc() { return getTextureSource(); }
+ ISoundManager *sound() { return getSoundManager(); }
// Causes urgent mesh updates (unlike Map::add/removeNodeWithEvent)
void removeNode(v3s16 p);
virtual IItemDefManager* getItemDefManager();
virtual INodeDefManager* getNodeDefManager();
virtual ICraftDefManager* getCraftDefManager();
- virtual ITextureSource* getTextureSource();
+ ITextureSource* getTextureSource();
virtual IShaderSource* getShaderSource();
- virtual scene::ISceneManager* getSceneManager();
+ IShaderSource *shsrc() { return getShaderSource(); }
+ scene::ISceneManager* getSceneManager();
virtual u16 allocateUnknownNodeId(const std::string &name);
virtual ISoundManager* getSoundManager();
virtual MtEventManager* getEventManager();
virtual ParticleManager* getParticleManager();
- virtual bool checkLocalPrivilege(const std::string &priv)
+ bool checkLocalPrivilege(const std::string &priv)
{ return checkPrivilege(priv); }
virtual scene::IAnimatedMesh* getMesh(const std::string &filename);
*/
ClientEnvironment::ClientEnvironment(ClientMap *map, scene::ISceneManager *smgr,
- ITextureSource *texturesource, IGameDef *gamedef,
+ ITextureSource *texturesource, Client *client,
IrrlichtDevice *irr):
m_map(map),
m_local_player(NULL),
m_smgr(smgr),
m_texturesource(texturesource),
- m_gamedef(gamedef),
+ m_client(client),
m_irr(irr)
{
char zero = 0;
stepTimeOfDay(dtime);
// Get some settings
- bool fly_allowed = m_gamedef->checkLocalPrivilege("fly");
+ bool fly_allowed = m_client->checkLocalPrivilege("fly");
bool free_move = fly_allowed && g_settings->getBool("free_move");
// Get local player
f32 post_factor = 1; // 1 hp per node/s
if(info.type == COLLISION_NODE)
{
- const ContentFeatures &f = m_gamedef->ndef()->
+ const ContentFeatures &f = m_client->ndef()->
get(m_map->getNodeNoEx(info.node_p));
// Determine fall damage multiplier
int addp = itemgroup_get(f.groups, "fall_damage_add_percent");
if(damage != 0){
damageLocalPlayer(damage, true);
MtEvent *e = new SimpleTriggerEvent("PlayerFallingDamage");
- m_gamedef->event()->put(e);
+ m_client->event()->put(e);
}
}
}
u32 damage_per_second = 0;
damage_per_second = MYMAX(damage_per_second,
- m_gamedef->ndef()->get(n1).damage_per_second);
+ m_client->ndef()->get(n1).damage_per_second);
damage_per_second = MYMAX(damage_per_second,
- m_gamedef->ndef()->get(n2).damage_per_second);
+ m_client->ndef()->get(n2).damage_per_second);
damage_per_second = MYMAX(damage_per_second,
- m_gamedef->ndef()->get(n3).damage_per_second);
+ m_client->ndef()->get(n3).damage_per_second);
if(damage_per_second != 0)
{
}
// Protocol v29 make this behaviour obsolete
- if (((Client*) getGameDef())->getProtoVersion() < 29) {
+ if (getGameDef()->getProtoVersion() < 29) {
/*
Drowning
*/
// head
v3s16 p = floatToInt(pf + v3f(0, BS * 1.6, 0), BS);
MapNode n = m_map->getNodeNoEx(p);
- ContentFeatures c = m_gamedef->ndef()->get(n);
+ ContentFeatures c = m_client->ndef()->get(n);
u8 drowning_damage = c.drowning;
if (drowning_damage > 0 && lplayer->hp > 0) {
u16 breath = lplayer->getBreath();
// head
v3s16 p = floatToInt(pf + v3f(0, BS * 1.6, 0), BS);
MapNode n = m_map->getNodeNoEx(p);
- ContentFeatures c = m_gamedef->ndef()->get(n);
+ ContentFeatures c = m_client->ndef()->get(n);
if (!lplayer->hp) {
lplayer->setBreath(11);
} else if (c.drowning == 0) {
v3s16 p = lplayer->getLightPosition();
node_at_lplayer = m_map->getNodeNoEx(p);
- u16 light = getInteriorLight(node_at_lplayer, 0, m_gamedef->ndef());
+ u16 light = getInteriorLight(node_at_lplayer, 0, m_client->ndef());
u8 day = light & 0xff;
u8 night = (light >> 8) & 0xff;
finalColorBlend(lplayer->light_color, day, night, day_night_ratio);
v3s16 p = obj->getLightPosition();
MapNode n = m_map->getNodeNoEx(p, &pos_ok);
if (pos_ok)
- light = n.getLightBlend(day_night_ratio, m_gamedef->ndef());
+ light = n.getLightBlend(day_night_ratio, m_client->ndef());
else
light = blend_light(day_night_ratio, LIGHT_SUN, 0);
v3s16 p = object->getLightPosition();
MapNode n = m_map->getNodeNoEx(p, &pos_ok);
if (pos_ok)
- light = n.getLightBlend(getDayNightRatio(), m_gamedef->ndef());
+ light = n.getLightBlend(getDayNightRatio(), m_client->ndef());
else
light = blend_light(getDayNightRatio(), LIGHT_SUN, 0);
const std::string &init_data)
{
ClientActiveObject* obj =
- ClientActiveObject::create((ActiveObjectType) type, m_gamedef, this);
+ ClientActiveObject::create((ActiveObjectType) type, m_client, this);
if(obj == NULL)
{
infostream<<"ClientEnvironment::addActiveObject(): "
class ClientActiveObject;
class GenericCAO;
class LocalPlayer;
+struct PointedThing;
/*
The client-side environment.
{
public:
ClientEnvironment(ClientMap *map, scene::ISceneManager *smgr,
- ITextureSource *texturesource, IGameDef *gamedef,
+ ITextureSource *texturesource, Client *client,
IrrlichtDevice *device);
~ClientEnvironment();
Map & getMap();
ClientMap & getClientMap();
- IGameDef *getGameDef()
- { return m_gamedef; }
+ Client *getGameDef() { return m_client; }
void step(f32 dtime);
LocalPlayer *m_local_player;
scene::ISceneManager *m_smgr;
ITextureSource *m_texturesource;
- IGameDef *m_gamedef;
+ Client *m_client;
IrrlichtDevice *m_irr;
UNORDERED_MAP<u16, ClientActiveObject*> m_active_objects;
std::vector<ClientSimpleObject*> m_simple_objects;
ClientMap::ClientMap(
Client *client,
- IGameDef *gamedef,
MapDrawControl &control,
scene::ISceneNode* parent,
scene::ISceneManager* mgr,
s32 id
):
- Map(dout_client, gamedef),
+ Map(dout_client, client),
scene::ISceneNode(parent, mgr, id),
m_client(client),
m_control(control),
return false;
}
-void ClientMap::getBlocksInViewRange(v3s16 cam_pos_nodes,
+void ClientMap::getBlocksInViewRange(v3s16 cam_pos_nodes,
v3s16 *p_blocks_min, v3s16 *p_blocks_max)
{
v3s16 box_nodes_d = m_control.wanted_range * v3s16(1, 1, 1);
const ContentFeatures& features = m_nodedef->get(n);
video::SColor post_effect_color = features.post_effect_color;
if(features.solidness == 2 && !(g_settings->getBool("noclip") &&
- m_gamedef->checkLocalPrivilege("noclip")) &&
+ m_client->checkLocalPrivilege("noclip")) &&
cam_mode == CAMERA_MODE_FIRST)
{
post_effect_color = video::SColor(255, 0, 0, 0);
/*
ClientMap
-
+
This is the only map class that is able to render itself on screen.
*/
public:
ClientMap(
Client *client,
- IGameDef *gamedef,
MapDrawControl &control,
scene::ISceneNode* parent,
scene::ISceneManager* mgr,
driver->setTransform(video::ETS_WORLD, AbsoluteTransformation);
renderMap(driver, SceneManager->getSceneNodeRenderPass());
}
-
+
virtual const aabb3f &getBoundingBox() const
{
return m_box;
}
-
- void getBlocksInViewRange(v3s16 cam_pos_nodes,
+
+ void getBlocksInViewRange(v3s16 cam_pos_nodes,
v3s16 *p_blocks_min, v3s16 *p_blocks_max);
void updateDrawList(video::IVideoDriver* driver);
void renderMap(video::IVideoDriver* driver, s32 pass);
// For debug printing
virtual void PrintInfo(std::ostream &out);
-
- // Check if sector was drawn on last render()
- bool sectorWasDrawn(v2s16 p)
- {
- return (m_last_drawn_sectors.find(p) != m_last_drawn_sectors.end());
- }
const MapDrawControl & getControl() const { return m_control; }
f32 getCameraFov() const { return m_camera_fov; }
private:
Client *m_client;
-
+
aabb3f m_box;
-
+
MapDrawControl &m_control;
v3f m_camera_position;
v3s16 m_camera_offset;
std::map<v3s16, MapBlock*> m_drawlist;
-
+
std::set<v2s16> m_last_drawn_sectors;
bool m_cache_trilinear_filter;
#include "clientobject.h"
#include "debug.h"
#include "porting.h"
-#include "constants.h"
/*
ClientActiveObject
*/
-ClientActiveObject::ClientActiveObject(u16 id, IGameDef *gamedef,
+ClientActiveObject::ClientActiveObject(u16 id, Client *client,
ClientEnvironment *env):
ActiveObject(id),
- m_gamedef(gamedef),
+ m_client(client),
m_env(env)
{
}
}
ClientActiveObject* ClientActiveObject::create(ActiveObjectType type,
- IGameDef *gamedef, ClientEnvironment *env)
+ Client *client, ClientEnvironment *env)
{
// Find factory function
UNORDERED_MAP<u16, Factory>::iterator n = m_types.find(type);
}
Factory f = n->second;
- ClientActiveObject *object = (*f)(gamedef, env);
+ ClientActiveObject *object = (*f)(client, env);
return object;
}
#include <map>
#include "util/cpp11_container.h"
-/*
-
-Some planning
--------------
-
-* Client receives a network packet with information of added objects
- in it
-* Client supplies the information to its ClientEnvironment
-* The environment adds the specified objects to itself
-
-*/
-
class ClientEnvironment;
class ITextureSource;
+class Client;
class IGameDef;
class LocalPlayer;
struct ItemStack;
class ClientActiveObject : public ActiveObject
{
public:
- ClientActiveObject(u16 id, IGameDef *gamedef, ClientEnvironment *env);
+ ClientActiveObject(u16 id, Client *client, ClientEnvironment *env);
virtual ~ClientActiveObject();
virtual void addToScene(scene::ISceneManager *smgr, ITextureSource *tsrc,
virtual void initialize(const std::string &data){}
// Create a certain type of ClientActiveObject
- static ClientActiveObject* create(ActiveObjectType type, IGameDef *gamedef,
+ static ClientActiveObject* create(ActiveObjectType type, Client *client,
ClientEnvironment *env);
// If returns true, punch will not be sent to the server
protected:
// Used for creating objects based on type
- typedef ClientActiveObject* (*Factory)(IGameDef *gamedef, ClientEnvironment *env);
+ typedef ClientActiveObject* (*Factory)(Client *client, ClientEnvironment *env);
static void registerType(u16 type, Factory f);
- IGameDef *m_gamedef;
+ Client *m_client;
ClientEnvironment *m_env;
private:
// Used for creating objects based on type
#include "map.h"
#include "nodedef.h"
#include "gamedef.h"
+#ifndef SERVER
#include "clientenvironment.h"
+#endif
#include "serverenvironment.h"
#include "serverobject.h"
+#include "util/timetaker.h"
#include "profiler.h"
// float error is 10 - 9.96875 = 0.03125
#include "collision.h"
#include "settings.h"
#include "serialization.h" // For decompressZlib
-#include "gamedef.h"
#include "clientobject.h"
#include "mesh.h"
#include "itemdef.h"
class TestCAO : public ClientActiveObject
{
public:
- TestCAO(IGameDef *gamedef, ClientEnvironment *env);
+ TestCAO(Client *client, ClientEnvironment *env);
virtual ~TestCAO();
ActiveObjectType getType() const
return ACTIVEOBJECT_TYPE_TEST;
}
- static ClientActiveObject* create(IGameDef *gamedef, ClientEnvironment *env);
+ static ClientActiveObject* create(Client *client, ClientEnvironment *env);
void addToScene(scene::ISceneManager *smgr, ITextureSource *tsrc,
IrrlichtDevice *irr);
// Prototype
TestCAO proto_TestCAO(NULL, NULL);
-TestCAO::TestCAO(IGameDef *gamedef, ClientEnvironment *env):
- ClientActiveObject(0, gamedef, env),
+TestCAO::TestCAO(Client *client, ClientEnvironment *env):
+ ClientActiveObject(0, client, env),
m_node(NULL),
m_position(v3f(0,10*BS,0))
{
{
}
-ClientActiveObject* TestCAO::create(IGameDef *gamedef, ClientEnvironment *env)
+ClientActiveObject* TestCAO::create(Client *client, ClientEnvironment *env)
{
- return new TestCAO(gamedef, env);
+ return new TestCAO(client, env);
}
void TestCAO::addToScene(scene::ISceneManager *smgr, ITextureSource *tsrc,
class ItemCAO : public ClientActiveObject
{
public:
- ItemCAO(IGameDef *gamedef, ClientEnvironment *env);
+ ItemCAO(Client *client, ClientEnvironment *env);
virtual ~ItemCAO();
ActiveObjectType getType() const
return ACTIVEOBJECT_TYPE_ITEM;
}
- static ClientActiveObject* create(IGameDef *gamedef, ClientEnvironment *env);
+ static ClientActiveObject* create(Client *client, ClientEnvironment *env);
void addToScene(scene::ISceneManager *smgr, ITextureSource *tsrc,
IrrlichtDevice *irr);
// Prototype
ItemCAO proto_ItemCAO(NULL, NULL);
-ItemCAO::ItemCAO(IGameDef *gamedef, ClientEnvironment *env):
- ClientActiveObject(0, gamedef, env),
+ItemCAO::ItemCAO(Client *client, ClientEnvironment *env):
+ ClientActiveObject(0, client, env),
m_selection_box(-BS/3.,0.0,-BS/3., BS/3.,BS*2./3.,BS/3.),
m_node(NULL),
m_position(v3f(0,10*BS,0))
{
- if(!gamedef && !env)
+ if(!client && !env)
{
ClientActiveObject::registerType(getType(), create);
}
{
}
-ClientActiveObject* ItemCAO::create(IGameDef *gamedef, ClientEnvironment *env)
+ClientActiveObject* ItemCAO::create(Client *client, ClientEnvironment *env)
{
- return new ItemCAO(gamedef, env);
+ return new ItemCAO(client, env);
}
void ItemCAO::addToScene(scene::ISceneManager *smgr, ITextureSource *tsrc,
void ItemCAO::updateInfoText()
{
try{
- IItemDefManager *idef = m_gamedef->idef();
+ IItemDefManager *idef = m_client->idef();
ItemStack item;
item.deSerialize(m_itemstring, idef);
if(item.isKnown(idef))
std::istringstream is(m_itemstring, std::ios_base::binary);
video::ITexture *texture = NULL;
try{
- IItemDefManager *idef = m_gamedef->idef();
+ IItemDefManager *idef = m_client->idef();
ItemStack item;
item.deSerialize(is, idef);
- texture = idef->getInventoryTexture(item.getDefinition(idef).name, m_gamedef);
+ texture = idef->getInventoryTexture(item.getDefinition(idef).name, m_client);
}
catch(SerializationError &e)
{
#include "genericobject.h"
-GenericCAO::GenericCAO(IGameDef *gamedef, ClientEnvironment *env):
- ClientActiveObject(0, gamedef, env),
+GenericCAO::GenericCAO(Client *client, ClientEnvironment *env):
+ ClientActiveObject(0, client, env),
//
m_is_player(false),
m_is_local_player(false),
//
m_smgr(NULL),
m_irr(NULL),
- m_gamedef(NULL),
+ m_client(NULL),
m_selection_box(-BS/3.,-BS/3.,-BS/3., BS/3.,BS/3.,BS/3.),
m_meshnode(NULL),
m_animated_meshnode(NULL),
m_last_light(255),
m_is_visible(false)
{
- if (gamedef == NULL) {
+ if (client == NULL) {
ClientActiveObject::registerType(getType(), create);
} else {
- m_gamedef = gamedef;
+ m_client = client;
}
}
}
if (m_nametag) {
- m_gamedef->getCamera()->removeNametag(m_nametag);
+ m_client->getCamera()->removeNametag(m_nametag);
m_nametag = NULL;
}
}
}
else if(m_prop.visual == "mesh") {
infostream<<"GenericCAO::addToScene(): mesh"<<std::endl;
- scene::IAnimatedMesh *mesh = m_gamedef->getMesh(m_prop.mesh);
+ scene::IAnimatedMesh *mesh = m_client->getMesh(m_prop.mesh);
if(mesh)
{
m_animated_meshnode = smgr->addAnimatedMeshSceneNode(mesh, NULL);
infostream<<"textures: "<<m_prop.textures.size()<<std::endl;
if(m_prop.textures.size() >= 1){
infostream<<"textures[0]: "<<m_prop.textures[0]<<std::endl;
- IItemDefManager *idef = m_gamedef->idef();
+ IItemDefManager *idef = m_client->idef();
ItemStack item(m_prop.textures[0], 1, 0, "", idef);
m_wield_meshnode = new WieldMeshSceneNode(
smgr->getRootSceneNode(), smgr, -1);
- m_wield_meshnode->setItem(item, m_gamedef);
+ m_wield_meshnode->setItem(item, m_client);
m_wield_meshnode->setScale(v3f(m_prop.visual_size.X/2,
m_prop.visual_size.Y/2,
scene::ISceneNode *node = getSceneNode();
if (node && m_prop.nametag != "" && !m_is_local_player) {
// Add nametag
- m_nametag = m_gamedef->getCamera()->addNametag(node,
+ m_nametag = m_client->getCamera()->addNametag(node,
m_prop.nametag, m_prop.nametag_color);
}
// increase speed if using fast or flying fast
if((g_settings->getBool("fast_move") &&
- m_gamedef->checkLocalPrivilege("fast")) &&
+ m_client->checkLocalPrivilege("fast")) &&
(controls.aux1 ||
(!player->touching_ground &&
g_settings->getBool("free_move") &&
- m_gamedef->checkLocalPrivilege("fly"))))
+ m_client->checkLocalPrivilege("fly"))))
new_speed *= 1.5;
// slowdown speed if sneeking
if(controls.sneak && walking)
}
removeFromScene(false);
- addToScene(m_smgr, m_gamedef->tsrc(), m_irr);
+ addToScene(m_smgr, m_client->tsrc(), m_irr);
// Attachments, part 2: Now that the parent has been refreshed, put its attachments back
for (std::vector<u16>::size_type i = 0; i < m_children.size(); i++) {
m_step_distance_counter = 0;
if(!m_is_local_player && m_prop.makes_footstep_sound)
{
- INodeDefManager *ndef = m_gamedef->ndef();
+ INodeDefManager *ndef = m_client->ndef();
v3s16 p = floatToInt(getPosition() + v3f(0,
(m_prop.collisionbox.MinEdge.Y-0.5)*BS, 0), BS);
MapNode n = m_env->getMap().getNodeNoEx(p);
SimpleSoundSpec spec = ndef->get(n).sound_footstep;
- m_gamedef->sound()->playSoundAt(spec, false, getPosition());
+ m_client->sound()->playSoundAt(spec, false, getPosition());
}
}
}
void GenericCAO::updateTextures(const std::string &mod)
{
- ITextureSource *tsrc = m_gamedef->tsrc();
+ ITextureSource *tsrc = m_client->tsrc();
bool use_trilinear_filter = g_settings->getBool("trilinear_filter");
bool use_bilinear_filter = g_settings->getBool("bilinear_filter");
{
assert(punchitem); // pre-condition
const ToolCapabilities *toolcap =
- &punchitem->getToolCapabilities(m_gamedef->idef());
+ &punchitem->getToolCapabilities(m_client->idef());
PunchDamageResult result = getPunchDamage(
m_armor_groups,
toolcap,
#include "itemgroup.h"
class Camera;
+class Client;
struct Nametag;
/*
//
scene::ISceneManager *m_smgr;
IrrlichtDevice *m_irr;
- IGameDef *m_gamedef;
+ Client *m_client;
aabb3f m_selection_box;
scene::IMeshSceneNode *m_meshnode;
scene::IAnimatedMeshSceneNode *m_animated_meshnode;
std::vector<u16> m_children;
public:
- GenericCAO(IGameDef *gamedef, ClientEnvironment *env);
+ GenericCAO(Client *client, ClientEnvironment *env);
~GenericCAO();
- static ClientActiveObject* create(IGameDef *gamedef, ClientEnvironment *env)
+ static ClientActiveObject* create(Client *client, ClientEnvironment *env)
{
- return new GenericCAO(gamedef, env);
+ return new GenericCAO(client, env);
}
inline ActiveObjectType getType() const
#include <IBillboardSceneNode.h>
#include "client/tile.h"
#include "clientenvironment.h"
-#include "gamedef.h"
+#include "client.h"
#include "map.h"
-/*
-static void setBillboardTextureMatrix(scene::IBillboardSceneNode *bill,
- float txs, float tys, int col, int row)
-{
- video::SMaterial& material = bill->getMaterial(0);
- core::matrix4& matrix = material.getTextureMatrix(0);
- matrix.setTextureTranslate(txs*col, tys*row);
- matrix.setTextureScale(txs, tys);
-}
-*/
-
class SmokePuffCSO: public ClientSimpleObject
{
float m_age;
#include "client/tile.h"
#include "mesh.h"
#include <IMeshManipulator.h>
-#include "gamedef.h"
+#include "client.h"
#include "log.h"
#include "noise.h"
void mapblock_mesh_generate_special(MeshMakeData *data,
MeshCollector &collector)
{
- INodeDefManager *nodedef = data->m_gamedef->ndef();
- scene::ISceneManager* smgr = data->m_gamedef->getSceneManager();
+ INodeDefManager *nodedef = data->m_client->ndef();
+ scene::ISceneManager* smgr = data->m_client->getSceneManager();
scene::IMeshManipulator* meshmanip = smgr->getMeshManipulator();
// 0ms
v3f p_pos = m_base_position;
v3f p_velocity = m_velocity;
v3f p_acceleration = m_acceleration;
- moveresult = collisionMoveSimple(m_env,m_env->getGameDef(),
+ moveresult = collisionMoveSimple(m_env, m_env->getGameDef(),
pos_max_d, box, m_prop.stepheight, dtime,
&p_pos, &p_velocity, p_acceleration,
this, m_prop.collideWithObjects);
// get head position
v3s16 p = floatToInt(m_base_position + v3f(0, BS * 1.6, 0), BS);
MapNode n = m_env->getMap().getNodeNoEx(p);
- const ContentFeatures &c = ((Server*) m_env->getGameDef())->ndef()->get(n);
+ const ContentFeatures &c = m_env->getGameDef()->ndef()->get(n);
// If node generates drown
if (c.drowning > 0) {
if (m_hp > 0 && m_breath > 0)
// No more breath, damage player
if (m_breath == 0) {
setHP(m_hp - c.drowning);
- ((Server*) m_env->getGameDef())->SendPlayerHPOrDie(this);
+ m_env->getGameDef()->SendPlayerHPOrDie(this);
}
}
}
// get head position
v3s16 p = floatToInt(m_base_position + v3f(0, BS * 1.6, 0), BS);
MapNode n = m_env->getMap().getNodeNoEx(p);
- const ContentFeatures &c = ((Server*) m_env->getGameDef())->ndef()->get(n);
+ const ContentFeatures &c = m_env->getGameDef()->ndef()->get(n);
// If player is alive & no drowning, breath
if (m_hp > 0 && c.drowning == 0)
setBreath(m_breath + 1);
m_attachment_position = v3f(0,0,0);
m_attachment_rotation = v3f(0,0,0);
setBasePosition(m_last_good_position);
- ((Server*)m_env->getGameDef())->SendMovePlayer(m_peer_id);
+ m_env->getGameDef()->SendMovePlayer(m_peer_id);
}
//dstream<<"PlayerSAO::step: dtime: "<<dtime<<std::endl;
setBasePosition(pos);
// Movement caused by this command is always valid
m_last_good_position = pos;
- ((Server*)m_env->getGameDef())->SendMovePlayer(m_peer_id);
+ m_env->getGameDef()->SendMovePlayer(m_peer_id);
}
void PlayerSAO::moveTo(v3f pos, bool continuous)
setBasePosition(pos);
// Movement caused by this command is always valid
m_last_good_position = pos;
- ((Server*)m_env->getGameDef())->SendMovePlayer(m_peer_id);
+ m_env->getGameDef()->SendMovePlayer(m_peer_id);
}
void PlayerSAO::setYaw(const float yaw)
void PlayerSAO::setYawAndSend(const float yaw)
{
setYaw(yaw);
- ((Server*)m_env->getGameDef())->SendMovePlayer(m_peer_id);
+ m_env->getGameDef()->SendMovePlayer(m_peer_id);
}
void PlayerSAO::setPitch(const float pitch)
void PlayerSAO::setPitchAndSend(const float pitch)
{
setPitch(pitch);
- ((Server*)m_env->getGameDef())->SendMovePlayer(m_peer_id);
+ m_env->getGameDef()->SendMovePlayer(m_peer_id);
}
int PlayerSAO::punch(v3f dir,
m_breath = MYMIN(breath, PLAYER_MAX_BREATH);
if (send)
- ((Server *) m_env->getGameDef())->SendPlayerBreath(this);
+ m_env->getGameDef()->SendPlayerBreath(this);
}
void PlayerSAO::setArmorGroups(const ItemGroupList &armor_groups)
//// EmergeManager
////
-EmergeManager::EmergeManager(IGameDef *gamedef)
+EmergeManager::EmergeManager(Server *server)
{
- this->ndef = gamedef->getNodeDefManager();
- this->biomemgr = new BiomeManager(gamedef);
- this->oremgr = new OreManager(gamedef);
- this->decomgr = new DecorationManager(gamedef);
- this->schemmgr = new SchematicManager(gamedef);
+ this->ndef = server->getNodeDefManager();
+ this->biomemgr = new BiomeManager(server);
+ this->oremgr = new OreManager(server);
+ this->decomgr = new DecorationManager(server);
+ this->schemmgr = new SchematicManager(server);
this->gen_notify_on = 0;
// Note that accesses to this variable are not synchronized.
m_qlimit_generate = 1;
for (s16 i = 0; i < nthreads; i++)
- m_threads.push_back(new EmergeThread((Server *)gamedef, i));
+ m_threads.push_back(new EmergeThread(server, i));
infostream << "EmergeManager: using " << nthreads << " threads" << std::endl;
}
class OreManager;
class DecorationManager;
class SchematicManager;
+class Server;
// Structure containing inputs/outputs for chunk generation
struct BlockMakeData {
SchematicManager *schemmgr;
// Methods
- EmergeManager(IGameDef *gamedef);
+ EmergeManager(Server *server);
~EmergeManager();
bool initMapgens(MapgenParams *mgparams);
#include "threading/atomic.h"
#include "network/networkprotocol.h" // for AccessDeniedCode
-class ITextureSource;
-class IGameDef;
-class Map;
-class GameScripting;
-class Player;
-class PointedThing;
-
class Environment
{
public:
}
static inline void create_formspec_menu(GUIFormSpecMenu **cur_formspec,
- InventoryManager *invmgr, IGameDef *gamedef,
- IWritableTextureSource *tsrc, IrrlichtDevice *device,
- JoystickController *joystick,
- IFormSource *fs_src, TextDest *txt_dest, Client *client)
+ Client *client, IrrlichtDevice *device, JoystickController *joystick,
+ IFormSource *fs_src, TextDest *txt_dest)
{
if (*cur_formspec == 0) {
*cur_formspec = new GUIFormSpecMenu(device, joystick,
- guiroot, -1, &g_menumgr, invmgr, gamedef, tsrc,
- fs_src, txt_dest, client);
+ guiroot, -1, &g_menumgr, client, client->getTextureSource(),
+ fs_src, txt_dest);
(*cur_formspec)->doPause = false;
/*
#endif
static void show_deathscreen(GUIFormSpecMenu **cur_formspec,
- InventoryManager *invmgr, IGameDef *gamedef,
+ Client *client,
IWritableTextureSource *tsrc, IrrlichtDevice *device,
- JoystickController *joystick, Client *client)
+ JoystickController *joystick)
{
std::string formspec =
std::string(FORMSPEC_VERSION_STRING) +
FormspecFormSource *fs_src = new FormspecFormSource(formspec);
LocalFormspecHandler *txt_dst = new LocalFormspecHandler("MT_DEATH_SCREEN", client);
- create_formspec_menu(cur_formspec, invmgr, gamedef, tsrc, device,
- joystick, fs_src, txt_dst, NULL);
+ create_formspec_menu(cur_formspec, client, device, joystick, fs_src, txt_dst);
}
/******************************************************************************/
static void show_pause_menu(GUIFormSpecMenu **cur_formspec,
- InventoryManager *invmgr, IGameDef *gamedef,
+ Client *client,
IWritableTextureSource *tsrc, IrrlichtDevice *device,
JoystickController *joystick, bool singleplayermode)
{
FormspecFormSource *fs_src = new FormspecFormSource(os.str());
LocalFormspecHandler *txt_dst = new LocalFormspecHandler("MT_PAUSE_MENU");
- create_formspec_menu(cur_formspec, invmgr, gamedef, tsrc, device,
- joystick, fs_src, txt_dst, NULL);
+ create_formspec_menu(cur_formspec, client, device, joystick, fs_src, txt_dst);
std::string con("btn_continue");
(*cur_formspec)->setFocus(con);
(*cur_formspec)->doPause = true;
bool *kill;
std::string *error_message;
bool *reconnect_requested;
- IGameDef *gamedef; // Convenience (same as *client)
scene::ISceneNode *skybox;
bool random_input;
/* Camera
*/
- camera = new Camera(smgr, *draw_control, gamedef);
+ camera = new Camera(smgr, *draw_control, client);
if (!camera || !camera->successfullyCreated(*error_message))
return false;
client->setCamera(camera);
player->hurt_tilt_timer = 0;
player->hurt_tilt_strength = 0;
- hud = new Hud(driver, smgr, guienv, gamedef, player, local_inventory);
+ hud = new Hud(driver, smgr, guienv, client, player, local_inventory);
if (!hud) {
*error_message = "Memory error: could not create HUD";
if (!client)
return false;
- gamedef = client; // Client acts as our GameDef
-
infostream << "Connecting to server at ";
connect_address.print(&infostream);
infostream << std::endl;
void Game::processQueues()
{
texture_src->processQueue();
- itemdef_manager->processQueue(gamedef);
+ itemdef_manager->processQueue(client);
shader_src->processQueue();
}
openInventory();
} else if (wasKeyDown(KeyType::ESC) || input->wasKeyDown(CancelKey)) {
if (!gui_chat_console->isOpenInhibited()) {
- show_pause_menu(¤t_formspec, client, gamedef,
+ show_pause_menu(¤t_formspec, client,
texture_src, device, &input->joystick,
simple_singleplayer_mode);
}
PlayerInventoryFormSource *fs_src = new PlayerInventoryFormSource(client);
TextDest *txt_dst = new TextDestPlayerInventory(client);
- create_formspec_menu(¤t_formspec, client, gamedef, texture_src,
- device, &input->joystick, fs_src, txt_dst, client);
+ create_formspec_menu(¤t_formspec, client, device, &input->joystick, fs_src, txt_dst);
cur_formname = "";
InventoryLocation inventoryloc;
rangelim(event.player_damage.amount / 4, 1.0, 4.0);
MtEvent *e = new SimpleTriggerEvent("PlayerDamage");
- gamedef->event()->put(e);
+ client->event()->put(e);
} else if (event.type == CE_PLAYER_FORCE_MOVE) {
cam->camera_yaw = event.player_force_move.yaw;
cam->camera_pitch = event.player_force_move.pitch;
} else if (event.type == CE_DEATHSCREEN) {
- show_deathscreen(¤t_formspec, client, gamedef, texture_src,
- device, &input->joystick, client);
+ show_deathscreen(¤t_formspec, client, texture_src,
+ device, &input->joystick);
chat_backend->addMessage(L"", L"You died.");
TextDestPlayerInventory *txt_dst =
new TextDestPlayerInventory(client, *(event.show_formspec.formname));
- create_formspec_menu(¤t_formspec, client, gamedef,
- texture_src, device, &input->joystick,
- fs_src, txt_dst, client);
+ create_formspec_menu(¤t_formspec, client, device, &input->joystick,
+ fs_src, txt_dst);
cur_formname = *(event.show_formspec.formname);
}
} else if ((event.type == CE_SPAWN_PARTICLE) ||
(event.type == CE_ADD_PARTICLESPAWNER) ||
(event.type == CE_DELETE_PARTICLESPAWNER)) {
- client->getParticleManager()->handleParticleEvent(&event, gamedef,
+ client->getParticleManager()->handleParticleEvent(&event, client,
smgr, player);
} else if (event.type == CE_HUDADD) {
u32 id = event.hudadd.id;
&client->getEnv().getClientMap(), nodepos);
TextDest *txt_dst = new TextDestNodeMetadata(nodepos, client);
- create_formspec_menu(¤t_formspec, client, gamedef,
- texture_src, device, &input->joystick, fs_src, txt_dst, client);
+ create_formspec_menu(¤t_formspec, client,
+ device, &input->joystick, fs_src, txt_dst);
cur_formname = "";
current_formspec->setFormSpec(meta->getString("formspec"), inventoryloc);
if (m_cache_enable_particles) {
const ContentFeatures &features =
client->getNodeDefManager()->get(n);
- client->getParticleManager()->addPunchingParticles(gamedef, smgr,
+ client->getParticleManager()->addPunchingParticles(client, smgr,
player, nodepos, features.tiles);
}
}
if (m_cache_enable_particles) {
const ContentFeatures &features =
client->getNodeDefManager()->get(wasnode);
- client->getParticleManager()->addDiggingParticles(gamedef, smgr,
+ client->getParticleManager()->addDiggingParticles(client, smgr,
player, nodepos, features.tiles);
}
// Send event to trigger sound
MtEvent *e = new NodeDugEvent(nodepos, wasnode);
- gamedef->event()->put(e);
+ client->event()->put(e);
}
if (runData->dig_time_complete < 100000.0) {
virtual INodeDefManager* getNodeDefManager()=0;
virtual ICraftDefManager* getCraftDefManager()=0;
- // This is always thread-safe, but referencing the irrlicht texture
- // pointers in other threads than main thread will make things explode.
- virtual ITextureSource* getTextureSource()=0;
-
- virtual IShaderSource* getShaderSource()=0;
-
// Used for keeping track of names/ids of unknown nodes
virtual u16 allocateUnknownNodeId(const std::string &name)=0;
- // Only usable on the client
- virtual ISoundManager* getSoundManager()=0;
virtual MtEventManager* getEventManager()=0;
- virtual scene::IAnimatedMesh* getMesh(const std::string &filename)
- { return NULL; }
- virtual scene::ISceneManager* getSceneManager()=0;
-
- virtual Camera* getCamera()
- { return NULL; }
- virtual void setCamera(Camera *camera) {}
// Only usable on the server, and NOT thread-safe. It is usable from the
// environment thread.
- virtual IRollbackManager* getRollbackManager(){return NULL;}
-
- // Only usable on the server. Thread safe if not written while running threads.
- virtual EmergeManager *getEmergeManager() { return NULL; }
-
- // Used on the client
- virtual bool checkLocalPrivilege(const std::string &priv)
- { return false; }
+ virtual IRollbackManager* getRollbackManager() { return NULL; }
// Shorthands
IItemDefManager *idef() { return getItemDefManager(); }
INodeDefManager *ndef() { return getNodeDefManager(); }
ICraftDefManager *cdef() { return getCraftDefManager(); }
- ITextureSource *tsrc() { return getTextureSource(); }
- ISoundManager *sound() { return getSoundManager(); }
- IShaderSource *shsrc() { return getShaderSource(); }
+
MtEventManager *event() { return getEventManager(); }
IRollbackManager *rollback() { return getRollbackManager();}
- EmergeManager *emerge() { return getEmergeManager(); }
};
#endif
-1,
m_menumanager,
NULL /* &client */,
- NULL /* gamedef */,
m_texture_source,
m_formspecgui,
m_buttonhandler,
- NULL,
false);
m_menu->allowClose(false);
GUIFormSpecMenu::GUIFormSpecMenu(irr::IrrlichtDevice* dev,
JoystickController *joystick,
gui::IGUIElement* parent, s32 id, IMenuManager *menumgr,
- InventoryManager *invmgr, IGameDef *gamedef,
+ Client *client,
ISimpleTextureSource *tsrc, IFormSource* fsrc, TextDest* tdst,
- Client* client, bool remap_dbl_click) :
+ bool remap_dbl_click) :
GUIModalMenu(dev->getGUIEnvironment(), parent, id, menumgr),
m_device(dev),
- m_invmgr(invmgr),
- m_gamedef(gamedef),
+ m_invmgr(client),
m_tsrc(tsrc),
m_client(client),
m_selected_item(NULL),
void GUIFormSpecMenu::parseList(parserData* data,std::string element)
{
- if (m_gamedef == 0) {
- warningstream<<"invalid use of 'list' with m_gamedef==0"<<std::endl;
+ if (m_client == 0) {
+ warningstream<<"invalid use of 'list' with m_client==0"<<std::endl;
return;
}
void GUIFormSpecMenu::parseListRing(parserData* data, std::string element)
{
- if (m_gamedef == 0) {
- errorstream << "WARNING: invalid use of 'listring' with m_gamedef==0" << std::endl;
+ if (m_client == 0) {
+ errorstream << "WARNING: invalid use of 'listring' with m_client==0" << std::endl;
return;
}
void GUIFormSpecMenu::parseItemImageButton(parserData* data,std::string element)
{
- if (m_gamedef == 0) {
- warningstream << "invalid use of item_image_button with m_gamedef==0"
+ if (m_client == 0) {
+ warningstream << "invalid use of item_image_button with m_client==0"
<< std::endl;
return;
}
if(!data->explicit_size)
warningstream<<"invalid use of item_image_button without a size[] element"<<std::endl;
- IItemDefManager *idef = m_gamedef->idef();
+ IItemDefManager *idef = m_client->idef();
ItemStack item;
item.deSerialize(item_name, idef);
if(!item.empty())
{
drawItemStack(driver, m_font, item,
- rect, &AbsoluteClippingRect, m_gamedef,
+ rect, &AbsoluteClippingRect, m_client,
rotation_kind);
}
// Draw tooltip
std::wstring tooltip_text = L"";
if (hovering && !m_selected_item) {
- tooltip_text = utf8_to_wide(item.getDefinition(m_gamedef->idef()).description);
+ tooltip_text = utf8_to_wide(item.getDefinition(m_client->idef()).description);
}
if (tooltip_text != L"") {
std::vector<std::wstring> tt_rows = str_split(tooltip_text, L'\n');
if (!m_selected_item) {
drawItemStack(driver, m_font, ItemStack(),
core::rect<s32>(v2s32(0, 0), v2s32(0, 0)),
- NULL, m_gamedef, IT_ROT_DRAGGED);
+ NULL, m_client, IT_ROT_DRAGGED);
return;
}
core::rect<s32> imgrect(0,0,imgsize.X,imgsize.Y);
core::rect<s32> rect = imgrect + (m_pointer - imgrect.getCenter());
rect.constrainTo(driver->getViewPort());
- drawItemStack(driver, m_font, stack, rect, NULL, m_gamedef, IT_ROT_DRAGGED);
+ drawItemStack(driver, m_font, stack, rect, NULL, m_client, IT_ROT_DRAGGED);
}
void GUIFormSpecMenu::drawMenu()
*/
for(u32 i=0; i<m_itemimages.size(); i++)
{
- if (m_gamedef == 0)
+ if (m_client == 0)
break;
const ImageDrawSpec &spec = m_itemimages[i];
- IItemDefManager *idef = m_gamedef->idef();
+ IItemDefManager *idef = m_client->idef();
ItemStack item;
item.deSerialize(spec.item_name, idef);
core::rect<s32> imgrect(0, 0, spec.geom.X, spec.geom.Y);
#endif
}
drawItemStack(driver, m_font, item, rect, &AbsoluteClippingRect,
- m_gamedef, IT_ROT_NONE);
+ m_client, IT_ROT_NONE);
}
/*
if (!item_hovered) {
drawItemStack(driver, m_font, ItemStack(),
core::rect<s32>(v2s32(0, 0), v2s32(0, 0)),
- NULL, m_gamedef, IT_ROT_HOVERED);
+ NULL, m_client, IT_ROT_HOVERED);
}
/* TODO find way to show tooltips on touchscreen */
// Check how many items can be moved
move_amount = stack_from.count = MYMIN(move_amount, stack_from.count);
- ItemStack leftover = stack_to.addItem(stack_from, m_gamedef->idef());
+ ItemStack leftover = stack_to.addItem(stack_from, m_client->idef());
// If source stack cannot be added to destination stack at all,
// they are swapped
if ((leftover.count == stack_from.count) &&
#include "util/string.h"
#include "util/enriched_string.h"
-class IGameDef;
class InventoryManager;
class ISimpleTextureSource;
class Client;
JoystickController *joystick,
gui::IGUIElement* parent, s32 id,
IMenuManager *menumgr,
- InventoryManager *invmgr,
- IGameDef *gamedef,
+ Client *client,
ISimpleTextureSource *tsrc,
IFormSource* fs_src,
TextDest* txt_dst,
- Client* client,
bool remap_dbl_click = true);
~GUIFormSpecMenu();
irr::IrrlichtDevice* m_device;
InventoryManager *m_invmgr;
- IGameDef *m_gamedef;
ISimpleTextureSource *m_tsrc;
Client *m_client;
#include "hud.h"
#include "settings.h"
#include "util/numeric.h"
-#include "util/string.h"
#include "log.h"
-#include "gamedef.h"
-#include "itemdef.h"
+#include "client.h"
#include "inventory.h"
#include "client/tile.h"
#include "localplayer.h"
#endif
Hud::Hud(video::IVideoDriver *driver, scene::ISceneManager* smgr,
- gui::IGUIEnvironment* guienv, IGameDef *gamedef, LocalPlayer *player,
+ gui::IGUIEnvironment* guienv, Client *client, LocalPlayer *player,
Inventory *inventory)
{
this->driver = driver;
this->smgr = smgr;
this->guienv = guienv;
- this->gamedef = gamedef;
+ this->client = client;
this->player = player;
this->inventory = inventory;
for (unsigned int i = 0; i < 4; i++)
hbar_colors[i] = video::SColor(255, 255, 255, 255);
- tsrc = gamedef->getTextureSource();
+ tsrc = client->getTextureSource();
v3f crosshair_color = g_settings->getV3F("crosshair_color");
u32 cross_r = rangelim(myround(crosshair_color.X), 0, 255);
m_selection_material.Lighting = false;
if (g_settings->getBool("enable_shaders")) {
- IShaderSource *shdrsrc = gamedef->getShaderSource();
+ IShaderSource *shdrsrc = client->getShaderSource();
u16 shader_id = shdrsrc->getShader(
mode == "halo" ? "selection_shader" : "default_shader", 1, 1);
m_selection_material.MaterialType = shdrsrc->getShaderInfo(shader_id).material;
if (!use_hotbar_image)
driver->draw2DRectangle(bgcolor2, rect, NULL);
drawItemStack(driver, g_fontengine->getFont(), item, rect, NULL,
- gamedef, selected ? IT_ROT_SELECTED : IT_ROT_NONE);
+ client, selected ? IT_ROT_SELECTED : IT_ROT_NONE);
}
//NOTE: selectitem = 0 -> no selected; selectitem 1-based
const ItemStack &item,
const core::rect<s32> &rect,
const core::rect<s32> *clip,
- IGameDef *gamedef,
+ Client *client,
ItemRotationKind rotation_kind)
{
static MeshTimeInfo rotation_time_infos[IT_ROT_NONE];
return;
}
- const ItemDefinition &def = item.getDefinition(gamedef->idef());
- scene::IMesh* mesh = gamedef->idef()->getWieldMesh(def.name, gamedef);
+ const ItemDefinition &def = item.getDefinition(client->idef());
+ scene::IMesh* mesh = client->idef()->getWieldMesh(def.name, client);
if (mesh) {
driver->clearZBuffer();
#include <IGUIFont.h>
#include "irr_aabb3d.h"
-class IGameDef;
+class Client;
class ITextureSource;
class Inventory;
class InventoryList;
video::IVideoDriver *driver;
scene::ISceneManager* smgr;
gui::IGUIEnvironment *guienv;
- IGameDef *gamedef;
+ Client *client;
LocalPlayer *player;
Inventory *inventory;
ITextureSource *tsrc;
bool use_hotbar_selected_image;
Hud(video::IVideoDriver *driver,scene::ISceneManager* smgr,
- gui::IGUIEnvironment* guienv, IGameDef *gamedef, LocalPlayer *player,
+ gui::IGUIEnvironment* guienv, Client *client, LocalPlayer *player,
Inventory *inventory);
~Hud();
const ItemStack &item,
const core::rect<s32> &rect,
const core::rect<s32> *clip,
- IGameDef *gamedef,
+ Client *client,
ItemRotationKind rotation_kind);
#endif
#include "itemdef.h"
-#include "gamedef.h"
#include "nodedef.h"
#include "tool.h"
#include "inventory.h"
#include "mesh.h"
#include "wieldmesh.h"
#include "client/tile.h"
+#include "client.h"
#endif
#include "log.h"
#include "settings.h"
#ifndef SERVER
public:
ClientCached* createClientCachedDirect(const std::string &name,
- IGameDef *gamedef) const
+ Client *client) const
{
infostream<<"Lazily creating item texture and mesh for \""
<<name<<"\""<<std::endl;
if(cc)
return cc;
- ITextureSource *tsrc = gamedef->getTextureSource();
+ ITextureSource *tsrc = client->getTextureSource();
const ItemDefinition &def = get(name);
// Create new ClientCached
ItemStack item = ItemStack();
item.name = def.name;
- scene::IMesh *mesh = getItemMesh(gamedef, item);
+ scene::IMesh *mesh = getItemMesh(client, item);
cc->wield_mesh = mesh;
// Put in cache
return cc;
}
ClientCached* getClientCached(const std::string &name,
- IGameDef *gamedef) const
+ Client *client) const
{
ClientCached *cc = NULL;
m_clientcached.get(name, &cc);
if(thr_is_current_thread(m_main_thread))
{
- return createClientCachedDirect(name, gamedef);
+ return createClientCachedDirect(name, client);
}
else
{
}
// Get item inventory texture
virtual video::ITexture* getInventoryTexture(const std::string &name,
- IGameDef *gamedef) const
+ Client *client) const
{
- ClientCached *cc = getClientCached(name, gamedef);
+ ClientCached *cc = getClientCached(name, client);
if(!cc)
return NULL;
return cc->inventory_texture;
}
// Get item wield mesh
virtual scene::IMesh* getWieldMesh(const std::string &name,
- IGameDef *gamedef) const
+ Client *client) const
{
- ClientCached *cc = getClientCached(name, gamedef);
+ ClientCached *cc = getClientCached(name, client);
if(!cc)
return NULL;
return cc->wield_mesh;
request = m_get_clientcached_queue.pop();
m_get_clientcached_queue.pushResult(request,
- createClientCachedDirect(request.key, gamedef));
+ createClientCachedDirect(request.key, (Client *)gamedef));
}
#endif
}
#include "itemgroup.h"
#include "sound.h"
class IGameDef;
+class Client;
struct ToolCapabilities;
/*
#ifndef SERVER
// Get item inventory texture
virtual video::ITexture* getInventoryTexture(const std::string &name,
- IGameDef *gamedef) const=0;
+ Client *client) const=0;
// Get item wield mesh
virtual scene::IMesh* getWieldMesh(const std::string &name,
- IGameDef *gamedef) const=0;
+ Client *client) const=0;
#endif
virtual void serialize(std::ostream &os, u16 protocol_version)=0;
#ifndef SERVER
// Get item inventory texture
virtual video::ITexture* getInventoryTexture(const std::string &name,
- IGameDef *gamedef) const=0;
+ Client *client) const=0;
// Get item wield mesh
virtual scene::IMesh* getWieldMesh(const std::string &name,
- IGameDef *gamedef) const=0;
+ Client *client) const=0;
#endif
// Remove all registered item and node definitions and aliases
#include "event.h"
#include "collision.h"
-#include "gamedef.h"
#include "nodedef.h"
#include "settings.h"
#include "environment.h"
LocalPlayer
*/
-LocalPlayer::LocalPlayer(Client *gamedef, const char *name):
- Player(name, gamedef->idef()),
+LocalPlayer::LocalPlayer(Client *client, const char *name):
+ Player(name, client->idef()),
parent(0),
hp(PLAYER_MAX_HP),
got_teleported(false),
camera_barely_in_ceiling(false),
m_collisionbox(-BS * 0.30, 0.0, -BS * 0.30, BS * 0.30, BS * 1.75, BS * 0.30),
m_cao(NULL),
- m_gamedef(gamedef)
+ m_client(client)
{
// Initialize hp to 0, so that no hearts will be shown if server
// doesn't support health points
std::vector<CollisionInfo> *collision_info)
{
Map *map = &env->getMap();
- INodeDefManager *nodemgr = m_gamedef->ndef();
+ INodeDefManager *nodemgr = m_client->ndef();
v3f position = getPosition();
}
// Skip collision detection if noclip mode is used
- bool fly_allowed = m_gamedef->checkLocalPrivilege("fly");
- bool noclip = m_gamedef->checkLocalPrivilege("noclip") &&
+ bool fly_allowed = m_client->checkLocalPrivilege("fly");
+ bool noclip = m_client->checkLocalPrivilege("noclip") &&
g_settings->getBool("noclip");
bool free_move = noclip && fly_allowed && g_settings->getBool("free_move");
if (free_move) {
v3f accel_f = v3f(0,0,0);
- collisionMoveResult result = collisionMoveSimple(env, m_gamedef,
+ collisionMoveResult result = collisionMoveSimple(env, m_client,
pos_max_d, m_collisionbox, player_stepheight, dtime,
&position, &m_speed, accel_f);
if(!result.standing_on_object && !touching_ground_was && touching_ground) {
MtEvent *e = new SimpleTriggerEvent("PlayerRegainGround");
- m_gamedef->event()->put(e);
+ m_client->event()->put(e);
// Set camera impact value to be used for view bobbing
camera_impact = getSpeed().Y * -1;
v3f speedH = v3f(0,0,0); // Horizontal (X, Z)
v3f speedV = v3f(0,0,0); // Vertical (Y)
- bool fly_allowed = m_gamedef->checkLocalPrivilege("fly");
- bool fast_allowed = m_gamedef->checkLocalPrivilege("fast");
+ bool fly_allowed = m_client->checkLocalPrivilege("fly");
+ bool fast_allowed = m_client->checkLocalPrivilege("fast");
bool free_move = fly_allowed && g_settings->getBool("free_move");
bool fast_move = fast_allowed && g_settings->getBool("fast_move");
setSpeed(speedJ);
MtEvent *e = new SimpleTriggerEvent("PlayerJump");
- m_gamedef->event()->put(e);
+ m_client->event()->put(e);
}
}
else if(in_liquid)
class LocalPlayer : public Player
{
public:
- LocalPlayer(Client *gamedef, const char *name);
+ LocalPlayer(Client *client, const char *name);
virtual ~LocalPlayer();
ClientActiveObject *parent;
aabb3f m_collisionbox;
GenericCAO* m_cao;
- Client *m_gamedef;
+ Client *m_client;
};
#endif
#include "map.h"
#include "profiler.h"
#include "nodedef.h"
-#include "gamedef.h"
#include "mesh.h"
#include "minimap.h"
#include "content_mapblock.h"
MeshMakeData
*/
-MeshMakeData::MeshMakeData(IGameDef *gamedef, bool use_shaders,
+MeshMakeData::MeshMakeData(Client *client, bool use_shaders,
bool use_tangent_vertices):
m_vmanip(),
m_blockpos(-1337,-1337,-1337),
m_crack_pos_relative(-1337, -1337, -1337),
m_smooth_lighting(false),
m_show_hud(false),
- m_gamedef(gamedef),
+ m_client(client),
m_use_shaders(use_shaders),
m_use_tangent_vertices(use_tangent_vertices)
{}
v3s16(1,1,1),
};
- INodeDefManager *ndef = data->m_gamedef->ndef();
+ INodeDefManager *ndef = data->m_client->ndef();
u16 ambient_occlusion = 0;
u16 light_count = 0;
*/
TileSpec getNodeTileN(MapNode mn, v3s16 p, u8 tileindex, MeshMakeData *data)
{
- INodeDefManager *ndef = data->m_gamedef->ndef();
+ INodeDefManager *ndef = data->m_client->ndef();
TileSpec spec = ndef->get(mn).tiles[tileindex];
// Apply temporary crack
if (p == data->m_crack_pos_relative)
*/
TileSpec getNodeTile(MapNode mn, v3s16 p, v3s16 dir, MeshMakeData *data)
{
- INodeDefManager *ndef = data->m_gamedef->ndef();
+ INodeDefManager *ndef = data->m_client->ndef();
// Direction must be (1,0,0), (-1,0,0), (0,1,0), (0,-1,0),
// (0,0,1), (0,0,-1) or (0,0,0)
u16 tile_index=facedir*16 + dir_i;
TileSpec spec = getNodeTileN(mn, p, dir_to_tile[tile_index], data);
spec.rotation=dir_to_tile[tile_index + 1];
- spec.texture = data->m_gamedef->tsrc()->getTexture(spec.texture_id);
+ spec.texture = data->m_client->tsrc()->getTexture(spec.texture_id);
return spec;
}
)
{
VoxelManipulator &vmanip = data->m_vmanip;
- INodeDefManager *ndef = data->m_gamedef->ndef();
+ INodeDefManager *ndef = data->m_client->ndef();
v3s16 blockpos_nodes = data->m_blockpos * MAP_BLOCKSIZE;
MapNode &n0 = vmanip.getNodeRefUnsafe(blockpos_nodes + p);
MapBlockMesh::MapBlockMesh(MeshMakeData *data, v3s16 camera_offset):
m_mesh(new scene::SMesh()),
m_minimap_mapblock(NULL),
- m_gamedef(data->m_gamedef),
- m_driver(m_gamedef->tsrc()->getDevice()->getVideoDriver()),
- m_tsrc(m_gamedef->getTextureSource()),
- m_shdrsrc(m_gamedef->getShaderSource()),
+ m_client(data->m_client),
+ m_driver(m_client->tsrc()->getDevice()->getVideoDriver()),
+ m_tsrc(m_client->getTextureSource()),
+ m_shdrsrc(m_client->getShaderSource()),
m_animation_force_timer(0), // force initial animation
m_last_crack(-1),
m_crack_materials(),
if (m_use_tangent_vertices) {
scene::IMeshManipulator* meshmanip =
- m_gamedef->getSceneManager()->getMeshManipulator();
+ m_client->getSceneManager()->getMeshManipulator();
meshmanip->recalculateTangents(m_mesh, true, false, false);
}
#include "util/cpp11_container.h"
#include <map>
-class IGameDef;
+class Client;
class IShaderSource;
/*
bool m_smooth_lighting;
bool m_show_hud;
- IGameDef *m_gamedef;
+ Client *m_client;
bool m_use_shaders;
bool m_use_tangent_vertices;
- MeshMakeData(IGameDef *gamedef, bool use_shaders,
+ MeshMakeData(Client *client, bool use_shaders,
bool use_tangent_vertices = false);
/*
private:
scene::IMesh *m_mesh;
MinimapMapblock *m_minimap_mapblock;
- IGameDef *m_gamedef;
+ Client *m_client;
video::IVideoDriver *m_driver;
ITextureSource *m_tsrc;
IShaderSource *m_shdrsrc;
#include "mg_biome.h"
#include "mg_decoration.h"
#include "emerge.h"
-#include "gamedef.h"
+#include "server.h"
#include "nodedef.h"
#include "map.h" //for MMVManip
-#include "log.h"
#include "util/numeric.h"
#include "util/mathconstants.h"
#include "porting.h"
///////////////////////////////////////////////////////////////////////////////
-BiomeManager::BiomeManager(IGameDef *gamedef) :
- ObjDefManager(gamedef, OBJDEF_BIOME)
+BiomeManager::BiomeManager(Server *server) :
+ ObjDefManager(server, OBJDEF_BIOME)
{
- m_gamedef = gamedef;
+ m_server = server;
// Create default biome to be used in case none exist
Biome *b = new Biome;
void BiomeManager::clear()
{
- EmergeManager *emerge = m_gamedef->getEmergeManager();
+ EmergeManager *emerge = m_server->getEmergeManager();
// Remove all dangling references in Decorations
DecorationManager *decomgr = emerge->decomgr;
#include "nodedef.h"
#include "noise.h"
+class Server;
class Settings;
class BiomeManager;
class BiomeManager : public ObjDefManager {
public:
- BiomeManager(IGameDef *gamedef);
+ BiomeManager(Server *server);
virtual ~BiomeManager();
const char *getObjectTitle() const
virtual void clear();
private:
- IGameDef *m_gamedef;
+ Server *m_server;
};
#include <fstream>
#include <typeinfo>
#include "mg_schematic.h"
-#include "gamedef.h"
+#include "server.h"
#include "mapgen.h"
#include "emerge.h"
#include "map.h"
///////////////////////////////////////////////////////////////////////////////
-SchematicManager::SchematicManager(IGameDef *gamedef) :
- ObjDefManager(gamedef, OBJDEF_SCHEMATIC)
+SchematicManager::SchematicManager(Server *server) :
+ ObjDefManager(server, OBJDEF_SCHEMATIC)
{
- m_gamedef = gamedef;
+ m_server = server;
}
void SchematicManager::clear()
{
- EmergeManager *emerge = m_gamedef->getEmergeManager();
+ EmergeManager *emerge = m_server->getEmergeManager();
// Remove all dangling references in Decorations
DecorationManager *decomgr = emerge->decomgr;
class MMVManip;
class PseudoRandom;
class NodeResolver;
-class IGameDef;
+class Server;
/*
Minetest Schematic File Format
class SchematicManager : public ObjDefManager {
public:
- SchematicManager(IGameDef *gamedef);
+ SchematicManager(Server *server);
virtual ~SchematicManager() {}
virtual void clear();
}
private:
- IGameDef *m_gamedef;
+ Server *m_server;
};
void generate_nodelist_and_update_ids(MapNode *nodes, size_t nodecount,
#ifndef SERVER
#include "client/tile.h"
#include "mesh.h"
+#include "client.h"
#include <IMeshManipulator.h>
#endif
#include "log.h"
#ifndef SERVER
void ContentFeatures::updateTextures(ITextureSource *tsrc, IShaderSource *shdsrc,
- scene::ISceneManager *smgr, scene::IMeshManipulator *meshmanip,
- IGameDef *gamedef, const TextureSettings &tsettings)
+ scene::IMeshManipulator *meshmanip, Client *client, const TextureSettings &tsettings)
{
// minimap pixel color - the average color of a texture
if (tsettings.enable_minimap && tiledef[0].name != "")
if ((drawtype == NDT_MESH) && (mesh != "")) {
// Meshnode drawtype
// Read the mesh and apply scale
- mesh_ptr[0] = gamedef->getMesh(mesh);
+ mesh_ptr[0] = client->getMesh(mesh);
if (mesh_ptr[0]){
v3f scale = v3f(1.0, 1.0, 1.0) * BS * visual_scale;
scaleMesh(mesh_ptr[0], scale);
#ifndef SERVER
infostream << "CNodeDefManager::updateTextures(): Updating "
"textures in node definitions" << std::endl;
- ITextureSource *tsrc = gamedef->tsrc();
- IShaderSource *shdsrc = gamedef->getShaderSource();
- scene::ISceneManager* smgr = gamedef->getSceneManager();
+
+ Client *client = (Client *)gamedef;
+ ITextureSource *tsrc = client->tsrc();
+ IShaderSource *shdsrc = client->getShaderSource();
+ scene::ISceneManager* smgr = client->getSceneManager();
scene::IMeshManipulator* meshmanip = smgr->getMeshManipulator();
TextureSettings tsettings;
tsettings.readSettings();
u32 size = m_content_features.size();
for (u32 i = 0; i < size; i++) {
- m_content_features[i].updateTextures(tsrc, shdsrc, smgr, meshmanip, gamedef, tsettings);
+ m_content_features[i].updateTextures(tsrc, shdsrc, meshmanip, client, tsettings);
progress_callback(progress_callback_args, i, size);
}
#endif
#ifndef SERVER
#include "client/tile.h"
#include "shader.h"
+class Client;
#endif
#include "itemgroup.h"
#include "sound.h" // SimpleSoundSpec
u32 shader_id, bool use_normal_texture, bool backface_culling,
u8 alpha, u8 material_type);
void updateTextures(ITextureSource *tsrc, IShaderSource *shdsrc,
- scene::ISceneManager *smgr, scene::IMeshManipulator *meshmanip,
- IGameDef *gamedef, const TextureSettings &tsettings);
+ scene::IMeshManipulator *meshmanip, Client *client, const TextureSettings &tsettings);
#endif
};
*/
#include "particles.h"
-#include "constants.h"
-#include "debug.h"
-#include "settings.h"
-#include "client/tile.h"
-#include "gamedef.h"
+#include "client.h"
#include "collision.h"
#include <stdlib.h>
#include "util/numeric.h"
}
}
-void ParticleManager::handleParticleEvent(ClientEvent *event, IGameDef *gamedef,
+void ParticleManager::handleParticleEvent(ClientEvent *event, Client *client,
scene::ISceneManager* smgr, LocalPlayer *player)
{
switch (event->type) {
}
video::ITexture *texture =
- gamedef->tsrc()->getTextureForMesh(*(event->add_particlespawner.texture));
+ client->tsrc()->getTextureForMesh(*(event->add_particlespawner.texture));
- ParticleSpawner* toadd = new ParticleSpawner(gamedef, smgr, player,
+ ParticleSpawner* toadd = new ParticleSpawner(client, smgr, player,
event->add_particlespawner.amount,
event->add_particlespawner.spawntime,
*event->add_particlespawner.minpos,
}
case CE_SPAWN_PARTICLE: {
video::ITexture *texture =
- gamedef->tsrc()->getTextureForMesh(*(event->spawn_particle.texture));
+ client->tsrc()->getTextureForMesh(*(event->spawn_particle.texture));
- Particle* toadd = new Particle(gamedef, smgr, player, m_env,
+ Particle* toadd = new Particle(client, smgr, player, m_env,
*event->spawn_particle.pos,
*event->spawn_particle.vel,
*event->spawn_particle.acc,
void step (float dtime);
- void handleParticleEvent(ClientEvent *event,IGameDef *gamedef,
+ void handleParticleEvent(ClientEvent *event, Client *client,
scene::ISceneManager* smgr, LocalPlayer *player);
void addDiggingParticles(IGameDef* gamedef, scene::ISceneManager* smgr,
#include "pathfinder.h"
#include "serverenvironment.h"
-#include "gamedef.h"
+#include "server.h"
#include "nodedef.h"
-#include "map.h"
-#include "log.h"
-#include "irr_aabb3d.h"
-#include "util/basic_macros.h"
//#define PATHFINDER_DEBUG
//#define PATHFINDER_CALC_TIME
#include "lua_api/l_nodemeta.h"
#include "lua_api/l_internal.h"
#include "lua_api/l_inventory.h"
-#include "common/c_converter.h"
#include "common/c_content.h"
#include "serverenvironment.h"
#include "map.h"
-#include "gamedef.h"
-#include "nodemetadata.h"
-
-
+#include "server.h"
/*
NodeMetaRef
#include "content_abm.h"
#include "content_sao.h"
#include "mods.h"
-#include "sound.h" // dummySoundManager
#include "event_manager.h"
#include "serverlist.h"
#include "util/string.h"
{
return m_craftdef;
}
-ITextureSource *Server::getTextureSource()
-{
- return NULL;
-}
-IShaderSource *Server::getShaderSource()
-{
- return NULL;
-}
-scene::ISceneManager *Server::getSceneManager()
-{
- return NULL;
-}
u16 Server::allocateUnknownNodeId(const std::string &name)
{
return m_nodedef->allocateDummy(name);
}
-ISoundManager *Server::getSoundManager()
-{
- return &dummySoundManager;
-}
-
MtEventManager *Server::getEventManager()
{
return m_event;
virtual IItemDefManager* getItemDefManager();
virtual INodeDefManager* getNodeDefManager();
virtual ICraftDefManager* getCraftDefManager();
- virtual ITextureSource* getTextureSource();
- virtual IShaderSource* getShaderSource();
virtual u16 allocateUnknownNodeId(const std::string &name);
- virtual ISoundManager* getSoundManager();
virtual MtEventManager* getEventManager();
- virtual scene::ISceneManager* getSceneManager();
- virtual IRollbackManager *getRollbackManager() { return m_rollback; }
+ IRollbackManager *getRollbackManager() { return m_rollback; }
virtual EmergeManager *getEmergeManager() { return m_emerge; }
IWritableItemDefManager* getWritableItemDefManager();
*/
ServerEnvironment::ServerEnvironment(ServerMap *map,
- GameScripting *scriptIface, IGameDef *gamedef,
+ GameScripting *scriptIface, Server *server,
const std::string &path_world) :
m_map(map),
m_script(scriptIface),
- m_gamedef(gamedef),
+ m_server(server),
m_path_world(path_world),
m_send_recommended_timer(0),
m_active_block_interval_overload_skip(0),
for (std::vector<RemotePlayer *>::iterator it = m_players.begin();
it != m_players.end(); ++it) {
RemotePlayer *player = dynamic_cast<RemotePlayer *>(*it);
- ((Server*)m_gamedef)->DenyAccessVerCompliant(player->peer_id,
+ m_server->DenyAccessVerCompliant(player->peer_id,
player->protocol_version, reason, str_reason, reconnect);
}
}
it != m_players.end();
++it) {
if ((*it)->checkModified()) {
- (*it)->save(players_path, m_gamedef);
+ (*it)->save(players_path, m_server);
}
}
}
std::string players_path = m_path_world + DIR_DELIM "players";
fs::CreateDir(players_path);
- player->save(players_path, m_gamedef);
+ player->save(players_path, m_server);
}
RemotePlayer *ServerEnvironment::loadPlayer(const std::string &playername, PlayerSAO *sao)
RemotePlayer *player = getPlayer(playername.c_str());
if (!player) {
- player = new RemotePlayer("", m_gamedef->idef());
+ player = new RemotePlayer("", m_server->idef());
newplayer = true;
}
} catch (SettingNotFoundException &e) {
// No problem, this is expected. Just continue with an empty string
}
- m_lbm_mgr.loadIntroductionTimes(lbm_introduction_times, m_gamedef, m_game_time);
+ m_lbm_mgr.loadIntroductionTimes(lbm_introduction_times, m_server, m_game_time);
m_day_count = args.exists("day_count") ?
args.getU64("day_count") : 0;
void ServerEnvironment::loadDefaultMeta()
{
- m_lbm_mgr.loadIntroductionTimes("", m_gamedef, m_game_time);
+ m_lbm_mgr.loadIntroductionTimes("", m_server, m_game_time);
}
struct ActiveABM
bool ServerEnvironment::setNode(v3s16 p, const MapNode &n)
{
- INodeDefManager *ndef = m_gamedef->ndef();
+ INodeDefManager *ndef = m_server->ndef();
MapNode n_old = m_map->getNodeNoEx(p);
// Call destructor
bool ServerEnvironment::removeNode(v3s16 p)
{
- INodeDefManager *ndef = m_gamedef->ndef();
+ INodeDefManager *ndef = m_server->ndef();
MapNode n_old = m_map->getNodeNoEx(p);
// Call destructor
class ServerEnvironment;
class ActiveBlockModifier;
class ServerActiveObject;
+class Server;
+class GameScripting;
/*
{Active, Loading} block modifier interface.
{
public:
ServerEnvironment(ServerMap *map, GameScripting *scriptIface,
- IGameDef *gamedef, const std::string &path_world);
+ Server *server, const std::string &path_world);
~ServerEnvironment();
Map & getMap();
GameScripting* getScriptIface()
{ return m_script; }
- IGameDef *getGameDef()
- { return m_gamedef; }
+ Server *getGameDef()
+ { return m_server; }
float getSendRecommendedInterval()
{ return m_recommended_send_interval; }
ServerMap *m_map;
// Lua state
GameScripting* m_script;
- // Game definition
- IGameDef *m_gamedef;
+ // Server definition
+ Server *m_server;
// World path
const std::string m_path_world;
// Active object list
#include "settings.h"
#include "wieldmesh.h"
#include "inventory.h"
-#include "gamedef.h"
+#include "client.h"
#include "itemdef.h"
#include "nodedef.h"
#include "mesh.h"
video::SMaterial &material = m_meshnode->getMaterial(0);
material.setTexture(0, tsrc->getTextureForMesh(imagename));
material.TextureLayer[0].TextureWrapU = video::ETC_CLAMP_TO_EDGE;
- material.TextureLayer[0].TextureWrapV = video::ETC_CLAMP_TO_EDGE;
+ material.TextureLayer[0].TextureWrapV = video::ETC_CLAMP_TO_EDGE;
material.MaterialType = m_material_type;
material.setFlag(video::EMF_BACK_FACE_CULLING, true);
// Enable bi/trilinear filtering only for high resolution textures
}
}
-void WieldMeshSceneNode::setItem(const ItemStack &item, IGameDef *gamedef)
+void WieldMeshSceneNode::setItem(const ItemStack &item, Client *client)
{
- ITextureSource *tsrc = gamedef->getTextureSource();
- IItemDefManager *idef = gamedef->getItemDefManager();
- IShaderSource *shdrsrc = gamedef->getShaderSource();
- INodeDefManager *ndef = gamedef->getNodeDefManager();
+ ITextureSource *tsrc = client->getTextureSource();
+ IItemDefManager *idef = client->getItemDefManager();
+ IShaderSource *shdrsrc = client->getShaderSource();
+ INodeDefManager *ndef = client->getNodeDefManager();
const ItemDefinition &def = item.getDefinition(idef);
const ContentFeatures &f = ndef->get(def.name);
content_t id = ndef->getId(def.name);
} else if (f.drawtype == NDT_NORMAL || f.drawtype == NDT_ALLFACES) {
setCube(f.tiles, def.wield_scale, tsrc);
} else {
- MeshMakeData mesh_make_data(gamedef, false);
+ MeshMakeData mesh_make_data(client, false);
MapNode mesh_make_node(id, 255, 0);
mesh_make_data.fillSingleNode(&mesh_make_node);
MapBlockMesh mapblock_mesh(&mesh_make_data, v3s16(0, 0, 0));
m_meshnode->setVisible(true);
}
-scene::IMesh *getItemMesh(IGameDef *gamedef, const ItemStack &item)
+scene::IMesh *getItemMesh(Client *client, const ItemStack &item)
{
- ITextureSource *tsrc = gamedef->getTextureSource();
- IItemDefManager *idef = gamedef->getItemDefManager();
- INodeDefManager *ndef = gamedef->getNodeDefManager();
+ ITextureSource *tsrc = client->getTextureSource();
+ IItemDefManager *idef = client->getItemDefManager();
+ INodeDefManager *ndef = client->getNodeDefManager();
const ItemDefinition &def = item.getDefinition(idef);
const ContentFeatures &f = ndef->get(def.name);
content_t id = ndef->getId(def.name);
mesh = cloneMesh(g_extrusion_mesh_cache->createCube());
scaleMesh(mesh, v3f(1.2, 1.2, 1.2));
} else {
- MeshMakeData mesh_make_data(gamedef, false);
+ MeshMakeData mesh_make_data(client, false);
MapNode mesh_make_node(id, 255, 0);
mesh_make_data.fillSingleNode(&mesh_make_node);
MapBlockMesh mapblock_mesh(&mesh_make_data, v3s16(0, 0, 0));
#include <string>
struct ItemStack;
-class IGameDef;
+class Client;
class ITextureSource;
struct TileSpec;
v3f wield_scale, ITextureSource *tsrc);
void setExtruded(const std::string &imagename,
v3f wield_scale, ITextureSource *tsrc, u8 num_frames);
- void setItem(const ItemStack &item, IGameDef *gamedef);
+ void setItem(const ItemStack &item, Client *client);
// Sets the vertex color of the wield mesh.
// Must only be used if the constructor was called with lighting = false
aabb3f m_bounding_box;
};
-scene::IMesh *getItemMesh(IGameDef *gamedef, const ItemStack &item);
+scene::IMesh *getItemMesh(Client *client, const ItemStack &item);
scene::IMesh *getExtrudedMesh(ITextureSource *tsrc,
const std::string &imagename);
projects / oweals / minetest.git / commitdiff