//////////////////////////////////////////////////////////////////////////////// // // Copyright 2016 RWS Inc, All Rights Reserved // // This program is free software; you can redistribute it and/or modify // it under the terms of version 2 of the GNU General Public License as published by // the Free Software Foundation // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License along // with this program; if not, write to the Free Software Foundation, Inc., // 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA // // napalm.cpp // Project: Postal // // This module implements the CNapalm weapon class which is a canister of // napalm gel that breaks apart when it hits the ground lays down a smear // of fire. The canister may be an alternate ordinate for the rocket launcher. // // // History: // 01/17/97 BRH Started this weapon object. // // 02/04/97 JMI Changed LoadDib() call to Load() (which now supports // loading of DIBs). // // 02/09/97 BRH Started the CNapalm from the CGrenade object since their // initial movement logic is similar. // // 02/10/97 JMI rspReleaseResource() now takes a ptr to a ptr. // // 02/18/97 BRH Added a time setting to the Fire with some randomness // to make it look better. // // 02/19/97 BRH Added message processing to check for ObjectDeleted // message. // // 02/19/97 BRH Changed this from 2D to 3D animation. // // 02/23/97 BRH Updated the transform with the angle so that the canister // faces the direction it is traveling. Also changed the // coordinate system to x,-z // // 02/23/97 BRH Added Preload() function to cache resources for this object // before play begins. // // 02/24/97 JMI No longer sets the m_type member of the m_sprite b/c it // is set by m_sprite's constructor. // // 02/24/97 BRH Changed fire to thin fire for more alpha effect since it // lays down many layers of fire. Also hides the napalm // canister by skipping the render when in the hidden state. // // 02/24/97 BRH Added sound effects for canister shooting, hitting things, // and when it breaks open. Used reality.h motion templates // and changed the algorithm for detecting ground and // walls. // // 03/03/97 BRH Derived this from the CWeapon base class. // // 03/03/97 JMI Commented out dHorizVelocity and dVertVelocity parameters // to Setup() so that this version would be a virtual over- // ride of CWeapon's. // // 03/06/97 JMI Upgraded to current rspMod360 usage. // // 03/13/97 JMI Load now takes a version number. // // 03/19/97 BRH Changed ProcessMessages to return a void so that it matches // the new virtual function in the CWeapon base class. // // 03/21/97 BRH Now ignores the ATTRIBUTE_NOT_WALKABLE so that the napalm // canisters don't bounce off of the edge of the world. // // 04/10/97 BRH Converted to using the new multi layer attribute maps and // the helper functions that go with them. // // 05/04/97 BRH Took out an old unused reference to an STL iterator. // // 05/29/97 JMI Removed ASSERT on m_pRealm->m_pAttribMap which no longer // exists. // // 06/11/97 BRH Added shooter ID passing to the fire that is created. // // 06/12/97 JMI Now handles State_Hide by setting m_sprite's InHidden flag. // // 06/16/97 BRH Fixed starting condition in not walkable area. // // 06/17/97 JMI Converted all occurrences of rand() to GetRand() and // srand() to SeedRand(). // // 06/25/97 BRH Added use of base class 2D shadow on the ground, but loaded // a smaller shadow resource. // // 06/30/97 BRH Added sound effect cache to Preload function. // // 07/01/97 JMI Replaced GetFloorMapValue() with GetHeight() call. // // 07/09/97 JMI Now uses m_pRealm->Make2dResPath() to get the fullpath // for 2D image components. // // 07/09/97 JMI Changed Preload() to take a pointer to the calling realm // as a parameter. // // 07/18/97 JMI Got rid of bogus immitation PlaySample functions. // Now there is one PlaySample() function. Also, you now // MUST specify a category and you don't have to specify a // SoundInstance ptr to specify a volume. // // 07/30/97 JMI Same old delete error showed up on Alpha. // ProcessMessages() was deleting the napalm on a delete msg // but, once returned to Update(), it was checking the // m_eState member to see if it should return. Unfortunately, // since 'this' had already been deallocated, it was too late // to do such a thing. // Also, m_dFireX and m_dFireZ were uninitialized causing // floating point exceptions (due to bad values) on the Alpha. // // 08/05/97 JMI Changed priority to use Z position rather than 2D // projected Y position. // // 08/17/97 JMI Changed m_pthingParent to m_idParent. // // 08/27/97 BRH Added large fire sound which had not been used until now. // // 08/28/97 BRH Added cache of large fire sound. // //////////////////////////////////////////////////////////////////////////////// #define NAPALM_CPP #include "RSPiX.h" #include #include "napalm.h" #include "dude.h" #include "fire.h" #include "SampleMaster.h" #include "game.h" #include "reality.h" //////////////////////////////////////////////////////////////////////////////// // Macros/types/etc. //////////////////////////////////////////////////////////////////////////////// #define SMALL_SHADOW_FILE "smallshadow.img" //////////////////////////////////////////////////////////////////////////////// // Variables/data //////////////////////////////////////////////////////////////////////////////// // These are default values -- actually values are set using the editor! double CNapalm::ms_dAccDrag = 300.0; // Acceleration due to drag double CNapalm::ms_dThrowVertVel = 30.0; // Throw up at this velocity double CNapalm::ms_dThrowHorizVel = 300; // Throw out at this velocity double CNapalm::ms_dMinFireInterval = 5*5; long CNapalm::ms_lGrenadeFuseTime = 1500; // Time from throw to blow // Let this auto-init to 0 short CNapalm::ms_sFileCount; /// Napalm Canister Animation Files // An array of pointers to res names (one for each animation component) static char* ms_apszResNames[] = { "3d/napalmcan.sop", "3d/napalmcan.mesh", "3d/napalmcan.tex", "3d/napalmcan.hot", "3d/napalmcan.bounds", "3d/napalmcan.floor", NULL, NULL }; //////////////////////////////////////////////////////////////////////////////// // Load object (should call base class version!) //////////////////////////////////////////////////////////////////////////////// short CNapalm::Load( // Returns 0 if successfull, non-zero otherwise RFile* pFile, // In: File to load from bool bEditMode, // In: True for edit mode, false otherwise short sFileCount, // In: File count (unique per file, never 0) ULONG ulFileVersion) // In: Version of file format to load. { short sResult = CWeapon::Load(pFile, bEditMode, sFileCount, ulFileVersion); if (sResult == SUCCESS) { // Load common data just once per file (not with each object) if (ms_sFileCount != sFileCount) { ms_sFileCount = sFileCount; // Load static data switch (ulFileVersion) { default: case 1: pFile->Read(&ms_dAccDrag); pFile->Read(&ms_dThrowVertVel); pFile->Read(&ms_dThrowHorizVel); pFile->Read(&ms_dMinFireInterval); pFile->Read(&ms_lGrenadeFuseTime); break; } } // Load object data switch (ulFileVersion) { default: case 1: break; } // Make sure there were no file errors or format errors . . . if (!pFile->Error() && sResult == 0) { // Get resources sResult = GetResources(); } else { sResult = -1; TRACE("CNapalm::Load(): Error reading from file!\n"); } } return sResult; } //////////////////////////////////////////////////////////////////////////////// // Save object (should call base class version!) //////////////////////////////////////////////////////////////////////////////// short CNapalm::Save( // Returns 0 if successfull, non-zero otherwise RFile* pFile, // In: File to save to short sFileCount) // In: File count (unique per file, never 0) { CWeapon::Save(pFile, sFileCount); // Save common data just once per file (not with each object) if (ms_sFileCount != sFileCount) { ms_sFileCount = sFileCount; // Save static data pFile->Write(&ms_dAccDrag); pFile->Write(&ms_dThrowVertVel); pFile->Write(&ms_dThrowHorizVel); pFile->Write(&ms_dMinFireInterval); pFile->Write(&ms_lGrenadeFuseTime); } // Save object data return 0; } //////////////////////////////////////////////////////////////////////////////// // Update object //////////////////////////////////////////////////////////////////////////////// void CNapalm::Update(void) { short sHeight; double dNewX; double dNewY; double dNewZ; double dX; double dZ; double dDistance; if (!m_sSuspend) { // Get new time long lThisTime = m_pRealm->m_time.GetGameTime(); // If elapsed time is too short, skip this update. // Calculate elapsed time in seconds double dSeconds = (double)(lThisTime - m_lPrevTime) / 1000.0; ProcessMessages(); if (m_eState == State_Deleted) { delete this; // Must return now, now to avoid accessing through deallocated // 'this'. return; } // Check the current state switch (m_eState) { case CWeapon::State_Idle: break; case CWeapon::State_Fire: // Make sure it starts in a valid location. If it is inside // a wall, delete it now. sHeight = m_pRealm->GetHeight((short) m_dX, (short) m_dZ); if (m_dY < sHeight) { delete this; return; } m_eState = State_Go; m_lTimer = lThisTime + ms_lGrenadeFuseTime; PlaySample( g_smidNapalmShot, SampleMaster::Weapon, DistanceToVolume(m_dX, m_dY, m_dZ, LaunchSndHalfLife) ); // In: Initial Sound Volume (0 - 255) break; //----------------------------------------------------------------------- // Go - fly through the air until hit the ground, change directions on // obstacle collision. //----------------------------------------------------------------------- case CWeapon::State_Go: // Do horizontal velocity dNewX = m_dX + COSQ[(short)m_dRot] * (m_dHorizVel * dSeconds); dNewZ = m_dZ - SINQ[(short)m_dRot] * (m_dHorizVel * dSeconds); // Do vertical velocity dNewY = m_dY; AdjustPosVel(&dNewY, &m_dVertVel, dSeconds); // Check the height to see if it hit the ground sHeight = m_pRealm->GetHeight((short) dNewX, (short) dNewZ); // If its lower than the last and current height, assume it // hit the ground. if (dNewY < sHeight && m_dY >= sHeight) { m_dY = sHeight; m_eState = CWeapon::State_Slide; PlaySample( g_smidNapalmFire, SampleMaster::Destruction, DistanceToVolume(m_dX, m_dY, m_dZ, NapalmSndHalfLife) ); // In: Initial Sound Volume (0 - 255) PlaySample( g_smidFireLarge, SampleMaster::Destruction, DistanceToVolume(m_dX, m_dY, m_dZ, NapalmSndHalfLife) ); } else { // If it is above the last known ground and is now lower // than the height at its new position, assume it hit // a wall and should bounce. if (dNewY < sHeight && m_dY < sHeight) { dNewX = m_dX; // Restore last x position dNewZ = m_dZ; // Restore last z position m_dRot = BounceAngle(m_dRot); // Change directions PlaySample( g_smidNapalmHit, SampleMaster::Weapon, DistanceToVolume(m_dX, m_dY, m_dZ, SideEffectSndHalfLife) ); // In: Initial Sound Volume (0 - 255) } else m_dY = dNewY; } m_dX = dNewX; m_dZ = dNewZ; break; //----------------------------------------------------------------------- // Slide - Once it hits the ground, slide until it stops. //----------------------------------------------------------------------- case CWeapon::State_Slide: // As the Napalm canister slides on the ground, it lays // down fire at intervals. Check the interval to see // it its time to creat a new fire yet. dX = m_dX - m_dFireX; dZ = m_dZ - m_dFireZ; dDistance = (dX*dX) + (dZ*dZ); if (dDistance > ms_dMinFireInterval) { m_dFireX = m_dX; m_dFireZ = m_dZ; // Start a fire here CFire* pFire; if (CThing::Construct(CThing::CFireID, m_pRealm, (CThing**) &pFire) == 0) { if (pFire->Setup(m_dX - 20 + (GetRand() % 40), m_dY, m_dZ - 20 + (GetRand() % 40), 4000 + (GetRand() % 9000), false, CFire::LargeFire) != SUCCESS) delete pFire; else pFire->m_u16ShooterID = m_u16ShooterID; } } // Ground causes drag // Decelerate to zero. When you reach zero, go // to find state. if (m_dHorizVel > 0) { AdjustVel(&m_dHorizVel, dSeconds, -ms_dAccDrag); if (m_dHorizVel < 0) m_dHorizVel = 0; } else if (m_dHorizVel < 0) { AdjustVel(&m_dHorizVel, dSeconds, ms_dAccDrag); m_dHorizVel = 0; } // If it has stopped, then change to find state if (m_dHorizVel == 0) m_eState = CWeapon::State_Explode; dNewX = m_dX + COSQ[(short)m_dRot] * (m_dHorizVel * dSeconds); dNewZ = m_dZ - SINQ[(short)m_dRot] * (m_dHorizVel * dSeconds); // Check for obstacles sHeight = m_pRealm->GetHeight((short) dNewX, (short) dNewZ); // If it hit any obstacles, make it bounce off if (sHeight > m_dY) { // Restore previous position dNewX = m_dX; dNewZ = m_dZ; // Change directions m_dRot = BounceAngle(m_dRot); PlaySample( g_smidNapalmHit, SampleMaster::Weapon, DistanceToVolume(m_dX, m_dY, m_dZ, SideEffectSndHalfLife) ); // In: Initial Sound Volume (0 - 255) } // See if it fell off of something. If so make it go back // to the airborne state if (sHeight < (short) m_dY) { m_dVertVel = 0; m_eState = State_Go; } m_dX = dNewX; m_dZ = dNewZ; break; //----------------------------------------------------------------------- // Explode //----------------------------------------------------------------------- case CWeapon::State_Explode: delete this; return; break; } // Save time for next time m_lPrevTime = lThisTime; } } //////////////////////////////////////////////////////////////////////////////// // Render object //////////////////////////////////////////////////////////////////////////////// void CNapalm::Render(void) { long lThisTime = m_pRealm->m_time.GetGameTime(); m_sprite.m_pmesh = (RMesh*) m_anim.m_pmeshes->GetAtTime(lThisTime); m_sprite.m_psop = (RSop*) m_anim.m_psops->GetAtTime(lThisTime); m_sprite.m_ptex = (RTexture*) m_anim.m_ptextures->GetAtTime(lThisTime); m_sprite.m_psphere = (RP3d*) m_anim.m_pbounds->GetAtTime(lThisTime); // Eventually this should be channel driven also m_sprite.m_sRadius = m_sCurRadius; // Reset rotation so it is not cumulative m_trans.Make1(); // Set its pointing direction m_trans.Ry(rspMod360(m_dRot)); if (m_eState == State_Hide) { // Hide. m_sprite.m_sInFlags = CSprite::InHidden; } else { // No special flags m_sprite.m_sInFlags = 0; } // If we're not a child of someone else... if (m_idParent == CIdBank::IdNil) { // Map from 3d to 2d coords Map3Dto2D((short) m_dX, (short) m_dY, (short) m_dZ, &m_sprite.m_sX2, &m_sprite.m_sY2); // Priority is based on bottom edge of sprite m_sprite.m_sPriority = m_dZ; // Layer should be based on info we get from attribute map m_sprite.m_sLayer = CRealm::GetLayerViaAttrib(m_pRealm->GetLayer((short) m_dX, (short) m_dZ)); m_sprite.m_ptrans = &m_trans; // Update sprite in scene m_pRealm->m_scene.UpdateSprite(&m_sprite); // Render the 2D shadow sprite CWeapon::Render(); } else { // m_idParent is setting our transform relative to its position // and we are drawn by the scene with the parent. } } //////////////////////////////////////////////////////////////////////////////// // Setup new object - called by object that created this object //////////////////////////////////////////////////////////////////////////////// short CNapalm::Setup( // Returns 0 if successfull, non-zero otherwise short sX, // In: New x coord short sY, // In: New y coord short sZ/*, // In: New z coord double dHorizVel, // In: Starting Horizontal Velocity (has default) double dVertVel*/) // In: Starting Vertical Velocity (has default) { short sResult = 0; // Use specified position m_dX = (double)sX; m_dY = (double)sY; m_dZ = (double)sZ; m_dHorizVel = ms_dThrowHorizVel;//dHorizVelocity; m_dVertVel = ms_dThrowVertVel;//dVertVelocity; // Default these to the start position so that, when we first enter // the slide state, we'll create some fire right away. m_dFireX = m_dX; m_dFireZ = m_dZ; // Load resources sResult = GetResources(); // Enable the 2D shadow PrepareShadow(); m_sCurRadius = 10; return sResult; } //////////////////////////////////////////////////////////////////////////////// // Get all required resources //////////////////////////////////////////////////////////////////////////////// short CNapalm::GetResources(void) // Returns 0 if successfull, non-zero otherwise { short sResult = 0; sResult = m_anim.Get(ms_apszResNames); if (sResult == 0) { sResult = rspGetResource(&g_resmgrGame, m_pRealm->Make2dResPath(SMALL_SHADOW_FILE), &(m_spriteShadow.m_pImage), RFile::LittleEndian); if (sResult == 0) { // add more gets } else { TRACE("CGrenade::GetResources - Failed to open 2D shadow image\n"); } } else { TRACE("CNapalm::GetResources - Failed to open 3D animation for napalm\n"); } return sResult; } //////////////////////////////////////////////////////////////////////////////// // Free all resources //////////////////////////////////////////////////////////////////////////////// short CNapalm::FreeResources(void) // Returns 0 if successfull, non-zero otherwise { m_anim.Release(); return 0; } //////////////////////////////////////////////////////////////////////////////// // Preload - basically trick the resource manager into caching resources // for this object so there won't be a delay the first time it is // created. //////////////////////////////////////////////////////////////////////////////// short CNapalm::Preload( CRealm* prealm) // In: Calling realm. { CAnim3D anim; RImage* pimage; short sResult = anim.Get(ms_apszResNames); anim.Release(); rspGetResource(&g_resmgrGame, prealm->Make2dResPath(SMALL_SHADOW_FILE), &pimage, RFile::LittleEndian); rspReleaseResource(&g_resmgrGame, &pimage); CacheSample(g_smidNapalmShot); CacheSample(g_smidNapalmHit); CacheSample(g_smidNapalmFire); CacheSample(g_smidFireLarge); return sResult; } //////////////////////////////////////////////////////////////////////////////// // ProcessMessages //////////////////////////////////////////////////////////////////////////////// void CNapalm::ProcessMessages(void) { GameMessage msg; if (m_MessageQueue.DeQ(&msg) == true) { switch(msg.msg_Generic.eType) { case typeObjectDelete: m_MessageQueue.Empty(); m_eState = State_Deleted; return; break; } } // Dump the rest of the messages m_MessageQueue.Empty(); return; } //////////////////////////////////////////////////////////////////////////////// // EOF ////////////////////////////////////////////////////////////////////////////////