/*
-Minetest-c55
-Copyright (C) 2010-2012 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2010-2013 celeron55, Perttu Ahola <celeron55@gmail.com>
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
#include "gamedef.h"
#include "nodedef.h"
#include "settings.h"
+#include "environment.h"
#include "map.h"
#include "util/numeric.h"
LocalPlayer
*/
-LocalPlayer::LocalPlayer(IGameDef *gamedef):
- Player(gamedef),
+LocalPlayer::LocalPlayer(IGameDef *gamedef, const char *name):
+ Player(gamedef, name),
+ parent(0),
isAttached(false),
overridePosition(v3f(0,0,0)),
last_position(v3f(0,0,0)),
last_pitch(0),
last_yaw(0),
last_keyPressed(0),
+ eye_offset_first(v3f(0,0,0)),
+ eye_offset_third(v3f(0,0,0)),
+ last_animation(NO_ANIM),
+ hotbar_image(""),
+ hotbar_selected_image(""),
+ light_color(255,255,255,255),
m_sneak_node(32767,32767,32767),
m_sneak_node_exists(false),
m_old_node_below(32767,32767,32767),
m_old_node_below_type("air"),
m_need_to_get_new_sneak_node(true),
- m_can_jump(false)
+ m_can_jump(false),
+ m_cao(NULL)
{
// Initialize hp to 0, so that no hearts will be shown if server
// doesn't support health points
{
}
-void LocalPlayer::move(f32 dtime, Map &map, f32 pos_max_d,
- core::list<CollisionInfo> *collision_info)
+void LocalPlayer::move(f32 dtime, Environment *env, f32 pos_max_d,
+ std::list<CollisionInfo> *collision_info)
{
+ Map *map = &env->getMap();
INodeDefManager *nodemgr = m_gamedef->ndef();
v3f position = getPosition();
if(isAttached)
{
setPosition(overridePosition);
+ m_sneak_node_exists = false;
return;
}
{
position += m_speed * dtime;
setPosition(position);
+ m_sneak_node_exists = false;
return;
}
Collision detection
*/
+ bool is_valid_position;
+ MapNode node;
+ v3s16 pp;
+
/*
Check if player is in liquid (the oscillating value)
*/
- try{
- // If in liquid, the threshold of coming out is at higher y
- if(in_liquid)
- {
- v3s16 pp = floatToInt(position + v3f(0,BS*0.1,0), BS);
- in_liquid = nodemgr->get(map.getNode(pp).getContent()).isLiquid();
- liquid_viscosity = nodemgr->get(map.getNode(pp).getContent()).liquid_viscosity;
- }
- // If not in liquid, the threshold of going in is at lower y
- else
- {
- v3s16 pp = floatToInt(position + v3f(0,BS*0.5,0), BS);
- in_liquid = nodemgr->get(map.getNode(pp).getContent()).isLiquid();
- liquid_viscosity = nodemgr->get(map.getNode(pp).getContent()).liquid_viscosity;
+
+ // If in liquid, the threshold of coming out is at higher y
+ if (in_liquid)
+ {
+ pp = floatToInt(position + v3f(0,BS*0.1,0), BS);
+ node = map->getNodeNoEx(pp, &is_valid_position);
+ if (is_valid_position) {
+ in_liquid = nodemgr->get(node.getContent()).isLiquid();
+ liquid_viscosity = nodemgr->get(node.getContent()).liquid_viscosity;
+ } else {
+ in_liquid = false;
}
}
- catch(InvalidPositionException &e)
+ // If not in liquid, the threshold of going in is at lower y
+ else
{
- in_liquid = false;
+ pp = floatToInt(position + v3f(0,BS*0.5,0), BS);
+ node = map->getNodeNoEx(pp, &is_valid_position);
+ if (is_valid_position) {
+ in_liquid = nodemgr->get(node.getContent()).isLiquid();
+ liquid_viscosity = nodemgr->get(node.getContent()).liquid_viscosity;
+ } else {
+ in_liquid = false;
+ }
}
+
/*
Check if player is in liquid (the stable value)
*/
- try{
- v3s16 pp = floatToInt(position + v3f(0,0,0), BS);
- in_liquid_stable = nodemgr->get(map.getNode(pp).getContent()).isLiquid();
- }
- catch(InvalidPositionException &e)
- {
+ pp = floatToInt(position + v3f(0,0,0), BS);
+ node = map->getNodeNoEx(pp, &is_valid_position);
+ if (is_valid_position) {
+ in_liquid_stable = nodemgr->get(node.getContent()).isLiquid();
+ } else {
in_liquid_stable = false;
}
Check if player is climbing
*/
- try {
- v3s16 pp = floatToInt(position + v3f(0,0.5*BS,0), BS);
- v3s16 pp2 = floatToInt(position + v3f(0,-0.2*BS,0), BS);
- is_climbing = ((nodemgr->get(map.getNode(pp).getContent()).climbable ||
- nodemgr->get(map.getNode(pp2).getContent()).climbable) && !free_move);
- }
- catch(InvalidPositionException &e)
- {
+
+ pp = floatToInt(position + v3f(0,0.5*BS,0), BS);
+ v3s16 pp2 = floatToInt(position + v3f(0,-0.2*BS,0), BS);
+ node = map->getNodeNoEx(pp, &is_valid_position);
+ bool is_valid_position2;
+ MapNode node2 = map->getNodeNoEx(pp2, &is_valid_position2);
+
+ if (!(is_valid_position && is_valid_position2)) {
is_climbing = false;
+ } else {
+ is_climbing = (nodemgr->get(node.getContent()).climbable
+ || nodemgr->get(node2.getContent()).climbable) && !free_move;
}
+
/*
Collision uncertainty radius
Make it a bit larger than the maximum distance of movement
// This should always apply, otherwise there are glitches
assert(d > pos_max_d);
- float player_radius = BS*0.30;
- float player_height = BS*1.55;
-
// Maximum distance over border for sneaking
f32 sneak_max = BS*0.4;
If sneaking, keep in range from the last walked node and don't
fall off from it
*/
- if(control.sneak && m_sneak_node_exists && !(fly_allowed && g_settings->getBool("free_move")) && !in_liquid)
+ if(control.sneak && m_sneak_node_exists &&
+ !(fly_allowed && g_settings->getBool("free_move")) && !in_liquid &&
+ physics_override_sneak)
{
f32 maxd = 0.5*BS + sneak_max;
v3f lwn_f = intToFloat(m_sneak_node, BS);
}
}
- /*
- Calculate player collision box (new and old)
- */
- core::aabbox3d<f32> playerbox(
- -player_radius,
- 0.0,
- -player_radius,
- player_radius,
- player_height,
- player_radius
- );
-
float player_stepheight = touching_ground ? (BS*0.6) : (BS*0.2);
v3f accel_f = v3f(0,0,0);
- collisionMoveResult result = collisionMoveSimple(&map, m_gamedef,
- pos_max_d, playerbox, player_stepheight, dtime,
+ collisionMoveResult result = collisionMoveSimple(env, m_gamedef,
+ pos_max_d, m_collisionbox, player_stepheight, dtime,
position, m_speed, accel_f);
/*
*/
v3s16 current_node = floatToInt(position - v3f(0,BS/2,0), BS);
if(m_sneak_node_exists &&
- nodemgr->get(map.getNodeNoEx(m_old_node_below)).name == "air" &&
+ nodemgr->get(map->getNodeNoEx(m_old_node_below)).name == "air" &&
m_old_node_below_type != "air")
{
// Old node appears to have been removed; that is,
m_need_to_get_new_sneak_node = false;
m_sneak_node_exists = false;
}
- else if(nodemgr->get(map.getNodeNoEx(current_node)).name != "air")
+ else if(nodemgr->get(map->getNodeNoEx(current_node)).name != "air")
{
// We are on something, so make sure to recalculate the sneak
// node.
m_need_to_get_new_sneak_node = true;
}
- if(m_need_to_get_new_sneak_node)
+ if(m_need_to_get_new_sneak_node && physics_override_sneak)
{
v3s16 pos_i_bottom = floatToInt(position - v3f(0,BS/2,0), BS);
v2f player_p2df(position.X, position.Z);
max_axis_distance_f > 0.5*BS + sneak_max + 0.1*BS)
continue;
- try{
- // The node to be sneaked on has to be walkable
- if(nodemgr->get(map.getNode(p)).walkable == false)
- continue;
- // And the node above it has to be nonwalkable
- if(nodemgr->get(map.getNode(p+v3s16(0,1,0))).walkable == true)
- continue;
- }
- catch(InvalidPositionException &e)
- {
+
+ // The node to be sneaked on has to be walkable
+ node = map->getNodeNoEx(p, &is_valid_position);
+ if (!is_valid_position || nodemgr->get(node).walkable == false)
continue;
+ // And the node above it has to be nonwalkable
+ node = map->getNodeNoEx(p + v3s16(0,1,0), &is_valid_position);
+ if (!is_valid_position || nodemgr->get(node).walkable) {
+ continue;
+ }
+ if (!physics_override_sneak_glitch) {
+ node =map->getNodeNoEx(p + v3s16(0,2,0), &is_valid_position);
+ if (!is_valid_position || nodemgr->get(node).walkable)
+ continue;
}
min_distance_f = distance_f;
if(!touching_ground_was && touching_ground){
MtEvent *e = new SimpleTriggerEvent("PlayerRegainGround");
m_gamedef->event()->put(e);
+
+ // Set camera impact value to be used for view bobbing
+ camera_impact = getSpeed().Y * -1;
}
{
camera_barely_in_ceiling = false;
v3s16 camera_np = floatToInt(getEyePosition(), BS);
- MapNode n = map.getNodeNoEx(camera_np);
+ MapNode n = map->getNodeNoEx(camera_np);
if(n.getContent() != CONTENT_IGNORE){
if(nodemgr->get(n).walkable && nodemgr->get(n).solidness == 2){
camera_barely_in_ceiling = true;
Update the node last under the player
*/
m_old_node_below = floatToInt(position - v3f(0,BS/2,0), BS);
- m_old_node_below_type = nodemgr->get(map.getNodeNoEx(m_old_node_below)).name;
+ m_old_node_below_type = nodemgr->get(map->getNodeNoEx(m_old_node_below)).name;
/*
Check properties of the node on which the player is standing
*/
- const ContentFeatures &f = nodemgr->get(map.getNodeNoEx(getStandingNodePos()));
+ const ContentFeatures &f = nodemgr->get(map->getNodeNoEx(getStandingNodePos()));
// Determine if jumping is possible
m_can_jump = touching_ground && !in_liquid;
if(itemgroup_get(f.groups, "disable_jump"))
m_can_jump = false;
}
-void LocalPlayer::move(f32 dtime, Map &map, f32 pos_max_d)
+void LocalPlayer::move(f32 dtime, Environment *env, f32 pos_max_d)
{
- move(dtime, map, pos_max_d, NULL);
+ move(dtime, env, pos_max_d, NULL);
}
void LocalPlayer::applyControl(float dtime)
bool free_move = fly_allowed && g_settings->getBool("free_move");
bool fast_move = fast_allowed && g_settings->getBool("fast_move");
- bool fast_or_aux1_descends = (fast_move && control.aux1) || (fast_move && g_settings->getBool("aux1_descends"));
+ // When aux1_descends is enabled the fast key is used to go down, so fast isn't possible
+ bool fast_climb = fast_move && control.aux1 && !g_settings->getBool("aux1_descends");
bool continuous_forward = g_settings->getBool("continuous_forward");
// Whether superspeed mode is used or not
}
else if(in_liquid || in_liquid_stable)
{
- // Always use fast when aux1_descends & fast_move are enabled in liquid, since the aux1 button would mean both turbo and "swim down" causing a conflict
- speedV.Y = -movement_speed_fast;
+ speedV.Y = -movement_speed_walk;
swimming_vertical = true;
}
else if(is_climbing)
{
- // Always use fast when aux1_descends & fast_move are enabled when climbing, since the aux1 button would mean both turbo and "descend" causing a conflict
- speedV.Y = -movement_speed_fast;
+ speedV.Y = -movement_speed_climb;
}
else
{
}
else if(in_liquid || in_liquid_stable)
{
- if(fast_or_aux1_descends)
- // Always use fast when aux1_descends & fast_move are enabled in liquid, since the aux1 button would mean both turbo and "swim down" causing a conflict
+ if(fast_climb)
speedV.Y = -movement_speed_fast;
else
speedV.Y = -movement_speed_walk;
}
else if(is_climbing)
{
- if(fast_or_aux1_descends)
- // Always use fast when aux1_descends & fast_move are enabled when climbing, since the aux1 button would mean both turbo and "descend" causing a conflict
+ if(fast_climb)
speedV.Y = -movement_speed_fast;
else
speedV.Y = -movement_speed_climb;
if(control.jump)
{
if(free_move)
- {
+ {
if(g_settings->getBool("aux1_descends") || g_settings->getBool("always_fly_fast"))
{
if(fast_move)
v3f speedJ = getSpeed();
if(speedJ.Y >= -0.5 * BS)
{
- speedJ.Y = movement_speed_jump;
+ speedJ.Y = movement_speed_jump * physics_override_jump;
setSpeed(speedJ);
MtEvent *e = new SimpleTriggerEvent("PlayerJump");
}
else if(in_liquid)
{
- if(fast_or_aux1_descends)
- // Always use fast when aux1_descends & fast_move are enabled in liquid, since the aux1 button would mean both turbo and "swim down" causing a conflict
+ if(fast_climb)
speedV.Y = movement_speed_fast;
else
speedV.Y = movement_speed_walk;
}
else if(is_climbing)
{
- if(fast_or_aux1_descends)
- // Always use fast when aux1_descends & fast_move are enabled when climbing, since the aux1 button would mean both turbo and "descend" causing a conflict
+ if(fast_climb)
speedV.Y = movement_speed_fast;
else
speedV.Y = movement_speed_climb;
}
// The speed of the player (Y is ignored)
- if(superspeed || (is_climbing && fast_or_aux1_descends) || ((in_liquid || in_liquid_stable) && fast_or_aux1_descends))
+ if(superspeed || (is_climbing && fast_climb) || ((in_liquid || in_liquid_stable) && fast_climb))
speedH = speedH.normalize() * movement_speed_fast;
else if(control.sneak && !free_move && !in_liquid && !in_liquid_stable)
speedH = speedH.normalize() * movement_speed_crouch;
incH = movement_acceleration_air * BS * dtime;
incV = 0; // No vertical acceleration in air
}
- else if(superspeed || (fast_move && control.aux1))
- incH = incV = movement_acceleration_fast * BS * dtime;
- else if ((in_liquid || in_liquid_stable) && fast_or_aux1_descends)
- // Always use fast when aux1_descends & fast_move are enabled in liquid, since the aux1 button would mean both turbo and "swim down" causing a conflict
+ else if (superspeed || (is_climbing && fast_climb) || ((in_liquid || in_liquid_stable) && fast_climb))
incH = incV = movement_acceleration_fast * BS * dtime;
else
incH = incV = movement_acceleration_default * BS * dtime;
// Accelerate to target speed with maximum increment
- accelerateHorizontal(speedH, incH);
- accelerateVertical(speedV, incV);
+ accelerateHorizontal(speedH * physics_override_speed, incH * physics_override_speed);
+ accelerateVertical(speedV * physics_override_speed, incV * physics_override_speed);
}
v3s16 LocalPlayer::getStandingNodePos()
{
if(m_sneak_node_exists)
return m_sneak_node;
- return floatToInt(getPosition(), BS);
+ return floatToInt(getPosition() - v3f(0, BS, 0), BS);
}
projects / dragonfireclient.git / blobdiff