Yo tambien ando en Madrit  B)  

 Perdonar que ande un poco desconectado pero....

¿Que paso con el proyecto Utopia?

Despues del famoso video, intro, animacion, o como se quiera llamar.

¿Se sigue trabajando en ello? ¿Hay capturas de un juego ya andando? ¿Le falta un 20 % como diria los maestros de alcachofa soft?

Pues eso, a ver si alguien me saca de dudas  :D  

 Decid la verdad, lo que pasa esque todos quereis ser una estrella y coleccionar cochazo, equipados con tias buenas de serie.

tsk

(twist)  

                                Bueno como tu, por tres o mas, pero no hablo por mi solo, melon.

Y por cierto un poco de respeto que sino te bajo de mi lista
de "escucha" en el irc  ;), como siga bajando gente al final
le tendre que responder las dudas hasta el ak47, ais.

Por cierto que lastima lo del codigo de la semana de esta
semana(o mes) yo tenia uno parecido pero con clases virtuales
CComrpresFile y CDataFile derivadas de un CFile quasi
virtual puro, con metodos read, seek, etc, todo sobre
pack propio,etc.

Pero esta visto que lo mio no son los codigos de la semana
a ver si me hago otro :P                                

                                Bueno contacto por email, pero suena interesante y
es una buena forma de volver a la actividad.

Asi que resumiendo si quereis programador creo que
habeis encontrado un par.                                

                                El IDirect3DSurface9 tiene un bonito metodo GetDC con el cual
puedes usar las tipicas y topicas funciones del api TextOut, etc.

Para muchos casos son mas que validas.

luego tu UpdateSurface y listo

Y sobre surfaces en Dx9 mirate esto para empezar

http://msdn.microsoft.com/library/default....es/surfaces.asp                                

                                Pedir que se comporte algo en release como en debug es una tonteria, si esta el modo debug es para que funcione como es.

Sino que sentido tiene 8)

Lo que tienes que hacer es un buen sistema de log que de paso puedes usar para depurar un poco el tema y ver donde te esta cascando, menssage box y message beep es un metodo demasiado anticuado.

Tambien te pueden valer unos buenos throw pero tendras que tener tu sistema de catch bien echo ya que el debug captura toda excepcion lanzada pero el release la tienes que manejar tu mismo.

Ala y suerte                                

                                Por si a alguien le interesa, ahí va la conversacion entre el arquitecto y
neo:

Arquitecto: Hola Neo.

Neo: ¿Quién eres tú?

Arquitecto: Yo soy el arquitecto. Yo creé Matrix. Te he estado esperando.

Tienes muchas preguntas y a pesar de que el proceso ha alterado tu
conciencia,permaneces irrevocablemente humano, ergo, algunas de mis
respuestas las entenderás, y otras no.

Concordantemente, mientras tu primera pregunta quizá sea la más pertinente,
puede que te des cuenta, o no, de que también es la más irrelevante.

Neo: ¿Por qué estoy aquí?

Arquitecto: Tu vida es la suma del remanente de una ecuación desequilibrada
inherente a la programación de Matrix.

Eres la eventualidad de una anomalía, que a pesar de mis más sinceros
esfuerzos me ha sido imposible eliminar, de lo que de otra manera sería una
armonía...de precisión matemática.

Aunque sigue siendo una carga asiduamente evitada, no es inesperada ni está
más allá de ser controlada. Lo cual te trajo inexorablemente... aquí.

Neo: No ha respondido mi pregunta.

Arquitecto: Cierto. Interesante, eso fue más rápido que los demás.

Neo: ¿Otros? ¿Cuántos? ¿Otros?

Arquitecto: Matrix es más vieja de lo que sabes. Yo prefiero contar de la
emergencia de una anomalía integral a la emergencia de la siguiente. En cuyo
caso esta es la sexta versión. Sólo hay dos posibles explicaciones...

Neo: ¿Por qué nadie me dijo...

Arquitecto: ...lo que nadie sabe?

Precisamente. Como indudablemente vas descifrando, la anomalía es sistémica,
creando fluctuaciones hasta en las ecuaciones más simplistas.

