def build_gradient_line(protocol, colors, points):
    sp = cbc.ServerPlayer()
    
    block_action = BlockAction()
    block_action.player_id = sp.player_id
    block_action.value = BUILD_BLOCK
    
    set_color = SetColor()
    set_color.player_id = sp.player_id
    
    color_range = zip(*colors)
    
    lp = len(points) - 1
    map = protocol.map
    for i in xrange(len(points)):
        if lp:
            pct = 1 - (i+0.0) / lp, (i+0.0) / lp
        else:
            pct = (1,0)
        
        color = tuple(int(round(sum(c*p for c,p in zip(crng, pct)))) for crng in color_range)
        
        map.set_point(*points[i], color = color)
        
        set_color.value = make_color(*color)
        protocol.send_contained(set_color, save = True)
        
        block_action.x, block_action.y, block_action.z = points[i]
        protocol.send_contained(block_action, save = True)
Example #2
0
 def cycle(self):
     if not self.blocks:
         self.loop.stop()
         if self.call_on_exhaustion:
             self.call_on_exhaustion()
         return
     blocks_left = self.blocks_per_cycle
     last_color = None
     while self.blocks and blocks_left:
         x, y, z, color = self.blocks.popleft()
         if color != last_color:
             set_color.value = make_color(*color)
             set_color.player_id = 32
             self.protocol.send_contained(set_color, save = True)
             last_color = color
         if not self.protocol.map.get_solid(x, y, z):
             block_action.value = BUILD_BLOCK
             block_action.player_id = 32
             block_action.x = x
             block_action.y = y
             block_action.z = z
             self.protocol.send_contained(block_action, save = True)
             self.protocol.map.set_point(x, y, z, color)
             blocks_left -= 1
     self.protocol.update_entities()
Example #3
0
def invisible(connection, player = None):
    protocol = connection.protocol
    if player is not None:
        player = get_player(protocol, player)
    elif connection in protocol.players:
        player = connection
    else:
        raise ValueError()
    player.invisible = not player.invisible
    player.filter_visibility_data = player.invisible
    player.god = player.invisible
    player.god_build = False
    player.killing = not player.invisible
    if player.invisible:
        player.send_chat("You're now invisible")
        protocol.irc_say('* %s became invisible' % player.name)
        kill_action = KillAction()
        kill_action.kill_type = choice([GRENADE_KILL, FALL_KILL])
        kill_action.player_id = kill_action.killer_id = player.player_id
        reactor.callLater(1.0 / NETWORK_FPS, protocol.send_contained,
            kill_action, sender = player)
    else:
        player.send_chat("You return to visibility")
        protocol.irc_say('* %s became visible' % player.name)
        x, y, z = player.world_object.position.get()
        create_player.player_id = player.player_id
        create_player.name = player.name
        create_player.x = x
        create_player.y = y
        create_player.z = z
        create_player.weapon = player.weapon
        create_player.team = player.team.id
        world_object = player.world_object
        input_data.player_id = player.player_id
        input_data.up = world_object.up
        input_data.down = world_object.down
        input_data.left = world_object.left
        input_data.right = world_object.right
        input_data.jump = world_object.jump
        input_data.crouch = world_object.crouch
        input_data.sneak = world_object.sneak
        input_data.sprint = world_object.sprint
        set_tool.player_id = player.player_id
        set_tool.value = player.tool
        set_color.player_id = player.player_id
        set_color.value = make_color(*player.color)
        weapon_input.primary = world_object.primary_fire
        weapon_input.secondary = world_object.secondary_fire
        protocol.send_contained(create_player, sender = player, save = True)
        protocol.send_contained(set_tool, sender = player)
        protocol.send_contained(set_color, sender = player, save = True)
        protocol.send_contained(input_data, sender = player)
        protocol.send_contained(weapon_input, sender = player)
    if connection is not player and connection in protocol.players:
        if player.invisible:
            return '%s is now invisible' % player.name
        else:
            return '%s is now visible' % player.name
Example #4
0
def build_filled_generator(protocol, x1, y1, z1, x2, y2, z2, color, god = False, god_build = False):
    # create a player instance, freed when the generator is done
    # other scripts that also use ServerPlayer won't get the same id!
    # this won't be necessary in 1.0
    splayer = cbc.ServerPlayer()
    
    line = BlockLine()
    line.player_id = splayer.player_id
    
    set_color = SetColor()
    set_color.value = make_color(*color)
    set_color.player_id = splayer.player_id
    protocol.send_contained(set_color, save = True)
    packets = 1
    
    check_protected = hasattr(protocol, 'protected')
    if god_build and protocol.god_blocks is None:
        protocol.god_blocks = set()
    
    map = protocol.map
    
    ranges = [xrange(min(x1 , x2) , max(x1 , x2)+1)
            , xrange(min(y1 , y2) , max(y1 , y2)+1)
            , xrange(min(z1 , z2) , max(z1 , z2)+1)]
    
    order = zip(*sorted(zip([len(x) for x in ranges], [0, 1, 2])))[1]
    
    # set the first block position
    prod = ordered_product(ranges, order)
    line.x1, line.y1, line.z1 = prod.next()
    line.x2 = line.x1
    line.y2 = line.y1
    line.z2 = line.z1
    map.set_point(line.x1, line.y1, line.z1, color)
    
    for x, y, z in prod:
        packets = 0
        if not god and check_protected and protocol.is_protected(x, y, z):
            continue
        if god_build:
            protocol.god_blocks.add((x, y, z))
        changed = (line.x1 != x or line.x2 != x) + (line.y1 != y or line.y2 != y) + (line.z1 != z or line.z2 != z)
        dist = abs(line.x1 - x) + abs(line.y1 - y) + abs(line.z1 - z)
        if changed > 1 or dist >= MAX_LINE_BLOCKS:
            protocol.send_contained(line, save = True)
            packets += 2
            line.x1 = x
            line.y1 = y
            line.z1 = z
        line.x2 = x
        line.y2 = y
        line.z2 = z
        map.set_point(x, y, z, color)
        
        yield packets, 0
    protocol.send_contained(line, save = True)
    yield 1, 0
Example #5
0
        def random_color(self):
            (h, l, s) = self.team.hls
            l = randint(self.team.light_range[0], self.team.light_range[1])
            color = byte_hls_to_rgb((h, l, s))

            self.color = color
            set_color.player_id = self.player_id
            set_color.value = make_color(*color)
            self.send_contained(set_color)
            self.protocol.send_contained(set_color, save=True)
Example #6
0
def rebuild_block(player, x, y, z, color):
    set_color.value = make_color(*color)
    set_color.player_id = 32
    block_action.player_id = 32
    block_action.x = x
    block_action.y = y
    block_action.z = z
    block_action.value = DESTROY_BLOCK
    player.send_contained(block_action)
    block_action.value = BUILD_BLOCK
    player.send_contained(set_color)
    player.send_contained(block_action)
Example #7
0
def rebuild_block(player, x, y, z, color):
    set_color.value = make_color(*color)
    set_color.player_id = 32
    block_action.player_id = 32
    block_action.x = x
    block_action.y = y
    block_action.z = z
    block_action.value = DESTROY_BLOCK
    player.send_contained(block_action)
    block_action.value = BUILD_BLOCK
    player.send_contained(set_color)
    player.send_contained(block_action)
def build_block(connection, x, y, z, color):
    set_color = SetColor()
    set_color.value = make_color(*color)
    set_color.player_id = 32
    connection.protocol.send_contained(set_color)
    block_action.player_id = 32
    block_action.x = x
    block_action.y = y
    block_action.z = z
    block_action.value = BUILD_BLOCK
    connection.protocol.map.set_point(x, y, z, color)
    connection.protocol.send_contained(block_action, save=True)
        def on_block_build_attempt(self, x, y, z):

            # make sure block is built with the team color
            if self.team is not None:
                brightness = random.randint(180, 255)
                self.color = (self.team.color[0] * brightness >> 8,
                              self.team.color[1] * brightness >> 8,
                              self.team.color[2] * brightness >> 8)
                set_color.player_id = self.player_id
                set_color.value = make_color(*self.color)
                self.protocol.send_contained(set_color, sender=None, save=True)

            return connection.on_block_build_attempt(self, x, y, z)
