No OneTemporary
Actions

Authored By

Unknown

Size

37 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/src/CyclopEntity.cpp b/src/CyclopEntity.cpp
	index 3373552..4358284 100644
	--- a/src/CyclopEntity.cpp
	+++ b/src/CyclopEntity.cpp
	@@ -1,373 +1,374 @@
	#include "CyclopEntity.h"
	#include "BoltEntity.h"
	#include "PlayerEntity.h"
	#include "RockMissileEntity.h"
	#include "FallingRockEntity.h"
	#include "sfml_game/SpriteEntity.h"
	#include "sfml_game/ImageManager.h"
	#include "sfml_game/SoundManager.h"
	#include "Constants.h"
	#include "WitchBlastGame.h"

	#include <iostream>

	CyclopEntity::CyclopEntity(float x, float y)
	: EnnemyEntity (ImageManager::getImageManager()->getImage(IMAGE_CYCLOP), x, y)
	{
	width = 128;
	height = 192;
	creatureSpeed = CYCLOP_SPEED[0];
	velocity = Vector2D(creatureSpeed);
	hp = CYCLOP_HP;
	hpDisplay = CYCLOP_HP;
	hpMax = CYCLOP_HP;
	meleeDamages = CYCLOP_DAMAGES;


	type = ENTITY_ENNEMY_BOSS;
	bloodColor = bloodRed;
	shadowFrame = 8;
	dyingFrame = 5;
	deathFrame = FRAME_CORPSE_CYCLOP;
	frame = 0;
	if (game().getPlayerPosition().x > x) isMirroring = true;

	nextRockMissile = 0;
	destroyLevel = 0;
	state = 0;
	timer = 2.0f;
	counter = 10;
	age = -1.5f;

	resistance[ResistanceFrozen] = ResistanceVeryHigh;
	+ resistance[ResistanceRecoil] = ResistanceVeryHigh;
	}

	int CyclopEntity::getHealthLevel()
	{
	int healthLevel = 0;
	if (hp <= hpMax * 0.25) healthLevel = 3;
	else if (hp <= hpMax * 0.5) healthLevel = 2;
	else if (hp <= hpMax * 0.75) healthLevel = 1;
	return healthLevel;
	}

	void CyclopEntity::fire()
	{
	new RockMissileEntity(x, y+30, nextRockMissile);
	SoundManager::getSoundManager()->playSound(SOUND_THROW);
	}

	void CyclopEntity::initFallingGrid()
	{
	for (int i = 0; i < MAP_WIDTH; i++)
	for (int j = 0; j < MAP_HEIGHT; j++)
	fallingGrid[i][j] = false;
	}

	void CyclopEntity::fallRock()
	{
	int rx, ry;
	do
	{
	rx = 1 + rand() % (MAP_WIDTH - 2);
	ry = 1 + rand() % (MAP_HEIGHT - 2);
	}
	while (fallingGrid[rx][ry]);

	fallingGrid[rx][ry] = true;
	new FallingRockEntity(rx * TILE_WIDTH + OFFSET_X + TILE_WIDTH / 2,
	ry * TILE_HEIGHT + OFFSET_Y + TILE_HEIGHT / 2,
	rand() % 3);
	}


	void CyclopEntity::computeNextRockMissile()
	{
	if (getHealthLevel() == 0)
	nextRockMissile = rand()%5 == 0 ? 1 : 0;
	else if (getHealthLevel() == 1)
	nextRockMissile = rand()%3 == 0 ? 1 : 0;
	else if (getHealthLevel() == 2)
	nextRockMissile = rand()%2 == 0 ? 0 : 1;
	else
	nextRockMissile = rand()%3 == 0 ? 0 : 1;
	}

	void CyclopEntity::computeStates(float delay)
	{
	timer -= delay;

	if (timer <= 0.0f)
	{
	if (state == 0) // walking
	{
	if (counter > 0)
	{
	counter--;
	timer = 0.5f;
	creatureSpeed = CYCLOP_SPEED[getHealthLevel()];
	setVelocity(Vector2D(x + 32, y + 96).vectorTo(game().getPlayerPosition(), creatureSpeed ));
	}
	else
	{
	velocity.x = 0.0f;
	velocity.y = 0.0f;
	if (destroyLevel < getHealthLevel())
	{
	state = 3; // charge to destroy
	destroyLevel++;
	counter = destroyLevel + 1;
	timer = 0.9f;
	SoundManager::getSoundManager()->playSound(SOUND_CYCLOP00);
	initFallingGrid();
	}
	else
	{
	state = 1; // charge to fire
	timer = 0.9f;
	counter = CYCLOP_NUMBER_ROCKS[getHealthLevel()];
	SoundManager::getSoundManager()->playSound(SOUND_CYCLOP00);

	computeNextRockMissile();
	}
	}
	}
	else if (state == 1) // fire
	{
	state = 2;
	fire();
	timer = CYCLOP_FIRE_DELAY[getHealthLevel()];
	}
	else if (state == 2) // fire end
	{
	if (counter <= 1)
	{
	state = 0;
	timer = 0.2f;
	counter = 10;
	}
	else
	{
	counter--;
	state = 1;
	timer = 0.2f;
	computeNextRockMissile();
	}
	}
	else if (state == 3)
	{
	state = 4; // destroy
	timer = 0.2;
	game().makeShake(0.4f);
	SoundManager::getSoundManager()->playSound(SOUND_WALL_IMPACT);
	for (int i = 0; i < 10 ; i++) fallRock();
	}
	else if (state == 4)
	{
	if (counter <= 1)
	{
	state = 0;
	timer = 0.2f;
	counter = 10;
	}
	else
	{
	counter--;
	state = 3;
	timer = 0.3f;
	}
	}
	}
	}

	void CyclopEntity::animate(float delay)
	{
	if (age <= 0.0f)
	{
	age += delay;
	return;
	}

	if (isAgonising)
	{
	if (h < -0.01f)
	{
	isDying = true;
	SpriteEntity* corpse;
	corpse = new SpriteEntity(ImageManager::getImageManager()->getImage(IMAGE_CORPSES_BIG), x, y + 48, 128, 128);
	corpse->setFrame(deathFrame - FRAME_CORPSE_KING_RAT);

	corpse->setZ(OFFSET_Y);
	corpse->setType(ENTITY_CORPSE);
	if (dyingSound != SOUND_NONE) SoundManager::getSoundManager()->playSound(dyingSound);
	}
	else
	{
	frame = dyingFrame;
	hVelocity -= 700.0f * delay;
	h += hVelocity * delay;
	}

	return;
	}

	// special states
	if (specialState[SpecialStateIce].active) delay *= specialState[SpecialStateIce].parameter;

	// IA
	computeStates(delay);

	// collisions
	if (canCollide()) testSpriteCollisions();
	BaseCreatureEntity::animate(delay);

	// current frame
	if (state == 0)
	{
	int r = ((int)(age * 5.0f)) % 4;
	if (r == 2) frame = 0;
	else if (r == 3) frame = 2;
	else frame = r;
	}
	else if (state == 1)
	{
	isMirroring = game().getPlayer()->getX() > x;
	frame = 3;
	}
	else if (state == 2)
	{
	frame = 4;
	}
	else if (state == 3)
	{
	frame = 6;
	}
	else if (state == 4)
	{
	frame = 7;
	}

	// frame's mirroring
	if (velocity.x > 1.0f)
	isMirroring = true;
	else if (velocity.x < -1.0f)
	isMirroring = false;
	}

	bool CyclopEntity::hurt(int damages, enumShotType hurtingType, int level)
	{
	return EnnemyEntity::hurt(damages, hurtingType, level);
	}

	void CyclopEntity::calculateBB()
	{
	boundingBox.left = OFFSET_X + (int)x - width / 2 + 64;
	boundingBox.width = 58;
	boundingBox.top = OFFSET_Y + (int)y - height / 2 + 152;
	boundingBox.height = 90;
	}

	void CyclopEntity::afterWallCollide()
	{
	}
	void CyclopEntity::collideMapRight()
	{
	velocity.x = -velocity.x;

	afterWallCollide();
	}

	void CyclopEntity::collideMapLeft()
	{
	velocity.x = -velocity.x;

	afterWallCollide();
	}

	void CyclopEntity::collideMapTop()
	{
	velocity.y = -velocity.y;

	afterWallCollide();
	}

	void CyclopEntity::collideMapBottom()
	{
	velocity.y = -velocity.y;

	afterWallCollide();
	}

	void CyclopEntity::dying()
	{
	EnnemyEntity::dying();
	}

	void CyclopEntity::drop()
	{
	ItemEntity* newItem = new ItemEntity(itemBossHeart, x + 32, y + 96);
	newItem->setVelocity(Vector2D(100.0f + rand()% 250));
	newItem->setViscosity(0.96f);
	}

	void CyclopEntity::render(sf::RenderTarget* app)
	{
	EnnemyEntity::render(app);

	// stones
	if (state == 1)
	{
	if (nextRockMissile == 0) // small rock
	{
	sprite.setTextureRect(sf::IntRect(1152, 0, 64, 64));
	if (isMirroring)
	sprite.setPosition(x + 60, y);
	else
	sprite.setPosition(x + 4, y);
	}
	else // medium rock
	{
	sprite.setTextureRect(sf::IntRect(1152, 64, 64, 64));
	if (isMirroring)
	sprite.setPosition(x + 60, y - 12);
	else
	sprite.setPosition(x + 4, y - 12);
	}

	app->draw(sprite);
	sprite.setPosition(x, y);
	}

	float l = hpDisplay * ((MAP_WIDTH - 1) * TILE_WIDTH) / hpMax;

	sf::RectangleShape rectangle(sf::Vector2f((MAP_WIDTH - 1) * TILE_WIDTH, 25));
	rectangle.setFillColor(sf::Color(0, 0, 0,128));
	rectangle.setPosition(sf::Vector2f(OFFSET_X + TILE_WIDTH / 2, OFFSET_Y + 25 + (MAP_HEIGHT - 1) * TILE_HEIGHT));
	app->draw(rectangle);

	rectangle.setSize(sf::Vector2f(l, 25));
	rectangle.setFillColor(sf::Color(190, 20, 20));
	rectangle.setPosition(sf::Vector2f(OFFSET_X + TILE_WIDTH / 2, OFFSET_Y + 25 + (MAP_HEIGHT - 1) * TILE_HEIGHT));
	app->draw(rectangle);

	game().write( "Cimmerian Cyclop",
	18,
	OFFSET_X + TILE_WIDTH / 2 + 10.0f,
	OFFSET_Y + 25 + (MAP_HEIGHT - 1) * TILE_HEIGHT + 1.0f,
	ALIGN_LEFT,
	sf::Color(255, 255, 255),
	app, 0 , 0);
	}

	void CyclopEntity::collideWithEnnemy(GameEntity* collidingEntity)
	{
	EnnemyEntity* entity = static_cast<EnnemyEntity*>(collidingEntity);
	if (entity->getMovingStyle() == movWalking)
	{
	inflictsRecoilTo(entity);
	}
	}

	void CyclopEntity::inflictsRecoilTo(BaseCreatureEntity* targetEntity)
	{
	}
	diff --git a/src/EnnemyEntity.cpp b/src/EnnemyEntity.cpp
	index 2b25371..7ef6209 100644
	--- a/src/EnnemyEntity.cpp
	+++ b/src/EnnemyEntity.cpp
	@@ -1,240 +1,254 @@
	#include "EnnemyEntity.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 <iostream>
	#include "WitchBlastGame.h"

	EnnemyEntity::EnnemyEntity(sf::Texture* image, float x, float y)
	: BaseCreatureEntity (image, x, y, 64, 64)
	{
	type = ENTITY_ENNEMY;
	bloodColor = bloodRed;

	z = y;
	h = 0;
	age = -0.001f * (rand()%800) - 0.4f;

	deathFrame = -1;
	dyingFrame = -1;
	dyingSound = SOUND_ENNEMY_DYING;
	agonizingSound = SOUND_NONE;
	hurtingSound = SOUND_NONE;
	isAgonising = false;
	}

	void EnnemyEntity::animate(float delay)
	{
	if (isAgonising)
	{
	if (h < -0.01f)
	{
	isDying = true;
	SpriteEntity* corpse;
	if (deathFrame >= FRAME_CORPSE_KING_RAT)
	{
	corpse = new SpriteEntity(ImageManager::getImageManager()->getImage(IMAGE_CORPSES_BIG), x, y, 128, 128);
	corpse->setFrame(deathFrame - FRAME_CORPSE_KING_RAT);
	}
	else
	{
	corpse = new SpriteEntity(ImageManager::getImageManager()->getImage(IMAGE_CORPSES), x, y, 64, 64);
	corpse->setFrame(deathFrame);
	}

	corpse->setZ(OFFSET_Y);
	corpse->setType(ENTITY_CORPSE);
	if (dyingSound != SOUND_NONE) SoundManager::getSoundManager()->playSound(dyingSound);
	}
	else
	{
	frame = dyingFrame;
	hVelocity -= 700.0f * delay;
	h += hVelocity * delay;
	}

	return;
	}

	if (canCollide()) testSpriteCollisions();
	if (age > 0.0f)
	BaseCreatureEntity::animate(delay);
	else
	age += delay;
	}

	void EnnemyEntity::calculateBB()
	{
	boundingBox.left = (int)x - width / 2;
	boundingBox.width = width;
	boundingBox.top = (int)y - height / 2;
	boundingBox.height = height;
	}

	void EnnemyEntity::collideMapRight()
	{
	velocity.x = 0.0f;
	}

	void EnnemyEntity::collideMapLeft()
	{
	velocity.x = 0.0f;
	}

	void EnnemyEntity::collideMapTop()
	{
	velocity.y = 0.0f;
	}

	void EnnemyEntity::collideMapBottom()
	{
	velocity.y = 0.0f;
	}

	void EnnemyEntity::readCollidingEntity(CollidingSpriteEntity* entity)
	{
	if (!isDying && !isAgonising && collideWithEntity(entity))
	{
	if (entity->getType() == ENTITY_PLAYER \|\| entity->getType() == ENTITY_BOLT )
	{
	PlayerEntity* playerEntity = dynamic_cast<PlayerEntity*>(entity);
	BoltEntity* boltEntity = dynamic_cast<BoltEntity*>(entity);

	if (playerEntity != NULL && !playerEntity->isDead())
	{
	if (playerEntity->hurt(meleeDamages, ShotTypeStandard, 0))
	{
	float xs = (x + playerEntity->getX()) / 2;
	float ys = (y + playerEntity->getY()) / 2;
	SpriteEntity* star = new SpriteEntity(ImageManager::getImageManager()->getImage(IMAGE_STAR_2), xs, ys);
	star->setFading(true);
	star->setZ(y+ 100);
	star->setLifetime(0.7f);
	star->setType(16);
	star->setSpin(400.0f);
	}
	inflictsRecoilTo(playerEntity);
	}

	else if (boltEntity != NULL && !boltEntity->getDying() && boltEntity->getAge() > 0.05f)
	{
	boltEntity->collide();
	hurt(boltEntity->getDamages(), boltEntity->getBoltType(), boltEntity->getLevel());
	if (bloodColor > bloodNone) game().generateBlood(x, y, bloodColor);
	SoundManager::getSoundManager()->playSound(SOUND_IMPACT);

	float xs = (x + boltEntity->getX()) / 2;
	float ys = (y + boltEntity->getY()) / 2;
	SpriteEntity* star = new SpriteEntity(ImageManager::getImageManager()->getImage(IMAGE_STAR_2), xs, ys);
	star->setFading(true);
	star->setZ(y+ 100);
	star->setLifetime(0.7f);
	star->setType(16);
	star->setSpin(400.0f);

	if (boltEntity->getBoltType() == ShotTypeStone)
	{
	+ float recoilVelocity = STONE_DECOIL_VELOCITY[boltEntity->getLevel()];
	+ float recoilDelay = STONE_DECOIL_DELAY[boltEntity->getLevel()];
	+
	+ if (resistance[ResistanceRecoil] == ResistanceHigh)
	+ {
	+ recoilVelocity *= 0.75f;
	+ recoilDelay *= 0.75f;
	+ }
	+ else if (resistance[ResistanceRecoil] == ResistanceVeryHigh)
	+ {
	+ recoilVelocity *= 0.5f;
	+ recoilDelay *= 0.5f;
	+ }
	+
	Vector2D recoilVector = Vector2D(boltEntity->getX(),
	boltEntity->getY()).vectorTo(Vector2D(x, y),
	- STONE_DECOIL_VELOCITY[boltEntity->getLevel()] );
	- giveRecoil(true, recoilVector, STONE_DECOIL_DELAY[boltEntity->getLevel()]);
	+ recoilVelocity );
	+ giveRecoil(true, recoilVector, recoilDelay);
	}
	}
	}
	else // collision with other enemy ?
	{
	if (entity->getType() >= ENTITY_ENNEMY && entity->getType() <= ENTITY_ENNEMY_MAX)
	{
	if (this != entity)
	{
	EnnemyEntity* ennemyEntity = static_cast<EnnemyEntity*>(entity);
	if (ennemyEntity->canCollide()) collideWithEnnemy(entity);
	}
	}
	}
	}
	}

	void EnnemyEntity::collideWithEnnemy(GameEntity* collidingEntity)
	{
	// To implement the behaviour when colliding with another ennemy
	}

	bool EnnemyEntity::hurt(int damages, enumShotType hurtingType, int level)
	{
	bool hurted = BaseCreatureEntity::hurt(damages, hurtingType, level);
	if (hurted && hurtingSound != SOUND_NONE && hp > 0)
	SoundManager::getSoundManager()->playSound(hurtingSound);
	return hurted;
	}

	void EnnemyEntity::dying()
	{
	if (dyingFrame == -1)
	{
	isDying = true;
	SpriteEntity* corpse = new SpriteEntity(ImageManager::getImageManager()->getImage(IMAGE_CORPSES), x, y, 64, 64);
	corpse->setZ(OFFSET_Y);
	corpse->setFrame(deathFrame);
	corpse->setType(ENTITY_CORPSE);
	if (dyingSound != SOUND_NONE) SoundManager::getSoundManager()->playSound(dyingSound);
	}
	else
	{
	isAgonising = true;
	hVelocity = 200.0f;
	if (agonizingSound != SOUND_NONE) SoundManager::getSoundManager()->playSound(agonizingSound);
	}
	for (int i = 0; i < 4; i++) game().generateBlood(x, y, bloodColor);
	drop();
	}

	void EnnemyEntity::drop()
	{
	if (rand() % 5 == 0)
	{
	ItemEntity* newItem = new ItemEntity(ItemCopperCoin, x, y);
	newItem->setMap(map, TILE_WIDTH, TILE_HEIGHT, OFFSET_X, OFFSET_Y);
	newItem->setVelocity(Vector2D(100.0f + rand()% 250));
	newItem->setViscosity(0.96f);
	}
	}

	bool EnnemyEntity::canCollide()
	{
	return (!isAgonising);
	}

	void EnnemyEntity::render(sf::RenderTarget* app)
	{
	if (isAgonising \|\| (isDying && dyingFrame > -1))
	{
	if (shadowFrame > -1)
	{
	// shadow
	sprite.setPosition(x, y);
	sprite.setTextureRect(sf::IntRect(shadowFrame * width, 0, width, height));
	app->draw(sprite);
	}
	int nx = dyingFrame;
	int ny = 0;
	if (imagesProLine > 0)
	{
	nx = dyingFrame % imagesProLine;
	ny = dyingFrame / imagesProLine;
	}
	sprite.setPosition(x, y - h);
	if (isMirroring)
	sprite.setTextureRect(sf::IntRect(nx * width + width, ny * height, -width, height));
	else
	sprite.setTextureRect(sf::IntRect(nx * width, ny * height, width, height));

	app->draw(sprite);
	}

	else
	BaseCreatureEntity::render(app);
	}
	diff --git a/src/GiantSlimeEntity.cpp b/src/GiantSlimeEntity.cpp
	index 3cf64ca..9c2244c 100644
	--- a/src/GiantSlimeEntity.cpp
	+++ b/src/GiantSlimeEntity.cpp
	@@ -1,450 +1,451 @@
	#include "GiantSlimeEntity.h"
	#include "BoltEntity.h"
	#include "EnnemyBoltEntity.h"
	#include "PlayerEntity.h"
	#include "SlimeEntity.h"
	#include "sfml_game/SpriteEntity.h"
	#include "sfml_game/ImageManager.h"
	#include "sfml_game/SoundManager.h"
	#include "Constants.h"
	#include "WitchBlastGame.h"

	#include <iostream>

	GiantSlimeEntity::GiantSlimeEntity(float x, float y)
	: EnnemyEntity (ImageManager::getImageManager()->getImage(IMAGE_GIANT_SLIME), x, y)
	{
	width = 128;
	height = 128;
	creatureSpeed = GIANT_SLIME_SPEED;
	velocity = Vector2D(creatureSpeed);
	hp = GIANT_SLIME_HP;
	hpDisplay = hp;
	hpMax = GIANT_SLIME_HP;
	meleeDamages = GIANT_SLIME_DAMAGES;
	missileDelay = GIANT_SLIME_MISSILE_DELAY;

	type = ENTITY_ENNEMY_BOSS;
	bloodColor = bloodGreen;
	shadowFrame = 3;
	frame = 0;
	sprite.setOrigin(64.0f, 64.0f);
	h = 0.0f;

	age = -2.0f;

	changeToState(0);
	slimeCounter = 0;
	slimeTimer =5.0f;

	resistance[ResistanceFrozen] = ResistanceVeryHigh;
	+ resistance[ResistanceRecoil] = ResistanceVeryHigh;
	}

	void GiantSlimeEntity::changeToState(int n)
	{
	if (n == 0) // walking
	{
	state = 0;
	counter = 8 + rand() % 7;
	timer = -1.0f;
	viscosity = 1.0f;
	}
	else if (n == 1 \|\| n == 3 \|\| n == 5 \|\| n == 8) // waiting
	{
	state = n;
	timer = 1.2f;
	setVelocity(Vector2D(0.0f, 0.0f));
	}
	else if (n == 2) // jumping
	{
	state = 2;
	timer = 4.0f;

	viscosity = 0.991f;

	SoundManager::getSoundManager()->playSound(SOUND_SLIME_JUMP);
	hVelocity = 420.0f + rand() % 380;

	isFirstJumping = true;

	float randVel = 350.0f + rand() % 200;

	if (rand() % 2 == 0)
	{
	float tan = (game().getPlayer()->getX() - x) / (game().getPlayer()->getY() - y);
	float angle = atan(tan);

	if (game().getPlayer()->getY() > y)
	setVelocity(Vector2D(sin(angle) * randVel,
	cos(angle) * randVel));
	else
	setVelocity(Vector2D(-sin(angle) * randVel,
	-cos(angle) * randVel));
	}
	else
	velocity = Vector2D(randVel);
	}
	else if (n == 4) // walking
	{
	state = 4;
	if (hp <= hpMax / 4)
	counter = 26;
	if (hp <= hpMax / 2)
	counter = 18;
	else
	counter = 12;
	timer = GIANT_SLIME_MISSILE_DELAY;
	}
	else if (n == 6) // jumping
	{
	state = 6;
	timer = 1.2f;

	viscosity = 1.0f;

	SoundManager::getSoundManager()->playSound(SOUND_SLIME_JUMP);
	hVelocity = 1200.0f;
	}
	else if (n == 7) // falling
	{
	isFalling = false;
	state = 7;
	timer = 4.0f;

	hVelocity = -1500.0f;
	h = 1500;
	}
	}

	void GiantSlimeEntity::animate(float delay)
	{
	slimeTimer -= delay;
	if (slimeTimer <= 0.0f)
	{
	switch (slimeCounter)
	{
	case 0: new SlimeEntity(OFFSET_X + TILE_WIDTH * 1.5f, OFFSET_Y + TILE_HEIGHT * 1.5f, SlimeTypeStandard, true); break;
	case 1: new SlimeEntity(OFFSET_X + TILE_WIDTH * (MAP_WIDTH - 2) + TILE_WIDTH * 0.5f, OFFSET_Y + TILE_HEIGHT * 1.5f, SlimeTypeStandard, true); break;
	case 2: new SlimeEntity(OFFSET_X + TILE_WIDTH * (MAP_WIDTH - 2) + TILE_WIDTH * 0.5f, OFFSET_Y + TILE_HEIGHT * (MAP_HEIGHT - 2) + TILE_HEIGHT * 0.5f, SlimeTypeStandard, true); break;
	case 3: new SlimeEntity(OFFSET_X + TILE_WIDTH * 1.5f, OFFSET_Y + TILE_HEIGHT * (MAP_HEIGHT - 2) + TILE_HEIGHT * 0.5f, SlimeTypeStandard, true); break;
	}
	slimeTimer = 7.0f;
	slimeCounter ++;
	if (slimeCounter == 4) slimeCounter = 0;
	}

	if (age <= 0.0f)
	{
	age += delay;
	return;
	}
	EnnemyEntity::animate(delay);
	if (specialState[SpecialStateIce].active) delay *= specialState[SpecialStateIce].parameter;

	timer -= delay;
	if (timer <= 0.0f)
	{
	if (state == 0) // walking
	{
	counter--;
	if (counter >= 0)
	{
	timer = 0.5f;
	if (hp <= hpMax / 4)
	creatureSpeed = GIANT_SLIME_SPEED * 1.4f;
	if (hp <= hpMax / 2)
	creatureSpeed = GIANT_SLIME_SPEED * 1.2f;
	else
	creatureSpeed = GIANT_SLIME_SPEED;

	setVelocity(Vector2D(x, y).vectorTo(game().getPlayerPosition(), GIANT_SLIME_SPEED ));
	}
	else
	{
	int r = rand() % 3;
	if (r == 0) changeToState(1);
	else if (r == 1) changeToState(3);
	else changeToState(5);
	}
	}
	else if (state == 1) // waiting for jumping
	{
	changeToState(2);
	}
	else if (state == 2) // jumping
	{
	changeToState(8);
	}
	else if (state == 3)
	{
	changeToState(4);
	}
	else if (state == 4) // walking
	{
	counter--;
	if (counter >= 0)
	{
	if (hp <= hpMax / 4)
	timer = missileDelay * 0.6f;
	if (hp <= hpMax / 2)
	timer = missileDelay * 0.8f;
	else
	timer = missileDelay;
	fire();
	}
	else
	{
	changeToState(8);
	}
	}
	else if (state == 5)
	{
	changeToState(6);
	}
	else if (state == 6) // jump
	{
	changeToState(7); // fall
	}
	else if (state == 7) // jump
	{
	}
	else if (state == 8) // jump
	{
	changeToState(0); // fall
	}
	}


	if (state == 0) // walking
	{
	frame = ((int)(age * 2.0f)) % 2;
	}
	else if (state == 1 \|\| state == 5) // waiting to jump
	{
	if (timer < 0.25f)
	frame = 1;
	else
	frame = 0;
	}
	else if (state == 2) // jumping
	{
	hVelocity -= 700.0f * delay;

	h += hVelocity * delay;

	if (h <= 0.0f)
	{
	if (hp <= 0)
	dying();
	else
	{
	h = 0.0f;
	if (isFirstJumping)
	{
	isFirstJumping = false;
	hVelocity = 160.0f;
	SoundManager::getSoundManager()->playSound(SOUND_SLIME_IMAPCT);
	}
	else
	{
	SoundManager::getSoundManager()->playSound(SOUND_SLIME_IMAPCT_WEAK);
	viscosity = 0.96f;
	changeToState(0);
	}
	}
	}
	if (hVelocity > 0.0f) frame = 2;
	else frame = 0;
	}
	else if (state == 6) // ultra jump
	{
	if (h < 2000)
	h += hVelocity * delay;
	}
	else if (state == 7) // ultra jump
	{
	if (!isFalling && timer <= 2.2f)
	{
	isFalling = true;
	x = game().getPlayer()->getX();
	y = game().getPlayer()->getY();
	// to prevent collisions
	if (x < OFFSET_X + TILE_WIDTH * 3) velocity.x = -1.1f;
	else if (x > OFFSET_X + TILE_WIDTH * (MAP_WIDTH - 3)) velocity.x = 1.1f;
	if (y < OFFSET_Y + TILE_HEIGHT * 3) velocity.y = -1.1f;
	else if (y > OFFSET_Y + TILE_HEIGHT * (MAP_HEIGHT - 3)) velocity.y = 1.1f;
	}
	if (timer < 2.3f)
	{
	h += hVelocity * delay;
	if (h <= 0)
	{
	h = 0;
	changeToState(8);
	game().makeShake(0.8f);
	SoundManager::getSoundManager()->playSound(SOUND_WALL_IMPACT);
	}
	}
	}

	//EnnemyEntity::animate(delay);

	if (state == 6 && timer < 0.5f)
	{
	int fade = timer * 512;
	if (fade < 0) fade = 0;
	sprite.setColor(sf::Color(255, 255, 255, fade));
	}
	else if (state == 7 && timer < 1.5f)
	sprite.setColor(sf::Color(255, 255, 255, 255));
	else if (state == 7 && timer < 2.0f)
	sprite.setColor(sf::Color(255, 255, 255, (2.0f - timer) * 512));
	else if (state == 7)
	sprite.setColor(sf::Color(255, 255, 255, 0));
	}

	void GiantSlimeEntity::calculateBB()
	{
	boundingBox.left = (int)x - width / 2 + GIANT_SLIME_BB_LEFT;
	boundingBox.width = width - GIANT_SLIME_BB_WIDTH_DIFF;
	boundingBox.top = (int)y - height / 2 + GIANT_SLIME_BB_TOP;
	boundingBox.height = height - GIANT_SLIME_BB_HEIGHT_DIFF - GIANT_SLIME_BB_TOP;
	}


	void GiantSlimeEntity::collideMapRight()
	{
	velocity.x = -velocity.x;
	}

	void GiantSlimeEntity::collideMapLeft()
	{
	velocity.x = -velocity.x;
	}

	void GiantSlimeEntity::collideMapTop()
	{
	velocity.y = -velocity.y;
	}

	void GiantSlimeEntity::collideMapBottom()
	{
	velocity.y = -velocity.y;
	}


	void GiantSlimeEntity::dying()
	{
	isDying = true;
	SpriteEntity* deadRat = new SpriteEntity(ImageManager::getImageManager()->getImage(IMAGE_CORPSES_BIG), x, y, 128, 128);
	deadRat->setZ(OFFSET_Y);
	deadRat->setFrame(FRAME_CORPSE_GIANT_SLIME - FRAME_CORPSE_KING_RAT);
	deadRat->setType(ENTITY_CORPSE);

	float xSlime = x;
	float ySlime = y;

	if (x <= OFFSET_X + 1.5 * TILE_WIDTH) x = OFFSET_X + 1.5f * TILE_WIDTH + 2;
	else if (x >= OFFSET_X + TILE_WIDTH * MAP_WIDTH - 1.5f * TILE_WIDTH) x = OFFSET_X + TILE_WIDTH * MAP_WIDTH - 1.5f * TILE_WIDTH -3;
	if (y <= OFFSET_Y + 1.5 * TILE_HEIGHT) y = OFFSET_Y + 1.5 * TILE_HEIGHT + 2;
	else if (y >= OFFSET_Y + TILE_HEIGHT * MAP_HEIGHT - 1.5f * TILE_HEIGHT) x = OFFSET_Y + TILE_HEIGHT * MAP_HEIGHT - 1.5f * TILE_HEIGHT -3;

	for (int i = 0; i < 9; i++)
	{
	game().generateBlood(xSlime, ySlime, bloodColor);
	new SlimeEntity(x, y, SlimeTypeStandard, true);
	}

	game().makeShake(1.0f);
	SoundManager::getSoundManager()->playSound(SOUND_SLIME_SMASH);

	ItemEntity* newItem = new ItemEntity(itemBossHeart, x, y);
	newItem->setVelocity(Vector2D(100.0f + rand()% 250));
	newItem->setViscosity(0.96f);

	SpriteEntity* star = new SpriteEntity(ImageManager::getImageManager()->getImage(IMAGE_GIANT_SLIME), x, y, 128, 128, 8);
	star->setFrame(4);
	star->setFading(true);
	star->setZ(y+ 100);
	star->setAge(-0.4f);
	star->setLifetime(0.3f);
	star->setType(16);
	star->setSpin(400.0f);
	}

	void GiantSlimeEntity::render(sf::RenderTarget* app)
	{
	if (!isDying)
	{
	// shadow
	sprite.setPosition(x, y);
	sprite.setTextureRect(sf::IntRect(shadowFrame * width, 0, width, height));
	app->draw(sprite);
	}
	sprite.setPosition(x, y - h);
	sprite.setTextureRect(sf::IntRect(frame * width, 0, width, height));
	app->draw(sprite);

	float l = hpDisplay * ((MAP_WIDTH - 1) * TILE_WIDTH) / GIANT_SLIME_HP;

	sf::RectangleShape rectangle(sf::Vector2f((MAP_WIDTH - 1) * TILE_WIDTH, 25));
	rectangle.setFillColor(sf::Color(0, 0, 0,128));
	rectangle.setPosition(sf::Vector2f(OFFSET_X + TILE_WIDTH / 2, OFFSET_Y + 25 + (MAP_HEIGHT - 1) * TILE_HEIGHT));
	app->draw(rectangle);

	rectangle.setSize(sf::Vector2f(l, 25));
	rectangle.setFillColor(sf::Color(190, 20, 20));
	rectangle.setPosition(sf::Vector2f(OFFSET_X + TILE_WIDTH / 2, OFFSET_Y + 25 + (MAP_HEIGHT - 1) * TILE_HEIGHT));
	app->draw(rectangle);

	game().write( "Giant Slime",
	18,
	OFFSET_X + TILE_WIDTH / 2 + 10.0f,
	OFFSET_Y + 25 + (MAP_HEIGHT - 1) * TILE_HEIGHT + 1.0f,
	ALIGN_LEFT,
	sf::Color(255, 255, 255),
	app, 0, 0);
	}

	void GiantSlimeEntity::collideWithEnnemy(GameEntity* collidingEntity)
	{
	EnnemyEntity* entity = static_cast<EnnemyEntity*>(collidingEntity);
	if (entity->getMovingStyle() == movWalking)
	{
	inflictsRecoilTo(entity);
	}
	}

	void GiantSlimeEntity::inflictsRecoilTo(BaseCreatureEntity* targetEntity)
	{
	if (state == 7)
	{
	Vector2D recoilVector = Vector2D(x, y).vectorTo(Vector2D(targetEntity->getX(), targetEntity->getY()), KING_RAT_RUNNING_RECOIL );
	targetEntity->giveRecoil(true, recoilVector, 1.0f);
	}
	}

	bool GiantSlimeEntity::canCollide()
	{
	return h <= 70.0f;
	}

	BaseCreatureEntity::enumMovingStyle GiantSlimeEntity::getMovingStyle()
	{
	if (h <= 70.0f)
	return movWalking;
	else
	return movFlying;
	}

	void GiantSlimeEntity::fire()
	{
	SoundManager::getSoundManager()->playSound(SOUND_BLAST_FLOWER);
	EnnemyBoltEntity* bolt = new EnnemyBoltEntity
	(x, y + 10, ShotTypeStandard, 0);
	bolt->setFrame(1);
	bolt->setMap(map, TILE_WIDTH, TILE_HEIGHT, OFFSET_X, OFFSET_Y);

	bolt->setVelocity(Vector2D(x, y).vectorTo(game().getPlayerPosition(),GIANT_SLIME_FIRE_VELOCITY ));
	}

	diff --git a/src/KingRatEntity.cpp b/src/KingRatEntity.cpp
	index 8487a80..a458af6 100644
	--- a/src/KingRatEntity.cpp
	+++ b/src/KingRatEntity.cpp
	@@ -1,366 +1,367 @@
	#include "KingRatEntity.h"
	#include "GreenRatEntity.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"

	#include <iostream>

	KingRatEntity::KingRatEntity(float x, float y)
	: EnnemyEntity (ImageManager::getImageManager()->getImage(IMAGE_KING_RAT), x, y)
	{
	width = 128;
	height = 128;
	creatureSpeed = KING_RAT_SPEED;
	velocity = Vector2D(creatureSpeed);
	hp = KING_RAT_HP;
	hpDisplay = hp;
	hpMax = KING_RAT_HP;
	meleeDamages = KING_RAT_DAMAGES;

	type = ENTITY_ENNEMY_BOSS;
	bloodColor = bloodRed;
	shadowFrame = 4;
	frame = 0;
	if (game().getPlayerPosition().x > x) sprite.setScale(-1.0f, 1.0f);
	sprite.setOrigin(64.0f, 64.0f);

	state = 0;
	timer = 2.0f + (rand() % 40) / 10.0f;
	age = -2.0f;

	berserkDelay = 1.0f + rand()%5 * 0.1f;

	hasBeenBerserk = false;

	resistance[ResistanceFrozen] = ResistanceVeryHigh;
	+ resistance[ResistanceRecoil] = ResistanceVeryHigh;
	}

	void KingRatEntity::animate(float delay)
	{
	if (age <= 0.0f)
	{
	age += delay;
	return;
	}

	EnnemyEntity::animate(delay);
	if (specialState[SpecialStateIce].active) delay *= specialState[SpecialStateIce].parameter;

	float timerMult = 1.0f;
	if (hp <= hpMax / 4)
	{
	creatureSpeed = KING_RAT_SPEED * 1.4f;
	timerMult = 0.7f;
	}
	else if (hp <= hpMax / 2)
	{
	creatureSpeed = KING_RAT_SPEED * 1.2f;
	timerMult = 0.85f;
	}
	else
	{
	creatureSpeed = KING_RAT_SPEED;
	}

	if (state == 5)
	{
	velocity.x *= 0.965f;
	velocity.y *= 0.965f;
	}

	else
	{
	if (velocity.x > 0.1f) sprite.setScale(-1.0f, 1.0f);
	else if (velocity.x < -0.1f) sprite.setScale(1.0f, 1.0f);
	}


	timer -= delay;

	if (timer <= 0.0f)
	{
	if (state == 0)
	{
	state = 1;
	// generate rats
	generateGreenRats();
	SoundManager::getSoundManager()->playSound(SOUND_KING_RAT_1);
	timer = 2.0f;

	velocity.x = 0.0f;
	velocity.y = 0.0f;
	}

	else if (state == 1) // generate rats
	{
	// to normal or berserk
	if (hp < hpMax / 4 && !hasBeenBerserk)
	{
	hasBeenBerserk = true;
	timer = 12.0f;
	state = 6;
	velocity = Vector2D(KING_RAT_BERSERK_SPEED);
	SoundManager::getSoundManager()->playSound(SOUND_KING_RAT_2);
	}
	else
	{
	timer = 7.0f * timerMult;
	velocity = Vector2D(creatureSpeed);
	state = 2;
	}
	}

	else if (state == 2) // normal -> rush
	{
	state = 3;
	// angry
	timer = 2.0f;

	velocity.x = 0.0f;
	velocity.y = 0.0f;
	SoundManager::getSoundManager()->playSound(SOUND_KING_RAT_2);
	}

	else if (state == 3) // normal -> rush
	{
	state = 4;
	// rush
	timer = 12.0f;

	float tan = (game().getPlayer()->getX() - x) / (game().getPlayer()->getY() - y);
	float angle = atan(tan);

	if (game().getPlayer()->getY() > y)
	setVelocity(Vector2D(sin(angle) * KING_RAT_RUNNING_SPEED,
	cos(angle) * KING_RAT_RUNNING_SPEED));
	else
	setVelocity(Vector2D(-sin(angle) * KING_RAT_RUNNING_SPEED,
	-cos(angle) * KING_RAT_RUNNING_SPEED));
	}
	else if (state == 5) // wall impact
	{
	// to normal or berserk
	if (hp < hpMax / 4 && !hasBeenBerserk)
	{
	hasBeenBerserk = true;
	timer = 12.0f;
	state = 6;
	velocity = Vector2D(KING_RAT_BERSERK_SPEED);
	SoundManager::getSoundManager()->playSound(SOUND_KING_RAT_2);
	}
	else
	{
	timer = 7.0f * timerMult;
	velocity = Vector2D(creatureSpeed);
	state = 0;
	}
	}

	else if (state == 6)
	{
	timer = 7.0f * timerMult;
	velocity = Vector2D(creatureSpeed);
	state = 0;
	}
	}

	if (state == 6)
	{
	berserkDelay -= delay;

	if (berserkDelay <= 0.0f)
	{
	berserkDelay = 0.8f + (rand()%10) / 10.0f;
	SoundManager::getSoundManager()->playSound(SOUND_KING_RAT_2);

	setVelocity(Vector2D(x, y).vectorTo(game().getPlayerPosition(),KING_RAT_BERSERK_SPEED ));
	}
	}

	frame = 0;

	if (state == 1)
	frame = 3;
	else if (state == 3 \|\| state == 6)
	{
	frame = 3; //0;
	int r = ((int)(age * 10.0f)) % 2;
	if (r == 0)
	sprite.setScale(-1.0f, 1.0f);
	else
	sprite.setScale(1.0f, 1.0f);
	}
	else if (state == 4)
	{
	int r = ((int)(age * 7.5f)) % 4;
	if (r == 1) frame = 1;
	else if (r == 3) frame = 2;
	}
	else if (state == 5)
	{
	frame = 0;
	}
	else
	{
	int r = ((int)(age * 5.0f)) % 4;
	if (r == 1) frame = 1;
	else if (r == 3) frame = 2;
	}
	}

	bool KingRatEntity::hurt(int damages, enumShotType hurtingType, int level)
	{
	int newDamages = damages;
	// berserk state protects
	if (state == 6)
	newDamages = damages / 4;

	return BaseCreatureEntity::hurt(newDamages, hurtingType, level);
	}

	void KingRatEntity::calculateBB()
	{
	boundingBox.left = (int)x - width / 2 + 25;
	boundingBox.width = width - 50;
	boundingBox.top = (int)y - height / 2 + 25;
	boundingBox.height = height - 35;
	}


	void KingRatEntity::afterWallCollide()
	{
	if (state == 4)
	{
	state = 5;
	timer = 1.4f;
	velocity.x *= 0.75f;
	velocity.y *= 0.75f;

	SoundManager::getSoundManager()->playSound(SOUND_BIG_WALL_IMPACT);
	game().makeShake(0.75f);
	}
	}
	void KingRatEntity::collideMapRight()
	{
	velocity.x = -velocity.x;

	afterWallCollide();
	}

	void KingRatEntity::collideMapLeft()
	{
	velocity.x = -velocity.x;

	afterWallCollide();
	}

	void KingRatEntity::collideMapTop()
	{
	velocity.y = -velocity.y;

	afterWallCollide();
	}

	void KingRatEntity::collideMapBottom()
	{
	velocity.y = -velocity.y;

	afterWallCollide();
	}


	void KingRatEntity::dying()
	{
	isDying = true;
	SpriteEntity* deadRat = new SpriteEntity(ImageManager::getImageManager()->getImage(IMAGE_CORPSES_BIG), x, y, 128, 128);
	deadRat->setZ(OFFSET_Y);
	deadRat->setFrame(FRAME_CORPSE_KING_RAT - FRAME_CORPSE_KING_RAT);
	deadRat->setType(ENTITY_CORPSE);

	for (int i = 0; i < 10; i++) game().generateBlood(x, y, bloodColor);

	SoundManager::getSoundManager()->playSound(SOUND_KING_RAT_DIE);

	ItemEntity* newItem = new ItemEntity(itemBossHeart, x, y);
	newItem->setVelocity(Vector2D(100.0f + rand()% 250));
	newItem->setViscosity(0.96f);
	}

	void KingRatEntity::generateGreenRats()
	{
	for (int i = 0; i < 5; i++)
	{
	float xr = x + -100 + rand() % 200;
	float yr = y + -100 + rand() % 200;

	if (xr > OFFSET_X + TILE_WIDTH * 1.5f && xr < OFFSET_X + TILE_WIDTH * (MAP_WIDTH - 2)
	&& yr > OFFSET_Y + TILE_HEIGHT * 1.5f && yr < OFFSET_Y + TILE_HEIGHT * (MAP_HEIGHT - 2))
	{
	new GreenRatEntity(xr, yr);
	}
	else
	i--;
	}
	}

	void KingRatEntity::render(sf::RenderTarget* app)
	{
	EnnemyEntity::render(app);

	if (state == 6)
	{
	int r = ((int)(age *12.0f)) % 2;
	if (r == 0)
	sprite.setTextureRect(sf::IntRect(1 * width, 1 * height, width, height));
	else
	sprite.setTextureRect(sf::IntRect(2 * width, 1 * height, -width, height));

	sprite.setPosition(x, y);
	sprite.setColor(sf::Color(255, 255, 255, 190));
	app->draw(sprite);
	sprite.setColor(sf::Color(255, 255, 255, 255));
	}

	float l = hpDisplay * ((MAP_WIDTH - 1) * TILE_WIDTH) / KING_RAT_HP;

	sf::RectangleShape rectangle(sf::Vector2f((MAP_WIDTH - 1) * TILE_WIDTH, 25));
	rectangle.setFillColor(sf::Color(0, 0, 0,128));
	rectangle.setPosition(sf::Vector2f(OFFSET_X + TILE_WIDTH / 2, OFFSET_Y + 25 + (MAP_HEIGHT - 1) * TILE_HEIGHT));
	app->draw(rectangle);

	rectangle.setSize(sf::Vector2f(l, 25));
	rectangle.setFillColor(sf::Color(190, 20, 20));
	rectangle.setPosition(sf::Vector2f(OFFSET_X + TILE_WIDTH / 2, OFFSET_Y + 25 + (MAP_HEIGHT - 1) * TILE_HEIGHT));
	app->draw(rectangle);

	game().write( "Rat King",
	18,
	OFFSET_X + TILE_WIDTH / 2 + 10.0f,
	OFFSET_Y + 25 + (MAP_HEIGHT - 1) * TILE_HEIGHT + 1.0f,
	ALIGN_LEFT,
	sf::Color(255, 255, 255),
	app, 0 , 0);
	}

	void KingRatEntity::collideWithEnnemy(GameEntity* collidingEntity)
	{
	EnnemyEntity* entity = static_cast<EnnemyEntity*>(collidingEntity);
	if (entity->getMovingStyle() == movWalking)
	{
	inflictsRecoilTo(entity);
	}
	}

	void KingRatEntity::inflictsRecoilTo(BaseCreatureEntity* targetEntity)
	{
	if (state == 4 \|\| state == 6)
	{
	Vector2D recoilVector = Vector2D(x, y).vectorTo(Vector2D(targetEntity->getX(), targetEntity->getY()), KING_RAT_RUNNING_RECOIL );
	targetEntity->giveRecoil(true, recoilVector, 1.0f);
	}
	}

File Metadata

Mime Type: text/x-diff
Expires: Thu, Jun 11, 10:28 AM (3 w, 5 d ago)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 68410
Default Alt Text: (37 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions