Exemple #1
0
static void
UpdateListener( ARRAY8Ptr addr, void **closure )
{
	struct socklist *s;

	*closure = NULL;

	if (addr == NULL) {
		ARRAY8 tmpaddr;
		struct in_addr in;
#if defined(IPv6) && defined(AF_INET6)
		struct in6_addr in6 = in6addr_any;
		tmpaddr.length = sizeof(in6);
		tmpaddr.data = (CARD8Ptr) &in6;
		UpdateListener( &tmpaddr, closure );
		if (*closure)
			return;
#endif
		in.s_addr = htonl( INADDR_ANY );
		tmpaddr.length = sizeof(in);
		tmpaddr.data = (CARD8Ptr) ∈
		UpdateListener( &tmpaddr, closure );
		return;
	}

	if (c_request_port == request_port &&
	    (s = FindInList( listensocks, addr )))
	{
		*closure = (void *)s;
		s->ref = 1;
		return;
	}

	if (!(s = CreateSocklistEntry( addr )))
		return;

	if ((s->fd = CreateListeningSocket( s->addr, s->salen )) < 0) {
		free( s->addr );
		free( s );
		return;
	}
	s->ref = 1;
	s->next = listensocks;
	listensocks = s;
	*closure = (void *)s;
}
status_t
NotificationManager::UpdateListener(const char* serviceName,
	uint32 eventMask, NotificationListener& listener)
{
	char buffer[96];
	KMessage specifier;
	specifier.SetTo(buffer, sizeof(buffer), 0);
	specifier.AddInt32(kEventMaskString, eventMask);

	return UpdateListener(serviceName, &specifier, listener);
}
Exemple #3
0
 void DefaultWinInputHandler::VOnUpdate(void)
 {
     for(uint i = 0; i < 0xFE; ++i)
     {
         if(m_isKeyDown[i])
         {
             InputMessage keymsg;
             keymsg.button = i;
             keymsg.message = KEY_DOWN;
             UpdateListener(keymsg);
         }
     }
 }
