PROJECTE INSTITUT GUTTMAN DE NEUROREHABILITACIÓ

- Creació de Tasques -

TITULACIÓ: ENGINYERIA TÈCNICA EN INFORMÀTICA DE GESTIÓ

AUTORS: Pol llauradó NavarroDIRECTORS: Maria Ferrè .

DATA: 06 / 2009

Departament d’Enginyeria Informàtica i Matemàtiques

1 Objectius del projecte .......................................................................................................... 4 2 Especificacions del projecte ................................................................................................ 6 3 Disseny ................................................................................................................................ 9 4 Desenvolupament .............................................................................................................. 13

4.1 Enfonsar la flota ......................................................................................................... 22 4.1.1 Problema clínic a estudi ...................................................................................... 22 4.1.2 Descripció del joc .............................................................................................. 22 4.1.3 Descripció de les classes utilitzades ................................................................... 23 4.1.4 Arxiu references.txt ............................................................................................. 28

4.2 Trencaclosques ........................................................................................................... 28 4.2.1 Problema clínic a estudi ..................................................................................... 29 4.2.2 Requisits del joc ................................................................................................ 29 4.2.3 Descripció de les classes utilitzades: ................................................................... 29 4.2.4 Arxiu references.txt ........................................................................................... 32

4.3 Aparellament ............................................................................................................. 33 4.3.1 Descripció de la tasca .......................................................................................... 33 4.3.2 Descripció de les classes utilitzades .................................................................... 34 4.3.3 Arxiu references.txt ............................................................................................ 40

4.4 Zigurat ....................................................................................................................... 41 4.4.1 Problema clínic a estudi ..................................................................................... 41 4.4.2 Descripció de la tasca .......................................................................................... 41 4.4.3 Descripció de les classes de la tasca .................................................................... 43 4.4.4 Arxiu references.txt ............................................................................................. 50

4.5 Sèrie cíclica ................................................................................................................ 51 4.5.1 Problema clínic a estudi ...................................................................................... 51 4.5.2 Descripció de la tasca .......................................................................................... 51 4.5.3 Descripció de les clases utilitzades ..................................................................... 52 4.5.4 Arxiu references.txt ............................................................................................. 59

4.6 Imatges Progressives .................................................................................................. 60 4.6.1 Problema clínic a estudi ...................................................................................... 60 4.6.2 Descripció de la tasca .......................................................................................... 60 4.6.3 Descripció de les classes utilitzades .................................................................... 61 4.6.4 Arxiu references.txt ............................................................................................ 67

5 Avaluacions ....................................................................................................................... 67 5.1 Enfosar la flota ........................................................................................................... 67 5.2 TrencaClosques .......................................................................................................... 69 5.3 Aparellament .............................................................................................................. 71 5.4 Zigurat ....................................................................................................................... 73 5.5 Sèrie Cíclica ............................................................................................................... 74 5.6 Imatges progressives .................................................................................................. 76

6 Conclusions ....................................................................................................................... 78 7 Recursos utilizats ............................................................................................................... 78

Figura 1. Model de connexió entre terapeutes i pacients...................................................... 5Figura 2 – Diagrama UML d’imatges progressives............................................................... 9Figura 3. Diagrama UML de Sèrie cíclica........................................................................... 10Figura 4. Diagrama UML d’enfonsar la flota.......................................................................10

2

Figura 5. Diagrama UML de Trencaclosques...................................................................... 11Figura 6. Diagrama UML de Zigurat................................................................................... 11Figura 7. Diagrama UML d’Aparellament...........................................................................12Figura 8. Classe Matrix detallada.........................................................................................12Figura 9. Logotip de l’institut Guttman................................................................................14Figura 10. Exemple del resultat de ThreatStatsBar..............................................................18Figura 11. Exemple d’una divisió d’àrees amb la classe Matrix..........................................21Figura 12. Pantalla de selecció dels vaixells........................................................................ 22Figura 13. Mostra del pantalla de Joc...................................................................................24Figura 14. Esquema del funcionament dels nivells 2 i 3......................................................28Figura 15. Exemple visual de la tasca a realitzar................................................................. 29Figura 16. Exemple del joc en execució...............................................................................32Figura 17. Llegenda d’estímuls FeedBack........................................................................... 36Figura 18. Exemple de joc amb la modalitat Estímul Triple................................................39Figura 19. Exemple de referències d’una piràmide..............................................................45Figura 20. Exemple dels componets del taulell....................................................................49Figura 21. Exemple de funcionament de transform()...........................................................56Figura 22. Pantalla del taulell de SerieCiclica..................................................................... 58Figura 23. Event Released....................................................................................................64Figura 24. Event Dragged.................................................................................................... 65Figura 25. Event Released....................................................................................................65Figura 26. Pantalla de Colocació del vaixells...................................................................... 68Figura 27. Pantalla del joc....................................................................................................68Figura 28. Pantalla de resultats.............................................................................................69Figura 29. Pantalla de joc ( Imatge desordenada)................................................................ 70Figura 30. Pantalla de joc ( Imatge ordenada)......................................................................70Figura 31. Pantalla de resultats............................................................................................71Figura 32. Pantalla del joc....................................................................................................72Figura 33. Pantalla de Resultats........................................................................................... 72Figura 34. Pantalla incial del joc.......................................................................................... 73Figura 35. Pantalla final del joc............................................................................................73Figura 36. Pantalla de resultats.............................................................................................74Figura 37. Pantalla incial del joc.......................................................................................... 75Figura 38. Pantalla final del joc............................................................................................75Figura 39. Pantalla de resultats.............................................................................................76Figura 40. Partida numero 1................................................................................................. 76Figura 41. Partida número 2................................................................................................. 77Figura 42. Partida número 3................................................................................................. 77Figura 43. Resultats..............................................................................................................77

3

1 Objectius del projecte

El projecte pretén complementar les eines que ajudin a resoldre les necessitats terapèutiques dels “ pacients amb dany cerebral adquirit ” amb l’ajuda d’ aplicacions informàtiques que afavoreixin la rehabilitació de les funcions cognitives afectades mitjançant situacions quotidianes de la vida real en un món virtual.

El grup de recerca d'Arquitectures i Serveis Telemàtics (AST) del Departament d'Enginyeria Informàtica i Matemàtiques de la URV, ha desenvolupat la plataforma PREVIRNEC en el context d'un projecte d'investigació amb l’Institut Guttmann i el Centre d'Investigació en Enginyeria Biomèdica (CREB) de la UPC, que treballen en un programa de telerehabilitació per al tractament dels dèficits originats pel dany cerebral adquirit.

PREVIRNEC és un nou sistema de neuro-rehabilitació que funciona a través d'Internet i permet tractar problemes d'atenció, memòria i diverses disfuncions neuro-cognitives.

Mitjançant aquest sistema, terapeutes experts de l’Institut Guttmann poden assignar plans de tasques personalitzades als seus pacients a través d'Internet i observar la seva evolució.

Això permet pautar tractaments que s'adapten a l'evolució del pacient sense necessitat de la presència física del terapeuta.

El desenvolupament de la plataforma informàtica del projecte, ha estat coordinada a la URV pels professors Maria Ferré i Pedro García. S'ha dissenyat un planificador automatitzat de tasques, un sistema que permet adaptar el grau de dificultat de les tasques als resultats que va obtenint cada pacient de forma individualitzada.

Aquesta plataforma consta d'una aplicació client que utilitzen els pacients des de casa o des de l'hospital que es connecta a través d'Internet a un servidor en l’Institut Gutmmann. Tota l'arquitectura de la xarxa informàtica ha estat dissenyada i desenvolupada des del grup d'investigació de la URV.

El sistema s'ha provat amb èxit amb pacients en l’Institut Guttmann, i ara s'està començant a estendre per diversos centres hospitalaris. Més concretament, està en fase de proves en el Centre Sociosanitari Francolí de Tarragona i s'està implantant a Igualada.

L’Institut Guttmann planteja estendre el seu ús a altres deu centres hospitalaris en els pròxims mesos. En cada centre hi ha diversos ordinadors amb el sistema PREVIRNEC i tots ells es connecten remotament al servidor de l’Institut Guttmann on els terapeutes segueixen els tractaments personalitzats. A més el projecte pretén que els pacients puguin connectar-se en un futur des de casa amb els seus propis ordinadors o fins i tot amb dispositius mòbils.

El sistema va molt més allà dels coneguts "brain trainer" o assistents personals que s'han popularitzat recentment. Disposa d’ un ampli conjunt de tasques i jocs adaptats a cada

4

problema (atenció, memòria, ...) dissenyats per un equip d'investigadors multidisciplinari. En ell participen el Centre de Recerca en Enginyeria Biomèdica (CREB), de la UPC, que s'ha encarregat del programari 3D, i l'equip del Institut Guttmann, hospital de referència en neuro-rehabilitació que aporta els coneixements neuropsicològics i terapèutics.

Com resultat de l'èxit de la plataforma s'ha creat un consorci format per empreses tecnològiques com Vodafone, institucions com la Fundació Institut Català de l'Envelliment i grups d'investigació de les universitats URV, UPM i UPC. Aquest consorci ha obtingut finançament del Ministeri d'Indústria Turisme i Comerç en un projecte Avança I+D de tres anys que permetrà estendre l'entorn i aplicar-lo a diversos àmbits.

A continuació es presenta una imatge orientativa, de com funciona les tasques remotes que executa el pacient en funció del pla terapèutic que li proporcionen els terapeutes (Figura 1).

Figura 1. Model de connexió entre terapeutes i pacients

Com a objectiu global, entenem la necessitat d’interactuar amb els pacients virtualment, i poder fer-los-hi un seguit de tasques adaptades a les deficiències que poden patir, mitjançant un ampli ventall de tasques, regulades per uns rangs terapèutics determinats pels terapeutes i els resultats es concretaran en uns nivells de jocs adaptats a cada pacient.

En canvi l’objectiu individual del projecte, es realitzar una petita part d’aquet global, en concret 6 jocs de tipus executiu amb els objectius esmentats anteriorment, per a tal s’ha d’entendre quines son les necessitats per a que aquets jocs puguin interactuar entre el terapeuta i el pacient, tenint d’intermediari el servidor.

Ja explicat el sentit global del projecte, podem dir que com a objectiu individual es realitzar un serie de tasques que s’implementaran dins d’aquet projecte.

5

2 Especificacions del projecte

• Es tenen que realitzar 6 jocs diferents amb les especificacions proporcionades pels terapeutes, les meves seran 4 tasques de caràcter executiu i sequencial, una d’ atencio selectiva, i una d’executiva i flexibilitat.

• S’ha d’utilitzar la última versió del JDK per a JAVA i instal·lar-se la última versió de l’Eclipse.

• Instal·lar la versió 2.4.4 de Python.

• Importar el projecte Gutmann.zip dins l'Eclipse. D'aquesta manera es carregarà tota l'estructura que permet crear noves tasques.

• Per tal de connectar-nos al servidor i obtenir tasques encomanades a l'usuari que desitgem, només ens caldrà executar el fitxer Login.bat i introduir a continuació el nom de l'usuari i la contrasenya associada.

• Es proporcionen paquets per al desenvolupament de les tasques, com per exemple classes genèriques com FullScreen, per unificar les diferents resolucions on es poden executar els programes client, o la classe InOutXml, que ens ajudara a agafar la informacio necessària rebuda pel terapeuta i poder programar els diferents nivells de dificultat de cada pacient.

• Els jocs han d’estar fets, per admetre un nombre il.limitat d’idiomes, en el nostre cas haurem de desenvolupar el català i el castellà, però se l’hi podrien incloure tots els que vulguesim afegint simplement el paquet necessari per a cada idioma.