Neos de las TV: ¡¡No pueden controlarme!! ¡Voy a romperte la cara...!
¡¡Estás muerto!! ¡Puedo decir lo que quiera! ¡No puedes obligarme!

Neo: Elección. El problema es la elección.

Arquitecto: La primera Matrix que diseñé era prácticamente perfecta, una
obra de arte. Impecable. Sublime. Igualada sólo por su monumental fracaso.
La inevitabilidad de su ocaso resultó como consecuencia de la imperfección
inherente a cada ser humano. Por ello la rediseñé, basado en tu historia.
Para reflejar con más precisión la variedad de lo grotezco de tu naturaleza.
Sin embargo, otra vez fui frustrado por el fracaso. Desde entonces comprendí
que la respuesta me ha eludido porque requería una mente menor, o quizá una
mente menos atada a los parámetros de la perfección.

Entonces tropezó con la respuesta a través de alguien más... Un programa
intuitivo...creado inicialmente para investigar ciertos aspectos de la
síquis humana.

Si yo soy el padre de Matrix, ella sería sin dudarlo su madre.

Neo: El Oráculo.

Arquitecto: Por favor...! Como decía, dió con una solución con la cual cerca
del 99% de todos los sujetos testeados aceptaron el programa si se les daba
a elegir. Incluso si registraban poder elegir en un nivel casi inconsciente.

Aunque esta respuesta funcionaba, obviamente tenía un fallo fundamental,
creando así la anomalía sistémica que de otro modo sería contradictoria, y
que dejada sin supervisión, podría poner en peligro al sistema mismo, ergo,
aquellos que se negaron al programa, aunque una minoría, dejados sin
supervisión, constituirían una creciente probabilidad de un desastre.

Neo: Zion.

Arquitecto: Tú estás aquí porque Zion está a punto de ser destruída. Cada
uno de sus seres vivos exterminados de su existencia, erradicados...

Neo: Patrañas.

Neos en TV: ¡Patrañas!

Arquitecto: La negación es la más predecible de las respuestas humanas. Pero
quédate tranquilo, que está habrá sido la sexta vez que la hemos destruído.
Y nos hemos vuelto extremadamente eficientes en ello. Ahora la función del
elegido es volver a la Fuente, permitiendo una diseminación temporal del
código que llevas, reinsertando así el programa primario. Tras lo cual,
tendrás que elegir 23 individuos de Matrix: 16 mujeres, 7 hombres, para
reconstruir Zion.

Si se fracasa en cumplir este proceso, resultará en un colapso cataclísmico
del sistema, que matará a todos los que estén conectados a Matrix, lo cual
sumado a la destrucción de Zion, llevaría a la extintión de la raza humana.

Neo: No permitirás que eso suceda. No puedes. Necesitas seres humanos para
sobrevivir.

Arquitecto: Estamos preparados para aceptar ciertos niveles de
supervivencia... Sin embargo, la cuestión relevante es si tú estás o no
preparado para aceptar la responsabilidad por la muerte de cada ser humano
de este mundo.

...

Es interesante leer tus reacciones...

Tus cinco predecesores estaban basados por diseño en una similar
predicación, una afirmación contingente que apuntaba a crear un profundo
desapego del resto de tu especie, facilitando así la función del elegido.
Mientras los demás experimentaron eso de una manera muy general, tú
experiencia es mucho más específica.

Vis a vis...

.. Amor.

Neo: Trinity.

Arquitecto: A propósito, ella entró en Matrix para salvarte la vida, a costa
de la suya.

Neo: ¡No!

Arquitecto: Lo cual nos lleva, por fin, al momento de la verdad, donde se
expresa el fallo fundamental y se revela la anomalía tanto como principio
como final.

Hay dos puertas. La que está a tu derecha lleva a la Fuente y a la salvación
de Zion. La puerta a tu izquierda lleva de regreso a Matrix, a Trinity y al
final de tu especie.

Como bien has dicho antes, el problema es la elección. Pero ya sabemos lo
que harás, ¿no? Ya puedo ver la reacción en cadena...

