Перепиши этот код:
script_name("g-meter")
script_author("plasma")
script_version("2.0")
local mad = require 'MoonAdditions'
local m = require "memory"


--variaveis--
local gColor = 0x00000000 -- cor do centro do g-meter (alpha, red, green, blue)
local gBorderColor = 0xCCFF5544  -- cor da borda do g-meter
local gPointColor = 0xFF1100CC -- cor do ponto medidor do g-meter
local gPointBorderColor = 0xFFFFFFFF -- cor da borda do ponto
local gBorderSize = 4 -- tamanho da borda
local gx = 20  -- posição horizontal do g-meter
local gy = 320 -- posição vertical do g-meter
local gSizeX = 150 -- tamanho horizontal do g-meter
local gSizeY = 130 -- tamanho vertical do g-meter
local maxLongG = 3.0 -- maximo Gs longitudinal (frente/traseira)
local maxLatG = 6.0 -- maximo Gs lateral (direita/esquerda)


local sp1 = 0
local sp2 = 0
local acel = 0
local acelL = 0
local t1 = 0
local t2 = 0
local deltaTimeime = 0
local car = 0
local angZ = 0
local angZ2 = 0
local radian = 0


local function getTimeScale()
	gameSpeed = m.getfloat(0xB7CB64, false)
	return gameSpeed
end


function updateDeltaTime()
	while true do
		local time1 = gameClock()
		wait(0)
		deltaTime = gameClock() - time1
	end
end


local function testSpeedDiff()
	if sp1 ~= sp2 then
		sp1 = sp2
	end
end


local function acelLong()
	sp2 = getCharSpeed(PLAYER_PED) -- velocidade atual do player
	acel = (sp2 - sp1)/deltaTime
	acel = acel/getTimeScale()
end


local function getZAngle(car)
	return getCarHeading(car)
end


local function acelLat()
	angZ = getZAngle(car)
	radian = ((angZ-angZ2) / (deltaTime)) * 0.01745 -- transforma a variação de deg/s em rad/s
	acelL = (radian * sp2) --  ao multiplicar rad/s por m/s temos m/s^2 = aceleração lateral
	acelL = acelL/getTimeScale()
end
	
	
local function testAngleDiff()
	if angZ2 ~= angZ then
		angZ2 = angZ
	end
end


function draw_text(str, x, y, r, g, b)
	mad.draw_text(str, x, y, mad.font_style.MENU, 0.3, 0.6, mad.font_align.LEFT, 2000, true, false, r, g, b, 255, 1, 0, 30, 30, 30, 120)
end


local function drawGraphics()
	local x, y = 0, 0
	local maxX, maxY = gx+gSizeX, gy+gSizeY
	local halfX, halfY = gSizeX/2, gSizeY/2
	
	local pointCenterX = gx+halfX+gBorderSize/2
	local pointCenterY = gy+halfY-gBorderSize
	
	x = pointCenterX + (acelL/9.8) * ((maxX - pointCenterX) / maxLatG)
	y = pointCenterY + (acel/9.8) * ((maxY - pointCenterY) / maxLongG)
	
	renderDrawBoxWithBorder(gx, gy, gSizeX, gSizeY, gColor, gBorderSize, gBorderColor)
	renderDrawLine(gx+1, gy+halfY-gBorderSize, gx+gSizeX, gy+halfY-gBorderSize, gBorderSize/2, gBorderColor) -- horizontal line
	renderDrawLine(gx+halfX+gBorderSize, gy+1, gx+halfX+gBorderSize, gy+gSizeY, gBorderSize/2, gBorderColor)
	
	x = x >= gx+gBorderSize and x or gx+gBorderSize
	x = x <= maxX-gBorderSize and x or maxX-gBorderSize
	y = y >= gy+gBorderSize and y or gy+gBorderSize
	y = y <= maxY-gBorderSize and y or maxY-gBorderSize
	
	renderDrawPolygon(x, y, 7, 7, 16, 0.0, gPointBorderColor) -- border
	renderDrawPolygon(x, y, 5, 5, 16, 0.0, gPointColor)
	
	draw_text("Lat: " .. string.format("%.2f", acelL/9.8) .. " g", gx+halfX/2, gy+gSizeY+gBorderSize, 255, 255, 255)
	draw_text("Long: " .. string.format("%.2f", acel/9.8) .. " g", gx+gSizeX+gBorderSize*2, gy+halfY, 255, 255, 255)
end


