Example #1
0
File: map.cpp Project: kanc/UTAD
Map::Map(const String &filename, uint16 firstColId) {
    valid = false;
    this->filename = filename;
    this->firstColId = firstColId;
    width = height = tileWidth = tileHeight = 0;

    // Analizamos el XML
    String buffer = String::Read(filename);
    xml_document<> doc;
    doc.parse<0>((char*)buffer.ToCString());

    // Obtenemos informacion de cabecera
    xml_node<>* mapNode = doc.first_node("map");
    width = atoi(mapNode->first_attribute("width")->value());
    height = atoi(mapNode->first_attribute("height")->value());
    tileWidth = atoi(mapNode->first_attribute("tilewidth")->value());
    tileHeight = atoi(mapNode->first_attribute("tileheight")->value());

    // Obtenemos informacion del tileset ("source" no esta soportado)
    xml_node<>* tilesetNode = mapNode->first_node("tileset");
    int firstGid = atoi(tilesetNode->first_attribute("firstgid")->value());
    uint16 tilesetTileWidth = atoi(tilesetNode->first_attribute("tilewidth")->value());
    uint16 tilesetTileHeight = atoi(tilesetNode->first_attribute("tileheight")->value());
    int offsetX = 0, offsetY = 0;
    if ( tilesetNode->first_node("tileoffset") ) {
        offsetX = atoi(tilesetNode->first_node("tileoffset")->first_attribute("x")->value());
        offsetY = atoi(tilesetNode->first_node("tileoffset")->first_attribute("y")->value());
    }
    imageFile = String(tilesetNode->first_node("image")->first_attribute("source")->value()).StripDir();
    int imageWidth = atoi(tilesetNode->first_node("image")->first_attribute("width")->value());
    int imageHeight = atoi(tilesetNode->first_node("image")->first_attribute("height")->value());

    // Leemos el primer layer, sin codificacion ni compresion (los demas son ignorados)
    xml_node<>* dataNode = mapNode->first_node("layer")->first_node("data");
    if ( dataNode->first_attribute("encoding") || dataNode->first_attribute("compression") ) return;
    xml_node<>* tileNode = dataNode->first_node("tile");
    while ( tileNode ) {
        tileIds.Add(atoi(tileNode->first_attribute("gid")->value()) - firstGid);
        tileNode = tileNode->next_sibling("tile");
    }

    // Cargamos la imagen
    image = ResourceManager::Instance().LoadImage(filename.ExtractDir() + "/" + imageFile, imageWidth/tilesetTileWidth, imageHeight/tilesetTileHeight);
    image->SetHandle(offsetX, offsetY);

    valid = true;
}
Entity * EntityFactory::CreatePlayerOne(World * world)
{
	Entity * entity;
	Image * ship = nullptr;
	Document document;
	String string;
	const char * json;
	float life, energy, eneryRegeneration;

	/*Retive spaceshipdata*/
	switch (LevelManager::Instance().GetPLayerOneSpaceShip())
	{
		
	case LevelManager::AVATAR:
		string = String::Read("../data/spaceships/avatar/data.cfg");
		json = string.ToCString();
		document.Parse(json);
		ship = ResourceStore::Instance().GetAvatarImage();
		break;
	case  LevelManager::DREADNOUGH:
		string = String::Read("../data/spaceships/dreadnought/data.cfg");
		json = string.ToCString();
		document.Parse(json);
		ship = ResourceStore::Instance().GetDreadnoughtImage();
		break;
	}
	entity = new Entity(0, 0, ship->GetWidth(), ship->GetHeight(), 0);//create entity
	/*Set spaceship control*/
	switch (LevelManager::Instance().GetPLayerOneType())
	{
		float linearVel, angularVel;
	case LevelManager::HUMAN:
	{
		string = String::Read("../data/config/keybindings.cfg");
		json = string.ToCString();

		Document keybindings;
		keybindings.Parse(json);

		assert(keybindings.HasMember("Player1"));
		assert(keybindings["Player1"].IsObject());

		assert(document.HasMember("LinearVelocity"));
		assert(document["LinearVelocity"].IsNumber());
		assert(document["LinearVelocity"].IsFloat());
		linearVel = document["LinearVelocity"].GetFloat();

		assert(document.HasMember("AngularVelocity"));
		assert(document["AngularVelocity"].IsNumber());
		assert(document["AngularVelocity"].IsFloat());
		angularVel = document["AngularVelocity"].GetFloat();

		ComponentPlayerController * playerController = new ComponentPlayerController(linearVel, angularVel);
		playerController->BinKeys(
			static_cast<inputs>(keybindings["Player1"]["UP"].GetInt()),
			static_cast<inputs>(keybindings["Player1"]["DOWN"].GetInt()), 
			static_cast<inputs>(keybindings["Player1"]["RLEFT"].GetInt()),
			static_cast<inputs>(keybindings["Player1"]["RRIGHT"].GetInt()),
			static_cast<inputs>(keybindings["Player1"]["FIREMAIN"].GetInt()),
			static_cast<inputs>(keybindings["Player1"]["FIRESECONDARY"].GetInt())
			);
		entity->AddComponent(playerController);
	}
	break;
	case  LevelManager::EASY:
		ComponentBehaviour *EasyIA= new ComponentBehaviour(new DroneBehaviouralTree(entity));
		break;
	}

	life = document["Life"].GetFloat();

	energy = document["Energy"].GetFloat();

	eneryRegeneration = document["EnergyRegeneration"].GetFloat();

	ComponentStats * stats = new ComponentStats(life, energy, eneryRegeneration);
	entity->AddComponent(stats);

	ComponentRenderer * renderer = new ComponentRenderer(ship);
	entity->AddComponent(renderer);

	ComponentCircleCollision * collider = new ComponentCircleCollision(1000, false);
	entity->AddComponent(collider);

	ComponentShipExplosion * explosion = new ComponentShipExplosion(this);
	entity->AddComponent(explosion);

	assert(document.HasMember("PrimaryWeapon"));
	assert(document["PrimaryWeapon"].IsObject());
	assert(document["PrimaryWeapon"].HasMember("Type"));
	assert(document["PrimaryWeapon"]["Type"].IsString());

	string = document["PrimaryWeapon"]["Type"].GetString();
	if(string==String("LASER")){
	ComponentLaserWeapon * weapon = new ComponentLaserWeapon(world,WT_MAIN, 
		document["PrimaryWeapon"]["Cooldown"].GetDouble(), document["PrimaryWeapon"]["Damage"].GetDouble(),
		document["PrimaryWeapon"]["EnergyConsumption"].GetDouble(), document["PrimaryWeapon"]["Range"].GetDouble());
	entity->AddComponent(weapon);
	}else if (string == String("MISSILE")) {
		ComponentBalisticWeapon * weapon = new ComponentBalisticWeapon(world, this,WT_MAIN,
			document["PrimaryWeapon"]["Cooldown"].GetDouble(), document["PrimaryWeapon"]["Damage"].GetDouble(),
			document["PrimaryWeapon"]["EnergyConsumption"].GetDouble(), document["PrimaryWeapon"]["Speed"].GetDouble());
		entity->AddComponent(weapon);
	}
	entityStore.Add(entity);
	return entity;
}
Example #3
0
Font::Font(const String& filename) : Image(filename, 16, 16)
{
	_glyphs = Array<Glyph>();
	Glyph myGlyph = Glyph();

	// Cargamos el buffer con la imagen
	int iWidth;
	int iHeight;
	unsigned char* buffer = stbi_load(filename.ToCString(), &iWidth, &iHeight, NULL, nElemPixel);

	// Calculamos las dimensiones de cada frame
	bool dimX = false;
	for (int i = 1; i < iWidth / nElemPixel && !dimX; i++)
	{
		uint8 r = buffer[i * nElemPixel];
		uint8 g = buffer[i * nElemPixel + 1];
		uint8 b = buffer[i * nElemPixel + 2];
		if (IsColor(r, g, b, 255, 255, 0))
		{
			_dimFrameX = i;
			dimX = true;
		}
	}
	bool dimY = false;
	for (int i = 1; i < iHeight / nElemPixel && !dimY; i++)
	{
		uint8 r = buffer[i * iWidth * nElemPixel];
		uint8 g = buffer[i * iWidth * nElemPixel + 1];
		uint8 b = buffer[i * iWidth * nElemPixel + 2];
		if (IsColor(r, g, b, 255, 255, 0))
		{
			_dimFrameY = i;
			dimY = true;
		}
	}

	// Tratamos los pixeles dentro de cada frame
	if ( buffer ) {
		if (dimX && dimY)
		{
			for (int j = 0; j < nFrameY; j++)
			{
				for (int i = 0; i < nFrameX; i++)
				{
					// Accedemos al frame[i,j]
					for (int k = 0; k < _dimFrameX; k++)
					{
						for (int l = 0; l < _dimFrameY; l++)
						{
							// Accedemos al pixel[k,l] del frame[i,j]
							uint8 r = buffer[IndexFrom(i, j, k, l, iWidth, 0)];
							uint8 g = buffer[IndexFrom(i, j, k, l, iWidth, 1)];
							uint8 b = buffer[IndexFrom(i, j, k, l, iWidth, 2)];
							if (IsColor(r, g, b, 255, 255, 0))
							{
								myGlyph.SetIni(i * _dimFrameX + k, j * _dimFrameY + l);
								buffer[IndexFrom(i, j, k, l, iWidth, 3)] = 0;
							}
							else if (IsColor(r, g, b, 255, 0, 0))
							{
								myGlyph.SetFin(i * _dimFrameX + k, j * _dimFrameY + l);
								buffer[IndexFrom(i, j, k, l, iWidth, 3)] = 0;
							}
							else if (IsColor(r, g, b, 0, 0, 0))
							{
								buffer[IndexFrom(i, j, k, l, iWidth, 3)] = 0;
							}
						}
					}
					if (myGlyph.GetIniX() != 0 || myGlyph.GetIniY() != 0 || myGlyph.GetFinX() != 0 || myGlyph.GetFinY() != 0)
						_glyphs.Add(myGlyph);
				}
			}
			glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, iWidth, iHeight, 0, GL_RGBA, GL_UNSIGNED_BYTE, buffer);
		}
		free(buffer);
	}
}
Example #4
0
AudioBuffer::AudioBuffer(const String & filename):alBuffer(0)
{

	if (filename.ExtractExt() == "wav") {

		alGenBuffers(1, &alBuffer);
		File file(filename, FILE_READ);
		file.Seek(16);
		uint32 fmtChunkSize;
		file.ReadBytes(&fmtChunkSize, 4);
		uint16 audioFormat;
		file.ReadBytes(&audioFormat, 2);
		uint16 channels;
		file.ReadBytes(&channels, 2);
		file.Seek(24);
		uint32 sampleRate;
		file.ReadBytes(&sampleRate, 4);
		file.Seek(34);
		uint16 bitsPerSample;
		file.ReadBytes(&bitsPerSample, 2);
		uint16 extraParamSize;
		if (fmtChunkSize != 16) {
			file.ReadBytes(&extraParamSize, 2);
			file.Seek(38 + extraParamSize);
		}
		char texto[5];
		texto[4] = '\0';

		while (String(texto) != "data") {

			file.ReadBytes(texto, 4);
		}

		uint32 dataSize;
		uint32* data;
		file.ReadBytes(&dataSize, 4);
		data = (uint32*)malloc(dataSize);
		file.ReadBytes(data, dataSize);

		ALenum format;

		if (bitsPerSample == 8) {
			if (channels == 1) {
				format = AL_FORMAT_MONO8;
			}
			else {
				format = AL_FORMAT_STEREO8;
			}
		}

		if (bitsPerSample == 16) {
			if (channels == 1) {
				format = AL_FORMAT_MONO16;
			}
			else {
				format = AL_FORMAT_STEREO16;
			}
		}

		alBufferData(alBuffer, format, data, dataSize, sampleRate);
		free(data);
	}
	else if (filename.ExtractExt() == "ogg") {
		stb_vorbis* stb_vorbis;

		stb_vorbis = stb_vorbis_open_filename(filename.ToCString(), nullptr, nullptr);
		if (stb_vorbis == nullptr) return;

		stb_vorbis_info info = stb_vorbis_get_info(stb_vorbis);
		uint32 dataSize = stb_vorbis_stream_length_in_samples(stb_vorbis) *  info.channels;
		int16* buffer = (int16*)malloc(dataSize  * sizeof(uint16));
		stb_vorbis_get_samples_short_interleaved(stb_vorbis, info.channels,(short *) buffer, dataSize);
		alGenBuffers(1, &alBuffer);
		ALenum format;
		if (info.channels == 1) {
			format = AL_FORMAT_MONO16;
		}
		else {
			format = AL_FORMAT_STEREO16;
		}
		alBufferData(alBuffer, format, buffer, dataSize * sizeof(int16), info.sample_rate);
		free(buffer);
		stb_vorbis_close(stb_vorbis);
	}




}
AudioBuffer::AudioBuffer(const String &filename) {
	if (filename.ExtractExt() == "wav") {
		m_alBuffer = 0;
		File * file = new File(filename, FILE_READ);

		int32 chunkId = file->ReadInt();
		int32 riffChunkSize = file->ReadInt();
		int32 format = file->ReadInt();
		int32 subChunkId = file->ReadInt();
		int32 fmtChunkSize = file->ReadInt();
		int16 audioFormat = file->ReadInt16();
		int16 channels = file->ReadInt16();
		int32 sampleRate = file->ReadInt();
		int32 byteRate = file->ReadInt();
		int16 blockAlign = file->ReadInt16();
		int16 bitsPerSample = file->ReadInt16();
		if (fmtChunkSize > 16) {
			int16 extraParamsSize = file->ReadInt16();
			file->Seek(file->Pos() + extraParamsSize);
		}

		char text[5] = "";
		file->ReadBytes(text, 4);
		while (String(text) != "data" && !file->Eof()) {
			file->ReadBytes(text, 4);
			if (String(text) == "data")
				break;
			file->Seek(file->Pos() + 4);
		}

		int32 dataSize = file->ReadInt();
		uint32 * data = (uint32 *)malloc(dataSize);
		file->ReadBytes(data, dataSize);

		ALenum bufferFormat;
		if (bitsPerSample == 8) {
			if (channels == 1)
				bufferFormat = AL_FORMAT_MONO8;
			else
				bufferFormat = AL_FORMAT_STEREO8;
		}
		else {
			if (channels == 1)
				bufferFormat = AL_FORMAT_MONO16;
			else
				bufferFormat = AL_FORMAT_STEREO16;
		}

		alGenBuffers(1, &m_alBuffer);
		alBufferData(m_alBuffer, bufferFormat, data, dataSize, sampleRate);
		delete file;
		free(data);
	} else if (filename.ExtractExt() == "ogg") {
		stb_vorbis * file = stb_vorbis_open_filename(filename.ToCString(), nullptr, nullptr);

		if (file) {
			stb_vorbis_info info = stb_vorbis_get_info(file);
			uint32 size = stb_vorbis_stream_length_in_samples(file) * info.channels;
			int16 * buffer = (int16 *)malloc(size * sizeof(int16));
			stb_vorbis_get_samples_short_interleaved(file, info.channels, buffer, size);
			alGenBuffers(1, &m_alBuffer);
			ALenum bufferFormat;
			if (info.channels == 1)
				bufferFormat = AL_FORMAT_MONO16;
			else
				bufferFormat = AL_FORMAT_STEREO16;
			alBufferData(m_alBuffer, bufferFormat, buffer, size, info.sample_rate);
			stb_vorbis_close(file);
			free(buffer);
		}
	}
}
Example #6
0
File: map.cpp Project: diboh/CPP
Map::Map(const String &filename, uint16 firstColId) {
	// TAREA: Implementar constructor

	//Guardamos en las variables miembro los valores de filename y firstColId, y fijamos el valor de valid a false.
	this->filename = filename;
	this->firstColId = firstColId;
	valid = false;

	//Otras variables miembro
	width = 0;
	height = 0;
	tileWidth = 0;
	tileHeight = 0;

	//Cargamos en un objeto String el contenido del fichero.Esto lo podemos hacer mediante el método Read de dicha clase.
	String buffer = String::Read(filename);



	//Generamos un objeto del tipo xml_document<>, y llamamos a su método parse<0>
	//pasándole como parámetro el array de chars contenido en el string cargado
	//anteriormente(esto lo hacemos mediante su método ToCString).
	xml_document<> datosXML;
	datosXML.parse<0>((char*)buffer.ToCString());




	//Obtenemos el primer(y único) elemento(en RapidXML se llaman “nodos”) del
	//documento de nombre “map”, mediante el método first_node(“map”), y lo
	//guardamos en una variable de tipo xml_node<>*
	xml_node<>* nodoMap = datosXML.first_node("map");		
	

	//Guardamos los atributos “width”, “height”, “tilewidth” y “tileheight” del elemento en
	//las variables miembro correspondientes.Podemos obtener el valor de un atributo con el
	//método first_attribute(nombre)->value().Como se devuelve como un array de
	//caracteres, podemos convertirlo en un entero con la función atoi.	
	width		= atoi(nodoMap->first_attribute("width")->value());
	height		= atoi(nodoMap->first_attribute("height")->value());
	tileWidth	= atoi(nodoMap->first_attribute("tilewidth")->value());
	tileHeight	= atoi(nodoMap->first_attribute("tileheight")->value());



	//Obtenemos el primer elemento del nodo “map” llamado “tileset”(si hay más de un
	//tileset, ignoraremos el resto) y lo guardamos en una variable de tipo xml_node<>*.
	xml_node<>* nodoTileSet = nodoMap->first_node("tileset");

	
	
	//Obtenemos el valor de los atributos “firstgid”, “tilewidth”, “tileheight” del elemento, y
	//los guardamos en variables de tipo entero.
	int firstgid	= atoi( nodoTileSet->first_attribute("firstgid")->value() );
	int tilewidth	= atoi(nodoTileSet->first_attribute("tilewidth")->value());
	int tileheight	= atoi(nodoTileSet->first_attribute("tileheight")->value());




	//Si el elemento “tileset” contiene un elemento “tileoffset”, guardamos los atributos “x” e
	//“y” de éste en variables locales enteras.
	int tileOffsetX = 0, tileOffsetY = 0;

	if ( nodoTileSet->first_attribute("tileoffset") )
	{
		int tileOffsetX = atoi( nodoTileSet->first_attribute("x")->value() );
		int tileOffsetY = atoi(nodoTileSet->first_attribute("y")->value());
	} 





	//Obtenemos el primer(y único) elemento llamado “image” del tileset, y guardamos sus
	//atributos “source”, “width” y “height” en las variables miembro correspondientes.
	//Hay que tener en cuenta que el atributo “source” se guarda en la variable miembro
	//imageFile sin ruta, cosa que se puede conseguir utilizando el método StripDir de la
	//clase String.
	
	this->imageFile = String( nodoTileSet->first_node("image")->first_attribute("source")->value() ).StripDir();
	int imageWidth = atoi( nodoTileSet->first_node("image")->first_attribute("width")->value() );
	int imageHeight = atoi(nodoTileSet->first_node("image")->first_attribute("height")->value());





	//Obtenemos el primer elemento “layer” del mapa(el resto son ignorados), y de éste el
	//primer(y único) elemento “data”, y lo guardamos en una variable de tipo xml_node<>*.
	xml_node<>* nodoData = nodoMap->first_node("layer")->first_node("data");
	




	//Si el elemento “data” tiene atributos “encoding” o “compression”, salimos del
	//constructor, ya que la carga de mapas codificados o comprimidos no está soportada.
	if ( nodoData->first_attribute("encoding") || nodoData->first_attribute("compression") )
	{
		return;
	}





	//Obtenemos el primer elemento “tile” del elemento “data”, y lo guardamos en una
	//variable de tipo xml_node<>*.
	xml_node<>* nodoTile = nodoData->first_node("tile");





	//Mientras la variable anterior tenga un valor distinto de NULL :
	while ( nodoTile != NULL)
	{
		//Añadimos al vector tileIds el valor del atributo “gid” del tile.Hay que restarle
		//el valor del atributo “firstgid” que habíamos leído anteriormente en el tileset.
		tileIds.Add(atoi(nodoTile->first_attribute("gid")->value()) - firstgid);





		//Obtenemos el siguiente tile mediante el método next_sibling(“tile”) y lo
		//guardamos en la misma variable.
		nodoTile = nodoTile->next_sibling("tile");

	}





	






	//Por último, vamos a cargar la imagen del tileset.Lo haremos de la siguiente forma :
	//Su nombre de fichero debe ser la ruta al fichero.tmx(que podemos obtener con
	//la función ExtractDir de la clase String) concatenada con el nombre de la
	//imagen obtenido en el tileset.
	

	//El número de frames lo obtendremos dividiendo el ancho y alto de la imagen
	//leídos del XML entre el ancho y el alto de tile leídos en el tileset
	//respectivamente.
	
	image = ResourceManager::Instance().LoadImage(filename.ExtractDir() + "/" + imageFile, imageWidth / tilewidth, imageHeight / tileheight);
	
	
	//El handle de la imagen se debe establecer con los valores de los atributos “x” e
	//“y” leídos en el elemento “tileoffset”.
	image->SetHandle(tileOffsetX, tileOffsetY);





	//Antes de terminar, establecemos el valor de la variable miembro valid a true, para
	//indicar que hemos cargado correctamente el mapa.
	valid = true;

}
Example #7
0
Map::Map(const String &filename, uint16 firstColId) {
	String mapInfo;
	xml_document<> doc;
	xml_node<>* root;
	String attr;
	xml_node<>* tileSet;
	xml_node<>* tileOffSet;
	xml_node<>* image;
	xml_node<>* data;
	xml_node<>* tile;

	uint32 firstGId, tileWidth, tileHeight,x,y,imageW,imageH;
	x = y = 0;

	// TAREA: Implementar constructor
	this->filename = filename;
	this->firstColId = firstColId;
	this->valid = false;
	mapInfo = String::Read(filename);
	
	doc.parse<0>((char*)mapInfo.ToCString());
	root = doc.first_node("map");
	

	attr=root->first_attribute("width")->value();
	this->width = attr.ToInt();
	attr = root->first_attribute("height")->value();
	this->height = attr.ToInt();
	attr = root->first_attribute("tilewidth")->value();
	this->tileWidth = attr.ToInt();
	attr = root->first_attribute("tileheight")->value();
	this->tileHeight = attr.ToInt();
	
	tileSet = root->first_node("tileset");
	attr = tileSet->first_attribute("firstgid")->value();
	firstGId = attr.ToInt();
	attr = tileSet->first_attribute("tilewidth")->value();
	tileWidth = attr.ToInt();
	attr = tileSet->first_attribute("tileheight")->value();
	tileHeight = attr.ToInt();
	tileOffSet= tileSet->first_node("tileoffset");
	if (tileOffSet) {
		attr = tileOffSet->first_attribute("x")->value();
		x = attr.ToInt();
		attr = tileOffSet->first_attribute("y")->value();
		y = attr.ToInt();
	}
	image= tileSet->first_node("image");
	attr = image->first_attribute("source")->value();
	this->imageFile = attr.StripDir();
	attr = image->first_attribute("height")->value();
	imageH = attr.ToInt();
	attr = image->first_attribute("width")->value();
	imageW = attr.ToInt();

	data = root->first_node("layer")->first_node("data");
	if (data->first_attribute("encoding")) {
		return;
	}
	tile = data->first_node("tile");
	while (tile)
	{
		attr = tile->first_attribute("gid")->value();
		this->tileIds.Add(attr.ToInt() - firstGId);
		tile = tile->next_sibling("tile");
	}
	this->image=ResourceManager::Instance().LoadImage(filename.ExtractDir()+"/"+ this->imageFile, imageW / tileWidth, imageH / tileHeight);
	if (!this->image) {
		return;
	}
	this->image->SetHandle(x, y);
	this->valid = true;
}
 kt_size_t String::Find(const String& rValue) const
 {
   return m_pStringPrivate->m_String.find(rValue.ToCString());
 }
 void String::Append(const String& rString)
 {
   m_pStringPrivate->m_String.append(rString.ToCString());
 }
 kt_size_t String::FindLastOf(const String& rValue) const
 {
   return m_pStringPrivate->m_String.find_last_of(rValue.ToCString());
 }