miércoles, 25 de marzo de 2020

Teoria Unidad 2 Graficación


2.1 Trazo de líneas rectas

Linea Recta:


En geometría euclidiana, la recta o la línea recta, se extiende en una misma dirección, existe en una sola dimensión y contiene infinitos puntos; está compuesta de infinitos segmentos (el fragmento de línea más corto que une dos puntos). También se describe como la sucesión continua e indefinida de puntos en una sola dimensión, es decir, no posee principio ni fin.







Algoritmo de Bresenham para trazar líneas

El algoritmo de Bresenham es un algoritmo creado para dibujar rectas en los dispositivos de gráficos rasterizados, como por ejemplo un monitor de ordenador, que determina qué pixeles se rellenarán, en función de la inclinación del ángulo de la recta a dibujar.

Es un algoritmo preciso para la generación de líneas de ratreo que convierte mediante rastreo las líneas al utilizar solo cálculos incrementales con enteros que se pueden adaptar para desplegar circunferencias y curvas. Los ejes verticales muestran las posiciones de rastreo y los ejes horizontales identifican columnas de pixel.

Si 0<|m|<1

*Se capturan los extremos de la línea y se almacena el extremo izquierdo en (x0,y0).

*Se carga (x0,y0) en el bufer de estructura (se traza el primer punto)

*Se calculan las constantes Δx,Δy, 2Δy y 2Δy-Δx y se obtiene el valor inicial para el

parametro de decisión p0=2Δy-Δx.

Para j=0 mientras j<Δx

*En cada xk a lo largo de la línea, que inicia en k=0 se efectúa la prueba siguiente:

Si pk<0

*Trazamos (xk+1,yk).

*Asignamos pk+1= pk+2Δy.

Sino

*Trazamos (xk+1,yk+1).

*Asignamos pk+1= pk+2Δy-2Δx.

Fin Para

Si |m|>1

*Recorremos la dirección en pasos unitarios y calculamos los valores sucesivos 

de x que se aproximen más a la trayectoria de la línea.







2.2 Representación y trazo de polígonos



Polígono
Un polígono es una figura bidimensional compuesta por una secuencia finita de segmentos rectos consecutivos que cierran una región en el espacio. Estos segmentos son llamados lados, y los puntos en que se intersecan se llaman vértices. El interior del polígono es llamado área.




Polígono
(lados rectos)
No es un polígono
(tiene una curva)

No
 es un polígono
(abierto, no cerrado)



Tipos de polígonos

· Simple o complejo

Un polígono simple sólo tiene un borde que no se cruza con él mismo. Uno complejo se interseca consigo mismo.

Polígono simple
(este es un pentágono)
Polígono complejo
(también es un pentágono)



· Cóncavo o convexo

Un polígono convexo no tiene ángulos que apunten hacia dentro. En concreto, los ángulos internos no son mayores que 180°.

Si hay algún ángulo interno mayor que 180° entonces es cóncavo.

Convexo
Cóncavo


· Regular o irregular

Si todos los ángulos son iguales y los lados también, es regular, si no es irregular


Regular
Irregular



2.3 Transformación bidimensional



2.3.1 Traslación



Una traslación es el movimiento en línea recta de un objeto de una posición a otra.

Se traslada cada punto P(x,y) dx unidades paralelamente al eje x y dy unidades paralelamente al eje y, hacia el nuevo punto P'(x',y').
Las ecuaciones quedan:



Si se definen los vectores columna queda:


Entonces la ecuación 1 puede ser expresada como:


Una forma de efectuar la traslación de un objeto es aplicándole a cada punto del mismo la ecuación 1. Para trasladar todos los puntos de una línea, simplemente se traslada los puntos extremos.








En la figura se muestra el efecto de trasladar un objeto 3 unidades en x y -4 unidades en y.

Esto se cumple también para el escalamiento y la rotación.







2.3.2 Escalamiento


Una transformación para alterar el tamaño de un objeto se denomina escalación.
Dependiendo del factor de escalación el objeto sufrirá un cambio en su tamaño pasando a ser mayor, o menor en su segmento de longitud.

El escalamiento se hace con un factor sx en el eje x y en un factor sy en el eje y. Escalamiento uniforme sx = sy
Escalamiento diferencial.
La transformación de escalamiento puede expresarse con las siguientes multiplicaciones