Example #10
0
        def quickbuild_generator(self, origin, structure, default_color):
            map = self.protocol.map
            protocol = self.protocol

            splayer = cbc.ServerPlayer()

            block_action = BlockAction()
            block_action.value = BUILD_BLOCK
            block_action.player_id = splayer.player_id

            set_color = SetColor()
            set_color.value = make_color(*default_color)
            set_color.player_id = splayer.player_id
            pcolor = default_color

            protocol.send_contained(set_color, save=True)

            if not isinstance(structure, dict):
                structure = dict(structure)

            for xyz, color in structure.iteritems():
                x, y, z = [a + b for a, b in zip(xyz, origin)]
                if (x < 0 or x >= 512 or y < 0 or y >= 512 or z < 0
                        or z >= 62):
                    continue
                if map.get_solid(x, y, z):
                    continue
                color = color or default_color
                if color != pcolor:
                    set_color.value = make_color(*color)
                    protocol.send_contained(set_color, save=True)
                    pcolor = color
                    yield 1, 0
                self.on_block_build(x, y, z)
                block_action.x, block_action.y, block_action.z = x, y, z
                protocol.send_contained(block_action, save=True)
                map.set_point(x, y, z, pcolor)
                yield 1, 0
 def quickbuild_generator(self, origin, structure, default_color):
     map = self.protocol.map
     protocol = self.protocol
     
     splayer = cbc.ServerPlayer()
     
     block_action = BlockAction()
     block_action.value = BUILD_BLOCK
     block_action.player_id = splayer.player_id
     
     set_color = SetColor()
     set_color.value = make_color(*default_color)
     set_color.player_id = splayer.player_id
     pcolor = default_color
     
     protocol.send_contained(set_color, save = True)
     
     if not isinstance(structure, dict):
         structure = dict(structure)
     
     for xyz, color in structure.iteritems():
         x, y, z = [a+b for a,b in zip(xyz, origin)]
         if (x < 0 or x >= 512 or y < 0 or y >= 512 or z < 0 or z >= 62):
             continue
         if map.get_solid(x, y, z):
             continue
         color = color or default_color
         if color != pcolor:
             set_color.value = make_color(*color)
             protocol.send_contained(set_color, save = True)
             pcolor = color
             yield 1, 0
         self.on_block_build(x, y, z)
         block_action.x, block_action.y, block_action.z = x, y, z
         protocol.send_contained(block_action, save = True)
         map.set_point(x, y, z, pcolor)
         yield 1, 0
def build_block(connection, x, y, z, color):
    if is_invalid_coord(x, y, z):
        return
    set_color = loaders.SetColor()
    set_color.value = make_color(*color)
    set_color.player_id = 32
    connection.protocol.broadcast_contained(set_color)
    block_action = loaders.BlockAction()
    block_action.player_id = 32
    block_action.x = x
    block_action.y = y
    block_action.z = z
    block_action.value = BUILD_BLOCK
    connection.protocol.map.set_point(x, y, z, color)
    connection.protocol.broadcast_contained(block_action, save=True)
Example #13
0
def setBlockColor(self, x, y, z, color):
    set_color = SetColor()
    set_color.value = make_color(*color)
    set_color.player_id = 32
    self.protocol.send_contained(set_color, save=True)

    block_action = BlockAction()
    block_action.x = x
    block_action.y = y
    block_action.z = z
    block_action.player_id = 32
    block_action.value = DESTROY_BLOCK
    self.protocol.send_contained(block_action, save=True)
    block_action.value = BUILD_BLOCK
    self.protocol.send_contained(block_action, save=True)
    self.protocol.map.set_point(x, y, z, color)
Example #14
0
def my_invisible(connection):
    protocol = connection.protocol

    player = connection

    player.invisible = not player.invisible
    player.filter_visibility_data = player.invisible

    if not player.invisible and player.world_object is not None:
        x, y, z = player.world_object.position.get()
        create_player.player_id = player.player_id
        create_player.name = player.name
        create_player.x = x
        create_player.y = y
        create_player.z = z
        create_player.weapon = player.weapon
        create_player.team = player.team.id

        world_object = player.world_object

        input_data.player_id = player.player_id
        input_data.up = world_object.up
        input_data.down = world_object.down
        input_data.left = world_object.left
        input_data.right = world_object.right
        input_data.jump = world_object.jump
        input_data.crouch = world_object.crouch
        input_data.sneak = world_object.sneak
        input_data.sprint = world_object.sprint

        set_tool.player_id = player.player_id
        set_tool.value = player.tool
        set_color.player_id = player.player_id
        set_color.value = make_color(*player.color)

        weapon_input.primary = world_object.primary_fire
        weapon_input.secondary = world_object.secondary_fire

        protocol.send_contained(create_player, sender = player, save = True)
        protocol.send_contained(set_tool, sender = player)
        protocol.send_contained(set_color, sender = player, save = True)
        protocol.send_contained(input_data, sender = player)
        protocol.send_contained(weapon_input, sender = player)

        player.send_chat("Now visible.")
