Exemplo n.º 1
0
    def config_from_file(self, a_path):
        """
            Configure the Brewer instantiates elements and populates the Tank as described by the selected config file
            :param a_path: path and name of the config file
            :type a_path: String
        """
        print "using path:"+a_path 
	with open(a_path) as f:
            content = f.read()
	f.close()
	print "content"+content
        y = BeautifulSoup(content,"xml")
        self.__name = y.brewer['name']
        self.__receipe=Receipe("Fill me !")
        self.__receipe.config_from_file(y.brewer.receipe.contents[0])
        thermo_tank=Thermometer(y.brewer.tank.equipments.thermometer['name'], y.brewer.tank.equipments.thermometer.path.contents[0])
        if(y.brewer.tank['drivetype']=="BOOLEAN"):
            self.__tank=Tank(y.brewer.tank['name'],int(y.brewer.tank['diameter']),thermo_tank, BOOLEAN)
        elif(y.brewer.tank['drivetype']=="PID"):
            self.__tank=Tank(y.brewer.tank['name'],int(y.brewer.tank['diameter']),thermo_tank, PID)
        elif(y.brewer.tank['drivetype']=="PREDICTIVE"):
            self.__tank=Tank(y.brewer.tank['name'],int(y.brewer.tank['diameter']),thermo_tank, PREDICTIVE)
        elif(y.brewer.tank['drivetype']=="STEP_INERTIA"):
            self.__tank=Tank(y.brewer.tank['name'],int(y.brewer.tank['diameter']),thermo_tank, STEP_INERTIA)
        for a_heater in y.find_all('heater'):
            self.__tank.add_heater(Heater(a_heater.get('name'),int(a_heater.get('power')),int(a_heater.get('GPIOpin'))))
        for an_ingredient in y.find_all('ingredient'):
            if(an_ingredient.get('type')=="Grain"):
                self.__tank.add_ingredient(Ingredient(an_ingredient.get('name'),GRAIN,float(an_ingredient.get('quantity'))))
            elif(an_ingredient.get('type')=="Water"):
                self.__tank.add_ingredient(Ingredient(an_ingredient.get('name'),WATER,float(an_ingredient.get('quantity'))))
        self.__outside_thermometer = Thermometer(y.brewer.outsidethermometer['name'],y.brewer.outsidethermometer.path.contents[0])   
        return self.__name
Exemplo n.º 2
0
    def __init__(self):
        Tank.__init__(self)
        self.sensors = [Sensor(-45, 90, 75, False), Sensor(45, 90, 75, False), 
Sensor(0, 10, 50, True)]
        self.clockwise = random.random() < 0.5
        self.tread_accel = 120
        self.tread_max = 120
Exemplo n.º 3
0
 def __init__(self):
     Tank.__init__(self)
     self.sensors = [Sensor(0, 45, 90, True)]
     #speed = int((0.5 - random.random())*500)
     self.speed = 500
     print(self.speed) 
     
     self.set_speed('l', self.speed)
     self.set_speed('r', self.speed)        
Exemplo n.º 4
0
 def __init__(self,  coords, direction, phoenix, image=None, enemy=None):
     self.player = pygame.image.load(image).convert_alpha()
     self.player = pygame.transform.scale(
         self.player, (PART_SIZE, PART_SIZE))
     self.direction = direction
     self.screen = pygame.display.set_mode(SCREEN_SIZE)
     self.phoenix = phoenix
     self.enemy = enemy
     Tank.__init__(self, coords, self.direction, self.phoenix, self.enemy)
Exemplo n.º 5
0
    def __init__(self):
        Tank.__init__(self)
        self.sensors = [Sensor(0, 90, 75, False), Sensor(180, 90, 75, False)]
        self.clockwise = True
        self.forward = 1

        r = 200
        g = 50
        b = 50
        self.primary_color = '#{:02X}{:02X}{:02X}'.format(r, g, b)

        r = 10
        g = 10
        b = 10
        self.secondary_color = '#{:02X}{:02X}{:02X}'.format(r, g, b)
Exemplo n.º 6
0
def transfer():
    sID = input("Enter source ID: ")
    if Tank.isIDValid(sID) == False:
        print("Invalid ID entered. \n Back to Menu.")
        return
    dID = input("Enter Destination ID: ")
    if Tank.isIDValid(dID) == False:
        print("Invalid ID entered. \n Back to Menu.")
        return
    transferAMT = 0
    while(transferAMT <= 0):
        transferAMT = int(input("Enter positive amount to transfer: "))

    if tank_manager.transfer(sID, dID, transferAMT) == True:
        print("Tank ID: %s transfered %d to Tank ID: %s" % (sID, transferAMT, dID))
    else:
        print("Did not transfer.")
Exemplo n.º 7
0
def delete():
    id = input("Enter the id of the tank you want to remove: ")
    if Tank.isIDValid(id) == False:
        print("Invalid ID entered. \n Back to Menu.")
        return
    if tank_manager.delete(id) == True:
        print("Tank with ID: %s terminated." % id)
    else:
        print("Tank Not terminated.")
Exemplo n.º 8
0
def main():
    game = Game()
    render = Render(game)
    timer = pygame.time.Clock()
    players = []

    # add player
    tank = Tank()
    tank.pos = Vec2d(200, 200)
    p1 = HumanPlayer('Ray', tank)
    p1.Mapping = HumanPlayer.MappingSet1

    tank2 = Tank()
    tank2.pos = Vec2d(400, 200)
    p2 = HumanPlayer('Pest', tank2)
    p2.Mapping = HumanPlayer.MappingSet2

    players += [p1, p2]
    for p in players:
        game.add_player(p)

    # add obstacle
    for pos, col in zip([(100, 400), (500, 400)], ['blue', 'red']):
        obs = ObstacleBlock((100, 100), pos,  Color(col))
        game.obstacles.append(obs)

    timer.tick()
    FPS = config.FPS
    dt = 1.0/FPS
    while 1:
        for e in pygame.event.get():
            if e.type == QUIT:
                return
            elif e.type == KEYDOWN:
                for p in players:
                    p.on_keydown(e.key)
                if e.key == K_b or (e.mod & KMOD_LCTRL) and e.key == K_q:
                    return
            elif e.type == KEYUP:
                for p in players:
                    p.on_keyup(e.key)
        game.loop(dt)
        render.draw()
        game.fps = timer.tick(FPS)
Exemplo n.º 9
0
def display(tanks):

    ## Implement the Tank class appropriately, so this code
    ## works as intended.

    ## DO NOT MODIFY this function ##

    print(Tank.getHeader())

    for tank in tanks:
        print(tank.formatted_str())
Exemplo n.º 10
0
class TestTankLogic(unittest.TestCase):

    def setUp(self):
        self.tank1 = Tank()
        self.tank2 = Tank()

    def test_moving(self):
        self.assertEqual(self.tank1.pos, 0)
        self.assertEqual(self.tank2.pos, 0)

        self.tank1.pos = 100

        self.assertEqual(self.tank1.pos, 100)
        self.assertEqual(self.tank2.pos, 0)


    def test_fire(self):
        self.tank1.pos = 100

        self.tank2.fire(self.tank1)

        self.assertEqual(self.tank1.pos, 0)
Exemplo n.º 11
0
def add():
    id = input("Enter new Tank ID: ")
    if Tank.isIDValid(id) == False:
        print("Invalid ID entered.\n Tank Not Added.")
        return
    pNumber = input("Enter Part Number: ")
    amtLeft = input("Enter Amount Left: ")
    capacity = input("Enter Capacity: ")
    date = input("Enter the date (Y-M-D): ")
    newTank = id +"," + pNumber + "," + amtLeft + "," + capacity + "," + date
    addedTank = Tank(newTank)
    if tank_manager.add(addedTank) == True:
        print("Tank with ID: %s Added." % id)
    else:
        print("Tank Not Added.")
Exemplo n.º 12
0
    def get_rand_spawn_space(self):

        (x,y) = (0,0)
        new_tank = None
        new_pixels = None
        for i in range(100):
            should_break = True
            (x,y) = random.choice(self.available_spawn_locs)
            new_pixels = Tank.three_by_three((x,y))
            for t in self.tanks:
                if len(filter(lambda x: x in new_pixels, t.get_pixel_pos())) > 0:
                    should_break = False
                    break
            if should_break:
                break
        return (x,y)
Exemplo n.º 13
0
	def makeTank(self):

		self.tank = Tank(world=self)
Exemplo n.º 14
0
def setup_scene(file_path=''):
    # RESOLUTION
    try:
        cmds.setAttr("defaultResolution.width",
                     Tank().data['project']['resolution'][0])
        cmds.setAttr("defaultResolution.height",
                     Tank().data['project']['resolution'][1])
        cmds.setAttr('defaultResolution.deviceAspectRatio',
                     ((Tank().data['project']['resolution'][0]) /
                      (Tank().data['project']['resolution'][1])))
    except:
        LOG.error('FAILED load resolution.', exc_info=True)

    # IMG FORMAT
    # try:
    #     cmds.setAttr("defaultRenderGlobals.imageFormat", 8)
    # except: LOG.error('FAILED load img format.', exc_info=True)

    # FPS
    try:
        fps = software_data['SETTINGS']['FPS'][Tank().data['project']['fps']]
        cmds.currentUnit(time=fps)
        cmds.optionVar(sv=("workingUnitTime", fps))
        cmds.optionVar(sv=("workingUnitTimeDefault", fps))
    except:
        LOG.error('FAILED load fps.', exc_info=True)

    # UNIT
    try:
        cmds.currentUnit(linear=software_data['SETTINGS']['unit'])
    except:
        LOG.error('FAILED load unit.', exc_info=True)

    # RENDERER
    try:
        renderer = software_data['renderer']
        cmds.optionVar(sv=("preferredRenderer", software_data['renderer']))
        cmds.optionVar(sv=("preferredRendererHold", software_data['renderer']))
    except:
        LOG.error('FAILED load renderer.', exc_info=True)

    # ANIMATION extension
    try:
        cmds.setAttr('defaultRenderGlobals.animation', 1)
        cmds.setAttr('defaultRenderGlobals.putFrameBeforeExt', 1)
        cmds.setAttr('defaultRenderGlobals.extensionPadding', 4)
    except:
        LOG.error('FAILED set extension.', exc_info=True)

    if file_path:
        try:
            render_path = os.path.dirname(os.path.dirname(file_path))
            render_path += "/" + Tank(
            ).data['rules']["STATUS"]["render"] + "/<Scene>/<Scene>"
            cmds.setAttr('defaultRenderGlobals.imageFilePrefix',
                         render_path,
                         type='string')
        except:
            LOG.error('FAILED set image path.', exc_info=True)

        try:
            import pymel.core as pm
            pm.mel.setProject(os.path.dirname(file_path))
        except:
            LOG.error('FAILED set project path.', exc_info=True)