Los precursos químicos ocasionan la creación de una emoción diseñada
específicamente para aplastar la lógica y la razón. Una emoción que ya te
está cegando de la simple y obvia verdad: Ella va a morir y no hay nada que
puedas hacer para evitarlo.




-Neo se acerca a la puerta de la izquierda-




Arquitecto: Esperanza. La quintaesencia de la desilusión humana. Fuente
simultánea de tu mayor poder y tu mayor debilidad.

Neo: Si fuera tú, mi esperanza sería que no nos volvamos a encontrar de
nuevo.

Arquitecto: No lo haremos.

                                http://www.codeguru.com/mfc_database/Ado_Aok.shtml                                

                                Yo hize un .js para el curro que hace algo parecido a lo que tu
necesitas, esta echo con el windows scripting host

Un saludo

mICrO

nota : guardar como actualiza.js

Código [Seleccionar] Expand



// ********************************************************************

// **  actualiza.js                                                  **

// **   Programa de copia de actualizacion de ficheros en maquinas.  **

// **                                                                **

// ** Autor:                                                         **

// **                                                                **

// **  Juan Antonio Medina Iglesias ^ Ibermatica                     **

// **                                                                **

// ** Descripcion :                                                  **

// ** Este programa "replica" una estructura de directorios, con sus **

// **  archivos en una lista de maquinas.                            **

// **                                                                **

// ** Funcionamiento :                                               **

// ** Crear una estructura de directorios que se desea replicar en   **

// **  la carpeta datos, esta carpeta contendra primero una carpeta  **

// **  que sera considerada la unidad por ejemplo "C" o "D", etc.    **

// **  Dentro de esas carpetas de unidades crear la carpetas y       **

// **  subcarpetas necesarias para la estructura dada.               **

// **                                                                **

// ** Ejemplo :                                                      **

// **                                                                **

// **  Datos                                                         **

// **   - C <dir>                                                    **

// **      - SAT <dir>                                               **

// **         - Bases <dir>                                          **

// **           - clientes.new <fichero>                             **

// **           - tabla20.txt<fichero>                               **

// **                                                                **

// ** Crear una fichero llamado maquinas.txt que este en la carpeta  **

// **  datos y que contenga una lista de maquinas , una maquina por  **

// **  por linea.                                                    **

// **                                                                **

// ** Ejemplo :                                                      **

// **                                                                **

// **  AUTOMATA1_A                                                   **

// **  AUTOMATA5_B                                                   **

// **                                                                **

// ** Tras estar todo listo lanzar el fichero bat run.bat, despues de**

// **  la ejecucion recoger el fichero log.txt                       **

// ********************************************************************









////// MAIN **************** INICIO //////



//  Llama a la funcion de actualizar los ficheros

actualizaFicheros("datosmaquinas.txt","datos");



////// FIN **************** MAIN //////









// ********************************************************************

// **  compruebaCarpetaDestino  (fileSystemObject,rutaFichero)       **

// **                                                                **

// **  Comprueba si el directorio de destiuno de un fichero existe y **

// **  sino lo crea adecuadamente.                                   **

// **  de crearlo.                                                   **

// **                                                                **

// ** Parametros :                                                   **

// **                                                                **

// **  fileSystemObject = una referencia a un objeto fylesystem      **

// **  rutaFichero = ruta completa al fichero que luego copiaremos   **

// ********************************************************************

