Пример #1
0
      def action(current_ticks):
         entities.remove_pending_action(entity, action)

         entities.next_image(entity)

         if repeat_count != 1:
            schedule_action(world, entity,
               entity.create_animation_action(world, entity, max(repeat_count - 1, 0)),
               current_ticks + entities.get_animation_rate(entity))

         return [entities.get_position(entity)]
Пример #2
0
   def action(current_ticks):
      entities.remove_pending_action(entity, action)
      blob = create_blob(world, entities.get_name(entity) + " -- blob",
         entities.get_position(entity),
         entities.get_rate(entity) // BLOB_RATE_SCALE,
         current_ticks, i_store)

      remove_entity(world, entity)
      worldmodel.add_entity(world, blob)

      return [entities.get_position(blob)]
Пример #3
0
       def action(current_ticks):
          entities.remove_pending_action(entity, action)
          blob = world.create_blob(world, entities.get_name(entity) + " -- blob",
             entities.get_position(entity),
             entities.get_rate(entity),
             current_ticks, i_store)

          remove_entity(world, entity)
          add_entity(world, blob)

          return [entities.get_position(blob)]
Пример #4
0
        def action(current_ticks):
            entities.remove_pending_action(entity, action)
            blob = world.create_blob(world,
                                     entities.get_name(entity) + " -- blob",
                                     entities.get_position(entity),
                                     entities.get_rate(entity), current_ticks,
                                     i_store)

            remove_entity(world, entity)
            add_entity(world, blob)

            return [entities.get_position(blob)]
Пример #5
0
    def action(current_ticks):
        entities.remove_pending_action(entity, action)
        blob = create_blob(world,
                           entities.get_name(entity) + " -- blob",
                           entities.get_position(entity),
                           entities.get_rate(entity) // BLOB_RATE_SCALE,
                           current_ticks, i_store)

        remove_entity(world, entity)
        worldmodel.add_entity(world, blob)

        return [entities.get_position(blob)]
Пример #6
0
        def action(current_ticks):
            entities.remove_pending_action(entity, action)

            entities.next_image(entity)

            if repeat_count != 1:
                schedule_action(
                    world, entity,
                    entity.create_animation_action(world, entity,
                                                   max(repeat_count - 1, 0)),
                    current_ticks + entities.get_animation_rate(entity))

            return [entities.get_position(entity)]
Пример #7
0
       def action(current_ticks):
          entities.remove_pending_action(entity, action)

          entity_pt = entities.get_position(entity)
          smith = find_nearest(world, entity_pt, entities.Blacksmith)
          (tiles, found) = entity.miner_to_smith(world, entity, smith)

          new_entity = entity
          if found:
             new_entity = world.try_transform_miner(world, entity,
                world.try_transform_miner_full)

          schedule_action(world, new_entity,
             world.create_miner_action(world, new_entity, i_store),
             current_ticks + entities.get_rate(new_entity))
          return tiles
Пример #8
0
   def action(current_ticks):
      entities.remove_pending_action(entity, action)

      entity_pt = entities.get_position(entity)
      ore = worldmodel.find_nearest(world, entity_pt, entities.Ore)
      (tiles, found) = miner_to_ore(world, entity, ore)

      new_entity = entity
      if found:
         new_entity = try_transform_miner(world, entity,
            try_transform_miner_not_full)

      schedule_action(world, new_entity,
         create_miner_action(world, new_entity, i_store),
         current_ticks + entities.get_rate(new_entity))
      return tiles
Пример #9
0
    def action(current_ticks):
        entities.remove_pending_action(entity, action)

        entity_pt = entities.get_position(entity)
        smith = worldmodel.find_nearest(world, entity_pt, entities.Blacksmith)
        (tiles, found) = miner_to_smith(world, entity, smith)

        new_entity = entity
        if found:
            new_entity = try_transform_miner(world, entity,
                                             try_transform_miner_full)

        schedule_action(world, new_entity,
                        create_miner_action(world, new_entity, i_store),
                        current_ticks + entities.get_rate(new_entity))
        return tiles
Пример #10
0
        def action(current_ticks):
            entities.remove_pending_action(entity, action)

            entity_pt = entities.get_position(entity)
            ore = find_nearest(world, entity_pt, entities.Ore)
            (tiles, found) = entity.miner_to_ore(world, entity, ore)

            new_entity = entity
            if found:
                new_entity = world.try_transform_miner(
                    world, entity, world.try_transform_miner_not_full)

            schedule_action(
                world, new_entity,
                world.create_miner_action(world, new_entity, i_store),
                current_ticks + entities.get_rate(new_entity))
            return tiles
Пример #11
0
       def action(current_ticks):
          entities.remove_pending_action(entity, action)

          entity_pt = entities.get_position(entity)
          vein = find_nearest(world, entity_pt, entities.Vein)
          (tiles, found) = entity.blob_to_vein(world, entity, vein)

          next_time = current_ticks + entities.get_rate(entity)
          if found:
             quake = world.create_quake(world, tiles[0], current_ticks, i_store)
             add_entity(world, quake)
             next_time = current_ticks + entities.get_rate(entity) * 2

          schedule_action(world, entity,
             world.create_ore_blob_action(world, entity, i_store),
             next_time)

          return tiles
Пример #12
0
       def action(current_ticks):
          entities.remove_pending_action(entity, action)

          open_pt = world.find_open_around(world, entities.get_position(entity),
             entities.get_resource_distance(entity))
          if open_pt:
             ore = world.create_ore(world,
                "ore - " + entities.get_name(entity) + " - " + str(current_ticks),
                open_pt, current_ticks, i_store)
             add_entity(world, ore)
             tiles = [open_pt]
          else:
             tiles = []

          schedule_action(world, entity,
             world.create_vein_action(world, entity, i_store),
             current_ticks + entities.get_rate(entity))
          return tiles
Пример #13
0
    def action(current_ticks):
        entities.remove_pending_action(entity, action)

        open_pt = find_open_around(world, entities.get_position(entity),
                                   entities.get_resource_distance(entity))
        if open_pt:
            ore = create_ore(
                world, "ore - " + entities.get_name(entity) + " - " +
                str(current_ticks), open_pt, current_ticks, i_store)
            worldmodel.add_entity(world, ore)
            tiles = [open_pt]
        else:
            tiles = []

        schedule_action(world, entity,
                        create_vein_action(world, entity, i_store),
                        current_ticks + entities.get_rate(entity))
        return tiles
Пример #14
0
    def action(current_ticks):
        entities.remove_pending_action(entity, action)

        entity_pt = entities.get_position(entity)
        vein = worldmodel.find_nearest(world, entity_pt, entities.Vein)
        (tiles, found) = blob_to_vein(world, entity, vein)

        next_time = current_ticks + entities.get_rate(entity)
        if found:
            quake = create_quake(world, tiles[0], current_ticks, i_store)
            worldmodel.add_entity(world, quake)
            next_time = current_ticks + entities.get_rate(entity) * 2

        schedule_action(world, entity,
                        create_ore_blob_action(world, entity, i_store),
                        next_time)

        return tiles
Пример #15
0
 def action(current_ticks):
     entities.remove_pending_action(entity, action)
     pt = entities.get_position(entity)
     remove_entity(world, entity)
     return [pt]
Пример #16
0
 def action(current_ticks):
    entities.remove_pending_action(entity, action)
    pt = entities.get_position(entity)
    remove_entity(world, entity)
    return [pt]