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

/** * Searches levels folder for LIF files and adds them to campaign levels list. */TbBool find_and_load_lif_files(void){  struct TbFileFind fileinfo;  unsigned char *buf;  char *fname;  short result;  int rc;  long i;  buf = LbMemoryAlloc(MAX_LIF_SIZE);  if (buf == NULL)  {    ERRORLOG("Can't allocate memory for .LIF files parsing.");    return false;  }  result = false;  fname = prepare_file_path(FGrp_VarLevels,"*.lif");  rc = LbFileFindFirst(fname, &fileinfo, 0x21u);  while (rc != -1)  {    fname = prepare_file_path(FGrp_VarLevels,fileinfo.Filename);    i = LbFileLength(fname);    if ((i < 0) || (i >= MAX_LIF_SIZE))    {      WARNMSG("File /"%s/" too long (Max size %d)", fileinfo.Filename, MAX_LIF_SIZE);    } else    if (LbFileLoadAt(fname, buf) != i)    {      WARNMSG("Unable to read .LIF file, /"%s/"", fileinfo.Filename);    } else    {      buf[i] = '/0';      if (level_lif_file_parse(fileinfo.Filename, (char *)buf, i))        result = true;    }    rc = LbFileFindNext(&fileinfo);  }  LbFileFindEnd(&fileinfo);  LbMemoryFree(buf);  return result;}

