Example #1
0
/*!
 * \brief create a single forest at the point specified
 * \param pos Position on the map to start from
 * \param size Radius of the forest to paint.
 */
static void
CreateForest(UInt32 pos, UInt16 size)
{
	UInt16 x, y, i, j, s;

	x = (UInt16)(pos % getMapWidth());
	y = (UInt16)(pos / getMapWidth());
	zone_lock(lz_world);
	zone_lock(lz_flags);
	i = x - size > 0 ? x - size : 0;
	j = y - size > 0 ? y - size : 0;

	for (; i <= x + size; i++) {
		for (j = y - size; j <= y + size; j++) {
			if (i >= getMapWidth() ||
			    j >= getMapHeight())
				continue;
			if (getWorld(WORLDPOS(i, j)) != Z_DIRT)
				continue;
			s = ((y > j) ? (y - j) : (j - y)) +
			    ((x > i) ? (x - i) : (i - x));
			if (GetRandomNumber(s) < 2) {
				/*!
				 * \todo count_trees or count_real_trees
				 */
				setWorldAndFlag(WORLDPOS(i, j), Z_REALTREE, 0);
				vgame.BuildCount[bc_count_trees]++;
			}
		}
		j = y - size > 0 ? y - size : 0;
	}
	zone_unlock(lz_flags);
	zone_unlock(lz_world);
}
Example #2
0
void
DoNastyStuffTo(welem_t type, UInt16 probability, UInt8 purge)
{
	/* nasty stuff means: turn it into wasteland */
	UInt32 randomTile;
	UInt16 i, x, y;

	if (GetRandomNumber(probability) != 0)
		return;

	zone_lock(lz_world);
	zone_lock(lz_flags);
	for (i = 0; i < 50; i++) {
		randomTile = GetRandomNumber(MapMul());
		if (getWorld(randomTile) == type) {
			/* wee, let's destroy something */
			x = (UInt16)(randomTile % getMapWidth());
			y = (UInt16)(randomTile / getMapWidth());
			if (!purge)
				CreateWaste(x, y);
			else
				Build_Destroy(x, y);
			break;
		}
	}
	zone_unlock(lz_flags);
	zone_unlock(lz_world);
}
Example #3
0
//--------------------------------
// 
//--------------------------------
bool AflMapData::saveMap(LPCSTR pFileName)
{
	int i,j,k;
	FILE* pFile;

	pFile = fopen(pFileName,TEXT("wb"));
	if(!pFile)
		return false;

	m_strFileName = pFileName;
	setRelativePath();

	fwrite(m_strMapHeader[MAP_BINHEADER],strlen(m_strMapHeader[MAP_BINHEADER])+1,1,pFile);
	
	//-----------------------------
	writeHeader(pFile,m_strMapHeader[MAP_VERSION],getVersion());
	writeHeader(pFile,m_strMapHeader[MAP_MAPNAME],getMapName());
	writeHeader(pFile,m_strMapHeader[MAP_BITMAP],getImageName(0));
	writeHeader(pFile,m_strMapHeader[MAP_SPRITE],getImageName(1));
	writeHeader(pFile,m_strMapHeader[MAP_WIDTH],getMapWidth());
	writeHeader(pFile,m_strMapHeader[MAP_HEIGHT],getMapHeight());
	writeHeader(pFile,m_strMapHeader[MAP_OPATTERN],getOutTipIndex());
	writeHeader(pFile,m_strMapHeader[MAP_PARTSWIDTH],getTipWidth());
	writeHeader(pFile,m_strMapHeader[MAP_PARTSHEIGHT],getTipHeight());
	writeHeader(pFile,m_strMapHeader[MAP_OBJECT],getObjectFileName());

	//-----------------------------
	//マップデータ
	for(k=0;k<4;k++)
	{
		if(!isZero(k))
		{
			PSHORT pData = m_ptrData[k].get();
			writeHeader(pFile,m_strMapHeader[MAP_MAPDATA0+k],
				pData,getMapWidth()*getMapHeight()*sizeof(short));
		}
	}

	//-----------------------------
	//パーツ接触フラグ
    for(j=0;j<5;j++)
    {
		int nCollide;
		for(nCollide=i=0;i<0xffff/8;i++)
			if(m_byCollide[j][i])
				nCollide = i+1;
		writeHeader(pFile,m_strMapHeader[MAP_PAERSCOLLIDE0+j],m_byCollide,nCollide);
	}
	//-----------------------------

	//-----------------------------
	//マップ個別フラグ
	writeHeader(pFile,m_strMapHeader[MAP_MAPFLAG0],getMapFlag(),getMapWidth()*getMapHeight());
	//-----------------------------
	fclose(pFile);
	return true;
}
Example #4
0
void AflMapData::setMapFlag(INT iX,INT iY,BYTE byFlag)
{
	if(iX < 0 || iY < 0 || iX >= m_iMapWidth || iY >= m_iMapHeight)
		return;
	LPBYTE pbyFlag = getMapFlag();
	 pbyFlag[iX + getMapWidth()*iY] = byFlag;
}
Example #5
0
bool AflMapData::isMapCollide(INT iX,INT iY) 
{
	if(iX < 0 || iY < 0 || iX >= getMapWidth() || iY >= getMapHeight())
		return true;
	BYTE byFlag = getMapFlag(iX,iY);
	return (byFlag & 0x80) != 0;
}
Example #6
0
void Map::handleFishNPC ()
{
	if (!_activateFishNPC)
		return;

	const float waterBodyY = getWaterHeight();
	// no fish if water is too low
	if (waterBodyY <= 0.5f)
		return;

	if (_spawnFishNPCTime > _time)
		return;

	const float gap = 2.0f;
	if (_fishNPC == nullptr) {
		if (_players.empty())
			return;

		const int index = rand() % _players.size();
		const Player* player = _players[index];
		const b2Vec2& pos = player->getPos();
		const float mapHeight = static_cast<float>(getMapHeight());
		float y = std::min(waterBodyY, std::max(mapHeight, mapHeight - 0.5f));
		if (y < 0.f) {
			return;
		}

		float x;
		if (pos.x > getMapWidth() / 2.0)
			x = -gap;
		else
			x = getMapWidth() + gap;
		const b2Vec2 npcSpawnPos(x, y);
		_fishNPC = createFishNPC(npcSpawnPos);
	} else {
		const b2Vec2 &pos = _fishNPC->getPos();
		const float x = pos.x;
		const float y = pos.y;
		if (x < -gap || y < 0 || x > getMapWidth() + gap || y > getMapHeight()) {
			_fishNPC->setRemove();
			_spawnFishNPCTime = _time + 2000 + rand() % SPAWN_FISH_NPC_DELAY;
			_fishNPC = nullptr;
		}
	}
}
Example #7
0
/*!
 * \todo Make the river more interesting
 */
