C++ ListIterator::has方法代码示例

/*---------------------------------------------------------------------*//**
	未定義の関数を外部関数によって解決を試みる

	@param codeExtScriptOut	追加スクリプトコード（戻り値 false の場合有効）
	@param paramParse		解析汎用パラメータ
	@retval true	解析を終了してよし
					※	外部拡張ネイティブ関数追加によって解決した場合も
						この戻り値でよい
	@retval false	解析を続ける
					※	codeExtScriptOut に該当関数のスクリプトコードを
						設定して、解決を試みる
**//*---------------------------------------------------------------------*/
bool EsExternalExtension::resolveUndefinedFunctionByExtFunc(VcString* codeExtScriptOut, EsExtParam paramParse)
{
	// 関数呼び出しが解決しているか調べる
	s32 numUnresolvedFuncCall = 0;
	for(ListIterator<EsParsedFuncInfo*> itCall = _listParsedFuncInfo->iterator(); itCall.has(); itCall.next())
	{
		if(itCall.object()->getKind() != EsParsedFuncInfo::KIND_CALL)	{	continue;	}

		const VcString* nameCall = itCall.object()->getFuncName();
		bool isDefFind = false;

		// スクリプト内定義関数から探す
		for(ListIterator<EsParsedFuncInfo*> itDef = _listParsedFuncInfo->iterator(); itDef.has(); itDef.next())
		{
			if(itDef.object()->getKind() != EsParsedFuncInfo::KIND_DEF)	{	continue;	}

			if(nameCall->equals(itDef.object()->getFuncName()))
			{
				isDefFind = true;
				break;
			}
		}
		
		if(!isDefFind)
		{
			// 既に追加済みの外部拡張ネイティブ関数から探す
			for(ListIterator<EsExtNativeFunc*> itEnf = _listExtNativeFunc->iterator(); itEnf.has(); itEnf.next())
			{
				if(nameCall->equals(itEnf.object()->getName()))
				{
					isDefFind = true;
					break;
				}
			}
		}

		itCall.object()->setUnresolved(!isDefFind);	// 未解決フラグを立てる
		if(!isDefFind) { numUnresolvedFuncCall++; }
	}

	if(numUnresolvedFuncCall <= 0)	// 未解決の関数呼び出しはない
	{
		return true;	// 解析を終わって問題ない
	}

	// 外部のスクリプト追加、もしくは外部拡張ネイティブ関数追加で解決を試みる
	bool isEndParse = true;	// 特に処理が入らなければ解決を終了する
	for(ListIterator<EsParsedFuncInfo*> itCall = _listParsedFuncInfo->iterator(); itCall.has(); itCall.next())
	{
		if(itCall.object()->getKind() != EsParsedFuncInfo::KIND_CALL)	{	continue;	}
		if(!itCall.object()->isUnresolved())	{	continue;	}
		if(!resolveUndefinedFunction(codeExtScriptOut, itCall.object()->getFuncName(), paramParse))
		{
			isEndParse = false;
		}
	}

	return isEndParse;
}

/*---------------------------------------------------------------------*//**
	自動開始イベントの開始
**//*---------------------------------------------------------------------*/
bool StoryManager::beginAutoBeginEvent(s32 kind)
{
	bool isBegin = false;

	for(ListIterator<AutoBeginEventInfo*> it = _listAutoBeginEvi->iterator(); it.has(); it.next())
	{
		AutoBeginEventInfo* abevi = it.object();
		if(abevi->getKind() == kind)	// 同じ種別
		{
			// イベント起動原因と起動判定
			short cid = EventCause::CID_NULL;
			bool isCall = true;
			switch(kind)
			{
			case AutoBeginEventInfo::KIND_STORY_START:
				cid = EventCause::CID_STORYSTART;
				break;
			case AutoBeginEventInfo::KIND_LOAD_INTVEV_START:
				cid = EventCause::CID_INTVLEVSTART;
				break;
			case AutoBeginEventInfo::KIND_MAP_START:
				cid = EventCause::CID_MAPSTART;
				if(Game::getGame()->getMoveMap()->getCurMapId() != abevi->getMapId())
				{
					isCall = false;
				}
				break;
			}

			// イベント起動
			if(isCall)
			{
				u16 evid = abevi->getCallEvi()->getInfo(abevi->getActiveCallEviIndex())->getEvid();
				if(evid != 0)	// わざわざ起動しない設定で上書きすることもありうる
				{
					EvCause evcause(cid);
					EventMatter* matter = (EventMatter*)_evsysRef->begin(evid, 0, &evcause);
					if(matter != 0L)
					{
						isBegin = true;

						// イベントが複数定義されている場合は、次に送る
						if(abevi->getCallEvi()->getInfoNum() >= 2)
						{
							abevi->nextCallEvi(false);
						}
					}
				}
			}
		}
	}

	return isBegin;
}

