// ////////////////////////////////////////////////////////////////////////////
// add an artifact on destruction if required.
void technologyGiveAway(const STRUCTURE *pS)
{
int i;
uint8_t count = 1;
uint32_t x, y;
FEATURE *pF = NULL;
FEATURE_TYPE type = FEAT_GEN_ARTE;
// If a fully built factory (or with modules under construction) which is our responsibility got destroyed
if (pS->pStructureType->type == REF_FACTORY && (pS->status == SS_BUILT || pS->currentBuildPts >= pS->body)
&& myResponsibility(pS->player))
{
x = map_coord(pS->pos.x);
y = map_coord(pS->pos.y);
// Pick a tile to place the artifact
if (!pickATileGen(&x, &y, LOOK_FOR_EMPTY_TILE, zonedPAT))
{
ASSERT(false, "technologyGiveAway: Unable to find a free location");
}
// Get the feature offset
for(i = 0; i < numFeatureStats && asFeatureStats[i].subType != FEAT_GEN_ARTE; i++);
// 'Build' the artifact
pF = buildFeature((asFeatureStats + i), world_coord(x), world_coord(y), false);
if (pF)
{
pF->player = pS->player;
}
NETbeginEncode(NET_ARTIFACTS, NET_ALL_PLAYERS);
{
/* Make sure that we don't have to violate the constness of pS.
* Since the nettype functions aren't const correct when sending
*/
uint8_t player = pS->player;
NETuint8_t(&count);
NETenum(&type);
NETuint32_t(&x);
NETuint32_t(&y);
NETuint32_t(&pF->id);
NETuint8_t(&player);
}
NETend();
}
return;
}
bool addOilDrum(uint8_t count)
{
syncDebug("Adding %d oil drums.", count);
int featureIndex;
for (featureIndex = 0; featureIndex < numFeatureStats && asFeatureStats[featureIndex].subType != FEAT_OIL_DRUM; ++featureIndex) {}
if (featureIndex >= numFeatureStats)
{
debug(LOG_WARNING, "No oil drum feature!");
return false; // Return value ignored.
}
for (unsigned n = 0; n < count; ++n)
{
uint32_t x, y;
for (int i = 0; i < 3; ++i) // try three times
{
// Between 10 and mapwidth - 10
x = gameRand(mapWidth - 20) + 10;
y = gameRand(mapHeight - 20) + 10;
if (pickATileGen(&x, &y, LOOK_FOR_EMPTY_TILE, zonedPAT))
{
break;
}
x = INVALID_XY;
}
if (x == INVALID_XY)
{
syncDebug("Did not find location for oil drum.");
debug(LOG_FEATURE, "Unable to find a free location.");
continue;
}
FEATURE *pF = buildFeature(&asFeatureStats[featureIndex], world_coord(x), world_coord(y), false);
if (pF)
{
pF->player = ANYPLAYER;
syncDebugFeature(pF, '+');
}
else
{
debug(LOG_ERROR, "Couldn't build oil drum?");
}
}
return true;
}
///////////////////////////////////////////////////////////////////////////////
// splatter artifact gifts randomly about.
void addMultiPlayerRandomArtifacts(uint8_t quantity, FEATURE_TYPE type)
{
int i, count;
uint32_t x, y;
uint8_t player = ANYPLAYER;
debug(LOG_FEATURE, "Sending %u artifact(s) type: (%s)", quantity, feature_names[type]);
NETbeginEncode(NETgameQueue(selectedPlayer), GAME_ARTIFACTS);
NETuint8_t(&quantity);
NETenum(&type);
ASSERT(mapWidth > 20, "map not big enough");
ASSERT(mapHeight > 20, "map not big enough");
for (count = 0; count < quantity; count++)
{
uint32_t id = generateNewObjectId();
for (i = 0; i < 3; i++) // try three times
{
// Between 10 and mapwidth - 10
x = (rand()%(mapWidth - 20)) + 10;
y = (rand()%(mapHeight - 20)) + 10;
if (pickATileGen(&x, &y, LOOK_FOR_EMPTY_TILE, zonedPAT))
{
break;
}
else if (i == 2)
{
debug(LOG_FEATURE, "Unable to find a free location after 3 tries; giving up.");
x = INVALID_XY;
}
}
NETuint32_t(&x);
NETuint32_t(&y);
NETuint32_t(&id);
NETuint8_t(&player);
}
NETend();
}
// ////////////////////////////////////////////////////////////////////////////
// add an artifact on destruction if required.
void technologyGiveAway(const STRUCTURE *pS)
{
// If a fully built factory (or with modules under construction) which is our responsibility got destroyed
if (pS->pStructureType->type == REF_FACTORY && (pS->status == SS_BUILT || pS->currentBuildPts >= pS->body))
{
syncDebug("Adding artefact.");
}
else
{
syncDebug("Not adding artefact.");
return;
}
int featureIndex;
for (featureIndex = 0; featureIndex < numFeatureStats && asFeatureStats[featureIndex].subType != FEAT_GEN_ARTE; ++featureIndex) {}
if (featureIndex >= numFeatureStats)
{
debug(LOG_WARNING, "No artefact feature!");
return;
}
uint32_t x = map_coord(pS->pos.x), y = map_coord(pS->pos.y);
if (!pickATileGen(&x, &y, LOOK_FOR_EMPTY_TILE, zonedPAT))
{
syncDebug("Did not find location for oil drum.");
debug(LOG_FEATURE, "Unable to find a free location.");
return;
}
FEATURE *pF = buildFeature(&asFeatureStats[featureIndex], world_coord(x), world_coord(y), false);
if (pF)
{
pF->player = pS->player;
syncDebugFeature(pF, '+');
}
else
{
debug(LOG_ERROR, "Couldn't build artefact?");
}
}
// ////////////////////////////////////////////////////////////////////////////
// add an artifact on destruction if required.
void technologyGiveAway(const STRUCTURE *pS)
{
uint8_t count = 1;
FEATURE_TYPE type = FEAT_GEN_ARTE;
// If a fully built factory (or with modules under construction) which is our responsibility got destroyed
if (pS->pStructureType->type == REF_FACTORY && (pS->status == SS_BUILT || pS->currentBuildPts >= pS->body)
&& myResponsibility(pS->player))
{
uint32_t x = map_coord(pS->pos.x);
uint32_t y = map_coord(pS->pos.y);
uint32_t id = generateNewObjectId();
// Pick a tile to place the artifact
if (!pickATileGen(&x, &y, LOOK_FOR_EMPTY_TILE, zonedPAT))
{
ASSERT(false, "technologyGiveAway: Unable to find a free location");
}
NETbeginEncode(NETgameQueue(selectedPlayer), GAME_ARTIFACTS);
{
/* Make sure that we don't have to violate the constness of pS.
* Since the nettype functions aren't const correct when sending
*/
uint8_t player = pS->player;
NETuint8_t(&count);
NETenum(&type);
NETuint32_t(&x);
NETuint32_t(&y);
NETuint32_t(&id);
NETuint8_t(&player);
}
NETend();
}
return;
}
///////////////////////////////////////////////////////////////////////////////
// splatter artifact gifts randomly about.
void addMultiPlayerRandomArtifacts(uint8_t quantity, FEATURE_TYPE type)
{
FEATURE *pF = NULL;
int i, featureStat, count;
uint32_t x, y;
uint8_t player = ANYPLAYER;
debug(LOG_FEATURE, "Sending %u artifact(s) type: (%s)", quantity, feature_names[type]);
NETbeginEncode(NET_ARTIFACTS, NET_ALL_PLAYERS);
NETuint8_t(&quantity);
NETenum(&type);
for(featureStat = 0; featureStat < numFeatureStats && asFeatureStats[featureStat].subType != type; featureStat++);
ASSERT(mapWidth > 20, "map not big enough");
ASSERT(mapHeight > 20, "map not big enough");
for (count = 0; count < quantity; count++)
{
for (i = 0; i < 3; i++) // try three times
{
// Between 10 and mapwidth - 10
x = (gameRand(mapWidth - 20)) + 10;
y = (gameRand(mapHeight - 20)) + 10;
if (pickATileGen(&x, &y, LOOK_FOR_EMPTY_TILE, zonedPAT))
{
break;
}
else if (i == 2)
{
debug(LOG_FEATURE, "Unable to find a free location after 3 tries; giving up.");
x = INVALID_XY;
}
}
if (x != INVALID_XY) // at least one of the tries succeeded
{
pF = buildFeature(asFeatureStats + featureStat, world_coord(x), world_coord(y), false);
if (pF)
{
pF->player = player;
}
else
{
x = INVALID_XY;
}
}
NETuint32_t(&x);
NETuint32_t(&y);
if (pF)
{
NETuint32_t(&pF->id);
}
else
{
NETuint32_t(&x); // just give them a dummy value; it'll never be used
}
NETuint8_t(&player);
}
NETend();
}