function compruebaCarpetaDestino(fileSystemObject,rutaFichero){



//el path de la carpeta que buscamos

var pathCarpetaRaiz = new String();



//en un principio cogemos la ruta del fichero

pathCarpetaRaiz = rutaFichero;



//creamos un array segun la cadena separando por

// por ejemplo la cadena servidor_orssacsatbasesclientes.new

// arrayElementos[0] = vacio = ""

// arrayElementos[1]= vacio = ""

// arrayElementos[2] = nombre maquina = "servidor_orssa"

// arrayElementos[3] = unidad = "c"

// arrayElementos[4] = carpeta = "sat"

// arrayElementos[5] = carpeta = "bases"

// arrayElementos[6] = fichero = "clientes.new"

var arrayElementos = rutaFichero.split("");



//el path de la carpeta raiz es maquinaunidad

pathCarpetaRaiz = "" + arrayElementos[2] + "" + arrayElementos[3];



//switch para saber si se llego a entrar en la carpeta raiz (maquina)

var llegoAMaquina = false;

try{

 //el path hasta la carpeta en la que estoy

 var carpetaActual = pathCarpetaRaiz;

 

 //el folder object de la raiz, exception si no existe

 var carpetaRaiz = fileSystemObject.GetFolder(pathCarpetaRaiz);  

 

 //al menos llegue a la maquina

 llegoAMaquina = true;

 

 //recorremos el array de supcarpetas hasta llegar a la que viene antes del nombre del fichero

 for(contador = 4; contador < arrayElementos.length-1;contador++){

 

  // en que subcarpeta estoy

  carpetaActual+=""+arrayElementos[contador];

 

  //sino existe esta carpeta

  if (!fileSystemObject.FolderExists(carpetaActual)){    

   

   //se crea la carpeta y se saca en el log

   fileSystemObject.CreateFolder(carpetaActual)    

   logOk("creando carpeta " + carpetaActual);

  }

 }

}

//exception producida

catch(e){

 //si al menos llegamos a la maquina

 if (llegoAMaquina){

  //hubo un error creado una carpeta

  logError("creando carpeta " + carpetaActual);

 }else{//sino fue al acceder a la maquina

  logError("acceder a unidad de red " + carpetaActual);

 }

 //levantamos para que la recoga la copia de ficheros

 throw e;

}

}



// ********************************************************************

// **  borraLog  ()                                                  **

// **                                                                **

// **  Si existe el fichero de log, lo borra.                        **

// ********************************************************************

function borraLog(){

//creacion del objeto filesystem

var fileSystemObject = WScript.CreateObject("Scripting.FilesystemObject");

//si existe el fichero de log

if (fileSystemObject.FileExists("log.txt")){

 //lo borramos

 fileSystemObject.DeleteFile("log.txt");

}

}



// ********************************************************************

// **  log  (texto)                                                  **

// **                                                                **

// ** inserta una linea en el log y escribe por la salida standard   **

// **                                                                **

// ** Parametros :                                                   **

// **                                                                **

// ** texto = una linea de texto                                     **

// ********************************************************************

function log(texto){

//modos para ficheros

var ForAppending = 8;

var TristateUseDefault = -2;



//el objeto de filesystem

var fileSystemObject = WScript.CreateObject("Scripting.FilesystemObject");



//abriemos el log para añadir sino existe se crea.

var textStream = fileSystemObject.OpenTextFile("log.txt", ForAppending, true);



//la fecha actual

var fechaActual = new Date();



//la fecha en formato [dd/mm/aaaa][hh:mm:ss.lll]

var fechaStr = new String();



//construimos la fecha

fechaStr += "["



if (fechaActual.getDate()<10) fechaStr += "0";

fechaStr += fechaActual.getDate();

fechaStr += "/";

if (fechaActual.getMonth()<10) fechaStr += "0";

fechaStr += fechaActual.getMonth();

fechaStr += "/";

fechaStr += fechaActual.getYear();



fechaStr += "][";



if (fechaActual.getHours()<10) fechaStr += "0";

fechaStr += fechaActual.getHours();

fechaStr += ":"

if (fechaActual.getMinutes()<10) fechaStr += "0";

fechaStr += fechaActual.getMinutes();

fechaStr += ":";

if (fechaActual.getSeconds()<10) fechaStr += "0";

fechaStr += fechaActual.getSeconds();

fechaStr += ".";

if (fechaActual.getMilliseconds()<100) fechaStr += "0";

if (fechaActual.getMilliseconds()<10) fechaStr += "0";

fechaStr += fechaActual.getMilliseconds();



fechaStr += "]"



//escribimos en el fichero de log

textStream.WriteLine(fechaStr + " " + texto);



//ceramos el fichero

textStream.close();



//enviamos a la salida standard

WScript.echo(texto);

}



// ********************************************************************

// **  logConFinal(texto,final,maximo)                               **

// **                                                                **

// ** inserta una linea en el log y escribe por la salida standard,  **