static void
CreateFullRiver(void)
{
	UInt16 i, j, k, width;
	int axis;
	UInt16 kmax;

	width = (UInt16)(GetRandomNumber(5) + 5);
	axis = (int)GetRandomNumber(1);
	kmax = axis ? getMapWidth() : getMapHeight();

	/* This is the start position of the center of the river */
	j = (UInt16)GetRandomNumber(kmax);

	zone_lock(lz_world);
	zone_lock(lz_flags);

	for (i = 0; i < kmax; i++) {
		for (k = j; k < (width + j); k++) {
			if (k < kmax) {
				if (axis)
					setWorldAndFlag(WORLDPOS(i, k),
					    Z_REALWATER, 0);
				else
					setWorldAndFlag(WORLDPOS(k, i),
					    Z_REALWATER, 0);
			}
		}

		switch (GetRandomNumber(3)) {
		case 0:
			if (width >  5)
				width--;
			break;
		case 1:
			if (width < 15)
				width++;
			break;
		default:
			break;
		}
		switch (GetRandomNumber(4)) {
		case 0:
			if (j > 0)
				j--;
			break;
		case 1:
			if (j < kmax)
				j++;
			break;
		default:
			break;
		}
	}
	zone_unlock(lz_flags);
	zone_unlock(lz_world);
}
Example #8
0
BYTE AflMapData::getMapFlag(INT iX,INT iY)
{
	if(iX < 0 || iY < 0 || iX >= m_iMapWidth || iY >= m_iMapHeight)
	{
		return 0;
	}
	LPBYTE pbyFlag = getMapFlag();
	return pbyFlag[iX + getMapWidth()*iY];
}
Example #9
0
void Map::handleFlyingNPC ()
{
	if (!_activateflyingNPC)
		return;

	if (_spawnFlyingNPCTime > _time)
		return;

	const float gap = 2.0f;
	if (_flyingNPC == nullptr) {
		if (_players.empty())
			return;

		const int index = rand() % _players.size();
		const Player* player = _players[index];
		const b2Vec2& pos = player->getPos();
		const float waterBodyY = getWaterHeight();
		float y = pos.y;
		if (y >= waterBodyY) {
			y = waterBodyY - 1.0f;
		}
		if (y < 0.f) {
			return;
		}

		float x;
		if (pos.x > getMapWidth() / 2.0)
			x = -gap;
		else
			x = getMapWidth() + gap;
		const b2Vec2 npcSpawnPos(x, y);
		_flyingNPC = createFlyingNPC(npcSpawnPos);
	} else {
		const b2Vec2 &pos = _flyingNPC->getPos();
		const float x = pos.x;
		const float y = pos.y;
		if (x < -gap || y < 0 || x > getMapWidth() + gap || y > getMapHeight()) {
			_flyingNPC->setRemove();
			_spawnFlyingNPCTime = _time + 2000 + rand() % SPAWN_FLYING_NPC_DELAY;
			_flyingNPC = nullptr;
		}
	}
}
Example #10
0
/*!
 * \brief Cause a fire to spread out from the point chosen
 * \param x position on horizontal of map to spread fire
 * \param y position on vertical of map to spread fire
 */
