X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=events.cpp;h=cc7a909cb90f7627e219dbbdd90dfcffaee46a0b;hb=eacc9e44fb6c07405ca07080deaa23bb89c99b00;hp=5752d82ca4fb5c8d7cfed40ec705e1d17f698258;hpb=a53c2f1a04693bf3085b777bc622623a02a64095;p=pkanalytics

diff --git a/events.cpp b/events.cpp
index 5752d82..cc7a909 100644
--- a/events.cpp
+++ b/events.cpp
@@ -10,6 +10,134 @@ using namespace std;
 
 string format_timestamp(uint64_t pos);
 
+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::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::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::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::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();
+}
+
 QVariant EventsModel::headerData(int section, Qt::Orientation orientation, int role) const
 {
 	if (role != Qt::DisplayRole) {
@@ -19,7 +147,7 @@ QVariant EventsModel::headerData(int section, Qt::Orientation orientation, int r
 		if (section == 0) {
 			return "Time";
 		} else if (section == 1) {
-			return "Player";
+			return "Who/what";
 		} else {
 			return "Type";
 		}
@@ -33,40 +161,69 @@ QVariant EventsModel::data(const QModelIndex &index, int role) const
 	if (role != Qt::DisplayRole) {
 		return QVariant();
 	}
-	refresh_if_needed();
+	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) {
-			const Player &p = players[*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();
 }
 
-void EventsModel::refresh_if_needed() const
+void EventsModel::load_data()
 {
-	if (!stale) {
-		return;
-	}
-
 	players.clear();
 	events.clear();
-	stale = false;
 
-	// 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) {
@@ -75,6 +232,33 @@ void EventsModel::refresh_if_needed() const
 			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 {
@@ -89,19 +273,25 @@ void EventsModel::refresh_if_needed() const
 	}
 
 	// 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) {
 			Event e;
 			e.event_id = sqlite3_column_int(stmt, 0);
 			e.t = sqlite3_column_int(stmt, 1);
-			e.player_id = sqlite3_column_int(stmt, 2);
-			e.type = (const char *)sqlite3_column_text(stmt, 3);
+			if (sqlite3_column_type(stmt, 2) == SQLITE_INTEGER) {  // Non-NULL.
+				e.player_id = sqlite3_column_int(stmt, 2);
+			}
+			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;
@@ -115,12 +305,9 @@ void EventsModel::refresh_if_needed() const
 		fprintf(stderr, "SELECT finalize: %s\n", sqlite3_errmsg(db));
 		abort();
 	}
-
-	// TODO what if data changes externally?
-	//emit dataChanged(QModelIndex(
 }
 
-unsigned EventsModel::insert_event(uint64_t t, int player_id)
+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; });
@@ -130,22 +317,33 @@ unsigned EventsModel::insert_event(uint64_t t, int player_id)
 	Event e;
 	e.t = t;
 	e.player_id = player_id;
-	e.type = "unknown";
+	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, 2, player_id);
-	sqlite3_bind_text(stmt, 3, e.type.data(), e.type.size(), SQLITE_STATIC);
+	sqlite3_bind_int64(stmt, 1, match_id);
+	sqlite3_bind_int64(stmt, 2, t);
+	if (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, 4);
+	}
+	sqlite3_bind_text(stmt, 5, type.data(), type.size(), SQLITE_STATIC);
 
 	ret = sqlite3_step(stmt);
 	if (ret == SQLITE_ROW) {
@@ -196,7 +394,7 @@ void EventsModel::delete_event(unsigned pos)
 
 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;
@@ -222,41 +420,256 @@ void EventsModel::set_event_type(unsigned pos, const string &type)
 	}
 }
 
+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.offense = true;
+	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 == "goal") {
+
+		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;
-			s.offense = false;
+			set_defense();
 			num_touches = 0;
 		}
-		if (e.type == "their_goal") {
+		if (e.type == EventType::THEIR_GOAL) {
 			++s.their_score;
-			s.offense = true;
+			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;
 		}
-		if (e.type == "interception") {
+		if (e.type == EventType::INTERCEPTION) {
 			num_touches = 1;
-			s.offense = true;
+			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.offense && last_gained_possession != 0) ? (t - last_gained_possession) / 1000 : 0;
+	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;
+}