370 lines
11 KiB
Dart
370 lines
11 KiB
Dart
import 'dart:math';
|
|
import 'package:vector_math/vector_math_64.dart';
|
|
|
|
import 'tetrio.dart';
|
|
|
|
// I want to implement those fancy TWC stats
|
|
// So, i'm going to read replay for things
|
|
|
|
int biggestSpikeFromReplay(events){
|
|
int previousIGEeventFrame = -1;
|
|
int spikeCounter = 0;
|
|
int biggestSpike = 0;
|
|
for (var event in events){
|
|
if (event["type"] == "ige" && event["data"]["data"]["type"] == "interaction"){
|
|
if (previousIGEeventFrame.isNegative){
|
|
spikeCounter = event['data']['data']['data']['amt'];
|
|
biggestSpike = spikeCounter;
|
|
}else{
|
|
if (event['data']['data']['frame'] - previousIGEeventFrame < 60){
|
|
spikeCounter = spikeCounter + event['data']['data']['data']['amt'] as int;
|
|
}else{
|
|
spikeCounter = event['data']['data']['data']['amt'];
|
|
}
|
|
biggestSpike = max(biggestSpike, spikeCounter);
|
|
}
|
|
previousIGEeventFrame = event['data']['data']['frame'];
|
|
}
|
|
}
|
|
return biggestSpike;
|
|
}
|
|
|
|
class Garbage{ // charsys where???
|
|
late int sent;
|
|
late int recived;
|
|
late int attack;
|
|
late int cleared;
|
|
|
|
Garbage({
|
|
required this.sent,
|
|
required this.recived,
|
|
required this.attack,
|
|
required this.cleared
|
|
});
|
|
|
|
Garbage.fromJson(Map<String, dynamic> json){
|
|
sent = json['sent'];
|
|
recived = json['received'];
|
|
attack = json['attack'];
|
|
cleared = json['cleared'];
|
|
}
|
|
|
|
Garbage.toJson(){
|
|
// наху надо
|
|
}
|
|
|
|
Garbage operator + (Garbage other){
|
|
return Garbage(sent: sent + other.sent, recived: recived + other.recived, attack: attack + other.attack, cleared: cleared + other.cleared);
|
|
}
|
|
}
|
|
|
|
class ReplayStats{
|
|
late int seed;
|
|
late int linesCleared;
|
|
late int piecesPlaced;
|
|
late int inputs;
|
|
late int holds;
|
|
late int score;
|
|
late int topCombo;
|
|
late int topBtB;
|
|
late int topSpike;
|
|
late int tspins;
|
|
late double roundLength; // in seconds
|
|
late Clears clears;
|
|
late Garbage garbage;
|
|
late Finesse finesse;
|
|
|
|
double get finessePercentage => finesse.perfectPieces / piecesPlaced;
|
|
|
|
ReplayStats({
|
|
required this.seed,
|
|
required this.linesCleared,
|
|
required this.piecesPlaced,
|
|
required this.inputs,
|
|
required this.holds,
|
|
required this.score,
|
|
required this.topCombo,
|
|
required this.topBtB,
|
|
required this.topSpike,
|
|
required this.tspins,
|
|
required this.roundLength,
|
|
required this.clears,
|
|
required this.garbage,
|
|
required this.finesse,
|
|
});
|
|
|
|
ReplayStats.fromJson(Map<String, dynamic> json, int inputTopSpike, int framesLength){
|
|
seed = json['seed'];
|
|
linesCleared = json['lines'];
|
|
piecesPlaced = json['piecesplaced'];
|
|
inputs = json['inputs'];
|
|
holds = json['holds'];
|
|
score = json['score'];
|
|
topCombo = json['topcombo'];
|
|
topBtB = json['topbtb'];
|
|
topSpike = inputTopSpike;
|
|
tspins = json['tspins'];
|
|
roundLength = framesLength / 60;
|
|
clears = Clears.fromJson(json['clears']);
|
|
garbage = Garbage.fromJson(json['garbage']);
|
|
finesse = Finesse.fromJson(json['finesse']);
|
|
}
|
|
|
|
double get kpp => inputs / piecesPlaced;
|
|
double get kps => inputs / roundLength;
|
|
double get spp => score / piecesPlaced;
|
|
|
|
ReplayStats.createEmpty(){
|
|
seed = -1;
|
|
linesCleared = 0;
|
|
piecesPlaced = 0;
|
|
inputs = 0;
|
|
holds = 0;
|
|
score = 0;
|
|
topCombo = 0;
|
|
topBtB = 0;
|
|
topSpike = 0;
|
|
tspins = 0;
|
|
roundLength = 0.0;
|
|
clears = Clears(singles: 0, doubles: 0, triples: 0, quads: 0, pentas: 0, allClears: 0, tSpinZeros: 0, tSpinSingles: 0, tSpinDoubles: 0, tSpinTriples: 0, tSpinPentas: 0, tSpinQuads: 0, tSpinMiniZeros: 0, tSpinMiniSingles: 0, tSpinMiniDoubles: 0);
|
|
garbage = Garbage(sent: 0, recived: 0, attack: 0, cleared: 0);
|
|
finesse = Finesse(combo: 0, faults: 0, perfectPieces: 0);
|
|
}
|
|
|
|
ReplayStats operator + (ReplayStats other){
|
|
return ReplayStats(seed: -1,
|
|
linesCleared: linesCleared + other.linesCleared,
|
|
piecesPlaced: piecesPlaced + other.piecesPlaced,
|
|
inputs: inputs + other.inputs,
|
|
holds: holds + other.holds,
|
|
score: score + other.score,
|
|
topCombo: max(topCombo, other.topCombo),
|
|
topBtB: max(topBtB, other.topBtB),
|
|
topSpike: max(topSpike, other.topSpike),
|
|
tspins: tspins + other.tspins,
|
|
roundLength: roundLength + other.roundLength,
|
|
clears: clears + other.clears,
|
|
garbage: garbage + other.garbage,
|
|
finesse: finesse + other.finesse
|
|
);
|
|
}
|
|
}
|
|
|
|
class ReplayData{
|
|
late String id;
|
|
late Map<dynamic, dynamic> rawJson;
|
|
late List<EndContextMulti> endcontext;
|
|
late List<List<ReplayStats>> stats;
|
|
late List<ReplayStats> totalStats;
|
|
late List<List<String>> roundWinners;
|
|
late List<int> roundLengths; // in frames
|
|
late int totalLength; // in frames
|
|
|
|
ReplayData({
|
|
required this.id,
|
|
required this.endcontext,
|
|
required this.stats,
|
|
required this.totalStats,
|
|
required this.roundWinners,
|
|
required this.roundLengths,
|
|
required this.totalLength
|
|
}){
|
|
rawJson = {};
|
|
}
|
|
|
|
ReplayData.fromJson(Map<String, dynamic> json){
|
|
rawJson = json;
|
|
id = json['_id'];
|
|
endcontext = [EndContextMulti.fromJson(json['endcontext'][0]), EndContextMulti.fromJson(json['endcontext'][1])];
|
|
roundLengths = [];
|
|
totalLength = 0;
|
|
stats = [];
|
|
roundWinners = [];
|
|
totalStats = [ReplayStats.createEmpty(), ReplayStats.createEmpty()];
|
|
for(var round in json['data']) {
|
|
int firstInEndContext = round['replays'][0]["events"].last['data']['export']['options']['gameid'].startsWith(endcontext[0].userId) ? 0 : 1;
|
|
int secondInEndContext = round['replays'][1]["events"].last['data']['export']['options']['gameid'].startsWith(endcontext[1].userId) ? 1 : 0;
|
|
roundLengths.add(max(round['replays'][0]['frames'], round['replays'][1]['frames']));
|
|
totalLength = totalLength + max(round['replays'][0]['frames'], round['replays'][1]['frames']);
|
|
int winner = round['board'].indexWhere((element) => element['success'] == true);
|
|
roundWinners.add([round['board'][winner]['id'], round['board'][winner]['username']]);
|
|
ReplayStats playerOne = ReplayStats.fromJson(round['replays'][firstInEndContext]['events'].last['data']['export']['stats'], biggestSpikeFromReplay(round['replays'][secondInEndContext]['events']), round['replays'][firstInEndContext]['frames']); // (events contain recived attacks)
|
|
ReplayStats playerTwo = ReplayStats.fromJson(round['replays'][secondInEndContext]['events'].last['data']['export']['stats'], biggestSpikeFromReplay(round['replays'][firstInEndContext]['events']), round['replays'][secondInEndContext]['frames']);
|
|
stats.add([playerOne, playerTwo]);
|
|
totalStats[0] = totalStats[0] + playerOne;
|
|
totalStats[1] = totalStats[1] + playerTwo;
|
|
}
|
|
}
|
|
|
|
Map<String, dynamic> toJson(){
|
|
final Map<String, dynamic> data = <String, dynamic>{};
|
|
data['_id'] = id;
|
|
data['endcontext'] = [endcontext[0].toJson(), endcontext[1].toJson()];
|
|
data['data'] = [];
|
|
for(var round in rawJson['data']) {
|
|
List<dynamic> eventsPlayerOne = round['replays'][0]['events'];
|
|
List<dynamic> eventsPlayerTwo = round['replays'][1]['events'];
|
|
eventsPlayerOne.removeWhere((v) => (v['type'] == 'ige' && v['data']['data']['type'] != 'interaction') || (v['type'] != 'end' && v['type'] != 'ige'));
|
|
eventsPlayerTwo.removeWhere((v) => (v['type'] == 'ige' && v['data']['data']['type'] != 'interaction') || (v['type'] != 'end' && v['type'] != 'ige'));
|
|
data['data'].add({'board': round['board'], 'replays': [
|
|
{'frames': round['replays'][0]['frames'], 'events': eventsPlayerOne},
|
|
{'frames': round['replays'][1]['frames'], 'events': eventsPlayerTwo}
|
|
]});
|
|
}
|
|
return data;
|
|
}
|
|
}
|
|
|
|
// can't belive i have to implement that difficult shit
|
|
|
|
class Event{
|
|
int id;
|
|
int frame;
|
|
String type;
|
|
//dynamic data;
|
|
|
|
Event(this.id, this.frame, this.type);
|
|
}
|
|
|
|
class Keypress{
|
|
String key;
|
|
double subframe;
|
|
|
|
Keypress(this.key, this.subframe);
|
|
}
|
|
|
|
class EventKeyPress extends Event{
|
|
Keypress data;
|
|
|
|
EventKeyPress(super.id, super.frame, super.type, this.data);
|
|
}
|
|
|
|
class IGE{
|
|
int id;
|
|
int frame;
|
|
String type;
|
|
int amount;
|
|
|
|
IGE(this.id, this.frame, this.type, this.amount);
|
|
}
|
|
|
|
class EventIGE extends Event{
|
|
IGE data;
|
|
|
|
EventIGE(super.id, super.frame, super.type, this.data);
|
|
}
|
|
|
|
class TetrioRNG{
|
|
late double _t;
|
|
|
|
TetrioRNG(int seed){
|
|
_t = seed % 2147483647;
|
|
if (_t <= 0) _t += 2147483646;
|
|
}
|
|
|
|
int next(){
|
|
_t = 16807 * _t % 2147483647;
|
|
return _t.toInt();
|
|
}
|
|
|
|
double nextFloat(){
|
|
return (next() - 1) / 2147483646;
|
|
}
|
|
|
|
List<Tetromino> shuffleList(List<Tetromino> array){
|
|
int length = array.length;
|
|
if (length == 0) return [];
|
|
|
|
for (; --length > 0;){
|
|
int swapIndex = ((nextFloat()) * (length + 1)).toInt();
|
|
Tetromino tmp = array[length];
|
|
array[length] = array[swapIndex];
|
|
array[swapIndex] = tmp;
|
|
}
|
|
return array;
|
|
}
|
|
}
|
|
|
|
enum Tetromino{
|
|
Z,
|
|
L,
|
|
O,
|
|
S,
|
|
I,
|
|
J,
|
|
T,
|
|
garbage,
|
|
empty
|
|
}
|
|
|
|
List<Tetromino> tetrominoes = [Tetromino.Z, Tetromino.L, Tetromino.O, Tetromino.S, Tetromino.I, Tetromino.J, Tetromino.T];
|
|
List<List<List<Vector2>>> shapes = [
|
|
[ // Z
|
|
[Vector2(0, 0), Vector2(1, 0), Vector2(1, 1), Vector2(2, 1)],
|
|
[Vector2(2, 0), Vector2(1, 1), Vector2(2, 1), Vector2(1, 2)],
|
|
[Vector2(0, 1), Vector2(1, 1), Vector2(1, 2), Vector2(2, 2)],
|
|
[Vector2(1, 0), Vector2(0, 1), Vector2(1, 1), Vector2(0, 2)]
|
|
],
|
|
[ // L
|
|
[Vector2(2, 0), Vector2(0, 1), Vector2(1, 1), Vector2(2, 1)],
|
|
[Vector2(1, 0), Vector2(1, 1), Vector2(1, 2), Vector2(2, 2)],
|
|
[Vector2(0, 1), Vector2(1, 1), Vector2(2, 1), Vector2(0, 2)],
|
|
[Vector2(0, 0), Vector2(1, 0), Vector2(1, 1), Vector2(1, 2)]
|
|
],
|
|
[ // O
|
|
[Vector2(0, 0), Vector2(1, 0), Vector2(0, 1), Vector2(1, 1)],
|
|
[Vector2(0, 0), Vector2(1, 0), Vector2(0, 1), Vector2(1, 1)],
|
|
[Vector2(0, 0), Vector2(1, 0), Vector2(0, 1), Vector2(1, 1)],
|
|
[Vector2(0, 0), Vector2(1, 0), Vector2(0, 1), Vector2(1, 1)]
|
|
],
|
|
[ // S
|
|
[Vector2(1, 0), Vector2(2, 0), Vector2(0, 1), Vector2(1, 1)],
|
|
[Vector2(1, 0), Vector2(1, 1), Vector2(2, 1), Vector2(2, 2)],
|
|
[Vector2(1, 1), Vector2(2, 1), Vector2(0, 2), Vector2(1, 2)],
|
|
[Vector2(0, 0), Vector2(0, 1), Vector2(1, 1), Vector2(1, 2)]
|
|
],
|
|
[ // I
|
|
[Vector2(0, 1), Vector2(1, 1), Vector2(2, 1), Vector2(3, 1)],
|
|
[Vector2(2, 0), Vector2(2, 1), Vector2(2, 2), Vector2(2, 3)],
|
|
[Vector2(0, 2), Vector2(1, 2), Vector2(2, 2), Vector2(3, 2)],
|
|
[Vector2(1, 0), Vector2(1, 1), Vector2(1, 2), Vector2(1, 3)]
|
|
],
|
|
[ // J
|
|
[Vector2(0, 0), Vector2(0, 1), Vector2(1, 1), Vector2(2, 1)],
|
|
[Vector2(1, 0), Vector2(2, 0), Vector2(1, 1), Vector2(1, 2)],
|
|
[Vector2(0, 1), Vector2(1, 1), Vector2(2, 1), Vector2(2, 2)],
|
|
[Vector2(1, 0), Vector2(1, 1), Vector2(0, 2), Vector2(1, 2)]
|
|
],
|
|
[ // T
|
|
[Vector2(1, 0), Vector2(0, 1), Vector2(1, 1), Vector2(2, 1)],
|
|
[Vector2(1, 0), Vector2(1, 1), Vector2(2, 1), Vector2(1, 2)],
|
|
[Vector2(0, 1), Vector2(1, 1), Vector2(2, 1), Vector2(1, 2)],
|
|
[Vector2(1, 0), Vector2(0, 1), Vector2(1, 1), Vector2(1, 2)]
|
|
]
|
|
];
|
|
List<Vector2> spawnPositionFixes = [Vector2(1, 1), Vector2(1, 1), Vector2(0, 1), Vector2(1, 1), Vector2(1, 1), Vector2(1, 1), Vector2(1, 1)];
|
|
|
|
const Map<String, double> garbage = {
|
|
"single": 0,
|
|
"double": 1,
|
|
"triple": 2,
|
|
"quad": 4,
|
|
"penta": 5,
|
|
"t-spin": 0,
|
|
"t-spin single": 2,
|
|
"t-spin double": 4,
|
|
"t-spin triple": 6,
|
|
"t-spin quad": 10,
|
|
"t-spin penta": 12,
|
|
"t-spin mini": 0,
|
|
"t-spin mini single": 0,
|
|
"t-spin mini double": 1,
|
|
"allclear": 10
|
|
};
|
|
int btbBonus = 1;
|
|
double btbLog = 0.8;
|
|
double comboBonus = 0.25;
|
|
int comboMinifier = 1;
|
|
double comboMinifierLog = 1.25;
|
|
List<int> comboTable = [0, 1, 1, 2, 2, 3, 3, 4, 4, 4, 5];
|