Add milestone table, unify game and milestone db inserts, set up points for games worshipping different gods.

git-svn-id: svn+ssh://crawl.akrasiac.org/usr/local/crawlsvn@174 42476179-f906-4ffd-81fe-f88aabc8fb63

Author: crawl

.gitignore

@@ -1,3 +1,4 @@
+TAGS
 *.swp
 *.pyc
 cao-*

TODO09

@@ -1,26 +1,35 @@
-Test code on 0.4 logfile (so we have lots of games)
-Rewire scripts to use 0.5 logfile once everything's tested and ok.
+Legend: ] done + tested
+        * done, not tested
+
+- Add new scoring rules.
+- New milestones for Crawl:
+   god.worship <- Worshipping a new god
+   god.renounce <- Renouncing an existing god.
+- Update list of uniques.
+- Update list of combos.
+- Test code on 0.4 logfile (so we have lots of games)
+- Rewire scripts to use 0.5 logfile once everything's tested and ok.
 
 Trophies for 2009:
 
 WINS:
 ----
-100 points for first win. (Since winning is kind of the goal.)
-50 points for second win that is not a repeat race or class.
-10 points for each win thereafter, repeat or not.
-50 extra points for your first all-rune victory.
-100 extra points for each consecutive win that is not a repeat race or class.
-30 extra points for each consecutive win that is a repeat race xor class.
-10 extra points for each consecutive win that is a repeat race and class.
-30 extra points for each non-consecutive win that is not a repeat race or
+]100 points for first win. (Since winning is kind of the goal.)
+]50 points for second win that is not a repeat race or class.
+]10 points for each win thereafter, repeat or not.
+]50 extra points for your first all-rune victory.
+]100 extra points for each consecutive win that is not a repeat race or class.
+]30 extra points for each consecutive win that is a repeat race xor class.
+]10 extra points for each consecutive win that is a repeat race and class.
+]30 extra points for each non-consecutive win that is not a repeat race or
  class.
-10 extra points for each non-consecutive win that is a repeat race xor class.
+]10 extra points for each non-consecutive win that is a repeat race xor class.
 
-20 extra points for each win with a new god (including "No God"). This does
-not apply if you changed gods during the game.
+*20 extra points for each win with a new god (including "No God").
+ This does not apply if you changed gods during the game.
 
-For streak wins, "Repeat" means "in that streak;" for non-streak wins,
-"repeat" means "ever."
+(For streak wins, "Repeat" means "in that streak;" for non-streak
+wins, "repeat" means "ever.")
 
 SPECIAL WINS
 ------------

database.sql

@@ -1,4 +1,5 @@
 DROP TABLE IF EXISTS players;
+DROP TABLE IF EXISTS milestones;
 DROP TABLE IF EXISTS teams;
 DROP TABLE IF EXISTS milestone_bookmark;
 DROP TABLE IF EXISTS games;
