void recvMultiPlayerFeature(NETQUEUE queue)
{
uint32_t ref = 0xff, x = 0, y = 0, id = 0;
unsigned int i;
NETbeginDecode(queue, GAME_DEBUG_ADD_FEATURE);
{
NETuint32_t(&ref);
NETuint32_t(&x);
NETuint32_t(&y);
NETuint32_t(&id);
}
NETend();
if (!getDebugMappingStatus() && bMultiPlayer)
{
debug(LOG_WARNING, "Failed to add feature for player %u.", NetPlay.players[queue.index].position);
return;
}
// Find the feature stats list that contains the feature type we want to build
for (i = 0; i < numFeatureStats; ++i)
{
// If we found the correct feature type
if (asFeatureStats[i].ref == ref)
{
// Create a feature of the specified type at the given location
FEATURE *result = buildFeature(&asFeatureStats[i], x, y, false);
result->id = id;
break;
}
}
}
void recvMultiPlayerFeature(NETQUEUE queue)
{
FEATURE_TYPE subType = FEAT_TREE; // Dummy initialisation.
uint32_t x, y, id;
unsigned int i;
NETbeginDecode(queue, GAME_FEATURES);
{
NETenum(&subType);
NETuint32_t(&x);
NETuint32_t(&y);
NETuint32_t(&id);
}
NETend();
// Find the feature stats list that contains the feature type we want to build
for (i = 0; i < numFeatureStats; ++i)
{
// If we found the correct feature type
if (asFeatureStats[i].subType == subType)
{
// Create a feature of the specified type at the given location
FEATURE *result = buildFeature(&asFeatureStats[i], x, y, false);
result->id = id;
break;
}
}
}
bool Tagger::read(FeatureCapture &featureCap,const pair<int,int> &blockPlace)
{
size_t nodesNum = featureCap.getSetSize(); //get the size of a data set, which means the number of nodes of a set
setSizeOfNodes(nodesNum); // reset the size number of nodes
setAnswersFromFC(featureCap, blockPlace); // get answers for a tagger
buildFeature(featureCap,blockPlace); // build features
return true;
}
// ///////////////////////////////////////////////////////////////
// receive splattered artifacts
void recvMultiPlayerRandomArtifacts(NETQUEUE queue)
{
int count, i;
uint8_t quantity, player;
uint32_t tx,ty;
uint32_t ref;
FEATURE_TYPE type = FEAT_TREE; // Dummy initialisation.
FEATURE *pF;
NETbeginDecode(queue, GAME_ARTIFACTS);
NETuint8_t(&quantity);
NETenum(&type);
debug(LOG_FEATURE, "receiving %u artifact(s) type: (%s)", quantity, feature_names[type]);
for (i = 0; i < numFeatureStats && asFeatureStats[i].subType != type; i++) {}
for (count = 0; count < quantity; count++)
{
MAPTILE *psTile;
NETuint32_t(&tx);
NETuint32_t(&ty);
NETuint32_t(&ref);
NETuint8_t(&player);
if (tx == INVALID_XY)
{
continue;
}
else if (!tileOnMap(tx, ty))
{
debug(LOG_ERROR, "Bad tile coordinates (%u,%u)", tx, ty);
continue;
}
psTile = mapTile(tx, ty);
if (!psTile || psTile->psObject != NULL)
{
debug(LOG_ERROR, "Already something at (%u,%u)!", tx, ty);
continue;
}
pF = buildFeature((asFeatureStats + i), world_coord(tx), world_coord(ty), false);
if (pF)
{
pF->id = ref;
pF->player = player;
syncDebugFeature(pF, '+');
}
else
{
debug(LOG_ERROR, "Couldn't build feature %u for player %u ?", ref, player);
}
}
NETend();
}
// ////////////////////////////////////////////////////////////////////////////
// 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;
}
// ////////////////////////////////////////////////////////////////////////////
// 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?");
}
}
///////////////////////////////////////////////////////////////////////////////
// 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();
}
