// ////////////////////////////////////////////////////////////////////////////
// give technologies.
static void giftResearch(uint8_t from, uint8_t to, bool send)
{
int i;
uint32_t dummy = 0;
if (send)
{
uint8_t giftType = RESEARCH_GIFT;
NETbeginEncode(NETgameQueue(selectedPlayer), GAME_GIFT);
NETuint8_t(&giftType);
NETuint8_t(&from);
NETuint8_t(&to);
NETuint32_t(&dummy);
NETend();
}
else if (alliancesCanGiveResearchAndRadar(game.alliance))
{
if (to == selectedPlayer)
{
CONPRINTF(ConsoleString, (ConsoleString, _("%s Gives You Technology Documents"), getPlayerName(from)));
}
// For each topic
for (i = 0; i < asResearch.size(); i++)
{
// If they have it and we don't research it
if (IsResearchCompleted(&asPlayerResList[from][i])
&& !IsResearchCompleted(&asPlayerResList[to][i]))
{
MakeResearchCompleted(&asPlayerResList[to][i]);
researchResult(i, to, false, NULL, true);
}
}
}
}
// recv a research topic that is now complete.
static bool recvResearch(NETQUEUE queue)
{
uint8_t player;
uint32_t index;
int i;
PLAYER_RESEARCH *pPlayerRes;
NETbeginDecode(queue, GAME_DEBUG_FINISH_RESEARCH);
NETuint8_t(&player);
NETuint32_t(&index);
NETend();
if (!getDebugMappingStatus() && bMultiPlayer)
{
debug(LOG_WARNING, "Failed to finish research for player %u.", NetPlay.players[queue.index].position);
return false;
}
syncDebug("player%d, index%u", player, index);
if (player >= MAX_PLAYERS || index >= asResearch.size())
{
debug(LOG_ERROR, "Bad GAME_DEBUG_FINISH_RESEARCH received, player is %d, index is %u", (int)player, index);
return false;
}
pPlayerRes = &asPlayerResList[player][index];
syncDebug("research status = %d", pPlayerRes->ResearchStatus & RESBITS);
if (!IsResearchCompleted(pPlayerRes))
{
MakeResearchCompleted(pPlayerRes);
researchResult(index, player, false, NULL, true);
}
// Update allies research accordingly
if (game.type == SKIRMISH)
{
for (i = 0; i < MAX_PLAYERS; i++)
{
if (alliances[i][player] == ALLIANCE_FORMED)
{
pPlayerRes = &asPlayerResList[i][index];
if (!IsResearchCompleted(pPlayerRes))
{
// Do the research for that player
MakeResearchCompleted(pPlayerRes);
researchResult(index, i, false, NULL, true);
}
}
}
}
return true;
}
// ///////////////////////////////////////////////////////////////
bool pickupArtefact(int toPlayer, int fromPlayer)
{
if (fromPlayer < MAX_PLAYERS && bMultiPlayer)
{
for (int topic = asResearch.size() - 1; topic >= 0; topic--)
{
if (IsResearchCompleted(&asPlayerResList[fromPlayer][topic])
&& !IsResearchPossible(&asPlayerResList[toPlayer][topic]))
{
// Make sure the topic can be researched
if (asResearch[topic].researchPower && asResearch[topic].researchPoints)
{
MakeResearchPossible(&asPlayerResList[toPlayer][topic]);
if (toPlayer == selectedPlayer)
{
CONPRINTF(ConsoleString,(ConsoleString,_("You Discover Blueprints For %s"), getName(asResearch[topic].pName)));
}
break;
}
// Invalid topic
else
{
debug(LOG_WARNING, "%s is a invalid research topic?", getName(asResearch[topic].pName));
}
}
}
audio_QueueTrack(ID_SOUND_ARTIFACT_RECOVERED);
return true;
}
return false;
}
// ///////////////////////////////////////////////////////////////
void giftArtifact(UDWORD owner, UDWORD x, UDWORD y)
{
PLAYER_RESEARCH *pR = asPlayerResList[selectedPlayer];
if (owner < MAX_PLAYERS)
{
PLAYER_RESEARCH *pO = asPlayerResList[owner];
int topic;
for (topic = numResearch - 1; topic >= 0; topic--)
{
if (IsResearchCompleted(&pO[topic])
&& !IsResearchPossible(&pR[topic]))
{
// Make sure the topic can be researched
if (asResearch[topic].researchPower
&& asResearch[topic].researchPoints)
{
MakeResearchPossible(&pR[topic]);
CONPRINTF(ConsoleString,(ConsoleString,_("You Discover Blueprints For %s"),
getName(asResearch[topic].pName)));
break;
}
// Invalid topic
else
{
debug(LOG_WARNING, "%s is a invalid research topic?", getName(asResearch[topic].pName));
}
}
}
}
}
// ////////////////////////////////////////////////////////////////////////////
// give technologies.
static void giftResearch(uint8_t from, uint8_t to, BOOL send)
{
PLAYER_RESEARCH *pR, *pRto;
int i;
uint32_t dummy = 0;
if (send)
{
uint8_t giftType = RESEARCH_GIFT;
NETbeginEncode(NETgameQueue(selectedPlayer), GAME_GIFT);
NETuint8_t(&giftType);
NETuint8_t(&from);
NETuint8_t(&to);
NETuint32_t(&dummy);
NETend();
}
else
{
if (to == selectedPlayer)
{
CONPRINTF(ConsoleString, (ConsoleString, _("%s Gives You Technology Documents"), getPlayerName(from)));
}
pR = asPlayerResList[from];
pRto = asPlayerResList[to];
// For each topic
for (i = 0; i < numResearch; i++)
{
// If they have it and we don't research it
if (IsResearchCompleted(&pR[i])
&& !IsResearchCompleted(&pRto[i]))
{
MakeResearchCompleted(&pRto[i]);
researchResult(i, to, false, NULL, true);
}
}
}
}
bool skTopicAvail(UWORD inc, UDWORD player)
{
UDWORD incPR, incS;
bool bPRFound, bStructFound;
//if the topic is possible and has not already been researched - add to list
if ((IsResearchPossible(&asPlayerResList[player][inc])))
{
if (!IsResearchCompleted(&asPlayerResList[player][inc])
&& !IsResearchStartedPending(&asPlayerResList[player][inc]))
{
return true;
}
}
// make sure that the research is not completed or started by another researchfac
if (!IsResearchCompleted(&asPlayerResList[player][inc])
&& !IsResearchStartedPending(&asPlayerResList[player][inc]))
{
// Research is not completed ... also it has not been started by another researchfac
//if there aren't any PR's - go to next topic
if (asResearch[inc].pPRList.empty())
{
return false;
}
//check for pre-requisites
bPRFound = true;
for (incPR = 0; incPR < asResearch[inc].pPRList.size(); incPR++)
{
if (IsResearchCompleted(&asPlayerResList[player][asResearch[inc].pPRList[incPR]]) == 0)
{
//if haven't pre-requisite - quit checking rest
bPRFound = false;
break;
}
}
if (!bPRFound)
{
//if haven't pre-requisites, skip the rest of the checks
return false;
}
//check for structure effects
bStructFound = true;
for (incS = 0; incS < asResearch[inc].pStructList.size(); incS++)
{
//if (!checkStructureStatus(asStructureStats + asResearch[inc].
// pStructList[incS], playerID, SS_BUILT))
if (!checkSpecificStructExists(asResearch[inc].pStructList[incS],
player))
{
//if not built, quit checking
bStructFound = false;
break;
}
}
if (!bStructFound)
{
//if haven't all structs built, skip to next topic
return false;
}
return true;
}
return false;
}
bool researchAvailable(int inc, int playerID, QUEUE_MODE mode)
{
// Decide whether to use IsResearchCancelledPending/IsResearchStartedPending or IsResearchCancelled/IsResearchStarted.
bool (*IsResearchCancelledFunc)(PLAYER_RESEARCH const *) = IsResearchCancelledPending;
bool (*IsResearchStartedFunc)(PLAYER_RESEARCH const *) = IsResearchStartedPending;
if (mode == ModeImmediate)
{
IsResearchCancelledFunc = IsResearchCancelled;
IsResearchStartedFunc = IsResearchStarted;
}
UDWORD incPR, incS;
bool bPRFound, bStructFound;
// if its a cancelled topic - add to list
if (IsResearchCancelledFunc(&asPlayerResList[playerID][inc]))
{
return true;
}
// if the topic is possible and has not already been researched - add to list
if ((IsResearchPossible(&asPlayerResList[playerID][inc])))
{
if (!IsResearchCompleted(&asPlayerResList[playerID][inc])
&& !IsResearchStartedFunc(&asPlayerResList[playerID][inc]))
{
return true;
}
}
// if single player mode and key topic, then ignore cos can't do it!
if (!bMultiPlayer && asResearch[inc].keyTopic)
{
return false;
}
bool researchStarted = IsResearchStartedFunc(&asPlayerResList[playerID][inc]);
if (researchStarted)
{
STRUCTURE *psBuilding = findResearchingFacilityByResearchIndex(playerID, inc); // May fail to find the structure here, if the research is merely pending, not actually started.
if (psBuilding != nullptr && psBuilding->status == SS_BEING_BUILT)
{
researchStarted = false; // Although research is started, the facility is currently being upgraded or demolished, so we want to be able to research this elsewhere.
}
}
// make sure that the research is not completed or started by another researchfac
if (!IsResearchCompleted(&asPlayerResList[playerID][inc]) && !researchStarted)
{
// Research is not completed ... also it has not been started by another researchfac
// if there aren't any PR's - go to next topic
if (asResearch[inc].pPRList.empty())
{
return false;
}
// check for pre-requisites
bPRFound = true;
for (incPR = 0; incPR < asResearch[inc].pPRList.size(); incPR++)
{
if (IsResearchCompleted(&(asPlayerResList[playerID][asResearch[inc].pPRList[incPR]])) == 0)
{
// if haven't pre-requisite - quit checking rest
bPRFound = false;
break;
}
}
if (!bPRFound)
{
// if haven't pre-requisites, skip the rest of the checks
return false;
}
// check for structure effects
bStructFound = true;
for (incS = 0; incS < asResearch[inc].pStructList.size(); incS++)
{
if (!checkSpecificStructExists(asResearch[inc].pStructList[incS], playerID))
{
//if not built, quit checking
bStructFound = false;
break;
}
}
if (!bStructFound)
{
// if haven't all structs built, skip to next topic
return false;
}
return true;
}
return false;
}
bool recvResearchStatus(NETQUEUE queue)
{
STRUCTURE *psBuilding;
PLAYER_RESEARCH *pPlayerRes;
RESEARCH_FACILITY *psResFacilty;
RESEARCH *pResearch;
uint8_t player;
bool bStart;
uint32_t index, structRef;
NETbeginDecode(queue, GAME_RESEARCHSTATUS);
NETuint8_t(&player);
NETbool(&bStart);
NETuint32_t(&structRef);
NETuint32_t(&index);
NETend();
syncDebug("player%d, bStart%d, structRef%u, index%u", player, bStart, structRef, index);
if (player >= MAX_PLAYERS || index >= asResearch.size())
{
debug(LOG_ERROR, "Bad GAME_RESEARCHSTATUS received, player is %d, index is %u", (int)player, index);
return false;
}
if (!canGiveOrdersFor(queue.index, player))
{
debug(LOG_WARNING, "Droid order for wrong player.");
syncDebug("Wrong player.");
return false;
}
int prevResearchState = 0;
if (aiCheckAlliances(selectedPlayer, player))
{
prevResearchState = intGetResearchState();
}
pPlayerRes = &asPlayerResList[player][index];
// psBuilding may be null if finishing
if (bStart) // Starting research
{
psBuilding = IdToStruct(structRef, player);
// Set that facility to research
if (psBuilding && psBuilding->pFunctionality)
{
psResFacilty = (RESEARCH_FACILITY *) psBuilding->pFunctionality;
popStatusPending(*psResFacilty); // Research is no longer pending, as it's actually starting now.
if (psResFacilty->psSubject)
{
cancelResearch(psBuilding, ModeImmediate);
}
// Set the subject up
pResearch = &asResearch[index];
psResFacilty->psSubject = pResearch;
// Start the research
MakeResearchStarted(pPlayerRes);
psResFacilty->timeStartHold = 0;
}
}
// Finished/cancelled research
else
{
// If they completed the research, we're done
if (IsResearchCompleted(pPlayerRes))
{
return true;
}
// If they did not say what facility it was, look it up orselves
if (!structRef)
{
// Go through the structs to find the one doing this topic
for (psBuilding = apsStructLists[player]; psBuilding; psBuilding = psBuilding->psNext)
{
if (psBuilding->pStructureType->type == REF_RESEARCH
&& psBuilding->status == SS_BUILT
&& ((RESEARCH_FACILITY *) psBuilding->pFunctionality)->psSubject
&& ((RESEARCH_FACILITY *) psBuilding->pFunctionality)->psSubject->ref - REF_RESEARCH_START == index)
{
break;
}
}
}
else
{
psBuilding = IdToStruct(structRef, player);
}
// Stop the facility doing any research
if (psBuilding)
{
cancelResearch(psBuilding, ModeImmediate);
popStatusPending(*(RESEARCH_FACILITY *)psBuilding->pFunctionality); // Research cancellation is no longer pending, as it's actually cancelling now.
}
}
if (aiCheckAlliances(selectedPlayer, player))
{
intAlliedResearchChanged();
intNotifyResearchButton(prevResearchState);
}
return true;
}
BOOL skTopicAvail(UWORD inc, UDWORD player)
{
UDWORD incPR, incS;
PLAYER_RESEARCH *pPlayerRes = asPlayerResList[player];
BOOL bPRFound, bStructFound;
//if the topic is possible and has not already been researched - add to list
if ((IsResearchPossible(&pPlayerRes[inc])))
{
if ((IsResearchCompleted(&pPlayerRes[inc])==FALSE) && (IsResearchStarted(&pPlayerRes[inc])==FALSE))
{
return TRUE;
}
}
// make sure that the research is not completed or started by another researchfac
if ((IsResearchCompleted(&pPlayerRes[inc])==FALSE) && (IsResearchStarted(&pPlayerRes[inc])==FALSE))
{
// Research is not completed ... also it has not been started by another researchfac
//if there aren't any PR's - go to next topic
if (!asResearch[inc].numPRRequired)
{
return FALSE;
}
//check for pre-requisites
bPRFound = TRUE;
for (incPR = 0; incPR < asResearch[inc].numPRRequired; incPR++)
{
if (IsResearchCompleted(&(pPlayerRes[asResearch[inc].pPRList[incPR]]))==0)
{
//if haven't pre-requisite - quit checking rest
bPRFound = FALSE;
break;
}
}
if (!bPRFound)
{
//if haven't pre-requisites, skip the rest of the checks
return FALSE;
}
//check for structure effects
bStructFound = TRUE;
for (incS = 0; incS < asResearch[inc].numStructures; incS++)
{
//if (!checkStructureStatus(asStructureStats + asResearch[inc].
// pStructList[incS], playerID, SS_BUILT))
if (!checkSpecificStructExists(asResearch[inc].pStructList[incS],
player))
{
//if not built, quit checking
bStructFound = FALSE;
break;
}
}
if (!bStructFound)
{
//if haven't all structs built, skip to next topic
return FALSE;
}
return TRUE;
}
return FALSE;
}