@@ -56,6 +57,8 @@ CREATE TABLE teams (
 
 -- For mappings of logfile fields to columns, see loaddb.py
 CREATE TABLE games (
+  id BIGINT AUTO_INCREMENT,
+  
   -- Source logfile
   source_file VARCHAR(150),
   -- Offset in the source file.
@@ -84,7 +87,7 @@ CREATE TABLE games (
   maxhp INT,
   maxmaxhp INT,
   strength INT,
-  intellegence INT,
+  intelligence INT,
   dexterity INT,
   god CHAR(20),
   duration INT,
@@ -102,9 +105,11 @@ CREATE TABLE games (
   verb_msg VARCHAR(255),
   nrune INT DEFAULT 0,
 
-  CONSTRAINT PRIMARY KEY (source_file, source_file_offset)
+  CONSTRAINT PRIMARY KEY (id)
   );
 
+CREATE INDEX games_source_offset ON games (source_file, source_file_offset);
+
 CREATE INDEX games_kgrp ON games (kgroup);
 CREATE INDEX games_ktyp ON games (killertype);
 CREATE INDEX games_p_ktyp ON games (player, killertype);
@@ -115,6 +120,63 @@ CREATE INDEX games_win_dur ON games (killertype, duration);
 -- Index to help us find fastest wins (turncount) quick.
 CREATE INDEX games_win_turn ON games (killertype, turn);
 
+CREATE TABLE milestones (
+  id BIGINT AUTO_INCREMENT PRIMARY KEY,
+  -- Source milestone file
+  source_file VARCHAR(150),
+
+  -- The actual game that this milestone is linked with.
+  game_id BIGINT,
+
+  version VARCHAR(10),
+  cv VARCHAR(10),
+  player VARCHAR(20),
+  race VARCHAR(20),
+  raceabbr CHAR(2) NOT NULL,
+  class VARCHAR(20),
+  charabbrev CHAR(4),
+  xl INT,
+  skill VARCHAR(16),
+  sk_lev INT,
+  title VARCHAR(50),
+  place VARCHAR(16),
+
+  branch VARCHAR(16),
+  lvl INT,
+  ltyp VARCHAR(16),
+  hp INT,
+  maxhp INT,
+  maxmaxhp INT,
+  strength INT,
+  intelligence INT,
+  dexterity INT,
+  god VARCHAR(50),
+  duration BIGINT,
+  turn BIGINT,
+  runes INT,
+  nrune INT,
+
+  -- Game start time.
+  start_time DATETIME,
+
+  -- Milestone time.
+  milestone_time DATETIME,
+
+  -- Known milestones: abyss.enter, abyss.exit, rune, orb, ghost, uniq,
+  -- uniq.ban, br.enter, br.end.
+  verb VARCHAR(20),
+  noun VARCHAR(100),
+
+  -- The actual milestone message.
+  milestone VARCHAR(255),
+
+  FOREIGN KEY (game_id) REFERENCES games (id)
+  ON DELETE SET NULL
+);
+
+-- To find milestones belonging to a particular game.
+CREATE INDEX milestone_lookup_by_time ON milestones (player, start_time, verb);
+
 -- A table to keep track of the last milestone we've processed. This
 -- will have only one row for one filename.
 CREATE TABLE milestone_bookmark (

loaddb.py

@@ -192,9 +192,6 @@ def line(self, cursor):
         self.offset = newoffset
       else:
         xdict = apply_dbtypes( xlog_dict(line) )
-        if xdict.get('time'):
-          xdict['time'] = datetime.to_sql(xdict['time'])
-
         xline = Xlogline( self, self.filename, self.offset,
                           xdict.get('end') or xdict.get('time'),
                           xdict, self.proc_op )
@@ -291,6 +288,28 @@ def xlog_set_killer_group(d):
 
   d['kgroup'] = killer
 
+def xlog_milestone_fixup(d):
+  for field in [x for x in ['lv', 'uid'] if d.has_key(x)]:
+    del d[field]
+  verb = d['type']
+  milestone = d['milestone']
+  noun = None
+  if verb == 'uniq':
+    match = R_MILE_UNIQ.findall(milestone)
+    if match[0][0] == 'banished':
+      verb = 'uniq.ban'
+    noun = match[0][1]
+  if verb == 'ghost':
+    match = R_MILE_GHOST.findall(milestone)
+    if match[0][0] == 'banished':
+      verb = 'ghost.ban'
+    noun = match[0][1]
+  if verb == 'rune':
+    noun = R_RUNE.findall(milestone)[0]
+  noun = noun or milestone
+  d['verb'] = verb
+  d['noun'] = noun
+
 def xlog_dict(logline):
   d = parse_logline(logline.strip())
   # Fake a raceabbr field.
@@ -305,6 +324,8 @@ def xlog_dict(logline):
     d['nrune'] = d.get('nrune') or d.get('urune')
     d['urune'] = d.get('urune') or d.get('nrune')
 
+  if d.has_key('milestone'):
+    xlog_milestone_fixup(d)
   xlog_set_killer_group(d)
 
   return d
@@ -332,7 +353,7 @@ def xlog_dict(logline):
     [ 'mhp', 'maxhp' ],
     [ 'mmhp', 'maxmaxhp' ],
     [ 'str', 'strength' ],
-    [ 'int', 'intellegence' ],
+    [ 'int', 'intelligence' ],
     [ 'dex', 'dexterity' ],
     [ 'god', 'god' ],
     [ 'start', 'start_time' ],
@@ -350,13 +371,52 @@ def xlog_dict(logline):
     [ 'vmsg', 'verb_msg' ],
     [ 'kaux', 'kaux' ],
     [ 'nrune', 'nrune' ],
-    [ 'urune', 'runes' ] ]
+    [ 'urune', 'runes' ],
+    ]
+
+MILE_DB_MAPPINGS = [
+    [ 'v', 'version' ],
+    [ 'lv', 'lv' ],
+    [ 'name', 'player' ],
+    [ 'uid', 'uid' ],
+    [ 'race', 'race' ],
+    [ 'raceabbr', 'raceabbr' ],
+    [ 'cls', 'class' ],
+    [ 'char', 'charabbrev' ],
+    [ 'xl', 'xl' ],
+    [ 'sk', 'skill' ],
+    [ 'sklev', 'sk_lev' ],
+    [ 'title', 'title' ],
+    [ 'place', 'place' ],
+    [ 'br', 'branch' ],
+    [ 'lvl', 'lvl' ],
+    [ 'ltyp', 'ltyp' ],
+    [ 'hp', 'hp' ],
+    [ 'mhp', 'maxhp' ],
+    [ 'mmhp', 'maxmaxhp' ],
+    [ 'str', 'strength' ],
+    [ 'int', 'intelligence' ],
+    [ 'dex', 'dexterity' ],
+    [ 'god', 'god' ],
+    [ 'start', 'start_time' ],
+    [ 'dur', 'duration' ],
+    [ 'turn', 'turn' ],
+    [ 'dam', 'damage' ],
+    [ 'piety', 'piety' ],
+    [ 'nrune', 'nrune' ],
+    [ 'urune', 'runes' ],
+    [ 'time', 'milestone_time' ],
+    ]
 
 LOGLINE_TO_DBFIELD = dict(LOG_DB_MAPPINGS)
+COMBINED_LOG_TO_DB = dict(LOG_DB_MAPPINGS + MILE_DB_MAPPINGS)
+
 R_MONTH_FIX = re.compile(r'^(\d{4})(\d{2})(.*)')
 R_GHOST_NAME = re.compile(r"^(.*)'s? ghost")
 R_MILESTONE_GHOST_NAME = re.compile(r"the ghost of (.*) the ")
 R_KILL_UNIQUE = re.compile(r'^killed (.*)\.$')
+R_MILE_UNIQ = re.compile(r'^\w+ (.*)\.$')
+R_MILE_GHOST = re.compile(r'^\w+ the ghost of (\S+)')
 R_RUNE = re.compile(r"found an? (.*) rune")
 R_HYDRA = re.compile(r'^an? (\w+)-headed hydra')
 
@@ -458,6 +518,7 @@ def count(self, cursor, msg=None, exc=Exception):
 	'piety':sql_int,
         'penitence':sql_int,
 	'end_time':datetime,
+        'milestone_time':datetime,
 	'terse_msg':varchar,
 	'verb_msg':varchar,
         'nrune':sql_int,
@@ -546,33 +607,40 @@ def apply_dbtypes(game):
   (i.e. not in dbfield_to_sqltype) are ignored."""
   new_hash = { }
   for key, value in game.items():
-    if LOGLINE_TO_DBFIELD.has_key(key):
-      new_hash[key] = dbfield_to_sqltype[LOGLINE_TO_DBFIELD[key]].to_sql(value)
+    if (COMBINED_LOG_TO_DB.has_key(key) and
+        dbfield_to_sqltype.has_key(COMBINED_LOG_TO_DB[key])):
+      new_hash[key] = dbfield_to_sqltype[COMBINED_LOG_TO_DB[key]].to_sql(value)
     else:
       new_hash[key] = value
   return new_hash
 
-def make_games_insert_query(dbfields, filename, offset):
-  fields = ["source_file", "source_file_offset"]
-  values = [filename, offset]
-
-  for logkey, sqlkey in LOG_DB_MAPPINGS:
-    if dbfields.has_key(logkey):
+def make_xlog_db_query(db_mappings, xdict, filename, offset, table):
+  fields = ['source_file']
+  values = [filename]
+  if offset is not None and offset != False:
+    fields.append('source_file_offset')
+    values.append(offset)
+  for logkey, sqlkey in db_mappings:
+    if xdict.has_key(logkey):
       fields.append(sqlkey)
-      values.append(dbfields[logkey])
-
-  return Query('INSERT INTO games (%s) VALUES (%s);' %
-               (",".join(fields), ",".join([ "%s" for v in values])),
+      values.append(xdict[logkey])
+  return Query('INSERT INTO %s (%s) VALUES (%s);' %
+               (table, ",".join(fields), ",".join([ "%s" for v in values])),
                *values)
 
-def insert_logline(cursor, logdict, filename, offset):
-  query = make_games_insert_query(logdict, filename, offset)
+def insert_xlog_db(cursor, xdict, filename, offset):
+  milestone = xdict.has_key('milestone')
+  db_mappings = milestone and MILE_DB_MAPPINGS or LOG_DB_MAPPINGS
+  thingname = milestone and 'milestone' or 'logline'
+  table = milestone and 'milestones' or 'games'
+  save_offset = not milestone
+  query = make_xlog_db_query(db_mappings, xdict, filename,
+                             save_offset and offset, table)
   try:
     query.execute(cursor)
   except Exception, e:
-    error("Error inserting logline %s (query: %s [%s]): %s"
-          % (logdict, query.query, query.values, e))
-    raise
+    error("Error inserting %s %s (query: %s [%s]): %s"
+          % (thingname, milestone, query.query, query.values, e))
 
 def dbfile_offset(cursor, table, filename):
   """Given a db cursor and filename, returns the offset of the last
@@ -651,7 +719,7 @@ def process_log(cursor, filename, offset, d):
 
   cursor.execute('BEGIN;')
   try:
-    insert_logline(cursor, d, filename, offset)
+    insert_xlog_db(cursor, d, filename, offset)
     if ghost_kill:
       record_ghost_kill(cursor, d)
 
@@ -752,6 +820,7 @@ def add_milestone_record(c, filename, offset, d):
   c.execute('BEGIN;')
   try:
     update_milestone_bookmark(c, filename, offset)
+    insert_xlog_db(c, d, filename, offset)
     handler = MILESTONE_HANDLERS.get(d['type'])
     if handler:
       handler(c, d)

outline.py

@@ -117,6 +117,14 @@ def repeat_race_class(previous_chars, char):
     repeats += 1
   return repeats
 
+def is_god_repeated(previous_wins, g):
+  """Returns true if the god in the current game was already used by
+the player in a previous winning game. The gods checked are the gods
+at end of game."""
+  def god(g):
+    return g.get('god') or ''
+  return god(g) in [god(x) for x in previous_wins]
+
 def crunch_winner(c, game):
   """A game that wins could assign a variety of irrevocable points for a
   variety of different things. This function needs to calculate them all."""
@@ -141,12 +149,19 @@ def crunch_winner(c, game):
                 "nth_win:%d" % (previous_wins + 1),
                 game['name'], get_points(previous_wins, 200, 100, 50))
 
-  my_wins = query.get_wins(c, player = game['name'], before = game['end'])
+  my_wins = query.get_winning_games(c, player = game['name'],
+                                    before = game['end'])
   n_my_wins = len(my_wins)
 
+  # Assign 20 extra points for winning with a god that you haven't used before.
+  if not is_god_repeated(my_wins, game) and not query.did_change_god(game):
+    god = (game.get('god') or 'atheist').lower()
+    assign_points(c, "my_win_" + god, 20)
+
   repeated = 0
   if n_my_wins > 0:
-    repeated = repeat_race_class(my_wins, game['char'])
+    repeated = repeat_race_class([x['charabbrev'] for x in my_wins],
+                                 game['char'])
 
   if n_my_wins == 0:
     # First win! I bet you don't have a streak