• Lunes 7 de Julio de 2025, 20:56

Mostrar Mensajes

Esta sección te permite ver todos los posts escritos por este usuario. Ten en cuenta que sólo puedes ver los posts escritos en zonas a las que tienes acceso en este momento.


Mensajes - JuanK

Páginas: 1 ... 29 30 [31] 32 33 ... 231
751
La taberna del BIT / Re: La Mujeres Son Màs Infieles Que Los Hombres ?
« en: Miércoles 21 de Marzo de 2007, 14:10 »
Por eso los hombres son tan diferentes de las mujeres en la mayoría de los casos, puntos de vista diferentes, moral diferentes etc... expresión diferente el hombre se expresa con mayor confianza de estos temas por que la sociedad se lo permite, en cambio a las mujeres la sociedad se lo reprocha.

En nuestra sociedad cuando un hombre se muestra como un gigolo suele verse como un acto de heroísmo reconocido por la mayoría, para una mujer hacer lo mismo es todo lo contrario y recae casi siempre en algo avergonzante.

Eso explica porque Tania_D es la unica mujer por acá sin contar con el agravante de que son muy pocas las mujeres interesadas en participar en un foro de programación... de hecho son pocas las que gustan de los computadores mas allá del trabajo.

En fin...

De ahí que las mujeres suelen ser mas reservadas con este tipo de temas y como suele suceder todas son unas santas a la vista del mundo, pero esta visto que no es así en la totalidad de los casos. No son muchas las mujeres que hablan de sus comportamientos sexuales 'instintivos' al menos en frente de los hombres, por que entre amigas suelen hablar de cosas que muchos ni siquiera llegan a imaginarse.

A muchas mujeres les da pena admitir que existen este tipo de cosas , incluso les da pena consigo mismas y nunca se ven así y suelen juzgar a la ligera con fuertes prejuicios morales... hasta que llega el momento en que ellas mismas caen, como es natural que suceda algunas veces.

Como aclaración(necesaria) nada de esto lo estoy diciendo como si fuera el caso  Tania_D.

Creo que las opiniones de Angel_K_ido y Eternal Idol son sensatas desde el punto de vista ético pero las demás opiniones no dejan de ser sensatas tampoco porque no han hablado de nada diferente de la realidad del hombre y de la mujer de los tiempos modernos.

Muchas veces el punto de vista ético no es el correcto ni el más acertado ni el que trae la ultima palabra, sino preguntenle a los sacerdotes católicos que han llegado a abusar de menores... éticamente incorrecto (y más proviniendo de una 'autoridad moral') y ellos lo sabían, pero su propia auto represión a lo largo de los años los llevo a hacer cosas terribles, cosas que no hubiesen pasado si la iglesia no les exigiera ser célives... vivir contra su propio instinto.

La infidelidad esta mal desde todo punto de vista, porque como bien se ha dicho no es correcto ni justo causarle daño a otra persona, pero el hecho es que es algo muy habitual tanto en hombres como en mujeres y nadie, absolutamente nadie esta exento de verse sometido a los deseos mas instintivos y básicos del cuerpo, la sensatez esta en ver la realidad y no quererla tapar con un dedo y desde luego en tener suficiente conciencia y respeto por la otra persona para evitar llegar a una situación que puede traerle a otro un sufrimiento terrible.

El problema no es la infidelidad en si, sino el engaño...

Hay mujeres que consienten la infidelidad de sus parejas y viceversa... y viven felices, también están las parejas que suelen asistir a swinger clubs y viven felices también porque ahí no ha habido engaño.  :rolleyes:

752
Programación de Videojuegos / Re: Xna Content Pipeline
« en: Miércoles 21 de Marzo de 2007, 04:32 »
Asi es es un poco chico, pero el chart que muestran alli se queda bastante corto con la realidad.

Por cierto que opinas de la propuesta que les hice para el alojamiento de mis articulos?
Si hay que pagar me cuentan .

753
VB .NET / Re: Donde Estan Los Numeros De Los Errores?
« en: Martes 20 de Marzo de 2007, 22:14 »
No se evalua el mensaje de error sino el la excepcion.

754
Windows / Re: Windows 2000
« en: Martes 20 de Marzo de 2007, 19:56 »
en cualquier lugar solo se copia, se ejecuta y sale.

755
Windows / Re: Windows 2000
« en: Martes 20 de Marzo de 2007, 19:32 »
la opcion:
copia el msconfig.exe de tu windows xp en el windows 2000.

hecho.

756
La taberna del BIT / Re: La Mujeres Son Màs Infieles Que Los Hombres ?
« en: Martes 20 de Marzo de 2007, 17:49 »
Cita de: "Bicholey"
:lol:  :lol:  :lol:


No no no no , creo que mal interpretan mis letras o las mal escribo, nunca he estado a favor de la cultura del engaño, ni busco un pretexto que me de anuencia para ello , lo que yo queria recalcar que lo peor serle infiel ala pareja es que hay veces en lo que les haces ver y sentir que ellos son los unicos, que hay veces que haces que la gente confie en ti para despuès engañarla y decepcionarla, eso es patetico e inhumano, y como dice Juank lo primero es poner las reglas bien en claro porque todos somos diferentes pensamos diferentes y nos educaron diferente.

Para desfortuna mia ami no me educaron a ser infiel y malo con las mujeres, porque a veces parece que las personas que peor las tratan, son las que mejor suerte tienen con las benditas mujeres.
si también es muy cierto, a muchas mujeres las atraen ese tipo de hombres especialmente beuno ahi hay mucha tela de donde cortar... ya pongamosle fin a esto.. no=?

757
La taberna del BIT / Re: La Mujeres Son Màs Infieles Que Los Hombres ?
« en: Martes 20 de Marzo de 2007, 17:16 »
Cita de: "Eternal Idol"
Cita de: "JuanK"
Estoy de acuerdo pero no siempre es fácil decidir cuando parar
Antes de empezar siquiera.
Ese si es un muy buen punto, hay que poner los limites desde un comienzo... después ya no hay nada que hacer.

758
La taberna del BIT / Re: La Mujeres Son Màs Infieles Que Los Hombres ?
« en: Martes 20 de Marzo de 2007, 16:41 »
Cita de: "Eternal Idol"
Engañar es una vileza, en cualquier orden de la vida y traicionar a tu pareja es patetico. En el mundo "occidental moderno" nadie nos obliga a estar con nadie y es muy facil decir hasta que llegamos.
Estoy de acuerdo pero no siempre es fácil decidir cuando parar, el cuerpo independientemente de nuestra capacidad de control sobre el aún reacciona de manera muy instintiva y hay situaciones en que no hay manera de hechar marcha atras, en especial si una mujer a uno le llega a gustar demasiado y esta no es indiferente ante eso.

