Compu Final 2

ESCUELA
POLITCNICA DEL
EJERCITO
CIENCIAS BSICAS
ELECTRNICA
MODO GRAFICO
Por:
Crdenas David
Donoso Sebastin
Armas Graciela
David Snchez
Fecha de entrega: 02/01/2006
DEDICATORIA
A este mundo, sus oportunidades y a las personas que nos apoyan.
Pag. 3
AGRADECIMIENTO
Agradecemos a todas las personas que hicieron posible la realizacin de

este trabajo y las diferentes fuentes que estuvieron a nuestra
disposicin.
Pag. 4
RESUMEN EJECUTIVO
Pag. 5
INDICE
DEDICATORIA............................................................................................................3
AGRADECIMIENTO....................................................................................................4
RESUMEN EJECUTIVO.............................................................................................5
INDICE........................................................................................................................6
OBJETIVOS................................................................................................................9
Monitor......................................................................................................................10
Tamao:.................................................................................................................11
Tubo: 11
Tamao de punto:..................................................................................................12
Frecuencia de refresco:.........................................................................................12
Resoluciones:............................................................................................................13
Otras consideraciones:..........................................................................................14
Pxel 15
Modo grfico..............................................................................................................16
Iniciar modo grfico...............................................................................................17
Los archivos BGI...................................................................................................18
Uso de coordenadas.............................................................................................20
Funciones de graficacin.......................................................................................20
Ejercicios...................................................................................................................27
Aplicacin a los juegos: Tiro al blanco..................................................................27
Solucin de una ecuacin no lineal por el mtodo de la Bisectriz:.......................42
Suministro de agua................................................................................................51
Volmenes de revolucin......................................................................................54
TIRO AL BLANCO.....................................................................................................67
Pag. 6
MANUAL DEL USUARIO......................................................................................67

Tabla de contenido................................................................................................68
INSTALACION DEL PROGRAMA DE JUEGO.....................................................68
MODO DE FUNCIONAMIENTO DEL PROGRAMA.............................................69
REQUERIMIENTOS DEL EQUIPO.......................................................................69
RESOLUCION DE PROBLEMAS.........................................................................69
INSTALACION DEL PROGRAMA DE JUEGO.........................................................69
MODO DE FUNCIONAMIENTO DEL PROGRAMA.............................................72
REQUERIMIENTOS DEL EQUIPO.......................................................................73
RESOLUCION DE PROBLEMAS.........................................................................74
CONCLUSIONES......................................................................................................75
RECOMENDACIONES.............................................................................................77
BIBLIOGRAFIA.........................................................................................................77
Pag. 7
Pag. 8
CAPITULO: Deber Conjunto
OBJETIVOS
Conocer todo lo referente a modo grafico sus caracteristicas y su

funcionamiento.
Cual es la manera de escribir estos comandos para su mayor

funcionamiento y provecho para el estudiante
Conocer las maneras de poder dibujar y presentar un buen programa

y amigable para el usuario
Pag. 9
Monitor
El monitor es una parte del ordenador a la que muchas veces no le damos la
importancia que se merece.
Hay que tener en cuenta que junto con el teclado y el ratn son las partes que
interactan con nuestro cuerpo, y que si no le prestamos la atencin
debida, podremos llegar incluso a perjudicar nuestra salud.
Evidentemente no en el caso de personas que hacen un so espordico, pero si
en programadores impenitentes o navegadores incansables, que puedan
pasarse muchas horas diarias al frente de la pantalla.
Vamos a explicar los parmetros que influyen en la calidad de un monitor:
Tamao:
El tamao de los monitores se mide en pulgadas, al igual que los televisores.
Hay que tener en cuenta que lo que se mide es la longitud de la diagonal,
Pag. 10

y que adems estamos hablando de tamao de tubo, ya que el tamao
aprovechable siempre es menor.
El tamao es importante porque nos permite tener varias tareas a la vez de
forma visible, y poder trabajar con ellas de manera cmoda.
Tambin es importante en el caso de que se manejen documentos de
gran tamao o complejidad, tales como archivos de CAD, diseo, 3D, etc
que requieren de gran detalle. En estos casos son aconsejables tamaos
de 21".
Tambin es importante tener en cuenta que con Windows 98 ya es posible
conectar varios monitores al mismo PC, por lo que en el caso de requerir
la visualizacin de varias tareas a la vez puede ser importante, por
ejemplo, sustituir un monitor de 27 pulgadas por dos de 15, que ser una
solucin ms barata y quizs ms cmoda.
Nunca hemos de aceptar menos de 15" (pulgadas). Hoy en da es el estndar, y
es lo mnimo exigible, adems de ser los que mejor precio ofrecen.
Tubo:
Otro aspecto importante es la marca del tubo y el tipo, as como otros detalles
relacionados con l. Fabricantes de monitores hay muchos, pero de tubos
son contados, con lo que si sabemos que modelo de tubo lleva nuestro
monitor sabremos ya bastantes cosas importantes de l.
Fabricantes de tubos son: Sony, Mitsubishi, Nec, Phillips, etc...
Y normalmente cada fabricante se identifica con un tipo de tubo, por ejemplo
Sony con el Trinitron (que sigue siendo punto de referencia), Mitsubishi
con el DiamondTron, etc...
Pag. 11

El tubo nos definir si la pantalla es ms o menos plana y cuadrada, el tamao
del punto (dot pix) si tiene tratamiento antirreflejos, etc...
Tambin nos servir para comparar entre diferentes marcas, ya que si
encontramos dos con el mismo tubo, pues ya sabemos que son iguales
en casi todas las caractersticas ms importantes, y por tanto no debera
haber mucha diferencia en cuanto a precio, a no ser que uno contara con
muchos aditivos como controles digitales y caractersticas multimedia y el
otro no. Tengamos presente que casi todo el coste del monitor es debido
al tubo.
Tamao de punto:
Esta es una de las caractersticas que depende del tubo, y define el tamao que
tendr cada uno de los puntos que forman la imagen, por tanto cuanto
ms pequeo ms preciso ser.
No hay que confundir el tamao de punto con el "pixel". El pixel depende de la
resolucin de la pantalla, y puede variar, mientras que el punto es fijo, y
depende exclusivamente del tubo.
Tamaos "normales" son alrededor de 0,28 mm. y es aconsejable que no sea de
mayor tamao, en todo caso menor, como los 0,25 de los tubos Trinitron.
Frecuencia de refresco:
Aqu si que podemos decir claramente que cuanto ms mejor. La frecuencia de
refresco est proporcionalmente ligada a la estabilidad de la imagen, y por
tanto al descanso y confort de nuestra vista.
Nunca deberamos escoger valores por debajo de los 75 Hz en modos de
1.024 x 768 puntos, aunque un valor ptimo sera de 90 Hz., que sera el
mnimo exigible en resoluciones menores.
Pag. 12

