-
Notifications
You must be signed in to change notification settings - Fork 11
/
Copy pathtourney-guide.txt
171 lines (154 loc) · 9.04 KB
/
tourney-guide.txt
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
This document is a checklist of all the steps involved in organizing and
running a tournament. The README file should be consulted for the actual
technical details of how to run the scripts.
NOTE: In examples in this document, we use 0.20 as the tournament release
version and 0.19 as the previous tournament release version. CSZO is the server
where the tournament database and scripts are running.
Notes on CSZO and the dcss_tourney repository:
* As of 0.20, CSZO is the server from where the tournament is
run and a shared login is used by everyone working on the tournament. The
README has details on what's needed to support the scripts should they need to
be run on another server.
* Contact |amethyst or a previous tournament organizer (gammafunk for 0.20) if
you need tournament login access.
* The public tourney repo is https://github.com/crawl/dcss_tourney/ and should
be kept up to date so that any contributers can collaborate.
* The tournaments scripts are run on CSZO through a local checkout of that repo
in ~/dcss_tourney, and this directory is the 'live' directory for generating
the tournament pages and database.
* A git branch is made for each tournament using the branch name format e.g.
"0.20-tourney". The master branch can be kept up to date with any necessary
commits merged, but when making a new tournament branch, always check that it
has the necessary commits from the previous tournament and see if there are any
unpushed changes/commits on the CSZO checkout.
* Commits can be made in ~/dcss_tourney and pushed to the github repo, but note
that the commit author will be "Crawl Tournament Organizers". You can set the
name and email to your details using `git config' while the tournament is
running. Please remember to set it back to the generic info after the
tournament so that commits made by others using the tourney login don't have
your author info.
Organizing a new tourney:
* Choose/announce dates for the tournament (usually 16 days long, including 3
weekends)
* Tell greensnark the dates (including exact times of day) so that Sequell
will know about the tourney and !time will count down to it
- You can commit a change to the sequell repo with the tournament change and
it will automatically be loaded by the Sequell server, see this commit:
https://github.com/crawl/sequell/commit/d1bcea9ec5787328fb8cf67645778f62dc22ca1d
* Decide on rules changes (usually there are at least a couple of new banners)
* Update templates/index.mako with the rules changes
* Announce tourney again, with link to the rules page
Cleaning up after the previous tourney:
* Commit the final nemelex-combos.txt file with the nchoices as
nemelex-combos-v19.txt
* Make any final commits relevant to the 0.19 tournament in the 0.19-tourney
branch (e.g. in ~/dcss_tourney on CSZO) and push these to the github repo.
* On CSZO: replace the symlink html.tourney0.19/images -> images with a
physical copy of the images (this is so that future image changes don't
affect past tourney pages)
* On CSZO: rename the rcfiles-cao/, rcfiles-cdo/, ... directories to
0.19rcfiles-cao/, 0.19rcfiles-cdo, .. (so that team composition isn't lost)
- This wasn't done for older tourneys, unfortunately
Updating the scripts:
* NOTE: These changes can be made in the ~/dcss_tourney repo on CSZO, but make
sure to set the new version before running the scripts to avoid overwriting
old tournament data. It's generally better if you can make these updates
first from a local checkout and test them locally.
* Make a new 0.20-tourney git branch in the dcss_tourney repo. It's probably
best to do this starting from a checkout of 0.19-tourney, but master can
be used if it has any necessary commits from the previous tourney merged.
* Change version everywhere
- Be sure to do this before running the scripts on CSZO so that you don't
overwrite stuff in the old html.tourney0.19 directory
* Change dates everywhere, including clan deadline and last_win deadline
- Set the clan deadline to one hour after the actual clan deadline, since the final
RC fetch will be done at the deadline (see CSZO setup below), and any
fetching will take a few minutes.
* Update list of servers everywhere
* Update banner images (CanOfWorms is making these currently)
- You always need a new banner_footer1.png with the new version number at
least
- The file bannerfactory.svg might be helpful for making the banners
* Banner text changes need to be mirrored in html.py
* Update list of uniques in uniq.py
* Update list of gods in crawl.py
* Update species/background/god win scoring based on the current number of each
- See race_formula(), class_formula(), god_formula() in query.py as well as
the rules page itself
* Update combos.txt (list of currently playable combos)
- Run crawl -playable-json to get this data. The "combos" key has the full
set of playable combos.
- This data must be modified to fit the combos.txt format, which is one combo
per line.
* Update nem_eligible.txt
- Use the !nwon command to do this with using the smallest win cutoff that
gives at least 110 combos, excluding nem choices from the previous
tournament and any species/classes enabled in trunk that aren't in 0.20
- Example Sequell command for 0.20 with a cutoff of 23 wins:
!nwon 23 !nchoice-0.19 !gn
- Should do this again within a day of tourney start to make sure it is up
to date
* Implement any new banners or other rules changes!
CSZO setup:
* Create rcfiles-cao/, rcfiles-cdo/, ... directories for every other server
* Add/uncomment the cronjobs that mirror rcfiles from other servers.
- In the entry for each server, there should be an hour/time that RCs are
fetched that falls on the same hour as the clan deadline. This is so any RC
file changes that happen before the deadline will be fetched properly.
- Keep in mind that CSZO uses CDT when making these crontab entries.
- See the crontab comments about which entries to use for CAO and CDO.
* Two lines need to be commented/uncommented in LOGS and MILESTONES in
loaddb.py to handle local logs/milestones correctly
* While testing tourney scripts on CSZO, make sure that the rules page doesn't
have links at the top to the scoring pages so that fewer people are confused
by the testing
- This will automatically happen if you create the rules page (with
update_index.py) while USE_TEST = true (in test_data.py)
* When you are done testing, delete all the player and clan pages in
html.tourney0.20/players/ and html.tourney0.20/clans/
During tourney:
* Add names of players to BAD_NAMERS in teams.py if they choose offensive
clan names. This sets their team name to the default team name
"Team player_name"
* Comment out/remove the cronjobs that mirror rcfiles from other servers once
the clan deadline is past
- should also make a copy of CSZO's rcfile directory at that time, to have
a fixed copy of it in case you have to rerun the scripts later
* Some players might have incorrect capitalization for their name at the
start of the tourney. You can recreate the database a few days into the
tournament to fix this.
- Recreating the database after several days of tournament games can take 3-5
hours, so it's wise to start this shortly after a new nemelex choice combo
has been chosen. While the database is processing, no tournament updates will
happen, including nem choice.
- First, kill the taildb.py process, then run the database recreation command
in the README to wipe the database and recreate all tables.
- Start taildb.py again. It will refetch the full logfiles/milestones from
all servers and begin processing.
* If you make any fixes to the tournament scripts during the tournament, test
rerunning the scoring scripts locally first before rerunning
them on CSZO, to make sure you aren't somehow losing data
* To block a player from the tournament:
You need to (1) add them to the player blocklist file to prevent further data
processing for their games, (2) remove their existing data from the database,
and (3) remove their existing player and clan pages.
- First, kill taildb.py if it's running.
- Add their name as a line in the file player_blocklist.txt, creating this
file if it doesn't exist. Case doesn't matter.
- Run the script blocklist-player-db.sh with the player's name as an
argument:
./blocklist-player-db.sh iamabadplayer
Case doesn't matter.
Note that this step is irreversible in that if you accidentally remove data
for the wrong player or need to remove them from the blocklist later, the
database will need to be recreated and reprocessed from scratch. This can
take a long time once the tournament is underway.
- Remove their clan page and player page from the html directory. You do not
need to remove or modify their fetched RC file since the entry
player_blocklist.txt will cause the scripts to ignore their clan
definitions and memberships.
- Restart taildb.py
At end of tourney:
* Kill taildb.py (make sure scripts have fully updated with the final results
first)
* Write results summary and post on CDO