Boston Advantage 2014 Select 1 Game Tracker

Boston Advantage 2014 Select 1 — Game Tracker
https://unpkg.com/react@18/umd/react.production.min.js
https://unpkg.com/react-dom@18/umd/react-dom.production.min.js
https://unpkg.com/@babel/standalone/babel.min.js
https://cdn.tailwindcss.com

function App() {
const TEAM_STATS = [
“Goal Against”,
“BA Shot on Goal”,
“Opponent Shot on Goal”,
“Positive/Aggressive Play”,
“Selfish Play/Turnover”,
“BA Blocked Shot”,
“Opponent Blocked Shot”,
“Smart Pass/Headman Play”,
“Overhandle/Late Decision”
];

const PENALTY_SEVERITIES = [
{ key: “Dumb”, label: “Dumb Penalty”, color: “red” },
{ key: “Mistake”, label: “Mistake Penalty”, color: “yellow” },
{ key: “Standard”, label: “Standard Penalty”, color: “green” }
];

const defaultRoster = [
{ number: “1”, name: “Jameson Dzialo”, active: true },
{ number: “8”, name: “Jackson Stevens”, active: true },
{ number: “9”, name: “Rocco Sorrentino”, active: true },
{ number: “11”, name: “Cam McNamara”, active: true },
{ number: “16”, name: “Ethan Hanson”, active: true },
{ number: “17”, name: “Griffin Shearing”, active: true },
{ number: “21”, name: “Cam Thompson”, active: true },
{ number: “22”, name: “Kyle Pavlu”, active: true },
{ number: “33”, name: “Cole McIntosh”, active: true },
{ number: “35”, name: “Nolan Cox”, active: true },
{ number: “37”, name: “Chris Murphy”, active: true },
{ number: “63”, name: “Zac Bosse”, active: true },
{ number: “82”, name: “Liam Larkin”, active: true },
{ number: “86”, name: “Shane Savastano”, active: true },
{ number: “88”, name: “Ryan Matheny”, active: true },
{ number: “93”, name: “Xavier Garrett”, active: true },
{ number: “97”, name: “Joey Pericolo”, active: true }
];

const [screen, setScreen] = React.useState(“tracker”);
const [roster, setRoster] = React.useState(defaultRoster);
const [period, setPeriod] = React.useState(“1”);
const [log, setLog] = React.useState([]);
const [flashMsg, setFlashMsg] = React.useState(“”);
const [playerModal, setPlayerModal] = React.useState(null);
const [syncUrl, setSyncUrl] = React.useState(“”);
const [syncStatus, setSyncStatus] = React.useState(“Not connected”);
const [showNewGameConfirm, setShowNewGameConfirm] = React.useState(false);
const [newGameStep, setNewGameStep] = React.useState(“roster”);
const [gaModalOpen, setGaModalOpen] = React.useState(false);
const [gaOnIce, setGaOnIce] = React.useState([]);
const [gaGoalie, setGaGoalie] = React.useState(null);
const [gameInfo, setGameInfo] = React.useState({ date: new Date().toISOString().slice(0, 10), opponent: “” });
const [newGameDate, setNewGameDate] = React.useState(new Date().toISOString().slice(0, 10));
const [newGameOpponent, setNewGameOpponent] = React.useState(“”);
const [newGameError, setNewGameError] = React.useState(“”);
const [notes, setNotes] = React.useState([]);
const [noteText, setNoteText] = React.useState(“”);
const [noteTimeRemaining, setNoteTimeRemaining] = React.useState(“”);
const [penaltyModalOpen, setPenaltyModalOpen] = React.useState(false);
const [penaltyPlayer, setPenaltyPlayer] = React.useState(null);
const [penaltySeverity, setPenaltySeverity] = React.useState(null);
const [gameHistory, setGameHistory] = React.useState(() => {
try {
const stored = window.localStorage.getItem(“ba_game_history”);
return stored ? JSON.parse(stored) : [];
} catch (e) {
return [];
}
});
const [gameOverModalOpen, setGameOverModalOpen] = React.useState(false);
const [finalScoreBA, setFinalScoreBA] = React.useState(“”);
const [finalScoreOpp, setFinalScoreOpp] = React.useState(“”);
const [gameOverError, setGameOverError] = React.useState(“”);
const [expandedGameId, setExpandedGameId] = React.useState(null);
const [editingGameId, setEditingGameId] = React.useState(null);
const [deleteConfirmGameId, setDeleteConfirmGameId] = React.useState(null);

React.useEffect(() => {
try {
window.localStorage.setItem(“ba_game_history”, JSON.stringify(gameHistory));
} catch (e) {}
}, [gameHistory]);

const GOALIES = [“Nolan Cox”, “Jameson Dzialo”];

const flashRef = React.useRef(null);

function showFlash(msg) {
setFlashMsg(msg);
if (flashRef.current) clearTimeout(flashRef.current);
flashRef.current = setTimeout(() => setFlashMsg(“”), 1200);
}

if (syncUrl.trim()) {
fetch(syncUrl.trim(), {
method: “POST”,
mode: “no-cors”,
headers: { “Content-Type”: “text/plain;charset=utf-8” },
body: JSON.stringify(entry)
})
.then(() => setSyncStatus(“Last event sent to Google Sheets”))
.catch(() => setSyncStatus(“Could not send — check the sync URL”));
}
return gid;
}

