No OneTemporary
Actions

Authored By

Unknown

Size

36 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/src/BaseCreatureEntity.cpp b/src/BaseCreatureEntity.cpp
	index 5f45212..db3761b 100644
	--- a/src/BaseCreatureEntity.cpp
	+++ b/src/BaseCreatureEntity.cpp
	@@ -1,840 +1,845 @@
	#include "BaseCreatureEntity.h"
	#include "sfml_game/ImageManager.h"
	#include "sfml_game/SoundManager.h"
	#include "Constants.h"
	#include "WitchBlastGame.h"
	#include "ExplosionEntity.h"
	#include "TextMapper.h"

	#include <iostream>
	#include <sstream>

	BaseCreatureEntity::BaseCreatureEntity(sf::Texture* image, float x = 0.0f, float y = 0.0f, int spriteWidth = -1, int spriteHeight = -1)
	: CollidingSpriteEntity (image, x, y, spriteWidth, spriteHeight )
	{
	hurting = false;
	displayDamage = true;
	hurtingType = ShotTypeStandard;
	shadowFrame = -1;
	setMap(game().getCurrentMap(), TILE_WIDTH, TILE_HEIGHT, 0, 0);
	hpDisplay = 0;
	armor = 0.0f;
	movingStyle = movWalking;
	for (int i = 0; i < NB_SPECIAL_STATES; i++)
	{
	specialState[i].type = (enumSpecialState)i;
	specialState[i].active = false;
	specialState[i].timer = 0.0f;
	specialState[i].param1 = 0.0f;
	specialState[i].param2 = 0.0f;
	specialState[i].waitUnclear = false;
	}
	for (int i = 0; i < NB_RESISTANCES; i++)
	{
	resistance[i] = ResistanceStandard;
	}
	recoil.active = false;
	facingDirection = 2;
	+ doesAccelerate = false;
	}

	int BaseCreatureEntity::getHp()
	{
	return hp;
	}

	int BaseCreatureEntity::getHpMax()
	{
	return hpMax;
	}

	void BaseCreatureEntity::setHp(int hp)
	{
	this->hp = hp;
	}

	void BaseCreatureEntity::setHpMax(int hpMax)
	{
	this->hpMax = hpMax;
	}

	int BaseCreatureEntity::getHpDisplay()
	{
	return hpDisplay;
	}

	float BaseCreatureEntity::getCreatureSpeed()
	{
	return creatureSpeed;
	}

	IntCoord BaseCreatureEntity::getCurrentTile()
	{
	int xMap = (x) / TILE_WIDTH;
	int yMap = (y) / TILE_HEIGHT;
	return (IntCoord(xMap, yMap));
	}

	BaseCreatureEntity::enumMovingStyle BaseCreatureEntity::getMovingStyle()
	{
	return movingStyle;
	}

	bool BaseCreatureEntity::isSpecialStateActive(enumSpecialState state)
	{
	return specialState[state].active;
	}

	specialStateStuct BaseCreatureEntity::getSpecialState(enumSpecialState state)
	{
	return specialState[state];
	}

	void BaseCreatureEntity::setSpecialState(enumSpecialState state, bool active, float timer, float param1, float param2,bool waitUnclear)
	{
	specialState[state].active = active;
	specialState[state].timer = timer;
	specialState[state].param1 = param1;
	specialState[state].param2 = param2;
	specialState[state].waitUnclear = false;
	}

	float BaseCreatureEntity::animateStates(float delay)
	{
	for (int i = 0; i < NB_SPECIAL_STATES; i++)
	{
	if (specialState[i].active)
	{
	specialState[i].timer -= delay;
	if (specialState[i].timer <= 0.0f)
	{
	setSpecialState((enumSpecialState)i, false, 0.0f, 0.0f, 0.0f);
	game().getPlayer()->computePlayer();

	if (i == SpecialStateTime) game().resumeMusic();
	}
	}
	else if (specialState[i].waitUnclear && !game().getCurrentMap()->isCleared())
	{
	specialState[i].waitUnclear = false;
	specialState[i].active = true;
	game().getPlayer()->computePlayer();
	}
	}
	// ice
	if (specialState[SpecialStateIce].active) delay *= specialState[SpecialStateIce].param1;

	// poison
	if (specialState[SpecialStatePoison].active)
	{
	specialState[SpecialStatePoison].param3 -= delay;
	if (specialState[SpecialStatePoison].param3 <= 0.0f)
	{
	specialState[SpecialStatePoison].param3 += specialState[SpecialStatePoison].param2;
	// TODO
	hurt(getHurtParams(specialState[SpecialStatePoison].param1, ShotTypeDeterministic, 0, false, SourceTypePoison, NB_ENEMY, false));
	}
	}

	return delay;
	}

	void BaseCreatureEntity::animateColors(float delay)
	{
	// no color
	sprite.setColor(sf::Color(255, 255, 255, 255 ));

	if (hurting && hp > 0)
	{
	hurtingDelay -= delay;
	if (hurtingDelay > 0.0f)
	{
	int fadeColor = (sf::Uint8)((HURTING_DELAY - hurtingDelay) * 255);
	if (hurtingDelay > HURTING_DELAY) fadeColor = 0;
	if (hurtingType == ShotTypeIce \|\| hurtingType == ShotTypeCold)
	sprite.setColor(sf::Color(fadeColor, fadeColor, 255, 255 )); // blue
	else if (hurtingType == ShotTypePoison)
	sprite.setColor(sf::Color(fadeColor, 255, fadeColor, 255 )); // green
	else
	sprite.setColor(sf::Color(255, fadeColor, fadeColor, 255 )); // red
	}
	else
	{
	hurting = false;
	sprite.setColor(sf::Color(255, 255, 255, 255 ));
	}
	}
	if (specialState[SpecialStateIce].active) sprite.setColor(sf::Color(100, 100, 255, 255 ));
	else if (specialState[SpecialStatePoison].active)
	{
	int fade = 180 + 70 * cos(age * 5);
	sprite.setColor(sf::Color(fade, 255, fade, 255 ));
	}
	}

	void BaseCreatureEntity::animateRecoil(float delay)
	{
	// recoil
	if (recoil.active)
	{
	recoil.velocity.x *= 0.97f;
	recoil.velocity.y *= 0.97f;

	recoil.timer -= delay;
	if (recoil.timer <= 0.0f)
	{
	recoil.active = false;
	computeFacingDirection();
	// TODO ?
	}
	}
	}

	void BaseCreatureEntity::animatePhysics(float delay)
	{
	- velocity.x += acceleration.x;
	- velocity.y += acceleration.y;
	- velocity.x =
	- std::min(std::max(velocity.x, -creatureSpeed), creatureSpeed);
	- velocity.y =
	- std::min(std::max(velocity.y, -creatureSpeed), creatureSpeed);
	+ if (doesAccelerate)
	+ {
	+ velocity.x += acceleration.x;
	+ velocity.y += acceleration.y;
	+ velocity.x =
	+ std::min(std::max(velocity.x, -creatureSpeed), creatureSpeed);
	+ velocity.y =
	+ std::min(std::max(velocity.y, -creatureSpeed), creatureSpeed);
	+ }
	+
	velocity.x *= viscosity;
	velocity.y *= viscosity;

	float velx = velocity.x;
	float vely = velocity.y;

	if (specialState[SpecialStateSlow].active)
	{
	velx *= specialState[SpecialStateSlow].param1;
	vely *= specialState[SpecialStateSlow].param1;
	}

	if (specialState[SpecialStateSpeed].active)
	{
	velx *= specialState[SpecialStateSpeed].param1;
	vely *= specialState[SpecialStateSpeed].param1;
	}

	if (recoil.active)
	{
	if (recoil.stun)
	{
	velx = 0.0f;
	vely = 0.0f;
	}
	velx += recoil.velocity.x;
	vely += recoil.velocity.y;
	}

	spin *= viscosity;
	angle += spin * delay;

	if (isCollidingWithMap())
	{
	stuck();
	}
	else
	{
	if ((int)velx > 0)
	{
	x += velx * delay;

	if (collideWithMap(DIRECTION_LEFT))
	{
	x = (float)((int)x);
	while (collideWithMap(DIRECTION_LEFT))
	x--;
	collideMapRight();
	}
	else if (x > map->getWidth() * tileWidth + offsetX)
	{
	exitMap(DIRECTION_RIGHT);
	}
	}
	else if ((int)velx < 0)
	{
	x += velx * delay;

	if (collideWithMap(DIRECTION_RIGHT))
	{
	x = (float)((int)x);
	while (collideWithMap(DIRECTION_RIGHT))
	x++;
	collideMapLeft();
	}
	else if (x < offsetX)
	{
	exitMap(DIRECTION_LEFT);
	}
	}
	}

	vely += weight * delay;
	if ( vely > maxY) vely = maxY;

	if ((int)vely > 0)
	{
	y += vely * delay;

	if (collideWithMap(DIRECTION_BOTTOM))
	{
	y = (float)((int)y);
	while (collideWithMap(DIRECTION_BOTTOM))
	y--;
	collideMapBottom();
	}
	}
	else if ((int)vely < 0)
	{
	y += vely * delay;

	if (collideWithMap(DIRECTION_TOP))
	{
	y = (float)((int)y);
	while (collideWithMap(DIRECTION_TOP))
	y++;
	collideMapTop();
	}
	}

	if (lifetime > 0)
	{
	if (age >= lifetime) dyingFromAge();
	}
	age += delay;
	}

	void BaseCreatureEntity::dyingFromAge()
	{
	dying();
	}

	void BaseCreatureEntity::animate(float delay)
	{
	if (hpDisplay > hp) hpDisplay--;
	else if (hpDisplay < hp) hpDisplay++;

	delay = animateStates(delay);
	animateColors(delay);
	animateRecoil(delay);
	animatePhysics(delay);

	z = y + height/2;
	}

	void BaseCreatureEntity::render(sf::RenderTarget* app)
	{
	if (!isDying && shadowFrame > -1)
	{
	// shadow
	int nx = shadowFrame;
	int ny = 0;

	if (imagesProLine > 0 && shadowFrame >= imagesProLine)
	{
	nx = shadowFrame % imagesProLine;
	ny = shadowFrame / imagesProLine;
	}
	sprite.setTextureRect(sf::IntRect(nx * width, ny * height, width, height));
	app->draw(sprite);
	}
	CollidingSpriteEntity::render(app);

	if (game().getShowLogical())
	{
	displayBoundingBox(app);
	displayCenterAndZ(app);
	}
	}

	void BaseCreatureEntity::calculateBB()
	{
	}

	bool BaseCreatureEntity::collideWithMap(int direction)
	{
	calculateBB();

	int xTile0 = (boundingBox.left - offsetX) / tileWidth;
	int xTilef = (boundingBox.left + boundingBox.width - offsetX) / tileWidth;
	int yTile0 = (boundingBox.top - offsetY) / tileHeight;
	int yTilef = (boundingBox.top + boundingBox.height - offsetY) / tileHeight;

	if (boundingBox.top < 0) yTile0 = -1;

	switch (direction)
	{
	case DIRECTION_RIGHT:
	if (xTilef > xTile0) xTilef = xTile0;
	break;

	case DIRECTION_LEFT:
	if (xTilef > xTile0) xTile0 = xTilef;
	break;

	case DIRECTION_TOP:
	if (yTilef > yTile0) yTilef = yTile0;
	break;

	case DIRECTION_BOTTOM:
	if (yTilef > yTile0) yTile0 = yTilef;
	break;
	}

	for (int xTile = xTile0; xTile <= xTilef; xTile++)
	for (int yTile = yTile0; yTile <= yTilef; yTile++)
	{
	if (movingStyle == movWalking)
	{
	if (isAttacking())
	{
	if ( dynamic_cast<DungeonMap*>(map)->isWalkable(xTile, yTile) == false
	&& dynamic_cast<DungeonMap*>(map)->getLogicalTile(xTile, yTile) != LogicalDestroyable)
	return true;
	}
	else
	{
	if ( dynamic_cast<DungeonMap*>(map)->isWalkable(xTile, yTile) == false )
	return true;
	}
	}
	else if (movingStyle == movFlying)
	{
	if ( dynamic_cast<DungeonMap*>(map)->isFlyable(xTile, yTile) == false ) return true;
	}
	}

	return false;
	}

	bool BaseCreatureEntity::determineSatusChance(enumStateResistance resistance, int level)
	{
	bool hit = true;
	switch (resistance)
	{
	case ResistanceVeryLow:
	case ResistanceLow:
	case ResistanceStandard: hit = true; break;
	case ResistanceHigh: hit = rand() % 8 <= level * 2; break;
	case ResistanceVeryHigh: hit = rand() % 10 <= level * 2; break;
	case ResistanceImmune: hit = false; break;
	}
	return hit;
	}

	int BaseCreatureEntity::determineDamageBonus(enumStateResistance resistance, int level)
	{
	int bonus = 0;
	switch (resistance)
	{
	case ResistanceVeryLow: bonus = 40 + 10 * level; break;
	case ResistanceLow: bonus = 20 + 5 * level; break;
	case ResistanceStandard: bonus = 0; break;
	case ResistanceHigh: bonus = -25 + 5 * level; break;
	case ResistanceVeryHigh: bonus = -50 + 5 * level; break;
	case ResistanceImmune: bonus = -100 + 5 * level; break;
	}
	return bonus;
	}

	bool BaseCreatureEntity::textTooClose(TextEntity* textEntity, float xDistMin, float yDistMin)
	{
	EntityManager::EntityList* entityList =EntityManager::getInstance().getList();
	EntityManager::EntityList::iterator it;

	for (it = entityList->begin (); it != entityList->end ();)
	{
	GameEntity e = it;
	it++;

	if (e->getType() == ENTITY_FLYING_TEXT)
	{
	if (e != textEntity)
	{
	if (textEntity->getX() - e->getX() < xDistMin && textEntity->getX() - e->getX() > - xDistMin
	&& textEntity->getY() - e->getY() < yDistMin && textEntity->getY() - e->getY() > - yDistMin)
	return true;
	}
	}
	}
	return false;
	}

	void BaseCreatureEntity::makeExplode()
	{
	new ExplosionEntity(x, y, ExplosionTypeStandard, 16, EnemyTypeNone, false);
	game().addCorpse(x, y, FRAME_CORPSE_SLIME_VIOLET);
	SoundManager::getInstance().playSound(SOUND_BOOM_00);
	}

	int BaseCreatureEntity::hurt(StructHurt hurtParam)
	{
	int oldHp = hp;
	int absorbedHp = 0;
	bool poisoned = false;
	hurtingType = hurtParam.hurtingType;
	if (armor > 0.01f && hurtingType != ShotTypeDeterministic)
	{
	absorbedHp = hurtParam.damage * armor;
	if (absorbedHp == 0) absorbedHp = 1;
	hurtParam.damage -= absorbedHp;
	}

	if (hurtingType == ShotTypeIce
	&& determineSatusChance(resistance[ResistanceFrozen], hurtParam.level))
	{
	// frozen ?
	specialState[SpecialStateIce].active = true;
	float frozenDelayMult = 1.0f;
	float frozenMultAdd = 0.0f;
	if (resistance[ResistanceFrozen] == ResistanceHigh)
	{
	if (hurtParam.level == 0)
	{
	frozenDelayMult = 0.8f;
	frozenMultAdd = 0.2f;
	}
	else
	{
	frozenDelayMult = 0.85f;
	frozenMultAdd = 0.15f;
	}
	}
	else if (resistance[ResistanceFrozen] == ResistanceVeryHigh)
	{
	if (hurtParam.level < 2)
	{
	frozenDelayMult = 0.7f;
	frozenMultAdd = 0.25f;
	}
	else
	{
	frozenDelayMult = 0.8f;
	frozenMultAdd = 0.2f;
	}
	}
	specialState[SpecialStateIce].timer = STATUS_FROZEN_DELAY[hurtParam.level] * frozenDelayMult;
	specialState[SpecialStateIce].param1 = STATUS_FROZEN_MULT[hurtParam.level] + frozenMultAdd;
	}
	else if (hurtingType == ShotTypePoison && determineSatusChance(resistance[ResistancePoison], hurtParam.level))
	{
	specialState[SpecialStatePoison].active = true;
	specialState[SpecialStatePoison].timer = POISON_TIMER[hurtParam.level];
	specialState[SpecialStatePoison].param1 = POISON_DAMAGE[hurtParam.level];
	specialState[SpecialStatePoison].param2 = POISON_DELAY[hurtParam.level];
	specialState[SpecialStatePoison].param3 = POISON_DELAY[hurtParam.level];
	poisoned = true;
	}

	// damage bonus
	if (hurtingType == ShotTypeIce \|\| hurtingType == ShotTypeCold)
	hurtParam.damage += (hurtParam.damage * determineDamageBonus(resistance[ResistanceIce], hurtParam.level)) / 100;
	else if (hurtingType == ShotTypeFire)
	hurtParam.damage += (hurtParam.damage * determineDamageBonus(resistance[ResistanceFire], hurtParam.level)) / 100;
	else if (hurtingType == ShotTypeLightning)
	hurtParam.damage += (hurtParam.damage * determineDamageBonus(resistance[ResistanceLightning], hurtParam.level)) / 100;
	else if (hurtingType == ShotTypeStone)
	hurtParam.damage += (hurtParam.damage * determineDamageBonus(resistance[ResistanceStone], hurtParam.level)) / 100;
	else if (hurtingType == ShotTypeIllusion)
	hurtParam.damage += (hurtParam.damage * determineDamageBonus(resistance[ResistanceIllusion], hurtParam.level)) / 100;
	//else if (hurtingType == ShotTypePoison)
	// hurtParam.damage += (hurtParam.damage * determineDamageBonus(resistance[ResistancePoison], hurtParam.level)) / 100;

	if (hurtParam.damage > 0)
	{
	hurting = true;
	hurtingDelay = HURTING_DELAY;
	this->hurtingType = hurtingType;

	hp -= hurtParam.damage;

	if (hp <= 0)
	{
	hp = 0;

	prepareDying();
	// exploding ?
	if (game().getPlayer()->isEquiped(EQUIP_SULFUR) && canExplode)
	{
	int luck = hurtingType == ShotTypeFire ? 33 : 25;
	if (rand() % 100 < luck) makeExplode();
	}
	}

	// display damage
	if (displayDamage && oldHp > 0)
	{
	int displayedDamage = hurtParam.damage;
	if (hurtParam.goThrough && hp == 0)
	{
	hurtParam.damage = oldHp + absorbedHp;
	displayedDamage = oldHp;
	}

	std::ostringstream oss;
	oss << "-" << displayedDamage;
	int textSize;
	if (displayedDamage < 8) textSize = 17;
	else textSize = 17 + (displayedDamage - 3) / 5;
	TextEntity* text = new TextEntity(oss.str(), textSize, x, y - 20.0f);
	text->setColor(TextEntity::COLOR_FADING_RED);
	text->setAge(-0.6f);
	text->setLifetime(0.3f);
	text->setWeight(-60.0f);
	text->setZ(2000);
	text->setAlignment(ALIGN_CENTER);
	text->setType(ENTITY_FLYING_TEXT);
	while (textTooClose(text, 15, 15)) text->setY(text->getY() - 5);

	if (hurtParam.critical)
	{
	std::ostringstream crss;
	crss << tools::getLabel("critical");
	if (game().getPlayer()->isEquiped(EQUIP_CRITICAL_ADVANCED))
	crss << " X3";
	else
	crss << " X2";
	displayFlyingText(x, text->getY() - 16.0f, 16, crss.str(), TextEntity::COLOR_FADING_RED);
	}

	if (poisoned)
	{
	displayFlyingText(x, text->getY() - 16.0f, 16, tools::getLabel("poison"), TextEntity::COLOR_FADING_RED);
	}
	if (hurtParam.critical) SoundManager::getInstance().playSound(SOUND_CRITICAL);
	}
	}
	return hurtParam.damage;
	}

	void BaseCreatureEntity::displayFlyingText(float xText, float yText, int sizeText, std::string text, TextEntity::colorTypeEnum color)
	{
	TextEntity* textEntity = new TextEntity(text, sizeText, xText, yText);
	textEntity->setColor(color);
	textEntity->setAge(-0.6f);
	textEntity->setLifetime(0.3f);
	textEntity->setWeight(-60.0f);
	textEntity->setZ(2000);
	textEntity->setAlignment(ALIGN_CENTER);
	textEntity->setType(ENTITY_FLYING_TEXT);
	}

	void BaseCreatureEntity::prepareDying()
	{
	dying();
	}

	void BaseCreatureEntity::dying()
	{
	isDying = true;
	}

	void BaseCreatureEntity::computeFacingDirection()
	{
	if (abs((int)velocity.x) > 0 \|\| abs((int)velocity.y) > 0)
	{
	if (abs((int)velocity.x) > abs((int)velocity.y))
	{
	if (velocity.x > 0.0f) facingDirection = 6;
	else facingDirection = 4;
	}
	else
	{
	if (velocity.y > 0.0f) facingDirection = 2;
	else facingDirection = 8;
	}
	}
	}

	void BaseCreatureEntity::giveRecoil(bool stun, Vector2D velocity, float timer)
	{
	if (resistance[ResistanceRecoil] == ResistanceHigh)
	{
	velocity.x *= 0.75f;
	velocity.y *= 0.75f;
	timer *= 0.75f;
	}
	else if (resistance[ResistanceRecoil] == ResistanceVeryHigh)
	{
	velocity.x *= 0.5f;
	velocity.y *= 0.5f;
	timer *= 0.5f;
	}

	if (!(recoil.active && recoil.stun))
	{
	recoil.active = true;
	recoil.stun = stun;

	if (this->velocity.x > 1.0f && velocity.x > 1.0f) recoil.velocity.x = velocity.x + this->velocity.x;
	else if (this->velocity.x < -1.0f && velocity.x < -1.0f) recoil.velocity.x = velocity.x + this->velocity.x;
	else recoil.velocity.x = velocity.x;

	if (this->velocity.y > 1.0f && velocity.y > 1.0f) recoil.velocity.y = velocity.y + this->velocity.y;
	else if (this->velocity.y < -1.0f && velocity.y < -1.0f) recoil.velocity.y = velocity.y + this->velocity.y;
	else recoil.velocity.y = velocity.y;

	recoil.timer = timer;
	}
	}

	void BaseCreatureEntity::inflictsRecoilTo(BaseCreatureEntity* targetEntity)
	{
	}

	bool BaseCreatureEntity::canCollide()
	{
	return true;
	}

	void BaseCreatureEntity::generateStar(sf::Color starColor)
	{
	game().generateStar(starColor, x, y);
	}

	bool BaseCreatureEntity::intersectsSegments(Vector2D a1, Vector2D a2, Vector2D b1, Vector2D b2)
	{
	Vector2D b(a2.x - a1.x, a2.y - a1.y);
	Vector2D d(b2.x - b1.x, b2.y - b1.y);
	float bDotDPerp = b.x * d.y - b.y * d.x;

	// if b dot d == 0, it means the lines are parallel so have infinite intersection points
	if (bDotDPerp == 0) return false;

	Vector2D c(b1.x - a1.x, b1.y - a1.y);
	float t = (c.x * d.y - c.y * d.x) / bDotDPerp;
	if (t < 0 \|\| t > 1) return false;

	float u = (c.x * b.y - c.y * b.x) / bDotDPerp;
	if (u < 0 \|\| u > 1) return false;

	return true;
	}

	bool BaseCreatureEntity::intersectsTile(Vector2D a1, Vector2D a2, int xTile, int yTile)
	{
	int posX = xTile * TILE_WIDTH;
	int posY = yTile * TILE_HEIGHT;

	if (intersectsSegments(a1, a2, Vector2D(posX, posY), Vector2D(posX + TILE_WIDTH, posY))) return true;
	else if (intersectsSegments(a1, a2, Vector2D(posX, posY + TILE_HEIGHT), Vector2D(posX + TILE_WIDTH, posY + TILE_HEIGHT))) return true;
	else if (intersectsSegments(a1, a2, Vector2D(posX + TILE_WIDTH, posY), Vector2D(posX + TILE_WIDTH, posY + TILE_HEIGHT))) return true;
	else if (intersectsSegments(a1, a2, Vector2D(posX, posY), Vector2D(posX, posY + TILE_HEIGHT))) return true;
	else

	return false;
	}

	bool BaseCreatureEntity::canSee(float xf, float yf)
	{
	int tileX0 = x / TILE_WIDTH;
	int tileXf = xf / TILE_WIDTH;
	int tileY0 = y / TILE_HEIGHT;
	int tileYf = yf / TILE_HEIGHT;

	int xBegin, xEnd, yBegin, yEnd;
	if (tileXf < tileX0)
	{
	xBegin = tileXf;
	xEnd = tileX0;
	}
	else
	{
	xBegin = tileX0;
	xEnd = tileXf;
	}

	if (tileYf < tileY0)
	{
	yBegin = tileYf;
	yEnd = tileY0;
	}
	else
	{
	yBegin = tileY0;
	yEnd = tileYf;
	}

	for (int i = xBegin; i <= xEnd; i++ )
	for (int j = yBegin; j <= yEnd; j++ )
	{
	if (!game().getCurrentMap()->isShootable(i, j))
	if (intersectsTile(Vector2D(x, y), game().getPlayerPosition(), i , j))
	return false;
	}

	return true;
	}

	bool BaseCreatureEntity::canWalkTo(float xf, float yf)
	{
	int tileX0 = x / TILE_WIDTH;
	int tileXf = xf / TILE_WIDTH;
	int tileY0 = y / TILE_HEIGHT;
	int tileYf = yf / TILE_HEIGHT;

	int xBegin, xEnd, yBegin, yEnd;
	if (tileXf < tileX0)
	{
	xBegin = tileXf;
	xEnd = tileX0;
	}
	else
	{
	xBegin = tileX0;
	xEnd = tileXf;
	}

	if (tileYf < tileY0)
	{
	yBegin = tileYf;
	yEnd = tileY0;
	}
	else
	{
	yBegin = tileY0;
	yEnd = tileYf;
	}

	for (int i = xBegin; i <= xEnd; i++ )
	for (int j = yBegin; j <= yEnd; j++ )
	{
	if (!game().getCurrentMap()->isWalkable(i, j))
	if (intersectsTile(Vector2D(x, y), game().getPlayerPosition(), i , j))
	return false;
	}

	return true;
	}

	void BaseCreatureEntity::heal(int healPoints)
	{
	int savedHp = hp;
	hp += healPoints;
	if (hp > hpMax) hp = hpMax;

	int healedHp = hp - savedHp;

	if (savedHp > 0)
	{
	std::ostringstream oss;
	oss << "+" << healedHp;
	int textSize;
	if (healedHp < 8) textSize = 17;
	else textSize = 17 + (healedHp - 3) / 5;
	TextEntity* text = new TextEntity(oss.str(), textSize, x, y - 20.0f);
	text->setColor(TextEntity::COLOR_FADING_GREEN);
	text->setAge(-0.6f);
	text->setLifetime(0.3f);
	text->setWeight(-60.0f);
	text->setZ(2000);
	text->setAlignment(ALIGN_CENTER);
	text->setType(ENTITY_FLYING_TEXT);
	while (textTooClose(text, 15, 15)) text->setY(text->getY() - 5);
	}
	}

	bool BaseCreatureEntity::isAttacking()
	{
	return false;
	}
	diff --git a/src/BaseCreatureEntity.h b/src/BaseCreatureEntity.h
	index dc0b7e9..6f1e019 100644
	--- a/src/BaseCreatureEntity.h
	+++ b/src/BaseCreatureEntity.h
	@@ -1,318 +1,319 @@
	#ifndef BASECREATUREENTITY_H
	#define BASECREATUREENTITY_H

	#include "sfml_game/CollidingSpriteEntity.h"
	#include "TextEntity.h"
	#include "Constants.h"

	enum enemyTypeEnum
	{
	// normal
	EnemyTypeBat,
	EnemyTypeBatSkeleton,
	EnemyTypeRat,
	EnemyTypeRatBlack,
	EnemyTypeRatHelmet,
	EnemyTypeRatBlackHelmet,
	EnemyTypeEvilFlower,
	EnemyTypeEvilFlowerIce,
	EnemyTypeEvilFlowerFire,
	EnemyTypeSnake,
	EnemyTypeSnakeBlood,
	EnemyTypeSlime,
	EnemyTypeSlimeRed,
	EnemyTypeSlimeBlue,
	EnemyTypeSlimeViolet,
	EnemyTypeImpBlue,
	EnemyTypeImpRed,
	EnemyTypePumpkin,
	EnemyTypeWitch,
	EnemyTypeWitchRed,
	EnemyTypeCauldron,
	EnemyTypeCauldronElemental,
	EnemyTypeSpiderEgg,
	EnemyTypeSpiderLittle,
	EnemyTypeSpiderTarantula,
	EnemyTypeGhost,
	EnemyTypeZombie,
	EnemyTypeZombieDark,
	EnemyTypeBogeyman,
	EnemyTypeSlimeLarge,
	EnemyTypeSlimeRedLarge,
	EnemyTypeSlimeBlueLarge,
	EnemyTypeSlimeVioletLarge,
	EnemyTypeSausage,

	// mini boss
	EnemyTypeBubble,
	EnemyTypeBubbleIce,
	EnemyTypeBubbleGreater,

	// boss
	EnemyTypeButcher,
	EnemyTypeSlimeBoss,
	EnemyTypeCyclops,
	EnemyTypeRatKing,
	EnemyTypeSpiderGiant,
	EnemyTypeFrancky,
	EnemyTypeVampire,

	// invocated
	EnemyTypeBat_invocated,
	EnemyTypeBatSkeleton_invocated,
	EnemyTypeRat_invocated,
	EnemyTypeRatGreen,
	EnemyTypeRatHelmet_invocated,
	EnemyTypeSnake_invocated,
	EnemyTypeSnakeBlood_invocated,
	EnemyTypeSlime_invocated,
	EnemyTypeSlimeRed_invocated,
	EnemyTypeSlimeBlue_invocated,
	EnemyTypeSlimeViolet_invocated,
	EnemyTypePumpkin_invocated,
	EnemyTypeSpiderEgg_invocated,
	EnemyTypeSpiderLittle_invocated,
	EnemyTypeSpiderTarantula_invocated,
	EnemyTypeZombie_invocated,
	EnemyTypeSausage_invocated,

	EnemyTypeRockFalling,
	EnemyTypeRockMissile,
	EnemyTypeSpiderWeb,

	EnemyTypeFranckyHead,
	EnemyTypeFranckyHand,
	EnemyTypeFranckyFoot,

	EnemyTypeVampireDead,

	EnemyTypeNone, // player of fairy
	EnemyTypeDestroyable,

	NB_ENEMY // = no enemy
	};

	enum sourceTypeEnum
	{
	SourceTypeMelee,
	SourceTypeBolt,
	SourceTypeExplosion,
	SourceTypePoison
	};

	struct StructHurt
	{
	int damage;
	enumShotType hurtingType;
	int level;
	bool critical;
	sourceTypeEnum sourceType;
	enemyTypeEnum enemyType;
	bool goThrough;
	};

	enum enumSpecialState
	{
	SpecialStateIce, // = 0
	SpecialStateSlow, // param 1 = multiplier
	SpecialStateSpeed, // param 1 = multiplier
	SpecialStatePoison,
	SpecialStateWeakness,
	SpecialStateStrength,
	SpecialStateRage,
	SpecialStateConfused,
	SpecialStateTime,

	DivineStateProtection,
	DivineStateSpeed,
	DivineStateFireRate,
	DivineStateFireDamage,

	NB_SPECIAL_STATES
	};

	enum enumStateResistance { ResistanceImmune, ResistanceVeryHigh, ResistanceHigh, ResistanceStandard, ResistanceLow, ResistanceVeryLow};

	enum enumResistances
	{
	ResistanceIce, // = 0
	ResistanceFire,
	ResistanceStone,
	ResistanceLightning,
	ResistanceIllusion,
	ResistancePoison,

	ResistanceRecoil,
	ResistanceFrozen,

	NB_RESISTANCES
	};

	struct specialStateStuct
	{
	enumSpecialState type;
	bool active;
	float timer;
	float param1;
	float param2;
	float param3;
	bool waitUnclear;
	};

	const std::string specialStateToLabel[NB_SPECIAL_STATES] =
	{
	"state_frozen",
	"state_slow",
	"state_speed",
	"state_poison",
	"state_weakness",
	"state_strength",
	"state_rage",
	"state_confusion",
	"state_time",

	"state_div_protection",
	"state_div_speed",
	"state_div_firerate",
	"state_div_damage"
	};

	const sf::Color specialStateToColor[NB_SPECIAL_STATES] =
	{
	sf::Color(100, 200, 255),
	sf::Color::Red,
	sf::Color::White,
	sf::Color::Green,
	sf::Color::Red,
	sf::Color::White,
	sf::Color::White,
	sf::Color::White,
	sf::Color::Red,

	sf::Color::Yellow,
	sf::Color::Yellow,
	sf::Color::Yellow,
	sf::Color::Yellow
	};

	class BaseCreatureEntity : public CollidingSpriteEntity
	{
	public:
	BaseCreatureEntity(sf::Texture* image, float x, float y, int spriteWidth, int spriteHeight);
	int getHp();
	int getHpMax();
	void setHp(int hp);
	void setHpMax(int hpMax);
	int getHpDisplay();
	float getCreatureSpeed();

	IntCoord getCurrentTile();

	virtual void animate(float delay);
	virtual float animateStates(float delay);
	virtual void animateColors(float delay);
	virtual void animateRecoil(float delay);
	virtual void animatePhysics(float delay);
	virtual void render(sf::RenderTarget* app);
	virtual void calculateBB();
	virtual bool collideWithMap(int direction);
	void displayFlyingText(float xText, float yText, int sizeText, std::string text, TextEntity::colorTypeEnum color);
	virtual int hurt(StructHurt hurtParam);
	virtual void prepareDying();
	virtual void dying();
	enum enumMovingStyle { movWalking, movFlying};
	virtual enumMovingStyle getMovingStyle();
	enum enumBloodColor
	{
	BloodNone = -1,
	BloodRed,
	BloodGreen,
	BloodRock,
	BloodEgg,
	BloodBubble,
	BloodBubbleIce,
	BloodBlack,
	BloodBarrel,
	BloodBarrelPowder,
	BloodSkull
	};

	specialStateStuct specialState[NB_SPECIAL_STATES];
	virtual void setSpecialState(enumSpecialState state, bool active, float timer, float param1, float param2, bool waitUnclear = false);

	enumStateResistance resistance[NB_RESISTANCES];

	bool isSpecialStateActive(enumSpecialState state);
	specialStateStuct getSpecialState(enumSpecialState state);

	virtual void giveRecoil(bool stun, Vector2D velocity, float timer);
	virtual void inflictsRecoilTo(BaseCreatureEntity* targetEntity);
	virtual void computeFacingDirection();
	virtual void dyingFromAge();
	virtual bool canCollide();
	bool canSee(float xf, float yf);
	bool canWalkTo(float xf, float yf);

	void heal(int healPoints);

	static StructHurt getHurtParams(int damage,
	enumShotType hurtingType,
	int level,
	bool critical,
	sourceTypeEnum sourceType,
	enemyTypeEnum enemyType,
	bool goThrough)
	{
	StructHurt hurtParams;
	hurtParams.damage = damage;
	hurtParams.hurtingType = hurtingType;
	hurtParams.level = level;
	hurtParams.critical = critical;
	hurtParams.sourceType = sourceType;
	hurtParams.enemyType = enemyType;
	hurtParams.goThrough = goThrough;

	return hurtParams;
	}

	bool intersectsSegments(Vector2D a1, Vector2D a2, Vector2D b1, Vector2D b2);
	bool intersectsTile(Vector2D a1, Vector2D a2, int xTile, int yTile);

	virtual bool isAttacking(); // true when the monster is performing a melee attack

	protected:
	int hp;
	int hpMax;
	int hpDisplay;
	float creatureSpeed;
	+ bool doesAccelerate;
	int shadowFrame;
	int facingDirection;
	float armor;

	bool canExplode; // true if the monster can explode with a fire attack
	bool displayDamage;

	bool hurting;
	float hurtingDelay;
	enumShotType hurtingType;
	enumBloodColor bloodColor;
	enumMovingStyle movingStyle;

	struct recoilStruct
	{
	bool active;
	Vector2D velocity;
	bool stun;
	float timer;
	} recoil;

	void generateStar(sf::Color starColor);
	virtual void makeExplode();

	private:
	bool determineSatusChance(enumStateResistance resistance, int level);
	int determineDamageBonus(enumStateResistance resistance, int level);
	bool textTooClose(TextEntity* textEntity, float xDistMin, float yDistMin);
	};

	#endif // BASECREATUREENTITY_H
	diff --git a/src/RatEntity.cpp b/src/RatEntity.cpp
	index f398740..674cca2 100644
	--- a/src/RatEntity.cpp
	+++ b/src/RatEntity.cpp
	@@ -1,219 +1,220 @@
	#include "RatEntity.h"
	#include "BoltEntity.h"
	#include "PlayerEntity.h"
	#include "sfml_game/SpriteEntity.h"
	#include "sfml_game/ImageManager.h"
	#include "sfml_game/SoundManager.h"
	#include "Constants.h"
	#include "WitchBlastGame.h"

	RatEntity::RatEntity(float x, float y, ratTypeEnum ratType, bool invocated)
	: EnemyEntity (ImageManager::getInstance().getImage(IMAGE_RAT), x, y)
	{
	this->ratType = ratType;
	imagesProLine = 10;
	this->invocated = invocated;
	+ doesAccelerate = true;

	if (ratType == RatTypeNormal)
	{
	frame = 1;
	dyingFrame = 9;
	deathFrame = FRAME_CORPSE_RAT;
	if (invocated) enemyType = EnemyTypeRat_invocated;
	else enemyType = EnemyTypeRat;
	hp = RAT_HP;
	creatureSpeed = RAT_SPEED;
	}
	else //(ratType == RatTypeHelmet)
	{
	frame = 31;
	dyingFrame = 39;
	deathFrame = FRAME_CORPSE_RAT_HELMET;
	if (invocated) enemyType = EnemyTypeRatHelmet_invocated;
	else enemyType = EnemyTypeRatHelmet;
	hp = RAT_HP_HELMET;
	creatureSpeed = RAT_SPEED_HELMET;
	}

	direction = rand() % 4;
	clockTurn = rand() % 2 == 0;
	compute(false);
	timer = 5 + rand() % 6;

	meleeDamages = RAT_DAMAGES;

	bloodColor = BloodRed;
	shadowFrame = -1;

	agonizingSound = SOUND_RAT_DYING;
	sprite.setOrigin(32.0f, 38.0f);
	}

	void RatEntity::animate(float delay)
	{
	if (age > 0.0f && !isAgonising)
	{
	timer -= delay;
	if (timer < 0.0f)
	{
	timer = 5 + rand() % 6;
	if (rand() % 3 == 0) clockTurn = !clockTurn;
	compute(true);
	}

	frame = ((int)(age * 7.0f)) % 4;
	if (frame == 3) frame = 1;
	if (facingDirection == 4 \|\| facingDirection == 6) frame += 3;
	isMirroring = (facingDirection == 6 );
	if (facingDirection == 8) frame += 6;
	if (ratType == RatTypeHelmet) frame += 30;
	}

	EnemyEntity::animate(delay);
	z = y + 17;
	}

	void RatEntity::compute(bool turn)
	{
	if (turn)
	{
	if (clockTurn)
	{
	direction++;
	if (direction == 4) direction = 0;
	}
	else
	{
	direction--;
	if (direction < 0) direction = 3;
	}
	}

	velocity = Vector2D{0, 0};
	switch (direction)
	{
	case 0:
	acceleration.x = 0;
	acceleration.y = -creatureSpeed / 20;
	facingDirection = 8;
	break;

	case 1:
	acceleration.x = creatureSpeed / 20;
	acceleration.y = 0;
	facingDirection = 6;
	break;

	case 2:
	acceleration.x = 0;
	acceleration.y = creatureSpeed / 20;
	facingDirection = 2;
	break;

	case 3:
	acceleration.x = -creatureSpeed / 20;
	acceleration.y = 0;
	facingDirection = 4;
	break;
	}
	}

	void RatEntity::calculateBB()
	{
	boundingBox.left = (int)x - width / 2 + RAT_BB_LEFT;
	boundingBox.width = width - RAT_BB_WIDTH_DIFF;
	boundingBox.top = (int)y - 13;
	boundingBox.height = 31;
	}

	void RatEntity::collideMapRight()
	{
	if (recoil.active) recoil.active = false;
	compute(true);
	}

	void RatEntity::collideMapLeft()
	{
	if (recoil.active) recoil.active = false;
	compute(true);
	}

	void RatEntity::collideMapTop()
	{
	if (recoil.active) recoil.active = false;
	compute(true);
	}

	void RatEntity::collideMapBottom()
	{
	if (recoil.active) recoil.active = false;
	compute(true);
	}

	void RatEntity::collideWithEnemy(EnemyEntity* entity)
	{
	if (entity->getMovingStyle() == movWalking)
	{
	Vector2D recoilVector = Vector2D(entity->getX(), entity->getY()).vectorTo(Vector2D(x, y), 50.0f);
	giveRecoil(false, recoilVector, 0.2f);
	compute(true);
	}
	}

	void RatEntity::collideWithBolt(BoltEntity* boltEntity)
	{
	if (ratType == RatTypeHelmet && boltEntity->getBoltType() != ShotTypeIllusion)
	{
	int collisionDir = getCollisionDirection(boltEntity);
	bool boltCollide = true;

	switch (facingDirection)
	{
	case 4:
	if (collisionDir == 7 \|\| collisionDir == 4 \|\| collisionDir == 1) boltCollide = false;
	break;
	case 2:
	if (collisionDir == 1 \|\| collisionDir == 2 \|\| collisionDir == 3) boltCollide = false;
	break;
	case 6:
	if (collisionDir == 9 \|\| collisionDir == 6 \|\| collisionDir == 3) boltCollide = false;
	break;
	case 8:
	if (collisionDir == 7 \|\| collisionDir == 8 \|\| collisionDir == 9) boltCollide = false;
	break;
	}
	if (boltCollide) EnemyEntity::collideWithBolt(boltEntity);
	else
	{
	float xs = (x + boltEntity->getX()) / 2;
	float ys = (y + boltEntity->getY()) / 2;
	boltEntity->collide();
	SpriteEntity* star = new SpriteEntity(ImageManager::getInstance().getImage(IMAGE_HURT_IMPACT), xs, ys);
	star->setFading(true);
	star->setZ(y+ 100);
	star->setLifetime(0.7f);
	star->setType(ENTITY_EFFECT);
	star->setSpin(400.0f);
	SoundManager::getInstance().playSound(SOUND_CLANG_00);

	boltEntity->loseDamages(boltEntity->getDamages());

	if (boltEntity->getBoltType() == ShotTypeStone)
	{
	float factor = (boltEntity->isFromPlayer() && game().getPlayer()->isEquiped(EQUIP_RAPID_SHOT)) ? 0.25f : 1.0f;
	float recoilVelocity = factor * STONE_DECOIL_VELOCITY[boltEntity->getLevel()];
	float recoilDelay = factor * STONE_DECOIL_DELAY[boltEntity->getLevel()];

	Vector2D recoilVector = Vector2D(0, 0).vectorTo(boltEntity->getVelocity(),
	recoilVelocity );
	giveRecoil(true, recoilVector, recoilDelay);
	}
	}
	}
	else EnemyEntity::collideWithBolt(boltEntity);
	}

	void RatEntity::drop()
	{
	if (!invocated) EnemyEntity::drop();
	}

File Metadata

Mime Type: text/x-diff
Expires: Thu, May 14, 11:44 PM (1 d, 2 h ago)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 63713
Default Alt Text: (36 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions