Archive/openmohaa
0
0
Fork 0
mirror of https://github.com/openmoh/openmohaa.git synced 2025-04-29 14:17:57 +03:00
Code Issues Projects Releases Packages Wiki Activity Actions 2

Reworked source tree so it compiles

Browse source
This commit is contained in:
L 2023-01-29 20:59:31 +01:00
parent 19e33444e7
commit 8ef16a91f2
164 changed files with 3183 additions and 20134 deletions
Download patch file Download diff file Expand all files Collapse all files

275
code/globalcpp/scripttimer.cpp
View file

@ -1,275 +0,0 @@
/*
===========================================================================
Copyright (C) 2015 the OpenMoHAA team
This file is part of OpenMoHAA source code.
OpenMoHAA source code is free software; you can redistribute it
and/or modify it under the terms of the GNU General Public License as
published by the Free Software Foundation; either version 2 of the License,
or (at your option) any later version.
OpenMoHAA source code is distributed in the hope that it will be
useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with OpenMoHAA source code; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
===========================================================================
*/
// scripttimer.cpp: Scripted Timer & Fader
//
#include "glb_local.h"
#include "scripttimer.h"
#include "level.h"
#include "archive.h"
Event EV_ScriptTimer_Think
(
"scripttimer_think",
EV_CODEONLY,
NULL,
NULL,
"Internal event",
EV_NORMAL
);
Container< ScriptTimer * > m_scriptTimers;
/*void ScriptTimer::HandleTimer( float frametime )
{
ScriptTimer *timer;
for( int i = 0; i < m_scriptTimers.NumObjects(); i++ )
{
timer = m_scriptTimers[ i ];
if( timer->isEnabled() && timer->GetTime() > 0.0f ) {
timer->Think( frametime );
}
}
}*/
ScriptTimer::ScriptTimer( timertype_e type )
{
Reset();
bEnabled = false;
setType( type );
m_scriptTimers.AddObject( this );
}
ScriptTimer::~ScriptTimer()
{
Disable();
if( m_scriptTimers.IndexOfObject( this ) )
{
m_scriptTimers.RemoveObject( this );
}
}
void ScriptTimer::Archive( Archiver &arc )
{
Listener::Archive( arc );
#ifdef CGAME_DLL
arc.ArchiveFloat( &targetTime );
arc.ArchiveFloat( &currentTime );
arc.ArchiveFloat( &realTime );
arc.ArchiveFloat( &glideRatio );
arc.ArchiveInteger( ( int * )&timerType );
arc.ArchiveBool( &bEnabled );
if( arc.Loading() && bEnabled ) {
Enable();
}
#endif
}
void ScriptTimer::GlideRefresh()
{
if( timerType != TIMER_GLIDE ) {
return;
}
if( targetTime <= 0.0f ){
return;
}
float r = realTime / ( targetTime * 0.5f );
if( r > 1.0f )
{
glideRatio = 2.0f - 2.0f * ( r - 1.0f );
if( glideRatio < 0.0f ) {
glideRatio = 0.0f;
}
}
else
{
glideRatio = 2.0f * r;
if( glideRatio > 2.0f ) {
glideRatio = 2.0f;
}
}
}
void ScriptTimer::Think( Event *ev )
{
if( !bEnabled ) {
return;
}
#ifdef CGAME_DLL
float frametime = ( float )cg->frametime;
#else
float frametime = level.frametime;
#endif
GlideRefresh();
if( currentTime < targetTime )
{
realTime += frametime;
if( timerType == TIMER_GLIDE ) {
currentTime += frametime * glideRatio;
} else {
currentTime += frametime;
}
}
else
{
currentTime = targetTime;
realTime = targetTime;
bEnabled = false;
CancelEventsOfType( &EV_ScriptTimer_Think );
return;
}
CancelEventsOfType( &EV_ScriptTimer_Think );
PostEvent( EV_ScriptTimer_Think, level.frametime );
}
void ScriptTimer::Disable()
{
bEnabled = false;
CancelEventsOfType( &EV_ScriptTimer_Think );
}
void ScriptTimer::Enable()
{
bEnabled = true;
CancelEventsOfType( &EV_ScriptTimer_Think );
Event *ev = new Event( &EV_ScriptTimer_Think );
ProcessEvent( ev );
}
qboolean ScriptTimer::Done()
{
return ( currentTime >= targetTime );
}
float ScriptTimer::GetCurrentTime()
{
return realTime;
}
float ScriptTimer::GetRatio()
{
float ratio;
if( targetTime <= 0.0f ) {
return 1.0f;
}
ratio = ( currentTime / targetTime );
// ratio must not go below 0.0 and above 1.0
return ( ratio < 0.0f ? 0.0f : ratio > 1.0f ? 1.0f : ratio );
}
float ScriptTimer::GetTime()
{
return targetTime;
}
float ScriptTimer::LerpValue( float start, float end )
{
return start + ( end - start ) * GetRatio();
}
Vector ScriptTimer::LerpValue( Vector start, Vector end )
{
return start + ( end - start ) * GetRatio();
}
void ScriptTimer::Reset()
{
currentTime = 0.f;
realTime = 0.f;
glideRatio = 0.f;
}
void ScriptTimer::SetCurrentTime( float time )
{
realTime = time * 1000.0f;
if( timerType == TIMER_GLIDE )
{
GlideRefresh();
currentTime = time * 1000.0f * glideRatio;
}
else
{
currentTime = time * 1000.0f;
}
}
void ScriptTimer::SetPhase( float phase )
{
float t = targetTime * ( phase / 2.0f ) / 1000.0f;
SetCurrentTime( t );
}
void ScriptTimer::SetTime( float time )
{
Reset();
targetTime = time * 1000.0f;
}
bool ScriptTimer::isEnabled()
{
return bEnabled;
}
void ScriptTimer::setType( timertype_e type )
{
timerType = type;
}
CLASS_DECLARATION( Listener, ScriptTimer, NULL )
{
{ &EV_ScriptTimer_Think, &ScriptTimer::Think },
{ NULL, NULL }
};