Exemplo n.º 15
0
def spawn_tank():
    tank = Tank(objects_to_add)
    tank.bag['tankx'] = 100
    tank.bag['tanky'] = 100
    tank.bag['barrelx'] = 100
    tank.bag['barrely'] = 100
Exemplo n.º 16
0
 def __init__(self):
     Tank.__init__(self)
     self.sensors = [Sensor(0, 90, 50, False), Sensor(0, 5, 400, True)]
     self.clockwise = random.random() < 0.5
Exemplo n.º 17
0
 def __init__(self):
     Tank.__init__(self)
     self.sensors = [Sensor(30, 60, 150, True), Sensor(-30, 60, 150, True), Sensor(0, 10, 50, True)]
     self.clockwise = True  # random.random() < 0.5
Exemplo n.º 18
0
from tank import Tank

tanks = {"a":Tank("Alpha"), "b":Tank("Blabo"), "c":Tank("Chary")}
alivetanks = len(tanks)

while alivetanks > 1:

    print
    for tankname in sorted( tanks.keys()):
        print (tankname, tanks[tankname])

    first = str(input("who fires??").lower())
    second= str(input("who at??").lower())

    try:
        firsttank = tanks[first]
        secondtank = tanks[second]
    except KeyError:
        print ("NO such Tank")

        continue

    if not firsttank.alive or not secondtank.alive:
        print("already dead")

        continue

    print ("*" *30)

    firsttank.fire_at(secondtank)
    if not secondtank.alive:
Exemplo n.º 19
0
class Game:
    def __init__(self):
        self.r = random.Random()

        self.scene = GameObject()

        # field --
        self.field = Field()
        self.field.load_from_file('data/level1.txt')
        self.scene.add_child(self.field)

        self.field_protector = FieldProtector(self.field)

        self.my_base = MyBase()
        self.my_base.position = self.field.map.coord_by_col_and_row(12, 24)
        self.scene.add_child(self.my_base)

        # tanks --
        self.tanks = GameObject()
        self.scene.add_child(self.tanks)

        self.make_my_tank()

        self.ai = EnemyFractionAI(self.field, self.tanks)

        # projectiles --
        self.projectiles = GameObject()
        self.scene.add_child(self.projectiles)

        # bonuses --
        self.bonues = GameObject()
        self.scene.add_child(self.bonues)

        self.score = 0
        self.score_layer = ScoreLayer()
        self.scene.add_child(self.score_layer)

        self.freeze_timer = Timer(10)
        self.freeze_timer.done = True

        # else --
        self.font_debug = pygame.font.Font(None, 18)

        # to test bonus
        self.make_bonus(*self.field.map.coord_by_col_and_row(13, 22),
                        BonusType.TOP_TANK)

    def respawn_tank(self, t: Tank):
        is_friend = self.is_friend(t)
        pos = random.choice(self.field.respawn_points(not is_friend))
        t.place(self.field.get_center_of_cell(*pos))
        if is_friend:
            t.tank_type = t.Type.LEVEL_1

    def make_my_tank(self):
        self.my_tank = Tank(Tank.FRIEND, Tank.Color.YELLOW, Tank.Type.LEVEL_1)
        self.respawn_tank(self.my_tank)
        self.my_tank.activate_shield()
        self.tanks.add_child(self.my_tank)
        self.my_tank_move_to_direction = None

    @property
    def frozen_enemy_time(self):
        return not self.freeze_timer.done

    def _on_destroyed_tank(self, t: Tank):
        if t.is_bonus:
            self.make_bonus(*t.center_point)

        if t.fraction == t.ENEMY:
            if t.tank_type == t.Type.ENEMY_SIMPLE:
                ds = 100
            elif t.tank_type == t.Type.ENEMY_FAST:
                ds = 200
            elif t.tank_type == t.Type.ENEMY_MIDDLE:
                ds = 300
            elif t.tank_type == t.Type.ENEMY_HEAVY:
                ds = 400
            else:
                ds = 0
            self.score += ds

            self.score_layer.add(*t.center_point, ds)

    def make_bonus(self, x, y, t=None):
        bonus = Bonus(BonusType.random() if t is None else t, x, y)
        self.bonues.add_child(bonus)

    def switch_my_tank(self):
        tank = self.my_tank
        t, d, p = tank.tank_type, tank.direction, tank.position
        tank.remove_from_parent()

        types = list(Tank.Type)
        current_index = types.index(t)
        next_type = types[(current_index + 1) % len(types)]
        tank = Tank(Tank.Color.PLAIN, next_type)
        tank.position = tank.old_position = p
        tank.direction = d
        tank.shielded = True
        tank.activate_shield()
        self.tanks.add_child(tank)
        self.my_tank = tank

    def make_explosion(self, x, y, expl_type):
        self.scene.add_child(Explosion(x, y, expl_type))

    def is_friend(self, tank):
        return tank.fraction == tank.FRIEND

    def fire(self, tank=None):
        tank = self.my_tank if tank is None else tank
        tank.want_to_fire = False

        if self.is_game_over and self.is_friend(tank):
            return

        if tank.try_fire():
            power = Projectile.POWER_HIGH if tank.tank_type.can_crash_concrete else Projectile.POWER_NORMAL
            projectile = Projectile(*tank.gun_point,
                                    tank.direction,
                                    sender=tank,
                                    power=power)
            self.projectiles.add_child(projectile)

    def move_tank(self, direction: Direction, tank=None):
        tank = self.my_tank if tank is None else tank
        tank.remember_position()
        tank.move_tank(direction)

    def apply_bonus(self, t: Tank, bonus: BonusType):
        if bonus == bonus.DESTRUCTION:
            for t in self.tanks:
                if not t.is_spawning and t.fraction == Tank.ENEMY:
                    self.kill_tank(t)
        elif bonus == bonus.CASK:
            t.shielded = True
        elif bonus == bonus.UPGRADE:
            t.upgrade()
        elif bonus == bonus.TIMER:
            self.freeze_timer.start()
        elif bonus == bonus.STIFF_BASE:
            self.field_protector.activate()
        elif bonus == bonus.TOP_TANK:
            t.upgrade(maximum=True)
        else:
            print(f'Bonus {bonus} not implemented yet.')

    def update_bonuses(self):
        for b in self.bonues:  # type: Bonus
            if b.intersects_rect(self.my_tank.bounding_rect):
                b.remove_from_parent()
                self.apply_bonus(self.my_tank, b.type)

    @property
    def all_mature_tanks(self):
        return (t for t in self.tanks if not t.is_spawning)

    @property
    def is_game_over(self):
        return self.my_base.broken

    def update_tanks(self):
        for tank in self.all_mature_tanks:
            self.field.oc_map.fill_rect(tank.bounding_rect,
                                        tank,
                                        only_if_empty=True)

        if not self.is_game_over:
            if self.my_tank_move_to_direction is None:
                self.my_tank.stop()
                self.my_tank.align()
            else:
                self.move_tank(self.my_tank_move_to_direction, self.my_tank)

        self.freeze_timer.tick()
        if self.frozen_enemy_time:
            self.ai.stop_all_moving()
        else:
            self.ai.update()

        for tank in self.all_mature_tanks:
            if tank.want_to_fire:
                self.fire(tank)

            if tank.to_destroy:
                tank.remove_from_parent()

            bb = tank.bounding_rect
            if not self.field.oc_map.test_rect(bb, good_values=(None, tank)):
                push_back = True
            else:
                push_back = self.field.intersect_rect(bb)

            if push_back:
                tank.undo_move()

    def is_player_tank(self, t: Tank):
        return t is self.my_tank

    def hit_tank(self, t: Tank):
        destroy = False
        if self.is_friend(t):
            destroy = True
            self.respawn_tank(t)
        else:
            t.hit = True
            self.ai.update_one_tank(t)
            if t.to_destroy:
                destroy = True
                t.remove_from_parent()
                self._on_destroyed_tank(t)

        if destroy:
            self.make_explosion(*t.center_point, Explosion.TYPE_FULL)

    def kill_tank(self, t: Tank):
        self.make_explosion(*t.center_point, Explosion.TYPE_FULL)

        if self.is_friend(t):
            self.respawn_tank(t)
        else:
            self.ai.update_one_tank(t)
            t.remove_from_parent()

    def make_game_over(self):
        self.my_base.broken = True
        go = GameOverLabel()
        go.place_at_center(self.field)
        self.scene.add_child(go)

    def update_projectiles(self):
        for p in self.projectiles:  # type: Projectile
            r = extend_rect((*p.position, 0, 0), 2)
            self.field.oc_map.fill_rect(r, p)

        remove_projectiles_waitlist = set()

        for p in self.projectiles:  # type: Projectile
            p.update()

            something = self.field.oc_map.get_cell_by_coords(*p.position)
            if something and something is not p and isinstance(
                    something, Projectile):
                remove_projectiles_waitlist.add(p)
                remove_projectiles_waitlist.add(something)

            was_stricken_object = False
            x, y = p.position
            if self.field.check_hit(p):
                was_stricken_object = True
                self.make_explosion(*p.position, Explosion.TYPE_SUPER_SHORT)
            elif self.my_base.check_hit(x, y):
                self.make_game_over()
                was_stricken_object = True
                self.make_explosion(*self.my_base.center_point,
                                    Explosion.TYPE_FULL)
            else:
                for t in self.all_mature_tanks:  # type : Tank
                    if t is not p.sender and t.check_hit(x, y):
                        was_stricken_object = True
                        if not t.shielded and p.sender.fraction != t.fraction:
                            self.make_explosion(*p.position,
                                                Explosion.TYPE_SHORT)
                            self.hit_tank(t)
                        break

            if was_stricken_object:
                remove_projectiles_waitlist.add(p)

        for p in remove_projectiles_waitlist:
            p.remove_from_parent()

    def update(self):
        self.field.oc_map.clear()
        self.field.oc_map.fill_rect(self.my_base.bounding_rect, self.my_base)

        self.field_protector.update()
        self.score_layer.update()

        self.update_tanks()
        self.update_bonuses()
        self.update_projectiles()

    # ---- render ----

    def render(self, screen):
        self.scene.visit(screen)

        score_label = self.font_debug.render(str(self.score), 1,
                                             (255, 255, 255))
        screen.blit(score_label, (GAME_WIDTH - 50, 5))

        # - 1 because the scene is not literally an object
        dbg_text = f'Objects: {self.scene.total_children - 1}'
        if self.is_game_over:
            dbg_text = 'Press R to restart! ' + dbg_text

        dbg_label = self.font_debug.render(dbg_text, 1, (255, 255, 255))
        screen.blit(dbg_label, (5, 5))

    # --- test ---

    def testus(self):
        self.respawn_tank(self.my_tank)
Exemplo n.º 20
0
# Colour constants
SKY_COLOR = (165, 182, 209)
SKY_COLOR = (165, 182, 209)
GROUND_COLOR = (9, 84, 5)
# Different tank colors for player 1 and player 2
# These colors must be unique as well as the GROUND_COLOR
TANK_COLOR_P1 = (216, 216, 153)
TANK_COLOR_P2 = (219, 163, 82)
SHELL_COLOR = (255, 255, 255)
TEXT_COLOR = (255, 255, 255)

# Timer used to create delays before action (prevent accidental button press)
game_timer = 0

# Tank 1 = Left
tank1 = Tank("left", TANK_COLOR_P1)
# Tank 2 = Right
tank2 = Tank("right", TANK_COLOR_P2)

# Only fire one shell at a time, a single shell object can be used for both player 1 and player 2
shell = Shell(SHELL_COLOR)

ground = Land(GROUND_COLOR, (WIDTH, HEIGHT))

# Get positions of tanks from ground generator
tank1.set_position(ground.get_tank1_position())
tank2.set_position(ground.get_tank2_position())


def draw():
    global game_state
Exemplo n.º 21
0
    screen.blit(settings.t2Icon, (650, 150)) 
    for i in range(25, tank2.hp * 25 + 1, 25):
        screen.blit(settings.heartImg, (650 + i, 150))

    textsurface = myfont.render(str(round(tank2.reload, 2)), False, WHITE)
    screen.blit(textsurface,(650,200))

    pygame.display.update(pygame.Rect(675, 50, 75, 200))

pygame.init()
clock = pygame.time.Clock()

pygame.font.init()  
myfont = pygame.font.SysFont('Comic Sans MS', 30)
    
tank1 = Tank(0, 0, settings.t1Img, 3, -1)
tank2 = Tank(settings.width - settings.block, settings.height - settings.block, settings.t2Img, 3, 1)
boxes = createBoxes()




screen = pygame.display.set_mode((settings.width + 200, settings.height))

play = True
while (play):
    circB = pygame.draw.rect(screen, BLACK, (tank1.X, tank1.Y, settings.block, settings.block))
    circB = pygame.draw.rect(screen, BLACK, (tank2.X, tank2.Y, settings.block, settings.block))
    grid.draw(screen)
    for i in pygame.event.get():
        if i.type == QUIT or (i.type == KEYDOWN and i.key == K_ESCAPE):
Exemplo n.º 22
0
 def make_my_tank(self):
     self.my_tank = Tank(Tank.FRIEND, Tank.Color.YELLOW, Tank.Type.LEVEL_1)
     self.respawn_tank(self.my_tank)
     self.my_tank.activate_shield()
     self.tanks.add_child(self.my_tank)
     self.my_tank_move_to_direction = None
from tank import Tank

tanks = {"a": Tank("Alice"), "b": Tank("Bob"), "c": Tank("Carol")}
alive_tanks = len(tanks)

while alive_tanks > 1:

    print
    for tank_name in sorted(tanks.keys()):
        print tank_name, tanks[tank_name]

    first = raw_input("Who fires? ").lower()
    second = raw_input("Who at? ").lower()

    try:
        first_tank = tanks[first]
        second_tank = tanks[second]
    except KeyError:
        print "No such tank!"
        continue

    if not first_tank.alive or not second_tank.alive:
        print "One of those tanks is dead!"
        continue

    print
    print "*" * 30

    first_tank.fire_at(second_tank)
    if not second_tank.alive:
        alive_tanks -= 1
Exemplo n.º 24
0
    def __init__(self):
        Tank.__init__(self)
        self.sensors = [Sensor(0, 180, 75, False), Sensor(0, 180, 50, False), Sensor(0, 180, 25, False)]
#, Sensor(0, 10, 50, True)]
        self.clockwise = random.random() < 0.5
Exemplo n.º 25
0
 def setUp(self):
     self.tank1 = Tank()
     self.tank2 = Tank()
Exemplo n.º 26
0
import sys, pygame
from bullet import Bullet
from tank import Tank
from chat import Chat
from config import *
import client



tank = Tank(width/2, height - 20)
enemy = Tank(width/2, 20, rotate = False)

# estabilish connect, have to receive
# 'conn' to be in the game
client = client.Client(sys.argv[1], int(sys.argv[2]))
print 'Conectando ao servidor...'
if client.connected():
	print 'OK!'
else:
	print 'Nao ha espaco livre no servidor'
	sys.exit()


# initialize chat
chat = Chat(client)

print 'Sincronizando...'
if client.synced():
	client.listen(tank, enemy, chat)

# init and show screen
Exemplo n.º 27
0
    def __init__(self):
        print 'Initiated main window'
        
        # Define the colors we will use in RGB format
        black = [  0,  0,  0]
        white = [255,255,255]
        self.dx = 0  # x travel
        self.dy = 0  # y travel
        self.dz = 0  # shot firing
        self.dzTime = 0 # shot last fired
        self.speed = 3 # tank speed
        pygame.init()
        screen = pygame.display.set_mode(SCREEN_SIZE)
        pygame.display.set_caption("Tanks Title") #FIXME working title
        
        # Initialize timer for MainWindow
        clock = pygame.time.Clock()
        
        font = pygame.font.Font(None, 25)
        # Render the text. "True" means anti-aliased text.
        # Black is the color. This creates an image of the
        # letters, but does not put it on the screen
        text = font.render("Tanks - hello world", True, black)
        
        tankPosition = [100, 100]
        self.localTank = Tank(tankPosition, "red")
        testDummy = Tank([400,400], "blue")
        self.tanks.add(testDummy)
        
#        self.sprites.add(testDummy)
        
        testSabot = Sabot(200,200, math.pi)
        
        mainExit=False
        while mainExit==False:
            # This limits the while loop to a max of 45 times per second.
            # Leave this out and we will use all CPU we can.
            clock.tick(45)
            
            for event in pygame.event.get(): # User did something
                # If user clicked close or hit escape key
                if event.type == pygame.QUIT or (event.type == pygame.KEYDOWN and event.key == pygame.K_ESCAPE):
                    mainExit = True # Flag that we are done so we exit this loop
                # FIXME Add menu system here
                self.userInput(event, tankPosition)
            # Put the image of the text on the screen at 250x250
            screen.fill(white)
            screen.blit(text, [250,250])
            
            # update the tank position
#            tankPosition = [tankPosition[0] + (self.dx * self.speed), tankPosition[1] + (self.dy * self.speed)]
#            self.localTank.moveTo(tankPosition)
            if self.dy > 0:
                self.localTank.moveForward()
            elif self.dy < 0:
                self.localTank.moveReverse()
            if self.dx > 0:
                self.localTank.rotateLeft()
            elif self.dx < 0:
                self.localTank.rotateRight()
            # paint the tank
            screen.blit(self.localTank.image, self.localTank.rect)
            testSabot.draw(screen)
            self.userAttack()
            for shot in self.sprites.sprites():
               shot.draw(screen)
             
            for t in self.tanks.sprites():
                t.draw(screen)   
            #screen.blit(testDummy.image, testDummy.rect)
            
            
            #self.sprites.
            if pygame.sprite.spritecollideany(testDummy, self.sprites):
                print 'Collide'
                self.sprites.remove(testDummy)
                collidedSabots = pygame.sprite.spritecollide(testDummy, self.sprites, True)
                if collidedSabots.__sizeof__() > 0: 
                    testDummy.killTank()
                    print 'Kill Tank'
            # Go ahead and update the screen with what we've drawn.
            # This MUST happen after all the other drawing commands.
            pygame.display.flip()
Exemplo n.º 28
0
    def create_folder_structure(self):
        # CHECK inputs
        for inputs in self.inputs:
            if not inputs.currentText():
                if self.scene_steps < 5 and self.wgSaveAs.cbxSet == inputs:
                    continue
                self.set_status('Missing input: {}'.format(
                    inputs.objectName().replace('cbx', '')),
                                msg_type=2)
                return False

        self.update_file()

        # CHECK FILE
        if os.path.exists(self.save_file):
            self.set_status('PATH already exists: {}'.format(self.save_file),
                            msg_type=2)
            return False

        save_list = []

        if self.all_task in self.save_file:
            for task in Tank().data_project['TASK'][
                    self.wgSaveAs.cbxScene.currentText()]:
                new_path = self.save_file.replace(self.all_task, task)
                save_list.append(new_path)
        else:
            save_list.append(self.save_file)

        LOG.debug('Folder list {}'.format(save_list))
        for folder in save_list:
            pipefunc.create_folder(folder)

        if self.new_file:
            Tank().software.scene_save_as(self.save_file, setup_scene=True)
            snapshot.create_any_screenshot(self.wgSaveAs)
            tmp_img_path = snapshot.save_snapshot(self.save_file)

            tmp_title = os.path.basename(self.save_file).split('.')[0]
            tmp_func = 'SAVE AS'

            self.set_meta_data(self.save_file)
        else:
            try:
                self.set_open_folder(save_list[0])
            except:
                LOG.error('CANT set folder: {}'.format(save_list))
            self.set_status('Created new {}'.format(
                self.wgSaveAs.cbxScene.currentText()),
                            msg_type=1)

            tmp_img_path = 'lbl/lbl_create'
            tmp_title = self.wgSaveAs.cbxScene.currentText()
            tmp_func = 'CREATE'

        note = arNotice.Notice(title=tmp_title,
                               msg='CREATED a new {} with folders'.format(
                                   self.wgSaveAs.cbxScene.currentText()),
                               func=tmp_func,
                               img=tmp_img_path,
                               img_link=os.path.dirname(self.save_file))
        arNotice.ArNotice(note)

        return True
Exemplo n.º 29
0
import os
import errno

import nuke

import libLog
import libFunc
from tank import Tank

TITLE = os.path.splitext(os.path.basename(__file__))[0]
LOG = libLog.init(script=TITLE)

#************************
# PIPELINE
all_data = Tank().data
project_data = all_data['project']
software_data = all_data['software']
RESOLUTION = (' ').join([
    str(project_data['resolution'][0]),
    str(project_data['resolution'][1]), project_data['name'].replace(' ', '')
])


#************************
# FOLDER CREATION
def createWriteDir():
    file_name = nuke.filename(nuke.thisNode())
    file_path = os.path.dirname(file_name)
    os_path = nuke.callbacks.filenameFilter(file_path)
Exemplo n.º 30
0
 def __init__(self):
     Tank.__init__(self)
     self.sensors = [Sensor(0, 90, 75, False), Sensor(90, 90, 75, False),Sensor(180, 90, 75, False),Sensor(270, 90, 75, False)]
     self.clockwise = random.random() < 0.5
 def create_tank(self):
     """Create A Tank Object and Fill it With Creatures"""
     self.__tank = Tank()
     self.__tank.fill_tank(self.__screen)
Exemplo n.º 32
0
    def __call__(self):
        from tank import Tank
        TITLE = os.path.splitext(os.path.basename(__file__))[0]
        LOG   = Tank().log.init(script=TITLE)

        LOG.debug('____________________________________________________________')
        LOG.debug('PIPELINE: {} [{}, {}, {}] {}'.format(self.pipeline_data['PIPELINE']['name'],
                           self.pipeline_data['PIPELINE']['version'],
                           os.environ['PIPELINE_STATUS'],
                           'user overwrite' if os.environ['DATA_USER_PATH'] else 'NO user overwrite',
                           self.data_pipeline_path))

        LOG.debug('PROJECT:  {} [{}, {}] [{}{}]'.format(self.project_data['name'],
                            '{} x {}'.format(Tank().data_project['resolution'][0], Tank().data_project['resolution'][1]),
                            Tank().data_project['fps'],
                            '' if os.path.exists(self.project_data['path']) else 'NOT existing: ',
                            os.path.normpath(self.project_data['path'])))

        LOG.debug('------------------------------------------------------------')
        LOG.debug('SYS_PATH: {}'.format('[%s]' % ', '.join(map(str, sys.path))))
        LOG.debug('ADD_ENV:  {}'.format(self.pipeline_env))
Exemplo n.º 33
0
 def respawn_tank(self, t: Tank):
     is_friend = self.is_friend(t)
     pos = random.choice(self.field.respawn_points(not is_friend))
     t.place(self.field.get_center_of_cell(*pos))
     if is_friend:
         t.tank_type = t.Type.LEVEL_1
Exemplo n.º 34
0
class Brewer:
    """
        A brewer uses the thermometers and heaters in order to follow the receipe. Each brewer has a single tank who knows its own composition in order to perform kick-ass calculations'
    """

    def __init__(self):
        """
            Constructor
        """
        self.__name = None
        self.__outside_thermometer = None
        self.__tank = None
        self.__receipe = None
        self.__brewing_started = False

    def config_from_file(self, a_path):
        """
            Configure the Brewer instantiates elements and populates the Tank as described by the selected config file
            :param a_path: path and name of the config file
            :type a_path: String
        """
        print "using path:"+a_path 
	with open(a_path) as f:
            content = f.read()
	f.close()
	print "content"+content
        y = BeautifulSoup(content,"xml")
        self.__name = y.brewer['name']
        self.__receipe=Receipe("Fill me !")
        self.__receipe.config_from_file(y.brewer.receipe.contents[0])
        thermo_tank=Thermometer(y.brewer.tank.equipments.thermometer['name'], y.brewer.tank.equipments.thermometer.path.contents[0])
        if(y.brewer.tank['drivetype']=="BOOLEAN"):
            self.__tank=Tank(y.brewer.tank['name'],int(y.brewer.tank['diameter']),thermo_tank, BOOLEAN)
        elif(y.brewer.tank['drivetype']=="PID"):
            self.__tank=Tank(y.brewer.tank['name'],int(y.brewer.tank['diameter']),thermo_tank, PID)
        elif(y.brewer.tank['drivetype']=="PREDICTIVE"):
            self.__tank=Tank(y.brewer.tank['name'],int(y.brewer.tank['diameter']),thermo_tank, PREDICTIVE)
        elif(y.brewer.tank['drivetype']=="STEP_INERTIA"):
            self.__tank=Tank(y.brewer.tank['name'],int(y.brewer.tank['diameter']),thermo_tank, STEP_INERTIA)
        for a_heater in y.find_all('heater'):
            self.__tank.add_heater(Heater(a_heater.get('name'),int(a_heater.get('power')),int(a_heater.get('GPIOpin'))))
        for an_ingredient in y.find_all('ingredient'):
            if(an_ingredient.get('type')=="Grain"):
                self.__tank.add_ingredient(Ingredient(an_ingredient.get('name'),GRAIN,float(an_ingredient.get('quantity'))))
            elif(an_ingredient.get('type')=="Water"):
                self.__tank.add_ingredient(Ingredient(an_ingredient.get('name'),WATER,float(an_ingredient.get('quantity'))))
        self.__outside_thermometer = Thermometer(y.brewer.outsidethermometer['name'],y.brewer.outsidethermometer.path.contents[0])   
        return self.__name
      

    def get_name(self):
        """
            Returns the name of the Brewer
            
            :return: Name of the Brewer
            :rtype: Sting
        """
        return self.__name


    def print_self(self):
        """
            Returns the Brewer as a human readable String ended with a new line
            
            :return: A String detailling the caracteristics of the Brewer
            :rtype: String
        """
        to_print="Name : "+self.__name
        to_print+="Outside thermometer : "+self.__outside_thermometer.print_self()
        to_print+="Tank : "+self.__tank.print_self()
        to_print+="Receipe : "+self.__receipe.print_self()+"\n"
        return to_print


    def init_brewing(self):
        """
            Checks that everything is ready for brewing and starts the receipe
            
            :return: A Boolean True = started OK, False for any anomaly
            :rtype: Boolean
        """
        if(self.__name == None or self.__tank == None or self.__receipe == None or self.__brewing_started == True):return False
        self.__brewing_started = True
        self.__receipe.start(self.__tank.get_current_temperature())
        print "***************************************************"
        print "Updated receipe "+self.__receipe.print_self()
        return True


    def log_temperatures(self,a_file):
        """
            This function logs in the desired output file the temperature state of the system.
            :param a_file: path and name of the file where all temperature will be reccorded
            :type a_file: String
        """
	f=open(a_file, "a")
	try:
	    f.write(str(datetime.datetime.now().strftime('%H:%M:%S'))+"\t"+unicodedata.normalize('NFKD',self.__receipe.get_current_step().get_name()).encode('ascii','ignore')+"\t"+str(self.__receipe.get_current_temperature_instruction())+"\t"+str(self.__tank.get_current_temperature())+"\t"+str(self.__tank.get_heating_status())+"\n")
	except:
            print "Unexpected log write error"
        f.close()


    def brew(self,a_outputfile):
        """
            This function is the main brewing function : ajusting the temperature according to the receipe. Function to be called regularily (every 5 seconds for instance).
            :param a_outputfile: path and name of the file where all temperature will be reccorded
            :type a_outputfile: String
        """
        while 1==1 :
            self.__receipe.update_step()
            if(self.__receipe.get_current_step().get_type()==TRANSITION):
				if(self.__tank.get_current_temperature()>=self.__receipe.get_next_temperature_instruction()): #Only works as long as transitions go from lower to higher temperatures...
					self.__receipe.transition_complete()
            if(self.__receipe.get_current_step()==None):
                print "Receipe completed"
                return True
            #self.__tank.temperature_hysteresis_drive(self.__receipe.get_current_temperature_instruction())
            #self.__tank.temperature_inertia_drive(self.__receipe.get_current_temperature_instruction(), self.__receipe.get_next_temperature_instruction())
            #self.__tank.temperature_model_drive(self.__receipe.get_current_temperature_instruction(), self.__receipe.get_next_temperature_instruction(),self.__outside_thermometer.read_temperature())
            self.__tank.temperature_step_inertia_drive(self.__receipe.get_current_temperature_instruction(), self.__receipe.get_next_temperature_instruction(),self.__receipe.get_current_step().get_inertia())
            print "Current step : "+self.__receipe.get_current_step().print_self()
            print "Temperature instuction : "+str(self.__receipe.get_current_temperature_instruction())
            print "Next Temperature instuction : "+str(self.__receipe.get_next_temperature_instruction())
            print "Current temperature : "+str(self.__tank.get_current_temperature())
            self.log_temperatures(a_outputfile)
            print 'Type "N" if you want to skip the current step',
            rlist, _, _ = select([sys.stdin], [], [], UPDATE_PERIOD)
            if rlist:
                s = sys.stdin.readline()
                if(s == "N\n"):
                    print "Skip order received"
                    self.__receipe.user_force_next_step()
            else:
                print "No input. Moving on..."
Exemplo n.º 35
0
# date      = 2019-12-01
#
# license   = MIT <https://github.com/alexanderrichtertd>
# author    = Alexander Richter <alexanderrichtertd.com>
#*********************************************************************

import os
import nuke
import webbrowser

from tank import Tank

#*********************************************************************
# VARIABLE
TITLE = os.path.splitext(os.path.basename(__file__))[0]
LOG = Tank().log.init(script=TITLE)


#*********************************************************************
# FUNCTIONS
def add_gizmo_menu(menu):
    for paths in os.getenv('SOFTWARE_SUB_PATH').split(';'):
        for file in os.listdir(paths):
            if file.endswith('.gizmo'):
                gizmo = file.replace('.gizmo', '')
                menu.addCommand('Gizmos/' + gizmo,
                                'nuke.tcl("{}")'.format(gizmo))


def add_write_node():
    import write_node
Exemplo n.º 36
0
    def __init__(self, perma_board = []):
        """ if we want walls/hospital we give them in perma_board
            perma_board should be formatted as a 64x64 2D list of pixel values """

        # the set of things on the board which never change
        # currently includes HOSPITAL and WALL
        # formatted as a 64x64 2D list of pixel values
        self.perma_board = perma_board
        if len(self.perma_board) == 0:
            for i in range(64):
                self.perma_board += [[EMPTY]*64]

        # the set of locations on the board where tanks can spawn
        # excludes HOSPITAL and WALL and anything adjacent to either
        # formatted as a 64x64 2D list of pixel values
        self.available_spawn_locs = [space for space in np.nindex(64,64)]
        self.available_spawn_locs = filter(lambda x: true_for_each(lambda y: self.perma_board[y[0],y[1]] == EMPTY, Tank.three_by_three(x)), self.available_spawn_locs)

        # purely aesthetic features which never interact
        # includes EYE for instance
        # formatted as a 64x64 2D list of pixel values
        self.ghost_board = []
        for i in range(64):
            self.ghost_board += [[EMPTY]*64]

        self.scores          = {}
        self.load_colors()
        self.tanks           = {}
        self.board           = copy.deepcopy(self.perma_board)
        self.bullets         = []
        self.t_minus         = TURN_RATE
        self.last_time_stamp = time.time()
        self.fast_forward    = False

        self.pending_tank_ids = []

        self.scomm = ServerCommunicator()
