puedes usar un firewall para caparle el acceso a internet.

yo no te puedo ayudar en eso pero alguna vez he preguntado por algo parecido y me comentaron que buscara info sobre como se crean juegos y sobre los algoritmos de colisiones asi que supongo que es lo que necesitas.

Bueno, no seria tan urgente cuando ni me contestaste 
De todos modos te pongo el enlace a algo que acabo de contestar donde puedes ver un codigo que te puede servir, y mucho, de apoyo para tu tarea: http://foro.elhacker.net/programacion_cc/problema_fwrite-t391462.0.html

No he podido responderte antes. Prueba este codigo a ver si te sirve:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
struct stRegistro {
   int ID;
   char nombre[25];
   int cantidad;
};
 
int Menu(void);
void ChangeStock(char *operacion, struct stRegistro *reg);
void MostrarCabecera(void);
void MostrarProducto(long n, struct stRegistro *reg);
long LeeNumero(void);
void Borrar(FILE **fa, long numero);
int Size(FILE **fa, int tam);
//--------------------------------------------------------------------------
 
int main()
{
   struct stRegistro reg;
   struct stRegistro aux;
   char nombre[25];
   FILE *fa;
   int i, opcion, nRegistros, encontrado, ID;
   long numero;
   fa = fopen("stock.dat", "r+b");          // Este modo permite leer y escribir
   if(!fa) fa = fopen("stock.dat", "w+b");  // si el fichero no existe, lo crea.
   do {
      opcion = Menu();
      switch(opcion) {
         case '1': // Añadir o incrementar el stock
            encontrado = 0;
            ChangeStock("Añadir al stock", &aux);
            nRegistros = Size(&fa, sizeof(struct stRegistro));
            for(i=0; i<nRegistros; i++)
            {
                fread(&reg,sizeof(struct stRegistro),1,fa);
                if(strcmp(aux.nombre, reg.nombre) == 0)
                {
                        reg.cantidad += aux.cantidad;
                        fseek(fa,i*sizeof(struct stRegistro),SEEK_SET);
                        fwrite(&reg, sizeof(struct stRegistro), 1, fa);
                        encontrado = 1;
                        break;
                }
            }
            if(encontrado == 0)
            {
                if(nRegistros == 0)
                        ID = 0;
                else
                {
                        fseek(fa, 0, nRegistros);
                        fread(&reg,sizeof(struct stRegistro), 1, fa);
                        ID = reg.ID + 1;
                }
                fseek(fa, 0, SEEK_END);
                aux.ID = ID;
                fwrite(&aux, sizeof(struct stRegistro), 1, fa);
            }
            break;
         case '2': // Ventas de stockaje
            encontrado = 0;
            ChangeStock("Venta de stockaje", &aux);
            nRegistros = Size(&fa, sizeof(struct stRegistro));
            fseek(fa, 0, SEEK_SET);
            for(i=0; i<nRegistros; i++)
            {
                fread(&reg,sizeof(struct stRegistro),1,fa);
                if(strcmp(aux.nombre, reg.nombre) == 0)
                {
                        encontrado = 1;
                        if(aux.cantidad <= reg.cantidad)
                        {
                                reg.cantidad -= aux.cantidad;
                                fseek(fa,i*sizeof(struct stRegistro),SEEK_SET);
                                fwrite(&reg, sizeof(struct stRegistro), 1, fa);
                        }else{
                                printf("No hay suficiente stockaje de ese producto para esta venta.\n");
                                MostrarCabecera();
                                MostrarProducto(i, &reg);
                                printf("|---------|-------------------------|--------|\n\n");
                                system("PAUSE");
                        }
                        break;
                }
            }
            if(encontrado == 0)
            {
                printf("No se puede encontrar el producto indicado.\n\n");
                system("PAUSE");
            }
            break;
         case '3': // Mostrar stock de un producto por su ID
            encontrado = 0;
            system("cls");
            printf("Buscar stock por ID: ");
            ID = LeeNumero();
            nRegistros = Size(&fa, sizeof(struct stRegistro));
            for(i=0; i<nRegistros; i++)
            {
                fread(&reg,sizeof(struct stRegistro),1,fa);
                if(ID == reg.ID)
                {
                        encontrado = 1;
                        MostrarCabecera();
                        MostrarProducto(i, &reg);
                        break;
                }
            }
            if(encontrado == 0)
            {
                printf("No se puede encontrar el producto indicado.\n\n");
            }
            else
            {
                printf("|---------|-------------------------|--------|\n\n");
            }
            system("PAUSE");
            break;
         case '4': // Mostrar stock de un producto por su nombre
            encontrado = 0;
            system("cls");
            printf("Buscar stock por nombre: ");
            fgets(nombre,25,stdin);
            for(i = strlen(nombre)-1; i && nombre[i] < ' '; i--)
                nombre[i] = 0;
            nRegistros = Size(&fa, sizeof(struct stRegistro));
            for(i=0; i<nRegistros; i++)
            {
                fread(&reg,sizeof(struct stRegistro),1,fa);
                if(strcmp(nombre, reg.nombre) == 0)
                {
                        encontrado = 1;
                        MostrarCabecera();
                        MostrarProducto(i, &reg);
                        break;
                }
            }
            if(encontrado == 0)
            {
                printf("No se puede encontrar el producto indicado.\n\n");
                system("PAUSE");
            }
            else
            {
                printf("|---------|-------------------------|--------|\n\n");
            }
            system("PAUSE");
            break;
         case '5': // Mostrar todo el stockaje
            encontrado = 0;
            rewind(fa);
            numero = 0;
            system("cls");
            nRegistros = Size(&fa,sizeof(struct stRegistro));
            if(nRegistros > 0)
            {
                encontrado = 1;
                MostrarCabecera();
                for(i = 0; i < nRegistros; i++)
                {
                        fread(&reg, sizeof(struct stRegistro), 1, fa);
                        MostrarProducto(numero++, &reg);
                }
            }
            if(encontrado == 0)
            {
                printf("No existen entradas en el registro.\n");
            }
            else
            {
                printf("|---------|-------------------------|--------|\n\n");
            }
            system("PAUSE");
            break;
         case '6': // Eliminar del stock
            system("cls");
            printf("Eliminar del stock: ");
            numero = LeeNumero();
            Borrar(&fa, numero);
            break;
      }
   } while(opcion != '0');
   fclose(fa);
   return 0;
}
//--------------------------------------------------------------------------
 
