自学教程：C++ IF_PRINT_WARNING函数代码示例

// The destructor frees all the modes still on the stackModeEngine::~ModeEngine(){    IF_PRINT_WARNING(MODE_MANAGER_DEBUG)            << "MODE MANAGER: ModeEngine destructor invoked" << std::endl;    // Delete any game modes on the stack    while(!_game_stack.empty()) {        delete _game_stack.back();        _game_stack.pop_back();    }    // Delete any game modes on the push stack    while(!_push_stack.empty()) {        delete _push_stack.back();        _push_stack.pop_back();    }    delete _help_window;}

void IndicatorSupervisor::AddHealingIndicator(uint32 amount, bool hit_points) {	const Color low_green(0.0f, 1.0f, 0.60f, 1.0f);	const Color mid_green(0.0f, 1.0f, 0.30f, 1.0f);	const Color high_green(0.0f, 1.0f, 0.15f, 1.0f);	const Color low_blue(0.0f, 0.60f, 1.0f, 1.0f);	const Color mid_blue(0.0f, 0.30f, 1.0f, 1.0f);	const Color high_blue(0.0f, 0.15f, 1.0f, 1.0f);	if (amount == 0) {		IF_PRINT_WARNING(BATTLE_DEBUG) << "function was given a zero value argument" << std::endl;		return;	}	std::string text = NumberToString(amount);	TextStyle style;	// TODO: use different colors/shades of green for different degrees of damage. There's a	// bug in rendering colored text that needs to be addressed first.	float healing_percent = static_cast<float>(amount / _actor->GetMaxHitPoints());	if (healing_percent < 0.10f) {		style.font = "text24";		style.color = hit_points ? low_green : low_blue;		style.shadow_style = VIDEO_TEXT_SHADOW_BLACK;	}	else if (healing_percent < 0.20f) {		style.font = "text24";		style.color = hit_points ? mid_green : mid_blue;		style.shadow_style = VIDEO_TEXT_SHADOW_BLACK;	}	else if (healing_percent < 0.30f) {		style.font = "text24";		style.color = hit_points ? high_green : high_blue;		style.shadow_style = VIDEO_TEXT_SHADOW_BLACK;	}	else { // (healing_percent >= 0.30f)		style.font = "text24";		style.color = hit_points ? Color::green : Color::blue;		style.shadow_style = VIDEO_TEXT_SHADOW_BLACK;	}	_wait_queue.push_back(new IndicatorText(_actor, text, style, HEALING_INDICATOR));}

uint16 CalculateOppositeDirection(const uint16 direction) {	switch (direction) {		case NORTH:      return SOUTH;		case SOUTH:      return NORTH;		case WEST:       return EAST;		case EAST:       return WEST;		case NW_NORTH:   return SE_SOUTH;		case NW_WEST:    return SE_EAST;		case NE_NORTH:   return SW_SOUTH;		case NE_EAST:    return SW_WEST;		case SW_SOUTH:   return NE_NORTH;		case SW_WEST:    return NE_EAST;		case SE_SOUTH:   return NW_NORTH;		case SE_EAST:    return NW_WEST;		default:			IF_PRINT_WARNING(MAP_DEBUG) << "invalid direction argument: " << direction << endl;			return SOUTH;	}}

bool DecrementIntensity(GLOBAL_INTENSITY &intensity, uint8 amount){    if(amount == 0)        return false;    if((intensity <= GLOBAL_INTENSITY_NEG_EXTREME) || (intensity >= GLOBAL_INTENSITY_TOTAL))        return false;    // This check protects against overflow conditions    if(amount > (GLOBAL_INTENSITY_TOTAL * 2)) {        IF_PRINT_WARNING(GLOBAL_DEBUG) << "attempted to decrement intensity by an excessive amount: " << amount << std::endl;        intensity = GLOBAL_INTENSITY_NEG_EXTREME;        return true;    }    intensity = GLOBAL_INTENSITY(intensity - amount);    if(intensity <= GLOBAL_INTENSITY_INVALID)        intensity = GLOBAL_INTENSITY_NEG_EXTREME;    return true;}

void DialogueSupervisor::AnnounceDialogueUpdate(uint32 dialogue_id) {	map<uint32, vector<uint32> >::iterator entry = _sprite_references.find(dialogue_id);	// Note that we don't print a warning if no entry was found, because the case where a dialogue exists	// but is not referenced by any sprites is a valid one	if (entry == _sprite_references.end())		return;	// Update the dialogue status of all sprites that reference this dialogue	for (uint32 i = 0; i < entry->second.size(); i++) {		MapSprite* referee = static_cast<MapSprite*>(MapMode::CurrentInstance()->GetObjectSupervisor()->GetObject(entry->second[i]));		if (referee == NULL) {			IF_PRINT_WARNING(MAP_DEBUG) << "map sprite: " << entry->second[i] << " references dialogue: " << dialogue_id << " but sprite object did not exist"<< endl;		}		else {			referee->UpdateDialogueStatus();		}	}}

void AudioSource::Reset(){    owner = NULL;    if(IsValid() == false) {        return;    }    alSourcei(source, AL_LOOPING, AL_FALSE);    alSourcef(source, AL_GAIN, 1.0f);    alSourcei(source, AL_SAMPLE_OFFSET, 0);		// This line will cause AL_INVALID_ENUM error in linux/Solaris. It is normal.    alSourcei(source, AL_BUFFER, 0);    if(AudioManager->CheckALError()) {#ifdef WIN32        IF_PRINT_WARNING(AUDIO_DEBUG) << "resetting source failed: " << AudioManager->CreateALErrorString() << std::endl;#endif    }}

void ResidentZone::AddPotentialResident(VirtualSprite* sprite) {	if (sprite == NULL) {		IF_PRINT_WARNING(MAP_DEBUG) << "function received NULL argument" << endl;		return;	}	// Check that sprite is not already a resident	if (IsSpriteResident(sprite) == true) {		return;	}	// Check that the sprite's context is compatible with this zone and is located within the zone boundaries	if (sprite->GetContext() & _active_contexts) {		if (IsInsideZone(sprite->GetXPosition(), sprite->GetYPosition())) {			_entering_residents.insert(sprite);			_residents.insert(sprite);		}	}}

void TreasureObject::Open(){    if(!_treasure) {        PRINT_ERROR << "Can't open treasure with invalid treasure content." << std::endl;        return;    }    if(_treasure->IsTaken()) {        IF_PRINT_WARNING(MAP_DEBUG) << "attempted to retrieve an already taken treasure: " << _object_id << std::endl;        return;    }    // Test whether events should be triggered    if (_events.empty())        _events_triggered = true;    SetCurrentAnimation(TREASURE_OPENING_ANIM);    _is_opening = true;}

void VideoEngine::MakeScreenshot(const std::string &filename){    private_video::ImageMemory buffer;    // Retrieve the width and height of the viewport.    GLint viewport_dimensions[4]; // viewport_dimensions[2] is the width, [3] is the height    glGetIntegerv(GL_VIEWPORT, viewport_dimensions);    // Buffer to store the image before it is flipped    buffer.width = viewport_dimensions[2];    buffer.height = viewport_dimensions[3];    buffer.pixels = malloc(buffer.width * buffer.height * 3);    buffer.rgb_format = true;    // Read the viewport pixel data    glReadPixels(viewport_dimensions[0], viewport_dimensions[1],                 buffer.width, buffer.height, GL_RGB, GL_UNSIGNED_BYTE, buffer.pixels);    if(CheckGLError() == true) {        IF_PRINT_WARNING(VIDEO_DEBUG) << "an OpenGL error occured: " << CreateGLErrorString() << std::endl;        free(buffer.pixels);        buffer.pixels = NULL;        return;    }    // Vertically flip the image, then swap the flipped and original images    void *buffer_temp = malloc(buffer.width * buffer.height * 3);    for(uint32 i = 0; i < buffer.height; ++i) {        memcpy((uint8 *)buffer_temp + i * buffer.width * 3,               (uint8 *)buffer.pixels + (buffer.height - i - 1) * buffer.width * 3, buffer.width * 3);    }    void *temp = buffer.pixels;    buffer.pixels = buffer_temp;    buffer_temp = temp;    buffer.SaveImage(filename);    free(buffer_temp);    free(buffer.pixels);    buffer.pixels = NULL;}

void DialogueSupervisor::AddSpeaker(const std::string& speaker_id, const std::string& name, const std::string& portrait){    if(_speakers.find(speaker_id) != _speakers.end()) {        PRINT_WARNING << "Speaker already existed with requested id: " << speaker_id << std::endl;        return;    }    Speaker new_speaker;    new_speaker.name = MakeUnicodeString(name);    if(!portrait.empty()) {        if(!new_speaker.portrait.Load(portrait)) {            IF_PRINT_WARNING(COMMON_DEBUG) << "invalid image filename for new portrait: " << portrait << std::endl;        }        // Make sure the portrait doesn't go over the screen edge.        if(new_speaker.portrait.GetHeight() > 130.0f)            new_speaker.portrait.SetHeightKeepRatio(130.0f);    }    _speakers[speaker_id] = new_speaker;}

void WriteScriptDescriptor::CloseFile() {	if (IsFileOpen() == false) {		IF_PRINT_WARNING(SCRIPT_DEBUG)			<< "SCRIPT ERROR: in WriteScriptDescriptor::CloseFile(), could not close the "			<< "file because it was not open." << std::endl;		return;	}	if (SCRIPT_DEBUG && IsErrorDetected()) {		PRINT_WARNING << "SCRIPT WARNING: In WriteScriptDescriptor::CloseFile(), the file " << _filename			<< " had error messages remaining. They are as follows:" << std::endl		    << _error_messages.str() << std::endl;	}	_outfile.close();	_error_messages.clear();	_open_tables.clear();	_access_mode = SCRIPT_CLOSED;	ScriptManager->_RemoveOpenFile(this);}

void AudioEngine::PlaySound(const std::string &filename){    std::map<std::string, AudioCacheElement>::iterator element = _audio_cache.find(filename);    if(element == _audio_cache.end()) {        // Don't check the current game mode to prevent the sound unloading in certain cases.        // We'll let the audio cache handle it all atm.        if(!LoadSound(filename)) {            IF_PRINT_WARNING(AUDIO_DEBUG)                    << "could not play sound from cache because "                    "the sound could not be loaded" << std::endl;            return;        } else {            element = _audio_cache.find(filename);        }    }    element->second.audio->Play();    element->second.last_update_time = SDL_GetTicks();}

bool TextureController::_SaveTempTextures() {	bool success = true;	for (map<string, ImageTexture*>::iterator i = _images.begin(); i != _images.end(); i++) {		ImageTexture *image = i->second;		// Check that this is a temporary texture and if so, save it to disk as a .png file		if (image->tags.find("<T>") != string::npos) {			IF_PRINT_DEBUG(VIDEO_DEBUG) << " saving temporary texture " << image->filename << endl;			ImageMemory buffer;			buffer.CopyFromImage(image);			string path = GetUserDataPath(true);			if (buffer.SaveImage(path + image->filename + ".png", true) == false) {				success = false;				IF_PRINT_WARNING(VIDEO_DEBUG) << "call to ImageMemory::SaveImage() failed" << endl;			}		}	}	return success;}

void DialogueSupervisor::BeginDialogue(uint32 dialogue_id){    SpriteDialogue *dialogue = GetDialogue(dialogue_id);    if(dialogue == NULL) {        PRINT_WARNING << "Could not begin dialogue because none existed for id: " << dialogue_id << std::endl            << "Did you register the dialogue using 'AddDialogue()'?" << std::endl;        return;    }    if(_current_dialogue != NULL) {        IF_PRINT_WARNING(COMMON_DEBUG) << "beginning a new dialogue while another dialogue is still active" << std::endl;    }    _line_counter = 0;    _current_dialogue = dialogue;    _emote_triggered = false;    _BeginLine();    MapMode::CurrentInstance()->PushState(STATE_DIALOGUE);}

void TextBox::Draw(){    if(_text.empty())        return;    if(_initialized == false) {        IF_PRINT_WARNING(VIDEO_DEBUG) << "function failed because the textbox was not initialized:/n" << _initialization_errors << std::endl;        return;    }    // Don't draw text window if parent window is hidden    if(_owner && _owner->GetState() == VIDEO_MENU_STATE_HIDDEN)        return;    VideoManager->PushState();    VideoManager->SetDrawFlags(_xalign, _yalign, VIDEO_BLEND, 0);    /*    // TODO: this block of code (scissoring for textboxes) does not work properly    if (_owner) {    	rect.Intersect(_owner->GetScissorRect());    }    rect.Intersect(VideoManager->GetScissorRect());    VideoManager->EnableScissoring(_owner || VideoManager->IsScissoringEnabled());    if (VideoManager->IsScissoringEnabled()) {    	VideoManager->SetScissorRect(_scissor_rect);    }    */    // Set the draw cursor, draw flags, and draw the text    VideoManager->Move(0.0f, _text_ypos);    VideoManager->SetDrawFlags(VIDEO_X_LEFT, VIDEO_Y_TOP, VIDEO_BLEND, 0);    _DrawTextLines(_text_xpos, _text_ypos, _scissor_rect);    if(GUIManager->DEBUG_DrawOutlines())        _DEBUG_DrawOutline();    VideoManager->PopState();} // void TextBox::Draw()

AudioMemory::AudioMemory(AudioInput *input) :    AudioInput(),    _audio_data(nullptr),    _data_position(0){    _filename = input->GetFilename();    _samples_per_second = input->GetSamplesPerSecond();    _bits_per_sample = input->GetBitsPerSample();    _number_channels = static_cast<uint8_t>(input->GetNumberChannels());    _total_number_samples = input->GetTotalNumberSamples();    _sample_size = input->GetSampleSize();    _play_time = input->GetPlayTime();    _data_size = input->GetDataSize();    _audio_data = new uint8_t[input->GetDataSize()];    bool all_data_read = false;    input->Read(_audio_data, input->GetTotalNumberSamples(), all_data_read);    if(all_data_read == false) {        IF_PRINT_WARNING(AUDIO_DEBUG) << "failed to read entire audio data stream for file: " << _filename << std::endl;    }}

bool TextTexture::Reload(){    // Regenerate text image if it is not already loaded in a texture sheet    if(texture_sheet == NULL)        return Regenerate();    ImageMemory buffer;    if(TextManager->_RenderText(string, style, buffer) == false)        return false;    if(texture_sheet->CopyRect(x, y, buffer) == false) {        IF_PRINT_WARNING(VIDEO_DEBUG) << "call to TextureSheet::CopyRect() failed" << std::endl;        free(buffer.pixels);        buffer.pixels = NULL;        return false;    }    free(buffer.pixels);    buffer.pixels = NULL;    return true;}

bool BattleTarget::IsValid(bool permit_dead_targets) {	// No dead enemies can be selected here.	if (IsTargetPoint(_type)) {		if (!_actor)			return false;		bool enemy_actor = _actor->IsEnemy();		if (_point >= _actor->GetAttackPoints().size())			return false;		// We extra check the actor HP since the state might desynced on purpose.		else if (!_actor->IsAlive() || _actor->GetHitPoints() == 0)			return !enemy_actor && permit_dead_targets;		else if (_actor->GetState() == ACTOR_STATE_DYING)			return !enemy_actor && permit_dead_targets;		else			return true;	}	else if (IsTargetActor(_type) == true) {		if (!_actor)			return false;		bool enemy_actor = _actor->IsEnemy();		if (!_actor->IsAlive() || _actor->GetHitPoints() == 0)			return !enemy_actor && permit_dead_targets;		else if (_actor->GetState() == ACTOR_STATE_DYING)			return !enemy_actor && permit_dead_targets;		else			return true;	}	else if (IsTargetParty(_type)) {		if (!_party)			return false;		else			return true;	}	else {		IF_PRINT_WARNING(BATTLE_DEBUG) << "invalid target type: " << _type << std::endl;		return false;	}}

void TradeInterface::_UpdateAvailableTradeDealTypes(){    _trade_deal_types = 0;    // Determine what types of objects the shop deals in based on the managed object list    std::map<uint32, ShopObject *>* trade_objects = ShopMode::CurrentInstance()->GetAvailableTrade();    for(std::map<uint32, ShopObject *>::iterator it = trade_objects->begin(); it != trade_objects->end(); ++it) {        vt_global::GLOBAL_OBJECT object_type = it->second->GetObject()->GetObjectType();        switch(object_type) {        case GLOBAL_OBJECT_ITEM:            _trade_deal_types |= DEALS_ITEMS;            break;        case GLOBAL_OBJECT_WEAPON:            _trade_deal_types |= DEALS_WEAPONS;            break;        case GLOBAL_OBJECT_HEAD_ARMOR:            _trade_deal_types |= DEALS_HEAD_ARMOR;            break;        case GLOBAL_OBJECT_TORSO_ARMOR:            _trade_deal_types |= DEALS_TORSO_ARMOR;            break;        case GLOBAL_OBJECT_ARM_ARMOR:            _trade_deal_types |= DEALS_ARM_ARMOR;            break;        case GLOBAL_OBJECT_LEG_ARMOR:            _trade_deal_types |= DEALS_LEG_ARMOR;            break;        case GLOBAL_OBJECT_SPIRIT:            _trade_deal_types |= DEALS_SPIRIT;            break;        default:            IF_PRINT_WARNING(SHOP_DEBUG) << "unknown object type sold in shop: " << object_type << std::endl;            break;        }        // Also test whether this is a key item        if (it->second->GetObject()->IsKeyItem())            _trade_deal_types |= DEALS_KEY_ITEMS;    }}

bool ParticleEffect::Update(float frame_time){    _age += frame_time;    _num_particles = 0;    if(!_alive)        return true;    bool success = true;    hoa_mode_manager::EffectParameters effect_parameters;    effect_parameters.orientation = _orientation;    // note we subtract the effect position to put the attractor point in effect    // space instead of screen space    effect_parameters.attractor_x = _attractor_x - _x;    effect_parameters.attractor_y = _attractor_y - _y;    std::vector<ParticleSystem>::iterator iSystem = _systems.begin();    while(iSystem != _systems.end()) {        if(!(*iSystem).IsAlive()) {            iSystem = _systems.erase(iSystem);            if(_systems.empty())                _alive = false;        } else {            if(!(*iSystem).Update(frame_time, effect_parameters)) {                success = false;                IF_PRINT_WARNING(VIDEO_DEBUG)                        << "Failed to update system!" << std::endl;            }            _num_particles += (*iSystem).GetNumParticles();            ++iSystem;        }    }    return success;}

void EnemyZone::AddEnemy(EnemySprite* enemy, MapMode* map, uint8 count) {	if (count == 0) {		IF_PRINT_WARNING(MAP_DEBUG) << "function called with a count argument equal to zero" << endl;		return;	}	// Prepare the first enemy	enemy->SetZone(this);	map->AddGroundObject(enemy);	_enemies.push_back(enemy);	// Create any additional copies of the enemy and add them as well	for (uint8 i = 1; i < count; i++) {		EnemySprite* copy = new EnemySprite(*enemy);		copy->SetObjectID(map->GetObjectSupervisor()->GenerateObjectID());		// Add a 10% random margin of error to make enemies look less synchronized		copy->SetTimeToChange(static_cast<uint32>(copy->GetTimeToChange() * (1 + RandomFloat() * 10)));		copy->Reset();		map->AddGroundObject(copy);		_enemies.push_back(copy);	}}

IndicatorElement::IndicatorElement(BattleActor* actor, INDICATOR_TYPE indicator_type) :	_actor(actor),	_timer(INDICATOR_TIME),	_alpha_color(1.0f, 1.0f, 1.0f, 0.0f),	_y_force(INITIAL_FORCE),	_x_position(0.0f),	_y_position(0.0f),	_x_absolute_position(0.0f),	_y_absolute_position(0.0f),	_indicator_type(indicator_type){	if (actor == NULL)		IF_PRINT_WARNING(BATTLE_DEBUG) << "constructor received NULL actor argument" << std::endl;    _x_force = RandomFloat(-20.0f, 20.0f);    // Setup a default aboslute position    if (_actor) {        _x_absolute_position = _actor->GetXLocation();        _y_absolute_position = _actor->GetYLocation();    }}

bool TexSheet::CopyScreenRect(int32 x, int32 y, const ScreenRect &screen_rect){    TextureManager->_BindTexture(tex_id);    glCopyTexSubImage2D(        GL_TEXTURE_2D, // target        0, // level        x, // x offset within tex sheet        y, // y offset within tex sheet        screen_rect.left, // left starting pixel of the screen to copy        screen_rect.top, // top starting pixel of the screen to copy        screen_rect.width, // width in pixels of image        screen_rect.height // height in pixels of image    );    if(VideoManager->CheckGLError() == true) {        IF_PRINT_WARNING(VIDEO_DEBUG) << "an OpenGL error occured: " << VideoManager->CreateGLErrorString() << std::endl;        return false;    }    return true;}

void IndicatorSupervisor::AddDamageIndicator(uint32 amount) {	const Color low_red(1.0f, 0.75f, 0.0f, 1.0f);	const Color mid_red(1.0f, 0.50f, 0.0f, 1.0f);	const Color high_red(1.0f, 0.25f, 0.0f, 1.0f);	const Color full_red(Color::red);	if (amount == 0) {		IF_PRINT_WARNING(BATTLE_DEBUG) << "function was given a zero value argument" << std::endl;		return;	}	std::string text = NumberToString(amount);	TextStyle style;	float damage_percent = static_cast<float>(amount) / static_cast<float>(_actor->GetMaxHitPoints());	if (damage_percent < 0.10f) {		style.font = "text24";		style.color = low_red;		style.shadow_style = VIDEO_TEXT_SHADOW_BLACK;	}	else if (damage_percent < 0.20f) {		style.font = "text24";		style.color = mid_red;		style.shadow_style = VIDEO_TEXT_SHADOW_BLACK;	}	else if (damage_percent < 0.30f) {		style.font = "text24";		style.color = high_red;		style.shadow_style = VIDEO_TEXT_SHADOW_BLACK;	}	else { // (damage_percent >= 0.30f)		style.font = "text24";		style.color = full_red;		style.shadow_style = VIDEO_TEXT_SHADOW_BLACK;	}	_wait_queue.push_back(new IndicatorText(_actor, text, style, DAMAGE_INDICATOR));}

void DialogueSupervisor::_BeginLine() {	_state = DIALOGUE_STATE_LINE;	_current_options = _current_dialogue->GetLineOptions(_line_counter);	// Initialize the line timer	if (_current_dialogue->GetLineDisplayTime(_line_counter) >= 0) {		_line_timer.Initialize(_current_dialogue->GetLineDisplayTime(_line_counter));		_line_timer.Run();	}	// If the line has no timer specified, set the line time to zero and put the timer in the finished state	else {		_line_timer.Initialize(0);		_line_timer.Finish();	}	// Setup the text and graphics for the dialogue window	_dialogue_window.Clear();	_dialogue_window.GetDisplayTextBox().SetDisplayText(_current_dialogue->GetLineText(_line_counter));	if (_current_options != NULL) {		for (uint32 i = 0; i < _current_options->GetNumberOptions(); i++) {			_dialogue_window.GetDisplayOptionBox().AddOption(_current_options->GetOptionText(i));		}		_dialogue_window.GetDisplayOptionBox().SetSelection(0);	}	BattleSpeaker* line_speaker = GetSpeaker(_current_dialogue->GetLineSpeaker(_line_counter));	if (line_speaker == NULL) {		IF_PRINT_WARNING(BATTLE_DEBUG) << "dialogue #" << _current_dialogue->GetDialogueID()			<< " referenced a speaker that did not exist with id: " << _current_dialogue->GetLineSpeaker(_line_counter) << std::endl;		_dialogue_window.GetNameText().SetText("");		_dialogue_window.SetPortraitImage(NULL);	}	else {		_dialogue_window.GetNameText().SetText(line_speaker->name);		_dialogue_window.SetPortraitImage(&(line_speaker->portrait));	}}

void EffectSupervisor::EnableLightning(int16 id, bool loop){    if(id > -1 && id < (int16)_lightning_inner_info._lightning_data.size()) {        _info.lightning.active_id = id;        _info.lightning.active = true;        _info.lightning.loop = loop;        _lightning_inner_info._lightning_current_time = 0;        // Load the current sound events        _lightning_inner_info._current_lightning_sound_events.clear();        std::vector<LightningVideoManagerInfo::lightning_sound_event>::iterator it, it_end;        for(it = _lightning_inner_info._lightning_sound_events.at(id).begin(),                it_end = _lightning_inner_info._lightning_sound_events.at(id).end(); it != it_end; ++it) {            _lightning_inner_info._current_lightning_sound_events.push_back(*it);            // Preload the files for efficiency            vt_audio::AudioManager->LoadSound(it->sound_filename);        }    } else {        IF_PRINT_WARNING(VIDEO_DEBUG) << "Invalid lightning effect requested: "                                      << id << ", the effect won't be displayed." << std::endl;        DisableLightning();    }}

bool BattleDialogue::Validate() {	if (CommonDialogue::Validate() == false) {		// The BattleDialogue::Validate() call will print the appropriate warning if debugging is enabled (common code debugging that is)		return false;	}	// Construct containers that hold all unique sprite and event ids for this dialogue	std::set<uint32> speaker_ids;	for (uint32 i = 0; i < _line_count; i++) {		speaker_ids.insert(_speakers[i]);	}	// Check that all sprites and events referrenced by the dialogue exist	for (std::set<uint32>::iterator i = speaker_ids.begin(); i != speaker_ids.end(); i++) {		if (BattleMode::CurrentInstance()->GetDialogueSupervisor()->GetSpeaker(*i) == NULL) {			IF_PRINT_WARNING(BATTLE_DEBUG) << "Validation failed for dialogue #" << _dialogue_id				<< ": dialogue referenced invalid speaker with id: " << *i << std::endl;			return false;		}	}	return true;}

bool TexSheet::CopyRect(int32 x, int32 y, ImageMemory &data){    TextureManager->_BindTexture(tex_id);    glTexSubImage2D(        GL_TEXTURE_2D, // target        0, // level        x, // x offset within tex sheet        y, // y offset within tex sheet        data.width, // width in pixels of image        data.height, // height in pixels of image        (data.rgb_format ? GL_RGB : GL_RGBA), // format        GL_UNSIGNED_BYTE, // type        data.pixels // pixels of the sub image    );    if(VideoManager->CheckGLError() == true) {        IF_PRINT_WARNING(VIDEO_DEBUG) << "an OpenGL error occured: " << VideoManager->CreateGLErrorString() << std::endl;        return false;    }    return true;}

bool ReadScriptDescriptor::OpenFile(const string& filename, bool force_reload) {	// Check for file extensions	string file_name = filename;	if (DoesFileExist(file_name + ".lua")) {		file_name = filename + ".lua";	}	if (DoesFileExist(file_name + ".hoa")) {		if (!(DoesFileExist(file_name + ".lua") && SCRIPT_DEBUG))			file_name = filename + ".hoa";	}	if (ScriptManager->IsFileOpen(file_name) == true) {		IF_PRINT_WARNING(SCRIPT_DEBUG) << "attempted to open file that is already opened: " << file_name << endl;		return false;	}	// Check if this file was opened previously.	if ((force_reload == true) || (_lstack = ScriptManager->_CheckForPreviousLuaState(file_name)) == NULL) {		// Increases the global stack size by 1 element. That is needed because the new thread will be pushed in the		// stack and we have to be sure there is enough space there.		lua_checkstack(ScriptManager->GetGlobalState(), 1);		_lstack = lua_newthread(ScriptManager->GetGlobalState());		// Attempt to load and execute the Lua file		if (luaL_loadfile(_lstack, file_name.c_str()) != 0 || lua_pcall(_lstack, 0, 0, 0)) {			PRINT_ERROR << "could not open script file: " << file_name << ", error message:" << endl;			cerr << lua_tostring(_lstack, private_script::STACK_TOP) << endl;			_access_mode = SCRIPT_CLOSED;			return false;		}	}	_filename = file_name;	_access_mode = SCRIPT_READ;	ScriptManager->_AddOpenFile(this);	return true;} // bool ReadScriptDescriptor::OpenFile(string file_name, bool force_reload)

bool FixedTexSheet::InsertTexture(BaseTexture *img){    if(img == nullptr) {        IF_PRINT_WARNING(VIDEO_DEBUG) << "nullptr pointer was given as function argument" << std::endl;        return false;    }    // Retrieve the node from the head of the list to use for this texture    FixedTexNode *node = _RemoveOpenNode();    if(node == nullptr)  // This condition indicates that there are no remaining free nodes on the open list        return false;    // Check if there's already an image allocated at this block (an image was freed earlier, but not removed)    // If so, we must now remove it from memory    if(node->image != nullptr) {        // TODO: TextureManager needs to have the image element removed from its map containers        node->image = nullptr;    }    // Calculate the texture's pixel coordinates in the sheet given this node's block index    img->x = _texture_width * (node->block_index % _block_width);    img->y = _texture_height * (node->block_index / _block_width);    // Calculate the u,v coordinates    float sheet_width = static_cast<float>(width);    float sheet_height = static_cast<float>(height);    img->u1 = static_cast<float>(img->x + 0.5f) / sheet_width;    img->u2 = static_cast<float>(img->x + img->width - 0.5f) / sheet_width;    img->v1 = static_cast<float>(img->y + 0.5f) / sheet_height;    img->v2 = static_cast<float>(img->y + img->height - 0.5f) / sheet_height;    img->texture_sheet = this;    node->image = img;    return true;} // bool FixedTexSheet::InsertTexture(BaseTexture* img)