def my_invisible(connection):
    protocol = connection.protocol

    player = connection

    player.invisible = not player.invisible
    player.filter_visibility_data = player.invisible

    if not player.invisible and player.world_object is not None:
        x, y, z = player.world_object.position.get()
        create_player.player_id = player.player_id
        create_player.name = player.name
        create_player.x = x
        create_player.y = y
        create_player.z = z
        create_player.weapon = player.weapon
        create_player.team = player.team.id

        world_object = player.world_object

        input_data.player_id = player.player_id
        input_data.up = world_object.up
        input_data.down = world_object.down
        input_data.left = world_object.left
        input_data.right = world_object.right
        input_data.jump = world_object.jump
        input_data.crouch = world_object.crouch
        input_data.sneak = world_object.sneak
        input_data.sprint = world_object.sprint

        set_tool.player_id = player.player_id
        set_tool.value = player.tool
        set_color.player_id = player.player_id
        set_color.value = make_color(*player.color)

        weapon_input.primary = world_object.primary_fire
        weapon_input.secondary = world_object.secondary_fire

        protocol.send_contained(create_player, sender = player, save = True)
        protocol.send_contained(set_tool, sender = player)
        protocol.send_contained(set_color, sender = player, save = True)
        protocol.send_contained(input_data, sender = player)
        protocol.send_contained(weapon_input, sender = player)

        player.send_chat("Ora visibile")
        def paint_block_by_team(self, player, points, team):
            updated_points = set()
            for x, y, z in points:
                if x < 0 or y < 0 or z < 0 or x >= 512 or y >= 512 or z >= 63:
                    continue

                # empty?
                if not self.map.get_solid(x, y, z) or not self.map.is_surface(
                        x, y, z):
                    continue

                # already owned?
                if not self.territory_map.own(x, y, z, team.id + 1):
                    pass  # return False

                updated_points.add((x, y, z))

                color = self.map.get_color(x, y, z)

                color = blend_color(color, team.color,
                                    random.randint(160, 200))

                self.map.set_point(x, y, z, color)

            for x, y, z in updated_points:
                color = self.map.get_color(x, y, z)

                player.color = color
                set_color.player_id = player.player_id
                set_color.value = make_color(*color)
                self.send_contained(set_color, sender=None, save=True)

                block_action.x = x
                block_action.y = y
                block_action.z = z
                block_action.player_id = player.player_id
                block_action.value = DESTROY_BLOCK
                self.send_contained(block_action, save=True)
                block_action.value = BUILD_BLOCK
                self.send_contained(block_action, save=True)

                if (x, y) not in self.check_destroy_spans:
                    self.check_destroy_spans.add((x, y))
                    self.check_destroy_spans_list.append((x, y))
Example #17
0
 def cast_rocket(self, pos, ori, start_boom=True):
     if pos.z <= -1:
         self.send_chat_error("Too high. Go down to launch a rocket")
         return False
     obj = Rocket()
     obj.pos = pos
     obj.ori = ori
     obj.player = self
     self.protocol.rockets.append(obj)
     set_color = SetColor()
     set_color.value = make_color(*ROCKET_COLOR.get())
     set_color.player_id = 32
     self.protocol.broadcast_contained(set_color)
     if start_boom:
         grenade_packet = GrenadePacket()
         grenade_packet.value = 0
         grenade_packet.player_id = self.player_id
         grenade_packet.position = self.world_object.position.get()
         grenade_packet.velocity = (0, 0, 0)
         self.protocol.broadcast_contained(grenade_packet)
     return True
Example #18
0
 def __init__(self, protocol, team, x, y):
     self.protocol = protocol
     self.team = team
     self.x = x
     self.y = y
     if self.random_colors:
         self.color = choice(self.random_colors)
     elif self.team_color:
         self.color = make_color(*team.color)
     self.blocks = set()
     base_lines, base_points = self.lines, self.points
     self.lines, self.points = [], []
     for line in base_lines:
         self.make_line(*line)
     for point in base_points:
         self.make_block(*point)
     # find markers we're colliding with
     has_timer = self.duration is not None
     collisions = []
     current_time = seconds()
     worst_time = current_time + self.duration if has_timer else None
     for marker in protocol.markers:
         intersect = marker.blocks & self.blocks
         if intersect:
             self.blocks -= intersect
             collisions.append(marker)
             if has_timer and marker.expire_call:
                 worst_time = min(worst_time, marker.expire_call.getTime())
     # forward expiration time so that colliding markers vanish all at once
     if has_timer:
         delay = worst_time - current_time
         self.expire_call = callLater(delay, self.expire)
     self.build()
     team.marker_count[self.__class__] += 1
     protocol.markers.append(self)
     if self.background_class:
         self.background = self.background_class(protocol, team, x, y)
