PyGame/funcionesVACIAS.py at main · ipicca/PyGame · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
from principal import *
import configuracion
from funcionesSeparador import *

import pygame
import random
import math


def lectura(archivo):
    a = archivo.read()
    lista = a.split("\n")
## Elimina el ultimo elemento de la lista, porque hay un espacio vacio.
    lista.pop(len(lista)-1)
    return lista


def actualizar(silabasEnPantalla,posiciones,listaDeSilabas):
## Extremos para generar una ubicacion al azar entre estos.
    extremoIzquierdo = (configuracion.ANCHO - 750)
    extremoDerecho = (configuracion.ANCHO - 50)
    nuevaSilabaPosicion = random.randint(extremoIzquierdo, extremoDerecho)
## Paso siguiente nos separa la silaba a crear de la ultima añadida.
    lastSilabaXIndex = len(posiciones) - 1
    if lastSilabaXIndex > 0:
        while (posiciones[lastSilabaXIndex][0] - 35) <= nuevaSilabaPosicion <= (posiciones[lastSilabaXIndex][0] + 35):
            nuevaSilabaPosicion = random.randint(extremoIzquierdo, extremoDerecho)
    silabasEnPantalla.append(nuevaSilaba(listaDeSilabas))
    posiciones.append([nuevaSilabaPosicion, configuracion.ORIGIN])
## Movimiento descendente
    amountOfSilabas = len(silabasEnPantalla)
    i = 0
    while (i < amountOfSilabas):
        posiciones[i][1] += configuracion.VSPEED
        if (posiciones[i][1] >= (configuracion.BOTTOMCLEAR)):
            posiciones.pop(i)
            silabasEnPantalla.pop(i)
            amountOfSilabas = len(silabasEnPantalla)
            ##
        else:
            i += 1


## Del archivo de silabas toma una al azar y la retorna como string
def nuevaSilaba(listaDeSilabas):
    newSilaba = listaDeSilabas[random.randint(0,len(listaDeSilabas)-1)]
    return newSilaba


def quitar(candidata, silabasEnPantalla, posiciones):
# Lista de silabas a eliminar
    toClean = dameSilabas(candidata)
    for elem in toClean:
        indexSilaba = (silabasEnPantalla.index(elem))
        silabasEnPantalla.pop(indexSilaba)
        posiciones.pop(indexSilaba)


def dameSilabas(candidata):
    n = 0
    toDeleteSilabas = []
    addToDeleteList = ""
    splitedWord = separador(candidata)
    for char in splitedWord:
        if (char == "-"):
            toDeleteSilabas.append(addToDeleteList)
            addToDeleteList = ""
        elif (n == len(splitedWord)-1):
            addToDeleteList += char
            toDeleteSilabas.append(addToDeleteList)
        else:
             addToDeleteList += char
        n = n + 1
    return toDeleteSilabas


## Recibe palabra ingresada, silabas en pantalla y lemario. Si no esta en lemario return False, si no esta alguna silaba en pantalla, False. De lo contrario True.
def esValida(candidata, silabasEnPantalla, lemario):
    candidataSeparada = dameSilabas(candidata)
    if candidata in lemario:
        for elem in candidataSeparada:
            if elem not in silabasEnPantalla:
                return False
        return True
    return False


def Puntos(candidata):
## Return puntaje en numero int.
    puntaje = 0
    vowels = ['a', 'e', 'i', 'o', 'u']
    hardConsonant = ['j', 'k', 'q', 'w', 'x', 'y', 'z']
    for char in candidata:
        if char in vowels:
            puntaje += 1
        elif char in hardConsonant:
            puntaje += 5
        else:
            puntaje += 2
    return puntaje


def procesar(candidata, silabasEnPantalla, posiciones, lemario, okSound, wrongSound):
## Le añadimos un contador para saber la cantidad de palabras acertadas. (cantPalarbas)
## Ademas cuando se apreta enter al validar la palabra ejecuta un sonido, diferido para ok y para erroneo.
    score = 0
    if esValida(candidata, silabasEnPantalla, lemario):
        score = Puntos(candidata)
        quitar(candidata, silabasEnPantalla, posiciones)
        candidata = ""
        okSound.play()
        return score
    else:
        wrongSound.play()
        return score


## Añadimos la siguiente funcion siguiente para poder darle un final al juego, previamente quedaba colgado al llegar
## a segundos cero, ahora da un resumen de la partida.
def dibujarGameOver(screen, puntos, cantPalabras):
# Paso siguiente para que no quede desprolijo si acertaba 1 palabra, el texto quedaba en plural.
    if cantPalabras == 1:
        palabra = " palabra!"
    else:
        palabra = " palabras!"
    defaultFont= pygame.font.Font( pygame.font.get_default_font(), configuracion.TAMANNO_LETRA)


    renGracias = defaultFont.render("Gracias por jugar 'SILABAS'", 1, configuracion.COLOR_LETRAS_FINAL)
    renCantPalabras = defaultFont.render("Usted acerto: " + str(cantPalabras) + palabra, 1, configuracion.COLOR_TEXTO_FINAL)
    renPuntaje = defaultFont.render("Su puntaje final es: " + str(puntos), 1, configuracion.COLOR_TEXTO_FINAL)


    screen.blit(renGracias, (configuracion.ANCHO - 525,configuracion.ALTO - 150))
    screen.blit(renCantPalabras, (configuracion.ANCHO - 515,configuracion.ALTO - 100))
    screen.blit(renPuntaje, (configuracion.ANCHO - 499, configuracion.ALTO - 50))