static void
FireSpread(UInt16 x, UInt16 y)
{
	if (x > 0)
		BurnField((UInt16)(x - 1), (UInt16)y, 0);
	if (x < (UInt16)(getMapWidth() - 1))
		BurnField((UInt16)(x + 1), (UInt16)y, 0);
	if (y > 0)
		BurnField((UInt16)x, (UInt16)(y - 1), 0);
	if (y < (UInt16)(getMapHeight() - 1))
		BurnField((UInt16)x, (UInt16)(y + 1), 0);
}
Example #11
0
/*--------------------------------------------------------------------------------------------  
--  FUNCTION:        drawMap
--  
--  DATE:            April 7th, 2016
--  
--  DESIGNERS:       Jaegar Sarauer
--  
--  REVISIONS:       NONE
--  
--  PROGRAMMERS:     Jaegar Sarauer
--  
--  INTERFACE:       void Map::drawMap (int ** mapArray)
--                   	int ** mapArray = A 2D array of ints which represent tile id's of a map.
--  
--  RETURNS:         void
--  
--  NOTES:           This function will draw a map layer (passed in as a parameter) as ascii characters
--                   which are represented from the tile id's of the map array.
--                   Mainly used for debugging.
------------------------------------------------------------------------------------------*/
void Map::drawMap (int ** mapArray) {
	printf ("\n\n -------------------------------------------------------------- \n\n");
	for (size_t x = 0; x < getMapWidth (); x++) {
		printf ("\n ");
		for (size_t y = 0; y < getMapHeight (); y++) {
			printf ("%-4d ", mapArray[x][y]);
		}
		/*if (map.isBaseWall(x,y))
		printf ("W ");
		else
		printf ("  ");*/
	}
}
Example #12
0
void
DoRandomDisaster(void)
{
	UInt32 randomTile;
	Int16 i, type, random;
	UInt16 x, y;
	UInt8 disaster_level;

	disaster_level = getDisasterLevel();
	/* for those who can't handle the game (truth?) */
	if (disaster_level == 0)
		return;

	zone_lock(lz_world);
	zone_lock(lz_flags);

	for (i = 0; i < 100; i++) { /* 100 tries to hit a useful tile */
		randomTile = GetRandomNumber(MapMul());
		type = getWorld(randomTile);
		if (type != Z_DIRT &&
			type != Z_REALWATER &&
			type != Z_CRATER) {
			x = (UInt16)(randomTile % getMapWidth());
			y = (UInt16)(randomTile / getMapHeight());
			/* TODO: should depend on difficulty */
			random = (Int16)GetRandomNumber(1000 / disaster_level);
			WriteLog("Random Disaster: %d\n", (int)random);
			if (random < 10 && vgame.BuildCount[bc_fire] == 0) {
				DoSpecificDisaster(diFireOutbreak, x, y);
			} else if (random < 15 &&
			    game.objects[obj_monster].active == 0) {
				DoSpecificDisaster(diMonster, x, y);
			} else if (random < 17 &&
			    game.objects[obj_dragon].active == 0) {
				DoSpecificDisaster(diDragon, x, y);
			} else if (random < 19) {
				DoSpecificDisaster(diMeteor, x, y);
			}
			/* only one chance for disaster per turn */
			break;
		}
	}
	zone_unlock(lz_flags);
	zone_unlock(lz_world);
}
Example #13
0
Int16
UpdateDisasters(void)
{
	/* return false if no disasters are found */
	UInt16 i, j;
	welem_t type;
	int retval = 0;

	zone_lock(lz_world);
	zone_lock(lz_flags);
	clearScratch(SCRATCHDISASTER);
	for (i = 0; i < getMapHeight(); i++) {
		for (j = 0; j < getMapWidth(); j++) {
			type = getWorld(WORLDPOS(i, j));
			/* already looked at this one? */
			if (getWorldFlags(WORLDPOS(i, j)) & SCRATCHDISASTER) {
				if (type == Z_FIRE2) {
					retval = 1;
					if (GetRandomNumber(5) != 0) {
						/* are there any defences */
						if (GetDefenceValue(i, j) < 3) {
							FireSpread(i, j);
						}
						setWorldAndFlag(WORLDPOS(i, j),
						    Z_FIRE3, 0);
					} else {
						CreateWaste(i, j);
					}
				} else if (type == Z_FIRE1) {
					retval = 1;
					setWorldAndFlag(WORLDPOS(i, j),
					    Z_FIRE2, 0);
				} else if (type == Z_FIRE3) {
					retval = 1;
					CreateWaste(i, j);
				}
			}
		}
	}
	zone_unlock(lz_flags);
	zone_unlock(lz_world);
	return (retval);
}
Example #14
0
void
DoCommitmentNasties(void)
{
	int i;

	zone_lock(lz_world);
	for (i = 0; i < 60 - getTax(); i++) {
		UInt32 loc = GetRandomNumber(MapMul());
		welem_t world = getWorld(GetRandomNumber(MapMul()));
		int x = loc % getMapWidth();
		int y = loc % getMapHeight();

		if ((IsTransport(world)) &&
		    (GetRandomNumber(100) > getUpkeep(ue_traffic)))
			Build_Destroy(x, y);
		if ((IsWaterPipe(world) || IsPowerLine(world) ||
			    IsPowerWater(world)) &&
		    (GetRandomNumber(100) > getUpkeep(ue_power)))
			Build_Destroy(x, y);
	}
	zone_unlock(lz_world);
}
Example #15
0
/*!
 * \brief Create a waste zone for the meteor.
 * \param x horizontal position
 * \param y vertical position
 * \param size size of the meteor
 */
