//=========================================================
// Spawn
//=========================================================
void CGargantua :: Spawn()
{
Precache( );
if (pev->model)
SET_MODEL(ENT(pev), STRING(pev->model)); //LRC
else
SET_MODEL(ENT(pev), "models/garg.mdl");
UTIL_SetSize( pev, Vector( -32, -32, 0 ), Vector( 32, 32, 64 ) );
pev->solid = SOLID_SLIDEBOX;
pev->movetype = MOVETYPE_STEP;
m_bloodColor = BLOOD_COLOR_GREEN;
if (!pev->health) pev->health = gSkillData.gargantuaHealth;
//pev->view_ofs = Vector ( 0, 0, 96 );// taken from mdl file
m_flFieldOfView = -0.2;// width of forward view cone ( as a dotproduct result )
m_MonsterState = MONSTERSTATE_NONE;
MonsterInit();
m_pEyeGlow = CSprite::SpriteCreate( GARG_EYE_SPRITE_NAME, GetAbsOrigin(), FALSE );
m_pEyeGlow->SetTransparency( kRenderGlow, 255, 255, 255, 0, kRenderFxNoDissipation );
m_pEyeGlow->SetAttachment( edict(), 1 );
EyeOff();
m_seeTime = gpGlobals->time + 5;
m_flameTime = gpGlobals->time + 2;
}
void CNPC_ControllerZapBall::Spawn( void )
{
Precache( );
// motor
SetMoveType( MOVETYPE_FLY );
// SetSolid( SOLID_CUSTOM );
SetSolid( SOLID_BBOX );
SetSize( vec3_origin, vec3_origin );
m_pSprite = CSprite::SpriteCreate( "sprites/xspark4.vmt", GetAbsOrigin(), FALSE );
m_pSprite->SetTransparency( kRenderTransAdd, 255, 255, 255, 255, kRenderFxNoDissipation );
m_pSprite->SetAttachment( this, 0 );
m_pSprite->SetScale( 0.5 );
UTIL_SetSize( this, Vector( 0, 0, 0), Vector(0, 0, 0) );
UTIL_SetOrigin( this, GetAbsOrigin() );
SetThink( &CNPC_ControllerZapBall::AnimateThink );
SetTouch( &CNPC_ControllerZapBall::ExplodeTouch );
m_hOwner = GetOwnerEntity();
m_flSpawnTime = gpGlobals->curtime; // keep track of when ball spawned
SetNextThink( gpGlobals->curtime + 0.1 );
}
void CPosition::setY(int _y) {
y = _y;
CSprite * sprite = (CSprite *) parent->getComponent("Sprite");
if ( sprite != NULL ) {
sprite->updatePosition();
}
}
void CPosition::setX(int _x) {
x = _x;
CSprite * sprite = (CSprite *) parent->getComponent("Sprite");
if ( sprite != NULL ) {
sprite->updatePosition();
}
}
void Game::InitialiseHadoken(CSprite* previous, bool isAI)
{
Hadoken* temp = new Hadoken();
temp->m_X = previous->m_X;
temp->m_Y = previous->m_Y;
temp->SetImage(g_pResources->getSettingsButton());
temp->m_AnchorX = previous->m_AnchorX;
temp->m_AnchorY = previous->m_AnchorY;
// Fit player to Device size
temp->m_ScaleX = (float)(ScreenWidth / 8) / temp->GetImage()->GetWidth();
temp->m_ScaleY = temp->m_ScaleX;
temp->setWidth(ScreenWidth / 8);
projectiles[isAI].push_back(temp);
CSprite* tempLine = new CSprite();
tempLine->m_X = player[isAI]->m_X + (temp->getWidth() / 2);
tempLine->m_Y = player[isAI]->m_Y;
tempLine->m_AnchorX = 0.5;
tempLine->m_AnchorY = (float)(isAI); /*1.0 for AI, 0.0 fir player*/
tempLine->SetImage(g_pResources->getGreenImage());
tempLine->m_ScaleX = (float)(ScreenWidth / 50) / lifeBars[isAI]->GetImage()->GetWidth();
projectileLines[isAI].push_back(tempLine);
AddChild(projectileLines[isAI].back());
ResizeLine(tempLine, isAI, projectiles[isAI].back()->m_Y);
//we add teh hadoken after to remove overlap
AddChild(projectiles[isAI].back());
}
void PlayState::init()
{
vertical = 1;
count = 0;
background = new CImage();
background->loadImage("data/maps/black.png");
while(count != 7){
CSprite* enemy = new CSprite();
enemy->loadSpriteSparrowXML("data/img/bug.xml");
if(count > 2) vertical = 3;
enemy->setPosition((count%3)*125,50*vertical);
enemy->setAnimRate(0);
enemies[count] = enemy;
count++;
}
player = new CSprite();
player->loadSpriteSparrowXML("data/img/spaceship.xml");
player->setPosition(172,550);
player->setAnimRate(0);
dirx = 0; // direção do personagem: para a direita (5), esquerda (-5)
diry = 0; // direção do personagem: para cima (5), baixo (-5)
keyState = SDL_GetKeyState(0); // get key state array
cout << "PlayState Init Successful" << endl;
}
void CSquidSpit::Shoot( CBaseEntity *pOwner, Vector vecStart, Vector vecVelocity )
{
CSquidSpit *pSpit = CREATE_ENTITY( CSquidSpit, "squidspit" );
pSpit->Spawn();
UTIL_SetOrigin( pSpit, vecStart );
pSpit->SetAbsVelocity( vecVelocity );
pSpit->SetOwnerEntity( pOwner );
CSprite *pSprite = (CSprite*)pSpit->GetSprite();
if ( pSprite )
{
pSprite->SetAttachment( pSpit, 0 );
pSprite->SetOwnerEntity( pSpit );
pSprite->SetScale( 0.5 );
pSprite->SetTransparency( pSpit->m_nRenderMode, pSpit->m_clrRender->r, pSpit->m_clrRender->g, pSpit->m_clrRender->b, pSpit->m_clrRender->a, pSpit->m_nRenderFX );
}
CPVSFilter filter( vecStart );
VectorNormalize( vecVelocity );
te->SpriteSpray( filter, 0.0, &vecStart , &vecVelocity, pSpit->m_nSquidSpitSprite, 210, 25, 15 );
}
bool LevelScene::onTouchBegan(Touch* touch, Event* event) {
Point point = this->convertTouchToNodeSpace(touch);
this->isMoved = false;
this->isTouched = false;
RectBody* chapterLayerBody = new RectBody(this->levelLayer->getContentSize().width, this->levelLayer->getContentSize().height);
chapterLayerBody->setPosition(this->levelLayer->getPosition() + Point(chapterLayerBody->getWidth() / 2, chapterLayerBody->getHeight() / 2));
if (chapterLayerBody->contains(point)) {
this->isTouched = true;
this->firstPoint = point;
// update flash
{
Point point = this->convertTouchToNodeSpace(touch);
point = point - this->levelLayer->getPosition();
for (int i = 0; i < this->levelLayer->getChildren().size(); i++) {
CSprite* levelFace = dynamic_cast<CSprite*>(this->levelLayer->getChildren().at(i));
if (levelFace != NULL) {
RectBody* levelBody = new RectBody(levelFace->getContentSize().width, levelFace->getContentSize().height);
levelBody->setPosition(levelFace->getPosition());
}
}
}
return true;
}
return false;
}
void CNPC_ControllerHeadBall::Spawn( void )
{
Precache( );
// motor
SetMoveType( MOVETYPE_FLY );
SetSolid( SOLID_BBOX );
SetSize( vec3_origin, vec3_origin );
m_pSprite = CSprite::SpriteCreate( "sprites/xspark4.vmt", GetAbsOrigin(), FALSE );
m_pSprite->SetTransparency( kRenderTransAdd, 255, 255, 255, 255, kRenderFxNoDissipation );
m_pSprite->SetAttachment( this, 0 );
m_pSprite->SetScale( 2.0 );
UTIL_SetSize( this, Vector( 0, 0, 0), Vector(0, 0, 0) );
UTIL_SetOrigin( this, GetAbsOrigin() );
SetThink( &CNPC_ControllerHeadBall::HuntThink );
SetTouch( &CNPC_ControllerHeadBall::BounceTouch );
// m_vecIdeal = vec3_origin; //(0,0,0)
SetNextThink( gpGlobals->curtime + 0.1 );
m_hOwner = GetOwnerEntity();
m_flSpawnTime = gpGlobals->curtime;
}
// UNDONE: right now this is pretty much a copy of the squid spit with minor changes to the way it does damage
void CBMortar:: Spawn( void )
{
SetMoveType( MOVETYPE_FLYGRAVITY );
SetClassname( "bmortar" );
SetSolid( SOLID_BBOX );
pSprite = CSprite::SpriteCreate( "sprites/mommaspit.vmt", GetAbsOrigin(), true );
if ( pSprite )
{
pSprite->SetAttachment( this, 0 );
pSprite->m_flSpriteFramerate = 5;
pSprite->m_nRenderMode = kRenderTransAlpha;
pSprite->SetBrightness( 255 );
m_iFrame = 0;
pSprite->SetScale( 2.5f );
}
UTIL_SetSize( this, Vector( 0, 0, 0), Vector(0, 0, 0) );
m_maxFrame = (float)modelinfo->GetModelFrameCount( GetModel() ) - 1;
m_flDmgTime = gpGlobals->curtime + 0.4;
}
// This is where the bones of the project are forged
// (loading sprites, for example)
BOOL CGameLogic::Init(CGame *game)
{
// Initialize the combination
m_combo = CreateCombination();
m_nodes = m_combo;
for (unsigned i = 0; i < m_nodes.size(); i++)
m_nodes[i] = i;
// Load sprites
auto path = game->GetExecutablePath();
// Slider (Mid-section)
CSprite *spr = nullptr;
if (!LoadSprite(path, L"sliderMid.png", game->GetRenderer(), &spr))
return FALSE;
m_sprites.push_back(spr);
spr->SetPosition(0, 0);
// Slider (nodes)
for (auto i = 0; i < 5; i++) {
spr = nullptr;
if (!LoadSprite(path, L"sliderNode.png", game->GetRenderer(), &spr))
return FALSE;
m_sprites.push_back(spr);
}
return TRUE;
}
void CGib::DieThink ( void )
{
if ( GetSprite() )
{
CSprite *pSprite = dynamic_cast<CSprite*>( GetSprite() );
if ( pSprite )
{
pSprite->FadeAndDie( 0.0 );
}
}
if ( GetFlame() )
{
CEntityFlame *pFlame = dynamic_cast< CEntityFlame*>( GetFlame() );
if ( pFlame )
{
pFlame->SetLifetime( 1.0f );
}
}
if ( g_pGameRules->IsMultiplayer() )
{
UTIL_Remove( this );
}
else
{
SetThink ( &CGib::SUB_FadeOut );
SetNextThink( gpGlobals->curtime );
}
}
void CEntity::RenderRallyPoint()
{
if( !m_visible )
return;
/*
if ( !entf_get(ENTF_HAS_RALLY_POINT) ||
g_Selection.m_unitUITextures.find(m_base->m_rallyName) == g_Selection.m_unitUITextures.end() )
{
return;
}
*/
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE);
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB_ARB, GL_REPLACE);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB_ARB, GL_TEXTURE);
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_RGB_ARB, GL_SRC_COLOR);
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA_ARB, GL_REPLACE);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_ALPHA_ARB, GL_TEXTURE);
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_ALPHA_ARB, GL_SRC_ALPHA);
glTexEnvf(GL_TEXTURE_FILTER_CONTROL, GL_TEXTURE_LOD_BIAS, g_Renderer.m_Options.m_LodBias);
CSprite sprite;
CTexture tex;
// tex.SetHandle( g_Selection.m_unitUITextures[m_base->m_rallyName] );
sprite.SetTexture(&tex);
// Place the sprite slightly above ground/water level.
float terrainHeight = g_Game->GetWorld()->GetTerrain()->GetExactGroundLevel(m_rallyPoint);
float height = std::max(terrainHeight, g_Renderer.GetWaterManager()->m_WaterHeight) + 0.5f;
CVector3D rally(m_rallyPoint.x, height, m_rallyPoint.y);
sprite.SetTranslation(rally);
sprite.Render();
}
void LevelScene::onTouchMoved(Touch* touch, Event* event) {
Point point = this->convertTouchToNodeSpace(touch);
Point vectorMove = Point::ZERO;
if (!this->isMoved) {
vectorMove = point - this->firstPoint;
} else {
vectorMove = point - this->movePoint;
}
this->updateLevelLayer(vectorMove);
this->movePoint = point;
this->isMoved = true;
// update flash
{
Point point = this->convertTouchToNodeSpace(touch);
point = point - this->levelLayer->getPosition();
for (int i = 0; i < this->levelLayer->getChildren().size(); i++) {
CSprite* levelFace = dynamic_cast<CSprite*>(this->levelLayer->getChildren().at(i));
if (levelFace != NULL) {
RectBody* levelBody = new RectBody(levelFace->getContentSize().width, levelFace->getContentSize().height);
levelBody->setPosition(levelFace->getPosition());
}
}
}
}
void CBoard::Render()
{
if (m_pBoard)
{
m_pBoard->Render();
}
for (int i = 0; i < 9; i++)
{
int x = i / 3;
int y = i % 3;
if ( IsTileFree( x, y ) )
{
continue;
}
CSprite *pIcon = m_iMatrix[x][y] == PLAYER_X ? m_pX : m_pO;
if (!pIcon)
{
continue;
}
pIcon->SetPosition( (x-1)*DELTA_WIDTH, (y-1)*DELTA_HEIGHT );
pIcon->SetScale( SCALE );
pIcon->Render();
}
}
//=========================================================
// WaitTillLand - in order to emit their meaty scent from
// the proper location, gibs should wait until they stop
// bouncing to emit their scent. That's what this function
// does.
//=========================================================
void CGib::WaitTillLand ( void )
{
if (!IsInWorld())
{
UTIL_Remove( this );
return;
}
if ( GetAbsVelocity() == vec3_origin )
{
SetRenderAlpha( 255 );
m_nRenderMode = kRenderTransTexture;
if ( GetMoveType() != MOVETYPE_VPHYSICS )
{
AddSolidFlags( FSOLID_NOT_SOLID );
}
SetLocalAngularVelocity( vec3_angle );
SetNextThink( gpGlobals->curtime + m_lifeTime );
SetThink ( &CGib::SUB_FadeOut );
if ( GetSprite() )
{
CSprite *pSprite = dynamic_cast<CSprite*>( GetSprite() );
if ( pSprite )
{
//Adrian - Why am I doing this? Check InitPointGib for the answer!
if ( m_lifeTime == 0 )
m_lifeTime = random->RandomFloat( 1, 3 );
pSprite->FadeAndDie( m_lifeTime );
}
}
if ( GetFlame() )
{
CEntityFlame *pFlame = dynamic_cast< CEntityFlame*>( GetFlame() );
if ( pFlame )
{
pFlame->SetLifetime( 1.0f );
}
}
// If you bleed, you stink!
if ( m_bloodColor != DONT_BLEED )
{
// ok, start stinkin!
// FIXME: It's too easy to fill up the sound queue with all these meat sounds
// CSoundEnt::InsertSound ( SOUND_MEAT, GetAbsOrigin(), 384, 25 );
}
}
else
{
// wait and check again in another half second.
SetNextThink( gpGlobals->curtime + 0.5f );
}
}
void CStomp::Think( void )
{
trace_t tr;
SetNextThink( gpGlobals->curtime + 0.1 );
// Do damage for this frame
Vector vecStart = GetAbsOrigin();
vecStart.z += 30;
Vector vecEnd = vecStart + (m_vecMoveDir * m_flSpeed * gpGlobals->frametime);
UTIL_TraceHull( vecStart, vecEnd, Vector(-32, -32, -32), Vector(32, 32, 32), MASK_SOLID, m_pOwner, COLLISION_GROUP_NONE, &tr );
// NDebugOverlay::Line( vecStart, vecEnd, 0, 255, 0, false, 10.0f );
if ( tr.m_pEnt )
{
CBaseEntity *pEntity = tr.m_pEnt;
CTakeDamageInfo info( this, this, 50, DMG_SONIC );
CalculateMeleeDamageForce( &info, m_vecMoveDir, tr.endpos );
pEntity->TakeDamage( info );
}
// Accelerate the effect
m_flSpeed += (gpGlobals->frametime) * m_uiFramerate;
m_uiFramerate += (gpGlobals->frametime) * 2000;
// Move and spawn trails
while ( gpGlobals->curtime - m_flDmgTime > STOMP_INTERVAL )
{
SetAbsOrigin( GetAbsOrigin() + m_vecMoveDir * m_flSpeed * STOMP_INTERVAL );
for ( int i = 0; i < 2; i++ )
{
CSprite *pSprite = CSprite::SpriteCreate( GARG_STOMP_SPRITE_NAME, GetAbsOrigin(), TRUE );
if ( pSprite )
{
UTIL_TraceLine( GetAbsOrigin(), GetAbsOrigin() - Vector(0,0,500), MASK_SOLID, this, COLLISION_GROUP_NONE, &tr );
pSprite->SetAbsOrigin( tr.endpos );
// pSprite->pev->velocity = Vector(RandomFloat(-200,200),RandomFloat(-200,200),175);
pSprite->SetNextThink( gpGlobals->curtime + 0.3 );
pSprite->SetThink( &CSprite::SUB_Remove );
pSprite->SetTransparency( kRenderTransAdd, 255, 255, 255, 255, kRenderFxFadeFast );
}
g_pEffects->EnergySplash( tr.endpos, tr.plane.normal );
}
m_flDmgTime += STOMP_INTERVAL;
// Scale has the "life" of this effect
m_flScale -= STOMP_INTERVAL * m_flSpeed;
if ( m_flScale <= 0 )
{
// Life has run out
UTIL_Remove(this);
// STOP_SOUND( edict(), CHAN_BODY, GARG_STOMP_BUZZ_SOUND );
CPASAttenuationFilter filter( this );
StopSound( entindex(), CHAN_STATIC, GARG_STOMP_BUZZ_SOUND );
}
}
}
void CStomp::Think( void )
{
TraceResult tr;
pev->nextthink = gpGlobals->time + 0.1;
// Do damage for this frame
Vector vecStart = GetAbsOrigin();
vecStart.z += 30;
Vector vecEnd = vecStart + (pev->movedir * pev->speed * STOMP_FRAMETIME);
UTIL_TraceHull( vecStart, vecEnd, dont_ignore_monsters, head_hull, ENT(pev), &tr );
if ( tr.pHit && tr.pHit != pev->owner )
{
CBaseEntity *pEntity = CBaseEntity::Instance( tr.pHit );
entvars_t *pevOwner = pev;
if ( pev->owner )
pevOwner = VARS(pev->owner);
if ( pEntity )
pEntity->TakeDamage( pev, pevOwner, gSkillData.gargantuaDmgStomp, DMG_SONIC );
}
// Accelerate the effect
pev->speed = pev->speed + (STOMP_FRAMETIME) * pev->framerate;
pev->framerate = pev->framerate + (STOMP_FRAMETIME) * 1500;
// Move and spawn trails
while ( gpGlobals->time - pev->dmgtime > STOMP_INTERVAL )
{
SetAbsOrigin( GetAbsOrigin() + pev->movedir * pev->speed * STOMP_INTERVAL );
for ( int i = 0; i < 2; i++ )
{
CSprite *pSprite = CSprite::SpriteCreate( GARG_STOMP_SPRITE_NAME, GetAbsOrigin(), TRUE );
if ( pSprite )
{
UTIL_TraceLine( GetAbsOrigin(), GetAbsOrigin() - Vector( 0, 0, 500 ), ignore_monsters, edict(), &tr );
pSprite->SetAbsOrigin( tr.vecEndPos );
pSprite->SetAbsVelocity( Vector(RANDOM_FLOAT(-200,200),RANDOM_FLOAT(-200,200),175));
// pSprite->AnimateAndDie( RANDOM_FLOAT( 8.0, 12.0 ) );
pSprite->pev->nextthink = gpGlobals->time + 0.3;
pSprite->SetThink( SUB_Remove );
pSprite->SetTransparency( kRenderTransAdd, 255, 255, 255, 255, kRenderFxFadeFast );
}
}
pev->dmgtime += STOMP_INTERVAL;
// Scale has the "life" of this effect
pev->scale -= STOMP_INTERVAL * pev->speed;
if ( pev->scale <= 0 )
{
// Life has run out
UTIL_Remove(this);
STOP_SOUND( edict(), CHAN_BODY, GARG_STOMP_BUZZ_SOUND );
}
}
}
// Initializare
void Init(CSprite *spr)
{
m_Sprite = spr;
glm::vec3 pz = m_Sprite->GetPosition();
m_Sprite->PlayAnimation("BugEye_Idle");
}
void update(Ogre::Real tpf) {
if (m_bVisible) {
m_Indicator.setPosition(getPosition());
m_Indicator.getTexture().setTexturePosRight(m_fValue);
m_Indicator.setSize(Ogre::Vector2(m_fValue * m_vSize.x, m_vSize.y));
CSprite::update(tpf);
}
}
void LevelScene::addSpriteToLayer(Obj* object, Layer* layer, int index) {
for (int i = 0; i < object->getSprites()->size(); i++) {
CSprite* cSprite = (CSprite*) object->getSprites()->at(i);
cSprite->setPosition(object->getPosition());
cSprite->setAnchorPoint(object->getBody()->getAnchorPoint());
cSprite->setFlippedX(object->getBody()->getFlipX());
layer->addChild(cSprite, index);
}
}
//-----------------------------------------------------------------------------
// Purpose: Spawn the entity
//-----------------------------------------------------------------------------
void CNPC_CeilingTurret::Spawn( void )
{
Precache();
SetModel( CEILING_TURRET_MODEL );
BaseClass::Spawn();
m_HackedGunPos = Vector( 0, 0, 12.75 );
SetViewOffset( EyeOffset( ACT_IDLE ) );
m_flFieldOfView = 0.0f;
m_takedamage = DAMAGE_YES;
m_iHealth = 1000;
m_bloodColor = BLOOD_COLOR_MECH;
SetSolid( SOLID_BBOX );
AddSolidFlags( FSOLID_NOT_STANDABLE );
SetHeight( CEILING_TURRET_RETRACT_HEIGHT );
AddFlag( FL_AIMTARGET );
AddEFlags( EFL_NO_DISSOLVE );
SetPoseParameter( m_poseAim_Yaw, 0 );
SetPoseParameter( m_poseAim_Pitch, 0 );
m_iAmmoType = GetAmmoDef()->Index( "AR2" );
//Create our eye sprite
m_pEyeGlow = CSprite::SpriteCreate( CEILING_TURRET_GLOW_SPRITE, GetLocalOrigin(), false );
m_pEyeGlow->SetTransparency( kRenderTransAdd, 255, 0, 0, 128, kRenderFxNoDissipation );
m_pEyeGlow->SetAttachment( this, 2 );
//Set our autostart state
m_bAutoStart = !!( m_spawnflags & SF_CEILING_TURRET_AUTOACTIVATE );
m_bEnabled = ( ( m_spawnflags & SF_CEILING_TURRET_STARTINACTIVE ) == false );
//Do we start active?
if ( m_bAutoStart && m_bEnabled )
{
SetThink( &CNPC_CeilingTurret::AutoSearchThink );
SetEyeState( TURRET_EYE_DORMANT );
}
else
{
SetEyeState( TURRET_EYE_DISABLED );
}
//Stagger our starting times
SetNextThink( gpGlobals->curtime + random->RandomFloat( 0.1f, 0.3f ) );
// Don't allow us to skip animation setup because our attachments are critical to us!
SetBoneCacheFlags( BCF_NO_ANIMATION_SKIP );
}
GLSprite::GLSprite(const std::string& name, int size_w, int size_h)
{
CSprite* sprite = new CSprite;
InitSprite data;
data.imgFile = name;
data.numFrameH = size_h;
data.numFrameW = size_w;
sprite->init(data);
Init(sprite);
}
void CGameStatePlay::render(Graphics &con){
CLog *pLog = CLog::Instance();
CGameData *pData = CGameData::Instance();
::ShowCursor(true);
// POINT pt;
// pt.x = g_Global.g_mouse.x;
// pt.y = g_Global.g_mouse.y;
int dx = 0; //used to convert object coordinates to screen coordinates
int dy = 0;
//HRESULT hr;
float playerAngle;
int lastHeight = 0; //used for adding hanging icicles
int skyOffsetY = 0; //moves sky mountain
int skyOffsetX = 0;
std::ostringstream oss;
static int m_winFrame = 0;//used to animate You Win
//Clear buffer and draw graphics
con.ClearBuffer(0, 0, 30, 0);
con.BeginDrawing();
GRAPHIC_IMAGE gi;
gi = g_Sprite.GetSpriteData(32);
con.RenderGraphicModulate(con.GetScreenCenterX() - gi.width/2 , con.GetScreenCenterY() - gi.height/2, gi, m_red, m_green, m_blue);
//display orders
for(int i = 0; i < pData->m_orders.size(); ++i)
con.Draw2DText(pData->m_orders[i],F_V20, con.GetScreenCenterX() - 150, con.GetScreenCenterY() - 180 + (i * 20), 0,0,0);
//accept...mouse hover outline
if(g_Global.g_mouse.x > 290 && g_Global.g_mouse.x < 407
&& g_Global.g_mouse.y > 684 && g_Global.g_mouse.y < 718){
gi = g_Sprite.GetSpriteData(54);
con.RenderGraphicModulate(278, 653, gi, m_red, m_green, m_blue);
}
//reject..mouse hover outline
if(g_Global.g_mouse.x > 627 && g_Global.g_mouse.x < 743
&& g_Global.g_mouse.y > 684 && g_Global.g_mouse.y < 718){
gi = g_Sprite.GetSpriteData(54);
con.RenderGraphicModulate(615, 653, gi, m_red, m_green, m_blue);
}
con.Draw2DText("Left click to continue.", F_V20, con.GetScreenCenterX() - 150, con.GetScreenCenterY() + 30, 0,0,0);
con.EndDrawing ();
con.Present();
}
CSprite *CSprite::SpriteCreate( const char *pSpriteName, const Vector &origin, BOOL animate )
{
CSprite *pSprite = GetClassPtr( (CSprite *)NULL );
pSprite->SpriteInit( pSpriteName, origin );
pSprite->pev->classname = MAKE_STRING("env_sprite");
pSprite->pev->solid = SOLID_NOT;
pSprite->pev->movetype = MOVETYPE_NOCLIP;
if ( animate )
pSprite->TurnOn();
return pSprite;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *pSpriteName -
// &origin -
// animate -
// Output : CSprite
//-----------------------------------------------------------------------------
CSprite *CSprite::SpriteCreate( const char *pSpriteName, const Vector &origin, bool animate )
{
CSprite *pSprite = CREATE_ENTITY( CSprite, "env_sprite" );
pSprite->SpriteInit( pSpriteName, origin );
pSprite->SetSolid( SOLID_NONE );
UTIL_SetSize( pSprite, vec3_origin, vec3_origin );
pSprite->SetMoveType( MOVETYPE_NONE );
if ( animate )
pSprite->TurnOn();
return pSprite;
}
// ----------------------------------------------------------------
// Render
// ----------------------------------------------------------------
void CAnimation::Render()
{
CSprite * sprite;
if( m_Fps == 0 )
sprite = m_Sprites[0];
else
sprite = m_Sprites[m_FrameNumber];
sprite->SetPosition( m_Position );
sprite->Render();
}
//Synchronizes the unit's psi field sprite position with the unit.
void updatePsiFieldPosition(const CUnit *unit) {
if (!unit || !unit->sprite || !unit->building.pylonAura) return;
CSprite *psiField = unit->building.pylonAura;
if (unit->sprite->position != psiField->position) {
//for (CImage *i = psiField->imageHead; i; i = i->link.next)
// i->flags |= 1; //Redraw image
psiField->setPosition(unit->getX(), unit->getY());
refreshSpriteData(psiField);
*canUpdatePoweredStatus = true;
}
}
void CSprite::copy( CSprite &Destination, SDL_Color *Palette )
{
Destination.m_bboxX1 = m_bboxX1;
Destination.m_bboxY1 = m_bboxY1;
Destination.m_bboxX2 = m_bboxX2;
Destination.m_bboxY2 = m_bboxY2;
Destination.setSize(m_xsize, m_ysize);
Destination.createSurface( mpSurface->flags, Palette );
SDL_FillRect(Destination.getSDLSurface(), NULL, COLORKEY);
SDL_BlitSurface( mpSurface.get(), NULL, Destination.getSDLSurface(), NULL);
}
/* <8d4ad> ../cstrike/dlls/func_tank.cpp:656 */
void CFuncTank::__MAKE_VHOOK(Fire)(const Vector &barrelEnd, const Vector &forward, entvars_t *pevAttacker)
{
if (m_fireLast != 0)
{
if (m_iszSpriteSmoke)
{
CSprite *pSprite = CSprite::SpriteCreate(STRING(m_iszSpriteSmoke), barrelEnd, TRUE);
pSprite->AnimateAndDie(RANDOM_FLOAT(15, 20));
pSprite->SetTransparency(kRenderTransAlpha, pev->rendercolor.x, pev->rendercolor.y, pev->rendercolor.z, 255, kRenderFxNone);
pSprite->pev->velocity.z = RANDOM_FLOAT(40, 80);
pSprite->SetScale(m_spriteScale);
}
if (m_iszSpriteFlash)
{
CSprite *pSprite = CSprite::SpriteCreate(STRING(m_iszSpriteFlash), barrelEnd, TRUE);
pSprite->AnimateAndDie(60);
pSprite->SetTransparency(kRenderTransAdd, 255, 255, 255, 255, kRenderFxNoDissipation);
pSprite->SetScale(m_spriteScale);
// Hack Hack, make it stick around for at least 100 ms.
pSprite->pev->nextthink += 0.1;
}
SUB_UseTargets(this, USE_TOGGLE, 0);
}
m_fireLast = gpGlobals->time;
}