En resoluciones mayores, seguramente nos tengamos que conformar con
valores ms bajos.
Tambin hay que tener claro que la tarjeta de video debe ser capaz de
proporcionar esos valores, ya que de no ser as, de nada nos servir que
el monitor los soporte.
Resoluciones:
Resolucin de pantalla se denomina a la cantidad de pixels que se pueden
ubicar en un determinado modo de pantalla. Estos pixels estn a su vez
distribuidos entre el total de horizontales y el de verticales.
Todos los monitores pueden trabajar con mltiples modos, pero dependiendo del
tamao del monitor, unos nos sern ms tiles que otros:
A nivel general se recomienda lo siguiente:
Tamao en
pulga
Resoluciones recomendables
das
14
640 x 480
800 x 600
15
800 x 600
1.024 x 768
17
1.024 x 768
1.280 x 1.024
19
1.280 x 1.024
1.600 x 1.024
21
1.600 x 1200
1.280 x 1200
Pag. 13

Cuando hablamos de resoluciones, hay que decir lo mismo que con las
frecuencias de refresco, si nuestra tarjeta de video no las soporta, no
podremos usarlas.
Hay que tener mucho cuidado de que estas resoluciones se obtengan de
manera "no entrelazada", ya que sino, la calidad de la imagen se resiente
de una forma inaceptable, reduciendo la frecuencia de refresco REAL a la
mitad.
Otras consideraciones:
Es habitual encontrarse con monitores "digitales". Este calificativo lo reciben los
monitores que basan sus ajustes (como el brillo y el contraste) en unos
pulsadores que permiten cambiar sus valores, en contraposicin con los
mandos analgicos que incorporaban los monitores ms antiguos, en
donde debes girar una pequea ruedecilla para modificar estos
parmetros.
Tienen importantes ventajas reales, como por ejemplo poder fijar para
cada frecuencia los ajustes pertinentes, y que no se "desajusten" de
nuevo al cambiar de resolucin.
Otra consideracin es el tipo de conector, que en ambientes domsticos y de
oficina es el estndar de 15 pines marcado por IBM con su VGA, pero en
entornos especializados en donde es imprescindible contar con monitores
de gran tamao y calidad, se hace necesario contar con los 5 conectores
BNC, que ofrecen una mayor proteccin frente a interferencias, y por
tanto una mayor calidad de imagen.
Tampoco hemos hablado de las pantallas TFT, ya que aunque empiezan a ser
estndar en monitores de ordenadores porttiles, para ordenadores
"desktop" todava son una opcin demasiado cara, aunque al ritmo que
Pag. 14

vamos quizs no tardemos mucho en conseguir que sea un opcin viable
(y muy buena).
En el apartado de Software, encontraremos un programa muy bueno, de la casa
Nokia, que nos permitir ajustar nuestro monitor para sacarle el mximo
rendimiento, y a su vez comprobar su calidad.
Pxel es la abreviatura de la expresin inglesa Picture Element (Elemento de
Imagen), y es la unidad ms pequea que encontraremos en las
imgenes compuestas por mapa de bits.
El pxel es la unidad mnima en que se divide la retcula de la pantalla del
monitor y cada uno de ellos tiene diferente color.
Su tono de color se consigue combinando los tres colores bsicos (rojo, verde y
azul) en distintas proporciones.
Un pxel tiene tres caractersticas distinguibles:
Forma cuadrada
Posicin relativa al resto de pxeles de un mapa de bits.
Profundidad de color (capacidad para almacenar color), que se expresa

en bits.
Una imagen bitmap o mapa de bits, esta compuesta por pequeos puntos o
pixeles con unos valores de color y luminancia propios. El conjunto de
esos pixeles componen la imagen total.
Para que un ordenador dibuje un grfico de mapa de bits, debe recibir un
conjunto de instrucciones para cada uno de esos puntos (cada bits de
datos) que constituyen la imagen
Pag. 15
Modo grfico
Cuando no usamos modo grfico (usando modo texto) la salida de nuestros

programas son caracteres (letras) con un limitado nmero de estos en
una pantalla; generalmente 80x24 caracteres. Al usar el modo grfico en
nuestras aplicaciones configuramos la pantalla (salida) para soportar
dibujado por pixeles; es decir, en realidad no mandamos letras a la salida
sino puntos de colores en determinadas posiciones. Esto nos permite
mandar figuras ms elaboradas a la salida de las aplicaciones: grficos.
Un programa en modo grfico tiene un esquema que consta de tres etapas:

inicio de mdo grfico, ejecucin del programa (la aplicacin en s) y
cierre de modo grfico. El establecimiento solamente se tiene que hacer
una sola vez en toda la aplicacin; mientras este no sea cerrado la
aplicacin seguir en l, no importa si la ejecucin est en el main() o en
alguna otra funcin.
Las funciones que controlan el modo grfico estn en la biblioteca graphics.h,

por eso es necesario que todo programa que quiera usar esta herramienta
incluya dicho archivo:
#include < graphics.h >
Iniciar modo grfico
Pag. 16

Para iniciar el modo grfico (de forma estndar) se utiliza una secuencia de
instrucciones, por eso es recomendable ocupar una funcin que agrupe
este proceso. Veamos la secuencia de comandos:
1: int gdriver = DETECT, gmode;

2: initgraph(&gdriver, &gmode,"C:\\TC\\BGI");
3: if (graphresult()!= grOk) {printf("\nERROR AL INICIAR MODO GRAFICO ");
exit(1);}
En la primera lnea declaramos dos variables enteras: gdriver y gmode. La

primera de estas la iniciamos con DETECT, una macro definida que indica
que el tipo de modo grfico sea auto-detectado por el programa.
En la segunda lnea hacemos la llamada a la funcin initgraph la cual establece

propiamente el modo grfico en la pantalla. A dicha funcin le pasamos
los parmetros gdriver y gmode como referencia y una cadena donde le
damos la ruta relativa o absoluta de un directorio donde tenemos los
archivitos controladores del modo grfico: los famosos BGI (ms adelante
vamos a ver esta cosa).
En la tercera lnea del cdigo verificamos que efectivamente el modo grfico se

ha activado. Para esto verificamos que el valor de la funcin graphresult
sea igual a grOK (grOK es otra macro definida). Si hubo algn problema
con la activacin del modo grfico mandamos un error y finalizamos el
programa.
Pag. 17
Con el cdigo anterior se iniciara el modo grfico de una aplicacin con

640x480 pixeles de resolucin a 16 colores (ms adelante trataremos la
resolucin y los colores).
Los archivos BGI
Los archivos BGI son los controladores del modo grfico, dichos archivos
generalmente se encuentran en una carpeta llamada BGI dentro del
directorio en el cual instalamos nuestro compilador. Por ejemplo: TC\BGI,
BC\BGI, BORLANDC\BGI, etc. Es indispensable saber donde se ubican
dichos archivos para iniciar el modo grfico, pues hay que indicar la ruta
relativa o absoluta a la hora de iniciar el modo grfico. Es muy
recomendable utilizar una macro para especificar esta carpeta, pues eso
har ms fcil la modificacin de nuestro cdigo.
En muchos de los programas de cdigo abierto que encontrars en este portal

definen esta macro como RUTA_BGI. Para compilar y ejecutar un
programa en modo grfico tienes que escribir la ruta de tus archivos BGI
en esta macro. Por ejemplo:
#define RUTA_BGI "C:\\TC\\BGI"
Dibujando
La resolucin es el nmero de puntos (pixeles) que posee la pantalla (salida).