Example #19
0
 def __init__(self, protocol, team, x, y):
     self.protocol = protocol
     self.team = team
     self.x = x
     self.y = y
     if self.random_colors:
         self.color = choice(self.random_colors)
     elif self.team_color:
         self.color = make_color(*team.color)
     self.blocks = set()
     base_lines, base_points = self.lines, self.points
     self.lines, self.points = [], []
     for line in base_lines:
         self.make_line(*line)
     for point in base_points:
         self.make_block(*point)
     # find markers we're colliding with
     has_timer = self.duration is not None
     collisions = []
     current_time = seconds()
     worst_time = current_time + self.duration if has_timer else None
     for marker in protocol.markers:
         intersect = marker.blocks & self.blocks
         if intersect:
             self.blocks -= intersect
             collisions.append(marker)
             if has_timer and marker.expire_call:
                 worst_time = min(worst_time, marker.expire_call.getTime())
     # forward expiration time so that colliding markers vanish all at once
     if has_timer:
         delay = worst_time - current_time
         self.expire_call = callLater(delay, self.expire)
     self.build()
     team.marker_count[self.__class__] += 1
     protocol.markers.append(self)
     if self.background_class:
         self.background = self.background_class(protocol, team, x, y)
Example #20
0
 def _set_paused(self, value):
     if self._paused == value:
         return
     is_spectator = self.team and self.team.spectator
     if value and is_spectator:
         # spectators are unaffected
         return
     self._paused = value
     self.filter_weapon_input = value
     self.filter_animation_data = value
     self.freeze_animation = value
     send_others = partial(self.protocol.send_contained,
         sender = self, save = True)
     world_object = self.world_object
     if value:
         # start sticky position loop
         self.pause_loop = LoopingCall(reposition, self)
         self.pause_loop.start(0.08)
         self.paused_spawn = None
         self.paused_orientation = None
         if world_object is None:
             return
         # stop walking and shooting
         world_object.set_walk(False, False, False, False)
         weapon_input.player_id = self.player_id
         weapon_input.primary = False
         weapon_input.secondary = False
         send_others(weapon_input)
     else:
         # end repositioning
         if self.pause_loop and self.pause_loop.running:
             self.pause_loop.stop()
         self.pause_loop = None
         if self.paused_spawn:
             # game got paused while player was waiting to spawn
             self.paused_spawn()
             self.paused_spawn = None
             return
         if world_object is None:
             return
         if self.paused_orientation:
             # assume stored orientation
             world_object.set_orientation(*self.paused_orientation)
         set_tool.player_id = self.player_id
         set_tool.value = self.tool
         set_color.player_id = self.player_id
         set_color.value = make_color(*self.color)
         weapon_input.player_id = self.player_id
         weapon_input.primary = world_object.primary_fire
         weapon_input.secondary = world_object.secondary_fire
         send_others(set_tool)
         send_others(set_color)
         send_others(weapon_input)
     input_data.player_id = self.player_id
     input_data.up = world_object.up
     input_data.down = world_object.down
     input_data.left = world_object.left
     input_data.right = world_object.right
     input_data.jump = world_object.jump
     input_data.crouch = world_object.crouch
     input_data.sneak = world_object.sneak
     input_data.sprint = world_object.sprint
     send_others(input_data)
Example #21
0
    def _send_connection_data(self):
        saved_loaders = self.saved_loaders = []
        if self.player_id is None:
            for player in self.protocol.players.values():
                if player.name is None:
                    continue
                existing_player.name = player.name
                existing_player.player_id = player.player_id
                existing_player.tool = player.tool or 0
                existing_player.weapon = player.weapon
                existing_player.kills = player.kills
                existing_player.team = player.team.id
                existing_player.color = make_color(*player.color)
                saved_loaders.append(existing_player.generate())

            self.player_id = self.protocol.player_ids.pop()
            self.protocol.update_master()

        # send initial data
        blue = self.protocol.blue_team
        green = self.protocol.green_team

        state_data.player_id = self.player_id
        state_data.fog_color = self.protocol.fog_color
        state_data.team1_color = blue.color
        state_data.team1_name = blue.name
        state_data.team2_color = green.color
        state_data.team2_name = green.name

        game_mode = self.protocol.game_mode

        if game_mode == CTF_MODE:
            blue_base = blue.base
            blue_flag = blue.flag
            green_base = green.base
            green_flag = green.flag
            ctf_data.cap_limit = self.protocol.max_score
            ctf_data.team1_score = blue.score
            ctf_data.team2_score = green.score

            ctf_data.team1_base_x = blue_base.x
            ctf_data.team1_base_y = blue_base.y
            ctf_data.team1_base_z = blue_base.z

            ctf_data.team2_base_x = green_base.x
            ctf_data.team2_base_y = green_base.y
            ctf_data.team2_base_z = green_base.z

            if green_flag.player is None:
                ctf_data.team1_has_intel = 0
                ctf_data.team2_flag_x = green_flag.x
                ctf_data.team2_flag_y = green_flag.y
                ctf_data.team2_flag_z = green_flag.z
            else:
                ctf_data.team1_has_intel = 1
                ctf_data.team2_carrier = green_flag.player.player_id

            if blue_flag.player is None:
                ctf_data.team2_has_intel = 0
                ctf_data.team1_flag_x = blue_flag.x
                ctf_data.team1_flag_y = blue_flag.y
                ctf_data.team1_flag_z = blue_flag.z
            else:
                ctf_data.team2_has_intel = 1
                ctf_data.team1_carrier = blue_flag.player.player_id

            state_data.state = ctf_data

        elif game_mode == TC_MODE:
            state_data.state = tc_data

        generated_data = state_data.generate()
        saved_loaders.append(generated_data)