static void
CreateMeteor(UInt16 x, UInt16 y, Int16 size)
{
	UInt16 j;
	UInt16 i =  (Int16)(x - size) < 0 ? 0 : (UInt16)(x - size);

	zone_lock(lz_world);
	zone_lock(lz_flags);
	UILockScreen();
	for (; i <= x + size; i++) {
		j = (Int16)(y - size) < 0 ? 0 : (UInt16)(y - size);
		for (; j <= y + size; j++) {
			if (i < getMapWidth() &&
			    j < getMapHeight()) {
				if (GetRandomNumber(5) < 2) {
					if (getWorld(WORLDPOS(i, j)) !=
					    Z_REALWATER) {
						CreateWaste(i, j);
					}
				} else if (GetRandomNumber(5) < 4) {
					if (getWorld(WORLDPOS(i, j)) !=
					    Z_REALWATER &&
					    getWorld(WORLDPOS(i, j)) !=
					    Z_FAKEWATER) {
						BurnField(i, j, 1);
					}
				}
			}
		}
	}
	Build_Destroy(x, y);
	setWorldAndFlag(WORLDPOS(x, y), Z_CRATER, 0);
	zone_unlock(lz_flags);
	zone_unlock(lz_world);
	UIUnlockScreen();
	RedrawAllFields();
}
Example #16
0
int BaseAI::mapWidth()
{
  return getMapWidth(c);
}
Example #17
0
void Map::initPhysics ()
{
	b2Vec2 gravity;
	gravity.Set(0.0f, getGravity());
	_world = new b2World(gravity);

	_world->SetDestructionListener(&_destructionListener);

	//_world->SetWarmStarting(false);
	//_world->SetContinuousPhysics(false);
	//_world->SetSubStepping(false);
	_world->SetAutoClearForces(true);
	_world->SetContactListener(this);
	_world->SetContactFilter(this);

	const float zeroX = 0.0f;
	const float zeroY = -0.5f;
	const float width = getMapWidth();
	// added a small offset to allow water diving out of screen
	const float height = getMapHeight() + 1.0f;

	b2BodyDef lineBodyDef;
	lineBodyDef.type = b2_staticBody;
	lineBodyDef.position.Set(0, 0);
	b2Body* boxBody = _world->CreateBody(&lineBodyDef);

	b2EdgeShape edge;
	b2FixtureDef fd;
	fd.friction = 1.0f;
	fd.restitution = 0.2f;
	fd.shape = &edge;

	_borders.resize(BORDER_MAX);
	const bool isSideBorderFail = getSetting(msn::SIDEBORDERFAIL).toBool();
	_borders[BORDER_TOP] = new Border(BorderType::TOP, *this);
	_borders[BORDER_LEFT] = new Border(BorderType::LEFT, *this, isSideBorderFail);
	_borders[BORDER_RIGHT] = new Border(BorderType::RIGHT, *this, isSideBorderFail);
	_borders[BORDER_BOTTOM] = new Border(BorderType::BOTTOM, *this);
	_borders[BORDER_PLAYER_BOTTOM] = new Border(BorderType::PLAYER_BOTTOM, *this);

	edge.Set(b2Vec2(zeroX, zeroY), b2Vec2(width, zeroY));
	b2Fixture *top = boxBody->CreateFixture(&fd);
	top->SetUserData(_borders[BORDER_TOP]);

	edge.Set(b2Vec2(zeroX, zeroY), b2Vec2(zeroX, height));
	b2Fixture *left = boxBody->CreateFixture(&fd);
	left->SetUserData(_borders[BORDER_LEFT]);

	edge.Set(b2Vec2(width, height), b2Vec2(width, zeroY));
	b2Fixture *right = boxBody->CreateFixture(&fd);
	right->SetUserData(_borders[BORDER_RIGHT]);

	edge.Set(b2Vec2(zeroX, height), b2Vec2(width, height));
	b2Fixture *bottom = boxBody->CreateFixture(&fd);
	bottom->SetUserData(_borders[BORDER_BOTTOM]);

	edge.Set(b2Vec2(zeroX, height), b2Vec2(width, getMapHeight()));
	b2Fixture *playerBottom = boxBody->CreateFixture(&fd);
	playerBottom->SetUserData(_borders[BORDER_PLAYER_BOTTOM]);

	initWater();
}
Example #18
0
void
MoveAllObjects(void)
{
	UInt16 i, x, y;

	for (i = 0; i < NUM_OF_OBJECTS; i++) {
		if (game.objects[i].active != 0) {
			/* hmm, is this thing destructive? */
			if (i == obj_dragon) {
				if (!BurnField(game.objects[i].x,
				    game.objects[i].y, 1)) {
					CreateWaste(game.objects[i].x,
					    game.objects[i].y);
				}
				MonsterCheckSurrounded(i);
			} else if (i == obj_monster) {
				/* whoo-hoo, bingo again */
				CreateWaste(game.objects[i].x,
				    game.objects[i].y);
				MonsterCheckSurrounded(i);
			}

			x = game.objects[i].x; /* save old position */
			y = game.objects[i].y;

			switch (GetRandomNumber(OBJ_CHANCE_OF_TURNING)) {
			case 1: /* yes, clockwise */
				game.objects[i].dir = (game.objects[i].dir+1)%8;
				break;
			case 2: /* yes, counter-clockwise */
				game.objects[i].dir = (game.objects[i].dir+7)%8;
				break;
			default:
				break;
			}
			/* now move it a nod */
			switch (game.objects[i].dir) { /* first up/down */
			case 0: /* up */
			case 1: /* up-right */
			case 7: /* up-left */
				if (game.objects[i].y > 0) {
					game.objects[i].y--;
				} else {
					game.objects[i].dir = 4;
				}
				break;
			case 3: /* down-right */
			case 4: /* down */
			case 5: /* down-left */
				if (game.objects[i].y <
				    (UInt16)(getMapHeight()-1)) {
					game.objects[i].y++;
				} else {
					game.objects[i].dir = 0;
				}
				break;
			default:
				break;
			}

			switch (game.objects[i].dir) { /* then left/right */
			case 1: /* up-right */
			case 2: /* right */
			case 3: /* down-right */
				if (game.objects[i].x <
				    (UInt16)(getMapWidth()-1)) {
					game.objects[i].x++;
				} else {
					game.objects[i].dir = 6;
				}
				break;
			case 5: /* down-left */
			case 6: /* left */
			case 7: /* up-left */
				if (game.objects[i].x > 0) {
					game.objects[i].x--;
				} else {
					game.objects[i].dir = 2;
				}
				break;
			default:
				break;
			}
			zone_lock(lz_world);
			zone_lock(lz_flags);
			DrawCross(x, y, 1, 1); /* (erase it) */
			DrawField(game.objects[i].x, game.objects[i].y);
			zone_unlock(lz_flags);
			zone_unlock(lz_world);
		}
	}
}