// **  con una terminacino dada y un maximo de longitud              **

// **                                                                **

// ** Parametros :                                                   **

// **                                                                **

// ** texto = una linea de texto                                     **

// ** final = una cadena final                                       **

// ** maximo = maximo numero de caracteres para la linea, sin final  **

// ********************************************************************

function logConFinal(texto,final,maximo){



//si la linea es mas pequeña que el maximo

if (texto.length<maximo){

 

 //añadir espacios hasta que sea del tamaño pedido

 var contador;

 for(contador = texto.length; contador < maximo; contador++){

  texto += ' ';

 }  

//sino

}else{

 //la corrtamos a 3 caracteres de a longitud y añadimos al final "..."

 texto = texto.substring(0,maximo-3);

 texto = texto + "..."

}



//logeamos añadiendo el final

log (texto+final);

}

// ********************************************************************

// **  logOk  (texto)                                                **

// **                                                                **

// ** inserta una linea en el log y escribe por la salida standard   **

// **  añade al final "[Ok]" y limita la linea a 72 caracteres.      **

// **                                                                **

// ** Parametros :                                                   **

// **                                                                **

// ** texto = una linea de texto                                     **

// ********************************************************************

function logOk(texto){

logConFinal(texto,"[Ok]",72);

}



// ********************************************************************

// **  logError  (texto)                                             **

// **                                                                **

// ** inserta una linea en el log y escribe por la salida standard   **

// **  añade al final "[Error]" y limita la linea a 72 caracteres.   **

// **                                                                **

// ** Parametros :                                                   **

// **                                                                **

// ** texto = una linea de texto                                     **

// ********************************************************************

function logError(texto){

logConFinal(texto,"[Error]",72);

}



// ********************************************************************

// **  insertaFicherosDeDirectorio (fileSystemObject,directorio,     **

// **                               directorio_raiz)                 **

// **                                                                **

// ** devuelve un diccionario con los ficheros de un directorio, la  **

// ** ruta es relativa a un directorio raiz.                         **

// **                                                                **

// ** Parametros :                                                   **

// **                                                                **

// ** fileSystemObject = una objecto FileSystem                      **

// ** directorio = una ruta de directorio                            **

// ** directorio_raiz = la ruta al directorio raiz                   **

// ********************************************************************

function insertaFicherosDeDirectorio(fileSystemObject,directorio,directorio_raiz){



//crea el diccionario

var diccionario = WScript.CreateObject("Scripting.Dictionary");



var counter = 0;



//obtiene la carpeta y enumera los ficheros

var carpeta = fileSystemObject.GetFolder(directorio);

var enumeratorFichero = new Enumerator(carpeta.Files);



//ruta del fichero

var ficheroStr = new String();



//recorre la lista

for (; !enumeratorFichero.atEnd(); enumeratorFichero.moveNext()){

 

 counter ++;

 

 //coge el path y le quita la ruta del directorio raiz

 ficheroStr = enumeratorFichero.item().Path;

 ficheroStr  = ficheroStr.replace(directorio_raiz,"");

 

 //añade el fichero al diccionario

 diccionario.add (directorio + counter,ficheroStr);

}



//devuelve el diccionario

return diccionario;

}



// ********************************************************************

// ** insertaDirectorio(fileSystemObject,directorio,directorio_raiz) **

// **                                                                **

// ** devuelve un diccionario con los ficheros de un directorio,  y  **

// ** subdirectorio ruta es relativa a un directorio raiz.           **

// **                                                                **

// ** Parametros :                                                   **

// **                                                                **

// ** fileSystemObject = una objecto FileSystem                      **

// ** directorio = una ruta de directorio                            **

// ** directorio_raiz = la ruta al directorio raiz                   **

// ********************************************************************

