def __init__(self, xi, yi, xf, yf, level_name, puzzle_number, final):
        self.puzzle_number = puzzle_number
        self.level_name = level_name        
        self.DIRECTORIO = "images/gameplay/"
        self.there_is_arm = False
        self.goal = None
        self.final = final

        self.num_stacks = Application.getNumberStacksLevel(level_name, puzzle_number)
        stack_desp = (8 - self.num_stacks)/2
        self.scale_x = (xf - xi)/1200.0
        self.scale_y = (yf - yi)/700.0
        self.stack_desp = stack_desp 
        self.stacks = []
        
        for i in range(self.num_stacks):
            self.stacks.append(Drawable_Stack(i, level_name, puzzle_number,self.scale_x, [xi, yi, xf, yf], final, stack_desp))

        #imagenes
        self.filter = Application.createSfSprite(self.DIRECTORIO+"scenario_filter.png", xi, yi, xf - xi, yf - yi)
        self.bg = Application.createSfSprite(self.DIRECTORIO+"scenario_bg2.png", xi, yi, xf - xi, yf - yi)

        #self.bg_bot = Application.createSfSprite(self.DIRECTORIO+"scenario_bg_bottom.png", xi, 650, xf - xi, yf - 650)

        #self.poleL = Application.createSfSprite(self.DIRECTORIO+"pole.png", xi, yi, 30, yf - yi)

        #self.poleR = Application.createSfSprite(self.DIRECTORIO+"pole.png", xf - 30, yi, 30, yf - yi)
        if not final:
            self.BuildArm([xi, yi, xf, yf])
    def __init__(self, initial_position, scale, num_stacks, scenario_boundaries, stack_desp):
        self.DIRECTORIO = "images/gameplay/arm/"
        self.estado = "IDLE"
        self.stack_desp = stack_desp
        self.scenario_boundaries = scenario_boundaries
        self.scale = scale
        self.moving = False
        self.direction = None
        self.scenario = None
        self.function_set = None
        self.velocity = 255
        self.function_id = 0
        self.instruction_id = 0
        self.ticksResuelto = 0
        self.termino_instruction = True
        self.currentPos = initial_position
        self.initial_pos = initial_position
        self.catching = False
        self.catching2 = False
        self.movingUp = False
        self.movingDown = False
        self.resuelto = False
        self.ERROR = False
        self.returnPoints = []

        self.attachedBox = None

        rscale_x = 145/283.0*self.scale
        rscale_y = 125/313.0*self.scale
        x0 = (160 + 110*(initial_position + self.stack_desp - 1) - 15)*self.scale + self.scenario_boundaries[0]
        y0 = self.scenario_boundaries[1] + 1

        self.cable = Application.createSfSprite(self.DIRECTORIO+"cable.png",
                                                x0 + (145*self.scale - rscale_x*44)/2.0, y0 - 4,
                                                44*rscale_x, 65*rscale_y + 4)

        self.base_cable_size = (44*rscale_x, 65*rscale_y + 4)
        self.cable_height = self.base_cable_size[1]

        self.holder = Application.createSfSprite(self.DIRECTORIO+"holder.png",
                                                 x0 + 26*rscale_x, y0 + 65*rscale_y,
                                                 230*rscale_x, 72*rscale_y)
        
        self.base_holder_size = (230*rscale_x, 72*rscale_y) 

        self.left_pin = Application.createSfSprite(self.DIRECTORIO+"left_pin.png",
                                                   x0, y0 + 65*rscale_y + 72*rscale_y,
                                                   53*rscale_x, 176*rscale_y)
        
        self.base_left_pin_pos = (x0, y0 + 65*rscale_y + 72*rscale_y)
        self.base_left_pin_size = (53*rscale_x, 176*rscale_y)

        self.ddx = 26*rscale_x

        self.right_pin = Application.createSfSprite(self.DIRECTORIO+"right_pin.png",
                                                    x0 + 145*self.scale - 53*rscale_x, y0 + 65*rscale_y + 72*rscale_y,
                                                    53*rscale_x, 176*rscale_y)
        
        self.base_right_pin_pos = (x0 + 145*self.scale - 53*rscale_x, y0 + 65*rscale_y + 72*rscale_y)
        self.base_right_pin_size = (53*rscale_x, 176*rscale_y)
    def DefinirTops(self):
        self.tops = []
        self.tops2 = []
        positions = [(292,190), (666,190), (1037,190), (292,438), (666,438), (1037,438)]

        for i in range(6):
            self.tops.append(Application.createSfSprite(self.DIRECTORIO+"buttons/top.png", positions[i][0], positions[i][1], 110, 64))
            self.tops2.append(Application.createSfSprite(self.DIRECTORIO+"buttons/top_2.png", positions[i][0], positions[i][1], 110, 64))
    def DefinirSprites(self):
        self.bgwidth = 65
        self.bgheight = 700 - 167
        posX_btns = 11
        self.btnwidth = 44
        width_btns = self.btnwidth
        height_btns = self.btnwidth

        self.bg = Application.createSfSprite(self.DIRECTORIO+"bg_toolbox.png", 0, 167, self.bgwidth, self.bgheight)        

        self.botonDown = Application.createSfSprite(self.DIRECTORIO+"img_INS_DOWN.png", posX_btns, 184, width_btns, height_btns)

        self.botonRight = Application.createSfSprite(self.DIRECTORIO+"img_INS_RIGHT.png", posX_btns, 249, width_btns, height_btns)

        self.botonLeft = Application.createSfSprite(self.DIRECTORIO+"img_INS_LEFT.png", posX_btns, 313, width_btns, height_btns)

        self.botonProg1 = Application.createSfSprite(self.DIRECTORIO+"img_PROG_1.png", posX_btns, 376, width_btns, height_btns)

        self.botonProg2 = Application.createSfSprite(self.DIRECTORIO+"img_PROG_2.png", posX_btns, 442, width_btns, height_btns)

        self.botonProg3 = Application.createSfSprite(self.DIRECTORIO+"img_PROG_3.png", posX_btns, 506, width_btns, height_btns)

        self.botonProg4 = Application.createSfSprite(self.DIRECTORIO+"img_PROG_4.png", posX_btns, 569, width_btns, height_btns)

        self.botonClear = Application.createSfSprite(self.DIRECTORIO+"img_INS_CLEAR_2.png", posX_btns, 634, width_btns, height_btns)
 def __init__(self, xi, yi, xf, yf, default_value):
     self.current = default_value
     self.clicked = False
     self.DIRECTORIO = "images/gameplay/slider/"
     r_width = 768
     r_height = 133
     scale_x = 356.0/768.0
     scale_y = 45.0/143.0
      
     self.piece = Application.createSfSprite(self.DIRECTORIO+"piece.png", xi, yi - 10, (xf - xi)*(2.03/13.0), yf - yi + 9)
     self.fixed = Application.createSfSprite(self.DIRECTORIO+"fixed.png", xi, yi + (1.02/2.27)*(yf - yi), xf - xi, (yf - yi)*(1.25/2.27))
    def DefinirFondo(self):
        self.Fondo = Application.createSfSprite(self.DIRECTORIO+"bgs/TBG.png", 0, 0, 1200, 700)
        
        font = sf.Font()
        font = sf.Font.GetDefaultFont()
        #font.LoadFromFile('my_downloaded_font.ttf', 50)
        self.tittle = sf.String("LEVEL: " + self.backScreen + ", PUZZLE " + str(self.puzzle_number) + "(" + Application.username + ")", font)
        color = sf.Color(0, 0, 0)
        rect = self.tittle.GetRect()
        self.tittle.SetColor(color)
        self.tittle.SetCenter(0,0)        
        self.tittle.SetSize(35)
        self.tittle.SetPosition((1200 - rect.GetWidth())/2, 15)

        self.delimiter = Application.createSfSprite(self.DIRECTORIO+"gameplay/delimiter.png", 0, rect.GetHeight() + 47, 1200, 10)
    def DefinirBotones(self):
        #boton create
        self.boton1 = Application.createSfSprite(self.DIRECTORIO+"buttons/button_create_1.png", 434, 504, 367, 140)
        self.boton2 = Application.createSfSprite(self.DIRECTORIO+"buttons/button_create_2.png", 434, 504, 367, 140)

        #boton home
        self.botonHome1 = Application.createSfSprite(self.DIRECTORIO+"buttons/button_home_1.png", 1200-157, 0, 157, 80)
        self.botonHome2 = Application.createSfSprite(self.DIRECTORIO+"buttons/button_home_2.png", 1200-157, 0, 157, 80)

        image = sf.Image()
        image.LoadFromFile(self.DIRECTORIO+"buttons/CREATE.png")
        self.create = sf.Sprite(image)
        self.create.Resize(1013-829,661-500)
        self.create.SetCenter(0, 0)
        self.create.SetPosition(688,348)
    def __init__(self, prevScreen, puzzle_number):
        self.puzzle_number = puzzle_number
        self.width = 1200
        self.heigth = 700
        self.blanco = sf.Color(250, 250, 250)
        self.negro = sf.Color(0, 0, 0)
        name = Application.username
        self.window = sf.RenderWindow(
            sf.VideoMode(self.width, self.heigth), "DRAG BOX - LETS PLAY " + name, sf.Style.Close
        )
        self.window.SetIcon(16, 16, Icon.window_icon())
        self.Evento = sf.Event()
        self.window.SetFramerateLimit(60)
        self.backScreen = prevScreen
        self.sonidos = None
        self.temp = None
        self.dragging_instruction = False
        self.playing = False
        self.playingStepByStep = False
        self.instruction_name = None
        self.function_set = Drawable_FunctionSet()
        self.slider = Drawable_Slider(249, 98, 505, 143, 50)

        self.toolbox = Drawable_Toolbox()
        self.goal = Drawable_Scenario(77, 461, 511, 700, prevScreen, str(puzzle_number), True)
        self.working_area = Drawable_Scenario(529, 87, 1200, 700, prevScreen, str(puzzle_number), False)
        self.working_area.goal = self.goal
        self.bg_over = Application.createSfSprite(self.DIRECTORIO + "bgs/gameplay/scenario_bg2.png", 0, 0, 2000, 1000)
        self.message = None
        Application.setActiveWindow(self)
 def __init__(self, tipo, mensaje):
     self.errorCount = 4
     self.DIRECTORIO = "images/errors/"
     self.fade = Application.createSfSprite(self.DIRECTORIO + "fade.png", 0, 0, 0, 0)
     if tipo in ["ERROR_1", "ERROR_2"]:
         self.DefinirMensaje(tipo, 0, 0, 350, 200)
     else:
         self.DefinirMensaje(tipo)
     self.DefinirSprites()
    def DefinirBotones(self):
        self.boton1 = Application.createSfSprite(self.DIRECTORIO+"buttons/button_choose_1.png", 434, 564, 367, 120)
        self.boton2 = Application.createSfSprite(self.DIRECTORIO+"buttons/button_choose_2.png", 434, 564, 367, 120)
        
        self.botonHome1 = Application.createSfSprite(self.DIRECTORIO+"buttons/button_home_1.png", 1200-157, 0, 157, 80)
        self.botonHome2 = Application.createSfSprite(self.DIRECTORIO+"buttons/button_home_2.png", 1200-157, 0, 157, 80)
        
        self.botonPrev1 = Application.createSfSprite(self.DIRECTORIO+"buttons/scroll_prev_1.png", 0, 0, 130, 700)
        self.botonPrev2 = Application.createSfSprite(self.DIRECTORIO+"buttons/scroll_prev_2.png", 0, 0, 130, 700)

        self.botonNext1 = Application.createSfSprite(self.DIRECTORIO+"buttons/scroll_next_1.png", 1070, 0, 130, 700)
        self.botonNext2 = Application.createSfSprite(self.DIRECTORIO+"buttons/scroll_next_2.png", 1070, 0, 130, 700)
    def DefinirFondo(self):
        self.Fondo0 = Application.createSfSprite(self.DIRECTORIO+"bgs/TBG3.png", 0, 0, 1200, 700)
        self.Fondo = Application.createSfSprite(self.DIRECTORIO+"bgs/GBG.png", 0, 0, 1200, 700)

        self.credits = Application.createSfSprite(self.DIRECTORIO+"scores/credits.png", 0, 700 - 43, 113, 43)
        self.mmenu = Application.createSfSprite(self.DIRECTORIO+"scores/main_menu.png", 1200 - 197, 700 - 43, 197, 43)

        self.credits_2 = Application.createSfSprite(self.DIRECTORIO+"scores/credits_2.png", 0, 700 - 43, 113, 43)
        self.mmenu_2 = Application.createSfSprite(self.DIRECTORIO+"scores/main_menu_2.png", 1200 - 197, 700 - 43, 197, 43)
    def __init__(self, stack_id, level_name, puzzle_number, scale, scenario_boundaries, final, stack_desp):
        self.DIRECTORIO = "images/gameplay/"
        self.stack_id = stack_id
        self.level_name = level_name
        self.puzzle_number = puzzle_number
        self.scenario_boundaries = scenario_boundaries
        self.final = final
        self.stack_desp = stack_desp
        self.stack = []

        self.base = Application.createSfSprite(self.DIRECTORIO+"base.png",
                                               (160 + 110*(stack_id+stack_desp) + 15)*scale + scenario_boundaries[0],650,
                                               90*scale, 30*scale)
        
        self.setInitialState(stack_id, level_name, puzzle_number, scale, scenario_boundaries, final, stack_desp)
    def DefinirBotones(self):
        self.botonHome1 = Application.createSfSprite(self.DIRECTORIO+"buttons/button_home_1.png", 1200-157, 0, 157, 80)
        self.botonHome2 = Application.createSfSprite(self.DIRECTORIO+"buttons/button_home_2.png", 1200-157, 0, 157, 80)

        self.botonBack1 = Application.createSfSprite(self.DIRECTORIO+"buttons/button_back_1.png", 0, 0, 80, 80)
        
        self.botonBack2 = Application.createSfSprite(self.DIRECTORIO+"buttons/button_back_2.png", 0, 0, 80, 80)

        self.botonPlayStop = Application.createSfSprite(self.DIRECTORIO+"gameplay/play_1.png", 10, 91, 100, 70)

        self.botonStep = Application.createSfSprite(self.DIRECTORIO+"gameplay/stepbystep.png", 125, 100, 70, 50)
