Exemplo n.º 1
0
void
RasterWeather::Reload(int day_time)
{
  static unsigned last_weather_time;
  bool found = false;
  bool now = false;

  if (_parameter == 0)
    // will be drawing terrain
    return;

  Poco::ScopedRWLock protect(lock, true);
  if (_weather_time == 0) {
    // "Now" time, so find time in half hours
    unsigned half_hours = (TimeLocal(day_time) / 1800) % 48;
    _weather_time = max(_weather_time, half_hours);
    now = true;
  }

  // limit values, for safety
  _weather_time = min(MAX_WEATHER_TIMES - 1, _weather_time);
  if (_weather_time != last_weather_time)
    reload = true;

  if (!reload) {
    // no change, quick exit.
    if (now)
      // must return to 0 = Now time on exit
      _weather_time = 0;

    return;
  }

  reload = false;

  last_weather_time = _weather_time;

  // scan forward to next valid time
  while ((_weather_time < MAX_WEATHER_TIMES) && (!found)) {
    if (!weather_available[_weather_time]) {
      _weather_time++;
    } else {
      found = true;

      _Close();

      if (!LoadItem(WeatherDescriptors[_parameter].name, _weather_time) &&
          _parameter == 1)
        LoadItem(_T("wstar_bsratio"), _weather_time);
    }
  }

  // can't find valid time, so reset to zero
  if (!found || now)
    _weather_time = 0;
}
Exemplo n.º 2
0
bool ResourceGUIBackend::LoadCommandLine(int argc,const char** argv)
{
  for(int i=1;i<argc;i++) {
    if(argv[i][0] == '-') {
      if(0==strcmp(argv[i],"-l")) {
	LoadResources(argv[i+1],*resources);
	i++;
      }
      else {
	printf("Unknown option %s",argv[i]);
	return 0;
      }
    }
    else {
      const char* ext=FileExtension(argv[i]);
      if(0==strcmp(ext,"xml")) {
	TiXmlDocument doc;
	if(!doc.LoadFile(argv[i])) {
	  printf("Error loading XML file %s\n",argv[i]);
	  return false;
	}
	if(0 == strcmp(doc.RootElement()->Value(),"world")) {
	  XmlWorld xmlWorld;
	  if(!xmlWorld.Load(doc.RootElement(),GetFilePath(argv[i]))) {
	    printf("Error loading world file %s\n",argv[i]);
	    return 0;
	  }
	  if(!xmlWorld.GetWorld(*world)) {
	    printf("Error loading world from %s\n",argv[i]);
	    return 0;
	  }
	}
	else if(0 == strcmp(doc.RootElement()->Value(),"resource_library")) {
	  LoadResources(doc.RootElement(),*resources);
	}
	else {
	  if(!LoadItem(argv[i],*resources))
	    return 0;
	}
      }
      else {
	//try loading into the world
	const char* ext = FileExtension(argv[i]);
	if(world->CanLoadElementExt(ext) && world->LoadElement(argv[i])>= 0) {
	  //loaded successfully
	}
	else {
	  //failed, now try resource library load
	  if(!LoadItem(argv[i],*resources))
	    return 0;
	}
      }
    }
  }
  return true;
}
Exemplo n.º 3
0
Ogre::MeshPtr CMapLoader::LoadModel(const char * path)
{
	MapResource<Ogre::MeshPtr> res;
	Ogre::MeshPtr pMesh;

	// Check if this model was already loaded
	pMesh = Ogre::MeshManager::getSingleton().getByName(path);
	if(!pMesh.isNull())
		return pMesh;

	sectionitem_t * item = LoadItem(path, &res.map);
	if(item == NULL)
		return Ogre::MeshPtr(NULL);

	pMesh = Ogre::MeshManager::getSingleton().createManual(path,
		Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME);

	Ogre::DataStreamPtr stream(new Ogre::MemoryDataStream(item->data, item->size, false, true));
	Ogre::MeshSerializer serializer;
	serializer.importMesh(stream, pMesh.getPointer());

	// No need to keep this in memory
	mapUnloadItem(item);

	// Track this resource
	res.data = pMesh;
	meshes.push_back(res);
	
	return pMesh;
}
Exemplo n.º 4
0
InMemoryIterator::InMemoryIterator(InMemorySSTableReader *sstable, const std::string &key)
                : sstable_(sstable) {
    SeekKey(key);
    if (valid_) {
        LoadItem();
    }
}
Exemplo n.º 5
0
ee::SprPtr LoadFromPSD::LoadGroup(const Json::Value& value, const std::string& dir, int tw, int th)
{
	std::string name = value[ee::SYM_GROUP_TAG].asString();

	bool visible = value["visible"].asBool();

	std::string _dir = dir + "\\" + name;
	
	auto sym = std::make_shared<Symbol>();
	auto spr = std::make_shared<Sprite>(sym);

	const Json::Value& cval = value["children"];
//	for (int i = 0, n = cval.size(); i < n; ++i) {
	for (int i = cval.size() - 1; i >= 0; --i) {
		ee::SprPtr cspr = LoadItem(cval[i], _dir, tw, th);
		if (cspr) {
			sym->Add(cspr);
		}
	}

//	sym->InitBounding();
	spr->UpdateBounding();

	spr->SetVisible(visible);

	return spr;
}
Exemplo n.º 6
0
void CSoundManager::PlayAsAmbient(const VfsPath& itemPath, bool looping)
{
	if (m_Enabled)
	{
		UNUSED2(looping);
		ISoundItem* aSnd = LoadItem(itemPath);
		if (aSnd != NULL)
			SetAmbientItem(aSnd);
	}
}
Exemplo n.º 7
0
void ScriptingSettingsDlg::OnListSelection(wxListEvent& event)
{
//    Manager::Get()->GetLogManager()->DebugLog(F(_T("Selected %d"), event.GetIndex()));

    // load
    long sel = event.GetIndex();
    LoadItem(sel);

    UpdateState();
}
Exemplo n.º 8
0
BOOL
CNewMenu::LoadAllItems()
{
    DWORD dwIndex = 0;
    WCHAR wszName[MAX_PATH];
    SHELLNEW_ITEM *pNewItem;
    SHELLNEW_ITEM *pCurItem = NULL;

    /* If there are any unload them */
    UnloadAllItems();

    /* Enumerate all extesions */
    while (RegEnumKeyW(HKEY_CLASSES_ROOT, dwIndex++, wszName, _countof(wszName)) == ERROR_SUCCESS)
    {
        if (wszName[0] != L'.')
            continue;

        pNewItem = LoadItem(wszName);
        if (pNewItem)
        {
            if (wcsicmp(pNewItem->pwszExt, L".lnk") == 0)
            {
                /* Link handler */
                m_pLinkItem = pNewItem;
            }
            else
            {
                /* Add at the end of list */
                if (pCurItem)
                {
                    pCurItem->pNext = pNewItem;
                    pCurItem = pNewItem;
                }
                else
                    pCurItem = m_pItems = pNewItem;
            }
        }
    }

    if (!m_pLinkItem)
    {
        m_pLinkItem = static_cast<SHELLNEW_ITEM *>(HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(SHELLNEW_ITEM)));
        if (m_pLinkItem)
        {
            m_pLinkItem->Type = SHELLNEW_TYPE_NULLFILE;
            m_pLinkItem->pwszDesc = _wcsdup(L"Link");
            m_pLinkItem->pwszExt = _wcsdup(L".lnk");
        }
    }

    if (m_pItems == NULL)
        return FALSE;
    else
        return TRUE;
}
Exemplo n.º 9
0
void LoadFromPSD::Load(const Json::Value& value, const std::string& dir, Symbol& complex)
{
	int w = value["document"]["width"].asInt(),
		h = value["document"]["height"].asInt();

	const Json::Value& cvalue = value["children"];
//	for (int i = 0, n = cvalue.size(); i < n; ++i) {
	for (int i = cvalue.size() - 1; i >= 0; --i) {
		auto spr = LoadItem(cvalue[i], dir, w, h);
		if (spr) {
			complex.Add(spr);
		}
	}
}
Exemplo n.º 10
0
void ScriptingSettingsDlg::OnRemoveScript(wxCommandEvent& event)
{
    wxListCtrl* list = XRCCTRL(*this, "chkStartupScripts", wxListCtrl);
    long sel = list->GetNextItem(-1, wxLIST_NEXT_ALL, wxLIST_STATE_SELECTED);

    list->DeleteItem(sel);
    m_ScriptsVector.erase(m_ScriptsVector.begin() + sel);

    if (sel > list->GetItemCount())
        --sel;
    list->SetItemState(sel, wxLIST_STATE_SELECTED | wxLIST_STATE_FOCUSED, wxLIST_STATE_SELECTED | wxLIST_STATE_FOCUSED);
    if (sel >= 0)
        LoadItem(sel);
    UpdateState();
}
Exemplo n.º 11
0
Item* ItemFactory::GetItem(Item::ItemType type, int itemId)
{
    Item* retval = new Item(itemId, type);
    LoadItem(type, itemId, retval);

    switch(itemId)
    {
        //TODO: Init Item with Id itemId

    default:
        std::string msg("Invalid ItemId ");
        msg.append(std::to_string(itemId));
        msg.append(" given in GetItem.");
        throw GenericException(msg);
    }
    return retval;
}
Exemplo n.º 12
0
    virtual bool ServiceItem(specialitemload_t const &item)
    {
        bool ret = false;
        if(m_SQL)
        {
            if(item.loadtype == SPECIALITEM_LOAD)
            {
                ret = LoadItem(item);
            }
            else if(item.loadtype == SPECIALITEM_SAVE)
            {
                ret = SaveItem(item);
            }
        }

        return ret;
    }