Example #22
0
 def create_rollback_generator(self, cur, new, start_x, start_y,
     end_x, end_y, ignore_indestructable):
     surface = {}
     block_action = BlockAction()
     block_action.player_id = 31
     set_color = SetColor()
     set_color.value = make_color(*NON_SURFACE_COLOR)
     set_color.player_id = 31
     self.send_contained(set_color, save = True)
     old = cur.copy()
     check_protected = hasattr(protocol, 'protected')
     x_count = abs(start_x - end_x)
     for x in xrange(start_x, end_x):
         block_action.x = x
         for y in xrange(start_y, end_y):
             block_action.y = y
             if check_protected and self.is_protected(x, y, 0):
                 continue
             for z in xrange(63):
                 action = None
                 cur_solid = cur.get_solid(x, y, z)
                 new_solid = new.get_solid(x, y, z)
                 if cur_solid and not new_solid:
                     if (not ignore_indestructable and
                         self.is_indestructable(x, y, z)):
                         continue
                     else:
                         action = DESTROY_BLOCK
                         cur.remove_point(x, y, z)
                 elif new_solid:
                     new_is_surface = new.is_surface(x, y, z)
                     if new_is_surface:
                         new_color = new.get_color(x, y, z)
                     if not cur_solid and new_is_surface:
                         surface[(x, y, z)] = new_color
                     elif not cur_solid and not new_is_surface:
                         action = BUILD_BLOCK
                         cur.set_point(x, y, z, NON_SURFACE_COLOR)
                     elif cur_solid and new_is_surface:
                         old_is_surface = old.is_surface(x, y, z)
                         if old_is_surface:
                             old_color = old.get_color(x, y, z)
                         if not old_is_surface or old_color != new_color:
                             surface[(x, y, z)] = new_color
                             action = DESTROY_BLOCK
                             cur.remove_point(x, y, z)
                 if action is not None:
                     block_action.z = z
                     block_action.value = action
                     self.send_contained(block_action, save = True)
                 yield action is not None, ((x-start_x+0.0) / x_count)
     last_color = None
     block_action.value = BUILD_BLOCK
     i = 0.0
     for pos, color in sorted(surface.iteritems()):
         x, y, z = pos
         packets_sent = 0
         if color != last_color:
             set_color.value = make_color(*color)
             self.send_contained(set_color, save = True)
             packets_sent += 1
             last_color = color
         cur.set_point(x, y, z, color)
         block_action.x = x
         block_action.y = y
         block_action.z = z
         self.send_contained(block_action, save = True)
         packets_sent += 1
         i += 1
         yield packets_sent, -(i / len(surface))