/*---------------------------------------------------------------------*//**
	シリアライズ
**//*---------------------------------------------------------------------*/
bool StoryManager::serialize(Serializer* ser) const
{
	// 実行中の Act イベント ID を得る
	u16 evidActing = 0;
	EventData* evdat = Game::getGame()->getEventSys()->getEventData();	ASSERT(evdat != 0L);
	for(int imat = 0; imat < evdat->getEventMatterNum(); imat++)
	{
		EventMatter* matterWk = evdat->getEventMatter(imat);
		if((matterWk->getMatterType() == EMTYPE_ACT) && matterWk->isBegin())	// 開始済み ActMatter 判定
		{
			evidActing = matterWk->getEvId();
		}
	}

	// ストーリーの保存
	if(ser->isStructureMode())	// ストラクチャモード
	{
		SaveStructure* svst = (SaveStructure*)ser->getStructure();
		svst->_gamesvst._storyid = _storyid;										// ストーリー ID の書き込み
		svst->_gamesvst._isPlayedStoryStartupEvent = _isPlayedStoryStartupEvent;	// ストーリー開始イベント起動フラグの書き込み
		svst->_gamesvst._evidActing = evidActing;									// 実行中の Act イベント ID の書き込み
	}
	else						// ダイレクトモード
	{
		ser->store(&_storyid);						// ストーリー ID の書き込み
		ser->store(&_isPlayedStoryStartupEvent);	// ストーリー開始イベント起動フラグの書き込み
		ser->store(&evidActing);					// 実行中の Act イベント ID の書き込み
	}

	// 配置オブジェクトの状態を保存する
	if(ser->isStructureMode())	// ストラクチャモード
	{
		SaveStructure* svst = (SaveStructure*)ser->getStructure();
		if(!svst->storePlacementObjData(_listPlaceObj))
		{
			return false;
		}
	}
	else						// ダイレクトモード
	{
		s32 numPobj = _listPlaceObj->getCount();
		ser->store(&numPobj);
		for(ListIterator<PlacementObj*> it = _listPlaceObj->iterator(); it.has(); it.next())
		{
			const PlacementObj* pobj = it.object();
			pobj->serialize(ser);
		}
	}

	// ワールドマップのシリアライズ
	_wmap->serialize(ser);

	return true;
}

/*---------------------------------------------------------------------*//**
	ストーリーの解放
**//*---------------------------------------------------------------------*/
void StoryManager::releaseStory()
{
	// ストーリーを削除
	if(_stmod != 0L)
	{
		_stmod->destroy();
		delete _stmod;
		_stmod = 0L;
	}

	// マップ置換イベントを戻す
	EventData* evdat = _evsysRef->getEventData();
	for(ListIterator<OverrideEventMatter*> it = _listOvrdEvm->iterator(); it.has(); it.next())
	{
		const OverrideEventMatter* oem = it.object();
		if(oem->getKind() == OverrideEventMatter::KIND_MAP)	// タイプがマップのもののみ
		{
			evdat->unoverrideMatter(oem);
		}
	}
	_listOvrdEvm->removeAll();	// 置換イベント情報クリア

	// 配置オブジェクト情報クリア
	for(ListIterator<PlacementObj*> it = _listPlaceObj->iterator(); it.has(); it.next())
	{
		PlacementObj* pobj = it.object();
		if(pobj->getMapId() == Game::getGame()->getMoveMap()->getCurMapId())
		{
			Game::getGame()->getMap()->unplacePlacementObj(pobj);	// 配置解除
		}
	}
	_listPlaceObj->removeAll();

	// 自動起動イベントリストをクリア
	_listAutoBeginEvi->removeAll();

	// その他の値をクリア
	_storyid = 0L;
	_isPlayedStoryStartupEvent = false;
}

SRCR_BEGIN_NS

////////////////////////////////////////////////////////////////////////////
// クラス