759
VB .NET / Re: Control Tipo Textbox
« en: Martes 20 de Marzo de 2007, 14:49 »

760
Programación de Videojuegos / Xna Content Pipeline
« en: Martes 20 de Marzo de 2007, 04:59 »
[dohtml]<style type="text/css">
<!--
body.hl { background-color:#ffffff; }
pre.hl { color:#000000; background-color:#FFFFFF; font-size:smaller; font-family:Courier New;}
.num { color:#000000; }
.esc { color:#000000; }
.str { color:#000000; }
.dstr { color:#000000; }
.slc { color:#008000; font-style:italic; }
.com { color:#008000; font-style:italic; }
.dir { color:#0000ff; }
.sym { color:#000000; }
.line { color:#008000; }
.kwa { color:#0000ff; font-weight:bold; }
.kwb { color:#0000ff; }
.kwc { color:#0000ff; font-weight:bold; }
.kwd { color:#000000; }
.clasMark { color:#339999 }
.stringMark { color: #660066 }
.Estilo1 {
   font-family: verdana;
   font-size: 85%;
}
.Estilo14 {font-size: smaller; font-family: verdana; text-align:justify}
.Estilo16 {font-size: large; font-family: verdana; font-weight: bold; }
.Estilo17 {font-size: medium}
.Estilo19 {font-size: smaller; font-family: verdana; color: #0000FF; }
.Estilo21 {font-size: smaller; font-family: verdana; color: rgb(51,153,153); }
//-->
</style>
<p class="Estilo16">
El XNA Content Pipeline</p>
<p class="Estilo16 Estilo17">
Que es el Content Pipeline?</p>
<p class="Estilo14">
    El content pipeline es una API que permite a los desarrolladores y diseñadores incorporar
    contenidos multimedia en los proyectos creados con XNA framework, estos contenidos
multimedia son por ejemplo:</p>
<ul>
  <li class="Estilo14">imágenes</li>
    <li class="Estilo14">sonidos</li>
    <li class="Estilo14">contenido 3d</li>
    <li class="Estilo14">efectos</li>
</ul>
<span class="Estilo14">Por defecto el content pipeline soporta una amplia gama de formatos
    de archivo diferentes los cuales son usualmente usados en la industria de los videojuegos,
    el content pipeline (en adelante CPL) facilita el acceso a estos archivos y brinda
    un interfaz de acceso unificada que permite acceder a dichos recursos desde cualquier
    objeto utilizado dentro del juego sin necesidad de hacer uso de múltiples referencias
    cruzadas lo cual desde luego va en favor de la independencia de cada componente
    lo cual en un juego generalmente es una tarea muy difícil de hacer. Sin embargo
    las capacidades del CPL podrían verse limitadas por la cantidad de archivos que
    soporta puesto que es muy común que en la industria de los videojuegos se usen formatos
    de archivo independientes de acuerdo a las necesidades particulares de cada proyecto,
    es aquí donde reside una de las mas importantes características del CPL... es <strong>
        extensible</strong>.
    <br />
    <br />
    El CPL incorpora un marco de trabajo que permite fácilmente incorporar soporte a
    diferentes tipos de archivo e incluso extender la funcionalidad de un tipo de archivo
ya soportado.</span>
<p class="Estilo16 Estilo17 ">
Como Funciona el Content PipeLine?</p>
<p>
  <span class="Estilo14">Lo primero ha tener en cuenta son los elementos con los cuales
trabaja:</span></p><p>
            <span class="Estilo19">Namespace: Microsoft.Xna.Framework.Content.Pipeline </span>
            <span class="Estilo21">
                <br />
                ContentImporter
                <br />
                ContentProcessor</span>
            <br />
            <span class="Estilo19">Namespace: Microsoft.Xna.Framework.Content </span>
            <br />
            <span class="Estilo21">ContentTypeReader</span><br />
            <span class="Estilo19">Namespace: Microsoft.Xna.Framework.Content.Pipeline.Serialization.Compile            </span>
            <br />
            <span class="Estilo21">ContentTypeWriter</span>
</p>
<p class="Estilo14">
                El camino comienza con el ContentImporter este es el encargado de realizar lectura
                física del archivo a importar y colocar la información en un objeto capaz de almacenarla.
                Seguidamente la información colocada en el objeto es pasada a través de un ContentProcessor
                el cual se encarga de realizar transformaciones en la información cargada en el
                paso anterior. El <span class="Estilo21">ContentTypeWriter</span> se encarga de
                escribir ese objeto en un archivo con el formato del CPL. Todos los pasos anteriores
                suceden en tiempo de compilación, el ultimo paso sucede en tiempo de ejecución cuando
                el juego ya esta ejecutándose, es allí donde el <span class="Estilo21">ContentTypeReader</span>
                lee los archivos creados por el CPL para cargar en memoria el recurso almacenado.
                Debido a que se debe adicionar una referencia a estas clases en el CPL es necesario
                que los tres primeros objetos existan compilados en una librería dinámica, mientras
                que el ultimo puede hacer parte el juego directamente.</p>
            <p>
              <a style="color: rgb(0, 0, 0);" onblur="try {parent.deselectBloggerImageGracefully();} catch(e) {}"
                    href="http://bp0.blogger.com/_SpDJXReOOTs/Rf2RfHjZDuI/AAAAAAAAAAM/8fYWjN1MDIc/s1600-h/CPL.PNG">
              <img style="margin: 0px auto 10px; display: block; text-align: center; cursor: pointer;"
                        src="http://bp0.blogger.com/_SpDJXReOOTs/Rf2RfHjZDuI/AAAAAAAAAAM/8fYWjN1MDIc/s400/CPL.PNG"
                        alt="" id="BLOGGER_PHOTO_ID_5043347121514286818" border="0" /></a>
            </p>
            <span class="Estilo16 Estilo17">Como hacer que el Content Pipeline soporte un archivo
  diferente? </span>
  <p>
    <span class="Estilo14">Normalmente con tan solo el </span><span class="Estilo21">ContentImporter</span><span
                    class="Estilo14"> y el </span><span class="Estilo21">ContentProcessor</span><span
                        class="Estilo14"> es suficiente para cargar un tipo de archivo ya que basicamente
                        lo que se hace es utilizar estos objetos para convertir los datos del archivo en
                        uno de los tipos de dato ya soportados por el CPL, sin embargo si se requiere información
                        adicional que no es contenida en el tipo soportado es entonces necesario que el
                        desarrollador establezca la forma en que el CPL escribe esos datos en un archivo
                        del CPL y la forma en que el CPL debe cargarlos una vez se solicite desde el juego,
                        para ello son las clases </span><span class="Estilo21">ContentTypeWriter</span><span
                            class="Estilo14"> y </span><span class="Estilo21">ContentTypeReader</span><span class="Estilo14">.
                                La buena noticia es que para adicionar soporte a un nuevo tipo de archivo estas
                                clases proveen los mecanismos necesarios para implementarlo de manera relativamente
                                fácil, la mala noticia es que todas son clases abstractas así que la mayoría del
                                trabajo lo debe hacer uno mismo. :P </span>
</p>
            <p class="Estilo14">
                A continuación un ejemplo de Implementación de un nuevo tipo de archivo para el
                CPL.
                <br />
                <br />
                Supongamos existe un tipo de arhivo bmp2 dicho archivo posee la información habitual
                de un archivo bmp más tres datos muy importantes que requerimos (todos los campos
  son un ejemplo):</p>
            <ul class="Estilo14">
              <li>Color de Máscara</li>
                <li>Número de Colores</li>
                <li>Prioridad</li>
            </ul>
            <span class="Estilo14">La tarea nro 1 crear un </span><span class="Estilo21">ContentImporter</span><span
                class="Estilo14"> . Hay que recordar que </span><span class="Estilo21">ContentImporter</span><span
                    class="Estilo14"> es una clase abstracta asi que se debe crear una clase que herede
                    de </span><span class="Estilo21">ContentImporter</span><span class="Estilo14"> , adicionalmente
                        esta clase es genérica por lo cual debemos pasar el parámetro del tipo de dato que
                        se soportara para importar.</span>
            <pre><span class="kwa">public class</span> <span class="clasMark">BMP2Importer</span> <span
                class="sym">:</span> <span class="clasMark">ContentImporter</span>
    <span class="sym">{ }</span></pre>
            <span class="Estilo14">pero un momento... de donde salio </span><span class="Estilo21">
                BMP2Content</span><span class="Estilo14">? bueno dado que se esta incorporando un nuevo
                    tipo de archivo es necesario que crear un objeto contenedor de los datos que se
                    cargan desde ese archivo, teniendo en cuenta que el formato bmp2 lo usaremos para
                    crear texturas 2D lo mejor que se puede hacer es crear una clase que herede de un
                    contenedor existente, para este caso </span><span class="Estilo21">Texture2DContent</span><span
                        class="Estilo14"> :</span>
 <pre><span class="kwa">using</span> Microsoft<span class="sym">.</span>Xna<span class="sym">.</span>Framework<span
                class="sym">;</span>
<span class="kwa">using</span> Microsoft<span class="sym">.</span>Xna<span class="sym">.</span>Framework<span
    class="sym">.</span>Graphics<span class="sym">;</span>
<span class="kwa">using</span> Microsoft<span class="sym">.</span>Xna<span class="sym">.</span>Framework<span
    class="sym">.</span>Content<span class="sym">.</span>Pipeline<span class="sym">;</span>
<span class="kwa">using</span> Microsoft<span class="sym">.</span>Xna<span class="sym">.</span>Framework<span
    class="sym">.</span>Content<span class="sym">.</span>Pipeline<span class="sym">.</span>Graphics<span
        class="sym">;</span>

<span class="kwa">public class</span> <span class="clasMark">BMP2Content</span> <span
    class="sym">:</span> <span class="clasMark">Texture2DContent</span>
<span class="sym">{</span>
  <span class="kwa">public</span> <span class="kwd">BMP2Content</span><span class="sym">():</span> <span
      class="kwa">base</span><span class="sym">()</span>
  <span class="sym">{}</span>
  <span class="kwa">private</span> <span class="clasMark">Color</span> maskColor<span
      class="sym">;</span>
  <span class="kwa">public</span> <span class="clasMark">Color</span> MaskColor
  <span class="sym">{</span>
      <span class="kwa">get</span>
      <span class="sym">{</span>
          <span class="kwa">return</span> maskColor<span class="sym">;</span>
      <span class="sym">}</span>
      <span class="kwa">set</span>
      <span class="sym">{</span>
          maskColor <span class="sym">=</span> <span class="kwa">value</span><span class="sym">;</span>
      <span class="sym">}</span>
  <span class="sym">}</span>

  <span class="kwa">private</span> <span class="kwb">int</span> numColores<span class="sym">;</span>
  <span class="kwa">public</span> <span class="kwb">int</span> NumColores
  <span class="sym">{</span>
      <span class="kwa">get</span>
      <span class="sym">{</span>
          <span class="kwa">return</span> numColores<span class="sym">;</span>
      <span class="sym">}</span>
      <span class="kwa">set</span>
      <span class="sym">{</span>
          numColores <span class="sym">=</span> <span class="kwa">value</span><span class="sym">;</span>
      <span class="sym">}</span>
  <span class="sym">}</span>
  <span class="kwa">private</span> <span class="kwb">byte</span> prioridad<span class="sym">;</span>
  <span class="kwa">public</span> <span class="kwb">byte</span> Prioridad
  <span class="sym">{</span>
      <span class="kwa">get</span>
      <span class="sym">{</span>
          <span class="kwa">return</span> prioridad<span class="sym">;</span>
      <span class="sym">}</span>
      <span class="kwa">set</span>
      <span class="sym">{</span>
          prioridad <span class="sym">=</span> <span class="kwa">value</span><span class="sym">;</span>
      <span class="sym">}</span>
  <span class="sym">}</span>
<span class="sym">}</span></pre>
<p class="Estilo14">
                Este contenedor permite manipular los datos desde su cargue hasta su transformacion
                y escritura en un archivo del content pipeline, sin embargo se requiere de una estructura
                adicional para manipularlo, porque? bueno el contenedor puede ser realmente cualquier
                estructura pero se requiere que sea liviana puesto que la cantidad de recursos que
                tengamos puede incrementar dramaticamente el tiempo que se invcierta en la compilacion
                del proyecto ya que cada uno de los recursos pasara por un importer, un processor
                y un writer, ya cuando se va a utilizar esa informacion en un objeto util para el
                juego si debemos disponer de toda la infromacion necesaria.
                <br />
                <br />
                Para este ejemplo, debido a que el archivo de tipo bmp2 va a ser usado como textura
                se pueden usar dos opciones, una es crear una clase de textura nueva (poco recomendable)
                y la otra es crear una clase que herede de un tipo de textura ya existente, para
                el caso lo que mas nos conviene es crear una clase que herede de <span class="Estilo21">
Texture2D</span>.</p>
<pre><span class="kwa">public class</span> <span class="clasMark">BMP2Texture2D</span> <span
                class="sym">:</span> <span class="clasMark">Texture2D</span>
<span class="sym">{</span>
    <span class="kwa">public</span> <span class="clasMark">BMP2Texture2D</span><span
        class="sym">(</span><span class="clasMark">GraphicsDevice</span> device<span class="sym">,</span> <span
            class="kwb">int</span> height<span class="sym">,</span> <span class="kwb">int</span> with<span
                class="sym">,</span>
                         <span class="kwb">int</span> numberLevels<span class="sym">,</span> <span class="clasMark">ResourceUsage</span> usage<span
                             class="sym">,</span> <span class="clasMark">SurfaceFormat</span> format<span class="sym">)</span>
           <span class="sym">:</span> <span class="kwa">base</span><span class="sym">(</span>device<span
               class="sym">,</span> with<span class="sym">,</span> height<span class="sym">,</span> numberLevels<span
                   class="sym">,</span> usage<span class="sym">,</span> format<span class="sym">)</span>
    <span class="sym">{}</span>

    <span class="kwa">public</span> <span class="kwd">BMP2Texture2D</span><span class="sym">(</span><span
        class="clasMark">GraphicsDevice</span> device<span class="sym">,</span> <span class="kwb">int</span> height<span
            class="sym">,</span> <span class="kwb">int</span> with<span class="sym">,</span> <span
                class="kwb">int</span> numberLevels<span class="sym">,</span>
                         <span class="clasMark">ResourceUsage</span> usage<span class="sym">,</span> <span
                             class="clasMark">SurfaceFormat</span> format<span class="sym">,</span>
                         <span class="clasMark">ResourceManagementMode</span> resourceManagementMode<span
                             class="sym">)</span>
           <span class="sym">:</span> <span class="kwa">base</span><span class="sym">(</span>device<span
               class="sym">,</span> with<span class="sym">,</span> height<span class="sym">,</span> numberLevels<span
                   class="sym">,</span> usage<span class="sym">,</span> format<span class="sym">,</span> resourceManagementMode<span
                       class="sym">)</span>
    <span class="sym">{</span>
    <span class="sym">}</span>

    <span class="kwa">private</span> <span class="clasMark">Color</span> maskColor<span
        class="sym">;</span>
    <span class="kwa">public</span> <span class="clasMark">Color</span> MaskColor
    <span class="sym">{</span>
        <span class="kwa">get</span>
        <span class="sym">{</span>
            <span class="kwa">return</span> maskColor<span class="sym">;</span>
        <span class="sym">}</span>
        <span class="kwa">set</span>
        <span class="sym">{</span>
            maskColor <span class="sym">=</span> <span class="kwa">value</span><span class="sym">;</span>
        <span class="sym">}</span>
    <span class="sym">}</span>
    <span class="kwa">private</span> <span class="kwb">int</span> numColores<span class="sym">;</span>
    <span class="kwa">public</span> <span class="kwb">int</span> NumColores
    <span class="sym">{</span>
        <span class="kwa">get</span>
        <span class="sym">{</span>
            <span class="kwa">return</span> numColores<span class="sym">;</span>
        <span class="sym">}</span>
        <span class="kwa">set</span>
        <span class="sym">{</span>
            numColores <span class="sym">=</span> <span class="kwa">value</span><span class="sym">;</span>
        <span class="sym">}</span>
    <span class="sym">}</span>
    <span class="kwa">private</span> <span class="kwb">byte</span> prioridad<span class="sym">;</span>
    <span class="kwa">public</span> <span class="kwb">byte</span> Prioridad
    <span class="sym">{</span>
        <span class="kwa">get</span>
        <span class="sym">{</span>
            <span class="kwa">return</span> prioridad<span class="sym">;</span>
        <span class="sym">}</span>
        <span class="kwa">set</span>
        <span class="sym">{</span>
            prioridad <span class="sym">=</span> <span class="kwa">value</span><span class="sym">;</span>
        <span class="sym">}</span>
    <span class="sym">}</span>
<span class="sym">}</span>
</pre>
<p class="Estilo14">
                Esta clase ya trae todo lo que necesita una textura 2d más las cosas propias del
                formato bmp2 de el ejemplo.
                <br />
                Ahora si se puede crear el <span class="Estilo21">ContentImporter</span> indicando
                el tipo de contenido a almacenar.
</p>
<pre>
<span class="sym">[</span><span class="kwd">ContentImporter</span><span class="sym">(</span><span
    class="stringMark">".bmp2"</span><span class="sym">,</span> DisplayName <span
        class="sym">=</span> <span class="stringMark">"Imagen BMP2"</span><span
            class="sym">,</span> DefaultProcessor <span class="sym">=</span> <span class="stringMark">"Procesador
                para imagenes BMP2"</span><span class="sym">)]</span>
<span class="kwa">public class</span> <span class="clasMark">BMP2Importer</span> <span
    class="sym">:</span> <span class="clasMark">ContentImporter</span><span class="sym"><</span><span
        class="clasMark">BMP2Content</span><span class="sym">></span>
<span class="sym">{</span>
    <span class="kwa">public override</span> <span class="clasMark">BMP2Content</span> <span
        class="kwd">Import</span><span class="sym">(</span><span class="kwb">string</span> filename<span
            class="sym">,</span> <span class="clasMark">ContentImporterContext</span> context<span
                class="sym">)</span>
    <span class="sym">{</span>
        <span class="clasMark">BPM2</span> miBmp <span class="sym">=</span> <span class="kwa">new</span> <span
            class="clasMark">BMP2</span><span class="sym">(</span>filename<span class="sym">);</span>
        <span class="slc">//Este objeto es de ayuda para recuperar la informacion de color y
            llevarla facilmente al</span>
        <span class="slc">//MipmapChain del objeto textureContent</span>
        <span class="clasMark">PixelBitmapContent</span><span class="sym"><</span><span
            class="clasMark">Rgb24</span><span class="sym">></span> pixelHelper<span class="sym">;</span>
        <span class="slc">//Array de textura a retornar</span>
        <span class="clasMark">BMP2Content</span> textureContent<span class="sym">;</span>
        <span class="slc">//Array de bytes para capturar la informacion del archivo JKI</span>
        <span class="kwb">byte</span><span class="sym">[]</span> byteArray<span class="sym">;</span>
        <span class="slc">//Inicializa un nuevo contenedor de datos de pixeles</span>
        pixelHelper <span class="sym">=</span> <span class="kwa">new</span> <span class="clasMark">PixelBitmapContent</span><span
            class="sym"><</span><span class="clasMark">Rgb24</span><span class="sym">>(</span>miBmp<span
                class="sym">.</span>Width<span class="sym">,</span>miBmp<span class="sym">.</span>Height<span
                    class="sym">);</span>
        <span class="slc">//Cargar la informacion de bytes para el archivo</span>
        byteArray <span class="sym">=</span> miBmp<span class="sym">.</span><span class="kwd">GetBytes</span><span
            class="sym">();</span>
        <span class="slc">//Envia los datos de bytes al pixel helper</span>
        pixelHelper<span class="sym">.</span><span class="kwd">SetPixelData</span><span class="sym">(</span>byteArray<span
            class="sym">);</span>
        <span class="slc">//Inicializa un nuevo contenedor para la textura</span>
        textureContent <span class="sym">=</span> <span class="kwa">new</span> <span class="clasMark">BMP2Content</span><span
            class="sym">();</span>
        <span class="slc">//Carga la informacion de la imagen en la textura</span>
        textureContent<span class="sym">.</span>Mipmaps <span class="sym">=</span> <span
            class="kwa">new</span> <span class="clasMark">MipmapChain</span><span class="sym">(</span>pixelHelper<span
                class="sym">);</span>
        <span class="slc">//Guarda el color de mascara de la imagen</span>
        textureContent<span class="sym">.</span>MaskColor <span class="sym">=</span> <span
            class="kwa">new</span> <span class="clasMark">Color</span><span class="sym">(</span>miBmp<span
                class="sym">.</span>ColorMascara<span class="sym">.</span>R<span class="sym">,</span>miBmp<span
                    class="sym">.</span>ColorMascara<span class="sym">.</span>G<span class="sym">,</span>
                                             miBmp<span class="sym">.</span>ColorMascara<span class="sym">.</span>B<span class="sym">);</span>
        <span class="slc">//Establecer el numero de colores</span>
        textureContent<span class="sym">.</span>NumColores <span class="sym">=</span> miBmp<span
            class="sym">.</span>Palette<span class="sym">.</span>Count<span class="sym">;</span>
        textureContent<span class="sym">.</span>Prioridad <span class="sym">=</span> <span
            class="num">0</span><span class="sym">;</span>
        <span class="kwa">return</span> textureContent<span class="sym">;</span>
    <span class="sym">}</span>
<span class="sym">}</span>
</pre>
<p class="Estilo14">
                La primera linea es un atributo de la clase, la cual le permitira al Content Pipeline
                identificar que esta es un <span class="Estilo21">ContentImporter</span> y le proporcionara
                informacion adicional acerca de que informacion debe mostrar desde el IDE de Visual
                Studio respecto a los archivos que este ContentImporter es capaz de utilizar asi
                como un nombre descriptivo de la funcionalidad. Seguidamente lo que se hace cargar
                desde archvo un objeto BMP2 el cual desde luego es un objeto que ya es capaz de
                cargar un archivo bmp2, el objeto pixelHelper es utilizado como una 'Helper Class'
                ya que si bien no se necesita de manera directa, si es un excelente atajo para poder
                crear un <span class="Estilo21">MipmapChain</span> el cual es requerido para cargar
                en un objeto <span class="Estilo21">Texture2DContent</span> con la informacion de
                la imagen que se requiere, finalmente en la parte inferior del método se asignan
                la informacion adicional que se requiere.
                <br />
                <br />
                Una vez se ha importado la informacion desde el archivo esta debe pasar por el processor,
                el procesor se debe hacer para que funcione igual que funciona un procesor para
                una imagen BMP normal asi que se puede reutilizar un processor que ya este creado
                en XNA y eso es todo ya que sobre el resto de la informacion no se requiere hacer
                ninguna modificacion. El processor en este caso es bastante sencillo:
</p>
<pre>
<span class="sym">[</span><span class="kwd">ContentProcessor</span><span class="sym">(</span>DisplayName <span
    class="sym">=</span> <span class="stringMark">"Procesador para imagenes BMP2"</span><span
        class="sym">)]</span>
<span class="kwa">class</span> <span class="clasMark">BMP2Processor</span> <span
    class="sym">:</span> <span class="clasMark">ContentProcessor</span><span class="sym"><</span><span
        class="clasMark">BMP2Content</span><span class="sym">,</span> <span class="clasMark">BMP2Content</span><span
            class="sym">></span>
<span class="sym">{</span>
    <span class="kwa">public override</span> <span class="clasMark">BMP2Content</span> <span
        class="kwd">Process</span><span class="sym">(</span><span class="clasMark">BMP2Content</span> input<span
            class="sym">,</span> <span class="clasMark">ContentProcessorContext</span> context<span
                class="sym">)</span>
    <span class="sym">{</span>
       input<span class="sym">[</span>i<span class="sym">] = (</span><span class="clasMark">BMP2Content</span><span
           class="sym">)</span>context<span class="sym">.</span>Convert<span class="sym"><</span><span
               class="clasMark">TextureContent</span><span class="sym">,</span><span class="clasMark">TextureContent</span><span
                   class="sym">>(</span>
                           <span class="sym">(</span><span class="clasMark">TextureContent</span><span class="sym">)</span>input<span
                               class="sym">[</span>i<span class="sym">],</span>
                           <span class="stringMark">"SpriteTextureProcessor"</span><span class="sym">);</span>
       <span class="kwa">return</span> input<span class="sym">;</span>
    <span class="sym">}</span>
<span class="sym">}</span>
</pre>
<p class="Estilo14">
                El atributo inicial tiene la misma funcionalidad que en el importer y es proveer
                una pequeña descripcion del ContentProcessor para que aparezca en el IDE de Visual
                Studio. Se llama al metodo context.Convert indicandole que debe usar el builting
                processor <span class="Estilo21">SpriteTextureProcessor</span>, esto hara que la
                informacion inherente a una textura 2d sea procesada de la manera habitual . Finalmente
se procede a crear el <span class="Estilo21">ContentTypeWriter</span>.</p>
            <pre>
<span class="sym">[</span>ContentTypeWriter<span class="sym">]</span>
<span class="kwa">public class</span> <span class="clasMark">BMP2ContentWriter</span> <span
    class="sym">:</span> <span class="clasMark">ContentTypeWriter</span><span class="sym"><</span><span
        class="clasMark">BMP2Content</span><span class="sym">></span>
<span class="sym">{</span>
    <span class="kwa">protected override</span> <span class="kwb">void</span> <span class="kwd">Write</span><span
        class="sym">(</span><span class="clasMark">ContentWriter</span> output<span class="sym">,</span> <span
            class="clasMark">BMP2Content</span> <span class="kwa">value</span><span class="sym">)</span>
    <span class="sym">{</span>
        <span class="slc">//Buffer para la informacion de la imagen</span>
        <span class="kwb">byte</span><span class="sym">[]</span> pixelData<span class="sym">;</span>
        <span class="slc">//Escribe alto y ancho</span>
        output<span class="sym">.</span><span class="kwd">Write</span><span class="sym">(</span><span
            class="kwa">value</span><span class="sym">.</span>Mipmaps<span class="sym">[</span><span
                class="num">0</span><span class="sym">].</span>Height<span class="sym">);</span>
        output<span class="sym">.</span><span class="kwd">Write</span><span class="sym">(</span><span
            class="kwa">value</span><span class="sym">.</span>Mipmaps<span class="sym">[</span><span
                class="num">0</span><span class="sym">].</span>Width<span class="sym">);</span>
        <span class="slc">//Obtiene el contenido de la imagen</span>
        pixelData <span class="sym">=</span> <span class="kwa">value</span><span class="sym">.</span>Mipmaps<span
            class="sym">[</span><span class="num">0</span><span class="sym">].</span><span class="kwd">GetPixelData</span><span
                class="sym">();</span>
        <span class="slc">//Escribe el tamaño de datos de la imagen</span>
        output<span class="sym">.</span><span class="kwd">Write</span><span class="sym">(</span>pixelData<span
            class="sym">.</span>Length<span class="sym">);</span>
        <span class="slc">//Escribe la informacion de la imagen</span>
        output<span class="sym">.</span><span class="kwd">Write</span><span class="sym">(</span>pixelData<span
            class="sym">);</span>
        <span class="slc">//Escribe el color de mascara de la imagen</span>
        output<span class="sym">.</span>WriteObject<span class="sym"><</span><span class="clasMark">Color</span><span
            class="sym">>(</span><span class="kwa">value</span><span class="sym">.</span>MaskColor<span
                class="sym">);</span>
    <span class="sym">}</span>
    <span class="kwa">public override</span> <span class="kwb">string</span> <span class="kwd">GetRuntimeReader</span><span
        class="sym">(</span><span class="clasMark">TargetPlatform</span> targetPlatform<span
            class="sym">)</span>
    <span class="sym">{</span>
        <span class="kwa">return</span> <span class="kwb">typeof</span><span class="sym">(</span><span
            class="clasMark">BMP2ContentReader</span><span class="sym">).</span>AssemblyQualifiedName<span
                class="sym">;</span>
    <span class="sym">}</span>
<span class="sym">}</span>
</pre>
<p class="Estilo14">
                El atributo inicial tiene la misma funcionalidad que en el importer. El método write
                lo que hace es escribir en el archivo del CPL la informacion relacionada con el
                archivo ya previamente cargado en el <span class="Estilo21">BMP2Content</span>,
                el objeto output recibido como parametro posee metodos para escribir a nivel de
                tipos nativos y soporta una amplia gama de tipos incluidos en el xna framework,
                el método GetRuntimeReader Almacena informacion que le indica el CPL en tiempo dejecucion
                que clase debe instanciar para poder convertir un archivo del CPL en el objeto que
                se desea, es decir indica cual implementacion de <span class="Estilo21">ContentTypeReader</span>
                debe utilizarce para tal fin. Esta es la implementacion de <span class="clasMark">ContentTypeReader</span>
                para leer en tiempo de ejecucion lo que el ContentTypeWriter ha guardado en tiempo
                de compilacion, el objeto input recibido como parametro posee metodos para leer
                a nivel de tipos nativos y soporta una amplia gama de tipos incluidos en el xna
framework.</p>
            <pre>
<span class="kwa">public class</span> <span class="Estilo13">BMP2ContentReader</span> <span
    class="sym">:</span> <span class="Estilo13">ContentTypeReader</span><span class="sym"><</span>BMP2Texture2D<span
        class="sym">></span>
<span class="sym">{</span>
    <span class="kwa">protected override</span> <span class="Estilo13">BMP2Texture2D</span> <span
        class="kwd">Read</span><span class="sym">(</span><span class="Estilo13">ContentReader</span> input<span
            class="sym">,</span> <span class="Estilo13">BMP2Texture2D</span> existingInstance<span
                class="sym">)</span>
    <span class="sym">{</span>
        <span class="slc">//Se obtiene el dispositivo grafico</span>
        <span class="Estilo13">GraphicsDevice</span> graphics <span class="sym">= ((</span>IGraphicsDeviceService<span
            class="sym">)</span>
                                   input<span class="sym">.</span>ContentManager<span class="sym">.</span>ServiceProvider<span
                                       class="sym">.</span><span class="kwd">GetService</span><span class="sym">(</span><span
                                           class="kwb">typeof</span><span class="sym">(</span><span class="Estilo13">IGraphicsDeviceService</span><span
                                               class="sym">))</span>

                                  <span class="sym">).</span>GraphicsDevice<span class="sym">;</span>
        <span class="slc">//Inicializa la instancia actual, lee el ancho y alto de la imagen</span>
        existingInstance <span class="sym">=</span> <span class="kwa">new</span> <span class="Estilo13">BMP2Texture2D</span><span
            class="sym">(</span>graphics<span class="sym">,</span>
                                             input<span class="sym">.</span><span class="kwd">ReadInt32</span><span class="sym">(),</span> input<span
                                                 class="sym">.</span><span class="kwd">ReadInt32</span><span class="sym">(),</span>
                                             <span class="num">1</span><span class="sym">,</span> <span class="Estilo13">ResourceUsage</span><span
                                                 class="sym">.</span>AutoGenerateMipMap<span class="sym">,</span> <span class="Estilo13">SurfaceFormat</span><span
                                                     class="sym">.</span>Color<span class="sym">);</span>

        <span class="slc">//Establece el contenido de la imagen</span>
        <span class="slc">//lee el tamaño de la informacion en bytes a leer</span>
        <span class="slc">//y lee la informacion en bytes</span>
        existingInstance<span class="sym">[</span>i<span class="sym">].</span>SetData<span
            class="sym"><</span><span class="kwb">byte</span><span class="sym">>(</span>input<span
                class="sym">.</span><span class="kwd">ReadBytes</span><span class="sym">(</span>input<span
                    class="sym">.</span><span class="kwd">ReadInt32</span><span class="sym">()));</span>
        <span class="slc">//Establece el color de mascara</span>
        existingInstance<span class="sym">[</span>i<span class="sym">].</span>maskColor <span
            class="sym">=</span> input<span class="sym">.</span>ReadObject<span class="sym"><</span><span
                class="Estilo13">Color</span><span class="sym">>();</span>
        <span class="kwa">return</span> existingInstance<span class="sym">;</span>
    <span class="sym">}</span>
<span class="sym">}</span>
</pre>
<p class="Estilo14">
                Eso es todo, para hacerlo funcionar, se requiere compilar estas clases en una dll
                la cual se debe adicionar al content pipeline, para hacer eso se debe ir a las propiedades
                del proyecto y luego a la ultima pestaña la cual desde luego se llama Content Pipeline,
                desde alli presionar el boton Add y seleccionar la dll creada. Para que desde el
                juego se peuda cargar la informacion se debe incluir referencia por lo menos al
                ensamblado donde se compilo el <span class="Estilo21">ContentTypeReader</span>.
                En adelante tan solo se accede al recurso a travez de un content manager como se
hace de manera habitual:</p>
            <pre>
        <span class="clasMark">ContentManager</span> content<span class="sym">;</span>
        <span class="sym">...</span>
        <span class="sym">...</span>
        <span class="sym">...</span>

        <span class="clasMark">BMP2Texture</span> myTexture <span class="sym">=</span> content<span
            class="sym">.</span>Load<span class="sym"><</span><span class="clasMark">BMP2Texture</span><span
                class="sym">>(</span><span class="stringMark">@"myImage.bmp2"</span><span
                    class="sym">);</span></pre>
        <p class="Estilo14">
Espero les sea de utilidad. Saludos.</p>
[/dohtml]

761
Programación de Videojuegos / Re: Aprendiendo Ogre3d Con Ibito
« en: Martes 20 de Marzo de 2007, 04:30 »
:huh:
Les cuento que tengp un articulo sobre creación de un plugin para extender el Content
Pipeline de XNA y que no lo he podido publicar porque ningun blog que conozco me deja publicar html y dejarlo de una manera descente...

blogger apesta,

spaces.live tambien

y un sin numero que he visto que si funcionan no son de libre aceso.  :(

No se si haya problema en montar mi pagina en http://black-byte.com como la de ibito y de paso si ibito me puede enseñar que sistema de publicación usa para que quede con ese tipo de interfaces y ya soportando RSS etc.

Quedo en espera de sus comentarios, por el momento dejo acá en el foro el articulo.

http://foros.solocodigo.com/index.php?act=ST&f=77&t=27652

762
Java / Re: Dudas Sobre Java
« en: Lunes 19 de Marzo de 2007, 19:23 »
claro que es posible , java es un lenguaje de propósito general.

763
C# / Re: Error Al Compilar
« en: Lunes 19 de Marzo de 2007, 19:22 »
Hata donde se, infortunadamente cuando lanzaron la versión express se incluye esa funcionalidad por defecto la cual es de gran beneficio cuando se desarrollan aplicaciones web, pero no sirve de nada cuando se desarrollan aplicaciones standalone, por eso salia ese error, ya despues del service pack no arroja error aunque este activado para una aplicación standalone.

Con vs 2005 se puede lanzar una pagina web sin necesidad de instalar el IIS, gracias a que posee un pequeño web server que hace las veces de host.

764
C# / Re: Error Al Compilar
« en: Lunes 19 de Marzo de 2007, 04:43 »
Hay dos formas.

1- Service Pack 1
2- Propiedades del proyecto, debug y deshabilitas la casilla >"Enable Visual Studio Hosting Process"

765
C# / Re: Contar Cantidad De Numeros De Un Cadena
« en: Lunes 19 de Marzo de 2007, 04:21 »
si.

766
C# / Re: Download C# Express!
« en: Domingo 18 de Marzo de 2007, 20:06 »
La versión express no incorpora esas facilidades, al menos no por defecto. Habrá que averiguar.

767
La taberna del BIT / Re: La Mujeres Son Màs Infieles Que Los Hombres ?
« en: Domingo 18 de Marzo de 2007, 18:26 »
Cita de: "Bicholey"
:P  :P  :P  :P  :P


Como dice Angel K ido su filosofia es muy bonita y yo espero que asi siga, no es que el este cerrado de los ojos o sea una cosa rara para nada, de hecho es uno de los muchos que creen en la institucion de matrimonio y la monogamia, y no es con animo de ofender pero creeme que varios de mis amigos pensaban como tù, y creian y confiaban ciegamente en el amor y confiaban en sus novias, en sus esposas pero desafortunadamente para ellos esas mismas mujeres que tanto querian y adoraban los hicieron cambiar ellos eran como tù y las mismas mujeres los hicieron cambiar, ojala y a ti no te pase lo mismo.

(y bueno como se ve que en este foro no hay mujeres.)
Asi es...
he conocido varios... entre ellos uno que era el campeon ( YO hace 7 años)...

Es bueno estar enamorado y creer en las personas pero siempre hay que guardarce algo para si mismo y sobre todo no pecar de ingenuo y luego quedar como un idiota...

pero según hemos concluido un grupo de victimas  :devil: eso es algo que no se aprende por mas de que a uno se lo digan se lo repitan y se lo adviertan muchas personas que han pasado por lo mismo... no se porque sera... pero la única forma en que se aprenden estas cosas es esperar a que los hechos se encarguen de bajarlo a uno mismo de la nube. :blink:

768
C/C++ / Re: Como Guardar
« en: Domingo 18 de Marzo de 2007, 18:12 »
Cita de: "Eternal Idol"
El punto esta en escribir desde la direccion de memoria donde esten los datos que queremos el tamaño de estos mismos y para eso usamos sizeof.

Cuidado con el ejemplo de JuanK que no es del todo correcto ya que esta haciendo sizeof de c y al ser este un puntero nos devuelve el tamaño del mismo (4 en 32 bits, 8 en 64 bits) y no el tamaño de la estructura a la que apunta. Por eso yo siempre recomiendo usar directamente el tipo y no el puntero (tambien se puede hacer sizeof del puntero).

Código: Text
  1.  
  2. fwrite(c, sizeof(*c), 1, arch);
  3. fwrite(c, sizeof(Componente), 1, arch);
  4.  
  5.  
:o tienes razón no me había fijado, ya lo corregi.

Código: Text
  1.   ofs.write((char *)&one, sizeof(one));
  2.  

Esta escribiendo el objeto one en disco, pero dado que el método write solo recibe como parámetro un char * le están haciendo un cast, adicionalmente la función recibe un puntero no un objeto así que lo que se hace con &one es pasar un puntero al objeto no un objeto completo, y lo complementan con el cast (char *) para que el metodo reciba el tipo de puntero requerido

769
C# / Re: Contar Cantidad De Numeros De Un Cadena
« en: Domingo 18 de Marzo de 2007, 18:07 »
Asumiendo que tienes todos los números en un array de caracteres o bien de números.

1- verificas que el primer y ultimo elemento sean el mismo numero
1.1- sino es asi entonces no hay hueco
1.2-Si si son iguales continuas
2- Restas el ultimo índice del primero

770
C/C++ / Re: Como Guardar
« en: Sábado 17 de Marzo de 2007, 20:32 »
Código: Text
  1. class prueba
  2. {
  3.   ...
  4.   void funcion()
  5.   {
  6.     Componente *c = new Componente();
  7.     FILE *arch;
  8.     arch = fopen(&#34;este.o&#34;, wb+);
  9.     fwrite(c, sizeof(*c), 1, arch);
  10.   }
  11.   ...
  12. }
  13.  

esa es la idea basica y funciona si Componente solo tiene tipos por valor, el problema radica en que attributos tiene la clase componente... si tiene tipos por referencia sera mas complicado pues nada ganas con restaurar punteros para los cuales ya no tienes acceso y cometerías una infracción de memoria.


http://www.functionx.com/cpp/articles/serialization.htm


Esto puede ser muy util para hacer lo que quieres:

http://msdn.microsoft.com/library/spa/defa...tion_topics.asp

771
C/C++ / Re: Uso Del Destructor Y Constructor De Una Clase
« en: Sábado 17 de Marzo de 2007, 20:05 »
en principio si se puede , pero no me es totalmente claro lo que quieres.

772
C/C++ / Re: Dudas Visual Express C++
« en: Sábado 17 de Marzo de 2007, 19:58 »
Citar
instale el VC++ express edition (como comentario me parece que el lanzamiento gratuito de versiones express por parte de MS para ser fruto de la guerra con Linux, como dicen en mi pais a rio revuelto ganancia de pescadores).

mm puede ser, pero si microsoft no saca versiones free entonces microsoft es lo peor por no tener versiones free, y si microsoft las saca free entonces es lo peor por copiarse de linux... ves?

yo creo que es cuestión de marketing...
los que mas pagan licencias y están fuertemente vigilados por ley son las empresas, y para tormentar el uso de .net en las empresas una buena técnica ( usada por ejemplo por java) es tener el framework y un IDE free para que la gente lo conozca, entre mas gente sepa .net y visual studio más gente a nivel de empresas querra usarlo como herramienta y es alli donde deben pagar licencia y es donde le dan $$ a microsoft.

Por otroo lado los estudiantes si ven que no deben pagar para poder aprovechar las herramientas se interesaran mas y asi cuando dejen de ser estudiantes usaran las herramientas en sus proyectos laborales.

Citar
Bueno la pregunta que tengo es que al parecer las app para windows forms que se pueden hacer con el vc++ express son solo para .Net ¿estoy en lo correcto o no?.
Así es porque vc++ express no incluye ni ATL ni MFC.

773
Dudas informáticas / Re: Pdf A Exel
« en: Sábado 17 de Marzo de 2007, 01:15 »
el problema es que son reportes que van desde 0 hasta 1000 hojas o mas...
pero en fin...

el verdadero problema es que oracle reports no tiene soporte para generar contenido de excel con la calidad esperada, por eso se hacen en pdf y ahora se estaba mirando como convertirlos a excel bien hecho.

774
La taberna del BIT / Re: La Mujeres Son Màs Infieles Que Los Hombres ?
« en: Sábado 17 de Marzo de 2007, 01:13 »
Cita de: "su -"
Nop, de hecho a nivel genetico no hemos degradado enormemente (comparar las supermodelos de los años 50's, 60's y 70's con la de las ahora)
no estoy de acuerdo, simplemente por circunstancias sociales y la tv y el cine sobre todo...

hace 50 años una modelo 'rellenita' era muy bien vista y era la top sex symbol... hoy en dia es lo contrario y es valido que lo sea porque las personas con mayor exito y renombre están en la tv y el cine y tienen mucho dinero...

pero dado que la tv y el cine 'te ponen 10 k demas' la gente fue necesitando estar mas delgada en la vida real de lo que se ve en los medios.. asi que la tendencia puede ser que a nivel instintivo si eres mas delgado o musculoso tienes mas oportunidades de exito que si eres obeso.  :rolleyes:

Desde luego se puede decir que los estereotipos delgados nos han vuelto una especie mas débil con menos oportunidades de vivir... en la selva, pero resulta que al tiempo que la gente 'bien' se hizo mas delgada, la ciencia también progreso y hoy dia la expectativa de vida de alguien es mucho mas alta que hace 50 años... con todo y que ahora la gente se alimenta peor que hace 50 años.

775
C/C++ / Re: Metodos Para Limpiar Pantalla
« en: Viernes 16 de Marzo de 2007, 22:11 »
Código: Text
  1. char a[5]={27,'[','j',0} /* Para ambos (en DOS cargando antes ansi.sys) */
  2. printf(&#34;%s&#34;,a);
  3.  


char a[5]={27,'[','j',0}

define un array de caracteres de 5 posiciones, si se considera a como un apuntador a una cadena entonces la cadena es : "←[j"

el primer caracter ( el # 27) corresponde al CARACTER SCAPE y el ultimo ( el 0) es un null.

esa secuencia de caracteres forma un caracter de escape que lo que hace es borrar toda la pantalla o sea un cls.

printf("%s",a);

ahi se imprime el caracter de escape , o sea ahi es donde se borra la pantalla.

Si miras el link que te envio su- veraz como esa secuencia de caracteres, en efecto borar la pantalla de acuerdo a la descripción indicada.

Páginas: 1 ... 29 30 [31] 32 33 ... 231