mirror of
https://github.com/SMGCommunity/Petari.git
synced 2024-11-26 23:10:24 +00:00
405 lines
11 KiB
Python
405 lines
11 KiB
Python
import csv, datetime, glob, json, io, math, os, sys
|
|
from git import Repo
|
|
from pathlib import Path
|
|
|
|
import pandas as pd
|
|
import plotly.express as px
|
|
|
|
libraries = { }
|
|
|
|
def truncate(number, digits) -> float:
|
|
stepper = 10.0 ** digits
|
|
return math.trunc(stepper * number) / stepper
|
|
|
|
def generateFullProgJSON(label, percent, color):
|
|
json = []
|
|
json.append("{\n")
|
|
json.append("\t\"schemaVersion\": 1,\n")
|
|
json.append(f"\t\"label\": \"{label}\",\n")
|
|
json.append(f"\t\"message\": \"{truncate(percent, 3)}%\",\n")
|
|
json.append(f"\t\"color\": \"{color}\"\n")
|
|
json.append("}")
|
|
|
|
with open(f"data/{label}.json", "w") as w:
|
|
w.writelines(json)
|
|
|
|
class Function:
|
|
name = ""
|
|
isCompleted = False
|
|
funcSize = 0
|
|
|
|
def __init__(self, name, isComplete, funcSize):
|
|
self.name = name
|
|
self.isCompleted = isComplete
|
|
self.funcSize = funcSize
|
|
|
|
class Object:
|
|
name = ""
|
|
functions = []
|
|
totalFunctions = 0
|
|
totalCompletedFunctions = 0
|
|
|
|
def __init__(self, name):
|
|
self.name = name
|
|
self.functions = list()
|
|
self.totalFunctions = 0
|
|
self.totalCompletedFunctions = 0
|
|
|
|
def addFunction(self, function):
|
|
self.functions.append(function)
|
|
|
|
if function.isCompleted:
|
|
self.totalCompletedFunctions += 1
|
|
|
|
self.totalFunctions += 1
|
|
|
|
def getFunctions(self):
|
|
return self.functions
|
|
|
|
def calculateProgress(self):
|
|
fullSize = 0
|
|
doneSize = 0
|
|
numFuncs = 0
|
|
doneFuncs = 0
|
|
for function in self.functions:
|
|
fullSize += function.funcSize
|
|
numFuncs += 1
|
|
|
|
if function.isCompleted:
|
|
doneSize += function.funcSize
|
|
doneFuncs += 1
|
|
|
|
return doneSize, fullSize, numFuncs, doneFuncs
|
|
|
|
class Library:
|
|
name = ""
|
|
objects = []
|
|
|
|
def __init__(self, name):
|
|
self.name = name
|
|
self.objects = list()
|
|
|
|
def addObject(self, object):
|
|
self.objects.append(object)
|
|
|
|
def addFunctionToObject(self, obj, function):
|
|
if self.containsObject(obj.name):
|
|
self.findObject(obj.name).addFunction(function)
|
|
else:
|
|
self.addObject(obj)
|
|
self.addFunctionToObject(obj, function)
|
|
|
|
def findObject(self, objectName):
|
|
for obj in self.objects:
|
|
if obj.name == objectName:
|
|
return obj
|
|
|
|
return None
|
|
|
|
def getObjects(self):
|
|
return self.objects
|
|
|
|
def containsObject(self, object):
|
|
for obj in self.objects:
|
|
if obj.name == object:
|
|
return True
|
|
|
|
return False
|
|
|
|
def calculateProgress(self):
|
|
fullSize = 0
|
|
doneSize = 0
|
|
funcNum = 0
|
|
funcDone = 0
|
|
|
|
for obj in self.objects:
|
|
d, f, func_num, func_done = obj.calculateProgress()
|
|
fullSize += f
|
|
doneSize += d
|
|
funcNum += func_num
|
|
funcDone += func_done
|
|
|
|
return doneSize, fullSize, funcNum, funcDone
|
|
|
|
|
|
def getName(self):
|
|
return self.name
|
|
|
|
def generateJSONTag(self, percent, color):
|
|
json = []
|
|
json.append("{\n")
|
|
json.append("\t\"schemaVersion\": 1,\n")
|
|
json.append(f"\t\"label\": \"{self.name}\",\n")
|
|
json.append(f"\t\"message\": \"{truncate(percent, 3)}%\",\n")
|
|
json.append(f"\t\"color\": \"{color}\"\n")
|
|
json.append("}")
|
|
|
|
with open(f"data/json/{self.name}.json", "w") as w:
|
|
w.writelines(json)
|
|
|
|
def generateMarkdown(self):
|
|
# first we are going to generate the tables for the object files themselves in the library
|
|
page = []
|
|
page.append(f"# {self.name}\n")
|
|
page.append("| Symbol | Meaning \n")
|
|
page.append("| ------------- | ------------- \n")
|
|
page.append("| :x: | Object has not yet been started. \n")
|
|
page.append("| :eight_pointed_black_star: | Object is in progress. \n")
|
|
page.append("| :white_check_mark: | Object is completed. \n")
|
|
page.append("\n\n")
|
|
page.append("| Object | Percentage (of Bytes) | Functions Done / Total Functions | Percentage (Functions) | Status \n")
|
|
page.append("| ------------- | ------------- | ------------- | ------------- | ------------- \n")
|
|
|
|
for obj in self.objects:
|
|
d, f, pad1, pad2 = obj.calculateProgress()
|
|
prog = (d / f) * 100.0
|
|
funcProg = (obj.totalCompletedFunctions / obj.totalFunctions) * 100.0
|
|
|
|
marker = ":x:"
|
|
|
|
if d == f:
|
|
marker = ":white_check_mark:"
|
|
elif d != f and d != 0:
|
|
marker = ":eight_pointed_black_star:"
|
|
|
|
obj_page_name = obj.name.replace(".o", "")
|
|
|
|
page.append(f"| [{obj.name}](https://github.com/shibbo/Petari/blob/master/docs/lib/{self.name}/{obj_page_name}.md) | {prog}% | {obj.totalCompletedFunctions} / {obj.totalFunctions} | {funcProg}% | {marker} \n")
|
|
|
|
with open(f"docs/lib/{self.name}.md", "w") as w:
|
|
w.writelines(page)
|
|
|
|
# now that we have written the main page, let's make the object page too
|
|
for obj in self.objects:
|
|
obj_page = []
|
|
|
|
obj_page.append(f"# {obj.name}\n")
|
|
obj_page.append("| Symbol | Meaning \n")
|
|
obj_page.append("| ------------- | ------------- \n")
|
|
obj_page.append("| :x: | Function has not yet been started or is not matching. \n")
|
|
obj_page.append("| :white_check_mark: | Function is completed. \n")
|
|
obj_page.append("\n\n")
|
|
|
|
pad1, pad2, numFunc, doneFunc = obj.calculateProgress()
|
|
percent = (doneFunc / numFunc) * 100.0
|
|
|
|
obj_page.append(f"# {doneFunc} / {numFunc} Completed -- ({percent}%)\n")
|
|
|
|
obj_page.append(f"# {obj.name}\n")
|
|
obj_page.append("| Symbol | Decompiled? |\n")
|
|
obj_page.append("| ------------- | ------------- |\n")
|
|
|
|
for func in obj.getFunctions():
|
|
marker = ":x:"
|
|
|
|
if func.isCompleted:
|
|
marker = ":white_check_mark:"
|
|
|
|
obj_page.append(f"| `{func.name}` | {marker} |\n")
|
|
|
|
obj_page_name = obj.name.replace(".o", "")
|
|
|
|
if not os.path.exists(f"docs/lib/{self.name}"):
|
|
os.makedirs(f"docs/lib/{self.name}")
|
|
|
|
with open(f"docs/lib/{self.name}/{obj_page_name}.md", "w") as w:
|
|
w.writelines(obj_page)
|
|
|
|
game_libs = [
|
|
"Animation.a",
|
|
"AreaObj.a",
|
|
"AudioLib.a",
|
|
"Boss.a",
|
|
"Camera.a",
|
|
"Demo.a",
|
|
"Effect.a",
|
|
"Enemy.a",
|
|
"GameAudio.a",
|
|
"Gravity.a",
|
|
"LiveActor.a",
|
|
"Map.a",
|
|
"MapObj.a",
|
|
"NameObj.a",
|
|
"NPC.a",
|
|
"NWC24.a",
|
|
"Player.a",
|
|
"RhythmLib.a",
|
|
"Ride.a",
|
|
"Scene.a",
|
|
"Screen.a",
|
|
"Speaker.a",
|
|
"System.a",
|
|
"Util.a"
|
|
]
|
|
|
|
lib_percent_colors = {
|
|
"Animation": "brightgreen",
|
|
"AreaObj": "green",
|
|
"AudioLib": "yellow",
|
|
"Boss": "orange",
|
|
"Camera": "red",
|
|
"Demo": "D65076",
|
|
"Effect": "pink",
|
|
"Enemy": "magenta",
|
|
"GameAudio": "teal",
|
|
"Gravity": "maroon",
|
|
"LiveActor": "cyan",
|
|
"Map": "silver",
|
|
"MapObj": "tan",
|
|
"NameObj": "indigo",
|
|
"NPC": "7fffd4",
|
|
"Player": "ff7f50",
|
|
"RhythmLib": "088da5",
|
|
"Ride": "ffff66",
|
|
"Scene": "a0db8e",
|
|
"Screen": "ff4040",
|
|
"Speaker": "daa520",
|
|
"System": "696969",
|
|
"Util": "ff6666"
|
|
}
|
|
|
|
doGraph = False
|
|
|
|
if "-graph" in sys.argv:
|
|
doGraph = True
|
|
|
|
func_sizes = {}
|
|
|
|
# start by reading function sizes
|
|
with open("data/funcSizes.txt", "r") as file:
|
|
lines = file.readlines()
|
|
|
|
for line in lines:
|
|
spl = line.split('=')
|
|
sym = spl[0]
|
|
func_sizes[sym] = spl[1].split(',', 1)[1]
|
|
|
|
csv_files = glob.glob("csv/*.csv")
|
|
|
|
for csv_file in sorted(csv_files, key=str.casefold):
|
|
lib_name = Path(csv_file).stem
|
|
lib_arch_name = Path(csv_file).stem + ".a"
|
|
|
|
library = Library(lib_name)
|
|
|
|
with open(csv_file, "r") as c:
|
|
csv_reader = csv.reader(c)
|
|
|
|
for row in csv_reader:
|
|
symbol = row[0]
|
|
symbol = symbol.replace(",", ",")
|
|
if symbol == "Symbol Name":
|
|
continue
|
|
|
|
obj = row[1]
|
|
lib = row[2]
|
|
done = row[3] == "true"
|
|
|
|
funcSize = int(func_sizes[symbol].strip("\n"))
|
|
func = Function(symbol, done, funcSize)
|
|
|
|
obj = Object(obj)
|
|
library.addFunctionToObject(obj, func)
|
|
|
|
libraries[lib_name] = library
|
|
|
|
full_sdk_size = 0
|
|
done_sdk_size = 0
|
|
|
|
num_funcs = 0
|
|
num_done_funcs = 0
|
|
|
|
print("Calculating percentages...")
|
|
|
|
for key in libraries:
|
|
lib = libraries[key]
|
|
d, f, funcNum, funcDoneNum = lib.calculateProgress()
|
|
|
|
libName = f"{lib.getName()}.a"
|
|
|
|
if libName in game_libs:
|
|
full_sdk_size += f
|
|
done_sdk_size += d
|
|
num_funcs += funcNum
|
|
num_done_funcs += funcDoneNum
|
|
|
|
if lib.getName() not in lib_percent_colors:
|
|
lib.generateJSONTag((d / f ) * 100.0, "ffff66")
|
|
else:
|
|
lib.generateJSONTag((d / f ) * 100.0, lib_percent_colors[lib.getName()])
|
|
|
|
progPercent_sdk = (done_sdk_size / full_sdk_size ) * 100.0
|
|
progPercent_Func = (num_done_funcs / num_funcs) * 100.0
|
|
|
|
print(f"Progress: {progPercent_sdk}% [{done_sdk_size} / {full_sdk_size}] bytes")
|
|
print(f"Progress: {progPercent_Func}% [{num_done_funcs} / {num_funcs}] functions")
|
|
print("Generating JSON...")
|
|
|
|
generateFullProgJSON("Game", progPercent_sdk, "blue")
|
|
|
|
print("Generating markdown pages...")
|
|
|
|
# now we generate our progress page
|
|
progressPage = []
|
|
progressPage.append("| Library | Percentage |\n")
|
|
progressPage.append("| ------------- | ------------- |\n")
|
|
|
|
for key in libraries:
|
|
lib = libraries[key]
|
|
d, f, pad1, pad2 = lib.calculateProgress()
|
|
libprog = (d / f) * 100.0
|
|
progressPage.append(f"| [{key}](https://github.com/shibbo/Petari/blob/master/docs/lib/{key}.md) | {libprog}% |\n")
|
|
|
|
with open("docs/PROGRESS.md", "w") as w:
|
|
w.writelines(progressPage)
|
|
|
|
# now we write the progress page for each library
|
|
for key in libraries:
|
|
lib = libraries[key]
|
|
lib.generateMarkdown()
|
|
|
|
if doGraph:
|
|
print("Generating progress graph...")
|
|
|
|
# now we do the cool progress drawing chart
|
|
x_axis = [datetime.datetime.now()]
|
|
y_axis = [progPercent_sdk]
|
|
|
|
# np.seterr(all="ignore")
|
|
|
|
repo = Repo(".")
|
|
|
|
for commit in repo.iter_commits(rev='92c1a7e..master'):
|
|
cur_file = None
|
|
|
|
try:
|
|
cur_file = commit.tree / 'data' / 'percent.json'
|
|
except:
|
|
try:
|
|
cur_file = commit.tree / 'data' / 'game.json'
|
|
except:
|
|
try:
|
|
cur_file = commit.tree / 'data' / 'Game.json'
|
|
except:
|
|
pass
|
|
pass
|
|
pass
|
|
|
|
if cur_file is None:
|
|
continue
|
|
|
|
with io.BytesIO(cur_file.data_stream.read()) as f:
|
|
try:
|
|
percent_str = json.loads(f.read().decode('utf-8'))['message'].strip("%")
|
|
x_axis.append(datetime.datetime.fromtimestamp(commit.committed_date))
|
|
y_axis.append(float(percent_str))
|
|
except:
|
|
continue
|
|
|
|
df = pd.DataFrame({'date': x_axis, 'progress': y_axis})
|
|
fig = px.line(df, x='date', y='progress', title='Petari Progress', line_shape='hv', markers=False)
|
|
fig.update_yaxes(ticksuffix='%')
|
|
fig.write_image('prog.png')
|
|
|
|
print("Done.")
|