En forma matricial






Se escala a ½ en el eje x y a ¼ en el eje y . 

El escalamiento se efectúa con respecto al origen;








2.3.3 Rotación


Para rotar un objeto (en este caso bidimensional), se ha de determinar la cantidad de grados en la que ha de rotarse la figura. Para ello, y sin ningún tipo de variación sobre la figura, la cantidad de ángulo ha de ser constante sobre todos los puntos.

Los puntos también pueden ser rotados un ángulo θ con respecto al origen





En forma matricial




En la figura se muestra la rotación de la casa 45º, con respecto al origen.








2.4 Representación matricial


En las aplicaciones de diseño y de creación de imágenes, realizamos traslaciones, rotaciones y escalaciones para ajustar los componentes de la imagen en sus posiciones apropiadas. En este tema consideramos cómo se pueden volver a formular las representaciones de la matriz de modo que se pueden procesar de manera eficiente esas secuencias de transformación. Es posible expresar cada una de las transformaciones básicas en la forma de matriz general con las posiciones de coordenadas P y P’ representadas como columnas de vector.

Con las representaciones de matriz podemos establecer una matriz para cualquier secuencia de transformaciones como una matriz de transformación compuesta al calcular el producto de la matriz de las transformaciones individuales. La creación de productos de matrices de transformación a menudo se conoce como concatenación o composición de matrices.

· Traslaciones

Se se aplican dos vectores de traslación sucesivos (tx1, t y1) y (tx2 , t y2 ) en la posición de coordenadas P, la localización transformada final P, la localización transformada final P’ se calcula como: P'=T(t x2,t2)·T(tx1,ty1)·P}{=T(tx2, 2)·T(t x1,t y1)}{·P

Donde se representan P y P’ como vectores de columna de coordenadas homogéneas. Podemos verificar este resultado al calcular el producto de la matriz para las dos agrupaciones asociativas. Asimismo, la matriz de transformación compuesta para esta secuencia de transformaciones.

· Rotaciones

Dos rotaciones sucesivas que se aplican en el punto P producen la posición transformada P'=R(θ2)·R(θ1){·P}=R(θ2){· (θ1)}·P

Al multiplicar las dos matrices de rotación, podemos verificar que dos rotaciones sucesivas son aditivas

· Escalamiento

La siguiente figura ilustra una secuencia de transformación para producir escalación con respecto de una posición fija seleccionada (xf,f) al utilizar una función de escalación que sólo puede escalar en relación con el origen de las coordenadas





Propiedades de concatenación



La multiplicación de matrices es asociativa. Para tres matrices cualesquiera A, B y C, el producto matricial A·B·C se puede llevar a cabo al multiplicar primero a por B o multiplicar primero B por C:2.35.A · BC=( A· B)·C =A·( B·C)

Por tanto, podemos evaluar los productos matriciales al utilizar una agrupación asociativa ya sea de izquierda a derecha o de derecha a izquierda. Por otro lado, los productos de la transformación tal vez no sean conmutativos. En general el producto matricial A·B no es igual que B·A. Esto significa queremos trasladar y girar un objeto, debemos tener cuidado sobre el sentido en que se evalúa la matriz compuesta.





2.5 Ventana y puerto de visión



Un área rectangular que se especifica en coordenadas mundiales se denomina ventana. El área rectangular en el dispositivo de despliegue en el cual se coloca la ventana se llama puerta de visión. La figura ilustra el trazo o planimetría de la selección de una imagen que queda dentro del área de ventana en una puerta de visión designada. Esta planimetría se llama transformación de la visión o bien transformación de normalización.





Los límites de la ventana se especifican en coordenadas mundiales. Las coordenadas de dispositivo normalizadas se usan con mayor frecuencia para la especificación de la puerta visión, aunque las coordenadas del dispositivo pueden emplearse si hay solamente un dispositivo de salida en el sistemas. Cuando se usan coordenadas de dispositivo normalizadas, el programador considera el dispositivo de salida como aquel que tiene valores coordenados dentro del intervalo de 0 a 1.