Exemplo n.º 37
0
class TankGame:
    """Class for the Tank Game"""
    def __init__(self):
        """Initializes the game"""
        pygame.init()
        self.settings = Settings()

        self.screen = pygame.display.set_mode(
            (self.settings.screen_width, self.settings.screen_height))
        pygame.display.set_caption("A Tank Game")

        self.tank = Tank(self)
        self.bullet = pygame.sprite.Group()

    def run_game(self):
        """Runs the game"""
        while True:
            self._check_event()
            self.tank.update()
            self._update_bullet()
            self._update_screen()

    def _check_event(self):
        """Checks for events"""
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                sys.exit()
            elif event.type == pygame.KEYDOWN:
                self._check_events_keydown(event)
            elif event.type == pygame.KEYUP:
                self._check_events_keyup(event)

    def _check_events_keydown(self, event):
        """Checks for keydown events"""
        if event.key == pygame.K_RIGHT:
            self.tank.moving_right = True
        elif event.key == pygame.K_LEFT:
            self.tank.moving_left = True
        elif event.key == pygame.K_UP:
            self.tank.moving_up = True
        elif event.key == pygame.K_DOWN:
            self.tank.moving_down = True
        elif event.key == pygame.K_q:
            sys.exit()
        elif event.key == pygame.K_SPACE:
            self._fire_bullet()

    def _check_events_keyup(self, event):
        """Checks for keyup events"""
        if event.key == pygame.K_RIGHT:
            self.tank.moving_right = False
        elif event.key == pygame.K_LEFT:
            self.tank.moving_left = False
        elif event.key == pygame.K_UP:
            self.tank.moving_up = False
        elif event.key == pygame.K_DOWN:
            self.tank.moving_down = False

    def _fire_bullet(self):
        """Produces a new bullet object and adds it to the 'bullet' list"""
        new_bullet = Bullet(self)
        self.bullet.add(new_bullet)

    def _update_bullet(self):
        """Updates the bullet and removes bullets that reaches out of screen"""
        self.bullet.update()
        for bullet in self.bullet.copy():
            if bullet.rect.bottom < 0:
                self.bullet.remove(bullet)

    def _update_screen(self):
        """Updates the screen """
        self.screen.fill(self.settings.bg_color)
        self.tank.blitme()
        for bullet in self.bullet.sprites():
            bullet.draw_bullet()
        pygame.display.flip()
Exemplo n.º 38
0
    def __init__(self):
        path_ui = ("/").join([os.path.dirname(__file__), "ui", TITLE + ".ui"])
        self.wgHeader = QtCompat.loadUi(path_ui)

        # VAR
        # self.monitor_res  = QtGui.QDesktopWidget().screenGeometry()
        # self.monitor_size = QtCore.QSize(self.monitor_res.width(), self.monitor_res.height())

        self.open_path = ""
        self.preview_img_path = ''
        Tank().user.create()

        self.wgHeader.setWindowIcon(
            QtGui.QPixmap(QtGui.QImage(
                Tank().get_img_path("btn/btn_project"))))

        # BUTTONS ICONS
        self.wgHeader.btnReport.setIcon(
            QtGui.QPixmap(QtGui.QImage(Tank().get_img_path("btn/btn_report"))))
        self.wgHeader.btnHelp.setIcon(
            QtGui.QPixmap(QtGui.QImage(Tank().get_img_path("btn/default"))))
        self.wgHeader.btnOpenFolder.setIcon(
            QtGui.QPixmap(QtGui.QImage(Tank().get_img_path("btn/btn_folder"))))
        self.wgHeader.btnUser.setIcon(
            QtGui.QPixmap(QtGui.QImage(
                Tank().get_img_path("user/default"))))  # current user
        self.wgHeader.btnUser.setToolTip(("").join([
            '<html><head/><body><p><span style=" font-weight:600;">',
            Tank().user.name, '</span><br>',
            Tank().user.rights, '<br>[open user folder]</p></body></html>'
        ]))

        self.wgHeader.btnProject.setIcon(
            QtGui.QPixmap(QtGui.QImage(
                Tank().get_img_path('btn/btn_project'))))  # current user
        self.wgHeader.btnProject.setToolTip(os.environ['PROJECT_NAME'] +
                                            '\n[open project folder]')

        # SIGNAL
        self.wgHeader.btnAccept.clicked.connect(self.press_btnAccept)
        self.wgHeader.btnAccept.setAttribute(
            QtCore.Qt.WA_TranslucentBackground)
        self.wgHeader.btnOption.clicked.connect(self.press_btnOption)

        self.wgHeader.btnOpenFolder.clicked.connect(self.press_btnOpenFolder)
        self.wgHeader.btnUser.clicked.connect(self.press_btnUser)
        self.wgHeader.btnProject.clicked.connect(self.press_btnProject)
        self.wgHeader.btnReport.clicked.connect(self.press_btnReport)
        self.wgHeader.btnHelp.clicked.connect(self.press_btnHelp)

        # SETUP
        self.refresh_data()
        self.set_status()
        self.set_open_folder()
        self.wgHeader.edtComment.setText('')
        self.wgHeader.setWindowIcon(
            QtGui.QIcon(Tank().get_img_path("btn/program")))
        #self.add_preview(self.wgHeader.layMain)
        #self.add_menu()

        self.wgHeader.setWindowFlags(QtCore.Qt.WindowStaysOnTopHint)
        # self.wgHeader.setWindowFlags(QtCore.Qt.CustomizeWindowHint | QtCore.Qt.FramelessWindowHint) # | QtCore.Qt.Tool | QtCore.Qt.WindowStaysOnTopHint)
        self.wgHeader.show()
Exemplo n.º 39
0
tank1_sprite = pygame.image.load("tank1_sprite.png").convert()
tank1_sprite = pygame.transform.scale(tank1_sprite, (35, 35))
tank1_sprite.set_colorkey((255, 255, 255))
tank2_sprite = pygame.image.load("tank2_sprite.png").convert()
tank2_sprite = pygame.transform.scale(tank2_sprite, (35, 35))
tank2_sprite.set_colorkey((255, 255, 255))

bullet1_sprite = pygame.image.load("bullet1_sprite.png").convert()
bullet1_sprite = pygame.transform.scale(bullet1_sprite, (15, 5))
bullet1_sprite.set_colorkey((255, 255, 255))
bullet2_sprite = pygame.image.load("bullet2_sprite.png").convert()
bullet2_sprite = pygame.transform.scale(bullet2_sprite, (15, 5))
bullet2_sprite.set_colorkey((255, 255, 255))

run = True
tank_1 = Tank(300, 300, 200, tank1_sprite, bullet1_sprite)
tank_2 = Tank(100, 100, 200, tank2_sprite, bullet2_sprite, pygame.K_d,
              pygame.K_a, pygame.K_w, pygame.K_s, pygame.K_SPACE)

tanks = [tank_1, tank_2]
bullets = []


def hit_check(bullet, which_bullet):
    global tanks

    shadow_x1 = []
    shadow_x2 = []
    shadow_y1 = []
    shadow_y2 = []
    i = 0
Exemplo n.º 40
0
def create_node(this_node=''):
    if not this_node: this_node = nuke.thisNode()

    if this_node["customRange"].getValue():
        this_node["frameStart"].setValue(int(nuke.Root()['first_frame'].getValue()))
        this_node["frameEnd"].setValue(int(nuke.Root()['last_frame'].getValue()))

    this_node["resolutionX"].setValue(this_node.width())
    this_node["resolutionY"].setValue(this_node.height())

    fileName   = os.path.basename(nuke.root().name()).split(".")[0]
    renderPath = os.path.dirname(os.path.dirname(nuke.root().name())) + "/{render}/{file}/exr/{file}.%04d.exr".format(render=Tank().data_project['STATUS']['render'], file=fileName)
    renderPath = renderPath.replace('\\','/')

    # this_node["rootPath"].setValue(renderPath)
    this_node["exrPath"].setValue(renderPath)
    this_node["jpgPath"].setValue(renderPath.replace("exr","jpg"))
    this_node["tifPath"].setValue(renderPath.replace("exr","tif"))
Exemplo n.º 41
0
from threading import Thread

from Qt import QtWidgets, QtGui, QtCore, QtCompat

import pipefunc
import arNotice
import snapshot

from tank import Tank
from users import User
from arUtil import ArUtil

#*********************************************************************
# VARIABLE
TITLE = os.path.splitext(os.path.basename(__file__))[0]
LOG = Tank().log.init(script=TITLE)


#*********************************************************************
# CLASS
class ArSaveAs(ArUtil):
    def __init__(self, new_file=True):
        super(ArSaveAs, self).__init__()

        path_ui = ("/").join([os.path.dirname(__file__), "ui", TITLE + ".ui"])
        self.wgSaveAs = QtCompat.loadUi(path_ui)

        self.all_task = '<all tasks>'

        self.new_file = new_file
        self.save_file = ''
Exemplo n.º 42
0
def openRV(path):
    if not os.path.exists(os.path.dirname(path)) or not os.listdir(os.path.dirname(path)):
        LOG.warning("FOLDER : NOT EXISTS : " + path)
    else:
        os.system('start "" "' + Tank().data_software['RV']['path'] + '" ' + path)
Exemplo n.º 43
0
 def set_meta_data(self, save_path=''):
     meta_path = os.path.dirname(
         save_path) + Tank().data_project['META']['file']
     comment_dict = {'user': User().id, 'comment': 'new scene'}
     Tank().set_data(meta_path, os.path.basename(save_path), comment_dict)
