bool BreakBlocksScene::init()
{
if (!CCLayer::init())
{
return false;
}
CCDirector::sharedDirector()->getTouchDispatcher()->addTargetedDelegate(this, 0, true);
auto size = CCDirector::sharedDirector()->getWinSize();
auto center = ccp(size.width * 0.5f, size.height * 0.5f);
this->presenter = new BreakBlocksPresenter();
this->presenter->initialize(0.0f, 0.0f, size.width, size.height);
auto ball = this->presenter->getBall();
ball->addListener(this->ballChangedHandler);
this->ball = CCSprite::create("ball.png");
this->ball->setPosition(ball->getCenterX(), ball->getCenterY());
this->addChild(this->ball);
auto bar = this->presenter->getBar();
bar->addListener(this->barChangedHandler);
this->bar = CCSprite::create("bar.png");
this->bar->setPosition(bar->getCenterX(), bar->getCenterY());
this->addChild(this->bar);
auto blockTexture = CCTextureCache::sharedTextureCache()->addImage("block.png");
for (int i = 0; i < this->presenter->getBlockCount(); i++)
{
auto b = this->presenter->getBlock(i);
b->addListener(this->blockChangedHandler);
auto block = CCSprite::createWithTexture(blockTexture);
block->setPositionX(b->getCenterX());
block->setPositionY(b->getCenterY());
block->setTag(b->getId());
this->blocks.push_back(block);
this->addChild(block);
}
this->label = CCLabelTTF::create("", "Thonburi", 50.0f);
this->label->setPosition(center);
this->addChild(this->label, 100);
this->schedule(schedule_selector(BreakBlocksScene::update));
return true;
}
//==========================================================
// Box collision
// Called by collides()
// Returns: Returns the side that it collided with
// Left = 1;
// Right = 2;
// Top = 3;
// Bottom = 4;
//==========================================================
bool Entity::collideBox(Entity &ent, VECTOR2 &collision)
{
if (!active || !ent.getActive())
return false;
if ((getCenterX() + edge.right*getScale() >= ent.getCenterX() + ent.getEdge().left*ent.getScale()) &&
(getCenterX() + edge.left*getScale() <= ent.getCenterX() + ent.getEdge().right*ent.getScale()) &&
(getCenterY() + edge.bottom*getScale() >= ent.getCenterY() + ent.getEdge().top*ent.getScale()) &&
(getCenterY() + edge.top*getScale() <= ent.getCenterY() + ent.getEdge().bottom*ent.getScale()))
{
// collision = *ent.getCenter() - *getCenter();
return 1;
}
return 0;
}
void FractalTexture::create() {
if(glIsTexture(texture.id)) glDeleteTextures(1, &texture.id); //cleaning gl memory up
m_iMaxIterations = (long)((double)m_iStdMaxIterations * 1.0); //todo?
m_dInvMaxIterations = 1.0 / (m_iMaxIterations+0.0001);
const double winv = 1.0/(texture.width -1);
const double hinv = 1.0/(texture.height-1);
util::timeDiff();
for (int x = 0; x < texture.width; ++x) {
for (int y = 0; y < texture.height; ++y) {
#ifdef ROE_FRACTAL_GMP_USE_C
mpf_set_d(m_xPos, x*winv);
mpf_set_d(m_yPos, y*hinv);
mpf_mul(m_xPos, m_xPos, m_width);
mpf_mul(m_yPos, m_yPos, m_height);
mpf_add(m_xPos, m_xUpLt, m_xPos);
mpf_sub(m_yPos, m_yUpLt, m_yPos);
#else
m_xPos = m_xUpLt + (x*winv)*m_width;
m_yPos = m_yUpLt - (y*hinv)*m_height;
#endif
computeColor(&(texture.data[((texture.height-1-y)*texture.width+x)*texture.bpp]));
}
}
cout << "dt: " << util::timeDiff() << endl;
cout << getCenterX() << endl;
cout << getCenterY() << endl;
cout << getZoomW() << endl;
updateMipmaps();
Texture::loadTextureIntoGL(&texture);
}
bool MapDraw::isVisible(short x, short y)
{
int distFromCenter =
getGrid()->distanceBetween(x, y, getCenterX(), getCenterY());
if (distFromCenter < (GRID_SIZE - 2 ))
return true;
else
return false;
/*
// Come on Owen, you have their X / Y.
// out of array bounds.
if ((x<0) || (y < 0) || (y>=DEPTH) || (x>=WIDTH))
return false;
float pos = positionY( y );
if (fabs(pos) > (GRID_SIZE-2))
return false;
pos = positionX( x );
if (fabs(pos) > (GRID_SIZE-2))
return false;
return true;
*/
}
void Gun::multiFire(float frameTime)
{
int count = frameTime/fireRate.fireTime;
float recoilTime = frameTime/count;
if(fireMode != AUTO)//accounts for burst fire
{
if(gunState == NONE && count == 0)
{
count = 1;
}
count = min(burstCount, count);
burstCount -= count;
}
timeSinceLastFired -= fireRate.fireTime*count;
while(count > 0)
{
chamberNextProjectile();
if(chamberedProjectile != 0)
{
float fireAngle = spriteData.angle + spread*PI*(((rand()%1000)-500)/1000.0)/180;
D3DXVECTOR2 fp(getCenterX() + cos(spriteData.angle)*fireLocation.x - sin(spriteData.angle)*fireLocation.y, getCenterY() + cos(spriteData.angle)*fireLocation.y + sin(spriteData.angle)*fireLocation.x);
//fire(fp, fireAngle);
fire(fp + D3DXVECTOR2(((count-1)*fireRate.fireTime*chamberedProjectile->muzzelVelocity)*cos(fireAngle), ((count-1)*fireRate.fireTime*chamberedProjectile->muzzelVelocity)*sin(fireAngle)), fireAngle);
recoil(recoilTime);
}
count--;
}
}
void BossEntity::draw(Rectangle* view, Graphics* g)
{
if(active)
{
if(image != NULL)
image->draw(getCenterX() - getWidth()/2 - view->getX(), getCenterY() - getHeight()/2 - view->getY(), g);
}
}
/**************************************
Debug Function.
***************************************/
void Camera::debug(){
system("clear");
cout << " Eye: " << getEyeX() << " " << getEyeY() << " " << getEyeZ() << endl;
cout << " Center: " << getCenterX() << " " << getCenterY() << " " << getCenterZ() << endl;
cout << " Up: " << getUpX() << " " << getUpY() << " " << getUpZ() << endl;
cout << endl;
cout << " Perspective: " << getFovy() << " " << getAspect() << " " << getZNear() << " " << getZFar() << endl;
}
//=============================================================================
// Axis aligned bounding box collision detection method
// Called by collision()
// Post: returns true if collision, false otherwise
// sets collisionVector if collision
//=============================================================================
bool Entity::collideBox(Entity &ent, VECTOR2 &collisionVector)
{
// if either entity is not active then no collision may occcur
if (!active || !ent.getActive())
return false;
// Check for collision using Axis Aligned Bounding Box.
if( (getCenterX() + edge.right*getScale() >= ent.getCenterX() + ent.getEdge().left*ent.getScale()) &&
(getCenterX() + edge.left*getScale() <= ent.getCenterX() + ent.getEdge().right*ent.getScale()) &&
(getCenterY() + edge.bottom*getScale() >= ent.getCenterY() + ent.getEdge().top*ent.getScale()) &&
(getCenterY() + edge.top*getScale() <= ent.getCenterY() + ent.getEdge().bottom*ent.getScale()) )
{
// set collision vector
collisionVector = *ent.getCenter() - *getCenter();
return true;
}
return false;
}
void Vehicle::moveLeft(float coeff,int h,int l) {
float deca=(int) (speed * coeff ) ;
angle=0;
if( (int)(getCenterX() - deca - longueur/2)>0) {
x=x - deca ;
}
}
// This is complicated because there's a circular array...
float MapDraw::positionX(short x)
{
// normal bounds.
if ( (x < (getCenterX()+GRID_SIZE)) && (x > (getCenterX()-GRID_SIZE)))
return ((getCenterX() - x + 1) * -1);
// over bounds.
else if ( ((WIDTH-1) < (getCenterX()+GRID_SIZE)) && (x < ((getCenterX()+GRID_SIZE)%WIDTH)))
return ((getCenterX() - (x+WIDTH) + 1) * -1);
// below bounds.
else if ( ((getCenterX()-GRID_SIZE) < 0) && (x > (getCenterX()-GRID_SIZE+WIDTH)))
return ((getCenterX() - (x-WIDTH) + 1) * -1);
//TODO: throw exception?
return 1215;
}
void Vehicle::moveRight(float coeff,int h,int l) {
int deca= (int)(speed* coeff );
angle=180;
int temp = getCenterX()+deca+longueur/2;
if(temp-5 < h) {
x=x + deca;
}
}
void Boss::vectorTrack()//We're going to want to change this so that it takes an argument that is what we want to track
{
VECTOR2 vel = getCenterPoint()-targetEntity.getCenterPoint();
if(vel.x == 0 && vel.y==0)
return;
VECTOR2* foo = D3DXVec2Normalize(&vel, &vel);
setVelocity(-vel);
setRadians((atan((targetEntity.getCenterY()-getCenterY())/(targetEntity.getCenterX()-getCenterX())))-PI/2);
if(targetEntity.getCenterX()>getCenterX())
setRadians(getRadians()+PI);
}
Projectile* Vehicle::fire(int _dx,int _dy) {
int _x=getCenterX();
int _y=getCenterY();
if(used) {
Obus* bul=new Obus(_x,_y,_dx,_dy);
return bul;
} else {
return NULL;
}
}
//=============================================================================
// Force of gravity on this entity from other entity
// Adds the gravitational force to the velocity vector of this entity
// force = GRAVITY * m1 * m2 / r*r
// 2 2
// r*r = (Ax - Bx) + (Ay - By)
//=============================================================================
void Entity::gravityForce(Entity *ent, float frameTime)
{
// if either entity is not active then no gravity effect
if (!active || !ent->getActive())
return ;
rr = pow((ent->getCenterX() - getCenterX()),2) +
pow((ent->getCenterY() - getCenterY()),2);
force = gravity * ent->getMass() * mass/rr;
// --- Using vector math to create gravity vector ---
// Create vector between entities
VECTOR2 gravityV(ent->getCenterX() - getCenterX(),
ent->getCenterY() - getCenterY());
// Normalize the vector
Graphics::Vector2Normalize(&gravityV);
// Multipy by force of gravity to create gravity vector
gravityV *= force * frameTime;
// Add gravity vector to moving velocity vector to change direction
velocity += gravityV;
}
void Turret::logic(Level* level)
{
mFrameCount++;
if(mFrameCount%60 == 0)
{
float speed = 1.5;
float shootingArc = (M_PI*(1/4.0f));
float leftArc = M_PI - shootingArc;
float angle = M_PI/2.0f;
if(mShots <= 1) {
if(mDirection == LEFT) angle += M_PI;
if(mDirection == DOWN) angle -= M_PI/2.0f;
if(mDirection == UP) angle += M_PI/2.0f;
float xSpeed=std::sin(angle)*speed, ySpeed=std::cos(angle)*speed;
level->addEntity(new EnemyBullet(getCenterX(), getCenterY(), xSpeed, ySpeed, 1, angle));
} else {
for(int i=0; i<mShots; i++)
{
angle = shootingArc*(i/((float)(mShots-1)));
angle += leftArc/2.0f;
if(mDirection == LEFT) angle += M_PI;
if(mDirection == DOWN) angle -= M_PI/2.0f;
if(mDirection == UP) angle += M_PI/2.0f;
float xSpeed=std::sin(angle)*speed, ySpeed=std::cos(angle)*speed;
level->addEntity(new EnemyBullet(getCenterX(), getCenterY(), xSpeed, ySpeed, 1, angle));
}
}
}
if (getY() + getHeight() + 64 < level->getScrollY())
{
mIsToBeDeleted = true;
}
}
//==========================================================
// Force of gravity on this entity
// Calculated by F = mass * acceleration (gravity)
// Using that information creates an always downward force
// to the Entity
//==========================================================
void Entity::gravityForce(float frameTime)
{
if (!active)
return;
force = gravity * mass;
VECTOR2 gravityV(getCenterX(), 0-getCenterY());
Graphics::Vector2Normalize(&gravityV);
gravityV *= force *frameTime;
velocity += gravityV;
}
void Camera::film(){
int currentTime = glutGet(GLUT_ELAPSED_TIME);
int timeInterval = 5;//currentTime - previousTime;
float tmpEyeX, tmpEyeY, tmpEyeZ;
tmpEyeX = sin(mouseDirection[1]*M_PI/180)*sin(mouseDirection[0]*M_PI/180);
tmpEyeZ = sin(mouseDirection[1]*M_PI/180)*cos(mouseDirection[0]*M_PI/180);
tmpEyeY = cos(mouseDirection[1]*M_PI/180);
if(move[FORWARD]){
setEyeX(getEyeX() + (timeInterval * tmpEyeX / 6));
setEyeY(getEyeY() + (timeInterval * tmpEyeY / 6));
setEyeZ(getEyeZ() + (timeInterval * tmpEyeZ / 6));
}
if(move[BACKWARD]){
setEyeZ( getEyeZ() - (timeInterval * tmpEyeZ / 6));
setEyeY( getEyeY() - (timeInterval * tmpEyeY / 6));
setEyeX( getEyeX() - (timeInterval * tmpEyeX / 6));
}
if(move[LEFT]){
setEyeX( getEyeX() + (timeInterval * sin((mouseDirection[0]+90)*M_PI/180) / 6));
setEyeZ( getEyeZ() + (timeInterval * cos((mouseDirection[0]+90)*M_PI/180) / 6));
}
if(move[RIGHT]){
setEyeX( getEyeX() - (timeInterval * sin((mouseDirection[0]+90)*M_PI/180) / 6));
setEyeZ( getEyeZ() - (timeInterval * cos((mouseDirection[0]+90)*M_PI/180) / 6));
}
glLoadIdentity();
setCenterX(getEyeX()+tmpEyeX);
setCenterY(getEyeY()+tmpEyeY);
setCenterZ(getEyeZ()+tmpEyeZ);
gluLookAt(
getEyeX(),getEyeY(),getEyeZ(),
getCenterX(),getCenterY(),getCenterZ(),
0.0f, 1.0f, 0.0f
);
int xc = glutGet(GLUT_WINDOW_WIDTH)/2;
int yc = glutGet(GLUT_WINDOW_HEIGHT)/2;
glutWarpPointer(xc,yc);
move[0] = false;
move[1] = false;
move[2] = false;
move[3] = false;
}
bool GuideRibbonEllipse::idealize(::pb::GuideRibbon* pOut) const
{
::pb::GuideRibbon::Ellipse* idea = pOut->mutable_ellipse();
{
idea->mutable_center()->set_x( getCenterX() );
idea->mutable_center()->set_y( getCenterY() );
idea->mutable_radius()->set_x( getRadiusX() );
idea->mutable_radius()->set_y( getRadiusY() );
idea->set_angle0( getBeginAngle() );
idea->set_angle1( getEndAngle() );
idea->set_direction( getDirection() );
}
return true;
}
void EnemyBase::update()
{
updateEffects();
bar.centerToPoint(this->getCenterX(),this->getCenterY() - getHeight()/2 - 10);
if(road != NULL)
if(currentRoadTile < road->getRoadLenght() - 1)
{
SDL_Point nextTile = road->getPointAt(currentRoadTile + 1);
SDL_Point curTile = road->getPointAt(currentRoadTile);
int dirX = nextTile.x - curTile.x;
int dirY = nextTile.y - curTile.y;
move(dirX * speed,dirY * speed);
distance += (double)speed;
double cpX = nextTile.x * TILEWIDTH + TILEWIDTH/2;
double cpY = nextTile.y * TILEHEIGHT + TILEHEIGHT/2;
if(dirX != 0)
{
if((cpX - getCenterX()) * dirX <= 0)
{
setX(cpX - getWidth()/2);
currentRoadTile++;
}
}
else
{
if((cpY - getCenterY())*dirY <= 0)
{
setY(cpY - getHeight()/2);
currentRoadTile++;
}
}
}
else
{
reachedEnd = true;
}
}
Projectile* Soldier::fire(int _dx,int _dy){
Projectile* ob;
int _x=getCenterX();
int _y=getCenterY();
if(activ){
Bullet* bul=new Bullet(_x,_y,_dx,_dy);
return bul;
}
else{
if(vehicleUti->getSymbole()){
ob = ((Tank*)vehicleUti)->fire(_dx, _dy);
return ob;
}
}
return ob;
}
void Vision::fire(int mouseX, int mouseY)
{
//setFrames(RUGGER_GUN_START, RUGGER_GUN_END);
if(timeSinceLastShot < visionNS::SHOT_DELAY) return;
for(int i=0; i<visionNS::NUM_BULLETS; i++)
{
if(!bullets[i].getActive())
{
timeSinceLastShot = 0;
VECTOR2 fireVec(mouseX - getCenterX(), mouseY - getCenterY());
VECTOR2* normalFireVec = D3DXVec2Normalize(&fireVec, &fireVec);
bullets[i].setX(getX());
bullets[i].setY(getY());
bullets[i].setVelocity(fireVec * bulletNS::SPEED);
bullets[i].setActiveAndVisible(true);
return;
}
}
}
void Fish::setTowards(Entity &boat) {
// Set vel towards boat
velocity.x = boat.getCenterX() - getCenterX();
velocity.y = boat.getY() + boat.getHeight() * BOAT_IMAGE_SCALE - spriteData.y;
D3DXVec2Normalize(&velocity, &velocity);
velocity *= speed;
// Set texture to face boat
if(!spriteData.flipHorizontal && spriteData.x > boat.getCenterX()) spriteData.flipHorizontal = true;
if(spriteData.flipHorizontal && spriteData.x + getWidth() < boat.getCenterX()) spriteData.flipHorizontal = false;
// Set angle towards boat
if(spriteData.flipHorizontal) setRadians(atan(spriteData.y / (spriteData.x + getHeight())));
else setRadians(-atan(spriteData.y / (spriteData.x + getHeight())));
}
void TankHead::fireBullet()
{
if (shotBuffer.canFire(SHOT_TIME_BUFFER) && numBulletsFired < MAX_PLAYER_SHOTS)
{
shotBuffer.start();
float nozzleRadius = getWidth()/2 * getScale();
bullet[numBulletsFired].setX(getCenterX() + angleVector.x * nozzleRadius);
bullet[numBulletsFired].setY(getCenterY() + angleVector.y * nozzleRadius);
bullet[numBulletsFired].setRadians(spriteData.angle);
bullet[numBulletsFired].setVelocity(*D3DXVec2Normalize(&angleVector, &angleVector) * bulletNS::SPEED);
bullet[numBulletsFired].setVisible(true);
}
//This is the case where the player has too many bullets on the screen, but he should be able to fire based on the time buffer.
organizeBullets();
}
void FireProjectile::update(float timeElapsed)
{
// bullet tracer effect
m_Duration -= timeElapsed;
addDirection(m_Dx * timeElapsed, m_Dy * timeElapsed);
m_CollisionBox.x = getPosition().x;
m_CollisionBox.y = getPosition().y;
if (m_Duration <= 0)
{
m_Destroy = true;
}
m_Light.setSize(glm::vec2(m_Size.x, m_Light.getSize().y));
m_Light.setLightPosition(getX(), getY(), m_Size.x / 2);
m_Light.setPosition(getCenterX() - m_Light.getSize().x / 2, getCenterY() - m_Light.getSize().y / 2);
}
void Turret::handleCollision(Entity *other, Level *level)
{
if(other->getType() == Entity::PLAYER_BULLET_TYPE)
{
int dx = getCenterX() - other->getCenterX();
mHitCount -= other->getDamage();
mRenderAsHit = true;
if(mHitCount <= 0)
{
mIsToBeDeleted = true;
mCollidable = false; //do not collide while blinking
level->spawnDebris(8, mX, mY, mW, mH);
level->spawnExplosions(10, mX, mY, mW, mH);
level->addShakeAmount(100);
GameState::getInstance()->addPoints(150);
level->addKilledEnemy(1);
}
}
}
void Character::update(float frameTime, bool rightButton, bool leftButton, bool jumpButton, bool shootButton, bool reloadButton)
{
//Show the Character angle
//Movement based on collision detection
if (standingOn == 0 || !standingOn->getActive()) {
D3DXVECTOR2 v (
body->getVelocity().x,
body->getVelocity().y + frameTime * characterNS::GRAVITY_Y
);
setVelocity(v);
} else {
int xpos = body->getX();
if (body->getCenterX() + 12 < standingOn->corners[0].x || body->getCenterX() - 12 > standingOn->corners[3].x) {
standingOn = 0;
}
}
//Move left or right
if (leftButton ^ rightButton) {
faceDir = rightButton ? 1 : -1;
body->walking = true;
} else {
faceDir = 0;
body->walking = false;
}
if (standingOn != 0) {
walk(frameTime);
if (jumpButton) {
jump();
body->jumping = true;
} else {
body->jumping = false;
}
} else {
walk(frameTime/3);
body->jumping = true;
}
//Determine orientation of the player, based on the mouse direction
if (aimAngle > PI2) { // Quadrant 1
faceDir = 1;
}
if (aimAngle < PI2 && aimAngle > 0.0) { // Quadrant 2
faceDir = -1;
}
if (aimAngle > -PI2 && aimAngle <= 0.0) { // Quadrant 3
faceDir = -1;
}
if (aimAngle < -PI2 && aimAngle <= 0.0) { // Quadrant 4
faceDir = 1;
}
//Set the direction of the player
body->faceDir = faceDir;
// head->faceDir = faceDir;
body->update(frameTime);
//cursor->update(frameTime);
// head->update(frameTime);
updateCorners();
if(currentWeapon != 0)
{
currentWeapon->setAngle(aimAngle);
currentWeapon->setX(getCenterX() + weaponPos.x * std::cos(aimAngle) + weaponPos.y * std::sin(aimAngle) - currentWeapon->getWidth()/2);
currentWeapon->setY(getCenterY() + weaponPos.y * std::cos(aimAngle) + weaponPos.x * std::sin(aimAngle) -currentWeapon->getHeight()/2);
currentWeapon->update(frameTime);
//Reload if r is pressed or the ammoCount is 0
if(reloadStep == 0 && (reloadButton || reinterpret_cast<Gun*>(currentWeapon)->mag->ammoCount == 0))
{
reloadStep = 1;
reloadTimer = frameTime;
}
if(reloadStep != 0)
{
reloadTimer += frameTime;
if(reloadTimer > static_cast<Gun*>(currentWeapon)->reloadTime)
{
if(static_cast<Gun*>(currentWeapon)->isMagInGun)
{
currentMag->loadAmmo();
}
static_cast<Gun*>(currentWeapon)->loadMag();
reloadStep = 0;
}
else if(reloadTimer > static_cast<Gun*>(currentWeapon)->reloadTime/100)
{
static_cast<Gun*>(currentWeapon)->removeMag();
currentMag->loadAmmo();
}
}
currentWeapon->act(frameTime, shootButton, false, false, false, false);
}
}
D3DXVECTOR2 Character::getCenter() {
return D3DXVECTOR2(getCenterX(), getCenterY());
}
/**
* Draw the text on screen
*/
void GuiText::draw(CVideo *pVideo)
{
if(!text)
return;
if(!isVisible())
return;
color[3] = getAlpha();
blurGlowColor[3] = blurAlpha * getAlpha();
int newSize = size * getScale();
if(newSize != currentSize)
{
currentSize = newSize;
if(text)
textWidth = font->getWidth(text, currentSize);
}
if(maxWidth > 0 && maxWidth <= textWidth)
{
if(wrapMode == DOTTED) // text dotted
{
if(textDyn.size() == 0)
makeDottedText();
if(textDynWidth.size() != textDyn.size())
{
textDynWidth.resize(textDyn.size());
for(u32 i = 0; i < textDynWidth.size(); i++)
textDynWidth[i] = font->getWidth(textDyn[i], currentSize);
}
if(textDyn.size() > 0)
font->drawText(pVideo, getCenterX(), getCenterY(), getDepth(), textDyn[textDyn.size()-1], currentSize, color, alignment, textDynWidth[textDyn.size()-1], defaultBlur, blurGlowIntensity, blurGlowColor);
}
else if(wrapMode == SCROLL_HORIZONTAL)
{
scrollText(pVideo->getFrameCount());
if(textDyn.size() > 0)
font->drawText(pVideo, getCenterX(), getCenterY(), getDepth(), textDyn[textDyn.size()-1], currentSize, color, alignment, maxWidth, defaultBlur, blurGlowIntensity, blurGlowColor);
}
else if(wrapMode == WRAP)
{
int lineheight = currentSize + 6;
int yoffset = 0;
int voffset = 0;
if(textDyn.size() == 0)
wrapText();
if(textDynWidth.size() != textDyn.size())
{
textDynWidth.resize(textDyn.size());
for(u32 i = 0; i < textDynWidth.size(); i++)
textDynWidth[i] = font->getWidth(textDyn[i], currentSize);
}
if(alignment & ALIGN_MIDDLE)
voffset = (lineheight * (textDyn.size()-1)) >> 1;
for(u32 i = 0; i < textDyn.size(); i++)
{
font->drawText(pVideo, getCenterX(), getCenterY() + voffset + yoffset, getDepth(), textDyn[i], currentSize, color, alignment, textDynWidth[i], defaultBlur, blurGlowIntensity, blurGlowColor);
yoffset -= lineheight;
}
}
}
//=============================================================================
// update
// typically called once per frame
// frameTime is used to regulate the speed of movement and animation
//=============================================================================
void TankHead::update(float frameTime)
{
D3DXVECTOR2 mouseLocation(input->getMouseX(), input->getMouseY());
D3DXVec2Normalize(&angleVector,(const D3DXVECTOR2*)new D3DXVECTOR2(mouseLocation.x - getCenterX(), mouseLocation.y - getCenterY()));
float headAngle = acos(D3DXVec2Dot(&angleVector, &D3DXVECTOR2(0, -1)));
spriteData.angle = headAngle;
if (angleVector.x < 0)
spriteData.angle = 2 * PI - spriteData.angle;
Entity::update(frameTime);
//spriteData.x += velocity.x * frameTime;
//velocity.x = 0;
//spriteData.y += velocity.y * frameTime;
//velocity.y = 0;
//// wrap around screen
//if (spriteData.x > GAME_WIDTH) // if off screen right
// spriteData.x = -tankHeadNS::WIDTH; // position off screen left
//else if (spriteData.x < -tankHeadNS::WIDTH) // else if off screen left
// spriteData.x = GAME_WIDTH; // position off screen right
//if (spriteData.y < -tankHeadNS::HEIGHT) // if off screen top
// spriteData.y = GAME_HEIGHT; // position off screen bottom
//else if (spriteData.y > GAME_HEIGHT) // else if off screen bottom
// spriteData.y = -tankHeadNS::HEIGHT; // position off screen top
}
void Slime::logic()
{
stateChangeTimer--;
if (stateChangeTimer <= 0)
{
Player* player = mRoom->getPlayer();
//std::cout << "type: " << mSlimeType << std::endl;
int distBeforeAggro = 0;
if(mSlimeType == 2)
{
distBeforeAggro = 120;
} else if(mSlimeType == 1)
{
distBeforeAggro = 60;
}
if(getDistance(player) < distBeforeAggro) // && Random::get().getInt(3) = 2)
{
if(Random::get().getInt(2) == 1)
{
if(player->getCenterX()<getCenterX())
{
setState("walkleft");
} else {
setState("walkright");
}
}
else
{
if(player->getCenterY()<getCenterY())
{
setState("walkup");
} else {
setState("walkdown");
}
}
}
else
{
switch (Random::get().getInt(5))
{
case 0:
setState("walkleft");
break;
case 1:
setState("walkright");
break;
case 2:
setState("walkup");
break;
case 3:
setState("walkdown");
break;
default:
setState(Random::get().getInt(2) == 0 ? "idleleft" : "idleright");
break;
}
}
stateChangeTimer = Random::get().getInt(10, 30);
}
Actor::move();
std::vector<Entity*> players = mRoom->collidesWith(this, Entity::PLAYER);
if (players.size() != 0)
{
mRoom->getPlayer()->damage(1, getDirection());
}
}
