Ayuda para programar juego en JAVA, soy novato

Primero tranquilo no tengo prisa por los puntos, así que iremos con calma.
Para empezar te recomiendo que el add (b6) y todo eso de agregar los botones va en el método init() no escribas repaint(), que quedaría algo así como:
public void init(){
         setLayout(null);
         empieza = new Thread();
        b6 = new Button("FACIL");
        b6.addActionListener(this);
       b7 = new Button("MEDIO");
        b7.addActionListener(this);
       b8 = new Button("DIFICIL");
        b8.addActionListener(this);
       Facil = new FACIL();
       Medio = new MEDIO();
       Dificil = new DIFICIL();
       add(b6);
       add(b7);
       add(b8);   
        empieza.start();
           }
Jamás uses repaint() en paint porque generarás un colapso del paint porque lo ejecutarías infinitamente.
Por favor explícame que deseas hacer con el thread que creaste para irte ayudando.

gracias amigo
La verdad es que no tengo mucha idea sobre las cosas que puse en el programa, miraba algunos ejemplos y tomaba algunas cosas y las implementaba, cualquier consejo es excelentemente recibido, todavia no termino la clase facil, pero te muestro lo que llevo y me dices si voy bien o no. gracias
CLASE FACIL
package JUEGOAP;
import java.awt.Button;
import java.awt.Color;
import java.awt.Font;
import java.awt.GridLayout;
import java.awt.Label;
import java.awt.Panel;
import java.awt.TextField;
import java.awt.event.ActionEvent;
import java.awt.event.KeyEvent;
/**
 *
 * @author Administrador
 */
public class FACIL implements Runnable{
    static void comenzar(Object object) {
        throw new UnsupportedOperationException("Not yet implemented");
    }
    static void moveBody() {
        throw new UnsupportedOperationException("Not yet implemented");
    }
Palabras pal1, pal2, pal3, pal4,pal5,pal6,pal7,pal8,pal9,pal10,pal11,pal12,pal13,pal14,pal15,pal16,pal17,pal18,pal19,pal20,pal21,pal22,pal23,pal24,pal25,pal26,pal27,pal28,pal29,pal30;
    Button b1;
    Label L1, L2, L3;
    Panel p1;
   TextField t1,t2,t3,t4,t5,t6,t7,t8,t9,t10,t11,t12,t13,t14,t15,t16,t17,t18,t19,t20,t21,t22,t23,t24,t25,t26,t27,t28,t29,t30, t31;
     public int puntaje = 0;
   static  final int MaxNiveles = 20;
    private Thread empieza;
    private int turno = 0;
    private String linea;
    private String linea2;
   public FACIL(Juego aThis) {
     pal1 = new Palabras ("auto");
     pal2 = new Palabras ("silla");
     pal3 = new Palabras ("armario");
     pal4 = new Palabras ("nube");
     pal5 = new Palabras ("caja");
     pal6 = new Palabras ("mesa");
     pal7 = new Palabras ("aerosol");
     pal8 = new Palabras ("consonante");
     pal9 = new Palabras ("abeja");
     pal10 = new Palabras ("flor");
     pal11 = new Palabras ("cesped");
     pal12 = new Palabras ("loco");
     pal13 = new Palabras ("comprender");
     pal14 = new Palabras ("camara");
     pal15 = new Palabras ("abrazar");
     pal16 = new Palabras ("parrilla");
     pal17 = new Palabras ("cerveza");
     pal18 = new Palabras ("celular");
     pal19 = new Palabras ("teclado");
     pal20 = new Palabras ("rosa");
     pal1 = new Palabras ("regar");
     pal2 = new Palabras ("iniciar");
     pal3 = new Palabras ("calendario");
     pal4 = new Palabras ("reloj");
     pal5 = new Palabras ("candelabro");
     pal6 = new Palabras ("lampara");
     pal7 = new Palabras ("estrella");
     pal8 = new Palabras ("pared");
     pal9 = new Palabras ("cancion");
     pal10 = new Palabras ("ver");
        t1 = new TextField(5);
        t2 = new TextField(5);
        t3 = new TextField(5);
        t4 = new TextField(5);
        t5 = new TextField(5);
        t6 = new TextField(5);
        t7 = new TextField(5);
        t8 = new TextField(5);
        t9 = new TextField(5);
        t10 = new TextField(5);
        t11 = new TextField(5);
        t12 = new TextField(5);
        t13 = new TextField(5);
        t14 = new TextField(5);
        t15 = new TextField(5);
        t16 = new TextField(5);
        t17 = new TextField(5);
        t18 = new TextField(5);
        t19 = new TextField(5);
        t20 = new TextField(5);
        t21 = new TextField(5);
        t22 = new TextField(5);
        t23 = new TextField(5);
        t24 = new TextField(5);
        t25 = new TextField(5);
        t26 = new TextField(5);
        t27 = new TextField(5);
        t28 = new TextField(5);
        t29 = new TextField(5);
        t30 = new TextField(5);
        t30 = new TextField(5);
        t31.setEnabled( false );
         }
    FACIL() {
        throw new UnsupportedOperationException("Not yet implemented");
    }
       public void paint(java.awt.Graphics G)
   {
       G.setFont(new Font("castellar", Font.BOLD, 30));
       G.drawString("MAXIMIZAR", 110, 100);
       int x[];
       int y[];
       x=new int [7];
       y=new int [7];
       x[0]=37;
       x[1]=57;
       x[2]=63;
       x[3]=70;
       x[4]=90;
       x[5]=63;
       x[6]=37;
       y[0]=80;
       y[1]=80;
       y[2]=65;
       y[3]=80;
       y[4]=80;
       y[5]=15;
       y[6]=80;
       G.setColor(Color.blue);
       G.drawPolygon(x,y,7);
       G.fillPolygon(x, y,7);
       int w[];
       int z[];
       w=new int [3];
       z=new int [3];
       w[0]=58;
       w[1]=63;
       w[2]=68;
       z[0]=58;
       z[1]=38;
       z[2]=58;
       G.setColor(Color.white);
       G.drawPolygon(w,z,3);
       G.fillPolygon(w,z,3);
       int v[];
       int u[];
       v=new int [6];
       u=new int [6];
       v[0]=96;
       v[1]=116;
       v[2]=116;
       v[3]=138;
       v[4]=96;
       v[5]=96;
       u[0]=80;
       u[1]=80;
       u[2]=62;
       u[3]=33;
       u[4]=18;
       u[5]=80;
       G.setColor(Color.RED);
       G.drawPolygon(v,u,6);
       G.fillPolygon(v,u,6);
       int c[];
       int d[];
       c=new int [3];
       d=new int [3];
       c[0]=108;
       c[1]=108;
       c[2]=120;
       d[0]=52;
       d[1]=36;
       d[2]=36;
       G.setColor(Color.white);
       G.drawPolygon(c,d,3);
       G.fillPolygon(c,d,3);
       add (t1);
       add (t2);
         add (t3);
       add (t4);
         add (t5);
       add (t6);
         add (t7);
       add (t8);
       add (t9);
       add (t10);
         add (t11);
       add (t12);
         add (t13);
       add (t14);
         add (t15);
       add (t16);
       add (t17);
       add (t18);
         add (t19);
       add (t20);
         add (t21);
       add (t22);
         add (t23);
       add (t24);
       add (t25);
       add (t26);
         add (t27);
       add (t28);
         add (t29);
       add (t30);
      add( t31 );
       addKeyListener( this );
       SetLayout(new GridLayout(4,10, 10,10));
       }
public void keyTyped( KeyEvent evento )
   {
      linea =" " + evento.getKeyChar();
        }
 public void comenzar(int object){
        empieza = new Thread(this);
        removeAllElements();
        puntaje = 0;
        t1.setText(pal1.pal1);
        t2.setText(pal2.pal2);
        t3.setText(pal3.pal3);
        if (linea==pal1.pal1+pal2.pal2+pal3.pal3){
            t4.setText(pal4.pal4);
            t5.setText(pal5.pal5);
            t6.setText(pal6.pal6);
            repaint();
                }
        else {t31.setText ("perdiste");}
        if (linea==pal1.pal1+pal2.pal2+pal3.pal3+pal4.pal4+pal5.pal5+pal6.pal6){
     t7.setText(pal7.pal7);
     t8.setText(pal8.pal8);
     t9.setText(pal9.pal9);
     repaint();
                }
        else {t31.setText ("perdiste");}
        if (linea==pal1.pal1+pal2.pal2+pal3.pal3+pal4.pal4+pal5.pal5+pal6.pal6+pal7.pal7+pal8.pal8+pal9.pal9){
                }
        else {t31.setText ("perdiste");}
        if (linea==pal1.pal1+pal2.pal2+pal3.pal3+pal4.pal4+pal5.pal5+pal6.pal6+pal7.pal7+pal8.pal8+pal9.pal9+pal10.pal10+pal11.pal11+pal12.pal12){
      remove(t1);
     remove(t2);
     remove(t3);
     remove(t4);
     remove(t5);
     remove(t6);
     remove(t7);
     remove(t8);
     remove(t9);
      remove(t10);
     remove(t11);
     remove(t12);
                }
        else {t31.setText ("perdiste");}
 }
    public void run() {
        throw new UnsupportedOperationException("Not supported yet.");
    }
    private void add(Label L1) {
        throw new UnsupportedOperationException("Not yet implemented");
    }
    private void add(Button b1) {
        throw new UnsupportedOperationException("Not yet implemented");
    }
    private void setLayout(GridLayout gridLayout) {
        throw new UnsupportedOperationException("Not yet implemented");
    }
    private void removeAllElements() {
        throw new UnsupportedOperationException("Not yet implemented");
    }
    public void actionPerformed(ActionEvent e) {
        throw new UnsupportedOperationException("Not supported yet.");
    }
    private void SetLayout(GridLayout gridLayout) {
        throw new UnsupportedOperationException("Not yet implemented");
    }
    private void add(TextField t1) {
        throw new UnsupportedOperationException("Not yet implemented");
    }
    private Object getContentPane() {
        throw new UnsupportedOperationException("Not yet implemented");
    }
    private void addKeyListener(FACIL aThis) {
        throw new UnsupportedOperationException("Not yet implemented");
    }
    private void remove(TextField t1) {
        throw new UnsupportedOperationException("Not yet implemented");
    }
    private void repaint() {
        throw new UnsupportedOperationException("Not yet implemented");
    }
     }
