620 lines
21 KiB
Lua
620 lines
21 KiB
Lua
--[[
|
|
S2 song attribute radar component
|
|
Original code thanks to RealFD, he's a real homie
|
|
]]
|
|
|
|
require("common.globals")
|
|
require("api.point2d")
|
|
require("api.color")
|
|
|
|
local Dim = require("common.dimensions")
|
|
local Util = require("common.util")
|
|
|
|
Dim.updateResolution()
|
|
|
|
local RADAR_PURPLE = ColorRGBA.new(238, 130, 238)
|
|
local RADAR_MAGENTA = ColorRGBA.new(191, 70, 235)
|
|
local RADAR_GREEN = ColorRGBA.new(0, 255, 100)
|
|
|
|
local maxScaleFactor = 1.8
|
|
|
|
---@param p1 Point2D
|
|
---@param p2 Point2D
|
|
---@param width number
|
|
---@param color ColorRGBA
|
|
local function drawLine(p1, p2, width, color)
|
|
gfx.BeginPath()
|
|
gfx.MoveTo(p1:coords())
|
|
gfx.LineTo(p2:coords())
|
|
gfx.StrokeColor(color:components())
|
|
gfx.StrokeWidth(width)
|
|
gfx.Stroke()
|
|
end
|
|
|
|
---@param pos Point2D
|
|
---@param text string
|
|
---@param outlineWidth number
|
|
---@param color ColorRGBA
|
|
local function renderOutlinedText(pos, text, outlineWidth, color)
|
|
local x, y = pos:coords()
|
|
|
|
local dimColor = color:mix(ColorRGBA.BLACK, 0.8)
|
|
gfx.FillColor(dimColor:components());
|
|
gfx.Text(text, x - outlineWidth, y + outlineWidth);
|
|
gfx.Text(text, x - outlineWidth, y - outlineWidth);
|
|
gfx.Text(text, x + outlineWidth, y + outlineWidth);
|
|
gfx.Text(text, x + outlineWidth, y - outlineWidth);
|
|
|
|
gfx.FillColor(color:components());
|
|
gfx.Text(text, x, y);
|
|
end
|
|
|
|
---@param pos Point2D
|
|
---@param graphdata table
|
|
local function drawDebugText(pos, graphdata)
|
|
local color = ColorRGBA.WHITE
|
|
gfx.Save()
|
|
gfx.TextAlign(gfx.TEXT_ALIGN_LEFT + gfx.TEXT_ALIGN_CENTER)
|
|
--renderOutlinedText(x, 20, '"' .. txtFilePath .. '"', 1, 255, 255, 255)
|
|
renderOutlinedText(pos, "NOTES = " .. graphdata.notes, 1, color)
|
|
renderOutlinedText(pos, "PEAK = " .. graphdata.peak, 1, color)
|
|
renderOutlinedText(pos, "TSUMAMI = " .. graphdata.tsumami, 1, color)
|
|
renderOutlinedText(pos, "TRICKY = " .. graphdata.tricky, 1, color)
|
|
renderOutlinedText(pos, "ONE-HAND = " .. graphdata.onehand, 1, color)
|
|
renderOutlinedText(pos, "HAND-TRIP = " .. graphdata.handtrip, 1, color)
|
|
--renderOutlinedText(pos, "NOTES (Relative) = " .. graphdata.notes_relative, 1, color)
|
|
--renderOutlinedText(pos, "TOTAL-MESURES = " .. graphdata.measures, 1, color)
|
|
gfx.Restore()
|
|
end
|
|
|
|
---@class CRadarAttributes
|
|
RadarAttributes = {
|
|
---Create RadarAttributes instance
|
|
---@param text? string # default ""
|
|
---@param offset? Point2D # default (0, 0)
|
|
---@param color? ColorRGBA # default BLACK
|
|
---@param align? integer # gfx.TEXT_ALIGN_<...> values, default gfx.TEXT_ALIGN_CENTER + gfx.TEXT_ALIGN_BASELINE
|
|
---@return RadarAttributes
|
|
new = function (text, offset, color, align)
|
|
---@class RadarAttributes
|
|
---@field text string
|
|
---@field offset Point2D
|
|
---@field color ColorRGBA
|
|
local o = {
|
|
text = text or "",
|
|
offset = offset or Point2D.ZERO,
|
|
color = color or ColorRGBA.BLACK,
|
|
align = align or gfx.TEXT_ALIGN_CENTER + gfx.TEXT_ALIGN_BASELINE
|
|
}
|
|
|
|
setmetatable(o, RadarAttributes)
|
|
return o
|
|
end
|
|
}
|
|
RadarAttributes.__index = RadarAttributes
|
|
|
|
|
|
---@class CRadar
|
|
Radar = {
|
|
---@type RadarAttributes[][]
|
|
ATTRIBUTES = {
|
|
{RadarAttributes.new("notes", Point2D.new(0, 0), ColorRGBA.CYAN, gfx.TEXT_ALIGN_CENTER + gfx.TEXT_ALIGN_BOTTOM),},
|
|
{RadarAttributes.new("peak", Point2D.new(0, 0), ColorRGBA.RED, gfx.TEXT_ALIGN_CENTER + gfx.TEXT_ALIGN_BOTTOM), },
|
|
{RadarAttributes.new("tsumami", Point2D.new(0, 0), RADAR_PURPLE, gfx.TEXT_ALIGN_CENTER + gfx.TEXT_ALIGN_TOP),},
|
|
{RadarAttributes.new("tricky", Point2D.new(0, 0), ColorRGBA.YELLOW, gfx.TEXT_ALIGN_CENTER + gfx.TEXT_ALIGN_TOP),},
|
|
{
|
|
RadarAttributes.new("hand", Point2D.new(0, 0), RADAR_MAGENTA, gfx.TEXT_ALIGN_CENTER + gfx.TEXT_ALIGN_TOP),
|
|
RadarAttributes.new("trip", Point2D.new(5, 16), RADAR_MAGENTA, gfx.TEXT_ALIGN_CENTER + gfx.TEXT_ALIGN_TOP),
|
|
},
|
|
{
|
|
RadarAttributes.new("one", Point2D.new(6, -16), RADAR_GREEN, gfx.TEXT_ALIGN_CENTER + gfx.TEXT_ALIGN_BOTTOM),
|
|
RadarAttributes.new("hand", Point2D.new(0, 0), RADAR_GREEN, gfx.TEXT_ALIGN_CENTER + gfx.TEXT_ALIGN_BOTTOM),
|
|
}
|
|
},
|
|
RADIUS = 100.0,
|
|
|
|
---Create Radar instance
|
|
---@param pos Point2D
|
|
---@param radius? number
|
|
---@return Radar
|
|
new = function (pos, radius)
|
|
---@class Radar : CRadar
|
|
local o = {
|
|
_graphdata = {
|
|
notes = 0,
|
|
peak = 0,
|
|
tsumami = 0,
|
|
tricky = 0,
|
|
handtrip = 0,
|
|
onehand = 0,
|
|
},
|
|
_hexagonMesh = gfx.CreateShadedMesh("radar"),
|
|
_outlineVertices = {},
|
|
_attributePositions = {}, ---@type Point2D[][]
|
|
_angleStep = (2 * math.pi) / #Radar.ATTRIBUTES, -- 360° / no. attributes, in radians
|
|
_initRotation = math.pi / 2, -- 90°, in radians
|
|
pos = pos or Point2D.ZERO,
|
|
scale = radius and radius / Radar.RADIUS or 1.0,
|
|
}
|
|
|
|
local sides = #Radar.ATTRIBUTES
|
|
|
|
local outlineRadius = Radar.RADIUS
|
|
local attributeRadius = Radar.RADIUS + 30
|
|
|
|
for i = 0, sides - 1 do
|
|
local attrIdx = i + 1
|
|
local angle = i * o._angleStep - o._initRotation
|
|
local cosAngle = math.cos(angle)
|
|
local sinAngle = math.sin(angle)
|
|
-- cache outline vertices
|
|
table.insert(o._outlineVertices, Point2D.new(outlineRadius * cosAngle, outlineRadius * sinAngle))
|
|
-- cache attribute positions
|
|
table.insert(o._attributePositions, {})
|
|
for j = 1, #Radar.ATTRIBUTES[attrIdx] do
|
|
local attr = Radar.ATTRIBUTES[attrIdx][j]
|
|
local attributePos = Point2D.new(attributeRadius * cosAngle, attributeRadius * sinAngle)
|
|
attributePos.x = attributePos.x + attr.offset.x
|
|
attributePos.y = attributePos.y + attr.offset.y
|
|
table.insert(o._attributePositions[attrIdx], j, attributePos)
|
|
end
|
|
end
|
|
|
|
setmetatable(o, Radar)
|
|
return o
|
|
end,
|
|
}
|
|
Radar.__index = Radar
|
|
|
|
---@param w number
|
|
---@param color ColorRGBA
|
|
function Radar:drawOutline(w, color)
|
|
---@cast self Radar
|
|
|
|
for i = 1, #self._outlineVertices do
|
|
local j = i % #self._outlineVertices + 1
|
|
drawLine(self._outlineVertices[i], self._outlineVertices[j], w, color)
|
|
end
|
|
end
|
|
|
|
---@param color ColorRGBA
|
|
---@param ticks? integer
|
|
function Radar:drawRadialTicks(color, ticks)
|
|
---@cast self Radar
|
|
|
|
ticks = ticks or 3
|
|
|
|
gfx.Save()
|
|
gfx.StrokeColor(color:components())
|
|
|
|
for i, vertex in ipairs(self._outlineVertices) do
|
|
gfx.BeginPath()
|
|
gfx.MoveTo(0, 0)
|
|
gfx.LineTo(vertex.x, vertex.y)
|
|
gfx.Stroke()
|
|
|
|
local lineLength = math.sqrt(vertex.x * vertex.x + vertex.y * vertex.y)
|
|
local tinyLineLength = 10
|
|
|
|
local tinyLineAngle = math.atan(vertex.y / vertex.x)
|
|
if vertex.x < 0 then
|
|
tinyLineAngle = tinyLineAngle + math.pi
|
|
end
|
|
|
|
local halfTinyLineLength = tinyLineLength / 2
|
|
|
|
for j = 1, ticks do
|
|
local distanceFromCenter = j * lineLength / (ticks + 1) -- Adjusted for 3 middle lines
|
|
|
|
local offsetX = distanceFromCenter * (vertex.x / lineLength)
|
|
local offsetY = distanceFromCenter * (vertex.y / lineLength)
|
|
|
|
local endX = halfTinyLineLength * math.cos(tinyLineAngle - math.pi / 2) -- Rotate by -90 degrees
|
|
local endY = halfTinyLineLength * math.sin(tinyLineAngle - math.pi / 2) -- Rotate by -90 degrees
|
|
|
|
local offsetX2 = halfTinyLineLength * math.cos(tinyLineAngle + math.pi / 2)
|
|
local offsetY2 = halfTinyLineLength * math.sin(tinyLineAngle + math.pi / 2)
|
|
|
|
gfx.BeginPath()
|
|
gfx.MoveTo(offsetX - offsetX2, offsetY - offsetY2)
|
|
gfx.LineTo(endX + offsetX + offsetX2 + offsetX2, endY + offsetY + offsetY2 + offsetY2)
|
|
gfx.Stroke()
|
|
end
|
|
end
|
|
|
|
gfx.Restore()
|
|
end
|
|
|
|
---@param fillColor ColorRGBA
|
|
function Radar:drawBackground(fillColor)
|
|
---@cast self Radar
|
|
|
|
gfx.Save()
|
|
|
|
gfx.BeginPath()
|
|
gfx.MoveTo(self._outlineVertices[1].x, self._outlineVertices[1].y)
|
|
for i = 2, #self._outlineVertices do
|
|
gfx.LineTo(self._outlineVertices[i].x, self._outlineVertices[i].y)
|
|
end
|
|
gfx.ClosePath()
|
|
|
|
gfx.FillColor(fillColor:components())
|
|
gfx.Fill()
|
|
|
|
gfx.Restore()
|
|
end
|
|
|
|
function Radar:drawAttributes()
|
|
---@cast self Radar
|
|
|
|
gfx.Save()
|
|
|
|
gfx.LoadSkinFont("contb.ttf")
|
|
gfx.FontSize(21)
|
|
for i = 1, #self._attributePositions do
|
|
local attrPos = self._attributePositions[i]
|
|
for j = 1, #attrPos do
|
|
local pos = attrPos[j]
|
|
local attr = Radar.ATTRIBUTES[i][j]
|
|
gfx.TextAlign(attr.align)
|
|
renderOutlinedText(pos, string.upper(attr.text), 1, attr.color)
|
|
end
|
|
end
|
|
|
|
gfx.Restore()
|
|
end
|
|
|
|
---Draw shaded radar mesh
|
|
---
|
|
---Bug: ForceRender resets every transformation, you need to re-setup view transform afterwards.
|
|
---ForceRender also resets the gfx stack, USC will crash if you try to call gfx.Restore(),
|
|
---make sure the gfx stack is clean before calling radar:drawRadarMesh()
|
|
function Radar:drawRadarMesh()
|
|
---@cast self Radar
|
|
|
|
local scaleFact = {
|
|
self._graphdata.notes,
|
|
self._graphdata.peak,
|
|
self._graphdata.tsumami,
|
|
self._graphdata.tricky,
|
|
self._graphdata.handtrip,
|
|
self._graphdata.onehand,
|
|
}
|
|
|
|
local colorMax = ColorRGBA.new(255, 12, 48, 230) -- magenta-ish
|
|
local colorCenter = ColorRGBA.new(112, 119, 255, 230) -- light blue-ish purple
|
|
|
|
-- Calculate the maximum size based on the constraint
|
|
local maxSize = self.RADIUS * self.scale
|
|
local maxLineLength = maxSize * maxScaleFactor
|
|
self._hexagonMesh:SetParam("maxSize", maxLineLength + .0)
|
|
|
|
-- Set the color of the hexagon
|
|
self._hexagonMesh:SetParamVec4("colorMax", colorMax:componentsFloat())
|
|
self._hexagonMesh:SetParamVec4("colorCenter", colorCenter:componentsFloat())
|
|
|
|
-- Set the primitive type to triangles
|
|
self._hexagonMesh:SetPrimitiveType(self._hexagonMesh.PRIM_TRIFAN)
|
|
|
|
-- Calculate the vertices of the hexagon
|
|
local sides = #Radar.ATTRIBUTES
|
|
|
|
local vertices = {}
|
|
table.insert(vertices, {{0, 0}, {0, 0}})
|
|
for i = 0, sides do
|
|
local j = i % sides + 1
|
|
local angle = i * self._angleStep - self._initRotation
|
|
|
|
--local angle = math.rad(60 * (i-1)) + rotationAngle
|
|
local scale = scaleFact[j]
|
|
local lineLength = maxSize * scale
|
|
local px = lineLength * math.cos(angle)
|
|
local py = lineLength * math.sin(angle)
|
|
table.insert(vertices, {{px, py}, {0, 0}})
|
|
end
|
|
|
|
-- Set the hexagon's vertices
|
|
self._hexagonMesh:SetData(vertices)
|
|
self._hexagonMesh:Draw()
|
|
|
|
-- YOU! You are the reason for all my pain!
|
|
gfx.ForceRender()
|
|
end
|
|
|
|
--NOTE: THIS IS BUGGY, ForceRender fucks up so many things, call the individual draw functions at top level
|
|
function Radar:drawGraph()
|
|
---@cast self Radar
|
|
|
|
game.Log("Radar:drawGraph() SHOULD NOT BE CALLED", game.LOGGER_WARNING)
|
|
|
|
gfx.Save()
|
|
gfx.Reset()
|
|
gfx.ResetScissor()
|
|
|
|
Dim.updateResolution()
|
|
Dim.transformToScreenSpace()
|
|
|
|
gfx.FontSize(28)
|
|
gfx.Translate(self.pos.x, self.pos.y)
|
|
gfx.Scale(self.scale, self.scale)
|
|
|
|
local strokeColor = ColorRGBA.new(255, 255, 255, 100)
|
|
local fillColor = ColorRGBA.new(0, 0, 0, 191)
|
|
|
|
self:drawBackground(fillColor)
|
|
self:drawOutline(3, strokeColor)
|
|
self:drawRadarMesh()
|
|
self:drawRadialTicks(strokeColor)
|
|
self:drawAttributes()
|
|
|
|
local pos = Point2D.new(self.pos:coords())
|
|
pos.y = pos.y - self.RADIUS
|
|
--drawDebugText(pos, self._graphdata)
|
|
|
|
gfx.Restore()
|
|
|
|
--NOTE: Bug workaround: forcerender resets every transformation, re-setup view transform
|
|
Dim.transformToScreenSpace()
|
|
end
|
|
|
|
---Compute radar attribute values from ksh
|
|
---@param info string # chart directory path
|
|
---@param dif string # chart name without extension
|
|
function Radar:updateGraph(info, dif)
|
|
---@cast self Radar
|
|
|
|
--local pattern = "(.*[\\/])"
|
|
--local extractedSubstring = info:match(pattern)
|
|
--local txtFilePath = extractedSubstring .. "radar\\" .. dif .. ".txt"
|
|
|
|
--local song = io.open(txtFilePath, "r")
|
|
local fullPath = info.."/"..dif..".ksh"
|
|
local song = io.open(fullPath)
|
|
game.Log('Reading chart data from "'..fullPath..'"', game.LOGGER_DEBUG)
|
|
game.Log(song and "file open" or "file not found", game.LOGGER_DEBUG)
|
|
if song then
|
|
local chartData = song:read("*all")
|
|
song:close()
|
|
|
|
local notesCount, knobCount, oneHandCount, handTripCount = 0, 0, 0, 0
|
|
local chartLineCount = 0
|
|
local notesValue = 0
|
|
local peakValue = 0
|
|
local tsumamiValue = 0
|
|
local trickyValue = 0
|
|
local totalMeasures = 0
|
|
|
|
local lastNotes = {}
|
|
local lastFx = {}
|
|
local measureLength = 0
|
|
|
|
---@cast chartData string
|
|
for line in chartData:gmatch("[^\r\n]+") do
|
|
-- <bt-lanes x 4>|<fx-lanes x 2>|<laser-lanes x 2><lane-spin (optional)>
|
|
|
|
--game.Log(line, game.LOGGER_DEBUG)
|
|
|
|
local patternBt = "([012][012][012][012])"
|
|
local patternFx = "([012ABDFGHIJKLPQSTUVWX][012ABDFGHIJKLPQSTUVWX])"
|
|
local patternLaser = "([%-:%dA-Za-o][%-:%dA-Za-o])"
|
|
local patternLaneSpin = "([@S][%(%)<>]%d+)" -- optional
|
|
local pattern = patternBt.."|"..patternFx.."|"..patternLaser
|
|
|
|
-- match line format
|
|
|
|
local noteType, fxType, laserType = line:match(pattern)
|
|
local laneSpin = line:match(patternLaneSpin)
|
|
|
|
if noteType and fxType and laserType then
|
|
chartLineCount = chartLineCount + 1
|
|
|
|
-- convert strings to array, to be easily indexable
|
|
|
|
noteType = {noteType:match("([012])([012])([012])([012])")}
|
|
fxType = {fxType:match("([012ABDFGHIJKLPQSTUVWX])([012ABDFGHIJKLPQSTUVWX])")}
|
|
laserType = {laserType:match("([%-:%dA-Za-o])([%-:%dA-Za-o])")}
|
|
|
|
---@cast noteType string[]
|
|
---@cast fxType string[]
|
|
---@cast laserType string[]
|
|
|
|
-- parse notes
|
|
|
|
local function isNewNote(idx, note)
|
|
if note == "2" and lastNotes[idx] ~= note then
|
|
-- a new hold note
|
|
return true
|
|
end
|
|
if note == "1" then
|
|
-- a chip
|
|
return true
|
|
end
|
|
end
|
|
for noteIdx, note in ipairs(noteType) do
|
|
if isNewNote(noteIdx, note) then
|
|
notesCount = notesCount + 1
|
|
end
|
|
end
|
|
|
|
-- parse fx
|
|
|
|
local function isNewFx(idx, fx)
|
|
if fx:match("[1ABDFGHIJKLPQSTUVWX]") and lastFx[idx] ~= fx then
|
|
-- a new hold note
|
|
return true
|
|
end
|
|
if fx == "2" then
|
|
-- a chip
|
|
return true
|
|
end
|
|
end
|
|
for fxIdx, fx in ipairs(fxType) do
|
|
if isNewFx(fxIdx, fx) then
|
|
notesCount = notesCount + 1
|
|
end
|
|
end
|
|
|
|
-- parse laser
|
|
|
|
for _, laser in ipairs(laserType) do
|
|
if laser ~= "-" then
|
|
knobCount = knobCount + 1
|
|
end
|
|
end
|
|
|
|
-- figure out one-handed notes (there's a BT or FX while a hand is manipulating a knob)
|
|
-- also try to figure out cross-handed notes (one-handed notes, but on the same side as knob)
|
|
|
|
local function countBtFx()
|
|
local count = 0
|
|
for noteIdx, note in ipairs(noteType) do
|
|
if isNewNote(noteIdx, note) then
|
|
count = count + 1
|
|
end
|
|
end
|
|
for fxIdx, fx in ipairs(fxType) do
|
|
if isNewFx(fxIdx, fx) then
|
|
count = count + 1
|
|
end
|
|
end
|
|
return count
|
|
end
|
|
---@param side "left"|"right"
|
|
local function countSide(side)
|
|
local count = 0
|
|
local notes = {}
|
|
local fx = ""
|
|
if side == "left" then
|
|
notes = {noteType[1], noteType[2]}
|
|
fx = fxType[1]
|
|
if isNewFx(1, fx) then
|
|
count = count + 1
|
|
end
|
|
elseif side == "right" then
|
|
notes = {noteType[3], noteType[4]}
|
|
fx = fxType[2]
|
|
if isNewFx(2, fx) then
|
|
count = count + 1
|
|
end
|
|
else
|
|
game.Log("countSide: Invalid side parameter", game.LOGGER_ERROR)
|
|
return 0
|
|
end
|
|
for noteIdx, note in ipairs(notes) do
|
|
if isNewNote(noteIdx, note) then
|
|
count = count + 1
|
|
end
|
|
end
|
|
return count
|
|
end
|
|
if laserType[1] ~= "-" and laserType[2] == "-" then
|
|
oneHandCount = oneHandCount + countBtFx()
|
|
handTripCount = handTripCount + countSide("left")
|
|
end
|
|
if laserType[1] == "-" and laserType[2] ~= "-" then
|
|
oneHandCount = oneHandCount + countBtFx()
|
|
handTripCount = handTripCount + countSide("right")
|
|
end
|
|
|
|
lastNotes = noteType
|
|
lastFx = fxType
|
|
|
|
measureLength = measureLength + 1
|
|
end
|
|
|
|
if line == "--" then
|
|
-- end of measure
|
|
measureLength = math.max(1, measureLength)
|
|
|
|
local relativeMeasureLength = measureLength / 192
|
|
|
|
-- calculate peak density
|
|
local peak = (notesCount / 6) / relativeMeasureLength
|
|
peakValue = math.max(peakValue, peak)
|
|
--[[
|
|
local debuglog = {
|
|
measureLength = measureLength,
|
|
notesCount = notesCount,
|
|
relativeMeasureLength = relativeMeasureLength,
|
|
peak = peak,
|
|
}
|
|
for k, v in pairs(debuglog) do
|
|
game.Log(k..": "..v, game.LOGGER_DEBUG)
|
|
end
|
|
]]
|
|
|
|
-- cumulate "time" spent operating the knobs
|
|
local tsumami = (knobCount / 2) / relativeMeasureLength
|
|
tsumamiValue = tsumamiValue + tsumami
|
|
|
|
measureLength = 0
|
|
notesCount = 0
|
|
|
|
-- cumulate peak values (used to average notes over the length of the song)
|
|
notesValue = notesValue + peak
|
|
|
|
totalMeasures = totalMeasures + 1
|
|
end
|
|
|
|
local beat = line:match("beat=(%d+/%d+)")
|
|
if beat then
|
|
beat = {beat:match("(%d+)/(%d+)")}
|
|
end
|
|
|
|
--BUG: This is not correct, it needs to account for effect length
|
|
local function isTricky()
|
|
local tricks = {
|
|
"beat",
|
|
"stop",
|
|
"zoom_top",
|
|
"zoom_bottom",
|
|
"zoom_side",
|
|
"center_split",
|
|
}
|
|
return Util.any(tricks, function(e) return line:match("e") end)
|
|
end
|
|
if laneSpin or isTricky() then
|
|
trickyValue = trickyValue + 1
|
|
end
|
|
end
|
|
|
|
local graphValues = {
|
|
notes = notesValue / totalMeasures,
|
|
peak = peakValue,
|
|
tsumami = tsumamiValue / totalMeasures,
|
|
tricky = trickyValue,
|
|
handtrip = handTripCount,
|
|
onehand = oneHandCount,
|
|
}
|
|
|
|
game.Log("graphValues", game.LOGGER_DEBUG)
|
|
for k,v in pairs(graphValues) do
|
|
game.Log(k..": "..v, game.LOGGER_DEBUG)
|
|
end
|
|
|
|
local calibration = {
|
|
notes = 10,
|
|
peak = 48,
|
|
tsumami = 20000,
|
|
tricky = 128,
|
|
handtrip = 300,
|
|
onehand = 300,
|
|
}
|
|
|
|
for key, factor in pairs(calibration) do
|
|
-- Apply the scaling factor to each value
|
|
self._graphdata[key] = graphValues[key] / factor
|
|
|
|
-- Limit to maximum scale factor
|
|
self._graphdata[key] = math.min(self._graphdata[key], maxScaleFactor)
|
|
end
|
|
|
|
game.Log("_graphdata", game.LOGGER_DEBUG)
|
|
for k,v in pairs(self._graphdata) do
|
|
game.Log(k..": "..v, game.LOGGER_DEBUG)
|
|
end
|
|
end
|
|
end
|
|
|
|
return Radar
|