自学教程：C++ CArrayGet函数代码示例

int CanCompleteMission(struct MissionOptions *options){	int i;	// Death is the only escape from dogfights and quick play	if (gCampaign.Entry.Mode == CAMPAIGN_MODE_DOGFIGHT)	{		return GetNumPlayersAlive() <= 1;	}	else if (gCampaign.Entry.Mode == CAMPAIGN_MODE_QUICK_PLAY)	{		return GetNumPlayersAlive() == 0;	}	// Check all objective counts are enough	for (i = 0; i < (int)options->Objectives.size; i++)	{		struct Objective *o = CArrayGet(&options->Objectives, i);		MissionObjective *mobj =			CArrayGet(&options->missionData->Objectives, i);		if (o->done < mobj->Required)		{			return 0;		}	}	return 1;}

void HUDNumPopupsDrawObjective(	const HUDNumPopups *popups, const int idx, const Vec2i pos){	const Objective *o = CArrayGet(&gMission.missionData->Objectives, idx);	const HUDNumPopup *p = CArrayGet(&popups->objective, idx);	DrawNumUpdate(p, "%d", o->done, pos, 0);}

static HitType GetHitType(	const TTileItem *ti, const TMobileObject *bullet, int *targetUID){	*targetUID = -1;	HitType ht = HIT_NONE;	switch (ti->kind)	{	case KIND_CHARACTER:		ht = HIT_FLESH;		*targetUID = ((const TActor *)CArrayGet(&gActors, ti->id))->uid;		break;	case KIND_OBJECT:		ht = HIT_OBJECT;		*targetUID = ((const TObject *)CArrayGet(&gObjs, ti->id))->uid;		break;	default:		CASSERT(false, "cannot damage target kind");		break;	}	if (bullet->tileItem.SoundLock > 0 ||		!HasHitSound(		bullet->bulletClass->Power, bullet->flags, bullet->PlayerUID,		ti->kind, *targetUID, bullet->bulletClass->Special, true))	{		ht = HIT_NONE;	}	return ht;}

static void DrawObjectiveHighlight(	TTileItem *ti, Tile *tile, DrawBuffer *b, Vec2i offset){	color_t color;	if (ti->flags & TILEITEM_OBJECTIVE)	{		// Objective		const int objective = ObjectiveFromTileItem(ti->flags);		const Objective *o =			CArrayGet(&gMission.missionData->Objectives, objective);		if (o->Flags & OBJECTIVE_HIDDEN)		{			return;		}		if (!(o->Flags & OBJECTIVE_POSKNOWN) &&			(tile->flags & MAPTILE_OUT_OF_SIGHT))		{			return;		}		color = o->color;	}	else if (ti->kind == KIND_PICKUP)	{		// Gun pickup		const Pickup *p = CArrayGet(&gPickups, ti->id);		if (!PickupIsManual(p))		{			return;		}		color = colorDarker;	}	else	{		return;	}		const Vec2i pos = Vec2iNew(		ti->x - b->xTop + offset.x, ti->y - b->yTop + offset.y);	const int pulsePeriod = ConfigGetInt(&gConfig, "Game.FPS");	int alphaUnscaled =		(gMission.time % pulsePeriod) * 255 / (pulsePeriod / 2);	if (alphaUnscaled > 255)	{		alphaUnscaled = 255 * 2 - alphaUnscaled;	}	color.a = (Uint8)alphaUnscaled;	if (ti->getPicFunc != NULL)	{		Vec2i picOffset;		const Pic *pic = ti->getPicFunc(ti->id, &picOffset);		BlitPicHighlight(			&gGraphicsDevice, pic, Vec2iAdd(pos, picOffset), color);	}	else if (ti->kind == KIND_CHARACTER)	{		TActor *a = CArrayGet(&gActors, ti->id);		ActorPics pics = GetCharacterPicsFromActor(a);		DrawActorHighlight(&pics, pos, color);	}}

static void DrawObjectiveInfo(	const struct MissionOptions *mo, const int idx, const Vec2i pos){	const MissionObjective *mobj =		CArrayGet(&mo->missionData->Objectives, idx);	const ObjectiveDef *o = CArrayGet(&mo->Objectives, idx);	const CharacterStore *store = &gCampaign.Setting.characters;	switch (mobj->Type)	{	case OBJECTIVE_KILL:		{			const Character *cd = CArrayGet(				&store->OtherChars, CharacterStoreGetSpecialId(store, 0));			const int i = cd->looks.face;			TOffsetPic pic;			pic.picIndex = cHeadPic[i][DIRECTION_DOWN][STATE_IDLE];			pic.dx = cHeadOffset[i][DIRECTION_DOWN].dx;			pic.dy = cHeadOffset[i][DIRECTION_DOWN].dy;			DrawTTPic(				pos.x + pic.dx, pos.y + pic.dy,				PicManagerGetOldPic(&gPicManager, pic.picIndex), &cd->table);		}		break;	case OBJECTIVE_RESCUE:		{			const Character *cd = CArrayGet(				&store->OtherChars, CharacterStoreGetPrisonerId(store, 0));			const int i = cd->looks.face;			TOffsetPic pic;			pic.picIndex = cHeadPic[i][DIRECTION_DOWN][STATE_IDLE];			pic.dx = cHeadOffset[i][DIRECTION_DOWN].dx;			pic.dy = cHeadOffset[i][DIRECTION_DOWN].dy;			DrawTTPic(				pos.x + pic.dx, pos.y + pic.dy,				PicManagerGetOldPic(&gPicManager, pic.picIndex), &cd->table);		}		break;	case OBJECTIVE_COLLECT:		{			const Pic *p = o->pickupClass->Pic;			Blit(&gGraphicsDevice, p, Vec2iAdd(pos, p->offset));		}		break;	case OBJECTIVE_DESTROY:		{			Vec2i picOffset;			const Pic *p =				MapObjectGetPic(IntMapObject(mobj->Index), &picOffset, false);			Blit(&gGraphicsDevice, p, Vec2iAdd(pos, picOffset));		}		break;	case OBJECTIVE_INVESTIGATE:		// Don't draw		return;	default:		CASSERT(false, "Unknown objective type");		return;	}}

void UIObjectDraw(	UIObject *o, GraphicsDevice *g, Vec2i pos, Vec2i mouse, CArray *drawObjs){	// Draw this UIObject and its children in BFS order	// Maintain a queue of UIObjects to draw	if (drawObjs->elemSize == 0)	{		CArrayInit(drawObjs, sizeof(UIObjectDrawContext));		UIObjectDrawContext c;		c.obj = o;		c.pos = pos;		CArrayPushBack(drawObjs, &c);		for (int i = 0; i < (int)drawObjs->size; i++)		{			UIObjectDrawContext *cPtr = CArrayGet(drawObjs, i);			UIObjectDrawAndAddChildren(				cPtr->obj, g, cPtr->pos, mouse, drawObjs);		}	}	else	{		for (int i = 0; i < (int)drawObjs->size; i++)		{			UIObjectDrawContext *cPtr = CArrayGet(drawObjs, i);			UIObjectDrawAndAddChildren(				cPtr->obj, g, cPtr->pos, mouse, NULL);		}	}}

TTileItem *ThingIdGetTileItem(ThingId *tid){	TTileItem *ti = NULL;	switch (tid->Kind)	{	case KIND_CHARACTER:		ti = &((TActor *)CArrayGet(&gActors, tid->Id))->tileItem;		break;	case KIND_PARTICLE:		ti = &((Particle *)CArrayGet(&gParticles, tid->Id))->tileItem;		break;	case KIND_MOBILEOBJECT:		ti = &((TMobileObject *)CArrayGet(			&gMobObjs, tid->Id))->tileItem;		break;	case KIND_OBJECT:		ti = &((TObject *)CArrayGet(&gObjs, tid->Id))->tileItem;		break;	case KIND_PICKUP:		ti = &((Pickup *)CArrayGet(&gPickups, tid->Id))->tileItem;		break;	default:		CASSERT(false, "unknown tile item to get");		break;	}	return ti;}

static void SetupBadguysForMission(Mission *mission){	int i;	CharacterStore *s = &gCampaign.Setting.characters;	CharacterStoreResetOthers(s);	if (s->OtherChars.size == 0)	{		return;	}	for (i = 0; i < (int)mission->Objectives.size; i++)	{		MissionObjective *mobj = CArrayGet(&mission->Objectives, i);		if (mobj->Type == OBJECTIVE_RESCUE)		{			CharacterStoreAddPrisoner(s, mobj->Index);			break;	// TODO: multiple prisoners		}	}	for (i = 0; i < (int)mission->Enemies.size; i++)	{		CharacterStoreAddBaddie(s, *(int *)CArrayGet(&mission->Enemies, i));	}	for (i = 0; i < (int)mission->SpecialChars.size; i++)	{		CharacterStoreAddSpecial(			s, *(int *)CArrayGet(&mission->SpecialChars, i));	}}

bool PlayerSelection(void){	PlayerSelectionData data;	memset(&data, 0, sizeof data);	data.IsOK = true;	GetDataFilePath(data.prefixes, "data/prefixes.txt");	GetDataFilePath(data.suffixes, "data/suffixes.txt");	GetDataFilePath(data.suffixnames, "data/suffixnames.txt");	NameGenInit(&data.g, data.prefixes, data.suffixes, data.suffixnames);	// Create selection menus for each local player	for (int i = 0, idx = 0; i < (int)gPlayerDatas.size; i++, idx++)	{		PlayerData *p = CArrayGet(&gPlayerDatas, i);		if (!p->IsLocal)		{			idx--;			continue;		}		PlayerSelectMenusCreate(			&data.menus[idx], GetNumPlayers(false, false, true), idx, i,			&gEventHandlers, &gGraphicsDevice, &data.g);	}	if (!gCampaign.IsClient)	{		NetServerOpen(&gNetServer);	}	GameLoopData gData = GameLoopDataNew(		&data, PlayerSelectionUpdate,		&data, PlayerSelectionDraw);	GameLoop(&gData);	if (data.IsOK)	{		for (int i = 0, idx = 0; i < (int)gPlayerDatas.size; i++, idx++)		{			PlayerData *p = CArrayGet(&gPlayerDatas, i);			if (!p->IsLocal)			{				idx--;				continue;			}			// For any player slots not picked, turn them into AIs			if (p->inputDevice == INPUT_DEVICE_UNSET)			{				PlayerSetInputDevice(p, INPUT_DEVICE_AI, 0);			}		}	}	for (int i = 0; i < GetNumPlayers(false, false, true); i++)	{		MenuSystemTerminate(&data.menus[i].ms);	}	NameGenTerminate(&data.g);	return data.IsOK;}

static void DrawObjectiveHighlight(	TTileItem *ti, Tile *tile, DrawBuffer *b, Vec2i offset){	if (!(ti->flags & TILEITEM_OBJECTIVE))	{		return;	}	int objective = ObjectiveFromTileItem(ti->flags);	MissionObjective *mo =		CArrayGet(&gMission.missionData->Objectives, objective);	if (mo->Flags & OBJECTIVE_HIDDEN)	{		return;	}	if (!(mo->Flags & OBJECTIVE_POSKNOWN) &&		(tile->flags & MAPTILE_OUT_OF_SIGHT))	{		return;	}	Vec2i pos = Vec2iNew(		ti->x - b->xTop + offset.x, ti->y - b->yTop + offset.y);	struct Objective *o =		CArrayGet(&gMission.Objectives, objective);	color_t color = o->color;	int pulsePeriod = FPS_FRAMELIMIT;	int alphaUnscaled =		(gMission.time % pulsePeriod) * 255 / (pulsePeriod / 2);	if (alphaUnscaled > 255)	{		alphaUnscaled = 255 * 2 - alphaUnscaled;	}	color.a = (Uint8)alphaUnscaled;	if (ti->getPicFunc != NULL)	{		Vec2i picOffset;		const Pic *pic = ti->getPicFunc(ti->id, &picOffset);		BlitPicHighlight(			&gGraphicsDevice, pic, Vec2iAdd(pos, picOffset), color);	}	else if (ti->getActorPicsFunc != NULL)	{		ActorPics pics = ti->getActorPicsFunc(ti->id);		// Do not highlight dead, dying or transparent characters		if (!pics.IsDead && !pics.IsTransparent)		{			for (int i = 0; i < 3; i++)			{				if (PicIsNotNone(&pics.Pics[i]))				{					BlitPicHighlight(						&gGraphicsDevice,						&pics.Pics[i], pos, color);				}			}		}	}}

static void DogfightFinalScoresDraw(void *data){	UNUSED(data);	// This will only draw once	const int w = gGraphicsDevice.cachedConfig.Res.x;	const int h = gGraphicsDevice.cachedConfig.Res.y;	GraphicsBlitBkg(&gGraphicsDevice);	// Work out who's the winner, or if it's a tie	int maxScore = 0;	int playersWithMaxScore = 0;	for (int i = 0; i < (int)gPlayerDatas.size; i++)	{		const PlayerData *p = CArrayGet(&gPlayerDatas, i);		if (p->RoundsWon > maxScore)		{			maxScore = p->RoundsWon;			playersWithMaxScore = 1;		}		else if (p->RoundsWon == maxScore)		{			playersWithMaxScore++;		}	}	const bool isTie = playersWithMaxScore == (int)gPlayerDatas.size;	// Draw players and their names spread evenly around the screen.	// If it's a tie, display the message in the centre,	// otherwise display the winner just below the winning player#define DRAW_TEXT	"It's a draw!"#define WINNER_TEXT	"Winner!"	CASSERT(		gPlayerDatas.size >= 2 && gPlayerDatas.size <= 4,		"Unimplemented number of players for dogfight");	for (int i = 0; i < (int)gPlayerDatas.size; i++)	{		const Vec2i pos = Vec2iNew(			w / 4 + (i & 1) * w / 2,			gPlayerDatas.size == 2 ? h / 2 : h / 4 + (i / 2) * h / 2);		const PlayerData *p = CArrayGet(&gPlayerDatas, i);		DisplayCharacterAndName(pos, &p->Char, p->name);		ShowPlayerScore(pos, p->RoundsWon);		if (!isTie && maxScore == p->RoundsWon)		{			FontStrMask(				WINNER_TEXT,				Vec2iNew(pos.x - FontStrW(WINNER_TEXT) / 2, pos.y + 30),				colorGreen);		}	}	if (isTie)	{		FontStrCenter(DRAW_TEXT);	}}

Ammo *AmmoGetById(AmmoClasses *ammo, const int id){	if (id < (int)ammo->Ammo.size)	{		return CArrayGet(&ammo->Ammo, id);	}	else	{		return CArrayGet(&ammo->CustomAmmo, id - (int)ammo->Ammo.size);	}}

static void ActionRun(Action *a, CArray *mapTriggers){	int i;	switch (a->action)	{	case ACTION_NULL:		return;	case ACTION_SOUND:		SoundPlayAt(&gSoundDevice, a->a.Sound, a->u.pos);		break;	case ACTION_SETTRIGGER:		for (i = 0; i < (int)mapTriggers->size; i++)		{			Trigger *tr = *(Trigger **)CArrayGet(mapTriggers, i);			if (tr->id == a->u.index)			{				tr->isActive = 1;				break;			}		}		break;	case ACTION_CLEARTRIGGER:		for (i = 0; i < (int)mapTriggers->size; i++)		{			Trigger *tr = *(Trigger **)CArrayGet(mapTriggers, i);			if (tr->id == a->u.index)			{				tr->isActive = 0;				break;			}		}		break;	case ACTION_CHANGETILE:		{			Tile *t= MapGetTile(&gMap, a->u.pos);			t->flags = a->a.tileFlags;			t->pic = a->tilePic;			t->picAlt = a->tilePicAlt;		}		break;	case ACTION_ACTIVATEWATCH:		ActivateWatch(a->u.index);		break;	case ACTION_DEACTIVATEWATCH:		DeactivateWatch(a->u.index);		break;	}}

MapObject *IndexMapObject(const int i){	CASSERT(		i >= 0 &&		i < (int)gMapObjects.Classes.size + (int)gMapObjects.CustomClasses.size,		"Map object index out of bounds");	if (i < (int)gMapObjects.Classes.size)	{		return CArrayGet(&gMapObjects.Classes, i);	}	return CArrayGet(&gMapObjects.CustomClasses, i - gMapObjects.Classes.size);}

bool ScreenMissionSummary(CampaignOptions *c, struct MissionOptions *m){	// Save password	MissionSave ms;	MissionSaveInit(&ms);	ms.Campaign = c->Entry;	// Don't make password for next level if there is none	int passwordIndex = m->index + 1;	if (passwordIndex == c->Entry.NumMissions)	{		passwordIndex--;	}	strcpy(ms.Password, MakePassword(passwordIndex, 0));	ms.MissionsCompleted = m->index + 1;	AutosaveAddMission(&gAutosave, &ms, ms.Campaign.BuiltinIndex);	AutosaveSave(&gAutosave, GetConfigFilePath(AUTOSAVE_FILE));	// Calculate bonus scores	// Bonuses only apply if at least one player has lived	if (AreAnySurvived())	{		int bonus = 0;		// Objective bonuses		for (int i = 0; i < (int)m->missionData->Objectives.size; i++)		{			const struct Objective *o = CArrayGet(&m->Objectives, i);			const MissionObjective *mo = CArrayGet(&m->missionData->Objectives, i);			if (o->done == mo->Count && o->done > mo->Required)			{				// Perfect				bonus += PERFECT_BONUS;			}		}		bonus += GetAccessBonus(m);		bonus += GetTimeBonus(m, NULL);		for (int i = 0; i < (int)gPlayerDatas.size; i++)		{			PlayerData *p = CArrayGet(&gPlayerDatas, i);			ApplyBonuses(p, bonus);		}	}	GameLoopWaitForAnyKeyOrButtonData wData;	GameLoopData gData = GameLoopDataNew(		&wData, GameLoopWaitForAnyKeyOrButtonFunc,		m, MissionSummaryDraw);	GameLoop(&gData);	if (wData.IsOK)	{		SoundPlay(&gSoundDevice, StrSound("mg"));	}	return wData.IsOK;}

static void DeathmatchFinalScoresDraw(void *data){	UNUSED(data);	// This will only draw once	const int w = gGraphicsDevice.cachedConfig.Res.x;	const int h = gGraphicsDevice.cachedConfig.Res.y;	GraphicsBlitBkg(&gGraphicsDevice);	// Work out the highest kills	int maxKills = 0;	for (int i = 0; i < (int)gPlayerDatas.size; i++)	{		const PlayerData *p = CArrayGet(&gPlayerDatas, i);		if (p->kills > maxKills)		{			maxKills = p->kills;		}	}	// Draw players and their names spread evenly around the screen.	CASSERT(		gPlayerDatas.size >= 2 && gPlayerDatas.size <= 4,		"Unimplemented number of players for deathmatch");#define LAST_MAN_TEXT	"Last man standing!"	for (int i = 0; i < (int)gPlayerDatas.size; i++)	{		const Vec2i pos = Vec2iNew(			w / 4 + (i & 1) * w / 2,			gPlayerDatas.size == 2 ? h / 2 : h / 4 + (i / 2) * h / 2);		const PlayerData *p = CArrayGet(&gPlayerDatas, i);		DisplayCharacterAndName(pos, &p->Char, p->name);				// Kills		char s[16];		sprintf(s, "Kills: %d", p->kills);		FontStrMask(			s, Vec2iNew(pos.x - FontStrW(s) / 2, pos.y + 20),			p->kills == maxKills ? colorGreen : colorWhite);		// Last man standing?		if (p->Lives > 0)		{			FontStrMask(				LAST_MAN_TEXT,				Vec2iNew(pos.x - FontStrW(LAST_MAN_TEXT) / 2, pos.y + 30),				colorGreen);		}	}}

GunDescription *IdGunDescription(const int i){	CASSERT(		i >= 0 &&		i < (int)gGunDescriptions.Guns.size +		(int)gGunDescriptions.CustomGuns.size,		"Gun index out of bounds");	if (i < (int)gGunDescriptions.Guns.size)	{		return CArrayGet(&gGunDescriptions.Guns, i);	}	return CArrayGet(		&gGunDescriptions.CustomGuns, i - gGunDescriptions.Guns.size);}

void PicManagerClear(CArray *pics, CArray *sprites){	for (int i = 0; i < (int)pics->size; i++)	{		NamedPic *n = CArrayGet(pics, i);		CFREE(n->name);		PicFree(&n->pic);	}	CArrayClear(pics);	for (int i = 0; i < (int)sprites->size; i++)	{		NamedSpritesFree(CArrayGet(sprites, i));	}	CArrayClear(sprites);}

void HealthPickupsUpdate(HealthPickups *h, int ticks){	// Don't spawn pickups if not allowed	if (!AreHealthPickupsAllowed(gCampaign.Entry.Mode) ||		!gConfig.Game.HealthPickups)	{		return;	}	double scalar = 1.0;	// Update time until next spawn based on:	// Damage taken (find player with lowest health)	int minHealth = ModeMaxHealth(gCampaign.Entry.Mode);	int maxHealth = minHealth;	for (int i = 0; i < (int)gPlayerDatas.size; i++)	{		const PlayerData *p = CArrayGet(&gPlayerDatas, i);		if (!IsPlayerAlive(p))		{			continue;		}		const TActor *player = CArrayGet(&gActors, p->Id);		minHealth = MIN(minHealth, player->health);	}	// Double spawn rate if near 0 health	scalar *= (minHealth + maxHealth) / (maxHealth * 2.0);	// Scale down over time	scalar *= pow(TIME_DECAY_EXPONENT, h->pickupsSpawned);	h->timeUntilNextSpawn = (int)floor(scalar * SPAWN_TIME);	// Update time	h->timer += ticks;	// Attempt to add health if time reached, and we haven't placed too many	if (h->timer >= h->timeUntilNextSpawn &&		h->map->NumExplorableTiles / MAX_TILES_PER_PICKUP + 1 > h->numPickups)	{		h->timer = 0;		if (TryPlacePickup(h))		{			h->pickupsSpawned++;			h->numPickups++;		}	}}

static void LoadGunSpawners(CArray *classes, const CArray *guns){	for (int i = 0; i < (int)guns->size; i++)	{		const GunDescription *g = CArrayGet(guns, i);		if (!g->IsRealGun)		{			continue;		}		MapObject m;		memset(&m, 0, sizeof m);		char buf[256];		sprintf(buf, "%s spawner", g->name);		CSTRDUP(m.Name, buf);		m.Normal.Pic = PicManagerGetPic(&gPicManager, "spawn_pad");		m.Normal.Offset = Vec2iNew(			-m.Normal.Pic->size.x / 2,			TILE_HEIGHT / 2 - m.Normal.Pic->size.y);		m.Size = Vec2iNew(TILE_WIDTH, TILE_HEIGHT);		m.Health = 0;		m.Type = MAP_OBJECT_TYPE_PICKUP_SPAWNER;		sprintf(buf, "gun_%s", g->name);		m.u.PickupClass = StrPickupClass(buf);		CArrayPushBack(classes, &m);	}}

static void MissionBriefingDraw(void *data){	const MissionBriefingData *mData = data;	GraphicsBlitBkg(&gGraphicsDevice);	// Mission title	FontStrOpt(mData->Title, Vec2iZero(), mData->TitleOpts);	// Display password	FontStrOpt(mData->Password, Vec2iZero(), mData->PasswordOpts);	// Display description with typewriter effect	FontStr(mData->TypewriterBuf, mData->DescriptionPos);	// Display objectives	for (int i = 0;		i < (int)mData->MissionOptions->missionData->Objectives.size;		i++)	{		const MissionObjective *o =			CArrayGet(&mData->MissionOptions->missionData->Objectives, i);		// Do not brief optional objectives		if (o->Required == 0)		{			continue;		}		const Vec2i yInc = Vec2iNew(0, i * mData->ObjectiveHeight);		FontStr(o->Description, Vec2iAdd(mData->ObjectiveDescPos, yInc));		DrawObjectiveInfo(			mData->MissionOptions, i, Vec2iAdd(mData->ObjectiveInfoPos, yInc));	}}

static json_t *SaveStaticTiles(Mission *m){	// Create a text buffer for CSV	// The buffer will contain n*5 chars (tiles, allow 5 chars each),	// and n - 1 commas, so 6n total	const int size = (int)m->u.Static.Tiles.size;	if (size == 0)	{		return json_new_string("");	}	char *bigbuf;	CCALLOC(bigbuf, size * 6);	char *pBuf = bigbuf;	CASSERT(pBuf != NULL, "memory error");	for (int i = 0; i < size; i++)	{		char buf[32];		sprintf(buf, "%d", *(unsigned short *)CArrayGet(			&m->u.Static.Tiles, i));		strcpy(pBuf, buf);		pBuf += strlen(buf);		if (i < size - 1)		{			*pBuf = ',';			pBuf++;		}	}	json_t *node = json_new_string(bigbuf);	CFREE(bigbuf);	return node;}

TBadGuy ConvertTBadGuy(Character *e){	TBadGuy b;	b.armedBodyPic = BODY_ARMED;	b.unarmedBodyPic = BODY_UNARMED;	b.facePic = e->looks.face;	b.speed = e->speed;	b.probabilityToMove = e->bot->probabilityToMove;	b.probabilityToTrack = e->bot->probabilityToTrack;	b.probabilityToShoot = e->bot->probabilityToShoot;	b.actionDelay = e->bot->actionDelay;	for (int i = 0; i < (int)gGunDescriptions.size; i++)	{		const GunDescription *g = CArrayGet(&gGunDescriptions, i);		if (strcmp(e->Gun->name, g->name) == 0)		{			b.gun = i;			break;		}	}	b.skinColor = e->looks.skin;	b.armColor = e->looks.arm;	b.bodyColor = e->looks.body;	b.legColor = e->looks.leg;	b.hairColor = e->looks.hair;	b.health = e->maxHealth;	b.flags = e->flags;	return b;}

void MenuDisplay(const MenuSystem *ms){	const menu_t *menu = ms->current;	if (menu->type == MENU_TYPE_CUSTOM)	{		menu->u.customData.displayFunc(			menu, ms->graphics, ms->pos, ms->size, menu->u.customData.data);	}	else	{		MenuDisplayItems(ms);		if (strlen(menu->u.normal.title) != 0)		{			FontOpts opts = FontOptsNew();			opts.HAlign = ALIGN_CENTER;			opts.Area = ms->size;			opts.Pad = Vec2iNew(20, 20);			FontStrOpt(menu->u.normal.title, ms->pos, opts);		}		MenuDisplaySubmenus(ms);	}	for (int i = 0; i < (int)ms->customDisplayFuncs.size; i++)	{		MenuCustomDisplayFunc *cdf = CArrayGet(&ms->customDisplayFuncs, i);		cdf->Func(NULL, ms->graphics, ms->pos, ms->size, cdf->Data);	}	if (menu->customDisplayFunc)	{		menu->customDisplayFunc(			menu, ms->graphics, ms->pos, ms->size, menu->customDisplayData);	}}

static char *MakeMapObjectTooltip(const MapObject *mo){	// Add a descriptive tooltip for the map object	char buf[512];	// Construct text representing explosion guns	char exBuf[256];	strcpy(exBuf, "");	if (mo->DestroyGuns.size > 0)	{		sprintf(exBuf, "/nExplodes: ");		for (int i = 0; i < (int)mo->DestroyGuns.size; i++)		{			if (i > 0)			{				strcat(exBuf, ", ");			}			const GunDescription **g = CArrayGet(&mo->DestroyGuns, i);			strcat(exBuf, (*g)->name);		}	}	sprintf(buf, "%s/nHealth: %d%s", mo->Name, mo->Health, exBuf);	char *tmp;	CSTRDUP(tmp, buf);	return tmp;}

void CollideAllItems(	const TTileItem *item, const Vec2i pos,	const int mask, const CollisionTeam team, const bool isPVP,	CollideItemFunc func, void *data){	const Vec2i tv = Vec2iToTile(pos);	Vec2i dv;	// Check collisions with all other items on this tile, in all 8 directions	for (dv.y = -1; dv.y <= 1; dv.y++)	{		for (dv.x = -1; dv.x <= 1; dv.x++)		{			const Vec2i dtv = Vec2iAdd(tv, dv);			if (!MapIsTileIn(&gMap, dtv))			{				continue;			}			CArray *tileThings = &MapGetTile(&gMap, dtv)->things;			for (int i = 0; i < (int)tileThings->size; i++)			{				TTileItem *ti = ThingIdGetTileItem(CArrayGet(tileThings, i));				// Don't collide if items are on the same team				if (!CollisionIsOnSameTeam(ti, team, isPVP))				{					if (item != ti &&						(ti->flags & mask) &&						ItemsCollide(item, ti, pos))					{						func(ti, data);					}				}			}		}	}}

TTileItem *GetItemOnTileInCollision(	TTileItem *item, Vec2i pos, int mask, CollisionTeam team, int isDogfight){	Vec2i tv = Vec2iToTile(pos);	Vec2i dv;	if (!MapIsTileIn(&gMap, tv))	{		return NULL;	}	// Check collisions with all other items on this tile, in all 8 directions	for (dv.y = -1; dv.y <= 1; dv.y++)	{		for (dv.x = -1; dv.x <= 1; dv.x++)		{			CArray *tileThings = &MapGetTile(&gMap, Vec2iAdd(tv, dv))->things;			for (int i = 0; i < (int)tileThings->size; i++)			{				TTileItem *ti = ThingIdGetTileItem(CArrayGet(tileThings, i));				// Don't collide if items are on the same team				if (!CollisionIsOnSameTeam(ti, team, isDogfight))				{					if (item != ti &&						(ti->flags & mask) &&						ItemsCollide(item, ti, pos))					{						return ti;					}				}			}		}	}	return NULL;}