Cuando hablamos de una resolucin de 640x480 pixeles estamos
diciendo que tenemos 640 puntos a lo ancho de la pantalla y 480 a lo alto.
Pag. 18
Cuando dibujamos en modo grfico indicamos mediante funciones las diferentes

formas que queremos que aparezcan en pantalla. A estas funciones les
pasamos como parmetros coordenadas y tamaos; as estamos
dibujando como en un plano cartesiano cuyas dimensiones estn
determinadas por la resolucin de la pantalla.
Por ejemplo si queremos dibujar un circulo en las coordenadas [100,80] con un
radio de 50 pixeles usaramos la siguiente funcin:
circle(100,80,50);
Tambin mediante funciones podemos definir los colores y estilos con los cuales
deseamos dibujar en nuestra pantalla. Por ejemplo si quisiramos definir
el color azul en el contorno de las figura usaramos:
setcolor(BLUE);
Donde BLUE es una macro definida que representa el color azul, la cual
pasamos como parmetro a la funcin que establece el color. Despus de
escribir esta lnea toda figura que dibujemos tendra el contorno azul, sin
embargo todas aquellas formas que ya hayamos dibujado con
anterioridad conservaran su apariencia.
Todas las funciones para pintar y definir apariencias estn incluidas en la ayuda
de nuestro compilador, basta con ver la seccin de ayuda correspondiente
a la biblioteca graphics.h.
Al igual que la activacin del modo grfico el cierre de este solamente se tiene
que hacer una sola vez, generalmente al finalizar el programa. Para cerrar
el modo grfico solo es necesario hacer una llamada a la funcin:
closegraph();
Pag. 19
Cerrar el modo grfico no es indispensable, pero es una prctica sana ya que

liberamos recursos de nuestra mquina que se emplearon en nuestro
programa y ya no ocupamos.
Uso de coordenadas
Una vez que se inicializa el monitor en modo grfico, las coordenadas tienen al
pxel como unidad de medida. La funcin getmaxx() calcula la cantidad de
pxeles por rengln y la funcin getmaxy() calcula la cantidad de
renglones de la pantalla.
Las funciones de grficos tienen como estndar el orden de manejo de
coordenadas como columna, rengln; es decir, primero se anota la columna y
despus el rengln para posicionarse en dicha coordenada.
Funciones de graficacin
Sera muy difcil considerar todas las opciones posibles de todas las funciones
de graficacin; sin embargo, en esta antologa se tratan los temas
fundamentales para implementar este tipo de funciones. Bsicamente
mostraremos que antes de utilizar un color, un tipo de lnea, de relleno,
etc. es necesario definirlo.
Pxeles, lneas, figuras geomtricas, colores y rellenos
En esta seccin se presentan las funciones bsicas de graficacin, utilizadas

para colocar pixeles, lneas, figuras geomtricas, etc. en la pantalla.
Pag. 20

La funcin putpixel()
Tal como se mencion en la seccin anterior, al habilitar el monitor en modo

grfico, la pantalla se divide en pequeos puntos llamados pixeles.
La funcin putpixel() coloca un punto o pxel de un color especfico en
determinada coordenada de la pantalla. Esta funcin requiere 3
argumentos:
1) Columna del punto (coordenada x).
2) Rengln del punto (coordenada y).
3) Color del pxel.
putpixel(int x, int y, int color);
La funcin line()
*/
#include <graphics.h> // Encabezado con declaraciones de
graficos
#include <conio.h> // Para el uso de kbhit()
#include <stdlib.h> // Para el uso de random()
#include <dos.h>
// Para el uso de delay
void main(void)
{
int monitor=VGA, modo=VGAHI; // Declaracion de tipo de monitor
y modo
initgraph(&monitor,&modo,"\\tc\\bgi");
Pag. 21

// Inicializa el modo grafico indicando el monitor y modo
utilizado
// El subdirectorio \\tc\\bgi indica la ruta de localizacion de
los
// archivos *.BGI (monitores) y *.CHR (tipos de letras)
while(!kbhit()) // Mientras no se oprima cualquier tecla
{
putpixel(random(getmaxx()),random(getmaxy()),random(getmaxcolor
()));
// Coloca un pixel en la pantalla, seleccionando al azar la
columna
// (1..getmaxx), el renglon (1..getmaxy) y el color
(1..getmaxcolor)
delay(5);
}
closegraph(); // Termina el modo grafico (vuelve a su modo
normal)
}
La funcin setlinestyle()
Esta funcin se utiliza para determinar el tipo de lnea o trazo que se desea. Se
pueden utilizar trazos con lnea continua, lnea punteada, lnea
interrumpida, o un patrn de lnea definido por el usuario. Esta funcin
requiere 3 argumentos:
1) Tipo de lnea: Puede ser SOLID_LINE, DOTTED_LINE, CENTER_LINE,
Pag. 22

DASHED_LINE o USERBIT_LINE.
2) Patrn: Este argumento regularmente es ignorado (excepto cuando se trata
de un
tipo de lnea definido por el usuario).
3) Ancho de lnea: Define la amplitud del trazo.
setlinestyle(DOTTED_LINE,0, NORM_WIDTH);
line(50,100,300,200);
La funcin circle()
Esta funcin dibuja un crculo y requiere 3 argumentos:
1) Coordenada de la columna del centro (en pixeles).
2) Coordenada del rengln del centro (en pixeles).
3) Radio del crculo (en pixeles).
La funcin rectangle()
Esta funcin dibuja un rectngulo indicando las coordenadas de las esquinas
superior izquierda e inferior derecha respectivamente.
La funcin ellipse()
Se usa esta funcin para dibujar un arco elptico o una elipse completa. Esta
funcin requiere 6 argumentos:
1) Columna del centro de la elipse (coordenada x).
2) Rengln del centro de la elipse (coordenada y).
3) ngulo inicial del arco.
4) ngulo donde termina el arco.
Pag. 23

5) Radio horizontal de la elipse.
6) Radio vertical de la elipse.
Se puede dibujar una elipse completa indicando el ngulo inicial como 0 (cero)
y
el ngulo final como 359 . La Fig. 12 dibuja una elipse completa con centro en
100,150,
con radio horizontal de 25 y radio vertical de 40 pixeles.
La funcin arc()
Se usa esta funcin para dibujar un arco circular. Esta funcin requiere 5
argumentos:
1) Columna del centro del arco (coordenada x).
2) Rengln del centro del arco (coordenada y).
3) ngulo inicial del arco.
4) ngulo donde termina el arco.
5) Radio.
Los puntos de inicio y final del arco se especifican por medio de sus ngulos
medidos en el sentido de las manecillas del reloj; es decir, con 0 en las 3:00,
90 en las
12:00 y as sucesivamente.
La funcin setcolor()
Se utiliza esta funcin para definir el color de los trazos siguientes; es decir,
antes de dibujar un trazo de un color especfico, ste debe definirse. Esta
Pag. 24

funcin slo tiene un argumento que representa el cdigo del color
deseado. P. ejem. BLACK, RED,
BLUE, GREEN, YELLOW, etc. o bien su nmero entero correspondiente. La
muestra la tabla de colores y sus respectivos valores.
BLACK 0
DARKGRAY 8
BLUE 1
LIGHTBLUE 9
GREEN 2
LIGHTGREEN 10
CYAN 3
LIGHTCYAN 11
RED 4
LIGHTRED 12
MAGENTA 5
LIGHTMAGENTA 13
BROWN 6
YELLOW 14
LIGHTGRAY 7
WHITE 15
Definiendo el tipo de relleno de una figura con la funcin setfillstyle()