function insertaDirectorio(fileSystemObject,directorio,directorio_raiz){



//el diccionario que sera devuelto

var diccionarioFinal =  WScript.CreateObject("Scripting.Dictionary");



//diccionario temporal

var diccionarioTemporal;

var arrayElementos;

var contador;



//obtiene la carpeta

var carpeta = fileSystemObject.GetFolder(directorio);



//enumera las subcarpetas

var enumeratorCarpetas = new Enumerator(carpeta.SubFolders);

 

//recorre las subcarpetas

var carpetaStr = new String();

for (; !enumeratorCarpetas.atEnd(); enumeratorCarpetas.moveNext()){

 

 //obtiene la ruta relativa

 carpetaStr = enumeratorCarpetas.item().Path;

 carpetaStr  = carpetaStr.replace(directorio_raiz,"");

 

 //obtiene los ficheros de esta carpeta

 diccionarioTemporal = insertaFicherosDeDirectorio(fileSystemObject,enumeratorCarpetas.item().Path,directorio_raiz);

 arrayElementos = (new VBArray(diccionarioTemporal.Items())).toArray();    

 for(contador = 0;contador <diccionarioTemporal.count;contador++){

  //copia los elementos al diccionario final        

  diccionarioFinal.Add (arrayElementos[contador],arrayElementos[contador]);

 }

 

 //obtien los ficheros de las subcarpetas (recursividad)

 diccionarioTemporal = insertaDirectorio(fileSystemObject,enumeratorCarpetas.item().Path,directorio_raiz);

 arrayElementos = (new VBArray(diccionarioTemporal.Items())).toArray();    

 for(contador = 0;contador <diccionarioTemporal.count;contador++){  

  //copia los elementos al diccionario final            

  diccionarioFinal.Add (arrayElementos[contador],arrayElementos[contador]);

 }  

}



//devuelve el diccionario

return diccionarioFinal;

}



// ********************************************************************

// ** dameDiccionarioDesdeDirectorio(directorio)                     **

// **                                                                **

// ** devuelve un diccionario con los ficheros de un directorio,  y  **

// **  sus subdirectorio la ruta es relativa al directorio dado      **

// **                                                                **

// ** Parametros :                                                   **

// **                                                                **

// ** directorio = una ruta de directorio                            **

// ********************************************************************

function dameDiccionarioDesdeDirectorio(directorio){



//objeto filesystem

var fileSystemObject = WScript.CreateObject("Scripting.FilesystemObject");  



//obtiene la carpeta

var carpeta = fileSystemObject.GetFolder(directorio);



//obtiene los ficheros

var elements = insertaDirectorio(fileSystemObject,carpeta.Path,carpeta.Path+"");



return elements;

}



// ********************************************************************

// ** cargaFicheroDiccionario(fichero_diccioanario)                  **

// **                                                                **

// ** Carga un diccionario con el contenido de un fichero de texto   **

// **  el fichero contendra un item por linea                        **

// **                                                                **

// ** Parametros :                                                   **

// **                                                                **

// ** fichero_diccioanario = una ruta hacia un fichero               **

// ********************************************************************

function cargaFicheroDiccionario(fichero_diccioanario){

var counter = 0;



//crea un diccionario

var elements = WScript.CreateObject("Scripting.Dictionary");



var ForReading = 1;

var TristateUseDefault = -2;



//objeto filesystem

var fileSystemObject = WScript.CreateObject("Scripting.FilesystemObject");



  //abre el fichero

textStream = fileSystemObject.OpenTextFile(fichero_diccioanario, ForReading, false);



//mientras no llegemos al final

while (!textStream.AtEndOfLine)

{

 //añadimos al diccionario la linea y seguimos hacia adelante

 counter ++;

 elements.add ("elemento" + counter ,textStream.ReadLine());

}

textStream.Close( );  



return elements;

}





// ********************************************************************

// ** copiaFicheros(maquina_destino,diccionarioFicheros)             **

// **                                                                **

// ** Copia una lista de ficheros a una maquina                      **

// **                                                                **

// ** Parametros :                                                   **

// **                                                                **

// ** maquina_destino = la maquina de destino                        **

// ** diccionarioFicheros = un diccionario con rutas de ficheros     **

// ********************************************************************