Exemplo n.º 13
0
void CSoundManager::IdleTask()
{
	if (m_Enabled)
	{
		if (m_CurrentTune)
		{
			m_CurrentTune->EnsurePlay();
			if (m_PlayingPlaylist && m_RunningPlaylist)
			{
				if (m_CurrentTune->Finished())
				{
					if (m_PlaylistGap == 0)
					{
						m_PlaylistGap = timer_Time() + 15;
					}
					else if (m_PlaylistGap < timer_Time())
					{
						m_PlaylistGap = 0;
						PlayList::iterator it = find(m_PlayListItems->begin(), m_PlayListItems->end(), m_CurrentTune->GetName());
						if (it != m_PlayListItems->end())
						{
							++it;

							Path nextPath;
							if (it == m_PlayListItems->end())
								nextPath = m_PlayListItems->at(0);
							else
								nextPath = *it;

							ISoundItem* aSnd = LoadItem(nextPath);
							if (aSnd)
								SetMusicItem(aSnd);
						}
					}
				}
			}
		}

		if (m_CurrentEnvirons)
			m_CurrentEnvirons->EnsurePlay();

		if (m_Worker)
			m_Worker->CleanupItems();
	}
}
Exemplo n.º 14
0
void CSoundManager::StartPlayList(bool doLoop)
{
	if (m_Enabled && m_MusicEnabled)
	{
		if (m_PlayListItems->size() > 0)
		{
			m_PlayingPlaylist = true;
			m_LoopingPlaylist = doLoop;
			m_RunningPlaylist = false;

			ISoundItem* aSnd = LoadItem((m_PlayListItems->at(0)));
			if (aSnd)
				SetMusicItem(aSnd);
			else
				SetMusicItem(NULL);
		}
	}
}
Exemplo n.º 15
0
void CSoundManager::PlayAsUI(const VfsPath& itemPath, bool looping)
{
	if (m_Enabled)
	{
		IdleTask();
	
		if (ISoundItem* anItem = LoadItem(itemPath))
		{
			if (m_UIGain > 0)
			{
				anItem->SetGain(m_UIGain);
				anItem->SetLooping(looping);
				anItem->PlayAndDelete();
			}
		}
		AL_CHECK;
	}
}
Exemplo n.º 16
0
//-------------------------------------------------------------------------
void CDocResource::Load( CTinyCadDoc* pDesign, CStream& oStream )
{
	// Number of Fonts in this list
	UInt16 		nCntRes		= 0;
	hRESOURCE 	nOldResNo 	= 0;

	// All the merge numbers to invalid
	ResetMerge();

	// Read in the number of Fonts
	oStream >> nCntRes;

	for( int n = 0; n < nCntRes; n++ )
	{
		oStream >> nOldResNo;
		LoadItem( pDesign, oStream, nOldResNo );
	}
}
Exemplo n.º 17
0
//---------------------------------------------------------------------------
void __fastcall TSynchronizeChecklistDialog::LoadList()
{
  memset(&FTotals, 0, sizeof(FTotals));
  memset(&FChecked, 0, sizeof(FChecked));
  FTotals[0] = FChecklist->Count;
  FChecked[0] = 0;

  ListView->Items->BeginUpdate();
  try
  {
    ListView->Items->Clear();
    for (int Index = 0; Index < FChecklist->Count; Index++)
    {
      const TSynchronizeChecklist::TItem * ChecklistItem =
        FChecklist->Item[ListView->Items->Count];
      FChangingItemIgnore = true;
      try
      {
        LoadItem(ListView->Items->Add());
      }
      __finally
      {
        FChangingItemIgnore = false;
      }
      FTotals[int(ChecklistItem->Action)]++;
      if (ChecklistItem->Checked)
      {
        FChecked[int(ChecklistItem->Action)]++;
        FChecked[0]++;
      }
    }
  }
  __finally
  {
    ListView->Items->EndUpdate();
  }

  ListView->AlphaSort();
  UpdateControls();
}
Exemplo n.º 18
0
void CBackgroundInfoLoader::Run()
{
    try
    {
        if (m_vecItems.size() > 0)
        {
            OnLoaderStart();

            for (std::vector<CFileItemPtr>::const_iterator iter = m_vecItems.begin(); iter != m_vecItems.end(); ++iter)
            {
                CFileItemPtr pItem = *iter;

                // Ask the callback if we should abort
                if ((m_pProgressCallback && m_pProgressCallback->Abort()) || m_bStop)
                    break;

                try
                {
                    if (LoadItem(pItem.get()) && m_pObserver)
                        m_pObserver->OnItemLoaded(pItem.get());
                }
                catch (...)
                {
                    CLog::Log(LOGERROR, "CBackgroundInfoLoader::LoadItem - Unhandled exception for item %s", CURL::GetRedacted(pItem->GetPath()).c_str());
                }
            }
        }

        OnLoaderFinish();
        m_bIsLoading = false;
    }
    catch (...)
    {
        m_bIsLoading = false;
        CLog::Log(LOGERROR, "%s - Unhandled exception", __FUNCTION__);
    }
}
Exemplo n.º 19
0
void __fastcall LoadGame(bool firstflag)
{
	int v1; // esi
	int v2; // edi
	int v5; // ebx
	int v6; // eax
	int v7; // eax
	int v8; // ecx
	bool v9; // sf
	unsigned char v10; // of
	int *v11; // esi
	int *v12; // esi
	int i; // esi
	int *v14; // esi
	int *v15; // esi
	int j; // esi
	int *v17; // esi
	int *v18; // esi
	int k; // esi
	int l; // esi
	signed int v21; // esi
	int m; // esi
	int v23; // esi
	int *v24; // esi
	int *v25; // esi
	int n; // esi
	int *v27; // esi
	char *v29; // edi
	char *v30; // edi
	char *v31; // edi
	char *v32; // edi
	int (*v33)[112]; // ebx
	_DWORD *v34; // edi
	char *v35; // edi
	char *v36; // edi
	char *v37; // edi
	char *v38; // edi
	signed int v39; // ebx
	bool *v40; // edi
	char *v41; // edi
	int v42; // esi
	char dst[260]; // [esp+0h] [ebp-120h]
	int len; // [esp+104h] [ebp-1Ch]
	int v46; // [esp+108h] [ebp-18h]
	int v47; // [esp+10Ch] [ebp-14h]
	void *ptr; // [esp+110h] [ebp-10h]
	int v49; // [esp+114h] [ebp-Ch]
	int from_save; // [esp+118h] [ebp-8h]
	int quest_num; // [esp+11Ch] [ebp-4h]

	FreeGameMem();
	pfile_remove_temp_files();
	pfile_get_game_name(dst);
	ptr = pfile_read(dst, &len);
	tbuff = ptr;
	if ( ILoad_2() != 'RETL' )
		TermMsg("Invalid save file");
	setlevel = OLoad();
	setlvlnum = ILoad();
	currlevel = ILoad();
	leveltype = ILoad();
	v1 = ILoad();
	v2 = ILoad();
	invflag = OLoad();
	chrflag = OLoad();
	v5 = ILoad();
	v47 = ILoad();
	v49 = ILoad();
	v6 = ILoad();
	quest_num = 0;
	v46 = v6;
	do
	{
		*(int *)((char *)glSeedTbl + quest_num) = ILoad_2();
		v7 = ILoad();
		v8 = quest_num;
		quest_num += 4;
		v10 = __OFSUB__(quest_num, 68);
		v9 = quest_num - 68 < 0;
		*(int *)((char *)gnLevelTypeTbl + v8) = v7;
	}
	while ( v9 ^ v10 );
	LoadPlayer(myplr);
	quest_num = 0;
	do
		LoadQuest(quest_num++);
	while ( quest_num < 16 );
	quest_num = 0;
	do
		LoadPortal(quest_num++);
	while ( quest_num < 4 );
	LoadGameLevel(firstflag, 4);
	SyncInitPlr(myplr);
	SyncPlrAnim(myplr);
	ViewX = v1;
	numitems = v47;
	nummissiles = v49;
	ViewY = v2;
	nummonsters = v5;
	nobjects = v46;
	v11 = monstkills;
	do
	{
		*v11 = ILoad_2();
		++v11;
	}
	while ( (signed int)v11 < (signed int)&monstkills[200] );
	if ( leveltype )
	{
		v12 = monstactive;
		do
		{
			*v12 = ILoad();
			++v12;
		}
		while ( (signed int)v12 < (signed int)&monstactive[200] );
		for ( i = 0; i < nummonsters; ++i )
			LoadMonster(monstactive[i]);
		v14 = missileactive;
		do
		{
			*v14 = BLoad();
			++v14;
		}
		while ( (signed int)v14 < (signed int)&missileactive[125] );
		v15 = missileavail;
		do
		{
			*v15 = BLoad();
			++v15;
		}
		while ( (signed int)v15 < (signed int)&missileavail[125] );
		for ( j = 0; j < nummissiles; ++j )
			LoadMissile(missileactive[j]);
		v17 = objectactive;
		do
		{
			*v17 = BLoad();
			++v17;
		}
		while ( (signed int)v17 < (signed int)&objectactive[127] );
		v18 = objectavail;
		do
		{
			*v18 = BLoad();
			++v18;
		}
		while ( (signed int)v18 < (signed int)&objectavail[127] );
		for ( k = 0; k < nobjects; ++k )
			LoadObject(objectactive[k]);
		for ( l = 0; l < nobjects; ++l )
			SyncObjectAnim(objectactive[l]);
		numlights = ILoad();
		v21 = 0;
		do
			lightactive[v21++] = BLoad();
		while ( v21 < 32 );
		for ( m = 0; m < numlights; ++m )
			LoadLighting((unsigned char)lightactive[m]);
		visionid = ILoad();
		v23 = 0;
		numvision = ILoad();
		if ( numvision > 0 )
		{
			do
				LoadVision(v23++);
			while ( v23 < numvision );
		}
	}
	v24 = itemactive;
	do
	{
		*v24 = BLoad();
		++v24;
	}
	while ( (signed int)v24 < (signed int)&itemactive[127] );
	v25 = itemavail;
	do
	{
		*v25 = BLoad();
		++v25;
	}
	while ( (signed int)v25 < (signed int)&itemavail[127] );
	for ( n = 0; n < numitems; ++n )
		LoadItem(itemactive[n]);
	v27 = UniqueItemFlag;
	do
	{
		*v27 = OLoad();
		++v27;
	}
	while ( (signed int)v27 < (signed int)&UniqueItemFlag[128] );
	quest_num = 0;
	do
	{
		from_save = 112;
		v29 = (char *)dTransVal + quest_num;
		do
		{
			*v29 = BLoad();
			v29 += 112;
			--from_save;
		}
		while ( from_save );
		++quest_num;
	}
	while ( quest_num < 112 );
	quest_num = 0;
	do
	{
		from_save = 112;
		v30 = (char *)dFlags + quest_num;
		do
		{
			*v30 = BLoad();
			v30 += 112;
			--from_save;
		}
		while ( from_save );
		++quest_num;
	}
	while ( quest_num < 112 );
	quest_num = 0;
	do
	{
		from_save = 112;
		v31 = (char *)dPlayer + quest_num;
		do
		{
			*v31 = BLoad();
			v31 += 112;
			--from_save;
		}
		while ( from_save );
		++quest_num;
	}
	while ( quest_num < 112 );
	quest_num = 0;
	do
	{
		from_save = 112;
		v32 = (char *)dItem + quest_num;
		do
		{
			*v32 = BLoad();
			v32 += 112;
			--from_save;
		}
		while ( from_save );
		++quest_num;
	}
	while ( quest_num < 112 );
	if ( leveltype )
	{
		v33 = dMonster;
		do
		{
			v34 = (unsigned int *)v33;
			from_save = 112;
			do
			{
				*v34 = ILoad();
				v34 += 112;
				--from_save;
			}
			while ( from_save );
			v33 = (int (*)[112])((char *)v33 + 4);
		}
		while ( (signed int)v33 < (signed int)dMonster[1] );
		quest_num = 0;
		do
		{
			from_save = 112;
			v35 = (char *)dDead + quest_num;
			do
			{
				*v35 = BLoad();
				v35 += 112;
				--from_save;
			}
			while ( from_save );
			++quest_num;
		}
		while ( quest_num < 112 );
		quest_num = 0;
		do
		{
			from_save = 112;
			v36 = (char *)dObject + quest_num;
			do
			{
				*v36 = BLoad();
				v36 += 112;
				--from_save;
			}
			while ( from_save );
			++quest_num;
		}
		while ( quest_num < 112 );
		quest_num = 0;
		do
		{
			from_save = 112;
			v37 = (char *)dTransVal + quest_num;
			do
			{
				*v37 = BLoad();
				v37 += 112;
				--from_save;
			}
			while ( from_save );
			++quest_num;
		}
		while ( quest_num < 112 );
		quest_num = 0;
		do
		{
			from_save = 112;
			v38 = (char *)dTransVal2 + quest_num;
			do
			{
				*v38 = BLoad();
				v38 += 112;
				--from_save;
			}
			while ( from_save );
			++quest_num;
		}
		while ( quest_num < 112 );
		v39 = 0;
		do
		{
			v40 = (bool *)automapview + v39;
			from_save = 40;
			do
			{
				*v40 = OLoad();
				v40 += 40;
				--from_save;
			}
			while ( from_save );
			++v39;
		}
		while ( v39 < 40 );
		quest_num = 0;
		do
		{
			from_save = 112;
			v41 = (char *)dMissile + quest_num;
			do
			{
				*v41 = BLoad();
				v41 += 112;
				--from_save;
			}
			while ( from_save );
			++quest_num;
		}
		while ( quest_num < 112 );
	}
	numpremium = ILoad();
	premiumlevel = ILoad();
	v42 = 0;
	do
		LoadPremium(v42++);
	while ( v42 < 6 );
	automapflag = OLoad();
	AutoMapScale = ILoad();
	mem_free_dbg(ptr);
	AutomapZoomReset();
	ResyncQuests();
	if ( leveltype )
		ProcessLightList();
	RedoPlayerVision();
	ProcessVisionList();
	missiles_process_charge();
	ResetPal();
	SetCursor(CURSOR_HAND);
	gbProcessPlayers = 1;
}
Exemplo n.º 20
0
void __cdecl LoadLevel()
{
	int i; // esi
	int j; // esi
	char dst[260]; // [esp+Ch] [ebp-10Ch]
	int len; // [esp+110h] [ebp-8h]
	void *LoadBuff; // [esp+114h] [ebp-4h]

	GetPermLevelNames(dst);
	LoadBuff = pfile_read(dst, &len);
	tbuff = LoadBuff;

	if ( leveltype )
	{
		for(i = 0; i < 112; i++)
		{
			for(j = 0; j < 112; j++)
			{
				dDead[j][i] = BLoad(); /* check */
			}
		}

		SetDead();
	}

	nummonsters = ILoad();
	numitems = ILoad();
	nobjects = ILoad();

	if ( leveltype )
	{
		for(i = 0; i < 200; i++)
			monstactive[i] = ILoad();

		for(i = 0; i < nummonsters; i++)
			LoadMonster(monstactive[i]);

		for(i = 0; i < 127; i++)
			objectactive[i] = BLoad();

		for(i = 0; i < 127; i++)
			objectavail[i] = BLoad();

		for(i = 0; i < nobjects; i++)
			LoadObject(objectactive[i]);

		for(i = 0; i < nobjects; i++)
			SyncObjectAnim(objectactive[i]);
	}

	for(i = 0; i < 127; i++)
		itemactive[i] = BLoad();

	for(i = 0; i < 127; i++)
		itemavail[i] = BLoad();

	for(i = 0; i < numitems; i++)
		LoadItem(itemactive[i]);

	for(i = 0; i < 112; i++)
	{
		for(j = 0; j < 112; j++)
		{
			dFlags[j][i] = BLoad();
		}
	}

	for(i = 0; i < 112; i++)
	{
		for(j = 0; j < 112; j++)
		{
			dItem[j][i] = BLoad();
		}
	}

	if ( leveltype )
	{
		for(i = 0; i < 112; i++)
		{
			for(j = 0; j < 112; j++)
			{
				dMonster[j][i] = ILoad();
			}
		}

		for(i = 0; i < 112; i++)
		{
			for(j = 0; j < 112; j++)
			{
				dObject[j][i] = BLoad();
			}
		}

		for(i = 0; i < 112; i++)
		{
			for(j = 0; j < 112; j++)
			{
				dTransVal[j][i] = BLoad();
			}
		}

		for(i = 0; i < 112; i++)
		{
			for(j = 0; j < 112; j++)
			{
				dTransVal2[j][i] = BLoad();
			}
		}

		for(i = 0; i < 40; i++)
		{
			for(j = 0; j < 40; j++)
			{
				automapview[j][i] = OLoad();
			}
		}

		for(i = 0; i < 112; i++)
		{
			for(j = 0; j < 112; j++)
			{
				dMissile[j][i] = 0;
			}
		}
	}

	AutomapZoomReset();
	ResyncQuests();
	SyncPortals();
	dolighting = 1;

	for(i = 0; i < 4; i++)
	{
		if ( plr[i].plractive && currlevel == plr[i].plrlevel )
			LightList[plr[i]._plid]._lunflag = 1;
	}

	mem_free_dbg(LoadBuff);
}
Exemplo n.º 21
0
static INT_PTR CALLBACK DlgProcOpts(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
	PFolderItem item;

	switch (msg) {
	case WM_INITDIALOG:
		lastItem = NULL;
		TranslateDialogDefault(hWnd);
		bInitializing = 1;
		LoadRegisteredFolderSections(hWnd);
		bInitializing = 0;
		break;

	case WM_COMMAND:
		switch (LOWORD(wParam)) {
		case IDC_FOLDER_EDIT:
			switch (HIWORD(wParam)) {
			case EN_CHANGE:
				RefreshPreview(hWnd);
				if (!bInitializing)
					SendMessage(GetParent(hWnd), PSM_CHANGED, 0, 0); //show the apply button.
			}
			break;

		case IDC_REFRESH_BUTTON:
			RefreshPreview(hWnd);
			break;

		case IDC_HELP_BUTTON:
			ShowWindow( CreateDialog(hInstance, MAKEINTRESOURCE(IDD_VARIABLES_HELP), hWnd, DlgProcVariables), SW_SHOW);
			break;

		case IDC_FOLDERS_SECTIONS_LIST:
			switch (HIWORD(wParam)) {
			case LBN_SELCHANGE:
				CheckForChanges(hWnd);
				LoadRegisteredFolderItems(hWnd);
				lastItem = NULL;
				SetEditText(hWnd, L"");
				RefreshPreview(hWnd);
			}
			break;

		case IDC_FOLDERS_ITEMS_LIST:
			switch (HIWORD(wParam)) {
			case LBN_SELCHANGE:
				item = GetSelectedItem(hWnd);
				if (item != NULL) {
					CheckForChanges(hWnd);
					LoadItem(hWnd, item);
				}
				lastItem = item;
			}
		}
		break;

	case WM_NOTIFY:
		switch(((LPNMHDR)lParam)->idFrom) {
		case 0:
			switch (((LPNMHDR)lParam)->code) {
			case PSN_APPLY:
				item = GetSelectedItem(hWnd);
				if (item) {
					SaveItem(hWnd, item, FALSE);
					LoadItem(hWnd, item);
				}

				for (int i=0; i < lstRegisteredFolders.getCount(); i++)
					lstRegisteredFolders[i].Save();
				CallPathChangedEvents();
			}
		}
		break;
	}

	return 0;
}
Exemplo n.º 22
0
void InMemoryIterator::Next() {
    NextItem();
    if (valid_) {
        LoadItem();
    }
}