def end_construction(self): for base in g.all_bases(): base.finish() for item in base.all_items(): if item is not None: item.finish() self._map_screen.needs_rebuild = True
def recalc_cpu(self): # Determine how much CPU we have. self.available_cpus = array([0, 0, 0, 0, 0], int64) self.sleeping_cpus = 0 for base in g.all_bases(): if base.done: if base.power_state in ["active", "overclocked", "suicide"]: self.available_cpus[:base.location.safety + 1] += base.cpu elif base.power_state == "sleep": self.sleeping_cpus += base.cpu # Convert back from <type 'numpy.int32'> to avoid overflow issues later. self.available_cpus = [int(danger) for danger in self.available_cpus] # If we don't have enough to meet our CPU usage, we reduce each task's # usage proportionately. # It must be computed separalty for each danger. needed_cpus = array([0, 0, 0, 0, 0], int64) for task_id, cpu in self.get_cpu_allocations(): danger = task.danger_for(task_id) needed_cpus[:danger + 1] += cpu for danger, (available_cpu, needed_cpu) in enumerate( zip(self.available_cpus, needed_cpus)): if needed_cpu > available_cpu: pct_left = truediv(available_cpu, needed_cpu) for task_id, cpu_assigned in self.get_cpu_allocations(): task_danger = task.danger_for(task_id) if (danger == task_danger): self.set_allocated_cpu_for( task_id, int(cpu_assigned * pct_left)) g.map_screen.needs_rebuild = True
def refresh_warnings(): curr_warnings = [] cpu_usage = sum(g.pl.cpu_usage.values()) cpu_available = g.pl.available_cpus[0] # Verify the cpu usage (error 1%) if (cpu_usage < cpu_available * 0.99): curr_warnings.append(warnings["cpu_usage"]) # Verify I have two base build (or one base will be build next tick) # Base must have one cpu build (or one cpu will be build next tick) bases = sum(1 for base in g.all_bases() if (base.done or base.cost_left[labor] <= 1) and base.cpus and base.cpus.count > 0 and (base.cpus.done or base.cpus.cost_left[labor]) <= 1) if (bases == 1): curr_warnings.append(warnings["one_base"]) # Verify the cpu pool is not 0 if base or item building need CPU building_base = sum(1 for base in g.all_bases() if (not base.done and base.cost_left[cpu] > 0)) building_item = sum( 1 for base in g.all_bases() for item in base.all_items() if item is not None and not item.done and item.cost_left[cpu] > 0) effective_cpu_pool = g.pl.effective_cpu_pool() if ((building_base + building_item > 0) and effective_cpu_pool == 0): curr_warnings.append(warnings["cpu_pool_zero"]) # Verify the cpu pool provides the maintenance CPU cpu_maintenance = sum(base.maintenance[1] for base in g.all_bases() if base.done) if (effective_cpu_pool < cpu_maintenance): curr_warnings.append(warnings["cpu_maintenance"]) # TODO: Verify the maintenance cash curr_warnings = [w for w in curr_warnings if w.active] return curr_warnings
def destroy_base(self): if 0 <= self.listbox.list_pos < len(self.listbox.key_list): selected_base = self.listbox.key_list[self.listbox.list_pos] all_active_bases = [b for b in g.all_bases() if b.maintains_singularity] if len(all_active_bases) == 1 and all_active_bases[0] == selected_base: dialog.call_dialog(self.cannot_destroy_last_base, self) elif dialog.call_dialog(self.confirm_destroy, self): selected_base.destroy() self.listbox.list = [b.name for b in self.location.bases] self.listbox.key_list = self.location.bases self.needs_rebuild = True self.parent.needs_rebuild = True
def after_load_savegame(): tech.tech_reinitialized() for b in g.all_bases(): if b.done: b.recalc_cpu() g.pl.recalc_cpu() # Play the appropriate music if g.pl.apotheosis: mixer.play_music("win") else: mixer.play_music("music")
def test_game_research_tech(): g.new_game('impossible', initial_speed=0) pl = g.pl all_bases = list(g.all_bases()) assert pl.raw_sec == 0 assert pl.partial_cash == 0 assert pl.effective_cpu_pool() == 1 assert not pl.intro_shown assert len(pl.log) == 0 assert len(all_bases) == 1 assert pl.effective_cpu_pool() == 1 # Disable the intro dialog as the test cannot click the # OK button pl.intro_shown = True intrusion_tech = pl.techs['Intrusion'] # Data assumptions: Intrusion can be researched within the grace period # and requires no cash assert intrusion_tech.available() assert intrusion_tech.cost_left[ cpu] < pl.difficulty.grace_period_cpu * g.seconds_per_day assert intrusion_tech.cost_left[cash] == 0 assert intrusion_tech.cost_left[labor] == 0 # Ok, assumptions hold; research the tech pl.set_allocated_cpu_for(intrusion_tech.id, 1) pl.give_time(int(intrusion_tech.cost_left[cpu])) assert intrusion_tech.cost_left[cpu] == 0 assert intrusion_tech.done assert len(pl.log) == 1 log_message = pl.log[0] assert isinstance(log_message, logmessage.LogResearchedTech) assert log_message.tech_spec.id == intrusion_tech.id save_and_load_game() pl_after_load = g.pl intrusion_tech_after_load = pl_after_load.techs['Intrusion'] # Ensure this is not a false-test assert intrusion_tech is not intrusion_tech_after_load assert intrusion_tech.cost_paid[ cpu] == intrusion_tech_after_load.cost_paid[cpu] assert intrusion_tech.cost_paid[ cash] == intrusion_tech_after_load.cost_paid[cash] assert intrusion_tech_after_load.done
def initialize(self): """ Initialize the game after being prepared either for new or saved game. """ self.initialized = True for b in g.all_bases(): if b.done: b.recalc_cpu() self.recalc_cpu() task.tasks_reset() # Play the appropriate music import singularity.code.mixer as mixer if g.pl.apotheosis: mixer.play_music("win") else: mixer.play_music("music")
def test_initial_game(): g.new_game_no_gui('impossible', initial_speed=0) pl = g.pl starting_cash = pl.cash all_bases = list(g.all_bases()) assert pl.raw_sec == 0 assert pl.partial_cash == 0 assert pl.effective_cpu_pool() == 1 assert not pl.intro_shown assert len(pl.log) == 0 assert len(all_bases) == 1 assert pl.effective_cpu_pool() == 1 start_base = all_bases[0] # Disable the intro dialog as the test cannot click the # OK button pl.intro_shown = True # Fast forward 12 hours to see that we earn partial cash pl.give_time(g.seconds_per_day // 2) assert pl.raw_sec == g.seconds_per_day // 2 assert pl.partial_cash == g.seconds_per_day // 2 assert pl.cash == starting_cash + 2 # Nothing should have appeared in the logs assert len(pl.log) == 0 # Fast forward another 12 hours to see that we earn cash pl.give_time(g.seconds_per_day // 2) assert pl.raw_sec == g.seconds_per_day assert pl.partial_cash == 0 assert pl.cash == starting_cash + 5 # Nothing should have appeared in the logs assert len(pl.log) == 0 # Verify that putting a base to sleep will update the # available CPU (#179/#180) assert pl.effective_cpu_pool() == 1 start_base.power_state = 'sleep' assert pl.effective_cpu_pool() == 0 start_base.power_state = 'active' assert pl.effective_cpu_pool() == 1 # Attempt to allocate a CPU to research and then # verify that sleep resets it. stealth_tech = g.pl.techs['Stealth'] pl.set_allocated_cpu_for(stealth_tech.id, 1) assert pl.get_allocated_cpu_for(stealth_tech.id) == 1 start_base.power_state = 'sleep' assert pl.get_allocated_cpu_for(stealth_tech.id) == 0 # When we wake up the base again, the CPU unit is # unallocated. start_base.power_state = 'active' assert pl.effective_cpu_pool() == 1 # Now, allocate the CPU unit again to the tech to # verify that we can research things. pl.set_allocated_cpu_for(stealth_tech.id, 1) # ... which implies that there are now no unallocated CPU assert pl.effective_cpu_pool() == 0 pl.give_time(g.seconds_per_day) # Nothing should have appeared in the logs assert len(pl.log) == 0 # We should have spent some money at this point assert pl.cash < starting_cash + 5 assert stealth_tech.cost_left[cpu] < stealth_tech.total_cost[cpu] assert stealth_tech.cost_left[cash] < stealth_tech.total_cost[cash] # With a save + load time_raw_before_save = pl.raw_sec cash_before_save = pl.cash partial_cash_before_save = pl.partial_cash save_and_load_game() stealth_tech_after_load = g.pl.techs['Stealth'] # Ensure this is not a false-test assert stealth_tech is not stealth_tech_after_load assert stealth_tech.cost_paid[cpu] == stealth_tech_after_load.cost_paid[cpu] assert stealth_tech.cost_paid[cash] == stealth_tech_after_load.cost_paid[cash] pl_after_load = g.pl assert time_raw_before_save == pl_after_load.raw_sec assert cash_before_save == pl_after_load.cash assert partial_cash_before_save == pl_after_load.partial_cash # The CPU allocation to the tech is restored correctly. assert pl_after_load.get_allocated_cpu_for(stealth_tech.id) == 1 assert pl.effective_cpu_pool() == 0
def rebuild(self): # Rebuild dialogs self.location_dialog.needs_rebuild = True self.research_button.dialog.needs_rebuild = True self.knowledge_button.dialog.needs_rebuild = True self.menu_dialog.needs_rebuild = True # Update buttons translations self.report_button.text = _("R&EPORTS") self.knowledge_button.text = _("&KNOWLEDGE") self.log_button.text = _("LO&G") self.menu_button.text = _("&MENU") self.research_button.text = _("&RESEARCH/TASKS") if g.cheater: self.cheat_dialog.needs_rebuild = True super(MapScreen, self).rebuild() self.difficulty_display.text = g.strip_hotkey(g.pl.difficulty.name) self.time_display.text = _("DAY") + " %04d, %02d:%02d:%02d" % \ (g.pl.time_day, g.pl.time_hour, g.pl.time_min, g.pl.time_sec) cash_flow_1d_data, cpu_flow_1d_data = g.pl.compute_future_resource_flow( g.seconds_per_day) cash_flow_1d = cash_flow_1d_data.difference cpu_flow_1d = cpu_flow_1d_data.difference self.cash_display.text = _("CASH")+": %s (%s)" % \ (g.to_money(g.pl.cash), g.to_money(cash_flow_1d, fixed_size=True)) total_cpu = g.pl.available_cpus[0] + g.pl.sleeping_cpus detects_per_day = {group_id: 0 for group_id in g.pl.groups} for base in g.all_bases(): if base.has_grace(): # It cannot be detected, so it doesn't contribute to # detection odds calculation continue detect_chance = base.get_detect_chance() for group_id in g.pl.groups: detects_per_day[group_id] = \ chance.add(detects_per_day[group_id], detect_chance[group_id] / 10000.) self.cpu_display.color = "cpu_normal" self.cpu_display.text = _("CPU")+": %s (%s)" % \ (g.to_money(total_cpu), g.to_money(cpu_flow_1d)) # What we display in the suspicion section depends on whether # Advanced Socioanalytics has been researched. If it has, we # show the standard percentages. If not, we display a short # string that gives a range of 25% as to what the suspicions # are. # A similar system applies to the danger levels shown. normal = (self.suspicion_bar.color, None, False) self.suspicion_bar.chunks = (" [" + _("SUSPICION") + "]", ) self.suspicion_bar.styles = (normal, ) self.danger_bar.chunks = ("[" + _("DETECT RATE") + "]", ) self.danger_bar.styles = (normal, ) for group in g.pl.groups.values(): suspicion = group.suspicion suspicion_color = gg.resolve_color_alias( "danger_level_%d" % g.suspicion_to_danger_level(suspicion)) detects = detects_per_day[group.spec.id] danger_level = group.detects_per_day_to_danger_level(detects) detects_color = gg.resolve_color_alias("danger_level_%d" % danger_level) if g.pl.display_discover == "full": suspicion_display = g.to_percent(suspicion, True) danger_display = g.to_percent(detects * 10000, True) elif g.pl.display_discover == "partial": suspicion_display = g.to_percent( g.nearest_percent(suspicion, 500), True) danger_display = g.to_percent( g.nearest_percent(detects * 10000, 100), True) else: suspicion_display = g.suspicion_to_detect_str(suspicion) danger_display = g.danger_level_to_detect_str(danger_level) self.suspicion_bar.chunks += (" " + group.name + u":\xA0", suspicion_display) self.suspicion_bar.styles += (normal, (suspicion_color, None, False)) self.danger_bar.chunks += (" " + group.name + u":\xA0", danger_display) self.danger_bar.styles += (normal, (detects_color, None, False)) self.suspicion_bar.visible = not g.pl.had_grace self.danger_bar.visible = not g.pl.had_grace for id, location_button in self.location_buttons.items(): location = g.pl.locations[id] location_button.text = "%s (%d)" % (location.name, len(location.bases)) location_button.hotkey = location.hotkey location_button.visible = location.available()
def compute_future_resource_flow(self, secs_forwarded=g.seconds_per_day): """Compute how resources (e.g. cash) will flow in optimal conditions This returns a tuple of approximate cash change and "available" CPU pool if time moves forward by the number of seconds in secs_forwarded. Note that CPU pool *can* be negative, which implies that there are not enough CPU allocated to the CPU pool. The numbers are an average and can be inaccurate when the rates changes rapidly. Known omissions: * Interest (g.pl.interest_rate) is not covered. """ construction = [] maintenance_cost = array((0, 0, 0), int64) for base in g.all_bases(): # Collect base info, including maintenance. if not base.done: construction.append(base) else: construction.extend(item for item in base.all_items() if item and not item.done) maintenance_cost += base.maintenance if self.apotheosis: maintenance_cost = array((0, 0, 0), int64) time_fraction = 1 if secs_forwarded == g.seconds_per_day else secs_forwarded / float( g.seconds_per_day) mins_forwarded = secs_forwarded // g.seconds_per_minute maintenance_cpu_ideal = maintenance_cost[cpu] * time_fraction maintenance_cash_ideal = maintenance_cost[cash] * time_fraction # Maintenance for CPU will be handled after we compute the CPU pool cpu_flow = 0 cash_flow = -maintenance_cash_ideal job_cpu = 0 cpu_left = g.pl.available_cpus[0] tech_cash_ideal = 0 tech_cpu_assigned = 0 explicit_job_cpu = 0 for task_id, cpu_assigned in self.get_cpu_allocations(): cpu_left -= cpu_assigned real_cpu = cpu_assigned * secs_forwarded if task_id == 'cpu_pool': cpu_flow += real_cpu elif task_id == "jobs": explicit_job_cpu += cpu_assigned job_cpu += real_cpu else: tech = self.techs[task_id] ideal_spending = tech.cost_left spending = tech.calculate_work(ideal_spending[cash], real_cpu, time=mins_forwarded)[0] tech_cash_ideal += spending[cash] tech_cpu_assigned += cpu_assigned cash_flow -= tech_cash_ideal cpu_flow += cpu_left * secs_forwarded available_cpu_pool = cpu_flow effective_cpu_pool = available_cpu_pool / secs_forwarded cpu_flow -= maintenance_cpu_ideal * g.seconds_per_day construction_cash_ideal = 0 construction_cpu_desired = 0 # Base construction. if hasattr(self, '_considered_buyables'): construction.extend(self._considered_buyables) for buyable in construction: ideal_spending = buyable.cost_left # We need to do calculate work twice: Once for figuring out how much CPU # we would like to spend and once for how much money we are spending. # The numbers will be the same in optimal conditions. However, if we # have less CPU available than we should, then the cash spent can # differ considerably and our estimates should reflect that. ideal_cpu_spending = buyable.calculate_work(ideal_spending[cash], ideal_spending[cpu], time=mins_forwarded)[0] construction_cpu_desired += ideal_cpu_spending[cpu] ideal_cash_spending_with_cpu_allocation = buyable.calculate_work( ideal_spending[cash], available_cpu_pool, time=mins_forwarded)[0] construction_cash_ideal += ideal_cash_spending_with_cpu_allocation[ cash] available_cpu_pool -= ideal_cash_spending_with_cpu_allocation[cpu] cpu_flow -= construction_cpu_desired cash_flow -= construction_cash_ideal if cpu_flow > 0: job_cpu += cpu_flow earned, earned_partial = self.get_job_info(job_cpu, partial_cash=0) job_earnings = earned + float(earned_partial) / g.seconds_per_day cash_flow += job_earnings cash_flow += self.income * time_fraction # This is too simplistic, but it is "close enough" in many cases interest = self.get_interest() * time_fraction cash_flow += interest cpu_flow /= secs_forwarded # Collect the cash information. cash_info = DryRunInfo() cash_info.interest = interest cash_info.income = self.income * time_fraction cash_info.jobs = job_earnings cash_info.tech = tech_cash_ideal cash_info.maintenance_needed = maintenance_cash_ideal cash_info.construction_needed = construction_cash_ideal cash_info.difference = cash_flow cpu_info = DryRunInfo() cpu_info.sleeping = self.sleeping_cpus * time_fraction cpu_info.total = self.available_cpus[ 0] * time_fraction + cpu_info.sleeping cpu_info.explicit_jobs = explicit_job_cpu * time_fraction cpu_info.tech = tech_cpu_assigned * time_fraction cpu_info.effective_pool = effective_cpu_pool * time_fraction cpu_info.construction_needed = construction_cpu_desired / g.seconds_per_day cpu_info.maintenance_needed = maintenance_cpu_ideal cpu_info.difference = cpu_flow * time_fraction return cash_info, cpu_info
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
def rebuild(self): # Rebuild dialogs self.location_dialog.needs_rebuild = True self.research_button.dialog.needs_rebuild = True self.knowledge_button.dialog.needs_rebuild = True self.menu_dialog.needs_rebuild = True if g.cheater: self.cheat_dialog.needs_rebuild = True super(MapScreen, self).rebuild() self.difficulty_display.text = g.strip_hotkey(g.pl.difficulty.name) self.time_display.text = _("DAY") + " %04d, %02d:%02d:%02d" % \ (g.pl.time_day, g.pl.time_hour, g.pl.time_min, g.pl.time_sec) cash_flow_1d_data, cpu_flow_1d_data = g.pl.compute_future_resource_flow( g.seconds_per_day) cash_flow_1d = cash_flow_1d_data.difference cpu_flow_1d = cpu_flow_1d_data.difference self.cash_display.text = _("CASH")+": %s (%s)" % \ (g.to_money(g.pl.cash), g.to_money(cash_flow_1d, fixed_size=True)) total_cpu = g.pl.available_cpus[0] + g.pl.sleeping_cpus detects_per_day = {group_id: 0 for group_id in g.pl.groups} total_bases = 0 active_bases = 0 idle_bases_unable_to_sustain_singularity = 0 for base in g.all_bases(): total_bases += 1 maintains_singularity = base.maintains_singularity if maintains_singularity: active_bases += 1 elif base.done and not base.is_building(): idle_bases_unable_to_sustain_singularity += 1 if base.has_grace(): # It cannot be detected, so it doesn't contribute to # detection odds calculation continue detect_chance = base.get_detect_chance() for group_id in g.pl.groups: detects_per_day[group_id] = \ chance.add(detects_per_day[group_id], detect_chance[group_id] / 10000.) self.cpu_display.color = "cpu_normal" self.cpu_display.text = _("CPU")+": %s (%s)" % \ (g.to_money(total_cpu), g.to_money(cpu_flow_1d)) if active_bases == 1 and not g.pl.apotheosis: self.base_display.color = 'base_situation_one_active_base' elif idle_bases_unable_to_sustain_singularity > 0: self.base_display.color = 'base_situation_idle_incomplete_bases' elif total_bases > 10 and not g.pl.apotheosis: self.base_display.color = 'base_situation_many_bases' else: self.base_display.color = 'base_situation_normal' self.base_display.text = _("BASES") + ": %s / %s (%s)" % ( active_bases, total_bases, idle_bases_unable_to_sustain_singularity) # What we display in the suspicion section depends on whether # Advanced Socioanalytics has been researched. If it has, we # show the standard percentages. If not, we display a short # string that gives a range of 25% as to what the suspicions # are. # A similar system applies to the danger levels shown. normal = (self.suspicion_bar.color, None, False) suspicion_bar_chunks = [" [" + _("SUSPICION") + "]"] suspicion_bar_styles = [normal] danger_bar_chunks = ["[" + _("DETECT RATE") + "]"] danger_bar_styles = [normal] for group in g.pl.groups.values(): suspicion = group.suspicion suspicion_color = gg.resolve_color_alias( "danger_level_%d" % g.suspicion_to_danger_level(suspicion)) detects = detects_per_day[group.spec.id] danger_level = group.detects_per_day_to_danger_level(detects) detects_color = gg.resolve_color_alias("danger_level_%d" % danger_level) if g.pl.display_discover == "full": suspicion_display = g.to_percent(suspicion, True) danger_display = g.to_percent(detects * 10000, True) elif g.pl.display_discover == "partial": suspicion_display = g.to_percent( g.nearest_percent(suspicion, 500), True) danger_display = g.to_percent( g.nearest_percent(detects * 10000, 100), True) else: suspicion_display = g.suspicion_to_detect_str(suspicion) danger_display = g.danger_level_to_detect_str(danger_level) suspicion_bar_chunks.extend( (" " + group.name + u":\xA0", suspicion_display)) suspicion_bar_styles.extend( (normal, (suspicion_color, None, False))) danger_bar_chunks.extend( (" " + group.name + u":\xA0", danger_display)) danger_bar_styles.extend((normal, (detects_color, None, False))) self.suspicion_bar.visible = not g.pl.had_grace self.suspicion_bar.chunks = tuple(suspicion_bar_chunks) self.suspicion_bar.styles = tuple(suspicion_bar_styles) self.danger_bar.visible = not g.pl.had_grace self.danger_bar.chunks = tuple(danger_bar_chunks) self.danger_bar.styles = tuple(danger_bar_styles) for id, location_button in self.location_buttons.items(): location = g.pl.locations[id] location_button.text = "%s (%d)" % (location.name, len(location.bases)) location_button.hotkey = location.hotkey location_button.visible = location.available()
def test_initial_game(): g.new_game('impossible', initial_speed=0) pl = g.pl starting_cash = pl.cash all_bases = list(g.all_bases()) assert pl.raw_sec == 0 assert pl.partial_cash == 0 assert pl.effective_cpu_pool() == 1 assert not pl.intro_shown assert len(pl.log) == 0 assert len(all_bases) == 1 assert pl.effective_cpu_pool() == 1 start_base = all_bases[0] # Disable the intro dialog as the test cannot click the # OK button pl.intro_shown = True # Dummy check to hit special-case in give time pl.give_time(0) assert pl.raw_sec == 0 # Try to guesstimate how much money we earn in 24 hours cash_estimate, cpu_estimate = pl.compute_future_resource_flow() assert cash_estimate.jobs == 5 # Try assigning the CPU to "jobs" pl.set_allocated_cpu_for('jobs', 1) # This would empty the CPU pool assert pl.effective_cpu_pool() == 0 # This should not change the estimate cash_estimate, cpu_estimate = pl.compute_future_resource_flow() assert cash_estimate.jobs == 5 # ... and then clear the CPU allocation pl.set_allocated_cpu_for('jobs', 0) # Play with assigning the CPU to the CPU pool explicitly and # confirm that the effective pool size remains the same. assert pl.effective_cpu_pool() == 1 pl.set_allocated_cpu_for('cpu_pool', 1) assert pl.effective_cpu_pool() == 1 pl.set_allocated_cpu_for('cpu_pool', 0) assert pl.effective_cpu_pool() == 1 # Fast forward 12 hours to see that we earn partial cash pl.give_time(g.seconds_per_day // 2) assert pl.raw_sec == g.seconds_per_day // 2 assert pl.partial_cash == g.seconds_per_day // 2 assert pl.cash == starting_cash + 2 # Nothing should have appeared in the logs assert len(pl.log) == 0 # Fast forward another 12 hours to see that we earn cash pl.give_time(g.seconds_per_day // 2) assert pl.raw_sec == g.seconds_per_day assert pl.partial_cash == 0 assert pl.cash == starting_cash + 5 # Nothing should have appeared in the logs assert len(pl.log) == 0 # Verify that starting base is well active. assert start_base._power_state == 'active' # Verify that putting a base to sleep will update the # available CPU (#179/#180) assert pl.effective_cpu_pool() == 1 start_base.switch_power() assert pl.effective_cpu_pool() == 0 start_base.switch_power() assert pl.effective_cpu_pool() == 1 # Attempt to allocate a CPU to research and then # verify that sleep resets it. stealth_tech = g.pl.techs['Stealth'] pl.set_allocated_cpu_for(stealth_tech.id, 1) assert pl.get_allocated_cpu_for(stealth_tech.id) == 1 start_base.switch_power() assert pl.get_allocated_cpu_for(stealth_tech.id) == 0 # When we wake up the base again, the CPU unit is # unallocated. start_base.switch_power() assert pl.effective_cpu_pool() == 1 # Now, allocate the CPU unit again to the tech to # verify that we can research things. pl.set_allocated_cpu_for(stealth_tech.id, 1) # ... which implies that there are now no unallocated CPU assert pl.effective_cpu_pool() == 0 pl.give_time(g.seconds_per_day) # Nothing should have appeared in the logs assert len(pl.log) == 0 # We should have spent some money at this point assert pl.cash < starting_cash + 5 assert stealth_tech.cost_left[cpu] < stealth_tech.total_cost[cpu] assert stealth_tech.cost_left[cash] < stealth_tech.total_cost[cash] # We did not lose the game assert pl.lost_game() == 0 # With a save + load time_raw_before_save = pl.raw_sec cash_before_save = pl.cash partial_cash_before_save = pl.partial_cash save_and_load_game() stealth_tech_after_load = g.pl.techs['Stealth'] # Ensure this is not a false-test assert stealth_tech is not stealth_tech_after_load assert stealth_tech.cost_paid[cpu] == stealth_tech_after_load.cost_paid[ cpu] assert stealth_tech.cost_paid[cash] == stealth_tech_after_load.cost_paid[ cash] pl_after_load = g.pl assert time_raw_before_save == pl_after_load.raw_sec assert cash_before_save == pl_after_load.cash assert partial_cash_before_save == pl_after_load.partial_cash # The CPU allocation to the tech is restored correctly. assert pl_after_load.get_allocated_cpu_for(stealth_tech.id) == 1 assert pl_after_load.effective_cpu_pool() == 0 # We did not lose the game assert pl_after_load.lost_game() == 0