int fh_privileged( dbref target, dbref player, FLAG flag, int fflags, int reset ) {
int has_it;
if( !God( player ) ) {
if( !isPlayer( player ) || ( player != Owner( player ) ) ) {
return 0;
}
if( isPlayer( target ) ) {
return 0;
}
if( fflags & FLAG_WORD3 ) {
has_it = ( Flags3( player ) & flag ) ? 1 : 0;
} else if( fflags & FLAG_WORD2 ) {
has_it = ( Flags2( player ) & flag ) ? 1 : 0;
} else {
has_it = ( Flags( player ) & flag ) ? 1 : 0;
}
if( !has_it ) {
return 0;
}
}
return ( fh_any( target, player, flag, fflags, reset ) );
}
static bool fh_ascii(dbref target, dbref player, FLAG flag, int fflags, bool reset)
{
bool result;
if (!isPlayer(target))
{
return false;
}
result = fh_any(target, player, flag, fflags, reset);
if (result)
{
DESC *dtemp;
DESC_ITER_PLAYER(target, dtemp)
{
if (!reset)
dtemp->encoding = CHARSET_ASCII;
else
dtemp->encoding = dtemp->negotiated_encoding;
}
}
return result;
}
int fh_dark_bit( dbref target, dbref player, FLAG flag, int fflags, int reset ) {
if( !reset && isPlayer( target ) && !( ( target == player ) &&
Can_Hide( player ) ) && ( !Wizard( player ) && !God( player ) ) ) {
return 0;
}
return ( fh_any( target, player, flag, fflags, reset ) );
}
void match_player(void)
{
if (md.confidence >= CON_DBREF)
{
return;
}
if (Good_obj(md.absolute_form) && isPlayer(md.absolute_form))
{
promote_match(md.absolute_form, CON_DBREF);
return;
}
if (*md.string == LOOKUP_TOKEN)
{
UTF8 *p;
for (p = md.string + 1; mux_isspace(*p); p++)
{
; // Nothing.
}
dbref match = lookup_player(NOTHING, p, true);
if (Good_obj(match))
{
promote_match(match, CON_TOKEN);
}
}
}
void PvpInternal::setPermFactionEnemyFlags(TangibleObject &dest)
{
FATAL(!dest.isAuthoritative(), ("setPermFactionEnemyFlags on non-authoritative object"));
// run through the current enemies list and remove any permanent factional enemies
TangibleObject::PvpEnemies &enemies = dest.getPvpEnemies();
unsigned int pos = 0;
while (pos < enemies.size())
{
if (!(enemies.get(pos).expireTime) && (enemies.get(pos).enemyId == NetworkId::cms_invalid) && isFactionAligned(enemies.get(pos).enemyFaction))
enemies.erase(pos);
else
++pos;
}
// add any permanent factional enemy flags
Pvp::FactionId align = getAlignedFaction(dest);
Pvp::PvpType pvpType = dest.getPvpType();
// if player character is neutral, see if he's a mercenary
if (PvpData::isNeutralFactionId(align) && isPlayer(dest))
{
align = dest.getPvpMercenaryFaction();
pvpType = dest.getPvpMercenaryType();
}
if ((pvpType == PvpType_Declared) && align)
{
std::vector<Pvp::FactionId> const &opposingFactions = PvpFactions::getOpposingFactions(align);
for (std::vector<Pvp::FactionId>::const_iterator j = opposingFactions.begin(); j != opposingFactions.end(); ++j)
enemies.push_back(PvpEnemy(NetworkId::cms_invalid, *j, 0));
}
}
static bool fh_unicode(dbref target, dbref player, FLAG flag, int fflags, bool reset)
{
if (!isPlayer(target))
{
return false;
}
if (fh_any(target, player, flag, fflags, reset))
{
DESC *dtemp;
DESC_ITER_PLAYER(target, dtemp)
{
if (!reset)
{
if (CHARSET_UTF8 != dtemp->encoding)
{
// Since we are changing to the UTF-8 character set, the
// printable state machine needs to be initialized.
//
dtemp->encoding = CHARSET_UTF8;
dtemp->raw_codepoint_state = CL_PRINT_START_STATE;
}
}
else
{
dtemp->encoding = dtemp->negotiated_encoding;
}
}
return true;
}
return false;
}
char *flag_description( dbref player, dbref target ) {
char *buff, *bp;
FLAGENT *fp;
int otype;
FLAG fv;
/*
* Allocate the return buffer
*/
otype = Typeof( target );
bp = buff = alloc_mbuf( "flag_description" );
/*
* Store the header strings and object type
*/
safe_mb_str( ( char * ) "Type: ", buff, &bp );
safe_mb_str( ( char * ) object_types[otype].name, buff, &bp );
safe_mb_str( ( char * ) " Flags:", buff, &bp );
if( object_types[otype].perm != CA_PUBLIC ) {
return buff;
}
/*
* Store the type-invariant flags
*/
for( fp = gen_flags; fp->flagname; fp++ ) {
if( fp->flagflag & FLAG_WORD3 ) {
fv = Flags3( target );
} else if( fp->flagflag & FLAG_WORD2 ) {
fv = Flags2( target );
} else {
fv = Flags( target );
}
if( fv & fp->flagvalue ) {
if( ( fp->listperm & CA_WIZARD ) && !Wizard( player ) ) {
continue;
}
if( ( fp->listperm & CA_GOD ) && !God( player ) ) {
continue;
}
/*
* don't show CONNECT on dark wizards to mortals
*/
if( isPlayer( target ) && isConnFlag( fp ) &&
Can_Hide( target ) && Hidden( target ) &&
!See_Hidden( player ) ) {
continue;
}
safe_mb_chr( ' ', buff, &bp );
safe_mb_str( ( char * ) fp->flagname, buff, &bp );
}
}
return buff;
}
MagicType Creature::getCastingType() const {
CreatureClass cls = getClass();
if(isPlayer()) {
if(getAsConstPlayer()->getSecondClass() == CreatureClass::MAGE)
cls = CreatureClass::MAGE;
else if(getAsConstPlayer()->getSecondClass() == CreatureClass::CLERIC)
cls = CreatureClass::CLERIC;
}
switch(cls) {
case CreatureClass::DUNGEONMASTER:
case CreatureClass::CARETAKER:
case CreatureClass::BUILDER:
// pure arcane
case CreatureClass::MAGE:
case CreatureClass::LICH:
// hybrid arcane
case CreatureClass::BARD:
case CreatureClass::PUREBLOOD:
return(Arcane);
// pure divine
case CreatureClass::CLERIC:
case CreatureClass::DRUID:
// hybrid divine
case CreatureClass::PALADIN:
case CreatureClass::RANGER:
case CreatureClass::DEATHKNIGHT:
return(Divine);
default:
return(NO_MAGIC_TYPE);
}
}
void Unit::changeState(UNIT_STATE state)
{
if ((isPlayer() && !m_isSelected && m_state == UNIT_STATE::WAITING))
{
//return;
}
if (m_state != state)
{
if (!m_isSelected || (m_isSelected && !isPlayer() && m_state == UNIT_STATE::WAITING) || (!isPlayer() && m_state == UNIT_STATE::FIRING))
{
m_previousState = m_state;
m_state = state;
}
}
}
int has_flag( dbref player, dbref it, char *flagname ) {
FLAGENT *fp;
FLAG fv;
fp = find_flag( it, flagname );
if( fp == NULL ) { /* find_flag() uppercases the string */
if( !strcmp( flagname, "PLAYER" ) ) {
return isPlayer( it );
}
if( !strcmp( flagname, "THING" ) ) {
return isThing( it );
}
if( !strcmp( flagname, "ROOM" ) ) {
return isRoom( it );
}
if( !strcmp( flagname, "EXIT" ) ) {
return isExit( it );
}
return 0;
}
if( fp->flagflag & FLAG_WORD3 ) {
fv = Flags3( it );
} else if( fp->flagflag & FLAG_WORD2 ) {
fv = Flags2( it );
} else {
fv = Flags( it );
}
if( fv & fp->flagvalue ) {
if( ( fp->listperm & CA_WIZARD ) && !Wizard( player ) ) {
return 0;
}
if( ( fp->listperm & CA_GOD ) && !God( player ) ) {
return 0;
}
/*
* don't show CONNECT on dark wizards to mortals
*/
if( isPlayer( it ) && isConnFlag( fp ) &&
Can_Hide( it ) && Hidden( it ) && !See_Hidden( player ) ) {
return 0;
}
return 1;
}
return 0;
}
HS_DBREF CHSInterface::ConsoleUser(int objnum)
{
HS_DBREF dbUser;
dbUser = GetLock(objnum, LOCK_USE);
if (dbUser == HSNOTHING || objnum == HSNOTHING)
return HSNOTHING;
#ifndef TM3
if (IsPlayer(dbUser))
#else
if (isPlayer(dbUser))
#endif
{
// If the user is not in the same location as the object,
// set the lock to the object and return NOTHING.
#ifdef PENNMUSH
if (Location(dbUser) != Location(objnum)
|| !HasFlag(dbUser, TYPE_PLAYER, PLAYER_CONNECT)
&& IsPlayer(dbUser))
#else
if (Location(dbUser) != Location(objnum) || !Connected(dbUser)
&& isPlayer(dbUser))
#endif
{
SetLock(objnum, objnum, LOCK_USE);
// Delete attribute from player.
hsInterface.AtrDel(dbUser, "MCONSOLE", GOD);
#ifdef PENNMUSH
notify_except(db[Location(objnum)].contents, dbUser,
tprintf("%s unmans the %s.", Name(dbUser),
Name(objnum)), 0);
#else
notify_except(Location(objnum), dbUser, NOTHING,
tprintf("%s unmans the %s.", Name(dbUser),
Name(objnum)), 0);
#endif
return NOTHING;
}
}
return dbUser;
}
void Character::collisionAction(Character *c) {
if(!c || (c->isNPC() || !isNPC()) || (c->isPlayer() || !isPlayer())) {
// Stop movement timer
m_movementTimer.stop();
// Update collision state
m_inCollision = true;
// Exit function to avoid problems if c == NULL
return;
}
if(c->isMonster() && isPlayer()) {
// Hurt player
hurt(m_x + m_hitboxW / 2 - c->x() + c->hitboxW() / 2, m_y + m_hitboxH / 2 - c->y() + c->hitboxH() / 2);
}
}
bool Creature::isPureCaster() const {
int second = isPlayer() ? getAsConstPlayer()->hasSecondClass() : 0;
return( (cClass == CreatureClass::MAGE && !second) ||
cClass == CreatureClass::LICH ||
(cClass == CreatureClass::CLERIC && !second) ||
cClass == CreatureClass::DRUID
);
}
/*
Determines if the position is available to have a stone placed in it
param x,y: integer coordinates of the stone to place
return bool: whether a stone can be placed there
*/
bool GoBoard::isValidMove( int x, int y)
{
if( isOnBoard( x, y ) && isPlayer( EMPTY, x, y ) && !isKo( x, y ))
{
return true;
}
return false;
}
int ph_restrict_player(dbref target, dbref player, POWER power, int fpowers, int reset)
{
if (isPlayer(target) && !Wizard(player) && !God(player)) {
return 0;
}
return (ph_any(target, player, power, fpowers, reset));
}
// NFY_DRAIN or NFY_NFYALL
//
static int CallBack_NotifySemaphoreDrainOrAll(PTASK_RECORD p)
{
if (p->fpTask == Task_SemaphoreTimeout)
{
// This represents a semaphore.
//
BQUE *point = (BQUE *)(p->arg_voidptr);
if ( point->sem == Notify_Sem
&& ( point->attr == Notify_Attr
|| !Notify_Attr))
{
Notify_Num_Done++;
if (Notify_Key == NFY_DRAIN)
{
// Discard the command
//
giveto(point->executor, mudconf.waitcost);
a_Queue(Owner(point->executor), -1);
for (int i = 0; i < MAX_GLOBAL_REGS; i++)
{
if (point->scr[i])
{
RegRelease(point->scr[i]);
point->scr[i] = NULL;
}
}
MEMFREE(point->text);
point->text = NULL;
free_qentry(point);
return IU_REMOVE_TASK;
}
else
{
// Allow the command to run. The priority may have been
// PRIORITY_SUSPEND, so we need to change it.
//
if (isPlayer(point->enactor))
{
p->iPriority = PRIORITY_PLAYER;
}
else
{
p->iPriority = PRIORITY_OBJECT;
}
p->ltaWhen.GetUTC();
p->fpTask = Task_RunQueueEntry;
return IU_UPDATE_TASK;
}
}
}
return IU_NEXT_TASK;
}
static int CallBack_HaltQueue(PTASK_RECORD p)
{
if ( p->fpTask == Task_RunQueueEntry
#ifdef QUERY_SLAVE
|| p->fpTask == Task_SQLTimeout
#endif // QUERY_SLAVE
|| p->fpTask == Task_SemaphoreTimeout)
{
// This is a @wait, timed Semaphore Task, or timed SQL Query.
//
BQUE *point = (BQUE *)(p->arg_voidptr);
if (que_want(point, Halt_Player_Target, Halt_Object_Target))
{
// Accounting for pennies and queue quota.
//
dbref dbOwner = point->executor;
if (!isPlayer(dbOwner))
{
dbOwner = Owner(dbOwner);
}
if (dbOwner != Halt_Player_Run)
{
if (Halt_Player_Run != NOTHING)
{
giveto(Halt_Player_Run, mudconf.waitcost * Halt_Entries_Run);
a_Queue(Halt_Player_Run, -Halt_Entries_Run);
}
Halt_Player_Run = dbOwner;
Halt_Entries_Run = 0;
}
Halt_Entries++;
Halt_Entries_Run++;
if (p->fpTask == Task_SemaphoreTimeout)
{
add_to(point->sem, -1, point->attr);
}
for (int i = 0; i < MAX_GLOBAL_REGS; i++)
{
if (point->scr[i])
{
RegRelease(point->scr[i]);
point->scr[i] = NULL;
}
}
MEMFREE(point->text);
point->text = NULL;
free_qentry(point);
return IU_REMOVE_TASK;
}
}
return IU_NEXT_TASK;
}
void RegularBattleScene::onHpChange(int spot, int)
{
info.animatedSpot = spot;
if (isPlayer(spot) && info.percentage[spot]) {
info.animatedValue = gui.bars[spot]->value() * data()->poke(spot).totalLife() / 100;
} else {
info.animatedValue = gui.bars[spot]->value();
}
pause();
animateHpBar();
}
int ph_privileged(dbref target, dbref player, POWER power, int fpowers, int reset)
{
if (!God(player)) {
if (!isPlayer(player) || (player != Owner(player))) {
return 0;
}
if (isPlayer(target)) {
return 0;
}
if (Powers(player) & power) {
return (ph_any(target, player, power, fpowers, reset));
} else {
return 0;
}
}
return (ph_any(target, player, power, fpowers, reset));
}
bool Creature::isHybridCaster() const {
CreatureClass second = isPlayer() ? getAsConstPlayer()->getSecondClass() : CreatureClass::NONE;
return( cClass == CreatureClass::BARD ||
cClass == CreatureClass::DEATHKNIGHT ||
cClass == CreatureClass::PALADIN ||
cClass == CreatureClass::RANGER ||
cClass == CreatureClass::PUREBLOOD ||
second == CreatureClass::MAGE ||
(cClass == CreatureClass::MAGE && second != CreatureClass::NONE) ||
(cClass == CreatureClass::CLERIC && second != CreatureClass::NONE)
);
}
static bool fh_dark_bit(dbref target, dbref player, FLAG flag, int fflags, bool reset)
{
if ( !reset
&& isPlayer(target)
&& !( (target == player)
&& Can_Hide(player))
&& !Wizard(player))
{
return false;
}
return (fh_any(target, player, flag, fflags, reset));
}
void do_report(dbref executor, dbref caller, dbref enactor, int extra)
{
UNUSED_PARAMETER(caller);
UNUSED_PARAMETER(enactor);
UNUSED_PARAMETER(extra);
char *buff = alloc_mbuf("do_report");
int nBin[NPERIODS];
int i;
for (i = 0; i < NPERIODS; i++)
{
nBin[i] = 0;
}
CLinearTimeAbsolute ltaNow, ltaPlayer;
ltaNow.GetLocal();
const int PeriodInSeconds = 28800;
int iPlayer;
DO_WHOLE_DB(iPlayer)
{
if (isPlayer(iPlayer))
{
int aowner, aflags;
char *player_last = atr_get(iPlayer, A_LAST, &aowner, &aflags);
if (ltaPlayer.SetString(player_last))
{
CLinearTimeDelta ltd(ltaPlayer, ltaNow);
int ltdSeconds = ltd.ReturnSeconds();
int iBin = ltdSeconds / PeriodInSeconds;
if (0 <= iBin && iBin < NPERIODS)
{
nBin[iBin]++;
}
}
free_lbuf(player_last);
}
}
int iHour, nSum = 0;
notify(executor, "Day Hours Players Total");
for (i = 0, iHour = 0; i < NPERIODS; i++, iHour += 8)
{
nSum += nBin[i];
mux_sprintf(buff, MBUF_SIZE, "%3d %03d - %03d: %6d %6d",
iHour/24 + 1, iHour, iHour+8, nBin[i], nSum);
notify(executor, buff);
}
free_mbuf(buff);
}
/* ---------------------------------------------------------------------------
* fh_privileged: You can set this flag on a non-player object, if you
* yourself have this flag and are a player who owns themselves (i.e.,
* no robots). Only God can set this on a player.
*/
static bool fh_privileged
(
dbref target,
dbref player,
FLAG flag,
int fflags,
bool reset
)
{
if (!God(player))
{
if ( isPlayer(target)
#if !defined(FIRANMUX)
|| !isPlayer(player)
|| player != Owner(player)
#endif // FIRANMUX
|| (db[player].fs.word[fflags] & flag) == 0)
{
return false;
}
}
return (fh_any(target, player, flag, fflags, reset));
}
void Unit::setTargetAngle(float targetAngle)
{
if (targetAngle != 2 * PI && targetAngle != m_targetAngle)
{
m_targetAngle = NormalizeAngle(targetAngle);
m_state = UNIT_STATE::MOVING;
}
else if (isPlayer() && targetAngle != m_targetAngle)
{
m_targetAngle = m_positionAngle;
m_state = UNIT_STATE::WAITING;
}
}
RegularBattleScene::RegularBattleScene(battledata_ptr dat, BattleDefaultTheme *theme, bool logNames) : mData(dat), unpausing(false),
pauseCount(0), info(dat->numberOfSlots()), mLogNames(logNames)
{
gui.theme = theme;
/* Sets the bar in non-percentage mode for players */
for (int i = 0; i < data()->numberOfSlots(); i++) {
if (isPlayer(i)) {
info.percentage[i] = false;
}
}
setupGui();
updateTimers();
}
/* ---------------------------------------------------------------------------
* fh_player_bit: Can set and reset this on everything but players.
*/
static bool fh_player_bit
(
dbref target,
dbref player,
FLAG flag,
int fflags,
bool reset
)
{
if (isPlayer(target))
{
return false;
}
return (fh_any(target, player, flag, fflags, reset));
}
/*
* ---------------------------------------------------------------------------
* * fh_restrict_player (renamed from fh_fixed): Only Wizards can set
* * this on players, but ordinary players can set it on other types
* * of objects.
*/
static bool fh_restrict_player
(
dbref target,
dbref player,
FLAG flag,
int fflags,
bool reset
)
{
if ( isPlayer(target)
&& !Wizard(player))
{
return false;
}
return (fh_any(target, player, flag, fflags, reset));
}
int betRound() {
int bet;
P_PLAYER playerOnTurn = game.flow.pCurrentPlayer;
if (game.flow.round == 0)
playerOnTurn = game.bet.smallBlindPlayer;
//auto-bets
if (game.flow.round == 0) {
smallBlindBet(playerOnTurn);
playerOnTurn = nextPlayer();
bigBlindBet(playerOnTurn);
playerOnTurn = nextPlayer();
}
//manual bets
for (int i = 0; i < MAX_PLAYERS; i++) {
printf("Player on turn: %s - %d\n", playerOnTurn->name, i);
if (playerOnTurn->isInGame && !playerOnTurn->allIn) {
if (isPlayer(playerOnTurn))
bet = betPlayer(playerOnTurn);
else
bet = betAI(playerOnTurn);
switch (bet) {
case -1: //fold
playerOnTurn->isInGame = 0;
break;
case 0: //check
break;
default: //raise - resatrt bet round
i = -1;
break;
}
}
playerOnTurn = nextPlayer();
//end betting if other players folded
if (countPlayersInGame() < 2)
return 0;
}
return 1;
}
static bool fh_hear_bit(dbref target, dbref player, FLAG flag, int fflags, bool reset)
{
if (isPlayer(target) && (flag & MONITOR))
{
if (Can_Monitor(player))
{
return (fh_any(target, player, flag, fflags, reset));
}
else
{
return false;
}
}
bool could_hear = Hearer(target);
bool result = fh_any(target, player, flag, fflags, reset);
handle_ears(target, could_hear, Hearer(target));
return result;
}
TRIGGER( targetobj )(obj user, obj usedon)
{
if(usedon == NULL())
{
removeObjVar(this, "bountyPlayer");
removeObjVar(this, "bountyPlayerName");
return(0x00);
}
if(!isPlayer(usedon))
{
removeObjVar(this, "bountyPlayer");
removeObjVar(this, "bountyPlayerName");
return(0x00);
}
systemMessage(user, getName(usedon) + " selected.");
setObjVar(this, "bountyPlayer", usedon);
setObjVar(this, "bountyPlayerName", getName(usedon));
return(0x00);
}
