def __init__(self, learning=True, epsilon=1, alpha=0.1, discount=1, tolerance=0.01): self.Q = dict() self.Q1 = dict() self.Q2 = dict() self.s = states.States() self.s.buildAllStates() self.cnn = Cnn() self.learning = learning self.epsilon = epsilon self.alpha = alpha self.discount = discount self.tolerance = tolerance self.t = 2 self.convolutionLayersNumber = 0 self.poolingLayersNumber = 0 self.fullyConnectedLayersNumber = 0 self.convolutionLayersLimit = 3 self.poolingLayersLimit = 2 self.fullyConnectedLayersLimit = 2 self.actionsInitialState() self.actionsConvolutionState() self.actionsPoolingState() self.actionsFullyConnectedState()
class Message (BaseObject, pygame.sprite.Sprite): font = None states = states.States('displaying', 'finished') state = None message_count = None verticle_padding = 5 def __init__ (self, manager, message, display_duration=3500, font_path='./fonts/'): BaseObject.__init__(self) pygame.sprite.Sprite.__init__(self) if Message.font == None: # Bitstream Vera Sans Mono Message.font = pygame.font.Font(font_path+'VeraMoBd.ttf', 12) # Increment the number of messages being displayed if Message.message_count == None: Message.message_count = 0 else: Message.message_count += 1 # Basically a duplication of damage animation - damage animation should probably be derived from this self.manager = manager shadow_offset = 3 text = Message.font.render(message, True, (200,200,200)).convert_alpha() shadow = Message.font.render(message, True, (50,50,50)).convert_alpha() self.image = pygame.surface.Surface( (text.get_width() + shadow_offset, text.get_height() + shadow_offset), 0, 32).convert_alpha() self.image.fill((0,0,0,0)) self.image.blit(shadow, (shadow_offset, shadow_offset)) self.image.blit(text, (0, 0)) display_geometery = pygame.display.get_surface().get_rect() x = (display_geometery.width - self.image.get_width()) / 2 y = (display_geometery.height - self.image.get_height()) / 2 + (self.image.get_height() * (Message.message_count-1)) self.rect = pygame.rect.Rect(x, y, self.image.get_width(), self.image.get_height()) self.display_duration = float(display_duration) self.state = self.states.displaying self.timestamp = pygame.time.get_ticks() self.emit(constants.EVENT_ENTITY_WAIT, 0) def update (self, ticks): if self.state == self.states.displaying: if ticks > self.timestamp + self.display_duration: self.state = self.states.finished # Decrement the number of messages being displayed Message.message_count -= 1 # Clean up self.emit(constants.EVENT_ENTITY_READY, 0) self.destroy() self.kill()
class LaserBlast(BaseObject, pygame.sprite.Sprite): states = states.States('idle', 'animating') state = None def __init__(self, manager, weapon, source_position, destination_position): BaseObject.__init__(self) pygame.sprite.Sprite.__init__(self) self.manager = manager self.weapon = weapon self.weapon.duration = float( self.weapon.duration) # ensure we are using floats self.padding = self.weapon.width self.source_position = source_position self.destination_position = destination_position self.idle_image = pygame.surface.Surface((0, 0)) self.image = self.idle_image self.rect = pygame.rect.Rect(self.source_position[0], self.source_position[1], self.image.get_width(), self.image.get_height()) self.framecount = 0 self.frameskip = 2 # Prerender the laser self.draw_laser() # Start animation self.current_pulse = 0 self.image = self.laser_image self.rect = self.laser_rect self.timestamp = pygame.time.get_ticks() self.state = self.states.animating self.emit(constants.EVENT_ENTITY_WAIT, self) def draw_laser(self): # determin width xwidth = (self.destination_position[0] - self.source_position[0]) ywidth = (self.destination_position[1] - self.source_position[1]) # alter width for padding if xwidth < 0: xwidth -= self.padding * 2 else: xwidth += self.padding * 2 if ywidth < 0: ywidth -= self.padding * 2 else: ywidth += self.padding * 2 # Create the laser alpha channel surface tmp_image = pygame.surface.Surface( (abs(xwidth), abs(ywidth))).convert_alpha() tmp_image.fill((0, 0, 0)) self.laser_rect = tmp_image.get_rect() # reorganise position variables depending on which quater we are in, also update our rect if xwidth > 0: if ywidth > 0: pos0 = [self.padding, self.padding] pos1 = [ self.laser_rect.width - self.padding, self.laser_rect.height - self.padding ] self.laser_rect.move_ip( (self.source_position[0] - self.padding, self.source_position[1] - self.padding)) else: pos0 = [self.laser_rect.width - self.padding, self.padding] pos1 = [self.padding, self.laser_rect.height - self.padding] self.laser_rect.move_ip( (self.source_position[0] - self.padding, self.destination_position[1] - self.padding)) else: if ywidth > 0: pos0 = [self.laser_rect.width - self.padding, self.padding] pos1 = [self.padding, self.laser_rect.height - self.padding] self.laser_rect.move_ip( (self.destination_position[0] - self.padding, self.source_position[1] - self.padding)) else: pos0 = [self.padding, self.padding] pos1 = [ self.laser_rect.width - self.padding, self.laser_rect.height - self.padding ] self.laser_rect.move_ip( (self.destination_position[0] - self.padding, self.destination_position[1] - self.padding)) # Draw laser pygame.draw.line(tmp_image, (255, 255, 255), pos0, (pos1[0], pos1[1]), self.weapon.width) # Blur surface (this will be a gaussian blur later and facilitate a less-poor looking beam) utility.blur_surface(tmp_image) utility.blur_surface(tmp_image) utility.blur_surface(tmp_image) tmp_array = pygame.surfarray.array3d(tmp_image) self.laser_image = tmp_image self.laser_image.fill(self.weapon.color) # cheap gradient, need to change this into a LUT of some kind w = self.weapon.width tm = (255 / w) color = (self.weapon.color[0], self.weapon.color[1], self.weapon.color[2]) while w > 0: color = (min(255, color[0] + tm), min(255, color[1] + tm), min(255, color[2] + tm)) pygame.draw.line(self.laser_image, color, pos0, (pos1[0], pos1[1]), w) w -= 1 pygame.surfarray.pixels_alpha(self.laser_image)[:, :] = tmp_array[:, :, 0] # Record of original alpha for blending self.laser_alpha = pygame.surfarray.array_alpha( self.laser_image.copy().convert_alpha()) #print self.laser_alpha, self.laser_image, self.laser_rect def update(self, ticks): if self.state == self.states.animating: self.framecount += 1 if self.framecount < self.frameskip: return self.framecount = 0 n = min(1, (ticks - self.timestamp) / self.weapon.duration) # Alpha fade pygame.surfarray.pixels_alpha(self.image)[:, :] = Numeric.multiply( self.laser_alpha, 1 - n).astype(Numeric.UInt8) if n == 1: # Loop if self.current_pulse < self.weapon.pulse: self.current_pulse += 1 self.timestamp = ticks else: # Complete animation self.state = self.states.idle # Clean up self.emit(constants.EVENT_ENTITY_READY, self) self.destroy() self.kill()
from connector.NeuroskyConnector import NeuroskyConnector from bluetooth.btcommon import BluetoothError from neurosky.parser import ThinkGearParser, TimeSeriesRecorder import wink, states from Talk import Talk import sys from nnet.A4NN import A4NN conn = NeuroskyConnector() socket = conn.getConnectionInstance() recorder = TimeSeriesRecorder() parser = ThinkGearParser(recorders=[recorder]) w = wink.Wink() s = states.States() t = Talk() net = A4NN() net.train() test_dataset = [ 87, 87, 97, 97, 97, 97, 97, 97, 97, 97, 97, 97, 107, 107, 107, 107, 107, 107, 167, 247, 55, 29, 59, 59, 29, 29, 29, 129, 129, 129, 129, 307, 309, 92, 37, 60, 72, 75, 97 ] result = net.predict(test_dataset) print("test-set validation. Expected: ~0 - Result:" + repr(result)) test_dataset = [ 85, 85, 85, 85, 85, 85, 85, 85, 85, 72, 72, 72, 97, 149, 337, 436, 436, 436, 436, 436, 436, 436, 436, 436, 436, 401, 295, 55, 55, 55, 55, 65, 121, 141, 141, 141, 141, 141, 141 ]
def __init__(self, *, rs=1.2, n_k_points=12, n_dimensions=2, instability_type='cRHF2cUHF', cylinder_radius=None, delta_fxn_magnitude=None, safe_eri=True): """Create the parameters object for the given parameters. :param rs: The wigner seitz radius, in 1 / bohr :type rs: float :param n_k_points: The number of reciprocal space grid points. Must be > 2 :type n_k_points: int :param n_dimensions: Number of physical dimensions: 1, 2 or 3. :type n_dimensions: int :param instability_type: The type of instability to be investigated. Must be one of the strings in the set __class__.instabilities_supported. :type instability_type: string :param cylinder_radius: The radius of the cylinder for the pseudo - 1 dimensional system. This is meant to be small such that motion in the radial dimension is 'frozen'. See the appendix of Guiliani and Vignale for a discussion on this. :type cylinder_radius: float :param delta_fxn_magnitude: The multiplicative constant for the delta function potential in 1 dimension. ( v(r12) = delta_fxn_magnitude * delta(r12) ) :type delta_fxn_magnitude: float :param safe_eri: Whether to check for momentum conservation explicitly in the two ERI. :type safe_eri: bool """ self.rs = rs self.n_k_points = n_k_points self.n_dimensions = n_dimensions self.safe_eri = safe_eri if self.n_dimensions == 1: if (cylinder_radius is None) and (delta_fxn_magnitude is None): raise ValueError( 'In one dimension, must specify exactly one of cylinder_radius or delta_fxn_magnitude, got Neither.' ) elif (cylinder_radius is not None) and (delta_fxn_magnitude is not None): raise ValueError( 'In one dimension, must specify exactly one of cylinder_radius or delta_fxn_magnitude, got Both.' ) elif (cylinder_radius is not None) and (delta_fxn_magnitude is None): self.cylinder_radius = cylinder_radius elif (cylinder_radius is None) and (delta_fxn_magnitude is not None): self.delta_fxn_magnitude = delta_fxn_magnitude self.instability_type = instability_type self.k_fermi = __class__._calc_k_fermi(rs=self.rs, n_dimensions=self.n_dimensions) self.k_max = (2.0 + 1E-8) * self.k_fermi # A bit offset from 2 helps with # not getting states exactly at kmax. # Make a grid 1 point too big then remove the last. This gives the desired # number of points in the grid, while removing equivalent points at # opposite ends of the first Brillouin zone. self.k_grid = np.linspace(-self.k_max, self.k_max, self.n_k_points + 1)[:-1] self.k_grid_spacing = np.diff(self.k_grid)[0] self.states = states.States(self) self.n_electrons = 2 * self.states.n_occupied self.volume = __class__._calc_volume(self.rs, self.n_electrons, self.n_dimensions) self.eri = twoERI.TwoElectronIntegral(self) self.states.calc_energies() self.states.sort_by_energy() self.excitations = excitations.Excitations(self)
class BasicEntity(BaseObject, pygame.sprite.Sprite): states = states.States('idle', 'death') state = None def __init__(self, manager, side, reference, name, model, weapon=None, weapon_points=[]): BaseObject.__init__(self) pygame.sprite.Sprite.__init__(self) self._signals[constants.EVENT_ENTITY_FIRE] = [] self._signals[constants.EVENT_ENTITY_DAMAGE] = [] self._signals[constants.EVENT_ENTITY_DEATH] = [] self._signals[constants.EVENT_ANIMATION_DAMAGE_COMPLETE] = [] self.manager = manager self.side = side self.reference = reference self.name = name self.weapon = weapon self.weapon_points = weapon_points self.damage_animation_queue = [] self.death_duration = 1500.0 self.image = pygame.image.load(model) self.rect = pygame.rect.Rect(0, 0, self.image.get_width(), self.image.get_height()) self.state = self.states.idle self.framecount = 0 self.frameskip = 3 def on_entity_fire(self, destination_reference): if isinstance(self.weapon, weapons.BasicLaser): # laser weapon # temporary until weapon hardpoints work spread = 12 x, y = self.get_position() laser_entity0 = entities.LaserBlast( self.manager, self.weapon, (x - spread, y), destination_reference.get_position()) laser_entity1 = entities.LaserBlast( self.manager, self.weapon, (x + spread, y), destination_reference.get_position()) self.emit(constants.EVENT_ANIMATION_LASER, laser_entity0) self.emit(constants.EVENT_ANIMATION_LASER, laser_entity1) else: print 'Warning Unknown weapon', self, self.weapon def get_position(self): return self.rect.center def on_entity_damage(self, amount): entity_instance = entities.DamageAnimation(self.manager, amount, self.get_position(), 2000, 400) self.damage_animation_queue.append(entity_instance) if len(self.damage_animation_queue) == 1: # Tell view to add this animation instance self.emit(constants.EVENT_ANIMATION_DAMAGE, (entity_instance)) def on_animation_damage_complete(self, animation_reference): if self.damage_animation_queue and id(animation_reference) == id( self.damage_animation_queue[0]): self.damage_animation_queue = self.damage_animation_queue[1:] if len(self.damage_animation_queue) > 0: # Trigger next animation self.emit(constants.EVENT_ANIMATION_DAMAGE, self.damage_animation_queue[0]) def on_entity_death(self): self.death() def notify(self, event): if event.signal == constants.EVENT_ENTITY_FIRE: if event.data[0] == self.reference: self.on_entity_fire(event.data[1]) elif event.signal == constants.EVENT_ENTITY_DAMAGE: if event.data[0] == self.reference: self.on_entity_damage(event.data[1]) elif event.signal == constants.EVENT_ANIMATION_DAMAGE_COMPLETE: # identify if it is our event inside callback self.on_animation_damage_complete(event.data) elif event.signal == constants.EVENT_ENTITY_DEATH: if event.data == self.reference: self.on_entity_death() def move(self, position): # Update our rect position self.rect.move_ip(position[0], position[1]) def death(self): self.emit(constants.EVENT_ENTITY_WAIT, self) self.timestamp = pygame.time.get_ticks() # Play fancy kill animation! self.state = self.states.death def update(self, ticks): if self.state == self.states.death: self.framecount += 1 if self.framecount < self.frameskip: return self.framecount = 0 n = min(1, (ticks - self.timestamp) / self.death_duration) # We can destroy this since this is the final use of this entities image pygame.surfarray.pixels3d( self.image)[:, :, 0] = 126 + 126 * math.cos(n * 24) if n == 1: self.visible = False self.state = self.states.idle # Clean up - This may need to be changed a bit self.emit(constants.EVENT_ENTITY_READY, self) self.destroy() self.kill()
class BattleView(BaseObject): verbose = False states = states.States('ready', 'waiting') def __init__(self, display_surface): BaseObject.__init__(self) # Set up list of signals to listen for for signal in (constants.EVENT_ROUND_START, constants.EVENT_MESSAGE, constants.EVENT_ENTITY_NEW, constants.EVENT_ENTITY_WAIT, constants.EVENT_ENTITY_READY, constants.EVENT_BATTLE_START, constants.EVENT_ANIMATION_LASER, constants.EVENT_ANIMATION_DAMAGE): self._signals[signal] = [] # Initialize the display self.display_surface = display_surface # Create a background surface background_color = (0, 0, 0) self.background_surface = pygame.surface.Surface( (self.display_surface.get_width(), self.display_surface.get_height())) self.background_surface.fill(background_color) # Create starfield background star_count = 200 utility.static_starfield(self.background_surface, star_count) # Blit the background surface to the display surface self.display_surface.blit(self.background_surface, (0, 0)) # Update the whole display pygame.display.flip() # Sprite group for drawing all messages self.message_group = pygame.sprite.RenderUpdates() # Sprite group for drawing all entities self.entity_group = pygame.sprite.RenderUpdates() # Sprite group for drawing all entities self.weapon_group = pygame.sprite.RenderUpdates() # Sprite group for damage animations self.damage_group = pygame.sprite.RenderUpdates() self.battle_active = False self.round_timestamp = None self.round_delay = 1500 # Should come from config file # Number of objects who have requested we wait for them before ending the round self.waiting_counter = 0 self.state = BattleView.states.ready def on_message(self, message): if self.verbose: print "'" + str(message) + "'" self.message_group.add(entities.Message(self.manager, str(message))) def on_entity_new(self, entity_instance): self.entity_group.add(entity_instance) def on_entity_wait(self, entity_ref): self.waiting_counter += 1 def on_entity_ready(self, entity_ref): self.waiting_counter -= 1 def on_round_start(self): self.state = BattleView.states.waiting def on_battle_start(self): # start waiting. must do this first incase on_entity_wait is called self.state = BattleView.states.waiting self.waiting_counter = 0 # Determin placement of entities and move them sides = {} for entity in self.entity_group: if not sides.has_key(entity.side): sides[entity.side] = [] sides[entity.side].append(entity) # right now will only work with 2 fleets until a suitable algo is decided upon # probably use a circle! send events to your brothers and parents, not to your children! y_padding = 64 x_padding = 64 entity_size = 138 y = y_padding for side in sides.values(): x = x_padding for entity in side: entity.move((x, y)) # add warp-in code here x += entity_size y += self.display_surface.get_height() - (y_padding * 2) - entity_size def on_start_round(self, data): # start waiting. must do this first incase on_entity_wait is called self.state = BattleView.states.waiting self.waiting_counter = 0 def on_animation_laser(self, animation_instance): self.weapon_group.add(animation_instance) def on_animation_damage(self, animation_instance): self.damage_group.add(animation_instance) def notify(self, event): if event.signal == constants.EVENT_ROUND_START: self.on_round_start() elif event.signal == constants.EVENT_MESSAGE: self.on_message(event.data) elif event.signal == constants.EVENT_ENTITY_NEW: self.on_entity_new(event.data) elif event.signal == constants.EVENT_BATTLE_START: self.on_battle_start() elif event.signal == constants.EVENT_ENTITY_WAIT: self.on_entity_wait(event.data) elif event.signal == constants.EVENT_ENTITY_READY: self.on_entity_ready(event.data) elif event.signal == constants.EVENT_ANIMATION_LASER: self.on_animation_laser(event.data) elif event.signal == constants.EVENT_ANIMATION_DAMAGE: self.on_animation_damage(event.data) def append_round(self, round_label, action_list): if self.verbose: print 'Added new round with', len(action_list), 'actions.' self.round_list.append({'label': round_label, 'actions': action_list}) def update(self): # update sprite groups. waiting_counter will be incrimented here by sprites calling a # EVENT_ENTITY_WAIT event and decrimented by an EVENT_ENTITY_READY event now = pygame.time.get_ticks() self.entity_group.update(now) self.weapon_group.update(now) self.damage_group.update(now) self.message_group.update(now) # Redraw sprites rectlist = self.entity_group.draw(self.display_surface) rectlist += self.weapon_group.draw(self.display_surface) rectlist += self.damage_group.draw(self.display_surface) rectlist += self.message_group.draw(self.display_surface) # Update the surface pygame.display.update(rectlist) # Clear the entities - Would be nice to know of a faster way to do this instead of using 3 seperate commands self.entity_group.clear(self.display_surface, self.background_surface) self.weapon_group.clear(self.display_surface, self.background_surface) self.damage_group.clear(self.display_surface, self.background_surface) self.message_group.clear(self.display_surface, self.background_surface) if self.state == BattleView.states.waiting and self.waiting_counter == 0: if self.round_timestamp == None: self.round_timestamp = pygame.time.get_ticks( ) + self.round_delay elif self.round_timestamp < pygame.time.get_ticks(): self.round_timestamp = None self.state = BattleView.states.ready # not waiting on any sprites. call a EVENT_VIEW_READY so the controller can continue self.emit(constants.EVENT_VIEW_READY, None)
class DamageAnimation(BaseObject, pygame.sprite.Sprite): states = states.States('waiting', 'animating', 'finished') state = None font = None def __init__(self, manager, damage_amount, position, animation_duration=0, wait_duration=0, font_path='./fonts/'): BaseObject.__init__(self) pygame.sprite.Sprite.__init__(self) if DamageAnimation.font == None: # Bitstream Vera Sans Mono DamageAnimation.font = pygame.font.Font(font_path + 'VeraMoBd.ttf', 18) if manager: self.manager = manager self.x = position[0] self.y = position[1] shadow_offset = 3 text = DamageAnimation.font.render(str(int(damage_amount)), False, (255, 0, 0)).convert() shadow = DamageAnimation.font.render(str(int(damage_amount)), False, (50, 50, 50)).convert() self.display_image = pygame.surface.Surface( (text.get_width() + shadow_offset, text.get_height() + shadow_offset), 0, 32).convert_alpha() self.display_image.fill((0, 0, 0, 0)) self.display_image.blit(shadow, (shadow_offset, shadow_offset)) self.display_image.blit(text, (0, 0)) self.idle_image = pygame.surface.Surface((0, 0)) self.image = self.idle_image self.rect = pygame.rect.Rect(self.x, self.y, self.image.get_width(), self.image.get_height()) self.wait_duration = wait_duration self.duration = float(animation_duration) # Record of original alpha for blending self.original_alpha = pygame.surfarray.array_alpha(self.display_image) self.state = self.states.waiting self.timestamp = pygame.time.get_ticks() self.emit(constants.EVENT_ENTITY_WAIT, self) def update(self, ticks): if self.state == self.states.waiting: if ticks > self.timestamp + self.wait_duration: self.timestamp = ticks self.state = self.states.animating self.image = self.display_image if self.state == self.states.animating: distance = 150 n = min(1, (ticks - self.timestamp) / self.duration) self.rect.left = self.x + self.image.get_width() * math.sin(n * 10) self.rect.top = self.y + (-distance * n) # Alpha fade pygame.surfarray.pixels_alpha(self.image)[:, :] = Numeric.multiply( self.original_alpha, 1 - n).astype(Numeric.UInt8) if n == 1: self.emit(constants.EVENT_ANIMATION_DAMAGE_COMPLETE, self) self.state = self.states.finished # Clean up self.emit(constants.EVENT_ENTITY_READY, self) self.destroy() self.kill()
class LaserSprite(pygame.sprite.Sprite): states = states.States('idle', 'active') state = None def __init__(self, laser_color=(255, 255, 255), width=1, duration=150.0, repeat=1): pygame.sprite.Sprite.__init__(self) self.laser_color = laser_color self.weapon_thickness = width self.padding = self.weapon_thickness self.idle_image = pygame.surface.Surface((0, 0)) self.original_alpha = None self.duration = float(duration) self.repeats = repeat self.current_repeat = 0 self.timestamp = 0 self.fire_halt() def fire_halt(self): self.image = self.idle_image self.rect = self.image.get_rect() self.state = self.states.idle self.original_alpha = None def draw_laser(self, p0, p1): # determin width xwidth = (p1[0] - p0[0]) ywidth = (p1[1] - p0[1]) # alter width for padding if xwidth < 0: xwidth -= self.padding * 2 else: xwidth += self.padding * 2 if ywidth < 0: ywidth -= self.padding * 2 else: ywidth += self.padding * 2 # Create the laser alpha channel surface mask_image = pygame.surface.Surface( (abs(xwidth), abs(ywidth))).convert_alpha() mask_image.fill((0, 0, 0)) self.rect = mask_image.get_rect() # reorganise position variables depending on which quater we are in, also update our rect if xwidth > 0: if ywidth > 0: pos0 = [self.padding, self.padding] pos1 = [ self.rect.width - self.padding, self.rect.height - self.padding ] self.rect.move_ip((p0[0] - self.padding, p0[1] - self.padding)) else: pos0 = [self.rect.width - self.padding, self.padding] pos1 = [self.padding, self.rect.height - self.padding] self.rect.move_ip((p0[0] - self.padding, p1[1] - self.padding)) else: if ywidth > 0: pos0 = [self.rect.width - self.padding, self.padding] pos1 = [self.padding, self.rect.height - self.padding] self.rect.move_ip((p1[0] - self.padding, p0[1] - self.padding)) else: pos0 = [self.padding, self.padding] pos1 = [ self.rect.width - self.padding, self.rect.height - self.padding ] self.rect.move_ip((p1[0] - self.padding, p1[1] - self.padding)) # Draw laser pygame.draw.line(mask_image, (255, 255, 255), pos0, (pos1[0], pos1[1]), self.weapon_thickness) # Blur surface (this will be a gaussian blur later and facilitate a less-poor looking beam) blur_surface(mask_image) blur_surface(mask_image) blur_surface(mask_image) mask_array = pygame.surfarray.array3d(mask_image) self.image = mask_image self.image.fill(self.laser_color) # cheap gradient w = self.weapon_thickness tm = (255 / self.weapon_thickness) color = (self.laser_color[0], self.laser_color[1], self.laser_color[2]) while w > 0: color = (min(255, color[0] + tm), min(255, color[1] + tm), min(255, color[2] + tm)) pygame.draw.line(self.image, color, pos0, (pos1[0], pos1[1]), w) w -= 1 pygame.surfarray.pixels_alpha(self.image)[:, :] = mask_array[:, :, 0] # Record of original alpha for blending self.original_alpha = pygame.surfarray.array_alpha( self.image.copy().convert_alpha()) self.timestamp = pygame.time.get_ticks() self.state = self.states.active def update(self, ticks): if self.original_alpha != None: n = min(1, (ticks - self.timestamp) / self.duration) # Alpha fade pygame.surfarray.pixels_alpha(self.image)[:, :] = Numeric.multiply( self.original_alpha, 1 - n).astype(Numeric.UInt8) if n == 1: # Loop if self.current_repeat < self.repeats: self.current_repeat + 1 self.timestamp = pygame.time.get_ticks()
import handlers, os import states name = "Live Sensor Details" __dir = os.path.dirname(os.path.realpath(__file__)) root = handlers.Index(os.path.join(__dir, 'sensorstates.html')) root.images = handlers.StaticFiles(os.path.join(__dir, 'images')) root.js = handlers.StaticFiles(os.path.join(__dir, 'js')) root.css = handlers.StaticFiles(os.path.join(__dir, 'css')) root.data = states.States()