void DemoSoundListener::PostUpdate (const NewtonWorld* const world, dFloat timestep)
{
	DemoEntityManager* const scene = (DemoEntityManager*) NewtonWorldGetUserData(world);

	DemoCamera* const camera = scene->GetCamera();
	dMatrix matrix0 (camera->GetCurrentMatrix ());
	dMatrix matrix1 (camera->GetNextMatrix ());
	dVector veloc ((matrix1.m_posit - matrix0.m_posit).Scale (1.0f / timestep));
	//printf ("%f %f %f %f\n", veloc.m_x, veloc.m_y, veloc.m_z, timestepInSecunds);

	UpdateListener (matrix1.m_posit, veloc, matrix0.m_front, matrix0.m_up);
	dSoundManager::Update();
}
bool CCheckpointSystem::SaveGame(EntityId checkpointId, const char* fileName)
{
	CRY_ASSERT(fileName);
	if(!fileName || CHECKPOINT_SAVE_XML_NODE || CHECKPOINT_LOAD_XML_NODE)
		return false;

	//set extension
	FixedCheckpointString file(fileName);
	SetFilenameExtension(file);

	CryWarning(VALIDATOR_MODULE_GAME, VALIDATOR_COMMENT, "Saving checkpoint %s", file.c_str());

	CHECKPOINT_SAVE_XML_NODE = GetISystem()->CreateXmlNode("Checkpoint");

	//write checkpoint data
	SCheckpointData metaData;
	WriteMetaData(checkpointId, CHECKPOINT_SAVE_XML_NODE, metaData);

	//actor data
	// TODO For now, not saving actor info (AI) - If this happens later, support needs to be added for entity pools
	//WriteActorData(CHECKPOINT_SAVE_XML_NODE);

	//vehicle data
	WriteVehicleData(CHECKPOINT_SAVE_XML_NODE);

	//write game tokens
	WriteGameTokens(CHECKPOINT_SAVE_XML_NODE);

	//let game write
	if (m_pGameHandler)
	{
		m_pGameHandler->OnWriteData(CHECKPOINT_SAVE_XML_NODE);
	}

	//inform listeners
	UpdateListener(metaData, true);

	//write to file
	WriteXML(CHECKPOINT_SAVE_XML_NODE, file.c_str());

	//draw text message on screen
	//static const ColorF color (0.0f, 0.85f, 0.2f, 1.0f);
	//g_pGame->GetIGameFramework()->GetIPersistantDebug()->Add2DText("Checkpoint saved", 2.5f, color, 2.0f);

	CHECKPOINT_SAVE_XML_NODE = NULL;

	return true;
}
void COpenALSound::Update()
{
	for (int a=0;a<maxSounds;a++) {
		if (Sources[a]) {
			ALint state;
			alGetSourcei(Sources[a],AL_SOURCE_STATE, &state);
			if (state == AL_STOPPED) {
				alDeleteSources(1,&Sources[a]);
				Sources[a]=0;
			}
		}
	}
	CheckError("COpenALSound::Update");

	UpdateListener();
}
Exemple #7
0
    bool DefaultWinInputHandler::VOnMessage(const MSG& msg)
    {
        switch(msg.message)
        {
        case WM_MOUSEMOVE:
            {
                int posx = GET_X_LPARAM(msg.lParam);
                int posy = GET_Y_LPARAM(msg.lParam);
                InputMessage imsg;

                imsg.mouseX = posx;
                imsg.mouseY = posy;

                if(m_isMouseGrabbed)
                {
                    RECT rc;
                    GetWindowRect(m_hwnd, &rc);
                    int x = (rc.right - rc.left) / 2;
                    int y = (rc.bottom - rc.top) / 2;

                    imsg.mouseDY = posy - y;
                    imsg.mouseDX = posx - x;
                    imsg.message = TBD_MOUSE_MOVED;

                    if(imsg.mouseDX != 0 || imsg.mouseDY != 0)
                    {
                        //add 8 and 30 pixels to compensate borders, TODO
                        SetCursorPos(rc.left + x + m_curserXOffset, rc.top + y + m_curserYOffset);
                    }
                }
                else
                {
                    imsg.mouseDY = posy - m_lastMousePosY;
                    imsg.mouseDX = posx - m_lastMousePosX;
                    imsg.message = TBD_MOUSE_MOVED;

                    m_lastMousePosX = posx;
                    m_lastMousePosY = posy;
                }
                if(imsg.mouseDX != 0 || imsg.mouseDY)
                {
                    UpdateListener(imsg);
                }

            } break;
        case WM_LBUTTONDOWN:
            {
                int posx = GET_X_LPARAM(msg.lParam);
                int posy = GET_Y_LPARAM(msg.lParam);
                InputMessage imsg;
                imsg.mouseX = posx;
                imsg.mouseY = posy;
                imsg.button = MOUSE_BTN_LEFT;
                imsg.message = MOUSE_BUTTON_PRESSED;
                UpdateListener(imsg);
            } break;
        case WM_RBUTTONDOWN:
            {
                int posx = GET_X_LPARAM(msg.lParam);
                int posy = GET_Y_LPARAM(msg.lParam);
                InputMessage imsg;
                imsg.mouseX = posx;
                imsg.mouseY = posy;
                imsg.button = MOUSE_BTN_RIGHT;
                imsg.message = MOUSE_BUTTON_PRESSED;
                UpdateListener(imsg);
            } break;
        case WM_LBUTTONUP:
            {
                int posx = GET_X_LPARAM(msg.lParam);
                int posy = GET_Y_LPARAM(msg.lParam);
                InputMessage imsg;
                imsg.mouseX = posx;
                imsg.mouseY = posy;
                imsg.button = MOUSE_BTN_LEFT;
                imsg.message = MOUSE_BUTTON_RELEASED;
                UpdateListener(imsg);
            } break;
        case WM_RBUTTONUP:
            {
                int posx = GET_X_LPARAM(msg.lParam);
                int posy = GET_Y_LPARAM(msg.lParam);
                InputMessage imsg;
                imsg.mouseX = posx;
                imsg.mouseY = posy;
                imsg.button = MOUSE_BTN_RIGHT;
                imsg.message = MOUSE_BUTTON_RELEASED;
                UpdateListener(imsg);
            } break;
        case WM_KEYDOWN:
            {
                InputMessage imsg;
                imsg.button = (uint)msg.wParam;
                imsg.message = (KF_REPEAT & HIWORD(msg.lParam)) ? KEY_REPEAT : KEY_PRESSED;
                UpdateListener(imsg);
                m_isKeyDown[imsg.button] = true;
            } break;
        case WM_KEYUP:
            {
                InputMessage imsg;
                imsg.button = (uint)msg.wParam;
                imsg.message = KEY_RELEASED;
                UpdateListener(imsg);
                m_isKeyDown[imsg.button] = false;
            } break;
        case WM_MOUSEWHEEL:
            {
                int posx = GET_X_LPARAM(msg.lParam);
                int posy = GET_Y_LPARAM(msg.lParam);
                InputMessage imsg;
                imsg.mouseX = posx;
                imsg.mouseY = posy;
                imsg.message = MOUSE_WHEEL;
                imsg.mouseWheelDelta = GET_WHEEL_DELTA_WPARAM(msg.wParam);
                UpdateListener(imsg);
            } break;
        }
        return true;
    }
