void EnemyLog::update(float deltaTime , Background *bg) {
_aliveTimer += deltaTime;
if(!_destroying && _aliveTimer > 5) {
//_alive = false;
_index = 0;
_destroying = true;
_animTimer.restart();
move(-31, -31);
}
if(_spawning){
updateSprite(true);
return;
}
if(_destroying){
updateSprite(false);
return;
}
setTexture(*_texture, true);
if(getOrigin().x == 0){
setPosition(getPosition().x + getLocalBounds().width/2+32, getPosition().y + getLocalBounds().height/2+32);
setOrigin( getLocalBounds().width/2, getLocalBounds().height/2);
}
movement(deltaTime, bg);
}
void moveSpriteCutsceneDirection(struct SPRITE *s, unsigned int animIndex, unsigned int loopAnim, unsigned int direction, float distance, float speed)
{
// only move sprite by specfic direction in cutscene
startCutscene();
switch (direction) {
case UP:
do {
if (refreshCutscene()) {
s->__internal__vy = -speed;
updateSprite(s);
s->SetAnim(s, animIndex, loopAnim);
}
} while (s->box.centerY > distance);
s->__internal__vy = 0;
s->box.y = distance;
break;
case DOWN:
do {
if (refreshCutscene()) {
s->__internal__vy = speed;
updateSprite(s);
s->SetAnim(s, animIndex, loopAnim);
}
} while (s->box.centerY < distance);
s->__internal__vy = 0;
s->box.y = distance;
break;
case LEFT:
do {
if (refreshCutscene()) {
s->__internal__vx = -speed;
updateSprite(s);
s->SetAnim(s, animIndex, loopAnim);
}
} while (s->box.centerX > distance);
s->__internal__vx = 0;
s->box.x = distance;
break;
case RIGHT:
do {
if (refreshCutscene()) {
s->__internal__vx = speed;
updateSprite(s);
s->SetAnim(s, animIndex, loopAnim);
}
} while (s->box.centerX < distance);
s->__internal__vx = 0;
s->box.x = distance;
break;
}
endCutscene();
}
void ConjAliens::update(float deltaTime)
{
int dirX = dir_actual == DRE ? 1 : dir_actual == ESQ ? -1 : 0;
int dirY = dir_actual == AVALL ? 1 : 0;
position += sf::Vector2f(dirX * VEL * deltaTime * speedMult, dirY * VEL * deltaTime* speedMult);
if (dir_actual == AVALL)
{
contadorAvall += deltaTime;
if (contadorAvall > 0.3f)
{
canviarDireccio();
contadorAvall = 0;
}
}
for (int i = 0; i < COLUMNES; i++)
{
for (int j = 0; j < FILES; j++)
{
aliens[i][j].update(deltaTime);
}
}
generarDispars();
updateSprite(deltaTime);
actualitzarDireccio();
}
static Boolean GraffitiFormHandleEvent(EventPtr event){
Boolean handled = false;
switch (event->eType) {
case frmOpenEvent:
FrmDrawForm(FrmGetActiveForm());
handled = true;
break;
case keyDownEvent:
if(event->data.keyDown.chr == sentence[offset]){
offset++;
if(offset == StrLen(sentence)){ FrmGotoForm(WinForm); }
}
handled = true;
break;
case nilEvent: {
if(offset < StrLen(sentence)){
updateSprite(&nextLetter);
drawSprite(&nextLetter);
}
handled = true;
break;
}
default:
break;
}
return handled;
}
void BilliardBall::updateBilliardBall(float dt) {
//log("%f %f %f %f", angularVelocity.x, angularVelocity.y, angularVelocity.z, pBody->GetAngularVelocity());
//log("%f %f", linearA.x, linearA.y);
updateSprite();
updateLinearVelocity(dt); //선운동
updateAngualrVelocity(dt); //각운동
}
/* Align a sprite to nearby platform level. */
void alignSpriteToPlatform(uint8_t slot) {
/* Align. */
GameSpriteSlots[slot].y&=0xf8;
/* Update sprite. */
updateSprite(slot);
}
bool Button::init(const std::string& normalImage, const std::string& selectedImage, const std::string& pressedImage, const std::string& disabledImage,
const std::string& label, const graphics::Color& labelColor, const std::string& font)
{
eventHandler = std::make_shared<EventHandler>(EventHandler::PRIORITY_MAX + 1);
eventHandler->gamepadHandler = std::bind(&Button::handleGamepad, this, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3);
eventHandler->uiHandler = std::bind(&Button::handleUI, this, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3);
sharedEngine->getEventDispatcher()->addEventHandler(eventHandler);
if (!normalImage.empty())
{
normalSprite = std::make_shared<scene::Sprite>();
if (normalSprite->initFromFile(normalImage, false))
{
addDrawable(normalSprite);
}
}
if (!selectedImage.empty())
{
selectedSprite = std::make_shared<scene::Sprite>();
if (selectedSprite->initFromFile(selectedImage, false))
{
addDrawable(selectedSprite);
}
}
if (!pressedImage.empty())
{
pressedSprite = std::make_shared<scene::Sprite>();
if (pressedSprite->initFromFile(pressedImage, false))
{
addDrawable(pressedSprite);
}
}
if (!disabledImage.empty())
{
disabledSprite = std::make_shared<scene::Sprite>();
if (disabledSprite->initFromFile(disabledImage, false))
{
addDrawable(disabledSprite);
}
}
if (!label.empty())
{
labelDrawable = scene::TextDrawable::create(font, label);
if (labelDrawable)
{
labelDrawable->setColor(labelColor);
addDrawable(labelDrawable);
}
}
updateSprite();
return true;
}
/* Change sprite direction. */
void changeSpriteDirection(uint8_t slot, uint8_t direction) {
/* Remember updated direction, reset animation. */
GameSpriteSlots[slot].flags=(GameSpriteSlots[slot].flags & ~(SPRITE_FLAGS_DIRECTION_MASK|SPRITE_FLAGS_ANIMATION_MASK)) | (direction & SPRITE_FLAGS_DIRECTION_MASK);
/* Update sprite. */
updateSprite(slot);
}
Entity::Entity(string sheetName, int tX, int tY)
{
// Initialize
tileX = tX;
tileY = tY;
moving = false;
dir = DIR_LEFT;
frame = 0;
rect.left = tileX * Tile::TILE_WIDTH;
rect.top = tileY * Tile::TILE_HEIGHT;
rect.width = Tile::TILE_WIDTH;
rect.height = Tile::TILE_HEIGHT;
// Set up the sprites and cut them out
for(int i = 0; i < MAX_FRAME; i++)
{
for(int j = 0; j < 4; j++)
{
sprites[i][j].setTexture(*TextureManager::getTexture(sheetName));
sprites[i][j].setTextureRect(sf::Rect<int>(i * rect.width, j * rect.height, rect.width, rect.height));
}
}
// Set up the current sprite
updateSprite();
m = NULL;
}
void Anisprite::loopUpdate()
{
_clock.timer->Update();
float ctime = float(_clock.timer->GetTime().asSec() - _clock.stime);
int t = int(floor(ctime * projections[cur_proj].animations[cur_anim].FPS)) % projections[cur_proj].animations[cur_anim].length;
updateSprite(t);
}
bool CheckBox::handleUI(Event::Type type, const UIEvent& event, const VoidPtr& sender)
{
OUZEL_UNUSED(event);
if (!enabled) return true;
if (sender.get() == this)
{
if (type == Event::Type::UI_ENTER_NODE)
{
pointerOver = true;
updateSprite();
}
else if (type == Event::Type::UI_LEAVE_NODE)
{
pointerOver = false;
updateSprite();
}
else if (type == Event::Type::UI_PRESS_NODE)
{
pressed = true;
updateSprite();
}
else if (type == Event::Type::UI_RELEASE_NODE)
{
if (pressed)
{
pressed = false;
updateSprite();
}
}
else if (type == Event::Type::UI_CLICK_NODE)
{
pressed = false;
checked = !checked;
updateSprite();
Event event;
event.sender = shared_from_this();
event.type = Event::Type::UI_WIDGET_CHANGE;
sharedEngine->getEventDispatcher()->dispatchEvent(event);
}
}
return true;
}
void Button::setTextures(const sf::Texture* textureinactive,
const sf::Texture* textureactive, const sf::Texture* texturehover)
{
textures[ES_INACTIVE] = textureinactive;
textures[ES_ACTIVE] = textureactive;
textures[ES_HOVER] = texturehover;
updateSprite();
}
PokeSelection::PokeSelection(Pokemon::uniqueId pokemon, QAbstractItemModel *pokemonModel) :
ui(new Ui::PokeSelection), search(NULL), newwidth(0)
{
ui->setupUi(this);
QSortFilterProxyModel *proxy = new QSortFilterProxyModel(this);
proxy->setFilterRegExp(".");
proxy->setSourceModel(pokemonModel);
this->sourceModel = pokemonModel;
this->proxy = proxy;
ui->pokemonList->setModel(proxy);
QCompleter *completer = new QCompleter(proxy, ui->pokeEdit);
completer->setCompletionColumn(1);
completer->setCompletionRole(Qt::DisplayRole);
completer->setCaseSensitivity(Qt::CaseInsensitive);
completer->setCompletionMode(QCompleter::PopupCompletion);
ui->pokeEdit->setCompleter(completer);
setNum(pokemon);
ui->pokemonList->setCurrentIndex(pokemonModel->index(pokemon.pokenum, 1));
ui->pokemonList->scrollTo(ui->pokemonList->currentIndex());
updateSprite();
updateTypes();
if (getGen() <= 1) {
ui->shiny->hide();
} else {
ui->shiny->show();
}
ui->baseStats->setGen(getGen());
connect(completer, SIGNAL(activated(QModelIndex)), SLOT(setPokemon(QModelIndex)));
connect(ui->shiny, SIGNAL(toggled(bool)), SLOT(updateSprite()));
connect(ui->pokemonList, SIGNAL(pokemonSelected(Pokemon::uniqueId)), SLOT(setNum(Pokemon::uniqueId)));
connect(ui->pokemonList, SIGNAL(pokemonSelected(Pokemon::uniqueId)), SLOT(updateSprite()));
connect(ui->pokemonList, SIGNAL(pokemonSelected(Pokemon::uniqueId)), SLOT(updateTypes()));
connect(ui->pokemonList, SIGNAL(pokemonActivated(Pokemon::uniqueId)), SLOT(finish()));
connect(ui->changeSpecies, SIGNAL(clicked()), SLOT(finish()));
connect(ui->pokemonFrame, SIGNAL(clicked()), SLOT(toggleSearchWindow()));
}
bool CheckBox::init(const std::string& normalImage, const std::string& selectedImage, const std::string& pressedImage, const std::string& disabledImage, const std::string& tickImage)
{
eventHandler = std::make_shared<EventHandler>(EventHandler::PRIORITY_MAX + 1);
eventHandler->gamepadHandler = std::bind(&CheckBox::handleGamepad, this, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3);
eventHandler->uiHandler = std::bind(&CheckBox::handleUI, this, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3);
sharedEngine->getEventDispatcher()->addEventHandler(eventHandler);
if (!normalImage.empty())
{
normalSprite = std::make_shared<scene::Sprite>();
if (normalSprite->initFromFile(normalImage, false))
{
addDrawable(normalSprite);
}
}
if (!selectedImage.empty())
{
selectedSprite = std::make_shared<scene::Sprite>();
if (selectedSprite->initFromFile(selectedImage, false))
{
addDrawable(selectedSprite);
}
}
if (!pressedImage.empty())
{
pressedSprite = std::make_shared<scene::Sprite>();
if (pressedSprite->initFromFile(pressedImage, false))
{
addDrawable(pressedSprite);
}
}
if (!disabledImage.empty())
{
disabledSprite = std::make_shared<scene::Sprite>();
if (disabledSprite->initFromFile(disabledImage, false))
{
addDrawable(disabledSprite);
}
}
if (!tickImage.empty())
{
tickSprite = std::make_shared<scene::Sprite>();
if (tickSprite->initFromFile(tickImage, false))
{
addDrawable(tickSprite);
}
}
updateSprite();
return true;
}
void NetworkSprite::visit(cocos2d::Renderer *r, const cocos2d::Mat4 &t, uint32_t f, ZPath &zPath) {
if (_assetDirty) {
if (AssetLibrary::getInstance()->isLoaded()) {
updateSprite();
_assetDirty = false;
}
}
DynamicSprite::visit(r, t, f, zPath);
}
/* Place a sprite somewhere. */
void placeSprite(uint8_t slot, uint8_t x, uint8_t y, uint16_t flags) {
/* Remember position and flags. */
GameSpriteSlots[slot].x=x;
GameSpriteSlots[slot].y=y;
GameSpriteSlots[slot].flags=flags;
/* Update sprite. */
updateSprite(slot);
}
bool Button::handleUI(Event::Type type, const UIEvent& event, const VoidPtr& sender)
{
OUZEL_UNUSED(event);
if (!enabled) return true;
if (sender.get() == this)
{
if (type == Event::Type::UI_ENTER_NODE)
{
pointerOver = true;
updateSprite();
}
else if (type == Event::Type::UI_LEAVE_NODE)
{
pointerOver = false;
updateSprite();
}
else if (type == Event::Type::UI_PRESS_NODE)
{
pressed = true;
updateSprite();
}
else if (type == Event::Type::UI_RELEASE_NODE)
{
if (pressed)
{
pressed = false;
updateSprite();
}
}
else if (type == Event::Type::UI_CLICK_NODE)
{
if (pressed)
{
pressed = false;
updateSprite();
}
}
}
return true;
}
void NetworkSprite::setUrl(const std::string &url, bool force) {
if (_url != url) {
_url = url;
if (force || isCachedTextureUrl(url)) {
updateSprite(true);
} else {
_assetDirty = true;
}
}
}
void moveSprite(uint8_t slot, int8_t x, int8_t y) {
/* Remember new position. */
GameSpriteSlots[slot].x+=x;
GameSpriteSlots[slot].y+=y;
/* Next animation step. */
GameSpriteSlots[slot].flags=(GameSpriteSlots[slot].flags & ~SPRITE_FLAGS_ANIMATION_MASK) | ((GameSpriteSlots[slot].flags+1) & SPRITE_FLAGS_ANIMATION_MASK);
/* Update sprite. */
updateSprite(slot);
}
void CheckBox::setEnabled(bool enabled)
{
Widget::setEnabled(enabled);
selected = false;
pointerOver = false;
pressed = false;
receiveInput = enabled;
updateSprite();
}
void updateEntity(Game* game, Entity* entity)
{
if(entity->sprite.alive)
{
updateSprite(game, &entity->sprite);
entity->sprite.position = getEntityDrawPosition(entity);
}
entity->position =
addPointfs(
entity->position,
scalePointf(entity->velocity, game->delta));
}
void Entity::tick()
{
// Change the frame and movement
if(moving)
{
frame++;
if(frame >= MAX_FRAME)
frame = 0;
// Move the player
switch(dir)
{
case DIR_UP:
rect.top -= Tile::TILE_HEIGHT / 8;
break;
case DIR_DOWN:
rect.top += Tile::TILE_HEIGHT / 8;
break;
case DIR_LEFT:
rect.left -= Tile::TILE_WIDTH / 8;
break;
case DIR_RIGHT:
rect.left += Tile::TILE_WIDTH / 8;
break;
}
// Check to see if we need to stop moving
if((rect.left == tileX * Tile::TILE_WIDTH) && (rect.top == tileY * Tile::TILE_HEIGHT))
moving = false;
}
else
{
// Reset everything
frame = 0;
rect.left = tileX * Tile::TILE_WIDTH;
rect.top = tileY * Tile::TILE_HEIGHT;
// Handle movement
move();
}
updateSprite();
if(m)
m->checkCollisions(this);
}
bool SpriteView::init(const std::string& spriteSheetPath, int newSpriteWidth, int newSpriteHeight) {
// try to load the texture
bool result = texture.loadFromFile(spriteSheetPath);
texture.setSmooth(false);
if (result == true) {
sprite.setTexture(texture);
sprite.setTextureRect(sf::IntRect(0, 0, spriteWidth, spriteHeight));
spritesPerRow = texture.getSize().x / newSpriteWidth;
spriteWidth = newSpriteWidth;
spriteHeight = newSpriteHeight;
updateSprite(0);
}
return result;
}
void moveSpriteCutscene(struct SPRITE *s, unsigned int animIndex, unsigned int loopAnim, float x, float y, float speed)
{
/* move sprite in a cutscene, to x and y */
struct HITBOX h;
newHitbox(&h, x, y, 1, 1);
startCutscene();
do {
/* update only this sprite and draw */
if (refreshCutscene()) {
SetVelocityBetweenHitboxes(s, h, speed);
updateSprite(s);
s->SetAnim(s, animIndex, loopAnim);
}
} while (!checkCollide(s->box, h));
endCutscene();
}
void updateParticle(struct SPRITE *s)
{
/* update particles, regardless of whether onscreen or not */
struct PARTICLE *data = (struct PARTICLE *)s->data;
data->colorTrans = data->colorTrans + data->rate;
if (data->colorTrans > 1) {
data->colorTrans = 0;
++data->stage;
}
if (data->stage == 3) {
s->__internal__alive = false;
return;
}
data->size = data->size + data->scaleFactor;
s->SetScaleX(s, data->size);
s->SetScaleY(s, data->size);
s->SetAngle(s, s->GetAngle(s) + data->angle);
s->__internal_tint = blendColor(data->c[data->stage], data->c[data->stage + 1], data->colorTrans);
updateSprite(s);
}
void Sprite::render(float dt)
{
if (!mVisible)
{
return;
}
if (mAsset == NULL || mAsset->getTexture() == NULL || !mAsset->getTexture()->isLoaded())
{
if (!mGfxComponent || (mGfxComponent && mGfxComponent->getColour().getAlpha() > 0.05f))
{
preRender(dt);
Texture::bindTexture(0);
if (mGfxComponent)
{
mGfxComponent->getColour().applyColour();
}
glBegin(GL_QUADS);
glVertex2f(0.0f, 0.0f);
glVertex2f(getWidth(), 0.0f);
glVertex2f(getWidth(), getHeight());
glVertex2f(0.0f, getHeight());
glEnd();
postRender(dt);
}
return;
}
preRender(dt);
updateSprite(dt);
renderSprite();
postRender(dt);
}
void updateEntity(Entity *entity, float dt) {
if(entity->type == ENTITY_PLAYER) {
if(isDown("up")) {
entity->pos.y = entity->pos.y - 200*dt;
}
if(isDown("down")) {
entity->pos.y = entity->pos.y + 200*dt;
}
if(isDown("left")) {
entity->pos.x = entity->pos.x - 200*dt;
}
if(isDown("right")) {
entity->pos.x = entity->pos.x + 200*dt;
}
}
if(entity->sprite) {
updateSprite(entity->sprite, dt);
}
}
static void gameScreen_PhysicsTick( float dt )
{
ourSpawnDelay -= dt;
if( ourSpawnDelay <= 0.0f ) {
spawnTroops( 0, MIN_ATTACKER_SPAWN, MAX_ATTACKER_SPAWN );
ourSpawnDelay = randFloat( MIN_SPAWN_DELAY, MAX_SPAWN_DELAY );
}
theirSpawnDelay -= dt;
if( theirSpawnDelay <=0.0f ) {
spawnTroops( 1, MIN_DEFENDER_SPAWN, MAX_DEFENDER_SPAWN );
theirSpawnDelay = randFloat( MIN_SPAWN_DELAY, MAX_SPAWN_DELAY );
}
updatePanjandrumsReady( dt );
updatePanjandrums( dt );
updateTroops( dt );
updateExplosions( );
updateMines( dt );
particlesPhysicsTick( dt );
updateSprite( launchToSprite, launchToPosition, VEC2_ONE, 0.0f );
}
void sdlTowerAff(const sdlMap *sdMap)
{
int i,iSprite;
int x,y,px,py;
//affichage des towers
Map *map = getSdlMap(sdMap);
for(i=0;i<getEnsTowerNb(getMapTowers(map));++i)
{
Tower *t = getMapTowers(map)->tab[i];//position
Coord* pos = getTowerPosition(t);
x = pos->x;
y = pos->y;
//Affichage de l'aura
if (getTowerLvl(t) == 5)
{
updateSprite(sdMap->TowerAura);
sdlApplySurface(sdMap->TowerAura->sprites[sdMap->TowerAura->actual], getSdlMapEcran(sdMap), (x-1), (y-1));
}
Projectile *p = getTowerProjectile(t);
pos = getProjectilePosition(p);
px = pos->x;
py = pos->y;
//Affichage de la tour
switch (map->towers->tab[i]->type)
{
case 'A':
//Affiche le projectile
if(p != NULL){
int spriteArcher = 2;
//diférentes direcions du sprite projectile
switch(map->towers->tab[i]->shot->spriteOrientation){
case 'd':
spriteArcher = 2;
break;
case 'b':
spriteArcher = 3;
break;
case 'g':
spriteArcher = 4;
break;
case 'h':
spriteArcher = 5;
break;
}
sdlApplySurface(sdMap->Projectile->sprites[spriteArcher], getSdlMapEcran(sdMap), px, py);
}
iSprite = getSpriteFromTimer(sdMap->TowerArcher, getTowerDefaultTimer(t), getTowerTimer(t));
sdlApplySurface(sdMap->TowerArcher->sprites[iSprite], getSdlMapEcran(sdMap), x, y);
break;
case 'K':
iSprite = getSpriteFromTimer(sdMap->TowerKnight, getTowerDefaultTimer(t), getTowerTimer(t));
sdlApplySurface(sdMap->TowerKnight->sprites[iSprite], getSdlMapEcran(sdMap), x, y);
break;
case 'M':
//Affiche le projectile
if(p != NULL)
sdlApplySurface(sdMap->Projectile->sprites[0], getSdlMapEcran(sdMap), px, py);
iSprite = getSpriteFromTimer(sdMap->TowerMage, getTowerDefaultTimer(t), getTowerTimer(t));
sdlApplySurface(sdMap->TowerMage->sprites[iSprite], getSdlMapEcran(sdMap), x, y);
break;
case 'C':
//Affiche le projectile
if(p != NULL)
sdlApplySurface(sdMap->Projectile->sprites[1], getSdlMapEcran(sdMap), px, py);
iSprite = getSpriteFromTimer(sdMap->TowerCannon, getTowerDefaultTimer(t), getTowerTimer(t));
sdlApplySurface(sdMap->TowerCannon->sprites[iSprite], getSdlMapEcran(sdMap), x, y);
break;
}
}
}
void CheckBox::setChecked(bool newChecked)
{
checked = newChecked;
updateSprite();
}
