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(); }