/***********************************************************
remove people online
***********************************************************/
void CommunityBox::RemoveOnline(const std::string & listname, const std::string &_offline)
{
if(listname == "online")
{
CEGUI::Listbox * lb = static_cast<CEGUI::Listbox *> (
CEGUI::WindowManager::getSingleton().getWindow("Community/onlinelist"));
std::map<std::string, CEGUI::ListboxItem *>::iterator itmap = _onlines.find(_offline);
if(itmap != _onlines.end())
{
lb->removeItem(itmap->second);
_onlines.erase(itmap);
}
if(IsFriend(_offline))
UpdateFriend(_offline);
}
if(listname == "IRC")
{
CEGUI::Listbox * lb = static_cast<CEGUI::Listbox *> (
CEGUI::WindowManager::getSingleton().getWindow("Community/IRClist"));
CEGUI::ListboxItem *it = lb->findItemWithText(_offline, NULL);
if(it != NULL)
lb->removeItem(it);
}
}
/////////////////////////////////////////////////
/// [Serverside] Assistance: GameObject can target a target with a helpful spell
///
/// @note Relations API Tier 3
///
/// This function is not intented to have client-side counterpart by original design.
/// Some gameobjects can be involved in spell casting, so server needs additional API support.
/// It utilizes owners CanAssistSpell if owner exists
/////////////////////////////////////////////////
bool GameObject::CanAssistSpell(Unit const* target, SpellEntry const* spellInfo) const
{
Unit* owner = GetOwner();
if (owner)
return owner->CanAssistSpell(target, spellInfo);
return IsFriend(target);
}
///
/// Check whether the two players have some relationship between them.
///
bool CheckRelation( CPlayer *first, const std::string &second, long check_flag )
{
bool ret = false;
if( check_flag & PR_FRIEND )
{
// when ret is false, it will then check the second expression.
ret = ( ret || IsFriend( first, second.c_str() ) );
}
if( check_flag & PR_TEAM )
{
ret = ( ret || IsInSameTeam( first, second.c_str() ) );
}
if( check_flag & PR_FACTION )
{
ret = ( ret || IsInSameFaction( first, second.c_str() ) );
}
return ret;
}
/***********************************************************
add people online
***********************************************************/
void CommunityBox::AddOnline(const std::string & listname, const std::string &_online,
const std::string &_status, const std::string &color)
{
if(listname == "online")
{
CEGUI::Listbox * lb = static_cast<CEGUI::Listbox *> (
CEGUI::WindowManager::getSingleton().getWindow("Community/onlinelist"));
std::string dis = "[colour='" + color + "']" + _online;
if(_status != "")
dis += " (" + _status + ")";
std::map<std::string, CEGUI::ListboxItem *>::iterator itmap = _onlines.find(_online);
if(itmap != _onlines.end())
{
itmap->second->setText(dis);
lb->invalidate();
}
else
{
CEGUI::ListboxItem *it = new MyComListItem(dis);
lb->addItem(it);
_onlines[_online] = it;
}
if(IsFriend(_online))
UpdateFriend(_online);
}
if(listname == "IRC")
{
CEGUI::Listbox * lb = static_cast<CEGUI::Listbox *> (
CEGUI::WindowManager::getSingleton().getWindow("Community/IRClist"));
CEGUI::ListboxItem *it = lb->findItemWithText(_online, NULL);
if(it == NULL)
lb->addItem(new MyComListItem(_online));
}
}
/////////////////////////////////////////////////
/// Opposition: Unit treats another unit as an enemy it can attack (generic)
///
/// @note Relations API Tier 1
///
/// Client-side counterpart: <tt>CGUnit_C::CanAttack(const CGUnit_C *this, const CGUnit_C *unit)</tt>
/// Backbone of all spells which can target hostile units.
/////////////////////////////////////////////////
bool Unit::CanAttack(const Unit* unit) const
{
// Simple sanity check
if (!unit)
return false;
// Original logic
// Creatures cannot attack player ghosts, unless it is a specially flagged ghost creature
if (GetTypeId() == TYPEID_UNIT && unit->GetTypeId() == TYPEID_PLAYER && static_cast<const Player*>(unit)->HasFlag(PLAYER_FLAGS, PLAYER_FLAGS_GHOST))
{
if (!(static_cast<const Creature*>(this)->GetCreatureInfo()->CreatureTypeFlags & CREATURE_TYPEFLAGS_GHOST_VISIBLE))
return false;
}
// We can't attack unit when at least one of these flags is present on it:
const uint32 mask = (UNIT_FLAG_NON_ATTACKABLE | UNIT_FLAG_NOT_ATTACKABLE_1 | UNIT_FLAG_NON_ATTACKABLE_2 | UNIT_FLAG_TAXI_FLIGHT | UNIT_FLAG_NOT_SELECTABLE);
if (unit->HasFlag(UNIT_FIELD_FLAGS, mask))
return false;
// Cross-check immunity and sanctuary flags: this <-> unit
const bool thisPlayerControlled = HasFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_PLAYER_CONTROLLED);
if (thisPlayerControlled)
{
if (unit->HasFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_IMMUNE_TO_PLAYER))
return false;
}
else if (unit->HasFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_IMMUNE_TO_NPC))
return false;
const bool unitPlayerControlled = unit->HasFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_PLAYER_CONTROLLED);
if (unitPlayerControlled)
{
if (HasFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_IMMUNE_TO_PLAYER))
return false;
}
else if (HasFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_IMMUNE_TO_NPC))
return false;
if (thisPlayerControlled || unitPlayerControlled)
{
if (thisPlayerControlled && unitPlayerControlled)
{
if (IsFriend(unit))
return false;
const Player* thisPlayer = GetControllingPlayer();
if (!thisPlayer)
return true;
const Player* unitPlayer = unit->GetControllingPlayer();
if (!unitPlayer)
return true;
if (thisPlayer->IsInDuelWith(unitPlayer))
return true;
if (unitPlayer->IsPvP())
return true;
if (thisPlayer->IsPvPFreeForAll() && unitPlayer->IsPvPFreeForAll())
return true;
return false;
}
return (!IsFriend(unit));
}
return (IsEnemy(unit) || unit->IsEnemy(this));
}
//---------------------------------------------------------
//---------------------------------------------------------
void CBounceBomb::SearchThink()
{
if( !UTIL_FindClientInPVS(edict()) )
{
// Sleep!
SetNextThink( gpGlobals->curtime + 0.5 );
return;
}
if( (CAI_BaseNPC::m_nDebugBits & bits_debugDisableAI) )
{
if( IsAwake() )
{
Wake(false);
}
SetNextThink( gpGlobals->curtime + 0.5 );
return;
}
SetNextThink( gpGlobals->curtime + 0.1 );
StudioFrameAdvance();
if( m_pConstraint && gpGlobals->curtime - m_flTimeGrabbed >= 1.0f )
{
m_OnPulledUp.FireOutput( this, this );
SetMineState( MINE_STATE_CAPTIVE );
return;
}
float flNearestNPCDist = FindNearestNPC();
if( flNearestNPCDist <= BOUNCEBOMB_WARN_RADIUS )
{
if( !IsAwake() )
{
Wake( true );
}
}
else
{
if( IsAwake() )
{
Wake( false );
}
return;
}
if( flNearestNPCDist <= BOUNCEBOMB_DETONATE_RADIUS && !IsFriend( m_hNearestNPC ) )
{
if( m_bBounce )
{
SetMineState( MINE_STATE_TRIGGERED );
}
else
{
// Don't pop up in the air, just explode if the NPC gets closer than explode radius.
SetThink( &CBounceBomb::ExplodeThink );
SetNextThink( gpGlobals->curtime + m_flExplosionDelay );
}
}
}
//---------------------------------------------------------
// Returns distance to the nearest BaseCombatCharacter.
//---------------------------------------------------------
float CBounceBomb::FindNearestNPC()
{
float flNearest = (BOUNCEBOMB_WARN_RADIUS * BOUNCEBOMB_WARN_RADIUS) + 1.0;
// Assume this search won't find anyone.
SetNearestNPC( NULL );
CAI_BaseNPC **ppAIs = g_AI_Manager.AccessAIs();
int nAIs = g_AI_Manager.NumAIs();
for ( int i = 0; i < nAIs; i++ )
{
CAI_BaseNPC *pNPC = ppAIs[ i ];
if( pNPC->IsAlive() )
{
// ignore hidden objects
if ( pNPC->IsEffectActive( EF_NODRAW ) )
continue;
// Don't bother with NPC's that are below me.
if( pNPC->EyePosition().z < GetAbsOrigin().z )
continue;
// Disregard things that want to be disregarded
if( pNPC->Classify() == CLASS_NONE )
continue;
// Disregard bullseyes
if( pNPC->Classify() == CLASS_BULLSEYE )
continue;
// Disregard turrets
if( pNPC->m_iClassname == gm_iszFloorTurretClassname || pNPC->m_iClassname == gm_iszGroundTurretClassname )
continue;
float flDist = (GetAbsOrigin() - pNPC->GetAbsOrigin()).LengthSqr();
if( flDist < flNearest )
{
// Now do a visibility test.
if( FVisible( pNPC, MASK_SOLID_BRUSHONLY ) )
{
flNearest = flDist;
SetNearestNPC( pNPC );
}
}
}
}
// finally, check the player.
CBasePlayer *pPlayer = UTIL_GetLocalPlayer();
if( pPlayer && !(pPlayer->GetFlags() & FL_NOTARGET) )
{
float flDist = (pPlayer->GetAbsOrigin() - GetAbsOrigin() ).LengthSqr();
if( flDist < flNearest && FVisible( pPlayer, MASK_SOLID_BRUSHONLY ) )
{
flNearest = flDist;
SetNearestNPC( pPlayer );
}
}
if( m_hNearestNPC.Get() )
{
// If sprite is active, update its color to reflect who is nearest.
if( IsFriend( m_hNearestNPC ) )
{
if( m_bFoeNearest )
{
// Changing state to where a friend is nearest.
if( IsFriend( m_hNearestNPC ) )
{
// Friend
UpdateLight( true, 0, 255, 0, 190 );
m_bFoeNearest = false;
}
}
}
else // it's a foe
{
if( !m_bFoeNearest )
{
// Changing state to where a foe is nearest.
UpdateLight( true, 255, 0, 0, 190 );
m_bFoeNearest = true;
}
}
}
return sqrt( flNearest );
}
