void Game_Character::SetGraphic(const std::string& name, int index) {
if (GetSpriteName() != name || GetSpriteIndex() != index) {
SetSpriteName(name);
SetSpriteIndex(index);
tile_id = 0;
pattern = RPG::EventPage::Frame_middle;
}
}
Uint16 Actor::SetSpriteIndex(Uint16 index) {
//zero the frame
image.SetClipX(0);
animator.SetFrame(0);
//set the index
image.SetClipY(index * image.GetClipH());
return GetSpriteIndex();
}
bool Heroes::Move(bool fast)
{
if(Modes(ACTION)) ResetModes(ACTION);
// move hero
if(path.isValid() &&
(isEnableMove() || (GetSpriteIndex() < 45 && GetSpriteIndex() % 9) || GetSpriteIndex() >= 45))
{
// fast move for hide AI
if(fast)
{
direction = path.GetFrontDirection();
MoveStep(true);
return true;
}
else
{
// if need change through the circle
if(GetDirection() != path.GetFrontDirection())
{
AngleStep(path.GetFrontDirection());
}
else
// move
if(MoveStep())
{
if(isFreeman()) return false;
return true;
}
}
}
else
{
SetMove(false);
}
return false;
}
void IdleActionRenderer::Init( const Actor& actor )
{
int32_t actorId = actor.GetId();
auto renderableC( actor.Get<IRenderableComponent>() );
actorId = GetSpriteId( renderableC->GetSpriteIndex(), actorId );
SpriteCollection const& Sprites = mRenderableRepo( actorId );
static int32_t aid = AutoId( "body_idle" );
Sprite const& Spr = Sprites( aid );
if( Spr.IsValid() )
{
mSpr = &Spr;
mSecsToEnd = Spr.GetSecsToEnd();
}
}
/**
** Define the sprite to show variables.
**
** @param l Lua_state
*/
static int CclDefineSprites(lua_State *l)
{
const int args = lua_gettop(l);
for (int i = 0; i < args; ++i) {
Decoration deco;
lua_pushnil(l);
const char *name = NULL;// name of the current sprite.
while (lua_next(l, i + 1)) {
const char *key = LuaToString(l, -2); // key name
if (!strcmp(key, "Name")) {
name = LuaToString(l, -1);
} else if (!strcmp(key, "File")) {
deco.File = LuaToString(l, -1);
} else if (!strcmp(key, "Offset")) {
CclGetPos(l, &deco.HotPos.x, &deco.HotPos.y);
} else if (!strcmp(key, "Size")) {
CclGetPos(l, &deco.Width, &deco.Height);
} else { // Error.
LuaError(l, "incorrect field '%s' for the DefineSprite." _C_ key);
}
lua_pop(l, 1); // pop the value;
}
if (name == NULL) {
LuaError(l, "CclDefineSprites requires the Name flag for sprite.");
}
int index = GetSpriteIndex(name); // Index of the Sprite.
if (index == -1) { // new sprite.
index = DecoSprite.SpriteArray.size();
DecoSprite.Name.push_back(name);
DecoSprite.SpriteArray.push_back(deco);
} else {
DecoSprite.SpriteArray[index].File.clear();
DecoSprite.SpriteArray[index] = deco;
}
// Now verify validity.
if (DecoSprite.SpriteArray[index].File.empty()) {
LuaError(l, "CclDefineSprites requires the File flag for sprite.");
}
// FIXME check if file is valid with good size ?
}
return 0;
}
/**
** Define the sprite to show variables.
**
** @param l Lua_state
*/
static int CclDefineSprites(lua_State *l)
{
const char *name; // name of the current sprite.
int args; // number of arguments.
int i; // iterator on argument.
const char *key; // Current key of the lua table.
int index; // Index of the Sprite.
args = lua_gettop(l);
for (i = 0; i < args; ++i) {
Decoration deco;
lua_pushnil(l);
name = 0;
while (lua_next(l, i + 1)) {
key = LuaToString(l, -2); // key name
if (!strcmp(key, "Name")) {
name = LuaToString(l, -1);
} else if (!strcmp(key, "File")) {
deco.File = LuaToString(l, -1);
} else if (!strcmp(key, "Offset")) {
if (!lua_istable(l, -1) || lua_objlen(l, -1) != 2) {
LuaError(l, "incorrect argument");
}
lua_rawgeti(l, -1, 1); // offsetX
lua_rawgeti(l, -2, 2); // offsetY
deco.HotX = LuaToNumber(l, -2);
deco.HotY = LuaToNumber(l, -1);
lua_pop(l, 2); // Pop offsetX and Y
} else if (!strcmp(key, "Size")) {
if (!lua_istable(l, -1) || lua_objlen(l, -1) != 2) {
LuaError(l, "incorrect argument");
}
lua_rawgeti(l, -1, 1); // Width
lua_rawgeti(l, -2, 2); // Height
deco.Width = LuaToNumber(l, -2);
deco.Height = LuaToNumber(l, -1);
lua_pop(l, 2); // Pop Width and Height
} else { // Error.
LuaError(l, "incorrect field '%s' for the DefineSprite." _C_ key);
}
lua_pop(l, 1); // pop the value;
}
if (name == NULL) {
LuaError(l, "CclDefineSprites requires the Name flag for sprite.");
}
index = GetSpriteIndex(name);
if (index == -1) { // new sprite.
index = DecoSprite.SpriteArray.size();
DecoSprite.Name.push_back(name);
DecoSprite.SpriteArray.push_back(deco);
} else {
DecoSprite.SpriteArray[index].File.clear();
DecoSprite.SpriteArray[index] = deco;
}
// Now verify validity.
if (DecoSprite.SpriteArray[index].File.empty()) {
LuaError(l, "CclDefineSprites requires the File flag for sprite.");
}
// FIXME check if file is valid with good size ?
}
return 0;
}
void Heroes::Redraw(Surface & dst, s32 dx, s32 dy, bool with_shadow) const
{
const Point & mp = GetCenter();
const Interface::GameArea & gamearea = Interface::Basic::Get().GetGameArea();
if(!(gamearea.GetRectMaps() & mp)) return;
bool reflect = ReflectSprite(direction);
const Sprite & sprite1 = SpriteHero(*this, sprite_index, reflect, false);
const Sprite & sprite2 = SpriteFlag(*this, sprite_index, reflect, false);
const Sprite & sprite3 = SpriteShad(*this, sprite_index);
const Sprite & sprite4 = SpriteFroth(*this, sprite_index, reflect);
Point dst_pt1(dx + (reflect ? TILEWIDTH - sprite1.x() - sprite1.w() : sprite1.x()), dy + sprite1.y() + TILEWIDTH);
Point dst_pt2(dx + (reflect ? TILEWIDTH - sprite2.x() - sprite2.w() : sprite2.x()), dy + sprite2.y() + TILEWIDTH);
Point dst_pt3(dx + sprite3.x(), dy + sprite3.y() + TILEWIDTH);
Point dst_pt4(dx + (reflect ? TILEWIDTH - sprite4.x() - sprite4.w() : sprite4.x()), dy + sprite4.y() + TILEWIDTH);
// apply offset
if(sprite_index < 45)
{
s32 ox = 0;
s32 oy = 0;
int frame = (sprite_index % 9);
switch(direction)
{
case Direction::TOP: oy = -4 * frame; break;
case Direction::TOP_RIGHT: ox = 4 * frame; oy = -4 * frame; break;
case Direction::TOP_LEFT: ox = -4 * frame; oy = -4 * frame; break;
case Direction::BOTTOM_RIGHT: ox = 4 * frame; oy = 4 * frame; break;
case Direction::BOTTOM: oy = 4 * frame; break;
case Direction::BOTTOM_LEFT: ox = -4 * frame; oy = 4 * frame; break;
case Direction::RIGHT: ox = 4 * frame; break;
case Direction::LEFT: ox = -4 * frame; break;
default: break;
}
dst_pt1.x += ox;
dst_pt1.y += oy;
dst_pt2.x += ox;
dst_pt2.y += oy;
dst_pt3.x += ox;
dst_pt3.y += oy;
dst_pt4.x += ox;
dst_pt4.y += oy;
}
if(isShipMaster())
{
dst_pt1.y -= 15;
dst_pt2.y -= 15;
dst_pt3.y -= 15;
dst_pt4.y -= 15;
sprite4.Blit(gamearea.RectFixed(dst_pt4, sprite4.w(), sprite4.h()), dst_pt4, dst);
}
// redraw sprites for shadow
if(with_shadow)
sprite3.Blit(gamearea.RectFixed(dst_pt3, sprite3.w(), sprite3.h()), dst_pt3, dst);
// redraw sprites hero and flag
sprite1.Blit(gamearea.RectFixed(dst_pt1, sprite1.w(), sprite1.h()), dst_pt1, dst);
sprite2.Blit(gamearea.RectFixed(dst_pt2, sprite2.w(), sprite2.h()), dst_pt2, dst);
// redraw dependences tiles
Maps::Tiles & tile = world.GetTiles(center.x, center.y);
const s32 centerIndex = GetIndex();
bool skip_ground = MP2::isActionObject(tile.GetObject(false), isShipMaster());
tile.RedrawTop(dst);
if(Maps::isValidDirection(centerIndex, Direction::TOP))
world.GetTiles(Maps::GetDirectionIndex(centerIndex, Direction::TOP)).RedrawTop4Hero(dst, skip_ground);
if(Maps::isValidDirection(centerIndex, Direction::BOTTOM))
{
Maps::Tiles & tile_bottom = world.GetTiles(Maps::GetDirectionIndex(centerIndex, Direction::BOTTOM));
tile_bottom.RedrawBottom4Hero(dst);
tile_bottom.RedrawTop(dst);
}
if(45 > GetSpriteIndex())
{
if(Direction::BOTTOM != direction &&
Direction::TOP != direction &&
Maps::isValidDirection(centerIndex, direction))
{
if(Maps::isValidDirection(Maps::GetDirectionIndex(centerIndex, direction), Direction::BOTTOM))
{
Maps::Tiles & tile_dir_bottom = world.GetTiles(Maps::GetDirectionIndex(Maps::GetDirectionIndex(centerIndex, direction), Direction::BOTTOM));
tile_dir_bottom.RedrawBottom4Hero(dst);
tile_dir_bottom.RedrawTop(dst);
}
if(Maps::isValidDirection(Maps::GetDirectionIndex(centerIndex, direction), Direction::TOP))
{
Maps::Tiles & tile_dir_top = world.GetTiles(Maps::GetDirectionIndex(Maps::GetDirectionIndex(centerIndex, direction), Direction::TOP));
tile_dir_top.RedrawTop4Hero(dst, skip_ground);
}
}
if(Maps::isValidDirection(centerIndex, Direction::BOTTOM))
{
Maps::Tiles & tile_bottom = world.GetTiles(Maps::GetDirectionIndex(centerIndex, Direction::BOTTOM));
if(tile_bottom.GetObject() == MP2::OBJ_BOAT)
tile_bottom.RedrawObjects(dst);
}
}
if(Maps::isValidDirection(centerIndex, direction))
{
if(Direction::TOP == direction)
world.GetTiles(Maps::GetDirectionIndex(centerIndex, direction)).RedrawTop4Hero(dst, skip_ground);
else
world.GetTiles(Maps::GetDirectionIndex(centerIndex, direction)).RedrawTop(dst);
}
}
void CHud :: VidInit( void )
{
m_scrinfo.iSize = sizeof(m_scrinfo);
GetScreenInfo(&m_scrinfo);
// ----------
// Load Sprites
// ---------
// m_hsprFont = LoadSprite("sprites/%d_font.spr");
m_hsprLogo = 0;
m_hsprCursor = 0;
if (ScreenWidth < 640)
m_iRes = 320;
else
m_iRes = 640;
// Only load this once
if ( !m_pSpriteList )
{
// we need to load the hud.txt, and all sprites within
m_pSpriteList = SPR_GetList("sprites/hud.txt", &m_iSpriteCountAllRes);
if (m_pSpriteList)
{
// count the number of sprites of the appropriate res
m_iSpriteCount = 0;
client_sprite_t *p = m_pSpriteList;
int j;
for ( j = 0; j < m_iSpriteCountAllRes; j++ )
{
if ( p->iRes == m_iRes )
m_iSpriteCount++;
p++;
}
// allocated memory for sprite handle arrays
m_rghSprites = new HSPRITE[m_iSpriteCount];
m_rgrcRects = new wrect_t[m_iSpriteCount];
m_rgszSpriteNames = new char[m_iSpriteCount * MAX_SPRITE_NAME_LENGTH];
p = m_pSpriteList;
int index = 0;
for ( j = 0; j < m_iSpriteCountAllRes; j++ )
{
if ( p->iRes == m_iRes )
{
char sz[256];
sprintf(sz, "sprites/%s.spr", p->szSprite);
m_rghSprites[index] = SPR_Load(sz);
m_rgrcRects[index] = p->rc;
strncpy( &m_rgszSpriteNames[index * MAX_SPRITE_NAME_LENGTH], p->szName, MAX_SPRITE_NAME_LENGTH );
index++;
}
p++;
}
}
}
else
{
// we have already have loaded the sprite reference from hud.txt, but
// we need to make sure all the sprites have been loaded (we've gone through a transition, or loaded a save game)
client_sprite_t *p = m_pSpriteList;
int index = 0;
for ( int j = 0; j < m_iSpriteCountAllRes; j++ )
{
if ( p->iRes == m_iRes )
{
char sz[256];
sprintf( sz, "sprites/%s.spr", p->szSprite );
m_rghSprites[index] = SPR_Load(sz);
index++;
}
p++;
}
}
// assumption: number_1, number_2, etc, are all listed and loaded sequentially
m_HUD_number_0 = GetSpriteIndex( "number_0" );
m_iFontHeight = m_rgrcRects[m_HUD_number_0].bottom - m_rgrcRects[m_HUD_number_0].top;
m_Ammo.VidInit();
m_Health.VidInit();
m_Spectator.VidInit();
m_Geiger.VidInit();
m_Train.VidInit();
m_Battery.VidInit();
m_Flash.VidInit();
m_Message.VidInit();
m_StatusBar.VidInit();
m_DeathNotice.VidInit();
m_SayText.VidInit();
m_Menu.VidInit();
m_AmmoSecondary.VidInit();
m_TextMessage.VidInit();
m_StatusIcons.VidInit();
m_Countdown.VidInit();
m_Crosshairs.VidInit();
m_CTF.VidInit();
m_Debug.VidInit();
m_Location.VidInit();
m_NextMap.VidInit();
m_PlayerId.VidInit();
m_Scores.VidInit();
m_Settings.VidInit();
m_Speedometer.VidInit();
m_SuddenDeath.VidInit();
m_Timeout.VidInit();
m_Timer.VidInit();
m_Vote.VidInit();
m_Watermark.VidInit();
GetClientVoiceMgr()->VidInit();
}
//==========================================================================
//***
// ParseStates
// parses a state block
//
//==========================================================================
void ParseStates(FScanner &sc, FActorInfo * actor, AActor * defaults, Baggage &bag)
{
FString statestring;
FState state;
char lastsprite[5]="";
sc.MustGetStringName ("{");
sc.SetEscape(false); // disable escape sequences in the state parser
while (!sc.CheckString ("}") && !sc.End)
{
memset(&state,0,sizeof(state));
statestring = ParseStateString(sc);
if (!statestring.CompareNoCase("GOTO"))
{
do_goto:
statestring = ParseStateString(sc);
if (sc.CheckString ("+"))
{
sc.MustGetNumber ();
statestring += '+';
statestring += sc.String;
}
if (!bag.statedef.SetGotoLabel(statestring))
{
sc.ScriptError("GOTO before first state");
}
}
else if (!statestring.CompareNoCase("STOP"))
{
do_stop:
if (!bag.statedef.SetStop())
{
sc.ScriptError("STOP before first state");
continue;
}
}
else if (!statestring.CompareNoCase("WAIT") || !statestring.CompareNoCase("FAIL"))
{
if (!bag.statedef.SetWait())
{
sc.ScriptError("%s before first state", sc.String);
continue;
}
}
else if (!statestring.CompareNoCase("LOOP"))
{
if (!bag.statedef.SetLoop())
{
sc.ScriptError("LOOP before first state");
continue;
}
}
else
{
sc.MustGetString();
if (sc.Compare (":"))
{
do
{
bag.statedef.AddStateLabel(statestring);
statestring = ParseStateString(sc);
if (!statestring.CompareNoCase("GOTO"))
{
goto do_goto;
}
else if (!statestring.CompareNoCase("STOP"))
{
goto do_stop;
}
sc.MustGetString ();
} while (sc.Compare (":"));
// continue;
}
sc.UnGet ();
if (statestring.Len() != 4)
{
sc.ScriptError ("Sprite names must be exactly 4 characters\n");
}
state.sprite = GetSpriteIndex(statestring);
state.Misc1 = state.Misc2 = 0;
state.ParameterIndex = 0;
sc.MustGetString();
statestring = sc.String;
if (sc.CheckString("RANDOM"))
{
int min, max;
sc.MustGetStringName("(");
sc.MustGetNumber();
min = clamp<int>(sc.Number, -1, SHRT_MAX);
sc.MustGetStringName(",");
sc.MustGetNumber();
max = clamp<int>(sc.Number, -1, SHRT_MAX);
sc.MustGetStringName(")");
if (min > max)
{
swapvalues(min, max);
}
state.Tics = min;
state.TicRange = max - min;
}
else
{
sc.MustGetNumber();
state.Tics = clamp<int>(sc.Number, -1, SHRT_MAX);
state.TicRange = 0;
}
while (sc.GetString() && !sc.Crossed)
{
if (sc.Compare("BRIGHT"))
{
state.Fullbright = true;
continue;
}
if (sc.Compare("FAST"))
{
state.Fast = true;
continue;
}
if (sc.Compare("SLOW"))
{
state.Slow = true;
continue;
}
if (sc.Compare("NODELAY"))
{
if (bag.statedef.GetStateLabelIndex(NAME_Spawn) == bag.statedef.GetStateCount())
{
state.NoDelay = true;
}
else
{
sc.ScriptMessage("NODELAY may only be used immediately after Spawn:");
}
continue;
}
if (sc.Compare("OFFSET"))
{
// specify a weapon offset
sc.MustGetStringName("(");
sc.MustGetNumber();
state.Misc1 = sc.Number;
sc.MustGetStringName (",");
sc.MustGetNumber();
state.Misc2 = sc.Number;
sc.MustGetStringName(")");
continue;
}
if (sc.Compare("LIGHT"))
{
sc.MustGetStringName("(");
do
{
sc.MustGetString();
#ifdef DYNLIGHT
AddStateLight(&state, sc.String);
#endif
}
while (sc.CheckString(","));
sc.MustGetStringName(")");
continue;
}
if (sc.Compare("CANRAISE"))
{
state.CanRaise = true;
continue;
}
// Make the action name lowercase
strlwr (sc.String);
if (DoActionSpecials(sc, state, bag))
{
goto endofstate;
}
FName funcname = FName(sc.String, true);
PSymbol *sym = bag.Info->Class->Symbols.FindSymbol (funcname, true);
if (sym != NULL && sym->SymbolType == SYM_ActionFunction)
{
PSymbolActionFunction *afd = static_cast<PSymbolActionFunction *>(sym);
state.SetAction(afd, false);
if (!afd->Arguments.IsEmpty())
{
const char *params = afd->Arguments.GetChars();
int numparams = (int)afd->Arguments.Len();
int v;
if (!islower(*params))
{
sc.MustGetStringName("(");
}
else
{
if (!sc.CheckString("("))
{
state.ParameterIndex = afd->defaultparameterindex+1;
goto endofstate;
}
}
int paramindex = PrepareStateParameters(&state, numparams, bag.Info->Class);
int paramstart = paramindex;
bool varargs = params[numparams - 1] == '+';
int varargcount = 0;
if (varargs)
{
paramindex++;
}
else if (afd->defaultparameterindex > -1)
{
StateParams.Copy(paramindex, afd->defaultparameterindex, int(afd->Arguments.Len()));
}
while (*params)
{
FxExpression *x;
if ((*params == 'l' || *params == 'L') && sc.CheckNumber())
{
// Special case: State label as an offset
if (sc.Number > 0 && statestring.Len() > 1)
{
sc.ScriptError("You cannot use state jumps commands with a jump offset on multistate definitions\n");
}
v=sc.Number;
if (v<0)
{
sc.ScriptError("Negative jump offsets are not allowed");
}
if (v > 0)
{
x = new FxStateByIndex(bag.statedef.GetStateCount() + v, sc);
}
else
{
x = new FxConstant((FState*)NULL, sc);
}
}
else
{
// Use the generic parameter parser for everything else
x = ParseParameter(sc, bag.Info->Class, *params, false);
}
StateParams.Set(paramindex++, x);
params++;
if (varargs)
{
varargcount++;
}
if (*params)
{
if (*params == '+')
{
if (sc.CheckString(")"))
{
StateParams.Set(paramstart, new FxConstant(varargcount, sc));
goto endofstate;
}
params--;
StateParams.Reserve(1, bag.Info->Class);
}
else if ((islower(*params) || *params=='!') && sc.CheckString(")"))
{
goto endofstate;
}
sc.MustGetStringName (",");
}
}
sc.MustGetStringName(")");
}
else
{
sc.MustGetString();
if (sc.Compare("("))
{
sc.ScriptError("You cannot pass parameters to '%s'\n", funcname.GetChars());
}
sc.UnGet();
}
goto endofstate;
}
sc.ScriptError("Invalid state parameter %s\n", sc.String);
}
sc.UnGet();
endofstate:
if (!bag.statedef.AddStates(&state, statestring))
{
sc.ScriptError ("Invalid frame character string '%s'", statestring.GetChars());
}
}
}
sc.SetEscape(true); // re-enable escape sequences
}
void CHud :: VidInit( void )
{
m_scrinfo.iSize = sizeof(m_scrinfo);
GetScreenInfo(&m_scrinfo);
// ----------
// Load Sprites
// ---------
// m_hsprFont = LoadSprite("sprites/%d_font.spr");
m_hsprLogo = 0;
m_hsprCursor = 0;
if (ScreenWidth < 640)
m_iRes = 320;
else
m_iRes = 640;
// Only load this once
if ( !m_pSpriteList )
{
// we need to load the hud.txt, and all sprites within
m_pSpriteList = SPR_GetList("sprites/hud.txt", &m_iSpriteCountAllRes);
if (m_pSpriteList)
{
// count the number of sprites of the appropriate res
m_iSpriteCount = 0;
client_sprite_t *p = m_pSpriteList;
for ( int j = 0; j < m_iSpriteCountAllRes; j++ )
{
if ( p->iRes == m_iRes )
m_iSpriteCount++;
p++;
}
// allocated memory for sprite handle arrays
m_rghSprites = new HSPRITE[m_iSpriteCount];
m_rgrcRects = new wrect_t[m_iSpriteCount];
m_rgszSpriteNames = new char[m_iSpriteCount * MAX_SPRITE_NAME_LENGTH];
p = m_pSpriteList;
int index = 0;
for ( j = 0; j < m_iSpriteCountAllRes; j++ )
{
if ( p->iRes == m_iRes )
{
char sz[256];
sprintf(sz, "sprites/%s.spr", p->szSprite);
m_rghSprites[index] = SPR_Load(sz);
m_rgrcRects[index] = p->rc;
strncpy( &m_rgszSpriteNames[index * MAX_SPRITE_NAME_LENGTH], p->szName, MAX_SPRITE_NAME_LENGTH );
index++;
}
p++;
}
}
}
else
{
// we have already have loaded the sprite reference from hud.txt, but
// we need to make sure all the sprites have been loaded (we've gone through a transition, or loaded a save game)
client_sprite_t *p = m_pSpriteList;
int index = 0;
for ( int j = 0; j < m_iSpriteCountAllRes; j++ )
{
if ( p->iRes == m_iRes )
{
char sz[256];
sprintf( sz, "sprites/%s.spr", p->szSprite );
m_rghSprites[index] = SPR_Load(sz);
index++;
}
p++;
}
}
// assumption: number_1, number_2, etc, are all listed and loaded sequentially
m_HUD_number_0 = GetSpriteIndex( "number_0" ); // ORiginal Halflife Number Index Keep For Compatibility
m_iFontHeight = m_rgrcRects[m_HUD_number_0].bottom - m_rgrcRects[m_HUD_number_0].top;
//Ben
m_Health.VidInit();
m_PredefinedMessage.VidInit();
m_Points.VidInit();
m_Clock.VidInit();//Baer
m_ColourMessage.VidInit();
m_Crosshair.VidInit();//BP
// m_CommanderMenu.VidInit();//BP
// m_ArmLegShot.VidInit();//Myristate
m_Ammo.VidInit();
m_Spectator.VidInit();
m_Geiger.VidInit();
m_Train.VidInit();
m_Message.VidInit();
m_StatusBar.VidInit();
m_DeathNotice.VidInit();
m_SayText.VidInit();
m_Menu.VidInit();
m_AmmoSecondary.VidInit();
m_TextMessage.VidInit();
m_StatusIcons.VidInit();
GetClientVoiceMgr()->VidInit();
if(pParticleManager)
delete pParticleManager;
pParticleManager = new CParticleSystemManager;
char szVersion[16];
_snprintf(szVersion, sizeof(szVersion) - 1, "%s\0", const_cast<char*>(sBgVersion));
gEngfuncs.Con_Printf("The Battle Grounds %s, Copyright (C) 2001 - 2004, The Battle Grounds Team and Contributors\n", szVersion);
gEngfuncs.Con_Printf("The Battle Grounds %s comes with ABSOLUTELY NO WARRANTY\n", szVersion);
gEngfuncs.Con_Printf("This is free software, and you are welcome to redistribute it\n");
gEngfuncs.Con_Printf("This software is licensed under the GNU LGPL and comes with a copy of its source\n");
}
void CHud :: VidInit( void )
{
m_scrinfo.iSize = sizeof( m_scrinfo );
GetScreenInfo( &m_scrinfo );
// ----------
// Load Sprites
// ---------
m_hHudError = 0;
if( ScreenWidth < 640 )
m_iRes = 320;
else m_iRes = 640;
// Only load this once
if( !m_pSpriteList )
{
// we need to load the hud.txt, and all sprites within
m_pSpriteList = SPR_GetList( "sprites/hud.txt", &m_iSpriteCountAllRes );
if( m_pSpriteList )
{
// count the number of sprites of the appropriate res
client_sprite_t *p = m_pSpriteList;
m_iSpriteCount = 0;
for( int j = 0; j < m_iSpriteCountAllRes; j++ )
{
if( p->iRes == m_iRes )
m_iSpriteCount++;
p++;
}
// allocated memory for sprite handle arrays
m_rghSprites = new HSPRITE[m_iSpriteCount];
m_rgrcRects = new wrect_t[m_iSpriteCount];
m_rgszSpriteNames = new char[m_iSpriteCount * MAX_SPRITE_NAME_LENGTH];
p = m_pSpriteList;
int index = 0;
for( j = 0; j < m_iSpriteCountAllRes; j++ )
{
if( p->iRes == m_iRes )
{
char sz[256];
Q_snprintf( sz, sizeof( sz ), "sprites/%s.spr", p->szSprite );
m_rghSprites[index] = SPR_Load( sz );
m_rgrcRects[index] = p->rc;
Q_strncpy( &m_rgszSpriteNames[index * MAX_SPRITE_NAME_LENGTH], p->szName, MAX_SPRITE_NAME_LENGTH );
index++;
}
p++;
}
}
else
{
ALERT( at_warning, "hud.txt couldn't load\n");
m_pCvarDraw->value = 0;
return;
}
}
else
{
// we have already have loaded the sprite reference from hud.txt, but
// we need to make sure all the sprites have been loaded (we've gone through a transition, or loaded a save game)
client_sprite_t *p = m_pSpriteList;
for( int j = 0, index = 0; j < m_iSpriteCountAllRes; j++ )
{
if( p->iRes == m_iRes )
{
char sz[256];
Q_snprintf( sz, sizeof( sz ), "sprites/%s.spr", p->szSprite );
m_rghSprites[index] = SPR_Load( sz );
index++;
}
p++;
}
}
// assumption: number_1, number_2, etc, are all listed and loaded sequentially
m_HUD_number_0 = GetSpriteIndex( "number_0" );
m_iFontHeight = m_rgrcRects[m_HUD_number_0].bottom - m_rgrcRects[m_HUD_number_0].top;
// loading error sprite
m_HUD_error = GetSpriteIndex( "error" );
m_hHudError = GetSprite( m_HUD_error );
m_Ammo.VidInit();
m_Health.VidInit();
m_Geiger.VidInit();
m_Train.VidInit();
m_Battery.VidInit();
m_Flash.VidInit();
m_MOTD.VidInit();
m_Message.VidInit();
m_Scoreboard.VidInit();
m_StatusBar.VidInit();
m_DeathNotice.VidInit();
m_SayText.VidInit();
m_Menu.VidInit();
m_AmmoSecondary.VidInit();
m_TextMessage.VidInit();
m_StatusIcons.VidInit();
}
void CHud :: VidInit( void )
{
#ifdef ENGINE_DEBUG
CONPRINT("## CHud::VidInit (hi from me)\n");
#endif
m_scrinfo.iSize = sizeof(m_scrinfo);
GetScreenInfo(&m_scrinfo);
// ----------
// Load Sprites
// ---------
// m_hsprFont = LoadSprite("sprites/%d_font.spr");
m_hsprLogo = 0;
m_hsprCursor = 0;
numMirrors = 0;
ResetRain();
//LRC - clear all shiny surfaces
if (m_pShinySurface)
{
delete m_pShinySurface;
m_pShinySurface = NULL;
}
if (ScreenWidth < 640)
m_iRes = 320;
else
m_iRes = 640;
// Only load this once
if ( !m_pSpriteList )
{
// we need to load the hud.txt, and all sprites within
m_pSpriteList = SPR_GetList("sprites/hud.txt", &m_iSpriteCountAllRes);
if (m_pSpriteList)
{
// count the number of sprites of the appropriate res
m_iSpriteCount = 0;
client_sprite_t *p = m_pSpriteList;
int j;
for ( j = 0; j < m_iSpriteCountAllRes; j++ )
{
if ( p->iRes == m_iRes )
m_iSpriteCount++;
p++;
}
// allocated memory for sprite handle arrays
m_rghSprites = new HL_HSPRITE[m_iSpriteCount];
m_rgrcRects = new wrect_t[m_iSpriteCount];
m_rgszSpriteNames = new char[m_iSpriteCount * MAX_SPRITE_NAME_LENGTH];
p = m_pSpriteList;
int index = 0;
for ( j = 0; j < m_iSpriteCountAllRes; j++ )
{
if ( p->iRes == m_iRes )
{
char sz[256];
sprintf(sz, "sprites/%s.spr", p->szSprite);
m_rghSprites[index] = SPR_Load(sz);
m_rgrcRects[index] = p->rc;
strncpy( &m_rgszSpriteNames[index * MAX_SPRITE_NAME_LENGTH], p->szName, MAX_SPRITE_NAME_LENGTH );
index++;
}
p++;
}
}
}
else
{
// we have already have loaded the sprite reference from hud.txt, but
// we need to make sure all the sprites have been loaded (we've gone through a transition, or loaded a save game)
client_sprite_t *p = m_pSpriteList;
int index = 0;
for ( int j = 0; j < m_iSpriteCountAllRes; j++ )
{
if ( p->iRes == m_iRes )
{
char sz[256];
sprintf( sz, "sprites/%s.spr", p->szSprite );
m_rghSprites[index] = SPR_Load(sz);
index++;
}
p++;
}
}
// assumption: number_1, number_2, etc, are all listed and loaded sequentially
m_HUD_number_0 = GetSpriteIndex( "number_0" );
m_iFontHeight = m_rgrcRects[m_HUD_number_0].bottom - m_rgrcRects[m_HUD_number_0].top;
m_Ammo.VidInit();
m_Health.VidInit();
m_Spectator.VidInit();
m_Geiger.VidInit();
m_Train.VidInit();
m_Battery.VidInit();
m_Flash.VidInit();
m_Message.VidInit();
m_StatusBar.VidInit();
m_DeathNotice.VidInit();
m_SayText.VidInit();
m_Menu.VidInit();
m_AmmoSecondary.VidInit();
m_TextMessage.VidInit();
m_StatusIcons.VidInit();
GetClientVoiceMgr()->VidInit();
m_Particle.VidInit(); // (LRC) -- 30/08/02 November235: Particles to Order
m_Lensflare.VidInit();
}
void CHud :: VidInit( void )
{
m_scrinfo.iSize = sizeof(m_scrinfo);
GetScreenInfo(&m_scrinfo);
// ----------
// Load Sprites
// ---------
// m_hsprFont = LoadSprite("sprites/%d_font.spr");
m_hsprLogo = 0;
m_hsprCursor = 0;
ResetRain();
//LRC - clear all shiny surfaces
if (m_pShinySurface)
{
delete m_pShinySurface;
m_pShinySurface = NULL;
}
if (ScreenWidth < 640)
m_iRes = 320;
else
m_iRes = 640;
// Only load this once
if ( !m_pSpriteList )
{
// we need to load the hud.txt, and all sprites within
m_pSpriteList = SPR_GetList("scripts/hud.txt", &m_iSpriteCountAllRes);
// m_pSpriteList = SPR_GetList("sprites/hud.txt", &m_iSpriteCountAllRes);
if (m_pSpriteList)
{
// count the number of sprites of the appropriate res
m_iSpriteCount = 0;
client_sprite_t *p = m_pSpriteList;
for ( int j = 0; j < m_iSpriteCountAllRes; j++ )
{
if ( p->iRes == m_iRes )
m_iSpriteCount++;
p++;
}
// allocated memory for sprite handle arrays
m_rghSprites = new HSPRITE[m_iSpriteCount];
m_rgrcRects = new wrect_t[m_iSpriteCount];
m_rgszSpriteNames = new char[m_iSpriteCount * MAX_SPRITE_NAME_LENGTH];
p = m_pSpriteList;
int index = 0;
for ( j = 0; j < m_iSpriteCountAllRes; j++ )
{
if ( p->iRes == m_iRes )
{
char sz[256];
sprintf(sz, "sprites/%s.spr", p->szSprite);
m_rghSprites[index] = SPR_Load(sz);
m_rgrcRects[index] = p->rc;
strncpy( &m_rgszSpriteNames[index * MAX_SPRITE_NAME_LENGTH], p->szName, MAX_SPRITE_NAME_LENGTH );
index++;
}
p++;
}
}
}
else
{
// we have already have loaded the sprite reference from hud.txt, but
// we need to make sure all the sprites have been loaded (we've gone through a transition, or loaded a save game)
client_sprite_t *p = m_pSpriteList;
int index = 0;
for ( int j = 0; j < m_iSpriteCountAllRes; j++ )
{
if ( p->iRes == m_iRes )
{
char sz[256];
sprintf( sz, "sprites/%s.spr", p->szSprite );
m_rghSprites[index] = SPR_Load(sz);
index++;
}
p++;
}
}
// assumption: number_1, number_2, etc, are all listed and loaded sequentially
m_HUD_number_0 = GetSpriteIndex( "number_0" );
m_iFontHeight = m_rgrcRects[m_HUD_number_0].bottom - m_rgrcRects[m_HUD_number_0].top;
m_Ammo.VidInit();
m_Health.VidInit();
m_Spectator.VidInit();
m_Geiger.VidInit();
m_Train.VidInit();
m_Battery.VidInit();
m_Flash.VidInit();
m_Message.VidInit();
m_StatusBar.VidInit();
m_DeathNotice.VidInit();
m_SayText.VidInit();
m_Menu.VidInit();
m_AmmoSecondary.VidInit();
m_TextMessage.VidInit();
m_StatusIcons.VidInit();
GetClientVoiceMgr()->VidInit();
// advanced NVG
m_NVG.VidInit();
// advanced NVG
m_Cine.VidInit();
m_Ricardo.VidInit();
m_LuzBar.VidInit();
m_FlashBar.VidInit();
m_HudRadar.VidInit();
m_Money.VidInit();
m_Tbutton.VidInit();
if(pParticleManager)
{
delete pParticleManager;
}
//sys add
pParticleManager = new CParticleSystemManager;
pParticleManager->PrecacheTextures();
if ( CVAR_GET_FLOAT( "cl_playmusic" ) == 1 )
gMP3.PlayMP3( "", -1 );
// gEngfuncs.Con_Printf("Arrange Mode %s, Copyright (C) 2004 - 2007, Arrange Mode Team and Contributors\n");
// gEngfuncs.Con_Printf("TArrange Mode %s comes with ABSOLUTELY NO WARRANTY\n");
// gEngfuncs.Con_Printf("This is free software, and you are welcome to redistribute it\n");
// gEngfuncs.Con_Printf("This software is licensed under the GNU LGPL and comes with a copy of its source\n");
}
DEFINE_ACTION_FUNCTION(AActor, GetSpriteIndex)
{
PARAM_PROLOGUE;
PARAM_NAME(sprt);
ACTION_RETURN_INT(GetSpriteIndex(sprt.GetChars(), false));
}