La educacion aqui es a distancia, cualquier apoyo es bien recibido, gracias por su tiempo

Pues amigo gracias, la verdad es que, como no me botaba errores, no vi que fueran innecesarios tantos procesos, pero si venia pensando que estaba mal con tantas clases, sin embargo me complique mucho, gracias por tus consejos y tu ayuda.

Ok. Viendo este código me doy cuenta de:
-Hay muchas clases.
-Se utilizan procesos innecesarios.
Aclaro, críticas totalmente constructivas. Es para ir avanzando.
¿Por qué digo esto?
Pues no hay necessidad de usar la clase Palabra, FACIL, DIFICIL, MEDIO.
Quiero replantearte lo que haz hecho, de una manera mucho más sencilla.
Eso vendrá en mi próximo mensaje.

Perdón, no sé por qué el mensaje salió dos veces.

no te preocupes, gracias por tus comentarios

Voy a empezar con una visión general del programa:
¿Qué se desea hacer? Un programa para memorizar palabras, un tipo de juego.
¿Qué es necesario para montarlo?
- El Applet donde se va a ver el juego.
   -Este incluye los botones, textos, etc para que el usuario ingrese las palabras.
- Tres colecciones, fácil, medio y difícil. (Van dentro de la clase del Applet)
- Algo que lleve la puntuación, las palabras que han sido utilizadas, etc.
Son necesarias dos clases:
- VistaUsuario. (Applet)

- ManejadorJuego. (El que procesa todo lo del juego)
Ciertas aclaraciones:
En java existe cierto estilo para escribir las clases, variables, y otros. Las clases siempre comienzan con mayúsculas y lo demás va en minúsculas excepto que se refiera.
Ejemplos: MiPrimeraClase, Applet, Button, ProcesadorLista.
Las variables siempre se escriben en minúscula al principio.
Ejemplos: frutas, palabras, carros, miNumeroTelefonico.
Repito es un estilo aceptado internacionalmente.
---
Antes de seguir con la ayuda necesito saber cómo imaginas exactamente el juego. Por ejemplo si sale una palabra y se espera 30 seg, luego aparecen dos con 30 seg para memorizar. Y hay un solo campo texto donde hay que ingresar los datos. Y luego aparece un mensaje... etc.

mira, el juego consiste en recordar las palabras, en el orden en que van saliendo, el numero de palabras que salen por turno depende del nivel (facil 3, medio 5, dificil 7). en el primer turno (ejemplo con facil) aparecen tres palabras, el jugador oprime el boton LISTO y las palabras se borran, en otro campo el jugador debe escribir las palabras que vio, en el orden que salieron, si es correcto, en el segundo turno, aparecen las mismas tres palabras mas tres nuevas, y el jugador debe repetir el proceso desde la palabra uno hasta la seis.

¿Y cuántos turnos máximo puede tener en una dificultad? ¿Se puede repetir palabras?

son treinta palabras, el usuario (en nivel facil) tiene que irlas memorizando todas, en el ultimo turno deberia escribir las treinta palabras en el mismo orden, despues de cada turno se deberian mostrar las palabras que ya escribio y las tres nuevas, cuando da en el boton comenzar, estas palabras se borran y el jugador tiene que escribirlas de nuevo desde el principio. en el nivel medio no aparecen tres nuevas palabras sino cinco, y en el dificil aparacen siete nuevas, las palabras para los niveles son las mismas solo que en diferente orden, y el juego termina cuando terminan las treinta palabras, es decir, el nivel facil tiene mas turnos, pero son menos las palabras que hay que memorizar por turno, y el nivel dificil tiene menos turnos pero mas palabras por turno
gracias de nuevo

Ok, empezaremos con la clase ManejadorJuego, te iré dando una idea del código.
Utilizaremos para las palabras la clase Vector, que puede hacer una colección de palabras.
Las palabras que pondré son ejemplos.
class ManejadorJuego {
String faciles[] = {"carro", "peluca", "hacha"};
Vector<String> facil;
public ManejadorJuego () {
facil = new Vector<String> ();
facil.addAll (Arrays.asList(faciles) );
}
}
Trata de agregar más palabras al listado fácil y repite lo mismo con medio y difícil. Te espero.

Perdona la demora
creo que asi:
class ManejadorJuego {
String faciles[] = {"carro", "peluca", "hacha","martillo","nube","señora","lampara","caballo","hoguera","cesped","guayaba","atun","madre","estrella","cielo","calor","camara","computador","escritorio","lapiz","papel","sol","animales","comisario","alcalde","ejercito","apartamento","perro","pais","gato"};
Vector<String> facil;
String medios[] = {"señora","padre","cohete","cajon","escopeta","policia","chofer","heroe","granada","medico","papaya","conejo","uva","celular","camara","estrella","hoguera","atun","ataud","pelicula","cine","boligrafo","armario","mueble","silla","cojin","memoria","programa","computador","gafas"};
Vector<String> medio;
String dificiles [] = {"calor","camara","computador","escritorio","lapiz","papel","sol","animales","comisario","alcalde","ejercito","apartamento","perro","pais","gato","uva","celular","camara","estrella","hoguera","atun","ataud","pelicula","cine","boligrafo","armario","mueble","silla","cojin","memoria"};
public ManejadorJuego () {
facil = new Vector<String> ();
facil.addAll (Arrays.asList(faciles) );
}
no conocia eso de Vector

Te faltaría
medio = new Vector<String> ();
medio.addAll (Arrays.asList(medios) );
dificil = new Vector<String> ();
dificil.addAll (Arrays.asList(dificiles) );
Los arrays de las String las metemos en un Vector porque más adelante verás que es mucho más fácil usarlas así.

perdon
class ManejadorJuego {
String faciles[] = {"carro", "peluca", "hacha","martillo","nube","señora","lampara","caballo","hoguera","cesped","guayaba","atun","madre","estrella","cielo","calor","camara","computador","escritorio","lapiz","papel","sol","animales","comisario","alcalde","ejercito","apartamento","perro","pais","gato"};
Vector<String> facil;
String medios[] = {"señora","padre","cohete","cajon","escopeta","policia","chofer","heroe","granada","medico","papaya","conejo","uva","celular","camara","estrella","hoguera","atun","ataud","pelicula","cine","boligrafo","armario","mueble","silla","cojin","memoria","programa","computador","gafas"};
Vector<String> medio;
String dificiles[]= {"calor","camara","computador","escritorio","lapiz","papel","sol","animales","comisario","alcalde","ejercito","apartamento","perro","pais","gato","uva","celular","camara","estrella","hoguera","atun","ataud","pelicula","cine","boligrafo","armario","mueble","silla","cojin","memoria"};
Vector<String>dificil;
public ManejadorJuego () {
facil = new Vector<String> ();
facil.addAll (Arrays.asList(faciles) );
medio = new Vector<String> ();
medio.addAll (Arrays.asList(medios) );
dificil = new Vector<String> ();
dificil.addAll (Arrays.asList(dificiles));
}

Supongo que no hay ningún error de compilación, ahora el ManejadorJuego deberá tener variables de tipo estática, más o menos para que entiendas es una instancia que no cambian. Después de que modifique la clase agrega
class ManejadorJuego {
public static String FACIL = "f";
public static String MEDIO = "m";
public static String DIFICIL = "d";
Vector<String> palabrasRestantes;
String faciles[] = {"carro", "peluca", "hacha","martillo","nube","señora","lampara","caballo","hoguera","cesped","guayaba","atun","madre","estrella","cielo","calor","camara","computador","escritorio","lapiz","papel","sol","animales","comisario","alcalde","ejercito","apartamento","perro","pais","gato"};
Vector<String> facil;
String medios[] = {"señora","padre","cohete","cajon","escopeta","policia","chofer","heroe","granada","medico","papaya","conejo","uva","celular","camara","estrella","hoguera","atun","ataud","pelicula","cine","boligrafo","armario","mueble","silla","cojin","memoria","programa","computador","gafas"};
Vector<String> medio;
String dificiles[]= {"calor","camara","computador","escritorio","lapiz","papel","sol","animales","comisario","alcalde","ejercito","apartamento","perro","pais","gato","uva","celular","camara","estrella","hoguera","atun","ataud","pelicula","cine","boligrafo","armario","mueble","silla","cojin","memoria"};
Vector<String>dificil;
public ManejadorJuego (String tipo) {
facil = new Vector<String> ();
facil.addAll (Arrays.asList(faciles) );
medio = new Vector<String> ();
medio.addAll (Arrays.asList(medios) );
dificil = new Vector<String> ();
dificil.addAll (Arrays.asList(dificiles));
if (tipo == DIFICIL) palabrasRestantes = dificil;
else if (tipo == MEDIO) palabrasRestantes = medio;
else if (tipo == FACIL) palabrasRestantes = facil;
dificultad = tipo;
}
Aclaro cualquier duda sobre eso, por cierto si es algún tipo de trabajo a asignación dime la fecha de entrega para acelerar el proceso.

Hasta ahi vamos excelente, todo claro, y pues en cuanto a la fecha, ya estoy un poco retrasado no te habia dicho nada para no afanarte, pero no te preocupes, algo inventare; pero todo me ah quedado clarisimo, ya me estoy dando cuenta que es mucho mas facil por este metodo, lastimosamente no lo conocia

Me falto otra instancia que es palabrasActuales:
Vector<String> palabrasActuales; // (Esto iría al principio de la clase)
palabrasActuales = new Vector<String> (); // (Esto iría dentro del constructor de la clase)
Ahora sí, agrega estos métodos a la clase:
public Vector<String> obtieneNuevasPalabras (int c) {
for (int i = 0; i < c; i++) {
Vector<String> palabrasNuevas;
int azar = Math.random()*palabrasRestantes.size()
palabrasRestantes.get (azar); //obtiene la palabra de la colección
palabrasRestantes.remove (azar); //borra la palabra de la colección
}
return palabrasNuevas;
}
public void agregaPalabras () {
int opcion;
if (dificultad == FACIL) opcion = 3;
if (dificultad == MEDIO) opcion = 5;
if (dificultad == DIFICIL) opcion = 5;
for (String nPalabra : obtieneNuevasPalabras() ) {
palabrasActuales.add(nPalabra);
}
public boolean noQuedanPalabras {
return (palabrasRestantes.size()  == 0);
}
Aclaro tus dudas y disculpa por lo de la fecha. No sé si conoces lo de returny for, todo eso, ahí me avisas. Hago lo que puedo, jeje tengo exámenes xD.
Piensa un método para verficar respuesta correcta y me dices.

No conocia lo de returny for, pero ya busque, y entendi, soy noob perdona
oye y me salio un error en esto
public boolean noQuedanPalabras{
return (palabrasRestantes.size()==0);
}

¿Mm qué error te da?

';' expected
return outside method

Ahh xD es que le faltan los paréntesis:
public boolean noQuedanPalabras () {
return (palabrasRestantes.size()==0);
}
Voy a estudiar un rato y te respondo aproximadamente en 25 min.

ok, gracias, ya se arreglo

supongo que las palabras se validan con un for y un do
do {
palabraingresada = JOptionPane.showInputDialog("escriba la secuencia");
for(int a=0;a<vector.length();a++)
{
if(palabraingresada.equals(vector.subst.
{
v=false;
aciertos=aciertos+1;
}
}
if(v==true)
{
("perdiste, intenta de nuevo")
la verdad, pues es mas o menos lo que pienso, no se, tu diras

Te voy a mostrar mi propuesta:
Vector<String> respuestas = new Vector<String> ();
for (int i = 0; i < palabrasActuales.size(); i++) {
String palabraIngresada = JOptionPane.showInputDialog("Escribe la secuencia").toLowerCase();
respuestas.add (palabraIngresada);
}
if (! (respuestas.equals(palabrasActuales) ) ) {JOptionPane.showMessageDialog (Has perdido.) }
ToLowerCase significa "en minúsculas" lo que hará que las palabras ingresadas sean sólo minúscula evitando problemas al comparar Strings.
Add sirve para agregar al Vector y get para obtener un elemento.
Eso es hasta que haya escrito todas las palabras ¿Quieres qué se notifique antes o después de ingresar una palabra?

no importa si es antes o despues

Ok.
Mmm creo que faltaría:
Verificar si ya es ganador;
Applet donde haya botones para elegir dificultad;
MétodosApplet para mostrar palabras si es q no se va usar el showMessageDialog.
¿Alguna idea?
Ya casi terminamos xD.

Tu eres el experto, yo al principio habia hecho algo asi:
op = new Choice();
        op.setBounds(130,120,80,60);
        op.setFont(font2);
        op.addItem("Facil");
        op.addItem("Medio");
        op.addItem("Dificil");
y luego
if(dificultad == 0)      facil;
        else if(dificultad == 1) medio;
        else if(dificultad == 2) dificil;
algo asi, no se

Sí, entiendo. Te pido que des ideas para que haya retroalimentación y no solo que te diga todo cómo hacerlo.
Bueno, tu código lo veo bien, pero necesitas un botón para que primero elijan de la lista desplegable y luego hagan clic en empezar juego.
Ejemplo:
También creas la clase que será el Applet
class MiApplet extends Applet implements ActionListener{
Choice op;
Button confirmar;
public void init () {
op = new Choice ();
op = new Choice();
        op.setBounds(130,120,80,60);
        op.setFont(font2);
        op.addItem("Facil");
        op.addItem("Medio");
        op.addItem("Dificil"); // Igual como escribiste
confirmar = new Button ("Empezar");
confirmar.setBounds (loqquieras, loqquieras, loqquieras, loqquieras);
confirmar.addActionListener (this);
}
public void actionPerformed (ActionEvent e) {
String respuesta = op.getSelectedItem();
//Aquí iría lo demás, disculpa estoy cansado sigo lo más pronto posible
}
}
Asegúrate de poner la instancia font2 para la fuente.
Si no sabes algo me preguntas y te explico =D.

Vamos bien amigo, ahora supongo que vendria el paint, y empezamos a agregar botones y eso, no se si se agrega un panel

Ok.
Es cierto de que falta el paint y todo eso.
La clase del Applet debe tener una variable de tipo ManejadorJuego.
ManejadorJuego mj;
Pero voy a terminar lo del actionPerformed (ActionEvent e) {
String respuesta = op.getSelectedItem();
if (respuesta == "Dificil") mj = new ManejadorJuego (ManejadorJuego.DIFICIL);
// igual con los otros
Y tendrías que llamar el método para preguntar.
}
Por favor manda TODO EL código para ver cómo va. (Incluye la clase del applet y la ManejadorJuego)

public static String FACIL = "f";
public static String MEDIO = "m";
public static String DIFICIL = "d";
Vector<String> palabrasActuales;
Vector<String> palabrasRestantes;
    class ManejadorJuego {
String faciles[] = {"carro", "peluca", "hacha","martillo","nube","señora","lampara","caballo","hoguera","cesped","guayaba","atun","madre","estrella","cielo","calor","camara","computador","escritorio","lapiz","papel","sol","animales","comisario","alcalde","ejercito","apartamento","perro","pais","gato"};
Vector<String> facil;
String medios[] = {"señora","padre","cohete","cajon","escopeta","policia","chofer","heroe","granada","medico","papaya","conejo","uva","celular","camara","estrella","hoguera","atun","ataud","pelicula","cine","boligrafo","armario","mueble","silla","cojin","memoria","programa","computador","gafas"};
Vector<String> medio;
String dificiles[]= {"calor","camara","computador","escritorio","lapiz","papel","sol","animales","comisario","alcalde","ejercito","apartamento","perro","pais","gato","uva","celular","camara","estrella","hoguera","atun","ataud","pelicula","cine","boligrafo","armario","mueble","silla","cojin","memoria"};
Vector<String>dificil;
        private final String dificultad;
        private Vector<String> palabrasNuevas;
        private Font font2 = new Font("Arial",Font.PLAIN, 12);
public ManejadorJuego (String tipo) {
facil = new Vector<String> ();
facil.addAll (Arrays.asList(faciles) );
medio = new Vector<String> ();
medio.addAll (Arrays.asList(medios) );
dificil = new Vector<String> ();
dificil.addAll (Arrays.asList(dificiles));
palabrasActuales = new Vector<String> ();
if (tipo == DIFICIL) palabrasRestantes = dificil;
else if (tipo == MEDIO) palabrasRestantes = medio;
else if (tipo == FACIL) palabrasRestantes = facil;
dificultad = tipo;
}
        private ManejadorJuego(Vector<String> dificil) {
            throw new UnsupportedOperationException("Not yet implemented");
        }
class MiApplet extends Applet implements ActionListener{
Choice op;
Button confirmar;
            private ManejadorJuego mj;
            @Override
public void init () {
op = new Choice ();
op = new Choice();
        op.setBounds(130,120,80,60);
        op.setFont(font2);
        op.addItem("Facil");
        op.addItem("Medio");
        op.addItem("Dificil");
confirmar = new Button ("Empezar");
confirmar.setBounds (30, 50, 80, 50);
confirmar.addActionListener (this);
}
public void actionPerformed (ActionEvent e) {
String respuesta = op.getSelectedItem();
if (respuesta == "Dificil") mj = new ManejadorJuego (ManejadorJuego.DIFICIL);
else if (respuesta=="Medio") mj= new ManejadorJuego (ManejadorJuego.MEDIO);
else if (respuesta=="Facil") mj= new ManejadorJuego (ManejadorJuego.FACIL);
}
        }
public Vector<String> obtieneNuevasPalabras (int c) {
for (int i = 0; i < c; i++) {
Vector<String> palabrasNuevas;
int azar =      (int) (Math.random() * palabrasRestantes.size());
palabrasRestantes.get (azar);
palabrasRestantes.remove (azar);
}
return palabrasNuevas;
}
public void agregaPalabras () {
int opcion;
if (dificultad == FACIL) opcion = 3;
if (dificultad == MEDIO) opcion = 5;
if (dificultad == DIFICIL) opcion = 5;
for (String nPalabra : obtieneNuevasPalabras() ) {
palabrasActuales.add(nPalabra);
}
Vector<String> respuestas = new Vector<String> ();
for (int i = 0; i < palabrasActuales.size(); i++) {
String palabraIngresada = JOptionPane.showInputDialog("Escribe la secuencia").toLowerCase();
respuestas.add (palabraIngresada);
}
if (! (respuestas.equals(palabrasActuales) ) ) {
   JOptionPane.showMessageDialog(null,"Has perdido.");
}
}
public boolean noQuedanPalabras(){
        return (palabrasRestantes.size()==0);
        }
        private Iterable<String> obtieneNuevasPalabras() {
            throw new UnsupportedOperationException("Not yet implemented");
        }
    }
        private Iterable<String> obtieneNuevasPalabras() {
            throw new UnsupportedOperationException("Not yet implemented");
        }
CRITICA TODO LO QUE QUIERAS

Envíame el código de nuevo sin los throw new UnsupportedOperationException por favor. No son necesarios.

public static String FACIL = "f";
public static String MEDIO = "m";
public static String DIFICIL = "d";
Vector<String> palabrasActuales;
Vector<String> palabrasRestantes;
    class ManejadorJuego {
String faciles[] = {"carro", "peluca", "hacha","martillo","nube","señora","lampara","caballo","hoguera","cesped","guayaba","atun","madre","estrella","cielo","calor","camara","computador","escritorio","lapiz","papel","sol","animales","comisario","alcalde","ejercito","apartamento","perro","pais","gato"};
Vector<String> facil;
String medios[] = {"señora","padre","cohete","cajon","escopeta","policia","chofer","heroe","granada","medico","papaya","conejo","uva","celular","camara","estrella","hoguera","atun","ataud","pelicula","cine","boligrafo","armario","mueble","silla","cojin","memoria","programa","computador","gafas"};
Vector<String> medio;
String dificiles[]= {"calor","camara","computador","escritorio","lapiz","papel","sol","animales","comisario","alcalde","ejercito","apartamento","perro","pais","gato","uva","celular","camara","estrella","hoguera","atun","ataud","pelicula","cine","boligrafo","armario","mueble","silla","cojin","memoria"};
Vector<String>dificil;
        private final String dificultad;
        private Vector<String> palabrasNuevas;
        private Font font2 = new Font("Arial",Font.PLAIN, 12);
public ManejadorJuego (String tipo) {
facil = new Vector<String> ();
facil.addAll (Arrays.asList(faciles) );
medio = new Vector<String> ();
medio.addAll (Arrays.asList(medios) );
dificil = new Vector<String> ();
dificil.addAll (Arrays.asList(dificiles));
palabrasActuales = new Vector<String> ();
if (tipo == DIFICIL) palabrasRestantes = dificil;
else if (tipo == MEDIO) palabrasRestantes = medio;
else if (tipo == FACIL) palabrasRestantes = facil;
dificultad = tipo;
}
class MiApplet extends Applet implements ActionListener{
Choice op;
Button confirmar;
            private ManejadorJuego mj;
            @Override
public void init () {
op = new Choice ();
op = new Choice();
        op.setBounds(130,120,80,60);
        op.setFont(font2);
        op.addItem("Facil");
        op.addItem("Medio");
        op.addItem("Dificil");
confirmar = new Button ("Empezar");
confirmar.setBounds (30, 50, 80, 50);
confirmar.addActionListener (this);
}
public void actionPerformed (ActionEvent e) {
String respuesta = op.getSelectedItem();
if (respuesta == "Dificil") mj = new ManejadorJuego (ManejadorJuego.DIFICIL);
else if (respuesta=="Medio") mj= new ManejadorJuego (ManejadorJuego.MEDIO);
else if (respuesta=="Facil") mj= new ManejadorJuego (ManejadorJuego.FACIL);
}
        }
public Vector<String> obtieneNuevasPalabras (int c) {
for (int i = 0; i < c; i++) {
Vector<String> palabrasNuevas;
int azar =      (int) (Math.random() * palabrasRestantes.size());
palabrasRestantes.get (azar);
palabrasRestantes.remove (azar);
}
return palabrasNuevas;
}
public void agregaPalabras () {
int opcion;
if (dificultad == FACIL) opcion = 3;
if (dificultad == MEDIO) opcion = 5;
if (dificultad == DIFICIL) opcion = 5;
for (String nPalabra : obtieneNuevasPalabras() ) {
palabrasActuales.add(nPalabra);
}
Vector<String> respuestas = new Vector<String> ();
for (int i = 0; i < palabrasActuales.size(); i++) {
String palabraIngresada = JOptionPane.showInputDialog("Escribe la secuencia").toLowerCase();
respuestas.add (palabraIngresada);
}
if (! (respuestas.equals(palabrasActuales) ) ) {
   JOptionPane.showMessageDialog(null,"Has perdido.");
}
}
public boolean noQuedanPalabras(){
        return (palabrasRestantes.size()==0);
        }
    }

ya lo puse

Voy a compilar lo que llevamos. Por cierto,
public static String FACIL = "f";
public static String MEDIO = "m";
public static String DIFICIL = "d";
Vector<String> palabrasActuales;
Vector<String> palabrasRestantes;
va después de
class ManejadorJuego {
Porque es parte de la clase

Lo compilé y vi que había que corregir ciertas cosas, mañana sin falta te doy terminado esto, pero para que veas como va quedando (lo puedes compilar).
import java.awt.*;
import java.applet.*;
import java.util.*;
import java.awt.event.*;
import javax.swing.*;
class ManejadorJuego {
    public static String FACIL = "f";
    public static String MEDIO = "m";
    public static String DIFICIL = "d";
    Vector<String> palabrasActuales;
    Vector<String> palabrasRestantes;
    String faciles[] = {"carro", "peluca", "hacha","martillo","nube","señora","lampara","caballo","hoguera","cesped","guayaba","atun","madre","estrella","cielo","calor","camara","computador","escritorio","lapiz","papel","sol","animales","comisario","alcalde","ejercito","apartamento","perro","pais","gato"};
    Vector<String> facil;
    String medios[] = {"señora","padre","cohete","cajon","escopeta","policia","chofer","heroe","granada","medico","papaya","conejo","uva","celular","camara","estrella","hoguera","atun","ataud","pelicula","cine","boligrafo","armario","mueble","silla","cojin","memoria","programa","computador","gafas"};
    Vector<String> medio;
    String dificiles[]= {"calor","camara","computador","escritorio","lapiz","papel","sol","animales","comisario","alcalde","ejercito","apartamento","perro","pais","gato","uva","celular","camara","estrella","hoguera","atun","ataud","pelicula","cine","boligrafo","armario","mueble","silla","cojin","memoria"};
    Vector<String>dificil;
    private final String dificultad;
    private Vector<String> palabrasNuevas;
    private Font font2 = new Font("Arial",Font.PLAIN, 12);
    public ManejadorJuego (String tipo) {
        facil = new Vector<String> ();
        facil.addAll (Arrays.asList(faciles) );
        medio = new Vector<String> ();
        medio.addAll (Arrays.asList(medios) );
        dificil = new Vector<String> ();
        dificil.addAll (Arrays.asList(dificiles));
        palabrasActuales = new Vector<String> ();
        if (tipo == DIFICIL) palabrasRestantes = dificil;
        else if (tipo == MEDIO) palabrasRestantes = medio;
        else if (tipo == FACIL) palabrasRestantes = facil;
        dificultad = tipo;
    }
    public Vector<String> obtieneNuevasPalabras (int c) {
    for (int i = 0; i < c; i++) {
    Vector<String> palabrasNuevas;
    int azar =      (int) (Math.random() * palabrasRestantes.size());
    palabrasRestantes.get (azar);
    palabrasRestantes.remove (azar);
    }
    return palabrasNuevas;
    }
        public void agregaPalabras () {
            int opcion = 0;
            if (dificultad == FACIL) opcion = 3;
            if (dificultad == MEDIO) opcion = 5;
            if (dificultad == DIFICIL) opcion = 5;
            for (String nPalabra : obtieneNuevasPalabras(opcion) ) {
            palabrasActuales.add(nPalabra);
            }
            Vector<String> respuestas = new Vector<String> ();
            for (int i = 0; i < palabrasActuales.size(); i++) {
            String palabraIngresada = JOptionPane.showInputDialog("Escribe la secuencia").toLowerCase();
            respuestas.add (palabraIngresada);
        }
    if (! (respuestas.equals(palabrasActuales) ) ) {
       JOptionPane.showMessageDialog(null,"Has perdido.");
    }
    }
    public boolean noQuedanPalabras(){
            return (palabrasRestantes.size()==0);
    }
}
public class MiApplet extends Applet implements ActionListener{
    Choice op;
    Button confirmar;
                private ManejadorJuego mj;
    public void init () {
    op = new Choice ();
    op = new Choice();
            op.setBounds(130,120,80,60);
            //op.setFont(font2);
            op.addItem("Facil");
            op.addItem("Medio");
            op.addItem("Dificil");
    confirmar = new Button ("Empezar");
    confirmar.setBounds (30, 50, 80, 50);
    confirmar.addActionListener (this);
    add (op);
    add (confirmar);
    }
    public void actionPerformed (ActionEvent e) {
    String respuesta = op.getSelectedItem();
    if (respuesta == "Dificil") mj = new ManejadorJuego (ManejadorJuego.DIFICIL);
    else if (respuesta=="Medio") mj= new ManejadorJuego (ManejadorJuego.MEDIO);
    else if (respuesta=="Facil") mj= new ManejadorJuego (ManejadorJuego.FACIL);
    }
}

Ok gracias, una pregunta, el error que tenia antes con los botones (se oprimian solos) era por el repaint?

Sí, y porque agregabas infinitamente los botones.

ahh, ok bueno saberlo, gracias

Mmm perdón... cuánto debía durar mostrándose la lista de palabras.

Pues ahi tengo un dilema, no se si poner tiempo o no, porque si le ponemos tiempo el juego podria tornarse demasiado dificil (incluso en nivel facil), lo mejor seria colocar un boton que indique cuando quitarlas, es decir, el usuario memoriza las 12 palabras (un ejemplo) en el tiempo que tarde, luego, cuando crea conveniente oprime el boton y las palabras se borra, inmediatamente procedera a escribirlas en el mismo orden, y asi sucesivamente.
tu que opinas
es mas dificl asi?

¿Podría ser que por palabra haya una duración de x segundos?

Mmmm así es más díficil. Tienes razón, mejor que tome su tiempo para aprenderlas.

Pues esa era mi idea original, no se si recomiendes adaptarla, pero considero que si le ponemos tiempo fijo a cada secuencia seria muy complicado memorizar, porque aprender la secuencia de por si es muy dificil, y encima le agregamos contra reloj, pues mas dificil aun

Apoyo lo de dejar el tiempo que el usuario quiera. ¿Te parece?

Perfecto, sera genial

Ok dame un tiempo para terminar el programa.

Mañana sin falta =S; ;D

Gracias

El código está casi terminador falta: que me des las listas de palabras en múltiplos de 3,5 y 7. Agregas mensaje de "Has ganado!". Además necesito que lo compiles para que me cuentes que es lo que piensas acerca del programa.
import java.awt.*;
import java.applet.*;
import java.util.*;
import java.awt.event.*;
import javax.swing.*;
public class MiApplet extends Applet implements ActionListener{
    Choice op;
    Button confirmar, intentar;
    private ManejadorJuego mj;
    private Font font2 = new Font("Arial",Font.PLAIN, 12);
    TextArea campoTexto;
    public void init () {
    op = new Choice ();
    op = new Choice();
            op.setBounds(130,120,80,60);
            op.setFont(font2);
            op.addItem("Fácil");
            op.addItem("Medio");
            op.addItem("Difícil");
    confirmar = new Button ("Empezar");
    confirmar.setBounds (30, 50, 80, 50);
    confirmar.addActionListener (this);
    campoTexto = new TextArea ("", 12, 56, TextArea.SCROLLBARS_VERTICAL_ONLY );
    intentar = new Button ("Repetir secuencia");
    add (op);
    add (confirmar);
    add (intentar); intentar.addActionListener (this);
    add (campoTexto);
    intentar.setVisible (false);
    }
    public void actionPerformed (ActionEvent e) {
    if (e.getSource() == confirmar) iniciaJuego();
    if (e.getSource() == intentar ) sigueJuego();
    }
    public void iniciaJuego () {
        String respuesta = op.getSelectedItem();
        if (respuesta.equals ("Difícil")) mj = new ManejadorJuego (ManejadorJuego.DIFICIL);
        else if (respuesta.equals ("Medio")) mj= new ManejadorJuego (ManejadorJuego.MEDIO);
        else if (respuesta.equals ("Fácil")) mj= new ManejadorJuego (ManejadorJuego.FACIL);
        intentar.setVisible (true);
        op.setVisible (false);
        confirmar.setVisible (false);
        doLayout();
        repaint();
        mj.agregaPalabras ();
        mostrar (mj.palabras());
    }
    public void sigueJuego () {
        campoTexto.setText ("");
        mj.pregunta();
        mj.agregaPalabras ();
        mostrar (mj.palabras());
    }
    public void mostrar (Vector<String> s) {
        campoTexto.setText ("");
        for (String palabra : s) {
            campoTexto.append (palabra+ " ");
        }
    }
}
//--------------------------------------------------------------------------------------------------------------------------
class ManejadorJuego {
    public static String FACIL = "f";
    public static String MEDIO = "m";
    public static String DIFICIL = "d";
    Vector<String> palabrasActuales;
    Vector<String> palabrasRestantes;
    String faciles[] = {"carro", "peluca", "hacha","martillo","nube","señora","lampara","caballo","hoguera","cesped","guayaba","atun","madre","estrella","cielo","calor","camara","computador","escritorio","lapiz","papel","sol","animales","comisario","alcalde","ejercito","apartamento","perro","pais","gato"};
    Vector<String> facil;
    String medios[] = {"señora","padre","cohete","cajon","escopeta","policia","chofer","heroe","granada","medico","papaya","conejo","uva","celular","camara","estrella","hoguera","atun","ataud","pelicula","cine","boligrafo","armario","mueble","silla","cojin","memoria","programa","computador","gafas"};
    Vector<String> medio;
    String dificiles[]= {"calor","camara","computador","escritorio","lapiz","papel","sol","animales","comisario","alcalde","ejercito","apartamento","perro","pais","gato","uva","celular","camara","estrella","hoguera","atun","ataud","pelicula","cine","boligrafo","armario","mueble","silla","cojin","memoria"};
    Vector<String>dificil;
    private final String dificultad;
    private Vector<String> palabrasNuevas;
    TextField campoTexto;
    public ManejadorJuego (String tipo) {
        facil = new Vector<String> ();
        facil.addAll (Arrays.asList(faciles) );
        medio = new Vector<String> ();
        medio.addAll (Arrays.asList(medios) );
        dificil = new Vector<String> ();
        dificil.addAll (Arrays.asList(dificiles));
        palabrasActuales = new Vector<String> ();
        palabrasRestantes = new Vector<String> ();
        if (tipo == DIFICIL) palabrasRestantes = dificil;
        else if (tipo == MEDIO) palabrasRestantes = medio;
        else if (tipo == FACIL) palabrasRestantes = facil;
        dificultad = tipo;
    }
    private Vector<String> obtieneNuevasPalabras (int c) {
    Vector<String> palabrasNuevas = new Vector<String> ();
    for (int i = 0; i < c; i++) {
    int azar = (int) (Math.random() * palabrasRestantes.size());
    palabrasNuevas.add(palabrasRestantes.get (azar));
    palabrasRestantes.remove (azar);
    }
    return palabrasNuevas;
    }
    public void agregaPalabras () {
            int opcion = 0;
            if (dificultad == FACIL) opcion = 3;
            if (dificultad == MEDIO) opcion = 5;
            if (dificultad == DIFICIL) opcion = 5;
            Vector<String> otras = obtieneNuevasPalabras(opcion);
            for (String nPalabra : otras ) {
            palabrasActuales.add(nPalabra);
            }
    }
    public void pregunta () {
        Vector<String> respuestas = new Vector<String> ();
            for (int i = 0; i < palabrasActuales.size(); i++) {
            String palabraIngresada = JOptionPane.showInputDialog("Escribe la secuencia palabra por palabra").toLowerCase();
            respuestas.add (palabraIngresada);
        }
            if (! (respuestas.equals(palabrasActuales) ) ) {
               JOptionPane.showMessageDialog(null,"¡¡¡Así no era la secuencia!!!");
            }
    }
    public boolean noQuedanPalabras(){
            return (palabrasRestantes.size()==0);
    }
    public Vector<String> palabras() {
        return palabrasActuales;
    }
}

Oye no te entendi muy bien lo de los multiplos de 3,5 y 7 puedes ser mas expecifico, y otra cosa, no se que paso , me sale que no tiene clase main, y no compila, ayudame por fa, gracias

Mmm es que si haces un applet no debe tener clase main. Cuando creas el nuevo proyecto debes darle crear un applet, no una aplicación.
Lo de los múltiplos de 3 es que me des una lista de palabras de 24 elementos, por ejemplo (es múltiplo de 3), esto para que las palabras salgan de 3 en 3 y dé un número exacto. No sé si me explico.

No se si lo que quieres es una nueva lista, porque las palabras que teniamos no sirven? eran 30 (multiplo de 3 y de 5) y le quitas dos y te queda multiplo de 7, si no es esto disculpame, has una peticion mas detallada de lo que quieres, perdon
carro
peluca
hacha
martillonube
señora
lampara
caballo
hoguera
cesped
guayaba
atun
madre
estrella
cielo
calor
camara
computador
escritorio
lapiz
papel
sol
animales
comisario
alcalde
ejercito
apartamento
perro
pais
gato
laguna

Ok. Está bien.
Y... ¿Pudiste corregir lo del applet?
import java.awt.*;
import java.applet.*;
import java.util.*;
import java.awt.event.*;
import javax.swing.*;
public class MiApplet extends Applet implements ActionListener{
    Choice op;
    Button confirmar, intentar;
    private ManejadorJuego mj;
    private Font font2 = new Font("Arial",Font.PLAIN, 12);
    TextArea campoTexto;
    public void init () {
    op = new Choice ();
    op = new Choice();
            op.setBounds(130,120,80,60);
            op.setFont(font2);
            op.addItem("Fácil");
            op.addItem("Medio");
            op.addItem("Difícil");
    confirmar = new Button ("Empezar");
    confirmar.setBounds (30, 50, 80, 50);
    confirmar.addActionListener (this);
    campoTexto = new TextArea ("", 12, 56, TextArea.SCROLLBARS_VERTICAL_ONLY );
    intentar = new Button ("Repetir secuencia");
    add (op);
    add (confirmar);
    add (intentar); intentar.addActionListener (this);
    add (campoTexto);
    intentar.setVisible (false);
    }
    public void actionPerformed (ActionEvent e) {
    if (e.getSource() == confirmar) iniciaJuego();
    if (e.getSource() == intentar ) sigueJuego();
    }
    public void iniciaJuego () {
        String respuesta = op.getSelectedItem();
        if (respuesta.equals ("Difícil")) mj = new ManejadorJuego (ManejadorJuego.DIFICIL);
        else if (respuesta.equals ("Medio")) mj= new ManejadorJuego (ManejadorJuego.MEDIO);
        else if (respuesta.equals ("Fácil")) mj= new ManejadorJuego (ManejadorJuego.FACIL);
        intentar.setVisible (true);
        op.setVisible (false);
        confirmar.setVisible (false);
        doLayout();
        repaint();
        mj.agregaPalabras ();
        mostrar (mj.palabras());
    }
    public void sigueJuego () {
        campoTexto.setText ("");
        mj.pregunta();
        if (mj.noQuedanPalabras () ) { JOptionPane.showMessageDialog (null, "¡Felicidades! Tienes una memoria asombrosa"); reinicia(); return;  }
        mj.agregaPalabras ();
        mostrar (mj.palabras());
    }
    public void mostrar (Vector<String> s) {
        campoTexto.setText ("");
        for (String palabra : s) {
            campoTexto.append (palabra+ " ");
        }
    }
    public void reinicia () {
        op.setVisible(true);
        confirmar.setVisible(true);
        intentar.setVisible (false);
        doLayout();
        repaint();
    }
}
//--------------------------------------------------------------------------------------------------------------------------
class ManejadorJuego {
    public static String FACIL = "f";
    public static String MEDIO = "m";
    public static String DIFICIL = "d";
    Vector<String> palabrasActuales;
    Vector<String> palabrasRestantes;
    String faciles[] = {"carro", "peluca", "hacha","martillo","nube","señora","lámpara","caballo","hoguera","cesped","guayaba","atun","madre","estrella","cielo","calor","camara","computador","escritorio","lapiz","papel","sol","animales","comisario","alcalde","ejercito","apartamento","perro","pais","gato"};
    Vector<String> facil;
    String medios[] = {"señora","padre","cohete","cajon","escopeta","policia","chofer","heroe","granada","medico","papaya","conejo","uva","celular","camara","estrella","hoguera","atun","ataud","pelicula","cine","boligrafo","armario","mueble","silla","cojin","memoria","programa","computador","gafas"};
    Vector<String> medio;
    String dificiles[]= {"calor","camara","computador","escritorio","lapiz","papel","sol","animales","comisario","alcalde","ejercito","apartamento","perro","pais","gato","uva","celular","camara","estrella","hoguera","atun","ataud","pelicula","cine","boligrafo","armario","mueble","silla"};
    Vector<String>dificil;
    private final String dificultad;
    private Vector<String> palabrasNuevas;
    TextField campoTexto;
    public ManejadorJuego (String tipo) {
        facil = new Vector<String> ();
        facil.addAll (Arrays.asList(faciles) );
        medio = new Vector<String> ();
        medio.addAll (Arrays.asList(medios) );
        dificil = new Vector<String> ();
        dificil.addAll (Arrays.asList(dificiles));
        palabrasActuales = new Vector<String> ();
        palabrasRestantes = new Vector<String> ();
        if (tipo == DIFICIL) palabrasRestantes = dificil;
        else if (tipo == MEDIO) palabrasRestantes = medio;
        else if (tipo == FACIL) palabrasRestantes = facil;
        dificultad = tipo;
    }
    private Vector<String> obtieneNuevasPalabras (int c) {
    Vector<String> palabrasNuevas = new Vector<String> ();
    for (int i = 0; i < c; i++) {
    int azar = (int) (Math.random() * palabrasRestantes.size());
    palabrasNuevas.add(palabrasRestantes.get (azar));
    palabrasRestantes.remove (azar);
    }
    return palabrasNuevas;
    }
    public void agregaPalabras () {
            int opcion = 0;
            if (dificultad == FACIL) opcion = 3;
            if (dificultad == MEDIO) opcion = 5;
            if (dificultad == DIFICIL) opcion = 5;
            Vector<String> otras = obtieneNuevasPalabras(opcion);
            for (String nPalabra : otras ) {
            palabrasActuales.add(nPalabra);
            }
    }
    public void pregunta () {
        Vector<String> respuestas = new Vector<String> ();
            for (int i = 0; i < palabrasActuales.size(); i++) {
            String palabraIngresada = JOptionPane.showInputDialog("Escribe la secuencia palabra por palabra").toLowerCase();
            respuestas.add (palabraIngresada);
        }
            if (! (respuestas.equals(palabrasActuales) ) ) {
               JOptionPane.showMessageDialog(null,"¡¡¡Así no era la secuencia!!!");
            }
    }
    public boolean noQuedanPalabras(){
            return (palabrasRestantes.size()==0);
    }
    public Vector<String> palabras() {
        return palabrasActuales;
    }
}

Si ya lo soluciones, gracias, habia sido un tonto error, el juego esta fantastico, no se tu que piensas

Sí, está bien bueno. Solo pregunto: ¿Quieres agregar algo más?

Para mi esta bien asi, muchas gracias, tu solo dime si tienes algo mas, o finalizo la pregunta, de todos modos mil gracias

Diría yo que sería importante acentuar las palabras que le faltaban la tilde ortográfica. Fue un placer ayudarte =D.

Dame unos minutos, me percaté de que al programa le faltaba algo.