Si se desea rellenar una figura, es necesario definir previamente el patrn y color
del relleno. La Fig. muestra los patrones de relleno disponibles.
EMPTY_FILL 0
SLASH_FILL 4
Color del fondo
Relleno con /// lneas
SOLID_FILL 1
BKSLASH_FILL 5
Relleno slido con el color
Relleno con \\\ lneas
determinado
LTBKSLASH_FILL 6
LINE_FILL 2
Relleno con lnea (---)
Relleno con \\\ lneas de ancho

normal
LTSLASH_FILL 3
HATCH_FILL 7
Relleno con /// lneas de ancho
Relleno de lneas cruzadas ligeras
normal
XHATCH_FILL 8
Pag. 25

Relleno de lneas cruzadas gruesas
INTERLEAVE_FILL 9
Relleno de lneas
WIDE_DOT_FILL 10
Relleno de puntos espaciados
CLOSE_DOT_FILL 11
Relleno de puntos cercanos
USER_FILL 12
Pag. 26
La funcin floodfill()
Una vez seleccionado el patrn de relleno mediante la funcin
setfillstyle(), se procede a rellenar una figura usando la funcin floodfill().
Es muy importante resaltar que la figura que se desea rellenar est
completamente cerrada, ya que esta funcin contiene un algoritmo
que busca el contorno de la figura y, en caso de encontrar una
apertura, la funcin extralimitar la figura y tambin rellenar la parte
externa de la misma. La funcin floodfill() requiere identificar un punto
que se encuentre dentro del contorno de la figura y necesita 3
argumentos:
1) Coordenada de la columna del punto interno de la figura.
2) Coordenada del rengln del punto interno de la figura.
3) Color del borde de la figura.
Ejercicios
Aplicacin a los juegos: Tiro al blanco

Lenguaje de programacin
#include<graphics.h>
#include<conio.h>
#include<stdio.h>
#include<stdlib.h>
#include<ctype.h>
#include<stdarg.h>
#include<dos.h>
#include<math.h>
int ControladorG, ModoG, ErrorG; /*VARIABLES PARA EL MODO

GRAFICO*/
int radio, radio1, radio2;
int xxx[5];
int yyy[5];
int puntaje[4]= {0,0,0,0}; /*esto ayuda para discernir el puntaje final*/
/*Esta funcion permite inicializar el modo grafico*/
void inicializar()
{
ControladorG= DETECT;
initgraph( &ControladorG , &ModoG, "BGI");
ErrorG = graphresult();
if(ErrorG!=grOk )
{
printf("\nError al inicializar el modo gr fico...\n%s",grapherrormsg(ErrorG) );
getch();
exit(1);
}
}
//640 x 480 es la resolucion de pantalla
int gprintf( int xloc, int yloc, char *fmt, ... )

{
va_list argptr;
/* lista de argumentos */
char str[140];
/* Buffer para las cadenas */
int cnt;
/* Resultado de SPRINTF */
va_start( argptr, fmt );
/* Inicializa las va_ functions
*/
cnt = vsprintf( str, fmt, argptr );
/* imprime la cadena al buffer
*/
outtextxy( xloc, yloc, str ); /* Enviar la cadena al modo grafico */

yloc += textheight( "H" ) + 2;
/* Avance hacia la siguiente linea */
va_end( argptr );
/* cierra va_ functions */
return( cnt );
/* Retorna la cuenta de conversion */
/*Esta funcion dibuja un cuadro de texto para ingresar datos*/
void caja_texto(char *nombre,int numr )

{
int cuadro[8]; //posicion del cuadro de texto

int i, x;
char cadena[30];

char *cad;
//setwritemode( OR_PUT);
setbkcolor(9);
setcolor(LIGHTRED);
cuadro[0]= 5;
cuadro[1]= 13;
cuadro[2]= 320;
cuadro[3]= 13;
cuadro[4]= 320;
cuadro[5]= 110;
cuadro[6]= 5;
cuadro[7]= 110;
setfillstyle(INTERLEAVE_FILL,LIGHTBLUE );
fillpoly( 4, cuadro );
setcolor( LIGHTGREEN);
settextstyle( 6,0, 1);
gprintf( 20, 50,"%s",nombre );
cuadro[0]= 90;
cuadro[1]= 48;

cuadro[2]= 290;
cuadro[3]= 48;
cuadro[4]= 290;
cuadro[5]= 75;
cuadro[6]= 90;
cuadro[7]= 75;
setfillstyle( 1, 15 );
fillpoly(4, cuadro);
settextstyle(2, 0, 5);
setcolor(MAGENTA);
/*Este bucle sirve para ingresar los valores*/
for( i = 0, x=110; i <25; ++i, x+=7 )

{
cadena[i]= toupper(getche());
if( i==25) getch();
if( cadena[i] =='\r' )
break;
if( ( cadena[i]=='\b') && (x>110) && (i>=0) )
{
i= i-1;
x= x-7;
setcolor(15);

cuadro[0]= x;
cuadro[1]= 53;
cuadro[2]= x+7;
cuadro[3]= 53;
cuadro[4]= x+7;
cuadro[5]= 68;
cuadro[6]= x;
cuadro[7]= 68;
setfillstyle( 1, 15 );
fillpoly( 4, cuadro );
x= x-7;
setcolor(MAGENTA)
;
continue;
}
/*en esta parte convierto los datos ingresados a char*/

sprintf( cad,"%c", cadena[i]);
outtextxy( x, 53, cad );
}
switch(numr)
{

case 1:
radio1=atoi(cadena);
break;
case 2:
radio2=atoi(cadena);
break;
case 3:
xxx[0]=atoi(cadena);
break;
case 4:
yyy[0]=atoi(cadena);
break;
case 5:
break;
case 6:
break;
case 7:
break;
case 8:
break;
case 9:

break;
case 10:
break;
case 11:
break;
case 12:
break;
}
}
/*Esta funcion dibuja las circunferencias respectivos con los radios*/

void dibujar_circulo(int r)
{
settextstyle(2, 0, 5);
circle (getmaxx()/2,getmaxy()/2,r); /*dibuja una circunferencia*/
}
/*Esta funcion borra la pantalla*/

void limpia_pantalla()
{
cleardevice(); /*Limpia la pantalla*/

setbkcolor(9); /*Pone un color de fondo*/
struct PTS {
int x, y;
};
/* estructura para los puntos del pentagrama
#define MAXPTS
#define PI 3.141516
void dibujar_pentagrama()
{
/*????*/
double AspectRatio;
int xasp, yasp;
getaspectratio(&xasp,&yasp);
AspectRatio=(double)xasp/(double)yasp;
struct viewporttype vp;

struct PTS points[MAXPTS];
int i, j, h, w, xcenter, ycenter;
int radius, angle, step;
double rads;
*/
getviewsettings( &vp );
xcenter=getmaxx()/2;
ycenter=getmaxy()/2;
radius=radio1; /*este es el radio menor */

step
= 360 / MAXPTS;
angle = 0;
/* Determiae el # de incrementos */
/* Begin at zero degrees
for( i=0 ; i<MAXPTS ; ++i ){
*/
/* Determine circle intercepts
rads = (double)angle * PI / 180.0;
/* Convert angle to radians */
points[i].x = xcenter + (int)( cos(rads) * radius );

points[i].y = ycenter - (int)( sin(rads) * radius * AspectRatio );
angle += step;
/* Move to next increment */
circle( xcenter, ycenter, radius ); /* Draw bounding circle
for( i=0 ; i<MAXPTS ; ++i ){

for( j=i ; j<MAXPTS ; ++j ){
*/
/* Draw the cords to the circle */

/* For each remaining intersect */
moveto(points[i].x, points[i].y); /* Move to beginning of cord
lineto(points[j].x, points[j].y); /* Draw the cord
*/
*/
*/

}
}
void dibuja_punto( int x,int y, int colorr)

