+// $Id$
+//
+// SuperTux
+// Copyright (C) 2000 Bill Kendrick <bill@newbreedsoftware.com>
+// Copyright (C) 2004 Tobias Glaesser <tobi.web@gmx.de>
+//
+// This program is free software; you can redistribute it and/or
+// modify it under the terms of the GNU General Public License
+// as published by the Free Software Foundation; either version 2
+// of the License, or (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+// 02111-1307, USA.
+#include <algorithm>
+#include <iostream>
#include "world.h"
#include "tile.h"
#include "gameloop.h"
#include "gameobjs.h"
+#include "sprite_manager.h"
+#include "resources.h"
+#include "level.h"
-void bouncy_distro_init(bouncy_distro_type* pbouncy_distro, float x, float y)
+void
+BouncyDistro::init(float x, float y)
{
- pbouncy_distro->base.x = x;
- pbouncy_distro->base.y = y;
- pbouncy_distro->base.ym = -2;
+ base.x = x;
+ base.y = y;
+ base.ym = -2;
}
-void bouncy_distro_action(bouncy_distro_type* pbouncy_distro)
+void
+BouncyDistro::action(double frame_ratio)
{
- pbouncy_distro->base.y = pbouncy_distro->base.y + pbouncy_distro->base.ym * frame_ratio;
+ base.y = base.y + base.ym * frame_ratio;
- pbouncy_distro->base.ym += 0.1 * frame_ratio;
+ base.ym += 0.1 * frame_ratio;
- if (pbouncy_distro->base.ym >= 0)
- world.bouncy_distros.erase(static_cast<std::vector<bouncy_distro_type>::iterator>(pbouncy_distro));
+ if (base.ym >= 0)
+ {
+ std::vector<BouncyDistro*>::iterator i
+ = std::find(World::current()->bouncy_distros.begin(),
+ World::current()->bouncy_distros.end(),
+ this);
+ if (i != World::current()->bouncy_distros.end())
+ World::current()->bouncy_distros.erase(i);
+ }
}
-void bouncy_distro_draw(bouncy_distro_type* pbouncy_distro)
+void
+BouncyDistro::draw()
{
- texture_draw(&img_distro[0],
- pbouncy_distro->base.x - scroll_x,
- pbouncy_distro->base.y);
+ img_distro[0]->draw(base.x - scroll_x,
+ base.y - scroll_y);
}
-void broken_brick_init(broken_brick_type* pbroken_brick, Tile* tile,
- float x, float y, float xm, float ym)
+
+void
+BrokenBrick::init(Tile* tile_, float x, float y, float xm, float ym)
{
- pbroken_brick->tile = tile;
- pbroken_brick->base.x = x;
- pbroken_brick->base.y = y;
- pbroken_brick->base.xm = xm;
- pbroken_brick->base.ym = ym;
+ tile = tile_;
+ base.x = x;
+ base.y = y;
+ base.xm = xm;
+ base.ym = ym;
- timer_init(&pbroken_brick->timer, true);
- timer_start(&pbroken_brick->timer,200);
+ timer.init(true);
+ timer.start(200);
}
-void broken_brick_action(broken_brick_type* pbroken_brick)
+void
+BrokenBrick::action(double frame_ratio)
{
- pbroken_brick->base.x = pbroken_brick->base.x + pbroken_brick->base.xm * frame_ratio;
- pbroken_brick->base.y = pbroken_brick->base.y + pbroken_brick->base.ym * frame_ratio;
+ base.x = base.x + base.xm * frame_ratio;
+ base.y = base.y + base.ym * frame_ratio;
- if (!timer_check(&pbroken_brick->timer))
- world.broken_bricks.erase(static_cast<std::vector<broken_brick_type>::iterator>(pbroken_brick));
+ if (!timer.check())
+ {
+ std::vector<BrokenBrick*>::iterator i
+ = std::find(World::current()->broken_bricks.begin(),
+ World::current()->broken_bricks.end(),
+ this);
+ if (i != World::current()->broken_bricks.end())
+ World::current()->broken_bricks.erase(i);
+ }
}
-void broken_brick_draw(broken_brick_type* pbroken_brick)
+void
+BrokenBrick::draw()
{
SDL_Rect src, dest;
src.x = rand() % 16;
src.w = 16;
src.h = 16;
- dest.x = (int)(pbroken_brick->base.x - scroll_x);
- dest.y = (int)pbroken_brick->base.y;
+ dest.x = (int)(base.x - scroll_x);
+ dest.y = (int)(base.y - scroll_y);
dest.w = 16;
dest.h = 16;
- if (pbroken_brick->tile->images.size() > 0)
- texture_draw_part(&pbroken_brick->tile->images[0],
- src.x,src.y,dest.x,dest.y,dest.w,dest.h);
+ if (tile->images.size() > 0)
+ tile->images[0]->draw_part(src.x,src.y,dest.x,dest.y,dest.w,dest.h);
}
-void bouncy_brick_init(bouncy_brick_type* pbouncy_brick, float x, float y)
+void
+BouncyBrick::init(float x, float y)
{
- pbouncy_brick->base.x = x;
- pbouncy_brick->base.y = y;
- pbouncy_brick->offset = 0;
- pbouncy_brick->offset_m = -BOUNCY_BRICK_SPEED;
- pbouncy_brick->shape = GameSession::current()->get_level()->gettileid(x, y);
+ base.x = x;
+ base.y = y;
+ offset = 0;
+ offset_m = -BOUNCY_BRICK_SPEED;
+ shape = World::current()->get_level()->gettileid(x, y);
}
-void bouncy_brick_action(bouncy_brick_type* pbouncy_brick)
+void
+BouncyBrick::action(double frame_ratio)
{
-
- pbouncy_brick->offset = (pbouncy_brick->offset +
- pbouncy_brick->offset_m * frame_ratio);
+ offset = (offset + offset_m * frame_ratio);
/* Go back down? */
-
- if (pbouncy_brick->offset < -BOUNCY_BRICK_MAX_OFFSET)
- pbouncy_brick->offset_m = BOUNCY_BRICK_SPEED;
+ if (offset < -BOUNCY_BRICK_MAX_OFFSET)
+ offset_m = BOUNCY_BRICK_SPEED;
/* Stop bouncing? */
-
- if (pbouncy_brick->offset >= 0)
- world.bouncy_bricks.erase(static_cast<std::vector<bouncy_brick_type>::iterator>(pbouncy_brick));
+ if (offset >= 0)
+ {
+ std::vector<BouncyBrick*>::iterator i
+ = std::find(World::current()->bouncy_bricks.begin(),
+ World::current()->bouncy_bricks.end(),
+ this);
+ if (i != World::current()->bouncy_bricks.end())
+ World::current()->bouncy_bricks.erase(i);
+ }
}
-void bouncy_brick_draw(bouncy_brick_type* pbouncy_brick)
+void
+BouncyBrick::draw()
{
- int s;
SDL_Rect dest;
- if (pbouncy_brick->base.x >= scroll_x - 32 &&
- pbouncy_brick->base.x <= scroll_x + screen->w)
+ if (base.x >= scroll_x - 32 &&
+ base.x <= scroll_x + screen->w)
{
- dest.x = (int)(pbouncy_brick->base.x - scroll_x);
- dest.y = (int)pbouncy_brick->base.y;
+ dest.x = (int)(base.x - scroll_x);
+ dest.y = (int)(base.y - scroll_y);
dest.w = 32;
dest.h = 32;
- Level* plevel = GameSession::current()->get_level();
+ Level* plevel = World::current()->get_level();
// FIXME: overdrawing hack to clean the tile from the screen to
// paint it later at on offseted position
if(plevel->bkgd_image[0] == '\0')
{
- fillrect(pbouncy_brick->base.x - scroll_x, pbouncy_brick->base.y,
+ fillrect(base.x - scroll_x, base.y - scroll_y,
32,32,
- plevel->bkgd_red, plevel->bkgd_green, plevel->bkgd_blue, 0);
+ plevel->bkgd_top.red, plevel->bkgd_top.green, plevel->bkgd_top.blue, 0);
+// FIXME: doesn't respect the gradient, futhermore is this necessary at all??
}
else
{
- s = (int)scroll_x / 30;
- texture_draw_part(&plevel->img_bkgd, dest.x + s, dest.y,
- dest.x, dest.y,dest.w,dest.h);
+ int s = ((int)scroll_x / 2)%640;
+ plevel->img_bkgd->draw_part(dest.x + s, dest.y,
+ dest.x, dest.y,dest.w,dest.h);
}
- Tile::draw(pbouncy_brick->base.x - scroll_x,
- pbouncy_brick->base.y + pbouncy_brick->offset,
- pbouncy_brick->shape);
+ Tile::draw(base.x - scroll_x,
+ base.y - scroll_y + offset,
+ shape);
}
}
-void floating_score_init(floating_score_type* pfloating_score, float x, float y, int s)
+void
+FloatingScore::init(float x, float y, int s)
{
- pfloating_score->base.x = x;
- pfloating_score->base.y = y - 16;
- timer_init(&pfloating_score->timer,true);
- timer_start(&pfloating_score->timer,1000);
- pfloating_score->value = s;
+ base.x = x;
+ base.y = y - 16;
+ timer.init(true);
+ timer.start(1000);
+ value = s;
}
-void floating_score_action(floating_score_type* pfloating_score)
+void
+FloatingScore::action(double frame_ratio)
{
- pfloating_score->base.y = pfloating_score->base.y - 2 * frame_ratio;
+ base.y = base.y - 2 * frame_ratio;
- if(!timer_check(&pfloating_score->timer))
- world.floating_scores.erase(static_cast<std::vector<floating_score_type>::iterator>(pfloating_score));
+ if(!timer.check())
+ {
+ std::vector<FloatingScore*>::iterator i
+ = std::find(World::current()->floating_scores.begin(),
+ World::current()->floating_scores.end(),
+ this);
+ if (i != World::current()->floating_scores.end())
+ World::current()->floating_scores.erase(i);
+ }
}
-void floating_score_draw(floating_score_type* pfloating_score)
+void
+FloatingScore::draw()
{
char str[10];
- sprintf(str, "%d", pfloating_score->value);
- text_draw(&gold_text, str, (int)pfloating_score->base.x + 16 - strlen(str) * 8, (int)pfloating_score->base.y, 1);
+ sprintf(str, "%d", value);
+ gold_text->draw(str, (int)base.x + 16 - strlen(str) * 8, (int)base.y, 1);
+}
+
+/* Trampoline */
+
+#define TRAMPOLINE_FRAMES 4
+Sprite *img_trampoline[TRAMPOLINE_FRAMES];
+
+void load_object_gfx()
+{
+ for (int i = 0; i < TRAMPOLINE_FRAMES; i++)
+ {
+ char sprite_name[16];
+ sprintf(sprite_name, "trampoline-%i", i+1);
+ img_trampoline[i] = sprite_manager->load(sprite_name);
+ }
+}
+
+void
+Trampoline::init(float x, float y)
+{
+ base.x = x;
+ base.y = y;
+ base.width = 32;
+ base.height = 32;
+
+ frame = 0;
+ mode = M_NORMAL;
+ physic.reset();
+}
+
+void
+Trampoline::draw()
+{
+ img_trampoline[frame]->draw((int)base.x, (int)base.y);
+
+ frame = 0;
+
+ if (debug_mode)
+ fillrect(base.x - scroll_x, base.y - scroll_y, base.width, base.height, 75, 75, 0, 150);
+}
+
+void
+Trampoline::action(double frame_ratio)
+{
+ // TODO: Remove if we're too far off the screen
+
+ physic.apply(frame_ratio, base.x, base.y);
+
+ // Falling
+ if (mode != M_HELD)
+ {
+ if (issolid(base.x + base.width/2, base.y + base.height))
+ {
+ base.y = int((base.y + base.height)/32) * 32 - base.height;
+
+ physic.enable_gravity(false);
+ physic.set_velocity_y(0.0f);
+
+ physic.set_velocity_x(0);
+ }
+ else
+ {
+ physic.enable_gravity(true);
+ }
+ }
+ else // Player is carrying us around
+ {
+ /* FIXME: The trampoline object shouldn't know about pplayer objects. */
+ /* If we're holding the iceblock */
+ Player& tux = *World::current()->get_tux();
+ Direction dir = tux.dir;
+
+ if(dir == RIGHT)
+ {
+ base.x = tux.base.x + 16;
+ base.y = tux.base.y + tux.base.height/1.5 - base.height;
+ }
+ else /* facing left */
+ {
+ base.x = tux.base.x - 16;
+ base.y = tux.base.y + tux.base.height/1.5 - base.height;
+ }
+
+ if(collision_object_map(base))
+ {
+ base.x = tux.base.x;
+ base.y = tux.base.y + tux.base.height/1.5 - base.height;
+ }
+ }
+}
+
+void
+Trampoline::collision(void *p_c_object, int c_object, CollisionType type)
+{
+ Player* pplayer_c = NULL;
+ switch (c_object)
+ {
+ case CO_PLAYER:
+ pplayer_c = (Player*) p_c_object;
+
+ if (type == COLLISION_NORMAL)
+ {
+ // Pick up if HELD (done in Player)
+ }
+
+ else if (type == COLLISION_SQUISH)
+ {
+ int squish_amount = (32 - (int)pplayer_c->base.y % 32);
+
+ if (squish_amount < 24)
+ frame = 3;
+ else if (squish_amount < 28)
+ frame = 2;
+ else if (squish_amount < 30)
+ frame = 1;
+ else
+ frame = 0;
+
+ if (squish_amount < 24)
+ pplayer_c->physic.set_velocity_y(power);
+ else if (pplayer_c->physic.get_velocity_y() < 0)
+ pplayer_c->physic.set_velocity_y(-squish_amount/32);
+ }
+
+ break;
+
+ default:
+ break;
+
+ }
}
/* EOF */
projects / supertux.git / blobdiff