11 string format_timestamp(uint64_t pos);
13 EventsModel::EventsModel(sqlite3 *db, int match_id) : db(db), match_id(match_id)
18 QVariant EventsModel::headerData(int section, Qt::Orientation orientation, int role) const
20 if (role != Qt::DisplayRole) {
23 if (orientation == Qt::Horizontal) {
26 } else if (section == 1) {
36 QVariant EventsModel::data(const QModelIndex &index, int role) const
38 if (role != Qt::DisplayRole) {
41 if (index.column() == 0) {
42 return QString::fromUtf8(format_timestamp(events[index.row()].t));
43 } else if (index.column() == 1) {
44 optional<int> player_id = events[index.row()].player_id;
45 optional<int> formation_id = events[index.row()].formation_id;
47 auto p_it = players.find(*player_id);
48 const Player &p = p_it->second;
49 return QString::fromUtf8(p.name + " (" + p.number + ")");
50 } else if (formation_id) {
51 auto f_it = formations.find(*formation_id);
52 const Formation &f = f_it->second;
53 return QString::fromUtf8(f.name);
57 } else if (index.column() == 2) {
58 return QString::fromUtf8(events[index.row()].type);
63 void EventsModel::load_data()
68 // Read the players. (The ordering is used to build the order map.)
70 int ret = sqlite3_prepare_v2(db, "SELECT player, number, name FROM player ORDER BY gender, (number+0), number", -1, &stmt, 0);
71 if (ret != SQLITE_OK) {
72 fprintf(stderr, "SELECT prepare: %s\n", sqlite3_errmsg(db));
77 ret = sqlite3_step(stmt);
78 if (ret == SQLITE_ROW) {
80 p.player_id = sqlite3_column_int(stmt, 0);
81 p.number = (const char *)sqlite3_column_text(stmt, 1);
82 p.name = (const char *) sqlite3_column_text(stmt, 2);
83 players[p.player_id] = std::move(p);
84 player_ordering[p.player_id] = order++;
85 } else if (ret == SQLITE_DONE) {
88 fprintf(stderr, "SELECT step: %s\n", sqlite3_errmsg(db));
92 ret = sqlite3_finalize(stmt);
93 if (ret != SQLITE_OK) {
94 fprintf(stderr, "SELECT finalize: %s\n", sqlite3_errmsg(db));
98 // Read the formations.
99 ret = sqlite3_prepare_v2(db, "SELECT formation, name FROM formation", -1, &stmt, 0);
100 if (ret != SQLITE_OK) {
101 fprintf(stderr, "SELECT prepare: %s\n", sqlite3_errmsg(db));
105 ret = sqlite3_step(stmt);
106 if (ret == SQLITE_ROW) {
108 f.formation_id = sqlite3_column_int(stmt, 0);
109 f.name = (const char *) sqlite3_column_text(stmt, 1);
110 formations[f.formation_id] = std::move(f);
111 } else if (ret == SQLITE_DONE) {
114 fprintf(stderr, "SELECT step: %s\n", sqlite3_errmsg(db));
118 ret = sqlite3_finalize(stmt);
119 if (ret != SQLITE_OK) {
120 fprintf(stderr, "SELECT finalize: %s\n", sqlite3_errmsg(db));
125 ret = sqlite3_prepare_v2(db, "SELECT event, t, player, formation, type FROM event WHERE match=? ORDER BY t", -1, &stmt, 0);
126 if (ret != SQLITE_OK) {
127 fprintf(stderr, "SELECT prepare: %s\n", sqlite3_errmsg(db));
130 sqlite3_bind_int64(stmt, 1, match_id);
132 ret = sqlite3_step(stmt);
133 if (ret == SQLITE_ROW) {
135 e.event_id = sqlite3_column_int(stmt, 0);
136 e.t = sqlite3_column_int(stmt, 1);
137 if (sqlite3_column_type(stmt, 2) == SQLITE_INTEGER) { // Non-NULL.
138 e.player_id = sqlite3_column_int(stmt, 2);
140 if (sqlite3_column_type(stmt, 3) == SQLITE_INTEGER) { // Non-NULL.
141 e.formation_id = sqlite3_column_int(stmt, 3);
143 e.type = (const char *)sqlite3_column_text(stmt, 4);
144 events.push_back(std::move(e));
145 } else if (ret == SQLITE_DONE) {
148 fprintf(stderr, "SELECT step: %s\n", sqlite3_errmsg(db));
152 ret = sqlite3_finalize(stmt);
153 if (ret != SQLITE_OK) {
154 fprintf(stderr, "SELECT finalize: %s\n", sqlite3_errmsg(db));
159 unsigned EventsModel::insert_event(uint64_t t, optional<int> player_id, optional<int> formation_id, const string &type)
161 auto it = lower_bound(events.begin(), events.end(), t,
162 [](const Event &e, uint64_t t) { return e.t < t; });
163 unsigned pos = distance(events.begin(), it);
164 beginInsertRows(QModelIndex(), pos, pos);
168 e.player_id = player_id;
170 events.insert(events.begin() + pos, e);
174 // Insert the new row into the database.
176 int ret = sqlite3_prepare_v2(db, "INSERT INTO event (match, t, player, formation, type) VALUES (?, ?, ?, ?, ?)", -1, &stmt, 0);
177 if (ret != SQLITE_OK) {
178 fprintf(stderr, "INSERT prepare: %s\n", sqlite3_errmsg(db));
182 sqlite3_bind_int64(stmt, 1, match_id);
183 sqlite3_bind_int64(stmt, 2, t);
185 sqlite3_bind_int64(stmt, 3, *player_id);
187 sqlite3_bind_null(stmt, 3);
190 sqlite3_bind_int64(stmt, 4, *formation_id);
192 sqlite3_bind_null(stmt, 4);
194 sqlite3_bind_text(stmt, 5, type.data(), type.size(), SQLITE_STATIC);
196 ret = sqlite3_step(stmt);
197 if (ret == SQLITE_ROW) {
198 fprintf(stderr, "INSERT step: %s\n", sqlite3_errmsg(db));
202 ret = sqlite3_finalize(stmt);
203 if (ret != SQLITE_OK) {
204 fprintf(stderr, "INSERT finalize: %s\n", sqlite3_errmsg(db));
208 events[pos].event_id = sqlite3_last_insert_rowid(db);
212 void EventsModel::delete_event(unsigned pos)
214 int event_id = events[pos].event_id;
216 beginRemoveRows(QModelIndex(), pos, pos);
217 events.erase(events.begin() + pos);
220 // Delete the row from the database.
222 int ret = sqlite3_prepare_v2(db, "DELETE FROM event WHERE event=?", -1, &stmt, 0);
223 if (ret != SQLITE_OK) {
224 fprintf(stderr, "DELETE prepare: %s\n", sqlite3_errmsg(db));
228 sqlite3_bind_int64(stmt, 1, event_id);
230 ret = sqlite3_step(stmt);
231 if (ret == SQLITE_ROW) {
232 fprintf(stderr, "DELETE step: %s\n", sqlite3_errmsg(db));
236 ret = sqlite3_finalize(stmt);
237 if (ret != SQLITE_OK) {
238 fprintf(stderr, "DELETE finalize: %s\n", sqlite3_errmsg(db));
243 void EventsModel::set_event_type(unsigned pos, const string &type)
245 events[pos].type = type;
246 emit dataChanged(createIndex(pos, 0), createIndex(pos, 2));
249 int ret = sqlite3_prepare_v2(db, "UPDATE event SET type=? WHERE event=?", -1, &stmt, 0);
250 if (ret != SQLITE_OK) {
251 fprintf(stderr, "INSERT prepare: %s\n", sqlite3_errmsg(db));
255 sqlite3_bind_text(stmt, 1, type.data(), type.size(), SQLITE_STATIC);
256 sqlite3_bind_int64(stmt, 2, events[pos].event_id);
258 ret = sqlite3_step(stmt);
259 if (ret == SQLITE_ROW) {
260 fprintf(stderr, "UPDATE step: %s\n", sqlite3_errmsg(db));
264 ret = sqlite3_finalize(stmt);
265 if (ret != SQLITE_OK) {
266 fprintf(stderr, "UPDATE finalize: %s\n", sqlite3_errmsg(db));
271 unsigned EventsModel::get_last_event_pos(uint64_t t) const
273 // upper_bound() gives first where e.t > t,
274 // and the one before that is the one we want.
275 auto it = upper_bound(events.begin(), events.end(), t,
276 [](uint64_t t, const Event &e) { return t < e.t; });
277 if (it == events.begin()) {
280 return distance(events.begin(), it - 1);
284 EventsModel::Status EventsModel::get_status_at(uint64_t t)
289 s.attack_state = Status::NOT_STARTED;
291 s.pull_state = Status::SHOULD_PULL;
292 uint64_t last_gained_possession = 0;
293 uint64_t last_stoppage = 0;
294 uint64_t time_spent_in_stoppage = 0;
295 unsigned num_touches = 0;
297 auto set_offense = [&s] { s.attack_state = Status::OFFENSE; };
298 auto set_defense = [&s] { s.attack_state = Status::DEFENSE; };
300 for (const Event &e : events) {
305 if (e.type == "goal" || e.type == "their_goal") {
306 s.pull_state = Status::SHOULD_PULL;
307 } else if (e.type == "in" || e.type == "out" || e.type == "stoppage" || e.type == "restart" || e.type == "unknown" || e.type == "set_defense" || e.type == "set_offense") {
308 // No effect on pull status.
309 } else if (e.type == "pull") {
310 s.pull_state = Status::PULL_IN_AIR;
312 s.pull_state = Status::NOT_PULLING; // Includes pull_landed and pull_oob.
315 if (e.type == "set_offense") {
317 } else if (e.type == "set_defense") {
321 if (e.type == "goal") {
326 if (e.type == "their_goal") {
331 if (e.type == "catch") {
332 if (num_touches == 0) { // Pick up.
333 last_gained_possession = e.t;
334 time_spent_in_stoppage = 0;
338 if (e.type == "interception") {
341 last_gained_possession = e.t;
342 time_spent_in_stoppage = 0;
344 if (e.type == "defense" || e.type == "their_throwaway") {
347 time_spent_in_stoppage = 0;
349 if (e.type == "drop" || e.type == "throwaway") {
353 if (e.type == "stoppage") {
357 if (e.type == "restart") {
359 if (last_stoppage != 0) {
360 time_spent_in_stoppage += (e.t - last_stoppage);
365 if (s.stoppage && last_stoppage != 0) {
366 time_spent_in_stoppage += (t - last_stoppage);
369 s.num_passes = (num_touches == 0) ? 0 : num_touches - 1;
370 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;
371 s.stoppage_sec = (s.attack_state == Status::OFFENSE && last_gained_possession != 0 && num_touches != 0) ? time_spent_in_stoppage / 1000 : 0;
375 set<int> EventsModel::get_team_at(uint64_t t)
378 for (const Event &e : events) {
382 if (e.type == "in") {
383 team.insert(*e.player_id);
385 if (e.type == "out") {
386 team.erase(*e.player_id);
392 void EventsModel::set_team_at(uint64_t t, const set<int> &new_team)
394 // Backdate to the last goal or stoppage, _or_ the last time someone
395 // going out is mentioned. (We don't really track injuries yet;
396 // do we want an explicit injury type? If we had one, it would probably
398 uint64_t backdate_point = 0;
399 for (const Event &e : events) {
403 if (e.type == "goal" || e.type == "their_goal" || e.type == "stoppage" || e.type == "reset" || e.type == "set_offense" || e.type == "set_defense") {
404 backdate_point = e.t + 1;
406 if (e.player_id.has_value() && !new_team.count(*e.player_id)) {
407 backdate_point = e.t + 1;
411 // Delete all in/outs already at the backdate point.
412 for (unsigned i = 0; i < events.size(); ) {
413 if (events[i].t > backdate_point) {
416 if (events[i].t == backdate_point && (events[i].type == "in" || events[i].type == "out")) {
423 // Finally make the subs we need.
424 set<int> old_team = get_team_at(backdate_point);
425 for (int player_id : old_team) {
426 if (!new_team.count(player_id)) {
427 insert_event(backdate_point, player_id, nullopt, "out");
430 for (int player_id : new_team) {
431 if (!old_team.count(player_id)) {
432 insert_event(backdate_point, player_id, nullopt, "in");
437 void EventsModel::set_formation_at(uint64_t t, bool offense, unsigned formation)
439 // If there's another goal/stoppage no more than 20 seconds ago,
440 // we assume that the formation started at that point (it just took
441 // the operator a bit of time to see it). If not, we assume we
442 // changed in the middle of a point.
443 uint64_t backdate_point = 0;
444 for (const Event &e : events) {
448 if (e.type == "goal" || e.type == "their_goal" || e.type == "stoppage" || e.type == "reset" || e.type == "set_offense" || e.type == "set_defense" || e.type == "in" || e.type == "out" || e.type == "pull" || e.type == "their_pull") {
449 backdate_point = e.t + 1;
451 if (e.type == "formation_offense" || e.type == "formation_defense") {
455 if (backdate_point != 0 && t - backdate_point < 20000) {
459 insert_event(t, nullopt, formation, "formation_offense");
461 insert_event(t, nullopt, formation, "formation_defense");
465 vector<int> EventsModel::sort_team(const set<int> &team) const
467 vector<int> ret(team.begin(), team.end());
468 std::sort(ret.begin(), ret.end(), [this](int a, int b) {
469 return player_ordering.find(a)->second < player_ordering.find(b)->second;