+ sqlite3_stmt *stmt;
+ int ret = sqlite3_prepare_v2(db, "UPDATE event SET type=? WHERE event=?", -1, &stmt, 0);
+ if (ret != SQLITE_OK) {
+ fprintf(stderr, "INSERT prepare: %s\n", sqlite3_errmsg(db));
+ abort();
+ }
+
+ sqlite3_bind_text(stmt, 1, type.data(), type.size(), SQLITE_STATIC);
+ 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();
+ }
+}
+
+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;
+ 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; };
+
+ for (const Event &e : events) {
+ if (e.t > t) {
+ break;
+ }
+
+ if (e.type == EventType::GOAL || e.type == EventType::THEIR_GOAL) {
+ s.pull_state = Status::SHOULD_PULL;
+ } else if (e.type == EventType::IN || e.type == EventType::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;
+ } else {
+ s.pull_state = Status::NOT_PULLING; // Includes pull_landed and pull_oob.
+ }
+
+ if (e.type == EventType::SET_OFFENSE) {
+ set_offense();
+ } else if (e.type == EventType::SET_DEFENSE) {
+ set_defense();
+ }
+
+ if (e.type == EventType::GOAL) {
+ ++s.our_score;
+ set_defense();
+ num_touches = 0;
+ }
+ if (e.type == EventType::THEIR_GOAL) {
+ ++s.their_score;
+ set_offense();
+ num_touches = 0;
+ }
+ if (e.type == EventType::CATCH) {
+ if (num_touches == 0) { // Pick up.
+ last_gained_possession = e.t;
+ time_spent_in_stoppage = 0;
+ }
+ ++num_touches;
+ }
+ if (e.type == EventType::INTERCEPTION) {
+ num_touches = 1;
+ set_offense();
+ last_gained_possession = e.t;
+ time_spent_in_stoppage = 0;
+ }
+ if (e.type == EventType::DEFENSE || e.type == EventType::THEIR_THROWAWAY) {
+ set_offense();
+ num_touches = 0;
+ time_spent_in_stoppage = 0;
+ }
+ 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 == EventType::STOPPAGE) {
+ s.stoppage = true;
+ last_stoppage = e.t;
+ }
+ 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);
+ }
+
+ s.num_passes = (num_touches == 0) ? 0 : num_touches - 1;
+ s.possession_sec = (s.attack_state == Status::OFFENSE && last_gained_possession != 0 && num_touches != 0) ? (t - last_gained_possession - time_spent_in_stoppage) / 1000 : 0;
+ s.stoppage_sec = (s.attack_state == Status::OFFENSE && last_gained_possession != 0 && num_touches != 0) ? time_spent_in_stoppage / 1000 : 0;
+ return s;
+}
+
+set<int> EventsModel::get_team_at(uint64_t t)
+{
+ set<int> team;
+ for (const Event &e : events) {
+ if (e.t > t) {
+ break;
+ }
+ if (e.type == EventType::IN) {
+ team.insert(*e.player_id);
+ }
+ if (e.type == EventType::OUT) {
+ team.erase(*e.player_id);
+ }
+ }
+ return team;
+}
+
+void EventsModel::set_team_at(uint64_t t, const set<int> &new_team)
+{
+ // Backdate to the last goal or stoppage, _or_ the last time someone
+ // going out is mentioned. (We don't really track injuries yet;
+ // do we want an explicit injury type? If we had one, it would probably
+ // be the simplest.)
+ 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::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)) {
+ backdate_point = e.t + 1;
+ }
+ }
+
+ // Delete all in/outs already at the backdate point.
+ for (unsigned i = 0; i < events.size(); ) {
+ if (events[i].t > backdate_point) {
+ break;
+ }
+ if (events[i].t == backdate_point && (events[i].type == EventType::IN || events[i].type == EventType::OUT)) {
+ delete_event(i);
+ } else {
+ ++i;
+ }
+ }
+
+ // Finally make the subs we need.
+ 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, nullopt, "out");
+ }
+ }
+ for (int player_id : new_team) {
+ if (!old_team.count(player_id)) {
+ 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::IN || e.type == EventType::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;