// Muestra un menú con las opciones disponibles y captura una opción del usuario
int Menu()
{
   char resp[20];
   do {
      system("cls");
      printf("MENU PRINCIPAL\n");
      printf("--------------\n\n");
      printf("1- Añadir al stock\n");
      printf("2- Venta\n");
      printf("3- Buscar stock por su ID\n");
      printf("4- Buscar stock por su nombre\n");
      printf("5- Mostrar todo el stockaje\n");
      printf("6- Eliminar producto del stock por su ID\n");
      printf("0- Salir\n");
      fgets(resp, 20, stdin);
   } while(resp[0] < '0' && resp[0] > '6');
   return resp[0];
}
//--------------------------------------------------------------------------
 
// Permite que el usuario introduzca un producto por pantalla
void ChangeStock(char * operacion, struct stRegistro *reg)
{
   int i;
   char numero[6];
   system("cls");
   printf("%s:", operacion);
   printf("\n\n");
   printf("Nombre: ");
   fgets(reg->nombre, 25, stdin);
   // la función fgets captura el retorno de línea, hay que eliminarlo:
   for(i = strlen(reg->nombre)-1; i && reg->nombre[i] < ' '; i--)
      reg->nombre[i] = 0;
   printf("Cantidad: ");
   fgets(numero, 6, stdin);
   reg->cantidad = atoi(numero);
}
//--------------------------------------------------------------------------
 
// Muestra la cabecera de la tabla por pantalla
void MostrarCabecera(void)
{
   printf("\n");
   printf("|---------|-------------------------|--------|\n"
          "|ID       |Nombre                   |Cantidad|\n"
          "|---------|-------------------------|--------|\n");
}
//--------------------------------------------------------------------------
 
// Muestra un producto por pantalla
void MostrarProducto(long n, struct stRegistro *reg)
{
        printf("|[%6ld] |%-25s| %4d   |\n", reg->ID, reg->nombre, reg->cantidad);
}
//--------------------------------------------------------------------------
 
// Lee un número suministrado por el usuario
long LeeNumero()
{
   char numero[6];
   fgets(numero, 6, stdin);
   return atoi(numero);
}
//--------------------------------------------------------------------------
 
