class Interfaz(object): #Interfaz de usuario #Constructor #Necesita obtener como parametro todos los objetos que tengan valores que se representaran def __init__(self, gato): self.gato = gato self.barra = Barra(cargarImagen("manzana"), 100, 20, 20) #Dibuja la interfaz en la pantalla #pantalla: Superficie donde se dibujara def dibujar(self, pantalla): self.barra.dibujar(pantalla) #Actualiza la interfaz #delta: Tiempo de juego, necesario para realizar algunas acciones def actualizar(self, delta): self.barra.actualizar(self.gato.hambre)
def __init__(self, modo, nivel, versus, tamaño=None, time=TIEMPO_NIVEL1): pygame.init() self.pantalla = pygame.display.set_mode((ANCHO, LARGO)) pygame.display.set_caption("Pong") self.FILAS = 30 self.COLUMNAS = 40 self.matriz = [] self.crearMatriz() self.score = 0 self.bola = Bola(20, 12, random.randrange(-1, 2), True) self.nivel = nivel self.modo = modo self.versus = versus self.CPU = 0 self.tamaño = tamaño self.time = time # Se define el tiempo, tamaño de barra, modo y versus de cada nivel if self.nivel == 1: if self.time == None: self.tiempo = TIEMPO_NIVEL1 else: self.tiempo = time if self.modo == "Single": if self.tamaño == None: self.barra1 = Barra(1, 2, TAMAÑO_BARRA_1) self.barra2 = Barra(38, 2, TAMAÑO_BARRA_1) else: # Si se le define un tamaño es porque está en modo práctica self.barra1 = Barra(1, 2, self.tamaño) self.barra2 = Barra(38, 0, TAMAÑO_BARRA_PRACTICA) if self.versus == "humano": self.CPU = 0 elif self.versus == "cpu": self.CPU = 1 else: # La primer barra es la de la izquiera, la otra la de la derecha if self.tamaño == None: self.barra1 = Barra_doble(1, 3, 9, 13, TAMAÑO_BARRA_1) self.barra2 = Barra_doble(38, 12, 32, 3, TAMAÑO_BARRA_1) else: self.barra1 = Barra_doble(1, 3, 9, 13, self.tamaño) self.barra2 = Barra(38, 0, TAMAÑO_BARRA_PRACTICA) if self.versus == "humano": # Si se escoje "humano" no se llama la función cpu() self.CPU = 0 elif self.versus == "cpu": self.CPU = 1
def inicializar_jogo(self): self.ambiente = pygame self.ambiente.init() self.sprites = Sprites(pygame) self.inputs = Inputs(self.ambiente) self.clock_soldados_atiradores = self.ambiente.time.get_ticks() self.clock_soldados_espada = self.ambiente.time.get_ticks() self.clock_corvo = self.ambiente.time.get_ticks() self.paused = False self.cont_background = 0 self.width = 1280 self.height = 768 self.device_screen = self.ambiente.display.Info() print(self.device_screen.current_w) self.screen = self.ambiente.display.set_mode([self.width, self.height], self.ambiente.FULLSCREEN | self.ambiente.DOUBLEBUF) self.background_imgs = [self.ambiente.image.load('imagens/mapa/mapa_1.png').convert(), self.ambiente.image.load('imagens/mapa/mapa_2.png').convert(),\ self.ambiente.image.load('imagens/mapa/mapa_3.png').convert(), self.ambiente.image.load('imagens/mapa/mapa_4.png').convert()] self.background_image = self.background_imgs[0] self.torre = self.ambiente.image.load( 'imagens/torre.png').convert_alpha() self.indio = Indio(self.ambiente, 3, 1000, 0, 510) self.cd = Cooldown(self.ambiente, 20, 490) self.barra = Barra(self.ambiente, 10, 650) self.lanca = Lanca(self.ambiente, 1, 0, 0, 20, 510, 0, 90) self.barreira1 = Barreira(self.ambiente, 2, 400, 300, 'top') self.barreira2 = Barreira(self.ambiente, 3, 400, 500, 'bot') self.sprites.barreiras.add(self.barreira1, self.barreira2) self.sprites.indio.add(self.indio) self.sprites.todos_objetos.add(self.sprites.indio, self.barra, self.sprites.barreiras) self.clock_mapa = self.ambiente.time.get_ticks() self.time = self.ambiente.time.get_ticks() self.seta_menu = Seta(self.ambiente, 350, 200) self.menu_background = self.ambiente.image.load( 'imagens/menu_background.png') self.ambiente.font.init() self.fonte = self.ambiente.font.SysFont('Comic Sans MS', 30) self.screen.blit(self.background_image, [0, 0])
def caso_D(): # Unidades base m = 1. kg = 1. s = 1. #Unidades derivadas N = kg * m / s**2 cm = 0.01 * m mm = 0.001 * m KN = 1000 * N Pa = N / m**2 KPa = 1000 * Pa MPa = 1000 * KPa GPa = 1000 * MPa #Parametros L = 5.0 * m B = 2.0 * m H = 3 * m #Inicializar modelo ret = Reticulado() #------------------------------------------------------------------------------------------------------------------------ # NODOS #------------------------------------------------------------------------------------------------------------------------ # -------- NODOS PLANTA INFERIOR Nodos_corrida_1_tablero = 45 for i in range(Nodos_corrida_1_tablero + 1): ret.agregar_nodo(L * (1 + i), 0, 100 * m) Nodos_corrida_2_tablero = 91 - 46 for i in range(Nodos_corrida_2_tablero + 1): ret.agregar_nodo(L * (1 + i), B, 100 * m) # -------- NODOS PLANTA SUPERIOR Nodos_corrida_3_tablero = 135 - 92 for i in range(Nodos_corrida_3_tablero + 1): ret.agregar_nodo(L * (i + 2), 0, 100 * m + H) Nodos_corrida_4_tablero = 179 - 136 for i in range(Nodos_corrida_4_tablero + 1): ret.agregar_nodo(L * (i + 2), B, 100 * m + H) # -------- NODOS COLUMNA 1 (BASE EN NODO GLOBAL 10) # CARA 1 ret.agregar_nodo(22 * m, 0, 83 * m) # 180 ret.agregar_nodo(22 * m, 0, 93 * m) # 181 ret.agregar_nodo(21 * m, 0, 96.5 * m) # 182 ret.agregar_nodo(23.5 * m, 0, 96.5 * m) # 183 # CARA 2 ret.agregar_nodo(22 * m, B, 83 * m) # 184 ret.agregar_nodo(22 * m, B, 93 * m) # 185 ret.agregar_nodo(21 * m, B, 96.5 * m) # 186 ret.agregar_nodo(23.5 * m, B, 96.5 * m) # 187 # # -------- NODOS COLUMNA 2 (BASE EN NODO GLOBAL 14) # CARA 1 ret.agregar_nodo(65 * m, 0, 47 * m) # 188 CENTRAL ret.agregar_nodo(65 * m, 0, 90 * m) # 189 CENTRAL ret.agregar_nodo((55 + 2.5) * m, 0, (90 + 7.5) * m) # 190 ret.agregar_nodo((55 + 5) * m, 0, (90 + 5) * m) # 191 ret.agregar_nodo((55 + 7.5) * m, 0, (90 + 2.5) * m) # 192 ret.agregar_nodo((65 + 2.5) * m, 0, (90 + 2.5) * m) # 193 ret.agregar_nodo((65 + 5) * m, 0, (90 + 5) * m) # 194 ret.agregar_nodo((65 + 7.5) * m, 0, (90 + 7.5) * m) # 195 #CARA 2 ret.agregar_nodo(65 * m, B, 47 * m) # 196 CENTRAL ret.agregar_nodo(65 * m, B, 90 * m) # 197 CENTRAL ret.agregar_nodo((55 + 2.5) * m, B, (90 + 7.5) * m) # 198 ret.agregar_nodo((55 + 5) * m, B, (90 + 5) * m) # 199 ret.agregar_nodo((55 + 7.5) * m, B, (90 + 2.5) * m) # 200 ret.agregar_nodo((65 + 2.5) * m, B, (90 + 2.5) * m) # 201 ret.agregar_nodo((65 + 5) * m, B, (90 + 5) * m) # 202 ret.agregar_nodo((65 + 7.5) * m, B, (90 + 7.5) * m) # 203 # # -------- NODOS COLUMNA 3 (BASE EN NODO GLOBAL 17) # CARA 1 ret.agregar_nodo(105 * m, 0, 65 * m) # 204 CENTRAL ret.agregar_nodo(105 * m, 0, 90 * m) # 205 CENTRAL ret.agregar_nodo((95 + 2.5) * m, 0, (90 + 7.5) * m) # 206 ret.agregar_nodo((95 + 5) * m, 0, (90 + 5) * m) # 207 ret.agregar_nodo((95 + 7.5) * m, 0, (90 + 2.5) * m) # 208 ret.agregar_nodo((105 + 2.5) * m, 0, (90 + 2.5) * m) # 209 ret.agregar_nodo((105 + 5) * m, 0, (90 + 5) * m) # 210 ret.agregar_nodo((105 + 7.5) * m, 0, (90 + 7.5) * m) # 211 #CARA 2 ret.agregar_nodo(105 * m, B, 65 * m) # 212 CENTRAL ret.agregar_nodo(105 * m, B, 90 * m) # 213 CENTRAL ret.agregar_nodo((95 + 2.5) * m, B, (90 + 7.5) * m) # 214 ret.agregar_nodo((95 + 5) * m, B, (90 + 5) * m) # 215 ret.agregar_nodo((95 + 7.5) * m, B, (90 + 2.5) * m) # 216 ret.agregar_nodo((105 + 2.5) * m, B, (90 + 2.5) * m) # 217 ret.agregar_nodo((105 + 5) * m, B, (90 + 5) * m) # 218 ret.agregar_nodo((105 + 7.5) * m, B, (90 + 7.5) * m) # 219 # # -------- NODOS COLUMNA 4 (BASE EN NODO GLOBAL 20) # CARA 1 ret.agregar_nodo(135 * m, 0, 66 * m) # 220 CENTRAL ret.agregar_nodo(135 * m, 0, 90 * m) # 221 CENTRAL ret.agregar_nodo((125 + 2.5) * m, 0, (90 + 7.5) * m) # 222 ret.agregar_nodo((125 + 5) * m, 0, (90 + 5) * m) # 223 ret.agregar_nodo((125 + 7.5) * m, 0, (90 + 2.5) * m) # 224 ret.agregar_nodo((135 + 2.5) * m, 0, (90 + 2.5) * m) # 225 ret.agregar_nodo((135 + 5) * m, 0, (90 + 5) * m) # 226 ret.agregar_nodo((135 + 7.5) * m, 0, (90 + 7.5) * m) # 227 # CARA 2 ret.agregar_nodo(135 * m, B, 66 * m) # 228 CENTRAL ret.agregar_nodo(135 * m, B, 90 * m) # 229 CENTRAL ret.agregar_nodo((125 + 2.5) * m, B, (90 + 7.5) * m) # 230 ret.agregar_nodo((125 + 5) * m, B, (90 + 5) * m) # 231 ret.agregar_nodo((125 + 7.5) * m, B, (90 + 2.5) * m) # 232 ret.agregar_nodo((135 + 2.5) * m, B, (90 + 2.5) * m) # 233 ret.agregar_nodo((135 + 5) * m, B, (90 + 5) * m) # 234 ret.agregar_nodo((135 + 7.5) * m, B, (90 + 7.5) * m) # 235 # # -------- NODOS COLUMNA 5 (BASE EN NODO GLOBAL 24) ret.agregar_nodo(172 * m, 0, 79 * m) # 236 CENTRAL ret.agregar_nodo(172 * m, 0, 90 * m) # 237 CENTRAL ret.agregar_nodo(171 * m, 0, 95 * m) # 238 ret.agregar_nodo(173.5 * m, 0, 95 * m) # 239 ret.agregar_nodo(172 * m, B, 79 * m) # 240 CENTRAL ret.agregar_nodo(172 * m, B, 90 * m) # 241 CENTRAL ret.agregar_nodo(171 * m, B, 95 * m) # 242 ret.agregar_nodo(173.5 * m, B, 95 * m) # 243 # # -------- NODOS COLUMNA 6 (BASE EN NODO GLOBAL 24) ret.agregar_nodo(198 * m, 0, 93 * m) # 244 ret.agregar_nodo(198 * m, B, 93 * m) # 245 #------------------------------------------------------------------------------------------------------------------------ # BARRAS #------------------------------------------------------------------------------------------------------------------------ # PROPIEDADES A = (1.1 * cm)**2 r = sqrt(A / 3.141593) props_C = [8 * cm, 1.76 * mm, 200 * GPa, 7600 * kg / m**3, 420 * MPa] props_C_BIG = [16 * cm, 3.5 * mm, 200 * GPa, 7600 * kg / m**3, 420 * MPa] props_C_BIG2 = [30 * cm, 3.57 * mm, 200 * GPa, 7600 * kg / m**3, 420 * MPa] props_C_BIG5 = [14 * cm, 1.5 * mm, 200 * GPa, 7600 * kg / m**3, 420 * MPa] props_C_BIG4 = [26 * cm, 1.4 * mm, 200 * GPa, 7600 * kg / m**3, 420 * MPa] props_elevacion_cruzadas = [ 8 * cm, 2 * mm, 200 * GPa, 7600 * kg / m**3, 420 * MPa ] props_elevacion_longitudinales = [ 5.5 * cm, 2 * mm, 200 * GPa, 7600 * kg / m**3, 420 * MPa ] props_elevacion_verticales = [ 5.3 * cm, 1 * mm, 200 * GPa, 7600 * kg / m**3, 420 * MPa ] props_tablero_inferior_cruzadas = [ 8 * cm, 3 * mm, 200 * GPa, 7600 * kg / m**3, 420 * MPa ] props_tablero_superiores_cruzadas = [ 6.9 * cm, 3 * mm, 200 * GPa, 7600 * kg / m**3, 420 * MPa ] props_tablero_inferior_horizontales = [ 8 * cm, 1 * mm, 200 * GPa, 7600 * kg / m**3, 420 * MPa ] props_tablero_superiores_horizontales = [ 5.5 * cm, 1 * mm, 200 * GPa, 7600 * kg / m**3, 420 * MPa ] # ALA 1 - BARRAS ELEVACION CRUZADAS # CARA 1 Nodos_tablero = 42 for i in range(Nodos_tablero + 1): if i % 2 == 0: ret.agregar_barra(Barra(i, i + 92, *props_elevacion_cruzadas)) for i in range(Nodos_tablero + 1): if i % 2 == 0: ret.agregar_barra(Barra(i + 2, i + 92, *props_elevacion_cruzadas)) ret.agregar_barra(Barra(45, 135, *props_elevacion_cruzadas)) # ALA 2 - BARRAS ELEVACION CRUZADAS # CARA 2 Nodos_tablero = 42 for i in range(Nodos_tablero + 1): if i % 2 == 0: ret.agregar_barra(Barra(i + 46, i + 136, *props_elevacion_cruzadas)) for i in range(Nodos_tablero + 1): if i % 2 == 0: ret.agregar_barra(Barra(i + 48, i + 136, *props_elevacion_cruzadas)) ret.agregar_barra(Barra(91, 179, *props_elevacion_cruzadas)) #BARRAS LONGITUDINALES INFERIORES for i in range(45): # print (i,i+1) ret.agregar_barra(Barra(i, i + 1, *props_elevacion_longitudinales)) for i in range(45): # print (i+46,i+1+46) ret.agregar_barra( Barra(i + 46, i + 1 + 46, *props_elevacion_longitudinales)) #BARRAS LONGITUDINALES SUPERIORES for i in range(43): # print (i+92,i+93) ret.agregar_barra( Barra(i + 92, i + 93, *props_elevacion_longitudinales)) for i in range(43): # print (i+136,i+137) ret.agregar_barra( Barra(i + 136, i + 137, *props_elevacion_longitudinales)) #BARRAS ELEVACION VERTICALES for i in range(44): # print (i+1,i+92) ret.agregar_barra(Barra(i + 1, i + 1 + 91, *props_elevacion_verticales)) for i in range(44): # print (i+46, i+1+135) ret.agregar_barra( Barra(i + 47, i + 1 + 135, *props_elevacion_verticales)) # Barras planta inferior nodos_planta_inferior = 45 for j in range(nodos_planta_inferior + 1): #Barras horizontales # print (j, j + 46) ret.agregar_barra( Barra(j, j + 46, *props_tablero_inferior_horizontales)) for j in range(nodos_planta_inferior): #Barras cruzadas # print (j, j + 47) ret.agregar_barra(Barra(j, j + 47, *props_tablero_inferior_cruzadas)) print(" ") for j in range(nodos_planta_inferior): #Barras cruzadas # print (j + 1 , j + 46 ) ret.agregar_barra( Barra(j + 1, j + 46, *props_tablero_inferior_cruzadas)) #Barras planta superior nodos_planta_superior = 135 - 91 for j in range(nodos_planta_superior): #Barras horizontales # print (j + 92 , j + 92 + 44) ret.agregar_barra( Barra(j + 92, j + 92 + 44, *props_tablero_superiores_horizontales)) for j in range(nodos_planta_superior - 1): #Barras cruzadas # print (j+ 93 , j + 136) ret.agregar_barra( Barra(j + 93, j + 136, *props_tablero_superiores_cruzadas)) for j in range(nodos_planta_superior - 1): #Barras cruzadas # print (j+ 92 , j + 137) ret.agregar_barra( Barra(j + 92, j + 137, *props_tablero_superiores_cruzadas)) # -------- BARRAS COLUMNA 1 (BASE EN NODO GLOBAL 10) ret.agregar_barra(Barra(180, 181, *props_C_BIG)) # CENTRAL ret.agregar_barra(Barra(181, 182, *props_C)) ret.agregar_barra(Barra(181, 183, *props_C)) ret.agregar_barra(Barra(182, 183, *props_C)) ret.agregar_barra(Barra(3, 182, *props_C)) ret.agregar_barra(Barra(4, 183, *props_C)) ret.agregar_barra(Barra(3, 183, *props_C)) ret.agregar_barra(Barra(4, 182, *props_C)) ret.agregar_barra(Barra(180 + 4, 181 + 4, *props_C_BIG)) # CENTRAL ret.agregar_barra(Barra(181 + 4, 182 + 4, *props_C)) ret.agregar_barra(Barra(181 + 4, 183 + 4, *props_C)) ret.agregar_barra(Barra(182 + 4, 183 + 4, *props_C)) ret.agregar_barra(Barra(3 + 46, 182 + 4, *props_C)) ret.agregar_barra(Barra(4 + 46, 183 + 4, *props_C)) ret.agregar_barra(Barra(3 + 46, 183 + 4, *props_C)) ret.agregar_barra(Barra(4 + 46, 182 + 4, *props_C)) # -------- BARRAS COLUMNA 2 (BASE EN NODO GLOBAL 14) ret.agregar_barra(Barra(188, 189, *props_C_BIG2)) # CENTRAL INFERIOR ret.agregar_barra(Barra(12, 189, *props_C_BIG2)) # CENTRAL SUPERIOR ret.agregar_barra(Barra(10, 190, *props_C)) ret.agregar_barra(Barra(190, 191, *props_C)) ret.agregar_barra(Barra(191, 192, *props_C)) ret.agregar_barra(Barra(189, 192, *props_C)) ret.agregar_barra(Barra(189, 193, *props_C)) ret.agregar_barra(Barra(193, 194, *props_C)) ret.agregar_barra(Barra(194, 195, *props_C)) ret.agregar_barra(Barra(14, 195, *props_C)) ret.agregar_barra(Barra(11, 191, *props_C)) ret.agregar_barra(Barra(13, 194, *props_C)) ret.agregar_barra(Barra(11, 190, *props_C)) ret.agregar_barra(Barra(13, 195, *props_C)) ret.agregar_barra(Barra(12, 192, *props_C)) ret.agregar_barra(Barra(12, 193, *props_C)) ret.agregar_barra(Barra(11, 192, *props_C)) ret.agregar_barra(Barra(13, 193, *props_C)) ret.agregar_barra(Barra(188 + 8, 189 + 8, *props_C_BIG2)) # CENTRAL INFERIOR ret.agregar_barra(Barra(12 + 46, 189 + 8, *props_C_BIG2)) # CENTRAL SUPERIOR ret.agregar_barra(Barra(10 + 46, 190 + 8, *props_C)) ret.agregar_barra(Barra(190 + 8, 191 + 8, *props_C)) ret.agregar_barra(Barra(191 + 8, 192 + 8, *props_C)) ret.agregar_barra(Barra(189 + 8, 192 + 8, *props_C)) ret.agregar_barra(Barra(189 + 8, 193 + 8, *props_C)) ret.agregar_barra(Barra(193 + 8, 194 + 8, *props_C)) ret.agregar_barra(Barra(194 + 8, 195 + 8, *props_C)) ret.agregar_barra(Barra(14 + 46, 195 + 8, *props_C)) ret.agregar_barra(Barra(11 + 46, 191 + 8, *props_C)) ret.agregar_barra(Barra(13 + 46, 194 + 8, *props_C)) ret.agregar_barra(Barra(11 + 46, 190 + 8, *props_C)) ret.agregar_barra(Barra(13 + 46, 195 + 8, *props_C)) ret.agregar_barra(Barra(12 + 46, 192 + 8, *props_C)) ret.agregar_barra(Barra(12 + 46, 193 + 8, *props_C)) ret.agregar_barra(Barra(11 + 46, 192 + 8, *props_C)) ret.agregar_barra(Barra(13 + 46, 193 + 8, *props_C)) # -------- BARRAS COLUMNA 3 (BASE EN NODO GLOBAL 17) ret.agregar_barra(Barra(188 + 16, 189 + 16, *props_C_BIG4)) # CENTRAL INFERIOR ret.agregar_barra(Barra(12 + 8, 189 + 16, *props_C_BIG4)) # CENTRAL SUPERIOR ret.agregar_barra(Barra(10 + 8, 190 + 16, *props_C)) ret.agregar_barra(Barra(190 + 16, 191 + 16, *props_C)) ret.agregar_barra(Barra(191 + 16, 192 + 16, *props_C)) ret.agregar_barra(Barra(189 + 16, 192 + 16, *props_C)) ret.agregar_barra(Barra(189 + 16, 193 + 16, *props_C)) ret.agregar_barra(Barra(193 + 16, 194 + 16, *props_C)) ret.agregar_barra(Barra(194 + 16, 195 + 16, *props_C)) ret.agregar_barra(Barra(14 + 8, 195 + 16, *props_C)) ret.agregar_barra(Barra(11 + 8, 191 + 16, *props_C)) ret.agregar_barra(Barra(13 + 8, 194 + 16, *props_C)) ret.agregar_barra(Barra(11 + 8, 190 + 16, *props_C)) ret.agregar_barra(Barra(13 + 8, 195 + 16, *props_C)) ret.agregar_barra(Barra(12 + 8, 192 + 16, *props_C)) ret.agregar_barra(Barra(12 + 8, 193 + 16, *props_C)) ret.agregar_barra(Barra(11 + 8, 192 + 16, *props_C)) ret.agregar_barra(Barra(13 + 8, 193 + 16, *props_C)) ret.agregar_barra(Barra(188 + 16 + 8, 189 + 16 + 8, *props_C_BIG4)) # CENTRAL INFERIOR ret.agregar_barra(Barra(12 + 8 + 46, 189 + 16 + 8, *props_C_BIG4)) # CENTRAL SUPERIOR ret.agregar_barra(Barra(10 + 8 + 46, 190 + 16 + 8, *props_C)) ret.agregar_barra(Barra(190 + 16 + 8, 191 + 16 + 8, *props_C)) ret.agregar_barra(Barra(191 + 16 + 8, 192 + 16 + 8, *props_C)) ret.agregar_barra(Barra(189 + 16 + 8, 192 + 16 + 8, *props_C)) ret.agregar_barra(Barra(189 + 16 + 8, 193 + 16 + 8, *props_C)) ret.agregar_barra(Barra(193 + 16 + 8, 194 + 16 + 8, *props_C)) ret.agregar_barra(Barra(194 + 16 + 8, 195 + 16 + 8, *props_C)) ret.agregar_barra(Barra(14 + 8 + 46, 195 + 16 + 8, *props_C)) ret.agregar_barra(Barra(11 + 8 + 46, 191 + 16 + 8, *props_C)) ret.agregar_barra(Barra(13 + 8 + 46, 194 + 16 + 8, *props_C)) ret.agregar_barra(Barra(11 + 8 + 46, 190 + 16 + 8, *props_C)) ret.agregar_barra(Barra(13 + 8 + 46, 195 + 16 + 8, *props_C)) ret.agregar_barra(Barra(12 + 8 + 46, 192 + 16 + 8, *props_C)) ret.agregar_barra(Barra(12 + 8 + 46, 193 + 16 + 8, *props_C)) ret.agregar_barra(Barra(11 + 8 + 46, 192 + 16 + 8, *props_C)) ret.agregar_barra(Barra(13 + 8 + 46, 193 + 16 + 8, *props_C)) # -------- BARRAS COLUMNA 4 (BASE EN NODO GLOBAL 20) #CARA 1 ret.agregar_barra(Barra(188 + 16 + 16, 189 + 16 + 16, *props_C_BIG4)) # CENTRAL INFERIOR ret.agregar_barra(Barra(12 + 8 + 6, 189 + 16 + 16, *props_C_BIG4)) # CENTRAL SUPERIOR ret.agregar_barra(Barra(10 + 8 + 6, 190 + 16 + 16, *props_C)) ret.agregar_barra(Barra(190 + 16 + 16, 191 + 16 + 16, *props_C)) ret.agregar_barra(Barra(191 + 16 + 16, 192 + 16 + 16, *props_C)) ret.agregar_barra(Barra(189 + 16 + 16, 192 + 16 + 16, *props_C)) ret.agregar_barra(Barra(189 + 16 + 16, 193 + 16 + 16, *props_C)) ret.agregar_barra(Barra(193 + 16 + 16, 194 + 16 + 16, *props_C)) ret.agregar_barra(Barra(194 + 16 + 16, 195 + 16 + 16, *props_C)) ret.agregar_barra(Barra(14 + 8 + 6, 195 + 16 + 16, *props_C)) ret.agregar_barra(Barra(11 + 8 + 6, 191 + 16 + 16, *props_C)) ret.agregar_barra(Barra(13 + 8 + 6, 194 + 16 + 16, *props_C)) ret.agregar_barra(Barra(11 + 8 + 6, 190 + 16 + 16, *props_C)) ret.agregar_barra(Barra(13 + 8 + 6, 195 + 16 + 16, *props_C)) ret.agregar_barra(Barra(12 + 8 + 6, 192 + 16 + 16, *props_C)) ret.agregar_barra(Barra(12 + 8 + 6, 193 + 16 + 16, *props_C)) ret.agregar_barra(Barra(11 + 8 + 6, 192 + 16 + 16, *props_C)) ret.agregar_barra(Barra(13 + 8 + 6, 193 + 16 + 16, *props_C)) #CARA 2 ret.agregar_barra( Barra(188 + 16 + 16 + 8, 189 + 16 + 16 + 8, *props_C_BIG4)) # CENTRAL INFERIOR ret.agregar_barra(Barra(12 + 8 + 6 + 46, 189 + 16 + 16 + 8, *props_C_BIG4)) # CENTRAL SUPERIOR ret.agregar_barra(Barra(10 + 8 + 6 + 46, 190 + 16 + 16 + 8, *props_C)) ret.agregar_barra(Barra(190 + 16 + 16 + 8, 191 + 16 + 16 + 8, *props_C)) ret.agregar_barra(Barra(191 + 16 + 16 + 8, 192 + 16 + 16 + 8, *props_C)) ret.agregar_barra(Barra(189 + 16 + 16 + 8, 192 + 16 + 16 + 8, *props_C)) ret.agregar_barra(Barra(189 + 16 + 16 + 8, 193 + 16 + 16 + 8, *props_C)) ret.agregar_barra(Barra(193 + 16 + 16 + 8, 194 + 16 + 16 + 8, *props_C)) ret.agregar_barra(Barra(194 + 16 + 16 + 8, 195 + 16 + 16 + 8, *props_C)) ret.agregar_barra(Barra(14 + 8 + 6 + 46, 195 + 16 + 16 + 8, *props_C)) ret.agregar_barra(Barra(11 + 8 + 6 + 46, 191 + 16 + 16 + 8, *props_C)) ret.agregar_barra(Barra(13 + 8 + 6 + 46, 194 + 16 + 16 + 8, *props_C)) ret.agregar_barra(Barra(11 + 8 + 6 + 46, 190 + 16 + 16 + 8, *props_C)) ret.agregar_barra(Barra(13 + 8 + 6 + 46, 195 + 16 + 16 + 8, *props_C)) ret.agregar_barra(Barra(12 + 8 + 6 + 46, 192 + 16 + 16 + 8, *props_C)) ret.agregar_barra(Barra(12 + 8 + 6 + 46, 193 + 16 + 16 + 8, *props_C)) ret.agregar_barra(Barra(11 + 8 + 6 + 46, 192 + 16 + 16 + 8, *props_C)) ret.agregar_barra(Barra(13 + 8 + 6 + 46, 193 + 16 + 16 + 8, *props_C)) # -------- BARRAS COLUMNA 5 (BASE EN NODO GLOBAL 24) #CARA 1 ret.agregar_barra(Barra(236, 237, *props_C_BIG5)) #CENTRAL ret.agregar_barra(Barra(237, 238, *props_C)) ret.agregar_barra(Barra(237, 239, *props_C)) ret.agregar_barra(Barra(238, 239, *props_C)) ret.agregar_barra(Barra(33, 238, *props_C)) ret.agregar_barra(Barra(33, 239, *props_C)) ret.agregar_barra(Barra(34, 238, *props_C)) ret.agregar_barra(Barra(34, 239, *props_C)) #CARA 2 ret.agregar_barra(Barra(236 + 4, 237 + 4, *props_C_BIG5)) #CENTRAL ret.agregar_barra(Barra(237 + 4, 238 + 4, *props_C)) ret.agregar_barra(Barra(237 + 4, 239 + 4, *props_C)) ret.agregar_barra(Barra(238 + 4, 239 + 4, *props_C)) ret.agregar_barra(Barra(33 + 46, 238 + 4, *props_C)) ret.agregar_barra(Barra(33 + 46, 239 + 4, *props_C)) ret.agregar_barra(Barra(34 + 46, 238 + 4, *props_C)) ret.agregar_barra(Barra(34 + 46, 239 + 4, *props_C)) # -------- BARRAS COLUMNA 6 (BASE EN NODO GLOBAL 26) ret.agregar_barra(Barra(38, 244, *props_C)) ret.agregar_barra(Barra(39, 244, *props_C)) ret.agregar_barra(Barra(38 + 46, 245, *props_C)) ret.agregar_barra(Barra(39 + 46, 245, *props_C)) #------------------------------------------------------------------------------------------------------------------------ # RESTRICCIONES #------------------------------------------------------------------------------------------------------------------------ # ------- APOYOS DEL TABLERO ret.agregar_restriccion(0, 0, 0) ret.agregar_restriccion(0, 1, 0) ret.agregar_restriccion(0, 2, 0) ret.agregar_restriccion(1, 0, 0) ret.agregar_restriccion(1, 1, 0) ret.agregar_restriccion(1, 2, 0) ret.agregar_restriccion(44, 0, 0) ret.agregar_restriccion(44, 1, 0) ret.agregar_restriccion(44, 2, 0) ret.agregar_restriccion(45, 0, 0) ret.agregar_restriccion(45, 1, 0) ret.agregar_restriccion(45, 2, 0) ret.agregar_restriccion(46, 0, 0) ret.agregar_restriccion(46, 1, 0) ret.agregar_restriccion(46, 2, 0) ret.agregar_restriccion(47, 0, 0) ret.agregar_restriccion(47, 1, 0) ret.agregar_restriccion(47, 2, 0) ret.agregar_restriccion(90, 0, 0) ret.agregar_restriccion(90, 1, 0) ret.agregar_restriccion(90, 2, 0) ret.agregar_restriccion(91, 0, 0) ret.agregar_restriccion(91, 1, 0) ret.agregar_restriccion(91, 2, 0) # ------- APOYOS COLUMNAS # --- COLUMNA 1 ret.agregar_restriccion(180, 0, 0) ret.agregar_restriccion(180, 1, 0) ret.agregar_restriccion(180, 2, 0) ret.agregar_restriccion(180 + 4, 0, 0) ret.agregar_restriccion(180 + 4, 1, 0) ret.agregar_restriccion(180 + 4, 2, 0) for i in range(181, 188): ret.agregar_restriccion(i, 1, 0) # --- COLUMNA 2 ret.agregar_restriccion(188, 0, 0) ret.agregar_restriccion(188, 1, 0) ret.agregar_restriccion(188, 2, 0) ret.agregar_restriccion(188 + 8, 0, 0) ret.agregar_restriccion(188 + 8, 1, 0) ret.agregar_restriccion(188 + 8, 2, 0) for i in range(189, 204): ret.agregar_restriccion(i, 1, 0) # --- COLUMNA 3 ret.agregar_restriccion(204, 0, 0) ret.agregar_restriccion(204, 1, 0) ret.agregar_restriccion(204, 2, 0) ret.agregar_restriccion(204 + 8, 0, 0) ret.agregar_restriccion(204 + 8, 1, 0) ret.agregar_restriccion(204 + 8, 2, 0) for i in range(204, 220): ret.agregar_restriccion(i, 1, 0) # --- COLUMNA 4 ret.agregar_restriccion(220, 0, 0) ret.agregar_restriccion(220, 1, 0) ret.agregar_restriccion(220, 2, 0) ret.agregar_restriccion(220 + 8, 0, 0) ret.agregar_restriccion(220 + 8, 1, 0) ret.agregar_restriccion(220 + 8, 2, 0) for i in range(220, 236): ret.agregar_restriccion(i, 1, 0) # --- COLUMNA 5 ret.agregar_restriccion(236, 0, 0) ret.agregar_restriccion(236, 1, 0) ret.agregar_restriccion(236, 2, 0) ret.agregar_restriccion(236 + 4, 0, 0) ret.agregar_restriccion(236 + 4, 1, 0) ret.agregar_restriccion(236 + 4, 2, 0) for i in range(236, 244): ret.agregar_restriccion(i, 1, 0) # --- COLUMNA 6 ret.agregar_restriccion(244, 0, 0) ret.agregar_restriccion(244, 1, 0) ret.agregar_restriccion(244, 2, 0) ret.agregar_restriccion(245, 0, 0) ret.agregar_restriccion(245, 1, 0) ret.agregar_restriccion(245, 2, 0) return ret
def caso_D(): # Unidades base m = 1. kg = 1. s = 1. #Unidades derivadas N = kg*m/s**2 cm = 0.01*m mm = 0.001*m KN = 1000*N kgf = 9.80665*N Pa = N / m**2 KPa = 1000*Pa MPa = 1000*KPa GPa = 1000*MPa #Parametros L = 5.0 *m B = 2.0 *m H = 3.5 *m q = 400*kgf/m**2 F = q*L*B F = F/4 #Inicializar modelo ret = Reticulado() #Nodos ret.agregar_nodo(0 , 0 , 0 ) #0 ret.agregar_nodo(L , 0 , 0 ) #1 ret.agregar_nodo(2*L , 0 , 0 ) #2 ret.agregar_nodo(3*L , 0 , 0 ) #3 ret.agregar_nodo(L/2 , B/2 , H ) #4 ret.agregar_nodo(3*L/2 , B/2 , H ) #5 ret.agregar_nodo(5*L/2 , B/2 , H ) #6 ret.agregar_nodo(0 , B , 0 ) #7 ret.agregar_nodo(L , B , 0 ) #8 ret.agregar_nodo(2*L , B , 0 ) #9 ret.agregar_nodo(3*L , B , 0 ) #10 #Barras R = 8 * cm t = 5 * mm props = [R, t, 200*GPa, 7600*kg/m**3, 420*MPa] # ------------------------------------ # BARRAS LONGITUDINALES INFERIORES ret.agregar_barra(Barra(0, 1, *props)) # 0 ret.agregar_barra(Barra(1, 2, *props)) # 1 ret.agregar_barra(Barra(2, 3, *props)) # 2 ret.agregar_barra(Barra(7, 8, *props)) # 3 ret.agregar_barra(Barra(8, 9, *props)) # 4 ret.agregar_barra(Barra(9, 10, *props)) # 5 # BARRAS TRANSVERSALES INFERIORES ret.agregar_barra(Barra(0, 7, *props)) # 6 ret.agregar_barra(Barra(1, 8, *props)) # 7 ret.agregar_barra(Barra(2, 9, *props)) # 8 ret.agregar_barra(Barra(3, 10, *props)) # 9 # BARRAS DIAGONALES CRUZADAS INFERIORES ret.agregar_barra(Barra(0, 8, *props)) # 10 ret.agregar_barra(Barra(7, 1, *props)) # 11 ret.agregar_barra(Barra(8, 2, *props)) # 12 ret.agregar_barra(Barra(1, 9, *props)) # 13 ret.agregar_barra(Barra(9, 3, *props)) # 14 ret.agregar_barra(Barra(2, 10, *props)) # 15 # BARRAS DIAGONALES SUPERIORES ret.agregar_barra(Barra(0, 4, *props)) # 16 ret.agregar_barra(Barra(1, 4, *props)) # 17 ret.agregar_barra(Barra(7, 4, *props)) # 18 ret.agregar_barra(Barra(8, 4, *props)) # 19 ret.agregar_barra(Barra(1, 5, *props)) # 20 ret.agregar_barra(Barra(2, 5, *props)) # 21 ret.agregar_barra(Barra(8, 5, *props)) # 22 ret.agregar_barra(Barra(9, 5, *props)) # 23 ret.agregar_barra(Barra(2, 6, *props)) # 24 ret.agregar_barra(Barra(3, 6, *props)) # 25 ret.agregar_barra(Barra(9, 6, *props)) # 26 ret.agregar_barra(Barra(10, 6, *props)) # 27 # BARRAS LONGITUDINALES SUPERIORES ret.agregar_barra(Barra(4, 5, *props)) # 28 ret.agregar_barra(Barra(5, 6, *props)) # 29 # ------------------------------------ # RESTRICCIONES EN LOS NODOS # Nodos 0 y 7 fijos ret.agregar_restriccion(0, 0, 0) ret.agregar_restriccion(0, 1, 0) ret.agregar_restriccion(0, 2, 0) ret.agregar_restriccion(7, 0, 0) ret.agregar_restriccion(7, 1, 0) ret.agregar_restriccion(7, 2, 0) # Nodos 3 y 10 fijos en y,z ret.agregar_restriccion(3, 1, 0) ret.agregar_restriccion(3, 2, 0) ret.agregar_restriccion(10, 1, 0) ret.agregar_restriccion(10, 2, 0) return ret
def fun(H, graficar=False): # Unidades base m = 1. kg = 1. s = 1. #Unidades derivadas N = kg * m / s**2 cm = 0.01 * m mm = 0.001 * m KN = 1000 * N Pa = N / m**2 KPa = 1000 * Pa MPa = 1000 * KPa GPa = 1000 * MPa #Parametros L = 5.0 * m F = 100 * KN B = 2.0 * m #Inicializar modelo ret = Reticulado() #Nodos ret.agregar_nodo(0, 0, 0) ret.agregar_nodo(L, 0, 0) ret.agregar_nodo(2 * L, 0, 0) ret.agregar_nodo(L / 2, B / 2, H) ret.agregar_nodo(3 * L / 2, B / 2, H) ret.agregar_nodo(0, B, 0) ret.agregar_nodo(L, B, 0) ret.agregar_nodo(2 * L, B, 0) #Barras A = (1.1 * cm)**2 r = sqrt(A / 3.141593) props = [r, r, 200 * GPa, 7600 * kg / m**3, 420 * MPa] props2 = [r, r, 200 * GPa, 7600 * kg / m**3, 420 * MPa] # props2 = [0.6*r, 0.6*r, 200*GPa, 7600*kg/m**3, 420*MPa] ret.agregar_barra(Barra(0, 1, *props)) # 0 ret.agregar_barra(Barra(1, 2, *props)) # 1 ret.agregar_barra(Barra(3, 4, *props)) # 2 ret.agregar_barra(Barra(0, 3, *props2)) # 3 ret.agregar_barra(Barra(3, 1, *props2)) # 4 ret.agregar_barra(Barra(1, 4, *props2)) # 5 ret.agregar_barra(Barra(4, 2, *props)) # 6 ret.agregar_barra(Barra(5, 6, *props)) # 7 ret.agregar_barra(Barra(6, 7, *props)) # 8 ret.agregar_barra(Barra(5, 3, *props2)) # 9 ret.agregar_barra(Barra(3, 6, *props2)) # 10 ret.agregar_barra(Barra(6, 4, *props2)) # 11 ret.agregar_barra(Barra(4, 7, *props)) # 12 ret.agregar_barra(Barra(0, 5, *props)) # 13 ret.agregar_barra(Barra(1, 6, *props)) # 14 ret.agregar_barra(Barra(2, 7, *props)) # 15 ret.agregar_barra(Barra(0, 6, *props)) # 16 ret.agregar_barra(Barra(6, 2, *props)) # 17 ret.agregar_barra(Barra(5, 1, *props)) # 18 ret.agregar_barra(Barra(1, 7, *props)) # 19 # ver_reticulado_3d(ret) ret.agregar_restriccion(0, 0, 0) ret.agregar_restriccion(0, 1, 0) ret.agregar_restriccion(0, 2, 0) ret.agregar_restriccion(2, 2, 0) ret.agregar_restriccion(5, 2, 0) ret.agregar_restriccion(7, 2, 0) ret.agregar_restriccion(5, 0, 0) ret.agregar_fuerza(4, 2, -F) peso = ret.calcular_peso_total() print(f"peso = {peso}") ret.ensamblar_sistema() ret.resolver_sistema() f = ret.recuperar_fuerzas() if graficar: ver_reticulado_3d(ret, opciones_nodos={ "usar_posicion_deformada": True, "factor_amplificacion_deformada": 30., }, opciones_barras={ "color_barras_por_dato": True, "ver_numeros_de_barras": False, "ver_dato_en_barras": True, "dato": f, "color_fondo": [1, 1, 1, 0.4] }, llamar_show=False) return f[2]
def caso_L(): # Unidades base m = 1. kg = 1. s = 1. #Unidades derivadas N = kg * m / s**2 cm = 0.01 * m mm = 0.001 * m KN = 1000 * N Pa = N / m**2 KPa = 1000 * Pa MPa = 1000 * KPa GPa = 1000 * MPa #Parametros L = 5.0 * m B = 2.0 * m H = 3.5 * m # q = 400 * kg / m**2 #Inicializar modelo ret = Reticulado() #Nodos ret.agregar_nodo(0, 0, 0) #NODO 0 ret.agregar_nodo(L, 0, 0) #NODO 1 ret.agregar_nodo(2 * L, 0, 0) #NODO 2 ret.agregar_nodo(3 * L, 0, 0) #NODO 3 ret.agregar_nodo(L / 2, B / 2, H) #NODO 4 ret.agregar_nodo(3 * L / 2, B / 2, H) #NODO 5 ret.agregar_nodo(5 * L / 2, B / 2, H) #NODO 6 ret.agregar_nodo(0, B, 0) #NODO 7 ret.agregar_nodo(L, B, 0) #NODO 8 ret.agregar_nodo(2 * L, B, 0) #NODO 9 ret.agregar_nodo(3 * L, B, 0) #NODO 10 # Barras props = [8 * cm, 5 * mm, 200 * GPa, 7600 * kg / m**3, 420 * MPa] ret.agregar_barra(Barra(0, 1, *props)) # 0 ret.agregar_barra(Barra(1, 2, *props)) # 1 ret.agregar_barra(Barra(2, 3, *props)) # 2 ret.agregar_barra(Barra(4, 5, *props)) # 3 ret.agregar_barra(Barra(5, 6, *props)) # 4 ret.agregar_barra(Barra(7, 8, *props)) # 5 ret.agregar_barra(Barra(8, 9, *props)) # 6 ret.agregar_barra(Barra(9, 10, *props)) # 7 ret.agregar_barra(Barra(0, 8, *props)) # 8 ret.agregar_barra(Barra(1, 7, *props)) # 9 ret.agregar_barra(Barra(1, 9, *props)) # 10 ret.agregar_barra(Barra(2, 8, *props)) # 11 ret.agregar_barra(Barra(2, 10, *props)) # 12 ret.agregar_barra(Barra(3, 9, *props)) # 13 ret.agregar_barra(Barra(0, 4, *props)) # 14 ret.agregar_barra(Barra(1, 4, *props)) # 15 ret.agregar_barra(Barra(7, 4, *props)) # 16 ret.agregar_barra(Barra(8, 4, *props)) # 17 ret.agregar_barra(Barra(1, 5, *props)) # 18 ret.agregar_barra(Barra(2, 5, *props)) # 19 ret.agregar_barra(Barra(8, 5, *props)) # 20 ret.agregar_barra(Barra(9, 5, *props)) # 21 ret.agregar_barra(Barra(2, 6, *props)) # 22 ret.agregar_barra(Barra(3, 6, *props)) # 23 ret.agregar_barra(Barra(9, 6, *props)) # 24 ret.agregar_barra(Barra(10, 6, *props)) # 25 ret.agregar_barra(Barra(0, 7, *props)) # 26 ret.agregar_barra(Barra(1, 8, *props)) # 27 ret.agregar_barra(Barra(2, 9, *props)) # 28 ret.agregar_barra(Barra(3, 10, *props)) # 29 ret.agregar_restriccion(0, 0, 0) ret.agregar_restriccion(0, 1, 0) ret.agregar_restriccion(0, 2, 0) ret.agregar_restriccion(7, 0, 0) ret.agregar_restriccion(7, 1, 0) ret.agregar_restriccion(7, 2, 0) ret.agregar_restriccion(3, 1, 0) ret.agregar_restriccion(3, 2, 0) ret.agregar_restriccion(10, 1, 0) ret.agregar_restriccion(10, 2, 0) return ret
kg = 1.0 GPa = 1e+9 MPa = 1e+6 KN = 1e3 m = 1.0 #Inicializar modelo ret = Reticulado() #Nodos ret.agregar_nodo(0,0) ret.agregar_nodo(1,0) ret.agregar_nodo(1,1) print(ret) #Barras b1 = Barra(0, 1, 20*cm, 4*mm, 200*GPa, 7600*kg/m**3, 420*MPa) b2 = Barra(1, 2, 20*cm, 4*mm, 200*GPa, 7600*kg/m**3, 420*MPa) b3 = Barra(0, 2, 20*cm, 4*mm, 200*GPa, 7600*kg/m**3, 420*MPa) ret.agregar_barra(b1) ret.agregar_barra(b2) ret.agregar_barra(b3) peso_total = ret.calcular_peso_total() print(f"peso_total = {peso_total}") ver_reticulado_2d(ret)
def jugar(self): fuera_juego = False # Genera múltiples eventos pygame.KEYDOWN pygame.key.set_repeat(50, 50) while not fuera_juego: # Si el score de alguno de los jugadores es igual a 5 if self.versus != "practica": if self.bola.get_score1() == 5 or self.bola.get_score2() == 5: # Se reinician los scores self.bola.set_score1(0) self.bola.set_score2(0) # Se pasa de nivel self.nivel += 1 # Se limpia la matriz para dibujar las barras del siguiente nivel self.matriz = [] # Se vuelve a crear la matriz self.crearMatriz() # Se definen las condiciones de acuerdo con cada nivel if self.nivel == 1: self.tiempo = TIEMPO_NIVEL1 if self.modo == "Single": self.barra1 = Barra(1, 2, TAMAÑO_BARRA_1) self.barra2 = Barra(38, 2, TAMAÑO_BARRA_1) else: self.barra1 = Barra_doble(1, 3, 9, 13, TAMAÑO_BARRA_1) self.barra2 = Barra_doble(38, 12, 32, 3, TAMAÑO_BARRA_1) if self.nivel == 2: self.tiempo = TIEMPO_NIVEL2 if self.modo == "Single": self.barra1 = Barra(1, 2, TAMAÑO_BARRA_2) self.barra2 = Barra(38, 2, TAMAÑO_BARRA_2) else: self.barra1 = Barra_doble(1, 3, 9, 13, TAMAÑO_BARRA_2) self.barra2 = Barra_doble(38, 12, 32, 3, TAMAÑO_BARRA_2) if self.nivel == 3: self.tiempo = TIEMPO_NIVEL3 if self.modo == "Single": self.barra1 = Barra(1, 2, TAMAÑO_BARRA_3) self.barra2 = Barra(38, 2, TAMAÑO_BARRA_3) else: self.barra1 = Barra_doble(1, 3, 9, 13, TAMAÑO_BARRA_3) self.barra2 = Barra_doble(38, 12, 32, 3, TAMAÑO_BARRA_3) # Si pierde en el nivel 3, vuelve al nivel 1 if self.nivel == 4: if self.bola.get_score1() == 5: font = pygame.font.Font(None, 48) texto = font.render( "¡Felicidades!", "Has aprobado INTRO & TALLER.\ \nListo para ALGORITMOS Y ESTRUCTURAS DE DATOS I. :D", True, (WHITE)) self.pantalla.blit(texto, (0, 0)) self.nivel = 0 else: if self.bola.get_score1() == 100: # Se reinician los scores self.bola.set_score1(0) # Se pasa de nivel self.nivel += 1 # Se limpia la matriz para dibujar las barras del siguiente nivel self.matriz = [] # Se vuelve a crear la matriz self.crearMatriz() if self.nivel == 1: self.tiempo = self.time if self.tamaño != None: if self.modo == "Single": self.barra1 = Barra(1, 2, self.tamaño) self.barra2 = Barra(38, 0, TAMAÑO_BARRA_PRACTICA) else: self.barra1 = Barra_doble( 1, 3, 7, 13, self.tamaño) self.barra2 = Barra(38, 0, TAMAÑO_BARRA_PRACTICA) # Eventos de las teclas for event in pygame.event.get(): if event.type == pygame.QUIT: #is le da X, cierra todo pygame.quit() quit() if event.type == pygame.KEYDOWN: #al presionar una tecla if event.key == pygame.K_UP: self.barra2.mover(1, self.matriz) elif event.key == pygame.K_DOWN: self.barra2.mover(-1, self.matriz) elif event.key == pygame.K_w: self.barra1.mover(1, self.matriz) elif event.key == pygame.K_s: self.barra1.mover(-1, self.matriz) elif event.key == pygame.K_ESCAPE: pygame.quit() quit() # Aquí se actualiza constántemente la matriz para que # ocurra el movimiento de forma continua self.dibujarMatriz() self.dibujar() # Lee los estimulos del Arduino #self.leerArduino() # se llama la función cpu solo si la variable CPU es igual a 1 if self.CPU == 1: self.cpu()
def jugar(self): global ventana, total, total1, total2, total3 fuera_juego = False # Genera múltiples eventos pygame.KEYDOWN pygame.key.set_repeat(50, 50) inicial = time.time() while not fuera_juego: # Si el score de alguno de los jugadores es igual a 5 if self.versus != "practica": if self.bola.get_score1() == 5 or self.bola.get_score2() == 5: # Se reinician los scores self.bola.set_score1(0) self.bola.set_score2(0) # Se pasa de nivel self.nivel += 1 self.musicSpeed += 1 self.playMusic() # Si pierde en el nivel 3, vuelve al nivel 1 if self.nivel == 4: total = str((time.time()-inicial)) self.archivarTiempos(total) pygame.quit() # Se limpia la matriz para dibujar las barras del siguiente nivel self.matriz = [] # Se vuelve a crear la matriz self.crearMatriz() # Se definen las condiciones de acuerdo con cada nivel if self.nivel == 1: self.tiempo = TIEMPO_NIVEL1 if self.modo == "Single": self.barra1 = Barra(1,2,TAMAÑO_BARRA_1,1) self.barra2 = Barra(38,2,TAMAÑO_BARRA_1,1) else: self.barra1 = Barra_doble(1,2,9,13,TAMAÑO_BARRA_1) self.barra2 = Barra_doble(38,12,32,3,TAMAÑO_BARRA_1) elif self.nivel == 2: self.tiempo = TIEMPO_NIVEL2 if self.modo == "Single": self.barra1 = Barra(1,2,TAMAÑO_BARRA_2,1) self.barra2 = Barra(38,2,TAMAÑO_BARRA_2,1) else: self.barra1 = Barra_doble(1,2,9,13,TAMAÑO_BARRA_2) self.barra2 = Barra_doble(38,12,30,3,TAMAÑO_BARRA_2) elif self.nivel == 3: self.tiempo = TIEMPO_NIVEL3 if self.modo == "Single": self.barra1 = Barra(1,2,TAMAÑO_BARRA_3,1) self.barra2 = Barra(38,2,TAMAÑO_BARRA_3,1) else: self.barra1 = Barra_doble(1,2,9,13,TAMAÑO_BARRA_3) self.barra2 = Barra_doble(38,12,30,3,TAMAÑO_BARRA_3) else: if self.bola.get_score1() == 100: # Se reinician los scores self.bola.set_score1(0) # Se pasa de nivel self.nivel += 1 self.musicSpeed +=1 self.playMusic() # Se limpia la matriz para dibujar las barras del siguiente nivel self.matriz = [] # Se vuelve a crear la matriz self.crearMatriz() if self.nivel == 1: self.tiempo = self.time if self.tamaño != None: if self.modo == "Single": self.barra1 = Barra(1,2,self.tamaño,1) self.barra2 = Barra(38,0,TAMAÑO_BARRA_PRACTICA,1) else: self.barra1 = Barra_doble(1,3,9,13,self.tamaño) self.barra2 = Barra(38,0,TAMAÑO_BARRA_PRACTICA,1) # Eventos de las teclas pygame.init() for event in pygame.event.get(): if event.type == pygame.QUIT: #is le da X, cierra todo pygame.quit() quit() if event.type == pygame.KEYDOWN: #al presionar una tecla if event.key == pygame.K_UP: self.barra2.mover(1,self.matriz) elif event.key == pygame.K_DOWN: self.barra2.mover(-1,self.matriz) elif event.key == pygame.K_w: self.barra1.mover(1,self.matriz) elif event.key == pygame.K_s: self.barra1.mover(-1,self.matriz) elif event.key == pygame.K_ESCAPE: pygame.quit() quit() elif event.key == pygame.K_p: self.pausa() elif event.key == pygame.K_SPACE: pygame.quit() quit() # Aquí se actualiza constántemente la matriz para que # ocurra el movimiento de forma continua self.dibujarMatriz() self.dibujar() # Lee los estimulos del Arduino self.leerArduino() self.sendArduino() # se llama la función cpu solo si la variable CPU es igual a 1 if self.CPU == 1: self.cpu()
def caso_L(): # Unidades base m = 1. kg = 1. s = 1. #Unidades derivadas N = kg*m/s**2 cm = 0.01*m mm = 0.001*m kgf = 9.80665*N KN = 1000*N Pa = N / m**2 KPa = 1000*Pa MPa = 1000*KPa GPa = 1000*MPa #Parametros L = 5.0 * m B = 2.0 * m H = 3.5 * m q = 400*kgf/m**2 F = q*L*B F = F/4 #Inicializar modelo ret = Reticulado() #Nodos tablero ret.agregar_nodo(0.0,0,100) # Nodo 0 (punto 7) ret.agregar_nodo(0.0,B,100) # Nodo 1 ret.agregar_nodo(5.0,0,100) # Nodo 2 ret.agregar_nodo(5.0,B,100) # Nodo 3 ret.agregar_nodo(10.0,0,100) # Nodo 4 ret.agregar_nodo(10.0,B,100) # Nodo 5 ret.agregar_nodo(15.0,0,100) # Nodo 6 ret.agregar_nodo(15.0,B,100) # Nodo 7 ret.agregar_nodo(20.0,0,100) # Nodo 8 ret.agregar_nodo(20.0,B,100) # Nodo 9 ret.agregar_nodo(25.0,0,100) # Nodo 10 ret.agregar_nodo(25.0,B,100) # Nodo 11 ret.agregar_nodo(30.0,0,100) # Nodo 12 ret.agregar_nodo(30.0,B,100) # Nodo 13 ret.agregar_nodo(35.0,0,100) # Nodo 14 ret.agregar_nodo(35.0,B,100) # Nodo 15 ret.agregar_nodo(40.0,0,100) # Nodo 16 ret.agregar_nodo(40.0,B,100) # Nodo 17 ret.agregar_nodo(45.0,0,100) # Nodo 18 ret.agregar_nodo(45.0,B,100) # Nodo 19 ret.agregar_nodo(50.0,0,100) # Nodo 20 ret.agregar_nodo(50.0,B,100) # Nodo 21 ret.agregar_nodo(55.0,0,100) # Nodo 22 ret.agregar_nodo(55.0,B,100) # Nodo 23 ret.agregar_nodo(60.0,0,100) # Nodo 24 ret.agregar_nodo(60.0,B,100) # Nodo 25 ret.agregar_nodo(65.0,0,100) # Nodo 26 ret.agregar_nodo(65.0,B,100) # Nodo 27 ret.agregar_nodo(70.0,0,100) # Nodo 28 ret.agregar_nodo(70.0,B,100) # Nodo 29 ret.agregar_nodo(75.0,0,100) # Nodo 30 ret.agregar_nodo(75.0,B,100) # Nodo 31 ret.agregar_nodo(80.0,0,100) # Nodo 32 ret.agregar_nodo(80.0,B,100) # Nodo 33 ret.agregar_nodo(85.0,0,100) # Nodo 34 ret.agregar_nodo(85.0,B,100) # Nodo 35 ret.agregar_nodo(90.0,0,100) # Nodo 36 ret.agregar_nodo(90.0,B,100) # Nodo 37 ret.agregar_nodo(95.0,0,100) # Nodo 38 ret.agregar_nodo(95.0,B,100) # Nodo 39 ret.agregar_nodo(100.0,0,100) # Nodo 40 ret.agregar_nodo(100.0,B,100) # Nodo 41 ret.agregar_nodo(105.0,0,100) # Nodo 42 ret.agregar_nodo(105.0,B,100) # Nodo 43 ret.agregar_nodo(110.0,0,100) # Nodo 44 ret.agregar_nodo(110.0,B,100) # Nodo 45 ret.agregar_nodo(115.0,0,100) # Nodo 46 ret.agregar_nodo(115.0,B,100) # Nodo 47 ret.agregar_nodo(120.0,0,100) # Nodo 48 ret.agregar_nodo(120.0,B,100) # Nodo 49 ret.agregar_nodo(125.0,0,100) # Nodo 50 ret.agregar_nodo(125.0,B,100) # Nodo 51 ret.agregar_nodo(130.0,0,100) # Nodo 52 ret.agregar_nodo(130.0,B,100) # Nodo 53 ret.agregar_nodo(135.0,0,100) # Nodo 54 ret.agregar_nodo(135.0,B,100) # Nodo 55 ret.agregar_nodo(140.0,0,100) # Nodo 56 ret.agregar_nodo(140.0,B,100) # Nodo 57 ret.agregar_nodo(145.0,0,100) # Nodo 58 ret.agregar_nodo(145.0,B,100) # Nodo 59 ret.agregar_nodo(150.0,0,100) # Nodo 60 ret.agregar_nodo(150.0,B,100) # Nodo 61 ret.agregar_nodo(155.0,0,100) # Nodo 62 ret.agregar_nodo(155.0,B,100) # Nodo 63 ret.agregar_nodo(160.0,0,100) # Nodo 64 ret.agregar_nodo(160.0,B,100) # Nodo 65 ret.agregar_nodo(165.0,0,100) # Nodo 66 ret.agregar_nodo(165.0,B,100) # Nodo 67 ret.agregar_nodo(170.0,0,100) # Nodo 68 ret.agregar_nodo(170.0,B,100) # Nodo 69 ret.agregar_nodo(175.0,0,100) # Nodo 70 ret.agregar_nodo(175.0,B,100) # Nodo 71 ret.agregar_nodo(180.0,0,100) # Nodo 72 ret.agregar_nodo(180.0,B,100) # Nodo 73 ret.agregar_nodo(185.0,0,100) # Nodo 74 ret.agregar_nodo(185.0,B,100) # Nodo 75 ret.agregar_nodo(190.0,0,100) # Nodo 76 ret.agregar_nodo(190.0,B,100) # Nodo 77 ret.agregar_nodo(195.0,0,100) # Nodo 78 ret.agregar_nodo(195.0,B,100) # Nodo 79 ret.agregar_nodo(200.0,0,100) # Nodo 80 ret.agregar_nodo(200.0,B,100) # Nodo 81 ret.agregar_nodo(205.0,0,100) # Nodo 82 ret.agregar_nodo(205.0,B,100) # Nodo 83 ret.agregar_nodo(210.0,0,100) # Nodo 84 ret.agregar_nodo(210.0,B,100) # Nodo 85 ret.agregar_nodo(215.0,0,100) # Nodo 86 ret.agregar_nodo(215.0,B,100) # Nodo 87 (punto 28) # Nodos Estructura j = np.arange(5.0,215,5) for i in j: ret.agregar_nodo(i, 0, 105) ret.agregar_nodo(i, B,105) ret.agregar_nodo(105, 1, 105)#172 ret.agregar_nodo(110, 1, 105)#173 # Barras props = [2*cm, 1*mm, 200*GPa, 7600*kg/m**3, 420*MPa] # Barras Tablero ret.agregar_barra(Barra(0, 2, *props)) ret.agregar_barra(Barra(1, 3, *props)) ret.agregar_barra(Barra(2, 4, *props)) ret.agregar_barra(Barra(3, 5, *props)) ret.agregar_barra(Barra(4, 6, *props)) ret.agregar_barra(Barra(5, 7, *props)) ret.agregar_barra(Barra(6, 8, *props)) ret.agregar_barra(Barra(7, 9, *props)) ret.agregar_barra(Barra(8, 10, *props)) ret.agregar_barra(Barra(9, 11, *props)) ret.agregar_barra(Barra(10, 12, *props)) ret.agregar_barra(Barra(11, 13, *props)) ret.agregar_barra(Barra(12, 14, *props)) ret.agregar_barra(Barra(13, 15, *props)) ret.agregar_barra(Barra(14, 16, *props)) ret.agregar_barra(Barra(15, 17, *props)) ret.agregar_barra(Barra(16, 18, *props)) ret.agregar_barra(Barra(17, 19, *props)) ret.agregar_barra(Barra(18, 20, *props)) ret.agregar_barra(Barra(19, 21, *props)) ret.agregar_barra(Barra(20, 22, *props)) ret.agregar_barra(Barra(21, 23, *props)) ret.agregar_barra(Barra(22, 24, *props)) ret.agregar_barra(Barra(23, 25, *props)) ret.agregar_barra(Barra(24, 26, *props)) ret.agregar_barra(Barra(25, 27, *props)) ret.agregar_barra(Barra(26, 28, *props)) ret.agregar_barra(Barra(27, 29, *props)) ret.agregar_barra(Barra(28, 30, *props)) ret.agregar_barra(Barra(29, 31, *props)) ret.agregar_barra(Barra(30, 32, *props)) ret.agregar_barra(Barra(31, 33, *props)) ret.agregar_barra(Barra(32, 34, *props)) ret.agregar_barra(Barra(33, 35, *props)) ret.agregar_barra(Barra(34, 36, *props)) ret.agregar_barra(Barra(35, 37, *props)) ret.agregar_barra(Barra(36, 38, *props)) ret.agregar_barra(Barra(37, 39, *props)) ret.agregar_barra(Barra(38, 40, *props)) ret.agregar_barra(Barra(39, 41, *props)) ret.agregar_barra(Barra(40, 42, *props)) ret.agregar_barra(Barra(41, 43, *props)) ret.agregar_barra(Barra(42, 44, *props)) ret.agregar_barra(Barra(43, 45, *props)) ret.agregar_barra(Barra(44, 46, *props)) ret.agregar_barra(Barra(45, 47, *props)) ret.agregar_barra(Barra(46, 48, *props)) ret.agregar_barra(Barra(47, 49, *props)) ret.agregar_barra(Barra(48, 50, *props)) ret.agregar_barra(Barra(49, 51, *props)) ret.agregar_barra(Barra(50, 52, *props)) ret.agregar_barra(Barra(51, 53, *props)) ret.agregar_barra(Barra(52, 54, *props)) ret.agregar_barra(Barra(53, 55, *props)) ret.agregar_barra(Barra(54, 56, *props)) ret.agregar_barra(Barra(55, 57, *props)) ret.agregar_barra(Barra(56, 58, *props)) ret.agregar_barra(Barra(57, 59, *props)) ret.agregar_barra(Barra(58, 60, *props)) ret.agregar_barra(Barra(59, 61, *props)) ret.agregar_barra(Barra(60, 62, *props)) ret.agregar_barra(Barra(61, 63, *props)) ret.agregar_barra(Barra(62, 64, *props)) ret.agregar_barra(Barra(63, 65, *props)) ret.agregar_barra(Barra(64, 66, *props)) ret.agregar_barra(Barra(65, 67, *props)) ret.agregar_barra(Barra(66, 68, *props)) ret.agregar_barra(Barra(67, 69, *props)) ret.agregar_barra(Barra(68, 70, *props)) ret.agregar_barra(Barra(69, 71, *props)) ret.agregar_barra(Barra(70, 72, *props)) ret.agregar_barra(Barra(71, 73, *props)) ret.agregar_barra(Barra(72, 74, *props)) ret.agregar_barra(Barra(73, 75, *props)) ret.agregar_barra(Barra(74, 76, *props)) ret.agregar_barra(Barra(75, 77, *props)) ret.agregar_barra(Barra(76, 78, *props)) ret.agregar_barra(Barra(77, 79, *props)) ret.agregar_barra(Barra(78, 80, *props)) ret.agregar_barra(Barra(79, 81, *props)) ret.agregar_barra(Barra(80, 82, *props)) ret.agregar_barra(Barra(81, 83, *props)) ret.agregar_barra(Barra(82, 84, *props)) ret.agregar_barra(Barra(83, 85, *props)) ret.agregar_barra(Barra(84, 86, *props)) ret.agregar_barra(Barra(85, 87, *props)) ret.agregar_barra(Barra(0, 1, *props)) ret.agregar_barra(Barra(2, 3, *props)) ret.agregar_barra(Barra(4, 5, *props)) ret.agregar_barra(Barra(6, 7, *props)) ret.agregar_barra(Barra(8, 9, *props)) ret.agregar_barra(Barra(10, 11, *props)) ret.agregar_barra(Barra(12, 13, *props)) ret.agregar_barra(Barra(14, 15, *props)) ret.agregar_barra(Barra(16, 17, *props)) ret.agregar_barra(Barra(18, 19, *props)) ret.agregar_barra(Barra(20, 21, *props)) ret.agregar_barra(Barra(22, 23, *props)) ret.agregar_barra(Barra(24, 25, *props)) ret.agregar_barra(Barra(26, 27, *props)) ret.agregar_barra(Barra(28, 29, *props)) ret.agregar_barra(Barra(30, 31, *props)) ret.agregar_barra(Barra(32, 33, *props)) ret.agregar_barra(Barra(34, 35, *props)) ret.agregar_barra(Barra(36, 37, *props)) ret.agregar_barra(Barra(38, 39, *props)) ret.agregar_barra(Barra(40, 41, *props)) ret.agregar_barra(Barra(42, 43, *props)) ret.agregar_barra(Barra(44, 45, *props)) ret.agregar_barra(Barra(46, 47, *props)) ret.agregar_barra(Barra(48, 49, *props)) ret.agregar_barra(Barra(50, 51, *props)) ret.agregar_barra(Barra(52, 53, *props)) ret.agregar_barra(Barra(54, 55, *props)) ret.agregar_barra(Barra(56, 57, *props)) ret.agregar_barra(Barra(58, 59, *props)) ret.agregar_barra(Barra(60, 61, *props)) ret.agregar_barra(Barra(62, 63, *props)) ret.agregar_barra(Barra(64, 65, *props)) ret.agregar_barra(Barra(66, 67, *props)) ret.agregar_barra(Barra(68, 69, *props)) ret.agregar_barra(Barra(70, 71, *props)) ret.agregar_barra(Barra(72, 73, *props)) ret.agregar_barra(Barra(74, 75, *props)) ret.agregar_barra(Barra(76, 77, *props)) ret.agregar_barra(Barra(78, 79, *props)) ret.agregar_barra(Barra(80, 81, *props)) ret.agregar_barra(Barra(82, 83, *props)) ret.agregar_barra(Barra(84, 85, *props)) ret.agregar_barra(Barra(86, 87, *props)) ret.agregar_barra(Barra(0, 3, *props)) ret.agregar_barra(Barra(1, 2, *props)) ret.agregar_barra(Barra(2, 5, *props)) ret.agregar_barra(Barra(3, 4, *props)) ret.agregar_barra(Barra(4, 7, *props)) ret.agregar_barra(Barra(5, 6, *props)) ret.agregar_barra(Barra(6, 9, *props)) ret.agregar_barra(Barra(7, 8, *props)) ret.agregar_barra(Barra(8, 11, *props)) ret.agregar_barra(Barra(9, 10, *props)) ret.agregar_barra(Barra(10, 13, *props)) ret.agregar_barra(Barra(11, 12, *props)) ret.agregar_barra(Barra(12, 15, *props)) ret.agregar_barra(Barra(13, 14, *props)) ret.agregar_barra(Barra(14, 17, *props)) ret.agregar_barra(Barra(15, 16, *props)) ret.agregar_barra(Barra(16, 19, *props)) ret.agregar_barra(Barra(17, 18, *props)) ret.agregar_barra(Barra(18, 21, *props)) ret.agregar_barra(Barra(19, 20, *props)) ret.agregar_barra(Barra(20, 23, *props)) ret.agregar_barra(Barra(21, 22, *props)) ret.agregar_barra(Barra(22, 25, *props)) ret.agregar_barra(Barra(23, 24, *props)) ret.agregar_barra(Barra(24, 27, *props)) ret.agregar_barra(Barra(25, 26, *props)) ret.agregar_barra(Barra(26, 29, *props)) ret.agregar_barra(Barra(27, 28, *props)) ret.agregar_barra(Barra(28, 31, *props)) ret.agregar_barra(Barra(29, 30, *props)) ret.agregar_barra(Barra(30, 33, *props)) ret.agregar_barra(Barra(31, 32, *props)) ret.agregar_barra(Barra(32, 35, *props)) ret.agregar_barra(Barra(33, 34, *props)) ret.agregar_barra(Barra(34, 37, *props)) ret.agregar_barra(Barra(35, 36, *props)) ret.agregar_barra(Barra(36, 39, *props)) ret.agregar_barra(Barra(37, 38, *props)) ret.agregar_barra(Barra(38, 41, *props)) ret.agregar_barra(Barra(39, 40, *props)) ret.agregar_barra(Barra(40, 43, *props)) ret.agregar_barra(Barra(41, 42, *props)) ret.agregar_barra(Barra(42, 45, *props)) ret.agregar_barra(Barra(43, 44, *props)) ret.agregar_barra(Barra(44, 47, *props)) ret.agregar_barra(Barra(45, 46, *props)) ret.agregar_barra(Barra(46, 49, *props)) ret.agregar_barra(Barra(47, 48, *props)) ret.agregar_barra(Barra(48, 51, *props)) ret.agregar_barra(Barra(49, 50, *props)) ret.agregar_barra(Barra(50, 53, *props)) ret.agregar_barra(Barra(51, 52, *props)) ret.agregar_barra(Barra(52, 55, *props)) ret.agregar_barra(Barra(53, 54, *props)) ret.agregar_barra(Barra(54, 57, *props)) ret.agregar_barra(Barra(55, 56, *props)) ret.agregar_barra(Barra(56, 59, *props)) ret.agregar_barra(Barra(57, 58, *props)) ret.agregar_barra(Barra(58, 61, *props)) ret.agregar_barra(Barra(59, 60, *props)) ret.agregar_barra(Barra(60, 63, *props)) ret.agregar_barra(Barra(61, 62, *props)) ret.agregar_barra(Barra(62, 65, *props)) ret.agregar_barra(Barra(63, 64, *props)) ret.agregar_barra(Barra(64, 67, *props)) ret.agregar_barra(Barra(65, 66, *props)) ret.agregar_barra(Barra(66, 69, *props)) ret.agregar_barra(Barra(67, 68, *props)) ret.agregar_barra(Barra(68, 71, *props)) ret.agregar_barra(Barra(69, 70, *props)) ret.agregar_barra(Barra(70, 73, *props)) ret.agregar_barra(Barra(71, 72, *props)) ret.agregar_barra(Barra(72, 75, *props)) ret.agregar_barra(Barra(73, 74, *props)) ret.agregar_barra(Barra(74, 77, *props)) ret.agregar_barra(Barra(75, 76, *props)) ret.agregar_barra(Barra(76, 79, *props)) ret.agregar_barra(Barra(77, 78, *props)) ret.agregar_barra(Barra(78, 81, *props)) ret.agregar_barra(Barra(79, 80, *props)) ret.agregar_barra(Barra(80, 83, *props)) ret.agregar_barra(Barra(81, 82, *props)) ret.agregar_barra(Barra(82, 85, *props)) ret.agregar_barra(Barra(83, 84, *props)) ret.agregar_barra(Barra(84, 87, *props)) ret.agregar_barra(Barra(85, 86, *props)) # Barras Estructura general #barras longitudinales estructura arco for i in range(88,170): ret.agregar_barra(Barra(i, i+2, *props)) for i in range(0,84): ret.agregar_barra(Barra(i, i+88, *props)) j = np.arange(88, 130, 2) for i in j: ret.agregar_barra(Barra(i, i+1, *props)) for i in np.arange(134,171,2): ret.agregar_barra(Barra(i, i+1, *props)) ret.agregar_barra(Barra(86,170,*props)) ret.agregar_barra(Barra(87,171,*props)) ret.agregar_barra(Barra(130, 172, *props)) ret.agregar_barra(Barra(131, 172, *props)) ret.agregar_barra(Barra(132, 173, *props)) ret.agregar_barra(Barra(133, 173, *props)) for i in range(4,42): ret.agregar_barra(Barra(i,i+84, *props)) for i in range(43,85): ret.agregar_barra(Barra(i, i+82, *props)) ret.agregar_restriccion(0, 0 ,0) ret.agregar_restriccion(0, 1 ,0) ret.agregar_restriccion(0, 2 ,0) ret.agregar_restriccion(1, 0 ,0) ret.agregar_restriccion(1, 1 ,0) ret.agregar_restriccion(1, 2 ,0) ret.agregar_restriccion(86, 0 ,0) ret.agregar_restriccion(86, 1 ,0) ret.agregar_restriccion(86, 2 ,0) ret.agregar_restriccion(87, 0 ,0) ret.agregar_restriccion(87, 1 ,0) ret.agregar_restriccion(87, 2 ,0) ret.agregar_restriccion(84, 0 ,0) ret.agregar_restriccion(84, 1 ,0) ret.agregar_restriccion(84, 2 ,0) ret.agregar_restriccion(85, 0 ,0) ret.agregar_restriccion(85, 1 ,0) ret.agregar_restriccion(85, 2 ,0) ret.agregar_restriccion(2, 0 ,0) ret.agregar_restriccion(2, 1 ,0) ret.agregar_restriccion(2, 2 ,0) ret.agregar_restriccion(3, 0 ,0) ret.agregar_restriccion(3, 1 ,0) ret.agregar_restriccion(3, 2 ,0) for i in range(88,174): ret.agregar_restriccion(i, 0 ,0) ret.agregar_restriccion(i, 1 ,0) ret.agregar_restriccion(i, 2 ,0) for i in range(2,86): ret.agregar_fuerza(i,2,-2*F) ret.agregar_fuerza(0,2,-F) ret.agregar_fuerza(1,2,-F) ret.agregar_fuerza(86,2,-F) ret.agregar_fuerza(87,2,-F) return ret
def __init__(self, gato): self.gato = gato self.barra = Barra(cargarImagen("manzana"), 100, 20, 20)
def caso_D(): # Unidades base m = 1. kg = 1. s = 1. #Unidades derivadas N = kg * m / s**2 cm = 0.01 * m mm = 0.001 * m KN = 1000 * N Pa = N / m**2 KPa = 1000 * Pa MPa = 1000 * KPa GPa = 1000 * MPa posibles_apoyos = loadtxt("coordenadas_apoyos.txt") importantes = [] for i in range(7, 29): importantes.append(list(posibles_apoyos[i])) x = [] z = [] for i in importantes: x.append(i[0]) z.append(i[1]) dist_x = [] for i in range(len(x) - 1): d = np.abs(x[i] - x[i + 1]) dist_x.append(d) nodos_x = [] for i in range(len(dist_x)): d = dist_x[i] if d > 6: cant = d / 6 dec, ent = math.modf(cant) for i in range(int(ent)): nodos_x.append(6.0) L = d - ent * 6 nodos_x.append(L) else: nodos_x.append(d) # Con BARRAS DE 6 m c/u i = 10 * m delta = 6 * m h = 5.0 ret = Reticulado() for j in range(37): ret.agregar_nodo(i + delta * j, 0, 100.0) ret.agregar_nodo(i + delta * j, 2, 100.0) ret.agregar_nodo(230.0, 0, 100.0) ret.agregar_nodo(230.0, 2, 100.0) nodos = np.arange(0, ret.Nnodos, 1) par = [] impar = [] for n in nodos: if n % 2 == 0: par.append(n) else: impar.append(n) # especie de arco for a in range(19): if a == 0: h = 115.0 else: h = 115.0 + a * 0.5 ret.agregar_nodo(a + delta * a, 1, h) for a in range(19, 37): h = 124 - (a - 19) * 0.5 if h <= 230: ret.agregar_nodo(a + delta * a, 1, h) ''' fig = plt.figure() fig.set_size_inches([12, 10], forward=True) ax = fig.add_subplot(111, projection='3d') graficar_nodos(ret, fig, opciones={}) plt.show() ''' #, R, t, E, ρ, σy R = 20 * cm t = 200 * mm props1 = [R, t, 200 * GPa, 7500 * kg / m**3, 420 * MPa] props2 = [R * 2, t * 3, 200 * GPa, 7500 * kg / m**3, 420 * MPa] for i in range(int(38 / 2)): a = par[2 * i] b = impar[2 * i + 1] ret.agregar_barra(Barra(a, b, *props2)) for i in range(int(38 / 2)): a = par[2 * i + 1] b = impar[2 * i] ret.agregar_barra(Barra(a, b, *props2)) for i in range(0, 75): ret.agregar_barra(Barra(i, i + 1, *props2)) for i in range(0, 36): p = i * 2 + 1 ret.agregar_barra(Barra(p, p + 2, *props2)) for i in range(0, 36): p = 2 * i ret.agregar_barra(Barra(p, p + 2, *props2)) arc = np.arange(76, 113, 1) for i in range(len(arc)): n1 = 2 * i n2 = 2 * i + 1 ret.agregar_barra(Barra(n1, arc[i], *props1)) ret.agregar_barra(Barra(arc[i], n2, *props1)) #restricciones ret.agregar_restriccion(0, 0, 0) ret.agregar_restriccion(0, 1, 0) ret.agregar_restriccion(0, 2, 0) ret.agregar_restriccion(1, 0, 0) ret.agregar_restriccion(1, 1, 0) ret.agregar_restriccion(1, 2, 0) ret.agregar_restriccion(38, 0, 0) ret.agregar_restriccion(38, 1, 0) ret.agregar_restriccion(38, 2, 0) ret.agregar_restriccion(39, 0, 0) ret.agregar_restriccion(39, 1, 0) ret.agregar_restriccion(39, 2, 0) ret.agregar_restriccion(74, 0, 0) ret.agregar_restriccion(74, 1, 0) ret.agregar_restriccion(74, 2, 0) ret.agregar_restriccion(75, 0, 0) ret.agregar_restriccion(75, 1, 0) ret.agregar_restriccion(75, 2, 0) for i in arc: ret.agregar_restriccion(i, 0, 0) ret.agregar_restriccion(i, 1, 0) ret.agregar_restriccion(i, 2, 0) # Carga muerta # nodos 0 y 1 peso = ret.calcular_peso_total() qD = ((peso) / (230 * m**2)) qD_A1 = -qD * (3 * m**2) ret.agregar_fuerza(0, 2, qD_A1) ret.agregar_fuerza(1, 2, qD_A1) # nodos 2 al 71 qD_A2 = -qD * (6 * m**2) for i in range(2, 72): ret.agregar_fuerza(i, 2, qD_A2) # nodos 72 y 73 qD_A3 = -qD * (5 * m**2) ret.agregar_fuerza(72, 2, qD_A3) ret.agregar_fuerza(73, 2, qD_A3) #nodos 74 y 75 qD_A4 = -qD * (2 * m**2) ret.agregar_fuerza(74, 2, qD_A4) ret.agregar_fuerza(75, 2, qD_A4) return ret
def jugar(self): fuera_juego = False # Genera múltiples eventos pygame.KEYDOWN pygame.key.set_repeat(50, 50) while not fuera_juego: # Si el score de alguno de los jugadores es igual a 5 if self.bola.get_score1() == 5 or self.bola.get_score2() == 5: # Se reinician los scores self.bola.set_score1(0) self.bola.set_score2(0) # Se pasa de nivel self.nivel += 1 # Se limpia la matriz para dibujar las barras del siguiente nivel self.matriz = [] # Se vuelve a crear la matriz self.crearMatriz() # Se definen las condiciones de acuerdo con cada nivel if self.nivel == 1: self.tiempo = TIEMPO_NIVEL1 if self.modo == "Single": self.barra1 = Barra(1, 2, TAMAÑO_BARRA_1) self.barra2 = Barra(38, 2, TAMAÑO_BARRA_1) else: self.barra1 = Barra_doble(1, 3, 9, 13, TAMAÑO_BARRA_1) self.barra2 = Barra_doble(38, 12, 30, 3, TAMAÑO_BARRA_1) if self.nivel == 2: self.tiempo = TIEMPO_NIVEL2 if self.modo == "Single": self.barra1 = Barra(1, 2, TAMAÑO_BARRA_2) self.barra2 = Barra(38, 2, TAMAÑO_BARRA_2) else: self.barra1 = Barra_doble(1, 3, 9, 13, TAMAÑO_BARRA_2) self.barra2 = Barra_doble(38, 12, 30, 3, TAMAÑO_BARRA_2) if self.nivel == 3: self.tiempo = TIEMPO_NIVEL3 if self.modo == "Single": self.barra1 = Barra(1, 2, TAMAÑO_BARRA_3) self.barra2 = Barra(38, 2, TAMAÑO_BARRA_3) else: self.barra1 = Barra_doble(1, 3, 9, 13, TAMAÑO_BARRA_3) self.barra2 = Barra_doble(38, 12, 30, 3, TAMAÑO_BARRA_3) # Si pierde en el nivel 3, vuelve al nivel 1 if self.nivel == 4: if self.bola.get_score1() == 5: messagebox.showinfo( "¡Felicidades!", "Has aprobado INTRO & TALLER.\nListo para ALGORITMOS Y ESTRUCTURAS DE DATOS I. :D" ) self.nivel = 0 # Eventos de las teclas for event in pygame.event.get(): if event.type == pygame.QUIT: #is le da X, cierra todo pygame.quit() quit() if event.type == pygame.KEYDOWN: #al presionar una tecla if event.key == pygame.K_UP: self.barra2.mover(1, self.matriz) elif event.key == pygame.K_DOWN: self.barra2.mover(-1, self.matriz) elif event.key == pygame.K_w: self.barra1.mover(1, self.matriz) elif event.key == pygame.K_s: self.barra1.mover(-1, self.matriz) elif event.key == pygame.K_ESCAPE: pygame.quit() quit() # Aquí se actualiza constántemente la matriz para que # ocurra el movimiento de forma continua self.dibujarMatriz() self.dibujar() # se llama la función cpu solo si la variable CPU es igual a 1 if self.CPU == 1: self.cpu()
def caso_L(): # Unidades base m = 1. kg = 1. s = 1. #Unidades derivadas N = kg * m / s**2 cm = 0.01 * m mm = 0.001 * m KN = 1000 * N Pa = N / m**2 KPa = 1000 * Pa MPa = 1000 * KPa GPa = 1000 * MPa # Parametros L = 5.0 * m H = 3.5 * m B = 2.0 * m q = 400 * 9.80665 * N / (m * m) # Areas Tributarias A0 = 1 * 2.5 * m * m A1 = 2 * 2.5 * m * m A2 = 2 * 2.5 * m * m A3 = 1 * 2.5 * m * m A7 = 1 * 2.5 * m * m A8 = 2 * 2.5 * m * m A9 = 2 * 2.5 * m * m A10 = 1 * 2.5 * m * m #Inicializar modelo ret = Reticulado() # Nodos ret.agregar_nodo(0, 0, 0) ret.agregar_nodo(L, 0, 0) ret.agregar_nodo(2 * L, 0, 0) ret.agregar_nodo(3 * L, 0, 0) ret.agregar_nodo(L / 2, B / 2, H) ret.agregar_nodo(3 * L / 2, B / 2, H) ret.agregar_nodo(5 * L / 2, B / 2, H) ret.agregar_nodo(0, B, 0) ret.agregar_nodo(L, B, 0) ret.agregar_nodo(2 * L, B, 0) ret.agregar_nodo(3 * L, B, 0) # Barras props = [8 * cm, 5 * mm, 200 * GPa, 7600 * kg / m**3, 420 * MPa] ret.agregar_barra(Barra(0, 1, *props)) # Hor 1 ret.agregar_barra(Barra(1, 2, *props)) ret.agregar_barra(Barra(2, 3, *props)) ret.agregar_barra(Barra(0, 8, *props)) # Diag 1 ret.agregar_barra(Barra(1, 9, *props)) ret.agregar_barra(Barra(2, 10, *props)) ret.agregar_barra(Barra(0, 4, *props)) # diag vertical 1.1 ret.agregar_barra(Barra(1, 5, *props)) ret.agregar_barra(Barra(2, 6, *props)) ret.agregar_barra(Barra(1, 4, *props)) # diag vertical 1.2 ret.agregar_barra(Barra(2, 5, *props)) ret.agregar_barra(Barra(3, 6, *props)) ret.agregar_barra(Barra(0, 7, *props)) # Lateral ret.agregar_barra(Barra(1, 8, *props)) ret.agregar_barra(Barra(2, 9, *props)) ret.agregar_barra(Barra(3, 10, *props)) ret.agregar_barra(Barra(1, 7, *props)) # Hor 2 ret.agregar_barra(Barra(2, 8, *props)) ret.agregar_barra(Barra(3, 9, *props)) ret.agregar_barra(Barra(7, 8, *props)) # Diag 2 ret.agregar_barra(Barra(8, 9, *props)) ret.agregar_barra(Barra(9, 10, *props)) ret.agregar_barra(Barra(4, 7, *props)) # diag vertical 2.1 ret.agregar_barra(Barra(5, 8, *props)) ret.agregar_barra(Barra(6, 9, *props)) ret.agregar_barra(Barra(4, 8, *props)) # diag vertical 2.2 ret.agregar_barra(Barra(5, 9, *props)) ret.agregar_barra(Barra(6, 10, *props)) ret.agregar_barra(Barra(4, 5, *props)) # Hor arriba ret.agregar_barra(Barra(5, 6, *props)) ret.agregar_restriccion(0, 0, 0) # Nodo 0 FIjo ret.agregar_restriccion(0, 1, 0) ret.agregar_restriccion(0, 2, 0) ret.agregar_restriccion(7, 0, 0) # Nodo 7 FIjo ret.agregar_restriccion(7, 1, 0) ret.agregar_restriccion(7, 2, 0) ret.agregar_restriccion(3, 1, 0) # Nodo 3 deslizable en x ret.agregar_restriccion(3, 2, 0) ret.agregar_restriccion(10, 1, 0) # Nodo 10 deslizable en x ret.agregar_restriccion(10, 2, 0) peso1 = ret.calcular_peso_total() ret.agregar_fuerza(0, 2, -q * A0) ret.agregar_fuerza(1, 2, -q * A1) ret.agregar_fuerza(2, 2, -q * A2) ret.agregar_fuerza(3, 2, -q * A3) ret.agregar_fuerza(7, 2, -q * A7) ret.agregar_fuerza(8, 2, -q * A8) ret.agregar_fuerza(9, 2, -q * A9) ret.agregar_fuerza(10, 2, -q * A10) return ret
def caso_D(): # Unidades base m = 1. kg = 1. s = 1. #Unidades derivadas N = kg * m / s**2 cm = 0.01 * m mm = 0.001 * m KN = 1000 * N kgf = 9.80665 * N Pa = N / m**2 KPa = 1000 * Pa MPa = 1000 * KPa GPa = 1000 * MPa #Parametros L = 5.0 * m B = 2.0 * m H = 3.5 * m q = 400 * kgf / m**2 F = q * L * B F = F / 4 #Inicializar modelo ret = Reticulado() #Nodos ret.agregar_nodo(0, 0, 0) #0 ret.agregar_nodo(L, 0, 0) #1 ret.agregar_nodo(2 * L, 0, 0) #2 ret.agregar_nodo(3 * L, 0, 0) #3 ret.agregar_nodo(L / 2, B / 2, H) #4 ret.agregar_nodo(3 * L / 2, B / 2, H) #5 ret.agregar_nodo(5 * L / 2, B / 2, H) #6 ret.agregar_nodo(0, B, 0) #7 ret.agregar_nodo(L, B, 0) #8 ret.agregar_nodo(2 * L, B, 0) #9 ret.agregar_nodo(3 * L, B, 0) #10 #Barras R = 8 * cm t = 5 * mm props = [R, t, 200 * GPa, 7600 * kg / m**3, 420 * MPa] ret.agregar_barra(Barra(0, 1, *props)) # 0 ret.agregar_barra(Barra(1, 2, *props)) # 1 ret.agregar_barra(Barra(2, 3, *props)) # 2 ret.agregar_barra(Barra(7, 8, *props)) # 3 ret.agregar_barra(Barra(8, 9, *props)) # 4 ret.agregar_barra(Barra(9, 10, *props)) # 5 ret.agregar_barra(Barra(0, 7, *props)) # 6 ret.agregar_barra(Barra(1, 8, *props)) # 7 ret.agregar_barra(Barra(2, 9, *props)) # 8 ret.agregar_barra(Barra(3, 10, *props)) # 9 ret.agregar_barra(Barra(0, 8, *props)) # 10 ret.agregar_barra(Barra(7, 1, *props)) # 11 ret.agregar_barra(Barra(8, 2, *props)) # 12 ret.agregar_barra(Barra(1, 9, *props)) # 13 ret.agregar_barra(Barra(9, 3, *props)) # 14 ret.agregar_barra(Barra(2, 10, *props)) # 15 ret.agregar_barra(Barra(0, 4, *props)) # 16 ret.agregar_barra(Barra(1, 4, *props)) # 17 ret.agregar_barra(Barra(7, 4, *props)) # 18 ret.agregar_barra(Barra(8, 4, *props)) # 19 ret.agregar_barra(Barra(1, 5, *props)) # 20 ret.agregar_barra(Barra(2, 5, *props)) # 21 ret.agregar_barra(Barra(8, 5, *props)) # 22 ret.agregar_barra(Barra(9, 5, *props)) # 23 ret.agregar_barra(Barra(2, 6, *props)) # 24 ret.agregar_barra(Barra(3, 6, *props)) # 25 ret.agregar_barra(Barra(9, 6, *props)) # 26 ret.agregar_barra(Barra(10, 6, *props)) # 27 ret.agregar_barra(Barra(4, 5, *props)) # 28 ret.agregar_barra(Barra(5, 6, *props)) # 29 #Nodo 0 y 7 fijos ret.agregar_restriccion(0, 0, 0) ret.agregar_restriccion(0, 1, 0) ret.agregar_restriccion(0, 2, 0) ret.agregar_restriccion(7, 0, 0) ret.agregar_restriccion(7, 1, 0) ret.agregar_restriccion(7, 2, 0) # Nodos 3 y 10 libres en X ret.agregar_restriccion(3, 1, 0) ret.agregar_restriccion(3, 2, 0) ret.agregar_restriccion(10, 1, 0) ret.agregar_restriccion(10, 2, 0) return ret
def caso_L(): # Unidades base m = 1. kg = 1. s = 1. #Unidades derivadas N = kg * m / s**2 cm = 0.01 * m mm = 0.001 * m KN = 1000 * N Pa = N / m**2 KPa = 1000 * Pa MPa = 1000 * KPa GPa = 1000 * MPa #parámetros A = 10.0 * m**2 q = 400 * kg / m**2 #Inicializar modelo ret = Reticulado() #Nodos #nodos 0-5 (6 nodos en total) for i in range(10, 15, 2): ret.agregar_nodo(puntos[i], 0, puntos[i + 1]) ret.agregar_nodo(puntos[i], 2, puntos[i + 1]) #nodos barras tablero 6-89 (86 nodos en total) for i in range(15, 221, 5): ret.agregar_nodo(i, 0, 100) ret.agregar_nodo(i, 2, 100) #nodos 90-95 (6 nodos en total) for i in range(56, 62, 2): ret.agregar_nodo(puntos[i], 0, puntos[i + 1]) ret.agregar_nodo(puntos[i], 2, puntos[i + 1]) #nodos 96 x 142 for i in np.arange(2.5, 235, 5): ret.agregar_nodo(i, 1, 102.88) #Barras props = [8 * cm, 5 * mm, 200 * GPa, 7600 * kg / m**3, 420 * MPa] props2 = [12 * cm, 15 * mm, 200 * GPa, 7600 * kg / m**3, 420 * MPa] props3 = [13 * cm, 15 * mm, 200 * GPa, 7600 * kg / m**3, 420 * MPa] for i in range(0, 94): ret.agregar_barra(Barra(i, i + 2, *props2)) #eje x for i in range(0, 95, 2): ret.agregar_barra(Barra(i, i + 1, *props3)) #eje y for i in range(96, 142): ret.agregar_barra(Barra(i, i + 1, *props)) j = 0 #union triangular for i in range(96, 143): ret.agregar_barra(Barra(i, j, *props)) ret.agregar_barra(Barra(i, j + 1, *props)) ret.agregar_barra(Barra(i, j + 2, *props)) ret.agregar_barra(Barra(i, j + 3, *props)) j += 2 #Restricciones ret.agregar_restriccion(0, 0, 0) ret.agregar_restriccion(0, 1, 0) ret.agregar_restriccion(1, 0, 0) ret.agregar_restriccion(1, 1, 0) ret.agregar_restriccion(94, 1, 0) ret.agregar_restriccion(95, 1, 0) #Fuerzas for i in range(0, 96): ret.agregar_fuerza(i, 2, q * A) return ret
class Juego: def __init__(self,trampolin, modo, nivel, versus, ventana, tamaño=None, time=TIEMPO_NIVEL1): self.pantalla = pygame.display.set_mode((ANCHO,LARGO)) pygame.display.set_caption("Pong") self.FILAS = 30 self.COLUMNAS = 40 self.matriz = [] self.crearMatriz() self.score = 0 self.bola = Bola(20,12, random.randrange(-1, 2), True) self.nivel = nivel self.modo = modo self.versus = versus self.CPU = 0 self.tamaño = tamaño self.time = time self.ventana = ventana self.trampolin = trampolin self.trampolin1 = Barra(10,5,4,2) self.trampolin2 = Barra(30,15,4,2) self.trampolin3 = Barra(20,10,4,2) self.musicOn = 1 self.musicSpeed = 1 self.background_color = (0, 0, 0) self.playMusic() # Se define el tiempo, tamaño de barra, modo y versus de cada nivel if self.nivel == 1: if self.time == None: self.tiempo = TIEMPO_NIVEL1 else: self.tiempo = time if self.modo == "Single": if self.tamaño == None: self.barra1 = Barra(1,2,TAMAÑO_BARRA_1,1) self.barra2 = Barra(38,2,TAMAÑO_BARRA_1,1) else: # Si se le define un tamaño es porque está en modo práctica self.barra1 = Barra(1,2,self.tamaño,1) self.barra2 = Barra(38,0,TAMAÑO_BARRA_PRACTICA,1) if self.versus == "humano": self.CPU = 0 elif self.versus == "cpu": self.CPU = 1 else: # La primer barra es la de la izquiera, la otra la de la derecha if self.tamaño == None: self.barra1 = Barra_doble(1,2,9,13,TAMAÑO_BARRA_1) self.barra2 = Barra_doble(38,12,30,3,TAMAÑO_BARRA_1) else: self.barra1 = Barra_doble(1,2,9,13,self.tamaño) self.barra2 = Barra(38,0,TAMAÑO_BARRA_PRACTICA,1) if self.versus == "humano": # Si se escoje "humano" no se llama la función cpu() self.CPU = 0 elif self.versus == "cpu": self.CPU = 1 # Se crea auna matriz binaria(compuesta por ahora por 0s), de 25 filas x 40 columnas def crearMatriz(self): for i in range(self.FILAS): fila = [] for j in range(self.COLUMNAS): # Llena la lista de ceros fila.append(0) self.matriz.append(fila) # Se va dibujando la matriz cuadro pr cuadro y se plasma en la pantalla def dibujarMatriz(self): for fila in range(self.FILAS): for columna in range(self.COLUMNAS): if self.matriz[fila][columna] == 0: # Si el cierta posición de la matriz hay un 0, se pinta de color negro pygame.draw.rect(self.pantalla, self.background_color, [L* columna,L * fila,L,L]) elif self.matriz[fila][columna] == 2: # Si el cierta posición de la matriz hay un 0, se pinta de color negro pygame.draw.rect(self.pantalla, GREEN, [L* columna,L * fila,L,L]) else: # Si el cierta posición de la matriz hay un 0, se pinta de color blanco # Esto es para la bola y las barras pygame.draw.rect(self.pantalla, WHITE, [L* columna,L * fila,L,L]) # Define cada cuánto tiempo se va a actualizar la matriz time.sleep(self.time) # Sibuja una línea blanca en medio de la pantalla pygame.draw.line(self.pantalla, WHITE, [ANCHO//2, 0], [ANCHO//2,LARGO], 4) # Barra controlada por la computadora def cpu(self): # La posicion en x de la bola es mayor a 28 if self.bola.get_x() > 28: if self.bola.get_y() > self.barra2.get_y(): # Si la posición en y de la bola es mayor que la de la barra # se mueve la barra hacia arriba o abajo siguiendo la bola self.barra2.mover(-1, self.matriz) else: self.barra2.mover(1, self.matriz) def jugar(self): global ventana, total, total1, total2, total3 fuera_juego = False # Genera múltiples eventos pygame.KEYDOWN pygame.key.set_repeat(50, 50) inicial = time.time() while not fuera_juego: # Si el score de alguno de los jugadores es igual a 5 if self.versus != "practica": if self.bola.get_score1() == 5 or self.bola.get_score2() == 5: # Se reinician los scores self.bola.set_score1(0) self.bola.set_score2(0) # Se pasa de nivel self.nivel += 1 self.musicSpeed += 1 self.playMusic() # Si pierde en el nivel 3, vuelve al nivel 1 if self.nivel == 4: total = str((time.time()-inicial)) self.archivarTiempos(total) pygame.quit() # Se limpia la matriz para dibujar las barras del siguiente nivel self.matriz = [] # Se vuelve a crear la matriz self.crearMatriz() # Se definen las condiciones de acuerdo con cada nivel if self.nivel == 1: self.tiempo = TIEMPO_NIVEL1 if self.modo == "Single": self.barra1 = Barra(1,2,TAMAÑO_BARRA_1,1) self.barra2 = Barra(38,2,TAMAÑO_BARRA_1,1) else: self.barra1 = Barra_doble(1,2,9,13,TAMAÑO_BARRA_1) self.barra2 = Barra_doble(38,12,32,3,TAMAÑO_BARRA_1) elif self.nivel == 2: self.tiempo = TIEMPO_NIVEL2 if self.modo == "Single": self.barra1 = Barra(1,2,TAMAÑO_BARRA_2,1) self.barra2 = Barra(38,2,TAMAÑO_BARRA_2,1) else: self.barra1 = Barra_doble(1,2,9,13,TAMAÑO_BARRA_2) self.barra2 = Barra_doble(38,12,30,3,TAMAÑO_BARRA_2) elif self.nivel == 3: self.tiempo = TIEMPO_NIVEL3 if self.modo == "Single": self.barra1 = Barra(1,2,TAMAÑO_BARRA_3,1) self.barra2 = Barra(38,2,TAMAÑO_BARRA_3,1) else: self.barra1 = Barra_doble(1,2,9,13,TAMAÑO_BARRA_3) self.barra2 = Barra_doble(38,12,30,3,TAMAÑO_BARRA_3) else: if self.bola.get_score1() == 100: # Se reinician los scores self.bola.set_score1(0) # Se pasa de nivel self.nivel += 1 self.musicSpeed +=1 self.playMusic() # Se limpia la matriz para dibujar las barras del siguiente nivel self.matriz = [] # Se vuelve a crear la matriz self.crearMatriz() if self.nivel == 1: self.tiempo = self.time if self.tamaño != None: if self.modo == "Single": self.barra1 = Barra(1,2,self.tamaño,1) self.barra2 = Barra(38,0,TAMAÑO_BARRA_PRACTICA,1) else: self.barra1 = Barra_doble(1,3,9,13,self.tamaño) self.barra2 = Barra(38,0,TAMAÑO_BARRA_PRACTICA,1) # Eventos de las teclas pygame.init() for event in pygame.event.get(): if event.type == pygame.QUIT: #is le da X, cierra todo pygame.quit() quit() if event.type == pygame.KEYDOWN: #al presionar una tecla if event.key == pygame.K_UP: self.barra2.mover(1,self.matriz) elif event.key == pygame.K_DOWN: self.barra2.mover(-1,self.matriz) elif event.key == pygame.K_w: self.barra1.mover(1,self.matriz) elif event.key == pygame.K_s: self.barra1.mover(-1,self.matriz) elif event.key == pygame.K_ESCAPE: pygame.quit() quit() elif event.key == pygame.K_p: self.pausa() elif event.key == pygame.K_SPACE: pygame.quit() quit() # Aquí se actualiza constántemente la matriz para que # ocurra el movimiento de forma continua self.dibujarMatriz() self.dibujar() # Lee los estimulos del Arduino self.leerArduino() self.sendArduino() # se llama la función cpu solo si la variable CPU es igual a 1 if self.CPU == 1: self.cpu() def dibujar(self): # Se defne un texto para poner en la pantalla font = pygame.font.Font(None, 100) score1 = self.bola.get_score1() score_text = font.render(str(score1), True, (WHITE)) # Se coloca el texto en la pantalla self.pantalla.blit(score_text, (150, 0)) score2 = self.bola.get_score2() score_text2 = font.render(str(score2), True, (WHITE)) self.pantalla.blit(score_text2, (620, 0)) # Coloca la bola en la matriz self.bola.mover(self.matriz) # Posiciona las barras en la matriz self.barra1.posicionar(self.matriz) self.barra2.posicionar(self.matriz) if self.trampolin == 1: if self.versus == "practica": if self.time == TIEMPO_NIVEL1: self.trampolin3.posicionar(self.matriz) elif self.time == TIEMPO_NIVEL2: self.trampolin1.posicionar(self.matriz) self.trampolin2.posicionar(self.matriz) elif self.time == TIEMPO_NIVEL3: self.trampolin1.posicionar(self.matriz) self.trampolin2.posicionar(self.matriz) self.trampolin3.posicionar(self.matriz) else: if self.nivel == 1: self.trampolin3.posicionar(self.matriz) elif self.nivel == 2: self.trampolin1.posicionar(self.matriz) self.trampolin2.posicionar(self.matriz) elif self.nivel == 3: self.trampolin1.posicionar(self.matriz) self.trampolin2.posicionar(self.matriz) self.trampolin3.posicionar(self.matriz) pygame.display.update() def playMusic(self): pygame.init() if self.musicSpeed == 1: back_music = pygame.mixer.music.load(os.path.join("sounds", "music.ogg")) elif self.musicSpeed == 2: back_music = pygame.mixer.music.load(os.path.join("sounds", "music_speed2.ogg")) elif self.musicSpeed == 3: back_music = pygame.mixer.music.load(os.path.join("sounds", "music_speed3.ogg")) if self.musicOn == 1: pygame.mixer.music.play(-1) else: pygame.mixer.music.play(-1) pygame.mixer.music.pause() # Cambia el color por uno aleatorio def colorCycle(self): self.background_color = (random.randrange(0, 256), random.randrange(0, 256), random.randrange(0, 256)) # Lee las instrucciones del Arduino con Pyserial def leerArduino(self): try: entrada = str(ser.readline()) datos = entrada[entrada.index("") + 1: entrada.index("\\")] comando = datos[:datos.index("%")] print(comando) if comando == "'P1_UP": self.barra1.mover(1, self.matriz) elif comando == "'P1_DOWN": self.barra1.mover(-1, self.matriz) elif comando == "'P2_UP": self.barra2.mover(1, self.matriz) elif comando == "'P2_DOWN": self.barra2.mover(-1, self.matriz) elif comando == "'MUTE": if self.musicOn == 1: self.musicOn = 0 pygame.mixer.music.pause() self.bola.set_mute(1) else: self.musicOn = 1 pygame.mixer.music.unpause() self.bola.set_mute(0) elif comando == "'COLOR": self.colorCycle() except: print('NO INPUT') time.sleep(0.0001) #def sendArduino(self): # if self.bola.get_score1() == 0: # ser.write(b'0') # elif self.bola.get_score1() == 1: # ser.write(b'1') # elif self.bola.get_score1() == 2: # ser.write(b'2') # elif self.bola.get_score1() == 3: # ser.write(b'3') # elif self.bola.get_score1() == 4: # ser.write(b'4') # elif self.bola.get_score1() == 5: # ser.write(b'5') # if self.bola.get_score2() == 0: # ser.write(b'6') # elif self.bola.get_score2() == 1: # ser.write(b'7') # elif self.bola.get_score2() == 2: # ser.write(b'8') # elif self.bola.get_score2() == 3: # ser.write(b'9') # elif self.bola.get_score2() == 4: # ser.write(b':') # elif self.bola.get_score2() == 5: # ser.write(b';') def archivarTiempos(self, total): vent = Tk() vent.title("Mejores Tiempos de Juego") vent.minsize (800, 500) vent.config(bg="black") pygame.quit() def unirLista(matriz): # Invierte las funciones de separar para la modificación del archivo txt if matriz == []: return [] else: return [";".join(matriz[0])] + unirLista(matriz[1:]) def abrirArchivo(archivo, modo): #abre el archivo file = open(archivo, modo) return file def separarTiempos(i): if i == len(highscore): return highscore[i] = highscore[i].replace("\n", "").split(";") separarTiempos(i + 1) archivo = abrirArchivo("Tiempos.txt", "r") highscore = archivo.readlines() separarTiempos(0) #print(highscore) archivo.close() def highscores(): iniciales = entradaNombre.get() if iniciales != "": if len(highscore) < 3: registrar = open("Tiempos.txt", "a") #abre un archivo registrar.write(iniciales + ";" + total + "\n") #escribe en el archivo registrar.close() else: if iniciales != highscore[0][0] and total != highscore[0][1]: if iniciales != highscore[1][0] and total != highscore[1][1]: if iniciales != highscore[2][0] and total != highscore[2][1]: return highscores_aux(total, iniciales) else: messagebox.showerror("Error en los datos", "No es record") else: messagebox.showerror("Error en los datos", "No es record") else: messagebox.showerror("Error en los datos", "No es record") else: messagebox.showerror("Error en los datos", "Ingrese sus iniciales") def highscores_aux(valor, iniciales): if valor < highscore[2][1]: hacer = True if iniciales != "": if valor <= highscore[0][1] and hacer: highscore[2][0] = highscore[1][0] highscore[2][1] = highscore[1][1] highscore[1][0] = highscore[0][0] highscore[1][1] = highscore[0][1] highscore[0][0] = iniciales highscore[0][1] = valor hacer = False if valor <= highscore[1][1] and valor > highscore[0][1] and hacer: highscore[2][0] = highscore[1][0] highscore[2][1] = highscore[1][1] highscore[1][0] = iniciales highscore[1][1] = valor hacer = False if valor < highscore[2][1] and valor > highscore[1][1] and hacer: highscore[2][0] = iniciales highscore[2][1] = valor nuevo_texto = "\n".join(unirLista(highscore)) archivo_highscores = abrirArchivo("Tiempos.txt", "w") archivo_highscores.write((str(nuevo_texto))) tiempo1.config(text = highscore[0][0] + " " + str(highscore[0][1])) tiempo2.config(text = highscore[1][0] + " " + str(highscore[1][1])) tiempo3.config(text = highscore[2][0] + " " + str(highscore[2][1])) labelNombre = Label(vent, text = "¡Tiempo récord! \n Ingrese sus iniciales:", font = ("arial bold", 30), bg = "black", fg = "yellow") labelNombre.place (x = 200, y = 250) entradaNombre = Entry (vent, font = ("arial", 16), width = 25, bg = "grey") entradaNombre.place (x = 257, y = 380) if len(highscore) == 3: tiempo1 = Label(vent, text = highscore[0][0] + " " + str(highscore[0][1]), font = ("arial bold", 16), bg = "black", fg = "white") tiempo1.place (x = 80, y = 100) tiempo2 = Label(vent, text = highscore[1][0] + " " + str(highscore[1][1]), font = ("arial bold", 16), bg = "black", fg = "white") tiempo2.place (x = 80, y = 150) tiempo3 = Label(vent, text = highscore[2][0] + " " + str(highscore[2][1]), font = ("arial bold", 16), bg = "black", fg = "white") tiempo3.place (x = 80, y = 200) else: label = Label(vent,text = "Nuevo record!", bg = "black", fg = "white", font = ("arial bold", 16)) label.place(x = 80, y = 100) boton = Button (vent, text = "Agregar", font = ("arial", 12), width = 6, command = highscores) boton.place (x = 120, y = 10) def listo(): vent.destroy() pygame.quit() self.ventana.deiconify() boton = Button (vent, text = "Volver al menú", font = ("arial", 12), width = 6, command = listo) boton.place (x = 200, y = 10) vent.mainloop() def crearVentana(): #Abre una nueva ventana donde hay dos botones: Administrar Apps y Administrar Vendedores vent = Tk() vent.title("Mejores Tiempos de Juego") vent.minsize (800, 500) canvas1 = Canvas (vent, width = 800, height = 500) canvas1.place (x = -1, y = -1) def volver(): vent.destroy() self.ventana.deiconify() boton = Button (vent, font = ("arial", 12), width = 6, command = volver) boton.place (x = 120, y = 10) vent.mainloop() pygame.quit() crearVentana() def pausa(self): pausado = True while pausado: pantalla = pygame.display.set_mode((ANCHO,LARGO)) font = pygame.font.Font(None, 25) for x in range (self.FILAS): score_text = font.render(str(self.matriz[x]), True,(WHITE)) # Se coloca el texto en la pantalla pantalla.blit(score_text, (20, 20*x)) pygame.display.update() for event in pygame.event.get(): if event.type == pygame.QUIT: #is le da X, cierra todo pygame.quit() quit() if event.type == pygame.KEYDOWN: #al presionar una tecla if event.key == pygame.K_p: pausado = False pygame.quit()
class Juego: def __init__(self, modo, nivel, versus, tamaño=None, time=TIEMPO_NIVEL1): pygame.init() self.pantalla = pygame.display.set_mode((ANCHO, LARGO)) pygame.display.set_caption("Pong") self.FILAS = 30 self.COLUMNAS = 40 self.matriz = [] self.crearMatriz() self.score = 0 self.bola = Bola(20, 12, random.randrange(-1, 2), True) self.nivel = nivel self.modo = modo self.versus = versus self.CPU = 0 self.tamaño = tamaño self.time = time # Se define el tiempo, tamaño de barra, modo y versus de cada nivel if self.nivel == 1: if self.time == None: self.tiempo = TIEMPO_NIVEL1 else: self.tiempo = time if self.modo == "Single": if self.tamaño == None: self.barra1 = Barra(1, 2, TAMAÑO_BARRA_1) self.barra2 = Barra(38, 2, TAMAÑO_BARRA_1) else: # Si se le define un tamaño es porque está en modo práctica self.barra1 = Barra(1, 2, self.tamaño) self.barra2 = Barra(38, 0, TAMAÑO_BARRA_PRACTICA) if self.versus == "humano": self.CPU = 0 elif self.versus == "cpu": self.CPU = 1 else: # La primer barra es la de la izquiera, la otra la de la derecha if self.tamaño == None: self.barra1 = Barra_doble(1, 3, 9, 13, TAMAÑO_BARRA_1) self.barra2 = Barra_doble(38, 12, 32, 3, TAMAÑO_BARRA_1) else: self.barra1 = Barra_doble(1, 3, 9, 13, self.tamaño) self.barra2 = Barra(38, 0, TAMAÑO_BARRA_PRACTICA) if self.versus == "humano": # Si se escoje "humano" no se llama la función cpu() self.CPU = 0 elif self.versus == "cpu": self.CPU = 1 # Se crea auna matriz binaria(compuesta por ahora por 0s), de 25 filas x 40 columnas def crearMatriz(self): for i in range(self.FILAS): fila = [] for j in range(self.COLUMNAS): # Llena la lista de ceros fila.append(0) self.matriz.append(fila) # Se va dibujando la matriz cuadro pr cuadro y se plasma en la pantalla def dibujarMatriz(self): for fila in range(self.FILAS): for columna in range(self.COLUMNAS): if self.matriz[fila][columna] == 0: # Si el cierta posición de la matriz hay un 0, se pinta de color negro pygame.draw.rect(self.pantalla, BLACK, [L * columna, L * fila, L, L]) else: # Si el cierta posición de la matriz hay un 0, se pinta de color blanco # Esto es para la bola y las barras pygame.draw.rect(self.pantalla, WHITE, [L * columna, L * fila, L, L]) # Define cada cuánto tiempo se va a actualizar la matriz time.sleep(self.tiempo) # Sibuja una línea blanca en medio de la pantalla pygame.draw.line(self.pantalla, WHITE, [ANCHO // 2, 0], [ANCHO // 2, LARGO], 4) # Barra controlada por la computadora def cpu(self): # La posicion en x de la bola es mayor a 28 if self.bola.get_x() > 28: if self.bola.get_y() > self.barra2.get_y(): # Si la posición en y de la bola es mayor que la de la barra # se mueve la barra hacia arriba o abajo siguiendo la bola self.barra2.mover(-1, self.matriz) else: self.barra2.mover(1, self.matriz) def jugar(self): fuera_juego = False # Genera múltiples eventos pygame.KEYDOWN pygame.key.set_repeat(50, 50) while not fuera_juego: # Si el score de alguno de los jugadores es igual a 5 if self.versus != "practica": if self.bola.get_score1() == 5 or self.bola.get_score2() == 5: # Se reinician los scores self.bola.set_score1(0) self.bola.set_score2(0) # Se pasa de nivel self.nivel += 1 # Se limpia la matriz para dibujar las barras del siguiente nivel self.matriz = [] # Se vuelve a crear la matriz self.crearMatriz() # Se definen las condiciones de acuerdo con cada nivel if self.nivel == 1: self.tiempo = TIEMPO_NIVEL1 if self.modo == "Single": self.barra1 = Barra(1, 2, TAMAÑO_BARRA_1) self.barra2 = Barra(38, 2, TAMAÑO_BARRA_1) else: self.barra1 = Barra_doble(1, 3, 9, 13, TAMAÑO_BARRA_1) self.barra2 = Barra_doble(38, 12, 32, 3, TAMAÑO_BARRA_1) if self.nivel == 2: self.tiempo = TIEMPO_NIVEL2 if self.modo == "Single": self.barra1 = Barra(1, 2, TAMAÑO_BARRA_2) self.barra2 = Barra(38, 2, TAMAÑO_BARRA_2) else: self.barra1 = Barra_doble(1, 3, 9, 13, TAMAÑO_BARRA_2) self.barra2 = Barra_doble(38, 12, 32, 3, TAMAÑO_BARRA_2) if self.nivel == 3: self.tiempo = TIEMPO_NIVEL3 if self.modo == "Single": self.barra1 = Barra(1, 2, TAMAÑO_BARRA_3) self.barra2 = Barra(38, 2, TAMAÑO_BARRA_3) else: self.barra1 = Barra_doble(1, 3, 9, 13, TAMAÑO_BARRA_3) self.barra2 = Barra_doble(38, 12, 32, 3, TAMAÑO_BARRA_3) # Si pierde en el nivel 3, vuelve al nivel 1 if self.nivel == 4: if self.bola.get_score1() == 5: font = pygame.font.Font(None, 48) texto = font.render( "¡Felicidades!", "Has aprobado INTRO & TALLER.\ \nListo para ALGORITMOS Y ESTRUCTURAS DE DATOS I. :D", True, (WHITE)) self.pantalla.blit(texto, (0, 0)) self.nivel = 0 else: if self.bola.get_score1() == 100: # Se reinician los scores self.bola.set_score1(0) # Se pasa de nivel self.nivel += 1 # Se limpia la matriz para dibujar las barras del siguiente nivel self.matriz = [] # Se vuelve a crear la matriz self.crearMatriz() if self.nivel == 1: self.tiempo = self.time if self.tamaño != None: if self.modo == "Single": self.barra1 = Barra(1, 2, self.tamaño) self.barra2 = Barra(38, 0, TAMAÑO_BARRA_PRACTICA) else: self.barra1 = Barra_doble( 1, 3, 7, 13, self.tamaño) self.barra2 = Barra(38, 0, TAMAÑO_BARRA_PRACTICA) # Eventos de las teclas for event in pygame.event.get(): if event.type == pygame.QUIT: #is le da X, cierra todo pygame.quit() quit() if event.type == pygame.KEYDOWN: #al presionar una tecla if event.key == pygame.K_UP: self.barra2.mover(1, self.matriz) elif event.key == pygame.K_DOWN: self.barra2.mover(-1, self.matriz) elif event.key == pygame.K_w: self.barra1.mover(1, self.matriz) elif event.key == pygame.K_s: self.barra1.mover(-1, self.matriz) elif event.key == pygame.K_ESCAPE: pygame.quit() quit() # Aquí se actualiza constántemente la matriz para que # ocurra el movimiento de forma continua self.dibujarMatriz() self.dibujar() # Lee los estimulos del Arduino #self.leerArduino() # se llama la función cpu solo si la variable CPU es igual a 1 if self.CPU == 1: self.cpu() def dibujar(self): # Se defne un texto para poner en la pantalla font = pygame.font.Font(None, 100) score1 = self.bola.get_score1() score_text = font.render(str(score1), True, (WHITE)) # Se coloca el texto en la pantalla self.pantalla.blit(score_text, (150, 0)) score2 = self.bola.get_score2() score_text2 = font.render(str(score2), True, (WHITE)) self.pantalla.blit(score_text2, (620, 0)) # Coloca la bola en la matriz self.bola.mover(self.matriz) # Posiciona las barras en la matriz self.barra1.posicionar(self.matriz) self.barra2.posicionar(self.matriz) pygame.display.update() def leerArduino(self): try: entrada = str(ser.readline()) datos = entrada[entrada.index("") + 1:entrada.index("\\")] comando = datos[:datos.index("%")] print(comando) if comando == "'P1_UP": self.barra1.mover(1, self.matriz) elif comando == "'P1_DOWN": self.barra1.mover(-1, self.matriz) except: print('NO INPUT') time.sleep(0.0001)
def caso_D(): # Unidades base m = 1. kg = 1. s = 1. #Unidades derivadas N = kg * m / s**2 cm = 0.01 * m mm = 0.1 * cm Pa = N / m**2 KPa = 1000 * Pa MPa = 1000 * KPa GPa = 1000 * MPa #Parametros L = 6.0 * m B = 2.0 * m H = 100 * m #Inicializar modelo ret = Reticulado() #Nodos y Barras altura_punta = 105 * m ############# NODOS PUENTE ################### ret.agregar_nodo(10, 0, H) #0 ret.agregar_nodo(10, B, H) #1 ret.agregar_nodo(14, 0, H) #2 primeros nodos para las barras de 4 m ret.agregar_nodo(14, B, H) #3 primeros nodos para las barras de 4 m ret.agregar_nodo(12, B / 2, altura_punta) #4 nodo punta contador_distancia_laterales = 14 contador_distancia_punta = 14 + L / 2 for i in range(36): contador_distancia_laterales += L ret.agregar_nodo(contador_distancia_laterales, 0, H) #5 ret.agregar_nodo(contador_distancia_laterales, B, H) #6 ret.agregar_nodo(contador_distancia_punta, B / 2, altura_punta) #7 nodo punta contador_distancia_punta += L ret.agregar_nodo(contador_distancia_laterales + 4, 0, H) #113 ultimos nodos para las barras de 4 m ret.agregar_nodo(contador_distancia_laterales + 4, B, H) #114 ultimos nodos para las barras de 4 m ret.agregar_nodo(contador_distancia_laterales + 2, B / 2, altura_punta) #115 nodo punta ############# BARRAS PUENTE ################### #Barras r = 8 * cm r2 = 10 * cm r3 = 10 * cm r4 = 20 * cm A = 3.141592 * (r)**2 t = 8 * mm t2 = 2 * mm t3 = 8 * mm t4 = 2 * cm props = [r, t, 200 * GPa, 7600 * kg / m**3, 420 * MPa] props2 = [r2, t2, 200 * GPa, 7600 * kg / m**3, 420 * MPa] props3 = [r3, t3, 200 * GPa, 7600 * kg / m**3, 420 * MPa] props4 = [r4, t4, 200 * GPa, 7600 * kg / m**3, 420 * MPa] ret.agregar_barra(Barra(0, 1, *props)) ret.agregar_barra(Barra(0, 2, *props)) ret.agregar_barra(Barra(0, 3, *props)) ret.agregar_barra(Barra(0, 4, *props2)) ret.agregar_barra(Barra(1, 2, *props)) ret.agregar_barra(Barra(1, 3, *props)) ret.agregar_barra(Barra(1, 4, *props2)) ret.agregar_barra(Barra(2, 3, *props)) ret.agregar_barra(Barra(2, 4, *props2)) ret.agregar_barra(Barra(3, 4, *props2)) for n in range(37): num = 3 * n + 2 ret.agregar_barra(Barra(num, num + 3, *props)) ret.agregar_barra(Barra(num, num + 4, *props)) ret.agregar_barra(Barra(num, num + 5, *props2)) ret.agregar_barra(Barra(num + 1, num + 3, *props)) ret.agregar_barra(Barra(num + 1, num + 4, *props)) ret.agregar_barra(Barra(num + 1, num + 5, *props2)) ret.agregar_barra(Barra(num + 3, num + 4, *props)) ret.agregar_barra(Barra(num + 3, num + 5, *props2)) ret.agregar_barra(Barra(num + 4, num + 5, *props2)) ret.agregar_barra(Barra(num + 2, num + 5, *props3)) ret.agregar_barra(Barra(110, 113, *props)) ret.agregar_barra(Barra(110, 114, *props)) ret.agregar_barra(Barra(110, 115, *props2)) ret.agregar_barra(Barra(111, 113, *props)) ret.agregar_barra(Barra(111, 114, *props)) ret.agregar_barra(Barra(111, 115, *props2)) ret.agregar_barra(Barra(113, 114, *props)) ret.agregar_barra(Barra(113, 115, *props2)) ret.agregar_barra(Barra(114, 115, *props2)) ############# RESTRICCIONES PUENTE ################### ret.agregar_restriccion(0, 0, 0) ret.agregar_restriccion(0, 1, 0) ret.agregar_restriccion(0, 2, 0) ret.agregar_restriccion(1, 0, 0) ret.agregar_restriccion(1, 1, 0) ret.agregar_restriccion(1, 2, 0) ret.agregar_restriccion(113, 0, 0) ret.agregar_restriccion(113, 1, 0) ret.agregar_restriccion(113, 2, 0) ret.agregar_restriccion(114, 0, 0) ret.agregar_restriccion(114, 1, 0) ret.agregar_restriccion(114, 2, 0) ############### NODOS PILAR 1 ############## B = 2.0 * m ret.agregar_nodo(44.0, 0, 53.0) #116 ret.agregar_nodo(44.0, B, 53.0) #117 ############### BARRAS PILAR 1 ############## ret.agregar_barra(Barra(116, 17, *props4)) ret.agregar_barra(Barra(116, 18, *props4)) ret.agregar_barra(Barra(117, 17, *props4)) ret.agregar_barra(Barra(117, 18, *props4)) ############### RESTRICCIONES PILAR 1 ############## ret.agregar_restriccion(116, 0, 0) ret.agregar_restriccion(116, 1, 0) ret.agregar_restriccion(116, 2, 0) ret.agregar_restriccion(117, 0, 0) ret.agregar_restriccion(117, 1, 0) ret.agregar_restriccion(117, 2, 0) ############### NODOS PILAR 2 ############## B = 2.0 * m ret.agregar_nodo(80.0, 0, 47.0) #118 ret.agregar_nodo(80.0, B, 47.0) #119 ############### BARRAS PILAR 2 ############## ret.agregar_barra(Barra(118, 35, *props4)) ret.agregar_barra(Barra(118, 36, *props4)) ret.agregar_barra(Barra(119, 35, *props4)) ret.agregar_barra(Barra(119, 36, *props4)) ############### RESTRICCIONES PILAR 2 ############## ret.agregar_restriccion(118, 0, 0) ret.agregar_restriccion(118, 1, 0) ret.agregar_restriccion(118, 2, 0) ret.agregar_restriccion(119, 0, 0) ret.agregar_restriccion(119, 1, 0) ret.agregar_restriccion(119, 2, 0) ############### NODOS PILAR 3 ############## B = 2.0 * m ret.agregar_nodo(164, 0, 64) #120 ret.agregar_nodo(164, B, 64) #121 ############### BARRAS PILAR 3 ############## ret.agregar_barra(Barra(120, 77, *props4)) ret.agregar_barra(Barra(120, 78, *props4)) ret.agregar_barra(Barra(121, 77, *props4)) ret.agregar_barra(Barra(121, 78, *props4)) ############### RESTRICCIONES PILAR 3 ############## ret.agregar_restriccion(120, 0, 0) ret.agregar_restriccion(120, 1, 0) ret.agregar_restriccion(120, 2, 0) ret.agregar_restriccion(121, 0, 0) ret.agregar_restriccion(121, 1, 0) ret.agregar_restriccion(121, 2, 0) return ret
def caso_D(): # Unidades base m = 1. kg = 1. s = 1. #Unidades derivadas N = kg * m / s**2 cm = 0.01 * m mm = 0.001 * m KN = 1000 * N Pa = N / m**2 KPa = 1000 * Pa MPa = 1000 * KPa GPa = 1000 * MPa #Parametros L = 5.0 * m F = 100 * KN B = 2.0 * m h = 3.5 * m #Inicializar modelo ret = Reticulado() #Nodos ret.agregar_nodo(0, 0, 0) #0 ret.agregar_nodo(L, 0, 0) #1 ret.agregar_nodo(2 * L, 0, 0) #2 ret.agregar_nodo(3 * L, 0, 0) #3 ret.agregar_nodo(L / 2, B / 2, h) #4 ret.agregar_nodo(3 * L / 2, B / 2, h) #5 ret.agregar_nodo(5 * L / 2, B / 2, h) #6 ret.agregar_nodo(0, B, 0) #7 ret.agregar_nodo(L, B, 0) #8 ret.agregar_nodo(2 * L, B, 0) #9 ret.agregar_nodo(3 * L, B, 0) #10 #Barras R = 8 * cm t = 5 * mm #, R, t, E, ρ, σy props = [R, t, 200 * GPa, 7600 * kg / m**3, 420 * MPa] ret.agregar_barra(Barra(0, 1, *props)) # 0 ret.agregar_barra(Barra(1, 2, *props)) # 1 ret.agregar_barra(Barra(2, 3, *props)) # 2 ret.agregar_barra(Barra(3, 10, *props)) # 3 ret.agregar_barra(Barra(9, 10, *props)) # 4 ret.agregar_barra(Barra(8, 9, *props)) # 5 ret.agregar_barra(Barra(7, 8, *props)) # 6 ret.agregar_barra(Barra(0, 7, *props)) # 7 ret.agregar_barra(Barra(1, 7, *props)) # 8 ret.agregar_barra(Barra(0, 8, *props)) # 9 ret.agregar_barra(Barra(1, 8, *props)) # 10 ret.agregar_barra(Barra(2, 8, *props)) # 11 ret.agregar_barra(Barra(1, 9, *props)) # 12 ret.agregar_barra(Barra(2, 9, *props)) # 13 ret.agregar_barra(Barra(3, 9, *props)) # 14 ret.agregar_barra(Barra(2, 10, *props)) # 15 ret.agregar_barra(Barra(4, 7, *props)) # 16 ret.agregar_barra(Barra(0, 4, *props)) # 17 ret.agregar_barra(Barra(4, 8, *props)) # 18 ret.agregar_barra(Barra(1, 4, *props)) # 19 ret.agregar_barra(Barra(5, 8, *props)) # 20 ret.agregar_barra(Barra(1, 5, *props)) # 21 ret.agregar_barra(Barra(5, 9, *props)) # 22 ret.agregar_barra(Barra(2, 5, *props)) # 23 ret.agregar_barra(Barra(6, 9, *props)) # 24 ret.agregar_barra(Barra(2, 6, *props)) # 25 ret.agregar_barra(Barra(6, 10, *props)) # 26 ret.agregar_barra(Barra(3, 6, *props)) # 27 ret.agregar_barra(Barra(4, 5, *props)) # 28 ret.agregar_barra(Barra(5, 6, *props)) # 29 #ver_reticulado_3d(ret) ret.agregar_restriccion(0, 0, 0) ret.agregar_restriccion(0, 1, 0) ret.agregar_restriccion(0, 2, 0) ret.agregar_restriccion(7, 0, 0) ret.agregar_restriccion(7, 1, 0) ret.agregar_restriccion(7, 2, 0) ret.agregar_restriccion(3, 1, 0) ret.agregar_restriccion(3, 2, 0) ret.agregar_restriccion(10, 1, 0) ret.agregar_restriccion(10, 2, 0) # Carga muerta peso = ret.calcular_peso_total() qD = ((peso) / (90 * m**2)) qD_A1 = -qD * (7.5 * m**2) qD_A2 = -qD * (15 * m**2) ret.agregar_fuerza(0, 2, qD_A1) ret.agregar_fuerza(3, 2, qD_A1) ret.agregar_fuerza(7, 2, qD_A1) ret.agregar_fuerza(10, 2, qD_A1) ret.agregar_fuerza(1, 2, qD_A2) ret.agregar_fuerza(2, 2, qD_A2) ret.agregar_fuerza(8, 2, qD_A2) ret.agregar_fuerza(9, 2, qD_A2) return ret
def caso_L(): # Unidades base m = 1. kg = 1. s = 1. #Unidades derivadas N = kg*m/s**2 cm = 0.01*m mm = 0.001*m KN = 1000*N Pa = N / m**2 KPa = 1000*Pa MPa = 1000*KPa GPa = 1000*MPa #Parametros L1 = 5.0 *m L2 = 2 * m # F = 100*KN qL = ((400*kg)/(m**2)) #Inicializar modelo ret = Reticulado() #Nodos ret.agregar_nodo(0 , 0 , 0 ) ret.agregar_nodo(L1 , 0 , 0 ) ret.agregar_nodo(2*L1 , 0 , 0 ) ret.agregar_nodo(3*L1 , 0 , 0 ) ret.agregar_nodo(L1/2 , L2/2 , 3.5 ) ret.agregar_nodo(L1 + L1/2 , L2/2 , 3.5) ret.agregar_nodo(2*L1 + L1/2 , L2/2 , 3.5 ) ret.agregar_nodo(0 , L2 , 0) ret.agregar_nodo(L1 , L2 , 0) ret.agregar_nodo(2*L1 , L2 , 0 ) ret.agregar_nodo(3*L1 , L2 , 0 ) #Barras props = [8*cm, 5*mm, 200*GPa, 0*7600*kg/m**3, 420*MPa] ret.agregar_barra(Barra(0, 1, *props)) # 0 ret.agregar_barra(Barra(1, 2, *props)) # 1 ret.agregar_barra(Barra(2, 3, *props)) # 2 ret.agregar_barra(Barra(3, 10, *props)) # 3 ret.agregar_barra(Barra(9, 10, *props)) # 4 ret.agregar_barra(Barra(8, 9, *props)) # 5 ret.agregar_barra(Barra(7, 8, *props)) # 6 ret.agregar_barra(Barra(0, 7, *props)) # 7 ret.agregar_barra(Barra(1, 7, *props)) # 8 ret.agregar_barra(Barra(0, 8, *props)) # 9 ret.agregar_barra(Barra(1, 8, *props)) # 10 ret.agregar_barra(Barra(2, 8, *props)) # 11 ret.agregar_barra(Barra(1, 9, *props)) # 12 ret.agregar_barra(Barra(2, 9, *props)) # 13 ret.agregar_barra(Barra(3, 9, *props)) # 14 ret.agregar_barra(Barra(2, 10, *props)) # 15 ret.agregar_barra(Barra(4, 7, *props)) # 16 ret.agregar_barra(Barra(0, 4, *props)) # 17 ret.agregar_barra(Barra(4, 8, *props)) # 18 ret.agregar_barra(Barra(1, 4, *props)) # 19 ret.agregar_barra(Barra(5, 8, *props)) # 20 ret.agregar_barra(Barra(1, 5, *props)) # 21 ret.agregar_barra(Barra(5, 9, *props)) # 22 ret.agregar_barra(Barra(2, 5, *props)) # 23 ret.agregar_barra(Barra(6, 9, *props)) # 24 ret.agregar_barra(Barra(2, 6, *props)) # 25 ret.agregar_barra(Barra(6, 10, *props)) # 26 ret.agregar_barra(Barra(3, 6, *props)) # 27 ret.agregar_barra(Barra(4, 5, *props)) # 28 ret.agregar_barra(Barra(5, 6, *props)) # 29 ret.agregar_restriccion(0, 0, 0) ret.agregar_restriccion(0, 1, 0) ret.agregar_restriccion(0, 2, 0) ret.agregar_restriccion(7, 0, 0) ret.agregar_restriccion(7, 1, 0) ret.agregar_restriccion(7, 2, 0) ret.agregar_restriccion(3, 1, 0) ret.agregar_restriccion(3, 2, 0) ret.agregar_restriccion(10, 1, 0) ret.agregar_restriccion(10, 2, 0) qL1 = -qL*(7.5*m**2)* 9.8 qL2 = -qL*(15*m**2)* 9.8 ret.agregar_fuerza(0, 2, qL1) ret.agregar_fuerza(3, 2, qL1) ret.agregar_fuerza(7, 2, qL1) ret.agregar_fuerza(10, 2, qL1) ret.agregar_fuerza(1, 2, qL2) ret.agregar_fuerza(2, 2, qL2) ret.agregar_fuerza(8, 2, qL2) ret.agregar_fuerza(9, 2, qL2) return ret
def caso_L(): # Unidades base m = 1. kg = 1. s = 1. #Unidades derivadas N = kg * m / s**2 cm = 0.01 * m mm = 0.001 * m KN = 1000 * N Pa = N / m**2 KPa = 1000 * Pa MPa = 1000 * KPa GPa = 1000 * MPa #Parametros L = 5.0 * m F1 = 9.8 * KN F2 = 19.6 * KN B = 2.0 * m H = 3.5 * m #Inicializar modelo ret = Reticulado() #Nodos ret.agregar_nodo(0, 0, 0) #0 ret.agregar_nodo(L, 0, 0) #1 ret.agregar_nodo(2 * L, 0, 0) #2 ret.agregar_nodo(3 * L, 0, 0) #3 ret.agregar_nodo(L / 2, B / 2, H) #4 ret.agregar_nodo(3 * L / 2, B / 2, H) #5 ret.agregar_nodo(5 * L / 2, B / 2, H) #6 ret.agregar_nodo(0, B, 0) #7 ret.agregar_nodo(L, B, 0) #8 ret.agregar_nodo(2 * L, B, 0) #9 ret.agregar_nodo(3 * L, B, 0) #10 #Barras r = 8 * cm A = 3.141592 * (r)**2 t = 5 * mm props = [r, t, 200 * GPa, 0 * kg / m**3, 420 * MPa] ret.agregar_barra(Barra(0, 1, *props)) # 0 ret.agregar_barra(Barra(0, 4, *props)) ret.agregar_barra(Barra(0, 7, *props)) ret.agregar_barra(Barra(0, 8, *props)) ret.agregar_barra(Barra(1, 2, *props)) ret.agregar_barra(Barra(1, 4, *props)) ret.agregar_barra(Barra(1, 5, *props)) ret.agregar_barra(Barra(1, 7, *props)) ret.agregar_barra(Barra(1, 8, *props)) ret.agregar_barra(Barra(1, 9, *props)) ret.agregar_barra(Barra(2, 3, *props)) ret.agregar_barra(Barra(2, 5, *props)) ret.agregar_barra(Barra(2, 6, *props)) ret.agregar_barra(Barra(2, 8, *props)) ret.agregar_barra(Barra(2, 9, *props)) ret.agregar_barra(Barra(2, 10, *props)) ret.agregar_barra(Barra(3, 6, *props)) ret.agregar_barra(Barra(3, 9, *props)) ret.agregar_barra(Barra(3, 10, *props)) ret.agregar_barra(Barra(4, 5, *props)) ret.agregar_barra(Barra(4, 7, *props)) ret.agregar_barra(Barra(4, 8, *props)) ret.agregar_barra(Barra(5, 6, *props)) ret.agregar_barra(Barra(5, 8, *props)) ret.agregar_barra(Barra(5, 9, *props)) ret.agregar_barra(Barra(6, 9, *props)) ret.agregar_barra(Barra(6, 10, *props)) ret.agregar_barra(Barra(7, 8, *props)) ret.agregar_barra(Barra(8, 9, *props)) ret.agregar_barra(Barra(9, 10, *props)) ret.agregar_restriccion(0, 0, 0) ret.agregar_restriccion(0, 1, 0) ret.agregar_restriccion(0, 2, 0) ret.agregar_restriccion(7, 0, 0) ret.agregar_restriccion(7, 1, 0) ret.agregar_restriccion(7, 2, 0) ret.agregar_restriccion(3, 1, 0) ret.agregar_restriccion(10, 1, 0) ret.agregar_restriccion(3, 2, 0) ret.agregar_restriccion(10, 2, 0) ret.agregar_fuerza(0, 2, -F1) ret.agregar_fuerza(3, 2, -F1) ret.agregar_fuerza(7, 2, -F1) ret.agregar_fuerza(10, 2, -F1) ret.agregar_fuerza(1, 2, -F2) ret.agregar_fuerza(2, 2, -F2) ret.agregar_fuerza(8, 2, -F2) ret.agregar_fuerza(9, 2, -F2) return ret
def caso_D(): # Unidades base m = 1. kg = 1. s = 1. #Unidades derivadas N = kg * m / s**2 cm = 0.01 * m mm = 0.001 * m KN = 1000 * N Pa = N / m**2 KPa = 1000 * Pa MPa = 1000 * KPa GPa = 1000 * MPa #Parametros L = 5.0 * m F = 100 * KN B = 2.0 * m #Inicializar modelo ret = Reticulado() #Nodos ret.agregar_nodo(0, 0, 0) ret.agregar_nodo(L, 0, 0) ret.agregar_nodo(2 * L, 0, 0) ret.agregar_nodo(L / 2, B / 2, sqrt(3) / 2 * L) ret.agregar_nodo(3 * L / 2, B / 2, sqrt(3) / 2 * L) ret.agregar_nodo(0, B, 0) ret.agregar_nodo(L, B, 0) ret.agregar_nodo(2 * L, B, 0) #Barras A = (1.1 * cm)**2 r = sqrt(A / 3.141593) props = [r, r, 200 * GPa, 7600 * kg / m**3, 420 * MPa] # props2 = [0.6*r, 0.6*r, 200*GPa, 7600*kg/m**3, 420*MPa] ret.agregar_barra(Barra(0, 1, *props)) # 0 ret.agregar_barra(Barra(1, 2, *props)) # 1 ret.agregar_barra(Barra(3, 4, *props)) # 2 ret.agregar_barra(Barra(0, 3, *props)) # 3 ret.agregar_barra(Barra(3, 1, *props)) # 4 ret.agregar_barra(Barra(1, 4, *props)) # 5 ret.agregar_barra(Barra(4, 2, *props)) # 6 ret.agregar_barra(Barra(5, 6, *props)) # 7 ret.agregar_barra(Barra(6, 7, *props)) # 8 ret.agregar_barra(Barra(5, 3, *props)) # 9 ret.agregar_barra(Barra(3, 6, *props)) # 10 ret.agregar_barra(Barra(6, 4, *props)) # 11 ret.agregar_barra(Barra(4, 7, *props)) # 12 ret.agregar_barra(Barra(0, 5, *props)) # 13 ret.agregar_barra(Barra(1, 6, *props)) # 14 ret.agregar_barra(Barra(2, 7, *props)) # 15 ret.agregar_barra(Barra(0, 6, *props)) # 16 ret.agregar_barra(Barra(6, 2, *props)) # 17 ret.agregar_barra(Barra(5, 1, *props)) # 18 ret.agregar_barra(Barra(1, 7, *props)) # 19 # ver_reticulado_3d(ret) ret.agregar_restriccion(0, 0, 0) ret.agregar_restriccion(0, 1, 0) ret.agregar_restriccion(0, 2, 0) ret.agregar_restriccion(2, 2, 0) ret.agregar_restriccion(5, 2, 0) ret.agregar_restriccion(7, 2, 0) ret.agregar_restriccion(5, 0, 0) return ret
def caso_L(): # Unidades base m = 1. kg = 1. s = 1. #Unidades derivadas N = kg * m / s**2 cm = 0.01 * m mm = 0.001 * m KN = 1000 * N kgf = 9.80665 * N Pa = N / m**2 KPa = 1000 * Pa MPa = 1000 * KPa GPa = 1000 * MPa #Parametros L = 5.0 * m B = 2.0 * m H = 3.5 * m q = 400 * kgf / m**2 F = q * L * B F = F / 4 #Inicializar modelo ret = Reticulado() #Nodos ret.agregar_nodo(0, 0, 0) #0 ret.agregar_nodo(L, 0, 0) #1 ret.agregar_nodo(2 * L, 0, 0) #2 ret.agregar_nodo(3 * L, 0, 0) #3 ret.agregar_nodo(L / 2, B / 2, H) #4 ret.agregar_nodo(3 * L / 2, B / 2, H) #5 ret.agregar_nodo(5 * L / 2, B / 2, H) #6 ret.agregar_nodo(0, B, 0) #7 ret.agregar_nodo(L, B, 0) #8 ret.agregar_nodo(2 * L, B, 0) #9 ret.agregar_nodo(3 * L, B, 0) #10 #Barras R = 8 * cm t = 5 * mm props = [R, t, 200 * GPa, 0 * kg / m**3, 420 * MPa] ret.agregar_barra(Barra(0, 1, *props)) # 0 ret.agregar_barra(Barra(1, 2, *props)) # 1 ret.agregar_barra(Barra(2, 3, *props)) # 2 ret.agregar_barra(Barra(3, 10, *props)) # 3 ret.agregar_barra(Barra(10, 9, *props)) # 4 ret.agregar_barra(Barra(9, 8, *props)) # 5 ret.agregar_barra(Barra(8, 7, *props)) # 6 ret.agregar_barra(Barra(7, 0, *props)) # 7 ret.agregar_barra(Barra(8, 1, *props)) # 8 ret.agregar_barra(Barra(9, 2, *props)) # 9 ret.agregar_barra(Barra(7, 4, *props)) # 10 ret.agregar_barra(Barra(0, 4, *props)) # 11 ret.agregar_barra(Barra(1, 4, *props)) # 12 ret.agregar_barra(Barra(8, 4, *props)) # 13 ret.agregar_barra(Barra(1, 5, *props)) # 14 ret.agregar_barra(Barra(2, 5, *props)) # 15 ret.agregar_barra(Barra(9, 5, *props)) # 16 ret.agregar_barra(Barra(8, 5, *props)) # 17 ret.agregar_barra(Barra(2, 6, *props)) # 18 ret.agregar_barra(Barra(3, 6, *props)) # 19 ret.agregar_barra(Barra(10, 6, *props)) # 20 ret.agregar_barra(Barra(9, 6, *props)) # 21 ret.agregar_barra(Barra(0, 8, *props)) # 2 ret.agregar_barra(Barra(1, 7, *props)) # 23 ret.agregar_barra(Barra(1, 9, *props)) # 24 ret.agregar_barra(Barra(2, 8, *props)) # 25 ret.agregar_barra(Barra(2, 10, *props)) # 26 ret.agregar_barra(Barra(3, 9, *props)) # 27 ret.agregar_barra(Barra(4, 5, *props)) # 28 ret.agregar_barra(Barra(5, 6, *props)) # 29 # Restricciones: Parte izquierda del reticulado es fija, y parte derecha es deslizante # Nodos 3 y 10 no desplazamiento en y,z....x libre ret.agregar_restriccion(10, 1, 0) ret.agregar_restriccion(10, 2, 0) ret.agregar_restriccion(3, 1, 0) ret.agregar_restriccion(3, 2, 0) #Nodo 7 y 0 son fijos ret.agregar_restriccion(7, 0, 0) ret.agregar_restriccion(7, 1, 0) ret.agregar_restriccion(7, 2, 0) ret.agregar_restriccion(0, 0, 0) ret.agregar_restriccion(0, 1, 0) ret.agregar_restriccion(0, 2, 0) ret.agregar_fuerza(0, 2, -F) ret.agregar_fuerza(1, 2, -2 * F) ret.agregar_fuerza(2, 2, -2 * F) ret.agregar_fuerza(3, 2, -F) ret.agregar_fuerza(7, 2, -F) ret.agregar_fuerza(8, 2, -2 * F) ret.agregar_fuerza(9, 2, -2 * F) ret.agregar_fuerza(10, 2, -F) return ret
def caso_L(): # Unidades base m = 1. kg = 1. s = 1. #Unidades derivadas N = kg*m/s**2 cm = 0.01*m mm = 0.001*m KN = 1000*N KGF = 9.8067*N Pa = N / m**2 KPa = 1000*Pa MPa = 1000*KPa GPa = 1000*MPa #Parametros L = 5.0 * m F = 100 * KN B = 2.0 * m H = 3.5 * m q = 400 * kg / m**2 #Inicializar modelo ret = Reticulado() #Nodos ret.agregar_nodo(0 , 0 , 0 ) #NODO 0 ret.agregar_nodo(L , 0 , 0 ) #NODO 1 ret.agregar_nodo(2*L , 0 , 0 ) #NODO 2 ret.agregar_nodo(3*L , 0 , 0 ) #NODO 3 ret.agregar_nodo(L/2 , B/2 , H ) #NODO 4 ret.agregar_nodo(3*L/2 , B/2 , H ) #NODO 5 ret.agregar_nodo(5*L/2 , B/2 , H ) #NODO 6 ret.agregar_nodo(0 , B , 0 ) #NODO 7 ret.agregar_nodo(L , B , 0 ) #NODO 8 ret.agregar_nodo(2*L , B , 0 ) #NODO 9 ret.agregar_nodo(3*L , B , 0 ) #NODO 10 #Barras # A = (1.1*cm)**2 # r = sqrt(A/3.141593) R = 8*cm t = 5*mm " R t E ρ σy" props = [R, t, 200*GPa, 0*7600*kg/m**3, 420*MPa] # ------------------------------------ # BARRAS LONGITUDINALES INFERIORES ret.agregar_barra(Barra(0, 1, *props)) # BARRA 0 ret.agregar_barra(Barra(1, 2, *props)) # BARRA 1 ret.agregar_barra(Barra(2, 3, *props)) # BARRA 2 ret.agregar_barra(Barra(7, 8, *props)) # BARRA 3 ret.agregar_barra(Barra(8, 9, *props)) # BARRA 4 ret.agregar_barra(Barra(9, 10, *props)) # BARRA 5 # BARRAS TRANSVERSALES INFERIORES ret.agregar_barra(Barra(0, 7, *props)) # BARRA 6 ret.agregar_barra(Barra(1, 8, *props)) # BARRA 7 ret.agregar_barra(Barra(2, 9, *props)) # BARRA 8 ret.agregar_barra(Barra(3, 10, *props)) # BARRA 9 # BARRAS DIAGONALES CRUZADAS INFERIORES ret.agregar_barra(Barra(1, 7, *props)) # BARRA 10 ret.agregar_barra(Barra(2, 8, *props)) # BARRA 11 ret.agregar_barra(Barra(3, 9, *props)) # BARRA 12 ret.agregar_barra(Barra(0, 8, *props)) # BARRA 13 ret.agregar_barra(Barra(1, 9, *props)) # BARRA 14 ret.agregar_barra(Barra(2, 10, *props)) # BARRA 15 # BARRAS DIAGONALES SUPERIORES ret.agregar_barra(Barra(4, 7, *props)) # BARRA 16 ret.agregar_barra(Barra(5, 8, *props)) # BARRA 17 ret.agregar_barra(Barra(6, 9, *props)) # BARRA 18 ret.agregar_barra(Barra(0, 4, *props)) # BARRA 19 ret.agregar_barra(Barra(1, 5, *props)) # BARRA 20 ret.agregar_barra(Barra(2, 6, *props)) # BARRA 21 ret.agregar_barra(Barra(4, 8, *props)) # BARRA 22 ret.agregar_barra(Barra(5, 9, *props)) # BARRA 23 ret.agregar_barra(Barra(6, 10, *props)) # BARRA 24 ret.agregar_barra(Barra(1, 4, *props)) # BARRA 25 ret.agregar_barra(Barra(2, 5, *props)) # BARRA 26 ret.agregar_barra(Barra(3, 6, *props)) # BARRA 27 # BARRAS LONGITUDINALES SUPERIORES ret.agregar_barra(Barra(4, 5, *props)) # BARRA 28 ret.agregar_barra(Barra(5, 6, *props)) # BARRA 29 # ------------------------------------ # RESTRICCIONES EN LOS NODOS ret.agregar_restriccion(0, 0, 0) ret.agregar_restriccion(0, 1, 0) ret.agregar_restriccion(0, 2, 0) ret.agregar_restriccion(7, 0, 0) ret.agregar_restriccion(7, 1, 0) ret.agregar_restriccion(7, 2, 0) ret.agregar_restriccion(3, 1, 0) ret.agregar_restriccion(3, 2, 0) ret.agregar_restriccion(10, 1, 0) ret.agregar_restriccion(10, 2, 0) # ------------------------------------ # FUERZAS F_int = L*B/2*q*KGF F_ext = L/2*B/2*q*KGF ret.agregar_fuerza(0, 2, -F_ext) ret.agregar_fuerza(1, 2, -F_int) ret.agregar_fuerza(2, 2, -F_int) ret.agregar_fuerza(3, 2, -F_ext) ret.agregar_fuerza(7, 2, -F_ext) ret.agregar_fuerza(8, 2, -F_int) ret.agregar_fuerza(9, 2, -F_int) ret.agregar_fuerza(10, 2, -F_ext) return ret
def caso_L(): # Unidades base m = 1. kg = 1. s = 1. #Unidades derivadas N = kg * m / s**2 cm = 0.01 * m mm = 0.001 * m KN = 1000 * N Pa = N / m**2 KPa = 1000 * Pa MPa = 1000 * KPa GPa = 1000 * MPa #Parametros # L = 5.0 *m # F = 100*KN # B = 2.0 *m #Parametros cargas vivas Q = 400 * (kg / (m**2)) g = 9.81 * (m / (s**2)) A0 = 2.5 * (m**2) A1 = 5 * (m**2) #Inicializar modelo ret = Reticulado() #Nodos ret.agregar_nodo(0, 0, 0) #0 ret.agregar_nodo(5, 0, 0) #1 ret.agregar_nodo(10, 0, 0) #2 ret.agregar_nodo(15, 0, 0) #3 ret.agregar_nodo(2.5, 1, 3.5) #4 ret.agregar_nodo(7.5, 1, 3.5) #5 ret.agregar_nodo(12.5, 1, 3.5) #6 ret.agregar_nodo(0, 2, 0) #7 ret.agregar_nodo(5, 2, 0) #8 ret.agregar_nodo(10, 2, 0) #9 ret.agregar_nodo(15, 2, 0) #10 #Barras """ PREGUNTAR, PARECIERA SER QUE ES UNA BARRA CUADRADA """ # A = (8*cm)**2 # r = sqrt(A/3.141593) r = 8 * cm t = 5 * mm """ REVISAR EN PROPS R,R DEBERIA SER R,T """ props = [r, t, 200 * GPa, 0 * 7600 * kg / m**3, 420 * MPa] ret.agregar_barra(Barra(0, 1, *props)) # 1 ret.agregar_barra(Barra(1, 2, *props)) # 2 ret.agregar_barra(Barra(2, 3, *props)) # 3 ret.agregar_barra(Barra(3, 10, *props)) # 4 ret.agregar_barra(Barra(9, 10, *props)) # 5 ret.agregar_barra(Barra(8, 9, *props)) # 6 ret.agregar_barra(Barra(7, 8, *props)) # 7 ret.agregar_barra(Barra(0, 7, *props)) # 8 ret.agregar_barra(Barra(1, 7, *props)) # 9 ret.agregar_barra(Barra(0, 8, *props)) # 10 ret.agregar_barra(Barra(1, 8, *props)) # 11 ret.agregar_barra(Barra(2, 8, *props)) # 12 ret.agregar_barra(Barra(1, 9, *props)) # 13 ret.agregar_barra(Barra(2, 9, *props)) # 14 ret.agregar_barra(Barra(3, 9, *props)) # 15 ret.agregar_barra(Barra(2, 10, *props)) # 16 ret.agregar_barra(Barra(4, 7, *props)) # 17 ret.agregar_barra(Barra(0, 4, *props)) # 18 ret.agregar_barra(Barra(4, 8, *props)) # 19 ret.agregar_barra(Barra(1, 4, *props)) # 20 ret.agregar_barra(Barra(5, 8, *props)) # 21 ret.agregar_barra(Barra(1, 5, *props)) # 22 ret.agregar_barra(Barra(5, 9, *props)) # 23 ret.agregar_barra(Barra(2, 5, *props)) # 24 ret.agregar_barra(Barra(6, 9, *props)) # 25 ret.agregar_barra(Barra(2, 6, *props)) # 26 ret.agregar_barra(Barra(6, 10, *props)) # 27 ret.agregar_barra(Barra(3, 6, *props)) # 28 ret.agregar_barra(Barra(4, 5, *props)) # 29 ret.agregar_barra(Barra(5, 6, *props)) # 30 # nodo 1 ret.agregar_restriccion(0, 0, 0) ret.agregar_restriccion(0, 1, 0) ret.agregar_restriccion(0, 2, 0) # nodo 7 ret.agregar_restriccion(7, 0, 0) ret.agregar_restriccion(7, 1, 0) ret.agregar_restriccion(7, 2, 0) # nodo 3 ret.agregar_restriccion(3, 1, 0) ret.agregar_restriccion(3, 2, 0) # nodo 10 ret.agregar_restriccion(10, 1, 0) ret.agregar_restriccion(10, 2, 0) # Carga viva en nodos ret.agregar_fuerza(0, 2, -Q * A0 * g) ret.agregar_fuerza(7, 2, -Q * A0 * g) ret.agregar_fuerza(3, 2, -Q * A0 * g) ret.agregar_fuerza(10, 2, -Q * A0 * g) ret.agregar_fuerza(1, 2, -Q * A1 * g) ret.agregar_fuerza(2, 2, -Q * A1 * g) ret.agregar_fuerza(8, 2, -Q * A1 * g) ret.agregar_fuerza(9, 2, -Q * A1 * g) return ret
ret.agregar_nodo(L / 2, B / 2, h) #4 ret.agregar_nodo(3 * L / 2, B / 2, h) #5 ret.agregar_nodo(5 * L / 2, B / 2, h) #6 ret.agregar_nodo(0, B, 0) #7 ret.agregar_nodo(L, B, 0) #8 ret.agregar_nodo(2 * L, B, 0) #9 ret.agregar_nodo(3 * L, B, 0) #10 #Barras R = 8 * cm t = 5 * mm #, R, t, E, ρ, σy props = [R, t, 200 * GPa, 7850 * kg / m**3, 360 * MPa] ret.agregar_barra(Barra(0, 1, *props)) # 0 ret.agregar_barra(Barra(1, 2, *props)) # 1 ret.agregar_barra(Barra(2, 3, *props)) # 2 ret.agregar_barra(Barra(3, 10, *props)) # 3 ret.agregar_barra(Barra(9, 10, *props)) # 4 ret.agregar_barra(Barra(8, 9, *props)) # 5 ret.agregar_barra(Barra(7, 8, *props)) # 6 ret.agregar_barra(Barra(0, 7, *props)) # 7 ret.agregar_barra(Barra(1, 7, *props)) # 8 ret.agregar_barra(Barra(0, 8, *props)) # 9 ret.agregar_barra(Barra(1, 8, *props)) # 10 ret.agregar_barra(Barra(2, 8, *props)) # 11 ret.agregar_barra(Barra(1, 9, *props)) # 12 ret.agregar_barra(Barra(2, 9, *props)) # 13 ret.agregar_barra(Barra(3, 9, *props)) # 14 ret.agregar_barra(Barra(2, 10, *props)) # 15
ret.agregar_nodo(L / 2, B / 2, sqrt(3) / 2 * L) ret.agregar_nodo(3 * L / 2, B / 2, sqrt(3) / 2 * L) ret.agregar_nodo(0, B, 0) ret.agregar_nodo(L, B, 0) ret.agregar_nodo(2 * L, B, 0) #Barras A = (1.1 * cm)**2 r = sqrt(A / 3.141593) props = [r, r, 200 * GPa, 7600 * kg / m**3, 420 * MPa] props2 = [r, r, 200 * GPa, 7600 * kg / m**3, 420 * MPa] # props2 = [0.6*r, 0.6*r, 200*GPa, 7600*kg/m**3, 420*MPa] ret.agregar_barra(Barra(0, 1, *props)) # 0 ret.agregar_barra(Barra(1, 2, *props)) # 1 ret.agregar_barra(Barra(3, 4, *props)) # 2 ret.agregar_barra(Barra(0, 3, *props2)) # 3 ret.agregar_barra(Barra(3, 1, *props2)) # 4 ret.agregar_barra(Barra(1, 4, *props2)) # 5 ret.agregar_barra(Barra(4, 2, *props)) # 6 ret.agregar_barra(Barra(5, 6, *props)) # 7 ret.agregar_barra(Barra(6, 7, *props)) # 8 ret.agregar_barra(Barra(5, 3, *props2)) # 9 ret.agregar_barra(Barra(3, 6, *props2)) # 10 ret.agregar_barra(Barra(6, 4, *props2)) # 11 ret.agregar_barra(Barra(4, 7, *props)) # 12 ret.agregar_barra(Barra(0, 5, *props)) # 13 ret.agregar_barra(Barra(1, 6, *props)) # 14 ret.agregar_barra(Barra(2, 7, *props)) # 15
#Nodos ret.agregar_nodo(0,0) ret.agregar_nodo(L,0) ret.agregar_nodo(2*L,0) ret.agregar_nodo(L/2,sqrt(3)/2*L) ret.agregar_nodo(3*L/2,sqrt(3)/2*L) #Barras A = (1.1*cm)**2 r = sqrt(A/3.141593) props = [r, r, 200*GPa, 0*7600*kg/m**3, 420*MPa] ret.agregar_barra(Barra(0, 1, *props)) ret.agregar_barra(Barra(1, 2, *props)) ret.agregar_barra(Barra(3, 4, *props)) ret.agregar_barra(Barra(0, 3, *props)) ret.agregar_barra(Barra(3, 1, *props)) ret.agregar_barra(Barra(1, 4, *props)) ret.agregar_barra(Barra(4, 2, *props)) ret.agregar_restriccion(0, 0, 0) ret.agregar_restriccion(0, 1, 0) ret.agregar_restriccion(2, 1, 0) ret.agregar_fuerza(4, 1, -F) ret.ensamblar_sistema() ret.resolver_sistema()