def create_star(ai_settings, screen, stars, star_number, row_number): """Создает звезду и размещает его в ряду.""" star = Star(ai_settings, screen) star_width = star.rect.width star.x = star_width + 4 * star_width * star_number + randint(-32, 32) star.rect.x = star.x star.rect.y = star.rect.height + 4 * star.rect.height * \ row_number + randint(-32,32) stars.add(star)
def create_star(ai_settings, screen, stars, x_number, y_number): random_star = random.randint(0, 3) star = Star(ai_settings, screen, random_star) star_width = star.rect.width star_height = star.rect.height star.x = 2 * star_width * x_number + star_width * (random.randint(-8, 8) / 16 + 1) star.y = 2 * star_height * y_number + star_height * random.randint(0, 16) / 16 star.rect.x = star.x star.rect.y = star.y stars.add(star)
def create_star(ai_settings, screen, stars): """Add stars to the group until it reach its limit""" count = 0 while count < ai_settings.star_max: new_star = Star(ai_settings, screen) stars.add(new_star) count += 1
def _create_star(self, x, y): star = Star(self) star.rect.x = x star.rect.y = y self.stars.add(star)
def __init__(self): '''初始化游戏''' Settings.__init__(self) # boom init self.booms = Group() self.ship_boom = Boom1() self.boom_count = 0 # background self.background_picture = "images/background_1.jpg" self.background_arrow = 0 # music init self.music_count = 0 # screen init self.screen_size = (self.screen_width, self.screen_height) # stars init self.stars = Group() for i in range(self.num_stars): new_star = Star() self.stars.add(new_star) pass # ship self.ship = Ship() self.ship_bullets = Group() # aliens self.aliens = Group() self.aliens_bullets = Group() pass
def create_stars(ai_settings, screen, stars): star = Star(ai_settings, screen, random.randint(0, 3)) number_stars_x, number_stars_y = get_number_stars_x_y(ai_settings, star.rect.width, star.rect.height) for x_number in range(number_stars_x): for y_number in range(number_stars_y): create_star(ai_settings, screen, stars, x_number, y_number)
def parse_line(line, name): alpha = convert_hours_to_angle(line[4:14].replace(' ', '0')) delta = convert_str_to_angle(line[16:24].replace(' ', '0')) if line[15] == '-': delta = -delta delta = 90 - delta color = line[49] let = line[103:106] m = float(line[41:46].replace(' ', '0')) return Star(spherical_to_decart(alpha, delta), color, m, name, GREEK[let])
def add_star(ai_settings, screen, stars): '''Создает звезды''' star = Star(screen, ai_settings) available_space_x = ai_settings.screen_width - 25 number_star_x = int(available_space_x/15) available_space_y = ai_settings.screen_height - 25 number_rows = int(available_space_y / 15) for row_number in range(12): for star_number in range(17): star = Star(screen, ai_settings) star.rect.x = 50 * star_number + randint(-20, 20) star.rect.y = 50 * row_number + randint(-20, 20) stars.add(star)
def create_many_stars(ai_settings, screen, ship, stars): """Создает звёзды.""" # Создание звезды и вычисление количества заёзд в ряду. star = Star(ai_settings, screen) number_stars_x = get_number_stars_x(ai_settings, star.rect.width) number_rows = get_number_star_rows(ai_settings, ship.rect.height, star.rect.height) # Создание множества звёзд. for row_number in range(number_rows): for star_number in range(number_stars_x): create_star(ai_settings, screen, stars, star_number, row_number)
def _create_stars_grid(self): """Создание сетки звёзд""" # Создание одной звезды star = Star(self) avaible_star_space_x = self.settings.screen_width avaible_star_space_y = self.settings.screen_height star_height = star.rect.y star_width = star.rect.x i = 0 star_x = [0] star_y = [0] for i in range(60): cur_pos_x = randrange(0, 1900, 50) cur_pos_y = randrange(0, 1080, 45) for x in star_x: if cur_pos_x == x: cur_pos_x = randrange(0, 1900, 50) star_x.append(cur_pos_x) break else: star_x.append(cur_pos_x) break for y in star_y: if cur_pos_y == y: cur_pos_y = randrange(0, 1080, 45) star_y.append(cur_pos_y) break else: star_y.append(cur_pos_y) break if star_x[i] == 0 and star_y[i] == 0: star.remove() else: self._create_star(star_x[i], star_y[i])
def creat_bg(ai_settings, screen, stars): star = Star(ai_settings, screen) star_width = star.rect.width number_rows = get_star_row_number(star, ai_settings) star_numbers = get_star_number_x(star, ai_settings) if len(stars) <= 400: for star_y in range(number_rows): for star_x in range(star_numbers): creat_star(ai_settings, screen, star_y, star_x, star.rect.width, star.rect.height, stars)
def create_stars_background(ai_settings, screen, stars): """Create a full screen of stars""" star = Star(screen) if len(stars) < 50: for star_number in range(1): star = Star(screen) star.x = randint(0, ai_settings.screen_width) star.y = randint(0, ai_settings.screen_height) star.rect.x = star.x star.rect.y = star.y stars.add(star)
def main(input_file): with open(input_file, 'r') as f: lines = f.readlines() stars_not_in_const = [] for line in lines: x, y, z, w = [int(a) for a in line.split(',')] stars_not_in_const.append(Star(x, y, z, w)) constellations = [] while len(stars_not_in_const) > 0: # Create new const new_const = Constellation() new_const.add_star(stars_not_in_const.pop(0)) for star in new_const.stars: # add to the constellation all non-placed stars # which are in distance with a star of the constellation # search for nearby stars remaining_stars = copy(stars_not_in_const) for star2 in stars_not_in_const: if star.manhattan_dist(star2) <= 3: new_const.add_star(star2) remaining_stars.remove(star2) stars_not_in_const = remaining_stars constellations.append(new_const) print('PART 1') print('List of constellations:') for i, c in enumerate(constellations): print(f'- Constellation {i}: {c}') print() print(f'Number of constellations = {len(constellations)}')
def create_star_and_vz(stars, vzs, screen, ai_settings, num): star = Star(screen, stars, ai_settings, num) vz = Visualization(screen, ai_settings, star) stars.add(star) vzs.add(vz)
def _build(self, review_data, app_version, logged_in_person, useful_votes): # all the attributes of review_data may need markup escape, # depending on if they are used as text or markup self.id = review_data.id self.person = review_data.reviewer_username displayname = review_data.reviewer_displayname # example raw_date str format: 2011-01-28 19:15:21 cur_t = self._get_datetime_from_review_date(review_data.date_created) review_version = review_data.version self.useful_total = useful_total = review_data.usefulness_total useful_favorable = review_data.usefulness_favorable useful_submit_error = review_data.usefulness_submit_error delete_error = review_data.delete_error modify_error = review_data.modify_error # upstream version version = GLib.markup_escape_text(upstream_version(review_version)) # default string version_string = _("For version %(version)s") % { 'version': version, } # If its for the same version, show it as such if (review_version and app_version and upstream_version_compare( review_version, app_version) == 0): version_string = _("For this version (%(version)s)") % { 'version': version, } m = '<small>%s</small>' self.version_label.set_markup(m % version_string) m = self._whom_when_markup(self.person, displayname, cur_t) who_when = Gtk.Label() who_when.set_name("subtle-label") who_when.set_justify(Gtk.Justification.RIGHT) who_when.set_markup(m) summary = Gtk.Label() try: s = GLib.markup_escape_text(review_data.summary.encode("utf-8")) summary.set_markup('<b>%s</b>' % s) except Exception: LOG.exception("_build() failed") summary.set_text("Error parsing summary") summary.set_ellipsize(Pango.EllipsizeMode.END) summary.set_selectable(True) summary.set_alignment(0, 0.5) text = Gtk.Label() text.set_text(review_data.review_text) text.set_line_wrap(True) text.set_line_wrap_mode(Pango.WrapMode.WORD_CHAR) text.set_selectable(True) text.set_alignment(0, 0) stars = Star() stars.set_rating(review_data.rating) a = Gtk.Alignment.new(0.5, 0.5, 0, 0) a.add(stars) self.header.pack_start(a, False, False, 0) self.header.pack_start(summary, False, False, 0) self.header.pack_end(who_when, False, False, 0) self.body.pack_start(text, False, False, 0) current_user_reviewer = False if self.person == self.logged_in_person: current_user_reviewer = True self._build_usefulness_ui(current_user_reviewer, useful_total, useful_favorable, useful_votes, useful_submit_error) self.flagbox = Gtk.HBox() self.flagbox.set_spacing(4) self._build_delete_flag_ui(current_user_reviewer, delete_error, modify_error) self.footer.pack_end(self.flagbox, False, False, 0) # connect network signals self.connect("realize", lambda w: self._on_network_state_change()) watcher = get_network_watcher() watcher.connect("changed", lambda w, s: self._on_network_state_change())
pygame.display.set_caption("Elements Game") all_sprites_list = pygame.sprite.Group() all_flying = pygame.sprite.Group() # ---------------------------------------------------------------------------- # This group stores the instances of all asteroids. There are always three of # them. It is global as it is referred to in the main while loop 'carryOn'. # ---------------------------------------------------------------------------- all_asteroids = pygame.sprite.Group() # === Create background stars === for i in range(1, 40): surface2 = pygame.Surface([20, 20], pygame.SRCALPHA) newstar = Star(surface2, WHITE, (10, 10), random.randint(1, 2), 20) # surface, colour, position, radius, speed all_flying.add(newstar) all_sprites_list.add(newstar) # === initalise font object to render text later === font = pygame.font.Font('OpenSans-Semibold.ttf', 24) carryOn = True clock = pygame.time.Clock() # === Two menu screens before main game === selection = game_difficulty(screen, BLACK, WHITE, BLUE, font, WIDTH, HEIGHT, Star, clock) username = game_intro(WIDTH, HEIGHT, screen, BLACK, WHITE, font, Star, clock)
def create_stars(ai_settings,screen,stars): for _ in range(ai_settings.stars_number): star=Star(ai_settings,screen) stars.add(star) return stars
def creat_star(ai_settings, screen, star_y, star_x, star_width, star_height, stars): star = Star(ai_settings, screen) star.rect.x = (star_width + 5 * star_width * star_x + randint(-20, 20)) star.rect.y = -(star_height + 5 * star_height * star_y + randint(-20, 20)) stars.add(star)
class Prediction(object): def __init__(self, body, date='2001-01-01', time='00:00:00'): self.setBody(body) self.setReferenceDateTime('2001-01-01', '00:00:00') self.setObservationDateTime(date, time) self.refGHA = Angle.parse('100d42.6') def setBody(self, body): self.star = Star(body) def setObservationDateTime(self, date, time): obsDate = datetime.strptime(date + ' ' + time, '%Y-%m-%d %H:%M:%S') if hasattr(self, 'refDate') and obsDate < self.refDate: raise ValueError('observation date > reference date') self.obsDate = obsDate def setReferenceDateTime(self, date, time): refDate = datetime.strptime(date + ' ' + time, '%Y-%m-%d %H:%M:%S') if hasattr(self, 'obsDate') and self.obsDate < refDate: raise ValueError('observation date > reference date') self.refDate = refDate def cumulativeProgression(self): return (self.obsDate.year - self.refDate.year) \ * float(Angle.parse('-0d14.31667')) def leapProgression(self): leap = 0 for i in xrange(self.refDate.year, self.obsDate.year): leap += 1 if i % 4 == 0 and (i % 100 != 0 or i % 400 == 0) else 0 return 0.9829167 * leap def ariesGHA(self): return float(Angle(float(self.refGHA) + self.cumulativeProgression() \ + self.leapProgression() + self.rotationAngle()) .normalize(0.0, 360.0)) def rotationAngle(self): return (self.obsDate - datetime(self.obsDate.year, self.obsDate.month, 1)).total_seconds() \ / 86164.1 * 360.0 def starGHA(self): return Angle( float( Angle(self.ariesGHA() + float(self.star.getSHA())).normalize( 0.0, 360.0))) def starDeclination(self): return self.star.getDeclination() @classmethod def dispatch(Prediction, values): try: if 'long' in values or 'lat' in values: raise ValueError('key "long" or "lat" can\'t be present') prediction = Prediction( values['body'], ('2001-01-01' if 'date' not in values else values['date']), ('00:00:00' if 'time' not in values else values['time'])) values['long'], values['lat'] = str(prediction.starGHA()), \ str(prediction.starDeclination()) except Exception as e: values['error'] = str(e) return values
bossShipImages = [graphics.g_ships.boss01, graphics.g_ships.boss02, graphics.g_ships.boss03, graphics.g_ships.boss04] explosionFrames = [graphics.g_explosion.explode01, graphics.g_explosion.explode02, graphics.g_explosion.explode03, graphics.g_explosion.explode04, graphics.g_explosion.explode05, graphics.g_explosion.explode06, graphics.g_explosion.explode07, graphics.g_explosion.explode08, graphics.g_explosion.explode09, graphics.g_explosion.explode10, graphics.g_explosion.explode11] dropImages = [graphics.g_items.drop01, graphics.g_items.drop02, graphics.g_items.drop03, graphics.g_items.spaceman] bulletImages = [graphics.g_bullets.bullet01, graphics.g_bullets.bullet02, graphics.g_bullets.bullet03, graphics.g_bullets.bullet04, graphics.g_bullets.bullet05] # Create stars for i in range(10): tmpX = random.getrandbits(7) tmpY = random.getrandbits(6) tmpSpd = random.getrandbits(2) if tmpSpd == 0: tmpSpd = 1 tmpClr = random.getrandbits(4) if tmpClr == 0: tmpClr = 15 starList.append(Star(tmpX, tmpY, tmpSpd, tmpClr)) # Create ship flames for i in range(4): tmpX = playerPos[0] + random.getrandbits(3) tmpY = playerPos[0] + 20 tmpSpd = random.getrandbits(3) if tmpSpd == 0: tmpSpd = 1 if tmpClr == 0: tmpClr = 15 flameList.append(Flames(tmpX, tmpY, tmpSpd)) # Create rocks for i in range(6): tmpX = random.getrandbits(7)
def _build(self, review_data, app_version, logged_in_person, useful_votes): # all the attributes of review_data may need markup escape, # depending on if they are used as text or markup self.id = review_data.id self.person = review_data.reviewer_username displayname = review_data.reviewer_displayname # example raw_date str format: 2011-01-28 19:15:21 cur_t = self._get_datetime_from_review_date(review_data.date_created) review_version = review_data.version self.useful_total = useful_total = review_data.usefulness_total useful_favorable = review_data.usefulness_favorable useful_submit_error = review_data.usefulness_submit_error delete_error = review_data.delete_error modify_error = review_data.modify_error # upstream version version = GLib.markup_escape_text(upstream_version(review_version)) # default string version_string = _("For version %(version)s") % { 'version': version, } # If its for the same version, show it as such if (review_version and app_version and upstream_version_compare(review_version, app_version) == 0): version_string = _("For this version (%(version)s)") % { 'version': version, } m = '<small>%s</small>' self.version_label.set_markup(m % version_string) m = self._whom_when_markup(self.person, displayname, cur_t) who_when = Gtk.Label() who_when.set_name("subtle-label") who_when.set_justify(Gtk.Justification.RIGHT) who_when.set_markup(m) summary = Gtk.Label() try: s = GLib.markup_escape_text(review_data.summary.encode("utf-8")) summary.set_markup('<b>%s</b>' % s) except Exception: LOG.exception("_build() failed") summary.set_text("Error parsing summary") summary.set_ellipsize(Pango.EllipsizeMode.END) summary.set_selectable(True) summary.set_alignment(0, 0.5) text = Gtk.Label() text.set_text(review_data.review_text) text.set_line_wrap(True) text.set_line_wrap_mode(Pango.WrapMode.WORD_CHAR) text.set_selectable(True) text.set_alignment(0, 0) stars = Star() stars.set_rating(review_data.rating) a = Gtk.Alignment.new(0.5, 0.5, 0, 0) a.add(stars) self.header.pack_start(a, False, False, 0) self.header.pack_start(summary, False, False, 0) self.header.pack_end(who_when, False, False, 0) self.body.pack_start(text, False, False, 0) current_user_reviewer = False if self.person == self.logged_in_person: current_user_reviewer = True self._build_usefulness_ui(current_user_reviewer, useful_total, useful_favorable, useful_votes, useful_submit_error) self.flagbox = Gtk.HBox() self.flagbox.set_spacing(4) self._build_delete_flag_ui(current_user_reviewer, delete_error, modify_error) self.footer.pack_end(self.flagbox, False, False, 0) # connect network signals self.connect("realize", lambda w: self._on_network_state_change()) watcher = get_network_watcher() watcher.connect( "changed", lambda w, s: self._on_network_state_change())
def gen_stars(ai_settings, screen, stars): '''Generate stars that randomly appear at one edge of the screen and move left.''' # use a random function to randomly generate points for the start to appear if len(stars) < ai_settings.stars_allowed * 2: new_star = Star(ai_settings, screen) stars.add(new_star)
def setBody(self, body): self.star = Star(body)