Creación de juegos mediante la plataforma XNA de Microsoft Visual Studio
Links para descargar material:
Parte 01: https://www.dropbox.com/s/2b3f27izg3wfqws/01.XNA.zip
Parte 02: https://www.dropbox.com/s/ep3634jsjullkbs/02.XNA.zip
Parte 03: https://www.dropbox.com/s/9e3q068t6mlkted/03.XNA.zip
Parte 04: https://www.dropbox.com/s/u4navlzlhtecjm0/04.XNA.zip
Parte 05: https://www.dropbox.com/s/oqjll5c73kbvu1j/05.XNA.zip
Creación de juegos mediante la plataforma XNA de Microsoft Visual Studio
Links para descargar material:
Parte 01: https://www.dropbox.com/s/2b3f27izg3wfqws/01.XNA.zip
Parte 02: https://www.dropbox.com/s/ep3634jsjullkbs/02.XNA.zip
Parte 03: https://www.dropbox.com/s/9e3q068t6mlkted/03.XNA.zip
Parte 04: https://www.dropbox.com/s/u4navlzlhtecjm0/04.XNA.zip
Parte 05: https://www.dropbox.com/s/oqjll5c73kbvu1j/05.XNA.zip
Creación de juegos mediante la plataforma XNA de Microsoft Visual Studio
Links para descargar material:
Parte 01: https://www.dropbox.com/s/2b3f27izg3wfqws/01.XNA.zip
Parte 02: https://www.dropbox.com/s/ep3634jsjullkbs/02.XNA.zip
Parte 03: https://www.dropbox.com/s/9e3q068t6mlkted/03.XNA.zip
Parte 04: https://www.dropbox.com/s/u4navlzlhtecjm0/04.XNA.zip
Parte 05: https://www.dropbox.com/s/oqjll5c73kbvu1j/05.XNA.zip
Creación de juegos mediante la plataforma XNA de Microsoft Visual Studio
Links para descargar material:
Parte 01: https://www.dropbox.com/s/2b3f27izg3wfqws/01.XNA.zip
Parte 02: https://www.dropbox.com/s/ep3634jsjullkbs/02.XNA.zip
Parte 03: https://www.dropbox.com/s/9e3q068t6mlkted/03.XNA.zip
Parte 04: https://www.dropbox.com/s/u4navlzlhtecjm0/04.XNA.zip
Parte 05: https://www.dropbox.com/s/oqjll5c73kbvu1j/05.XNA.zip
El documento habla sobre árboles de búsqueda y búsqueda entre adversarios en juegos. Explica que los juegos se pueden representar como árboles de juego donde los nodos son configuraciones de tablero y las ramas son movimientos. También describe algoritmos como minimax y poda alfa-beta para encontrar la mejor jugada considerando las respuestas del adversario.
Este documento presenta los conceptos básicos de la planificación entre adversarios en juegos. Explica los conceptos de juegos, estrategias óptimas, el algoritmo minimax y su mejora alfa-beta. También cubre decisiones en tiempo real imperfectas usando funciones de evaluación y corte de búsqueda, así como juegos que incluyen elementos aleatorios como backgammon.
El documento presenta un proyecto para desarrollar un juego de tres en raya orientado a objetos en Java. Se describen las clases necesarias como Raya y Maticruzgudinhernad, que implementan el tablero de juego y la interfaz gráfica respectivamente. El juego permitirá a dos jugadores ingresar sus nombres y jugar de forma alternada hasta que uno complete tres en raya de forma horizontal, vertical o diagonal, resultando en un ganador.
El documento describe los juegos como problemas de búsqueda entre adversarios en entornos competitivos. Explica que los juegos implican dos agentes cuyas acciones deben alternar y cuyos valores de utilidad al final del juego son siempre opuestos. También introduce el algoritmo minimax para determinar las estrategias óptimas en los juegos y la técnica de poda alfa-beta para mejorar la eficiencia de la búsqueda minimax.
Este documento describe dos métodos para detectar colisiones en juegos: colisión circular y colisión rectangular. La colisión circular compara la distancia entre los centros de dos objetos circulares con la suma de sus radios. La colisión rectangular verifica si la diferencia en las coordenadas X e Y de dos objetos cuadrados es menor que la suma de sus distancias al centro. El documento incluye pseudocódigo para implementar ambos métodos.
Creación de juegos mediante la plataforma XNA de Microsoft Visual Studio
Links para descargar material:
Parte 01: https://www.dropbox.com/s/2b3f27izg3wfqws/01.XNA.zip
Parte 02: https://www.dropbox.com/s/ep3634jsjullkbs/02.XNA.zip
Parte 03: https://www.dropbox.com/s/9e3q068t6mlkted/03.XNA.zip
Parte 04: https://www.dropbox.com/s/u4navlzlhtecjm0/04.XNA.zip
Parte 05: https://www.dropbox.com/s/oqjll5c73kbvu1j/05.XNA.zip
Creación de juegos mediante la plataforma XNA de Microsoft Visual Studio
Links para descargar material:
Parte 01: https://www.dropbox.com/s/2b3f27izg3wfqws/01.XNA.zip
Parte 02: https://www.dropbox.com/s/ep3634jsjullkbs/02.XNA.zip
Parte 03: https://www.dropbox.com/s/9e3q068t6mlkted/03.XNA.zip
Parte 04: https://www.dropbox.com/s/u4navlzlhtecjm0/04.XNA.zip
Parte 05: https://www.dropbox.com/s/oqjll5c73kbvu1j/05.XNA.zip
Creación de juegos mediante la plataforma XNA de Microsoft Visual Studio
Links para descargar material:
Parte 01: https://www.dropbox.com/s/2b3f27izg3wfqws/01.XNA.zip
Parte 02: https://www.dropbox.com/s/ep3634jsjullkbs/02.XNA.zip
Parte 03: https://www.dropbox.com/s/9e3q068t6mlkted/03.XNA.zip
Parte 04: https://www.dropbox.com/s/u4navlzlhtecjm0/04.XNA.zip
Parte 05: https://www.dropbox.com/s/oqjll5c73kbvu1j/05.XNA.zip
El documento habla sobre árboles de búsqueda y búsqueda entre adversarios en juegos. Explica que los juegos se pueden representar como árboles de juego donde los nodos son configuraciones de tablero y las ramas son movimientos. También describe algoritmos como minimax y poda alfa-beta para encontrar la mejor jugada considerando las respuestas del adversario.
Este documento presenta los conceptos básicos de la planificación entre adversarios en juegos. Explica los conceptos de juegos, estrategias óptimas, el algoritmo minimax y su mejora alfa-beta. También cubre decisiones en tiempo real imperfectas usando funciones de evaluación y corte de búsqueda, así como juegos que incluyen elementos aleatorios como backgammon.
El documento presenta un proyecto para desarrollar un juego de tres en raya orientado a objetos en Java. Se describen las clases necesarias como Raya y Maticruzgudinhernad, que implementan el tablero de juego y la interfaz gráfica respectivamente. El juego permitirá a dos jugadores ingresar sus nombres y jugar de forma alternada hasta que uno complete tres en raya de forma horizontal, vertical o diagonal, resultando en un ganador.
El documento describe los juegos como problemas de búsqueda entre adversarios en entornos competitivos. Explica que los juegos implican dos agentes cuyas acciones deben alternar y cuyos valores de utilidad al final del juego son siempre opuestos. También introduce el algoritmo minimax para determinar las estrategias óptimas en los juegos y la técnica de poda alfa-beta para mejorar la eficiencia de la búsqueda minimax.
Este documento describe dos métodos para detectar colisiones en juegos: colisión circular y colisión rectangular. La colisión circular compara la distancia entre los centros de dos objetos circulares con la suma de sus radios. La colisión rectangular verifica si la diferencia en las coordenadas X e Y de dos objetos cuadrados es menor que la suma de sus distancias al centro. El documento incluye pseudocódigo para implementar ambos métodos.
El documento describe el desarrollo de un juego del Tres en Raya utilizando el framework AWT de Java. El juego tendrá dos modalidades, entre humanos y entre un humano y la computadora (que jugará de forma aleatoria). Se implementarán botones, paneles, grupos de casillas y lógica para detectar ganadores.
1) El documento explica cómo crear habitaciones y añadir objetos en Game Maker 2. 2) Detalla las opciones de configuración de cada habitación como el nombre, tamaño, fondo y velocidad. 3) Proporciona consejos sobre la planificación de un videojuego, incluyendo definir fondos, sonidos, sprites y comportamientos de objetos antes de empezar a codificar.
Este documento presenta un tutorial básico sobre el uso del programa Game Maker 8 para crear videojuegos de manera sencilla. Explica conceptos clave como objetos, salas, sprites y eventos, e incluye instrucciones sobre cómo instalar el programa e introducirse en su interfaz de usuario.
Este documento proporciona una introducción a los componentes básicos y funciones de Game Maker, incluyendo sprites, sonidos, objetos, habitaciones y eventos. Explica cómo crear y configurar estos elementos, así como las acciones disponibles como mover objetos, establecer variables y más. El resumen ofrece una visión de alto nivel de los principales conceptos cubiertos en el manual para crear y programar juegos 2D básicos en Game Maker.
El documento explica cómo crear una tabla geográfica en PostgreSQL, incluyendo la definición de campos, restricciones, verificación de la tabla, definición de accesos privilegiados y secuencias. Se comienza creando la tabla con el tipo de campo geométrico obligatorio y restricciones como la proyección y dimensión. Luego se verifica la tabla, se definen los permisos de usuario y por último se crean y asignan permisos a las secuencias relacionadas.
Este documento presenta un programa de ficción interactiva desarrollado con PyGame. El programa consta de tres clases (Narrar, Hablar y Juego) y una función (procesar). La clase Juego representa el estado del juego y está ligada a las clases Narrar y Hablar. La clase Narrar muestra la descripción del entorno y la clase Hablar muestra el cuadro donde el jugador escribe acciones. La función procesar analiza las órdenes del jugador para realizar acciones en el juego. El programa implementa
Este documento presenta el código para crear una simulación 3D interactiva utilizando VPython que incluye figuras geométricas básicas, objetos animados y texto. El código crea una base, columna central, esfera, cubos grises, portal, reloj y más. También incluye código para mover objetos como una bola, tronco, nube y anillos de humo.
Este documento presenta el código para una aplicación móvil que permite seleccionar colores mediante códigos hexadecimales. Incluye la interfaz gráfica con TextViews y SeekBars para mostrar y seleccionar los valores del rojo, verde y azul. El código Java obtiene los valores de los componentes de color y genera el código hexadecimal correspondiente.
Este documento presenta una introducción a los comandos básicos del programa estadístico R. Explica cómo usar comandos como mode(), length(), as.character(), numeric(), character(), summary() y plot() para trabajar con objetos, cambiar sus modos y atributos, y obtener resúmenes e información gráfica. También cubre factores, variables indexadas y matrices, así como la creación y modificación de vectores y objetos.
Este documento describe cómo usar el paquete pst-solides3d de PSTricks para crear gráficos 3D. Explica cómo incluir objetos 3D como cubos, cilindros, esferas y más. También cubre cómo manipular los objetos 3D mediante traslaciones, rotaciones y otras transformaciones. El objetivo es proporcionar una guía de la sintaxis de PSTricks para crear gráficos 3D.
Este documento explica cómo personalizar las teclas de acceso directo y la ayuda en Warcraft III mediante la creación de un archivo llamado "CustomKeys.txt" en la carpeta de instalación del juego. Se pueden personalizar las teclas de acceso directo, las posiciones de los botones en la interfaz de usuario, y los textos de la ayuda para que coincidan con las teclas personalizadas. También proporciona ejemplos de cómo personalizar las teclas, posiciones y ayudas para diferentes acciones en el juego.
Este documento describe un programa de ruleta de colores interactivo que permite al usuario apostar dinero en un color seleccionado. El programa generará un color ganador aleatoriamente y le dirá al usuario si ganó o perdió, mostrando su nuevo saldo. Usa gráficos, clases como Math, Thread y JFrame para crear la interfaz, animar la ruleta y manejar la interacción del usuario.
Java Applet:::Pelota que rebota en un recinto.jubacalo
Este documento presenta un applet Java que simula una pelota rebotando dentro de un recinto. Usa la técnica del doble buffer para evitar parpadeos y un objeto MediaTracker para asegurar que la imagen de la pelota se carga correctamente antes de iniciar la simulación. La pelota se mueve a una velocidad constante y cambia de dirección al chocar con los límites del recinto.
El documento presenta un manual sobre OpenGL. Explica que OpenGL es una interfaz de hardware gráfico que define funciones para acceder a las capacidades de una tarjeta gráfica. Incluye ejemplos de código para crear primitivas gráficas como un tablero de ajedrez, un cubo con líneas, una estrella y una pirámide usando OpenGL.
El documento describe las funciones del paquete PSTricks en LaTeX, incluyendo la creación de grillas personalizadas, objetos gráficos básicos como puntos, líneas y polígonos, nodos y conectores de nodos, y la simulación de gráficos 3D. Explica cómo colocar las librerías de PSTricks y cómo usar el entorno pspicture para incluir gráficos.
1) Explica cómo instalar y configurar MySQL por primera vez en Linux y Windows, incluyendo la creación de usuarios y bases de datos. 2) Detalla los tipos de datos soportados por MySQL como VARCHAR, DATE, INTEGER y BLOB. 3) Resume los pasos básicos para crear y administrar tablas, como definir campos, llaves primarias y secundarias.
Este documento presenta 16 prácticas de programación en OpenGL utilizando Dev C++. Las prácticas van desde lo básico como dibujar un tablero de ajedrez hasta objetos 3D más complejos e incluso animaciones. Se explican funciones como glBegin, glVertex, glColor y el uso de bucles for para crear formas repetitivas.
El documento describe los tipos de datos en Visual Basic .NET, incluyendo el tipo, la estructura de tipo Common Language Runtime, la asignación de almacenamiento nominal y los intervalos de valores. Se enumeran tipos como enteros, decimales, fechas, cadenas y objetos, y se especifican sus rangos de valores. También incluye un ejemplo de código para una aplicación que realiza cálculos matemáticos básicos utilizando estos tipos de datos.
Este documento presenta una sesión de capacitación sobre tecnologías web. Cubre temas como navegadores, lenguaje HTML, correo electrónico, mensajería instantánea y aplicaciones de Google. Explica conceptos como Internet, navegadores, buscadores, lenguaje HTML y sus elementos básicos. También aborda temas de correo electrónico como direcciones de correo, cuidados y recomendaciones para evitar spam.
Este documento presenta la segunda clase de un taller de programación orientada a objetos. Explica conceptos como paradigmas de programación, instalación de herramientas de desarrollo Java, tipos de datos primitivos, operadores aritméticos y lógicos, condicionales if y retos de programación. También incluye código de ejemplo para ingreso de datos, cálculos matemáticos y comparaciones.
Este documento describe diferentes herramientas para el uso de bases de datos, incluyendo sistemas gestores de bases de datos como MySQL, Firebird y SQLite. También menciona herramientas como PHPMyAdmin, DBDesigner, SQL Designer y Umodel para diseñar y administrar bases de datos. Concluye que existen muchas aplicaciones gratuitas y de pago para manipular e implementar bases de datos en las organizaciones.
Este documento presenta las lecciones de una clase de programación. Inicialmente resume un reto de la clase anterior sobre determinar si un año es bisiesto y muestra su solución implementada en Java. Luego introduce ejemplos básicos de programación orientada a objetos en Java, incluyendo la creación de clases y métodos para gestionar libros de calificaciones.
El documento describe el desarrollo de un juego del Tres en Raya utilizando el framework AWT de Java. El juego tendrá dos modalidades, entre humanos y entre un humano y la computadora (que jugará de forma aleatoria). Se implementarán botones, paneles, grupos de casillas y lógica para detectar ganadores.
1) El documento explica cómo crear habitaciones y añadir objetos en Game Maker 2. 2) Detalla las opciones de configuración de cada habitación como el nombre, tamaño, fondo y velocidad. 3) Proporciona consejos sobre la planificación de un videojuego, incluyendo definir fondos, sonidos, sprites y comportamientos de objetos antes de empezar a codificar.
Este documento presenta un tutorial básico sobre el uso del programa Game Maker 8 para crear videojuegos de manera sencilla. Explica conceptos clave como objetos, salas, sprites y eventos, e incluye instrucciones sobre cómo instalar el programa e introducirse en su interfaz de usuario.
Este documento proporciona una introducción a los componentes básicos y funciones de Game Maker, incluyendo sprites, sonidos, objetos, habitaciones y eventos. Explica cómo crear y configurar estos elementos, así como las acciones disponibles como mover objetos, establecer variables y más. El resumen ofrece una visión de alto nivel de los principales conceptos cubiertos en el manual para crear y programar juegos 2D básicos en Game Maker.
El documento explica cómo crear una tabla geográfica en PostgreSQL, incluyendo la definición de campos, restricciones, verificación de la tabla, definición de accesos privilegiados y secuencias. Se comienza creando la tabla con el tipo de campo geométrico obligatorio y restricciones como la proyección y dimensión. Luego se verifica la tabla, se definen los permisos de usuario y por último se crean y asignan permisos a las secuencias relacionadas.
Este documento presenta un programa de ficción interactiva desarrollado con PyGame. El programa consta de tres clases (Narrar, Hablar y Juego) y una función (procesar). La clase Juego representa el estado del juego y está ligada a las clases Narrar y Hablar. La clase Narrar muestra la descripción del entorno y la clase Hablar muestra el cuadro donde el jugador escribe acciones. La función procesar analiza las órdenes del jugador para realizar acciones en el juego. El programa implementa
Este documento presenta el código para crear una simulación 3D interactiva utilizando VPython que incluye figuras geométricas básicas, objetos animados y texto. El código crea una base, columna central, esfera, cubos grises, portal, reloj y más. También incluye código para mover objetos como una bola, tronco, nube y anillos de humo.
Este documento presenta el código para una aplicación móvil que permite seleccionar colores mediante códigos hexadecimales. Incluye la interfaz gráfica con TextViews y SeekBars para mostrar y seleccionar los valores del rojo, verde y azul. El código Java obtiene los valores de los componentes de color y genera el código hexadecimal correspondiente.
Este documento presenta una introducción a los comandos básicos del programa estadístico R. Explica cómo usar comandos como mode(), length(), as.character(), numeric(), character(), summary() y plot() para trabajar con objetos, cambiar sus modos y atributos, y obtener resúmenes e información gráfica. También cubre factores, variables indexadas y matrices, así como la creación y modificación de vectores y objetos.
Este documento describe cómo usar el paquete pst-solides3d de PSTricks para crear gráficos 3D. Explica cómo incluir objetos 3D como cubos, cilindros, esferas y más. También cubre cómo manipular los objetos 3D mediante traslaciones, rotaciones y otras transformaciones. El objetivo es proporcionar una guía de la sintaxis de PSTricks para crear gráficos 3D.
Este documento explica cómo personalizar las teclas de acceso directo y la ayuda en Warcraft III mediante la creación de un archivo llamado "CustomKeys.txt" en la carpeta de instalación del juego. Se pueden personalizar las teclas de acceso directo, las posiciones de los botones en la interfaz de usuario, y los textos de la ayuda para que coincidan con las teclas personalizadas. También proporciona ejemplos de cómo personalizar las teclas, posiciones y ayudas para diferentes acciones en el juego.
Este documento describe un programa de ruleta de colores interactivo que permite al usuario apostar dinero en un color seleccionado. El programa generará un color ganador aleatoriamente y le dirá al usuario si ganó o perdió, mostrando su nuevo saldo. Usa gráficos, clases como Math, Thread y JFrame para crear la interfaz, animar la ruleta y manejar la interacción del usuario.
Java Applet:::Pelota que rebota en un recinto.jubacalo
Este documento presenta un applet Java que simula una pelota rebotando dentro de un recinto. Usa la técnica del doble buffer para evitar parpadeos y un objeto MediaTracker para asegurar que la imagen de la pelota se carga correctamente antes de iniciar la simulación. La pelota se mueve a una velocidad constante y cambia de dirección al chocar con los límites del recinto.
El documento presenta un manual sobre OpenGL. Explica que OpenGL es una interfaz de hardware gráfico que define funciones para acceder a las capacidades de una tarjeta gráfica. Incluye ejemplos de código para crear primitivas gráficas como un tablero de ajedrez, un cubo con líneas, una estrella y una pirámide usando OpenGL.
El documento describe las funciones del paquete PSTricks en LaTeX, incluyendo la creación de grillas personalizadas, objetos gráficos básicos como puntos, líneas y polígonos, nodos y conectores de nodos, y la simulación de gráficos 3D. Explica cómo colocar las librerías de PSTricks y cómo usar el entorno pspicture para incluir gráficos.
1) Explica cómo instalar y configurar MySQL por primera vez en Linux y Windows, incluyendo la creación de usuarios y bases de datos. 2) Detalla los tipos de datos soportados por MySQL como VARCHAR, DATE, INTEGER y BLOB. 3) Resume los pasos básicos para crear y administrar tablas, como definir campos, llaves primarias y secundarias.
Este documento presenta 16 prácticas de programación en OpenGL utilizando Dev C++. Las prácticas van desde lo básico como dibujar un tablero de ajedrez hasta objetos 3D más complejos e incluso animaciones. Se explican funciones como glBegin, glVertex, glColor y el uso de bucles for para crear formas repetitivas.
El documento describe los tipos de datos en Visual Basic .NET, incluyendo el tipo, la estructura de tipo Common Language Runtime, la asignación de almacenamiento nominal y los intervalos de valores. Se enumeran tipos como enteros, decimales, fechas, cadenas y objetos, y se especifican sus rangos de valores. También incluye un ejemplo de código para una aplicación que realiza cálculos matemáticos básicos utilizando estos tipos de datos.
Este documento presenta una sesión de capacitación sobre tecnologías web. Cubre temas como navegadores, lenguaje HTML, correo electrónico, mensajería instantánea y aplicaciones de Google. Explica conceptos como Internet, navegadores, buscadores, lenguaje HTML y sus elementos básicos. También aborda temas de correo electrónico como direcciones de correo, cuidados y recomendaciones para evitar spam.
Este documento presenta la segunda clase de un taller de programación orientada a objetos. Explica conceptos como paradigmas de programación, instalación de herramientas de desarrollo Java, tipos de datos primitivos, operadores aritméticos y lógicos, condicionales if y retos de programación. También incluye código de ejemplo para ingreso de datos, cálculos matemáticos y comparaciones.
Este documento describe diferentes herramientas para el uso de bases de datos, incluyendo sistemas gestores de bases de datos como MySQL, Firebird y SQLite. También menciona herramientas como PHPMyAdmin, DBDesigner, SQL Designer y Umodel para diseñar y administrar bases de datos. Concluye que existen muchas aplicaciones gratuitas y de pago para manipular e implementar bases de datos en las organizaciones.
Este documento presenta las lecciones de una clase de programación. Inicialmente resume un reto de la clase anterior sobre determinar si un año es bisiesto y muestra su solución implementada en Java. Luego introduce ejemplos básicos de programación orientada a objetos en Java, incluyendo la creación de clases y métodos para gestionar libros de calificaciones.
Este documento presenta conceptos básicos sobre análisis de señales y sistemas. Define términos clave como señal, amplitud, frecuencia, forma de onda, sistema, función, variable, análisis, síntesis, señal analógica y digital. Explica que una señal es una función matemática que proporciona información sobre un fenómeno físico, y que la amplitud, frecuencia y forma de onda son características importantes de una señal. También define los conceptos de sistema, función, variable, an
Este documento presenta una introducción a los números complejos. Explica la clasificación de los diferentes tipos de números, incluyendo números naturales, enteros, racionales, reales y complejos. También describe el origen histórico de los números complejos y las diferentes formas de representarlos, como forma binómica, representación vectorial, polar y matricial. Finalmente, discute brevemente la relación entre las matemáticas y el desarrollo social a lo largo de la historia.
El documento presenta las estructuras iterativas, en particular el ciclo for. Explica que el ciclo for consta de tres partes: la expresión de inicio, la expresión de condición y la expresión de incremento/decremento. Además, provee ejemplos detallados del uso del ciclo for en Java para iterar sobre un rango de números e imprimirlos.
Este documento presenta un examen diagnóstico para el curso de Taller de Base de Datos. Contiene preguntas sobre diferentes temas como el análisis de problemas y diseño de algoritmos, desarrollo de aplicaciones con programación estructurada y orientada a objetos, instalación y uso de sistemas operativos, análisis de necesidades de información, y diseño de bases de datos en diferentes sistemas gestores de bases de datos. El examen consta de 14 páginas e incluye una portada, índice, introducción y secciones de
Este documento presenta un prototipo didáctico para la asignatura de Programación II. El prototipo cubre cinco unidades sobre fundamentos de programación en Java, incluyendo temas como objetos, eventos, métodos, propiedades, controles, estructuras de control, archivos y acceso a datos. Cada unidad contiene ejemplos de código, ejercicios propuestos y un proyecto integral para reforzar los conceptos. El objetivo es guiar al estudiante en el aprendizaje secuencial de la programación orientada a objetos usando Java.
El documento describe diferentes tipos y enfoques de investigación. Explica que existen varios tipos de investigación como la básica, estratégica, aplicada, acción, desarrollo, descriptiva, experimental, documental y adaptativa. También describe tres enfoques principales: cualitativo, cuantitativo y mixto. Finalmente, proporciona detalles sobre cada tipo y enfoque, así como referencias bibliográficas utilizadas.
El documento describe diferentes métodos para generar números aleatorios en C++, incluyendo el uso de las funciones rand() y srand() para generar números entre 0 y 32767, así como formas de establecer la semilla aleatoria y generar números aleatorios enteros y reales en diferentes rangos. También presenta un algoritmo para simular el juego de dados Craps usando números aleatorios.
Este documento describe un programa de juego de bingo que permite generar tableros aleatoriamente o manualmente, crear una figura en forma de L, e imprimir los tableros. El programa almacena los tableros en matrices, genera números aleatorios para rellenar los tableros de forma aleatoria, y permite al usuario rellenar los tableros manualmente. El programa también lleva un registro de los datos y fichas de los usuarios.
El documento contiene código Java que implementa diferentes programas para calcular edades, índices de masa corporal, determinar el número mayor entre varios valores ingresados, realizar operaciones matemáticas básicas y más. Se importan librerías como Swing y AWT para interfaces gráficas y manejo de eventos. Los programas solicitan datos de entrada al usuario y muestran resultados a través de ventanas emergentes.
Este documento presenta varios problemas de estructura de datos y algoritmos resueltos con código de programación en Java. Incluye problemas como calcular el número de pasos necesarios para cambiar un precio en una caja registradora antigua con carretes, imprimir la matriz transpuesta de una matriz dada y encontrar los números no pertenecientes a la sucesión de Fibonacci. Para cada problema, se describe la entrada, salida y el algoritmo correspondiente, y se incluye el código de programa completo.
El documento presenta un programa Java que lee números binarios de entrada y verifica que solo contengan los dígitos 0 y 1, lanzando una excepción en caso contrario. También incluye clases para realizar operaciones como suma, resta, complemento a 1 y complemento a 2 de números binarios.
Creación de juegos mediante la plataforma XNA de Microsoft Visual Studio
Links para descargar material:
Parte 01: https://www.dropbox.com/s/2b3f27izg3wfqws/01.XNA.zip
Parte 02: https://www.dropbox.com/s/ep3634jsjullkbs/02.XNA.zip
Parte 03: https://www.dropbox.com/s/9e3q068t6mlkted/03.XNA.zip
Parte 04: https://www.dropbox.com/s/u4navlzlhtecjm0/04.XNA.zip
Parte 05: https://www.dropbox.com/s/oqjll5c73kbvu1j/05.XNA.zip
El documento describe los conceptos básicos de XNA Game Studio, incluyendo sus métodos clave como Initialize, LoadContent, Update y Draw que componen el bucle principal del juego, así como también explica cómo desplegar sprites en una primera aplicación de prueba. Adicionalmente, presenta un taller para crear un juego simple que muestre varios sprites en diferentes posiciones.
Creación de juegos mediante la plataforma XNA de Microsoft Visual Studio
Links para descargar material:
Parte 01: https://www.dropbox.com/s/2b3f27izg3wfqws/01.XNA.zip
Parte 02: https://www.dropbox.com/s/ep3634jsjullkbs/02.XNA.zip
Parte 03: https://www.dropbox.com/s/9e3q068t6mlkted/03.XNA.zip
Parte 04: https://www.dropbox.com/s/u4navlzlhtecjm0/04.XNA.zip
Parte 05: https://www.dropbox.com/s/oqjll5c73kbvu1j/05.XNA.zip
Este documento presenta la sesión #1 de un diplomado en docencia universitaria y edumática. Introduce conceptos clave como arquitectura de redes, tipos de redes, protocolos y servicios de red. Explica los tipos de redes como LAN, WAN y MAN, así como las diferencias entre redes públicas e privadas. Finalmente, cubre temas como direccionamiento IP, direcciones estáticas y dinámicas, y direcciones reservadas.
Este documento presenta la solución a un reto de programación de la clase anterior. Se explican los métodos estáticos y por qué el método main debe ser estático. También se discute la generación de números aleatorios y se propone un nuevo reto que involucra adivinar un número aleatorio generado por la computadora. Finalmente, se presenta la solución completa al reto propuesto.
El documento presenta varias clases en Java que implementan conceptos de programación orientada a objetos como métodos, constructores, atributos privados y parámetros. La clase LibroCalificaciones muestra mensajes y la clase PruebaLibroCalificaciones prueba sus métodos. LibroCalificaciones2 mejora la primera clase al agregar un atributo privado de nombre de curso y constructores. PruebaLibroCalificaciones2 prueba a LibroCalificaciones2 creando objetos y usando sus métodos. Finalmente, se presentan estructuras de control como if
La inteligencia artificial sigue evolucionando rápidamente, prometiendo transformar múltiples aspectos de la sociedad mientras plantea importantes cuestiones que requieren una cuidadosa consideración y regulación.
Catalogo Refrigeracion Miele Distribuidor Oficial Amado Salvador ValenciaAMADO SALVADOR
Descubre el catálogo general de la gama de productos de refrigeración del fabricante de electrodomésticos Miele, presentado por Amado Salvador distribuidor oficial Miele en Valencia. Como distribuidor oficial de electrodomésticos Miele, Amado Salvador ofrece una amplia selección de refrigeradores, congeladores y soluciones de refrigeración de alta calidad, resistencia y diseño superior de esta marca.
La gama de productos de Miele se caracteriza por su innovación tecnológica y eficiencia energética, garantizando que cada electrodoméstico no solo cumpla con las expectativas, sino que las supere. Los refrigeradores Miele están diseñados para ofrecer un rendimiento óptimo y una conservación perfecta de los alimentos, con características avanzadas como la tecnología de enfriamiento Dynamic Cooling, sistemas de almacenamiento flexible y acabados premium.
En este catálogo, encontrarás detalles sobre los distintos modelos de refrigeradores y congeladores Miele, incluyendo sus especificaciones técnicas, características destacadas y beneficios para el usuario. Amado Salvador, como distribuidor oficial de electrodomésticos Miele, garantiza que todos los productos cumplen con los más altos estándares de calidad y durabilidad.
Explora el catálogo completo y encuentra el refrigerador Miele perfecto para tu hogar con Amado Salvador, el distribuidor oficial de electrodomésticos Miele.
SOPRA STERIA presenta una aplicació destinada a persones amb discapacitat intel·lectual que busca millorar la seva integració laboral i digital. Permet crear currículums de manera senzilla i intuitiva, facilitant així la seva participació en el mercat laboral i la seva independència econòmica. Aquesta iniciativa no només aborda la bretxa digital, sinó que també contribueix a reduir la desigualtat proporcionant eines accessibles i inclusives. A més, "inCV" està alineat amb els Objectius de Desenvolupament Sostenible de l'Agenda 2030, especialment els relacionats amb el treball decent i la reducció de desigualtats.
para programadores y desarrolladores de inteligencia artificial y machine learning, como se automatiza una cadena de valor o cadena de valor gracias a la teoría por Manuel Diaz @manuelmakemoney
HPE presenta una competició destinada a estudiants, que busca fomentar habilitats tecnològiques i promoure la innovació en un entorn STEAM (Ciència, Tecnologia, Enginyeria, Arts i Matemàtiques). A través de diverses fases, els equips han de resoldre reptes mensuals basats en àrees com algorísmica, desenvolupament de programari, infraestructures tecnològiques, intel·ligència artificial i altres tecnologies. Els millors equips tenen l'oportunitat de desenvolupar un projecte més gran en una fase presencial final, on han de crear una solució concreta per a un conflicte real relacionat amb la sostenibilitat. Aquesta competició promou la inclusió, la sostenibilitat i l'accessibilitat tecnològica, alineant-se amb els Objectius de Desenvolupament Sostenible de l'ONU.
2. Introducción
Este es un juego clásico de cartas. En esta implementación, lo haremos para 2
jugadores. Cada jugador inicia con 2 cartas, y el objetivo es que la suma de
los puntos de las cartas sea 21. Si el jugador se pasa de 21, pierde. Gana el
que tenga 21 punto o el que más se aproxime.
Las cartas del 2 a 10, valen el número de la carta, es decir, el 2 vale 2, e 3
vale 3, y así sucesivamente
La J, Q y K, valen 10 puntos
El As vale 1 u 11 puntos dependiendo de lo que más le convenga al jugador
3. Cree un proyecto XNA. Yo lo llame: Black Jack
Cree la carpeta Images y agregue las imágenes que utilizaremos en este proyecto,
que son: un fondo verde, un logo de Black Jack y las 52 cartas que están PN,
donde P es la pinta (P: Corazones, D: Diamantes, P: Picas, T: Tréboles) y N el
número, que va del 2 al 10, más: J, Q, K y A.
Cree la carpeta Fonts y cree un nuevo archivo de letras llamado Font. Cambie
estas etiquetas:
<FontName>Impact</FontName>
<Size>24</Size>
Agreguemos la enumeración GameState que utilizamos en el ejemplo anterior. No
olvide cambiar el nombre del NameSpace
Agregue una nueva clase llamada Pinta, la cual será una enumeración con las
pintas de la baraja
enum Pinta
{
Corazón,
Diamante,
Pica,
Trébol
}
Agregue una nueva clase llamada Carta, la cual empaquetará todos los atributos
de una carta
4. using System;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Graphics;
namespace Black_Jack
{
class Carta
{
public Texture2D Textura { get; set; }
public Pinta Pinta { get; set; }
public string Letra { get; set; }
public int Valor1 { get; set; }
public int Valor2 { get; set; }
}
}
Primero pintemos como se verá nuestro juego cuando lo ejecutemos.
Agreguemos estos atributos a la clase Game1
Texture2D fondo;
Texture2D logo;
SpriteFont font;
GameState gameState;
int width;
int height;
En el constructor de la case Game1, adicione las siguientes líneas:
5. // change windows size
width = 900;
height = 600;
graphics.PreferredBackBufferWidth = width;
graphics.PreferredBackBufferHeight = height;
En el Initizalice:
gameState = GameState.Uninitiated;
En el Load
fondo = Content.Load<Texture2D>("Images/FondoVerde");
logo = Content.Load<Texture2D>("Images/BlackJack");
font = Content.Load<SpriteFont>("Fonts/Font");
En el Draw
spriteBatch.Begin();
spriteBatch.Draw(fondo, new Vector2(0, 0), Color.White);
spriteBatch.Draw(logo, new Vector2((width - logo.Width) / 2, 20), Color.White);
if (gameState == GameState.Uninitiated)
{
spriteBatch.DrawString(font, "Presioner ENTER para empezar...", new Vector2(250, 250),
Color.White);
}
spriteBatch.End();
6. Probemos lo que llevamos hasta el momento:
Ahora empecemos con la lógica del juego. Vamos a cargar toda la baraja en memoria y
cuando el usuario presione ENTER, vamos a darle a cada jugador 2 cartas y las vamos a
mostrar
Vamos a adicionar estos nuevos atributos a la clase Game1
KeyboardState tecladoPrevio;
Random rd = new Random();
List<Carta> baraja;
List<Carta> jugador1;
List<Carta> jugador2;
7. En el Initialize:
baraja = new List<Carta>();
jugador1 = new List<Carta>();
jugador2 = new List<Carta>();
Ahora empecemos con la lógica del juego. Vamos a cargar toda la baraja en memoria y
cuando el usuario presione ENTER, vamos a darle a cada jugador 2 cartas y las vamos a
mostrar
Vamos a adicionar estos nuevos atributos a la clase Game1
KeyboardState tecladoPrevio;
Random rd = new Random();
List<Carta> baraja;
List<Carta> jugador1;
List<Carta> jugador2;
Adicionemos el método LoadBaraja. El cual carga todo el mazo de cartas en memoria (este
método puede ser reutilizable por otros juegos de cartas)
private void LoadBaraja()
{
Pinta pinta = Pinta.Corazón;
string pintaLetra = "C";
for (int i = 0; i < 4; i++)
{
for (int j = 1; j <= 13; j++)
{
string letra;
int valor1;
int valor2;
if (j == 1)
8. {
letra = "A";
valor1 = 1;
valor2 = 11;
}
else if (j == 11)
{
letra = "J";
valor1 = 10;
valor2 = 10;
}
else if (j == 12)
{
letra = "Q";
valor1 = 10;
valor2 = 10;
}
else if (j == 13)
{
letra = "K";
valor1 = 10;
valor2 = 10;
}
else
{
letra = j.ToString();
valor1 = j;
valor2 = j;
}
Texture2D textura = Content.Load<Texture2D>("Images/" + pintaLetra + letra);
Carta carta = new Carta();
carta.Letra = letra;
9. carta.Pinta = pinta;
carta.Textura = textura;
carta.Valor1 = valor1;
carta.Valor2 = valor2;
baraja.Add(carta);
}
pinta++;
if (pinta == Pinta.Diamante) pintaLetra = "D";
if (pinta == Pinta.Pica) pintaLetra = "P";
if (pinta == Pinta.Trébol) pintaLetra = "T";
}
}
Adicionemos el método AsignarCarta. El cual le asigna una carta NO repetida al jugador
(este método puede ser reutilizable por otros juegos de cartas)
private void AsignaCarta(List<Carta> jugador)
{
int index = rd.Next(0, baraja.Count - 1);
jugador.Add(baraja[index]);
baraja.RemoveAt(index);
}
Adicionemos estas líneas al método Update
10. carta.Pinta = pinta;
carta.Textura = textura;
carta.Valor1 = valor1;
carta.Valor2 = valor2;
baraja.Add(carta);
}
pinta++;
if (pinta == Pinta.Diamante) pintaLetra = "D";
if (pinta == Pinta.Pica) pintaLetra = "P";
if (pinta == Pinta.Trébol) pintaLetra = "T";
}
}
Adicionemos el método AsignarCarta. El cual le asigna una carta NO repetida al jugador
(este método puede ser reutilizable por otros juegos de cartas)
private void AsignaCarta(List<Carta> jugador)
{
int index = rd.Next(0, baraja.Count - 1);
jugador.Add(baraja[index]);
baraja.RemoveAt(index);
}
Adicionemos estas líneas al método Update
12. Agregue estas líneas al Draw, antes del spriteBatch.End();
if (gameState == GameState.Running)
{
spriteBatch.DrawString(font, "I) Carta jugador izquierda, D) Carta jugador derecha, P) Plantar",
new Vector2(50, 250), Color.White);
MostrarCartas(jugador1, 100, 350);
MostrarCartas(jugador2, 500, 350);
}
Probemos lo que llevamos hasta el momento:
13. Ahora agreguemos la lógica del juego y el manejo de puntajes
Adicione estos atributos a la clase Game1:
int puntaje1Jugador1;
int puntaje2Jugador1;
int puntaje1Jugador2;
int puntaje2Jugador2;
int ganador;
En el Initialize:
puntaje1Jugador1 = 0;
puntaje2Jugador1 = 0;
puntaje1Jugador2 = 0;
puntaje2Jugador2 = 0;
ganador = 0;
14. Adicione el método revisar puntajes:
private void RevisarPuntajes()
{
puntaje1Jugador1 = 0;
puntaje2Jugador1 = 0;
puntaje1Jugador2 = 0;
puntaje2Jugador2 = 0;
foreach (Carta carta in jugador1)
{
puntaje1Jugador1 += carta.Valor1;
puntaje2Jugador1 += carta.Valor2;
}
foreach (Carta carta in jugador2)
{
puntaje1Jugador2 += carta.Valor1;
puntaje2Jugador2 += carta.Valor2;
}
}
Cambien el método Update por el siguiente:
15. protected override void Update(GameTime gameTime)
{
// Allows the game to exit
if (GamePad.GetState(PlayerIndex.One).Buttons.Back == ButtonState.Pressed)
this.Exit();
// TODO: Add your update logic here
KeyboardState tecladoActual = Keyboard.GetState();
if ((gameState == GameState.Uninitiated || gameState == GameState.Finish) &&
tecladoActual.IsKeyDown(Keys.Enter))
{
gameState = GameState.Running;
jugador1.Clear();
jugador2.Clear();
LoadBaraja();
AsignaCarta(jugador1);
AsignaCarta(jugador2);
AsignaCarta(jugador1);
AsignaCarta(jugador2);
RevisarPuntajes();
}
if (gameState == GameState.Running &&
tecladoActual.IsKeyDown(Keys.I) &&
!tecladoPrevio.IsKeyDown(Keys.I) &&
(puntaje1Jugador1 < 21 || puntaje2Jugador1 < 21))
{
AsignaCarta(jugador1);
RevisarPuntajes();
}