Per accedir a aquesta configuració haurem d`obrir el fitxer lang (es troba incorporat en el projecte desplegat a l'Eclipse) i escriure a la primera línia el llenguatge que utilitzarà el client. Actualment només es troba disponible en català i castellà.

• Les tasques estarán organitzades segons el nom de cadascuna, i totes les seves classificacions penjaran del paquet task , i despres portaran els identificatius proporcionats per la tasca. Presentem la forma genèrica de proporcionar noms a les tasques :

tasks.funcio.subfuncio.nomTasca

• Hi han 3 tipus de tasques:

- atenció, - memòria, - executives.

6

• Abans de començar a dissenyar una tasca caldrà que planifiquem quins recursos (imatges, texts, sons) necessitarem. Els integrarem al client de la següent forma:

1. Imatges:

a) Si es tracta d'una imatge que només utilitzarà la tasca que estem dissenyant i que no varia depenent de llenguatge (per exemple, la foto del puzzle) crearem una carpeta a dintre d’imatges amb el nom de la tasca en minúscula i posarem l'imatge a dins.

b) Si es tracta d'una imatge comuna a dos o més tasques i que no varia depenent del llenguatge la posarem directament a dins la carpeta /imatges.

c) En els dos casos anteriors, si existeix una variació de la mateixa imatge depenent del llenguatge ( per exemple, amb un botó que indica continuar) crearem dins els directoris una nova carpeta que indiqui el llenguatge

Exemple: Amb el botó de continuar en català, al ser una imatge que varia depenent del llenguatge i que pot anar associada a més de una tasca la posaríem dins de /imatges/català

2. Sons:

a) Seguirem el mateix criteri que amb les imatges però a partir de la carpeta /rounds

3. Texts:a) Els texts aniran incorporats dins el propi package de la tasca i per tal de diferenciar cada llenguatge es crearà una nova carpeta amb el nom del llenguatge on inserirem els diferents arxius de texts .Exemple: Si volem text en català i castellà a la tasca de puzzle crearem els següents directoris:

/tasks/executives/planificacio/puzzle/catala/tasks/executives/planificacio/puzzle/castellano

A dins hi col·locarem els respectius texts en cada idioma.

• Si volem compilar totes les tasques del client, podem fer-ho automàticament a traves de l'Eclipse. Ara bé, també ens interessa tenir un mecanisme que permeti fer-ho sense haver de tenir instal·lada una IDE. Per aquesta raó s'ha creat un fitxer Compila.bat que compila tots els arxius de totes les classes que composen les tasques.

En el cas de que afegiu una nova tasca al client, es recomanable que també afegiu una línia amb les sentències de compilació necessàries per compilar-lo.Alhora existeix un fitxer Clean.bat que ens permet esborrar tots els fitxers *.class de les tasques i que haurem d'anar actualitzant

7

• Per tal d'adaptar el nivell de les tasques al pacient a mesura que les va completant, existeixen uns llindars especificats pels terapeutes que determinen si una tasca s'haurà de executar amb uns paràmetres més difícils o fàcils, un cop el pacient l'ha finalitzat.

Per tant, haurem de proveir a cada tasca dels paràmetres per separat i un únic paràmetre que el servidor utilitzarà per a fer aquest test de llindar. Per determinar aquet llindar se’ns proporciona la funció :

public void setThreshold(String s);

• Es recomana seguir aquest consells bàsics per al posicionament de text:

1. En el moment de definir la posició d'un text, és molt recomanable definir-la en funció de la posició d'algun element gràfic amb el que pugui estar vinculat. Per exemple, si tenim un cercle i ha dins hi volem escriure un número, definirem la posició relativa del text a partir de la posició del cercle. D'aquesta manera , si canviem la posició del text no haurem de controlar que el text s'ajusti al seu interior.

2. Tot i que veiem correctament el nostre text amb la resolució normal del monitor, cal fer un joc de proves per comprovar que al canviar de resolució, no provoquem col·lisions entre elements de la pantalla.

Molts problemes de col·lisions es solucionen ràpidament efectuant un anàlisi detallat de l'ordenament dels elements en pantalla i de les orientacions òptimes per a cada cas.

3. Per tal de facilitar el dimensionament automàtic de les fonts, s'ha dissenyat una funció anomenada getSizedFont(...) que retorna una font determinada escalada per a la resolució actual del monitor. La especificació de Javadoc es la següent:

public Font getSizedFont(String name, int type, double scale);

• Per tal de facilitar la creació d'una tasca i unificar el disseny, existeixen una sèrie de threads que proveeixen un servei genèrica per a qualsevol tasca.Els serveis actualment disponibles són: Animació automàtica de la barra de progrés. A l’especificació de la classe ThreadStatusBar.java trobem el següent constructor:public ThreadStatsBar(Fullscreen s, double f[], double seconds, int subtotal, int total, Font font);

• Per tal de facilitar la feina de l'alta de tasques al servidor web, cada tasca haurà d'incorporar en el directori amb la classe del main un arxiu anomenat reference.txt amb el següent format:

@TASK INFOTASKNAME = Nom de la tasca

8

FUNCTION = Funció de la tascaSUBFUNCTION = Subfunció de la tasca

@PARAMSPARAMNAME1 = nom del paràmetre 1 d'entradaPARAMTYPE1 = tipus del paràmetre 1 d'entradaPARAMNAME2 = nom del paràmetre 1 d'entradaPARAMTYPE2 = tipus del paràmetre 1 d'entrada(etc...)

@RESULTSRESULTNAME1 = nom del resultat 1RESULTTYPE1 = tipus del resultat 1RESULTNAME2 = nom del resultat 2RESULTTYPE2 = tipus del resultat 2(etc...)

La utilitat que té, es que mitjançant un script es podrà recopilar aquesta informació de les tasques i crear un document unificat per a donar-les d'alta al servidor més ràpidament.

3 Disseny

Presentem el disseny de totes les tasques en UML. Notem que els dissenys d’Imatges progressives (Figura 2), Enfonsar la flota (Figura 4), Sèrie cíclica (Figura 3) i Trencaclosques (Figura 5) es construeixen al voltant de la classe matrix, tal i com després desenvoluparem al següent punt. Els dos darrers Zigurat (Figura 6) i Aparellament (Figura7), també ho veurem després. Ho fan al voltant de diferents col·leccions, carte i estímuls respectivament.

Figura 2 – Diagrama UML d’imatges progressives

9

Figura 3. Diagrama UML de Sèrie cíclica

Figura 4. Diagrama UML d’enfonsar la flota

10

Figura 5. Diagrama UML de Trencaclosques

Figura 6. Diagrama UML de Zigurat

11

Figura 7. Diagrama UML d’Aparellament

Vinculats a cada imatge i adjunt a l’apartat d’annexes s’incorpora un diagrama detallat de cada tasca.

A la Figura 8 s’exposa el diagrama detallat de la classe matrix, on es veuen els diferents mètodes que encapsulen la gestió de coordenades d’una graella NxM.

Figura 8. Classe Matrix detallada

12

4 Desenvolupament

A continuació es detallarà una explicació sobre el progrés dels sis jocs , amb l’explicació de les funcions més destacades. Abans de començar el desenvolupament, tractarem alguna de les classes que s’han creat per facilitar la programació de varis jocs.

Classe Principal.java :

Tots els jocs tenen la seva classe principal, on està contingut el main(). Aquesta classe s’ha format amb una estructura comuna per a tots els jocs, i que pràcticament no ha de patir cap transformació. Les variacions s’explicaran en cada apartat. Escriurem la classe tasca base breument amb pseudocodi :

classe tasca ésConstructor Tasca(Paràmetres de la tasca) és

Inicialització de recursosCàrrega de la pantalla inicial

fi ConstructorFunció carregaPantallaActual és

opció (pantallaActual) :si instruccions: (...)si ajuda: (...)si resultats: (...); Guardar resultats

(etc.)fiOpció

fiFunciófunció manegadorRatolí()funció manegadorTeclat()(altres funcions auxiliars)funció main és

Obtenir els paràmetres de la tascaInstanciar l'objecte Tasca amb paràmetres obtinguts

fiFunciófiClasse

Es carrega la tasca amb el constructor i els paràmetres obtinguts. Si observem la funció main(), veurem que hem d’obtenir els paràmetres de la tasca, aquests es recuperen del servidor mitjançant una classe anomenada inOutXml.java , aquesta classe l’explicarem a continuació.

Els jocs es composen de 4 pantalles: 1.- la pantalla d’instruccions, on es defineixen els objectius del joc. 2.- la pantalla d’ajuda, que és la que ens recorda durant la partida (per si tenim algun dubte, ja que no podem tornar a la pantalla d’instruccions), quines son les premisses de la partida. 3.- La pantalla del joc, on es desenvolupa la partida, i, 5.- la pantalla de resultats, on es mostren els percentatges d’encerts, errors i tots aquells paràmetres quantificables per cada partidaA cada classe principal, tindrem unes constants per aquestes 4 pantalles:

private final int INSTRUCTIONS_SCREEN = 0;

13

private final int GAME_SCREEN = 1;private final int HELP_SCREEN = 2;private final int RESULTS_SCREEN = 3;

El manegador de ratolí, s’encarrega de rebre els events click del ratolí, i tracta segons l’àrea clicada i la pantalla actual.Les funcions auxiliars, s’expliquen per a cada joc, donat que varien segons les necessitats establertes.

Totes les pantalles acostumen a tindre un fons blanc i una imatge amb el logotip de Guttman (Figura 9) .

Figura 9. Logotip de l’institut Guttman

Classe FullScreen.java :

Per fer totes les resolucions compatibles se’ns han facilitat una classe FullScreen.java , que ens ajuda a que tots els jocs puguin funcionar de la mateixa manera amb diferents resolucions, donada l’extensió de la classe, comentarem les classes més emprades durant la realització del projecte.

La capçalera de la classe extendrà de JFrame, per poder contenir l’objecte graphics.

Constructor de FullScreen .

public Fullscreen() {super(gConfiguration);try {

this.setUndecorated(true);this.setIgnoreRepaint(true);this.setResizable(false);this.setBackground(defaultBackground);this.setForeground(defaultForeground);gDevice.setFullScreenWindow(this);this.setNBuffers(this.nBuffers);

14

defaultFont = this.getSizedFont("Century Gothic", Font.BOLD, 1.0);this.setFont(defaultFont);

} finally {}

}

blankScreen ens deixarà la pantalla en blanc per poder repintar-la amb la pantalla adient.

public void blankScreen() {Graphics2D g = (Graphics2D) this.getBufferStrategy().getDrawGraphics();try {

if (g != null) {g.setColor(this.getBackground());g.fillRect(0, 0, this.getWidth(), this.getHeight());

}} finally {

g.dispose();}

}

displayImage s’encarrega de pintar imatges del tipus BufferImage , en la regió delimitada per l’objecte AffineTransform, és un del mètodes més utilitzats durant el joc.

public void displayImage(BufferedImage image, AffineTransform at) {Graphics2D g = (Graphics2D) this.getBufferStrategy().getDrawGraphics();try {

if ((g != null) && (image != null)) {g.drawImage(image, at, null);

}} finally {

g.dispose();}

}

displayText ens escriura el contigut del String

public void displayText(int x, int y, String text, Font font, Color col) {

Graphics2D g = (Graphics2D) this.getBufferStrategy().getDrawGraphics();try {

if ((g != null) && (text != null)) {g.setFont(font);g.setColor(col);g.drawString(text, x, y);

}} finally {

g.dispose();}

}

15

Classe InOutXML.java:

Aquesta classe està creada per enviar , rebre dades i apart llegir cadenes de caràcters d’un fitxer.El mètode per rebre dades és getParams , i ens retorna una estructura Hashtable amb parelles de valors String,String , que iterant-ho , i coneixent el nom de cada valor, ens permet obtenir els paràmetres desitjats.

públic Hashtable<String, String> getParams(String name) {DocumentBuilderFactory dbFactory = DocumentBuilderFactory.newInstance();DocumentBuilder docBuilder = dbFactory.newDocumentBuilder();xmlDoc = docBuilder.parse("in.xml");NodeList nodes = xmlDoc.getChildNodes(); for (int i = 0; i < nodes.getLength(); i++) { Node node = nodes.item(i); if (node.getNodeName().equals("PARAMETERS")) { NodeList param = node.getChildNodes();

for (int j = 0; j < param.getLength(); j++) { Node NP = param.item(j); if (np.getNodeName().equals("PARAM")) {

NamedNodeMap attr = np.getAttributes(); this.params.put(attr.getNamedItem("PARAMNAME").getNodeValue(),attr.getNamedItem("PARAMVALUE").getNodeValue());

}}

}

return params;}

Per enviar resultats haurem de combinar dos mètodes , durant la partida, afegirem resultats amb el mètode addResults((String resultName, String resultValue)) on resultName és el nom de la variable afegida i resultValure el valor que li donarem a dita variable, i un cop hagi acabat el joc , construirem l’arxiu final anomenat per a tots els jocs out.xml amb el mètode buildOutFile ().

public void addResult(String resultName, String resultValue) {if (!this.results.containsKey(resultName)) {

this.results.put(resultName, resultValue);}

}

públic void buildOutFile(String name) {Element param, results,thres;StringWriter strWriter = null;XMLSerializer xmlSerializer = null;OutputFormat outFormat = null;try {

DocumentBuilderFactory dbFactory = DocumentBuilderFactory.newInstance();DocumentBuilder docBuilder = dbFactory.newDocumentBuilder();xmlDoc = docBuilder.newDocument();results = xmlDoc.createElement("RESULTS");xmlDoc.appendChild(results);param = xmlDoc.createElement("PARAM");

16

param.setAttribute("RESULTNAME", "Threshold");param.setAttribute("RESULTVALUE", threshold);results.appendChild(param);Enumeration<String> keys = this.results.keys();while (keys.hasMoreElements()) {

String key = keys.nextElement();String value = this.results.get(key);param = xmlDoc.createElement("PARAM");param.setAttribute("RESULTNAME", key);param.setAttribute("RESULTVALUE", value);results.appendChild(param);

}xmlSerializer = new XMLSerializer();strWriter = new StringWriter();outFormat = new OutputFormat();outFormat.setEncoding("ISO-8859-1");outFormat.setVersion("1.0");outFormat.setIndenting(true);outFormat.setIndent(4);xmlSerializer.setOutputCharStream(strWriter);xmlSerializer.setOutputFormat(outFormat);xmlSerializer.serialize(xmlDoc);OutputStream fout = new FileOutputStream(name);OutputStream bout = new BufferedOutputStream(fout);OutputStreamWriter out = new OutputStreamWriter(bout);strWriter.close();out.write(strWriter.toString());out.flush();out.close();

} catch (Exception e) {e.printStackTrace();

}}

Per últim tenim un mètode afegit anomenat readFile que ens servirà per obtenir el contingut dels arxius en forma de vector de Strings, cada element del vector contindrà una línea del arxiu.

public String[] readFile(String name) throws IOException {BufferedReader input = null;// use buffering, reading one line at a timeinput = new BufferedReader(new FileReader(name));String line = null;int i = 0;while ((line = input.readLine()) != null) {

i++;}String contents[] = new String[i];input.close();input = new BufferedReader(new FileReader(name));i = 0;while ((line = input.readLine()) != null) {

contents[i] = line;i++;

}input.close();return contents;

}

Classe ThreadStatsBar:

17

Ens permet instanciar un Thread que animarà (a la pantalla que li passem per paràmetre) la barra de progrés tenint en compte la regió que volem que ocupi i els paràmetres total i subtotal que defineixen el tan per cent que s’omplirà la barra.

El constructor de la classe serà el següent:

public ThreadStatsBar(Fullscreen s, double f[], double seconds, int subtotal, int total, Font font);

Per tant en la nostra aplicació per tal de començar a animar la barra amb els paràmetresdesitjats només haurem de fer :

ThreadStatsBar thread = new ThreadStatsBar(screen, fBar, seconds, subtotal, total, GotSmall); thread.start();

Veurem una animació (Figura 10) que durarà el nombre de “seconds” demanants i omplirà la barra de progrés al 50%. Cal tenir en compte, que si passem un valor de total més petit que subtotal (en teoria no hauria de passar mai) el thread truncarà el valor de total igual a subtotal, i veurem la barra de progrés plena al 100%.

En quan al control de finalització del thread, no ens caldrà fer cap crida explícita perquè un cop acabada l'animació automàticament finalitzarà.

Figura 10. Exemple del resultat de ThreatStatsBar

El Codi que dóna vida a aquesta barra es el següent:

private void animStatsBar(Fullscreen screen, double[] fBar, double seconds, int corrects, int total) {int w = screen.getWidth();int h = screen.getHeight();int ho = (int) (((fBar[3] - fBar[2]) * h * corrects / total));

18

if (ho > 0) {int hf = (int) (fBar[3] * h);int wi = (int) (fBar[0] * w);int wo = (int) ((fBar[1] - fBar[0]) * w);int ms = (int) seconds * 1000 / ho;try { for (int i = 0; i <= ho; i++) { if (i < ho) {

screen.drawRect(wi, hf - i, 1, 1, Color.BLACK); screen.drawRect(wi + 1, hf - i, wo - 2, 1, Color.YELLOW);

screen.drawRect(wi + wo - 1, hf - i, 1, 1, Color.BLACK); } else {

screen.drawRect(wi, hf - i, wo, 1, Color.BLACK); }

screen.updateScreen();Thread.sleep(ms);

} screen.updateScreen(); } catch (Exception e) { }

}}

Classe Martrix.java :

En la majoria dels jocs ens trobem la necessitat de dividir certes àrees quadrades en diferents caselles de tamany NxM . La problemàtica és, calcular totes les coordenades que formen aquesta matriu, i poder-la moure lliurement pel taulell. Així que s’ha creat la classe Matrix, que li passarem per paràmetre el nombre de files , el nombre de columnes i una àrea quadrada limitada per dos punts ( x1,y1 ) i (x2,y2). El codi de la classe es presenta a continuació:

/** * @author Pol Llauradó Navarro * @see Matrix * @version 1.0 */

públic class Matrix {private int cols,rows; // Graella de n x m Elementsprivate double[] table;private double[][] fTable;públic Matrix(int x,int y,double[] t) { // constructor

fTable= new double [x*y][4];cols= x;rows = y;table=t;

}

públic Matrix(int x,int y) { // sobrecarrega del constructorfTable= new double [x*y][4];cols= x;rows = y;

}

19

// funció especifica per enfosar la flota

públic double[] fusion(int x,int y,int direction,int size){ double[] fVar=new double[4];double tWidth = table[1] - table[0]; double tHeight = table[3] - table[2];if (direction==1){

double[] fAux=getCoordenades(getRelativePosition(x,y));fVar[0]=fAux[0];fVar[1]=fAux[1] + ( (tWidth/cols) * (size-1) );fVar[2]=fAux[2];fVar[3]=fAux[3];

}else if(direction==0){double[] fAux=getCoordenades(getRelativePosition(x,y));fVar[0]=fAux[0];fVar[1]=fAux[1];fVar[2]=fAux[2];fVar[3]=fAux[3]+ ( (tHeight/rows) * (size-1) );

}

return fVar;}

public double[] fusion(int relPos,int direction,int size){int x,y;y = relPos / cols;x = relPos - (y * cols);return fusion(x, y,direction,size);

}

public void divideTable(){double tWidth = table[1] - table[0]; double tHeight = table[3] - table[2];for (int i=0;i<this.rows;i++){

for(int j=0;j<this.cols;j++){fTable[getRelativePosition(j,i)][0]=((tWidth/cols)*j)+(table[0]); fTable[getRelativePosition(j,i)][1]=((tWidth/cols)*(j+1))+(table[0]); fTable[getRelativePosition(j,i)][2]=((tHeight/rows)*i)+(table[2]);fTable[getRelativePosition(j,i)][3]=((tHeight/rows)*(i+1))+(table[2]);

}}

}

public double[] getCoordenades(int index){double[] fVar = new double[4];fVar[0]= fTable[index][0];fVar[1]= fTable[index][1];fVar[2]= fTable[index][2];fVar[3]= fTable[index][3];

20

return fVar;}

públic double[] getCoordenades(int x,int y){double[] fVar = new double[4];int índex;índex = getRelativePosition(x,y);fVar[0]= fTable[index][0];fVar[1]= fTable[index][1];fVar[2]= fTable[index][2];fVar[3]= fTable[índex][3];return fVar;

}

public int getRelativePosition(int x,int y){return (x + (y * cols));

} }

Com es pot observar, un cop tenim les files , les columnes i l’àrea quadrada, ja podem cridar al mètode divideTable(). Aquest dividirà el taulell i ho emmagatzemarà a una matriu bidimensional, anomenada fTable[][].

Aquí es presenta una idea il·lustrada (Figura 11) per un major aclariment d’un taulell de N = 13 , M= 7 i un vector de coordenades { X1,X2,Y1,Y2} :

Figura 11. Exemple d’una divisió d’àrees amb la classe Matrix

21

Aquesta classe ens és de gran utilitat per quasi tots els jocs, ja que aquests segueixen un padró bastant semblant en quant a àrees quadrades i dividides equitativament. Només haurem d’afegir algun mètode més concret que ens faciliti la programació en determinats jocs. Aquests els explicarem dins el desenvolupament de cada joc.

4.1 Enfonsar la flota

L’objectiu del joc es enfonsar la flota del seu contrincant (l’ordenador) abans que aquest enfonsi la seva.

4.1.1 Problema clínic a estudi

Dificultat o incapacitat per planificar / organitzar els passos a seguir per tal de desenvolupar una tasca. La planificació es un aspecte executiu d’ordre superior a la seqüenciació.

4.1.2 Descripció del joc

La flota de cadascun dels jugadors està formada pels següents vaixells:

- un portaavions (5 quadres)- dos creuers (4 quadres)- quatre fragates (3 quadres)- quatre buscamines (2 quadres)

Abans de començar a jugar el subjecte ha de col·locar en una graella de 16 x 16 la seva flota (Figura 12). A la part superior de la pantalla es mostra el següent missatge: “col·loca els teus vaixells abans de començar la partida”. Al costat dret de la pantalla apareix una llista amb els vaixells; a mesura que el subjecte els va col·locant van desapareixent d’aquesta llista.

Figura 12. Pantalla de selecció dels vaixells

22

Partida: sobre un fons blanc es presenten dues graelles de 16 x 16 (una per cada un dels jugadors). A l’inferior de la pantalla s’indica els efectius de cadascun dels jugadors que resten per ser enfonsats. (veure mostra de la tasca).

En la tasca, la ubicació dels vaixells del subjecte s’ha d’indicar mitjançant imatges de vaixells que ocupin de dues a cinc caselles, segons correspongui.

Per mostrar la localització dels vaixells enfonsats es podria mantenir el color vermell utilitzat a la mostra.

Les caselles on s’ha provat de localitzar un vaixell però no n’hi havia s’hauria d’indicar amb una imatge escaient.

Al final de la partida s’ha d’indicar el guanyador amb el següents missatges:

- has guanyat! (quan guanya el jugador)- guanya l’ordinador

4.1.3 Descripció de les classes utilitzades S’han utilitzat 5 classes que s’especifiquen a continuació : BattleShips.java

Classe principal del joc, on està contingut la classe main(). Podem destacar com ha modificació important l’afegiment d’una nova constant per les pantalles, ja que s’han d’escollir els vaixells abans de començar; i interessa tenir una pantalla separada per facilitar la feina , aquesta l’anomenem :

private final int SELECT_MY_BATTLE_SCREEN = 4;

A part de totes les funcions bàsiques i objectes d’inici, l’hi afegim dos taulells del tipus BattleTable, per a cada jugador, un per l’ordinador i un per l’usuari/pacient (els taulells sempre seran de 16x16):

tablePlayer = new BattleTable(16, 16, fBat, screen, lang);tableOponent = new BattleTable(16, 16, fOponent, screen, lang);

Per a cada tirada l’event loadScreen() ens torna a pintar el taulell (tauler.paintTable())i els vaixells enfonsats(tauler.PaintShips()). El mateix paint table s’encarrega de veure la informació de casella per poder pintar els dos estímuls possibles (aigua i tocat).

El usuari/pacient té possibilitat de tirar allí on no hi hagi cap event clicat, i automàticament l’oponent tira al taulell del jugador. Depenent del nivell de la partida l’ordinador afinarà més o menys segons les pistes de què disposi, mentre no trobi cap pista anirà buscant aleatoriament pel taulell. Els nivells s’amplien més detalladament a la classe BattleTable.

InfoCasella.java ( Informació pertanyent a cada casella )

Guardem la informació de cada casella amb els següents atributs:

23

double[] fCasella;boolean free;boolean used;BufferedImage image;

Únicament contindrà els mètodes getters i setters dels mateixos. Una aclaració per a les booleanas free i used , que no volen dir el contrari, les necessitem per poder dir no nomes si una casella ja ha sigut clicada (used) , sinò també per dir si aquella casella hi contenia un vaixell o aigua (free).

InfoShip .java

Cada vaixell conté la seva informació, (tamany , tipus d’imatge, vegades que ha estat tocat...) amb la següent estructura:

final int VERTICAL = 0;final int HORIZONTAL=1;int shipSize; // Tamany del vaixellint damageRecived; // Bales rebudesdouble[] shipPosition; // Coordenades dins del taulellboolean sunk; // boolean HundidoBufferedImage shipImageH; BufferedImage shipImageV;BufferedImage shipImageBlank;int relPosition;int direction;

Al dibuixar els vaixells ens trobem amb la problemàtica de tenir vaixells en horitzontal, vaixells en vertical i vaixells amb el fons blanc.

Per raons estètiques s’han fet aquestes imatges, per a que concordessin amb el fons del mar i no deixar espais en blanc en mig del taulell. Les imatges de fons blanc, únicament s’utilitzen per dibuixar les estadístiques del joc, enteses pels vaixells que ens queden per enfonsar . En la següent imatge (Figura 13) es mostra un exemple de com queden dibuixats els diferents tipus de vaixells per tal d’homogeneïtzar el joc.

Figura 13. Mostra del pantalla de Joc

24

En aquesta classe es troben dues funcions, que es diferencien dels getters i setters plans per l’accés als atributs, un d’aquests es el mètode setShoted() que ens suma els impactes contra el vaixell i quan no pugui rebre més impactes, el marcarem com enfonsat.

public void setShoted(){if (damageRecived<shipSize){

damageRecived++;if (damageRecived==shipSize){ sunk=true;}

}

}

Matrix.java

La classe matrix és igual que l’explicada anteriorment, l’únic que hem afegit un mètode ( fusion() ), per a que es puguin fusionar caselles doncs les necessitem per dibuixar els vaixells de diferent longitud.

public double[] fusion(int x,int y,int direction,int size){ double[] fVar=new double[4]; double tWidth = table[1] - table[0]; double tHeight = table[3] - table[2]; if (direction==1){

double[] fAux=getCoordenades(getRelativePosition(x,y));fVar[0]=fAux[0];fVar[1]=fAux[1] + ( (tWidth/cols) * (size-1) );fVar[2]=fAux[2];fVar[3]=fAux[3];

}else if(direction==0){double[] fAux=getCoordenades(getRelativePosition(x,y));fVar[0]=fAux[0];fVar[1]=fAux[1];fVar[2]=fAux[2];fVar[3]=fAux[3]+ ( (tHeight/rows) * (size-1) );

} return fVar;}

Depenent de la direcció on es dibuixi el vaixell, estirarem l’eix de les x o l’eix de les y, així tindrem la mesura geomètrica perfecta per encaixar dintre de la graella.

BattleTable.java ( Taulell )

Trobem la majoria de funcions pel funcionament del joc en aquesta classe, entre elles, aquelles que posen els vaixells aleatoris per al taulell del ordinador, putShip(); les que corregeixen , dibuixen els taulells, les estadístiques... de totes aquestes en ressaltarem dues com les més importants en quant a funcionament es refereix. Son les encarregades d’avaluar el estímuls del usuari/pacient, en el cas del usuari/pacient, i la de jugar automàticament en el cas de l’ordinador.

Quan l’usuari/pacient clica un estímul, aquest acaba sent controlat per la següent funció:

public boolean checkMisilPosition(int x,int y){int rp;

25

int auxX, auxY;rp = RelativePositionClick(x,y);auxY = rp / fMatrixGame.getCols(); // RowsauxX = rp - (auxY * fMatrixGame.getCols()); // Colsif (!tableGame[auxX][auxY].isUsed()){

selectShip(x, y);tableGame[auxX][auxY].setUsed(true);if (shipSelected){

if (!tableShips[indexShip].isSunk()){tableShips[indexShip].setShoted();

}}shipSelected = false;return true;

}else{return false;// Missatge de casella ja utilitzada

}}

Comprovem si la casella ha estat clicada, si no ho ha estat, la marquem com utilitzada, si en aquella posició es troba un vaixell, es detecta quin vaixell a estat tocat i li restarem un 1 punt de vida , només si el vaixell esta enfonsat es dibuixa ell mateix, en cas contrari dibuixem una imatge d’explosió. Si no hem tocat cap vaixell ens sortirà una casella de mar.

L’ordinador fa la següent tirada en funció del nivell que s’hagi escollit, cada nivell incrementa la intel·ligència de l’ordinador.

El primer nivell es trivial, en aquest, l’ordinador no prepara cap jugada, únicament es dedica a enfonsar caselles aleatòries, sense tenir en conte l’anterior. És en els altres nivells on es comencen a crear estratègies, per poder guanyar la partida.

El nivell 2 i 3, un cop trobin un encert, es comença a buscar al voltant d’aquest fins que s’aconsegueix enfonsar el vaixell, la diferència entre els dos és que en el nivell 3, encara que hagi trobat el vaixell , si durant la recerca del mateix a pitjat una casella on es trobava un altre, al acabar d’enfonsar-lo anirà a pel següent que tingui una pista, al contrari que el nivell 2, que un cop l’hagi trobat, independentment que hagués trobat un pista d’un altre vaixell al voltant durant la recerca del primer, tornarà a tirar aleatòriament fins trobar una altra pista.

A continuació farem una explicació gràfica del desenvolupament dels nivells acompanyat del codi més explicatiu.

Nivell 1 :

Busca x i y aleatòriament durant tota la partida sense tenir en compte les pistes.do{

x =(int) (Math.random() * fMatrixGame.getCols());y =(int) (Math.random() * fMatrixGame.getRows());

}while (tableGame[x][y].isUsed()); tableGame[x][y].setUsed(true);

rp = fMatrixGame.getRelativePosition(x, y);

26

if (isMyRelativePosition(rp)){ tableShips[indexShip].setShoted(); }

}

Nivell 2 i 3:

Busca al voltant de la primera pista trobada . Degut a la l’extensió del mètode, l’escriurem amb pseudocodi, per a que sigui mes entenedor:

Funció setAutomaticalMisil és Si (Vector[] esta buit)llavors Var tirada = Tirada Aleatòria Sino Var tirada = Tirada Condicionada Fisi

Si (tirada = aigua) llavors Tornem a començar

FiSiSi (tirada = vaixell) llavors

Vector [] = emmgatzema una InfocasellaFiSiSi (vaixell Enfosat) llavors Eliminem elements del vector del vaixellFiSi

fiFunció

Ja hem explicat que la diferència entre els dos nivells, és que al tercer, un cop s’enfonsi el vaixell i en tingui algun altre de detectat, el buscarà, en canvi, en el nivell 2 tornarà a buscar aleatòriament, perquè li borrarem tot el contingut.Aquí un esquema orientatiu del funcionament (Figura 14), per aclarir dubtes.

27

Figura 14. Esquema del funcionament dels nivells 2 i 3

4.1.4 Arxiu references.txt

L’arxiu amb les variables que es comuniquen amb el servidor (references.txt) serà el següent:

@TASK INFOTASKNAME = Enfonsar la flotaFUNCTION = ExecutivesSUBFUNCTION = Seqüenciació

@PARAMS PARAMNAME1 = levelPARAMTYPE1 = integer

@RESULTSRESULTNAME1 = TotalDamageRESULTTYPE1 = integer

RESULTNAME2 = TimeRESULTTYPE2 = double

4.2 Trencaclosques

L’objectiu de la tasca consisteix en formar una figura combinant correctament les parts d’aquesta que es troben en diferents peces, movent sempre la peça escollida sobre l’espai buit del taulell (Figura 5.2.1).

28

4.2.1 Problema clínic a estudiDificultat o incapacitat per planificar / organitzar els passos a seguir per tal de desenvolupar una tasca. La planificació es un aspecte executiu d’ordre superior a la seqüenciació.

4.2.2 Requisits del joc

Sobre un fons de color blanc es presenta una graella dividida en diferents peces segons indiqui el terapeuta (per una combinació de files y columnes) . Així, les dimensions de la graella son sempre les mateixes (Figura 15) i el que canvia son les divisions internes.

Dins d’aquesta graella es presenta una imatge dividida en tantes parts com peces indica el terapeuta menys una peça que es mostra de color blanc. El subjecte ha de col·locar les peces correctament per reconstruir la imatge desplaçant les peces d’una en una (utilitzant la peça blanca per tal de moure la resta –en realitat es tracta de un buit–).

Un cop el subjecte aconsegueix reconstruir la imatge a la part superior central surt el següent missatge: “tasca completada!”.

Els nivells de dificultat s’estableixen en funció dels següents paràmetres:

1 número de columnes: de 3 a 7 2 número de files: de 3 a 73 dificultat de la imatge utilitzada

Figura 15. Exemple visual de la tasca a realitzar

4.2.3 Descripció de les classes utilitzades:

1 Matrix.java – Conjunt de Coordenades2 PuzzleTable – Taulell de joc3 TrencaClosques – Classe principal

29

La classe matrix.java no pateix cap modificació, l’utilitzarem per obtenir el conjunt de coordenades del taulell.

TrencaClosques.java:

Utilitzarem una classe Timer per controlar el temps del joc i una classe PuzzleTable per crear el taulell de joc. Com a les altres ens servirà per recollir tots els esdeveniments generats per l’usuari/pacient i poder interpretar-los. No tindrà cap afegit més, i ens limitarem a explicar les línies de codi que faran de motor per aquesta tasca:

if (newGame) { puzzleTable.divideImage(iPuzzle); initialTime = (int) System.currentTimeMillis(); newGame = false;}puzzleTable.drawImages();

if (puzzleTable.isComplete()) { totalTime = (int) (System.currentTimeMillis() - initialTime); screen.displayImage(iContinue, atCon);}

Aquest codi està ubicat dintre del controlador de pantalla, per al GAME_SCREEN, s’encarrega d’inicialitzar la tasca a l’entrada de la mateixa i redibuixa la pantalla quan s’hagi fet algun canvi al taulell. Un cop finalitzada guarda el temps emprat en realitzar-la i mostra el botó continuar, per avançar a la següent pantalla o anar als resultats obtinguts.

if (puzzleTable.isComplete()) {if (screen.isInArea(x, y, fCon)) {

currentScreen = RESULTS_SCREEN;loadScreen();

}} else {

if (screen.isInArea(x, y, ftable)) {if (puzzleTable.checkClick(x, y)) {

loadScreen();}

}}

En el controlador d’events per al ratolí comprovarem que la tasca no ha estat completada, per validar el moviment dins del taulell, si la tasca hagués finalitzat només escoltarem els events del botó continuar.

Els paràmetres necessaris per executar la tasca son les files, columnes i imatge, que venen donats pels terapeutes.

PuzzleTable.java :

El taulell ha de dibuixar les imatges, dividir-les , corregir-les...Primer estudiarem la forma de dividir les imatges mitjançant l’objecte PixelGrabber , que és una classe utilitzada per convertir una imatge en un array de valors que corresponen als seus píxels. Implementa una interficie ImageConsumer, que pot ser acoblada a un objecte Image o ImageProducer que podrà realitzar qualsevol manipulació amb la imatge, en el

30

nostre cas , la dividirem en regions de píxels, però també es pot combinar amb diferents funcions per tal d’acoblar una imatge damunt d’una altra, fer algun tipus de transparència ... La funció divideImage ens genera el array de n * m , amb les divisions demanades.

public void divideImage(BufferedImage image) { int i, j; BufferedImage newImage[][] = new BufferedImage[rows][cols]; int width = image.getWidth() / cols; int height = image.getHeight() / rows; int[] pix = new int[width * height]; for (i = 0; i < cols; i++) {

for (j = 0; j < rows; j++) {PixelGrabber pgObj = new PixelGrabber(image, j * width, i * height, width, height,pix, 0, width);try { pgObj.grabPixels();} catch (InterruptedException e) {

System.err.println("Interrupted waiting for pixels!");e.printStackTrace();

}if ((pgObj.getStatus() & ImageObserver.ABORT) != 0) { System.err.println("Image fetch aborted or errored");

} else {Image img = Toolkit.getDefaultToolkit().createImage(new MemoryImageSource(width, height, pix, 0, width));newImage[i][j] = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB);Graphics2D big = newImage[i][j].createGraphics();big.drawImage(img, 0, 0, null);big.dispose();

} } }puzzleImages = newImage;}

Com es veu en la següent imatge (Figura 16) una seqüència del joc, amb un array d’imatges pràcticament ordenades i un espai buit on anirà a parar el següent pas.

Per poder controlar els events de ratolí, en concret el clic sobre el taulell hem desenvolupat la funció checkClick (x,y) , que comprovarà que estem clicant sobre un tros d’imatge que esta al voltant de l’estímul blanc.

31

Figura 16. Exemple del joc en execució

Per últim explicar la funció Exchange (posicio1,posicio2) , que ens farà un swap entre el tros d’imatge escollida i l’espai en blanc (el jugador només podrà tirar, si clica a un casella del voltant de la blanca). Quan comencem una partida, es desordena el taulell a base de Exchange, assegurant-nos que com a mínim desordenem un 70% sobre el màxim de possibles tirades, així ens assegurarem que el joc te solució. Si col·loquéssim les peces totalment aleatòries, ens trobaríem amb solucions molt complicades.

4.2.4 Arxiu references.txt

L’arxiu de references.txt, per a controlar les variables d’entrada i sortida al servidor, serà el següent:

@TASK INFO

TASKNAME = TrencaClosquesFUNCTION = ExecutivesSUBFUNCTION = Planificacio

@PARAMS

PARAMNAME1 = rowsPARAMTYPE1 = integer

PARAMNAME2 = colsPARAMTYPE2 = integer

PARAMNAME3 = imagePARAMTYPE3 = string

@RESULTS

RESULTNAME1 = totalMovimentsRESULTTYPE1 = integer

32

RESULTNAME2 = maxMovimentsRESULTTYPE2 = integer

Codi per generar l’arxiu de sortida out.xml

private void generateXml() {totalTime = ticks;totalDamage = tableOponent.getTotalPuntuation();double res =(double) totalDamage / TOTAL_PERCENTATGE_SHIPS;System.out.println(res);xml.addResult("Time", Integer.toString(totalTime));xml.addResult("TotalDamage", Integer.toString(totalDamage));xml.setThreshold(Double.toString((double)(res * 100)));xml.buildOutFile("out.xml");

}

4.3 Aparellament

4.3.1 Descripció de la tasca

Es tracta d’una tasca d’atenció selectiva, en la qual el subjecte ha de buscar els estímuls iguals a un model predeterminat. Els estímuls diana es troben situats entre molts altres interferents de diferent categoria, mateixa categoria o diferent orientació.Es guanya un punt quan es localitza correctament un estímul. Si el subjecte tarda més de cinc minuts en donar la resposta correcta, finalitza l’exercici de forma automàtica.Hi ha la possibilitat de jugar contra l’ordinador, de manera que si es triga més temps del estipulat (45 segons) en trobar el estímul diana, ho farà l’ordinador i ens guanya el punt.

Apareix el botó d’ajuda en la part inferior esquerra de la pantalla, donant la possibilitat de recordar les instruccions per fer l’exercici en qualsevol moment. També es mostra el botó de sortir, a la part superior esquerra de la pantalla, per poder sortir del exercici en qualsevol moment i consultar els resultats obtinguts fins el moment.

Quan l’usuari/pacient finalitza una pantalla apareix automàticament el botó de continuar, per passar a la següent o finalitzar la tasca.

Les variables amb les quals es treballa son les següents:

Tipus d’estímul: Tindrem objectes concrets com fruites, verdures, mobles, cotxes, banderes …, i abstractes (símbols).

Grandària d’estímul: la grandària podrà ser de les següents mides1.25, 1.5 y 1.75cm.

Modalitat del estímul:

- Estímuls simples: Només es presenta un estímul de 1.75 cm.- Estímuls dobles: Es presenten dos estímuls de 1.5 cm.- Estímuls triples: Es presenten tres estímuls de 1.25 cm.

Nombre d’estímuls que apareixen a la pantalla: 75, 100 y 125.

33

Modalitat d’exercici: Exercici i Competició.

Temps límit per fer la tasca en la modalitat d’exercici: 300 segons.Temps límit de resposta per la modalitat de competició: 45 segons.

Els nivells de dificultat es formen en funció de les variables presentades.Per la modalitat, exercici /competició, ha de ser la mateixa distribució del nivells.

FeedBack

Cada vegada que el subjecte realitzi una resposta correcta, desapareix l’estímul i parpalleja intermitentment 2 vegades amb un estímul “visto”, així mateix l’encert anirà associat a un so agut. Si la resposta no és correcta, l’estímul parpalleja intermitentment 2 vegades amb un estímul “X”. De la mateixa manera, l’error va associat a un so greu. En el cas de les omissions, respostes correctes no clickades, l’estímul parpalleja intermitentment 2 vegades amb un estímul d’interrogació.

Instruccions

En aquest exercici, per qualsevol modalitat (exercici/competició), s’ha d’assenyalar, el més ràpidament possible, cada un dels objectes iguals al model situat en la part superior de la pantalla.

En la modalitat competició hi ha una puntuació diferent:

- Guanya 1 punt si clicka l’estímul abans que l’ordinador. - Perd un punt si l’ordinador clicka l’estímul abans que vostè doni la resposta.

Un cop acabats els estimuls presentats per la pantalla de joc, s’enviarà cap a la pantalla de resultats.

Paràmetres quantificables:

Paràmetre DescripcióNombre d’estímuls correctes Estímuls clicats correctament a la tascaNombre d’omissions Estímuls correctes no assenyalatsNombre d’errors Estímuls incorrectes assenyalats.Temps Temps utilitzat en detectar i assenyalar

tots els estímuls-target.

4.3.2 Descripció de les classes utilitzades

Jerarquia de classes utilitzades :

- Aparellament.java- TableGame.java- FeedBack.java

34

- GameTimer.java- InfoEstímul.java

Començarem parlant de les classes que emmagatzemen informació i les que tenen petites funcionalitats sobre la tasca per després poder explicar les principals, amb més claredat.

InfotEstímul.java :

private AffineTransform at;private BufferedImage image;private boolean view;private double[] coord;private double[] auxCoord;

Cada estímul tindrà aquesta informació continguda, per poder tractar d’una manera opaca. Li donarem directament un AffineTransform, que ens diu en quin lloc de la pantalla ha d’anar dibuixada la imatge, i el contingut de la imatge (BufferedImage) que s’ha de dibuixar. L’atribut view serà una booleana , que l’indicarà a aquest estímul si es pot dibuixar, o per contrari ja ha estat exclòs del joc ( per que ha estat clicat correctament).Coord i auxCoord, contindran coordenades, per poder variar la posició de l’estímul en temps del joc, encara que és una funcionalitat afegida, que potser no s’acaba d’implantar, les imatges poden anar variant les posicions segons ho necessitem. Ens vàrem trobar amb el fet de que si apareixien tres estímuls en el taulell referents l’estímul objectiu, a l’hora d’aparèixer, era evident, on estarien situats, així que donem la possibilitat de que en aquests nivells del joc (Estímul doble i triple), es pugui variar totes les posicions dels estímuls, per amagar una mica millor l’estímul objectiu. Per tant, si no s’arribés a utilitzar, aquets atributs podrien ser eliminats.

Els únics mètodes que existeixen per aquesta classe, són els getters i setters, per poder consultar i modificar la informació. No te cap funcionalitat.GameTimer.java

Hem dissenyat un rellotge per controlar els temps del joc, extenent-lo de la classe java.util.timer . Tenim els següents atributs, per poder manipular, una de les variables de cada tasca (Temps):

private int ticks, totalTicks;private boolean finalize;private long totalTime;

Ticks i totalTicks, poden semblar iguals, però a l’hora de jugar, totalTicks, s’encarrega de contar els temps totals de la partida, mentre que ticks ens fa de limitador, quan necessitem ( per exemple en la modalitat de competició cada 45s l’ordinador ens esbrina un estímul ) genera events dins del temps total, sense perdre les referències.La booleana finalize, ens fa d’emissària per avisar-nos de que el temps del joc ha finalitzat. Això passarà quan el ticks totals , arribin a totalTime, que és una variable que inicialitzarem amb una valor que dependrà del tipus de la tasca realitzada.El mètode TimerTask, de Timer, es limitarà a sumar un tick cada segon, i comprovar si hem arribat a final.

FeedBack.java

35

Hem agafat la classe que se’ns proporcionava al paquet de Guttman , anomenada ThreadCursor, i l’hem fet nostra. Únicament perquè la classe feedBack, està implentada per escriure un text parpellejant, i nosaltres necessitàvem fer que parpellegessin les imatges, en concret, imatges de informació. Quan encertem apareix un tick verd, quan fallem apareix una creu vermella i si es fa una omissió, apareix un interrogant. En la següent imatge (Figura 17) ens fem una idea de com son aquests estímuls.

Figura 17. Llegenda d’estímuls FeedBack

El codi de es pràcticament el mateix, només hem variat la funció run() , que en comptes de mostrar un text ens mostra una imatge :

Public void Run(){..

synchronized (this) {screen.displayImage(iImage, atImage);painted = true;

}..

}

Ja podem parlar de TableGame.java, que es la classe on estaran continguts tots els estímuls. Tindrem diferents punts que parlar, ja que no segueix pràcticament cap patró de les altres classes realitzades.

tableGame.java

Tots els atributs que necessita la tasca per escollir les dificultats es troben aquí, ja sigui la grandària dels estímuls (Simple , Doble o Triple), els temps del joc, el nombre d’estímuls que es mostraran, els tipus de imatges ( Concretes o abstractes) ...

També trobem la informació necessària per delimitar el taulell on estan els estímuls, les àrees per situar l’estímul l’objectiu, o les puntuacions del usuari/pacient.

36

Un dels mètodes creats, és per seleccionar el nivell. Si veiem la taula de nivells ens trobem amb patrons que es repeteixen a cada nivell, per tant, per comptes de crear un array directament copiant la informació de cada nivell, hem decidit fer aquest mètode, que mitjançant petits càlculs matemàtics ens trobarà els paràmetres que necessitem executar. Així també si volguéssim ampliar els nivells ens seria de gran utilitat.Per fer-nos una idea, presentarem un tros de la taula i després explicarem quin càlcul li hem aplicat a cada paràmetre.

Nivells Nombre d’estímuls

Mod. Del Estímul

Mod. Exercici

Tipus d’estímul

Temps max (segons)

1 75 Simple Exercici Concretes 3002 75 Doble Exercici Concretes 3003 75 Triple Exercici Concretes 3004 75 Simple Exercici Abstractes 3005 75 Doble Exercici Abstractes 3006 75 Triple Exercici Abstractes 3007 75 Simple Competició Concretes 45..... ... ... ... ... ...13 100 Simple Exercici Concretes 30014 100 Doble Exercici Concretes 30015 100 Triple Exercici Concretes 30016 100 Simple Exercici Abstractes 300... ... ... ... ... ...25 125 Simple Exercici Concretes 30026 125 Doble Exercici Concretes 30027 125 Triple Exercici Concretes 300... ... ... ... ... ...35 125 Doble Competició Abstractes 4536 125 Triple Competició Abstractes 45

Taula explicativa dels paràmetre establerts per cada nivell de joc.Per calcular els paràmetres a partir del nivell, ens adonem que els nombres d’estímuls canvien cada 12 nivells, la modalitat cada 1 nivell, el tipus d’exercici cada 6, els tipus d’estímuls cada 3 i els temps cada 6. Per tant el càlcul automàtic de cada nivell ens quedarà de la següent manera:

nombreDePeCes = estímulsCase[(nivell / 12) % 3]; {75,100,125}modalEstímul = estímulsMode[nivell % 3]; {Simple,Doble,Triple}TipusEstímul = estímulsType[(nivell / 3) % 2]; {Exercici,Competicio}modalTasca = tasksMode[(nivell / 6) % 2]; {Concretes,Abstractes}temps = tempsCase[(nivell / 6) % 2]; {300,45}

Aquesta tasca no ens permet utilitzar la classe Matrix, per calcular les coordenades dels estímuls, perquè aquests han de ser desordenats pel taulell, sense un sentit aparent. Per automatitzar aquest procediment, utilitzarem un mètode que ens comprovarà si en una posició aleatòria, se’ns solaparia amb una posició ja existent. El mètode s’anomena AreaInArea(Coord[] EstímulA,Coord EstímulB). Ens retornarà verdader si l’àrea que busquem està solapada amb alguna del tauler, i fals, si no es sobreposa amb ningú. A continuació es presenten les quatre condicions que s’han de complir per a que pugui estar solapades, tenint en compte el que el vector conté la informació [x1,x2,y1,y2] .if ((fImagA[0] > fImagB[0] && fImagA[0] < fImagB[1])

37

&& (fImagA[2] > fImagB[2] && fImagA[2] < fImagB[3])) return true;if ((fImagA[1] > fImagB[0] && fImagA[1] < fImagB[1])&& (fImagA[3] > fImagB[2] && fImagA[3] < fImagB[3])) return true;if ((fImagA[0] > fImagB[0] && fImagA[0] < fImagB[1])&& (fImagA[3] > fImagB[2] && fImagA[3] < fImagB[3])) return true;if ((fImagA[1] > fImagB[0] && fImagA[1] < fImagB[1])&& (fImagA[2] > fImagB[2] && fImagA[2] < fImagB[3])) return true;

Si no es compleix cap d’aquestes condicions, podrem assegurar que la imatge es podrà situar sense cap perill de que es solapi, i per tant retornarem un false.

fullTable omplirà el taulell d’estímuls, ajudant-se de dues funcions més. La primera obtindrà una posició aleatòria sense tenir en compte cap restricció. A partir d’aquesta posició generada, aplicarem la funció searchPosition, que ens dirà, si hi ha algun element del taulell solapat sobre la posició aleatòria. Per tant, obtindrem un condició així:

Si positionSearch(RandomPosition()) llavorsPosicio Correcta . podem afegir l’estímul al taulell

SinoRepetim la recerca

Fisi

Cal dir que el funcionament de positionSearch , és un recorregut per tots els elements continguts al taulell, en busca d’una AreaInArea().

Un cop tinguem tot els estímuls creats i situats, ve el moment de dibuixar-los. Els estímuls, ja contenen tota la informació necessària, i amb un simple for, que l’executarà drawTable() , es dibuixaran sobre el taulell. L’element a destacar aquí, serà el dibuixar l’estímul objectiu, que serà seleccionat a l’atzar. I comprovar la modalitat per si hem de dibuixar 2 o 3 estímuls més, referents al objectiu (Doble o Triple).Per tant tenim la funció DrawEstímul() que dibuixarà l’estímul objectiu, i DrawOthers, si haguéssim de dibuixar els estímuls repetits.Al dibuixar l’estímul objectiu creem un objecte vector amb les coordenades del mateix, per facilitar la recerca de l’estímul clicat. DrawOthers s’atindrà a les següents condicions

Si ModalitaEstímul = ESTÍMULDOBLE llavorsGenera 1 estímul extra idèntic al estímul objectiu

FisiSi ModalitaEstímul = ESIMULTRIPLE llavors

Genera 2 estímuls extra idèntics al estímul objectiuFisi

Farem el mateix que amb el primer objecte fFind , i en crearem 1 o 2 més segons les necessitats, anomenats fFind2 ,fFind3.

Així ja tindrem tot el taulell complert dibuixat. Per fer-nos una idea, es presenta una copia d’una pantalla (Figura 18) de joc, durant una partida.

Com a dades importants ja només ens faltarà explicar el control d’events del taulell, generat pel usuari/pacient. Hem creat la classe estímulClick(int x, int y) on x,y seran les coordenades clicades. I la seva funcionalitat serà esbrinar si l’estímul clicat, és o no un dels estímuls diana, ( fFind , fFind2 , fFind3) en conseqüència , sumar els encerts o les

38

equivocacions, i afegir un intent a les nostres variables de control (corrects , incorrects , attemps ).

Figura 18. Exemple de joc amb la modalitat Estímul Triple

Al finalitzar la funció llençarà el mètode clickControl(event) , per a que s’encarregui de crear el feedBack corresponent damunt de l’estímul . Els resultats possibles són :

- Correcte : llençarà el tick verd- Incorrecte : llençarà la creu vermella- Omissió: llençarà l’interrogant blanc

Acabarem parlant de la classe principal (Aparellament.java), on trobarem alguns paràmetres afegits, per poder realitzar la tasca.

Aparellament.java

Variables de control de la tasca:

GameTimer clock Timer timer TableGame tGameint level int numGames boolean waitResultsboolean runboolean stop

Cal destacar que timer és un rellotge generat per escoltar a GameTimer ja que per si sol, GameTimer genera els events dins d’ell , i algú te que relacionar-lo amb la classe principal.

tGame serà el taulell que ja hem explicat. Level és el nivell seleccionat, el desem per tenir una referència de quin nivell estem realitzant, i poder augmentar-lo automàticament.

39

numGames serà el nombre de jocs que es realitzarà a cada nivell.Per començar una partida executarem el següent codi:

first = false; //primer pastGame.fullTable(); // omple el taulelltGame.setFirst(false); // deixa de ser el primer pasclock.setTotalTime(tGame.getTemps()); //afegim temps de jocclock.iniTimer(); // incialitzaem el rellotgetimer.scheduleAtFixedRate(timerTask, 0, 1000);waitResults = false; // no esperem resultats

Un cop començada la partida el mètode loadScreen, només es dedicarà a anar dibuixant el taulell i l’estímul objectiu.

Els events click de ratolí seran enviats cap al taulell per a ser tractats.

L’objecte Timer creat apart del GameTimer, tindrà el seu TimerTask dins de la classe principal, i respondrà de la següent manera

TimerTask de Timer

Si ModalitatDeTasca = Exercici Llavors // 300 SegonsSi Gametimer = finalitzat I EsperemResultats Llavors

Finalitzem la tasca i enviem al usuari/pacient als resultats.Fisi

Fisi

Si ModalitatDeTasca = Competicio LlavorsSi GameTimer = finalitzat Llavors // 45 Segons

Oponent troba l’estímul objectiuSi NoQuedenMesPeces Llavors

Finalitzem la tasca i enviem al usuari/pacient als resultatsSino

Incialitzem GameTimer a 0 i continuem el jocFisi

FisiFisi

Fi TimerTask

La condició indispensable per a que es pugui executar el joc, es a dir, per a que l’objecte Aparellament pugui crear-se, és que el seu nivell estigui entre els valors 1 i 36 tots dos inclosos al rang.

4.3.3 Arxiu references.txt

@TASK INFO

TASKNAME = AparellamentFUNCTION = AtencioSUBFUNCTION = Selectiva

@PARAMS

40

PARAMNAME1 = LevelPARAMTYPE1 = integer

@RESULTS

RESULTNAME1 = CorrectsRESULTTYPE1 = integer

RESULTNAME2 = OmissionsRESULTTYPE2 = integer

RESULTNAME3 = ErrorsRESULTTYPE3 = integer

RESULTNAME4 = TimeRESULTTYPE4 = integer

Codi que generarà els resultats a partir de les variables donades.

public void setXmlFile() {xml.addResult("Corrects", Integer.toString(tGame.getCorrects()))xml.addResult("Incorrects", Integer.toString(tGame.getCorrects()))xml.addResult("Omisions", Integer.toString(tGame.getOmissions()))xml.addResult("Time",Double.valueOf(clock.getTotalTicks()).toString())if ((tGame.getCorrects() + tGame.getCorrects()) > 0)

xml.setThreshold(Integer.toString((tGame.getCorrects() * 100)/ (tGame.getCorrects() + tGame.getCorrects())));

elsexml.setThreshold(Integer.toString(0));xml.buildOutFile("out.xml");

}}

4.4 Zigurat

L’objectiu d’aquest joc és fer desaparèixer totes les cartes que formen les tres piràmides que hi ha a la pantalla. Per tal d’aconseguir-ho, has d’aparellar la carta que hi ha a la part inferior de la pantalla amb una carta de qualsevol piràmide. Ara bé, només es poden aparellar quan la carta de la piràmide és la immediatament superior o inferior a la carta de la part inferior de la pantalla. Hi ha un temps limitat per fer desaparèixer totes les cartes.

4.4.1 Problema clínic a estudi

Dificultat o incapacitat per adaptar la conducta en funció de les variacions que es produeixen a l’entorn, o bé en funció de necessitats del subjecte.El subjecte ha d’alterar la seva execució en funció de les demandes de la tasca.

4.4.2 Descripció de la tasca

La pantalla presentada és de fons blanc. A la pantalla es distribueixen formant 3 piràmides -10 cartes per piràmide-. (veure croquis)

41

A la part inferior de la pantalla es mostra una carta cap amunt (l’anomenarem carta X) i a la seva esquerra una baralla formada per 21 cartes (a la part superior s’indica el número de cartes que resten per acabar la baralla). Cada vegada que el subjecte cliqui a sobre de la baralla a la dreta d’aquesta es mostra la carta seleccionada.

El subjecte ha d’aconseguir aparellar la carta X amb alguna de les cartes que formen la piràmide. Per poder fer això s’ha de complir la següent regla: la carta aparellada ha de ser la immediatament superior o inferior a la carta X (p. exemple. Si la carta X correspon a un 5 podré aparellar aquelles cartes que siguin 4 o 6). En el moment que una carta és aparellada automàticament és eliminada.

L’eliminació de cartes segueix un ordre. S’ha de començar per la base de qualsevol de les 3 piràmides per anar pujant progressivament.

Las cartes utilitzades són les del pòquer (A, 2, 3, 4, 5, 6, 7, 8, 9, 10, J, Q, K).

La partida s’acaba si:- el subjecte aconsegueix fer desaparèixer totes les cartes que formen cadascuna de

les tres piràmides. A la part superior de la pantalla s’indica “Has guanyat!”- o bé quan s’exhaureix el temps màxim establert (1 minut i 45 segons). A la part

superior de la pantalla s’indica “Has perdut”

L’ordre de presentació de les cartes a les tres piràmides ha de ser diferent per a cada partida

NOTA: a l’hora d’aparellar cartes, es considera que immediatament per sota de la K hi ha la Q i immediatament per sobre la A.

Nivells de dificultat

L’increment de la dificultat s’estableix a partir de dos paràmetres:

- Nivell de dificultat:

o Nivell baix

o Nivell mig

o Nivell alt

- número de partides:

o 1 partida

o 5 partides

o 10 partides

Quan es tria l’opció 5 o bé 10 partides es considera que si el temps límit s’esgota el jugador ha perdut la partida. Així, aquestes opcions (5 o 10 partides) funcionen com un torneig. En

42

el cas de triar 5 partides, si el subjecte guanya 3 partides es considera que ha guanyat a la màquina (respecte a la opció 10 partides parlaríem de 6 partides guanyades). En la opció 5 partides, en el moment que el subjecte guanya o perd 3 partides s’acaba la tasca (en el cas de la opció 10 partides si el subjecte guanya o perd 6 partides s’acaba la tasca).

Paràmetres quantificables1. número d’encerts

2. número d’errors

3. percentatge de respostes correctes (PRC) respecte al total de respostes donades pel subjecte.

4.4.3 Descripció de les classes de la tasca

Les classes creades per realitzar aquesta tasca són les següents:

- card.java

- deckCards.java

- enums.java

- progressBar.java

- pyramid.java

- Zigurat.java

- ziguraTable.java

Explicarem primer les classes petites on es contindrà la informació del joc.

Enum.java

Dins d’aquesta classe crearem dos enumerats, anomenats Rank i Suit. El Rank seran els números de les cartes, en modalitat text , numèrics i lletra que ocupen dins de la baralla. Així ja tindrem tota la informació que necessitem per muntar les cartes.

L’enumerat Rank contindrà un constructor, per a que cada enumerat pugui contenir més d’un valor, i dos atributs, per poder emmagatzemar aquests valors. En canvi Suit, només tindrà que tenir el nom dels quatre pals.

Codi d’exemple per demostrar la classe enumerada:

public class enums {public enum Rank {

TWO(2,"2"), THREE(3,"3"), FOUR(4,"4"), FIVE(5,"5"), SIX(6,"6"), SEVEN(7,"7"), EIGHT(8,"8"),NINE(9,"9"), TEN(10,"10"), JACK(11,"J"), QUEEN(12,"Q"), KING(13,"K"), ACE(14,"A");

43

private int value;private String strValue;Rank(int val,String strValue){ this.value = val; this.strValue = strValue;}public int getValue(){

return value;}public String getStrValue(){

return this.strValue;}

}

public enum Suit {CLUBS, DIAMONDS, HEARTS, CLOVER

}

}Card.java

En aquesta classe es guarda la informació de cada carta (pal,valor...), i també s’afegeixen dues referències a la mateixa classe, que ens ajudaran en una de les parts del joc, a saber què tenim sota de cada carta.

Atributs de la classe:

Card refCardLeft;Card refCardRight;double fPos[];Rank rank;Suit suit;

Rank i Suit són els valors de carta , que ja hem vist a la classe d’enumerats. fPos[] és el vector de doubles que cont la posició de la carta per dibuixar-se per pantalla.

El que m’agradaria remarcar es que refCardLeft i refCardRight són referències a classes del mateix tipus (Card) . Una de les regles d’aquest joc, és que una carta només pot ser escollida si està lliure, és a dir, que no es poden escollir cartes que immediatament a sota ni hagi una altra. Per poder controlar aquest problema , hem decidit crear les dues referències (Figura 1Figura 19).

44

Figura 19. Exemple de referències d’una piràmide

Com es pot observar, si cada fletxa representa una referència d’una carta a una altra, només podrem utilitzar les cartes on les seves referències siguin nul·les.El constructor de la classe pyramid s’encarrega de crear aquestes referències, que ja veurem més endavant.

La resta de mètodes seran de llegir i escriure atributs.

DeckCard.java

L’anomenem així perquè és la nostra baralla de cartes, conceptualment , una baralla de cartes tindrà 52 cartes , 13 per cada pal i 4 pals per baralla, (13 x 4 = 52).

Hem trobat que creant un patro singleton1 , podem crear una baralla i anar-la manipulant des de tots els llocs de igual manera. Això ens ajuda a tenir una única instància de la classe DeckCards, i per tant podem assegurar que durant la partida nomes podrà existir aquesta.

Es mostra el codi amb el que s’ha creat la clase:

1 el patró singleton és un patró de disseny que es fa servir per a restringir la instanciació d'una classe a un objecte. Això és útil quan es necessita exactament un objecte per a coordinar accions a tot sistema. De vegades és generalitzat a sistemes que operen més eficientment quan només un o pocs objectes existeixen. També és considerat un anti-patró ja que sovint és utilitzat com a eufemisme de variable global.

45

public class DeckCards {private static final List<Card> deck = new ArrayList<Card>();static{

for (Suit suit : Suit.values())for (Rank rank : Rank.values())

deck.add(new Card(rank, suit));}public static ArrayList<Card> newDeck() {

return new ArrayList<Card>(deck);}

}

Nomès hem de cridar a newDeck() quan vulguem obtenir una baralla nova ( Una instancia única de la classe).

ProgressBar.java

Necessitem controlar el temps del joc, i l’ usuàri/pacient ha de veure com transcorre el temps. Per manipular aquest conjunt, tenim aquesta classe, que ens dibuixa una barra a la part superior de la pantalla, que s’anirà omplint a mesura que passi el temps.

Aquesta classe extendrà de Timer, proporcionat per java.util.

Es mostra la part que ens dibuixa la progressió , contingut a l’event TimerTask de Timer.

TimerTask timerTask = new TimerTask() { public void run() { if (start==true){

ticks ++;progress = progress + (MAX_TICKS / TOTAL_TIME);scren.drawRect(1000, 50,MAX_TICKS * 2 ,25, Color.LIGHT_GRAY);scren.drawRect(1000, 50, progress * 2 ,25, Color.black);if (ticks==MAX_TICKS){

start = false; finalized = true;}

} }};

On els ticks es generen a cada segon. Al finalitzar, el rellotge deixarà de contar, i posarà finalized a true, per a que la classe principal, pugui saber que ja ha finalitzat.

Pyramid.java

Tenim 3 piràmides amb igual distribució al taulell. Hem creat una classe que a partir d’una coordenada 2D i uns llista de 10 cartes, ens generarà la piràmide demanada.

List<Card> cards;Fullscreen screen;BufferedImage iClubs, iDiamonds, iHearts, iClovers;

46

float width,height;Font GotNormal;double tab = 0.002;

El width i el height són les proporcions de les cartes a dibuixar. La font serà GotNormal, per escriure el contingut de les cartes, i el tab és l’espai que hi haurà entre elles.

Cards és la llista de cartes continguda dins la piràmide, que li serà facilitada des de la classe que manipuli la baralla de cartes.

Necessitem les imatges de les cartes buides (iClubs, iDiamonds, iHearts, iClovers) , per poder completar la imatge que volem presentar al usuari/pacient.

Un cop tinguem tota la informació necessària el constructor de la piràmide ens col·locarà cada carta al seu lloc i li crearem les referències ( setReferences() ) entre elles per controlar les cartes bloquejades.

Exemple de codi per a crear les referències entre les cartes, suposarem que tenim una carta x i per sota d’ella dues cartes , la y i la z.

cards.get(x).setRefCardLeft(cards.get(y));cards.get(x).setRefCardRight(cards.get(z));

I així per a totes les cartes contingudes a les piràmides de la tasca.

Dibuixarem tot el taulell una única vegada ( draw() ), i anirem esborrant les cartes que s’hagin clicat correctament.( clearPaintedCar() ).

Tenim diversos mètodes per controlar els events del taulell, per tal de corregir els moviments que faci l’usuari/pacient. El mètode goodCard() , ens dirà si la carta clicada, es correcta o incorrecta, per a que sigui correcta, ha de complir les següents condicions:

- Card.ReferenciaDreta = null I Card.ReferenciaDreta = null - Card.Valor + 1 = playCard.getValue- Card.Valor - 1 = playCard.getValue- Card.Rank = ACE I playCard.Rank = TWO- Card.Rank = TWO I playCard.Rank = ACE

Entenem per Card la carta que ha estat clicada, i per playCard, la carta que esta en joc.S’ha de complir per necessitat la primera condició i una de les 4 següents, si no, la carta clicada és incorrecta.

ziguratTable.java

Atributs més rellevants per al funcionament del taulell:

Pyramid p1,p2,p3,pyramidSelected;List<Card> playCard;Fullscreen screen;final float COORDX = 0.2f;final float COORDY = 0.2f;

List<Card> deck ;private int corrects,incorrects,omisions;

47

private double totalTime;

S’haurà de inicialitzar les variables i el objectes al començar la partida amb el següent codi:

public void newGame() { deck = DeckCards.newDeck(); // creem baralla estatica Collections.shuffle(deck); //desordenem la baralla try { p1 = new Pyramid (COORDX,COORDY,deal(deck,10),screen);

p2 = new Pyramid (COORDX+ 0.3f,COORDY, deal(deck,10),screen);p3 = new Pyramid (COORDX + 0.6f,COORDY ,deal(deck,10),screen);playCard = deal (deck,1);

} catch (Exception e) { } first =true;}

Crearem una instància de DeckCards, és a dir, una baralla, i la desordenarem amb la funció Shuffle de Collections proporcionada per java. Després crearem tres piràmides a partir d’unes coordenades bàsiques ( COORDX , COORDY ), i una llista de 10 cartes que extraurem de la baralla. Per últim inici la carta en joc ( PlayCard), extraient una carta de la baralla.

Per extraure cartes de la baralla i fer que desapareguin d’ella, hem utilitzat la funció deal (baralla,nombre de cartes). Mitjançant el mètode subList de la classe List i després fent un clear de la subList.

public static ArrayList<Card> deal(List<Card> deck, int n) { int deckSize = deck.size(); List<Card> handView = deck.subList(deckSize-n, deckSize); ArrayList<Card> hand = new ArrayList<Card>(handView); handView.clear(); return hand; }

Ens és de gran utilitat, per simular el repartiment de cartes d’una baralla real.

Tal i com es mosta en la (Figura 20) el taulell conté 3 piràmides p1,p2 i p3 , una baralla de cartes deck i una carta de joc playCard, per a poder fer funcionar la tasca, la resta d’atributs son per situar les piràmides, o per contemplar les respostes correctes, incorrectes o les omissions.

Per controlar la carta clicada, primer cridarem el mètode onArea() que ens extrau la informació necessària de la carta escollida. Necessitem saber a quina piràmide pertany o si pel contrari s’ha clicat a la baralla de cartes restants, per canviar la carta en joc.

Un cop sapiguem on esta la carta podrem corregir-la amb checkCard() que s’ajudarà de checkCard() , que ens farà la funció de corrector. Si la carta és correcta li direm a la piràmide, que esborri la carta i les referències que apunten a ella. Sumarem un encert, en cas contrari sumarem una equivocació i no variarem cap element del taulell.

48

Figura 20. Exemple dels componets del taulell

Quan ja no quedin més cartes a la baralla restant, ens quedarà una carta en joc i les que encara no s’hagin eliminat de les baralles. En aquest punt haurem de controlar que quedin possibilitats de joc. Com a mínim hi ha d’haver una carta que pugui ser correcta. Tenim el mètode anyPossibilityCard() que ens retornarà true si encara queda alguna carta correcta o false en cas contrari.

Zigurat.java

Conté el taulell , els events del joc , el temporitzador i les variables que controlen el nombre de partides realitzades, guanyades i perdudes.

int numGames;int winGames,loseGames;ZiguratTable zt;ProgressBar timeProgress;

Timer timerControl; boolean gameFinalized = false;

boolean fi = false;

Per validar les jugades farà referència al mètode onArea() de la classe taulell.

L’element de control del joc que cal explicar amb deteniment és el timerTaskZigurat de la classe Timer . On està representat el funcionament principal de la partida. Amb aquest podrem manipular el nombre de partides jugades, guanyades i perdudes, per poder finalitzar la partida al moment que li toqui, en funció del paràmetre numGames.Una explicació en pseudocodi de la implementació del mètode Run de timerTask.

Si No ha finalitzat la Partida LlavorsSi No Queda cap Carta a la Baralla I No Queden Possibilitats Llavors

49

Finalitzem la partida

Comptabilitzem una derrota

FisiSi No queda cap carta a les piràmides Llavors

Finalitzem la partida

Comptabilitzem una victòria

FisiSi s’acaba el temps Llavors

Finalitzem la partida

Comptabilitzem una derrota

FisiFisi

Si Ha finalitzat la Partida Llavors Si queden jocs per disputar Llavors

Acumulem els resultats obtinguts

Nova Partida

SinoAcumulem Resultats

Finalitzem el joc

Pantalla de Resultats

FisiFisi

4.4.4 Arxiu references.txt

@TASK INFOTASKNAME = ZiguratFUNCTION = ExecutivesSUBFUNCTION = Planificacio

@PARAMS PARAMNAME1 = NumGamesPARAMTYPE1 = integer

PARAMNAME2 = LevelPARAMTYPE2 = integer

@RESULTSRESULTNAME1 = CorrectsRESULTTYPE1 = integer

50

RESULTNAME2 = OmissionsRESULTTYPE2 = integer

RESULTNAME3 = ErrorsRESULTTYPE3 = integer

RESULTNAME4 = TimeRESULTTYPE4 = double

Funcio que genera l’archiu out.xml :

public void setXmlFile(){ int corrects = zt.getCorrects(); int incorrects = zt.getIncorrects(); int omissions = zt.getTotalOmisions(); double time = zt.getTotalTime();

xml.addResult("Omissions", Integer.toString(omissions));xml.addResult("Errors", Integer.toString(incorrects)); xml.addResult("Corrects", Integer.toString(corrects)); xml.addResult("Time", Double.toString(time));

if ((corrects+incorrects)>0){xml.setThreshold(Integer.toString((corrects*100)/(corrects+incorrects)));

}else{ xml.setThreshold(Integer.toString(0));

}xml.buildOutFile("out.xml");

}

4.5 Sèrie cíclica

4.5.1 Problema clínic a estudi

Dificultat o incapacitat per organitzar els passos a seguir per tal de desenvolupar una tasca. El subjecte ha d’esbrinar el color dels rombes que estan en blanc.

4.5.2 Descripció de la tasca

La pantalla que es mostra al usuari/pacient té un fons de color blanc. Al mig de la pantalla es presenta una seqüència de rombes de diferents colors. El 25% d’aquest rombes no tenen color (blanc). Colors dels rombes: taronja, groc, blau, verd i negre. El programa ha de generar seqüències aleatòries (depenen de la llargada de les mateixes –veure apartat nivells de dificultat– ) deixant un 25% dels rombes sense color. Per cada exercici les seqüències es repeteixen (és a dir, si la matriu està formada per 100 rombes i la longitud de la sèrie 5 elements llavors tindrem 20 sèries, totes elles iguals). En el cas que la combinació entre matriu i longitud de la sèrie generi números amb decimals la seqüència de rombes es

51

completa amb el fragment de sèrie corresponent. Per exemple, matriu de 7x7 amb series de longitud 5, genera 5,4 series.

A la dreta de la pantalla es mostren els diferents colors dels rombes (veure mostra tasca). El subjecte selecciona d’aquest colors el que cregui correspon al rombe en blanc. El subjecte es pot col·locar a sobre de qualsevol rombe blanc (queda ressaltat per tal de la seva identificació) i seleccionar de la llista de la dreta el color corresponent. En aquest moment el rombe blanc es posa del color indicat.

Els botons que apareixen en pantalla son els següents: sortir, ajuda, corregir i borra.

Un cop el subjecte ha omplert de color tots els rombes blancs ha de prémer el botó “corregir” per tal de saber si ho ha fet correctament. En cas de voler rectificar (i sempre abans de donar al botó “corregir”) el subjecte pot clicar “borra” i tornar a omplir els rombes. El subjecte pot clicar “borrar” tantes vegades com vulgui. En el moment que clica “corregir” automàticament desapareixen els botons “corregir” i “borrar”, apareixent el botó “Continuar”.

Instruccions

A continuació es presenta una seqüència de rombes de diferents colors. S’ha d’indicar quin hauria de ser el color dels rombes en blanc. Per seleccionar el color corresponent cliqui a sobre de la llista de colors que apareix a la dreta de la pantalla.

Nivells de dificultat

L’increment de la dificultat s’estableix a partir dels següents paràmetres:

- Dimensions de la matriu: 7x7, 8x8, 9x9, 10x10- Longitud de la seqüència: 5, 6, 7, 8 i 9

Paràmetres quantificats

- número d’encerts (s’entén número d’encerts com la quantitat d’estímuls diana seleccionats correctament).

- número d’errors (s’entén número d’errors com la quantitat d’estímuls no-diana seleccionats)

- percentatge de respostes correctes (PRC) respecte al total de respostes donades pel subjecte.

4.5.3 Descripció de les clases utilitzades

- colors.java- estimul.java- estimulGraella.java- funcions.java

52

- matrix.java- sequencia.java- sequenciaItem.java- taulell.java- SerieCiclica.java

Colors.java

És un enumerat que implementa la interficie comparable , per construir els valors necessaris per manipular-lo, hem afegit dos atributs.

Cada enumerat tindrà el nom d’un color, un valor i un Color de java.awt.Color.

public enum Colors implements Comparable<Colors> {TARONJA(0, Color.ORANGE), GROC(1, Color.YELLOW), BLAU(2, Color.BLUE), VERD(3, Color.GREEN), NEGRE(4, Color.BLACK), BLANC(5, Color.WHITE);

private int value;private Color color;private Colors(int value, Color color) {

this.value = value;this.color = color;

}}

Funcions.java

S’ha cerat una classe estàtica, amb varis mètodes per ajudar-nos a convertir punts de pantalla absoluts de [0 - 1] en punts de pantalla concrets a la resolució establerta pel usuari/pacient .

Es pot demanar la conversió des d’un vetor de double[] o directament des d’ un valor en concret.

public static int[] transformaX(double[] x, Fullscreen s) {int[] vectorX = new int[x.length];for (int i = 0; i < x.length; i++) {

vectorX[i] = (int) (x[i] * s.getWidth());}return vectorX;

}

public static int transformaX(double x, Fullscreen s) {return (int) (x * s.getWidth());

}

public static int[] transformaY(double[] y, Fullscreen s) {int[] vectorY = new int[y.length];for (int i = 0; i < y.length; i++) {

vectorY[i] = (int) (y[i] * s.getHeight());}return vectorY;

}

53

public static int transformaY(double y, Fullscreen s) {return (int) (y * s.getHeight());

}}

Matrix.java

Igual que la explicada al principi del desenvolupament. Ens ajuda a dividir el taulell en NxM posicions.

SequenciaItem.java

Conté les atributs que formaran cada element de la seqüència, i un mètode per poder dibuixar aquets elements.

Colors color;String label;double[] coord;

Els ítems de la seqüència necessiten tenir un color, que li proporcionarem des de l’enumerat Colors, una label que ens dirà el nom del color i unes coordenades que el situaran dins del joc.

El mètode draw(FullScreen screen) ens dibuixa un rectangle , del color de l’ítem , transformant les seves coordenades delimitades per els valors [0 - 1], en coordenades corresponents a les resolucions utilitzades.

Sequencia.java

La seqüència és el conjunt de SequenciaItem[] que s’han d’anar col·locant als estímuls. Pot ser de diferents longituds (nSeq), segons ho requereixi la partida (transparent per aquesta classe), però el nombre de colors que conté serà fix.Els atributs d’aquesta classe es presenten a continuació:

SequenciaItem[] items;Matrix matrix;double table[] = { 0.8, 0.99, 0.3, 0.75 };int nSeq;

S’ha implementat uns mètodes per ajudar al funcionament de la tasca, tan com per fer correccions , com per dibuixar tota la seqüència.

Els mètodes de correcció s’han enfocat des de dos punts vista, ja que podem necessitar saber quin color seria el correcte en cada posició, enviant com a paràmetre la posició i rebent el color demanat ( A l’hora d’inicialitzar una partida o necessitarem per anar dibuixant els estímuls base), o per contra preguntar si un color i una posició són correctes ( quan necessitem corregir la partida).

public Colors getCorrectColor(int position) {return items[((position % nSeq) % items.length)].getColors();

}

public boolean isCorrect(Colors c, int position) {

54

if (c.getValue() == (items[(position % nSeq) % items.length].getColors()).getValue()) {

return true;} else {

return false;}

}

Estimul.java

Els estímuls són en aquest joc, els rombes presentats per pantalla, tan els que hem d’esbrinar com els que se’ns proporcionen de pista.La informació que necessitem per manipular-los es la següent:

Colors color;double pos[];int x2Datos[];int y2Datos[];boolean isItemHidden;

Cada estímul té un color, per poder-se dibuixar, una posició per dibuixar-se per patanlla i una boleana isItemHidden, que ens indica si es un element a descobrir, o ja esta descobert. En cas que l’hagués de descobrir, el dibuixarem blanc, en cas contrari el dibuixarem del color que l’indica l’atribut.

Ell mateix, s’haurà de dibuixar, quan el taulell li demani, per a tal , s’implementa el mètode draw() i redraw() , per poder-lo dibuixar.

Draw() dibuixarà l’element al taulell que li demani, i redraw() l’utilitzem per esborrar-lo i així no crear el parpelleig ( Flicker ) .

El codi del mètode draw() :

public void draw(Fullscreen screen) {Graphics2D g = (screen.getBufferStrategy().getDrawGraphics();transform(screen, x2Datos, y2Datos);g.setColor(color.getColor());g.fillPolygon(x2Datos, y2Datos, 5);g.setColor(Colors.NEGRE.getColor());g.drawPolygon(x2Datos, y2Datos, 5);

}

El codi del mètode reDraw() :

public void redraw(Fullscreen screen) {Graphics2D g = screen.getBufferStrategy().getDrawGraphics();int x1 = Funcions.transformaX(getPosition()[0], screen);int y1 = Funcions.transformaY(getPosition()[2], screen);int width = Funcions.transformaX(getPosition()[1], screen)

- Funcions.transformaX(getPosition()[0], screen);int height = Funcions.transformaY(getPosition()[3], screen)

- Funcions.transformaY(getPosition()[2], screen);g.setColor(Color.white);g.fillRect(x1, y1, width, height);

55

draw(screen);}

Ja tenint els elements dibuixats per la pantalla, només ens faltarà anar dibuixant el voltant de l’estímul objectiu per a que ressalti sobre els altres . Utilitzem el mètode paintSelected().

public void paintSelected(Fullscreen screen) {int x2Datos[] = new int[5];int y2Datos[] = new int[5];Graphics2D g = screen.getBufferStrategy().getDrawGraphics();transform(screen, x2Datos, y2Datos);BasicStroke bs = new BasicStroke(6.0F, BasicStroke.CAP_BUTT, BasicStroke.JOIN_BEVEL);g.setColor(Color.BLACK);g.setStroke(bs);g.drawPolygon(x2Datos, y2Datos, 5);

}

Ressaltem d’aquest mètode, l’objecte BasicStroke que creem per poder augmentar la grandària del contorn. Ens serveix per manipular la mesura de la “mina” utilitzada. Un cop s’ha creat l’adequat , l’afegim al objecte graphics i dibuixem el contorn.

Sempre buscarem el distància màxima entre els punts per dibuxar-lo i no deformar-lo. A la següent imatge(Figura 21) s’il·lustra la funcionalitat de transform().

Figura 21. Exemple de funcionament de transform()

Per aconseguir rombes que siguin proporcionals a la resolució que s’estigui utilitzant, abans de dibuixar-lo, cridarem el mètode transform() . Ens fa els càlculs necessaris per fer un rombe equitatiu a les seves proporcions, i ens el plasma en el format de resolució desitjat.

estimulGraella.java

56

És el taulell dels estímuls. Té com a objectiu controlar el funcionament correcte dels estímuls. Utilitzarem els següents atributs, per tal d’emmagatzemar tota la informació que ens és necessària.

final double PERCENTATGEBLANC = 0.25;Estimul[][] tauler;Matrix matrix;double table[] = { 0.1, 0.6, 0.15, 0.80 };int rows, cols;int encerts, errors;Estimul estimulSeleccionat;

La constant PERCENTATGEBLANC es el nombre de rombes en tan per cent, que hauran d’esser blancs. El taulell (tauler[][]) seran el conjunt d’estímuls que formaran la tasca. Matrix , rows i cols ,les utilitzem per obtenir el nombre concret de coordenades per dibuixar els rombes a partir de les coordenades proporcionades per table[]

Expliquem el mètode iniGraella() que conté la crida als mètodes que ens son més rellevants.

public void iniGraella() {ompleTauler();iniHiddenList();setHiddenList();}

ompleTauler() omple les coordenades del tauler. Per poder diferenciar els estímuls que son objectius per al usuari/pacient , dels que ja es donen resolts, hem creat la funció iniHiddenList() . Aquesta escollirà aleatòriament el tan per cent d’estímuls que haurem d’esbrinar, així que activarà la booleana continguda en l’estímul (isItemHidden) i la tractarà com a tal. Necessitem aquesta variable, per tal de poder esborrar els estímuls objectiu si el usuari/pacient desitgés tornar a començar prement el boto corregir.

Fragment de iniHiddenList on totalItems es el nombre de totals d’estímuls a esbrinar:

while (totalItems != itemsColocats) {x = (int) (rows * Math.random());y = (int) (cols * Math.random());if (!tauler[x][y].isItemHidden()) {

tauler[x][y].setItemHidden(true);itemsColocats++;

}}

Finalment setHiddenList() inicialitzarà aquets estímuls en color Blanc .

Ja tenint explicats els diferents elements continguts dins del taulell principal, descriurem el funcionament del taulell.

Taulell.java

Un taulell (Figura 22) per aquesta tasca tindrà dos atributs diferenciables, una graella d’estímuls i una de seqüència.

EstimulGraella graella;Sequencia sequencia;

57

El constructor ens inicialitzarà els dos atributs.

public Taulell(int n, int m, int s, String[] sColors) {graella = new EstimulGraella(n, m);sequencia = new Sequencia(s, sColors);graella.ompleSequencia(sequencia);graella.iniGraella();

}

Figura 22. Pantalla del taulell de SerieCiclica

Mitjançant getters i setters, podrem instanciar els diferents elements , per tal d’accedir als seus mètodes.

La funció setColorSeleccionat , ens dibuixarà el color de la seqüència que creurem correcte, dins l’estímul seleccionat.

public void setColorSeleccionat(int x, int y, Fullscreen screen) {Estimul estimul = graella.getEstimulSeleccionat();SequenciaItem seq = sequencia.getItemSelected(x, y, screen);

if (estimul != null && seq != null) {Colors c = seq.getColors();estimul.setColor(c);estimul.redraw(screen);estimul.paintSelected(screen);

} }

SerieCiclica.java

Variables per controlar la tasca global:

Taulell tauler;Timer timerControl;int ticks;boolean gameRun;

58

El taulell, contindrà els dos elements bàsics, i a part, tindrem un timer per controlar el temps de realització de la tasca.La variable gameRun, ens pararà el rellotge si en algun moment del joc, volem mirar les instruccions. Quan estiguem jugant, el mètode loadScreen() , es limitarà a instanciar els diferents elements del taulell i dibuixar-los.

tauler.getGraella().draw(screen);tauler.getSequencia().draw(screen);

Per controlar els events de ratolí, utilitzarem el següent mètode.

tauler.setColorSeleccionat(x, y, screen);

on x i y son coordenades de pantalla.

4.5.4 Arxiu references.txt

@TASK INFOTASKNAME = serieCiclicaFUNCTION = ExecutivesSUBFUNCTION = Sequenciacio

@PARAMS PARAMNAME1 = rowsPARAMTYPE1 = integer

PARAMNAME2 = colsPARAMTYPE2 = integer

PARAMNAME3 = longSequenciaPARAMTYPE3 = integer

@RESULTSRESULTNAME1 = CorrectsRESULTTYPE1 = integer

RESULTNAME2 = ErrorsRESULTTYPE2 = integer

RESULTNAME3 = TimeRESULTTYPE3 = double

Funció que omplirà l’arxiu de sortida out.xml:

public void setXmlResult(){int en = tauler.getGraella().getEncerts();int er = tauler.getGraella().getErrors();xml.addResult("Corrects", Integer.toString(en));xml.addResult("Incorrects", Integer.toString(er));xml.addResult("Time", Integer.toString(ticks));if ((en+er)>0) xml.setThreshold(Integer.toString((en*100)/(en+er)));else xml.setThreshold(Integer.toString(0));

59

xml.buildOutFile("out.xml");}

4.6 Imatges Progressives

4.6.1 Problema clínic a estudi

Dificultat o incapacitat per organitzar els passos a seguir per tal de desenvolupar una tasca. El subjecte ha d’ordenar diverses figures en una seqüència.

4.6.2 Descripció de la tasca

La pantalla que es mostra a l’usuari/pacient té un fons de color blanc. A la part central de la pantalla es presenta una seqüència de figures desordenada.

El programa ha de permetre que el subjecte ordeni la seqüència començant per un extrem de la seqüència o bé l’altre (així per exemple el subjecte pot ordenar la seqüència de la següent forma fig1, fig2, fig3, fig4, com d’aquesta altre fig4, fig3, fig2, fig1).

El programa ha de generar seqüències aleatòries (depenen de la llargada de les mateixes)

Número de passos de la seqüència: mínim: 5 figures – màxim:10 figures.

Cada tasca està formada per 5 seqüències (totes elles de la mateixa longitud).

El subjecte ha d’ordenar les figures clicant amb botó esquerra del ratolí a sobre de la figura que vol moure i arrossegant-la al lloc on la vol col·locar (automàticament la figura que ocupava aquesta ubicació ocupa el lloc de la primera). (veure mostra tasca).

Els botons que apareixen en pantalla son els següents: sortir, ajuda, corregir i borra.

Un cop el subjecte creu tenir la seqüència construïda a de prémer el botó “corregir” per tal de saber si l’ha construït correctament.

En cas de voler rectificar (i sempre abans de donar al botó “corregir”) el subjecte pot clicar “borra” i tornar a ordenar les figures. El subjecte pot clicar “borrar” tantes vegades com vulgui. En el moment que clica “corregir” automàticament desapareixen els botons “corregir” i “borrar”, apareixent el botó “continuar”.

Nivells de dificultat

L’increment de la dificultat s’estableix a partir dels següents paràmetres:

- Augment del número de figures que formen la seqüència (de 5 a 10 figures).

Paràmetres quantificables1. número d’encerts

60

2. número d’errors

3. percentatge de respostes correctes (PRC) respecte al total de respostes donades pel subjecte.

4.6.3 Descripció de les classes utilitzades

-Estímul.java-Funcions.java-ImatgeProgressiva.java-Matrix.java-Taulell.java-ImatgesProgressives.java

Estímul.java

Es l’objecte que conté la informació dels ítems integrats a les seqüències d’imatges. Per tal de emmagatzemar la informació , generem els següents atributs:

double pos[] = new double[4];ImageProgressiva image;int value;

El vector de posicions pos[] conté les coordenades de cada estímul. La ImageProgressiva image contindrà la imatge a dibuixar, i el value serà el valor que ens dirà la posició que ocupa aquest element dins de la seqüència, i no té perquè ser correcta.

Cada estímul ha de tenir la característica de poder-se dibuixar a ell mateix, per això conté tots els atributs necessaris per a fer-ho, al igual que ha de poder corregir-se. Per dibuixar-se hem implementat el mètode draw() i reDraw() , per poder manipular-les. Draw() dibuixa la imatge , i reDraw() l’esborra.

Funcions.java i Matrix.java

Ja han estat explicades en les tasques anteriors, i no han patit cap modificació.

ImageProgressiva.java

Implementarà dos atributs per tal d’identificar cada imatge amb el seu valor de posició correcta. Així a l’hora de corregir, només s’haurà de comparar aquet valor, amb el contingut dins da cada element del arrayList.

int value;BufferedImage image;

Cada ImageProgressiva es carregarà ella mateixa la seva pròpia imatge, obtenint el basepath pasat per parametre:

image = ImageIO.read(new File(basePath + "/" + value + ".jpg"));

Tots aquets elements seran instanciats fora de la classe.

61

Taulell.java

El taulell és l’encarregat de controlar totes les variacions que pugui anar patint a causa dels events de ratolí. Per poder fer-ho robustament, implementa els següents atributs.

ArrayList<Estimul> tauler;Matrix matrix;double table[] = { 0.15, 0.9, 0.3, 0.63 };static Estimul estimulDragged = new Estimul();static Estimul estimulOver = new Estimul();static Estimul stackDragged,stackOver;

int corrects,incorrects;int nEstimuls;

Matrix i table, s’ajudaran per crear les diferents divisions del taulell, i aportar les coordenades a les imatges, contingudes als estimuls de tauler.

Creem varis estímuls (estimulDragged, estimulOver, stackDragged, stackOver) per controlar-ne les posicions, i poder variar-les.

Les variables corrects i incorrects , són comptadors d’encerts i errors a l’hora de corregir. La longitud de la seqüència està delimitada per nEstímuls que són el nombre d’estímuls.

Tenim varis mètodes per poder manipular el joc al nostre gust. Els primers que utilitzarem son els d’inicialització . Per omplir el taulell ( iniGraella() ) , per desornar-lo abans de començar cada partida , utilitzem desordenaTauler() i per dibuixar-lo per pantalla el mètode draw(). Un cop ja estiguin tots elements carregats, podem començar a explicar els mètodes que faran funcionar el taulell en temps de joc.

Els mètodes emprats, els anomenarem press(), que l’executarem quan es produeixi un event de ratolí, més en concret del botó esquerre del ratolí . El mètode released(), es posara en marxa quan soltem el boto de ratolí. I durant els events d’arrastra, s’executarà drag().

Codis per explicar el funcionament d’aquets tres mètodes:

public void press(int x, int y, Fullscreen screen) {for (Estimul e : tauler) {

if (screen.isInArea(x, y, e.getPosition())) {estimulDragged.copy(e);estimulOver.copy(e);stackDragged = estackOver = e;return;}

}}Quan cliquem ens interessa emmagatzemar l’element clicat, per després poder arrossegar-lo, així que el guardarem en estimulDragged, i com en aquest moment també serà l’element sobre el que estem, l’emmagatzemarem a estimulOver. Inicialitzem els dos apuntadors, que ens serviran per anar recorrent amb l’element clicat ( stackOver,stackDragged ).

public void drag(int x, int y, Fullscreen screen) {if (estimulDragged == null) {

62

return;}for (Estimul e : tauler) {

if (screen.isInArea(x, y, e.getPosition())) {if (stackOver==e) {

return;}stackOver.swap(estimulOver);stackOver.redraw(screen);estimulOver.copy(e);stackOver = e;break;

}}if (estimulOver == null || stackOver == null) {

return;} stackOver.setImage(estimulDragged.getImage());stackOver.redraw(screen);

}

Cada moviment realitzat des de la classe principal amb el botó esquerre del ratolí premut, ens genera un event dragged que executa aquest codi. El que farem primer que res és comprovar que s’ha canviat d’element, si no, no farem res. En cas de d’haver canviat, farem el canvi de variables, per resituar-ho tot.

Ens ajudem amb la classe swap continguda als estímuls. Primer canviem stackOver, que és el punter que apunta al anterior element, i l’hem d’actualitzar per l’actual estímul, informació continguda al estimulOver. Un cop canviat , redibuixem l’element. Fem una copia del estimulOver sobre la variable e i igualarem la referència de e amb stackOver.

Un cop fets aquets canvis, ens mancarà refer la informació de stackOver, que ha de contenir la imatge estimulDragged.

Es presenten un seguit de 3 d’imatges (Figura 23, Figura 24 i Figura 25), intentant simplificar aquet procés per entendre millor la idea del canvis.

protected void released (Fullscreen screen){try {

stackDragged.setImage(estimulOver.getImage()); stackDragged.redraw(screen);

} catch (Exception e) {System.out.println("No Card Drop");

}

}

Capturem el possible event, que espodria podruir, si el stackDragged fora null, ja que estariem fent un released fora del taulell.

Presentació en imatges del canvis :

Els estímuls Dragged i Over , són objetectes ImegeProgressiva. Els stacks Dragged i Over, son apuntadors aquets objectes.

63

Figura 23. Event Released

64

Figura 24. Event Dragged

Figura 25. Event Released

65

Gracies aquets canvis de 3 fases, podem arrossegar les figures pel taulell lliurement, aixi que ja queda explicada la classe taulell.java.

ImatgesProgressives.java

S’encarrega de carregar tots els elements , ( tauler , imatges ...) i controlar les partides realitzades correctament i incorrectament, per després donar els resultats.Atributs creats per controlar aquests variables de tasca.

Taulell tauler; int nEstimuls; boolean next; int nGames; int totalCorrects; int totalIncorrects;

Destacarem la funció loadImages() que depenent de la llargada de la progressió, agafarà imatges d’un package o d’un altre, els package existents són un per cada possible nivell [5 – 10] tots dos inclosos.

Events que llençarà la classe principal cap al taulell:

1 . Cuan fem un press

Public void mousePressend (Event e){if (!next){

tauler.press(e.getX(), e.getY(), screen); }

}

2. Quan arrosseguem per la pantalla

public void mouseDragged(MouseEvent arg0) {if (currentScreen == GAME_SCREEN && !next) {

if (screen.isInArea(arg0.getX(), arg0.getY(), tauler.getTable())) {

tauler.drag(arg0.getX(), arg0.getY(), screen);} else {

tauler.released(screen);}

}}

Si mentre arrosseguem ens sortim de les coordenades del taulell, ho entendrem com si haguéssim fet un released. Es una desició de disseny modificable.

3. Quan soltem el botó del ratolí

public void mouseReleased(MouseEvent e) {if (currentScreen == GAME_SCREEN && !next)

if (screen.isInArea(e.getX(), e.getY(), tauler.getTable())) tauler.released(screen);

}}}

66

La resta de codi s’encarregarà de controlar els resultats generats en cada joc de la tasca.

4.6.4 Arxiu references.txt

@TASK INFO

TASKNAME = ImatgesProgressivesFUNCTION = ExecutivesSUBFUNCTION = Sequenciacio

@PARAMS

PARAMNAME1 = NumFiguresPARAMTYPE1 = integer

@RESULTS

RESULTNAME1 = CorrectsRESULTTYPE1 = integer

RESULTNAME2 = ErrorsRESULTTYPE2 = integer

Codi que genera l’arxiu de sortida al servidor out.xml

public void setXmlResult() {xml.addResult("Corrects", Integer.toString(totalCorrects));xml.addResult("Incorrects", Integer.toString(totalIncorrects));if (((totalCorrects + totalIncorrects) > 0))

xml.setThreshold(Integer.toString((totalCorrects * 100)/ (totalCorrects + totalIncorrects)));

elsexml.setThreshold(Integer.toString(0));xml.buildOutFile("out.xml");

}}

5 Avaluacions

A continuació realitzarem les avaluacions de cada tasca, compilant-la desde l’eclipse. Es mostraran els arxius in.xml creats i mostrarem els arxius out.xml acompanyat de les impressions de pantalla.

5.1 Enfosar la flota

Entrada de parametres mitjançant l’arxiu in.xml

<PARAMETERS>

67

<PARAM PARAMNAME="level" PARAMVALUE="1" /> </PARAMETERS>

El parametre level igual a 1 correspon al nivell MIG .

El primer pas del joc (Figura 26) consiteix en col·locar els vaixells situats a la dreta segons ens assembli. La col·locació dels vaixells en vertical i horitzontal, es fara seleccionat-los amb el boto dret o esquerra , per tal de poder col·locarlos en vertical i horitzontal.

Figura 26. Pantalla de Colocació del vaixells

Situats tots els vaixells en le taulell, premem “ Continuar ” per tal de començar la partida. L’ordinador col·locarà els vaixells aleatoriament. Inicialitzarem el temporitzador per tal controlar els temps de la partida (Figura 27).

Figura 27. Pantalla del joc

68

Ja hem finalitzat la partida. Tal i com apareix el missatge per pantalla “GUANYA L’ORDINADOR ”, per tant hem perdut la patida, en ha faltat trobar un vaixell de dues posicions, mentre qye l’ordiandor ens els ha enfonsat tots.

Un cop acabem la partida podem premer el botó continuar. Aquet ens conduir a la pantalla de resultats(Figura 28) i generara l’arxiu out.xml

Figura 28. Pantalla de resultats

Arxiu out.xml

<RESULTS>

<PARAM RESULTNAME="Threshold" RESULTVALUE="94" /> <PARAM RESULTNAME="TotalDamage" RESULTVALUE="31" /> <PARAM RESULTNAME="Time" RESULTVALUE="148" /> </RESULTS>

5.2 TrencaClosques

Contingut de l’arxiu in.xml

<PARAMETERS>

<PARAM PARAMNAME="rows" PARAMVALUE="3"/><PARAM PARAMNAME="cols" PARAMVALUE="3"/><PARAM PARAMNAME="image" PARAMVALUE="pez.bmp"/>

</PARAMETERS>

La dificultat de la imatge es baixa. Les files i les columnes son iguals a 3. Hem de recordar que un condició bàsica per validar els paramentres, és que les files i les columnes ha de ser d’igual mida.

La pantalla inicial de la tasca, esta completament desordenada (Figura 29). S’ha dissenyat per a que pugui ser reordenada amb el nombre minim de moviments necessitats.

69

Figura 29. Pantalla de joc ( Imatge desordenada)

Ja realitzada la tasca, apareix el boto continuar (Figura 30).

Figura 30. Pantalla de joc ( Imatge ordenada)

S’han necessitat 2 passes mes del màxim , per tant no hem aconsseguit el 100% de la tasca. El temps de realizació ha sigut de 14,9 segons. Aixi queda representada la pantalla resultats (Figura 31)

70

Figura 31. Pantalla de resultats

Contigut de l’arxiu de sortida out.xml

<RESULTS>

<PARAM RESULTNAME="Threshold" RESULTVALUE="100" /> <PARAM RESULTNAME="totalMoviments" RESULTVALUE="7" /> <PARAM RESULTNAME="maxMoviments" RESULTVALUE="9" /> </RESULTS>

5.3 Aparellament

Contingut de l’arxiu in.xml :

<PARAMETERS>

<PARAM PARAMNAME="level" PARAMVALUE="2" /> </PARAMETERS>

Hem escollit executar el level = 2 que correspon als següents parametres :

Nivell : 2Nombre d’estímuls mostrats : 75Grandaria de l’estímul : Doble Modalitat de la tasca : ExerciciTipus d’estimul : Concretes Temps de realització : 300

La primera pantalla del joc (Figura 32), ens apareixeran tots els estímuls desordenats, recordem que al ser estimul Doble, tindrem en tot moment, 2 estímuls iguals al objectiu.

71

Figura 32. Pantalla del joc

Despres d’haber trobat tots els estimuls necessaris per finalitzar la partida, la tasca ens redireccionarà a la pantalla de resultats (Figura 33), monstant les estadistiques aconseguides.

Figura 33. Pantalla de Resultats

Arxiu out.xml:

<RESULTS>

<PARAM RESULTNAME="Threshold" RESULTVALUE="99" /> <PARAM RESULTNAME="Omisions" RESULTVALUE="0" /> <PARAM RESULTNAME="Corrects" RESULTVALUE="75" /> <PARAM RESULTNAME="Time" RESULTVALUE="124.0" /> <PARAM RESULTNAME="Incorrects" RESULTVALUE="1" />

</RESULTS>

72

5.4 Zigurat

Contingut de l’arxiu in.xml

<PARAMETERS>

<PARAM PARAMNAME="NumGames" PARAMVALUE="1"/><PARAM PARAMNAME="Level" PARAMVALUE="1"/>

</PARAMETERS>

Jugarem una partida amb els següents parametres:

• Nombre de jocs = 1• Nivell = 1

En la primera pantalla (Figura 34), tindrem les 3 piramides complertes, ordenades aleatoriament, el temps esta a 0.

Figura 34. Pantalla incial del joc

Figura 35. Pantalla final del joc

73

Hem finalitzat la partida ganyant abans de que s’acabes el temps, ens han sobrat 5 cartes de la baralla restant i uns cuants segons. Com es pot veure apareix el missatge de “ HAS GUANYAT “ (Figura 35)

A la part inferior de la pantalla ens apareix el botó continuar, que ens direcciona a la pantalla de resultats (Figura 36).

Figura 36. Pantalla de resultats

Contingut de l’arxiu out.xml

<RESULTS>

<PARAM RESULTNAME="Threshold" RESULTVALUE="100" /> <PARAM RESULTNAME="Corrects" RESULTVALUE="30" /> <PARAM RESULTNAME="Omissions" RESULTVALUE="0" /> <PARAM RESULTNAME="Time" RESULTVALUE="91.0" /> <PARAM RESULTNAME="Errors" RESULTVALUE="0" /> </RESULTS>

5.5 Sèrie Cíclica

Contingut de l’arxiu in.xml

<PARAMETERS>

<PARAM PARAMNAME="rows" PARAMVALUE="7"/> <PARAM PARAMNAME="cols" PARAMVALUE="7"/> <PARAM PARAMNAME="longSequencia" PARAMVALUE="5"/> </PARAMETERS>

Els paràmetres vindran donats pels següents valors:

Files = 7Columnes = 7

74

Longitud de la seqüencia = 5

En primera instancia (Figura 37) tindrem el 25% dels estímuls, esta buits, per tant seràn els que haurem d’esbrinar.

Un cop creguem que la seqüencia és correcta, premem el botó continuar (Figura 38).

Figura 37. Pantalla incial del joc

Figura 38. Pantalla final del joc

Pantalla de resultats (Figura 39).

75

Figura 39. Pantalla de resultats

Contingut de l’arxiu out.xml

<RESULTS>

<PARAM RESULTNAME="Threshold" RESULTVALUE="83"/> <PARAM RESULTNAME="Corrects" RESULTVALUE="10"/> <PARAM RESULTNAME="Time" RESULTVALUE="51"/> <PARAM RESULTNAME="Incorrects" RESULTVALUE="2"/></RESULTS>

5.6 Imatges progressives

Contingut de l’arxiu In.xml

<PARAMETERS> <PARAM PARAMNAME="NumFigures" PARAMVALUE="6" /> </PARAMETERS>

Durant la partida haurem de completar 5 pantalles de la mateixa longituda de figures. Presentem 3 pantalles de les 5 ( Figura 40, Figura 41 i Figura 42).

Figura 40. Partida numero 1

76

Figura 41. Partida número 2

Paritda 5 i última, despres d’aquesta finalitza el joc.

Figura 42. Partida número 3

Resultats de la partida (Figura 43).

Figura 43. Resultats

77

Arxiu out.xml

<RESULTS>

<PARAM RESULTNAME="Threshold" RESULTVALUE="90" /> <PARAM RESULTNAME="Corrects" RESULTVALUE="27" /> <PARAM RESULTNAME="Incorrects" RESULTVALUE="3" /> </RESULTS>

6 Conclusions

És ben cert que els avenços en matèria didàctica han progressat vertiginosament en els darrers anys. La conscienciació de la necessitat de projectes innovadors, junt amb una societat que aposta cada cop més per la qualitat de vida en tots els sectors, ha portat a la creació de grans grups multidisciplinaris. Aquests, han aconseguit unificar objectius en la consecució de que les eines didàctiques tinguin un caràcter més personalitzat, i accessible, tan per al terapeuta com per al usuari/pacient. D’aquesta manera es faciliten les tasques de tractament, rehabilitació i seguiments posteriors.

El desenvolupament d’aquestes tasques són una petita part d’aquest projecte innovador, una eina que, donades les seves característiques, compleix els requisits de: donar una atenció individualitzada, cobrir les necessitats didàctiques, facilitar el treball al terapeuta, i poder arribar a un nombre major d’usuaris que el que permetria el treball a una aula.

El fet d’haver tingut l’ajuda desde difrents punts , ja sigui pel tutor, com el client proporcionat per fer el projecte, han facilitat en gran mesura el desenvolupament de les tasques, encara que el concepte global d’aquestes fóra unificar conceptes per a conseguir una execució uniforme. Indiferenment de com hem programat cada tasca.

Formar part d’aquest projecte i de tot el que aquest implica, aporta una sensibilització i una aturada a pensar en sectors de la societat que no coneixia en profunditat. No només el fet de fer els jocs com a eina o com a material, sinó el que aquesta representa, on i per a què serà emprada.

7 Recursos utilizats

Per la realitzacio dels objetius, s’han utilizat els següents recursos:

http://www.tottarragona.cat/ca/salut/229-la-urv-la-upc-i-linstitut-guttmann-desenvolupen-una-plataforma-de-neuro-rehabilitacio-per-internet.html

http://www.upc.edu/saladepremsa/al-dia/mes-noticies/el-instituto-guttmann-la-upc-y-la-urv-desarrollan?set_language=es

http://www.universia.es/portada/actualidad/noticia_actualidad.jsp?noticia=98060

78

Per poder descriure les especificacions de disseny s’ha utilitzat :

Creació de tasques de rehabilitació (Proporcionada per la URV)

Durant la realització del projecte, s’han utilitzat les següents referencies:

http://java.sun.com/javase/downloads/index.jsp

http://www.eclipse.org/downloads/

http://www.python.org/download/releases/2.4.4/

- http://www.pygame.org/wiki/index

- Tutorial Java : “Aprendre Java como si estuvieras en primero”http://www.abcdatos.com/tutoriales/tutorial/l7041.html

- Consulta de patrons de diseny – Generic http://java.ciberaula.com/articulo/diseno_patrones_j2ee/

- Utilització del patró Singletonhttp://www.elrincondelprogramador.com/default.asp?id=45&pag=articulos%2Fleer.asp

- Definició de Singleton http://ca.wikipedia.org/wiki/Patr%C3%B3_singleton

79