Sorry your browser is not supported!

Function TBM_Update()
    deltaTime# = ABS(Timer() - oldTime) / 16.666 
    If ABS(Timer() - oldTime) > 1000 Then deltaTime# = 0.0
    oldTime = Timer()
EndFunction

speed#=25
   `Start timer
      global FrameTime#=0.0
      global StartTime=timer()
      global Timer#
      do
   `Update timer
      FrameTime#=(FrameTime#*0.5)+((timer()-StartTime)*0.5)
      StartTime=timer()
      Timer#=FrameTime#*0.06
      if Timer#<0.05 then Timer#=0.05
      if Timer#>10 then Timer#=10

move_camera( speed#/Timer# )

sync 
loop

#CONSTANT FOOT_MAX_SPEED 55.0
#CONSTANT FOOT_ACCELERATION (SYSTEM.timing.loopsPerSec * 0.266)

type charBaseData
    x            as float
    y            as float
    z            as float
    oldx         as float
    oldy         as float
    oldz         as float
    facing       as float
    oldfacing    as float
    heading      as float
    speed        as float
    timestamp    as integer
    elapsed      as float
    obj          as integer
endtype

type charData
    baseData     as charBaseData
endtype
dim Chars() as charData
    
function framework_update_characters()

    system_log(2, "main", "Begin Update: characters()")
    updateMark as double integer
    updateMark = hitimer()    

    for c = 0 to array count(Chars())
            
        system_log(2, "chars", "Begin character update for character " + str$(c))
    
        `store old data
        Chars(c).baseData.oldfacing = object angle y(Chars(c).baseData.obj)
        Chars(c).baseData.oldx = Chars(c).baseData.x
        Chars(c).baseData.oldy = Chars(c).baseData.y
        Chars(c).baseData.oldz = Chars(c).baseData.z

        `get elapsed time in seconds
        Chars(c).baseData.elapsed = (timer()-Chars(c).baseData.timestamp)/1000.0
        dec Chars(c).baseData.elapsed, (SYSTEM.timing.pauseElapsed/1000.0)
        
        `get current speed
        Chars(c).baseData.speed = curvevalue(FOOT_MAX_SPEED, Chars(c).baseData.speed, FOOT_ACCELERATION)

        `new position
        Chars(c).baseData.x = Chars(c).baseData.x + sin(Chars(c).baseData.heading) * Chars(c).baseData.speed * Chars(c).baseData.elapsed
        Chars(c).baseData.z = Chars(c).baseData.z + cos(Chars(c).baseData.heading) * Chars(c).baseData.speed * Chars(c).baseData.elapsed        
        
        `update the object
        yrotate object Chars(c).baseData.obj,curveangle(Chars(c).baseData.facing,Chars(c).baseData.oldfacing,FOOT_TURN_SPEED)
        position object Chars(c).baseData.obj, Chars(c).baseData.x, Chars(c).baseData.y, Chars(c).baseData.z        
    
        `time stamp update finished
        Chars(c).baseData.timestamp = timer()
        
    next c
    
    system_log(2, "main", "End Update: characters()," + str$(hitimer() - updateMark))
    
endfunction    

//////////////////////////////////////////////////////////////
//  Game Engine Standard Modules - TBM MODULE
//  Concept and code by thenerd, Summer 2012!
//////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////
//  DOCUMENTATION
//////////////////////////////////////////////////////////////
// Set of standard timer-based code for game engines. 
// Calculates a variable, "TBM", with a multiplier. 
// USAGE:
// -Call TBMInit in your initialization code
// -Call TBMUpdate at the start of your loop
// -Multiply all timer-based operations by "TBM".
//
//////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////
//  FUNCTIONS
//////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////
//  Function: TBM_Init()
//  Author: thenerd, bmaczero, kaedroho
//  Description: Sets up variables for the TBM system.
//  Input variables: *none*
//  Output variables: *none*
//////////////////////////////////////////////////////////////
function TBM_Init():
    Global TBM As Float
    Global TBM_timer      As Float : TBM_timer      = Hitimer()
    Global TBM_timer_last As Float : TBM_timer_last = TBM_timer
    Global TBM_timer_scale As Float : TBM_timer_scale = 1.0
endfunction

//////////////////////////////////////////////////////////////
//  Function: TBM_Update()
//  Author: thenerd, bmaczero, kaedroho
//  Description: Recalculates the TBM variable. Call each loop!
//  Input variables: *none*
//  Output variables: *none*
//////////////////////////////////////////////////////////////
function TBM_Update():
    TBM_timer     = hitimer()
    Diff#          = TBM_timer - TBM_timer_last
    TBM_timer_last= TBM_timer
    TBM        = Diff# / 10.0
    TBM = TBM * TBM_timer_scale
    if TBM>10 then TBM=10
endfunction

//////////////////////////////////////////////////////////////
//  Function: TBM_SetTimerScale()
//  Author: thenerd
//  Description: Sets the scale for the timer. Useful for slow-mo!
//  Input variables: scale
//  Output variables: *none*
//////////////////////////////////////////////////////////////
function TBM_SetTimerScale(scale as float):
    TBM_timer_scale = scale
endfunction

//////////////////////////////////////////////////////////////
//  Function: TBM_CurveValue()
//  Author: Joseph Thomson, 23/7/04
//  Description: Timer-based version of Curvevalue.
//  Input variables: destination value, current value, speed.
//  Output variables: interpolated value
//////////////////////////////////////////////////////////////
function TBM_CurveValue(dest as float, current as float, speed as float):
    local diff as float : local value as float
    diff = dest - current
    value = current + (diff * ((speed^TBM-(speed-1)^TBM)/(speed^TBM)))
endfunction value

//////////////////////////////////////////////////////////////
//  Function: TBM_CurveAngle()
//  Author: Joseph Thomson, 23/7/04
//  Description: Timer-based version of Curveangle.
//  Input variables: destination angle, current angle, speed.
//  Output variables: interpolated angle
//////////////////////////////////////////////////////////////
function TBM_CurveAngle(dest as float, current as float, speed as float):
    local diff as float : local value as float : local tempCurrent as float
    tempCurrent = wrapvalue(current - dest)
    if tempCurrent <= 180.0
        diff = -tempCurrent
    else
        diff = 360-tempCurrent
    endif
    value = wrapvalue(current + (diff * ((speed^TBM-(speed-1)^TBM)/(speed^TBM))))
endfunction value

//////////////////////////////////////////////////////////////
//  Function: TBMTerminate()
//  Author: thenerd, bmaczero, kaedroho
//  Description: Terminates the TBM module. Does nothing!
//  Input variables: *none*
//  Output variables: *none*
//////////////////////////////////////////////////////////////
function TBM_Terminate():
    //Terminate code
    //This module doesn't need anything terminated!
Endfunction

//////////////////////////////////////////////////////////////
//End of file
//////////////////////////////////////////////////////////////