Exemplo n.º 44
0
class GameWindow(arcade.Window):
    def __init__(self, width, height, title, key_mappings):
        super().__init__(width, height, title)
        self.window_size = (width, height)
        self.key_mappings = key_mappings
        self.key_state = {key: None for key in self.key_mappings.keys()}
        self.mouse_position = (0, 0)
        self.view_left = 0
        self.view_bottom = 0

    def setup_level(self, map_source="res/level.tmx"):
        self.tank_list = arcade.SpriteList()
        self.tank = Tank(self.tank_list)
        self.tank.set_position(100, 100)

        self.bullet_list = arcade.SpriteList()

        level_map = arcade.tilemap.read_tmx(map_source)
        self.level_boundary = ((0, 0), (level_map.map_size.width *
                                        level_map.tile_size.width,
                                        level_map.map_size.height *
                                        level_map.tile_size.height))
        enemies_position = self.get_enemies_position(level_map)
        self.layers = {
            key: None
            for key in ("boundary", "background", "terrain", "box")
        }

        if level_map.background_color:
            arcade.set_background_color(level_map.background_color)
        for layer_name in self.layers.keys():
            self.layers[layer_name] = arcade.tilemap.process_layer(
                map_object=level_map, layer_name=layer_name)
        for sprite in self.layers["box"]:
            sprite.health = 20

        self.physics_engines = []
        self.physics_engines.append(
            arcade.PhysicsEngineSimple(self.tank.wheel_sprite,
                                       self.layers["boundary"]))
        self.physics_engines.append(
            arcade.PhysicsEngineSimple(self.tank.wheel_sprite,
                                       self.layers["box"]))

        self.ai_sprite_list = arcade.SpriteList()
        self.ai_objects = []
        for position in enemies_position:
            ai_obj = Tank(self.ai_sprite_list, "res/ai.png")
            ai_obj.set_position(*position)
            self.ai_objects.append(ai_obj)
            self.physics_engines.append(
                arcade.PhysicsEngineSimple(ai_obj.wheel_sprite,
                                           self.tank_list))
            self.physics_engines.append(
                arcade.PhysicsEngineSimple(self.tank.wheel_sprite,
                                           self.ai_sprite_list))
            self.physics_engines.append(
                arcade.PhysicsEngineSimple(ai_obj.wheel_sprite,
                                           self.layers["boundary"]))
            self.physics_engines.append(
                arcade.PhysicsEngineSimple(ai_obj.wheel_sprite,
                                           self.layers["box"]))
        self.path = None
        self.create_barriers()

    def create_barriers(self):
        grid_size = 64

        playing_field_left_boundary = self.level_boundary[0][0] + 64
        playing_field_right_boundary = self.level_boundary[1][0] - 64
        playing_field_top_boundary = self.level_boundary[1][1] - 64
        playing_field_bottom_boundary = self.level_boundary[0][1] + 64
        self.ai_barriers = []
        sp_list = arcade.SpriteList()
        sp_list.extend(self.layers["box"])
        sp_list.extend(self.layers["boundary"])

        barrier_list = CustomAStarBarrierList(None, sp_list, grid_size,
                                              playing_field_left_boundary,
                                              playing_field_right_boundary,
                                              playing_field_bottom_boundary,
                                              playing_field_top_boundary)
        for ai in self.ai_objects:
            barrier_list.moving_sprite = ai.wheel_sprite
            self.ai_barriers.append(barrier_list)

    def get_enemies_position(self, level_map):
        object_layers = filter(
            lambda x: isinstance(x, pytiled_parser.objects.ObjectLayer),
            level_map.layers)
        location = []
        for layer in object_layers:
            if layer.name == "enemies":
                for obj in layer.tiled_objects:
                    location.append(
                        (obj.location.x,
                         self.level_boundary[1][1] - obj.location.y))
        return location

    def on_key_press(self, key, modifiers):
        for key_k in self.key_state.keys():
            if self.key_mappings[key_k] == key:
                self.key_state[key_k] = True

    def on_key_release(self, key, modifiers):
        for key_k in self.key_state.keys():
            if self.key_mappings[key_k] == key:
                self.key_state[key_k] = False

    def on_mouse_press(self, x, y, button, modifiers):
        #print(x, y)
        self.bullet_list.append(self.tank.fire())

    def on_mouse_motion(self, x, y, dx, dy):
        self.mouse_position = (x + dx, y + dy)
        self.tank.rotate_turret(self.mouse_position,
                                (self.view_left, self.view_bottom))

    def on_update(self, delta_time):
        """ Movement and game logic """
        self.tank.movement(self.key_state, delta_time)

        for engine in self.physics_engines:
            engine.update()

        self.bullet_list.update()
        for bullet in self.bullet_list:
            hit_list = arcade.check_for_collision_with_list(
                bullet, self.layers["boundary"])
            hit_list.extend(
                arcade.check_for_collision_with_list(bullet,
                                                     self.layers["box"]))

            items = arcade.check_for_collision_with_list(
                bullet, self.layers["box"])

            removed = False
            for item in items:
                if hasattr(item, "health"):
                    item.health -= bullet.damage
                    if item.health <= 0:
                        item.remove_from_sprite_lists()
                        removed = True
            if removed:
                self.create_barriers()
            if len(hit_list) > 0:
                bullet.remove_from_sprite_lists()

        self.tank.update()

        self.tank.rotate_turret(self.mouse_position,
                                (self.view_left, self.view_bottom))
        for self.ai_object in self.ai_objects:
            self.ai_object.update()

            enemy = self.ai_object.wheel_sprite
            enemy_x, enemy_y = enemy.position
            tank_x, tank_y = self.tank.wheel_sprite.position
            distance_between_ai_and_tank = ((tank_x - enemy_x)**2 +
                                            (tank_y - enemy_y)**2)**(0.5)
            if distance_between_ai_and_tank < 1000 and distance_between_ai_and_tank > 100:
                self.path = arcade.astar_calculate_path(
                    enemy.position,
                    self.tank_list[0].position,
                    self.ai_barriers[0],
                    diagonal_movement=True)
                if self.path and len(
                        self.path) > 1 and distance_between_ai_and_tank > 100:
                    x1, y1 = self.path[1]
                    x2, y2 = self.ai_object.wheel_sprite.position
                    direction = (x1 - x2), (y1 - y2)
                    x, y = direction
                    magnitude = (x**2 + y**2)**0.5
                    unit_vector = x / magnitude, y / magnitude
                    velocity = self.ai_object.movement_speed
                    req_vector = unit_vector[0] * velocity, unit_vector[
                        1] * velocity
                    delta_position = req_vector[0] * \
                        delta_time, req_vector[1] * delta_time

                    angle = math.atan2(
                        *unit_vector[::-1]) - self.ai_object.rotation
                    self.ai_object.rotate_body(angle)
                    #ai turret roatation
                    x, y = self.tank.body_sprite.position
                    turret_x, turret_y = self.ai_object.turret_sprite.position
                    if (turret_y - y) != 0:
                        rad = math.atan2((turret_x - x), (y - turret_y))
                        self.ai_object.turret_sprite.radians = rad

                    #ai bullet firing
                    self.ai_object.change_position(*delta_position)
                    self.ai_object.ai_fire_dt += delta_time
                    if (self.ai_object.ai_fire_dt >
                        (1 / self.ai_object.ai_fire_rate)):
                        self.bullet_list.append(self.ai_object.fire())
                        self.ai_object.ai_fire_dt -= (
                            1 / self.ai_object.ai_fire_rate)
        self.scroll(self.tank.body_sprite)

    def draw_health(self):
        height_offset = 15
        healthbar_width = 70
        healthbar_height = 10
        if hasattr(self.tank, "health"):
            sprite = self.tank.body_sprite
            if self.tank.health != 100:
                arcade.draw_rectangle_filled(
                    sprite.center_x,
                    sprite.center_y + sprite.height + height_offset,
                    healthbar_width, healthbar_height, arcade.csscolor.WHITE)
                width = healthbar_width * self.tank.health / 100
                width_reduced = healthbar_width - width
                arcade.draw_rectangle_filled(
                    sprite.center_x - width_reduced / 2,
                    sprite.center_y + sprite.height + height_offset, width,
                    healthbar_height, arcade.csscolor.GREEN)

    def scroll(self, follow_sprite):
        left_viewport_margin = 250
        right_viewport_margin = 250
        bottom_viewport_margin = 250
        top_viewport_margin = 250

        changed = False

        # Scroll left
        left_boundary = self.view_left + left_viewport_margin
        if self.tank.body_sprite.left < left_boundary and self.view_left > self.level_boundary[
                0][0]:
            self.view_left -= left_boundary - self.tank.body_sprite.left
            changed = True

        # Scroll right
        right_boundary = self.view_left + \
            self.window_size[0] - right_viewport_margin
        if self.tank.body_sprite.right > right_boundary and self.view_left + self.window_size[
                0] < self.level_boundary[1][0]:
            self.view_left += self.tank.body_sprite.right - right_boundary
            changed = True

        # Scroll up
        top_boundary = self.view_bottom + \
            self.window_size[1] - top_viewport_margin
        if self.tank.body_sprite.top > top_boundary and self.view_bottom + self.window_size[
                1] < self.level_boundary[1][1]:
            self.view_bottom += self.tank.body_sprite.top - top_boundary
            changed = True

        # Scroll down
        bottom_boundary = self.view_bottom + bottom_viewport_margin
        if self.tank.body_sprite.bottom < bottom_boundary and self.view_bottom > self.level_boundary[
                0][1]:
            self.view_bottom -= bottom_boundary - self.tank.body_sprite.bottom
            changed = True

        if changed:
            # Only scroll to integers. Otherwise we end up with pixels that
            # don't line up on the screen
            self.view_bottom = int(self.view_bottom)
            self.view_left = int(self.view_left)
            arcade.set_viewport(self.view_left,
                                int(self.window_size[0] + self.view_left),
                                self.view_bottom,
                                self.window_size[1] + self.view_bottom)

    def on_draw(self):
        arcade.start_render()

        for value in self.layers.values():
            value.draw()
        self.bullet_list.draw()
        self.ai_sprite_list.draw()
        self.tank_list.draw()
        self.draw_health()

        if self.path:
            arcade.draw_line_strip(self.path, arcade.color.BLUE, 2)
Exemplo n.º 45
0
        value = os.path.normpath(value)
        if self.has_key(key): self[key].append(value)
        else:                 self[key] = [value]

    def __missing__(self, key):
        return key



#*********************************************************************
# START
import argparse

parser = argparse.ArgumentParser(description='Setup your pipeline and start scripts.')
parser.add_argument('-so','--software', help='add software: nuke')
parser.add_argument('-p', '--proxy', action='store_true')

args = parser.parse_args()

if args.software:
    Setup()

    from tank import Tank
    if args.software == 'desktop':
        # Tank().start_software(args.software)
        import arDesktop
        arDesktop.start()
    else:
        Tank().start_software(args.software)

Exemplo n.º 46
0
from stream import Stream
from tank import Tank
from system import System