Las posiciones de coordenadas que se expresan en coordenadas de dispositivo normalizadas deben convertirse a las coordenadas del dispositivo antes de que un dispositivo de salida específico haga el despliegue. Una rutina específica del dispositivo se incluye en paquetes de gráficas con este fin. La ventaja de emplear coordenadas de dispositivo normalizadas es que el paquete de gráficas es considerablemente independiente del dispositivo. Pueden utilizarse distintos dispositivos de salida ofreciendo los conductores adecuados del dispositivo.

Cambiando la posición de la puerta de visión, los objetos pueden desplegarse en diferentes posiciones en un dispositivo de salida. Asimismo, variando el tamaño de las puertas de visión, el tamaño y las proporciones de los objetos pueden alterarse. Cuando se trazan en forma sucesiva ventanas de diferentes tamaños en una puerta de visión, pueden lograrse efectos de acercamiento. Conforme las ventanas se hacen pequeñas, un usuario puede lograr el acercamiento de alguna parte de una escena para visualizar detalles que no se muestran con las ventanas mayores.

Analógicamente, puede obtener un panorama general más amplio realizando un acercamiento de una sección de escena con ventanas cada vez más mayores. Los efectos de toma panorámica se producen moviendo o desplazando una ventana de tamaño fijo a través de una imagen grande.







Conclusiones :

En esta unidad aprendimos acerca de los gráficos 2D o bidimensionales. Éstos solo cuentan con 2 propiedades, largo y ancho, y en un plano, ocuparían los ejes x e y.

Un ejemplo muy de un grafo de una sola dimensión es una línea, que es una sucesión de puntos infinitos que cuenta con un punto inicial y un punto final.
Existen diversos algoritmos para trazar lineas rectas como el Analizador Diferencial Digital, pero uno mas especializado a lineas rectas es el algoritmo de Bresenham que determina que pixeles se rellenaran en función al grado de inclinación de la recta.

A partir de estas lineas rectas unidimensionales podemos crear figuras bidimensionales, como lo son los polígonos, los cuales están formados por lineas que encierran una determinada área. A las lineas que forman al polígono se les llama lados o aristas y al punto donde se unen dos lineas se llama vértice.

Existe una clasificación para polígonos, si son simples o complejos, cóncavos o convexos (ángulos) o regulares o irregulares (lados iguales). En este caso, para trazar polígonos en una computadora, es mas efectivo el algoritmo diferencial digital.

Los objetos bidimensionales pueden transformarse. Si cambian su posición en el plano, se le llama Traslación. Si aumenta o disminuye su tamaño, se llama Escalamiento. Si gira o cambia su posición respecto a los grados de algún punto, se llama Rotación.

Además, para poder visualizar determinada parte de algún objeto bidimensional, se hace uso de las ventanas o puerto de visión, los cuales, de determinado objeto creado, permite visualizar en el monitor un área seleccionada.

martes, 24 de marzo de 2020

Mi Proyecto Figura con Poligonos (POCION DE JUEGO MINECRAFT)




from tkinter import *

ventana = Tk()
ventana.title('Pocion de Minecraft')
c= Canvas(ventana, width=550,height=600)
ventana.geometry("550x600")
c.place(x=0,y=0)

c.create_rectangle(0,0,550,600,fill='#DA9F21')
c.create_rectangle(190,7,350,80,fill='black')
c.create_rectangle(190,75,150,40,fill='black')
c.create_rectangle(350,75,390,40,fill='black')

c.create_rectangle(350,75,390,40,fill='black')

##colores grisesc.create_rectangle(190,75,230,40,fill='#E5E3DA')
c.create_rectangle(230,75,275,40,fill='#D6D5D3')
c.create_rectangle(270,75,310,40,fill='#ADA79D')
c.create_rectangle(310,75,350,40,fill='#73706C')
##othersc.create_rectangle(190,75,230,110,fill='#D6D5D3')
c.create_rectangle(230,75,275,110,fill='#ADA79D')
c.create_rectangle(270,75,310,110,fill='#73706C')
c.create_rectangle(310,75,350,110,fill='#73706C')

##orillacelestexDc.create_rectangle(150,75,190,110,fill='#9BF3DE')
c.create_rectangle(390,75,350,110,fill='#9BF3DE')

