int find_next_state_for_state( STATE current, STATE *next, int flag )
{
    int i = 0;

    for( i=0; TABLE_CURRENT_STATE_TYPE(i)!=0; ++i ) {
	if( flag == STATE_FLAG_ALL ) {
	    if( ( ( STATE_TYPE(current) == TABLE_CURRENT_STATE_TYPE(i) ) ||
			( TABLE_CURRENT_STATE_TYPE(i) == STATE_ANY ) ) &&
		    ( STATE_MAIN_CMD(current) == TABLE_CURRENT_STATE_MAIN_CMD(i) ) &&
		    ( STATE_SUB_CMD(current) == TABLE_CURRENT_STATE_SUB_CMD(i) ) ) {
		memcpy( next, &state_table[i].next_state, sizeof( STATE ) );

		return 1;
	    }
	}
	else if( ( flag & STATE_FLAG_TYPE ) &&
                 ( ( STATE_TYPE(current) == TABLE_CURRENT_STATE_TYPE(i) ) ||
                   ( TABLE_CURRENT_STATE_TYPE(i) == STATE_ANY )
		 ) &&
		 ( flag & STATE_FLAG_MAIN_CMD ) &&
		 ( STATE_MAIN_CMD(current) == TABLE_CURRENT_STATE_MAIN_CMD(i) )
	       ) {
	    memcpy( next, &state_table[i].next_state, sizeof( STATE ) );

	    return 1;
	}
	else if( ( ( flag == STATE_FLAG_TYPE ) &&
		   ( ( STATE_TYPE(current) == TABLE_CURRENT_STATE_TYPE(i) ) ||
		     ( TABLE_CURRENT_STATE_TYPE(i) == STATE_ANY )
		   )
		 )
	       ) {
	    memcpy( next, &state_table[i].next_state, sizeof( STATE ) );

	    return 1;
	}
	else if( ( flag == STATE_FLAG_MAIN_CMD ) &&
		 ( STATE_MAIN_CMD(current) == TABLE_CURRENT_STATE_MAIN_CMD(i) )
	       ) {
	    memcpy( next, &state_table[i].next_state, sizeof( STATE ) );

	    return 1;
	}
	else if( ( flag == STATE_FLAG_SUB_CMD ) &&
		 ( STATE_SUB_CMD(current) == TABLE_CURRENT_STATE_SUB_CMD(i) )
	       ) {
	    memcpy( next, &state_table[i].next_state, sizeof( STATE ) );

	    return 1;
	}
    }

    return 0;
}
void print_state_machine(void)
{
    log_msg(MSGL_VGSM_INFO,"==========================\n");
   log_msg(MSGL_VGSM_INFO, "PREV_STATE: %s, %d, %d, %p \n",
	    string_state[STATE_TYPE(state_machine->prev_state)],
	    STATE_MAIN_CMD(state_machine->prev_state),
	    STATE_SUB_CMD(state_machine->prev_state),
	    STATE_FUNCTION(state_machine->prev_state) );
    log_msg(MSGL_VGSM_INFO, "CURRENT_STATE: %s, %d, %d, %p\n",
	    string_state[STATE_TYPE(state_machine->current_state)],
	    STATE_MAIN_CMD(state_machine->current_state),
	    STATE_SUB_CMD(state_machine->current_state),
	    STATE_FUNCTION(state_machine->current_state) );
    log_msg(MSGL_VGSM_INFO,"==========================\n");
}
void print_state( STATE state )
{
    log_msg(MSGL_VGSM_INFO, "STATE: %d, %d, %d\n",
	    STATE_TYPE(state),
	    STATE_MAIN_CMD(state),
	    STATE_SUB_CMD(state) );
}
void set_state_machine( STATE state )
{
    int type = STATE_TYPE(state_machine->current_state);

    _ENTER();

    memcpy( &state_machine->prev_state, &state_machine->current_state, sizeof( STATE ) );
    memcpy( &state_machine->current_state, &state, sizeof( STATE ) );

    if( ( STATE_TYPE(state) == STATE_NONE ) || ( STATE_TYPE(state) == STATE_ANY ) )
	STATE_TYPE(state_machine->current_state) = type;

#ifdef	_DEBUG
    print_state_machine();
#endif /* _DEBUG */

    _LEAVE();
}
void set_current_state( int state, int main_cmd, int sub_cmd)
{
    _ENTER();

	STATE st;
    STATE_TYPE(st) = state;
    STATE_MAIN_CMD(st) = main_cmd;
    STATE_SUB_CMD(st) = sub_cmd;
    //STATE_FUNCTION(st) = func;
    set_state_machine( st );
	    _LEAVE();
}
Exemple #6
0
/// 중복적용 가능 체크...
/*static*/ bool CSkillManager::CheckDuplicatable( int iSkillIDX, CObjCHAR* pCaster, int iTargetObjIDX )
{
	if( pCaster == NULL )
		return false;	

	/// 지속형 스킬의 경우.. 중복여부를 체크한다.
	if( SKILL_TYPE( iSkillIDX ) == SKILL_ACTION_SELF_BOUND_DURATION ||
		SKILL_TYPE( iSkillIDX ) == SKILL_ACTION_TARGET_BOUND_DURATION ||
		SKILL_TYPE( iSkillIDX ) == SKILL_ACTION_SELF_STATE_DURATION ||
		SKILL_TYPE( iSkillIDX ) == SKILL_ACTION_TARGET_STATE_DURATION )
	{
		int		iStateSTB		= 0;
		int		iSkillState		= 0;
		DWORD	dwSkillStateFlag = 0;
		DWORD	dwState 		 = 0;

		int		iBoundStateSTB = 0;

		CObjCHAR *pTargetCHAR = NULL;
		
		/// 나한테 거는거라면..
		if( SKILL_TYPE( iSkillIDX ) == SKILL_ACTION_SELF_BOUND_DURATION ||
			SKILL_TYPE( iSkillIDX ) == SKILL_ACTION_SELF_STATE_DURATION )
		{
			pTargetCHAR = pCaster;	
		}else
		{
			pTargetCHAR = g_pObjMGR->Get_CharOBJ( iTargetObjIDX, false );	
		}

		if( pTargetCHAR == NULL )
			return false;

		for( int i = 0; i < SKILL_INCREASE_ABILITY_CNT; i++ )
		{			
			iStateSTB = SKILL_STATE_STB( iSkillIDX, i );
			if( iStateSTB == 0 )
				continue;

			iSkillState = STATE_TYPE( iStateSTB );
			dwSkillStateFlag = c_dwIngFLAG[ iSkillState ];

			/// 상태 해지 스킬은 중복상태를 체크하지 않음	
			if( ( iSkillState == ING_CLEAR_GOOD ) ||
				( iSkillState == ING_CLEAR_BAD ) ||
				( iSkillState == ING_CLEAR_ALL ) )
			{
				continue;
			}

			dwState = pTargetCHAR->m_EndurancePack.GetStateFlag();			

			/// 현재 걸려는 스킬타입이 이미 걸려있다.
			if( dwState & dwSkillStateFlag )
			{
				/// 중복불가..
				if( STATE_CAN_DUPLICATED( iStateSTB ) == 0 )
				{
					return false;
				}

				CEnduranceProperty* pEntity = pTargetCHAR->m_EndurancePack.GetEntityByStateType( iSkillState );

				/// 새로 발동한 스킬이 현재 걸린 스킬의 LIST_STATUS.STB 상의 번호가 작을때는 패스..
				if( pEntity && iStateSTB < pEntity->GetStateSTBNO() )
				{
					return false;
				}
			}
		}		
	}

	return true;
}