void CEnemyBoss::OnCollision(CEntity* Entity) {
// Prevent premature damage taking
if( !CAppStateGame::Instance.BossFightOn ) return;
if( !IsActive() || !Entity->IsActive() ) return;
switch( Entity->Type ) {
case ENTITY_TYPE_BULLET:
if( Entity->SubType == ENTITY_SUBTYPE_BULLET_NORMAL ) {
Damage(BULLET_NORMAL_STR);
}
else if( Entity->SubType == ENTITY_SUBTYPE_BULLET_SMALL_45U || Entity->SubType == ENTITY_SUBTYPE_BULLET_SMALL_45D) {
Damage(BULLET_SMALL_STR);
}
else if( Entity->SubType == ENTITY_SUBTYPE_BULLET_CHARGE1 ) {
Damage(BULLET_CHARGE1_STR);
}
if( IsDead() ){
// Need to substract bullet life, since it won't check collission when enemy dies from hit
Entity->Damage(1);
}
break;
case ENTITY_TYPE_PLAYER:
Entity->Damage(1);
default:
return;
}
return;
}
int GuiCombat::resolve() // Returns the number of damage objects dealt this turn.
{
DamageStack* stack = NEW DamageStack(observer);
for (inner_iterator it = attackers.begin(); it != attackers.end(); ++it)
{
MTGCardInstance * attacker = (*it)->card;
signed dmg = attacker->stepPower(step);
for (vector<DefenserDamaged*>::iterator q = (*it)->blockers.begin(); q != (*it)->blockers.end(); ++q)
{
for (vector<Damage>::iterator d = (*q)->damages.begin(); d != (*q)->damages.end(); ++d)
stack->Add(NEW Damage(*d));
dmg -= (*q)->sumDamages();
}
if (dmg > 0 && ((!attacker->isBlocked()) || attacker->has(Constants::TRAMPLE)))
stack->Add(NEW Damage(observer, (*it)->card, (Damageable*)attacker->isAttacking?(Damageable*)attacker->isAttacking:observer->opponent(), dmg, DAMAGE_COMBAT));
for (vector<Damage>::iterator d = (*it)->damages.begin(); d != (*it)->damages.end(); ++d)
stack->Add(NEW Damage(*d));
}
int v = stack->mObjects.size();
if (v > 0)
{
observer->mLayers->stackLayer()->Add(stack);
observer->mLayers->stackLayer()->resolve(); // This will delete the damage stack which will in turn delete the Damage it contains
}
else
SAFE_DELETE(stack);
return v;
}
//-----------------------------------------------------------------------------//
// 충돌이 일어나면 이 함수가 호출된다.
// TestNum : 1 = 주인공이 공격한후 충돌체크
// 2 = 적이 공격한후 충돌체크
// ICollisionable : 충돌한 객체 포인터
//-----------------------------------------------------------------------------//
void CCharacter::Collision( int TestNum, ICollisionable *pObj )
{
if( CHAR_HERO == m_Group )
{
switch( TestNum )
{
case 1:
break;
case 2:
{
int damage = 0;
ATTACK_TYPE type = NONE;
Vector3 dir(0,0,0);
CCharacter *p = (CCharacter*)pObj;
if( p->m_pCurAct )
{
damage = p->m_pCurAct->damage;
type = (ATTACK_TYPE)p->m_pCurAct->attack_type;
dir = GetPos() - p->GetPos();
dir.Normalize();
}
Damage( type, damage, &dir );
}
break;
}
}
else if( CHAR_ENEMY == m_Group )
{
switch( TestNum )
{
case 1:
{
int damage = 0;
ATTACK_TYPE type = NONE;
Vector3 dir(0,0,0);
CCharacter *p = (CCharacter*)pObj;
if( p->m_pCurAct )
{
damage = p->m_pCurAct->damage;
type = (ATTACK_TYPE)p->m_pCurAct->attack_type;
dir = GetPos() - p->GetPos();
dir.Normalize();
}
Damage( type, damage, &dir );
}
break;
case 2:
break;
}
}
}
bool CShieldClass::GetReferenceDamageAdj (const CItem *pItem, CSpaceObject *pInstalled, int *retiHP, int *retArray) const
// GetReferenceDamageAdj
//
// Returns an array of damage adj values
{
CItemCtx Ctx(pItem, pInstalled);
int i;
const CItemEnhancement &Mods = Ctx.GetMods();
int iMinHP, iMaxHP;
CalcMinMaxHP(Ctx, m_iMaxCharges, 0, 0, &iMinHP, &iMaxHP);
if (retiHP)
*retiHP = iMaxHP;
if (retArray)
{
for (i = 0; i < damageCount; i++)
{
DamageDesc Damage((DamageTypes)i, DiceRange(0, 0, 0));
int iAdj = GetDamageAdj(Mods, Damage);
if (iAdj == 0)
retArray[i] = -1;
else
retArray[i] = (int)((iMaxHP * 100.0 / iAdj) + 0.5);
}
}
return true;
}
// Main part, calls simulating damage function
int main()
{
enum { numSimulation = 10000000 };
enum { numAttackDice = 2 };
enum { AttackFocus = true };
enum { TargetLock = false };
enum { Howlrunner = true };
enum { CrackShot = true };
enum { numEvadeDice = 3 };
enum { EvadeFocus = true };
enum { EvadeToken = false };
std::vector<double> Damage (numSimulation);
std::cout << "Rolling " << numAttackDice << " attack dice and " << numEvadeDice << " evade dice" << '\n'; //Code-Review - std::endl includes a flush, most of the time this isn't essential.
std::cout << "Attack Focus: " << AttackFocus << " Evade Focus: " << EvadeFocus << " Target Lock: " << TargetLock << " Evade Action: " << EvadeToken << '\n';
std::cout << "HowlRunner: " << Howlrunner << " Crack Shot : " << CrackShot << '\n';
clock_t begin = clock();
std::generate(std::begin(Damage),std::end(Damage),
[&]()
{
auto result = SimulateDamage(numAttackDice, AttackFocus, TargetLock, numEvadeDice, EvadeFocus, EvadeToken, Howlrunner, CrackShot);
return result;
});
const auto DamageSum = std::accumulate(std::begin(Damage), std::end(Damage), 0.0);
std::cout << "Number of simulations was " << numSimulation << '\n';
std::cout << "Average damage was " << DamageSum / numSimulation << '\n';
clock_t end = clock();
double elapsed_secs = double(end - begin) / CLOCKS_PER_SEC;
std::cout << "Time needed for calculation: " << elapsed_secs << std::endl;
}
void Square::Update()
{
if ( GetNonWallCount() == 0 && IsOnScreen() )
_timer--;
else
_timer = GetLib().RandInt( 80 ) + 40;
if ( _timer == 0 )
Damage( 4, false, 0 );
Vec2 pos = GetPosition();
if ( pos._x < 0 && _dir._x <= 0 ) {
_dir._x = -_dir._x;
if ( _dir._x <= 0 ) _dir._x = 1;
}
if ( pos._y < 0 && _dir._y <= 0 ) {
_dir._y = -_dir._y;
if ( _dir._y <= 0 ) _dir._y = 1;
}
if ( pos._x > Lib::WIDTH && _dir._x >= 0 ) {
_dir._x = -_dir._x;
if ( _dir._x >= 0 ) _dir._x = -1;
}
if ( pos._y > Lib::HEIGHT && _dir._y >= 0 ) {
_dir._y = -_dir._y;
if ( _dir._y >= 0 ) _dir._y = -1;
}
_dir.Normalise();
Move( _dir * SPEED );
SetRotation( _dir.Angle() );
}
void CSelection::MakeEmpty( BOOL bDamage, BOOL bAtEnd )
{
if ( !IsEmpty() )
{
EnableColumnSel( FALSE );
if ( bDamage )
{
Damage();
}
if ( bAtEnd )
{
m_nStartCol = m_nEndCol;
m_nStartViewCol = m_nEndViewCol;
m_nStartRow = m_nEndRow;
}
else
{
m_nEndCol = m_nStartCol;
m_nEndViewCol = m_nStartViewCol;
m_nEndRow = m_nStartRow;
}
UpdateCaretPosition();
}
}
void Converter::DoRareAction() {
if ( isOn && fuelLevel < World::SECONDS_IN_DAY/DamageLevel() ) {
for (int i=GetSize()-1; i>=0; --i) {
Block* const block = ShowBlock(i);
if ( block ) {
const int add = ConvertRatio(block->Sub());
if ( add > 0 ) {
fuelLevel += add;
Pull(i);
delete block;
break;
}
}
}
}
World* const world = World::GetWorld();
if ( fuelLevel <= 0
|| ( Sub() == STONE
&& world->GetBlock(X(), Y(), Z()+1)->Sub() == WATER ) )
{
Damage(1, damageKindOff);
} else {
if (world->Damage(X(), Y(), Z()+1, DamageLevel(), damageKindOn)<=0)
{
world->DestroyAndReplace(X(), Y(), Z()+1);
}
fuelLevel -= DamageLevel();
}
}
bool CArmorClass::GetReferenceDamageAdj (const CItem *pItem, CSpaceObject *pInstalled, int *retiHP, int *retArray)
// GetReferenceDamageAdj
//
// Returns armor HP after adjustment for damage type
{
int i;
CItemCtx ItemCtx(pItem, pInstalled);
int iHP = GetMaxHP(ItemCtx);
if (retiHP)
*retiHP = iHP;
for (i = 0; i < damageCount; i++)
{
DamageDesc Damage((DamageTypes)i, DiceRange(0, 0, 0));
int iAdj = GetDamageAdj(ItemCtx.GetMods(), Damage);
if (retArray)
retArray[i] = CalcHPDamageAdj(iHP, iAdj);
}
return true;
}
bool Enemy::IsHit(const double & ColX, const double & ColY, const int& DAMAGE)
{
if (!isExist) return false;
bool isHit;
switch (type)
{
case 0:
isHit = Vector2D::CirclesCollision(hitRange, 6, pos.x, pos.y + 9., ColX, ColY);
break;
case 1:
break;
case 2:
isHit = Vector2D::CirclesCollision(hitRange, 6, pos.x, pos.y + 9., ColX, ColY);
break;
case 3:
break;
case 4:
isHit = Vector2D::CirclesCollision(hitRange, 6, pos.x, pos.y + 9., ColX, ColY);
break;
case 5:
break;
case 6:
break;
case 7:
break;
}
// ダメージ処理
if (isHit) Damage(DAMAGE);
// 全部falseならここにくる
return isHit;
}
static bool HitItemFunc(TTileItem *ti, void *data)
{
HitItemData *hData = data;
if (!CanHit(hData->Obj->flags, hData->Obj->ActorUID, ti))
{
goto bail;
}
int targetUID = -1;
hData->HitType = GetHitType(ti, hData->Obj, &targetUID);
Damage(
hData->Obj->vel, hData->Obj->bulletClass->Power,
hData->Obj->flags, hData->Obj->PlayerUID, hData->Obj->ActorUID,
ti->kind, targetUID,
hData->Obj->bulletClass->Special);
if (hData->Obj->tileItem.SoundLock <= 0)
{
hData->Obj->tileItem.SoundLock += SOUND_LOCK_TILE_OBJECT;
}
if (ti->SoundLock <= 0)
{
ti->SoundLock += SOUND_LOCK_TILE_OBJECT;
}
if (hData->Obj->specialLock <= 0)
{
hData->Obj->specialLock += SPECIAL_LOCK;
}
bail:
// Whether to produce multiple hits from the same TMobileObject
return hData->MultipleHits;
}
//update the game
void GameWindow::Update()
{
//if in game
if(m_bInGame){
//Spawn Enemies
Spawn();
//check for damage
Damage();
//run enemy ai
for(int i = 0; i < 7; i++){
if(m_eAllEnemies[i].m_bOnScreen){
m_eAllEnemies[i].AI(m_pPlatformList, m_PlatformCount, m_wPlayer);
}
}
//move all entities
Movement();
//check players displayed image
m_wPlayer.SwapImage();
m_wPlayer.Tick();
//apply gravity to all entities
Gravity();
//reset player velocity
m_wPlayer.m_xVelocity = 0;
}
//handle key input
HandleInput();
//draw all images and sprites
Draw();
//check if game over
EndGame();
}
int ActionStack::addDamage(MTGCardInstance * _source, Damageable * _target, int _damage)
{
Damage * damage = NEW Damage(observer, _source, _target, _damage);
addAction(damage);
_source->thatmuch = _damage;
_target->thatmuch = _damage;
return 1;
}
void Ability::Activate(Combatant& attacker, Combatant& defender) const
{
int damage = 0;
damage = Damage();
if( m->activate ){
m->activate(attacker, defender);
}
defender.TakeDamage(damage);
}
Damage Damage::operator *(double factor) const
{
std::vector<AttackValue> retValues;
for(unsigned i=0 ; i<values.size() ; i++)
{
retValues.push_back(values.at(i)*factor);
}
return Damage(retValues,effects);
}
void Personaje::FunctionTimerSixSec()
{
if(CoinTimer)
{
WinCoin();
Damage();
}
}
void ASpell::Move( float t )
{
if( Arcs )
{
AProjectile::Move( t );
}
// Deal DPS to each overlap
// Deal damage to the target, draining HP
for( AGameObject* go : HitOverlaps )
{
// Anything in the hit overlaps bounds gets damaged
if( DamagesFriendly && isAllyTo( go ) )
Damage( go, t );
else if( isEnemyTo( go ) )
Damage( go, t );
}
}
// Animal:: section
inner_actions Animal::ActInner() {
if ( GROUP_MEAT != GetSubGroup(Sub()) ) return INNER_ACTION_NONE;
if ( satiation <= 0 ) {
Damage(5, DAMAGE_HUNGER);
} else {
--satiation;
Mend(1);
}
emit Updated();
return INNER_ACTION_NONE;
}
// 080910 LUJ, 데미지 상태 처리를 RESULTINFO 구조체를 받아 처리하도록 함
void CObjectActionManager::ApplyResult(CObject* pObject,CObject* pOperator,RESULTINFO* pRInfo,BYTE DamageKind)
{
if(pRInfo->RealDamage)
{
Damage(pObject,pOperator,DamageKind,pRInfo->RealDamage,*pRInfo);
if(pObject->IsDied())
Die(pObject,pOperator,FALSE,pRInfo->bCritical,pRInfo->bDecisive);
}
// 100223 ShinJS --- 마나 데미지 추가
if(pRInfo->ManaDamage)
{
ManaDamage(pObject,pOperator,DamageKind,pRInfo->ManaDamage,*pRInfo);
}
if(pRInfo->CounterDamage)
{
const RESULTINFO emptyResult = { 0 };
Damage(pOperator,pObject,eDamageKind_Counter,pRInfo->CounterDamage,emptyResult);
if(pOperator->IsDied())
Die(pOperator,pObject,FALSE,FALSE,FALSE);
}
if(pRInfo->HealLife)
Heal(pObject,pOperator,DamageKind,pRInfo->HealLife);
if(pRInfo->RechargeMana)
Recharge(pObject,pOperator,0,pRInfo->RechargeMana);
if(pRInfo->StunTime)
if(pRInfo->Vampiric_Life)
{
if(pOperator->GetID() == gHeroID)
HERO->ChangeLife(pRInfo->Vampiric_Life);
else
pOperator->SetLife(pOperator->GetLife()+pRInfo->Vampiric_Life);
}
if(pRInfo->Vampiric_Mana)
{
pOperator->SetMana(pOperator->GetMana()+pRInfo->Vampiric_Mana);
}
}
/*********************************************************************
** Shadow::attack Function
** Description: This function simulates rolling attack dice.
** Parameters: No input parameters. The function returns a Damage object.
*********************************************************************/
Damage Shadow::attack()
{
int attackTotal = 0;
for (int i=0; i<numAttackDice; i++)
{
int rollVal;
rollVal = (rand() % numAttackSides + 1);
//std::cout << "Attack Roll " << i+1 << " = " << rollVal << std::endl;
attackTotal += rollVal;
}
//std::cout << "Attack Total: " << attackTotal << std::endl;
return Damage(attackTotal, false);
}
bool World::CanMove(const ushort x, const ushort y, const ushort z,
const ushort newx, const ushort newy, const ushort newz,
const quint8 dir)
{
if ( !InBounds(x, y, z) ) {
return false;
}
Block * const block = GetBlock(x, y, z);
if ( NOT_MOVABLE == block->Movable() ) {
return false;
}
Block * block_to = GetBlock(newx, newy, newz);
if ( ENVIRONMENT == block->Movable() ) {
if ( *block == *block_to ) {
return false;
} else if ( MOVABLE == block_to->Movable() ) {
NoCheckMove(x, y, z, newx, newy, newz, dir);
return true;
}
}
switch ( block_to->BeforePush(dir, block) ) {
case MOVE_SELF: block_to = GetBlock(newx, newy, newz); break;
case DESTROY:
DeleteBlock(block_to);
PutBlock(Normal(AIR), newx, newy, newz);
return true;
break;
case JUMP:
if ( DOWN!=dir && UP!=dir ) {
Jump(x, y, z, dir);
return false;
}
break;
case MOVE_UP:
if ( DOWN!=dir && UP!=dir ) {
Move(x, y, z, UP);
return false;
}
break;
case DAMAGE:
Damage(x, y, z,
block_to->DamageLevel(),
block_to->DamageKind());
return false;
break;
}
return ( ENVIRONMENT==block_to->Movable() );/* ||
( (block->Weight() > block_to->Weight()) &&
Move(newx, newy, newz, dir) ) );*/
} // bool World::CanMove(ushort x, y, z, newx, newy, newz, quint8 dir)
void
BatMan::OnCollided(Collider* col)
{
if (col->Type() == col_attack&&col->CharaType() == ct_player){
Vector2 vec = (_pos - _playerRef.GetCenter()).Normalize();
Reject(Vector2(vec.x * 20, 0));
Player* p = dynamic_cast<Player*>(col->_gameObject);
Damage(p->GetAttackDmg());
}
if (col->Type() == col_default&&col->CharaType() == ct_player){
}
}
void DamagerDamaged::addDamage(int damage, DamagerDamaged* source)
{
for (vector<Damage>::iterator i = damages.begin(); i != damages.end(); ++i)
if (i->source == source->card)
{
i->damage += damage;
if (0 >= i->damage)
damages.erase(i);
return;
}
if (0 < damage)
damages.push_back(Damage(card->getObserver(), source->card, card, damage, Damage::DAMAGE_COMBAT));
return;
}
bool Shot_ice::Action(Game_Manager* gm_)
{
if(valid)
{
if(gm_)
{
for(list<Unit*>::iterator it = gm_->unit_list.begin();it != gm_->unit_list.end();it++)
{
bool hit_ = true;
if((*it)->isLive() && !(*it)->isNonTarget() && (*it)->GetTeam() != GetTeam())
{
for(vector<Unit*>::iterator it2 = hit_unit.begin(); it2 != hit_unit.end() ; it2++)
{
if((*it) == (*it2))
{
hit_ = false;
}
}
if(hit_ && (*it)->collution(GetPos(), 3.0f))
{
Damage(gm_, (*it));
}
}
}
}
if(collution(3))
{
valid = false;
}
else
Move();
UpDownSpeed(-decel);
size += size_inc;
color -= 0x02000000;
time--;
if(time<0)
valid = false;
}
if(!valid)
{
return true;
}
return false;
}
static bool HitItemFunc(TTileItem *ti, void *data)
{
HitItemData *hData = data;
if (!CanHit(hData->Obj->flags, hData->Obj->ActorUID, ti))
{
goto bail;
}
int targetUID = -1;
switch (ti->kind)
{
case KIND_CHARACTER:
hData->HitType = HIT_FLESH;
targetUID = ((const TActor *)CArrayGet(&gActors, ti->id))->uid;
break;
case KIND_OBJECT:
hData->HitType = HIT_OBJECT;
targetUID = ((const TObject *)CArrayGet(&gObjs, ti->id))->uid;
break;
default:
CASSERT(false, "cannot damage target kind");
break;
}
if (hData->Obj->soundLock > 0 ||
!HasHitSound(
hData->Obj->bulletClass->Power, hData->Obj->flags, hData->Obj->PlayerUID,
ti->kind, targetUID, hData->Obj->bulletClass->Special, true))
{
hData->HitType = HIT_NONE;
}
Damage(
hData->Obj->vel, hData->Obj->bulletClass->Power,
hData->Obj->flags, hData->Obj->PlayerUID, hData->Obj->ActorUID,
ti->kind, targetUID,
hData->Obj->bulletClass->Special);
if (hData->Obj->soundLock <= 0)
{
hData->Obj->soundLock += SOUND_LOCK_MOBILE_OBJECT;
}
if (hData->Obj->specialLock <= 0)
{
hData->Obj->specialLock += SPECIAL_LOCK;
}
bail:
// Whether to produce multiple hits from the same TMobileObject
return hData->MultipleHits;
}
void Animal::DoRareAction() {
if ( GROUP_MEAT != GetSubGroup(Sub()) ) return;
if ( not IsSubAround(AIR) ) {
if ( breath <= 0 ) {
Damage(10, DAMAGE_BREATH);
} else {
--breath;
}
} else if ( breath < MAX_BREATH ) {
++breath;
}
if ( GetDurability() <= 0 ) {
GetWorld()->DestroyAndReplace(X(), Y(), Z());
} else {
emit Updated();
}
}
void Enemy::Move()
{
switch (m_pattern)
{
case 0: Move_0(); break;
case 1: Move_1(); break;
case 2: Move_2(); break;
case 3: Move_3(); break;
case 4: Move_4(); break;
case 5: Move_5(); break;
case 6: Move_6(); break;
case 7: Move_7(); break;
}
const bool& IS_HIT = Game::IsHitPlayer(hitRange, Player::HIT_RANGE, pos.x, pos.y, Game::GetPlayerPos().x, Game::GetPlayerPos().y);
if (IS_HIT) Damage(1);
}
void Box::DoRareAction() {
if ( GROUP_MEAT == GetSubGroup(Sub()) ) {
Damage(MAX_DURABILITY/World::SECONDS_IN_DAY, DAMAGE_TIME);
if ( GetDurability() <= 0 ) {
World::GetWorld()->DestroyAndReplace(X(), Y(), Z());
}
} else if ( Sub() == DIFFERENT ) {
World* const world = World::GetWorld();
Inventory* const inv =
world->GetBlock(X(), Y(), Z()-1)->HasInventory();
if ( inv ) {
inv->GetAll(this);
}
if ( IsEmpty() ) {
world->DestroyAndReplace(X(), Y(), Z());
}
}
}
//-----------------------------------------------------------------------------
//! 更新
//-----------------------------------------------------------------------------
void EnemyLeader::UpdateByCommand()
{
// 一定距離はなれていなければ
if( (_goalPos - _position).length() <= 3000.0f && !_goGoal){
// ターゲットの検索、設定
EnemyBase::searchAndSetTarget();
// キーの更新
_key->Update();
//---- キャラの移動
Vector3 StickState = _key->getVector();
// スティック操作がされていたら
if( abs(atan2f(StickState._x, StickState._z) ) > 0.0f )
{
_rotation._y = atan2f( StickState._x, StickState._z );
_speed = _myStatus->getParam()->_speedMAX;
}else{
_speed = 0.0f;
}
}else{
UpdateNormal(_goalPos);
}
// 当たり判定とダメージ計算
s32 damage = EnemyBase::calcDamageAndCollision();
s32 currentAnimation = _pTaskModel->getAnimation();
if( damage > 0 ) {
Damage(damage);
// ダメージアニメーションへ
_pTaskModel->setAnimation(_aniDamage);
}else if( currentAnimation == _aniDamage ){
_isDamage = false;
}
_pTaskModel->update();
}
void Wall::Update()
{
if ( GetNonWallCount() == 0 && _timer % 8 < 2 ) {
if ( GetHP() > 2 )
PlaySound( Lib::SOUND_ENEMY_SPAWN );
Damage( GetHP() - 2, false, 0 );
}
if ( _rotate ) {
Vec2 d( _dir );
d.Rotate( ( _rdir ? _timer - TIMER : TIMER - _timer ) * M_PI / ( M_FOUR * TIMER ) );
SetRotation( d.Angle() );
_timer--;
if ( _timer <= 0 ) {
_timer = 0;
_rotate = false;
_dir.Rotate( _rdir ? -M_PI / M_FOUR : M_PI / M_FOUR );
}
return;
}
else {
_timer++;
if ( _timer > TIMER * 6 ) {
if ( IsOnScreen() ) {
_timer = TIMER;
_rotate = true;
}
else
_timer = 0;
}
}
Vec2 pos = GetPosition();
if ( ( pos._x < 0 && _dir._x < -M_PT_ZERO_ONE ) ||
( pos._y < 0 && _dir._y < -M_PT_ZERO_ONE ) ||
( pos._x > Lib::WIDTH && _dir._x > M_PT_ZERO_ONE ) ||
( pos._y > Lib::HEIGHT && _dir._y > M_PT_ZERO_ONE ) ) {
_dir = Vec2() - _dir;
_dir.Normalise();
}
Move( _dir * SPEED );
SetRotation( _dir.Angle() );
}