Example #23
0
 def create_rollback_generator(self, cur, new, start_x, start_y, end_x,
                               end_y, ignore_indestructable):
     surface = {}
     block_action = BlockAction()
     block_action.player_id = 31
     set_color = SetColor()
     set_color.value = make_color(*NON_SURFACE_COLOR)
     set_color.player_id = 31
     self.send_contained(set_color, save=True)
     old = cur.copy()
     check_protected = hasattr(protocol, 'protected')
     for x in xrange(start_x, end_x):
         block_action.x = x
         for y in xrange(start_y, end_y):
             block_action.y = y
             if check_protected and self.is_protected(x, y, 0):
                 continue
             for z in xrange(63):
                 action = None
                 cur_solid = cur.get_solid(x, y, z)
                 new_solid = new.get_solid(x, y, z)
                 if cur_solid and not new_solid:
                     if (not ignore_indestructable
                             and self.is_indestructable(x, y, z)):
                         continue
                     else:
                         action = DESTROY_BLOCK
                         cur.remove_point(x, y, z)
                 elif new_solid:
                     new_is_surface = new.is_surface(x, y, z)
                     if new_is_surface:
                         new_color = new.get_color(x, y, z)
                     if not cur_solid and new_is_surface:
                         surface[(x, y, z)] = new_color
                     elif not cur_solid and not new_is_surface:
                         action = BUILD_BLOCK
                         cur.set_point(x, y, z, NON_SURFACE_COLOR)
                     elif cur_solid and new_is_surface:
                         old_is_surface = old.is_surface(x, y, z)
                         if old_is_surface:
                             old_color = old.get_color(x, y, z)
                         if not old_is_surface or old_color != new_color:
                             surface[(x, y, z)] = new_color
                             action = DESTROY_BLOCK
                             cur.remove_point(x, y, z)
                 if action is not None:
                     block_action.z = z
                     block_action.value = action
                     self.send_contained(block_action, save=True)
                     yield 1
         yield 0
     last_color = None
     block_action.value = BUILD_BLOCK
     for pos, color in sorted(surface.iteritems(),
                              key=operator.itemgetter(1)):
         x, y, z = pos
         packets_sent = 0
         if color != last_color:
             set_color.value = make_color(*color)
             self.send_contained(set_color, save=True)
             packets_sent += 1
             last_color = color
         cur.set_point(x, y, z, color)
         block_action.x = x
         block_action.y = y
         block_action.z = z
         self.send_contained(block_action, save=True)
         packets_sent += 1
         yield packets_sent
Example #24
0
class NumberMarker(BaseMarker):
    duration = Enemy.duration
    background_class = Enemy
    color = make_color(255, 255, 255)
    always_there = True
Example #25
0
class BuildBackground(BaseMarker):
    color = make_color(255, 255, 255)
    s = """
Example #26
0
class BackupBackground(BaseMarker):
    color = make_color(0, 0, 0)
    s = """
Example #27
0
def send_color(protocol, color):
    set_color_packet = SetColor()
    set_color_packet.value = make_color(*color)
    set_color_packet.player_id = 32
    protocol.send_contained(set_color_packet, save=True)
Example #28
0
def send_fog(player, color):
    fog_color.color = make_color(*color)
    player.send_contained(fog_color)
Example #29
0
        def set_fog_color(self, color):
            self.fog_color = color
            fog_color.color = make_color(*color)

            self.send_contained(fog_color, save=True, rule=send_fog_rule)
Example #30
0
def send_fog(player, color):
    fog_color.color = make_color(*color)
    player.send_contained(fog_color)
Example #31
0
 def send_fog(self, sender = None):
     sender = sender or self.protocol
     color = self.get_color()
     fog_color.color = make_color(*color)
     sender.send_contained(fog_color, save = True)
Example #32
0
def send_fog(player, color):
    fog_color = loaders.FogColor()
    fog_color.color = make_color(*color)
    player.send_contained(fog_color)
Example #33
0
	def updateColor(self, protocol, color):
		set_color.value = make_color(*color)
		set_color.player_id = 32
		protocol.send_contained(set_color, save = True)
		return color
Example #34
0
class EnemyBackground(BaseMarker):
    color = make_color(0, 0, 0)
    s = """
Example #35
0
 def set_fog_effects_on_color(self, color):
     self._fog_effects_on_color = color
     if self._fog_effects:
         fog_color.color = make_color(*color)
         self.send_contained(fog_color, save=True)
Example #36
0
class Intel(BaseMarker):
    name = 'Intel'
    color = make_color(255, 255, 255)
    s = """
Example #37
0
 def updateColor(self, protocol, color):
     set_color.value = make_color(*color)
     set_color.player_id = 32
     protocol.send_contained(set_color, save=True)
     return color