function handleTeamStatTap(stat) {
if (stat === “Goal Against”) {
setGaOnIce([]);
setGaGoalie(null);
setGaModalOpen(true);
return;
}
logEvent(null, stat);
}

function toggleOnIce(name) {
setGaOnIce(prev =>
prev.includes(name) ? prev.filter(n => n !== name) : […prev, name]
);
}

function handleGoalAssistTap(stat) {
setPlayerModal(stat);
}

function openPenaltyModal() {
setPenaltyPlayer(null);
setPenaltySeverity(null);
setPenaltyModalOpen(true);
}

function choosePlayer(playerName) {
logEvent(playerName, playerModal);
setPlayerModal(null);
}

function deleteLogEntry(id) {
setLog(prev => prev.filter(e => e.id !== id));
}

function addNote() {
if (!noteText.trim()) {
showFlash(“Enter a note first”);
return;
}
const note = {
id: Date.now() + Math.random(),
time: new Date().toLocaleTimeString(),
timestamp: new Date().toISOString(),
gameDate: gameInfo.date,
opponent: gameInfo.opponent,
period,
timeRemaining: noteTimeRemaining.trim(),
text: noteText.trim()
};
setNotes(prev => [note, …prev]);
setNoteText(“”);
setNoteTimeRemaining(“”);
showFlash(“Note added”);

if (syncUrl.trim()) {
fetch(syncUrl.trim(), {
method: “POST”,
mode: “no-cors”,
headers: { “Content-Type”: “text/plain;charset=utf-8” },
body: JSON.stringify({ action: “note”, …note })
})
.then(() => setSyncStatus(“Note sent to Google Sheets”))
.catch(() => setSyncStatus(“Could not send — check the sync URL”));
}
}

function deleteNote(id) {
setNotes(prev => prev.filter(n => n.id !== id));
}

function startNewGame() {
if (!newGameDate.trim() || !newGameOpponent.trim()) {
setNewGameError(“Please enter both a date and an opponent.”);
return;
}

const completedGame = {
action: “new_game”,
completedAt: new Date().toISOString(),
gameDate: gameInfo.date,
opponent: gameInfo.opponent,
roster: activeRoster,
events: log,
notes: notes
};

if (syncUrl.trim()) {
fetch(syncUrl.trim(), {
method: “POST”,
mode: “no-cors”,
headers: { “Content-Type”: “text/plain;charset=utf-8” },
body: JSON.stringify(completedGame)
})
.then(() => setSyncStatus(“Game summary sent to Google Sheets”))
.catch(() => setSyncStatus(“Could not send summary — check the sync URL”));
}

if (log.length > 0) {
setGameHistory(prev => [
…prev,
{
id: Date.now() + Math.random(),
gameDate: gameInfo.date,
opponent: gameInfo.opponent,
events: log,
notes: notes,
roster: activeRoster,
finalized: false,
baScore: null,
oppScore: null
}
]);
}

setLog([]);
setNotes([]);
setPeriod(“1”);
setFlashMsg(“”);
setShowNewGameConfirm(false);
setNewGameError(“”);
setGameInfo({ date: newGameDate.trim(), opponent: newGameOpponent.trim() });
showFlash(syncUrl.trim() ? “New game started — summary sent” : “New game started”);
}

function openGameOverModal() {
setFinalScoreBA(“”);
setFinalScoreOpp(“”);
setGameOverError(“”);
setGameOverModalOpen(true);
}

function confirmGameOver() {
if (finalScoreBA.trim() === “” || finalScoreOpp.trim() === “”) {
setGameOverError(“Please enter both final scores.”);
return;
}
const baScore = parseInt(finalScoreBA, 10);
const oppScore = parseInt(finalScoreOpp, 10);
if (isNaN(baScore) || isNaN(oppScore) || baScore < 0 || oppScore […prev, finishedGame]);

if (syncUrl.trim()) {
fetch(syncUrl.trim(), {
method: “POST”,
mode: “no-cors”,
headers: { “Content-Type”: “text/plain;charset=utf-8” },
body: JSON.stringify({ action: “game_over”, …finishedGame })
})
.then(() => setSyncStatus(“Final game summary sent to Google Sheets”))
.catch(() => setSyncStatus(“Could not send summary — check the sync URL”));
}

setLog([]);
setNotes([]);
setPeriod(“1”);
setFlashMsg(“”);
setGameOverModalOpen(false);
setGameOverError(“”);
setGameInfo({ date: new Date().toISOString().slice(0, 10), opponent: “” });
showFlash(`Game Over — Final ${baScore}-${oppScore} saved to Game Log`);
}

function deleteGameFromHistory(id) {
setGameHistory(prev => prev.filter(g => g.id !== id));
if (expandedGameId === id) setExpandedGameId(null);
if (editingGameId === id) setEditingGameId(null);
if (deleteConfirmGameId === id) setDeleteConfirmGameId(null);
showFlash(“Game deleted”);
}

