def func(self):
"""Show server time data in a table."""
table1 = EvTable("|wServer time", "", align="l", width=78)
table1.add_row("Current uptime",
utils.time_format(gametime.uptime(), 3))
table1.add_row("Total runtime",
utils.time_format(gametime.runtime(), 2))
table1.add_row(
"First start",
datetime.datetime.fromtimestamp(gametime.server_epoch()))
table1.add_row("Current time", datetime.datetime.now())
table1.reformat_column(0, width=30)
table2 = EvTable("|wIn-Game time",
"|wReal time x %g" % gametime.TIMEFACTOR,
align="l",
width=77,
border_top=0)
epochtxt = "Epoch (%s)" % ("from settings" if settings.TIME_GAME_EPOCH
else "server start")
table2.add_row(epochtxt,
datetime.datetime.fromtimestamp(gametime.game_epoch()))
table2.add_row("Total time passed:",
utils.time_format(gametime.gametime(), 2))
table2.add_row(
"Current time ",
datetime.datetime.fromtimestamp(gametime.gametime(absolute=True)))
table2.reformat_column(0, width=30)
self.caller.msg(unicode(table1) + "\n" + unicode(table2))
def func(self):
"""Show server time data in a table."""
table1 = EvTable("|wServer time", "", align="l", width=78)
table1.add_row("Current uptime", utils.time_format(gametime.uptime(), 3))
table1.add_row("Total runtime", utils.time_format(gametime.runtime(), 2))
table1.add_row("First start", datetime.datetime.fromtimestamp(gametime.server_epoch()))
table1.add_row("Current time", datetime.datetime.now())
table1.reformat_column(0, width=30)
table2 = EvTable("|wIn-Game time", "|wReal time x %g" % gametime.TIMEFACTOR, align="l", width=77, border_top=0)
epochtxt = "Epoch (%s)" % ("from settings" if settings.TIME_GAME_EPOCH else "server start")
table2.add_row(epochtxt, datetime.datetime.fromtimestamp(gametime.game_epoch()))
table2.add_row("Total time passed:", utils.time_format(gametime.gametime(), 2))
table2.add_row("Current time ", datetime.datetime.fromtimestamp(gametime.gametime(absolute=True)))
table2.reformat_column(0, width=30)
self.caller.msg(unicode(table1) + "\n" + unicode(table2))
def gametime():
"""Return the current game time as a datetime object.
This returns a datetime opbject with an additional property: `season`. It returns the current reason as a string (like "winter").
"""
return GTime.fromtimestamp(gtime.gametime(absolute=True))
def real_seconds_until(**kwargs):
"""
Return the real seconds until game time.
If the game time is 5:00, TIME_FACTOR is set to 2 and you ask
the number of seconds until it's 5:10, then this function should
return 300 (5 minutes).
Args:
times (str: int): the time units.
Example:
real_seconds_until(hour=5, min=10, sec=0)
Returns:
The number of real seconds before the given game time is up.
"""
current = gametime.gametime(absolute=True)
units = sorted(set(UNITS.values()), reverse=True)
# Remove seconds from the tuple
del units[-1]
divisors = list(time_to_tuple(current, *units))
# For each keyword, add in the unit's
units.append(1)
higher_unit = None
for unit, value in kwargs.items():
# Get the unit's index
if unit not in UNITS:
raise ValueError("unknown unit".format(unit))
seconds = UNITS[unit]
index = units.index(seconds)
divisors[index] = value
if higher_unit is None or higher_unit > index:
higher_unit = index
# Check the projected time
# Note that it can be already passed (the given time may be in the past)
projected = 0
for i, value in enumerate(divisors):
seconds = units[i]
projected += value * seconds
if projected <= current:
# The time is in the past, increase the higher unit
if higher_unit:
divisors[higher_unit - 1] += 1
else:
divisors[0] += 1
# Get the projected time again
projected = 0
for i, value in enumerate(divisors):
seconds = units[i]
projected += value * seconds
return (projected - current) / TIMEFACTOR
def real_seconds_until(**kwargs):
"""
Return the real seconds until game time.
If the game time is 5:00, TIME_FACTOR is set to 2 and you ask
the number of seconds until it's 5:10, then this function should
return 300 (5 minutes).
Args:
times (str: int): the time units.
Example:
real_seconds_until(hour=5, min=10, sec=0)
Returns:
The number of real seconds before the given game time is up.
"""
current = gametime.gametime(absolute=True)
units = sorted(set(UNITS.values()), reverse=True)
# Remove seconds from the tuple
del units[-1]
divisors = list(time_to_tuple(current, *units))
# For each keyword, add in the unit's
units.append(1)
higher_unit = None
for unit, value in kwargs.items():
# Get the unit's index
if unit not in UNITS:
raise ValueError("unknown unit".format(unit))
seconds = UNITS[unit]
index = units.index(seconds)
divisors[index] = value
if higher_unit is None or higher_unit > index:
higher_unit = index
# Check the projected time
# Note that it can be already passed (the given time may be in the past)
projected = 0
for i, value in enumerate(divisors):
seconds = units[i]
projected += value * seconds
if projected <= current:
# The time is in the past, increase the higher unit
if higher_unit:
divisors[higher_unit - 1] += 1
else:
divisors[0] += 1
# Get the projected time again
projected = 0
for i, value in enumerate(divisors):
seconds = units[i]
projected += value * seconds
return (projected - current) / TIMEFACTOR
def func(self):
""" Execute the time command. """
tempus = datetime.datetime.fromtimestamp(
gametime.gametime(absolute=True))
hōra = tempus.hour
if hōra > 17 or hōra < 6:
self.msg("Nox est.")
# set outside rooms as dark
else:
self.msg(f"Nunc est hōra {hōra - 5}.")
def ago(self):
"""Return the time since the notification was created."""
if self.timestamp is None:
return "now"
gtime = gametime.gametime(absolute=True)
seconds = gtime - self.timestamp
if seconds < 5:
return "a few seconds ago"
ago = time_format(seconds, 4)
return "{} ago".format(ago)
def sent_ago(self):
"""Return the human-readable time since sent (X units ago)."""
global _GAMETIME
if not _GAMETIME:
from evennia.utils import gametime as _GAMETIME
gtime = datetime.datetime.fromtimestamp(
_GAMETIME.gametime(absolute=True))
gtime = make_aware(gtime)
seconds = (gtime - self.date_sent).total_seconds()
ago = time_format(seconds, 4)
return "{} ago".format(ago)
def send(self, sender, recipients, content):
"""Send a text message from `number` to `recipients`.
Args:
sender (str): the number (7-digit).
recipients (list of str): a list of 7-digit strings.
content (str): the text of the message.
Returns:
text (Text): the newly-sent text message.
"""
global _GAMETIME, _THREAD, _NUMBER
if not _GAMETIME:
from evennia.utils import gametime as _GAMETIME
if not _THREAD:
from web.text.models import Thread as _THREAD
if not _NUMBER:
from web.text.models import Number as _NUMBER
# First, get the sender's phone number
recipients = [sender] + recipients
try:
sender = _NUMBER.objects.get(db_phone_number=sender)
except _NUMBER.DoesNotExist:
sender = _NUMBER(db_phone_number=sender)
sender.save()
gtime = datetime.datetime.fromtimestamp(_GAMETIME.gametime(absolute=True))
gtime = make_aware(gtime)
# Look for a thread or create one
thread = _THREAD.objects.get_thread(recipients)
if thread is None:
thread = _THREAD()
thread.save()
# For every participant, add it as recipient
for number in recipients:
try:
recipient = _NUMBER.objects.get(db_phone_number=number)
except _NUMBER.DoesNotExist:
recipient = _NUMBER(db_phone_number=number)
recipient.save()
thread.db_recipients.add(recipient)
thread.db_read.clear()
thread.db_read.add(sender)
return thread.text_set.create(
db_sender=sender, db_content=content, db_date_sent=gtime)
def func(self):
"Updates the journal"
caller = self.caller
location = caller.location
zone = "A Fake Dungeon"
time = gametime()
journal = caller.db.journal
usage = "+journal <Your entry>"
if not self.args:
caller.msg(usage)
return
else:
entry = self.lhs
journal.append([time, zone, location, entry])
caller.msg("Added to journal:\n%s" % entry)
def get_time(*args, **kwargs):
time = datetime.datetime.fromtimestamp(gametime.gametime(absolute=True))
hour = time.hour
min = time.minute
ampm = "AM"
if hour >= 12:
ampm = "PM"
if hour > 12:
hour = hour - 12
if min < 10:
min = f"0%s" % (str(min), )
return f"%s:%s %s" % (hour, min, ampm)
def func(self):
"Show server time data in a table."
table = prettytable.PrettyTable(["{wserver time statistic", "{wtime"])
table.align = 'l'
table.add_row(
["Current server uptime",
utils.time_format(gametime.uptime(), 3)])
table.add_row([
"Total server running time",
utils.time_format(gametime.runtime(), 2)
])
table.add_row([
"Total in-game time (realtime x %g)" % (gametime.TIMEFACTOR),
utils.time_format(gametime.gametime(), 2)
])
table.add_row(["Server time stamp", datetime.datetime.now()])
self.caller.msg(str(table))
def custom_gametime(absolute=False):
"""
Return the custom game time as a tuple of units, as defined in settings.
Args:
absolute (bool, optional): return the relative or absolute time.
Returns:
The tuple describing the game time. The length of the tuple
is related to the number of unique units defined in the
settings. By default, the tuple would be (year, month,
week, day, hour, minute, second).
"""
current = gametime.gametime(absolute=absolute)
units = sorted(set(UNITS.values()), reverse=True)
del units[-1]
return time_to_tuple(current, *units)
def custom_gametime(absolute=False):
"""
Return the custom game time as a tuple of units, as defined in settings.
Args:
absolute (bool, optional): return the relative or absolute time.
Returns:
The tuple describing the game time. The length of the tuple
is related to the number of unique units defined in the
settings. By default, the tuple would be (year, month,
week, day, hour, minute, second).
"""
current = gametime.gametime(absolute=absolute)
units = sorted(set(UNITS.values()), reverse=True)
del units[-1]
return time_to_tuple(current, *units)
def add(self,
title,
screen,
app,
folder="app",
content="",
db=None,
group=None):
"""Add a new notificaiton.
Args:
title (str): title of the notification to add.
screen (str): screen path when addressing the notification.
app (str): app name that sent the application.
folder (str, optional): the folder containing the app.
content (str, optional): the content of the notification.
db (dict, optional): db attributes to give to the screen.
group (str, optional): a group identifier [1].
[1] Notifications can be grouped using a group identifier. Notifications
that have this identifier can be removed. This is useful in
some apps that want to remove notifications based on certain
actions: for instance, if you mark a text as read in the text
app, you want to remove the unread notification for this thread.
"""
timestamp = gametime.gametime(absolute=True)
kwargs = {
"title": title,
"screen": screen,
"app": app,
"folder": folder,
"content": content,
"db": db,
"group": group,
"timestamp": timestamp,
}
notification = Notification(**kwargs)
notification.obj = self.obj
notification.handler = self
self.db.append(kwargs)
return notification
def return_appearance(type, looker, number=False, header=""):
"""Return the formatted appearance for a phone or computer."""
phone_number = type.obj.tags.get(category="phone number")
if not isinstance(phone_number, str):
phone_number = "|gunset|n"
else:
phone_number = phone_number[:3] + "-" + phone_number[3:]
date = datetime.datetime.fromtimestamp(gametime.gametime(absolute=True))
text = dedent("""
{header}
{time}
{date}
""".strip("\n")).format(
header=header,
date=date.strftime("%A, %B {}, %Y".format(date.day)),
time=date.strftime("%I:%M %p"),
)
# If a phone number, display it
if number:
text += "\n\n" + """
{number}
""".rstrip("\n").format(number=phone_number)
# Display the notifications
notifications = type.notifications.all()
if notifications:
text += "\n\n"
for notification in notifications:
title = crop(notification.title, 55, "...")
content = "\n ".join(wrap(notification.content, 74))
text += "\n- {:<55} ({})".format(title, notification.ago)
if content:
text += "\n " + content
return text
def func(self):
if not self.args:
self.caller.msg("You must suply a target for the spell.")
return
if (self.args == "Use" or self.args == "use"):
if (self.caller.db.astro == 0):
self.caller.db.astro = 1
self.caller.db.blessed = int(self.caller.db.blessed) + 1
self.caller.msg("You are aligned with the universe.")
else:
self.caller.msg("Try again soon.")
return
hit = self.caller.search(self.args)
if hit:
t = gametime.gametime(absolute=True)
tst = time.strftime("%m", time.gmtime(t))
self.caller.msg("Month: %s" % int(tst))
self.caller.msg("Star Sign: %s'" % int(hit.db.starsign))
if (int(tst) == int(hit.db.starsign)):
self.caller.msg("The stars are aligned for %s." % hit)
else:
self.caller.msg("You can't find that person.")
def test_gametime_downtimes(self):
gametime.IGNORE_DOWNTIMES = True
self.assertAlmostEqual(gametime.gametime(), 630 * 5.0)
gametime.IGNORE_DOWNTIMES = False
def test_gametime_absolute(self):
self.assertAlmostEqual(gametime.gametime(absolute=True), 1555597898.0)
def test_gametime_simple(self):
self.assertAlmostEqual(gametime.gametime(), 630.0 * 5)
def func(self):
"Show server time data in a table."
table = prettytable.PrettyTable(["{wserver time statistic","{wtime"])
table.align = 'l'
table.add_row(["Current server uptime", utils.time_format(gametime.uptime(), 3)])
table.add_row(["Total server running time", utils.time_format(gametime.runtime(), 2)])
table.add_row(["Total in-game time (realtime x %g)" % (gametime.TIMEFACTOR), utils.time_format(gametime.gametime(), 2)])
table.add_row(["Server time stamp", datetime.datetime.now()])
self.caller.msg(str(table))
def test_gametime_absolute(self):
self.assertAlmostEqual(gametime.gametime(absolute=True),
datetime(2019, 4, 18, 14, 31, 38).timestamp())