for steps in [10, 50, 100, 200, 500]:
    tank_system = System()

    tank1 = Tank('Tank A')
    tank2 = Tank('Tank B', start_salt=20, line_color="-b")

    streams1_in = [Stream(6, 0.2), Stream(1, tank2)]
    streams1_out = [Stream(3, tank1), Stream(4, tank1)]

    for stream in streams1_in:
        tank1.add_stream_in(stream)

    for stream in streams1_out:
        tank1.add_stream_out(stream)

    streams2_in = [Stream(3, tank1)]
    streams2_out = [Stream(1, tank2), Stream(2, tank2)]

    for stream in streams2_in:
        tank2.add_stream_in(stream)

    for stream in streams2_out:
        tank2.add_stream_out(stream)

    tank_system.add_tank(tank1)
    tank_system.add_tank(tank2)
Exemplo n.º 47
0
    def set_pipeline_env(self):

        # SET STATUS
        os.environ['PIPELINE_STATUS'] = self.pipeline_status

        # ADD sub ENV
        for eachPath in self.data_pipeline_path:
            self.pipeline_env.add('PIPELINE_PATH', eachPath)

            if os.path.exists(eachPath + '/img'):        self.pipeline_env.add('IMG_PATH', eachPath + '/img')
            if os.path.exists(eachPath + '/software'):   self.pipeline_env.add('SOFTWARE_PATH', eachPath + '/software')
            if os.path.exists(eachPath + '/lib'):        self.pipeline_env.add('LIB_PATH', eachPath + '/lib')

            if os.path.exists(eachPath + '/lib/apps'):   self.pipeline_env.add('APPS_PATH', eachPath + '/lib/apps')
            if os.path.exists(eachPath + '/lib/extern'): self.pipeline_env.add('EXTERN_PATH', eachPath + '/lib/extern')
            if os.path.exists(eachPath + '/lib/dcc'):    self.pipeline_env.add('DCC_PATH', eachPath + '/lib/dcc')

        os.environ['DATA_PATH'] = self.data_pipeline_path[0] + '/data'
        os.environ['DATA_PROJECT_PATH'] = self.data_pipeline_path[0] + '/data/project/' + self.pipeline_data['project']

        # ADD all pipeline env
        self.add_env('PIPELINE_PATH', (';').join(self.pipeline_env['PIPELINE_PATH']))
        try:
            self.add_env('IMG_PATH',     (';').join(self.pipeline_env['IMG_PATH']))
            self.add_env('LIB_PATH',     (';').join(self.pipeline_env['LIB_PATH']))
            self.add_env('APPS_PATH',    (';').join(self.pipeline_env['APPS_PATH']))
            self.add_env('EXTERN_PATH',  (';').join(self.pipeline_env['EXTERN_PATH']))
            self.add_env('DCC_PATH',     (';').join(self.pipeline_env['DCC_PATH']))

            self.add_env('SOFTWARE_PATH',     (';').join(self.pipeline_env['SOFTWARE_PATH']))
            self.add_env('SOFTWARE_SRC_PATH', (';').join(self.pipeline_env['SOFTWARE_PATH']))
        except: raise OSError ('STOP PROCESS', 'PATH doesnt exist in data/pipeline.yml', self.this_pipeline)

        sys.path.append(os.environ['PIPELINE_PATH'])
        sys.path.append(os.environ['IMG_PATH'] )
        sys.path.append(os.environ['LIB_PATH'])
        sys.path.append(os.environ['APPS_PATH'])
        sys.path.append(os.environ['DCC_PATH'])
        sys.path.append(os.environ['SOFTWARE_PATH'] )
        sys.path.append(os.environ['DATA_PATH'])
        sys.path.append(os.environ['DATA_PROJECT_PATH'])

        self.add_env('PYTHONPATH', os.environ['IMG_PATH'])
        self.add_env('PYTHONPATH', os.environ['LIB_PATH'])
        self.add_env('PYTHONPATH', os.environ['APPS_PATH'])
        self.add_env('PYTHONPATH', os.environ['EXTERN_PATH'])
        self.add_env('PYTHONPATH', os.environ['DCC_PATH'])

        # DATA ENV
        os.environ['DATA_USER_PATH']      = self.data_pipeline_path[0] + '/data/user/' + getpass.getuser()
        os.environ['DATA_USER_OVERWRITE'] = str(self.pipeline_data['user_data'])
        sys.path.append(os.environ['DATA_USER_PATH'])

        # SET project Data
        from tank import Tank

        self.project_data = Tank().data_project
        os.environ['PROJECT_NAME'] = self.project_data['name']

        # ADD project path
        if os.path.exists(self.project_data['path']):
            os.environ['PROJECT_PATH'] = os.path.normpath(self.project_data['path'])
        else: os.environ['PROJECT_PATH'] = ''

        # OS & PYTHON_VERSION
        os.environ['OS'] = sys.platform
        os.environ['PYTHON_VERSION'] = sys.version[:3]
Exemplo n.º 48
0
class PyTanksIO:
    """
    Main class that contains most of the code for the game
    """

    def __init__(self, width, height, title):
        # Window initializing code
        self.win_size = width, height
        self.win = pygame.display.set_mode((width, height))
        pygame.display.set_caption(title)

        self.running = True
        self.background = (0, 0, 0)

        # Pymunk initializing code
        pymunk.pygame_util.positive_y_is_up = False
        self.space = pymunk.Space()
        self.space.gravity = 0, 700

        # Create game objects
        self.ground = Ground(self.win_size[0], 150, self.win_size)
        self.player1 = Tank("red")
        self.player2 = Tank("blue")
        self.bullets = []

        # Setup code
        self.current_player = self.player1
        self.other_player = self.player2
        self.moves_left = 100
        self.shoot_wait = 380
        self.shooting = False

        self.player1.body._set_position((100, 250))
        self.player2.body._set_position((width-136, 250))

        # Add game objects to space
        self.ground.add_to_space(self.space)
        self.player1.add_to_space(self.space)
        self.player2.add_to_space(self.space)

    def input(self, keys):
        current_p = self.current_player
        body = self.current_player.body
        speed = Tank("ehhh").vertices[2][0] * 2.3333333333
        rot_speed = 0.7
        power_speed = 1

        if not self.shooting:
            # Tank Movement
            if body.velocity[1] < 1 and self.moves_left > 0:
                if keys[pygame.K_d] or keys[pygame.K_RIGHT]:
                    body.velocity = speed, body.velocity[1]
                    self.moves_left -= 1
                if keys[pygame.K_a] or keys[pygame.K_LEFT]:
                    body.velocity = -speed, body.velocity[1]
                    self.moves_left -= 1

            # Turret Rotation
            if keys[pygame.K_q] or keys[pygame.K_COMMA]:
                current_p.turn_turret(rot_speed)
            if keys[pygame.K_e] or keys[pygame.K_PERIOD]:
                current_p.turn_turret(-rot_speed)

            # Power Adjusting
            if keys[pygame.K_w] or keys[pygame.K_UP]:
                current_p.fire_power += power_speed
            if keys[pygame.K_s] or keys[pygame.K_DOWN]:
                current_p.fire_power -= power_speed

            # Firing
            if keys[pygame.K_SPACE] and current_p.fire_timer >= 100:
                self.shooting = True
                current_p.fire_timer = 0
                bullet = current_p.shoot()
                bullet.add_to_space(self.space)
                self.bullets.append(bullet)

        elif self.shooting:
            self.shoot_wait -= 1
            self.moves_left = 100

    def logic(self):
        # Update Rects for rendering
        self.player1.update()
        self.player2.update()

        current_p = self.current_player
        other_p = self.other_player

        for bullet in self.bullets:
            # Collision with ground
            if self.ground.rect.colliderect(bullet.rect):
                bullet.body.velocity *= 0, 1

            bullet.update()

            # Collision with tanks
            if bullet.rect.colliderect(current_p.rect):
                current_p.score -= randint(5, 10)
                self.bullets.remove(bullet)
                self.shoot_wait = 35
            elif bullet.rect.colliderect(other_p.rect):
                current_p.score += randint(10, 15)
                self.bullets.remove(bullet)
                self.shoot_wait = 35

        # Reset self.shooting
        if self.shoot_wait <= 0:
            self.bullets.clear()
            self.shooting = False
            self.shoot_wait = 380
            self.current_player, self.other_player = self.other_player, self.current_player

    def render(self):
        self.win.fill(self.background)

        # Render Game Objects
        self.ground.render(self.win)
        self.player1.render(self.win)
        self.player2.render(self.win)

        for bullet in self.bullets:
            bullet.render(self.win)

        # Render UI Elements
        text(
            self.win,
            "Player 1: " + str(self.player1.score),
            35,
            (255, 255, 255),
            (80, 30)
        )

        text(
            self.win,
            "Player 2: " + str(self.player2.score),
            35,
            (255, 255, 255),
            (self.win_size[0] - 80, 30)
        )

        if self.current_player == self.player1:
            turn_display = "Player 1's Turn"
        elif self.current_player == self.player2:
            turn_display = "Player 2's Turn"

        if not self.shooting:
            text(
                self.win,
                turn_display,
                40,
                (255, 255, 255),
                (self.win_size[0] / 2, self.win_size[1] - 70)
            )

        pygame.display.flip()
Exemplo n.º 49
0
import os

import maya.mel as mel
import maya.cmds as cmds
import maya.OpenMaya as api

import libLog
from tank import Tank

import libLog

TITLE = os.path.splitext(os.path.basename(__file__))[0]
LOG = libLog.init(script=TITLE)

software_data = Tank().software.data


def setup_scene(file_path=''):
    # RESOLUTION
    try:
        cmds.setAttr("defaultResolution.width",
                     Tank().data['project']['resolution'][0])
        cmds.setAttr("defaultResolution.height",
                     Tank().data['project']['resolution'][1])
        cmds.setAttr('defaultResolution.deviceAspectRatio',
                     ((Tank().data['project']['resolution'][0]) /
                      (Tank().data['project']['resolution'][1])))
    except:
        LOG.error('FAILED load resolution.', exc_info=True)
Exemplo n.º 50
0
 def __init__(self, grid: Grid):
     self.grid = grid
     self.shots = Shots(self.grid)
     self.greenTank = Tank(CellType.GreenTankBody, self.grid.green_start)
     self.blueTank = Tank(CellType.BlueTankBody, self.grid.blue_start)
Exemplo n.º 51
0
# date      = 2019-12-01
#
# license   = MIT <https://github.com/alexanderrichtertd>
# author    = Alexander Richter <alexanderrichtertd.com>
#*********************************************************************

import os
import sys

import maya.cmds as cmds

import maya_utils
from tank import Tank

#*********************************************************************
# VARIABLE
TITLE = 'userSetup'  # os.path.splitext(os.path.basename(__file__))[0]
LOG = Tank().log.init(script=TITLE)