c.create_rectangle(110,75,150,110,fill='black')
c.create_rectangle(390,75,430,110,fill='black')

c.create_rectangle(150,240,190,110,fill='black')
c.create_rectangle(390,240,350,110,fill='black')

c.create_rectangle(190,240,230,110,fill='#9BF3DE')
c.create_rectangle(230,240,275,110,fill='black')
c.create_rectangle(270,240,310,110,fill='black')
c.create_rectangle(310,240,350,110,fill='#9BF3DE')

c.create_rectangle(150,275,190,240,fill='#9BF3DE')
c.create_rectangle(390,275,350,240,fill='#9BF3DE')

c.create_rectangle(190,275,350,240,fill='black')

c.create_rectangle(110,275,150,240,fill='black')
c.create_rectangle(430,275,390,240,fill='black')

c.create_rectangle(110,275,150,310,fill='#9BF3DE')
c.create_rectangle(430,275,390,310,fill='#9BF3DE')

c.create_rectangle(70,275,110,310,fill='black')
c.create_rectangle(470,275,430,310,fill='black')

###azul del aguac.create_rectangle(150,275,390,310,fill='#2698EB')
c.create_rectangle(70,430,110,310,fill='#9BF3DE')
c.create_rectangle(470,430,430,310,fill='#9BF3DE')
c.create_rectangle(30,430,70,310,fill='black')
c.create_rectangle(510,430,470,310,fill='black')

c.create_rectangle(110,430,150,310,fill='#01309E')
c.create_rectangle(430,430,390,310,fill='#01309E')

c.create_rectangle(150,350,190,310,fill='#01309E')

c.create_rectangle(190,350,350,310,fill='#2698EB')
c.create_rectangle(190,390,350,350,fill='#01309E')
c.create_rectangle(350,350,390,310,fill='#01309E')

##qac.create_rectangle(150,430,190,350,fill='#01309E')
c.create_rectangle(150,390,190,350,fill='#388EDA')
c.create_rectangle(350,390,390,350,fill='#388EDA')
c.create_rectangle(350,390,390,350,fill='#388EDA')

c.create_rectangle(310,430,390,390,fill='#01309E')
c.create_rectangle(270,430,310,390,fill='#388EDA')
c.create_rectangle(230,430,270,390,fill='#01309E')
c.create_rectangle(190,430,230,390,fill='#388EDA')
##c.create_rectangle(70,470,110,430,fill='black')
c.create_rectangle(470,470,430,430,fill='black')

c.create_rectangle(110,470,150,430,fill='#9BF3DE')
c.create_rectangle(430,470,390,430,fill='#9BF3DE')
c.create_rectangle(150,470,390,430,fill='#01309E')

c.create_rectangle(110,510,150,470,fill='black')
c.create_rectangle(430,510,390,470,fill='black')
c.create_rectangle(150,510,390,470,fill='#9BF3DE')

c.create_rectangle(150,550,390,510,fill='black')

ventana.mainloop()

Juego del Gato con Tkinter Python 3.x


#-*- coding: utf-8 -*-from tkinter import *
from tkinter import messagebox
from tkinter import simpledialog


# Variables globales.ventanaPrincipal = Tk()
nombreJugador1 = ""                 # Variable que contendrá el nombre de un jugador.nombreJugador2 = ""                 # Variable que contendrá el nombre de un jugador.listaBotones = []                   # Lista/arreglo que almacenará cada uno de los botones del tablero de juego.casillas = []                       # Lista/arreglo que almacenará la elección de cada jugador.etiquetaTurnoJugador = StringVar()  # Declara una variable Tkinter(), de tipo cadena para mostrar el nombre del jugador.numeroJugador = 0                   # Variable para cambiar entre jugador según el turno correspondiente.

