string format_timestamp(uint64_t pos);
-EventsModel::EventsModel(sqlite3 *db) : db(db)
+static string event_type_to_string(EventType type)
+{
+ switch (type) {
+ case EventType::CATCH:
+ return "catch";
+ case EventType::DEFENSE:
+ return "defense";
+ case EventType::DEFENSIVE_SOFT_MINUS:
+ return "defensive_soft_minus";
+ case EventType::DEFENSIVE_SOFT_PLUS:
+ return "defensive_soft_plus";
+ case EventType::FORMATION_DEFENSE:
+ return "formation_defense";
+ case EventType::FORMATION_OFFENSE:
+ return "formation_offense";
+ case EventType::DROP:
+ return "drop";
+ case EventType::GOAL:
+ return "goal";
+ case EventType::SWAP_IN:
+ return "in";
+ case EventType::INTERCEPTION:
+ return "interception";
+ case EventType::OFFENSIVE_SOFT_MINUS:
+ return "offensive_soft_minus";
+ case EventType::OFFENSIVE_SOFT_PLUS:
+ return "offensive_soft_plus";
+ case EventType::SWAP_OUT:
+ return "out";
+ case EventType::PULL:
+ return "pull";
+ case EventType::PULL_LANDED:
+ return "pull_landed";
+ case EventType::PULL_OOB:
+ return "pull_oob";
+ case EventType::RESTART:
+ return "restart";
+ case EventType::SET_DEFENSE:
+ return "set_defense";
+ case EventType::SET_OFFENSE:
+ return "set_offense";
+ case EventType::STALLOUT:
+ return "stallout";
+ case EventType::STOPPAGE:
+ return "stoppage";
+ case EventType::THEIR_GOAL:
+ return "their_goal";
+ case EventType::THEIR_PULL:
+ return "their_pull";
+ case EventType::THEIR_THROWAWAY:
+ return "their_throwaway";
+ case EventType::THROWAWAY:
+ return "throwaway";
+ case EventType::UNKNOWN:
+ return "unknown";
+ case EventType::WAS_D:
+ return "was_d";
+ }
+ abort();
+}
+
+static EventType string_to_event_type(const string &type)
+{
+ if (type == "catch") {
+ return EventType::CATCH;
+ } else if (type == "defense") {
+ return EventType::DEFENSE;
+ } else if (type == "defensive_soft_minus") {
+ return EventType::DEFENSIVE_SOFT_MINUS;
+ } else if (type == "defensive_soft_plus") {
+ return EventType::DEFENSIVE_SOFT_PLUS;
+ } else if (type == "formation_defense") {
+ return EventType::FORMATION_DEFENSE;
+ } else if (type == "formation_offense") {
+ return EventType::FORMATION_OFFENSE;
+ } else if (type == "drop") {
+ return EventType::DROP;
+ } else if (type == "goal") {
+ return EventType::GOAL;
+ } else if (type == "in") {
+ return EventType::SWAP_IN;
+ } else if (type == "interception") {
+ return EventType::INTERCEPTION;
+ } else if (type == "offensive_soft_minus") {
+ return EventType::OFFENSIVE_SOFT_MINUS;
+ } else if (type == "offensive_soft_plus") {
+ return EventType::OFFENSIVE_SOFT_PLUS;
+ } else if (type == "out") {
+ return EventType::SWAP_OUT;
+ } else if (type == "pull") {
+ return EventType::PULL;
+ } else if (type == "pull_landed") {
+ return EventType::PULL_LANDED;
+ } else if (type == "pull_oob") {
+ return EventType::PULL_OOB;
+ } else if (type == "restart") {
+ return EventType::RESTART;
+ } else if (type == "set_defense") {
+ return EventType::SET_DEFENSE;
+ } else if (type == "set_offense") {
+ return EventType::SET_OFFENSE;
+ } else if (type == "stallout") {
+ return EventType::STALLOUT;
+ } else if (type == "stoppage") {
+ return EventType::STOPPAGE;
+ } else if (type == "their_goal") {
+ return EventType::THEIR_GOAL;
+ } else if (type == "their_pull") {
+ return EventType::THEIR_PULL;
+ } else if (type == "their_throwaway") {
+ return EventType::THEIR_THROWAWAY;
+ } else if (type == "throwaway") {
+ return EventType::THROWAWAY;
+ } else if (type == "unknown") {
+ return EventType::UNKNOWN;
+ } else if (type == "was_d") {
+ return EventType::WAS_D;
+ } else {
+ fprintf(stderr, "Unknown event type “%s”\n", type.c_str());
+ exit(1);
+ }
+}
+
+EventsModel::EventsModel(sqlite3 *db, int match_id) : db(db), match_id(match_id)
{
load_data();
}
if (section == 0) {
return "Time";
} else if (section == 1) {
- return "Player";
+ return "Who/what";
} else {
return "Type";
}
if (role != Qt::DisplayRole) {
return QVariant();
}
+ const Event &e = events[index.row()];
if (index.column() == 0) {
- return QString::fromUtf8(format_timestamp(events[index.row()].t));
+ return QString::fromUtf8(format_timestamp(e.t));
} else if (index.column() == 1) {
- optional<int> player_id = events[index.row()].player_id;
+ optional<int> player_id = e.player_id;
+ optional<int> formation_id = e.formation_id;
if (player_id) {
auto p_it = players.find(*player_id);
const Player &p = p_it->second;
return QString::fromUtf8(p.name + " (" + p.number + ")");
+ } else if (formation_id) {
+ auto f_it = formations.find(*formation_id);
+ const Formation &f = f_it->second;
+ return QString::fromUtf8(f.name);
+ } else if (e.type == EventType::FORMATION_OFFENSE || e.type == EventType::FORMATION_DEFENSE) {
+ return "(None/unknown)";
} else {
return QVariant();
}
} else if (index.column() == 2) {
- return QString::fromUtf8(events[index.row()].type);
+ string type = event_type_to_string(e.type);
+ type[0] = toupper(type[0]);
+ for (char &ch : type) {
+ if (ch == '_') {
+ ch = ' ';
+ }
+ }
+
+ // Various fixups.
+ if (type == "Pull oob") {
+ type = "Pull OOB";
+ } else if (type == "Formation defense") {
+ type = "Defensive formation";
+ } else if (type == "Formation offense") {
+ type = "Offensive formation";
+ } else if (type == "Set offense") {
+ type = "On offense";
+ } else if (type == "Set defense") {
+ type = "On defense";
+ } else if (type == "Catch") {
+ type = "Catch/take";
+ } else if (type == "Was d") {
+ type = "Was d-ed";
+ }
+
+ return QString::fromUtf8(type);
}
return QVariant();
}
players.clear();
events.clear();
- // Read the players.
+ // Read the players. (The ordering is used to build the order map.)
sqlite3_stmt *stmt;
- int ret = sqlite3_prepare_v2(db, "SELECT player, number, name FROM player", -1, &stmt, 0);
+ int ret = sqlite3_prepare_v2(db, "SELECT player, number, name FROM player ORDER BY gender, (number+0), number", -1, &stmt, 0);
if (ret != SQLITE_OK) {
fprintf(stderr, "SELECT prepare: %s\n", sqlite3_errmsg(db));
abort();
}
+ int order = 0;
for ( ;; ) {
ret = sqlite3_step(stmt);
if (ret == SQLITE_ROW) {
p.number = (const char *)sqlite3_column_text(stmt, 1);
p.name = (const char *) sqlite3_column_text(stmt, 2);
players[p.player_id] = std::move(p);
+ player_ordering[p.player_id] = order++;
+ } else if (ret == SQLITE_DONE) {
+ break;
+ } else {
+ fprintf(stderr, "SELECT step: %s\n", sqlite3_errmsg(db));
+ abort();
+ }
+ }
+ ret = sqlite3_finalize(stmt);
+ if (ret != SQLITE_OK) {
+ fprintf(stderr, "SELECT finalize: %s\n", sqlite3_errmsg(db));
+ abort();
+ }
+
+ // Read the formations.
+ ret = sqlite3_prepare_v2(db, "SELECT formation, name FROM formation", -1, &stmt, 0);
+ if (ret != SQLITE_OK) {
+ fprintf(stderr, "SELECT prepare: %s\n", sqlite3_errmsg(db));
+ abort();
+ }
+ for ( ;; ) {
+ ret = sqlite3_step(stmt);
+ if (ret == SQLITE_ROW) {
+ Formation f;
+ f.formation_id = sqlite3_column_int(stmt, 0);
+ f.name = (const char *) sqlite3_column_text(stmt, 1);
+ formations[f.formation_id] = std::move(f);
} else if (ret == SQLITE_DONE) {
break;
} else {
}
// Read the events.
- ret = sqlite3_prepare_v2(db, "SELECT event, t, player, type FROM event ORDER BY t", -1, &stmt, 0);
+ ret = sqlite3_prepare_v2(db, "SELECT event, t, player, formation, type FROM event WHERE match=? ORDER BY t", -1, &stmt, 0);
if (ret != SQLITE_OK) {
fprintf(stderr, "SELECT prepare: %s\n", sqlite3_errmsg(db));
abort();
}
+ sqlite3_bind_int64(stmt, 1, match_id);
for ( ;; ) {
ret = sqlite3_step(stmt);
if (ret == SQLITE_ROW) {
if (sqlite3_column_type(stmt, 2) == SQLITE_INTEGER) { // Non-NULL.
e.player_id = sqlite3_column_int(stmt, 2);
}
- e.type = (const char *)sqlite3_column_text(stmt, 3);
+ if (sqlite3_column_type(stmt, 3) == SQLITE_INTEGER) { // Non-NULL.
+ e.formation_id = sqlite3_column_int(stmt, 3);
+ }
+ e.type = string_to_event_type((const char *)sqlite3_column_text(stmt, 4));
events.push_back(std::move(e));
} else if (ret == SQLITE_DONE) {
break;
}
}
-unsigned EventsModel::insert_event(uint64_t t, optional<int> player_id, const string &type)
+unsigned EventsModel::insert_event(uint64_t t, optional<int> player_id, optional<int> formation_id, const string &type)
{
auto it = lower_bound(events.begin(), events.end(), t,
[](const Event &e, uint64_t t) { return e.t < t; });
Event e;
e.t = t;
e.player_id = player_id;
- e.type = type;
+ e.formation_id = formation_id;
+ e.type = string_to_event_type(type);
events.insert(events.begin() + pos, e);
endInsertRows();
// Insert the new row into the database.
sqlite3_stmt *stmt;
- int ret = sqlite3_prepare_v2(db, "INSERT INTO event (t, player, type) VALUES (?, ?, ?)", -1, &stmt, 0);
+ int ret = sqlite3_prepare_v2(db, "INSERT INTO event (match, t, player, formation, type) VALUES (?, ?, ?, ?, ?)", -1, &stmt, 0);
if (ret != SQLITE_OK) {
fprintf(stderr, "INSERT prepare: %s\n", sqlite3_errmsg(db));
abort();
}
- sqlite3_bind_int64(stmt, 1, t);
+ sqlite3_bind_int64(stmt, 1, match_id);
+ sqlite3_bind_int64(stmt, 2, t);
if (player_id) {
- sqlite3_bind_int64(stmt, 2, *player_id);
+ sqlite3_bind_int64(stmt, 3, *player_id);
+ } else {
+ sqlite3_bind_null(stmt, 3);
+ }
+ if (formation_id) {
+ sqlite3_bind_int64(stmt, 4, *formation_id);
} else {
- sqlite3_bind_null(stmt, 2);
+ sqlite3_bind_null(stmt, 4);
}
- sqlite3_bind_text(stmt, 3, type.data(), type.size(), SQLITE_STATIC);
+ sqlite3_bind_text(stmt, 5, type.data(), type.size(), SQLITE_STATIC);
ret = sqlite3_step(stmt);
if (ret == SQLITE_ROW) {
void EventsModel::set_event_type(unsigned pos, const string &type)
{
- events[pos].type = type;
+ events[pos].type = string_to_event_type(type);
emit dataChanged(createIndex(pos, 0), createIndex(pos, 2));
sqlite3_stmt *stmt;
}
}
+void EventsModel::set_event_formation(unsigned pos, int formation_id)
+{
+ events[pos].formation_id = formation_id;
+ emit dataChanged(createIndex(pos, 0), createIndex(pos, 2));
+
+ sqlite3_stmt *stmt;
+ int ret = sqlite3_prepare_v2(db, "UPDATE event SET formation=? WHERE event=?", -1, &stmt, 0);
+ if (ret != SQLITE_OK) {
+ fprintf(stderr, "INSERT prepare: %s\n", sqlite3_errmsg(db));
+ abort();
+ }
+
+ sqlite3_bind_int64(stmt, 1, formation_id);
+ sqlite3_bind_int64(stmt, 2, events[pos].event_id);
+
+ ret = sqlite3_step(stmt);
+ if (ret == SQLITE_ROW) {
+ fprintf(stderr, "UPDATE step: %s\n", sqlite3_errmsg(db));
+ abort();
+ }
+
+ ret = sqlite3_finalize(stmt);
+ if (ret != SQLITE_OK) {
+ fprintf(stderr, "UPDATE finalize: %s\n", sqlite3_errmsg(db));
+ abort();
+ }
+}
+
+unsigned EventsModel::get_last_event_pos(uint64_t t) const
+{
+ // upper_bound() gives first where e.t > t,
+ // and the one before that is the one we want.
+ auto it = upper_bound(events.begin(), events.end(), t,
+ [](uint64_t t, const Event &e) { return t < e.t; });
+ if (it == events.begin()) {
+ return 0;
+ } else {
+ return distance(events.begin(), it - 1);
+ }
+}
+
EventsModel::Status EventsModel::get_status_at(uint64_t t)
{
Status s;
s.our_score = 0;
s.their_score = 0;
s.attack_state = Status::NOT_STARTED;
+ s.offensive_formation = 0;
+ s.defensive_formation = 0;
s.stoppage = false;
s.pull_state = Status::SHOULD_PULL;
+ s.last_catching_player = -1;
uint64_t last_gained_possession = 0;
uint64_t last_stoppage = 0;
uint64_t time_spent_in_stoppage = 0;
unsigned num_touches = 0;
- auto set_offense = [&s] { s.attack_state = Status::OFFENSE; };
- auto set_defense = [&s] { s.attack_state = Status::DEFENSE; };
+ auto set_offense = [&s] { s.attack_state = Status::OFFENSE; s.last_catching_player = -1; };
+ auto set_defense = [&s] { s.attack_state = Status::DEFENSE; s.last_catching_player = -1; };
for (const Event &e : events) {
if (e.t > t) {
break;
}
- if (e.type == "goal" || e.type == "their_goal") {
+ if (e.type == EventType::GOAL || e.type == EventType::THEIR_GOAL) {
s.pull_state = Status::SHOULD_PULL;
- } else if (e.type == "in" || e.type == "out" || e.type == "stoppage" || e.type == "restart" || e.type == "unknown") {
+ } else if (e.type == EventType::SWAP_IN || e.type == EventType::SWAP_OUT || e.type == EventType::STOPPAGE || e.type == EventType::RESTART || e.type == EventType::UNKNOWN || e.type == EventType::SET_DEFENSE || e.type == EventType::SET_OFFENSE) {
// No effect on pull status.
+ } else if (e.type == EventType::PULL) {
+ s.pull_state = Status::PULL_IN_AIR;
+ s.last_catching_player = -1; // Just to be sure.
} else {
- s.pull_state = Status::NOT_PULLING;
+ s.pull_state = Status::NOT_PULLING; // Includes pull_landed and pull_oob.
}
- if (e.type == "set_offense") {
+ if (e.type == EventType::SET_OFFENSE) {
set_offense();
- } else if (e.type == "set_defense") {
+ } else if (e.type == EventType::SET_DEFENSE) {
set_defense();
}
- if (e.type == "goal") {
+ if (e.type == EventType::GOAL) {
++s.our_score;
set_defense();
num_touches = 0;
}
- if (e.type == "their_goal") {
+ if (e.type == EventType::THEIR_GOAL) {
++s.their_score;
set_offense();
num_touches = 0;
}
- if (e.type == "catch") {
+ if (e.type == EventType::CATCH) {
if (num_touches == 0) { // Pick up.
last_gained_possession = e.t;
time_spent_in_stoppage = 0;
}
++num_touches;
+ s.last_catching_player = *e.player_id;
}
- if (e.type == "interception") {
+ if (e.type == EventType::INTERCEPTION) {
num_touches = 1;
set_offense();
+ s.last_catching_player = *e.player_id;
last_gained_possession = e.t;
time_spent_in_stoppage = 0;
}
- if (e.type == "defense" || e.type == "their_throwaway") {
+ if (e.type == EventType::DEFENSE || e.type == EventType::THEIR_THROWAWAY) {
set_offense();
num_touches = 0;
time_spent_in_stoppage = 0;
}
- if (e.type == "drop" || e.type == "throwaway") {
+ if (e.type == EventType::DROP || e.type == EventType::WAS_D || e.type == EventType::THROWAWAY || e.type == EventType::STALLOUT) {
set_defense();
num_touches = 0;
}
- if (e.type == "stoppage") {
+ if (e.type == EventType::STOPPAGE) {
s.stoppage = true;
last_stoppage = e.t;
}
- if (e.type == "restart") {
+ if (e.type == EventType::RESTART) {
s.stoppage = false;
if (last_stoppage != 0) {
time_spent_in_stoppage += (e.t - last_stoppage);
last_stoppage = 0;
}
}
+ if (e.type == EventType::FORMATION_OFFENSE) {
+ if (e.formation_id) {
+ s.offensive_formation = *e.formation_id;
+ } else {
+ s.offensive_formation = 0;
+ }
+ }
+ if (e.type == EventType::FORMATION_DEFENSE) {
+ if (e.formation_id) {
+ s.defensive_formation = *e.formation_id;
+ } else {
+ s.defensive_formation = 0;
+ }
+ }
}
if (s.stoppage && last_stoppage != 0) {
time_spent_in_stoppage += (t - last_stoppage);
if (e.t > t) {
break;
}
- if (e.type == "in") {
+ if (e.type == EventType::SWAP_IN) {
team.insert(*e.player_id);
}
- if (e.type == "out") {
+ if (e.type == EventType::SWAP_OUT) {
team.erase(*e.player_id);
}
}
if (e.t > t) {
break;
}
- if (e.type == "goal" || e.type == "their_goal" || e.type == "stoppage" || e.type == "reset") {
+ if (e.type == EventType::GOAL || e.type == EventType::THEIR_GOAL || e.type == EventType::STOPPAGE || e.type == EventType::SET_OFFENSE || e.type == EventType::SET_DEFENSE) {
backdate_point = e.t + 1;
}
if (e.player_id.has_value() && !new_team.count(*e.player_id)) {
if (events[i].t > backdate_point) {
break;
}
- if (events[i].t == backdate_point && (events[i].type == "in" || events[i].type == "out")) {
+ if (events[i].t == backdate_point && (events[i].type == EventType::SWAP_IN || events[i].type == EventType::SWAP_OUT)) {
delete_event(i);
} else {
++i;
set<int> old_team = get_team_at(backdate_point);
for (int player_id : old_team) {
if (!new_team.count(player_id)) {
- insert_event(backdate_point, player_id, "out");
+ insert_event(backdate_point, player_id, nullopt, "out");
}
}
for (int player_id : new_team) {
if (!old_team.count(player_id)) {
- insert_event(backdate_point, player_id, "in");
+ insert_event(backdate_point, player_id, nullopt, "in");
+ }
+ }
+}
+
+void EventsModel::set_formation_at(uint64_t t, bool offense, unsigned formation)
+{
+ // If there's another goal/stoppage/turnover no more than 20 seconds ago,
+ // we assume that the formation started at that point (it just took
+ // the operator a bit of time to see it). If not, we assume we
+ // changed in the middle of a point.
+ uint64_t backdate_point = 0;
+ for (const Event &e : events) {
+ if (e.t > t) {
+ break;
+ }
+ if (e.type == EventType::GOAL || e.type == EventType::THEIR_GOAL ||
+ e.type == EventType::SWAP_IN || e.type == EventType::SWAP_OUT ||
+ e.type == EventType::STOPPAGE ||
+ e.type == EventType::SET_DEFENSE || e.type == EventType::SET_OFFENSE ||
+ e.type == EventType::THROWAWAY || e.type == EventType::THEIR_THROWAWAY ||
+ e.type == EventType::DROP || e.type == EventType::WAS_D || e.type == EventType::DEFENSE || e.type == EventType::INTERCEPTION || e.type == EventType::STALLOUT ||
+ e.type == EventType::PULL || e.type == EventType::PULL_LANDED || e.type == EventType::PULL_OOB || e.type == EventType::THEIR_PULL ||
+ e.type == EventType::FORMATION_OFFENSE || e.type == EventType::FORMATION_DEFENSE) {
+ backdate_point = e.t + 1;
+ }
+ if (e.type == EventType::FORMATION_OFFENSE || e.type == EventType::FORMATION_DEFENSE) {
+ backdate_point = 0;
}
}
+ if (backdate_point != 0 && t - backdate_point < 20000) {
+ t = backdate_point;
+ }
+ if (offense) {
+ insert_event(t, nullopt, formation == 0 ? nullopt : optional{formation}, "formation_offense");
+ } else {
+ insert_event(t, nullopt, formation == 0 ? nullopt : optional{formation}, "formation_defense");
+ }
+}
+
+vector<int> EventsModel::sort_team(const set<int> &team) const
+{
+ vector<int> ret(team.begin(), team.end());
+ std::sort(ret.begin(), ret.end(), [this](int a, int b) {
+ return player_ordering.find(a)->second < player_ordering.find(b)->second;
+ });
+ return ret;
}
projects / pkanalytics / blobdiff