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()