# Función para configurar el diseño de la ventana principal y sus elementos.def tablero():
    # Configuración de la ventana.    ventanaPrincipal.title("Juego del gato")    # Título de la ventana    ventanaPrincipal.geometry("370x460")        # Medidas de la ventana
    # Etiqueta en la que se muestra el nombre del jugador según sea su turno proporcionado por la variable turnoJugador    etiquetaTurno = Label(ventanaPrincipal, textvariable=etiquetaTurnoJugador, font='bold 16')
    etiquetaTurno.place(x=130, y=10)    # Coordenadas de posición en la ventana.
    # Botón de inicio del juego que ejecuta a la función iniciarJuego()    botonIniciar = Button(ventanaPrincipal, bg='blue', fg='white', text='Iniciar juego', cursor="sizing", width=15, height=3, command=lambda: iniciarJuego())
    botonIniciar.place(x=130, y=380)    # Coordenadas de posición en la ventana.
    # Lineas que dividen el tablero.    linea1 = Canvas(ventanaPrincipal, width=310, height=10)
    linea1.place(x=30, y=140)           # Coordenadas de posición en la ventana.    linea1.create_line(310, 0, 0, 0, width=25, fill='black')

    linea2 = Canvas(ventanaPrincipal, width=310, height=10)
    linea2.place(x=30, y=240)           # Coordenadas de posición en la ventana.    linea2.create_line(310, 0, 0, 0, width=25, fill='black')

    linea3 = Canvas(ventanaPrincipal, width=10, height=310)
    linea3.place(x=130, y=45)           # Coordenadas de posición en la ventana.    linea3.create_line(0, 310, 0, 0, width=25, fill='black')

    linea4 = Canvas(ventanaPrincipal, width=10, height=310)
    linea4.place(x=230, y=45)           # Coordenadas de posición en la ventana.    linea4.create_line(0, 310, 0, 0, width=25, fill='black')

    # Botones del tablero de juego que ejecutan la función selección() enviando un número que hace referencia a su posición.    boton0 = Button(ventanaPrincipal, width=9, height=3, relief=SOLID, cursor="pencil", command=lambda: selecion(0))
    listaBotones.append(boton0) # El botón se almacena en la lista de botones.    boton0.place(x=50, y=70)    # Coordenadas de posición en la ventana.
    boton1 = Button(ventanaPrincipal, width=9, height=3, relief=SOLID, cursor="pencil", command=lambda: selecion(1))
    listaBotones.append(boton1)  # El botón se almacena en la lista de botones.    boton1.place(x=150, y=70)    # Coordenadas de posición en la ventana.
    boton2 = Button(ventanaPrincipal, width=9, height=3, relief=SOLID, cursor="pencil", command=lambda: selecion(2))
    listaBotones.append(boton2)  # El botón se almacena en la lista de botones.    boton2.place(x=250, y=70)    # Coordenadas de posición en la ventana.
    boton3 = Button(ventanaPrincipal, width=9, height=3, relief=SOLID, cursor="pencil", command=lambda: selecion(3))
    listaBotones.append(boton3)  # El botón se almacena en la lista de botones.    boton3.place(x=50, y=170)    # Coordenadas de posición en la ventana.
    boton4 = Button(ventanaPrincipal, width=9, height=3, relief=SOLID, cursor="pencil", command=lambda: selecion(4))
    listaBotones.append(boton4)  # El botón se almacena en la lista de botones.    boton4.place(x=150, y=170)   # Coordenadas de posición en la ventana.
    boton5 = Button(ventanaPrincipal, width=9, height=3, relief=SOLID, cursor="pencil", command=lambda: selecion(5))
    listaBotones.append(boton5)  # El botón se almacena en la lista de botones.    boton5.place(x=250, y=170)   # Coordenadas de posición en la ventana.
    boton6 = Button(ventanaPrincipal, width=9, height=3, relief=SOLID, cursor="pencil", command=lambda: selecion(6))
    listaBotones.append(boton6)  # El botón se almacena en la lista de botones.    boton6.place(x=50, y=270)    # Coordenadas de posición en la ventana.
    boton7 = Button(ventanaPrincipal, width=9, height=3, relief=SOLID, cursor="pencil", command=lambda: selecion(7))
    listaBotones.append(boton7)  # El botón se almacena en la lista de botones.    boton7.place(x=150, y=270)   # Coordenadas de posición en la ventana.
    boton8 = Button(ventanaPrincipal, width=9, height=3, relief=SOLID, cursor="pencil", command=lambda: selecion(8))
    listaBotones.append(boton8)  # El botón se almacena en la lista de botones.    boton8.place(x=250, y=270)  # Coordenadas de posición en la ventana.
    # Se llena la lista -> casillas = [] con la letra "N" para que la lista tenga un tamaño de 9 elementos.    for i in range(0, 9):       # Ciclo en el que se le asignan valores a la variable "i" en un rango de 0 a 8.        casillas.append("N")    # Se almacena la letra N en la posición i de la lista/arreglo.