Exemple #14
0
 def FillInTops(self, data, posiciones, size):
     self.tops = []
     self.stars = []
     for i in range(len(data)):
         if data[i][0] == "__EMPTY__":
             t = sf.String("----------")                
         else:
             t = sf.String(data[i][0])
             print "valor: " + str(data[i][1])
             self.stars.append(Application.createSfSprite("images/buttons/stars/" + str(data[i][1]) + ".png",
                                                          self.star_posiciones[i][0], self.star_posiciones[i][1],
                                                          self.starSize[0], self.starSize[1]))
                               
         color = sf.Color(0, 0, 0)
         rect = t.GetRect()
         t.SetColor(color)
         t.SetCenter(0,0)        
         t.SetSize(25)
         t.SetPosition(posiciones[i][0] + (size[0] - rect.GetWidth())/2 + 5, posiciones[i][1] + (size[1] - rect.GetHeight())/2)
         self.tops.append(t)
    def __init__(self, score, made_it, personal_mark):
        self.width = 1200
        self.heigth = 700
        self.window = sf.RenderWindow(sf.VideoMode(self.width, self.heigth), "DRAG BOX - CONGRATULATIONS!", sf.Style.Close)
        self.Evento = sf.Event()
        self.sonidos = None

        if not (personal_mark in ["BETTER", "NOT_BETTER", "FIRST_TIME", "EQUAL"] or made_it):
            self.img_score = Application.createSfSprite(self.DIRECTORIO+"scores/"+str(score)+".png", 181, 350, 1022-181, 336 - 251)
        else:
            self.img_score = Application.createSfSprite(self.DIRECTORIO+"scores/"+str(score)+".png", 181, 251, 1022-181, 336 - 251)
        
        if made_it:        
            self.img_gratz = Application.createSfSprite(self.DIRECTORIO+"scores/gratz.png", 181, 330, 1022 - 181, 250)
        elif personal_mark == "BETTER":
            self.img_gratz = Application.createSfSprite(self.DIRECTORIO+"scores/better.png", 181, 330, 1022 - 181, 250)
        elif personal_mark == "NOT_BETTER":
            self.img_gratz = Application.createSfSprite(self.DIRECTORIO+"scores/worse.png", 181, 330, 1022 - 181, 250)
        elif personal_mark == "FIRST_TIME":
            self.img_gratz = Application.createSfSprite(self.DIRECTORIO+"scores/first.png", 181, 330, 1022 - 181, 250)
        elif personal_mark == "EQUAL":
            self.img_gratz = Application.createSfSprite(self.DIRECTORIO+"scores/equal.png", 181, 330, 1022 - 181, 250)
 def DefinirFondo(self):
     self.Fondo = Application.createSfSprite(self.DIRECTORIO+"bgs/CB2.png", 0, 0, 1200, 700)
     self.text = Application.createSfSprite(self.DIRECTORIO+"bgs/text_create.png", 0, 0, 1200, 700)
 def DefinirBox(self, stack_id, box, scale, tot):
     rand_desp = random.randrange(int(-5*scale), int(5*scale))
     self.box = Application.createSfSprite(self.DIRECTORIO+"box_"+self.color+".png",
                                           self.stack_boundaries[0] + 5*scale + rand_desp,
                                           self.stack_boundaries[1] - math.ceil(80*scale*(tot - self.id + 1)),
                                           80*scale, 80*scale)
 def DefinirFondo(self):
     self.Fondo = Application.createSfSprite(self.DIRECTORIO+"bgs/change_profile2.png", 0, 0, 1200, 700)
 def DefinirMensaje(self, tipo, x = 0, y = 0, w = 0, h = 0):
     tipo = "ERROR_" + str(random.randint(0,self.errorCount - 1))
     self.mensaje  = Application.createSfSprite(self.DIRECTORIO + tipo + ".png", x, y, w, h)
 def DefinirEstrellas(self):
     self.stars = []
     positions = [(46, 294), (421, 294), (795, 294), (46, 551), (421, 551), (795, 551)]
     for i in range(6):
         self.stars.append(Application.createSfSprite(self.DIRECTORIO+"buttons/stars/"+str(i+1)+".png", positions[i][0], positions[i][1], 64, 64))
 def DefinirSprites(self):
     x = self.mensaje.GetPosition()[0] - 5
     y = self.mensaje.GetPosition()[1] - 5
     w = self.mensaje.GetSize()[0] + 10
     h = self.mensaje.GetSize()[1] + 10
     self.bg = Application.createSfSprite(self.DIRECTORIO+"bg.png", x, y, w, h)        
    def DefinirBotones(self):
        self.botonHome1 = Application.createSfSprite(self.DIRECTORIO+"buttons/button_home_1.png", 1200-157, 0, 157, 80)
        self.botonHome2 = Application.createSfSprite(self.DIRECTORIO+"buttons/button_home_2.png", 1200-157, 0, 157, 80)
        
        self.botonBack1 = Application.createSfSprite(self.DIRECTORIO+"buttons/button_back_1.png", 0, 0, 80, 80)
        self.botonBack2 = Application.createSfSprite(self.DIRECTORIO+"buttons/button_back_2.png", 0, 0, 80, 80)


        #botones numero hover
        self.num1_2 = Application.createSfSprite(self.DIRECTORIO+"buttons/button_1_2.png", 77, 199, 360 - 77, 338 - 199)
        self.num2_2 = Application.createSfSprite(self.DIRECTORIO+"buttons/button_2_2.png", 451, 199, 360 - 77, 338 - 199)
        self.num3_2 = Application.createSfSprite(self.DIRECTORIO+"buttons/button_3_2.png", 822, 199, 360 - 77, 338 - 199)
        self.num4_2 = Application.createSfSprite(self.DIRECTORIO+"buttons/button_4_2.png", 77, 446, 360 - 77, 338 - 199)
        self.num5_2 = Application.createSfSprite(self.DIRECTORIO+"buttons/button_5_2.png", 451, 446, 360 - 77, 338 - 199)
        self.num6_2 = Application.createSfSprite(self.DIRECTORIO+"buttons/button_6_2.png", 822, 446, 360 - 77, 338 - 199)
        
        #botones numero
        self.num1 = Application.createSfSprite(self.DIRECTORIO+"buttons/button_1.png", 77, 199, 360 - 77, 338 - 199)
        self.num2 = Application.createSfSprite(self.DIRECTORIO+"buttons/button_2.png", 451, 199, 360 - 77, 338 - 199)
        self.num3 = Application.createSfSprite(self.DIRECTORIO+"buttons/button_3.png", 822, 199, 360 - 77, 338 - 199)
        self.num4 = Application.createSfSprite(self.DIRECTORIO+"buttons/button_4.png", 77, 446, 360 - 77, 338 - 199)
        self.num5 = Application.createSfSprite(self.DIRECTORIO+"buttons/button_5.png", 451, 446, 360 - 77, 338 - 199)
        self.num6 = Application.createSfSprite(self.DIRECTORIO+"buttons/button_6.png", 822, 446, 360 - 77, 338 - 199)
 def DefinirFondo(self):
     self.Fondo = Application.createSfSprite(self.DIRECTORIO+"bgs/tutorial5.png", 0, 0, 1200, 700)
 def DefinirSprites(self, x, y):
     self.height = 44
     self.empty = Application.createSfSprite(self.DIRECTORIO+"empty_instruction_set_"+str(self.function_id)+".png", x, y, 433, 46)
Exemple #25
0
 def DefinirBotones(self):
     self.botonHome1 = Application.createSfSprite(self.DIRECTORIO+"buttons/button_home_1.png", 1200-157, 0, 157, 80)
     self.botonHome2 = Application.createSfSprite(self.DIRECTORIO+"buttons/button_home_2.png", 1200-157, 0, 157, 80)
     
     self.botonBack1 = Application.createSfSprite(self.DIRECTORIO+"buttons/button_back_1.png", 0, 0, 80, 80)
     self.botonBack2 = Application.createSfSprite(self.DIRECTORIO+"buttons/button_back_2.png", 0, 0, 80, 80)
Exemple #26
0
 def DefinirFondo(self):
     self.Fondo = Application.createSfSprite(self.DIRECTORIO + "bgs/Top_BG.png", 0, 0, 1200, 700)
     self.Fondo0 = Application.createSfSprite(self.DIRECTORIO + "bgs/TBG3.png", 0, 0, 1200, 700)