}
void
-Camera::expose(HSQUIRRELVM vm, int table_idx)
+Camera::expose(HSQUIRRELVM vm, SQInteger table_idx)
{
Scripting::Camera* interface = new Scripting::Camera(this);
expose_object(vm, table_idx, interface, "Camera", true);
}
void
-Camera::unexpose(HSQUIRRELVM vm, int table_idx)
+Camera::unexpose(HSQUIRRELVM vm, SQInteger table_idx)
{
Scripting::unexpose_object(vm, table_idx, "Camera");
}
Camera::parse(const lisp::Lisp& reader)
{
std::string modename;
-
+
reader.get("mode", modename);
if(modename == "normal") {
mode = NORMAL;
Camera::write(lisp::Writer& writer)
{
writer.start_list("camera");
-
+
if(mode == NORMAL) {
writer.write_string("mode", "normal");
writer.write_bool("backscrolling", do_backscrolling);
} else if(mode == MANUAL) {
writer.write_string("mode", "manual");
}
-
+
writer.end_list("camera");
}
void
Camera::keep_in_bounds(Vector& translation)
{
- float width = sector->solids->get_width() * 32;
- float height = sector->solids->get_height() * 32;
+ float width = sector->get_width();
+ float height = sector->get_height();
// don't scroll before the start or after the level's end
if(translation.y > height - SCREEN_HEIGHT)
translation.y = height - SCREEN_HEIGHT;
- if(translation.y < 0)
- translation.y = 0;
+ if(translation.y < 0)
+ translation.y = 0;
if(translation.x > width - SCREEN_WIDTH)
translation.x = width - SCREEN_WIDTH;
if(translation.x < 0)
- translation.x = 0;
+ translation.x = 0;
}
void
{
assert(sector != 0);
Player* player = sector->player;
-
+
// check that we don't have division by zero later
if(elapsed_time < EPSILON)
return;
/****** Vertical Scrolling part ******/
bool do_y_scrolling = true;
- if(player->is_dying() || sector->solids->get_height() == 19)
+ if(player->is_dying() || sector->get_height() == 19*32)
do_y_scrolling = false;
if(do_y_scrolling) {
float speed_y = delta_y / elapsed_time;
// limit the camera speed when jumping upwards
- if(player->fall_mode != Player::FALLING
+ if(player->fall_mode != Player::FALLING
&& player->fall_mode != Player::TRAMPOLINE_JUMP) {
if(speed_y > max_speed_y)
speed_y = max_speed_y;
// finally scroll with calculated speed
translation.y -= speed_y * elapsed_time;
+
+ // make sure to always keep the player inside the middle 1/6 of the screen
+ translation.y = std::min(player->get_bbox().p1.y - SCREEN_HEIGHT*1/6, translation.y);
+ translation.y = std::max(player->get_bbox().p2.y - SCREEN_HEIGHT*5/6, translation.y);
}
/****** Horizontal scrolling part *******/
// our camera is either in leftscrolling, rightscrolling or nonscrollingmode.
-
+
// when suddenly changing directions while scrolling into the other direction.
// abort scrolling, since tux might be going left/right at a relatively small
// part of the map (like when jumping upwards)
speed_x = maxv;
else if(speed_x < -maxv)
speed_x = -maxv;
-
+
+ // If player is peeking scroll in that direction. Fast.
+ if( player->peeking_direction() == ::LEFT ){
+ speed_x = maxv;
+ }
+ if( player->peeking_direction() == ::RIGHT ){
+ speed_x = -maxv;
+ }
+
// apply scrolling
translation.x -= speed_x * elapsed_time;
+ // make sure to always keep the player inside the middle 4/6 of the screen
+ translation.x = std::min(player->get_bbox().p1.x - SCREEN_WIDTH*1/6, translation.x);
+ translation.x = std::max(player->get_bbox().p2.x - SCREEN_WIDTH*5/6, translation.x);
+
keep_in_bounds(translation);
shake();
}
void
Camera::update_scroll_autoscroll(float elapsed_time)
{
- Player* player = sector->player;
+ Player* player = sector->player;
if(player->is_dying())
return;
- translation += autoscroll_walker->advance(elapsed_time);
+ translation = autoscroll_walker->advance(elapsed_time);
keep_in_bounds(translation);
shake();
translation = scroll_from + (scroll_goal - scroll_from) * scroll_to_pos;
}
-