# Función para bloquear todos los botones del tablero según sea necesario.def bloquearInicio():
    for i in range(0, 9):                           # Ciclo en el que se le asignan valores a la variable "i" en un rango de 0 a 8.        listaBotones[i].config(state="disable")     # Se inhabilita el botón en la posición i de la lista/arreglo.

# Función para iniciar la ejecución del juego.def iniciarJuego():
    for i in range(0, 9):                           # Ciclo en el que se le asignan valores a la variable "i" en un rango de 0 a 8.        listaBotones[i].config(state="normal")      # Se habilita el botón en la posición i de la lista/arreglo.        listaBotones[i].config(bg="lightgray")      # Se le asigna un nuevo fondo al botón.        listaBotones[i].config(text="")             # Se le asigna una cadena de texto vacía al botón para limpiar cualquier texto anterior.        casillas[i] = "N"                           # Para no tener que reiniciar la ventana al volver a precionar el botón Iniciar juego.    print(casillas)

    global nombreJugador1, nombreJugador2           # Se llama a las variables globales a las que vamos a acceder.
    # Lanza una ventana de diálogo en la que se puede ingresar una cadena de texto, la cual se va almacenar en la variable.    # Se le envía como parametro el título de la ventana y un mensaje para mostrar.    nombreJugador1 = simpledialog.askstring("Jugador", "Escribe el nombre del jugador 1: ")
    nombreJugador2 = simpledialog.askstring("Jugador", "Escribe el nombre del jugador 2: ")

    # Comprobamos que no se hayan ingresado datos sin tipo a las variables de los nombres o cadenas vacías    # Si se cumple la condición anterior se concatena el contenido de nombreJugador1 a la etiqueta que muestra los turnos.    if ((nombreJugador1 and nombreJugador2) is not None) and ((nombreJugador1 and nombreJugador2)!=""):
        etiquetaTurnoJugador.set("Turno: " + nombreJugador1)
    else:
    #Si no se cumple la condición aparece una ventana informando el error, y se bloquea el inicio del juego.        messagebox.showwarning("Error", "Favor de llenar correctamente los nombres de usuario.")
        bloquearInicio()


# Función que slecciona y marca el botón (casilla) deacuerdo al turno y al jugador, recibiendo como parámetro el número del botón.def selecion(numero):
    global numeroJugador, nombreJugador1, nombreJugador2    # Se llama a las variables globales a las que vamos a acceder
    if numeroJugador == 0:                                  # Se verifica que la casilla contenga N y que sea el turno del jugador 0.        listaBotones[numero].config(text="X")               # Coloca X en el botón.        listaBotones[numero].config(bg="white")             # Cambia el fondo del botón.        casillas[numero] = "X"                              # Se almacena X en la lista casillas = []        numeroJugador = 1                                   # Cambia el turno del jugador.        etiquetaTurnoJugador.set("Turno: " + nombreJugador2)# La etiqueta cambia y muestra el nombre del otro jugador.        print (casillas)

    elif casillas[numero] == "N" and numeroJugador == 1:    # Se verifica que la casilla contenga N y que sea el turno del jugador 1.        listaBotones[numero].config(text="O")               # Coloca O en el botón.        listaBotones[numero].config(bg="lightblue")         # Cambia el fondo del botón.        casillas[numero] = "O"                              # Se almacena O en la lista casillas = []        numeroJugador = 0                                   # Cambia el turno del jugador.        etiquetaTurnoJugador.set("Turno: " + nombreJugador1)# La etiqueta cambia y muestra el nombre del otro jugador.        print (casillas)

    listaBotones[numero].config(state="disable")            # El botón seleccionado de acuerdo a su número (parámetro enviado) se desactiva.
    verificarVictoria()                                     # Se llama a la función verificarVictoria() al finalizar la selección en cada turno.

