FFR-Bot/ffrrace.py at master · Steven-Biro/FFR-Bot · GitHub

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
import time
from datetime import datetime, timedelta
from sys import maxsize
import json
import redis
import os

redis_db = redis.Redis(host=os.environ.get("REDIS_HOST", "localhost"),
            port=int(os.environ.get("REDIS_PORT", "6379")))

class Race:
    """
    A class to model a FFR race
    """

    def __init__(self, id, name = None, flags = None):
        self.id = id
        self.name = name
        self.flags = flags
        self.runners = dict()
        self.started = False
        self.role = None
        self.channel = None
        self.owner = None
        self.readycount = 0
        self.message = None
        self.restream = None


    # def savedata(self):
    #     redis_db.hmset('active_races', json.dumps(active_races))
    #

    def addRunner(self, runnerid, runner):
        self.runners[runnerid] = dict([("name", runner), ("stime", None), ("etime", None), ("ready", False)])

    def removeRunner(self, runnerid):
        del self.runners[runnerid]

    def ready(self, runnerid):
        if (self.runners[runnerid]["ready"] == True):
            return
        self.runners[runnerid]["ready"] = True
        self.readycount += 1

    def unready(self, runnerid):
        if (self.runners[runnerid]["ready"] == False):
            return
        self.runners[runnerid]["ready"] = False
        self.readycount -= 1

    def start(self):
        self.started = True
        stime = time.perf_counter_ns()
        for runnerid in self.runners.values():
            runnerid["stime"] = stime


    def done(self, runnerid):
        etime = time.perf_counter_ns()
        self.runners[runnerid]["etime"] = etime

        if (all(r["etime"] != None for r in self.runners.values())):
            return self.finishRace()

        rval = timedelta(microseconds=round(etime - self.runners[runnerid]["stime"], -3) // 1000)
        return self.runners[runnerid]["name"] + ": " + str(rval)

    def undone(self, runnerid):
        self.runners[runnerid]["etime"] = None
        return self.runners[runnerid]["name"] + " is back in the race!"

    def forfeit(self, runnerid):
        self.runners[runnerid]["etime"] = maxsize
        if (all(r["etime"] != None for r in self.runners.values())):
            return self.finishRace()

        return self.runners[runnerid]["name"] + " forfeited"

    def getUpdate(self):
        rval = "Current Entrants:\n"
        for runner in self.runners.values():
            rval += runner["name"] + " "
            if (self.started):
                if (runner["etime"] is maxsize):
                    rval += "forfeited"
                elif (runner["etime"] != None):
                    time = timedelta(microseconds=round(runner["etime"] - runner["stime"], -3) // 1000)
                    rval += "done: " + str(time)
                else:
                    rval += "still going"
            else:
                rval += ("ready" if runner["ready"] else "not ready")
            rval += "\n"
        return rval

    def getTime(self):
        for i in self.runners.values():
            return timedelta(microseconds=round(time.perf_counter_ns() - i["stime"], -3) // 1000)

    def finishRace(self):
        rstring = "Race " + self.name + " results:\n\n"
        place = 0
        for runner in sorted(list(self.runners.values()), key=lambda k: k["etime"]):
            place += 1
            rstring += str(place) + ") " + runner["name"] + ": "
            if (runner["etime"] is maxsize):
                rstring += "Forfeited\n"
            else:
                rstring += str(timedelta(microseconds=round(runner["etime"] - runner["stime"], -3) // 1000)) + "\n"
        return rstring