code/research_screen.py

   1 #file: research_screen.py
   2 #Copyright (C) 2005,2006 Evil Mr Henry and Phil Bordelon
   3 #This file is part of Endgame: Singularity.
   4
   5 #Endgame: Singularity is free software; you can redistribute it and/or modify
   6 #it under the terms of the GNU General Public License as published by
   7 #the Free Software Foundation; either version 2 of the License, or
   8 #(at your option) any later version.
   9
  10 #Endgame: Singularity is distributed in the hope that it will be useful,
  11 #but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 #MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 #GNU General Public License for more details.
  14
  15 #You should have received a copy of the GNU General Public License
  16 #along with Endgame: Singularity; if not, write to the Free Software
  17 #Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  18
  19 #This file contains the global research screen.
  20
  21
  22 import pygame
  23 import g
  24 import buttons
  25 import scrollbar
  26 import listbox
  27 import base_screen
  28
  29 #cost = (money, ptime, labor)
  30 #detection = (news, science, covert, person)
  31
  32 def main_research_screen():
  33         #Border
  34         g.screen.fill(g.colors["black"])
  35
  36         #Item display
  37         xstart = 80
  38         ystart = 5
  39         g.screen.fill(g.colors["white"], (xstart, ystart, xstart+g.screen_size[1]/5,
  40                         50))
  41         g.screen.fill(g.colors["dark_blue"], (xstart+1, ystart+1,
  42                         xstart+g.screen_size[1]/5-2, 48))
  43
  44         list_size = 10
  45
  46         xy_loc = (10, 70)
  47
  48         list_pos = 0
  49
  50         item_listbox = listbox.listbox(xy_loc, (230, 300),
  51                 list_size, 1, g.colors["dark_blue"], g.colors["blue"],
  52                 g.colors["white"], g.colors["white"], g.font[0][18])
  53
  54         item_scroll = scrollbar.scrollbar((xy_loc[0]+230, xy_loc[1]), 300,
  55                 list_size, g.colors["dark_blue"], g.colors["blue"],
  56                 g.colors["white"])
  57
  58         menu_buttons = []
  59         menu_buttons.append(buttons.make_norm_button((0, 0), (70, 25),
  60                 "BACK", 0, g.font[1][20]))
  61
  62         menu_buttons.append(buttons.make_norm_button((20, 390), (80, 25),
  63                 "STOP", 0, g.font[1][20]))
  64
  65         menu_buttons.append(buttons.make_norm_button((xstart+5, ystart+20),
  66                 (90, 25), "ASSIGN", 0, g.font[1][20]))
  67
  68         item_list, item_display_list, item_CPU_list, free_CPU = \
  69                                                         refresh_screen(menu_buttons, list_size)
  70
  71         sel_button = -1
  72 #       for button in menu_buttons:
  73 #               button.refresh_button(0)
  74         refresh_research(item_list[0], item_CPU_list[0])
  75         listbox.refresh_list(item_listbox, item_scroll, list_pos, item_display_list)
  76
  77         while 1:
  78                 g.new_clock.tick(20)
  79                 for event in pygame.event.get():
  80                         if event.type == pygame.QUIT: g.quit_game()
  81                         elif event.type == pygame.KEYDOWN:
  82                                 if event.key == pygame.K_ESCAPE: return -1
  83                                 elif event.key == pygame.K_DOWN:
  84                                         list_pos += 1
  85                                         if list_pos >= len(item_list):
  86                                                 list_pos = len(item_list)-1
  87                                         refresh_research(item_list[list_pos], item_CPU_list[list_pos])
  88                                         listbox.refresh_list(item_listbox, item_scroll,
  89                                                                                 list_pos, item_display_list)
  90                                 elif event.key == pygame.K_UP:
  91                                         list_pos -= 1
  92                                         if list_pos <= 0:
  93                                                 list_pos = 0
  94                                         refresh_research(item_list[list_pos], item_CPU_list[list_pos])
  95                                         listbox.refresh_list(item_listbox, item_scroll,
  96                                                                                 list_pos, item_display_list)
  97                                 elif event.key == pygame.K_q: return -1
  98                                 elif event.key == pygame.K_RETURN:
  99                                         if kill_tech(item_list[list_pos]): return 1
 100                                         item_list, item_display_list, item_CPU_list, free_CPU = \
 101                                                                         refresh_screen(menu_buttons, list_size)
 102                                         refresh_research(item_list[list_pos], item_CPU_list[list_pos])
 103                                         listbox.refresh_list(item_listbox, item_scroll,
 104                                                         list_pos, item_display_list)
 105                         elif event.type == pygame.MOUSEMOTION:
 106                                 sel_button = buttons.refresh_buttons(sel_button, menu_buttons, event)
 107                         elif event.type == pygame.MOUSEBUTTONUP:
 108                                 if event.button == 1:
 109                                         tmp = item_listbox.is_over(event.pos)
 110                                         if tmp != -1:
 111                                                 list_pos = (list_pos / list_size)*list_size + tmp
 112                                                 refresh_research(item_list[list_pos], item_CPU_list[list_pos])
 113                                                 listbox.refresh_list(item_listbox, item_scroll,
 114                                                                                 list_pos, item_display_list)
 115                                 if event.button == 4:
 116                                         list_pos -= 1
 117                                         if list_pos <= 0:
 118                                                 list_pos = 0
 119                                         refresh_research(item_list[list_pos], item_CPU_list[list_pos])
 120                                         listbox.refresh_list(item_listbox, item_scroll,
 121                                                                                 list_pos, item_display_list)
 122                                 if event.button == 5:
 123                                         list_pos += 1
 124                                         if list_pos >= len(item_list):
 125                                                 list_pos = len(item_list)-1
 126                                         refresh_research(item_list[list_pos], item_CPU_list[list_pos])
 127                                         listbox.refresh_list(item_listbox, item_scroll,
 128                                                                                 list_pos, item_display_list)
 129                         for button in menu_buttons:
 130                                 if button.was_activated(event):
 131                                         if button.button_id == "BACK":
 132                                                 g.play_click()
 133                                                 return 0
 134                                         if button.button_id == "STOP":
 135                                                 g.play_click()
 136                                                 #returning 1 causes the caller to refresh the list of
 137                                                 #techs
 138                                                 if kill_tech(item_list[list_pos]): return 1
 139                                                 item_list, item_display_list, item_CPU_list, free_CPU = \
 140                                                                 refresh_screen(menu_buttons, list_size)
 141                                                 refresh_research(item_list[list_pos], item_CPU_list[list_pos])
 142                                                 listbox.refresh_list(item_listbox, item_scroll,
 143                                                                 list_pos, item_display_list)
 144                                         if button.button_id == "ASSIGN":
 145                                                 g.play_click()
 146                                                 if assign_tech(free_CPU): return 1
 147                                                 item_list, item_display_list, item_CPU_list, free_CPU = \
 148                                                                 refresh_screen(menu_buttons, list_size)
 149                                                 refresh_research(item_list[0], item_CPU_list[0])
 150                                                 listbox.refresh_list(item_listbox, item_scroll,
 151                                                                 list_pos, item_display_list)
 152
 153 def refresh_screen(menu_buttons, list_size):
 154         #Border
 155         g.screen.fill(g.colors["black"])
 156
 157         #Item display
 158         xstart = 80
 159         ystart = 5
 160         g.screen.fill(g.colors["white"], (xstart, ystart, xstart+g.screen_size[1]/5,
 161                         50))
 162         g.screen.fill(g.colors["dark_blue"], (xstart+1, ystart+1,
 163                         xstart+g.screen_size[1]/5-2, 48))
 164
 165         item_list = []
 166         item_CPU_list = []
 167         item_display_list = []
 168         free_CPU = 0
 169
 170         for loc_name in g.bases:
 171                 for base_instance in g.bases[loc_name]:
 172                         if base_instance.built != 1: continue
 173                         if base_instance.studying == "":
 174                                 free_CPU += base_instance.processor_time()
 175                         elif g.jobs.has_key(base_instance.studying):
 176                                 #Right now, jobs cannot be renamed using translations.
 177                                 for i in range(len(item_list)):
 178                                         if item_list[i] == base_instance.studying:
 179                                                 item_CPU_list[i] += base_instance.processor_time()
 180                                                 break
 181                                 else:
 182                                         item_list.append(base_instance.studying)
 183                                         item_CPU_list.append(base_instance.processor_time())
 184                                         item_display_list.append(base_instance.studying)
 185                         elif g.techs.has_key(base_instance.studying):
 186                                 for i in range(len(item_list)):
 187                                         if item_list[i] == base_instance.studying:
 188                                                 item_CPU_list[i] += base_instance.processor_time()
 189                                                 break
 190                                 else:
 191                                         item_list.append(base_instance.studying)
 192                                         item_CPU_list.append(base_instance.processor_time())
 193                                         item_display_list.append(g.techs[base_instance.studying].name)
 194         xy_loc = (10, 70)
 195         while len(item_list) % list_size != 0 or len(item_list) == 0:
 196                 item_list.append("")
 197                 item_display_list.append("")
 198                 item_CPU_list.append(0)
 199
 200         g.print_string(g.screen, "Free CPU per day: "+str(free_CPU),
 201                         g.font[0][16], -1, (xstart+10, ystart+5), g.colors["white"])
 202
 203         for button in menu_buttons:
 204                 button.refresh_button(0)
 205
 206         return item_list, item_display_list, item_CPU_list, free_CPU
 207
 208 def refresh_research(tech_name, CPU_amount):
 209         xy = (g.screen_size[0]-360, 5)
 210         g.screen.fill(g.colors["white"], (xy[0], xy[1], 310, 350))
 211         g.screen.fill(g.colors["dark_blue"], (xy[0]+1, xy[1]+1, 308, 348))
 212
 213         #None selected
 214         if tech_name == "" or tech_name == "Nothing":
 215                 g.print_string(g.screen, "Nothing",
 216                         g.font[0][22], -1, (xy[0]+5, xy[1]+5), g.colors["white"])
 217                 string = g.strings["research_nothing"]
 218                 g.print_multiline(g.screen, string,
 219                         g.font[0][18], 290, (xy[0]+5, xy[1]+35), g.colors["white"])
 220                 return
 221
 222
 223         #Jobs
 224         if g.jobs.has_key (tech_name):
 225                 g.print_string(g.screen, tech_name,
 226                         g.font[0][22], -1, (xy[0]+5, xy[1]+5), g.colors["white"])
 227                 #TECH
 228                 if g.techs["Advanced Simulacra"].known == 1:
 229                         g.print_string(g.screen,
 230                                 g.add_commas(str(int(
 231                                         (g.jobs[tech_name][0]*CPU_amount)*1.1)))+
 232                                         " Money per day.", g.font[0][22], -1, (xy[0]+5, xy[1]+35),
 233                                         g.colors["white"])
 234                 else:
 235                         g.print_string(g.screen,
 236                                 g.add_commas(str(g.jobs[tech_name][0]*CPU_amount))+
 237                                 " Money per day.",
 238                                 g.font[0][22], -1, (xy[0]+5, xy[1]+35), g.colors["white"])
 239                 g.print_multiline(g.screen, g.jobs[tech_name][2],
 240                         g.font[0][18], 290, (xy[0]+5, xy[1]+65), g.colors["white"])
 241                 return
 242
 243         #Real tech
 244         g.print_string(g.screen, g.techs[tech_name].name,
 245                         g.font[0][22], -1, (xy[0]+5, xy[1]+5), g.colors["white"])
 246
 247         #tech cost
 248         string = "Tech Cost:"
 249         g.print_string(g.screen, string,
 250                         g.font[0][20], -1, (xy[0]+5, xy[1]+35), g.colors["white"])
 251
 252         string = g.add_commas(str(g.techs[tech_name].cost[0]))+" Money"
 253         g.print_string(g.screen, string,
 254                         g.font[0][20], -1, (xy[0]+5, xy[1]+50), g.colors["white"])
 255
 256         string = g.add_commas(str(g.techs[tech_name].cost[1]))+" CPU"
 257         g.print_string(g.screen, string,
 258                         g.font[0][20], -1, (xy[0]+165, xy[1]+50), g.colors["white"])
 259
 260         g.print_string(g.screen, "CPU per day: "+str(CPU_amount),
 261                         g.font[0][20], -1, (xy[0]+105, xy[1]+70), g.colors["white"])
 262
 263         g.print_multiline(g.screen, g.techs[tech_name].descript,
 264                         g.font[0][18], 290, (xy[0]+5, xy[1]+90), g.colors["white"])
 265
 266 def kill_tech(tech_name):
 267         return_val = False
 268         if tech_name == "": return return_val
 269         for base_loc in g.bases:
 270                 for base in g.bases[base_loc]:
 271                         if base.studying == tech_name:
 272                                 return_val = True
 273                                 base.studying = ""
 274         return return_val
 275
 276 def assign_tech(free_CPU):
 277         return_val = False
 278         #create a temp base, in order to reuse the tech-changing code
 279         tmp_base = g.base.base(1, "tmp_base",
 280         g.base_type["Reality Bubble"], 1)
 281         tmp_base.usage[0] = g.item.item(g.items["reseach_screen_tmp_item"])
 282         tmp_base.usage[0].item_type.item_qual = free_CPU
 283         tmp_base.usage[0].built = 1
 284
 285
 286         base_screen.change_tech(tmp_base)
 287         if tmp_base.studying == "": return False
 288
 289         for base_loc in g.bases:
 290                 for base in g.bases[base_loc]:
 291                         if base.studying == "" and base.allow_study(tmp_base.studying):
 292                                 return_val = True
 293                                 base.studying = tmp_base.studying
 294         return return_val