function updateGameScoreField(id, field, value) {
setGameHistory(prev =>
prev.map(g => (g.id === id ? { …g, [field]: value === “” ? “” : parseInt(value, 10) || 0 } : g))
);
}

function deleteEventFromGame(gameId, eventId) {
setGameHistory(prev =>
prev.map(g =>
g.id === gameId ? { …g, events: g.events.filter(e => e.id !== eventId) } : g
)
);
}

function toggleExpandGame(id) {
setExpandedGameId(prev => (prev === id ? null : id));
}

function toggleEditGame(id) {
setEditingGameId(prev => (prev === id ? null : id));
}

function updateRosterField(index, field, value) {
setRoster(prev => {
const copy = […prev];
copy[index] = { …copy[index], [field]: value };
return copy;
});
}

function toggleRosterActive(index) {
setRoster(prev => {
const copy = […prev];
copy[index] = { …copy[index], active: copy[index].active === false ? true : false };
return copy;
});
}

const activeRoster = roster.filter(p => p.name && p.name.trim() !== “”);
const availableRoster = activeRoster.filter(p => p.active !== false);

const periods = [“1”, “2”, “3”, “OT”];
const allStats = […TEAM_STATS];

function plusMinusFor(playerName) {
const goals = log.filter(e => e.stat === “Goal” && e.player === playerName).length;
const assists = log.filter(e => e.stat === “Assist” && e.player === playerName).length;
const onIceGA = log.filter(e => e.stat === “On Ice For GA” && e.player === playerName).length;
return { goals, assists, onIceGA, plusMinus: goals + assists – onIceGA };
}

function countFor(stat, per) {
return log.filter(e => e.stat === stat && (per === “Total” || e.period === per)).length;
}

function penaltyCountFor(severityKey, per) {
return countFor(`Penalty (${severityKey})`, per);
}

function penaltiesByPlayer() {
return activeRoster
.map(p => ({
name: p.name,
number: p.number,
dumb: log.filter(e => e.stat === “Penalty (Dumb)” && e.player === p.name).length,
mistake: log.filter(e => e.stat === “Penalty (Mistake)” && e.player === p.name).length,
standard: log.filter(e => e.stat === “Penalty (Standard)” && e.player === p.name).length
}))
.filter(p => p.dumb + p.mistake + p.standard > 0);
}

Player	G	A	GA On-Ice	+/-
{p.number ? `#${p.number} ` : “”} {p.name}	{goals}	{assists}	{onIceGA}	{plusMinus > 0 ? `+${plusMinus}` : plusMinus}
Add players on the Roster tab to see plus/minus.

Penalty Type	P1	P2	P3	OT	Total
{sev.label}	{penaltyCountFor(sev.key, “1”)}	{penaltyCountFor(sev.key, “2”)}	{penaltyCountFor(sev.key, “3”)}	{penaltyCountFor(sev.key, “OT”)}	{penaltyCountFor(sev.key, “Total”)}
Total Penalties	{PENALTY_SEVERITIES.reduce((sum, sev) => sum + penaltyCountFor(sev.key, “1”), 0)}	{PENALTY_SEVERITIES.reduce((sum, sev) => sum + penaltyCountFor(sev.key, “2”), 0)}	{PENALTY_SEVERITIES.reduce((sum, sev) => sum + penaltyCountFor(sev.key, “3”), 0)}	{PENALTY_SEVERITIES.reduce((sum, sev) => sum + penaltyCountFor(sev.key, “OT”), 0)}	{PENALTY_SEVERITIES.reduce((sum, sev) => sum + penaltyCountFor(sev.key, “Total”), 0)}

Player	Dumb	Mistake	Standard	Total
{p.number ? `#${p.number} ` : “”} {p.name}	{p.dumb}	{p.mistake}	{p.standard}	{p.dumb + p.mistake + p.standard}
No penalties logged yet this game.

Penalty Type	Total
{sev.label}	{seasonPenaltyCountFor(sev.key)}
Total Penalties	{PENALTY_SEVERITIES.reduce((sum, sev) => sum + seasonPenaltyCountFor(sev.key), 0)}

Player	G	A	+/-	Pen (D/M/S)
{p.number ? `#${p.number} ` : “”} {p.name}	{p.goals}	{p.assists}	{p.plusMinus > 0 ? `+${p.plusMinus}` : p.plusMinus}	{p.dumb}/{p.mistake}/{p.standard}
No player stats recorded for this game.

{gameInfo.opponent ? `vs ${gameInfo.opponent} · ${gameInfo.date}` : “2014 SELECT 1 · GAME TRACKER”}

{gameInfo.opponent ? `vs ${gameInfo.opponent} · ${gameInfo.date}` : “2014 SELECT 1 · GAME TRACKER”}

{gameInfo.opponent
? `vs ${gameInfo.opponent} · ${gameInfo.date}`
: “2014 SELECT 1 · GAME TRACKER”}

{gameInfo.opponent
? `vs ${gameInfo.opponent} · ${gameInfo.date}`
: “2014 SELECT 1 · GAME TRACKER”}