// Borra una entrada del archivo
void Borrar(FILE **fa, long numero)
{
        struct stRegistro reg;
        FILE *ftemp;
        int largo, nRegistros, i;
        rewind(*fa);
        ftemp = fopen("temp.dat", "wb");
        nRegistros = Size(*&fa,sizeof(struct stRegistro));
        for(i=0; i<nRegistros; i++)
        {
                fread(&reg,sizeof(struct stRegistro),1,*fa);
                if(numero != reg.ID)
                {
                        fwrite(&reg, sizeof(struct stRegistro), 1, ftemp);
                }
        }
        fclose(ftemp);
        fclose(*fa);
        remove("stock.dat");
        rename("temp.dat", "stock.dat");
        *fa = fopen("stock.dat", "r+b");
}
//--------------------------------------------------------------------------
 
int Size(FILE **fa, int tam)
{
        int largo, n;
        fseek(*fa, 0, SEEK_END);
        largo = ftell(*fa);
        n = largo / tam;
        fseek(*fa, 0, SEEK_SET);
        return n;
}
//--------------------------------------------------------------------------
 

tengo dudas con alguna que otra cosa que estáen catalan o no se que es pero intentaré ayudarte. Tengo varias preguntas para poder ayudarte. ¿Puedes usar archivos para guardar los datos o tiene que ser un array de estructuras de tamaño fijo o tiene que ser con asignacion de memoria dinamica? Dependiendo de lo que se use la cosa cambia. En el caso de usar archivos pues necesitarias tocar el tema de archivos de acceso aleatorio, para el caso de usar asignacion de memoria dinamica pues tendrias que estudiar mas el tema de punteros y el uso de malloc y free, y en el caso de usar un tamaño fijo de array de estructura pues la cosa se hace mucho mas sencilla y solo tendrias que tener claro el uso de punteros.

yo hace muchos años que no copio cds de juegos que son los que traian este tipo de proteccion pero era la version 4 y se podia copiar perfectamente usando el alcohol 120% y luego usabas la emulacion del securom del mismo alcohol o el daemon tools y funcionaba de maravilla. La version ya a avanzado pero tambien el alcohol y el daemon asi que supongo que sigue siendo posible por ese metodo.

que yo sepa la consola no admite rgb, va a 8 bits que ya es bastante. Para trabajar con rgb tienes que usar poo y ahi si que puedes usar rgb.

que lio de codigo, todo se ve sin identar al menos donde lo estoy viendo. De todos modos creo que si lo que quieres es simplemente leer un fichero en busca de un valor concreto y si existe incrementas x pues te sobra la mitad del codigo. Yo es que no termino de entender para que abres y cierras tanto los ficheros y para que tantos. Yo lo que haria seria abrir el fichero y primero de nada me iria al final del fichero y luego obtendria la posicion, eso se hace con fseek y ftell y el valor obtenido lo divido entre el tamaño de la estructura para obtener el numero de entradas y luego en un for uso ese valor como limite para buscar el nombre de la fruta usando fread para rellenar la estructura y luego si lo encuentra le sumo el valor que sea y como tengo el valor donde fue encontrado pues me posiciono ahi en el fichero y con fwrite machaco ese registro. Para hacerlo asi tienes que haber creado el fichero con el mismo formato que lo estes leyendo ya que si para crearlo usas fprint y para luego leerlo usas fread no te va a ir bien. Busca informacion sobre archivos de acceso aleatorio en C.

¿createfile para ver si se esta ejecutando un proceso? ¿Pero eso lo que haria no seria crear un archivo o abrirlo y darnos el handle? Yo para eso uso dos formas diferentes, la primera lo que haria es buscar la ventana con findwindow y si la encuentra es que ya se esta ejecutando. El segundo metodo lo que haria es un snapshop de todos los procesos que esten ejecutandose y comparando el nombre de mi proceso con el que lea y si coincide pues esta ya ejecutandose.

¿Puedes usar c++builder? Yo crearia un array de enteros tridimensional, el primer indice seria el numero de bolas que han salido de dicho carton y que se inicializa a 0 y el segundo las bolas que contiene. Reservamos la memoria necesaria dependiendo del numero de cartones que le pidamos.  Rellenaria esos valores de bolas usando rand de forma que no se puedan repetir las bolas. Una vez relleno todo pues seria ir usando rand con la misma funcion para no repetir bolas e ir buscando cada bola en todos los cartones. Si encuentro ese valor incremento el primer valor del array y cuando ese valor sea igual al numero de bolas del carton pues ya sabriamos que hay bingo. Para el resto es mas o menos igual, podrias hacer que el array fuera de mas dimensiones para poder ir viendo si se encuentran las esquinas, las diagonales... Es solo una idea.