Exemple #8
0
int KRLLocalCharacter::Update(double fTime, double fTimeLast, DWORD dwGameLoop, BOOL bFrame)
{
    int nRetCode = false;
    int nResult = false;
    HRESULT hr = E_FAIL;
    RL_ANIMATION_UP nAnimationUp = RL_ANIMATION_UP_NONE;
    RL_ANIMATION_DOWN nAnimationDown = RL_ANIMATION_DOWN_NONE;
    RL_ADVANCE nAdvance = RL_ADVANCE_FORWARD;

    ASSERT(!m_RLCharacter.IsFadeOut());

    if (m_RLCharacter.m_RenderData.HasLoadedMDL())
    {
        if (bFrame)
        {
            m_RLCharacter.m_FrameData.UpdateRepresentFrameData(TRUE);

            if (m_bSheath != m_RLCharacter.m_FrameData.m_Current.bSheathFlag)
            {
                m_bSheath = m_RLCharacter.m_FrameData.m_Current.bSheathFlag;
                m_RLCharacter.UpdateSheath(m_bSheath);
            }
        }

        nRetCode = m_RLCharacter.m_FrameData.Interpolate(m_RLCharacter.m_RenderData.IsVisible(), false);
        KGLOG_PROCESS_ERROR(nRetCode);

        nRetCode = UpdatePosition();
        KGLOG_PROCESS_ERROR(nRetCode);

        nRetCode = UpdateDirection();
        KGLOG_PROCESS_ERROR(nRetCode);

        nAnimationDown = GetRLAnimationDown(
                             m_RLCharacter.m_FrameData.m_Current.nMoveState,
                             m_RLCharacter.m_FrameData.m_Current.nOTAction,
                             m_RLCharacter.m_FrameData.m_Current.nJumpCount,
                             m_nTurning);

        nAdvance = GetAdvance(nAnimationDown);

        nRetCode = UpdateListener();
        KGLOG_PROCESS_ERROR(nRetCode);

        if (bFrame)
        {
            if (m_RLCharacter.m_bAnimationPaused && nAnimationDown != RL_ANIMATION_DOWN_FREEZE)
                m_RLCharacter.PauseAnimation(FALSE);

            nAnimationUp = GetRLAnimationUp(m_RLCharacter.m_FrameData.m_Current.nOTAction);

            if (nAnimationUp == RL_ANIMATION_UP_NONE && m_nAnimationUp != RL_ANIMATION_UP_NONE ||
                    nAnimationUp != RL_ANIMATION_UP_NONE)
            {
                nRetCode = m_RLCharacter.UpdateAnimationUp(nAnimationUp);
                KGLOG_PROCESS_ERROR(nRetCode);

                m_nAnimationUp = nAnimationUp;
            }

            nRetCode = m_RLCharacter.UpdateVehicle(
                           m_RLCharacter.m_FrameData.m_Current.nVehicleTrack,
                           FALSE);
            KGLOG_PROCESS_ERROR(nRetCode);

            nRetCode = m_RLCharacter.UpdateAnimationDown(nAnimationDown, nAdvance,
                       m_RLCharacter.m_FrameData.m_Current.nFightFlag,
                       m_RLCharacter.m_FrameData.m_Current.dwSkillBuffs);
            KGLOG_PROCESS_ERROR(nRetCode);

            UpdateLifeState();

            UpdateAnimationSpeed(nAnimationDown, nAdvance);

            if (m_dwLockControlFrame > 0)
            {
                --m_dwLockControlFrame;
            }

            hr = m_RLCharacter.m_RenderData.Update();
            KGLOG_COM_PROCESS_ERROR(hr);
        }
    }

    nResult = true;
Exit0:
    return nResult;
}
bool CCheckpointSystem::LoadGame(const char* fileName)
{
	//make sure not not save/load recursively or multiple times at once
	if(CHECKPOINT_SAVE_XML_NODE || CHECKPOINT_LOAD_XML_NODE)
		return false;

	//set extension
	FixedCheckpointString file(fileName);
	SetFilenameExtension(file);

	CHECKPOINT_LOAD_XML_NODE = ReadXML(file.c_str());
	if(!CHECKPOINT_LOAD_XML_NODE)
		return false;

	CryWarning(VALIDATOR_MODULE_GAME, VALIDATOR_COMMENT, "Loading checkpoint %s", file.c_str());

	//check for EntityId errors
	CHECKPOINT_RESAVE_NECESSARY = false;

	//process meta data
	SCheckpointData metaData;
	if(!ReadMetaData(CHECKPOINT_LOAD_XML_NODE, metaData))
		return false;

	//check version number
	if(metaData.m_versionNumber != CHECKPOINT_VERSION_NUMBER)
	{
		CryWarning(VALIDATOR_MODULE_GAME, VALIDATOR_ERROR, "Checkpoint version number (%i) does not match current version (%i). Please reexport all checkpoints of this level to prevent errors!", metaData.m_versionNumber, CHECKPOINT_VERSION_NUMBER);
	}
 
	//check for level mismatch
	CryFixedStringT<32> curlevelName = CCryAction::GetCryAction()->GetLevelName();
	RepairLevelName(curlevelName);
	if(curlevelName.empty() || stricmp(metaData.m_levelName.c_str(), curlevelName.c_str()))
	{
		if(!LoadCheckpointMap(metaData, curlevelName))
			return false;
	}
	else
	{
		//reset the dynamic parts of the engine
		ResetEngine();
	}

	//read actor data and respawn AI
	// TODO For now, not restoring actor info (AI) - If this happens later, support needs to be added for entity pools
	//RespawnAI(CHECKPOINT_LOAD_XML_NODE);

	//load gametokens again
	ReadGameTokens(CHECKPOINT_LOAD_XML_NODE);

	//let game read
	if (m_pGameHandler)
	{
		m_pGameHandler->OnReadData(CHECKPOINT_LOAD_XML_NODE);
	}

	//resets some gameplay data like action filters etc.
	RestartGameplay();

	//load external entities, that are controlled by flowgraph
	LoadExternalEntities(CHECKPOINT_LOAD_XML_NODE);

	//inform listeners
	UpdateListener(metaData, false);

	//trigger flowgraph node
	OnCheckpointLoaded(metaData);

	//draw text message on screen
	//static const ColorF color (0.0f, 0.85f, 0.2f, 1.0f);
	//g_pGame->GetIGameFramework()->GetIPersistantDebug()->Add2DText("Checkpoint loaded", 2.5f, color, 2.0f);

	//checkpoint file sanity check
	if(CHECKPOINT_RESAVE_NECESSARY)
	{
		CryWarning(VALIDATOR_MODULE_GAME, VALIDATOR_WARNING, "Checkpoint file contained obsolete or wrong data, trying to re-save checkpoint.");
		//resave checkpoint to fix changed entity Ids
		SaveGame(metaData.m_checkPointId, fileName);
		//make sure the script entity is aware of the activity
		OnCheckpointLoaded(metaData);
	}

	CHECKPOINT_LOAD_XML_NODE = NULL;

	//when a checkpoint was loaded, it becomes the most recent checkpoint
	g_lastSavedCheckpoint = fileName;

	//make sure the scripts are clean
	//CXP : this caused a crash after some reloads, which hints to problems in the gamerules script
	//gEnv->pScriptSystem->ForceGarbageCollection();

	return true;
}
// Rebuild the sound stage to reflect any recent changes in sound
HRESULT DS3DSoundEngine::Update()
{
    HRESULT hr;
    Vector vectListenerPosition;
    DWORD dwUpdateTime = timeGetTime();
    DWORD dwUpdatePeriod = dwUpdateTime - m_dwLastUpdateTime;

	// mdvalley: Update no faster than every 30ms
	if(dwUpdatePeriod < 30)
		return S_OK;

    // fire the update event.
    m_peventsourceUpdate->Trigger(dwUpdatePeriod);

    typedef std::vector<DSVirtualSoundBuffer*> TempSoundList;

    // get the current position of the listener, to use for future 
    // calculations.
    hr = m_plistener->GetPosition(vectListenerPosition);
    if (ZFailed(hr)) return hr;

    
    // Walk the list of active sounds and call update for each one, 
    // removing the sounds which have ended, keeping track of which sounds
    // have playing buffers
    
    TempSoundList listPrevSounds;
    listPrevSounds.reserve(m_nNumBuffersMax);

    VirtualSoundList::iterator iterSound;
    for (iterSound = m_listActiveSounds.begin();
        iterSound != m_listActiveSounds.end();)
    {
        hr = (*iterSound)->Update(dwUpdatePeriod, vectListenerPosition, 
            m_fRolloffFactor);
        if (ZFailed(hr)) return hr;

        // if this is no longer playing, remove it from the list.
        if ((*iterSound)->IsStopped())
        {
            iterSound = m_listActiveSounds.erase(iterSound);
        }
        else
        {
            // if the sound has an active buffer, keep track of it.
            if ((*iterSound)->HasPlayingBuffer())
                listPrevSounds.push_back(
                    (TRef<DSVirtualSoundBuffer>)(*iterSound)
                    );
            ++iterSound;
        }
    }


    // get the n most important sounds that we wish to play
    TempSoundList listNewSounds;
    if (!m_listActiveSounds.empty())
    {
        // create a list of all of the sounds
        TempSoundList listAllSounds(m_listActiveSounds.size());
        std::transform(m_listActiveSounds.begin(), m_listActiveSounds.end(), 
            listAllSounds.begin(), RefToPtr<DSVirtualSoundBuffer>());

        // turn it into a priority queue
        std::make_heap(listAllSounds.begin(), listAllSounds.end(), std::not2(SoundPriorityCompare()));

        // get the m_nNumBuffersDesired most important sounds by popping 
        // them off of the queue
        listNewSounds.reserve(m_nNumBuffersDesired);
        for (int nSound = 0; nSound < min(m_nNumBuffersDesired, listAllSounds.size()); nSound++)
        {
            std::pop_heap(listAllSounds.begin(), listAllSounds.end() - nSound, 
                std::not2(SoundPriorityCompare()));

            DSVirtualSoundBuffer* pbuffer = (*(listAllSounds.end() - nSound - 1));
            if (pbuffer->IsAudible())
                listNewSounds.push_back(pbuffer);
        }
    }

   
    // Compare the previously playing sounds and the list of new sounds we
    // want to play, and start and stop the sound buffers as needed to 
    // achieve this.
    {
        // sort the old list by priority
        std::sort(listPrevSounds.begin(), listPrevSounds.end(), SoundPriorityCompare());

        // find the first sound which is not in the new list
        TempSoundList::iterator iterDead = 
            (listNewSounds.empty()) ? listPrevSounds.begin() :
            std::find_if(listPrevSounds.begin(), listPrevSounds.end(), 
                std::bind1st(SoundPriorityCompare(), *(listNewSounds.end() - 1)));

        // stop all of the old buffers 
        // REVIEW: should fade out, if we have buffers.
        for (; iterDead != listPrevSounds.end(); iterDead++)
        {
            hr = (*iterDead)->StopBuffer();
            if (ZFailed(hr)) return hr;
        }

        // Start any new sounds            
        for (TempSoundList::iterator iterNew = listNewSounds.begin();
            iterNew != listNewSounds.end(); ++iterNew)
        {
            if (!(*iterNew)->HasPlayingBuffer())
            {
				if(m_pDirectSound8)
					hr = (*iterNew)->StartBuffer8(m_pDirectSound8, m_quality, m_bAllowHardware);
				else
					hr = (*iterNew)->StartBuffer(m_pDirectSound, m_quality, m_bAllowHardware);
                if (IsSeriousError(hr))
                {
                    // Silently fail
                    debugf("Serious error during update while starting sound: %X\n", hr);
                }
            }
        };
    }

    // update the listener's position, velocity, etc., 
    hr = UpdateListener();
    if (ZFailed(hr)) return hr;

    // Commit any and all deferred changes.
    hr = m_pDSListener->CommitDeferredSettings();
    if (ZFailed(hr)) return hr;

    m_dwLastUpdateTime = dwUpdateTime;

    return S_OK;
}