//==========================================================================
// SaveStructure メソッド

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
// 外部サービス

/*---------------------------------------------------------------------*//**
	配置オブジェクトリストのセーブデータを保存する

	@param listPlaceObj 配置オブジェクトリスト
	@retval true 成功
	@retval false 失敗
**//*---------------------------------------------------------------------*/
bool SaveStructure::storePlacementObjData(const List<PlacementObj*>* listPlaceObj)
{
    // 末端を得る
    s32 idx = 0;
    while(idx < NUM_POBJ_MAX)
    {
        if(_pobjsvst[idx]._ucase == 0)	// 未記録
        {
            break;
        }
        idx++;
    }

    for(ListIterator<PlacementObj*> it = listPlaceObj->iterator(); it.has(); it.next())
    {
        if(idx >= NUM_POBJ_MAX)
        {
            ASSERT(idx < NUM_POBJ_MAX);
            return false;
        }
        const PlacementObj* pobj = it.object();
        if(!pobj->isNullState())	// 初期状態以外なら
        {
            PlacementObj::SaveStructure* pobjsvst = &_pobjsvst[idx];
            pobj->storeToStructure(pobjsvst);	// 保存
            idx++;
        }
    }
    ASSERT(idx <= NUM_POBJ_MAX);

    return true;
}

/*---------------------------------------------------------------------*//**
	配置オブジェクトリストへセーブデータを復元する

	@param listPlaceObj 配置オブジェクトリスト
	@retval true 成功
	@retval false 失敗
**//*---------------------------------------------------------------------*/
bool SaveStructure::restorePlacementObjData(List<PlacementObj*>* listPlaceObj) const
{
    for(ListIterator<PlacementObj*> it = listPlaceObj->iterator(); it.has(); it.next())
    {
        PlacementObj* pobj = it.object();

        for(int idx = 0; idx < NUM_POBJ_MAX; idx++)
        {
            const PlacementObj::SaveStructure* pobjsvst = &_pobjsvst[idx];
            if(isSamePlacementObj(pobjsvst, pobj))
            {
                pobj->restoreFromStructure(pobjsvst);	// 復元
                break;
            }
        }
    }

    return true;
}

/*---------------------------------------------------------------------*//**
	解析関数情報追加
**//*---------------------------------------------------------------------*/
void EsExternalExtension::addParsedFuncInfo(const VcString* nameFunc, bool isDef)
{
	if(_listParsedFuncInfo == 0L)	{	return;	}

	// 入力された関数の種類
	EsParsedFuncInfo::Kind kind = isDef ? EsParsedFuncInfo::KIND_DEF : EsParsedFuncInfo::KIND_CALL;

	// 重複チェック
	for(ListIterator<EsParsedFuncInfo*> it = _listParsedFuncInfo->iterator(); it.has(); it.next())
	{
		EsParsedFuncInfo* pfi = it.object();
		if(	(pfi->getKind() == kind) &&
			(pfi->getFuncName()->equals(nameFunc))	)
		{
			return;	// 重複
		}
	}

	// リストに追加する
	EsParsedFuncInfo* pfi = new EsParsedFuncInfo(nameFunc, kind);
	_listParsedFuncInfo->addTail(pfi);
}

/*---------------------------------------------------------------------*//**
	スキルフレーム処理 - 実行中
**//*---------------------------------------------------------------------*/
bool Char1504_Shika_EnemySpirit::execSkillAct(ExecRes* res, const ExecCtx* ec, s32 cntStep, f32 frmcntStep)
{
	const f32 FRAME_STEP = 0.76667f * FRAMERATE;

	if(cntStep == 1)
	{
		setBefaviorMaxFrame(FRAME_STEP);	// 最大の行動フレーム数設定
	}

	setBefaviorCurrentFrame(frmcntStep);	// 現在の行動フレーム数設定

	if(frmcntStep >= FRAME_STEP)	// 攻撃フレーム
	{
		const CharLogicData* cldat = getCharLogicData(); ASSERT(cldat != 0L);
		// 範囲内の対象をリストアップ
		f32 lenEffctvSq = cldat->getSkillRange() * cldat->getSkillRange();
		List<Unit*> listUnits;
		CalcUtils::collectUnitFanRange(
			&listUnits,
			getThisUnit()->getPosition(),
			getThisUnit()->getDirection()->y(),
			Unit::UNITFLAG_PC,
			lenEffctvSq,
			TFW_COS45	);	// ±45°以内
		// リストアップしたユニットにクラスタを投げる
		Unit* unitTrg = 0L;
		for(ListIterator<Unit*> it = listUnits.iterator(); it.has(); it.next())
		{
			unitTrg = it.object();
			break;
		}

#if 1
		TransStat tstat;
		EleneStat eestatSkill(cldat->getSkillOqlElene(), cldat->getSkillCurElene());
		tstat.setupForSkill(getThisUnit(), &eestatSkill);
		MagicInfluencer::serveGeneralMc(getThisUnit(), unitTrg, &tstat, GameParticleDef::PTCLK_SKILL_SHOCK_WAVE);
#else
		MagicSys* mgcsys = Game::getGame()->getMagicSys(); ASSERT(mgcsys != 0L);
		MagicClusterCreateParam mccprm(MagicClusterType::SERVED, GameParticleDef::PTCLK_SKILL_SHOCK_WAVE);
		EleneStat eestatSkill(cldat->getSkillOqlElene(), cldat->getSkillCurElene());
		Vector3F pos(*getThisUnit()->getCenterPos());
		mccprm._unitOwnrRef = getThisUnit();
		mccprm._unitMainTrgRef = unitTrg;
		mccprm._pos = &pos;
		mccprm._tstat.setupForSkill(getThisUnit(), &eestatSkill);
		mccprm._lifeframe = cldat->getSkillCurElene()->getWater() / Elene::ELENE_VALID_FIGURE;
		mccprm._isNoOnlyTrgColl = true;
		u16 mcidNew = mgcsys->appearCluster(&mccprm);
		if(mcidNew == 0)		{	return true;	}	// 成功ではないが終えるために次のステップへ
		MagicCluster* mcNew = mgcsys->getCluster(mcidNew);
		if(mcNew == 0L)			{	return true;	}	// 成功ではないが終えるために次のステップへ
		TFW_SET_FLAG(*mcNew->ctrlFlags(), MagicCluster::CTRLF_DIR_TO_ROTZ, true);	// 方向を Z 軸回転に反映させる

		// クラスタ発射
		/*
		f32 acc = cldat->getSkillCurElene()->getWind() * (0.1f / (f32)Elene::ELENE_VALID_FIGURE);
		if(acc < 0.033f)	{	acc = 0.033f;	}
		Vector3F accMc(0.0, 0.0, acc);
		Matrix4F mtxRot;
		mtxRot.rotateY(getThisUnit()->getDirection()->y());
		mtxRot.mult(&accMc, &accMc);
		mcNew->accelerate(&accMc);
		*/
		f32 speed = cldat->getSkillCurElene()->getWind() * (0.1f / (f32)Elene::ELENE_VALID_FIGURE);
		if(speed < 0.033f)	{ speed = 0.033f; }
		Vector3F velMc(0.0f, 0.0f, speed);
		Matrix4F mtxRot;
		mtxRot.rotateY(getThisUnit()->getDirection()->y());
		mtxRot.mult(&velMc, &velMc);
		mcNew->setInitialVelocity(&velMc);
		mcNew->reflectPosture();
#endif

		resetBefaviorFrame();		// 行動フレームリセット
		return true;
	}

	return false;	// 継続する
}

/*---------------------------------------------------------------------*//**
	デシリアライズ
**//*---------------------------------------------------------------------*/
bool StoryManager::deserialize(Serializer* ser)
{
	// ストーリーデータの読み込み
	s32 storyid = 0;
	u16 evidActing = 0;
	bool isPlayedStoryStartupEvent = false;
	bool isEvIntvl = TFW_IS_FLAG(Game::getGame()->getSaveSys()->getSaveData()->getLoadTimeSaveFlags(), SaveData::SVF_EVENT_INTVL);
	if(ser->isStructureMode())	// ストラクチャモード
	{
		const SaveStructure* svst = (SaveStructure*)ser->getStructure();
		storyid = svst->_gamesvst._storyid;										// ストーリー ID 値の読み込み
		isPlayedStoryStartupEvent = svst->_gamesvst._isPlayedStoryStartupEvent;	// ストーリー開始イベント起動フラグの読み込み
		evidActing = svst->_gamesvst._evidActing;								// 実行中の Act イベント ID の読み込み
	}
	else						// ダイレクトモード
	{
		ser->restore(&storyid);						// ストーリー ID 値の読み込み
		ser->restore(&isPlayedStoryStartupEvent);	// ストーリー開始イベント起動フラグの読み込み
		ser->restore(&evidActing);					// 実行中の Act イベント ID の読み込み
	}

	// Volume 1 Lite 版はストーリーが 10203 まで（この実装はあまり美しくない…．オーバーライドによる実装を要検討【2010/10/29 r-kishi】）
	#if defined(_ENLIGHT_V01_LITE)
		if(storyid > 10203)
		{
			storyid	= 10203;
			isPlayedStoryStartupEvent = false;
			Game::getGame()->getSaveSys()->getSaveData()->setSaveF(SaveIdDef::SFID_ST10203_CORPO_SAY_TOGETHER, false);	// [St10203] アサダウン後コルポ合流時のイベントを見ていない
		}
	#endif

	// ストーリーのロード
	loadStory(storyid);	// ストーリーを読み込む
	_isPlayedStoryStartupEvent = isPlayedStoryStartupEvent;

	// 配置オブジェクトの状態を読み込む
	if(ser->isStructureMode())	// ストラクチャモード
	{
		SaveStructure* svst = (SaveStructure*)ser->getStructure();
		if(!svst->restorePlacementObjData(_listPlaceObj))
		{
			return false;
		}
	}
	else						// ダイレクトモード
	{
		s32 numPobj = 0;
		ser->restore(&numPobj);
		ASSERT(_listPlaceObj->getCount() == numPobj);
		ListIterator<PlacementObj*> it = _listPlaceObj->iterator();
		for(int i = 0; i < numPobj; i++)
		{
			if(!it.has())
			{
				ASSERT(false);
				return false;
			}
			PlacementObj* pobj = it.object();
			pobj->deserialize(ser);
			it.next();
		}
	}

	// ワールドマップのデシリアライズ
	_wmap->deserialize(ser);

	// イベント途中セーブデータは再開時イベントをセットする
	if(isEvIntvl && (evidActing != 0))
	{
		reserveEventForResume(evidActing, true);
	}

	return true;
}

/*---------------------------------------------------------------------*//**
	マップ変更後通知
**//*---------------------------------------------------------------------*/
void StoryManager::notifyChangedMap(bool isDeserializeCase)
{
	Map* map = Game::getGame()->getMap(); ASSERT(map != 0L);
	MoveMap* mvmap = Game::getGame()->getMoveMap(); ASSERT(mvmap != 0L);

	// マップに脇役を配置
	for(ListIterator<PlacementObj*> it = _listPlaceObj->iterator(); it.has(); it.next())
	{
		PlacementObj* pobj = it.object();

		if(isDeserializeCase)	// セーブデータ読み込み時
		{
			if(pobj->isPlaced())		// 配置済み
			{
				map->placePlacementObj(pobj, true);		// マップ配置を復元
			}
			else if(pobj->isNewPlacedCondition())
			{
				map->placePlacementObj(pobj, false);	// マップに通常条件配置
			}
		}
		else
		{
			if(pobj->isNewPlacedCondition())
			{
				map->placePlacementObj(pobj, false);	// マップに配置
			}
			else if(pobj->isPlaced())	// 配置済み
			{
				map->unplacePlacementObj(pobj);			// 配置解除
			}
		}
	}

	// マップ置換イベントを処理
	EventData* evdat = _evsysRef->getEventData();
	for(ListIterator<OverrideEventMatter*> it = _listOvrdEvm->iterator(); it.has(); it.next())
	{
		const OverrideEventMatter* oem = it.object();
		if(oem->getKind() == OverrideEventMatter::KIND_MAP)	// タイプがマップのもののみ
		{
			if(oem->isCondition())
			{
				evdat->overrideMatter(oem);
			}
		}
	}

	// マップモジュールを作成
	_mapmod = MapModFactory::makeMapMod(mvmap->getCurMapId()); ASSERT(_mapmod != 0L);

	// マップ開始時イベントを起動
	beginAutoBeginEvent(AutoBeginEventInfo::KIND_MAP_START);

	// 各通知処理
	ASSERT(_stmod != 0L);
	_stmod->onDecisionParty(mvmap->getCurMapId(), mvmap->getPrevMapId());
	_stmod->notifyChangedMap(mvmap->getCurMapId(), mvmap->getPrevMapId());
	_mapmod->begin();
	_wmap->notifyChangedMap();
}