Instrument* Instrument::load_from( XMLNode* node, const QString& dk_path, const QString& dk_name ){	int id = node->read_int( "id", EMPTY_INSTR_ID, false, false );	if ( id==EMPTY_INSTR_ID ) return 0;	Instrument* instrument = new Instrument( id, node->read_string( "name", "" ), 0 );	instrument->set_drumkit_name( dk_name );	instrument->set_volume( node->read_float( "volume", 1.0f ) );	instrument->set_muted( node->read_bool( "isMuted", false ) );	instrument->set_pan_l( node->read_float( "pan_L", 1.0f ) );	instrument->set_pan_r( node->read_float( "pan_R", 1.0f ) );	// may not exist, but can't be empty	instrument->set_filter_active( node->read_bool( "filterActive", true, false ) );	instrument->set_filter_cutoff( node->read_float( "filterCutoff", 1.0f, true, false ) );	instrument->set_filter_resonance( node->read_float( "filterResonance", 0.0f, true, false ) );	instrument->set_random_pitch_factor( node->read_float( "randomPitchFactor", 0.0f, true, false ) );	float attack = node->read_float( "Attack", 0.0f, true, false );	float decay = node->read_float( "Decay", 0.0f, true, false  );	float sustain = node->read_float( "Sustain", 1.0f, true, false );	float release = node->read_float( "Release", 1000.0f, true, false );	instrument->set_adsr( new ADSR( attack, decay, sustain, release ) );	instrument->set_gain( node->read_float( "gain", 1.0f, true, false ) );	instrument->set_mute_group( node->read_int( "muteGroup", -1, true, false ) );	instrument->set_midi_out_channel( node->read_int( "midiOutChannel", -1, true, false ) );	instrument->set_midi_out_note( node->read_int( "midiOutNote", MIDI_MIDDLE_C, true, false ) );	instrument->set_stop_notes( node->read_bool( "isStopNote", true ,false ) );	for ( int i=0; i<MAX_FX; i++ ) {		instrument->set_fx_level( node->read_float( QString( "FX%1Level" ).arg( i+1 ), 0.0 ), i );	}	int n = 0;	XMLNode layer_node = node->firstChildElement( "layer" );	while ( !layer_node.isNull() ) {		if ( n >= MAX_LAYERS ) {			ERRORLOG( QString( "n >= MAX_LAYERS (%1)" ).arg( MAX_LAYERS ) );			break;		}		instrument->set_layer( InstrumentLayer::load_from( &layer_node, dk_path ), n );		n++;		layer_node = layer_node.nextSiblingElement( "layer" );	}	return instrument;}

short good_wait_in_exit_door(struct Thing *thing){    struct CreatureControl *cctrl;    struct Thing *tmptng;    // Debug code to find incorrect states    if (!is_hero_thing(thing))    {        ERRORLOG("Non hero thing %s index %d, owner %d - reset",            thing_model_name(thing), (int)thing->index, (int)thing->owner);        set_start_state(thing);        erstat_inc(ESE_BadCreatrState);        return 0;    }    //return _DK_good_wait_in_exit_door(thing);    cctrl = creature_control_get_from_thing(thing);    if (cctrl->field_282 <= 0)        return 0;    cctrl->field_282--;    if (cctrl->field_282 == 0)    {        tmptng = find_base_thing_on_mapwho(TCls_Object, 49, thing->mappos.x.stl.num, thing->mappos.y.stl.num);        if (!thing_is_invalid(tmptng))        {            if (cctrl->byte_8A == tmptng->creation_turn)            {                remove_thing_from_creature_controlled_limbo(thing);                set_start_state(thing);                return 1;            }        }        thing->creature.gold_carried = 0;        tmptng = thing_get(cctrl->dragtng_idx);        TRACE_THING(tmptng);        if (!thing_is_invalid(tmptng))        {            delete_thing_structure(tmptng, 0);        }        kill_creature(thing, INVALID_THING, -1, CrDed_NoEffects|CrDed_NotReallyDying);    }    return 0;}

short good_back_at_start(struct Thing *thing){    // Debug code to find incorrect states    if (!is_hero_thing(thing))    {        ERRORLOG("Non hero thing %ld, %s, owner %ld - reset",(long)thing->index,thing_model_name(thing),(long)thing->owner);        set_start_state(thing);        return false;    }    //return _DK_good_back_at_start(thing);    if (thing->creature.gold_carried <= 0)    {        set_start_state(thing);        return 1;    }    SubtlCodedCoords stl_num;    long m,n;    stl_num = get_subtile_number(thing->mappos.x.stl.num,thing->mappos.y.stl.num);    m = ACTION_RANDOM(AROUND_MAP_LENGTH);    for (n=0; n < AROUND_MAP_LENGTH; n++)    {        struct Map *mapblk;        mapblk = get_map_block_at_pos(stl_num+around_map[m]);        // Per-block code        if ((mapblk->flags & MapFlg_IsTall) == 0)        {            MapSubtlCoord stl_x, stl_y;            stl_x = stl_num_decode_x(stl_num+around_map[m]);            stl_y = stl_num_decode_y(stl_num+around_map[m]);            if (setup_person_move_to_position(thing, stl_x, stl_y, NavRtF_Default)) {                thing->continue_state = CrSt_GoodDropsGold;                return 1;            }        }        // Per-block code ends        m = (m + 1) % AROUND_MAP_LENGTH;    }    set_start_state(thing);    return 1;}

/** * Returns if the door was at least one built by a player. */TbBool is_door_built(PlayerNumber plyr_idx, long door_idx){    struct Dungeon *dungeon;    dungeon = get_players_num_dungeon(plyr_idx);    // Check if the player even have a dungeon    if (dungeon_invalid(dungeon)) {        return false;    }    // Player must have dungeon heart to build anything    if (!player_has_heart(plyr_idx)) {        return false;    }    if ((door_idx <= 0) || (door_idx >= DOOR_TYPES_COUNT)) {        ERRORLOG("Incorrect door %d (player %d)",(int)door_idx, (int)plyr_idx);        return false;    }    if ((dungeon->door_build_flags[door_idx] & MnfBldF_Built) != 0) {        return true;    }    return false;}

/** * Returns if the trap can be placed by a player. * Checks only if it's available and if the player is 'alive'. * Doesn't check if map position is on correct spot. */TbBool is_trap_placeable(PlayerNumber plyr_idx, long tngmodel){    struct Dungeon *dungeon;    dungeon = get_players_num_dungeon(plyr_idx);    // Check if the player even have a dungeon    if (dungeon_invalid(dungeon)) {        return false;    }    // Player must have dungeon heart to place traps    if (!player_has_heart(plyr_idx)) {        return false;    }    if ((tngmodel <= 0) || (tngmodel >= TRAP_TYPES_COUNT)) {        ERRORLOG("Incorrect trap %d (player %d)",(int)tngmodel, (int)plyr_idx);        return false;    }    if (dungeon->trap_amount_placeable[tngmodel] > 0) {        return true;    }    return false;}

struct Thing *get_group_last_member(struct Thing *thing){    struct Thing *ctng;    struct CreatureControl *cctrl;    long k;    ctng = thing;    cctrl = creature_control_get_from_thing(ctng);    k = 0;    while (cctrl->next_in_group > 0)    {        ctng = thing_get(cctrl->next_in_group);        cctrl = creature_control_get_from_thing(ctng);        k++;        if (k > CREATURES_COUNT)        {          ERRORLOG("Infinite loop detected when sweeping creatures group");          break;        }    }    return ctng;}

short creature_choose_room_for_lair_site(struct Thing *thing){    TRACE_THING(thing);    //return _DK_creature_choose_room_for_lair_site(thing);    struct Room *room;    room = get_best_new_lair_for_creature(thing);    if (room_is_invalid(room))    {        update_cannot_find_room_wth_spare_capacity_event(thing->owner, thing, RoK_LAIR);        set_start_state(thing);        return 0;    }    if (!setup_head_for_random_unused_lair_slab(thing, room))    {        ERRORLOG("Chosen lair is not valid, internal inconsistency.");        set_start_state(thing);        return 0;    }    thing->continue_state = CrSt_CreatureAtNewLair;    return 1;}

void TransportInfo::printInfo(){	switch ( m_status ) {	case STOPPED:		INFOLOG( "status = STOPPED" );		break;	case ROLLING:		INFOLOG( "status = ROLLING" );		break;	case BAD:		INFOLOG( "status = BAD" );		break;	default:		ERRORLOG( "status = unknown" );	}	INFOLOG( QString( "frames = %1" ).arg( m_nFrames ) );	INFOLOG( QString( "tickSize = %1" ).arg( m_nTickSize ) );}

/** * Returns if the trap can be manufactured by a player. * Checks only if it's set as buildable in level script. * Doesn't check if player has workshop or workforce for the task. */TbBool is_trap_buildable(PlayerNumber plyr_idx, long tngmodel){    struct Dungeon *dungeon;    dungeon = get_players_num_dungeon(plyr_idx);    // Check if the player even have a dungeon    if (dungeon_invalid(dungeon)) {        return false;    }    // Player must have dungeon heart to build anything    if (!player_has_heart(plyr_idx)) {        return false;    }    if ((tngmodel <= 0) || (tngmodel >= TRAP_TYPES_COUNT)) {        ERRORLOG("Incorrect trap %d (player %d)",(int)tngmodel, (int)plyr_idx);        return false;    }    if ((dungeon->trap_build_flags[tngmodel] & MnfBldF_Manufacturable) != 0) {        return true;    }    return false;}

TbBool load_map_wlb_file(unsigned long lv_num){    struct SlabMap *slb;    unsigned long x,y;    unsigned char *buf;    unsigned long i;    unsigned long n;    unsigned long nfixes;    long fsize;    SYNCDBG(7,"Starting");    nfixes = 0;    fsize = map_tiles_y*map_tiles_x;    buf = load_single_map_file_to_buffer(lv_num,"wlb",&fsize,LMFF_Optional);    if (buf == NULL)      return false;    i = 0;    for (y=0; y < map_tiles_y; y++)      for (x=0; x < map_tiles_x; x++)      {        slb = get_slabmap_block(x,y);        n = (buf[i] << 3);        n = slb->field_5 ^ ((slb->field_5 ^ n) & 0x18);        slb->field_5 = n;        n &= (0x08|0x10);        if ((n != 0x10) || (slb->kind != SlbT_WATER))          if ((n != 0x08) || (slb->kind != SlbT_LAVA))            if (((n == 0x10) || (n == 0x08)) && (slb->kind != SlbT_BRIDGE))            {                nfixes++;                slb->field_5 &= ~(0x08|0x10);            }        i++;      }    LbMemoryFree(buf);    if (nfixes > 0)    {      ERRORLOG("WLB file is muddled - Fixed values for %lu tiles",nfixes);    }    return true;}

long delaunay_seeded(long start_x, long start_y, long end_x, long end_y){    long tri_idx,cor_idx;    long tri_id2,cor_id2;    long count;    NAVIDBG(19,"Starting");    //return _DK_delaunay_seeded(start_x, start_y, end_x, end_y);    tags_init();    delaunay_init();    delaunay_stack_point(start_x, start_y);    delaunay_stack_point(start_x, end_y);    delaunay_stack_point(end_x, start_y);    delaunay_stack_point(end_x, end_y);    count = 0;    while (ix_delaunay > 0)    {        ix_delaunay--;        tri_idx = delaunay_stack[ix_delaunay];        for (cor_idx=0; cor_idx < 3; cor_idx++)        {            if (!optimise_heuristic(tri_idx, cor_idx))                continue;            count++;            edge_rotateAC(tri_idx, cor_idx);            if (ix_delaunay+4 >= DELAUNAY_COUNT)            {              ERRORLOG("stack full");              return count;            }            for (cor_id2=0; cor_id2 < 3; cor_id2++)            {                tri_id2 = Triangles[tri_idx].tags[cor_id2];                if (tri_id2 == -1)                    continue;                delaunay_add_triangle(tri_id2);            }        }    }    return count;}

short load_continue_game(void){    unsigned char buf[14];    unsigned char bonus[20];    char cmpgn_fname[CAMPAIGN_FNAME_LEN];    long lvnum;    long i;    if (!read_continue_game_part(buf,0,14))    {        WARNLOG("Can't read continue game file head");        return false;    }    i = (char *)&game.campaign_fname[0] - (char *)&game;    read_continue_game_part((unsigned char *)cmpgn_fname,i,CAMPAIGN_FNAME_LEN);    cmpgn_fname[CAMPAIGN_FNAME_LEN-1] = '/0';    if (!change_campaign(cmpgn_fname))    {        ERRORLOG("Unable to load campaign");        return false;    }    lvnum = ((struct Game *)buf)->continue_level_number;    if (!is_singleplayer_like_level(lvnum))    {      WARNLOG("Level number in continue file is incorrect");      return false;    }    set_continue_level_number(lvnum);    LbMemorySet(bonus, 0, sizeof(bonus));    i = (char *)&game.intralvl.bonuses_found[0] - (char *)&game;    read_continue_game_part(bonus,i,16);    for (i=0; i < BONUS_LEVEL_STORAGE_COUNT; i++)      game.intralvl.bonuses_found[i] = bonus[i];    LbStringCopy(game.campaign_fname,campaign.fname,sizeof(game.campaign_fname));    update_extra_levels_visibility();    i = (char *)&game.intralvl_transfered_creature - (char *)&game.intralvl.bonuses_found[0];    game.intralvl_transfered_creature.model = bonus[i];    game.intralvl_transfered_creature.explevel = bonus[i+1];    return true;}

TbBool load_action_point_file(LevelNumber lv_num){  struct InitActionPoint iapt;  unsigned long i;  long k;  long total;  unsigned char *buf;  long fsize;  SYNCDBG(5,"Starting");  fsize = 4;  buf = load_single_map_file_to_buffer(lv_num,"apt",&fsize,LMFF_None);  if (buf == NULL)    return false;  i = 0;  total = llong(&buf[i]);  i += 4;  // Validate total amount of action points  if ((total < 0) || (total > (fsize-4)/sizeof(struct InitActionPoint)))  {    total = (fsize-4)/sizeof(struct InitActionPoint);    WARNMSG("Bad amount of action points in APT file; corrected to %ld.",total);  }  if (total > ACTN_POINTS_COUNT-1)  {    WARNMSG("Only %d action points supported, APT file has %ld.",ACTN_POINTS_COUNT-1,total);    total = ACTN_POINTS_COUNT-1;  }  // Create action points  for (k=0; k < total; k++)  {    LbMemoryCopy(&iapt, &buf[i], sizeof(struct InitActionPoint));    if (actnpoint_create_actnpoint(&iapt) == INVALID_ACTION_POINT)    {      ERRORLOG("Cannot allocate action point %d during APT load",k);    }    i += sizeof(struct InitActionPoint);  }  LbMemoryFree(buf);  return true;}

void lightning_modify_palette(struct Thing *thing){    struct PlayerInfo *myplyr;    myplyr = get_my_player();    if (thing->health == 0)    {      PaletteSetPlayerPalette(myplyr, engine_palette);      myplyr->field_3 &= ~Pf3F_Unkn08;      return;    }    if (myplyr->acamera == NULL)    {        ERRORLOG("No active camera");        return;    }    if (((thing->health % 8) != 7) && (thing->health != 1) && (ACTION_RANDOM(4) != 0))    {        if ((myplyr->field_3 & Pf3F_Unkn08) != 0)        {            if (get_2d_box_distance(&myplyr->acamera->mappos, &thing->mappos) < 11520)            {                PaletteSetPlayerPalette(myplyr, engine_palette);                myplyr->field_3 &= ~Pf3F_Unkn08;            }        }        return;    }    if ((myplyr->view_mode != PVM_ParchFadeIn) && (myplyr->view_mode != PVM_ParchFadeOut) && (myplyr->view_mode != PVM_ParchmentView))    {        if ((myplyr->field_3 & Pf3F_Unkn08) == 0)        {            if (get_2d_box_distance(&myplyr->acamera->mappos, &thing->mappos) < 11520)            {              PaletteSetPlayerPalette(myplyr, lightning_palette);              myplyr->field_3 |= Pf3F_Unkn08;            }        }    }}

void SCDEVICE::LateInit(void){  DEBUGLOG("%s", __FUNCTION__);  int n = CardIndex();  if (DeviceNumber() != n)    ERRORLOG("CardIndex - DeviceNumber mismatch! Put DVBAPI plugin first on VDR commandline!");  softcsa = (fd_ca < 0);  if (softcsa)  {    if (HasDecoder())      INFOLOG("Card %s is a full-featured card but no ca device found!", devId);  }  else if (cScDevices::ForceBudget(n))  {    INFOLOG("Budget mode forced on card %s", devId);    softcsa = true;  }  if (softcsa)  {    INFOLOG("Using software decryption on card %s", devId);  }}

struct CreatureSound *get_creature_sound(struct Thing *thing, long snd_idx){    unsigned int cmodel;    cmodel = thing->model;    if ((cmodel < 1) || (cmodel >= CREATURE_TYPES_COUNT))    {        ERRORLOG("Trying to get sound for undefined creature type");        // Return dummy element        return &creature_sounds[0].foot;    }    switch (snd_idx)    {    case CrSnd_Hurt:        return &creature_sounds[cmodel].hurt;    case CrSnd_Hit:        return &creature_sounds[cmodel].hit;    case CrSnd_Happy:        return &creature_sounds[cmodel].happy;    case CrSnd_Sad:        return &creature_sounds[cmodel].sad;    case CrSnd_Hang:        return &creature_sounds[cmodel].hang;    case CrSnd_Drop:        return &creature_sounds[cmodel].drop;    case CrSnd_Torture:        return &creature_sounds[cmodel].torture;    case CrSnd_Slap:        return &creature_sounds[cmodel].slap;    case CrSnd_Die:        return &creature_sounds[cmodel].die;    case CrSnd_Foot:        return &creature_sounds[cmodel].foot;    case CrSnd_Fight:        return &creature_sounds[cmodel].fight;    default:        // Return dummy element        return &creature_sounds[0].foot;    }}

void process_network_error(long errcode){  const char *text;  switch (errcode)  {  case 4:      text = get_string(GUIStr_NetLineEngaged);      break;  case 5:      text = get_string(GUIStr_NetUnknownError);      break;  case 6:      text = get_string(GUIStr_NetNoCarrier);      break;  case 7:      text = get_string(GUIStr_NetNoDialTone);      break;  case -1:      text = get_string(GUIStr_NetNoResponse);      break;  case -2:      text = get_string(GUIStr_NetNoServer);      break;  case -800:      text = get_string(GUIStr_NetUnableToInit);      break;  case -801:      text = get_string(GUIStr_NetUnableToCrGame);      break;  case -802:      text = get_string(GUIStr_NetUnableToJoin);      break;  default:      ERRORLOG("Unknown modem error code %ld",errcode);      return;  }  //display_centered_message(3000, text);  create_frontend_error_box(3000, text);}

InstrumentComponent* InstrumentComponent::load_from( XMLNode* node, const QString& dk_path ){	int id = node->read_int( "component_id", EMPTY_INSTR_ID, false, false );	if ( id==EMPTY_INSTR_ID ) {		return nullptr;	}	InstrumentComponent* pInstrumentComponent = new InstrumentComponent( id );	pInstrumentComponent->set_gain( node->read_float( "gain", 1.0f, true, false ) );	XMLNode layer_node = node->firstChildElement( "layer" );	int n = 0;	while ( !layer_node.isNull() ) {		if ( n >= maxLayers ) {			ERRORLOG( QString( "n (%1) >= maxLayers (%2)" ).arg( n ).arg( maxLayers ) );			break;		}		pInstrumentComponent->set_layer( InstrumentLayer::load_from( &layer_node, dk_path ), n );		n++;		layer_node = layer_node.nextSiblingElement( "layer" );	}	return pInstrumentComponent;}

struct audio_oops*setup_alsa(const char *dev, const char *ctl){  static int init_complete = 0;  if(dev && strlen(dev) > 0) {    device = strdup(dev);  } else {    device = strdup("plughw:0,0"); /* playback device */  }  if(init_complete) {    ERRORLOG("already initialized/n");    return NULL;  }  if(!alsa_open())    init_complete = 1;  else    return NULL;  return &alsa_oops;}

bool MovieController::processGetMarks(MsgPacket* request, MsgPacket* response) {    const char* recid = request->get_String();    uint32_t uid = recid2uid(recid);    cRecording* recording = RecordingsCache::instance().lookup(uid);    if(recording == NULL) {        ERRORLOG("GetMarks: recording not found !");        response->put_U32(ROBOTV_RET_DATAUNKNOWN);        return true;    }    cMarks marks;    if(!marks.Load(recording->FileName(), recording->FramesPerSecond(), recording->IsPesRecording())) {        INFOLOG("no marks found for: '%s'", recording->FileName());        response->put_U32(ROBOTV_RET_NOTSUPPORTED);        return true;    }    response->put_U32(ROBOTV_RET_OK);    response->put_U64(recording->FramesPerSecond() * 10000);    cMark* end = NULL;    cMark* begin = NULL;    while((begin = marks.GetNextBegin(end)) != NULL) {        end = marks.GetNextEnd(begin);        if(end != NULL) {            response->put_String("SCENE");            response->put_U64(begin->Position());            response->put_U64(end->Position());            response->put_String(begin->ToText());        }    }    return true;}

TbBool mark_creature_joined_dungeon(struct Thing *creatng){    if (creatng->owner == game.neutral_player_num) {        // Neutral player has no dungeon        return false;    }    struct Dungeon *dungeon;    dungeon = get_dungeon(creatng->owner);    if (dungeon_invalid(dungeon)) {        ERRORLOG("Can't mark; player %d has no dungeon",(int)creatng->owner);        return false;    }    if ((dungeon->owned_creatures_of_model[creatng->model] <= 1) && (dungeon->creature_models_joined[creatng->model] <= 0))    {        event_create_event(creatng->mappos.x.val, creatng->mappos.y.val, EvKind_NewCreature, creatng->owner, creatng->index);    }    if (dungeon->creature_models_joined[creatng->model] < 255)    {        dungeon->creature_models_joined[creatng->model]++;    }    return true;}

bool cLiveQueue::Add(MsgPacket* p){  cMutexLock lock(&m_lock);  // in timeshift mode ?  if(m_pause || (!m_pause && m_writefd != -1))  {    // write packet    if(!p->write(m_writefd, 1000))    {      ERRORLOG("Unable to write packet into timeshift ringbuffer !");      delete p;      return false;    }    // ring-buffer overrun ?    off_t length = lseek(m_writefd, 0, SEEK_CUR);    if(length >= (off_t)BufferSize)    {      // truncate to current position      if(ftruncate(m_writefd, length) == 0)        lseek(m_writefd, 0, SEEK_SET);    }    delete p;    return true;  }  // queue too long ?  if (size() > 100) {    delete p;    return false;  }  // add packet to queue  push(p);  m_cond.Signal();  return true;}

bool cVideoBufferTest::Init(){  m_ReadCache = 0;  m_ReadCacheMaxSize = 8000;  m_ReadCache = (uint8_t*)malloc(m_ReadCacheMaxSize);  if (!m_ReadCache)    return false;  m_Fd = open(m_Filename, O_RDONLY);  if (m_Fd == -1)  {    ERRORLOG("Could not open file: %s", (const char*)m_Filename);    return false;  }  m_WritePtr = 0;  m_ReadPtr = 0;  m_ReadCacheSize = 0;  m_InputAttached = false;  return true;}

short good_returns_to_start(struct Thing *thing){    struct Thing *heartng;    // Debug code to find incorrect states    SYNCDBG(7,"Starting");    if (!is_hero_thing(thing))    {        ERRORLOG("Non hero thing %ld, %s, owner %ld - reset",(long)thing->index,thing_model_name(thing),(long)thing->owner);        set_start_state(thing);        erstat_inc(ESE_BadCreatrState);        return 0;    }    //return _DK_good_returns_to_start(thing);    heartng = get_player_soul_container(thing->owner);    TRACE_THING(heartng);    //TODO CREATURE_AI Heroes don't usually have hearts; maybe they should also go back to hero gates, or any room?    if (!setup_person_move_to_coord(thing, &heartng->mappos, NavRtF_Default))    {        return 0;    }    thing->continue_state = CrSt_GoodBackAtStart;    return 1;}

void CoreAudioDriver::retrieveDefaultDevice(void){	UInt32 dataSize = 0;	OSStatus err = 0;	AudioObjectPropertyAddress propertyAddress = {		kAudioHardwarePropertyDefaultOutputDevice,		kAudioObjectPropertyScopeGlobal,		kAudioObjectPropertyElementMaster	};	dataSize = sizeof(AudioDeviceID);	err = AudioObjectGetPropertyData(kAudioObjectSystemObject,											&propertyAddress,											0,											NULL,											&dataSize,											&m_outputDevice);	if ( err != noErr ) {		ERRORLOG( "Could not get Default Output Device" );	}}

void cRecordingsCache::SaveResumeData(){  cMutexLock lock(&m_mutex);  cString filename = AddDirectory(XVDRServerConfig.ConfigDirectory, RESUME_DATA_FILE);  FILE* f = fopen((const char*)filename, "w");  if(f == NULL)  {    ERRORLOG("unable to create resume data: %s", (const char*)filename);    return;  }  std::map<uint32_t, struct RecEntry>::iterator i;  for(i = m_recordings.begin(); i != m_recordings.end(); i++)  {    if(i->second.lastplayedposition != 0 || i->second.playcount != 0)      fprintf(f, "%08x = %"PRIu64", %i/n", i->first, i->second.lastplayedposition, i->second.playcount);  }  fclose(f);  return;}