Example #38
0
class TunnelBackground(BaseMarker):
    color = make_color(255, 255, 255)
    s = """
Example #39
0
def build_filled_generator(protocol,
                           x1,
                           y1,
                           z1,
                           x2,
                           y2,
                           z2,
                           color,
                           god=False,
                           god_build=False):
    # create a player instance, freed when the generator is done
    # other scripts that also use ServerPlayer won't get the same id!
    # this won't be necessary in 1.0
    splayer = cbc.ServerPlayer()

    line = BlockLine()
    line.player_id = splayer.player_id

    set_color = SetColor()
    set_color.value = make_color(*color)
    set_color.player_id = splayer.player_id
    protocol.send_contained(set_color, save=True)
    packets = 1

    check_protected = hasattr(protocol, 'protected')
    if god_build and protocol.god_blocks is None:
        protocol.god_blocks = set()

    map = protocol.map

    ranges = [
        xrange(min(x1, x2),
               max(x1, x2) + 1),
        xrange(min(y1, y2),
               max(y1, y2) + 1),
        xrange(min(z1, z2),
               max(z1, z2) + 1)
    ]

    order = zip(*sorted(zip([len(x) for x in ranges], [0, 1, 2])))[1]

    # set the first block position
    prod = ordered_product(ranges, order)
    line.x1, line.y1, line.z1 = prod.next()
    line.x2 = line.x1
    line.y2 = line.y1
    line.z2 = line.z1
    map.set_point(line.x1, line.y1, line.z1, color)

    for x, y, z in prod:
        packets = 0
        if not god and check_protected and protocol.is_protected(x, y, z):
            continue
        if god_build:
            protocol.god_blocks.add((x, y, z))
        changed = (line.x1 != x or line.x2 != x) + (
            line.y1 != y or line.y2 != y) + (line.z1 != z or line.z2 != z)
        dist = abs(line.x1 - x) + abs(line.y1 - y) + abs(line.z1 - z)
        if changed > 1 or dist >= MAX_LINE_BLOCKS:
            protocol.send_contained(line, save=True)
            packets += 2
            line.x1 = x
            line.y1 = y
            line.z1 = z
        line.x2 = x
        line.y2 = y
        line.z2 = z
        map.set_point(x, y, z, color)

        yield packets, 0
    protocol.send_contained(line, save=True)
    yield 1, 0
Example #40
0
def invisible(connection, player):
    """
    Turn invisible
    /invisible [player]
    """
    protocol = connection.protocol
    # TODO: move this logic to a more suitable place
    player.invisible = not player.invisible
    player.filter_visibility_data = player.invisible
    player.god = player.invisible
    player.god_build = False
    player.killing = not player.invisible
    if player.invisible:
        player.send_chat("You're now invisible")
        protocol.irc_say('* %s became invisible' % player.name)
        kill_action = KillAction()
        kill_action.kill_type = choice([GRENADE_KILL, FALL_KILL])
        kill_action.player_id = kill_action.killer_id = player.player_id
        reactor.callLater(1.0 / NETWORK_FPS, protocol.broadcast_contained,
                          kill_action, sender=player)
    else:
        player.send_chat("You return to visibility")
        protocol.irc_say('* %s became visible' % player.name)
        x, y, z = player.world_object.position.get()
        create_player = CreatePlayer()
        create_player.player_id = player.player_id
        create_player.name = player.name
        create_player.x = x
        create_player.y = y
        create_player.z = z
        create_player.weapon = player.weapon
        create_player.team = player.team.id
        world_object = player.world_object
        input_data = InputData()
        input_data.player_id = player.player_id
        input_data.up = world_object.up
        input_data.down = world_object.down
        input_data.left = world_object.left
        input_data.right = world_object.right
        input_data.jump = world_object.jump
        input_data.crouch = world_object.crouch
        input_data.sneak = world_object.sneak
        input_data.sprint = world_object.sprint
        set_tool = SetTool()
        set_tool.player_id = player.player_id
        set_tool.value = player.tool
        set_color = SetColor()
        set_color.player_id = player.player_id
        set_color.value = make_color(*player.color)
        weapon_input = WeaponInput()
        weapon_input.primary = world_object.primary_fire
        weapon_input.secondary = world_object.secondary_fire
        protocol.broadcast_contained(create_player, sender=player, save=True)
        protocol.broadcast_contained(set_tool, sender=player)
        protocol.broadcast_contained(set_color, sender=player, save=True)
        protocol.broadcast_contained(input_data, sender=player)
        protocol.broadcast_contained(weapon_input, sender=player)
    if connection is not player and connection in protocol.players.values():
        if player.invisible:
            return '%s is now invisible' % player.name
        else:
            return '%s is now visible' % player.name
Example #41
0
 def send_fog(self, sender=None):
     sender = sender or self.protocol
     color = self.get_color()
     fog_color.color = make_color(*color)
     sender.send_contained(fog_color, save=True)
Example #42
0
 def set_fog_color(self, color):
     self.fog_color = color
     fog_color = loaders.FogColor()
     fog_color.color = make_color(*color)
     self.send_contained(fog_color, save=True)
Example #43
0
        def set_fog_color(self, color):
            self.fog_color = color
            fog_color.color = make_color(*color)

            self.send_contained(fog_color, save=True, rule=send_fog_rule)