void BrowseFolderMenuItem::onSelect()
{
if (SUCCEEDED(CoInitializeEx(NULL, COINIT_APARTMENTTHREADED)))
{
DropDownMenu* dropDownMenu = dynamic_cast<DropDownMenu*>(getParent());
if (dropDownMenu)
{
BROWSEINFO browseInfo;
ZeroMemory(&browseInfo, sizeof(browseInfo));
browseInfo.hwndOwner = winOS->GetWindowsHandle();
browseInfo.ulFlags = BIF_USENEWUI | BIF_RETURNONLYFSDIRS;
PIDLIST_ABSOLUTE pidl = SHBrowseForFolder(&browseInfo);
if (pidl)
{
if (winOS->GetLibraryManager())
{
QSharedPointer<Library> library = winOS->GetLibraryManager()->addFolderAsLibrary(pidl);
if (library)
{
LOG(QString("Library Directory: %1\n").arg(library->getFolderPaths().front()));
// Save the newly created library
QList<QString> otherLibs = winOS->GetLibraryManager()->getFolderLibraryDirectories();
GLOBAL(settings).otherLibraries = otherLibs;
winOS->SaveSettingsFile();
LibraryMenuItem* item = new LibraryMenuItem(library);
dropDownMenu->select(item);
SwitchToLibrary(library);
}
}
CoTaskMemFree(pidl);
}
else
{
// Reselect the last selected object, since this selection failed
dropDownMenu->select(dropDownMenu->items().front());
}
}
CoUninitialize();
}
}
static bool
GenerateIlwrath_generateOrbital (SOLARSYS_STATE *solarSys, PLANET_DESC *world)
{
if (matchWorld (solarSys, world, 0, MATCH_PLANET))
{
if (ActivateStarShip (ILWRATH_SHIP, SPHERE_TRACKING))
{
NotifyOthers (ILWRATH_SHIP, IPNL_ALL_CLEAR);
PutGroupInfo (GROUPS_RANDOM, GROUP_SAVE_IP);
ReinitQueue (&GLOBAL (ip_group_q));
assert (CountLinks (&GLOBAL (npc_built_ship_q)) == 0);
CloneShipFragment (ILWRATH_SHIP,
&GLOBAL (npc_built_ship_q), INFINITE_FLEET);
GLOBAL (CurrentActivity) |= START_INTERPLANETARY;
SET_GAME_STATE (GLOBAL_FLAGS_AND_DATA, 1 << 7);
InitCommunication (ILWRATH_CONVERSATION);
if (!(GLOBAL (CurrentActivity) & (CHECK_ABORT | CHECK_LOAD)))
{
GLOBAL (CurrentActivity) &= ~START_INTERPLANETARY;
ReinitQueue (&GLOBAL (npc_built_ship_q));
GetGroupInfo (GROUPS_RANDOM, GROUP_LOAD_IP);
}
return true;
}
else
{
LoadStdLanderFont (&solarSys->SysInfo.PlanetInfo);
solarSys->PlanetSideFrame[1] =
CaptureDrawable (
LoadGraphic (RUINS_MASK_PMAP_ANIM));
solarSys->SysInfo.PlanetInfo.DiscoveryString =
CaptureStringTable (LoadStringTable (RUINS_STRTAB));
}
}
GenerateDefault_generateOrbital (solarSys, world);
if (matchWorld (solarSys, world, 0, MATCH_PLANET))
{
solarSys->SysInfo.PlanetInfo.Weather = 2;
solarSys->SysInfo.PlanetInfo.Tectonics = 3;
}
return true;
}
static void
sis_hyper_postprocess (ELEMENT *ElementPtr)
{
STARSHIP *StarShipPtr;
GLOBAL (velocity) = ElementPtr->velocity;
GetElementStarShip (ElementPtr, &StarShipPtr);
if (((StarShipPtr->cur_status_flags & WEAPON) ||
PulsedInputState.menu[KEY_MENU_CANCEL])
&& StarShipPtr->special_counter == 0)
{
#define MENU_DELAY 10
DoMenuOptions ();
StarShipPtr->cur_status_flags &= ~SHIP_AT_MAX_SPEED;
StarShipPtr->special_counter = MENU_DELAY;
}
}
static bool
GeneratePkunk_generateOrbital (SOLARSYS_STATE *solarSys, PLANET_DESC *world)
{
if (matchWorld (solarSys, world, 0, MATCH_PLANET))
{
// JMS: No ships orbit Pkunk homeworld anymore.
//if (ActivateStarShip (PKUNK_SHIP, SPHERE_TRACKING))
if (0)
{
NotifyOthers (PKUNK_SHIP, IPNL_ALL_CLEAR);
PutGroupInfo (GROUPS_RANDOM, GROUP_SAVE_IP);
ReinitQueue (&GLOBAL (ip_group_q));
assert (CountLinks (&GLOBAL (npc_built_ship_q)) == 0);
CloneShipFragment (PKUNK_SHIP,
&GLOBAL (npc_built_ship_q), INFINITE_FLEET);
GLOBAL (CurrentActivity) |= START_INTERPLANETARY;
SET_GAME_STATE (GLOBAL_FLAGS_AND_DATA, 1 << 7);
InitCommunication (PKUNK_CONVERSATION);
if (!(GLOBAL (CurrentActivity) & (CHECK_ABORT | CHECK_LOAD)))
{
GLOBAL (CurrentActivity) &= ~START_INTERPLANETARY;
ReinitQueue (&GLOBAL (npc_built_ship_q));
GetGroupInfo (GROUPS_RANDOM, GROUP_LOAD_IP);
}
return true;
}
else
{
LoadStdLanderFont (&solarSys->SysInfo.PlanetInfo);
solarSys->PlanetSideFrame[1] =
CaptureDrawable (LoadGraphic (RUINS_MASK_PMAP_ANIM));
solarSys->SysInfo.PlanetInfo.DiscoveryString =
CaptureStringTable (LoadStringTable (PKUNK_RUINS_STRTAB));
// JMS: No more clear spindles!
//if (GET_GAME_STATE (CLEAR_SPINDLE))
solarSys->SysInfo.PlanetInfo.DiscoveryString =
SetAbsStringTableIndex (
solarSys->SysInfo.PlanetInfo.DiscoveryString, 1);
}
}
GenerateDefault_generateOrbital (solarSys, world);
return true;
}
void
BattleSong (BOOLEAN DoPlay)
{
if (BattleRef == 0)
{
if (LOBYTE (GLOBAL (CurrentActivity)) != IN_HYPERSPACE)
BattleRef = LoadMusic (BATTLE_MUSIC);
else if (GET_GAME_STATE (ORZ_SPACE_SIDE) > 1) // BY JMS - this condition activates Orz space music
BattleRef = LoadMusic (ORZSPACE_MUSIC);
else if (GET_GAME_STATE (ARILOU_SPACE_SIDE) <= 1)
BattleRef = LoadMusic (HYPERSPACE_MUSIC);
else
BattleRef = LoadMusic (QUASISPACE_MUSIC);
}
if (DoPlay)
PlayMusic (BattleRef, TRUE, 1);
}
void tick_rgbLeds(void) {
if(GLOBAL(rgbleds)) {
if(frames > 0) {
if(ctr == 0) {
ws2812_sendarray(&leds[framectr*3*8+2], 3*8);
framectr++;
if(framectr >= frames)
framectr = 0;
}
ctr++;
// LED delay is in leds[0:1]
if(ctr >= ((leds[0]<<8) + leds[1]))
ctr = 0;
}
}
return;
}
void
PlayMusic (MUSIC_REF MusicRef, BOOLEAN Continuous, BYTE Priority)
{
LastMusicRef = MusicRef;
LastContinuous = Continuous;
LastPriority = Priority;
if (
#ifdef NEVER
Priority > 1
||
#endif /* NEVER */
!(GLOBAL (glob_flags) & MUSIC_DISABLED)
)
{
PLRPlaySong (MusicRef, Continuous, Priority);
}
}
static bool
GenerateSupox_generateOrbital (SOLARSYS_STATE *solarSys, PLANET_DESC *world)
{
if (matchWorld (solarSys, world, 0, MATCH_PLANET))
{
if (StartSphereTracking (SUPOX_SHIP))
{
NotifyOthers (SUPOX_SHIP, IPNL_ALL_CLEAR);
PutGroupInfo (GROUPS_RANDOM, GROUP_SAVE_IP);
ReinitQueue (&GLOBAL (ip_group_q));
assert (CountLinks (&GLOBAL (npc_built_ship_q)) == 0);
CloneShipFragment (SUPOX_SHIP, &GLOBAL (npc_built_ship_q),
INFINITE_FLEET);
GLOBAL (CurrentActivity) |= START_INTERPLANETARY;
SET_GAME_STATE (GLOBAL_FLAGS_AND_DATA, 1 << 7);
InitCommunication (SUPOX_CONVERSATION);
if (!(GLOBAL (CurrentActivity) & (CHECK_ABORT | CHECK_LOAD)))
{
GLOBAL (CurrentActivity) &= ~START_INTERPLANETARY;
ReinitQueue (&GLOBAL (npc_built_ship_q));
GetGroupInfo (GROUPS_RANDOM, GROUP_LOAD_IP);
}
return true;
}
else
{
LoadStdLanderFont (&solarSys->SysInfo.PlanetInfo);
solarSys->PlanetSideFrame[1] =
CaptureDrawable (LoadGraphic (RUINS_MASK_PMAP_ANIM));
solarSys->SysInfo.PlanetInfo.DiscoveryString =
CaptureStringTable (LoadStringTable (SUPOX_RUINS_STRTAB));
if (GET_GAME_STATE (ULTRON_CONDITION))
{ // Already picked up the Ultron, skip the report
solarSys->SysInfo.PlanetInfo.DiscoveryString =
SetAbsStringTableIndex (
solarSys->SysInfo.PlanetInfo.DiscoveryString, 1);
}
}
}
GenerateDefault_generateOrbital (solarSys, world);
return true;
}
// Sets whether this actor should be thumbnailed at all, and if loadThumbnail
// is true, queues the thumbnail operation on the texture loader.
// If no thumbnail exists, it will use the default filesystem icon.
void FileSystemActor::enableThumbnail(bool enableThumbnail/*=true*/, bool loadThumbnail/*=true*/)
{
useThumbnail = enableThumbnail;
// Load this Thumbnail because it wasn't loaded before
if (useThumbnail)
{
GLTextureDetail detail = SampledImage;
// NOTE: workaround for keeping training images in hires
// also use hi-res if user wants to skip thumbs db usage
bool isTrainingImage = getFullPath().startsWith(native(winOS->GetTrainingDirectory()), Qt::CaseInsensitive);
if (!GLOBAL(settings).useThumbsDb || isTrainingImage)
detail = HiResImage;
if (loadThumbnail)
loadThumbnailTexture(GLTextureObject(Load|Reload, _alternateThumbnailId, getTargetPath(), detail, NormalPriority, true, isFileSystemType(Image)));
}
}
static bool
HasTech (TechId_t techId)
{
const TechData* techData = GetTechData (techId);
if (!techData)
return false;
switch (techData->type)
{
case TECH_TYPE_MODULE:
return GLOBAL (ModuleCost[techData->subtype]) != 0;
case TECH_TYPE_LANDER_SHIELD:
return (GET_GAME_STATE (LANDER_SHIELDS) & (1 << techData->subtype)) != 0;
case TECH_TYPE_STATE:
return HasStateTech (techData->subtype);
}
return false;
}
/* initialize the Token Cache Manager */
int tcm_init(TokenCacheManager *tcm)
{
TLS_VARS;
tcm->active = 0;
tcm->token_caches = (TokenCache *) emalloc(sizeof(TokenCache) * TOKEN_CACHES_BLOCK_SIZE);
if (!tcm->token_caches) {
return FAILURE;
} else {
tcm->max = TOKEN_CACHES_BLOCK_SIZE;
}
if (tc_init(&tcm->token_caches[0],TOKEN_CACHE_BLOCK_SIZE) == FAILURE) {
return FAILURE;
}
tcm->initialized = 1;
GLOBAL(tc) = &tcm->token_caches[0];
last_token_type=-1;
return SUCCESS;
}
static bool screen_gameover() {
char key =0;
while(key==0) {
lcdFill(0x00);
setIntFont(&Font_7x8);
setTextColor(0x00,0b11100000);
lcdSetCrsr(14+15,32+15);lcdPrint("GAME OVER");
setTextColor(0x00,0xff);
lcdSetCrsr(0,0);lcdPrint(IntToStr(game.score,6,F_LONG));
if (highscore_set(game.score, GLOBAL(nickname))){
setTextColor(0x00,0b00011000);
lcdSetCrsr(0,9);lcdPrint("HIGHSCORE!");
};
lcdDisplay();
key=getInputWaitTimeout(5000);
}
//getInputWaitRelease();
return !(key==BTN_LEFT);
}
static bool highscore_set(uint32_t score)
{
writeFile("snake.5cr", &score , sizeof(uint32_t));
// old r0ket code to get highscore from the world
#if 0
MPKT * mpkt= meshGetMessage('s');
if(MO_TIME(mpkt->pkt)>score)
return false;
MO_TIME_set(mpkt->pkt,score);
strcpy((char*)MO_BODY(mpkt->pkt),nick);
if(GLOBAL(privacy)==0) {
uint32touint8p(GetUUID32(),mpkt->pkt+26);
mpkt->pkt[25]=0;
};
#endif
return true;
}
bool PbPersistenceManager::saveScene(const QString& filePath)
{
PbBumpTop bumptop;
// save the header
if (bumptop.mutable_header())
{
PbHeader * header = bumptop.mutable_header();
QString buildStr;
QTextStream stream(&buildStr);
stream << "BumpTop,";
stream << winOS->BumpTopEditionName(winOS->GetBumpTopEdition()) << ",";
stream << ((GLOBAL(settings).freeOrProLevel == AL_PRO) ? "Pro," : "Free,");
stream << winOS->GetBuildNumber() << ",";
stream << winOS->GetLocaleLanguage() << ",";
stream << "win32";
header->set_build(stdString(buildStr));
header->set_version(atoi(SVN_VERSION_NUMBER));
}
// save the scene data
if (!scnManager->serializeToPb(bumptop.mutable_scene()))
{
assert(false);
return false;
}
// write the bumptop root to disk
std::ofstream fileOut(filePath.utf16(), ios::trunc | ios::binary);
if (!bumptop.SerializeToOstream(&fileOut))
{
fileOut.close();
return false;
}
fileOut.close();
bool ret = bumptop.IsInitialized();
if (ret)
LOG("PbPersistenceManager::saveScene successful");
return ret;
}
BYTE
NameCaptain (PQUEUE pQueue, STARSHIPPTR StarShipPtr)
{
BYTE name_index;
HSTARSHIP hStarShip;
do
{
HSTARSHIP hNextShip;
name_index = PickCaptainName ();
for (hStarShip = GetHeadLink (pQueue); hStarShip; hStarShip = hNextShip)
{
STARSHIPPTR TestShipPtr;
TestShipPtr = LockStarShip (pQueue, hStarShip);
hNextShip = _GetSuccLink (TestShipPtr);
if (TestShipPtr->RaceResIndex == StarShipPtr->RaceResIndex)
{
BOOLEAN SameName;
if (LOBYTE (GLOBAL (CurrentActivity)) == SUPER_MELEE)
SameName = (BOOLEAN)(
name_index == TestShipPtr->captains_name_index
);
else
SameName = (BOOLEAN)(
name_index == StarShipCaptain (TestShipPtr)
);
if (SameName)
{
UnlockStarShip (pQueue, hStarShip);
break;
}
}
UnlockStarShip (pQueue, hStarShip);
}
} while (hStarShip);
return (name_index);
}
void mesh_sendloop(void){
int ctr=0;
__attribute__ ((aligned (4))) uint8_t buf[32];
int status;
uint32_t rnd=0xffffffff;
if(meshnice)
rnd=getRandom();
nrf_config_get(&oldconfig);
nrf_set_channel(MESH_CHANNEL);
nrf_set_tx_mac(strlen(MESH_MAC),(uint8_t*)MESH_MAC);
// Update [T]ime packet
MO_TIME_set(meshbuffer[0].pkt,getSeconds());
MO_GEN_set(meshbuffer[0].pkt,meshgen);
if(GLOBAL(privacy)==0)
uint32touint8p(GetUUID32(),MO_BODY(meshbuffer[0].pkt));
else
uint32touint8p(0,MO_BODY(meshbuffer[0].pkt));
MO_BODY(meshbuffer[0].pkt)[4]=meshnice;
for (int i=0;i<MESHBUFSIZE;i++){
if(!meshbuffer[i].flags&MF_USED)
continue;
if(meshbuffer[i].flags&MF_LOCK)
continue;
if(meshnice&0xf){
if((rnd++)%0xf < (meshnice&0x0f)){
meshincctr++;
continue;
};
};
ctr++;
memcpy(buf,meshbuffer[i].pkt,MESHPKTSIZE);
status=nrf_snd_pkt_crc_encr(MESHPKTSIZE,buf,meshkey);
//Check status? But what would we do...
};
nrf_config_set(&oldconfig);
};
//Analogous to getUniqueNewFolderPathInWorkingDirectory, this function returns a unique file path using the parameter as a template
QFileInfo FileSystemManager::getUniqueNewFilePathInWorkingDirectory(QString fileName) {
QFileInfo newFile;
int file_extension_division = fileName.lastIndexOf(".");
QString ext = fileName.mid(file_extension_division,fileName.size()-file_extension_division);
QString fileBase = fileName.mid(0,file_extension_division);
QString oldBase = fileBase;
int x = 1;
do
{
QString counter = QString::number(x);
fileBase.append(counter);
fileBase.append(ext);
newFile = make_file(GLOBAL(getWorkingDirectory()), fileBase);
fileBase = oldBase;
x++;
}
while (exists(newFile));
return newFile;
}
static void
DrawSISComWindow (void)
{
CONTEXT OldContext;
if (LOBYTE (GLOBAL (CurrentActivity)) != WON_LAST_BATTLE)
{
RECT r;
OldContext = SetContext (SpaceContext);
r.corner.x = 0;
r.corner.y = SLIDER_Y + SLIDER_HEIGHT;
r.extent.width = SIS_SCREEN_WIDTH;
r.extent.height = SIS_SCREEN_HEIGHT - r.corner.y;
SetContextForeGroundColor (COMM_PLAYER_BACKGROUND_COLOR);
DrawFilledRectangle (&r);
SetContext (OldContext);
}
}
BOOLEAN
RosterMenu (void)
{
MENU_STATE MenuState;
ROSTER_STATE RosterState;
memset (&MenuState, 0, sizeof MenuState);
MenuState.privData = &RosterState;
memset (&RosterState, 0, sizeof RosterState);
RosterState.count = CountLinks (&GLOBAL (built_ship_q));
if (!RosterState.count)
return FALSE;
// Get the escort positions we will use and sort on X then Y
assert (sizeof (RosterState.shipPos) == sizeof (ship_pos));
memcpy (RosterState.shipPos, ship_pos, sizeof (ship_pos));
qsort (RosterState.shipPos, RosterState.count,
sizeof (RosterState.shipPos[0]), compShipPos);
LockMutex (GraphicsLock);
SetContext (StatusContext);
selectSupportShip (&RosterState, MenuState.CurState);
UnlockMutex (GraphicsLock);
SetMenuSounds (MENU_SOUND_ARROWS, MENU_SOUND_SELECT);
MenuState.InputFunc = DoModifyRoster;
DoInput (&MenuState, TRUE);
LockMutex (GraphicsLock);
SetContext (StatusContext);
// unselect the last ship
drawSupportShip (&RosterState, FALSE);
DrawStatusMessage (NULL);
UnlockMutex (GraphicsLock);
return TRUE;
}
int seek_token(TokenCacheManager *tcm, int token_number, int *yychar)
{
int t_offset, tc_offset;
TLS_VARS;
clear_lookahead(yychar);
tc_offset = TC_OFFSET(token_number);
if (tc_offset >= tcm->initialized) {
return FAILURE;
}
t_offset = TOKEN_OFFSET(token_number);
if (t_offset > tcm->token_caches[tc_offset].count) {
return FAILURE;
}
tcm->active = tc_offset;
tcm->token_caches[tc_offset].pos = t_offset;
GLOBAL(tc) = &tcm->token_caches[tc_offset];
return SUCCESS;
}
/* prepare a new token cache */
int tcm_new(TokenCacheManager *tcm, int block_size)
{
TLS_VARS;
if (tcm->initialized >= (1<<TC_BITS)) {
return FAILURE;
}
tcm->initialized++;
if (tcm->initialized >= tcm->max) {
tcm->token_caches = (TokenCache *) erealloc(tcm->token_caches, (tcm->max + TOKEN_CACHES_BLOCK_SIZE) * sizeof(TokenCache));
if (!tcm->token_caches) {
return FAILURE;
}
tcm->max += TOKEN_CACHES_BLOCK_SIZE;
}
tcm->active = tcm->initialized - 1;
if (tc_init(&tcm->token_caches[tcm->active],block_size) == FAILURE) {
return FAILURE;
}
GLOBAL(tc) = &tcm->token_caches[tcm->active];
return SUCCESS;
}
void
resetEnergyBattle (void)
{
STARSHIP *StarShipPtr;
COUNT delta;
CONTEXT OldContext;
if (!(GLOBAL (CurrentActivity) & IN_BATTLE) ||
(inHQSpace ()))
return;
StarShipPtr = findPlayerShip (RPG_PLAYER_NUM);
if (StarShipPtr == NULL || StarShipPtr->RaceDescPtr == NULL)
return;
delta = StarShipPtr->RaceDescPtr->ship_info.max_energy -
StarShipPtr->RaceDescPtr->ship_info.energy_level;
OldContext = SetContext (StatusContext);
DeltaEnergy (StarShipPtr->hShip, delta);
SetContext (OldContext);
}
static void
flame_napalm_preprocess (ELEMENT *ElementPtr)
{
ZeroVelocityComponents (&ElementPtr->velocity);
if (ElementPtr->state_flags & NONSOLID)
{
ElementPtr->state_flags &= ~NONSOLID;
ElementPtr->state_flags |= APPEARING;
SetPrimType (&(GLOBAL (DisplayArray))[ElementPtr->PrimIndex],
STAMP_PRIM);
InitIntersectStartPoint (ElementPtr);
InitIntersectEndPoint (ElementPtr);
InitIntersectFrame (ElementPtr);
}
/* turn_wait is abused here to store the speed of the decay animation */
else if (ElementPtr->turn_wait > 0)
--ElementPtr->turn_wait;
else
{
if (ElementPtr->life_span <= NUM_NAPALM_FADES * (NAPALM_DECAY_RATE + 1)
|| GetFrameIndex (
ElementPtr->current.image.frame
) != NUM_NAPALM_FADES)
ElementPtr->next.image.frame =
DecFrameIndex (ElementPtr->current.image.frame);
else if (ElementPtr->life_span > NUM_NAPALM_FADES * (NAPALM_DECAY_RATE + 1))
ElementPtr->next.image.frame = SetAbsFrameIndex (
ElementPtr->current.image.frame,
GetFrameCount (ElementPtr->current.image.frame) - 1
);
/* turn_wait is abused here to store the speed of the decay
* animation. */
ElementPtr->turn_wait = NAPALM_DECAY_RATE;
ElementPtr->state_flags |= CHANGING;
}
}
COUNT
calculateMineralValue (const SOLARSYS_STATE *system, const PLANET_DESC *world)
{
COUNT result;
COUNT numDeposits;
COUNT i;
assert (system->pOrbitalDesc == world);
numDeposits = callGenerateForScanType (system, world, GENERATE_ALL,
MINERAL_SCAN, NULL);
result = 0;
for (i = 0; i < numDeposits; i++)
{
NODE_INFO info;
callGenerateForScanType (system, world, i, MINERAL_SCAN, &info);
result += HIBYTE (info.density) *
GLOBAL (ElementWorth[ElementCategory (info.type)]);
}
return result;
}
static void
ilwrath_intelligence (ELEMENT *ShipPtr, EVALUATE_DESC *ObjectsOfConcern,
COUNT ConcernCounter)
{
EVALUATE_DESC *lpEvalDesc;
STARSHIP *StarShipPtr;
lpEvalDesc = &ObjectsOfConcern[ENEMY_SHIP_INDEX];
lpEvalDesc->MoveState = PURSUE;
if (lpEvalDesc->ObjectPtr && lpEvalDesc->which_turn <= 10)
/* don't want to dodge when you could be flaming */
ObjectsOfConcern[ENEMY_WEAPON_INDEX].ObjectPtr = 0;
ship_intelligence (ShipPtr, ObjectsOfConcern, ConcernCounter);
GetElementStarShip (ShipPtr, &StarShipPtr);
if (lpEvalDesc->ObjectPtr
&& (lpEvalDesc->which_turn <= 6
|| (lpEvalDesc->which_turn <= 10
&& ObjectsOfConcern[ENEMY_WEAPON_INDEX].which_turn <= 10)))
{
StarShipPtr->ship_input_state &= ~SPECIAL;
if (OBJECT_CLOAKED (ShipPtr))
{
StarShipPtr->ship_input_state &= ~LEFT | RIGHT;
StarShipPtr->ship_input_state |= THRUST;
}
StarShipPtr->ship_input_state |= WEAPON;
}
else if (StarShipPtr->special_counter == 0
&& (LOBYTE (GLOBAL (CurrentActivity)) != IN_ENCOUNTER
|| !GET_GAME_STATE (PROBE_ILWRATH_ENCOUNTER)))
{
StarShipPtr->ship_input_state &= ~SPECIAL;
if (!OBJECT_CLOAKED (ShipPtr)
&& !(StarShipPtr->ship_input_state & WEAPON))
StarShipPtr->ship_input_state |= SPECIAL;
}
}
void perform_gc(){
int i;
obj * scur;
string * s;
table * t;
for (scur = stack ; scur < sp ; scur++)
explore_heap (*scur);
for (i = 0; i < NB_GLOBALS ; i++)
explore_heap (GLOBAL(i));
for (i = 0 ; i < NB_QUOTE_CONSTANTS ; i++)
explore_heap (QUOTE_CONSTANTS[i]);
for (i = 0 ; i < HEAP_SIZE ; i++){
switch (freel.mark[i]){
case UNMARKED:
if (ATBL(freel.heap[i])){
t = (table *) (freel.heap[i]);
free(t->keys);
free(t->values);
}
else if (ASTR(freel.heap[i])){
s = (string *) (freel.heap[i]);
free (s->cpts);
}
free((void *)(freel.heap[i]));
freel.mark[i] = FREE;
freel.free[freel.nbfree++] = i;
break;
case MARKED:
freel.mark[i] = UNMARKED;
break;
}
}
}
// Pre: caller holds the graphics lock.
void
MeleeGameOver (void)
{
COUNT playerI;
DWORD TimeOut;
BOOLEAN PressState, ButtonState;
// Show the battle result.
for (playerI = 0; playerI < NUM_PLAYERS; playerI++)
DrawPickMeleeFrame (playerI);
#ifdef NETPLAY
negotiateReadyConnections(true, NetState_inSetup);
#endif
TimeOut = GetTimeCounter () + (ONE_SECOND * 4);
PressState = PulsedInputState.menu[KEY_MENU_SELECT] ||
PulsedInputState.menu[KEY_MENU_CANCEL];
do
{
UpdateInputState ();
ButtonState = PulsedInputState.menu[KEY_MENU_SELECT] ||
PulsedInputState.menu[KEY_MENU_CANCEL];
if (PressState)
{
PressState = ButtonState;
ButtonState = FALSE;
}
Async_process ();
TaskSwitch ();
} while (!(GLOBAL (CurrentActivity) & CHECK_ABORT) && (!ButtonState
&& (!(PlayerControl[0] & PlayerControl[1] & PSYTRON_CONTROL)
|| GetTimeCounter () < TimeOut)));
}
static int showHighscore()
{
int key = getInputRaw(); //throw away pending keypress
char nick[20];
uint32_t score = 0;
highscore_set(points,GLOBAL(nickname));
score = highscore_get(nick);
lcdClear();
setTextColor(0xff,0x00);
DoString(0,RESY/2-33, " Your Score");
// Display own score in green color, if it's higher than high score, else red
if (points > score) {
setTextColor(0xff,0b00011100);
} else {
setTextColor(0xff,0b11100000);
}
DoString(RESX/2-4, RESY/2-25, IntToStr(points,6,0));
setTextColor(0xff,0x00);
DoString(0,RESY/2-10, " Highscore");
setTextColor(0xff,0b11100000);
DoString(RESX/2-4, RESY/2-2, IntToStr(score,6,0));
setTextColor(0xff,0x00);
DoString(0, RESY/2+18, " UP to play ");
DoString(0, RESY/2+26, "DOWN to quit ");
lcdDisplay();
while(1) {
key = getInputRaw();
if (key&BTN_DOWN) {
return 1;
} else if (key&BTN_UP) {
return 0;
}
}
}
// When gas expires, display animation of the gas dissolving.
static void
gas_death (ELEMENT *ElementPtr)
{
STARSHIP *StarShipPtr;
GetElementStarShip (ElementPtr, &StarShipPtr);
if (StarShipPtr->hShip)
{
HELEMENT hDissolve;
ELEMENT *ShipPtr;
LockElement (StarShipPtr->hShip, &ShipPtr);
if ((hDissolve = AllocElement ()))
{
ELEMENT *DissolvePtr;
LockElement (hDissolve, &DissolvePtr);
DissolvePtr->playerNr = ElementPtr->playerNr;
DissolvePtr->state_flags = FINITE_LIFE | NONSOLID | IGNORE_SIMILAR | APPEARING;
DissolvePtr->turn_wait = 0;
DissolvePtr->life_span = NUM_DISSOLVE_FRAMES;
DissolvePtr->current.location.x = ElementPtr->current.location.x;
DissolvePtr->current.location.y = ElementPtr->current.location.y;
DissolvePtr->current.image.farray = StarShipPtr->RaceDescPtr->ship_data.special;
DissolvePtr->current.image.frame = SetAbsFrameIndex (ElementPtr->current.image.frame, LAST_SHOCKWAVE_INDEX);
DissolvePtr->preprocess_func = gas_death_animation;
SetElementStarShip (DissolvePtr, StarShipPtr);
SetPrimType (&(GLOBAL (DisplayArray))[DissolvePtr->PrimIndex], STAMP_PRIM);
UnlockElement (hDissolve);
PutElement (hDissolve);
}
UnlockElement (StarShipPtr->hShip);
}
}
static void
GrantTech (TechId_t techId)
{
const TechData* techData = GetTechData (techId);
if (!techData)
return;
switch (techData->type)
{
case TECH_TYPE_MODULE:
GLOBAL (ModuleCost[techData->subtype]) = techData->info / MODULE_COST_SCALE;
return;
case TECH_TYPE_LANDER_SHIELD:
{
COUNT state = GET_GAME_STATE (LANDER_SHIELDS) | (1 << techData->subtype);
SET_GAME_STATE (LANDER_SHIELDS, state);
return;
}
case TECH_TYPE_STATE:
GrantStateTech (techData->subtype, techData->info);
return;
}
}