function main()
	local threadTime = lua_thread.create(updateDeltaTime)
	while true do
		wait(0)
		if isPlayerPlaying(PLAYER_HANDLE) then
			if not isCharOnFoot(PLAYER_PED) then --calculos secudarios sao feitos apenas quando dentro de um veiculo
				car = getCarCharIsUsing(PLAYER_PED)
				testSpeedDiff()	
				testAngleDiff()
				acelLong()
				acelLat()
				drawGraphics()
			end
			
		end
	end
	return
end


под рендер в таком стиле:

angular.module('beamng.apps')
.directive('gforcesDebug', [function () {
  return {
    template: '<canvas width="300" height="300"></canvas>',
    replace: true,
    restrict: 'EA',
    link: function (scope, element, attrs) {
      var streamsList = ['sensors']
      StreamsManager.add(streamsList)

      scope.$on('$destroy', function () {
        StreamsManager.remove(streamsList)
      })

      var c = element[0]
        , ctx = c.getContext('2d')
        , history = []
        , historySize = 50
        , maxG = 2
        , circleSize = 100 / maxG
        , gxMin = 0.0
        , gxMax = 0.0
        , gyMin = 0.0
        , gyMax = 0.0
        , gxLargest = 0.0
        , gyLargest = 0.0
        , frameCounter = 0


      ctx.setTransform(c.width/200, 0, 0, c.height/200, c.width/2,c.height/2)

      scope.$on('streamsUpdate', function (event, streams) {
        if (!streams.sensors) { return }

        var gForces = {}

        var gravity = streams.sensors.gravity
        gravity = gravity >= 0 ? Math.max(0.1, gravity) : Math.min(-0.1, gravity)

        for (var key in streams.sensors) {
          gForces[key] = streams.sensors[key] / -gravity
        }
        frameCounter++
        if (frameCounter == 200) {
          frameCounter = 0
          gxMin = 0.0
          gxMax = 0.0
          gyMin = 0.0
          gyMax = 0.0
        }

        gxMax = Math.max(gxMax, gForces.gx2)
        gxMin = Math.min(gxMin, gForces.gx2)
        gyMax = Math.max(gyMax, gForces.gy2)
        gyMin = Math.min(gyMin, gForces.gy2)
        gxLargest = -gxMin > gxMax ? gxMin : gxMax
        gyLargest = -gyMin > gyMax ? gyMin : gyMax

        var px = gForces.gx2 *  circleSize
        var py = gForces.gy2 * -circleSize

        ctx.clearRect(-100,-100,200,200)
        // ctx.clearRect(0, 0, 300, 300)

        // draw background circles
        let circleBorder = 1.5
        ctx.strokeStyle = "RGBA(0,0,0, 0.0)"
        ctx.fillStyle = "RGBA(0,0,0, 0.35)"
        ctx.lineWidth = circleBorder
        ctx.beginPath()
        ctx.arc(0,0,circleSize*maxG,0,2*Math.PI,false)
        ctx.fill()
        ctx.stroke()
        for (var i = 1; i <= maxG; i++) {
            ctx.strokeStyle = "RGBA(63,63,63, 0.5)"
            ctx.fillStyle = "RGBA(63,63,63, 0.0)"
            ctx.lineWidth = circleBorder
            ctx.beginPath()
            ctx.arc(0,0,circleSize*i-0.5*circleBorder,0,2*Math.PI,false)
            ctx.fill()
            ctx.stroke()
        }

        // draw background markers
        ctx.strokeStyle = "RGBA(63,63,63, 0.5)"
        ctx.lineWidth = 1
        ctx.beginPath()
        ctx.moveTo(-maxG*circleSize, 0)
        ctx.lineTo(+maxG*circleSize, 0)
        ctx.stroke()
        ctx.beginPath()
        ctx.moveTo(0,-maxG*circleSize)
        ctx.lineTo(0,+maxG*circleSize)
        ctx.stroke()

        // draw min/max G ends
        ctx.strokeStyle = "rgba(255, 165, 63, 1.0)"
        ctx.lineWidth = 2
        let size = 6
        ctx.beginPath()
        ctx.moveTo(gxLargest * circleSize, -size)
        ctx.lineTo(gxLargest * circleSize, +size)
        ctx.stroke()
        ctx.beginPath()
        ctx.moveTo(-size, gyLargest * -circleSize)
        ctx.lineTo(+size, gyLargest * -circleSize)
        ctx.stroke()

        // draw min/max G lines
        ctx.strokeStyle = "rgba(255, 165, 63, 1.0)"
        ctx.lineWidth = 2
        ctx.lineCap = ""
        ctx.beginPath()
        ctx.moveTo(Math.sign(gxLargest)*0.5*ctx.lineWidth, 0) // don't draw from dead center, it'll show a few ugly missing pixels
        ctx.lineTo(gxLargest * circleSize, 0)
        ctx.stroke()
        ctx.beginPath()
        ctx.moveTo(0,Math.sign(gyLargest)*0.5*ctx.lineWidth) // don't draw from dead center, it'll show a few ugly missing pixels
        ctx.lineTo(0,gyLargest * -circleSize)
        ctx.stroke()

        // previous values (historic trail)
        if(history.length > 0) {
            ctx.lineWidth = 3
            for(var i = 1; i < history.length; i++) {
                ctx.beginPath()
                ctx.moveTo(history[i-1][0], history[i-1][1])
                let p = i/history.length
                //ctx.lineWidth = 1 + (2*i/p)
                ctx.strokeStyle = "RGBA(255,255,255," + p + ")"
                ctx.lineTo(history[i][0], history[i][1])
                ctx.stroke()
            }
            if(history.length > historySize) {
                history.splice(0, 1)
            }
            var sx = Math.abs(history[history.length - 1][0] - px)
            var sy = Math.abs(history[history.length - 1][1] - py)
            if(sx > 2 || sy > 2) {
                history.push([px, py])
            }
        } else {
            history.push([px, py])
        }

        // draw 1g,2g labels
        ctx.fillStyle = "RGBA(255,255,255,1)"
        ctx.font = '12px "Lucida Console", Monaco, monospace'
        ctx.textAlign = "left"
        ctx.textBaseline = "bottom"
        for (var i = 1; i <= maxG; i++) {
            ctx.fillText(i+"g",-circleSize*i/1.41421, circleSize*i/1.41421)
        }

        // line to instant value
        ctx.strokeStyle = "RGBA(255,255,255,0.5)"
        ctx.lineWidth = 3
        ctx.beginPath()
        ctx.moveTo(gForces.gx*circleSize, gForces.gy*-circleSize)
        ctx.lineTo(px, py)
        ctx.stroke()

        // instant value
        ctx.fillStyle = "rgba(0, 0, 0, 0.8)"
        ctx.beginPath()
        ctx.arc(gForces.gx*circleSize, gForces.gy*-circleSize, 5, 0, 2*Math.PI, false)
        ctx.fill()
        ctx.fillStyle = "rgba(255, 102, 0, 0.8)"
        ctx.beginPath()
        ctx.arc(gForces.gx*circleSize, gForces.gy*-circleSize, 4, 0, 2*Math.PI, false)
        ctx.fill()

        // averaged value
        ctx.fillStyle = "rgba(0, 0, 0, 1.0)"
        ctx.beginPath()
        ctx.arc(px, py, 7, 0, 2*Math.PI, false)
        ctx.fill()
        ctx.fillStyle = "rgba(255, 102, 0, 1.0)"
        ctx.beginPath()
        ctx.arc(px, py, 5, 0, 2*Math.PI, false)
        ctx.fill()

        // averaged and max value labels, for x and y axis
        ctx.fillStyle = "RGBA(255,255,255,1)"
        ctx.font = 'bolder 14px "Lucida Console", Monaco, monospace'
        ctx.textAlign = "right"
        ctx.textBaseline = "top"
        ctx.fillText(Math.abs(gForces.gx2).toFixed(2), 100-2, 0)
        ctx.fillStyle = "rgba(255, 165, 63, 1.0)"
        ctx.fillText(Math.abs(gxLargest).toFixed(2), 100-2, 13)

        ctx.font = 'bolder 14px "Lucida Console", Monaco, monospace'
        ctx.fillStyle = "RGBA(255,255,255,1)"
        ctx.textAlign = "center"
        ctx.textBaseline = "top"
        ctx.fillText(Math.abs(gForces.gy2).toFixed(2),  0, -(100-2))
        ctx.fillStyle = "rgba(255, 165, 63, 1.0)"
        ctx.fillText(Math.abs(gyLargest).toFixed(2), 0, -(100-2-13))
      })

      scope.$on('app:resized', function (event, data) {
        c.width = data.width
        c.height = data.height
        ctx.setTransform(c.width/200, 0, 0, c.height/200, c.width/2,c.height/2)
      })
    }
  }
}]);