fork/replay-manager-for-slippi

git clone https://git.julia.blue/fork/replay-manager-for-slippi

Nicoletoffline mode read6d9f344

main
8.6 KiB306 linesraw
1import { useState } from 'react';
2import { Tournament as ParryggTournament } from '@parry-gg/client';
3import SearchBox from './SearchBox';
4import StartggView from './StartggView';
5import {
6  ChallongeTournament,
7  GuideState,
8  Mode,
9  PlayerOverrides,
10  RendererOfflineModeTournament,
11  SelectedEvent,
12  SelectedPhase,
13  SelectedPhaseGroup,
14  SelectedSetChain,
15  Set,
16  Tournament,
17} from '../common/types';
18import ChallongeView from './ChallongeView';
19import ParryggView from './ParryggView';
20import ManualView from './ManualView';
21import ErrorDialog from './ErrorDialog';
22import {
23  assertInteger,
24  assertIntegerOrUndefined,
25  assertString,
26  assertStringOrUndefined,
27} from '../common/asserts';
28import OfflineModeView from './OfflineModeView';
29
30export default function RightColumn({
31  mode,
32  guideState,
33  selectSet,
34  setGuideState,
35  vlerkMode,
36  selectedSetChain,
37  setSelectedSetChain,
38  startggTournament,
39  challongeTournaments,
40  getChallongeTournament,
41  setSelectedChallongeTournament,
42  parryggTournament,
43  offlineModeTournament,
44  manualNames,
45  selectedChipData,
46  setSelectedChipData,
47}: {
48  mode: Mode;
49  guideState: GuideState;
50  selectSet: (set: Set) => void;
51  setGuideState: (guideState: GuideState) => void;
52  vlerkMode: boolean;
53  selectedSetChain: SelectedSetChain;
54  setSelectedSetChain: (selectedSetChain: SelectedSetChain) => void;
55  startggTournament: Tournament;
56  challongeTournaments: Map<string, ChallongeTournament>;
57  getChallongeTournament: (maybeSlug: string) => Promise<void>;
58  setSelectedChallongeTournament: (selectedChallongeTournament: {
59    name: string;
60    slug: string;
61    tournamentType: string;
62  }) => void;
63  parryggTournament: ParryggTournament.AsObject | undefined;
64  offlineModeTournament: RendererOfflineModeTournament;
65  manualNames: string[];
66  selectedChipData: PlayerOverrides;
67  setSelectedChipData: (selectedChipData: PlayerOverrides) => void;
68}) {
69  const [searchSubstr, setSearchSubstr] = useState('');
70  const [error, setError] = useState('');
71  const [errorOpen, setErrorOpen] = useState(false);
72
73  // start.gg tournament view
74  const getPhaseGroup = async (id: number) => {
75    try {
76      await window.electron.getPhaseGroup(id);
77    } catch (e: any) {
78      setError(e.toString());
79      setErrorOpen(true);
80    }
81  };
82  const getPhase = async (id: number) => {
83    try {
84      await window.electron.getPhase(id);
85    } catch (e: any) {
86      setError(e.toString());
87      setErrorOpen(true);
88    }
89  };
90
91  const getEvent = async (id: number) => {
92    try {
93      await window.electron.getEvent(id);
94    } catch (e: any) {
95      setError(e.toString());
96      setErrorOpen(true);
97    }
98  };
99
100  const getParryggBracket = async (id: string) => {
101    try {
102      await window.electron.getParryggBracket(id);
103    } catch (e: any) {
104      setError(e.toString());
105      setErrorOpen(true);
106    }
107  };
108
109  const getParryggPhase = async (id: string) => {
110    try {
111      await window.electron.getParryggPhase(id);
112    } catch (e: any) {
113      setError(e.toString());
114      setErrorOpen(true);
115    }
116  };
117
118  const getParryggEvent = async (id: string) => {
119    try {
120      await window.electron.getParryggEvent(id);
121    } catch (e: any) {
122      setError(e.toString());
123      setErrorOpen(true);
124    }
125  };
126
127  const selectStartggSet = async (
128    set: Set,
129    phaseGroup: SelectedPhaseGroup,
130    phase: SelectedPhase,
131    event: SelectedEvent,
132  ) => {
133    selectSet(set);
134    setSelectedSetChain({
135      event,
136      phase,
137      phaseGroup,
138    });
139    await window.electron.setSelectedSetChain(
140      assertInteger(event.id),
141      assertInteger(phase.id),
142      assertInteger(phaseGroup.id),
143    );
144  };
145  const selectChallongeSet = async (
146    set: Set,
147    selectedTournament: ChallongeTournament,
148  ) => {
149    selectSet(set);
150    setSelectedChallongeTournament({
151      name: selectedTournament.name,
152      slug: selectedTournament.slug,
153      tournamentType: selectedTournament.tournamentType,
154    });
155    await window.electron.setSelectedChallongeTournament(
156      selectedTournament.slug,
157    );
158  };
159  const selectParryggSet = async (
160    set: Set,
161    phaseGroup: SelectedPhaseGroup,
162    phase: SelectedPhase,
163    event: SelectedEvent,
164  ) => {
165    selectSet(set);
166    setSelectedSetChain({ event, phase, phaseGroup });
167    await window.electron.setSelectedSetChain(
168      assertString(event.id),
169      assertString(phase.id),
170      assertString(phaseGroup.id),
171    );
172  };
173  const selectOfflineModeSet = async (
174    set: Set,
175    phaseGroup: SelectedPhaseGroup,
176    phase: SelectedPhase,
177    event: SelectedEvent,
178  ) => {
179    selectSet(set);
180    setSelectedSetChain({ event, phase, phaseGroup });
181    await window.electron.setSelectedSetChain(
182      event.id,
183      phase.id,
184      phaseGroup.id,
185    );
186  };
187
188  return (
189    <>
190      <SearchBox
191        mode={mode}
192        searchSubstr={searchSubstr}
193        setSearchSubstr={setSearchSubstr}
194        vlerkMode={vlerkMode}
195      />
196      {mode === Mode.STARTGG && (
197        <StartggView
198          searchSubstr={searchSubstr}
199          tournament={startggTournament}
200          vlerkMode={vlerkMode}
201          selectedEventId={assertIntegerOrUndefined(selectedSetChain.event?.id)}
202          selectedPhaseId={assertIntegerOrUndefined(selectedSetChain.phase?.id)}
203          selectedPhaseGroupId={assertIntegerOrUndefined(
204            selectedSetChain.phaseGroup?.id,
205          )}
206          getEvent={(id: number) => getEvent(id)}
207          getPhase={(id: number) => getPhase(id)}
208          getPhaseGroup={getPhaseGroup}
209          selectSet={async (
210            set: Set,
211            phaseGroup: SelectedPhaseGroup,
212            phase: SelectedPhase,
213            event: SelectedEvent,
214          ) => {
215            await selectStartggSet(set, phaseGroup, phase, event);
216            if (guideState !== GuideState.NONE) {
217              setGuideState(GuideState.REPLAYS);
218            }
219          }}
220        />
221      )}
222      {mode === Mode.CHALLONGE &&
223        Array.from(challongeTournaments.values()).map((challongeTournament) => (
224          <ChallongeView
225            key={challongeTournament.slug}
226            searchSubstr={searchSubstr}
227            tournament={challongeTournament}
228            getChallongeTournament={() =>
229              getChallongeTournament(challongeTournament.slug)
230            }
231            selectSet={(set: Set) => {
232              selectChallongeSet(set, challongeTournament);
233              if (guideState !== GuideState.NONE) {
234                setGuideState(GuideState.REPLAYS);
235              }
236            }}
237          />
238        ))}
239      {mode === Mode.PARRYGG && (
240        <ParryggView
241          searchSubstr={searchSubstr}
242          tournament={parryggTournament}
243          vlerkMode={vlerkMode}
244          selectedEventId={assertStringOrUndefined(selectedSetChain?.event?.id)}
245          selectedPhaseId={assertStringOrUndefined(selectedSetChain?.phase?.id)}
246          selectedBracketId={assertStringOrUndefined(
247            selectedSetChain?.phaseGroup?.id,
248          )}
249          getEvent={getParryggEvent}
250          getPhase={getParryggPhase}
251          getBracket={getParryggBracket}
252          selectSet={async (
253            set: Set,
254            bracket: SelectedPhaseGroup,
255            phase: SelectedPhase,
256            event: SelectedEvent,
257          ) => {
258            await selectParryggSet(set, bracket, phase, event);
259            if (guideState !== GuideState.NONE) {
260              setGuideState(GuideState.REPLAYS);
261            }
262          }}
263        />
264      )}
265      {mode === Mode.OFFLINE_MODE && (
266        <OfflineModeView
267          searchSubstr={searchSubstr}
268          offlineModeTournament={offlineModeTournament}
269          vlerkMode={vlerkMode}
270          selectedEventId={assertIntegerOrUndefined(selectedSetChain.event?.id)}
271          selectedPhaseId={assertIntegerOrUndefined(selectedSetChain.phase?.id)}
272          selectedPhaseGroupId={assertIntegerOrUndefined(
273            selectedSetChain.phaseGroup?.id,
274          )}
275          selectSet={async (
276            set: Set,
277            phaseGroup: SelectedPhaseGroup,
278            phase: SelectedPhase,
279            event: SelectedEvent,
280          ) => {
281            await selectOfflineModeSet(set, phaseGroup, phase, event);
282            if (guideState !== GuideState.NONE) {
283              setGuideState(GuideState.REPLAYS);
284            }
285          }}
286        />
287      )}
288      {mode === Mode.MANUAL && (
289        <ManualView
290          manualNames={manualNames}
291          searchSubstr={searchSubstr}
292          selectedChipData={selectedChipData}
293          setSelectedChipData={setSelectedChipData}
294        />
295      )}
296      <ErrorDialog
297        messages={[error]}
298        onClose={() => {
299          setError('');
300          setErrorOpen(false);
301        }}
302        open={errorOpen}
303      />
304    </>
305  );
306}