void AttackCurrentMonster(void)
{
DamageCurrentMonster(GetCharacter()->stats.strength, GetCharacter()->level, GetMonsterDefense(currentMonster->defenseLevel), 1, 100);
}
void UseLightningOnCurrentMonster(void)
{
DamageCurrentMonster(GetCharacter()->stats.magic, GetCharacter()->level, GetMonsterDefense(currentMonster->magicDefenseLevel), 3, currentMonster->extraLightningDefenseMultiplier);
}
bool CGUIFontTTFBase::Load(const std::string& strFilename, float height, float aspect, float lineSpacing, bool border)
{
// we now know that this object is unique - only the GUIFont objects are non-unique, so no need
// for reference tracking these fonts
m_face = g_freeTypeLibrary.GetFont(strFilename, height, aspect, m_fontFileInMemory);
if (!m_face)
return false;
/*
the values used are described below
XBMC coords Freetype coords
0 _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ bbox.yMax, ascender
A \
A A |
A A |
AAAAA pppp cellAscender
A A p p |
A A p p |
m_cellBaseLine _ _A_ _A_ pppp_ _ _ _ _/_ _ _ _ _ 0, base line.
p \
p cellDescender
m_cellHeight _ _ _ _ _ p _ _ _ _ _ _/_ _ _ _ _ bbox.yMin, descender
*/
int cellDescender = std::min<int>(m_face->bbox.yMin, m_face->descender);
int cellAscender = std::max<int>(m_face->bbox.yMax, m_face->ascender);
if (border)
{
/*
add on the strength of any border - the non-bordered font needs
aligning with the bordered font by utilising GetTextBaseLine()
*/
FT_Pos strength = FT_MulFix( m_face->units_per_EM, m_face->size->metrics.y_scale) / 12;
if (strength < 128)
strength = 128;
cellDescender -= strength;
cellAscender += strength;
m_stroker = g_freeTypeLibrary.GetStroker();
if (m_stroker)
FT_Stroker_Set(m_stroker, strength, FT_STROKER_LINECAP_ROUND, FT_STROKER_LINEJOIN_ROUND, 0);
}
// scale to pixel sizing, rounding so that maximal extent is obtained
float scaler = height / m_face->units_per_EM;
cellDescender = MathUtils::round_int(cellDescender * scaler - 0.5f); // round down
cellAscender = MathUtils::round_int(cellAscender * scaler + 0.5f); // round up
m_cellBaseLine = cellAscender;
m_cellHeight = cellAscender - cellDescender;
m_height = height;
delete(m_texture);
m_texture = NULL;
delete[] m_char;
m_char = NULL;
m_maxChars = 0;
m_numChars = 0;
m_strFilename = strFilename;
m_textureHeight = 0;
m_textureWidth = ((m_cellHeight * CHARS_PER_TEXTURE_LINE) & ~63) + 64;
m_textureWidth = CBaseTexture::PadPow2(m_textureWidth);
if (m_textureWidth > g_Windowing.GetMaxTextureSize())
m_textureWidth = g_Windowing.GetMaxTextureSize();
m_textureScaleX = 1.0f / m_textureWidth;
// set the posX and posY so that our texture will be created on first character write.
m_posX = m_textureWidth;
m_posY = -(int)GetTextureLineHeight();
// cache the ellipses width
Character *ellipse = GetCharacter(L'.');
if (ellipse) m_ellipsesWidth = ellipse->advance;
return true;
}
void CGUIFontTTFBase::DrawTextInternal(float x, float y, const vecColors &colors, const vecText &text, uint32_t alignment, float maxPixelWidth, bool scrolling)
{
Begin();
uint32_t rawAlignment = alignment;
bool dirtyCache(false);
bool hardwareClipping = g_Windowing.ScissorsCanEffectClipping();
CGUIFontCacheStaticPosition staticPos(x, y);
CGUIFontCacheDynamicPosition dynamicPos;
if (hardwareClipping)
{
dynamicPos = CGUIFontCacheDynamicPosition(g_graphicsContext.ScaleFinalXCoord(x, y),
g_graphicsContext.ScaleFinalYCoord(x, y),
g_graphicsContext.ScaleFinalZCoord(x, y));
}
CVertexBuffer unusedVertexBuffer;
CVertexBuffer &vertexBuffer = hardwareClipping ?
m_dynamicCache.Lookup(dynamicPos,
colors, text,
alignment, maxPixelWidth,
scrolling,
XbmcThreads::SystemClockMillis(),
dirtyCache) :
unusedVertexBuffer;
std::shared_ptr<std::vector<SVertex> > tempVertices = std::make_shared<std::vector<SVertex> >();
std::shared_ptr<std::vector<SVertex> > &vertices = hardwareClipping ?
tempVertices :
static_cast<std::shared_ptr<std::vector<SVertex> >&>(m_staticCache.Lookup(staticPos,
colors, text,
alignment, maxPixelWidth,
scrolling,
XbmcThreads::SystemClockMillis(),
dirtyCache));
if (dirtyCache)
{
// save the origin, which is scaled separately
m_originX = x;
m_originY = y;
// Check if we will really need to truncate or justify the text
if ( alignment & XBFONT_TRUNCATED )
{
if ( maxPixelWidth <= 0.0f || GetTextWidthInternal(text.begin(), text.end()) <= maxPixelWidth)
alignment &= ~XBFONT_TRUNCATED;
}
else if ( alignment & XBFONT_JUSTIFIED )
{
if ( maxPixelWidth <= 0.0f )
alignment &= ~XBFONT_JUSTIFIED;
}
// calculate sizing information
float startX = 0;
float startY = (alignment & XBFONT_CENTER_Y) ? -0.5f*m_cellHeight : 0; // vertical centering
if ( alignment & (XBFONT_RIGHT | XBFONT_CENTER_X) )
{
// Get the extent of this line
float w = GetTextWidthInternal( text.begin(), text.end() );
if ( alignment & XBFONT_TRUNCATED && w > maxPixelWidth + 0.5f ) // + 0.5f due to rounding issues
w = maxPixelWidth;
if ( alignment & XBFONT_CENTER_X)
w *= 0.5f;
// Offset this line's starting position
startX -= w;
}
float spacePerSpaceCharacter = 0; // for justification effects
if ( alignment & XBFONT_JUSTIFIED )
{
// first compute the size of the text to render in both characters and pixels
unsigned int numSpaces = 0;
float linePixels = 0;
for (vecText::const_iterator pos = text.begin(); pos != text.end(); ++pos)
{
Character *ch = GetCharacter(*pos);
if (ch)
{
if ((*pos & 0xffff) == L' ')
numSpaces += 1;
linePixels += ch->advance;
}
}
if (numSpaces > 0)
spacePerSpaceCharacter = (maxPixelWidth - linePixels) / numSpaces;
}
float cursorX = 0; // current position along the line
// Collect all the Character info in a first pass, in case any of them
// are not currently cached and cause the texture to be enlarged, which
// would invalidate the texture coordinates.
std::queue<Character> characters;
if (alignment & XBFONT_TRUNCATED)
GetCharacter(L'.');
for (vecText::const_iterator pos = text.begin(); pos != text.end(); ++pos)
{
Character *ch = GetCharacter(*pos);
if (!ch)
{
Character null = { 0 };
characters.push(null);
continue;
}
characters.push(*ch);
if (maxPixelWidth > 0 &&
cursorX + ((alignment & XBFONT_TRUNCATED) ? ch->advance + 3 * m_ellipsesWidth : 0) > maxPixelWidth)
break;
cursorX += ch->advance;
}
cursorX = 0;
for (vecText::const_iterator pos = text.begin(); pos != text.end(); ++pos)
{
// If starting text on a new line, determine justification effects
// Get the current letter in the CStdString
color_t color = (*pos & 0xff0000) >> 16;
if (color >= colors.size())
color = 0;
color = colors[color];
// grab the next character
Character *ch = &characters.front();
if (ch->letterAndStyle == 0)
{
characters.pop();
continue;
}
if ( alignment & XBFONT_TRUNCATED )
{
// Check if we will be exceeded the max allowed width
if ( cursorX + ch->advance + 3 * m_ellipsesWidth > maxPixelWidth )
{
// Yup. Let's draw the ellipses, then bail
// Perhaps we should really bail to the next line in this case??
Character *period = GetCharacter(L'.');
if (!period)
break;
for (int i = 0; i < 3; i++)
{
RenderCharacter(startX + cursorX, startY, period, color, !scrolling, *tempVertices);
cursorX += period->advance;
}
break;
}
}
else if (maxPixelWidth > 0 && cursorX > maxPixelWidth)
break; // exceeded max allowed width - stop rendering
RenderCharacter(startX + cursorX, startY, ch, color, !scrolling, *tempVertices);
if ( alignment & XBFONT_JUSTIFIED )
{
if ((*pos & 0xffff) == L' ')
cursorX += ch->advance + spacePerSpaceCharacter;
else
cursorX += ch->advance;
}
else
cursorX += ch->advance;
characters.pop();
}
if (hardwareClipping)
{
CVertexBuffer &vertexBuffer = m_dynamicCache.Lookup(dynamicPos,
colors, text,
rawAlignment, maxPixelWidth,
scrolling,
XbmcThreads::SystemClockMillis(),
dirtyCache);
CVertexBuffer newVertexBuffer = CreateVertexBuffer(*tempVertices);
vertexBuffer = newVertexBuffer;
m_vertexTrans.push_back(CTranslatedVertices(0, 0, 0, &vertexBuffer, g_graphicsContext.GetClipRegion()));
}
else
{
m_staticCache.Lookup(staticPos,
colors, text,
rawAlignment, maxPixelWidth,
scrolling,
XbmcThreads::SystemClockMillis(),
dirtyCache) = *static_cast<CGUIFontCacheStaticValue *>(&tempVertices);
/* Append the new vertices to the set collected since the first Begin() call */
m_vertex.insert(m_vertex.end(), tempVertices->begin(), tempVertices->end());
}
}
else
{
if (hardwareClipping)
bool RPG_AiControllerComponent::HasLineOfSightToTarget(bool& left, bool& center, bool& right) const
{
VASSERT(GetCharacter());
VASSERT(m_target);
RPG_ClosestRaycastResultIgnoreSourceTarget raycastResult(GetCharacter(), m_target);
hkvVec3 rayStart;
GetCharacter()->CalcPositionForTargeting(rayStart);
hkvVec3 rayEnd;
GetTarget()->CalcPositionForTargeting(rayEnd);
hkvVec3 directionToTarget = rayEnd - rayStart;
directionToTarget.normalizeIfNotZero();
// check from the center
center = true;
raycastResult.Reset();
raycastResult.vRayStart = rayStart;
raycastResult.vRayEnd = rayEnd;
Vision::GetApplication()->GetPhysicsModule()->PerformRaycast(&raycastResult);
if (GetCharacter()->ShouldDisplayDebugStateInformation())
{
if(raycastResult.bHit)
{
Vision::Game.DrawSingleLine(raycastResult.vRayStart, raycastResult.vRayEnd, VColorRef(208, 24, 24), 3.0f);
}
else
{
Vision::Game.DrawSingleLine(raycastResult.vRayStart, raycastResult.vRayEnd, VColorRef(24, 208, 24), 3.0f);
}
}
if(raycastResult.bHit)
{
center = false;
}
// check from the left side
left = true;
raycastResult.Reset();
raycastResult.vRayStart = rayStart + hkvVec3(-directionToTarget.y, directionToTarget.x, 0.0f) * GetCharacter()->GetCollisionRadius();
raycastResult.vRayEnd = rayEnd + hkvVec3(-directionToTarget.y, directionToTarget.x, 0.0f) * GetCharacter()->GetCollisionRadius();
Vision::GetApplication()->GetPhysicsModule()->PerformRaycast(&raycastResult);
if (GetCharacter()->ShouldDisplayDebugStateInformation())
{
if(raycastResult.bHit)
{
Vision::Game.DrawSingleLine(raycastResult.vRayStart, raycastResult.vRayEnd, VColorRef(208, 24, 24), 3.0f);
}
else
{
Vision::Game.DrawSingleLine(raycastResult.vRayStart, raycastResult.vRayEnd, VColorRef(24, 208, 24), 3.0f);
}
}
if(raycastResult.bHit)
{
left = false;
}
// check from the right side
right = true;
raycastResult.Reset();
raycastResult.vRayStart = rayStart + hkvVec3(directionToTarget.y, -directionToTarget.x, 0.0f) * GetCharacter()->GetCollisionRadius();
raycastResult.vRayEnd = rayEnd + hkvVec3(directionToTarget.y, -directionToTarget.x, 0.0f) * GetCharacter()->GetCollisionRadius();
Vision::GetApplication()->GetPhysicsModule()->PerformRaycast(&raycastResult);
if (GetCharacter()->ShouldDisplayDebugStateInformation())
{
if(raycastResult.bHit)
{
Vision::Game.DrawSingleLine(raycastResult.vRayStart, raycastResult.vRayEnd, VColorRef(208, 24, 24), 3.0f);
}
else
{
Vision::Game.DrawSingleLine(raycastResult.vRayStart, raycastResult.vRayEnd, VColorRef(24, 208, 24), 3.0f);
}
}
if(raycastResult.bHit)
{
right = false;
}
return left && center && right;
}
// check attack task for Group
void AIAttack_CheckTask(string sGroupID)
{
ref rG1 = Group_GetGroupByID(sGroupID);
ref rG2 = Group_GetGroupByID(rG1.Task.Target);
string sGroupType1 = Group_GetTypeR(rG1);
ref rCharacter1 = Group_GetGroupCommanderR(rG1);
// skip if group is player group
if (sGroupID == PLAYER_GROUP) { return; }
// if group task is lock, check for task complete, if not - continue task
float fAng = frnd() * PIm2;
if (Group_isDeadR(rG2))
{
switch (sGroupType1)
{
case "trade":
Group_SetTaskMove(sGroupID, stf(rG1.Task.Target.Pos.x), stf(rG1.Task.Target.Pos.z));
break;
case "war":
Group_SetTaskMove(sGroupID, 10000.0 * sin(fAng) , 10000.0 * cos(fAng));
break;
case "pirate":
Group_SetTaskMove(sGroupID, 10000.0 * sin(fAng) , 10000.0 * cos(fAng));
break;
}
// find new task
return;
}
if (!Group_isTaskLockR(rG1))
{
float fHP1 = Group_GetPowerHP_R(rG1);
float fHP2 = Group_GetPowerHP_R(rG2);
float fAHP1 = Group_GetAttackHPDistance_R(rG1, 300.0);
float fAHPRatio1 = fHP1 / (fAHP1 + 0.0001);
float fHPRatio1 = fHP1 / (fHP2 + 0.0001);
float fLeadership = MakeFloat(GetSummonSkillFromName(rCharacter1, SKILL_LEADERSHIP)) / SKILL_MAX;
float fTmp = fAHPRatio1;// * Clampf(fLeadership + 0.01);
switch (AIAttack_SelectTask(sGroupType1, fTmp))
{
case AITASK_RUNAWAY:
Group_SetTaskRunaway(sGroupID);
return;
break;
}
}
// check attack task for dead targets
int iIndex = 0;
int iCharactersNum2 = Group_GetCharactersNumR(rG2);
// find targets for rG1
int i = 0;
while (true)
{
int iCharacterIndex = Group_GetCharacterIndexR(rG1, i); i++;
if (iCharacterIndex < 0) { break; }
ref rCharacter = GetCharacter(iCharacterIndex);
if (LAi_IsDead(rCharacter)) { continue; }
if (CheckAttribute(rCharacter, "SeaAI.Task"))
{
if (sti(rCharacter.SeaAI.Task) != AITASK_ATTACK) { continue; }
if (!LAi_IsDead(&Characters[sti(rCharacter.SeaAI.Task.Target)])) { continue; }
}
int iCharacterVictim = -1;
while (iCharacterVictim < 0)
{
iCharacterVictim = Group_GetCharacterIndexR(rG2, iIndex);
if (iCharacterVictim < 0) { iIndex = 0; continue; }
if (LAi_IsDead(&Characters[iCharacterVictim])) { iCharacterVictim = -1; }
iIndex++;
}
Ship_SetTaskAttack(SECONDARY_TASK, iCharacterIndex, iCharacterVictim);
}
}
void CActiveConsole::ProcessKeyPressL(TChar aChar)
{
if (aChar == EKeyEscape)
{
PRINT(_L("CActiveConsole: ESC key pressed -> stopping active scheduler...\n"));
CActiveScheduler::Stop();
return;
}
aChar.UpperCase();
if (iCmdGetValue != 0 && aChar == '\r')
{
if (iLastChar == 'K')
{
iValue *= iGetHexValue ? 0x400 : 1000;
}
if (iLastChar == 'M')
{
iValue *= iGetHexValue ? 0x10000 : 1000000;
}
PRINT1(_L("CActiveConsole: Value %d\n"),iValue);
ProcessValue();
}
if (iCmdGetValue != 0 )
{
if (iGetHexValue)
{
if (aChar.IsDigit())
{
iValue = iValue * 16 + aChar.GetNumericValue();
}
else
{
if (aChar.IsHexDigit())
{
iValue = iValue * 16 + (TUint)aChar - 'A' + 10;
}
else
{
if (aChar != 'K' && aChar != 'M')
{
PRINT(_L("Illegal hexadecimal character - Enter command\n"));
iCmdGetValue = 0;
}
}
}
}
else
{
if (aChar.IsDigit())
{
iValue = iValue * 10 + aChar.GetNumericValue();
}
else
{
if ((aChar == 'X') && (iLastChar == '0') && (iValue == 0))
iGetHexValue = ETrue;
else
{
if (aChar != 'K' && aChar != 'M')
{
test.Printf(_L("Illegal decimal character - Enter command\n"));
iCmdGetValue = 0;
}
}
}
}
}
else
{
switch (aChar)
{
case 'F' :
TESTNEXT(_L("Flushing Cache"));
test_KErrNone(DPTest::FlushCache());
ShowMemoryUse();
iPrompt = ETrue;
break;
case 'I' :
CacheSize(0,0);
ShowMemoryUse();
iPrompt = ETrue;
break;
case 'Q' :
gQuiet = ETrue;
iPrompt = ETrue;
break;
case 'V' :
gQuiet = EFalse;
iPrompt = ETrue;
break;
case '?' :
ShowHelp();
break;
case '=' :
iCmdGetValue = iLastChar;
iGetHexValue = EFalse;
iValue = 0;
break;
default :
if (aChar.IsDigit())
{
if (iLastChar == 'R')
{
if (aChar.GetNumericValue() < (TInt)gNextChunk)
{
ReadChunk (&gChunk[aChar.GetNumericValue()]);
}
else
{
for (TUint i = 0; i < gNextChunk; i++)
ReadChunk (&gChunk[i]);
}
iPrompt = ETrue;
}
if (iLastChar == 'W')
{
if (aChar.GetNumericValue() < (TInt)gNextChunk)
{
WriteChunk (&gChunk[aChar.GetNumericValue()]);
}
else
{
for (TUint i = 0; i < gNextChunk; i++)
WriteChunk (&gChunk[i]);
}
iPrompt = ETrue;
}
if (iLastChar == 'M')
{
if (aChar.GetNumericValue() == 0)
{
iActions = (TUint16)(iPeriod < KFlushQuietLimit ? EFlushQuiet : EFlush);
}
else
{
iActions = (TUint16)(aChar.GetNumericValue() << 4);
}
iPrompt = ETrue;
}
}
break;
}
}
iLastChar = aChar;
GetCharacter();
return;
}
void Update(clock_t &tLast, short &charIndex, bool &newWord, char(&command)[MAX_CHARATERS_PER_LINE])
{
command[charIndex] = GetCharacter(newWord); //escuchamos la entrada de datos con un timeout para poder dedicar tiempo a los calculos posteriores
//verificamos que tenemos caracter leido o nueva palabra empezada
if (command[charIndex] != NULL || newWord != 0)
{
if (newWord == 0) { newWord = 1; } //ponemos a true el boleano de palabra
//cuando pulse enter el jugador, almacenamos la palabra en el stack y reseteamos el indice de nuestra palabra asi como el boleano
//en caso contrario aumentamos el indice para obtener una nueva letra
if (command[charIndex] == '\n')
{
command[charIndex] = 0;
if (charIndex > 0) //si tan solo pulsa enter no necesitamos almacenarlo en la pila
{
newWord = 0;
stackCommands.Push((std::string) command);
command[0] = 0;
}
else
{
Prompt();
}
charIndex = 0;
}
else
{
++charIndex;
}
}
//tratamiento acciones o comandos
//Si la pila no esta vacia y el delay se cumple ejecutamos una nueva instruccion
if (!stackCommands.Empty() && (clock() - tLast) > DELAY_BETWEEN_COMMANDS)
{
//La palabra reservada para ejecutar 'salir del juego' es especial ya que requiere de verificación.
if (LEAVE == Upcase(stackCommands.Consult()))
{
char a[MAX_CHARATERS_PER_LINE]; //para no obtener datos de la pila definios una nueva variable
a[0] = 0;
do //para salir hay que verificar antes
{
printf(LEAVE_Q);
scanf_s("%s", a, _countof(a));
} while (!Compare(YES, Upcase(a)) && !Compare(NO, Upcase(a)));
if (Compare(YES, Upcase(a))) gameState = endLoop;
else
{
Prompt();
stackCommands.Pop();
}
}
else
ShowCommands();
tLast = clock();
}
}
void CPlayer::Snap(int SnappingClient)
{
#ifdef CONF_DEBUG
if(!g_Config.m_DbgDummies || m_ClientID < MAX_CLIENTS-g_Config.m_DbgDummies)
#endif
if(!Server()->ClientIngame(m_ClientID))
return;
CNetObj_ClientInfo *pClientInfo = static_cast<CNetObj_ClientInfo *>(Server()->SnapNewItem(NETOBJTYPE_CLIENTINFO, m_ClientID, sizeof(CNetObj_ClientInfo)));
if(!pClientInfo)
return;
StrToInts(&pClientInfo->m_Name0, 4, Server()->ClientName(m_ClientID));
StrToInts(&pClientInfo->m_Clan0, 3, Server()->ClientClan(m_ClientID));
pClientInfo->m_Country = Server()->ClientCountry(m_ClientID);
StrToInts(&pClientInfo->m_Skin0, 6, m_TeeInfos.m_SkinName);
pClientInfo->m_UseCustomColor = m_TeeInfos.m_UseCustomColor;
pClientInfo->m_ColorBody = m_TeeInfos.m_ColorBody;
pClientInfo->m_ColorFeet = m_TeeInfos.m_ColorFeet;
CNetObj_PlayerInfo *pPlayerInfo = static_cast<CNetObj_PlayerInfo *>(Server()->SnapNewItem(NETOBJTYPE_PLAYERINFO, m_ClientID, sizeof(CNetObj_PlayerInfo)));
if(!pPlayerInfo)
return;
pPlayerInfo->m_Latency = SnappingClient == -1 ? m_Latency.m_Min : GameServer()->m_apPlayers[SnappingClient]->m_aActLatency[m_ClientID];
pPlayerInfo->m_Local = 0;
pPlayerInfo->m_ClientID = m_ClientID;
pPlayerInfo->m_Score = m_Score;
//pPlayerInfo->m_Team = m_Team;
if (SnappingClient != GetCID())
pPlayerInfo->m_Team = m_Team;
else
{
if (GetCharacter() || GameServer()->m_pController->IsGameOver())
pPlayerInfo->m_Team = m_Team;
else
pPlayerInfo->m_Team = TEAM_SPECTATORS;
}
/*
if (SnappingClient == GetCID())
pPlayerInfo->m_Team = m_Team;
else
pPlayerInfo->m_Team = m_WantedTeam;
*/
if(m_ClientID == SnappingClient)
pPlayerInfo->m_Local = 1;
if(m_ClientID == SnappingClient && pPlayerInfo->m_Team == TEAM_SPECTATORS)
{
CNetObj_SpectatorInfo *pSpectatorInfo = static_cast<CNetObj_SpectatorInfo *>(Server()->SnapNewItem(NETOBJTYPE_SPECTATORINFO, m_ClientID, sizeof(CNetObj_SpectatorInfo)));
if(!pSpectatorInfo)
{
// SPEC_FREEVIEW
//pSpectatorInfo->m_X = 0;
//pSpectatorInfo->m_Y = 0;
}
else
{
pSpectatorInfo->m_SpectatorID = m_SpectatorID;
pSpectatorInfo->m_X = m_ViewPos.x;
pSpectatorInfo->m_Y = m_ViewPos.y;
}
}
}
void CPlayer::Snap(int SnappingClient)
{
if(!IsDummy() && !Server()->ClientIngame(m_ClientID))
return;
CNetObj_PlayerInfo *pPlayerInfo = static_cast<CNetObj_PlayerInfo *>(Server()->SnapNewItem(NETOBJTYPE_PLAYERINFO, m_ClientID, sizeof(CNetObj_PlayerInfo)));
if(!pPlayerInfo)
return;
pPlayerInfo->m_PlayerFlags = m_PlayerFlags&PLAYERFLAG_CHATTING;
if(Server()->IsAuthed(m_ClientID))
pPlayerInfo->m_PlayerFlags |= PLAYERFLAG_ADMIN;
if(!GameServer()->m_pController->IsPlayerReadyMode() || m_IsReadyToPlay)
pPlayerInfo->m_PlayerFlags |= PLAYERFLAG_READY;
if(m_RespawnDisabled && (!GetCharacter() || !GetCharacter()->IsAlive()))
pPlayerInfo->m_PlayerFlags |= PLAYERFLAG_DEAD;
if(SnappingClient != -1 && (m_Team == TEAM_SPECTATORS || m_DeadSpecMode) && (SnappingClient == m_SpectatorID))
pPlayerInfo->m_PlayerFlags |= PLAYERFLAG_WATCHING;
pPlayerInfo->m_Latency = SnappingClient == -1 ? m_Latency.m_Min : GameServer()->m_apPlayers[SnappingClient]->m_aActLatency[m_ClientID];
pPlayerInfo->m_Score = m_Score;
if(m_ClientID == SnappingClient && (m_Team == TEAM_SPECTATORS || m_DeadSpecMode))
{
CNetObj_SpectatorInfo *pSpectatorInfo = static_cast<CNetObj_SpectatorInfo *>(Server()->SnapNewItem(NETOBJTYPE_SPECTATORINFO, m_ClientID, sizeof(CNetObj_SpectatorInfo)));
if(!pSpectatorInfo)
return;
pSpectatorInfo->m_SpecMode = m_SpecMode;
pSpectatorInfo->m_SpectatorID = m_SpectatorID;
if(m_pSpecFlag)
{
pSpectatorInfo->m_X = m_pSpecFlag->GetPos().x;
pSpectatorInfo->m_Y = m_pSpecFlag->GetPos().y;
}
else
{
pSpectatorInfo->m_X = m_ViewPos.x;
pSpectatorInfo->m_Y = m_ViewPos.y;
}
}
// demo recording
if(SnappingClient == -1)
{
CNetObj_De_ClientInfo *pClientInfo = static_cast<CNetObj_De_ClientInfo *>(Server()->SnapNewItem(NETOBJTYPE_DE_CLIENTINFO, m_ClientID, sizeof(CNetObj_De_ClientInfo)));
if(!pClientInfo)
return;
pClientInfo->m_Local = 0;
pClientInfo->m_Team = m_Team;
StrToInts(pClientInfo->m_aName, 4, Server()->ClientName(m_ClientID));
StrToInts(pClientInfo->m_aClan, 3, Server()->ClientClan(m_ClientID));
pClientInfo->m_Country = Server()->ClientCountry(m_ClientID);
for(int p = 0; p < 6; p++)
{
StrToInts(pClientInfo->m_aaSkinPartNames[p], 6, m_TeeInfos.m_aaSkinPartNames[p]);
pClientInfo->m_aUseCustomColors[p] = m_TeeInfos.m_aUseCustomColors[p];
pClientInfo->m_aSkinPartColors[p] = m_TeeInfos.m_aSkinPartColors[p];
}
}
}
// Command control vars
bool Game_Interpreter::CommandControlVariables(RPG::EventCommand const& com) { // Code ControlVars
int i, value = 0;
Game_Actor* actor;
Game_Character* character;
switch (com.parameters[4]) {
case 0:
// Constant
value = com.parameters[5];
break;
case 1:
// Var A ops B
value = Game_Variables[com.parameters[5]];
break;
case 2:
// Number of var A ops B
value = Game_Variables[Game_Variables[com.parameters[5]]];
break;
case 3:
// Random between range
int a, b;
a = max(com.parameters[5], com.parameters[6]);
b = min(com.parameters[5], com.parameters[6]);
value = rand() % (a-b+1)+b;
break;
case 4:
// Items
switch (com.parameters[6]) {
case 0:
// Number of items posessed
value = Game_Party::ItemNumber(com.parameters[5]);
break;
case 1:
// How often the item is equipped
value = Game_Party::ItemNumber(com.parameters[5], true);
break;
}
break;
case 5:
// Hero
actor = Game_Actors::GetActor(com.parameters[5]);
if (actor != NULL) {
switch (com.parameters[6]) {
case 0:
// Level
value = actor->GetLevel();
break;
case 1:
// Experience
value = actor->GetExp();
break;
case 2:
// Current HP
value = actor->GetHp();
break;
case 3:
// Current MP
value = actor->GetSp();
break;
case 4:
// Max HP
value = actor->GetMaxHp();
break;
case 5:
// Max MP
value = actor->GetMaxSp();
break;
case 6:
// Attack
value = actor->GetAtk();
break;
case 7:
// Defense
value = actor->GetDef();
break;
case 8:
// Intelligence
value = actor->GetSpi();
break;
case 9:
// Agility
value = actor->GetAgi();
break;
case 10:
// Weapon ID
value = actor->GetWeaponId();
break;
case 11:
// Shield ID
value = actor->GetShieldId();
break;
case 12:
// Armor ID
value = actor->GetArmorId();
break;
case 13:
// Helmet ID
value = actor->GetHelmetId();
break;
case 14:
// Accesory ID
value = actor->GetAccessoryId();
break;
}
}
break;
case 6:
// Characters
if (com.parameters[6] != 0){
character = GetCharacter(com.parameters[5]);
} else {
// Special case for Player Map ID
character = NULL;
value = Game_Map::GetMapId();
}
// Other cases
if (character != NULL) {
switch (com.parameters[6]) {
case 1:
// X Coordinate
value = character->GetX();
break;
case 2:
// Y Coordinate
value = character->GetY();
break;
case 3:
// TODO Orientation
// Needs testing
value = character->GetDirection();
break;
case 4:
// Screen X
value = character->GetScreenX();
break;
case 5:
// Screen Y
value = character->GetScreenY();
}
}
break;
case 7:
// More
switch (com.parameters[5]) {
case 0:
// Gold
value = Game_Party::GetGold();
break;
case 1:
value = Game_Party::ReadTimer(Game_Party::Timer1);
break;
case 2:
// Number of heroes in party
value = Game_Party::GetActors().size();
break;
case 3:
// Number of saves
value = Game_System::GetSaveCount();
break;
case 4:
// Number of battles
value = Game_Party::GetBattleCount();
break;
case 5:
// Number of wins
value = Game_Party::GetWinCount();
break;
case 6:
// Number of defeats
value = Game_Party::GetDefeatCount();
break;
case 7:
// Number of escapes (aka run away)
value = Game_Party::GetRunCount();
break;
case 8:
// TODO: MIDI play position
break;
case 9:
value = Game_Party::ReadTimer(Game_Party::Timer2);
break;
}
break;
default:
;
}
switch (com.parameters[0]) {
case 0:
case 1:
// Single and Var range
for (i = com.parameters[1]; i <= com.parameters[2]; i++) {
switch (com.parameters[3]) {
case 0:
// Assignement
Game_Variables[i] = value;
break;
case 1:
// Addition
Game_Variables[i] += value;
break;
case 2:
// Subtraction
Game_Variables[i] -= value;
break;
case 3:
// Multiplication
Game_Variables[i] *= value;
break;
case 4:
// Division
if (value != 0) {
Game_Variables[i] /= value;
}
break;
case 5:
// Module
if (value != 0) {
Game_Variables[i] %= value;
}
}
if (Game_Variables[i] > MaxSize) {
Game_Variables[i] = MaxSize;
}
if (Game_Variables[i] < MinSize) {
Game_Variables[i] = MinSize;
}
}
break;
case 2:
switch (com.parameters[3]) {
case 0:
// Assignement
Game_Variables[com.parameters[1]] = value;
break;
case 1:
// Addition
Game_Variables[com.parameters[1]] += value;
break;
case 2:
// Subtraction
Game_Variables[com.parameters[1]] -= value;
break;
case 3:
// Multiplication
Game_Variables[com.parameters[1]] *= value;
break;
case 4:
// Division
if (value != 0) {
Game_Variables[com.parameters[1]] /= value;
}
break;
case 5:
// Module
if (value != 0) {
Game_Variables[com.parameters[1]] %= value;
}
}
if (Game_Variables[com.parameters[1]] > MaxSize) {
Game_Variables[com.parameters[1]] = MaxSize;
}
if (Game_Variables[com.parameters[1]] < MinSize) {
Game_Variables[com.parameters[1]] = MinSize;
}
}
Game_Map::SetNeedRefresh(true);
return true;
}
