Programación Básica

Batch (BAT): .bat
HTML: .html
CSS: .css
Java: .java
Python .py
Ruby: .rb.
C: .c
C++ .cpp
C#: .cs

El lenguaje de programación orientado a objetos fue creado en 1995 por James Gosling, lo que significa que representa conceptos como «objetos» con «campos» (que son atributos que describen el objeto) y «métodos» (acciones que el objeto puede hacer).

Bloc de notas o Notepad++ es un editor de textos que viene preinstalado en las computadoras con Windows. Este software no solo sirve para realizar anotaciones y abrir archivos . También puedes utilizarlo para crear programas de computadora básicos. Para ello, crea archivos batch que ejecuten scripts en el símbolo del sistema de Windows. También puedes escribir líneas de código en el interior del Bloc de notas. Este wikiHow te enseñará a crear programas utilizándolo

Tener en cuenta algunos consejos generales

Puedes usar una secuencia de comandos batch para crear archivos batch que se ejecuten en el símbolo del sistema de Windows.
Usa sangría.
añadir comentarios. (# en .app)
sintaxis esté correcta.
uso de mayúsculas sea correcto. ,
los corchetes o paréntesis de apertura correctos para el lenguaje de programación (por ejemplo, { o [).
cerrar  las líneas abiertas de código se cierren.
caracteres especiales
extensión de archivo correcta
los lenguajes de programación comunes:
Batch (BAT): .bat
HTML: .html
CSS: .css
Java: .java
Python .py
Ruby: .rb.
C: .c
C++ .cpp
C#: .cs

Guardar el archivo correctamente. «Guardar como tipo:»>Todos los archivos (*.*).  Se añade la extensión de archivo correcta al final.

BAT básico

«.bat»

Ejecución del archivo batch. Una vez  guardado, se hace doble clic en él para abrir el símbolo del sistema y ejecutar la secuencia de comandos batch.

Se puedes hacer mucho solo con secuencias de comandos batch.

Ingresa los comandos de la secuencia batch. Puedes usar la secuencia de comandos batch para ejecutar programas y secuencias de comandos básicos para Windows en el símbolo del sistema. Estos son algunos comandos batch básicos:

• @echo off: esto elimina todo el texto innecesario que puede interferir con el programa. Siempre debe ser el primer comando que ingreses.(apaga los comentarios de la línea de comandos.)
• echo: este comando muestra el texto que se haya escrito después de él en el símbolo del sistema (por ejemplo, «echo Hola, mundo» mostraría «Hola, mundo» como una línea de texto en el símbolo del sistema).
• echo.: el comando «echo.» (con un punto al final) muestra una línea en blanco en el símbolo del sistema. Esto es útil para aislar líneas de texto y hacer que no parezcan abarrotadas.
• pause: este comando muestra la instrucción «Presiona cualquier tecla para continuar…» en el símbolo del sistema. Se usa para crear un descanso en el programa. Puedes usarlo para darle tiempo al usuario de leer texto en el programa.
• cls: este comando es la abreviatura en inglés de «despejar pantalla». Despeja todo el texto de la pantalla. (borra la pantalla de la línea de comandos. Esto solamente hace que el símbolo del sistema luzca más ordenado.)
• title: este comando muestra el texto que le sigue en la barra de título del símbolo del sistema.
• color: con este comando, puedes cambiar el color del texto en el símbolo del sistema si ingresas la letra o número correspondiente después del comando. Puedes ver las letras y números que correspondan a cada color si escribes «color/?» en el símbolo del sistema.
• exit: este comando sale del programa.
• goto  : dirígete a cualquier bandera que especifiques inmediatamente después de goto.
• %random%  : una variable de Windows que genera aleatoriamente un número desde 0 a 9.
• : (número, letra o palabra)  : una bandera. Los comandos «Goto» envían el programa a cualquier bandera que especifiquen

/a answer=%RANDOM%
set variable1=surf33
echo -------------------------------------------------
echo ¡Bienvenidos al juego de adivinanzas!
echo.
echo ¡Intenten adivinar mi número!
echo -------------------------------------------------
echo.
:top
echo.
set /p guess=
echo.
if %guess% GTR %answer% ECHO ¡Más alto!
if %guess% LSS %answer% ECHO ¡Más bajo!
if %guess%==%answer% GOTO EQUAL
set /a guessnum=%guessnum% +1
if %guess%==%variable1% ECHO ¿Encontraste la puerta trasera?, la respuesta es: %answer%
goto top
:equal
echo Felicidades, ¡¡¡adivinaste correctamente!!!
echo.
echo Te tomó %guessnum% intentos.
echo.
pause

lluvia de códigos

@echo off
:a
color 2
echo 1 1 1 0 1 0 0 0 1 1 1 1 0 0 0 1 1 0 0 1 0 0 0 1 1 0 1 0 1 0 0 0 1 1 1 1
ping localhost -n 1 > nul
echo 1 1 0 1 1 1 0 0 0 1 0 1 a f h 0 0 0 1 0 1 1 0 0 1 1 1 0 0 1 0 1 0 0 1 1 0
echo 1 0 0 1 1 0 9 8 1 2 0 1 9 9 2 1 1 1 0 0 1 0 1 1 1 0 1 1 0 1 0 0 0 1 0 1 1
ping localhost -n 1 > nul
echo 0 1 0 0 0 1 0 0 0 1 0 0 0 1 0 1 0 0 1 0 1 0 1 1 0 1 0 0 0 01 0 1 0 0 1 0
ping localhost -n 1 > nul
echo 1 0 1 1 1 0 1 1 0 9 1 1 2 1 1 0 9 1 0 5 7 7 8 7 8 1 3 2 1 2 1 2 3 2 1 3 4
ping localhost -n 1 > nul
echo 1 1 1 0 1 0 0 1 0 0 0 1 1 1 0 0 1 1 1 4 1 2 1 1 2 0 1 0 1 2 2 1 0 1 1 0 1
goto a

bloqueo [la computadora abra programas de forma aleatoria hasta que el archivo “batch” se desactive o la computadora se bloquee]

@ECHO OFF
title Folder Private
if EXIST "Panel de Control.{21EC2020-3AEA-1069-A2DD-08002B30309D}" goto :UNLOCK
if NOT EXIST Private goto :MDLOCKER
:CONFIRM
echo Estás seguro que quieres bloquear la carpeta(Y/N)
set/p "cho=>"
if %cho%==Y goto :LOCK
if %cho%==y goto :LOCK
if %cho%==n goto :END
if %cho%==N goto :END
echo Invalid choice.
goto :CONFIRM
:LOCK
ren Private "Control Panel.{21EC2020-3AEA-1069-A2DD-08002B30309D}"
attrib +h +s "Control Panel.{21EC2020-3AEA-1069-A2DD-08002B30309D}"
echo Folder locked
goto :End
:UNLOCK
echo Enter password to unlock folder
set/p "pass=>"
if NOT %pass%== Contraseña aquí goto :FAIL//
attrib -h -s "Control Panel.{21EC2020-3AEA-1069-A2DD-08002B30309D}"
ren "Panel de Control.{21EC2020-3AEA-1069-A2DD-08002B30309D}" Private
echo Folder Unlocked successfully
goto :End
:FAIL
echo Invalid password
goto :end
:MDLOCKER
md Private
echo Private created successfully
goto :End
:End

[Necesitas guardar tu contraseña cuidadosamente.
No cambies el nombre después de asegurarlo, o ya no estará protegido.
Alguien que realmente entienda los archivos batch podrá averiguar tu contraseña. Si realmente necesitas proteger tu información, entonces necesitas encriptarla.
Programas como 7zip podrán acceder a esa carpeta.
El buscador de Windows puede encontrar esa carpeta.]

bloqueo [la computadora abra programas de forma aleatoria hasta que el archivo “batch” se desactive o la computadora se bloquee]

-tenemos 10 banderas. Si dejamos un número fuera, el programa debería cerrarse cuando %random% genere ese número.

%%% abrir el Bloc de notas un número infinito de veces hasta que cierres la línea de comandos.
@echo off
:a
start notepad
goto a
%%% abrir progamas un número infinito de veces hasta que cierres la línea de comandos.

@echo off
cls
begin
goto %random%
:1
start cmd.exe
goto begin
:2
start mspaint.exe
goto begin
:3
start pinball.exe
goto begin
:4
start iexplore.exe
goto begin
:5
start explorer.exe
goto begin
:6
start solitaire.exe
goto begin
:7
start explorer.exe
goto begin
:8
start edit.exe
goto begin
:9
start iexplore.exe
goto begin
:0
start mspaint.exe
goto begin

archivo Visual Basic (VBA) [.vba]

se ejecuta directamente en windows con doble clic.

crea una serie de mensajes de error

 "x=msgbox("Mensaje de error aquí", 5+16, "Título de error aquí").
'El "5+16" es: 5 (botones Reintentar y Cancelar) + 16 (ícono Crítico)
* Donde: 
0 (botón Aceptar)
1 (botones de Aceptar y Cancelar)
2 (botones Abortar, Reintentar e Ignorar)
3 (botones Sí, No y Cancelar)
4 (Botones Sí y No)
5 (botones Reintentar y Cancelar)
16 (ícono Crítico)
32 (ícono Ayuda)
48 (ícono Advertencia)
64 (ícono Información)
*

HTML básico

«.html»

El HTML -HTML es la abreviación de Hyper Text Markup Language (lenguaje de marcas de hipertexto) -se usa principalmente para el diseño web.uno de los lenguajes de programación más fáciles de aprender.   los HTML son de “texto sin formato” en lugar de “texto enriquecido” (a diferencia de los archivos «.doc»)
Con Notepad ;  Microsoft Word para Windows; o TextEdit para Mac,
Archivo >→ Guardar como>“página web”,
o cambiar la extensión a “.html” o “.htm” en lugar de “.doc”, “.rtf” o alguna otra extensión.

[Como utilizar el navegador para “leer” el documento HTML como si fuera una página web, no para crear un sitio web en línea]

Ejecución del archivo HTML:  Abre el archivo HTML en un navegador web. Si quieres ver lo que hayas creado, dirígete a donde hayas guardado el archivo HTML, hazle clic derecho y selecciona Abrir con…. Luego, selecciona el navegador web que quieras. Con esto se abrirá el archivo HTML en el navegador.
otra opcion , es arrastrar el archivo a la barra de URL en tu navegador
etiquetas:   estan entre  paréntesis triangulares <>(de inicio) y </ >(la final)

Escribe <!DOCTYPE html> y presiona Entrar. Esta línea le indica al navegador web que es un documento HTML.

Escribe <html> (la etiqueta de inicio ) y presiona Entrar. Esta es la etiqueta de apertura para todo el código HTML. Será necesario que haya una etiqueta de cierre al final del documento. Todo el código HTML se encontrará entre estos dos corchetes.

 <head>   etiqueta de apertura para la porción del encabezado  de tu documento
<title>     </title>   Entre las etiquetas se escribe el titulo de la forma  <title>Mi Titulo</title> y aparecera en la parte superior del navegador, arriba de la barra de direcciones.
</head>,   etiqueta de cierre

Escribe <body> y presiona Entrar. Esta es la etiqueta de apertura para el cuerpo del documento HTML. El cuerpo contiene todos los detalles visuales del documento, lo cual abarca el texto, las imágenes, los enlaces y los medios insertados

Escribe <h1>Texto</h1> y presiona Entrar. Esta es la etiqueta de apertura y cierre para el encabezado de texto del documento. Esto muestra texto en letras grandes y en negrita. Reemplaza «Texto» por lo que quieras que se muestre en el texto del encabezado.

Ejemplo: si quieres crear una página cuyo encabezado diga «¡Hola!», debes escribir «<h1>¡Hola!</h1>» en el Bloc de Notas.

Escribe <p>Texto</p> y presiona Entrar. Esta es la etiqueta de apertura y cierre para el texto del párrafo. Esto muestra texto en letra pequeña normal. Reemplaza «Texto» por lo que quieras que diga el texto del párrafo.

Ejemplo, escribirías <p>¿Cómo estás hoy?</p> en el Bloc de Notas para que se muestre la frase «¿Cómo estás hoy?» debajo del encabezado.

Escribe </body> y presiona Entrar. Esta es la etiqueta de cierre del cuerpo. Con esto, finalizarás la sección del cuerpo del documento HTML.

Escribe </html> en el Bloc de Notas. Esta es la etiqueta de cierre del documento HTML. Con esto, se cierra todo el documento. Suele ser la última línea de código en un documento HTML.

el código del programa. Debe verse así:

<!DOCTYPE html>
<html>
<body>
<h1>¡Hola!</h1>
<p>¿Cómo estás hoy?</p>
</body>
</html>

ver aqui entrada de programacion en HTML y con LaTex<

CCS

CSS: .css

A Cascading Style Sheet (CSS) is a system for website coding that allows designers to manipulate several features at once by assigning certain elements to groups. For instance, by using a code for the website background, designers can change the background color or image on all pages of the website with one change to the CSS file. Here’s how to create CSS for a basic website.

Be sure you have a basic understanding of HTML tags. You should know how tags work and of thesrcand href attributes.

Learn some of the basic CSS properties. You will find that there are very many properties. However, it is not necessary to learn them all.

• Some good basic CSS properties to know are color and font-family.

Learn about values for each respective property. All properties need a value. For thecolor property, for example, you might put the red value.
Learn about the style HTML attribute. It is used within an element like href or src. To use it, within the quotation marks after the equal sign, put the CSS attribute, a colon, and then the value of the property. This is known as a CSS rule.
Understand that inline CSS is not usually used for websites by professional web developers. Inline CSS can add unnecessary clutter to an HTML document. However, it is a great way to get introduced to how CSS works.

Writing Basic CSS

Launch the program you desire to use. It should allow you to create HTML and CSS files.

If you don’t have a special program installed, you can use Notepad or another text editor. Simply save your file both as a text file and a CSS file.

Open the HTML file for your website. You should open this with an HTML editor as well, if you have one installed.

HTML editors allow you to edit HTML and CSS at the same time.

Create a <style> tag within your HTML head. This will let you write CSS without the need for a separate file.

Choose an element you want to add styling to and type the name of the element followed by a set of curly braces ({ }). To make your code more legible, always put the second curly brace on its own line.

Between the braces, type your CSS rules as you would using the style attribute. Each line must end with a semicolon (;). To make your code legible, each rule should start on its own line and each line should be indented.
It is very important to note that this styling will affect all elements of the selected type on the page. More specific styling will be covered in the next section

More Advanced CSS

Create a CSS file, not an HTML file and save it using the .css extension. Open your HTML file as well.

Create a <link> tag in your HTML head. This will allow you to link a separate CSS file to your HTML document. Your link tag needs three attributes: rel, type, and href.

• rel means «relationship» and tells the browser what the relationship is to the HTML document. Here it should have a value of "stylesheet".
• type tells what type of media is being linked to. Here it should have a value of "text/css"
• href here is used similarly to how it is used in an <a> element, but here it must link to a CSS file. If the CSS file is located in the same folder as the HTML file, only the file name needs to be written within the quotation marks.

Select elements of different types you want to add the same styling to. Add a class attribute to these elements and set them equal to a class name of your choice. This will give your elements the same styling.

Assign what styling a class will receive. Type the class name in your CSS file with a period (.) preceding it (i.e. .class).

Select single elements you want to add special styling to and add an id attribute. Id’s are created in CSS using a pound symbol (#) rather than a period.

• Id’s are more specific than classes, so an id will override any class styling if it has an attribute with a different value than the class.

 

<html>
<head>
<style>
h1 {color:red;}
p {color:blue;}
</style>
</head>
</body>
<h1>A heading</h1>
<p>A paragraph,</p >
</body>
</htm1>


<html>
<body>
<h1 id="myHeader">Hello World!</h1>
<button onclick-"displayResult()>Change text</ button>
<Script>
function displayResults
document.getElements ="Hace nice day";
}
</script>
</body>
</html>
w3schools.com

link to a external style sheet
<head>
<link reloj ="stylesheet" type="text/ccs" href="theme.ccs">
</head>

++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

drop-down box’s code for menu in HTML and CSS.

replace «#»=16 with the number you want to use (the larger the number, the larger your drop-down menu will be)

Close the CSS section:
</style>
</head>

<!DOCTYPE html>
<html>
<head>
<style>

.dropbtn {
    background-color: black;
    color: white;
    padding: 16px;
    font-size: 16px;
    border: none;
}

.dropdown {
    position: relative;
    display: inline-block;
}

.dropdown-content {
    display: none;
    position: absolute;
    background-color: lightgrey;
    min-width: 200px;
    z-index: 1;
}

.dropdown-content a {
    color: black;
    padding: 12px 16px;
    text-decoration: none;
    display: block;
}

.dropdown-content a:hover {background-color: white;}
.dropdown:hover .dropdown-content {display: block;}
.dropdown:hover .dropbtn {background-color: grey;}

</style>
</head>

<div class="dropdown">
<button class="dropbtn">Social Media</button>
<div class="dropdown-content">

<a href="https://www.google.com">Google</a>
<a href="https://www.facebook.com">Facebook</a>
<a href="https://www.youtube.com">YouTube</a>

</div>
</div>
</body>
</html>

template example

<!DOCTYPE html>
<html lang="en">
<head>
<title>CSS Template</title>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1">
<style>
* {
box-sizing: border-box;
}

body {
margin: 0;
font-family: Arial, Helvetica, sans-serif;
}

/* Style the side navigation */
.sidenav {
height: 100%;
width: 200px;
position: fixed;
z-index: 1;
top: 0;
left: 0;
background-color: #111;
overflow-x: hidden;
}


/* Side navigation links */
.sidenav a {
color: white;
padding: 16px;
text-decoration: none;
display: block;
}

/* Change color on hover */
.sidenav a:hover {
background-color: #ddd;
color: black;
}

/* Style the content */
.content {
margin-left: 200px;
padding-left: 20px;
}
</style>
</head>
<body>

<div class="sidenav">
<a href="#">Link</a>
<a href="#">Link</a>
<a href="#">Link</a>
</div>

<div class="content">
<h2>CSS Template</h2>
<p>A full-height, fixed sidenav and content.</p>
</div>

</body>
</html>

CSS tricks.com

w3 schools.

programa básico de Python

«.py»

Instala Python. Si quieres ejecutar archivos Python en tu computadora, primero debes instalar Python. Puedes descargarlo en Python.org.
Abre el Bloc de Notas. Con el comando «print» en Python, puedes mostrar cualquier texto que desees. Sin espacios al escribir el comando de apertura.

print("¡Hola!")

Abre el símbolo del sistema [command promt.exe]. Sigue estos pasos para
Inicio de Windows>Escribe CMD>clic en ícono del Símbolo del sistema
Cambia la ubicación del archivo Python en el símbolo del sistema. si el simbolo de sistema (CMD) abre en C: y se quiere cambiar a leer el archivo de pyton en D: , se será necesario  escribir los comando en el CMD
cd D:\user\…..  [se escribe pega (Ctrl+V) la dirección del archivo «.py» ] [Enter]

aparecera D:\…[dirección]\
allí se escribe el nombre del archivo con su extension «.py» y se presiona [Enter]

Escribe el nombre del archivo Python y presiona Entrar. Con esto se ejecuta el archivo en el símbolo del sistema. Por ejemplo, si el archivo tiene el nombre «hola.py», debes escribir «hola.py» y presionar Entrar para ejecutarlo.

Importa Pygame. Pygame es una biblioteca que te dará acceso a funciones gráficas.[https://www.pygame.org/docs/.]
Descarga Pygame. Busca la versión correspondiente a tu plataforma en el sitio http://www.pygame.org/download.shtml. Ejecuta el instalador. y Verifica que la instalación haya funcionado. Abre la terminal de Python y escribe «import pygame». Si no aparece un error, entonces Pygame se habrá instalado correctamente.

Juego «balón prisionero» en el cual el jugador tiene que esquivar pelotas que rebotan.

Pasos:

-Instalar Pygame
-Configurar una ventana básica
-Crear un objeto del juego
-Organizar el juego
-Agregar un objeto del jugador
-Hacer que los objetos interactúen con el jugador
-Agregar un controlador de juego para crear objetos
-Agregar el puntaje y el mensaje de «Juego terminado»

'''[1.1]En el Hyperterminal de Python. Verifica que la instalación haya funcionado. Abre la terminal de Python y escribe "import pygame". Si no aparece un error, entonces Pygame se habrá instalado correctamente. '''
import pygame

'''[2.1]Importa Pygame. En archivo nuevo.'''
import pygame
'''------[2.1]'''

'''[7.3]a .Agregar un controlador de juego para crear objetos. Asígnales velocidades aleatorias a las pelotas. Se importa la libreria '''
from random import random
 '''------[]'''

'''[2.2]Importa Pygame.'''
from pygame.locals import *
'''------[2.2]'''
 
'''[2.3]Configurar una ventana básica: Configura la resolución de pantalla. Ahora deberás crear una variable global para la resolución de la pantalla de modo que puedas referenciarla en distintas partes del juego. Generalmente va en la parte superior del archivo para que sea más fácil cambiarla más adelante. En proyectos avanzados, es mejor poner esta información en un archivo separado.'''
resolution = (400,300)
'''------[2.3]'''

'''[2.4]Configurar una ventana básica Define algunos colores. Los colores en Pygame son RGBA, con valores que varían entre 0 y 255. El valor alfa (A) es opcional, pero los demás colores (rojo, azul y verde) son obligatorios.'''
white = (255,255,255)
black = (0,0,0)
red = (255,0,0)
'''------[2.4]'''

'''[2.5]Configurar una ventana básica. Inicializa la pantalla. Utiliza la variable de la resolución que habías definido anteriormente.'''
screen = pygame.display.set_mode(resolution)
'''------[2.5]'''

'''[3.1]Crear un objeto del juego. Crea una nueva clase y un constructor. Configura todas las propiedades del objeto. También deberás proporcionar valores para cada una de esas propiedades. ''' 
class Ball:
    def __init__(self, xPos =  resolution[0] / 2, yPos = resolution[1] / 2, xVel = 1, yVel = 1, rad = 15):
        self.x = xPos
        self.y = yPos
        self.dx = xVel
        self.dy = yVel
        self.radius = rad
        self.type = "ball"
'''------[3.1]'''
'''[7.4] Agregar un controlador de juego para crear objetos. Arregla la función de dibujo. La función de dibujo no acepta números en punto flotante, por lo que deberás convertir la posición de las pelotas a enteros para que estas se puedan dibujar.'''
 '''[3.2]Crear un objeto del juego. Determina la forma en la que se dibujará el objeto. Utiliza las propiedades que definiste en el constructor tanto para dibujar la pelota como un círculo, como para pasarle a la función la superficie sobre la cual se dibujará el objeto. La superficie será el objeto de la pantalla que creaste anteriormente a través de la resolución. '''
    def draw(self, surface):
     '''pygame.draw.circle(surface, black, (self.x, self.y), self.radius) # Provisional de [3.2] hasta [7.4]'''
        pygame.draw.circle(surface, black, (int(self.x), int(self.y)), self.radius) # punto flotantes eliminados para aceptar la funcion de dbujo
'''------[3.2]'''
'''------[7.4]''' 

'''[6.1]a Hacer que los objetos interactúen con el jugador. Cambia las funciones de actualización. Para que los objetos puedan interactuar, es necesario que dichos objetos puedan accederse entre sí. Agrega otro parámetro a la función de actualización para pasarle la lista de objetos del juego (gameObjects). Tendrás que agregársela tanto al objeto del jugador como a los objetos de la pelota. Si tienes muchos objetos de juego, la herencia podría ayudarte a hacer que todas las firmas del método sean iguales.  
     def update(self, gameObjects): # de [6.1] reemplaza la linea del [3.4]
'''------[6.1]a'''

'''[3.4] Crear un objeto del juego. Haz que el objeto se mueva. Crea una función que actualice la posición del objeto. Llama a esta función en cada repetición del bucle. '''
'''  def update(self): # esta linea de [3.4] provisional hasta [6.1]'''
        self.x += self.dx
        self.y += self.dy
'''------[3.4]'''
'''[3.6] Crear un objeto del juego. Mantén la pelota dentro de la pantalla. Agrega controles en la función de actualización para revertir la dirección de la pelota en caso de que golpee uno de los bordes de la pantalla. Correr el programa: hasta este punto se grafica el fondo blanco y la pelota negra'''
        if (self.x <= 0 or self.x >= resolution[0]):
            self.dx *= -1
        if (self.y <= 0 or self.y >= resolution[1]):
            self.dy *= -1
''------[3.6]'''

'''[5.1] Agregar un objeto del jugador. Crea una clase y un constructor para el jugador. Ahora deberás crear otro círculo que se controle a través del ratón. Inicializa los valores en el constructor. El radio es el único valor importante.''' 
class Player:
    def __init__(self, rad = 20):
        <self.x = 0
        self.y = 0
        self.radius = rad
        self.type = "player"
'''------[5.1]'''
'''[8.2]a Agregar el puntaje y el mensaje de "Juego terminado". Modifica la finalización del juego. Ahora en vez de cerrar el juego cuando el jugador sufra una colisión, puedes configurar una variable en el jugador para que el juego pueda verificarla. Cuando la variable "gameOver" (juego terminado) tome el valor "true" (verdadero), deja de actualizar los objetos. Al hacerlo, se congelará la pantalla para que el jugador pueda ver lo que sucedió y revisar su puntaje. Ten en cuenta que los objetos quedarán dibujados, solo que no se actualizarán. ''' 
        self.gameOver = False
'''------[8.2]a'''
'''[5.2] Agregar un objeto del jugador. Define cómo dibujar el objeto del jugador. Se dibujará del mismo modo que dibujaste los otros objetos del juego.''' 
 
    def draw(self, surface):
        pygame.draw.circle(surface, red, (self.x, self.y), self.radius)
'''------[5.2]'''

'''[5.3] Agregar un objeto del jugador. Agrégale el control del ratón al objeto del jugador. En cada cuadro, revisa la ubicación del ratón y establece la ubicación de los objetos del jugador en ese punto. '''
'''[6.1]a Hacer que los objetos interactúen con el jugador. Cambia las funciones de actualización. 
    def update(self, gameObjects): # se agrega reemplazando la del paso 5.3
'''------[6.1]b'''
 '''def update(self): # linea de [5.3] provisional hasta [6.1] '''
        cord = pygame.mouse.get_pos()
        self.x = cord[0]
        self.y = cord[1]
'''------[5.3]'''

'''[6.2] Hacer que los objetos interactúen con el jugador. Ocúpate de las colisiones entre el jugador y las pelotas. Revisa todos los objetos del juego para determinar si son de tipo "ball" (pelota). Luego utiliza las fórmulas de radios y distancias entre dos objetos para determinar si estos colisionarán. Los círculos son formas en las cuales resulta muy sencillo determinar si se producirá una colisión. Esta es la principal razón por la cual no se usan otros tipos de formas en el juego. ''' 
        for gameObj in gameObjects:
            if gameObj.type == "ball":
                if (gameObj.x - self.x)**2 + (gameObj.y - self.y)**2 <= (gameObj.radius +self.radius)**2:
'''------[6.2]'''
'''[6.3] Hacer que los objetos interactúen con el jugador. Finaliza el juego si el jugador es "golpeado" por una pelota. Por ahora, simplemente se cerrará el juego si eso sucede. Corrida del programa: Dos bolas negras en movimiento que al golpear la roja, finaliza el juego ''' 
'''                pygame.quit() # Linea provisional hasta [8.2]b'''
'''------[6.3]'''
'''[8.2]b Agregar el puntaje y el mensaje de "Juego terminado".Modifica la finalización del juego.''' 
                    self.gameOver = True
'''------[8.2]b'''

'''[7.1] Agregar un controlador de juego para crear objetos. Crea una clase de controlador de juego. Los controladores de juego son los responsables de mantener el juego "en ejecución". Son distintos a la clase del juego, que se encarga de dibujar y actualizar todos los objetos. El controlador agregará periódicamente otra pelota a la pantalla para que el juego se vuelva más difícil. Agrega un constructor e inicializa algunos valores básicos. El intervalo representará al tiempo que deberá transcurrir antes de agregar una nueva pelota.''' 
class GameController:  
'''------[7.1]'''
'''[8.1]a Agregar el puntaje y el mensaje de "Juego terminado".Agrégale un puntaje a la clase del controlador del juego. Crea un objeto de fuente y una variable de puntaje. Deberás dibujar la fuente en cada cuadro para que muestre el puntaje e incrementar dicho puntaje en cada cuadro a través de la función de actualización.  '''
    def __init__(self, interval = 5):


        self.inter = interval
        self.next = pygame.time.get_ticks() + (2 * 1000)
        self.type = "game controller"
        
'''------[7.1]'''
'''------[8.1]a # esta seccion Se mantiene igual'''
'''[8.1]b''' 
        self.score = 0
        self.scoreText = pygame.font.Font(None, 12)
'''------[8.1]b'''
'''[7.2] Agregar un controlador de juego para crear objetos. Agrega la función de actualización. Esta función se encargará de determinar cuánto tiempo ha transcurrido desde que se agregó la última pelota o desde que se inició el juego. Si el tiempo es mayor al intervalo, se reiniciará el tiempo y se agregará una pelota. ''' 
    def update(self, gameObjects):
        if self.next < pygame.time.get_ticks():
            self.next = pygame.time.get_ticks() + (self.inter * 1000)
         '''gameObjects.append(Ball()) # provisional de [7.2] hasta [7.3]'''
''' Nota: Crea las pelotas llamando a la clase Ball, aqui sin movimiento, lo que se le asigna en [7.3]
'''------[7.2]'''
'''[7.3]b Agregar un controlador de juego para crear objetos. Asígnales velocidades aleatorias a las pelotas. Deberás utilizar números aleatorios para hacer que el juego varíe a lo largo del tiempo. Sin embargo, las velocidades de las pelotas ahora estarán representadas por un número en punto flotante en lugar de un entero, Antes se debio importar la libreria al inicio de codigo''' 
            gameObjects.append(Ball(xVel=random()*2, yVel=random()*2))
'''------[7.3]'''
'''[8.1]c''' 
        self.score += 1
'''------[8.1]c'''
'''[7.5] Agregar un controlador de juego para crear objetos. Define un método de dibujo para el controlador del juego. Al tratarse de un objeto del juego, el bucle principal intentará dibujarlo. Deberás definir una función de dibujo que no haga nada para que el juego no deje de responder.  
    def draw(self, screen):
     '''pass              # Provisional de [7.5] hasta [8.1]d'''
'''------[7.5]'''
'''[8.1]d'''
        screen.blit(self.scoreText.render(str(self.score), True, black), (5,5)) # Se elimina la linea de [7.5]
'''------[8.1d]'''
'''[]''' 
'''[4.1] Organizar el juego. Organiza todo a través de clases. El juego se volverá más complicado. Utiliza las técnicas de la programación orientada a objetos para organizar tu código.
'''[4.2] Organizar el juego. Convierte el bucle del juego en una clase. Como el juego ahora tiene datos que incluyen los objetos y las funciones del juego, sería lógico convertir el bucle del juego en una clase. Nota: Al final se agrega "game().run()" ''' 
class game():
'''-----[4.2]'''
'''-----[4.1]'''
'''[4.3] Organizar el juego. Agrega un constructor. En él instanciarás algunos objetos del juego, crearás la pantalla y el reloj, e inicializarás Pygame. Es necesario inicializar Pygame para poder usar ciertas características como texto y sonido. '''
    def __init__(self):
        pygame.init()  # Es la linea de inicializacion de programa      
        self.screen = pygame.display.set_mode(resolution)
        self.clock = pygame.time.Clock()
'''------[4.3]'''

'''[4.6]a Organizar el juego. Controla varios objetos del juego. Ahora mismo, el código debe llamar a la función de dibujo y de actualización del objeto en cada cuadro. Esto podría volverse muy complicado si tuvieras muchos objetos, por lo que sería mejor agregar el objeto a un arreglo y posteriormente actualizar y dibujar todos los objetos el arreglo en cada repetición. Así podrás agregar fácilmente otro objeto y asignarle una posición inicial diferente. Corrida del Programa: Muestra una segunda bola negra en el fondo blanco''' 
        self.gameObjects = []
     '''self.gameObjects.append(Ball())   # Provisional, hasta [7.6]'''
     '''self.gameObjects.append(Ball(100))# Provisional, hasta [7.6]'''
     ''' NOTA: se llama a la clase Ball dos veces, que dibuja la bola, la situa  y le da velocidad'''
'''------[4.6]a'''
'''[7.6] Agregar un controlador de juego para crear objetos. Agrega el controlador del juego a "gameObjects" y elimina las dos pelotas. El juego ahora generará una nueva pelota cada cinco segundos ''' 
        self.gameObjects.append(GameController())# Se eliminan 2 lineas de [4.6]a.'''
'''------[7.6]'''
<'''[5.4] Agregar un objeto del jugador. Agrega un objeto del jugador a los objetos del juego (gameObjects). Crea una nueva instancia de jugador y agrégala a la lista. Corrida del preograma: En este punto aparece el (tercer) objeto, este del jugador (circulo Rojo un poco mas grande).  ''' 
        self.gameObjects.append(Player())
'''------[5.4]'''
'''[8.2]c Agregar el puntaje y el mensaje de "Juego terminado".Modifica la finalización del juego.''' 
        self.gameOver = False
'''------[8.2]c'''
'''[4.4]a Organizar el juego. Controla los eventos a través de una función.'''
    def handleEvents(self):
'''[4.4]b Controla los eventos. (esta seccion, se elimina del paso [2.9] y se inserta aqui para ser controlada en la clase class game)'''
        for event in pygame.event.get():
            if event.type == QUIT:
                pygame.quit() # es la linea de salida del programa
'''------[4.4]b'''
'''------[4.4]a'''

'''[4.6]b Organizar el juego. Controla varios objetos del juego. ''' 
'''[4.5]a Organizar el juego. Convierte el bucle del juego en una función. Llama a la función que controla al evento en cada repetición.'''
    def run(self): 
'''------[4.5]a'''
'''------[4.6]b'''

'''[3.3]a''' 
''' ball = Ball() # [3.3]a Crear un objeto del juego.Crea una instancia de la clase y haz que el bucle del juego dibuje la pelota en cada repetición.  esta linea es solo de prueba hasta este punto, no para el codigo final'''
'''------[3.3]a'''
'''[3.5]a'''
'''clock = pygame.time.Clock() #[3.5]a Crear un objeto del juego. Limita la tasa de cuadros por segundo. La pelota se moverá rápido porque el bucle del juego se ejecuta cientos de veces por segundo. Utiliza el reloj de Pygame para limitar la tasa a 60 cuadros por segundo. Esta linea es solo de prueba hasta este punto, no para el codigo final'''
'''------[3.5]a'''

#+++++++++++++++++++++++++++++++++++++++++++++++++++++
#++++++++++++++++++++Cuerpo del Bucle++++++++++++++

'''[2.6]Configurar una ventana básica. Crea un bucle para el juego. Repite ciertas acciones en todos los cuadros del juego. Crea un bucle que se repita indefinidamente replicando estas acciones. con while True:''' 
   while True:
'''------[2.6]'''

'''[3.3]b Crear un objeto del juego.'''
''' ball.draw(screen) # esta linea es solo de prueba hasta este punto, no para el codigo final'''
'''------[3.3]b'''

'''[4.6]c Organizar el juego. Controla varios objetos del juego.
'''[4.5]b Organizar el juego. Convierte el bucle del juego en una función. Llama a la función que controla al evento en cada repetición.'''
      self.handleEvents()
'''------[4.5]b'''
'''------[4.6]c'''

'''[8.2]d Agregar el puntaje y el mensaje de "Juego terminado".Modifica la finalización del juego.''' 
           if not self.gameOver:
'''[4.6]d Organizar el juego. Controla varios objetos del juego. ''' 
                for gameObj in self.gameObjects:
                 '''gameObj.update() # provisional hasta [4.6]d'''
'''------[4.6]d'''
                    gameObj.update(self.gameObjects)
                    if gameObj.type == "player":
                        self.gameOver = gameObj.gameOver
'''------[8.2]d'''

'''[4.6]e Organizar el juego. Controla varios objetos del juego.'''
'''[4.5]c Convierte el bucle del juego en una función'''  
'''[2.7]Configurar una ventana básica.Colorea la pantalla. dentro del while True, con screen.fill(white)'''
      self.screen.fill(white)
'''------[2.7]'''
'''------[4.5]c'''
'''------[4.5]e'''

'''[]''' 
'''[4.6]f Organizar el juego. Controla varios objetos del juego. ''' 
                for gameObj in self.gameObjects:
                    gameObj.draw(self.screen)
'''------[4.6]f'''

'''[4.6]g Organizar el juego. Controla varios objetos del juego. ''' 
'''[4.5]d Organizar el juego.Convierte el bucle del juego en una función''' 
      self.clock.tick(60)
'''[2.8]Configurar una ventana básica. Muestra la pantalla. dentro del while True, Si ejecutas el programa, la pantalla se volverá blanca y luego el programa dejará de responder. Esto se debe a que el sistema operativo estará enviándole eventos al juego y el juego no puede hacer nada con ellos. Al recibir tantos eventos no controlados, el juego dejará de responder. '''
     pygame.display.flip()
'''------[2.8]'''
'''------[4.5]d'''
'''------[4.6]g'''

'''[3.5]b Crear un objeto del juego. Limita la tasa de cuadros por segundo. esta linea es solo de prueba hasta este punto, no para el codigo final'''
'''  clock.tick(60) #solo provisional [3.5]b hasta agregar [4.5]d'''
'''------[3.5]b'''


'''[2.9]Configurar una ventana básica. Controla los eventos. Obtén una lista de todos los eventos que ocurren en cada cuadro. Por ahora te ocuparás de un solo evento, el Evento de Salida (estaria al final dentro del bucle 'While True' pero se separo de alli en el 'class game()' y usando aqui el 'for..in..' y el 'if...'). Este evento ocurre cuando el usuario cierra el juego. Al hacerlo, evitarás que el programa deje de responder como consecuencia del exceso de eventos. Correr el programa: Hasta este punto se abre la ventana y se muestra solo el fondo en blanco''' 
   '''for event in pygame.event.get():# provisional, en [4.4] se extraera'''
   '''      if event.type == QUIT:    # provisional, en [4.4] se extraera'''
   '''        pygame.quit()           # provisional, en [4.4] se extraera'''
'''------[2.9]'''

'''[4.2]''' 
game().run()  # [4.2] para llamar la ejecucion de la funcion a partir de cuando de agrega el "class game()" el cual es el cuerpo del juego que ahora dentro del bucle pero la clase que lo contiene se extrajo a partir del paso [4].
'''------[4.2]'''

>https://unipython.com/

programa C++ básico

«.cpp»

Descarga e instala un compilador de C++. Es posible escribir un archivo C++ en el Bloc de Notas, pero no podrás compilar un programa C++. Para ello, se necesitará un compilador aparte. Existen varios compiladores de C++ para Windows, entre ellos
VisualStudio [VisualStudio.microsoft.com/vs/older-downloads] Instalación.
Cygwin,
Visual Basic
GCC. [compilador GNU (GCC)]

PowerShell (PS) [https://aka.ms/pscore6]
Descarga e instala el compilador que elijas.

Abre el Bloc de Notas. Usarás el Bloc de Notas para crear un programa básico de C++ que muestre «¡Hola, mundo!» al ejecutarlo.

//Título del programa 
#include <iostream> 
int main () 
{ 
std::cout << "¡Hola, mundo!"; 
}

#include <iostream>
using namespace std;
int main(){
    cout << "Hello, world, from Visual C++!" << endl;
}

Escribe // y luego el título del programa. Escribir dos barras oblicuas es la forma de comentar en C++. El compilador no compilará ningún texto escrito después de estas dos marcas. Escribe dos barras oblicuas después del nombre del programa en la parte superior de la página.

Escribe #include <iostream> y presiona Entrar. Este es el comando de preprocesador. Este comando le indica a C++ que ejecute las siguientes líneas de código como un programa.

Escribe int main () y presiona Entrar. Esto declara la función del programa.

Escribe { y presiona Entrar. Con esto se crea una apertura de corchete. El código principal del programa se encontrará entre esta apertura de corchete y el cierre.

Escribe std::cout << "¡Hola, mundo!"; y presiona Entrar. Este es el código de ejecución del programa.

Escribe }. Esto añade el cierre de corchetes y cierra la fase de ejecución del programa.

Revisa el programa.

Guarda el archivo como un archivo C++. Sigue estos pasos para guardar el programa como un archivo C++

Compila el programa. para compilar el archivo del programa dependerá del compilador que hayas descargado.

Visual Studio: Es uno de los casos de compiladores, que necesitan abrir el archivo C++ en el compilador en sí o compilar desde la ventana del símbolo del sistema [DOS o del programa] .

PS: se navega hasta el archivo en el símbolo del sistema y se escribe un comando específico (g++) seguido del nombre de archivo [nombre.cpp].

Después de que se haya compilado, se creará un archivo ejecutable (.exe) a partir del archivo C++.

Abre el archivo ejecutable. Después de compilar el archivo C++, hazle doble clic al archivo ejecutable (.exe) para ejecutar el programa.

CMD

 Creacion de archivo y compilacion desde la venta de simbolo ( ejemplo DOS)

//Crear el directorio[carpeta] hello en c:
c:\> md hello

c:\> cd hello
  c:\hello
// abre el programa Notepad creando un archivo .cpp [en el se escribe el codigo fuente]
c:\hello> notepad hello.cpp 
// verifica el contenido de la carpeta
c:\hello> dir
...
// Compila el archivo usando en compilador de VisualStudio "cl.exe"
c:\hello>cl /EHsc hello.cpp

Del Tutorial: creación de una aplicación de escritorio de Windows tradicional (C++)

Con la API de Windows, [Nota: eliminar los comentarios en color rojo]
En el menú Compilar , elija Compilar solución.
Para ejecutar la aplicación, presione F5
https://learn.microsoft.com/es-es/cpp/windows/walkthrough-creating-windows-desktop-applications-cpp?view=msvc-170

https://learn.microsoft.com/es-es/cpp/build/media/desktop-app-project-run-157.png?view=msvc-170

C++

// HelloWindowsDesktop.cpp
// compile with: /D_UNICODE /DUNICODE /DWIN32 /D_WINDOWS /c
//[1.2]iniciar una aplicación de escritorio de Windows.Los programas de escritorio de Windows requieren <windows.h>. <tchar.h> define la macro TCHAR, que se resuelve finalmente en wchar_t si el símbolo UNICODE se define en el proyecto; de lo contrario, se resuelve en char. Si siempre compila con UNICODE habilitado, no necesita TCHAR y solo puede usar wchar_t directamente.
#include <windows.h>
#include <stdlib.h>
#include <string.h>
#include <tchar.h>

// Global variables

//[2.3]a Ahora puede crear una ventana. Use la función CreateWindowEx.
// The main window class name.
/*  Nombre que se le asignara al proceso de la ventana, servira para el handle. Se usara en la funcion CreateWindowEx
Otra forma:
const char g_szClassName[] = "myWindowClass"; */
static TCHAR szWindowClass[] = _T("DesktopApp");

// The string that appears in the application's title bar.
// nombre que se le asignara a la ventana. 
static TCHAR szTitle[] = _T("Windows Desktop Guided Tour Application");
//-----[2.3]a

//[1.1]b ¿Qué son todas esas palabras adicionales, como WINAPI, CALLBACK, HINSTANCE o _In_? La API de Windows hace un uso extensivo de tipos de definiciones y macros de preprocesador para abstraer algunos de los detalles de tipos y código específico de la plataforma, como las convenciones de llamada, las declaraciones __declspec y las pragmas del compilador. 
// Stored instance handle for use in Win32 API calls such as FindResource
HINSTANCE hInst;
//-----[1.1]b

//[1.3] 
 Microsoft Windows utiliza identificadores de ventana internamente para acceder a las ventanas lac que abren com un número arbitrario. Con el nodo HWND se obtiene el identificador de una ventana con un título determinado (que se muestra en el área de título de la ventana). 

Además de la función WinMain, todas las aplicaciones de escritorio de Windows deben tener una función de procedimiento de ventana. Esta función se suele denominar WndProc, pero puede asignarle el nombre que quiera. WndProc tiene la siguiente sintaxis.
C++
LRESULT CALLBACK WndProc(
_In_ HWND hWnd,
_In_ UINT message,
_In_ WPARAM wParam,
_In_ LPARAM lParam
);
En esta función, escribirá código para controlar los mensajes que la aplicación recibe de Windows cuando se producen eventos. Por ejemplo, si un usuario elige un botón Aceptar en la aplicación, Windows le enviará un mensaje y puede escribir código dentro de la función WndProc que haga el trabajo que sea adecuado. Esto se conoce como controlar un evento. Solo se controlan los eventos que son pertinentes para la aplicación. 
NOTA: se llamara la funcion mas adelante en []  .
// Forward declarations of functions included in this code module:
LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM);
// Step 4: the Window Procedure ( ver paso [3.1])
Nota esta secuencia de declaracion de punteros y con el
 switch(msg){.....
se encuentra aqui al inicio o al final [caso de este codigo]:



//-----[1.3]

/*[1.1]iniciar una aplicación de escritorio de Windows.deben tener una función main como punto de partida, todas las aplicaciones de escritorio de Windows deben tener una función WinMain. WinMain tiene la siguiente sintaxis.// Se hace la llamada a la api 
El winmain contiene, entre otras (HINSTANCE, LPSTR, int), las variables:
WNDCLASSEX wc;
// es una estructura de datos. almacena la informacion de la ventana 
// http://winapi.freetechsecrets.com/win32/WIN32WNDCLASSEX.htm
HWND hwnd; 
//obtiene el apuntador de la ventana de un grupo de ventanas
MSG Msg; 
//Contiene información de mensajes de la cola de mensajes de un hilo.
*/
int WINAPI WinMain(
   _In_ HINSTANCE hInstance,
   _In_opt_ HINSTANCE hPrevInstance,
   _In_ LPSTR     lpCmdLine,
   _In_ int       nCmdShow
)
//-----[1.1]

//[2.1]Para agregar funcionalidad a la función WinMain. En la función WinMain, se rellena una estructura de tipo WNDCLASSEX.. Esta estructura contiene información sobre la ventana, por ejemplo, el icono de la aplicación, el color de fondo de la ventana, el nombre para mostrar en la barra de título, etc. Lo importante es que contiene un puntero de función al procedimiento de ventana. El ejemplo siguiente muestra una estructura típica de WNDCLASSEX . 
//Step 1: Registering the Window Class
{
   WNDCLASSEX wcex;

   wcex.cbSize = sizeof(WNDCLASSEX);
// tamaño de la ventana
   wcex.style          = CS_HREDRAW | CS_VREDRAW;
// el estilo de la clase ->investigar cs y ws
   wcex.lpfnWndProc    = WndProc;
// puntero al window procesure de la clase
   wcex.cbClsExtra     = 0;
// cantidad extra de asignacion de memoria
   wcex.cbWndExtra     = 0;
 // cantidad extra de asignacion de memoria por ventana 
   wcex.hInstance      = hInstance;
// Handle a la instancia de la aplicación (la que obtenemos en el primer parámetro de WinMain( ) )
   wcex.hIcon          = LoadIcon(wcex.hInstance, IDI_APPLICATION);
// Handle al ícono grande (32x32), mostrado cuando el usuario presiona Alt+Tab
   wcex.hCursor        = LoadCursor(NULL, IDC_ARROW);
// Handle al cursor que será mostrado sobre la ventana.
   wcex.hbrBackground  = (HBRUSH)(COLOR_WINDOW+1);
//Pincel para fijar el color de fondo de nuestra ventana.
   wcex.lpszMenuName   = NULL;
// Nombre del recurso Menú para usar con las ventanas de esta clase.
   wcex.lpszClassName  = szWindowClass;
// Nombre para identificar la clase.
   wcex.hIconSm        = LoadIcon(wcex.hInstance, IDI_APPLICATION);
// Handle al ícono pequeño (16x16), usado en la barra de tareas y en la esquina superior izquierda de la ventana.
//-----[2.1]

/*[2.2]Registre WNDCLASSEX en Windows para que sepa sobre la ventana y cómo enviar mensajes a ella. Use la función RegisterClassEx y pase la estructura de clase de ventana como argumento.
La macro _T se usa porque usamos el tipo TCHAR.
otra forma:

 if(!RegisterClassEx(&wc))
  {
      MessageBox(NULL, 
         "Window Registration Failed!",
         "Error!",
         MB_ICONEXCLAMATION | MB_OK);
      return 0;
  }

*/
   if (!RegisterClassEx(&wcex))
   {
      MessageBox(NULL,
         _T("Call to RegisterClassEx failed!"),
         _T("Windows Desktop Guided Tour"),
         NULL);

      return 1;
   }
//-----[2.2]

//[] 
   // Store instance handle in our global variable
   hInst = hInstance;
//-----[2.2]

/*[2.3]b Ahora puede crear una ventana. 
Use la función CreateWindowEx.Esta función devuelve HWND, que es un manipulador de una ventana. Un manipulador es algo parecido a un puntero que Windows usa para realizar un seguimiento de las ventanas abiertas. Para obtener más información, vea Tipos de datos de Windows.*/
 HWND hWnd = CreateWindowEx(
   // The parameters to CreateWindowEx explained:
   // hwnd apunta a la ventana que se esta creando.

WS_EX_OVERLAPPEDWINDOW,
   // WS_EX_OVERLAPPEDWINDOW : An optional extended window style.
/* o bien se podria llamar WS_EX_CLIENTEDGE es el estilo extendido de la ventana, en este caso he configurado éste para darle un borde interno y hundido al marco de la ventana. Pon este valor en cero para observar la diferencia, o prueba con otros valores para ver que hacen.*/ 
  
 szWindowClass,
   // szWindowClass: the name of the application
/* o bien se podria llamar g_szClassName  nombre previamente asignado en varibles globales al proceso de la ventana, sirve para el handle éste le dice al sistema que tipo de ventana crear. Debido a que queremos crear una ventana a partir de la clase que hemos registrado, usamos el nombre de dicha clase*/

 szTitle,
   // szTitle: the text that appears in the title bar 
 /* Declarado al inicio en las varables globales titulo de la ventana, si no se declara se coloca el nombre entre comillas como 
"The title of my window", */
 WS_OVERLAPPEDWINDOW,
   // WS_OVERLAPPEDWINDOW: the type of window to create
-
/* Los siguientes cuatro parámetros (CW_USEDEFAULT,CW_USEDEFAULT,320,240) son las coordenadas X e Y de la esquina superior izquierda de la ventana y el alto y ancho de de la ventana, respectivamente. He puesto los campos X e Y con el valor CW_USEDEFALT para dejar que windows elija en qué lugar de la pantalla ubicar la ventana. */
/*Recuerda que la parte izquierda de la pantalla tiene un valor de X igual a cero y se incrementa hacia la derecha y la parte superior de la pantalla tiene un valor cero de Y y se incrementa cuando avanzamos hacia abajo en la pantalla. Las unidades son los pixeles, el cual es la miníma unidad que una pantalla puede mostrar en una resolución determinada.*/
 CW_USEDEFAULT, CW_USEDEFAULT,
   // CW_USEDEFAULT, CW_USEDEFAULT: initial position (x, y)
 500, 100,
   // 500, 100: initial size (width, length)
/* Los siguientes (NULL,NULL,hInstance,NULL) corresponden al handle de la ventana padre, al handle del menú, al handle de la instancia de la aplicación y un puntero a los datos con los cuales se creó la ventana. 
En windows las ventanas son ordenadas en la pantalla de acuerdo a una jerarquía de padre e hijo. 
Cuando ves un botón en una ventana, el botón es el Hijo de la ventana en la cual está contenido y dicha ventana es su Padre. En este ejemplo, 
-El handle al padre es nulo debido a que no tenemos padre, estamos en el nivel principal de las ventanas. 
-El handle al menú es nulo debido a que, por ahora, no tenemos menú. 
-El handle a la instancia de la aplicación es puesto con el valor que es pasado en el primer parámetro del WinMain( ).
-Los datos de creación (los culaes nunca uso) pueden ser usados para enviar información adicional a la ventana que está siendo creada. 
También es nulo.
 Si estás preguntándote que es la palabra mágica NULL, es simplemente definida como cero (0). En realidad, en C está definida como ((void *) 0), debido a que está destinada a ser usada con punteros. Por lo tanto probablemente obtengas algunos "warnings" si la utilizas para valores enteros, de todas maneras esto depende del compilador y del nivel de warnings en la configuaración del mismo. Puedes elegir ignorar los warnings o usar el valor cero (0)en lugar de NULL.  */
  NULL,
   // NULL: the parent of this window
  NULL,
   // NULL: this application does not have a menu bar 
 hInstance,
   // hInstance: the first parameter from WinMain 
  NULL
   // NULL: not used in this application
   );
 /* verifica si se ha creado el apuntador de la ventana, que otra forma seria
  if(hwnd == NULL){
     MessageBox(NULL,
         "Window Creation Failed!",
         "Error!", 
          MB_ICONEXCLAMATION | MB_OK);
     return 0;
   }   
NOTA: los apuntadores  */
   if (!hWnd)
   {
      MessageBox(NULL,
         _T("Call to CreateWindow failed!"),
         _T("Windows Desktop Guided Tour"),
         NULL);

      return 1;
   }
//-----[2.3]b

//[2.4]En este momento, se ha creado la ventana, pero todavía es necesario indicar a Windows que la haga visible. Y eso es lo que hace este código:
La ventana mostrada no tiene mucho contenido porque aún no ha implementado la función WndProc. En otras palabras, la aplicación aún no controla los mensajes que Windows le envía.
   // The parameters to ShowWindow explained:
   // hWnd: the value returned from CreateWindow
   // nCmdShow: the fourth parameter from WinMain
   ShowWindow(hWnd,
      nCmdShow); // muestra la ventana en pantalla
    UpdateWindow(hWnd); // refresca la pantalla
//-----[2.4]
//[2.5]Para controlar los mensajes, primero agregamos un bucle de mensajes para escuchar los mensajes que Windows envía. Cuando la aplicación recibe un mensaje, este bucle lo envía a la función WndProc que se va a controlar. El bucle de mensajes es similar al código siguiente.
Para más información sobre las estructuras y funciones que se usan en el bucle de mensajes, vea MSG, GetMessage, TranslateMessagey DispatchMessage.
   // Main message loop:
   MSG msg;
   while (GetMessage(&msg, NULL, 0, 0))
   {
      TranslateMessage(&msg);
      DispatchMessage(&msg);
   }

   return (int) msg.wParam;
}

//  FUNCTION: WndProc(HWND, UINT, WPARAM, LPARAM)
//
//  PURPOSE:  Processes messages for the main window.
//
//  WM_PAINT    - Paint the main window
//  WM_DESTROY  - post a quit message and return

/* [3.2]Una aplicación normalmente controla muchos otros mensajes. Por ejemplo, WM_CREATE cuando se crea una ventana por primera vez y WM_DESTROY cuando se cierra la ventana. 
El código siguiente muestra una función WndProc básica pero completa. */

 LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam) 
{
 /*[3.1]Para agregar funcionalidad a la función WndProc. Para habilitar la función WndProc a fin de controlar los mensajes que recibe la aplicación, implemente una instrucción switch.
El primer mensaje que se va a controlar es el mensaje WM_PAINT. La aplicación recibe el mensaje WM_PAINT cuando debe actualizarse parte de su ventana mostrada. El evento puede producirse cuando un usuario mueve una ventana delante de su ventana y, luego, lo mueve de nuevo. La aplicación no sabe cuándo se producen estos eventos. Solo Windows lo sabe, por lo que lo notifica a la aplicación con un mensaje WM_PAINT. Cuando se muestra por primera vez la ventana, toda ella se debe actualizar. Para controlar un mensaje WM_PAINT , primero llame a BeginPaint, controle toda la lógica para mostrar el texto, los botones y otros controles de la ventana y luego llame a EndPaint. Para la aplicación, la lógica entre la llamada inicial y la llamada final muestra la cadena "Hello, Windows desktop!" en la ventana. En el siguiente código, la función TextOut se usa para mostrar la cadena.
HDC en el código es un manipulador de un contexto de dispositivo, que se usa para dibujar en el área cliente de la ventana. Use las funciones BeginPaint y EndPaint para preparar y completar el dibujo en el área cliente. BeginPaint devuelve un manipulador para el contexto del dispositivo de visualización utilizado para dibujar en el área cliente; EndPaint finaliza la solicitud de pintura y libera el contexto del dispositivo.*/ 
PAINTSTRUCT ps; HDC hdc; TCHAR greeting[] = _T("Hello, Windows desktop!");
/* Nota esta secuencia se encuentra aqui al inicio o al final [caso de este codigo]: usando los punteros (hWnd, message, wParam, lParam) bien:
HWND hwnd
// obtiene el apuntador de la ventana de un grupo de ventanas
UINT msg 
// Contiene información de mensajes de la cola de mensajes de un hilo.
WPARAM wParam
LPARAM lParam

{
{
switch(msg){
case WM_CLOSE:
DestroyWindow(hwnd);
break;
case WM_DESTROY:
PostQuitMessage(0);
break;
default:
return DefWindowProc(hwnd, msg, wParam, lParam);
}
return 0;
}
*/
switch (message) 
{ 
case WM_PAINT: hdc = BeginPaint(hWnd, &ps);
// Here your application is laid out. 
// For this introduction, we just print out "Hello, Windows desktop!" 
// in the top left corner.
 TextOut(hdc,
5, 5,
greeting, _tcslen(greeting));

// End application-specific layout section.
 EndPaint(hWnd, &ps);
 break;
 case WM_DESTROY:
PostQuitMessage(0);
 break;
default:
 return DefWindowProc(hWnd, message, wParam, lParam);
 break;
} 
//-----[3.1]
 return 0; 
} 
//-----[3.2] 

ver

ver

Programa Java

[.java]

es un lenguaje de «escribir una vez, ejecutar en cualquier lugar», lo que significa que está diseñado para ejecutarse en cualquier plataforma que tenga una máquina virtual Java (JVM).

work environment.:
-Integrated Development Environments (IDEs):
Eclipse
Netbeans
Android Studio [para desarrollar aplicaciones para dispositivos Android en Java]

  Java Runtime Environment.  Es el software necesario para ejecutar aplicaciones Java en su equipo, no contiene las herramientas necesarias para escribir y compilar código Java en Java de aplicaciones de clase. El entorno de ejecución de Java es la capa de software que se utiliza para ejecutar aplicaciones Java. Contiene las bibliotecas, la Máquina Virtual de Java (JVM), y otros componentes necesarios para ejecutar aplicaciones Java.

 Java Development Kit:se necesitará adicionalmente el Kit de Desarrollo de Java.

[https://www.java.com/en/download/ ]

Compilacion: puede escribir un programa en Java (en cualquir editor de texto) y compilarlo sin descargar los  IDEs, pero si el Java Software Development Kit ( How to Install the Java Software Development Kit )
–abrir el símbolo del sistema o terminal para compilar el programa. Navegue a la carpeta donde guardó el archivo .java y  escribir javac filename.java

-ejecutar el archivo .java (filename.java) tipeando  en la consola java, su nombre sin extension y luego enter

c:\>javac filename.java
c:\>java filename

-*El https://www.codiva.io en un compilador web (necesita Iniciar sesión o crear una cuenta). Codiva es un compilador de Java en línea que es ideal para personas que no pueden instalar un compilador local—incluso puede ser utilizado en un teléfono o tablet.Hay una gran variedad de online compiladores si Codiva no funciona para sus necesidades. Algunas otras opciones populares son Jdoodle, y OnlineGDB.

Hello World program

el archivo se guarda (HelloWorld.java).

HelloWorld es el nombre de la clase y s

//=============================
// Hello World program

public class HelloWorld {
  //Declarar su clase, el nombre de clase  (class HelloWorld) debe ser el mismo nombre que el archivo guardado (HelloWorld.java).
    public static void main(String[] args) {
  // Declarar su método principal (public static void main(String[] args)). El método principal es el que se ejecutará cuando la programación se está ejecutando es declarado de la misma forma para todos los programas Java. 
  //Los métodos pueden ser llamados y corridos en instancias posteriores en el código
        System.out.println("Hello World.");
  //Escribir la línea de código que se va a imprimir "Hola Mundo". El  método consiste en que la clase "sistema" (System) activa una salida (out) de impresion [panel de salida, terminal o línea de comandos] de una linea (println), tomando un parámetro (el String "Hello World.").siempre separar con un punto y  agregar una coma al final de cada línea.
    }
}

Nota:
-Java es sensible a mayúsculas y minúsculas, por lo que debe escribir los nombres de método, los nombres de las variables, y los nombres de clase en el caso correcto o se producirá un error.
-Los bloques de código específico para un determinado método o bucle están encerrados entre llaves.

– La palabra clave «pública» de nuevo es el modificador de acceso. Ya que se establece para el «público» significa que este método puede ser llamado en cualquier lugar en el programa. Si se establece en «privado», esto significaría que el método sólo se podía acceder dentro de la clase. Público implica clases, subclases y paquetes. Privado implica solo clases y subclases.
-La palabra «static» indica que este miembro puede ser consultado antes de cualquier otro objeto en la clase y sin hacer referencia a otros objetos o instancias.
-La palabra «void» es el valor de retorno del método. Esto indica que no devuelve ningún valor. Si fuera para devolver un número, sería cambiado a «int» o «float» o «doble», dependiendo del tipo de valor que querían volver.
-Cuando se tiene cualquier texto entre paréntesis (es decir, String[] args{}), este se llama un argumento. Un argumento puede ser muchas cosas como un integer, double, float o chain (cadena). Esta línea de código indica que el método es una espera un argumento de tipo array (lista de objetos), que contiene las cadenas.
-La sangría al código no es necesariamente obligatoria.

cuando el usuario llega a entrar de entrada en el programa,  ahora vamos a extender el programa para:
-solicitar al usuario su nombre y,

-a continuación, saludar al usuario por su nombre.

//=============================
// tomar la entrada del usuario.

import java.util.Scanner;
  //la biblioteca Escáner de objetos que necesitamos para obtener la entrada del usuario. Con el fin de importar el  la clase de Escáner
  //Si queremos tener acceso a todos los objetos en java.util paquete, simplemente debemos escribir importar java.util.*; al principio de nuestro código.
Scanner userInputScanner = new Scanner(System.in);
  //Para utilizar el Escáner de clase, tenemos que crear un nuevo Escáner de objetos donde podemos rellenar los campos y usar los de los métodos 
  //userInputScanner es el nombre escrito en la convención para nombres de variables en Java.  
  //El operador new es usado para crear una nueva instancia del objeto Escáner, escrito como: new Scanner(System.in). 
  //El objeto Escáner  toma (in) un parámetro (System.in) que indica al programa que analice (Scanner) la entrada del sistema, que es la entrada que el usuario escribira en el programa.
System.out.print("What's your name? ");
  //Solicitar al usuario una entrada. Tenemos que pedir al usuario una entrada para que el usuario sepa cuando escrir algo en la consola. Esto se puede lograr con un System.out.print o un System.out.println. 
String userInputName = userInputScanner.nextLine();
  //Pedir al objeto Escáner tomar la siguiente línea que el usuario escribe (su nombre) y almacenarla en una variable. El Escáner esta siempre tomando en datos sobre lo que el usuario está escribiendo.
  //En Java, por convención se utiliza un  para nombrar métodos de objetos es objectName.methodName(parameters). Asi userInputScanner.nextLine(), llama al Escáner de objetos por el nombre que hemos dado y, a continuación, estamos llamando a su método nextLine(), que no toma ningun parámetro. 
  //Tener en cuenta que se almacena la línea siguiente en otro objeto: el objeto tipo String. Se ha llamado a este objeto: userInputName 
System.out.println("Hello " + userInputName + "!");
  //Imprimir un saludo para el usuario. el nombre del usuario almacenados, se usa para imprimir un saludo para el usuario. desde el System.out.println("Hello World.") escrito en la clase principal. Todo el escrito debe ir por encima de la línea. Ahora podemos modificar esa línea que diga:



 public class HelloWorld {  public static void main(String[] args) { Scanner userInputScanner = new Scanner(System.in); System.out.print("What's your name? "); String userInputName = userInputScanner.nextLine(); System.out.println("Hello " + userInputName + "!"); } }

Entre las etiquetas

<head> y </head>

del documento HTML, inserta el siguiente código JavaScript

(script de parpadeo en la cabecera del documento HTML)

El script solo afecta a elementos identificados como «announcement».

1000″ en el script establece el espacio de tiempo entre parpadeos en microsegundos.

Firefox no soporta las animaciones con CSS interno

<head>
function blinktext() {
  var f = document.getElementById('announcement');
  setInterval(function() {
    f.style.visibility = (f.style.visibility == 'hidden' ? '' : 'hidden');
}, 1000);
}
 </head> 
<body onload="blinktext();">. 
<p id="announcement">Texto parpadeante aquí.</p> 
<div id="announcement">Texto parpadeante aquí.</div>.