{ putpixel(x,y,colorr);
putpixel(x+1,y,colorr);
putpixel(x,y+1,colorr);
putpixel( x+1,y+1,colorr);
putpixel( x-1,y-1,colorr);
putpixel(x-1,y,colorr);
putpixel(x,y-1,colorr);
}
/*Esta funcioncilla calcula el score del jugador*/

void calcula_marcador()
{
int centrox, centroy;

centrox = getmaxx()/2;
centroy= getmaxy()/2;
for(int v=0;v<=4;v++)
{

if(xxx[v]< centrox+ (radio1/3) && xxx[v] > centrox - (radio1/3) && yyy[v] >
centroy - (radio1/3) && yyy[v] < centroy + (radio1/3) )
puntaje[0]=puntaje[0]+5;
else
{
if(xxx[v]< centrox+ (radio1/2) && xxx[v] > centrox - (radio1/2) && yyy[v] >
centroy - (radio1/2) && yyy[v] < centroy +(radio1/2) )
else
{
if(xxx[v]< centrox+ (radio1) && xxx[v] > centrox - (radio1) && yyy[v] >
centroy - (radio1) && yyy[v] < centroy + radio1 )
else
{
if(xxx[v]< centrox+ (radio2) && xxx[v] > centrox - (radio2) && yyy[v] >
centroy - (radio2) && yyy[v] < centroy + radio2 )
}
}
}
}/*fin del for*/
}
void dibuja_marcador()
{
setcolor(15);
gprintf(250,100, "EL MARCADOR ES:");

gprintf(250,120, "Zona 1:
%d",puntaje[0]);
%d",puntaje[1]);
%d",puntaje[2]);
%d",puntaje[3]);
gprintf(250,200, "TOTAL :
%d",puntaje[0]+puntaje[1]+puntaje[2]+puntaje[3]);
void main() {
inicializar();
/* llama al mtodo inicializar */
caja_texto("Radio1:",1);
caja_texto("Radio2:",2);
limpia_pantalla();
dibujar_circulo(radio1);
dibujar_pentagrama();
getch();
limpia_pantalla();
caja_texto("Coord X1:",3);
caja_texto("Coord Y1:",4);

limpia_pantalla();
dibuja_punto(xxx[0],yyy[0],2);
getch();
limpia_pantalla();
limpia_pantalla();
getch();
limpia_pantalla();
limpia_pantalla();

getch();
limpia_pantalla();
limpia_pantalla();
getch();
limpia_pantalla();
limpia_pantalla();

getch();
limpia_pantalla();
calcula_marcador();
dibuja_marcador();
getch();
}
Solucin de una ecuacin no lineal por el mtodo de la Bisectriz:

Lenguaje de programacin
#include <iostream.h>
#include <graphics.h>
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>
#include <math.h>
#include <string.h>
int main(void)
{
int gdriver = DETECT, gmode, errorcode, gx, gy, gc, inicior, i, xp, yp,
cp,escala;
char op;

float a,b,intmin,intmax,error,xi,yi,incremento,errori,inta,intb,intm,ya,yb,ym;
char *msg, *msg1;
a=1;
b=0.2;
intmin=0.001;
intmax=1;
error=0.001;
escala=200;
do
{
initgraph(&gdriver, &gmode, "");
errorcode = graphresult();
gx=getmaxx();
gy=getmaxy();
if (errorcode != grOk)
{
printf("Error al cargar unidad gr fica: %s\n", grapherrormsg(errorcode));
printf("Presione una tecla para continuar");
getch();
exit(1);
}
cleardevice();
setcolor(1);
bar(0,0,gx,gy);
/* return with error code */

setcolor(6);
rectangle(10,10,40,gy-10);
rectangle(gx-10,10,gx-50,gy-10);
rectangle(0,0,gx,gy);
rectangle(2,2,gx-2,gy-2);
settextjustify(1,1);
settextstyle(1,0,2);
outtextxy(gx/2,20,"Escuela Politcnica del Ecuador");
outtextxy(gx/2,50,"Trabajo de Programacin");
settextjustify(0,0);
outtextxy(100,110,"1.- Ingresar valor de a");
outtextxy(100,140,"2.- Ingresar el valor de b");
outtextxy(100,170,"3.- Ingresar el valor de intelvalo mnimo");
outtextxy(100,200,"4.- Ingresar el valor de intervalo m ximo");
outtextxy(100,230,"5.- Ingresar el valor del error admitido");
outtextxy(100,260,"6.- Graficar la ecuacin");
outtextxy(100,290,"7.- Salir del programa");
rectangle(100,320,gx-100,460);
outtextxy(gx/2-50,330,"DATOS DEL PROGRAMA");
gcvt(a,10,msg);
outtextxy(120,345,"a = ");
outtextxy(160,345,msg);
gcvt(b,4,msg);

outtextxy(120,360,"b = ");
gcvt(intmin,10,msg);
outtextxy(120,375,"Int. mnimo = ");
gcvt(intmax,10,msg);
outtextxy(120,390,"Int. m ximo = ");
gcvt(error,10,msg);
outtextxy(120,405,"Error mnimo = ");
op=getch();
if (op=='1')
{
closegraph();
printf("Ingrese el valor de a: ");
cin>>a;
}
if (op=='2')
{
closegraph();
printf("Ingrese el valor de b: ");
cin>>b;

}
if (op=='3')
{
closegraph();
printf("Ingrese el valor del intervalo mnimo: ");
cin>>intmin;
}
if (op=='4')
{
closegraph();
printf("Ingrese el valor del intervalo m ximo: ");
cin>>intmax;
}
if (op=='5')
{
closegraph();
printf("Ingrese el valor del m ximo error permitido: ");
cin>>error;
}
if (op=='6')
{
cleardevice();

setcolor(4);
for (i=0;i<=20;i++)
{
line(i*escala/10,0,i*escala/10,escala*2);
line(0,i*escala/10,escala*2,i*escala/10);
}
setcolor(7);
rectangle(0,0,escala*2,escala*2);
rectangle(escala*2,0,escala*2+100,escala*2);
rectangle(escala*2+100,0,escala*2+200,escala*2);
rectangle(escala*2,0,escala*2+200,20);
outtextxy(escala*2+50,15,"X");
outtextxy(escala*2+150,15,"Y");
line(escala,0,escala,escala*2);
line(0,escala,escala*2,escala);
for (xi=intmin;xi<=intmax;xi=xi+0.0001)
{
yi=(a*xi*sin(1/xi))-b*exp(-xi);
putpixel(escala+xi*escala,escala-yi*escala,10);
}
i=0;
incremento=(intmax-intmin)/36;
for (xi=intmin;xi<=intmax;xi=xi+incremento)
{
i++;

yi=(a*xi*sin(1/xi))-b*exp(-xi);
gcvt(xi,10,msg);
outtextxy(410,i*10+20,msg);
gcvt(yi,10,msg);
}
i++;
yi=(a*intmax*sin(1/intmax))-b*exp(-intmax);
gcvt(intmax,10,msg);
gcvt(yi,10,msg);
inta=intmin;
intb=intmax;
intm=(intmin+intmax)/2;
i=0;
do
{
i++;
intm=(inta+intb)/2;
ya=(a*inta*sin(1/inta))-b*exp(-inta);
ym=(a*intm*sin(1/intm))-b*exp(-intm);
yb=(a*intb*sin(1/intb))-b*exp(-intb);
errori=ym;
if (errori<0) errori=-errori;

setcolor(getmaxcolor());
bar(1,402,600,gy);
setcolor(0);
gcvt(ya,10,msg);
outtextxy(20,430,"a");
gcvt(inta,10,msg);
gcvt(ym,10,msg);
outtextxy(120,430,"m");
gcvt(intm,10,msg);
gcvt(yb,10,msg);
outtextxy(220,430,"b");
gcvt(intb,10,msg);
gcvt(errori,10,msg);
outtextxy(320,430,"Error");
itoa(i,msg,10);
outtextxy(420,430,"Iteraccin");
if (ya<0)

{
if (ym>0)
intb=intm;
else
inta=intm;
}
else
{
if (ym<0)
intb=intm;
else
{
inta=intm;
}
}
getch();
}while (errori>error);
outtextxy(gx/2-100,470,"SOLUCION ENCONTRADA...!");
getch();
}
}while (op!='7');
return 0;
}

Suministro de agua
#include<stdlib.h>
#include<stdio.h>
#include<conio.h>
#include<math.h>
#include<dos.h>
#define E 2.7182818
#define PI 3.14156564
void main()
{
long float a,b,c,d,e,f,g,h,ta,rd,ca,bm,cd,ct,C_ab,C_cd,C_ef,C_gh;
char k;
do
{
clrscr();
printf("CALCULO DEL MINIMIO COSTO DE ABASTECIMIENTO DE UNA
CIUDAD");
printf("\n\n Ingrese el minimo abastecimiento para la ciudad: ");
scanf("\t%lf",&ta);
while(ta<0)
{
printf("\nEl abastecimiento de la ciudad no es negativo");
printf("\nReingreselo: ");
scanf("%lf",&ta);
}
do
{
printf("\n Ingrese la maxima cantidad que pasa por el deposito local:\t");
scanf("%lf",&rd);
while(rd<0)
{
printf("\nEl abastecimiento del deposito no es negativo");
scanf("%lf",&rd);
}
do
{
printf("\n Ingrese el MAXIMA cantidad que pasa por la TUBERIA,\n\nno
olvide que la suma de los dos caudales sera\n mayor o igual a la necesidad
de la ciudad:\t");
scanf("%lf",&ca);
while(ca<0)
{
printf("\nLa cantidad maxima de agua por la tuberia no es
negativa");
printf("\nReingresela: ");
scanf("%lf",&ca);
}
printf("\n Ingrese la MINIMA cantidad de agua que puede pasar por la

TUBERIA:\t");
scanf("%lf",&bm);
while(bm<0)
{
printf("\nLa cantidad minima de agua por la tuberia no es negativa");
scanf("%lf",&bm);
}
}
while(ca<bm);
}
while((ca+rd)<ta);
printf("\n Ingrese el costo por enviar por el deposito local:\t");
scanf("%lf",&cd);
while(cd<0)
{
printf("\n Ingrese el costo dicho costo positivo:\t");
scanf("%lf",&cd);
}
printf("\n Ingrese el costo por enviar por la tuberia:\t");
scanf("%lf",&ct);
while(ct<0)
{
printf("\n Ingrese dicho costo positivo:\t");
scanf("%lf",&ct);
}
b=bm;
a=ta-b;
d=ca;
c=ta-d;
f=ca;
e=rd;
h=bm;
g=rd;
C_ab=a*cd+b*ct;
C_cd=c*cd+d*ct;
C_ef=e*cd+f*ct;
C_gh=g*cd+h*ct;
int gdriver = DETECT, gmode, errorcode;
int midx, midy;
initgraph(&gdriver, &gmode, "..//BGI");
errorcode = graphresult();
if (errorcode != grOk)
{
printf("Graphics error: %s\n", grapherrormsg(errorcode));
printf("Press any key to halt:");

getch();
exit(1);
}
midx = getmaxx() / 4;
midy = getmaxy()-midx;
setcolor(5);
line(midx,0,midx,getmaxy());
line(0,midy,getmaxx(),midy);
setcolor(2);
line((midx+a*15),(midy-b*15),(midx+c*15),(midy-d*15));
line((midx+a*15),(midy-b*15),(midx+g*15),(midy-h*15));
line((midx+e*15),(midy-f*15),(midx+c*15),(midy-d*15));
line((midx+g*15),(midy-h*15),(midx+e*15),(midy-f*15));
gotoxy((midx+a*15),(midy-b*15));
printf("Los puntos criticos son:");
printf("\ndeposito local\ttuberia");
printf("\n%.2lf\t\t%.2lf",a,b);
gotoxy((midx+c*15),(midy-d*15));
printf("\n%.2lf\t\t%.2lf",c,d);
gotoxy((midx+e*15),(midy-f*15));
printf("\n%.2lf\t\t%.2lf",e,f);
gotoxy((midx+g*15),(midy-h*15));
printf("\n%.2lf\t\t%.2lf",g,h);
getch();
closegraph();
if(C_ab<=C_cd&&C_ab<=C_ef&&C_ab<=C_gh)
{
printf("\n\nEl menor costo es:\t%lf por dia",C_ab);
printf("\nla cantidad que pasa por el deposito es: %lf",a);
printf("\nla cantidad que pasa por la tuberia es: %lf",b);
}
else
{
if(C_cd<=C_ab&&C_cd<=C_ef&&C_cd<=C_gh)
{
printf("\nEl menor costo es:\t%lf por dia",C_cd);
printf("\nla cantidad que pasa por el deposito es: %lf",c);
printf("\nla cantidad que pasa por la tuberia es: %lf",d);
}
else
{
if(C_ef<=C_cd&&C_ef<=C_ab&&C_ef<=C_gh)
{
printf("\nEl menor costo es:\t%lf por dia",C_ef);
printf("\nla cantidad que pasa por el deposito es: %lf",e);
printf("\nla cantidad que pasa por la tuberia es: %lf",f);
}
else
{
printf("\nEl menor costo es:\t%lf por dia",C_gh);
printf("\n\nla cantidad que pasa por el deposito es: %lf",g);

printf("\n\nla cantidad que pasa por la tuberia es: %lf",h);
}
}
}
getch();
clrscr();
printf("DESEA EJECUTAR EL PROGRAMA DENUEVO: (S/N)\t");
scanf("%s",&k);
getch();
clrscr();
}
while(k=='s'||k=='S');
}
Volmenes de revolucin.
#include<iostream.h>
#include<stdio.h>
#include<conio.h>
#include<stdlib.h>
#include<math.h>
#include<complex.h>
void main()
{
clrscr();
int

a=0,x=0,y=0,op=0,r=0,i=0,c=0,h=0,x1=0,y1=0,y3=0,p=0,s=0,j=0,s3=0,w=0,x
2=0,y2=0,p3=0;
float PI,M,M1,D;
double v=0;
PI=3.1415926554;
M=1.33333333333;
M1=0.3333333333;
D=0.11785113;
do
{
clrscr();
gotoxy(40,5);
printf("MENU\n");
gotoxy(5,10);
printf("1.esfera\n");
gotoxy(10,15);
printf("2.cono\n");
gotoxy(15,20);
printf("\n\ningresar la opcion",op);
scanf("%d",&op);
switch(op)
{
case 1:
{
clrscr();
do
{
printf("\n\n ingrese coord.x:");
scanf("%d",&x);
printf("\ningrese coord.y:");
scanf("%d",&y);
printf("\ningrese radio r:");
scanf("%d",&r);
}
while(r>x||r>y);
{
v=(r*r*r*PI*M);
printf("\n\nel volumen es=%1fU^2,v");

printf("\n\ningrese numero para colorear\n1-azul 2-verde\n3-celeste 4rojo\n5-fucsia 6-naranja\n7-blanco 8-gris\n9-turquesa\n");
printf("\n su numero deceado para la esfera es=");
scanf("%d",&c);
int gdriver=DETECT;
int gmode,errorcode;
int i;
clrscr();
initgraph(&gdriver,&gmode,"..\\BGI");
errorcode=graphresult();
if(errorcode!=grOk)
{
clrscr();
printf("error de grafico:%s\n",grapherrormsg(errorcode));
printf("\n presione cualquier tecla para que usted salga");
getch();
}
setcolor(red);
gotoxy(40,5);
cout<<"Esfera";

setcolor(c);
circle(x,y,r);
for(i=0;i<r;i++)
{
setcolor(c);
circle(x,y,i);
}
}
}
break;
case 2:
{
clrscr();
do
{
printf("\n\ningrese coord. centro en x=");
scanf("%d",&x);
printf("\n\ningrese coord. centro en y=");
scanf("%d",&y);

printf("\n\ningrese cuanto vale el eje mayor=");
scanf("%d",&x1);
printf("\n\ningrese cuanto vale el eje menor=");
scanf("%d",&y1);
printf("\n-la altura tiene que ser minimo el doble del eje mayor-");
printf("\ningrese altura=");
scanf("%d",&h);
y3=y-h;
}
while(y1>x1||h<x1||h>y);
{
v=(x1*x1*PI*M1*h);
printf("\n\nel volumen del cono es=%21fU^2",v);
printf("\n\ningrese numero para colorear\n1-azul 2-verde\n3-celeste 4rojo\n5-fucsia 6-naranja\n7-blanco 8-gris\n9-turquesa\n");
printf("\n su numero deceado para el cono es =");
scanf("%d",&c);
int gdriver=DETECT;
clrscr();

initgraph(&gdriver,&gmode,"..\\BGI");
if(errorcode!=grOk)
{
clrscr();
printf("error de grafico:%s\n",grapherrorms(errorcode));
printf("\npresione cualquier tecla para que usted salga");
getch();
}
setcolor(RED);
gotoxy(40,5);
cout<<"CONO";
setcolor(c);
ellipse(x,y,180,360,x1,y1);
p=x+x1;
s=x-x1;
setcolor(c);
line(s,y,x,y3);
setcolor(c);

line(p,y,x,y3);
for(i=s;i<=x;i++)
{
setcolor(c);
line(x,y3,i,y);
}
for(i=x;i<=p;i++)
{
setcolor(c);
line(x,y3,i,y);
}
for(i=x1;i>=0;i--)
{
do
{
j=y1+1;
setcolor(c);
ellipse(x,y,180,360,x1,j);
}

while(j>=y);
{
setcolor(c);
ellipse(x,y,180,360,i,y1);
}
}
w=y+y1;
setcolor(c);
line(x,y,x,w);
}
}
break;
case 3:
{
clrscr();
do
{
printf("\n\n ingrese la coordenada del punto inicial en x=");

scanf("%d",&x);
printf("\n ingrese la coordenada del punto inicial en y=");
scanf("%d",&y);
prinft("\n ingrese el encho de la base=");
scanf("%d",&r);
printf("\n ingrese la altura h=");
scanf("%d",&h);
x1=x+r;
j=(0.75*r);
x2=x1+(j*cos(PI/6));
y2=y-(j*sin(PI/6));
p3=(x1-((x1-x)*M1));
s3=(y-(y-y2));
w=s3-h;
}
while(r<=o||h<=0);
{
a=sqrt(((p3-x1)*(p3-x1))+((w-y)*(w-y)));
v=(a*a*a*D);

prinft("\n \n el volumen de la piramide es =%2lfU^2",v);
prinft("\n \n necesito que ingrese numero para el color \n1-azul
2-
verde \n 3-celeste 4-rojo \n 5-fucsia 6-naranja\n 7-blanco 8-gris\n 9turquesa\n");

prinft("\n su numero deceado para la piramide es=");
scanf("%d",&c);
int gdriver=DETECT;
clrscr();
initgraph(&gdrive,gmode,"..\\BGI");
if(errorcode!=grOk)
{
clrscr();
prinft("error de grafico:%\n",grapherrormsg(errorcode));
printf("\npresione cualquier tecla para que usted pueda salir");
getch();
}
setcolor(RED);
gotoxy(40,5);

cout<<"PIRAMIDE";
setcolor(c);
line(p3,w,x,y);
line(p3,w,x1,y);
line(p3,w,x2,y2);
line(x,y,x1,y);
line(x1,y,x2,y2);
for(i=x;i<=x;i++)
{
setcolor(c);
line(p3,w,i,y);
}
}
}
break;
default:
printf("opcion incorrecta");
}
}

while(op!=1||op!=2||op!3);
getch();
}
CAPITULO: CONCLUSIONES
TIRO AL BLANCO
MANUAL DEL USUARIO
BIENVENIDO
ADVERTENCIA!
Se recomienda que antes de utilizar el programa lea con atencin este
manual para asi conocer el uso apropiado de este y su mayor
aprovechamiento.
Tabla de contenido
INSTALACION DEL PROGRAMA DE JUEGO
MODO DE FUNCIONAMIENTO DEL PROGRAMA
REQUERIMIENTOS DEL EQUIPO
RESOLUCION DE PROBLEMAS
INSTALACION DEL PROGRAMA DE JUEGO
Inserte el CD del juego en la unidad lectora de la CPU.
Haga doble click en Mi PC que se encuentra en el escritorio.
Haga doble click en My Disc (D:)
Haga click derecho sobre pentagrama y deslice el mouse hacia enviar a y

alli
haga click sobre mis documentos, como lo indica la figura:
1.5
Ahora vaya a Mis documentos y haga click derecho sobre el archivo

que dice ESPE y deslcelo hacia Enviar a deslice el mouse hacia
Escritorio (Crear acceso directo) y haga click en el, como lo indica la
figura.
Ahora ya esta listo para disfrutar de su adquisicin.
MODO DE FUNCIONAMIENTO DEL PROGRAMA
Al inicializar el programa la pantalla cambiara y dir Radio 1, en el espacio

en blanco se debe colocar el radio de el blanco estrellado, y al
aparecer Radio 2
se debe escribir el radio de la circunferencia externa.
Despues de esto, el juego pedira Coord X1 lo que quiere decir que se debe
escribir la coordenada del eje x, asi mismo sucedera con el eje Y.
El juego cuenta con 5 oportunidades para acertar al blanco, y despus de

cada lanzamiento, se sealara con un punto el lugar de impacto
Pasadas la 5 oportunidades el juego mostrara un resumen, lanzamiento por

lanzamiento, de los puntos obtenidos, y un total.
REQUERIMIENTOS DEL EQUIPO
Este juego funciona en cualquier computadora que tenga MS-DOS, aunque

para la optima utilizacin y la correcta interpretacin del manual, se
recomienda correrlo en Windows XP.
- Se requiere de una tarjeta de video mnima de 64 MB
- Un monitor de mnimo 256 colores
RESOLUCION DE PROBLEMAS
Sntomas
Causas
Soluciones
El programa no corre
Mala instalacin
Revise cuidadosamente
que cada uno de
los pasos dados en
el manual sean
cumplidos al pie de
la letra.
La pantalla se pone
Procesador deficiente
Cierre todos los
negra y vuelve
programas que se
al Windows
estn ejecutando y
reintente correrlo
CONCLUSIONES
Que al trabajar en modo grafico nos dimos cuenta que los programas se
pueden hacer mas amigables y que sea mas facil para que el usuario
pueda trabajar con el
Que el modo grafico es de gran ayuda para resolver programas donde se

necesita una gran explicacin grafica ya que algunos problemas o
programas necesitan un grafico para ser entendidos.
Que al realizar este trabajo los conocimientos adquiridos una a despertado

una gran curiosidad acerca de este modo grafico y su funcionamiento
CAPTITULO: BIBLIOGRAFIA
RECOMENDACIONES
Que necesitamos una mayor y gran explicacin por que hubo algunos temas
que nos quedaron en el aire y que necesitamos una aclaracion
Que tambin necesitamos poner mas atencin en clases ya que estos

conocimientos nos ayuda al resolver estos deberes que son largos y
necesitan una gran concentracin y dedicacin para no tener
problemas en el futuro.
BIBLIOGRAFIA
www2.canalaudiovisual.com/ ezine/books/acjirINFORMATICA/3info05.htm 10k

www.hispasec.com/directorio/laboratorio/articulos/Comparativa2001/mundor
eal/10.html - 33k
Microsoft Encarta Biblioteca de Consulta 2003. 1993-2002 Microsoft
Corporation. Reservados todos los derechos.
Enciclopedia Microsof Encarta 2000
www.monografas.com
www.symantec.com
www.pandasoftware.com
http://www.monografias.com/trabajos/hackers/hackers.shtml
CAPTITULO: ANEXOS
Pag. 1

Compu Final 2

Încărcat de

Informații document

Drepturi de autor

Formate disponibile

Partajați acest document

Partajați sau inserați document

Opțiuni de partajare

Vi se pare util acest document?

Este necorespunzător acest conținut?

Drepturi de autor:

Formate disponibile

Compu Final 2

Încărcat de

Drepturi de autor:

Formate disponibile

ESCUELA

Fecha de entrega: 02/01/2006

A este mundo, sus oportunidades y a las personas que nos apoyan.

Agradecemos a todas las personas que hicieron posible la realizacin de

MANUAL DEL USUARIO......................................................................................67

CAPITULO: Deber Conjunto

Conocer todo lo referente a modo grafico sus caracteristicas y su

Cual es la manera de escribir estos comandos para su mayor

Conocer las maneras de poder dibujar y presentar un buen programa

CAPITULO: Deber Conjunto

CAPITULO: Deber Conjunto

CAPITULO: Deber Conjunto

CAPITULO: Deber Conjunto

CAPITULO: Deber Conjunto

CAPITULO: Deber Conjunto

Profundidad de color (capacidad para almacenar color), que se expresa

CAPITULO: Deber Conjunto

Cuando no usamos modo grfico (usando modo texto) la salida de nuestros

Un programa en modo grfico tiene un esquema que consta de tres etapas:

Las funciones que controlan el modo grfico estn en la biblioteca graphics.h,

#include < graphics.h >

Iniciar modo grfico

CAPITULO: Deber Conjunto

1: int gdriver = DETECT, gmode;

En la primera lnea declaramos dos variables enteras: gdriver y gmode. La

En la segunda lnea hacemos la llamada a la funcin initgraph la cual establece

En la tercera lnea del cdigo verificamos que efectivamente el modo grfico se

CAPITULO: Deber Conjunto

Con el cdigo anterior se iniciara el modo grfico de una aplicacin con

En muchos de los programas de cdigo abierto que encontrars en este portal

#define RUTA_BGI "C:\\TC\\BGI"

La resolucin es el nmero de puntos (pixeles) que posee la pantalla (salida).

CAPITULO: Deber Conjunto

Cuando dibujamos en modo grfico indicamos mediante funciones las diferentes

CAPITULO: Deber Conjunto

Cerrar el modo grfico no es indispensable, pero es una prctica sana ya que

Pxeles, lneas, figuras geomtricas, colores y rellenos

En esta seccin se presentan las funciones bsicas de graficacin, utilizadas

CAPITULO: Deber Conjunto

Tal como se mencion en la seccin anterior, al habilitar el monitor en modo

CAPITULO: Deber Conjunto

CAPITULO: Deber Conjunto

CAPITULO: Deber Conjunto

CAPITULO: Deber Conjunto

Definiendo el tipo de relleno de una figura con la funcin setfillstyle()

Color del fondo

Relleno con /// lneas

Relleno slido con el color

Relleno con \\\ lneas

Relleno con \\\ lneas de ancho

Relleno con /// lneas de ancho

Relleno de lneas cruzadas ligeras

CAPITULO: Deber Conjunto

CAPITULO: Deber Conjunto

Aplicacin a los juegos: Tiro al blanco

CAPITULO: Deber Conjunto

int ControladorG, ModoG, ErrorG; /*VARIABLES PARA EL MODO

int gprintf( int xloc, int yloc, char *fmt, ... )

CAPITULO: Deber Conjunto

/* Buffer para las cadenas */

va_start( argptr, fmt );

/* Inicializa las va_ functions

cnt = vsprintf( str, fmt, argptr );

/* imprime la cadena al buffer

/Esta funcion dibuja un cuadro de texto para ingresar datos/

/Este bucle sirve para ingresar los valores/

/en esta parte convierto los datos ingresados a char/

/Esta funcion dibuja las circunferencias respectivos con los radios/

/Esta funcion borra la pantalla/

radius=radio1; /este es el radio menor /

/Esta funcioncilla calcula el score del jugador/