def _check_event(self, time_sec):
for event_id in g.events:
event_spec = g.events[event_id]
event_target = self.events.get(event_id, None)
# Skip events already flagged as triggered.
if event_target and event_target.triggered:
continue
if chance.roll_interval(event_spec.chance / 10000., time_sec):
self.trigger_event(event_spec)
return True # Don't trigger more than one at a time.
return False
def _check_event(self, time_sec):
for event_id in g.events:
event_spec = g.events[event_id]
event_target = self.events.get(event_id, None)
# Skip events already flagged as triggered.
if event_target and event_target.triggered == 1:
continue
if chance.roll_interval(event_spec.chance / 10000., time_sec):
self.pause_game()
if not event_target:
event_target = event.Event(event_spec)
self.events[event_id] = event_target
event_target.trigger()
self.log.append(LogEmittedEvent(self.raw_sec, event_id))
return True # Don't trigger more than one at a time.
return False
def give_time(self, time_sec, midnight_stop=True):
if time_sec <= 0:
assert time_sec == 0, "give_time cannot go backwards in time!"
return 0
old_time = self.raw_sec
last_minute = self.raw_min
last_day = self.raw_day
self.raw_sec += time_sec
self.update_times()
days_passed = self.raw_day - last_day
if days_passed > 1:
# Back up until only one day passed.
# Times will update below, since a day passed.
extra_days = days_passed - 1
self.raw_sec -= g.seconds_per_day * extra_days
day_passed = (days_passed != 0)
if midnight_stop and day_passed:
# If a day passed, back up to 00:00:00 for midnight_stop.
self.raw_sec = self.raw_day * g.seconds_per_day
self.update_times()
secs_passed = self.raw_sec - old_time
mins_passed = self.raw_min - last_minute
time_of_day = self.raw_sec % g.seconds_per_day
techs_researched = []
bases_constructed = []
items_constructed = []
bases_under_construction = []
items_under_construction = []
self.cpu_pool = 0
# Collect base info, including maintenance.
maintenance_cost = array((0, 0, 0), int64)
for base in g.all_bases():
if not base.done:
bases_under_construction.append(base)
else:
items_under_construction += [(base, item)
for item in base.all_items()
if item and not item.done]
maintenance_cost += base.maintenance
# Maintenance? Gods don't need no stinking maintenance!
if self.apotheosis:
maintenance_cost = array((0, 0, 0), int64)
# Do Interest and income.
self.do_interest(secs_passed)
self.do_income(secs_passed)
# Any CPU explicitly assigned to jobs earns its dough.
job_cpu = self.get_allocated_cpu_for("jobs", 0) * secs_passed
self.do_jobs(job_cpu)
# Pay maintenance cash, if we can.
cash_maintenance = g.current_share(int(maintenance_cost[cash]),
time_of_day, secs_passed)
if cash_maintenance > self.cash:
cash_maintenance -= self.cash
self.cash = 0
else:
self.cash -= cash_maintenance
cash_maintenance = 0
# Do research, fill the CPU pool.
default_cpu = self.available_cpus[0]
for task, cpu_assigned in self.get_cpu_allocations():
default_cpu -= cpu_assigned
real_cpu = cpu_assigned * secs_passed
if task != "jobs":
self.cpu_pool += real_cpu
if task != "cpu_pool":
tech_task = self.techs[task]
# Note that we restrict the CPU available to prevent
# the tech from pulling from the rest of the CPU pool.
if tech_task.work_on(self.cash, real_cpu, mins_passed):
techs_researched.append(tech_task)
self.cpu_pool += default_cpu * secs_passed
# And now we use the CPU pool.
# Maintenance CPU.
cpu_maintenance = maintenance_cost[cpu] * secs_passed
if cpu_maintenance > self.cpu_pool:
cpu_maintenance -= self.cpu_pool
self.cpu_pool = 0
else:
self.cpu_pool -= int(cpu_maintenance)
cpu_maintenance = 0
# Base construction.
for base in bases_under_construction:
if base.work_on(self.cash, self.cpu_pool, mins_passed):
bases_constructed.append(base)
# Item construction.
for base, item in items_under_construction:
if item.work_on(self.cash, self.cpu_pool, mins_passed):
items_constructed.append((base, item))
# Jobs via CPU pool.
if self.cpu_pool > 0:
self.do_jobs(self.cpu_pool)
# Second attempt at paying off our maintenance cash.
if cash_maintenance > self.cash:
# In the words of Scooby Doo, "Ruh roh."
cash_maintenance -= self.cash
self.cash = 0
else:
# Yay, we made it!
self.cash -= cash_maintenance
cash_maintenance = 0
# Apply max cash cap to avoid overflow @ 9.220 qu
self.cash = min(self.cash, g.max_cash)
# Record statistics about the player
self.used_cpu += self.available_cpus[0] * secs_passed
# Reset current log message
self.curr_log = []
need_recalc_cpu = False
# Tech gain dialogs.
for tech in techs_researched:
del self.cpu_usage[tech.id]
tech_log = LogResearchedTech(self.raw_sec, tech.id)
self.append_log(tech_log)
need_recalc_cpu = True
# Base complete dialogs.
for base in bases_constructed:
log_message = LogBaseConstructed(self.raw_sec, base.name,
base.spec.id, base.location.id)
self.append_log(log_message)
need_recalc_cpu = True
# Item complete dialogs.
for base, item in items_constructed:
log_message = LogItemConstructionComplete(self.raw_sec,
item.spec.id, item.count,
base.name, base.spec.id,
base.location.id)
self.append_log(log_message)
need_recalc_cpu = True
# Are we still in the grace period?
grace = self.in_grace_period(self.had_grace)
# If we just lost grace, show the warning.
if self.had_grace and not grace:
self.had_grace = False
self.pause_game()
g.map_screen.show_story_section("Grace Warning")
# Maintenance death, discovery.
dead_bases = []
for base in g.all_bases():
dead = False
# Maintenance deaths.
if base.done:
if cpu_maintenance and base.maintenance[cpu]:
refund = base.maintenance[cpu] * secs_passed
cpu_maintenance = max(0, cpu_maintenance - refund)
#Chance of base destruction if cpu-unmaintained: 1.5%
if not dead and chance.roll_interval(.015, secs_passed):
dead_bases.append((base, "maint"))
dead = True
if cash_maintenance:
base_needs = g.current_share(base.maintenance[cash],
time_of_day, secs_passed)
if base_needs:
cash_maintenance = max(0,
cash_maintenance - base_needs)
#Chance of base destruction if cash-unmaintained: 1.5%
if not dead and chance.roll_interval(
.015, secs_passed):
dead_bases.append((base, "maint"))
dead = True
# Discoveries
if not (grace or dead or base.has_grace()):
detect_chance = base.get_detect_chance()
if g.debug: # pragma: no cover
print("Chance of discovery for base %s: %s" % \
(base.name, repr(detect_chance)))
for group, group_chance in detect_chance.items():
if chance.roll_interval(group_chance / 10000.,
secs_passed):
dead_bases.append((base, group))
dead = True
break
if dead_bases:
# Base disposal and dialogs.
self.remove_bases(dead_bases)
need_recalc_cpu = True
# Random Events
if not grace:
self._check_event(time_sec)
# Process any complete days.
if day_passed:
self.new_day()
if need_recalc_cpu:
self.recalc_cpu()
return mins_passed