path: root/src/game/effects.cpp

/*
This file is part of Minitrem.

Minitrem 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.

Minitrem 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 Minitrem.  If not, see <http://www.gnu.org/licenses/>.
*/

#include "game.hpp"

namespace game {

effect_t::effect_t(state_t *game_) : game::entity_t(game_, ET_EFFECT)
{
}

void effect_t::on_think(void)
{
	if (game->now >= ttl)
		delete this;
}

fx_tracer_t::fx_tracer_t(state_t *game_, v2f_t x0_, v2f_t x1_) : effect_t(game_)
{
	ttl = game->now + 0.07;

	x0 = x0_;
	x1 = x1_;

	render_bounds[0] = x0;
	render_bounds[1] = x1;
	render_bounds = render_bounds.norm();
	render_layer = render::LAYER_TOP;
	cmodel.bounds = render_bounds;
	cmodel.cflags = 0;

	ignore_waking = true;
	wake();
}

void fx_tracer_t::render_to(render::state_t *render)
{
	v2f_t x0l, x1l;
	float t;

	t = (1.0f - (ttl - game->now) / 0.07f) * 0.7f;

	x0l[0] = lerp(x0[0], x1[0], t);
	x0l[1] = lerp(x0[1], x1[1], t);
	x1l[0] = lerp(x0[0], x1[0], t + 0.3f);
	x1l[1] = lerp(x0[1], x1[1], t + 0.3f);

	render->render_line(x0l, x1l, sf::Color::Yellow);
}


fx_flash_t::fx_flash_t(state_t *game_, v2f_t x_, float radius_, sf::Color color_) : effect_t(game_)
{
	ttl = game->now + 0.07;

	x = x_;
	radius = radius_;
	color = color_;

	render_bounds[0] = x - v2f_t(radius, radius);
	render_bounds[1] = x + v2f_t(radius, radius);
	render_bounds = render_bounds.norm();
	render_layer = render::LAYER_TOP;
	cmodel.bounds = render_bounds;
	cmodel.cflags = 0;

	ignore_waking = true;
	wake();
}

void fx_flash_t::render_to(render::state_t *render)
{
	render->render(0.0f, &assets::fx.flash, render_bounds, color);
}

fx_blood_t::fx_blood_t(state_t *game_, v2f_t x_, bool alien_) : effect_t(game_)
{
	ttl = game->now + 0.3f;

	x = x_;
	alien = alien_;

	render_bounds[0] = x - v2f_t(0.2, 0.2);
	render_bounds[1] = x + v2f_t(0.2, 0.2);
	cmodel.bounds = render_bounds;
	cmodel.cflags = 0;

	ignore_waking = true;
	wake();
}

void fx_blood_t::render_to(render::state_t *render)
{
	double phase;
	sf::Color color;

	phase = (game->now - ttl) / 0.3 + 1;

	if (alien)
		color = sf::Color::Green;
	else
		color = sf::Color::Red;

	render->render(phase, &assets::fx.blood, render_bounds, color);
}

fx_move_marker_t::fx_move_marker_t(state_t *game_, v2f_t x_) : effect_t(game_)
{
	x = x_;
	render_bounds[0] = x + v2f_t(-0.15, -0.4);
	render_bounds[1] = x + v2f_t(0.15, 0.2);
	cmodel.bounds = render_bounds;
	cmodel.cflags = 0;

	ignore_waking = true;
	link(&game->world);
}

void fx_move_marker_t::render_to(render::state_t *render)
{
	render->render(game->now * 2, &assets::move_marker, render_bounds, sf::Color::White);
}

fx_aim_marker_t::fx_aim_marker_t(state_t *game_, v2f_t x_) : effect_t(game_)
{
	x = x_;
	render_bounds[0] = x + v2f_t(-0.2, -0.2);
	render_bounds[1] = x + v2f_t(0.2, 0.2);
	render_layer = render::LAYER_TOP;
	cmodel.bounds = render_bounds;
	cmodel.cflags = 0;

	ignore_waking = true;
	link(&game->world);
}

void fx_aim_marker_t::render_to(render::state_t *render)
{
	render->render(game->now * 2, &assets::aim_marker, render_bounds, sf::Color::White);
}

fx_explosion_t::fx_explosion_t(state_t *game_, v2f_t x_) : effect_t(game_)
{
	fx_flash_t *flash;

	ttl = game->now + 0.8;

	x = x_;

	render_bounds[0] = x + v2f_t(-1.0, -2.5);
	render_bounds[1] = x + v2f_t(1.0, 0.5);
	render_bounds = render_bounds.norm();
	cmodel.bounds = render_bounds;
	cmodel.cflags = 0;

	ignore_waking = true;
	wake();

	assets::fx.explosion_sound.play_3d(x);

	flash = new fx_flash_t(game, x, 5.0f, sf::Color(255, 255, 170, 255));
	flash->place(&game->world);
}

void fx_explosion_t::render_to(render::state_t *render)
{
	double phase = (game->now - ttl) / 0.8f;
	render->render(phase, &assets::fx.explosion, render_bounds, sf::Color::White);
}

fx_bullet_miss_t::fx_bullet_miss_t(state_t *game_, v2f_t x_, bool water_) : effect_t(game_)
{
	ttl = game->now + 0.3;

	x = x_;
	water = water_;

	render_bounds[0] = x - v2f_t(0.12f, 0.12f);
	render_bounds[1] = x + v2f_t(0.12f, 0.12f);
	render_bounds = render_bounds.norm();
	cmodel.bounds = render_bounds;
	cmodel.cflags = 0;

	ignore_waking = true;
	wake();

	if (water)
		assets::fx.water_splash_sound.play_3d(x);
	else
		assets::fx.ricochet_sound.play_3d(x);

	game->hivemind_alert(x, 6.0f, false, v2f_t(0, 0));
}

void fx_bullet_miss_t::render_to(render::state_t *render)
{
	double phase = (game->now - ttl) / 0.3f;
	render->render(phase, (water ? &assets::fx.water_splash : &assets::fx.ricochet), render_bounds, sf::Color::White);
}

fx_debug_hivemind_t::fx_debug_hivemind_t(state_t *game_, v2f_t x_, float r_, bool do_move_, v2f_t move_to_) : effect_t(game_)
{
	ttl = game->now + 1.0;

	x = x_;
	r = r_;
	do_move = do_move_;
	move_to = move_to_;

	render_bounds[0] = x - v2f_t(r, r);
	render_bounds[1] = x + v2f_t(r, r);
	render_bounds = render_bounds.norm();
	cmodel.bounds = render_bounds;
	cmodel.cflags = 0;

	ignore_waking = true;
	wake();
}

void fx_debug_hivemind_t::render_to(render::state_t *render)
{
	static const sf::Color color(0, 255, 0, 50);

	if (debug_AI) {
		render->render_circle(x, r, color);

		if (do_move) {
			render->render_line(x, move_to, sf::Color::Red);
			render->render_circle(x, 0.1f, sf::Color::Red);
		}
	}
}


} // namespace game