Programar un juego para el ordenador que realice diferentes combinaciones numéricas

La verdad que al menos yo no me entero de lo que has preguntado. Explica mejor de que va el juego y luego explica mejor cual es tu problema. Recuerda que para obtener una buena respuesta es necesario hacer una buena pregunta.

Hola! Perdón por la pregunta tan poco clara.
Básicamente lo que quiero es saber como calcular los posibles movimientos que puede haber dentro del tablero.
El minijuego consiste en sumar 7 con las caras de los dados (de 1 a 6), de forma que el jugador pueda señalar (1,6),(1,1,5),(1,1,1,4).. etc y el tablero es de 10x10 dados.
http://www.subirimagenes.com/imagen-tablero-3844421.html
No se si me he explicado bien, si falta algún dato dímelo por favor.
Gracias!

Entonces el juego consiste en coger todos los dados del tablero que necesites para completar 7, ¿no?
¿Pero con alguna regla? ¿Por ejemplo todos de la misma fila o la misma columna o es libre?

Es libre, puede coger los dados al azar (por ejemplo), lo único es que tiene que sumar 7 con los dados señalados.
Yo por ahora lo poco que he conseguido es intentar que la suma total de los dados sea divisible entre 7 y de resto de 0, pero falla una cosa, por ejemplo me pueden quedar 3 dados (6,2,3), y que la suma total si podría ser divisible (pero no da de resto 0), pero con esos dados no se puede sumar 7. Bueno era un ejemplo para que lo entendieses mejor.
Muchas gracias por tu tiempo.

BUeno ya está más claro,
La verdad que va a ser difícil. Pero bueno...
Supongo que conforme vayas utilizando los números estos ya no se quedan disponibles, ¿no? Voy a suponer que es así...
Entonces la mejor forma para ahorra tiempo al programa que veo es que, el programa internamente haga al principio un listado de todas las posibles combinaciones que suman 7, con los números que ha colocado aleatoriamente.
Primero las sumas de dos dígitos, es decir coge el primer número en la posición (1,1) y lo va sumando con el resto de posiciones, luego coges el (1,2), que no hace falta sumarlo con el (1,1) porque ya lo has hecho antes. Luego las de tres números, y así hasta las de 7 número que sólo hay una posible combinación y es la 1111111, siete unos.
Se trata de que almacenes junto con la combinación la posición que ocupa cada elemento de la suma, así cuando lo utilices eliminas esa combinación. Y así vas viendo cuantas quedan. Para hacer pruebas te aconsejo que al principio utilices los número fijos, es decir, pones tu los número que quieras en las casillas.
De todas formas, no se si es la forma más eficiente, pero así te evitas que cada vez que selecciones un número para que sumen 7, tengas que volver a calcularlo todo de nuevo. Así, hace un repaso general al principio y ya está.
No soy informático así que no de que forma lo podrías hacer, lo del resto no está mal, pero el problema que le veo es que complicas más el código, porque haces la operación de sumar, luego de comprobar el resto.

Es una buena idea, pero quizás si que se consigue conplicar demasiado, xDD.
Bueno aun así lo intentare.
Por cierto si conoces una manera de representarlo matemáticamente y me imformas de ello, es posible que la consiga transcribir para mi juego, eso si que seria de muchísima ayuda.
Si no puedes, no importa.
Gracias por tu esfuerzo/tiempo.

¿Matemáticamente? No sabría bien como representarlo, ya que realmente es un problema de combinatoria.
Lo que te aconsejo es que crees un array de dimensión dinámica, que contenga campos con las coordenadas de los elementos de las casillas y un último campo que sea de 0 o 1, según si la combinación ha sido utilizada o no, o si aún se puede realizar, así la suma de esa columna será el número de combinaciones restantes, ejemplo
(1,1) ; (2,1) ; 1
(3,1) ; (1,1) ; 1
así por ejemplo en el momento que utilice la casilla (1,1) el array será
(1,1) ; (2,1) ; 0
(3,1) ; (1,1) ; 0
Ya que no puedo volver a utilizarla, esas dos combinaciones no son posibles.
De todas formas pensándolo este algoritmo será un poco lento creo.
A ver si se me ocurre otro.

Gracias. Yo tambien seguire intentandolo

Bueno, no lo había pensado... si se puede hacer mediante combinatoria mediante alguna fórmula o algún patrón a lo mejor así seria más fácil.
Gracias de todos modos.

Mediante combinatoria sería buscar todas las posibles combinaciones que suman 7, te las paso y mte explico.

Estas son todas las combinaciones posibles que suman 7, creo que no me he dejado ninguna pero te puedes hacer un programa que te cree todas las combinaciones y escoger las que sumen 7, ten encuenta que para el método que te voy a decir no tienes que tener en cuenta el orden, es decir, la combinación (1,6) es la misma que la (6,1)
1 6 0 0 0 0 0
2 5 0 0 0 0 0
3 4 0 0 0 0 0
1 1 5 0 0 0 0
1 2 4 0 0 0 0
1 3 3 0 0 0 0
2 2 3 0 0 0 0
1 1 1 4 0 0 0
1 1 2 3 0 0 0
1 2 2 2 0 0 0
1 1 1 1 3 0 0
1 1 1 2 2 0 0
1 1 2 1 2 0 0
1 1 1 1 1 2 0
1 1 1 1 1 1 1
Los ceros son espacios en blanco es para que si lo metes en un array no lo dejes en blanco, pero primero van las de dos combinaciones luego las de tres, las de 4 las 5 la de 6 y la de 7.
BUeno la otra forma que se me ha ocurrido es que, pongas los números en tu tablero 10x10, una vez puestos calcules las frecuencias de cada número, es decir, por ejemplo el 1 sale tres veces, el 2 sale cinco veces y así con todos, entonces en el array de combinaciones posibles, las de arriba, pones al lado 6 columnas con las frecuencias de cada número necesarias para crear la combinación, entonces lo único que tienes que comprobar es que las frecuencias del tablero para cuantas combinaciones te da, es decir si para crear la (115) necesitas dos unos y un cinco, pues si en tu tablero hay más de dos unos y más de un cinco puedes hacer, así cada vez que taches un número del tablero solamente tienes que recalcular las frecuencias del tablero, aunque puedes poner que las vaya restando, y comprobar únicamente las combinaciones de arriba, no las miles de combinaciones posibles del tablero.
No se si me has entendido

Para contar la frecuencias sería algo así en Visual Basic
------------------------------------------
for i = 1 to 6
  Frec_tabla[i,1] = i
  Frec_tabla[i,2] = 0
next i
for i = 1 to 10
  for j = 1 to 10
 t = Tabla[i,j]
 Frec_tabla[t,2] = Frec_tabla[t,2] + 1
   next j
next i
--------------------------------------------
Donde Frec_tabla, es una matriz de 6 filas y dos columnas, la primera columna contiene los 6 números, y la segunda columna las frecuencias de cada número.
Y Tabla[i,j] es una matriz 10x10 que contiene los números.
El primer bucle for, rellena la Frec_tabla, con frecuencias 0.
El segundo coge el valor de cada casilla de la tabla y como son valores de 1 al 6, pues coge esa posición de la tabla de frecuencias y le suma uno, por ejemplo imagina que que el primer elemento de la tabla es el 2
pues cogera Frec_tabla[2,2] = Frec_tabla[2,2] + 1 = 0 + 1.
pero como Frec_tabla[2,2]=0 antes de empezar al sumarle 1 se queda en 1.
Y así

Bueno creo que seria una buenísima solución me pondré a fondo con ello y te contare el resultado.
Muchísimas gracias por tu ayuda.
PD: Así poco a poco aprendes a programar xDD

De acuerdo,
Je je la verdad que algo se de programar, pero a nivel muuuuuuuuuuuy básico, lo suficiente para hacerme mis pogramillas.
Ya me cuentas

Je je! Ya lo conseguí!
Te paso como he hecho las combinaciones:
Donde numX es el numero de veces que sale repetido en el panel el numero X.
''PARA EL CASO 1,6
        aux1 = num1
        aux6 = num6
        Do While aux1 >= 1 And aux6 >= 1
            aux1 -= 1
            aux6 -= 6
            comp1 += 1
        Loop
        ''PARA EL CASO 2,5
        aux2 = num2
        aux5 = num5
        Do While aux2 >= 1 And aux5 >= 1
            aux2 -= 1
            aux5 -= 1
            comp2 += 1
        Loop
        ''PARA EL CASO 3,4
        aux3 = num3
        aux4 = num4
        Do While aux3 >= 1 And aux4 >= 1
            aux3 -= 1
            aux4 -= 1
            comp3 += 1
        Loop
        ''PARA EL CASO 1,1,5
        aux1 = num1
        aux5 = num5
        Do While aux1 >= 2 And aux5 >= 1
            aux1 -= 2
            aux5 -= 1
            comp4 += 1
        Loop
        ''PARA EL CASO 1,2,4
        aux1 = num1
        aux2 = num2
        aux4 = num4
        Do While aux1 >= 1 And aux2 >= 1 And aux4 >= 1
            aux1 -= 1
            aux2 -= 1
            aux4 -= 1
            comp5 += 1
        Loop
        ''PARA EL CASO 1,3,3
        aux1 = num1
        aux3 = num3
        Do While aux1 >= 1 And aux3 >= 2
            aux1 -= 1
            aux3 -= 2
            comp6 += 1
        Loop
        ''PARA EL CASO 2,2,3
        aux2 = num2
        aux3 = num3
        Do While aux2 >= 2 And aux3 >= 1
            aux1 -= 2
            aux3 -= 1
            comp7 += 1
        Loop
        ''PARA EL CASO 1,1,1,4
        aux1 = num1
        aux4 = num4
        Do While aux1 >= 3 And aux4 >= 1
            aux1 -= 3
            aux4 -= 1
            comp8 += 1
        Loop
        ''PARA EL CASO 1,1,2,3
        aux1 = num1
        aux2 = num2
        aux3 = num3
        Do While aux2 > 0 And aux3 > 0 And aux1 > 0
            aux1 -= 2
            aux2 -= 1
            aux3 -= 1
            comp9 += 1
        Loop
        ''PARA EL CASO 1,2,2,2
        aux1 = num1
        aux2 = num2
        Do While aux1 > 0 And aux2 >= 3
            aux1 -= 1
            aux2 -= 3
            comp10 += 1
        Loop
        ''PARA EL CASO 1,1,1,1,3
        aux1 = num1
        aux3 = num3
        Do While aux1 >= 4 And aux3 > 0
            aux1 -= 4
            aux3 -= 1
            comp11 += 1
        Loop
        ''PARA EL CASO 1,1,1,2,2
        aux1 = num1
        aux2 = num2
        Do While aux1 >= 3 And aux2 >= 2
            aux1 -= 3
            aux2 -= 2
            comp12 += 1
        Loop
        ''PARA EL CASO 1,1,1,1,1,2
        aux1 = num1
        aux2 = num2
        Do While aux1 >= 5 And aux2 >= 1
            aux1 -= 5
            aux2 -= 1
            comp13 += 1
        Loop
        ''PARA EL CASO 1,1,1,1,1,1,1
        aux1 = num1
        Do While aux1 >= 7
            aux1 -= 7
            comp14 += 1
        Loop
        'Se suman todas las combinaciones posibles:
        Dim combinaciones As Integer = comp1 + comp2 + comp3 + comp4 + comp5 + comp6 _
        + comp7 + comp8 + comp9 + comp10 + comp11 + comp12 + comp13 + comp14
Si quieres probar el resultado, descargatele:
     http://www.megaupload.com/?d=SEO6EIUT
Aunque se que se puede mejorar mucho.
Muchas gracias por todo.