git.sesse.net Git - pkanalytics/blob - events.cpp

   1 #include <algorithm>
   2 #include <string>
   3 #include <map>
   4 #include <vector>
   5 #include <optional>
   6 #include <sqlite3.h>
   7 #include "events.h"
   8
   9 using namespace std;
  10
  11 string format_timestamp(uint64_t pos);
  12
  13 EventsModel::EventsModel(sqlite3 *db) : db(db)
  14 {
  15         load_data();
  16 }
  17
  18 QVariant EventsModel::headerData(int section, Qt::Orientation orientation, int role) const
  19 {
  20         if (role != Qt::DisplayRole) {
  21                 return QVariant();
  22         }
  23         if (orientation == Qt::Horizontal) {
  24                 if (section == 0) {
  25                         return "Time";
  26                 } else if (section == 1) {
  27                         return "Player";
  28                 } else {
  29                         return "Type";
  30                 }
  31         } else {
  32                 return "";
  33         }
  34 }
  35
  36 QVariant EventsModel::data(const QModelIndex &index, int role) const
  37 {
  38         if (role != Qt::DisplayRole) {
  39                 return QVariant();
  40         }
  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                 if (player_id) {
  46                         auto p_it = players.find(*player_id);
  47                         const Player &p = p_it->second;
  48                         return QString::fromUtf8(p.name + " (" + p.number + ")");
  49                 } else {
  50                         return QVariant();
  51                 }
  52         } else if (index.column() == 2) {
  53                 return QString::fromUtf8(events[index.row()].type);
  54         }
  55         return QVariant();
  56 }
  57
  58 void EventsModel::load_data()
  59 {
  60         players.clear();
  61         events.clear();
  62
  63         // Read the players.
  64         sqlite3_stmt *stmt;
  65         int ret = sqlite3_prepare_v2(db, "SELECT player, number, name FROM player", -1, &stmt, 0);
  66         if (ret != SQLITE_OK) {
  67                 fprintf(stderr, "SELECT prepare: %s\n", sqlite3_errmsg(db));
  68                 abort();
  69         }
  70         for ( ;; ) {
  71                 ret = sqlite3_step(stmt);
  72                 if (ret == SQLITE_ROW) {
  73                         Player p;
  74                         p.player_id = sqlite3_column_int(stmt, 0);
  75                         p.number = (const char *)sqlite3_column_text(stmt, 1);
  76                         p.name = (const char *) sqlite3_column_text(stmt, 2);
  77                         players[p.player_id] = std::move(p);
  78                 } else if (ret == SQLITE_DONE) {
  79                         break;
  80                 } else {
  81                         fprintf(stderr, "SELECT step: %s\n", sqlite3_errmsg(db));
  82                         abort();
  83                 }
  84         }
  85         ret = sqlite3_finalize(stmt);
  86         if (ret != SQLITE_OK) {
  87                 fprintf(stderr, "SELECT finalize: %s\n", sqlite3_errmsg(db));
  88                 abort();
  89         }
  90
  91         // Read the events.
  92         ret = sqlite3_prepare_v2(db, "SELECT event, t, player, type FROM event ORDER BY t", -1, &stmt, 0);
  93         if (ret != SQLITE_OK) {
  94                 fprintf(stderr, "SELECT prepare: %s\n", sqlite3_errmsg(db));
  95                 abort();
  96         }
  97         for ( ;; ) {
  98                 ret = sqlite3_step(stmt);
  99                 if (ret == SQLITE_ROW) {
 100                         Event e;
 101                         e.event_id = sqlite3_column_int(stmt, 0);
 102                         e.t = sqlite3_column_int(stmt, 1);
 103                         if (sqlite3_column_type(stmt, 2) == SQLITE_INTEGER) {  // Non-NULL.
 104                                 e.player_id = sqlite3_column_int(stmt, 2);
 105                         }
 106                         e.type = (const char *)sqlite3_column_text(stmt, 3);
 107                         events.push_back(std::move(e));
 108                 } else if (ret == SQLITE_DONE) {
 109                         break;
 110                 } else {
 111                         fprintf(stderr, "SELECT step: %s\n", sqlite3_errmsg(db));
 112                         abort();
 113                 }
 114         }
 115         ret = sqlite3_finalize(stmt);
 116         if (ret != SQLITE_OK) {
 117                 fprintf(stderr, "SELECT finalize: %s\n", sqlite3_errmsg(db));
 118                 abort();
 119         }
 120 }
 121
 122 unsigned EventsModel::insert_event(uint64_t t, optional<int> player_id, const string &type)
 123 {
 124         auto it = lower_bound(events.begin(), events.end(), t,
 125                 [](const Event &e, uint64_t t) { return e.t < t; });
 126         unsigned pos = distance(events.begin(), it);
 127         beginInsertRows(QModelIndex(), pos, pos);
 128
 129         Event e;
 130         e.t = t;
 131         e.player_id = player_id;
 132         e.type = type;
 133         events.insert(events.begin() + pos, e);
 134
 135         endInsertRows();
 136
 137         // Insert the new row into the database.
 138         sqlite3_stmt *stmt;
 139         int ret = sqlite3_prepare_v2(db, "INSERT INTO event (t, player, type) VALUES (?, ?, ?)", -1, &stmt, 0);
 140         if (ret != SQLITE_OK) {
 141                 fprintf(stderr, "INSERT prepare: %s\n", sqlite3_errmsg(db));
 142                 abort();
 143         }
 144
 145         sqlite3_bind_int64(stmt, 1, t);
 146         if (player_id) {
 147                 sqlite3_bind_int64(stmt, 2, *player_id);
 148         } else {
 149                 sqlite3_bind_null(stmt, 2);
 150         }
 151         sqlite3_bind_text(stmt, 3, type.data(), type.size(), SQLITE_STATIC);
 152
 153         ret = sqlite3_step(stmt);
 154         if (ret == SQLITE_ROW) {
 155                 fprintf(stderr, "INSERT step: %s\n", sqlite3_errmsg(db));
 156                 abort();
 157         }
 158
 159         ret = sqlite3_finalize(stmt);
 160         if (ret != SQLITE_OK) {
 161                 fprintf(stderr, "INSERT finalize: %s\n", sqlite3_errmsg(db));
 162                 abort();
 163         }
 164
 165         events[pos].event_id = sqlite3_last_insert_rowid(db);
 166         return pos;
 167 }
 168
 169 void EventsModel::delete_event(unsigned pos)
 170 {
 171         int event_id = events[pos].event_id;
 172
 173         beginRemoveRows(QModelIndex(), pos, pos);
 174         events.erase(events.begin() + pos);
 175         endRemoveRows();
 176
 177         // Delete the row from the database.
 178         sqlite3_stmt *stmt;
 179         int ret = sqlite3_prepare_v2(db, "DELETE FROM event WHERE event=?", -1, &stmt, 0);
 180         if (ret != SQLITE_OK) {
 181                 fprintf(stderr, "DELETE prepare: %s\n", sqlite3_errmsg(db));
 182                 abort();
 183         }
 184
 185         sqlite3_bind_int64(stmt, 1, event_id);
 186
 187         ret = sqlite3_step(stmt);
 188         if (ret == SQLITE_ROW) {
 189                 fprintf(stderr, "DELETE step: %s\n", sqlite3_errmsg(db));
 190                 abort();
 191         }
 192
 193         ret = sqlite3_finalize(stmt);
 194         if (ret != SQLITE_OK) {
 195                 fprintf(stderr, "DELETE finalize: %s\n", sqlite3_errmsg(db));
 196                 abort();
 197         }
 198 }
 199
 200 void EventsModel::set_event_type(unsigned pos, const string &type)
 201 {
 202         events[pos].type = type;
 203         emit dataChanged(createIndex(pos, 0), createIndex(pos, 2));
 204
 205         sqlite3_stmt *stmt;
 206         int ret = sqlite3_prepare_v2(db, "UPDATE event SET type=? WHERE event=?", -1, &stmt, 0);
 207         if (ret != SQLITE_OK) {
 208                 fprintf(stderr, "INSERT prepare: %s\n", sqlite3_errmsg(db));
 209                 abort();
 210         }
 211
 212         sqlite3_bind_text(stmt, 1, type.data(), type.size(), SQLITE_STATIC);
 213         sqlite3_bind_int64(stmt, 2, events[pos].event_id);
 214
 215         ret = sqlite3_step(stmt);
 216         if (ret == SQLITE_ROW) {
 217                 fprintf(stderr, "UPDATE step: %s\n", sqlite3_errmsg(db));
 218                 abort();
 219         }
 220
 221         ret = sqlite3_finalize(stmt);
 222         if (ret != SQLITE_OK) {
 223                 fprintf(stderr, "UPDATE finalize: %s\n", sqlite3_errmsg(db));
 224                 abort();
 225         }
 226 }
 227
 228 EventsModel::Status EventsModel::get_status_at(uint64_t t)
 229 {
 230         Status s;
 231         s.our_score = 0;
 232         s.their_score = 0;
 233         s.offense = true;
 234         s.stoppage = false;
 235         s.should_pull = true;
 236         uint64_t last_gained_possession = 0;
 237         uint64_t last_stoppage = 0;
 238         uint64_t time_spent_in_stoppage = 0;
 239         unsigned num_touches = 0;
 240         for (const Event &e : events) {
 241                 if (e.t > t) {
 242                         break;
 243                 }
 244
 245                 if (e.type == "goal" || e.type == "their_goal") {
 246                         s.should_pull = true;
 247                 } else if (e.type == "in" || e.type == "out" || e.type == "stoppage" || e.type == "restart" || e.type == "unknown") {
 248                         // No effect on pull status.
 249                 } else {
 250                         s.should_pull = false;
 251                 }
 252
 253                 if (e.type == "goal") {
 254                         ++s.our_score;
 255                         s.offense = false;
 256                         num_touches = 0;
 257                 }
 258                 if (e.type == "their_goal") {
 259                         ++s.their_score;
 260                         s.offense = true;
 261                         num_touches = 0;
 262                 }
 263                 if (e.type == "catch") {
 264                         if (num_touches == 0) {  // Pick up.
 265                                 last_gained_possession = e.t;
 266                                 time_spent_in_stoppage = 0;
 267                         }
 268                         ++num_touches;
 269                 }
 270                 if (e.type == "interception") {
 271                         num_touches = 1;
 272                         s.offense = true;
 273                         last_gained_possession = e.t;
 274                         time_spent_in_stoppage = 0;
 275                 }
 276                 if (e.type == "defense" || e.type == "their_throwaway") {
 277                         s.offense = true;
 278                         num_touches = 0;
 279                         time_spent_in_stoppage = 0;
 280                 }
 281                 if (e.type == "drop" || e.type == "throwaway") {
 282                         s.offense = false;
 283                         num_touches = 0;
 284                 }
 285                 if (e.type == "stoppage") {
 286                         s.stoppage = true;
 287                         last_stoppage = e.t;
 288                 }
 289                 if (e.type == "restart") {
 290                         s.stoppage = false;
 291                         if (last_stoppage != 0) {
 292                                 time_spent_in_stoppage += (e.t - last_stoppage);
 293                                 last_stoppage = 0;
 294                         }
 295                 }
 296         }
 297         if (s.stoppage && last_stoppage != 0) {
 298                 time_spent_in_stoppage += (t - last_stoppage);
 299         }
 300
 301         s.num_passes = (num_touches == 0) ? 0 : num_touches - 1;
 302         s.possession_sec = (s.offense && last_gained_possession != 0 && num_touches != 0) ? (t - last_gained_possession - time_spent_in_stoppage) / 1000 : 0;
 303         s.stoppage_sec = (s.offense && last_gained_possession != 0 && num_touches != 0) ? time_spent_in_stoppage / 1000 : 0;
 304         return s;
 305 }
 306
 307 set<int> EventsModel::get_team_at(uint64_t t)
 308 {
 309         set<int> team;
 310         for (const Event &e : events) {
 311                 if (e.t > t) {
 312                         break;
 313                 }
 314                 if (e.type == "in") {
 315                         team.insert(*e.player_id);
 316                 }
 317                 if (e.type == "out") {
 318                         team.erase(*e.player_id);
 319                 }
 320         }
 321         return team;
 322 }
 323
 324 void EventsModel::set_team_at(uint64_t t, const set<int> &new_team)
 325 {
 326         // Backdate to the last goal or stoppage, _or_ the last time someone
 327         // going out is mentioned. (We don't really track injuries yet;
 328         // do we want an explicit injury type? If we had one, it would probably
 329         // be the simplest.)
 330         uint64_t backdate_point = 0;
 331         for (const Event &e : events) {
 332                 if (e.t > t) {
 333                         break;
 334                 }
 335                 if (e.type == "goal" || e.type == "their_goal" || e.type == "stoppage" || e.type == "reset") {
 336                         backdate_point = e.t + 1;
 337                 }
 338                 if (e.player_id.has_value() && !new_team.count(*e.player_id)) {
 339                         backdate_point = e.t + 1;
 340                 }
 341         }
 342
 343         // Delete all in/outs already at the backdate point.
 344         for (unsigned i = 0; i < events.size(); ) {
 345                 if (events[i].t > backdate_point) {
 346                         break;
 347                 }
 348                 if (events[i].t == backdate_point && (events[i].type == "in" || events[i].type == "out")) {
 349                         delete_event(i);
 350                 } else {
 351                         ++i;
 352                 }
 353         }
 354
 355         // Finally make the subs we need.
 356         set<int> old_team = get_team_at(backdate_point);
 357         for (int player_id : old_team) {
 358                 if (!new_team.count(player_id)) {
 359                         insert_event(backdate_point, player_id, "out");
 360                 }
 361         }
 362         for (int player_id : new_team) {
 363                 if (!old_team.count(player_id)) {
 364                         insert_event(backdate_point, player_id, "in");
 365                 }
 366         }
 367 }