# Función que ejecuta las condiciones de victoria.def verificarVictoria():
    # Verificación de victoria horizontal para el numeroJugador = 0 (1).    if (casillas[0] == "X" and casillas[1] == "X" and casillas[2] == "X") or (
        casillas[3] == "X" and casillas[4] == "X" and casillas[5] == "X") or (
        casillas[6] == "X" and casillas[7] == "X" and casillas[8] == "X"):
        bloquearInicio()  # Bloquemos las botones.        # Mostramos ventana de victoria con nombreJugador1.        messagebox.showinfo("Ganaste", "Ganaste jugador: " + nombreJugador1)

    # Verificación de victoria vertical para el numeroJugador = 0 (1).    elif (casillas[0] == "X" and casillas[3] == "X" and casillas[6] == "X") or (
          casillas[1] == "X" and casillas[4] == "X" and casillas[7] == "X") or (
          casillas[2] == "X" and casillas[5] == "X" and casillas[8] == "X"):
          bloquearInicio() # Bloquemos las botones.          # Mostramos ventana de victoria con nombreJugador1.          messagebox.showinfo("Ganaste", "Ganaste jugador: " + nombreJugador1)

    # Verificación de victoria diagonal para el numeroJugador = 0 (1).    elif (casillas[0] == "X" and casillas[4] == "X" and casillas[8] == "X") or (
          casillas[2] == "X" and casillas[4] == "X" and casillas[6] == "X"):
        bloquearInicio()  # Bloquemos las botones.        # Mostramos ventana de victoria con nombreJugador1.        messagebox.showinfo("Ganaste", "Ganaste jugador: " + nombreJugador1)

    # Verificación de victoria horizontal para el numeroJugador = 1 (2).    elif (casillas[0] == "O" and casillas[1] == "O" and casillas[2] == "O") or (
          casillas[3] == "O" and casillas[4] == "O" and casillas[5] == "O") or (
          casillas[6] == "O" and casillas[7] == "O" and casillas[8] == "O"):
          bloquearInicio()  # Bloquemos las botones.          # Mostramos ventana de victoria con nombreJugador2.          messagebox.showinfo("Ganaste", "Ganaste jugador: " + nombreJugador2)

    # Verificación de victoria vertical para el numeroJugador = 1 (2).    elif (casillas[0] == "O" and casillas[3] == "O" and casillas[6] == "O") or (
          casillas[1] == "O" and casillas[4] == "O" and casillas[7] == "O") or (
          casillas[2] == "O" and casillas[5] == "O" and casillas[8] == "O"):
          bloquearInicio()  # Bloquemos las botones.          # Mostramos ventana de victoria con nombreJugador2.          messagebox.showinfo("Ganaste", "Ganaste jugador: " + nombreJugador2)

    # Verificación de victoria diagonal para el numeroJugador = 1 (2).    elif (casillas[0] == "O" and casillas[4] == "O" and casillas[8] == "O") or (
          casillas[2] == "O" and casillas[4] == "O" and casillas[6] == "O"):
          bloquearInicio()  # Bloquemos las botones.          # Mostramos ventana de victoria con nombreJugador2.          messagebox.showinfo("Ganaste", "Ganaste jugador: " + nombreJugador2)

    # Si todas las condiciones anteriores no se cumplen y todas las casillas han sido seleccionadas    # muestra una ventana de diálogo indicando el empate.    elif (casillas[0] != "N" and casillas[1] != "N" and casillas[2] != "N" and          casillas[3] != "N" and casillas[4] != "N" and casillas[5] != "N" and          casillas[6] != "N" and casillas[7] != "N" and casillas[8] != "N"):
          bloquearInicio()  # Bloquemos las botones.          # Mostramos ventana de empate con los nombres de los jugadores.          messagebox.showinfo("Empate", "Los jugadores: " + nombreJugador1 + " y " + nombreJugador2 + " han empatado.")



tablero()                   # Se ejecuta la función tablero para crear todos los elementos de la ventana de juego.bloquearInicio()            # Bloqueamos los botones.ventanaPrincipal.mainloop() # Se ejecuta la ventana principal.

Instalación de Módulos Graficación Unidad 4

Instalacion de Modulos Localizacion de carpetas. Lo primero que vamos a hacer es localizar nuestras carpetas de python 2.7 y 3.8 en donde...