Bulldozed And Scorched Tile Indexing

[Hooman]

I noticed a slight oddity in some code where tile index 10 is always considered to be a bulldozed tile index. This is hardcoded into a routine to check if a tile index is a bulldozed tile index, which is never called anywhere that I can see, but it does seem to be inlined in a function that is called. Also, when bulldozing a tile, if there is no mapping from the source tile to a bulldozed tile, then it will use tile index 10 for the bulldozed tile index.

Scorched/burned tiles have a different mapping depending on if the terrain is bulldozed or not. Hence the 10 above is relevant to this. There are 3 tiles for each of the normal and bulldozed terrain. It randomly chooses one.


Here's an attempt to reverse the code into something C++ like. I chose to use "continue" instead of nested if statements, since I didn't have to complement that branch condition that way. I tend to make mistakes when I complement branch conditions.

Code: [Select]

// Note: tileIndex 10 is always considered to be bulldozed
IsBulldozedTileIndex(int tileIndex)
{
	int i;

	for (i = 0; i < numTerrainTypes; i++)
	{
  if (terrainType[i]->bulldozedTileIndex > tileIndex) continue;
  if (terrainType[i]->bulldozedTileIndex + 1 > tileIndex) return true;	// (bulldozedTileIndex == tileIndex)
	}

	return (tileIndex == 10);
}

IsScorchedTileIndex(int tileIndex)
{
	int i;

	for (i = 0; i < numTerrainTypes; i++)
	{
  scorchedTileIndex = terrainType[i].scorchedTileIndex;
  if (scorchedTileIndex == 0) continue;

  if (tileIndex < scorchedTileIndex) continue;
  if (scorchedTileIndex + 6 > tileIndex) return true;	// (scorchedTileIndex <= tileIndex < scorchedTileIndex + 6)
	}

	return false;
}


GetScorchMarkTileIndex(int tileIndex)
{
	int i, j;
	int newTileIndex = 0;

	for (i = 0; i < numTerrainTypes; i++)
	{
  if (terrainType[i]->firstTile > tileIndex) continue;
  if (terrainType[i]->lastTile < tileIndex) continue;

  newTileIndex = terrainType[i]->scorchedTileIndex;
  if (newTileIndex == 0) continue;

  for (j = 0; j < numTerrainTypes; j++)
  {
  	if (terrainType[j]->bulldozedTileIndex > tileIndex) continue;
  	if (terrainType[j]->bulldozedTileIndex + 1 > tileIndex) continue(2);	// (bulldozedTileIndex == tileIndex)
  }

  if (tileIndex == 10) continue;

  // Increment to non bulldozed scorched tile index
  newTileIndex += 3;  	// **  ((tileIndex != 10) && (tileIndex != bulldozedTileIndex[0..?]))
	}
	if (newTileIndex != 0)
	{
  newTileIndex += Rand(3);
	}

	return newTileIndex;
}

Note that there are 9 burn tiles for the rock tile set, but this code only ever makes use of 6 tiles per terrain type. (Granted, you can have more than 1 terrain type object for a tile set). There is also more code to check if a tile index is a scorched/burn tile index, and it checks for a range of 6 tiles from the base scorch/burn index.