function copiaFicheros(maquina_destino,diccionarioFicheros){



//creamos el filesystem object

var fileSystemObject = WScript.CreateObject("Scripting.FilesystemObject");



//añadimos al log

log("Actualizando ficheros en la maquina : " + maquina_destino);



var contador;



//enumeramos los elementos del diccionario

var arrayFicheros = (new VBArray(diccionarioFicheros.Items())).toArray();  



//origen y destino

var origen = new String();

var destino = new String();



//cuenta los ficheros buenos y malos

var ficherosBuenos = 0;

var ficherosMalos = 0;



//recorremos el diccionario

for(contador = 0;contador < diccionarioFicheros.count;contador++){



 //origen y destino del fichero

 origen = "datos" + arrayFicheros[contador];

 destino = "" + maquina_destino + "" + origen.replace("datos","");

 

 //capturamos errores

 try{  

  //comprueba si la carpeta de destino existe y sino la crea

  compruebaCarpetaDestino(fileSystemObject,destino);

 

  //copiamos el fichero

  fileSystemObject.CopyFile(origen,destino);

 

  //sacamos una linea en el log

  logOk("de "+ origen + " a " + destino);

 

  //un fichero bueno

  ficherosBuenos++;

 }  

 //error

 catch(e){  

 

  //sacamos el error

  logError("de "+ origen + " a " + destino);

 

  //un fichero malo

  ficherosMalos++;

 }

 

 

 

 

}

//sacamos el log final

log(ficherosBuenos+" fichero(s) correcto(s), "+ficherosMalos+" fichero(s) incorrecto(s)");

log("");



}



// ********************************************************************

// ** actualizaFicheros(lista_maquinas,directorio_datos)             **

// **                                                                **

// ** Actualiza unas maquinas con unos ficheros                      **

// **                                                                **

// ** Parametros :                                                   **

// **                                                                **

// ** lista_maquinas = fichero que contiene la lista de maquinas     **

// ** directorio_datos = El directorio con los datos a copiar        **

// ********************************************************************

function actualizaFicheros(lista_maquinas,directorio_datos){

try{

 //boramos el log

 borraLog();

 

 //sacamos informacion en el log

 log("ACTUALIZADOR DE FICHEROS:");

 log("");

 log("inicializando...");



 var contador;



 //cargamos el fichero de maquinas

 log("cargando fichero de maquinas");

 var listaMaquinas = cargaFicheroDiccionario(lista_maquinas);

 var arrayMaquinas = (new VBArray(listaMaquinas.Items())).toArray();  



 log("cargando lista de ficheros");

 

 //creamos la lista de ficheros

 var listaFicheros = dameDiccionarioDesdeDirectorio(directorio_datos);

 

 //copiamos a cada maquina

 log(" ");

 for(contador = 0;contador <listaMaquinas.count;contador++){

  copiaFicheros(arrayMaquinas[contador],listaFicheros);

 }

}

//algun error

catch(e){

 log("Se ha producido un error");

}

}









run.bat

Código [Seleccionar] Expand



@CScript.exe actualiza.js

pause

                               

                                Magnifico codigo de la semana.

mICrO                                

                                Prueba a usar la vieja tecnica del boton hombre muerto.

Es la tipica que tu sistema manda un mensaje que es un timestamp cada x tiempo, algo asi como "estoy vivo", "estoy vivo", "estoy vivo". Si en el otro punto no recibe un "estoy vivo" en xxx tiempo da como que el otro lado esta muerto


mICrO                                

                               

El 2002-09-05 16:37, Cronodragón escribió:

Ahora, alguien sabe como puedo calcular las normales para cada vértice?

En este enlace hay un tutorial sobre generacion de terrenos, incluyendo una parte de Heith Maps, tambien tecnicas de smoth, etc y por su puesto cubre lo de las normales :ojo:

http://www.lighthouse3d.com/opengl/terrain...p3?introduction
                               

                               

blah, blah, blah

Mi mama decia que tonto es el que hace tonterias. Forest Gump
                               

                               

El 2002-09-04 11:20, NeLo escribió:
Si, ya sabía lo del motion blur con vertex shaders, era más bien para saber si se podía con el sistema de Ithaqua.

Gracias a los dos :ojo:

PD: mICrO envíame el DX9SDK a mi e-mail xD

email : Unreachable Recipient

:ojo: