Bueno pues esta ya por fin, es la ultima y definitiva. Primero decir que esta práctica no nos ha parecido demasiado difícil de realizar, ya que con la amplia base que teníamos después de hacer el juego y otros cursos ya sabíamos de qué iba el tema. Ya sin más preámbulos os vamos a pasar a comentar como hemos realizado el reproductor.

Lo primero que hemos hecho ha sido crear una clase que implementase a ActionListener y a ControllerListener. No hemos extendido de JFrame para cambiar un poco el modo de utilizar las interfaces gráficas, aunque lo que hemos hecho simplemente ha sido crear un JFrame y “jugar” con él como veréis a continuación.

Ahí va el constructor comentado:

public Reproductor(){             

         ppal=new JFrame(“Reproductor”);     

         boton1=new JButton(new ImageIcon( “imagen1.jpg” ));  

         boton2=new JButton(new ImageIcon( “imagen2.jpg” ));     

         boton3=new JRadioButton( “Reinicio” ); //casilla de verificación, en caso de que se seleccione el video se reiniciara automáticamente al acabar su reproducción.

         panel=new JPanel();

         try{

            url=new URL( “file:video.mpg” ); //lo hemos guardado en la misma carpeta

            player=Manager.createPlayer(url);

            player.addControllerListener(this);

         } //sencillo no??

            catch(Exception e){ //habíamos puesto más excepciones pero por no cansar…

               System.exit(0);

            }    

          ensamblar(); //método donde se añade los botones al panel y este al ppal //(JFrame), también se añade el escuchador a los botones y diversas chorradillas para //dejarlo bonito. Por último también le metimos player.realize() porque sino no no //se ve el Reproductor

      }//constructor

Ya que hemos implementado ActionListener y ControllerListener, tenemos que usar a la fuerza los métodos actionPerformed y controllerUpdate.

public synchronized void controllerUpdate(ControllerEvent e){

         if(e instanceof RealizeCompleteEvent){

            visual=player.getVisualComponent();

            control=player.getControlPanelComponent();

            ppal.add( “Center” ,visual); //lo añade al centro del Frame

            ppal.add( “South” ,control); //lo añade al sur del Frame

         }

         if(e instanceof EndOfMediaEvent){

            if(boton3.isSelected()){

               player.setMediaTime(new Time(0)); //lo pone al inicio del video, Time es float

               player.start();

            }

            else{

               player.stop();

               player.deallocate(); //libera recursos

            }

         }

         ppal.validate(); //muy importante para que se vea algo

      } //controllerUpdate

public void actionPerformed(ActionEvent e){ //este es fácil

         if(e.getSource()==boton1){

            player.setMediaTime(new Time(6.0));

         }

         else if(e.getSource()==boton2){

            player.setMediaTime(new Time(12.0));

         }

      } //actionPerformed

Os hemos puesto casi todo el código de nuestro Reproductor, para los que no supieseis como funciona JMF os pudieseis enterar de forma rápida y sencilla, y para los que ya supieseis por si queréis coger ideas, aunque no hay nada del otro mundo…

P.D: esperamos no escribir por aquí más después de este último y definitivo post, si seguimos escribiendo empezaros a preocupar seriamente por nosotros, porque sería un síntoma de que algo en nuestras vidas no iría nada bien…

Ultima cosa que decimos de nuestro gran amigo:

Chuck Norris ha contado hasta el infinito, 2 VECES.

Agur.

Lo que hemos hecho en esta práctica no ha sido demasiado porque nos hemos quedado sin tiempo de terminarla por completo, pero bueno eso no quería decir que por eso no subiésemos nada, así que por lo menos vamos a comentar lo que hemos hecho si os parece…

La clase Simple02GUI es relativamente fácil de realizar, os vamos a dejar nuestro código comentado para no perder la costumbre para que le echeis un vistazo, empezamos por el constructor, antes de nada decir que nuestra clase no extiende de ninguna clase ni implementa ninguna interfaz:

public Simple01GUI(){

         frame= new JFrame( “Eventos” );

         panel= new JPanel();

         boton=new JButton( “Mi boton” );

         etiqueta= new JLabel ( “cambiame el color” );

         frame.add(panel);

         panel.add(boton);

         panel.add(etiqueta);

         etiqueta.setOpaque(true); //para que se vea el nombre de la etiqueta al cambiarle el fondo

         etiqueta.setBackground(Color.YELLOW);

         OyenteBoton pulsaBoton=new OyenteBoton();

         boton.addActionListener(pulsaBoton); //le añadimos la acción de ser pulsado

         Enter teclado=new Enter();

         boton.addKeyListener(teclado); //le añadimos la acción de pulsar el teclado

         frame.setDefaultCloseOperation(frame.EXIT_ON_CLOSE);

         frame.setVisible(true);

         frame.setSize(200,100);

} //constructor

class OyenteBoton implements ActionListener { 

            public void actionPerformed(ActionEvent evento) {

               if(etiqueta.getBackground()==Color.YELLOW){

               System.out.println(Thread.currentThread().getName()); //devuelve el nombre del //evento que se produce en ese instante por consola

               etiqueta.setBackground(Color.RED); //si la etiqueta es amarilla al ser pulsado el boton //cambia de color y en else al revés.

               System.out.println(“Me has pulsado “); //imprime un mensaje en consola

            }

            else {

               System.out.println(Thread.currentThread().getName());

               etiqueta.setBackground(Color.YELLOW);

               System.out.println(“Me has pulsado “);

            }

         }

      } //ActionListener

Importante!!: Extendemos de KeyAdapter para poder implementar únicamente el método keyPressed, si   implementásemos de KeyListener también tendríamos que implementar los metodos keyTyped() y keyReleased().    

      public class Enter extends KeyAdapter{             

         public void keyPressed(KeyEvent evento){            

           char e=evento.getKeyChar();

            if(e==’\n’){ //si la tecla pulsada es enter hace lo mismo que en el método //actionPerformed, también se podría haber hecho con el metodo getKeyCode y utilizando //VK_ENTER en vez de ‘\n’

               if(etiqueta.getBackground()==Color.YELLOW){

                  System.out.println(Thread.currentThread().getName());

                  etiqueta.setBackground(Color.RED);

                  System.out.println(“Me has pulsado “);

               }

               else {

                  System.out.println(Thread.currentThread().getName());

                  etiqueta.setBackground(Color.YELLOW);

                  System.out.println(“Me has pulsado “);

               }

            } //keyPressed()

          } //KeyAdapter

La clase no logramos terminarla porque nos daba un error que no supimos resolver en el método public String query(int i), esto fue lo que le pasamos a este método:

         String alumno=(String)alumnos.get(i);     

         throw new InterruptedException(“mete un NIA correcto”);

         return alumno;

Seguro que es un fallo tonto pero no supimos arreglarlo, alumnos es un objeto Hashtable que se declara en el constructor de la clase.

Todo esto ha sido lo que hemos hecho de esta práctica, bueno también hicimos algo del siguiente ejercicio pero nada reseñable.

Para terminar y poco antes de colgar la última práctica, queríamos pedir perdón por la tardanza en subir muchos de los post, pero esto es debido a que también tenemos más asignaturas en las que también nos ‘exigen’ entregar semanalmente prácticas, ejercicios y demás… y también porque pensamos que ya que nos poníamos a subir post lo suyo sería que contuviesen información que fuese útil para todos y por supuesto también para nosotros, por lo que también nos llevaba un tiempo extra realizar cada uno de los post que hemos colgado en nuestro blog.

P.D: un saludo para esas personas que ven nuestro blog aunque no estén cursando la asignatura, y como no os dejamos con un par de cosillas de Chuck Norris:

Cuando Chuck Norris va a donar sangre no usa jeringuillas: Pide un cubo y un cuchillo.

Chuck Norris puede quemar una hormiga con una lupa… de noche.

Agur.

Buenas!! En esta y en la siguiente práctica os vamos a hablar un poco sobre threads, básicamente lo que nosotros sabemos y lo que como en las demás prácticas creemos que es más importante.

Vamos a empezar por comentar las diferencias entre las clases TwoThreads, TwoThreadsSimple y TwoThreadsSimple2.

En la clase TwoThreads, primeramente se crea un método (PrintThreadName()) que devuelve el nombre del proceso actual por pantalla, luego dentro del ‘main’ se crea un objeto de la interfaz Runnable en el que incluimos el método run() (indispensable al implementar esta interfaz), que lo que hace simplemente es invocar PrintThreadName().

Por último se crea un objeto de la clase Thread al que le pasamos como parámetro el objeto de la interfaz Runnable para que nos saque por pantalla el Thread que se esta ejecutando en ese momento. La ultima línea de código sirve para que imprima por pantalla donde se esta ejecutando el proceso actual, en nuestro caso en el ‘main’.

La clase TwoThreadsSimple implementa Runnable, por lo que esta obligada a crear el método run(), que como en el caso anterior invoca a PrintThreadName(). En el main de la clase crea un objeto de la misma clase y se lo pasa posteriormente a un objeto de Thread, como el objeto TwoThreadsSimple contiene los métodos run() y PrintThreadName() e implementa Runnable no hace falta llamar a los métodos de la clase.

**Como ejemplo también se hace lo mismo al crear un ActionListener y añadirle el escuchador, que para que funcione no hace falta llamar expresamente al método  actionPerformed().

La última clase es la más sencilla de todas ya que extiende de Thread y esto hace todo más fácil. Simplemente crea los dos métodos de las anteriores clases y luego en el main crea un objeto de TwoThreadsSimple2, que como hereda de Thread solo con arrancarlo ya llama a los métodos de su clase tts2.start().

De las clases RaceCondition y RaceConditionSolved no vamos a comentar nada porque creemos que esta bien explicado n el guión y realmente tampoco lo entendíamos demasiado bien como para poder contaros algo sin liaros…

Para acabar os vamos a pasar a comentar como hemos hecho la clase StroboscopicGUI para que funcione como el ejecutable, realmente lo hemos hecho a ‘nuestra’ manera porque todavía no sabemos muy bien como utilizar procesos. Os dejamos comentado nuestro código para que le echéis un vistazo aunque como ya os decimos según dice la práctica no se debería hacer así pero es como nosotros sabemos y funciona!!!

      public StroboscopicGUI(){             

         frame=new JFrame( “StroboscopicGUI” );

         etiqueta1=new JLabel( “StroboscopicGUI” ,JLabel.CENTER);

         panel=new JPanel();   

         frame.add(panel);

         panel.setLayout(new BorderLayout());     

         panel.add(etiqueta1,BorderLayout.CENTER);

         frame.setSize(200,200);     

         //setPack();

         frame.setResizable(false);

         frame.setVisible(true);

         frame.setDefaultCloseOperation(frame.EXIT_ON_CLOSE);    

         try{

            while(true){

               etiqueta1.setOpaque(true);

               etiqueta1.setForeground(Color.BLACK);

               etiqueta1.setBackground(Color.WHITE);

               Thread.sleep(100);

               etiqueta1.setOpaque(true);

               etiqueta1.setForeground(Color.WHITE);

               etiqueta1.setBackground(Color.BLACK);

               Thread.sleep(100);

            }}              

             catch (InterruptedException e) {                 

              System.out.println( “Interrupted while sleeping” );}

}

 Lo del contador binario y demás os dejamos para que lo intentéis en casa, porque no os vamos a dar todo hecho…jeje. No en verdad no hemos tenido tiempo para “meterle mano” así que como referencia os recomendamos que os paséis por el blog de Jose y Marco’s que tienen algo explicado y os puede quedar un poco más claro.

Bueno y para acabar definitivamente en estas tres últimas prácticas os vamos a dejar con nuestro gran amigo Chuck Norris y sus actos celebres, ahí van las dos  primeras:

Chuck Norris toma la sopa con tenedor.

Chuck Norris jugó a la ruleta rusa con un revolver completamente cargado y ganó.

Aquí os dejamos la memoria de nuestro juego (encima que la colgamos no es plan de que os copieis)

Memoria de la práctica de software del Juego de TSIOCA

• Fecha: 30-05-2008.
• Nombre del juego: “PAREJAS”.
• Autor 1: Juan Luís Campins Frau.
• Autor 2: Francisco José González León.

1.DIAGRAMA DE USO:

El juego que hemos realizado, es el de las ‘PAREJAS’, cuya interacción con el usuario es total, y es la que sigue:

-El usuario puede comenzar una partida del juego.

-Introducir/cambiar su nombre.

-Establecer un numero de intentos para resolver la pantalla, o de lo contrario un numero  ilimitado de intentos.

-Puede cerrar la aplicación, es decir, acabar el juego.

-Iniciar una partida nueva, parando la que estaba en juego.

-Resolver el panel del juego que, a continuación, se iniciara una partida nueva.

-Ver los créditos del juego, para ver quienes son los autores.

2.DIAGRAMA DE CLASES:

La aplicación consta solamente de una clase, que es la principal, la cual inicializa el sistema, todos los componentes gráficos, todos los escuchadores de los distintos componentes gráficos como los JButton, JMenuItem…, es decir, que esta única clase realiza todas las funciones que el juego requiere y su ejecución.

3.DIAGRAMA DE FUNCIONAMIENTO:

La estructura del juego en marcha es la siguiente:

-Muestra de una pantalla inicial en la que se puede elegir 2 opciones: una la de salir, que saldrá de la aplicación, y otra la de jugar, que nos llevara a la pantalla principal del juego.

-Si hemos elegido la opción de jugar en la pantalla anterior, nos encontraremos con el tablero principal del juego, con los distintos botones y un menú en la parte superior de esta pantalla, todos ellos para su interacción. En esta pantalla se podrán elegir muchas opciones del juego, explicadas en el punto 1, solo añadir como dato, que una vez en el tablero principal, si se pulsa la tecla ENTER, en lugar de jugar con las imágenes de una determinada serie de TV, se jugarán con otras de una distinta serie.

4.DIAGRAMA DE DESPLIEGUE:

-Es necesario tener el classpath de JMF debido a que se reproducen distintos sonidos a lo largo del juego.

-El código fuente, y los distintos class no se encuentran en ninguna carpeta, solo las imágenes y sonidos que, mediante código java, se acceden a ellas, por lo que solo el zip hay que descomprimirlo y dejarlo como se encuentre.

-Para su ejecución, hay que ejecutar java Parejas.

-En nuestro blog se encuentra la memoria:  http://losquintos.wordpress.com/.

Vamos a empezar directamente con el ejercicio de las etiquetas en blanco y negro que nos pareció interesante. El primer problema que tuvimos que solucionar mediante el API de java fue el de cambiar el nombre al panel mediante:

         TitledBorder nombre;

         nombre=  BorderFactory.createTitledBorder(“nombre del panel”);

         panel.setBorder(nombre);

Posteriormente creamos un array de 20 etiquetas que le añadimos al panel principal y las hicimos opacas ( setOpaque(true) ), después creamos un algoritmo sencillo para que las etiquetas pares tuvieran el fondo blanco y el nombre en negro, y las impares al revés.

Esto lo hicimos de la siguiente forma:

if (i%2==0){

               etiquetas[i].setBackground(Color.WHITE);

               etiquetas[i].setForeground(Color.BLACK);

            }

            else  {

               etiquetas[i].setBackground(Color.BLACK);

               etiquetas[i].setForeground(Color.WHITE);

Ahora vamos a pasar a comentaros directamente el último ejercicio que es el más completo y el que más nos va ayudar para aprender a utilizar los Layouts paneles y demás utilidades. Nosotros lo hemos dividido todo en varios paneles y hemos creado un array de etiquetas para posteriormente añadírselo a los paneles de la izquierda. Para que os hagáis una idea os lo ponemos:

         contenedor= getContentPane();

         panel= new JPanel();

         derecha= new JPanel();

         izquierda= new JPanel();

         uno=new JPanel();

         dos=new JPanel();

         tres=new JPanel();

         etiquetas= new JLabel [5];

         contenedor.add(panel);

         panel.setLayout (new GridLayout (1,2));

         izquierda.setLayout(new GridLayout(3,1));

         panel.add(izquierda);

         panel.add(derecha);

Para las etiquetas lo que hacíamos era dependiendo del número de etiquetas que hiciesen falta recorríamos el array hasta una posición u otra, de esta forma:

            for(int i=0; i<3; i++){        

            etiquetas[i]=new JLabel(“etiqueta”+(i+1));

            dos.add(etiquetas[i]);

}

Para el panel de la derecha creamos cinco etiquetas dependiendo de su posición en el panel y se las añadimos a este:

derecha.setLayout(new BorderLayout());

JLabel centro = new JLabel(“Center”,JLabel.CENTER);

centro.setForeground (Color.BLACK);

centro.setBackground(Color.WHITE);

centro.setOpaque(true);

derecha.add(norte, BorderLayout.NORTH);

Esto fue todo lo que dio de sí esta práctica, nos sirvió para confirmar lo que ya sabíamos de swing y para recordar algunas cosillas que ya teníamos en el olvido.

Bueno pues nada ya sabéis, ir guardando la ropa de invierno los que todavía no la hayáis hecho que ya estamos a punto de acabar el curso y esto tiene que empezar a parecer que se aproximan las vacaciones (o por lo menos el verano).

Agur.

public void Insertar(Pieza p){

         Nodo N;
         N = new Nodo(p,Ultimo);  //se crea un nodo y se le mete la pieza en la ultima posicion de la lista enlazada

         if(n==0)} //si no hay nigun nodo todavia se lo asigna al primero

            Primero=N;
        }

         else{       

 ultimo = N;
         }

         n++; //incrementa el contador

      } //Insertar()

 public Pieza Sacar(){             

         Recorrido=Ultimo.Siguiente(); //asigna Recorrido al nodo que apunta Ultimo

         for(int k=0; k<n; k++){ //bucle que recorre la lista de nodos si se hubiese puesto el bucle hasta k<=n devolveria un null, ya que intentaria
        //devolver un nodo al que apunta el primero que hemos metido y no apunta a nada

            Recorrido=Recorrido.Siguiente(); //va recorriendo los nodos y asignando Recorrido al nodo apuntado e incrementado k hasta llegar a n-1
            k++;

         }//for

         Primero=Recorrido; //asigna Primero a Recorrido que esta en la ultima posicion del bucle for anterior
         n–-; //se decrementa un nodo
         return Recorrido.Siguiente(); //devuelve el nodo al que apunta Primero

      } //Sacar()

Como veis hemos destacado, a nuestra forma de ver las cosas,lo más difícil e importante de esta práctica y lo que a nosotros nos a dado más problemas.También nos hemos ayudado del archivo de listas enlazadas que suibieron los profesores a la web de oca.
Esperamos que os haya servido de algo, aunque el código lo hayamos cogido prestado de Jose y Marco.
P.D: Vamos a tener que empezar a rezar para que en época de exámenes llueva todo lo que no ha llovido hasta ahora para tener que quedarnos en casa y hacer algo de provecho, porque con el tiempo que hace, hay ganas de todo menos de estar en casa;)
Agur.

En esta práctica hemos realizado una cola mediante un array de Piezas como nos decían. La hemos hecho de una forma entendible, sencilla y como no, que funcione. Para empezar hemos creado tres clases: Pieza(donde solo le pasamos como atributo el tipo de pieza que vamos a meter en el array), Cola(donde se encuentra el array de Piezas, un puntero que se va moviendo según encolamos y desencolamos, y los distintos métodos para utilizar la cola(“no seais mal pensaos eee…jeje”)) y Tetris que es la que contiene el método main y donde creamos los objetos.

Os voi a dejar la implementación solo de la clase Cola porque lo demás creemos que es muy facil.

   public class Cola{

      Pieza[] array;

      public int ultimo=-1;//puntero que indica la posicion en el array

      public int numElementos;//tamaño del array

      public Cola(int numElementos){

         this.numElementos=numElementos;

         array=new Pieza[numElementos];

      }

      public boolean estaVacia(){

         return ultimo==-1;

      }

      public boolean estaLlena(){

         return ultimo==numElementos-1;

      }

      public void encolar(Pieza p){

//desplazo primero el puntero para que se incremente una posición en el array     

         ultimo++;

//en esta posición es donde almaceno la pieza, como yo soy quién le paso el objeto                    //se debe declarar así.            

         array[ultimo]=p;

//Esto lo hago para que cada vez que inserto una pieza sepa lo que insertamos.

System.out.println ( “Has insertado una pieza tipo: “  +p.tipo);

      }//encolar

      public Pieza desencolar(){

         Pieza p;

//A la pieza que acabo de crear le asigno la ultima posición a la que apunta el puntero.

         p=array[ultimo];

//Recorro el array y lo que estaba en la posición i+1 me lo pasa a la posición i.

         for(int i=0;i<numElementos-1;i++)

            array[i]=array[i+1];

//Una vez recorrido el array decremento en una posición el puntero para poder seguir //sacando piezas.

         ultimo–;

         return p;

      }//desencolar()

}//class

Bueno pues eso es todo, si teneís alguna duda, no os sale o no lo veís claro nos lo decís y resolvemos vuestras dudas que para eso estamos.

Os voi a dejar un chiste para mayores de 18 años asi que si le estais enseñando lo bonito que es este blog  a vuestro sobrino/a, primo/a pequeña… mandarle a ver la tele mientras os leeis el chistecillo:

Uno que entra al telepizza con dos mujeres de uso público y dice:

-Quiero dos pizzas.

-Familiares?

-No son putas pero tambien tienen hambre.

Agur.

Vamos a empezar a comentar la práctica por apartados.

Ejercicio 1: en este apartado lo reseñable es la forma de como heredar metodos de la clase base, que se hace mediante  la referencia super y a continuación el método del que se quiere heredar, en este caso super.toString(); Esto nosotros ya lo hicimos en la práctica anterior porque ya tenemos tablas en este asuntillo. El otro apartado reseñable es el aprovechamiento del mecanismo de polimorfismo, lo explicamos con este ejemplo:

for(int i=0;i<miembros.length;i++)
//asi lo hacíamos antes->s+=miembros[i].toString();
 s+=miembros[i];

También se puede ver en la clase ejecutable que al hacer la llamada a los objetos para que nos imprima la cadena de caracteres por pantalla no hace falta volver a invocar el método toString(), ahí va el ejemplo:

/*antes lo haciamos asi->System.out.println(” La meta-información ‘en tiempo de ejecución’ del OBJETO “
+o1.toString()+” es: “+analizadorObjeto1.toString());*/
System.out.println(” La meta-información ‘en tiempo de ejecución’ del OBJETO “
+o1+” es: “+analizadorObjeto1);

Ejercicio 2: para este ejercicio nos hizo falta ayuda de las soluciones para poder implemetar el método guarda, porque más o menos nos hacíamos una idea de como hacer que guardara la cadena con

->out.write(toString);, pero lo siguiente no sabíamos asi que nada un poco de ayuda del api de java y las soluciones y listo. Lo que nos pareció importante de comprender era que en las INTERFACES solo se definen los metodos->public void guarda( java.io.FileWriter out ) throws Exception ; , y en las clases que implementan estos interfaces los declaramos->public void guarda( java.io.FileWriter out ) throws Exception {//cuerpo del método}.

La otra parte de la aplicación gráfica también la hicimos pero realmente nos parecio que esta bien hacerla para entender la parte del contenedor, la ventana y eso, pero nosotros que ya hemos utilizado swing en java creemos que luego lo que se ve en estos apartados solo nos da una pequeña idea de como lo vamos a utilizar posteriormente a la hora de crear una interfaz gráfica(con esto no queremos decir que no lo hagaís eeee, que si lo han puesto sera por algo).

Por último y en compensación de que no hemos comentado como hicímos la interfaz gráfica, vamos a poner un ejemplo de como se crea una clase abstracta y como se hereda de esta, que es lo unico que no viene un ejemplo en esta práctica, ahí va:

public abstract class Abstracta{
          
      protected int x=2;
    protected String frase=”También se pueden implementar metodos”;
   //solo definimos este método
             
      public abstract int getX();
             
   //este lo declaramos   
             
      public String getFrase(){
             
         return frase;
      }
   
   }//clase

   public class HeredaAbstracta extends Abstracta{
          
     //tenemos que declarar el método que hemos definido en
     //la clase abstracta sino daría error.
             
      public int getX(){
             
         return x;
      }
             
      public static void main(String[] args){
             
         HeredaAbstracta h=new HeredaAbstracta();
         System.out.println(h.getX());
         System.out.println(h.getFrase());
     
      }//main
  
  
   }//clase

 Es facilito, simplemente es para que veais como se utilizan las clases abstractas, si teneís dudas decirnoslo y las intentarmos solucionar(no prometemos nada;)).

P.D: siguiendo con la tónica de la práctica anterior despues de que nos hemos creado unas clases y todo a modo de ejemplo, si nos llamais frikis lo entendermos aunque nos duela…

Os voi a contar un chistecillo para terminar:

Se abre le telón, y se ve en una reunión a Office, a PowerPoint y a Excel. Se cierra el telón.¿Cómo se llama la película? 

->Star Word?

Agur.