#*********************************************************************
# INIT AND PRINT CONSOLE
Tank().init_software(os.getenv('SOFTWARE'))

Tank().software.print_checked_header(
    'menu', func=cmds.evalDeferred("maya_utils.load_menus()"))
Tank().software.print_checked_header('shelf')
Tank().software.print_checked_header('scene setup')
Tank().software.print_checked_header('render setup')

print("")
Exemplo n.º 52
0
 def __init__(self):
     Tank.__init__(self)
     self.sensors = [Sensor(0, 10, 60, True), Sensor(0, 120, 100, False),
         Sensor(120, 120, 100, False), Sensor(240, 120, 100, False)]
Exemplo n.º 53
0
class World(object):

	''' 
	
	Inits 
	=================================='''

	def __init__(self, width, height):
		self.width = width
		self.height = height
		self.center = Vector2D(width/2, height/2)
		

		self.obstacles = []
		self._clock = 0
		
		
		self.scale = 10
		self.gravity = Vector2D(0, -900)
		

		self.makeTank()
		
		self.makeFish()

		self.makeDebug()

		self.makeFood()

		self.makeObstacles()

		self.makeHunters()



	'''

	Setup methods
	=================================='''



	def makeFish(self):        
		self.fishes = []


	
	def makeFood(self):
		self.food = []
		self.foodDistance = 30
		self.autoFeed = True
		self.autoFeedAboveInterval = 2    # seconds
		self.autoFeedBelowInterval = 1    # seconds
		self.sicknessEnabled = True
		self.sicknessInterval = 0.1

		
		clock.schedule_interval(self.autoAddFoodAbove, self.autoFeedAboveInterval)
		clock.schedule_interval(self.autoAddFoodBelow, self.autoFeedBelowInterval)
		clock.schedule_interval(self.makeFishSicker, self.sicknessInterval)


	def makeTank(self):

		self.tank = Tank(world=self)


	def makeObstacles(self):

		self.obstacles = []

		self.addRocks(10)



	def makeHunters(self):

		self.hunters = []

		self.addHunters()


	'''

	'Add' methods
	=================================='''



	def addFood(self, x, y=None, num = 1):

		# If no y was given then use the standard food distance above the tank
		if(y is None):
			y = self.height - self.foodDistance
		else:
			y = Util.clamp(self.tank.box.bottom, y, self.height)

		# Make sure the food will go in the tank
		x = Util.clamp(self.tank.box.left, x, self.tank.box.right)

		# Add the foods
		for _ in range(num):
			newFood = Food(world=self)
			newFood.pos = Vector2D(x, y)
			self.food.append(newFood)


	def obstacleOverlapsOtherObstacles(self, obstacle):
		breathingSpace = 20
		for o in self.obstacles:
			if(o.pos.distance(obstacle.pos) - obstacle.boundingRadius - o.boundingRadius < breathingSpace):
				return True
		return False


	def addRocks(self, num=10):

		for i in range(num):
			newRock = Rock(world=self)
			
			newRock.vel = Vector2D.random(newRock.maxSpeed)
			newRock.vel.y = 0

			newRock.pos = self.tank.randomPosition()
			while(self.obstacleOverlapsOtherObstacles(newRock)):
				newRock.pos = self.tank.randomPosition()

			self.obstacles.append(newRock)
		   

	def autoAddFoodAbove(self, dt=0):
		self.autoAddFood(above=True)


	def autoAddFoodBelow(self, dt=0):
		self.autoAddFood(above=False)
		self.autoAddFood(above=False)


	def autoAddFood(self, above = True):

		# Make sure auto food is enabled
		if(not self.autoFeed): return

		position = self.tank.randomPosition()

		# Add the food
		if(above):
			self.addFood(x = position.x)
		else:
			self.addFood(x = position.x, y = position.y)


	def addHunters(self, num=1):
		
		# Add the foods
		for _ in range(num):
			newHunter = Hunter(world=self)
			newHunter.pos = self.tank.randomPosition()
			self.hunters.append(newHunter)




	'''

	Updating
	=================================='''

	def update(self, delta, forced=False):
		
		self.lastDelta = delta

		if not self.paused or forced:
			self._clock += delta

			# Debug fish
			if(len(self.fishes)): self.fishes[0].chosenOne = True
			if(len(self.hunters)): self.hunters[0].chosenOne = True

			# Keep list of living fish for food calculatinons
			self.livingFishes = [f for f in self.fishes if not f.dead]

			# TODO: Calculate fish times/distances from foods for everything so it isn't
			#       recalculated by every fish * food
			# self.calculateFoodData()

			# Updates
			[f.update(delta) for f in self.fishes]
			[f.update(delta) for f in self.food if not f.eaten]
			[o.update(delta) for o in self.obstacles]
			[h.update(delta) for h in self.hunters]




			# Kill dead fishes
			self.fishes = [f for f in self.fishes if not (f.dead and f.pos.y < self.tank.box.bottom - 50)]

			# Remove food that's off the screen
			self.food = [f for f in self.food if not f.eaten]


	def makeFishSicker(self, dt=0):
		# Make sure sickness is enabled
		if(not self.sicknessEnabled): return

		[f.sicker() for f in self.fishes]    


	




	''' 
	
	Rendering 
	=================================='''

	def render(self):

		# Draw tank first
		self.tank.render()

		# Then fish
		[f.render() for f in self.fishes]

		# Food
		[f.render() for f in self.food if not f.eaten]

		# Rocks
		[o.render() for o in self.obstacles]

		# Hunters
		[h.render() for h in self.hunters]

		

		

		










	''' 
	
	World logic 
	=================================='''


	def resize(self, width, height):
		self.width = width
		self.height = height
		self.center = Vector2D(width/2, height/2)

		self.tank.resize()


	def addFish(self, num=1):
		if(num < 1): return

		newFishes = []
		for _ in xrange(num):
			newFish = Guppy(world=self, scale=10)
			self.fishes.append(newFish)
			newFishes.append(newFish)

		# if(num == 1)
		#     return newFishes[0]

		return newFishes


	def randomizePath(self):
		self.path.create_random_path(8, self.width/6, self.height/6, self.width*2/3 + self.width/6, self.height*2/3 + self.height/6)
		for agent in self.fishes:
				agent.path = self.path


	


	def getNeighbours(self, agent, distance=100):

		distanceSq = distance**2

		return [a for a in self.fishes if a != agent and a.pos.distanceSq(agent.pos) < distanceSq]


	def getFood(self, agent, distance=10000):

		return [f for f in self.food if not f.eaten and self.tank.contains(f.pos)]


	# Enables/disables the circle of life properties
	@property
	def lionKing(self):
		return self.autoFeed # same value for both, so just pick this one

	@lionKing.setter
	def lionKing(self, value):
		self.autoFeed = value
		self.sicknessEnabled = value







	 
	''' 

	Util 
	=================================='''


	def wrap_around(self, pos):
		''' Treat world as a toroidal space. Updates parameter object pos '''
		max_x, max_y = self.width, self.height
		if pos.x > max_x:
			pos.x = pos.x - max_x
		elif pos.x < 0:
			pos.x = max_x - pos.x
		if pos.y > max_y:
			pos.y = pos.y - max_y
		elif pos.y < 0:
			pos.y = max_y - pos.y


	def transform_points(self, points, pos, forward, side, scale=Vector2D(1, 1)):
		''' Transform the given list of points, using the provided position,
			direction and scale, to object world space. '''
		# make a copy of original points (so we don't trash them)
		wld_pts = Util.copyPoints(points)

		# create a transformation matrix to perform the operations
		mat = Matrix33()

		# scale,
		mat.scale_update(scale.x, scale.y)

		# rotate
		mat.rotate_by_vectors_update(forward, side)

		# and translate
		mat.translate_update(pos.x, pos.y)

		# now transform all the points (vertices)
		mat.transform_vector2d_list(wld_pts)

		# done
		return wld_pts


	def transform_point(self, point, pos, forward, side):
		''' Transform the given single point, using the provided position,
		and direction (forward and side unit vectors), to object world space. '''
		# make a copy of the original point (so we don't trash it)
		wld_pt = point.copy()

		# create a transformation matrix to perform the operations
		mat = Matrix33()

		# rotate
		mat.rotate_by_vectors_update(forward, side)

		# and translate
		mat.translate_update(pos.x, pos.y)

		# now transform the point (in place)
		mat.transform_vector2d(wld_pt)

		# done
		return wld_pt









	''' 
	
	Debug variables
	=================================='''

	def makeDebug(self):

		self.paused = False
		self.drawDebug = False,
		self.drawComponentForces = False
		self.drawHidingSpots = False
		self.awokenHunter = True
		
Exemplo n.º 54
0
def create_basic_enemy(position):
    return Tank(position, [
        controllers.BounceMoveController(),
        controllers.BasicTargetingController(),
        controllers.EnemyDieController()
    ])
Exemplo n.º 55
0
from tank import Tank
brewer = None
tank = None

print('Listening to Slack...')
try:
	while True:
		for notification in Chat.getNotifications():
			Chat.processNotification(notification)
		while True:
			action = Chat.getNextAction()
			if action is None:
				break
			if brewer and brewer.isAlive():
				Chat.talk('Oh I\'m kind of busy now! Please wait a bit and I\'ll take your order @{0}.'
					.format(action['user']['name']),
					channel=action['notification']['channel'])
				continue
			# Spam a brewing process.
			brewer = Brewer(action['isShort'], action['notification']['channel'],
				action['user'])
			brewer.start()
		if not tank or not tank.isAlive() and not Chat.isDisabled():
			# Spam a tank check process.
			tank = Tank()
			tank.start()
		time.sleep(0.5)
finally:
	Senseo.disablePump()
	Senseo.close()
Exemplo n.º 56
0
                time.sleep(0.1)  # 软件延时
    except KeyboardInterrupt:
        pass
    ser.close()
    return result_str


fruit_list = ['fruit', 'apple', 'banana', 'orange']
meat_list = ['meat', 'beef', 'pork', 'fish']
drinking_list = ['drinking', 'milk', 'yogurt', 'coke']

food_database = [fruit_list, meat_list, drinking_list]

for list in food_database:
    if detection_result in list:
        detection_attribute = list[0]
        new_food = Food(detection_result, detection_attribute)
        break

fridge = []
for i in range(6):
    tank = Tank()
    fridge.append(tank)

new_food_2 = Food('orange', 'fruit')
fridge[0].add_food(new_food)
fridge[0].add_food(new_food_2)

for tank in fridge:
    tank.print_content()