Tesis. Anexo. Análisis, Diseño e Implementación de Un Administrador de Torneos de Ajedrez

PONTIFICIA UNIVERSIDAD CATÓLICA DEL PERÚ
FACULTAD DE CIENCIAS E INGENIERÍA
ANEXO
ANÁLISIS, DISEÑO E IMPLEMENTACIÓN

DE UN SISTEMA DE ADMINISTRACIÓN DE TORNEOS
DEL JUEGO DE AJEDREZ
Tesis para optar por el Título de Ingeniero Informático, que presenta el bachiller:
Billy Antonio Colonia Machado
ASESOR: Carlos Molina Maraví
Lima, Diciembre del 2008
i
Índice de Contenido
1. Anexos ............................................................................................................................. 1
1.1. RUP (Rational Unified Process) .................................................................................. 2
1.1.1. Fases de RUP a desarrollar en el proyecto ............................................................ 3
1.1.2. Flujos de trabajo a realizar en el proyecto .............................................................. 4
1.1.3. Objetivos de cada iteración en el proyecto ............................................................. 5
1.2. UML.............................................................................................................................. 7
1.3. Lenguajes de Programación........................................................................................ 9
1.4. Base de Datos ........................................................................................................... 11
1.5. Arquitectura Cliente – Servidor.................................................................................. 13
1.5.1. Capas .................................................................................................................... 14
1.6. Requerimientos.......................................................................................................... 15
1.6.1. Módulo de Administración de Torneos.................................................................. 15
1.6.2. Módulo de Administración de Partidas.................................................................. 17
1.6.3. Características Generales del Sistema ................................................................. 18
1.7. Modelos de Casos de Uso......................................................................................... 20
1.7.1. Caso de Uso de Administración de torneos .......................................................... 20
1.7.2. Caso de Uso de Partidas....................................................................................... 22
1.8. Especificación de Casos de Uso ............................................................................... 24
1.8.1. Mantenimiento de Jugadores ................................................................................ 25
1.8.2. Mantenimiento de Torneo...................................................................................... 27
1.8.3. Mantenimiento de Divisiones................................................................................. 29
1.8.4. Buscar Jugadores.................................................................................................. 30
1.8.5. Elegir División........................................................................................................ 31
1.8.6. Generar Emparejamientos .................................................................................... 32
1.8.7. Inscribir Jugadores a División................................................................................ 34
1.8.8. Ingresar Resultados .............................................................................................. 36
1.8.9. Calcular ELO ......................................................................................................... 37
1.8.10. Generar Reportes de Torneo ............................................................................ 39
1.8.11. Comentar Partidas ............................................................................................ 40
1.8.12. Aprender Jugadas Básicas ............................................................................... 41
1.8.13. Buscar Partida................................................................................................... 43
1.8.14. Generar Reporte de Partida.............................................................................. 45
1.8.15. Leer Movimientos de Partida ............................................................................ 46
1.8.16. Ingresar Nueva Partida ..................................................................................... 48
1.9. Diagrama de Secuencias........................................................................................... 50
1.9.1. Crear un Torneo .................................................................................................... 50
1.9.2. Crear y Editar División de Torneo ......................................................................... 51
1.9.3. Agregar e Inscribir Jugadores a Torneo................................................................ 52
1.9.4. Emparejar Jugadores ............................................................................................ 53
1.9.5. Registrar Resultados de Encuentros Jugados ...................................................... 54
1.9.6. Ingresar Partidas al Sistema ................................................................................. 55
1.9.7. Buscar y Leer Partidas del Sistema ...................................................................... 56
1.9.8. Calcular ELO de jugador en torneo....................................................................... 57
1.10. Diagrama de Clases .................................................................................................. 58
1.10.1. Crear Torneo ..................................................................................................... 58
1.10.2. Agregar Jugadores al Sistema.......................................................................... 59
1.10.3. Inscribir Jugador a División de Torneo ............................................................. 60
1.10.4. Crear División de Torneo .................................................................................. 61
1.10.5. Emparejamientos de Jugadores ....................................................................... 62
1.10.6. Registrar Resultados de Enfrentamientos ........................................................ 64
1.10.7. Ingresar Partidas............................................................................................... 66
1.10.8. Leer movimientos de Partidas........................................................................... 68
1.10.9. Calcular ELO ..................................................................................................... 69
1.11. Especificaciones de Diagramas de Clase ................................................................. 70
1.11.1. Clase ButtonListener......................................................................................... 70
1.11.2. Clase ButtonSgteListener ................................................................................. 71
1.11.3. Clase DivisionTorneo ........................................................................................ 72
ii
1.11.4. Clase Grupo ...................................................................................................... 72
1.11.5. Clase Jugador ................................................................................................... 73
1.11.6. Clase JugadorxDivision..................................................................................... 73
1.11.7. Clase JugadorxELO .......................................................................................... 74
1.11.8. Clase JugadorxFechas ..................................................................................... 74
1.11.9. Clase ManejadordeLectura ............................................................................... 75
1.11.10. Clase ManejadordePiezas ................................................................................ 75
1.11.11. Clase ManejadordeTablero............................................................................... 76
1.11.12. Clase Partida..................................................................................................... 77
1.11.13. Clase Pieza (Abstracta) .................................................................................... 78
1.11.14. Clase TipoTorneo.............................................................................................. 78
1.11.15. Clase Torneo..................................................................................................... 79
1.12. Diseño del modelo físico de datos............................................................................. 80
1.13. Diseño de Interfaz Gráfica ......................................................................................... 82
1.13.1. Ventana de Inicio de Sistema ........................................................................... 82
1.13.2. Ventana de Ingreso de Partidas........................................................................ 83
1.13.3. Ventana de Lectura de Partidas ....................................................................... 84
1.13.4. Ventana de Ingreso de nuevos Jugadores ....................................................... 85
1.13.5. Ventana de Inscripción de jugadores a división de torneo ............................... 86
1.13.6. Ventana de Creación de Torneos ..................................................................... 87
1.13.7. Ventana de Administración de Torneos............................................................ 88
1.13.8. Ventana de Creación de División de Torneo .................................................... 89
1.13.9. Ventana de Resultados de Torneo ................................................................... 90
1.13.10. Ventana de Registro de Resultados ................................................................. 91
1.13.11. Ventana de Búsqueda de Partidas ................................................................... 92
1.13.12. Ventana de Edición de Partidas....................................................................... 93
1.13.13. Ventana de Selección de Jugador .................................................................... 94
1.13.14. Ventana de Edición de Jugadores .................................................................... 95
1.13.15. Ventana de Selección de Torneo...................................................................... 96
1.13.16. Ventana de Edición de Torneo.......................................................................... 97
1.13.17. Ventana de Cálculo de ELO en Torneo ............................................................ 98
1.13.18. Ventana de Cálculo de ELO FIDE .................................................................... 99
1.14. Estrategia de Planificación de Pruebas ................................................................... 100
1.15. Casos de Prueba ..................................................................................................... 101
Tabla 69. Casos de Uso a ser probados............................................................................... 102
1.16. Ejecución de Pruebas .............................................................................................. 103
1.16.1. Mantenimiento de torneos............................................................................... 103
1.16.2. Mantenimiento de divisiones de torneo .......................................................... 107
1.16.3. Mantenimiento de jugadores........................................................................... 110
1.16.4. Ingreso de Jugadores a División de Torneo ................................................... 113
1.16.5. Emparejamiento de Jugadores ....................................................................... 117
1.16.6. Ingresar Resultados de Emparejamientos...................................................... 131
1.16.7. Ingresar partidas de los enfrentamientos generados por sistema................. 133
1.16.8. Calcular ELO de jugador................................................................................. 137
1.16.9. Buscar Jugadores ........................................................................................... 143
1.16.10. Buscar Partidas ............................................................................................... 146
1.16.11. Buscar Torneos ............................................................................................... 148
1.16.12. Ingresar Nuevas Partidas................................................................................ 150
1.16.13. Comentar Partidas .......................................................................................... 156
1.16.14. Leer Movimientos de Partida .......................................................................... 159
1.16.15. Generar Reportes de Partida .......................................................................... 164
1.16.16. Pruebas de Caso de Uso: Generar Reportes de Torneo .............................. 167
1.16.17. Pruebas de Caso de Uso: Mostrar Movimientos de Piezas ........................... 170
1.17. Sistema de Desempate de Torneos ........................................................................ 176
1.17.1. Mediana........................................................................................................... 177
1.17.2. Solkoff ............................................................................................................. 177
1.17.3. Acumulativo..................................................................................................... 178
1.18. Cálculo del ELO en un torneo.................................................................................. 179
1.18.1. Primer Caso .................................................................................................... 179
1.18.2. Segundo Caso ................................................................................................ 179
1.18.3. Tercer Caso..................................................................................................... 180
iii
1.19. Entrada de un Jugador en la lista de ELO FIDE ..................................................... 181
1.20. Sistema de Rating FIDE .......................................................................................... 182
1.21. Herramientas de construcción de Software............................................................. 184
1.21.1. Software de Construcción ............................................................................... 184
1.21.2. Librerías utilizadas en Construcción ............................................................... 185
1.22. Instalación y Ejecución del Sistema ........................................................................ 186
1.23. Descripción de menús del Sistema ......................................................................... 187
1.23.1. Menú Inicio del Sistema .................................................................................. 187
1.23.2. Menú Partidas del Sistema ............................................................................. 188
1.23.3. Menú ELO del Sistema ................................................................................... 189
1.24. Descripción de funcionalidades del Sistema ........................................................... 190
1.24.1. Crear nuevo Torneo ........................................................................................ 190
1.24.2. Crear nuevo Jugador ...................................................................................... 190
1.24.3. Inscribir jugador a división de torneo .............................................................. 191
1.24.4. Crear Nueva División de torneo ...................................................................... 191
1.24.5. Emparejar jugadores....................................................................................... 192
1.24.6. Ingresar Resultados de Enfrentamientos........................................................ 192
1.24.7. Registrar Partidas ........................................................................................... 193
1.24.8. Reproducir Partidas ........................................................................................ 193
1.24.9. Calcular ELO de Jugador en torneo ............................................................... 194
1.24.10. Calcular ELO FIDE de Jugador....................................................................... 194
1.25. Algoritmo de emparejamiento de un torneo tipo suizo ............................................ 195
1.25.1. La función emparejarSegunGrupos ................................................................ 196
1.25.2. La función emparejarDentrodeGrupo ............................................................. 198
1.25.3. La función proponerRivales ............................................................................ 200
1.25.4. La función llenarMatrizPareos......................................................................... 202
1.25.5. La función dameMatrizdeRivales .................................................................... 203
1.26. Optimización del algoritmo de Sistema Suizo ......................................................... 204
1.27. Procedimiento FIDE................................................................................................. 204
1.28. Procedimiento Optimizado....................................................................................... 205
iv
Índice de Imágenes
Figura 1. Modelo Cliente-Servidor con tres capas. ................................................................. 13
Figura 2. Caso de uso Administración de torneos .................................................................. 20
Figura 3. Caso de uso de Partidas .......................................................................................... 22
Figura 4. Diagrama de Secuencia “Crear un Torneo” ............................................................. 50
Figura 5. Diagrama de Secuencia “Agregar y Editar División de Torneo” .............................. 51
Figura 6. Diagrama de Secuencia “Agregar Jugadores a Torneo”. ........................................ 52
Figura 7. Diagrama de Secuencia “Emparejar Jugadores” ..................................................... 53
Figura 8. Diagrama de Secuencia “Ingresar Resultados de Encuentros Jugados” ................ 54
Figura 9. Diagrama de Secuencia “Ingresar Partidas al Sistema” .......................................... 55
Figura 10. Diagrama de Secuencia “Buscar y Leer Partidas del Sistema”. ............................ 56
Figura 11. Diagrama de Secuencia “Calcular ELO de Jugador”............................................. 57
Figura 12. Diagrama de clases “Creación de torneo” ............................................................. 58
Figura 13. Diagrama de clases “Agregar Jugadores al Sistema” .......................................... 59
Figura 14. Diagrama de clases “Inscribir Jugador a División de Torneo” ............................... 60
Figura 15. Diagrama de clases “Creación de División de Torneo” ......................................... 61
Figura 16. Diagrama de clases “Emparejamiento de Jugadores”........................................... 62
Figura 17. Diagrama de clases “Ingreso de Resultados” ........................................................ 64
Figura 18. Diagrama de clases “Ingreso de Partidas”............................................................. 66
Figura 19. Diagrama de clases “Lectura de Partidas”............................................................. 68
Figura 20. Diagrama de clases “Cálculo de ELO”................................................................... 69
Figura 21. Modelo físico de la base de datos......................................................................... 80
Figura 22. Pantalla de inicio de Sistema ................................................................................. 82
Figura 23. Pantalla de Ingreso de partidas con vista de la pestaña “Jugadas”. ..................... 83
Figura 24. Pantalla de Lectura de partidas de ajedrez............................................................ 84
Figura 25. Pantalla de Ingreso de nuevos jugadores.............................................................. 85
Figura 26. Pantalla de Asignación de jugadores a división de torneo .................................... 86
Figura 27. Pantalla de Ingreso de nuevo torneo ..................................................................... 87
Figura 28. Pantalla principal de administración de torneos .................................................... 88
Figura 29. Pantalla de creación de nueva división en torneo ................................................. 89
Figura 30. Pantalla de registro de resultados por división de torneo ...................................... 90
Figura 31. Pantalla de emparejamientos y registro de resultados por ronda. ........................ 91
Figura 32. Pantalla de “Búsqueda de Partidas” ...................................................................... 92
Figura 33. Pantalla de “Edición de Partidas”........................................................................... 93
Figura 34. Pantalla de “Elección de Jugador” ......................................................................... 94
Figura 35. Pantalla de “Edición de Jugadores” ....................................................................... 95
Figura 36. Pantalla de Elección de torneo ............................................................................. 96
Figura 37. Pantalla de Edición de torneo ................................................................................ 97
Figura 38. Pantalla de Cálculo de ELO en Torneo.................................................................. 98
Figura 39. Pantalla de Cálculo de ELO FIDE.......................................................................... 99
Figura 40. Datos de Ingreso de nuevo torneo....................................................................... 103
Figura 41. Mensaje de éxito de operación. ........................................................................... 103
Figura 42. El registro “torneo de prueba 1” se muestra en la grilla Registros Abiertos. ....... 103
Figura 43. Datos de ingreso de nuevo torneo. ...................................................................... 104
Figura 44. Mensaje informativo del sistema.......................................................................... 104
Figura 45. Se ingresan datos de nuevo torneo. .................................................................... 104
Figura 47. Se selecciona registro “torneo de prueba 1” ........................................................ 104
Figura 48. Se muestra el detalle del registro seleccionado .................................................. 104
Figura 49. Se presiona el botón “Editar Torneo”. .................................................................. 105
Figura 50. Se carga el detalle del registro “torneo de prueba 1” para ser editado. .............. 105
Figura 51. Se actualiza el nombre del torneo........................................................................ 105
Figura 52. Mensaje de operación exitosa. ............................................................................ 105
Figura 53. Se muestra el registro actualizado en la grilla Registros Abiertos....................... 105
Figura 54. Se elimina el nombre del torneo. ......................................................................... 105
Figura 56. No se selecciona ningún registro. ........................................................................ 106
Figura 58. Se selecciona registro a eliminar. ........................................................................ 106
v
Figura 59. Mensaje de confirmación del sistema. ................................................................. 106
Figura 60. El registro “torneo de prueba Edición” ha sido eliminado. ................................... 106
Figura 61. Se ingresan datos de nueva división de torneo. .................................................. 107
Figura 63. Se crea una nueva hoja en el árbol “Vista de Torneo”. ....................................... 107
Figura 64. Se ingresan datos de nueva división sin determinar su nombre. ........................ 107
Figura 66. Se selecciona una división de torneo................................................................... 108
Figura 67. Se muestran los datos de la división a editar. ..................................................... 108
Figura 68. Se ingresa a ventana de Edición de División eligiendo una división. .................. 108
Figura 70. Se ingresa a ventana de Edición de División eligiendo una división. .................. 108
Figura 71. Se muestra la ventana “Actualizar División de Torneo”....................................... 108
Figura 72. Se cambia el nombre de la división a “División Única”. ....................................... 109
Figura 74. Se muestra la actualización del registro en el panel “Datos de División”. ........... 109
Figura 75. El registro Iniciado muestra “SI”. Se inició división. ............................................. 109
Figura 77. Presionar botón “Agregar Jugadores”.................................................................. 110
Figura 78. Se muestra la ventana “Inscribir Jugadores”. ...................................................... 110
Figura 79. No se ingresa el apellido paterno......................................................................... 110
Figura 80. Mensaje informativo de sistema........................................................................... 110
Figura 81. Información de nuevo jugador sin determinar nombre. ....................................... 111
Figura 82. Mensaje informativo de sistema........................................................................... 111
Figura 83. Se ingresa todos los datos pedidos para crear un nuevo jugador....................... 111
Figura 85. Una vez creado el jugador, se busca y se encuentra el registro. ........................ 111
Figura 86. Se presiona el botón “Actualizar datos”. .............................................................. 111
Figura 87. Se muestra pestaña “Ingresar Jugadores”........................................................... 111
Figura 88. Se edita el ELO del jugador seleccionado de 1000 a 2250. ................................ 112
Figura 90. Se busca el registro editado y se comprueba actualización. ............................... 112
Figura 91. Se edita información de jugador eliminado su apellido paterno. ......................... 112
Figura 93. Se presiona el botón “Agregar Jugadores”. ......................................................... 113
Figura 94. Se muestra la ventana “Inscribir Jugadores”. ...................................................... 113
Figura 95. Se seleccionan jugadores a ser inscritos............................................................. 114
Figura 96. Se muestra a los jugadores seleccionados con signo de aprobación. ................ 114
Figura 97. Se inscriben jugadores seleccionados a la división “División Única”. ................ 114
Figura 99. Se muestra en árbol “Vista de Torneo” a los jugadores inscritos. ...................... 114
Figura 100. Se inscriben nuevamente a jugadores registrados............................................ 115
Figura 101. El árbol “Vista de Torneo” muestra a los jugadores registrados........................ 115
Figura 102. Se presiona botón “Eliminar Jugador”................................................................ 115
Figura 103. Mensaje informativo del sistema........................................................................ 115
Figura 104. Se selecciona el registro a eliminar. .................................................................. 115
Figura 105. Se procede a eliminar al jugador de identificador 33......................................... 116
Figura 106. Mensaje de confirmación del sistema. ............................................................... 115
Figura 107. Se muestra en árbol que el jugador “colonia, billy” ha sido eliminado............... 116
Figura 108. Previamente se procede a emparejar la siguiente ronda”. ................................ 116
Figura 109. Después se procede a eliminar a jugador de la división ya iniciada. ............... 116
Figura 110. Mensaje de advertencia del sistema.................................................................. 116
Figura 111. Se presiona botón “Ingresar Resultados”. ......................................................... 117
Figura 112. Se muestra la ventana “Resultados de torneo”. ................................................ 117
Figura 113. Se presiona botón “Siguiente” sin jugadores. .................................................... 117
Figura 115. Jugadores inscritos antes de emparejar la primera ronda................................. 118
Figura 116. Se asigna en la primera ronda un identificador a cada jugador inscrito. ........... 118
Figura 117. Se activa botón que muestra ventana de ingreso de resultados de la ronda.... 118
Figura 118. Se presiona botón “Siguiente” sin ingresar todos los resultados de la ronda.... 118
vi
Figura 120. Se presiona botón “Siguiente” habiendo concluido el torneo. ........................... 119
Figura 122. Se presiona botón “Siguiente” para emparejamientos de ronda uno. ............... 119
Figura 123. Listado de emparejamientos de jugadores de la ronda uno. ............................ 119
Figura 124. Tabla de posiciones después de la ronda 1....................................................... 120
Figura 125. Listado de emparejamientos de jugadores de la ronda dos. ............................ 120
Figura 127. Listado de emparejamientos de jugadores de la ronda tres. ............................ 121
Figura 129. Listado de emparejamientos de jugadores de la ronda cuatro......................... 122
Figura 131. Listado de emparejamientos de jugadores de la ronda cinco........................... 123
Figura 132. Tabla de resultados de las primeras cuatro rondas........................................... 123
Figura 134. Tabla de desempate que ubica al jugador 6 en el primer lugar......................... 124
Figura 135. Se presiona botón “Siguiente” para emparejamientos de ronda uno. ............... 124
Figura 136. Listado de emparejamientos de jugadores de la ronda uno. ............................ 124
Figura 138. Listado de emparejamientos de jugadores de la ronda dos. ............................ 125
Figura 140. Listado de emparejamientos de jugadores de la ronda tres. ............................ 126
Figura 142. Tabla de desempate que ubica al jugador 1 en el primer lugar......................... 127
Figura 143. Se presiona botón “Siguiente”............................................................................ 127
Figura 145. Se intenta emparejar con tres jugadores inscritos............................................. 128
Figura 147. Se inicia torneo con cinco jugadores. ................................................................ 128
Figura 148. Se asigna identificador y los rivales para todas las rondas. .............................. 128
Figura 149. Se inicia torneo con seis jugadores. .................................................................. 128
Figura 151. Se inicia torneo sin inscribir jugadores............................................................... 129
Figura 153. Se intenta emparejar con un jugador inscrito. ................................................... 129
Figura 155. Se inicia torneo con cinco jugadores. ................................................................ 130
Figura 157. Se inicia torneo con seis jugadores. .................................................................. 130
Figura 159. Presionar botón “Ingresar Resultados”. ............................................................. 131
Figura 160. Se muestra ventana “Resultados de Torneo”. ................................................... 131
Figura 161. Se presiona el botón “R1” para ingreso de resultados. .................................... 131
Figura 162. Se muestra ventana “Registrar Resultados” para la ronda uno......................... 131
Figura 163. Sistema muestra lista de enfrentamientos de una ronda................................... 132
Figura 164. Se procede a ingresar resultados de una ronda................................................ 132
Figura 165. Se muestran los resultados registrados............................................................. 132
Figura 166. Se reingresan resultados de las partidas........................................................... 132
Figura 167. Se oprime botón “R1” para ingresar resultados............................................... 132
Figura 168. El botón “Guardar” aparece deshabilitado. ........................................................ 132
Figura 171. Se presiona el botón “R1” para ingreso de resultados ..................................... 133
Figura 172. Se muestra ventana “Registrar Resultados” para la ronda uno......................... 133
Figura 173. Presionar botón “Registrar Partida”. .................................................................. 134
Figura 174. Se muestra ventana de ingreso de partidas. ..................................................... 134
Figura 175. Ingresar movimientos de una partida................................................................. 134
Figura 176. El sistema interpreta y registra el movimiento solicitado. .................................. 134
Figura 177. Ingresar de forma errónea un movimiento de una pieza. .................................. 135
Figura 178. El sistema reconoce el error y retrocede la jugada............................................ 135
Figura 179. Se elige enfrentamiento y se presiona botón “Ver Partida”. .............................. 135
Figura 180. Se muestra ventana “Lectura de Partida” con partida cargada. ........................ 135
vii
Figura 181. Se presiona botón “Avanzar”. ............................................................................ 136
Figura 182. Se reproducen las jugadas registradas de la partida......................................... 136
Figura 185. Presionar botón “Calcular ELO” sin seleccionar jugador. .................................. 137
Figura 187. Presionar botón “Calcular ELO” seleccionando un jugador............................... 138
Figura 188. Se muestra la ventana “Cálculo de ELO”........................................................... 138
Figura 189. Se obtiene ELO de oponentes de jugador y los puntos obtenidos................... 138
Figura 190. Se generan datos para cálculo de ELO. ............................................................ 139
Figura 192. Se generan datos para cálculo de ELO. ............................................................ 139
Figura 193. Se elige opción “Calcular ELO” de menú ELO. ................................................. 140
Figura 196. Se calcula el nuevo ELO.................................................................................... 140
Figura 198. Se calcula el nuevo ELO.................................................................................... 141
Figura 199. Se elige opción “Calcular ELO” de menú ELO. ................................................. 141
Figura 201. Se ingresa ELO obtenido y partidas jugadas por torneo. .................................. 142
Figura 202. Se calcula el nuevo ELO FIDE........................................................................... 142
Figura 203. Se presiona botón “Agregar Jugadores” en “Administración de torneos”.......... 143
Figura 204. Se muestra la ventana “Inscribir Jugadores”. .................................................... 143
Figura 205. Se ingresa criterio de búsqueda. ....................................................................... 143
Figura 206. Se muestran registros que coinciden con el criterio ingresado. ........................ 143
Figura 208. Se muestra grilla vacía si ningún registro coincide con criterio ingresado. ....... 144
Figura 209. Se ingresa a la opción “Ingresar Partidas” de menú Partidas. .......................... 144
Figura 210. Se muestra la ventana de ingreso de partidas. ................................................. 144
Figura 211. Se presiona botón “…” que elige a jugador de piezas blancas de la partida. ... 145
Figura 212. Se muestra la ventana “Elegir Jugador”............................................................. 145
Figura 217. Se presiona botón “Buscar Partidas” de “Administración de torneos”............... 146
Figura 218. Se muestra la ventana “Buscar Partidas”. ......................................................... 146
Figura 225. Se presiona botón “…” que elige torneo donde se desarrolla la partida. .......... 148
Figura 226. Se muestra la ventana “Elegir Jugador”............................................................. 148
Figura 233. Se elige al alfil como la pieza a mover............................................................... 150
Figura 234. Se resaltan las casillas posibles de destino....................................................... 150
Figura 235. Se traslada el caballo a casilla resaltada. .......................................................... 151
Figura 236. El caballo es situado en su nueva posición. ...................................................... 151
Figura 237. Se mueve el peón a posición no válida.............................................................. 151
Figura 238. El peón es devuelto a su anterior posición. ....................................................... 151
Figura 239. Se elige mover al rey a la casilla g1................................................................... 151
Figura 240. El enroque corto es efectuado. .......................................................................... 151
Figura 241. Se elige mover al rey a la casilla c1................................................................... 152
viii
Figura 242. El enroque largo es efectuado. .......................................................................... 152
Figura 243. El peón negro va a tomar al caballo blanco....................................................... 152
Figura 244. El peón negro toma su nueva posición después de comer al caballo............... 152
Figura 245. El peón negro g7 se mueve a casilla g5. ........................................................... 152
Figura 246. El peón blanco h5 tomar el peón negro g5 y se ubica en la casilla g6............. 152
Figura 247. El peón blanco en casilla g7 avanza una casilla................................................ 153
Figura 248. El peón blanco llega a última fila y se convierte en dama. ................................ 153
Figura 249. Se mueve el peón de casilla a2 a a3. ................................................................ 153
Figura 250. Se registra el movimiento a3 en la jugada 9 ...................................................... 153
Figura 251. Se mueve peón a casilla a3. .............................................................................. 153
Figura 252. Se retrocede peón a casilla a2........................................................................... 153
Figura 253. Lista de notaciones previo al retroceso.............................................................. 154
Figura 254. Lista de notaciones después del retroceso........................................................ 154
Figura 255. No se elige al jugador de piezas blancas de la partida a registrar. ................... 154
Figura 257. No se elige al jugador de piezas blancas de la partida a registrar. ................... 154
Figura 259. No se ha realizado ninguna jugada de la partida a registrar. ............................ 155
Figura 261. No se elige el torneo donde se realiza la partida a registrar.............................. 155
Figura 263. Se eligen a los jugadores y al torneo de la partida a registrar........................... 155
Figura 264. Mensaje de operación exitosa. .......................................................................... 155
Figura 265. Se confirma el registro de la partida al buscar la partida en el sistema. ........... 155
Figura 268. Se ingresa un comentario. ................................................................................. 156
Figura 269. Se registra y se muestra el comentario.............................................................. 156
Figura 270. Se elige la jugada y se ingresa el comentario. .................................................. 157
Figura 271. Se registra y se muestra el comentario.............................................................. 157
Figura 272. Se selecciona el registro de un comentario. ...................................................... 157
Figura 273. Se muestra el comentario completo seleccionado. ........................................... 157
Figura 274. Se ingresa nuevo comentario y se presiona botón “Ingresar Comentario”. ...... 158
Figura 275. Se actualiza el registro de comentarios. ............................................................ 158
Figura 276. Se ingresa a la opción “Leer Partidas” de menú Partidas. ................................ 159
Figura 277. Se muestra la ventana “Lectura de Partidas”. ................................................... 159
Figura 278. Se elige la pestaña “PGN”. ................................................................................ 159
Figura 279. Se activa el panel de la pestaña “PGN”. ............................................................ 159
Figura 280. Se ingresan los movimientos de una partida. .................................................... 160
Figura 282. Se reproduce la partida de ajedrez según movimientos ingresados. ................ 160
Figura 283. Se ingresan los movimientos de una partida con comentarios. ........................ 161
Figura 285. Se reproduce la partida de ajedrez según movimientos ingresados ................. 161
Figura 286. Se ingresan movimientos no válidos.................................................................. 161
Figura 287. No se carga la lista de los registros de las jugadas de la partida...................... 161
Figura 288. No se ingresa al jugador de piezas blancas de la partida. ................................ 161
Figura 290. No se ingresa al jugador de piezas negras de la partida................................... 162
Figura 292. Se intenta guardar partida sin ingresar movimientos......................................... 162
Figura 294. No se ingresa el torneo de la partida. ................................................................ 162
Figura 296. Se eligen a los jugadores y al torneo de la partida a registrar........................... 163
Figura 298. Se confirma el registro de la partida al buscar la partida en el sistema. ........... 163
Figura 300. Se muestra ventana de ingreso de partidas. ..................................................... 164
Figura 301. Se realizan movimientos en el tablero. .............................................................. 164
Figura 302. Se genera la lista de notaciones de la partida. .................................................. 164
ix
Figura 303. Se presiona botón “Generar Reporte”................................................................ 165
Figura 304. Se genera un reporte con el detalle de la partida jugada. ................................ 165
Figura 305. Se ingresa a la opción “Leer Partidas” de menú Partidas. ................................ 165
Figura 306. Se carga ventana de lectura de partidas. .......................................................... 165
Figura 307. Se ingresan los movimientos de una partida ..................................................... 166
Figura 308. Se genera una partida........................................................................................ 166
Figura 309. Movimientos generados de la partida. ............................................................... 166
Figura 310. Reporte de partida generado. ............................................................................ 166
Figura 312. Se muestra la ventana “Resultados de Torneo”. ............................................... 167
Figura 313. Tabla de resultados generales de un torneo. .................................................... 168
Figura 315. Reporte generado de torneo en una hoja de cálculo......................................... 168
Figura 317. Se muestra la ventana “Resultados de Torneo”. ............................................... 168
Figura 318. Se presiona el botón “R1” para ingreso de resultados ..................................... 169
Figura 319. Se muestra la ventana “Registrar Resultados” para la ronda uno.................... 169
Figura 320. Lista de enfrentamientos de jugadores en una ronda........................................ 169
Figura 322. Reporte generado de torneo en una hoja de cálculo......................................... 169
Figura 324. Se selecciona opción Peón de menú Aprendizaje............................................. 170
Figura 325. Se muestra ventana con peones desplegados en tablero................................. 170
Figura 326. Se selecciona peón blanco de casilla c2. .......................................................... 170
Figura 327. Se ubica peón seleccionado en la casilla c4. .................................................... 170
Figura 328. Se selecciona opción Alfil de menú Aprendizaje. .............................................. 171
Figura 329. Se muestra ventana con alfiles desplegados en tablero. .................................. 171
Figura 330. Se selecciona alfil blanco de casilla f1............................................................... 171
Figura 331. Se ubica alfil seleccionado en la casilla a6. ....................................................... 171
Figura 332. Se selecciona opción Rey de menú Aprendizaje............................................... 172
Figura 333. Se muestra ventana con reyes desplegados en tablero.................................... 172
Figura 334. Se selecciona rey blanco de casilla d3. ............................................................. 172
Figura 335. Se ubica rey seleccionado en la casilla e4. ....................................................... 172
Figura 336. Se selecciona opción Torre de menú Aprendizaje. ........................................... 173
Figura 337. Se muestra ventana con torres desplegadas en tablero. .................................. 173
Figura 338. Se selecciona torre negra de casilla f6. ............................................................. 173
Figura 339. Se ubica torre seleccionada en la casilla f1. ...................................................... 173
Figura 340. Se selecciona opción Dama de menú Aprendizaje. .......................................... 174
Figura 341. Se muestra ventana con damas desplegadas en tablero.................................. 174
Figura 342. Se selecciona dama negra de casilla g1............................................................ 174
Figura 343. Se ubica dama seleccionada en la casilla e1. ................................................... 174
Figura 344. Se selecciona opción Caballo de menú Aprendizaje......................................... 175
Figura 345. Se muestra ventana con caballos desplegados en tablero. .............................. 175
Figura 346. Se selecciona caballo blanco de casilla d2........................................................ 175
Figura 347. Se ubica caballo seleccionado en la casilla e4.................................................. 175
Figura 348. Fórmula de ELO en caso lograr 50% de puntos posibles.................................. 179
Figura 349. Fórmula de ELO en caso lograr mas del 50% de puntos posibles.................... 179
Figura 350. Fórmula de ELO en caso lograr menos del 50% de puntos posibles................ 180
Figura 351. Fórmula para cálculo de ELO FIDE. .................................................................. 181
Figura 352. Menú Inicio del Sistema ..................................................................................... 187
Figura 353. Menú Partida del Sistema .................................................................................. 188
Figura 354. Menú ELO del Sistema ...................................................................................... 189
Figura 355. Pantalla de Ingreso de nuevo torneo ................................................................. 190
Figura 356. Pantalla de Ingreso de nuevos jugadores.......................................................... 190
Figura 357. Pantalla de Asignación de jugadores a división de torneo ................................ 191
Figura 358. Pantalla de creación de nueva división en torneo ............................................. 191
Figura 359. Pantalla de registro de resultados por división de torneo .................................. 192
Figura 360. Pantalla de emparejamientos y registro de resultados por fecha...................... 192
Figura 361. Pantalla de Ingreso de partidas con vista de la pestaña “Datos”. ..................... 193
Figura 362. Pantalla de Lectura de partidas de ajedrez........................................................ 193
Figura 363. Pantalla de Cálculo de ELO en torneo............................................................... 194
Figura 364. Pantalla de Cálculo de ELO FIDE...................................................................... 194
x
Índice de tablas
Tabla 1. Fases de RUP.......................................................................................................... 2
Tabla 2. Fases de RUP a desarrollar en el proyecto............................................................. 3
Tabla 3. Flujos de trabajo del proyecto.................................................................................. 4
Tabla 4. Objetivos por iteración del proyecto ........................................................................ 6
Tabla 5. Diagramas a utilizar en el Proyecto ......................................................................... 8
Tabla 6. Descripción de lenguajes de programación a elegir.............................................. 10
Tabla 7. Descripción de gestores de base de datos............................................................ 12
Tabla 8. Capas de Arquitectura ........................................................................................... 14
Tabla 9. Requerimientos del módulo de administración de torneo ..................................... 16
Tabla 10. Requerimientos del módulo de aprendizaje ........................................................ 17
Tabla 11. Requerimientos no funcionales del sistema ........................................................ 18
Tabla 12. Descripción de valores del criterio dificultad........................................................ 19
Tabla 13. Descripción de valores del criterio prioridad........................................................ 19
Tabla 14. Descripción de valores de tipo de torneo. ........................................................... 19
Tabla 15. Casos de Uso de Administración de torneo ........................................................ 21
Tabla 16. Casos de Uso de Administración de Partidas ..................................................... 23
Tabla 17. Especificación de Caso de Uso ........................................................................... 24
Tabla 18. Especificación de Caso de Uso: “Mantenimiento de Jugadores”........................ 26
Tabla 19. Especificación de Caso de Uso: “Mantenimiento de torneo”............................... 28
Tabla 20. Especificación de Caso de Uso: “Mantenimiento de Divisiones” ........................ 29
Tabla 21. Especificación de Caso de Uso: “Buscar Jugadores” ......................................... 30
Tabla 22. Especificación de Caso de Uso: “Elegir División”................................................ 31
Tabla 23. Especificación de Caso de Uso: “Generar Emparejamientos” ............................ 33
Tabla 24. Especificación de Caso de Uso: “Inscribir Jugadores a División” ....................... 35
Tabla 25. Especificación de Caso de Uso: “Ingresar Resultados” ...................................... 36
Tabla 26. Especificación de Caso de Uso: “Calcular ELO” ................................................. 38
Tabla 27. Especificación de Caso de Uso: “Generar Reporte de Torneo”.......................... 39
Tabla 28. Especificación de Caso de Uso: “Comentar Partidas” ........................................ 40
Tabla 29. Especificación de Caso de Uso: “Aprender Jugadas Básicas” ........................... 42
Tabla 30. Especificación de Caso de Uso: “Buscar Partida”............................................... 44
Tabla 31. Especificación de Caso de Uso: “Generar Reporte de Partida” .......................... 45
Tabla 32. Especificación de Caso de Uso: “Leer Movimientos de Partida” ........................ 47
Tabla 33. Especificación de Caso de Uso: “Ingresar Nueva Partidas”................................ 49
Tabla 34. Diccionario de datos de la clase ButtonListener.................................................. 70
Tabla 35. Diccionario de datos de la clase ButtonSgteListener. ......................................... 72
Tabla 36. Diccionario de datos de la clase DivisionTorneo................................................. 72
Tabla 37. Diccionario de datos de la clase Grupo. .............................................................. 72
Tabla 38. Diccionario de datos de la clase Jugador ............................................................ 73
Tabla 39. Diccionario de datos de la clase JugadorxDivision ............................................. 73
Tabla 40. Diccionario de datos de la clase JugadorxELO ................................................... 74
Tabla 41. Diccionario de datos de la clase JugadorxFechas. ............................................. 74
Tabla 42. Diccionario de datos de la clase ManejadordeLectura........................................ 75
Tabla 43. Diccionario de datos de la clase ManejadordePiezas ......................................... 75
Tabla 44. Diccionario de datos de la clase ManejadordeTablero........................................ 76
Tabla 45. Diccionario de datos de la clase Partida.............................................................. 77
Tabla 46. Diccionario de datos de la clase abstracta Pieza. ............................................... 78
Tabla 47. Diccionario de datos de la clase TipoTorneo....................................................... 78
Tabla 48. Diccionario de datos de la clase Torneo.............................................................. 79
Tabla 49. Descripción de las tablas del modelo físico de la base de datos. ...................... 81
Tabla 50. Características de la ventana “Inicio de sistema”................................................ 82
Tabla 51. Características de la ventana “Ingreso de Partidas” ........................................... 83
Tabla 52. Características de la ventana “Lectura de partidas”............................................ 84
Tabla 53. Características de la ventana “Ingreso de jugadores al sistema” ....................... 85
Tabla 54. Características de la ventana “Inscripción de jugadores”.................................... 86
Tabla 55. Características de la ventana “Creación de nuevo torneo” ................................. 87
Tabla 56. Características de la ventana “Administración de torneo”................................... 88
Tabla 57. Características de la ventana “Creación de división de torneo” .......................... 89
xi
Tabla 58. Características de la ventana “Resultados de división de torneos” .................... 90
Tabla 59. Características de la ventana “Registro de Resultados” ..................................... 91
Tabla 60. Características de la ventana “Búsqueda de Partidas” ....................................... 92
Tabla 61. Características de la ventana “Edición de Partidas”............................................ 93
Tabla 62. Características de la ventana “Elección de Partidas”.......................................... 94
Tabla 63. Características de la ventana “Edición de Jugador”............................................ 95
Tabla 64. Características de la ventana “Elección de Torneo”............................................ 96
Tabla 65. Características de la ventana “Edición de Torneo” ............................................. 97
Tabla 66. Características de la ventana “Cálculo de ELO en Torneo” ................................ 98
Tabla 67. Características de la ventana “Cálculo de ELO FIDE” ........................................ 99
Tabla 68. Formulario para ejecución de pruebas del sistema a cada caso de uso .......... 100
Tabla 69. Casos de Uso a ser probados ........................................................................... 102
Tabla 70. Pruebas de Caso de Uso: Mantenimiento de torneo......................................... 106
Tabla 71. Pruebas de Caso de Uso: Mantenimiento de divisiones de torneo................... 109
Tabla 72. Pruebas de Caso de Uso: Mantenimiento de jugadores ................................... 112
Tabla 73. Pruebas de Caso de Uso: Ingreso de jugadores a división de torneo .............. 116
Tabla 74. Pruebas de Caso de Uso: Emparejamiento de Jugadores ............................... 130
Tabla 75. Pruebas de Caso de Uso: Ingresar Resultados de Emparejamientos .............. 132
Tabla 76. Pruebas de Caso de Uso: Ingresar Partidas ..................................................... 136
Tabla 77. Pruebas de Caso de Uso: Calcular ELO de jugador ........................................ 142
Tabla 78. Pruebas de Caso de Uso: Buscar Jugadores ................................................... 145
Tabla 79. Pruebas de Caso de Uso: Buscar Partidas ....................................................... 147
Tabla 80. Pruebas de Caso de Uso: Buscar Torneos ....................................................... 149
Tabla 81. Pruebas de Caso de Uso: Ingresar Nuevas Partidas........................................ 155
Tabla 82. Pruebas de Caso de Uso: Comentar Partidas .................................................. 158
Tabla 83. Pruebas de Caso de Uso: Leer Movimientos de Partidas................................. 163
Tabla 84. Pruebas de Caso de Uso: Generar Reportes de Partida .................................. 166
Tabla 85. Pruebas de Caso de Uso: Generar Reportes de torneo ................................... 169
Tabla 86. Pruebas de Caso de Uso: Aprendizaje de Movimientos de Piezas .................. 175
Tabla 87. Sistemas de desempate .................................................................................... 176
Tabla 88. Tabla de Posiciones de torneo ficticio. .............................................................. 176
Tabla 89. Tabla para cálculo de Mediana de Billy, Coco, Danny y Erick. ......................... 177
Tabla 90. Tabla para cálculo de puntaje Solkoff de Billy, Danny y Erick........................... 178
Tabla 91. Tabla para cálculo de puntaje Acumulativo de Billy y Danny. ........................... 178
Tabla 92. Tabla de diferenciales para cálculo de ELO de jugadores principiantes........... 182
Tabla 93. Tabla de diferenciales para cálculo de jugadores experimentados. ................. 183
Tabla 94. Software utilizado en el proyecto....................................................................... 184
Tabla 95. Librerías utilizadas en el proyecto. .................................................................... 185
Tabla 96. Tabla de descripción del menú “Inicio”. ............................................................. 187
Tabla 97. Tabla de descripción del menú “Partidas” ......................................................... 188
Tabla 98. Tabla de descripción del menú “ELO”. .............................................................. 189
Tabla 99. Funciones de emparejamiento de Sistema Suizo ............................................. 195
Tabla 100. Función emparejarSegunGrupos..................................................................... 197
Tabla 101. emparejarDentrodeGrupo................................................................................ 199
Tabla 102. Función proponerRivales ................................................................................. 201
Tabla 103. Función llenarMatrizPareos ............................................................................. 202
Tabla 104. Función dameMatrizdeRivales ........................................................................ 203
Tabla 105. Terna de jugadores a emparejar. .................................................................... 205
xii
1. Anexos
En este documento se presenta toda la información que resulta relevante para el
entendimiento pleno del presente trabajo de tesis.
1
1.1. RUP (Rational Unified Process)
Es un proceso de ingeniería de software, el cual proporciona una aproximación

estandarizada a la asignación de tareas y responsabilidades dentro de las
organizaciones que se encargan en el desarrollo de software. El objetivo es asegurar
la calidad del software desarrollado que cumpliendo con satisfacer las necesidades de
los usuarios finales, con el cronograma establecido y los presupuestos prefijados. El
proceso RUP está dividido en las etapas que son descritas en la tabla siguiente:
Fases de RUP
Fase Descripción
Punto donde se definen los objetivos del ciclo de vida.
Fase
El alcance, la estimación de tiempo y costo
de Inicio
Determinación de requerimientos, plasmados en casos de uso
Establecer una arquitectura sólida lo que requiere una visión global
del sistema, permitiendo ejecutar los casos de uso críticos
Desarrollar un plan de trabajo para el proyecto
Fase Definir y analizar como se pueden minimizar los riesgos mas altos,
de para que se pueda desarrollar un proyecto con éxito
Elaboración A partir de este punto: la arquitectura, los requerimientos y los planes
de desarrollo son más estables.
El modelo de casos de uso con descripciones detalladas
Requerimientos no funcionales
Todos los componentes se elaboran e incorporan en el producto
Realización de pruebas internas con el cliente (usuario final)
Fase
Producción eficiente y efectiva para lograr eficacia
de
Desarrollo de actividades, cumpliendo un plan y cronograma definido
Construcción
Se obtiene un producto de software integrado y corriendo en una
plataforma adecuada y con manuales de usuario.
Tabla 1. Fases de RUP.
2
1.1.1. Fases de RUP a desarrollar en el proyecto
El desarrollo de las actividades del sistema del sistema para el presente proyecto para
cada uno de sus módulos, será conducido usando un esquema aproximado de fases
donde las iteraciones múltiples ocurran en una fase. La tabla a continuación describe
cada fase y el hito de fin de cada una.
Fases de RUP a desarrollar en el proyecto

Fase Descripción Misión
Definición preliminar del producto. La definición preliminar del

producto contiene la lista de
Fase exigencias que se
de Inicio implementarán en el sistema
Plan de proyecto.
para asegurar su correcto
funcionamiento.
Estándares de diseño, programación
e Interfaces El prototipo de la
Documento preliminar de arquitectura arquitectura del sistema es la
(especificación de los requisitos de tarea que pone fin a la etapa
Software, diagrama de clases). de elaboración. Con esto se
Fase Diagrama de secuencia. obtiene el diseño del sistema
de Documento preliminar de diseño para su posterior
Elaboración detallado (diseño de BD). construcción cumpliendo así
Preliminar de la interfaz gráfica. con las listas de exigencias

especificadas.
Preliminar del plan de pruebas
Documentación final del plan de
pruebas (casos de prueba,
secuencia de pruebas).
Revisión final de la interfaz gráfica El producto final del sistema
Presentación del prototipo. es el hito final de esta fase

Fase
siendo la última versión del
de Programación del sistema.
sistema, lista para su
Construcción
Revisión de pruebas unitarias utilización por parte del
cliente.
Tabla 2. Fases de RUP a desarrollar en el proyecto
3
1.1.2. Flujos de trabajo a realizar en el proyecto
A continuación se describen los flujos de trabajo utilizados en la metodología RUP.
Flujos de trabajo
Flujo Descripción
En este flujo se encuentran los artefactos utilizados de la
Modelado del
metodología RUP para definir un modelo del negocio, modelos de
Negocio
objetos del negocio y el modelo del dominio.
En este flujo se muestran el documento plan de desarrollo
software, el documento visión y las especificaciones tanto de los
Requisitos casos de uso. También se muestran los casos de uso de cada
subsistema, y desde los cuales también se puede consultar la
especificación del caso de uso.
En este flujo se muestran tanto el modelo de análisis/diseño
(diagrama de clases) como el modelo de datos (modelo entidad -
Análisis /
relación), desde los cuales se puede consultar la especificación
Diseño
de los métodos de clase más relevantes o las especificaciones de
atributos
En este flujo se muestran los prototipos de interfaces de usuario
de la aplicación. También se muestran los diagramas de
Implementación componentes y diagrama de despliegue que modelan las
aplicaciones incorporadas en el proyecto.
En este flujo se muestra la especificación de casos de pruebas

funcionales Se muestran únicamente los casos de pruebas
Pruebas
generados para los casos de uso incorporados en las iteraciones
de la fases del proyecto.
Tabla 3. Flujos de trabajo del proyecto
4
1.1.3. Objetivos de cada iteración en el proyecto
Cada fase consiste en iteraciones en las cuales una parte del sistema es desarrollado.
En general, los objetivos de estas iteraciones son:
• Reducir el porcentaje de errores técnicos utilizando para ello fases definidas
en que se basará el desarrollo del sistema.
• Proveer versiones iniciales de un sistema en operatividad.
• Permitir administrar los cambios en el alcance del sistema de manera
eficiente mediante iteraciones cíclicas.
Objetivos por iteración

Puntos
Fase Iteración Descripción Riesgo asociado
de control
Fase Iteración Definir los Definición Especificaciones

de Inicio Preliminar requerimientos del preliminar equivocadas sobre
modulo y su alcance, del la funcionalidad
crear el documento de producto. deseada.
visión, y el plan del
proyecto. Definir un alcance
amplio para el
poco tiempo del
proyecto.
Fase Iteración Se completa el análisis Prototipo No explicar

de E1. y diseño de todos los de adecuadamente
Elabora- Elaborar la casos de uso arquitectura los prototipos al
ción arquitectura identificados en los de cliente.
del requerimientos. Software.
prototipo.
Desarrolla los
prototipos de la
arquitectura de los
requisitos identificados
en la iteración
preliminar.
5
Iteración Implementa y prueba Software No plasmar los
C1 los casos de uso de la versión de prototipos
Desarrollo iteración E1 prueba (V1 correctamente.
de la Beta). El equipo de
versión de trabajo no este
prueba (V1 familiarizado con
Beta). los programas a
utilizar.
Iteración Implementar y probar Software No cambiar todos

C2 los casos de uso versión 1 los defectos
Desarrollo faltantes en la versión (V1) detectados en la
de la de prueba, solucionar versión Beta.
versión de los errores identificados
Software en la versión beta e
Fase (V1) incorporar
de retroalimentación
Cons- obtenida a partir de V1
trucción Beta.
Desarrollar el sistema
V1
Iteración Diseño, Software Problemas de

C3 implementación y versión 2 eficiencia en
Desarrollo prueba de Casos de (V2) cuanto a recursos
de la Uso corregidos. Adición al momento de
versión de de mejoras y solución hacer pruebas de
Software de imperfecciones desarrollo.
(V2) detectadas en base a No cambiar todos
casos de uso los defectos
anteriores. detectados en la
Desarrollo del sistema revisión anterior
V2.
Empaquetado del
sistema V2.
Tabla 4. Objetivos por iteración del proyecto
6
1.2. UML
El Lenguaje Unificado de Modelado (UML) se ha convertido en el lenguaje aceptado

universalmente para los planos del diseño software. Este proceso define quién está
haciendo qué, cuándo y cómo alcanzar un determinado objetivo, proporcionando
normas para el desarrollo eficiente de un software de calidad. Aporta la ventaja de
reducir los riesgos, hace al proyecto más factible, permite modelar el sistema con
tecnología orientada a objetos y genera diseños que capturan las ideas de los
creadores de forma convencional y muy fácil de comprender para comunicar a otras
personas.
Es un lenguaje gráfico para visualizar, especificar, construir y documentar un sistema

de software. UML ofrece un estándar para describir un "plano" del sistema (modelo),
incluyendo aspectos conceptuales tales como procesos de negocios y funciones del
sistema, y aspectos concretos como expresiones de lenguajes de programación,
esquemas de bases de datos y componentes de software reutilizables
7
Los diagramas UML utilizados en el presente tema de tesis son los siguientes:
Diagramas a utilizar en el Proyecto

Diagrama Descripción
Los casos de uso permiten obtener información acerca de la
manera como un sistema o negocio trabaja, o cómo se desea que
Diagrama de trabaje; se describe bajo la forma de acciones y reacciones, el
Casos de Uso comportamiento de un sistema desde el punto de vista del usuario.
Para el caso del presente sistema se especificaran los casos de
uso de “Administración de torneos” y “Administración de Partidas”.
Se presentan los elementos más estables del sistema, los cuales
son los dispositivos de control de datos e información,
correspondientes a las clases del sistema, con sus relaciones
estructurales y de herencia. El modelo de casos de uso aporta
Diagrama de
información para establecer las clases, objetos, atributos y
Clases
operaciones. Entre las clases a considerar en el presente se
incluyen los siguientes elementos: torneo, tipo de torneo, jugador,
partida, movimientos de partida, tipo de resultados y las
categorías o divisiones en las que esta dividido el torneo.
Presenta una interacción, la cual es un conjunto de mensajes entre

un conjunto de instancias interactuando, las cuales son un grupo
de estímulos entre instancias con el efecto de determinar el
funcionamiento deseado de un proceso o un resultado. Se
Diagrama de detallaran los siguientes procesos en los diagramas de secuencia
Secuencias del presente proyecto: “Mantenimiento de Partidas”,
“Mantenimiento de torneos“, “Mantenimiento de Jugadores”,
“Mantenimientos de divisiones de torneo”, “Búsqueda de Partidas”,
“Emparejamientos de jugadores”, “Ingreso de Resultados”,
“Ingreso de Partidas” y “Lectura de Partidas”.
Tabla 5. Diagramas a utilizar en el Proyecto
8
1.3. Lenguajes de Programación
Los lenguajes de programación son una de las principales herramientas de las que se
dispone para especificar de forma precisa las operaciones que debe realizar una
computadora sobre los datos para proporcionar unos resultados o servicios.
Hoy en día existe un amplio abanico de posibilidades. Cada lenguaje de programación

tiene sus propias características, ventajas y desventajas. Es muy importante encontrar
el lenguaje más apropiado para la realización del proyecto porque este nos proveerá
de los recursos necesarios para el adecuado cumplimiento de las tareas establecidas.
Entre las tareas a realizar en este proyecto se encuentran principalmente: la adecuada
interacción con la base de datos y el diseño de interfaces gráficas,
9
A continuación se describe brevemente a cada uno de los lenguajes de programación
candidatos a elaborar el presente proyecto:
Lenguajes de Programación
Lenguaje Descripción
Es un lenguaje de programación orientado a objetos desarrollado por
Sun Microsystems a principios de los años 1990. Las aplicaciones
Java están típicamente compiladas en un bytecode el cual es
normalmente interpretado o compilado a código nativo para la
ejecución.
El lenguaje en sí mismo toma mucha de su sintaxis de C y C++, pero

tiene un modelo de objetos más simple y elimina herramientas de
Java
bajo nivel como punteros. Sun Microsystems proporciona una
implementación GNU (General Public License) de un compilador
Java y una máquina virtual Java aunque la biblioteca de clases que
se requiere para ejecutar los programas Java no es software libre.
A mediados del 2007, Sun Microsystems liberó la mayor parte de sus

tecnologías Java bajo la licencia GNU GPL, de tal forma que
prácticamente todo el Java de Sun es ahora software libre [9].
“Es un lenguaje de programación orientado a objetos que se puede
considerar una evolución de Visual Basic implementada sobre el
framework .NET. Su introducción resultó muy controvertida, ya que
debido a cambios significativos en el lenguaje VB.NET no es
compatible hacia atrás con Visual Basic, cosa que causó gran
división en la comunidad de desarrolladores de Visual Basic.
Visual
Basic .NET Como pasa con todos los lenguajes de programación basados en
.NET, los programas escritos en VB.NET requieren el Framework
.NET para ejecutarse. Cabe señalar que el .NET Framework es una
nueva plataforma diseñada para simplificar el desarrollo de
aplicaciones en el entorno distribuido de Internet” [12]. Es necesario
el uso de licencias para utilizar esta herramienta.
Tabla 6. Descripción de lenguajes de programación a elegir
10
1.4. Base de Datos
Una base de datos es un conjunto de datos almacenados siguiendo una estructura

lógica. Tan importante son los datos que esta contiene como la estructura utilizada
para la relación entre ellos. Esta interrelación es la que marca la diferencia entre una
buena y mala base de datos.
Una base de datos debe:
• Evitar problemas como la ambigüedad de datos y su duplicación.

• Simplificar con un buen diseño las operaciones de búsqueda, inserción, etc.
• Ser escalable, facilitando posibles ampliaciones
Actualmente existen varios sistemas especializados en la creación y gestión de una

base de datos. En este proyecto se utiliza SQLite, pero cabe destacar que existe en el
mercado diversas soluciones alternativas que pueden ser una muy buena selección
para esta finalidad, como por ejemplo PostgreSQL o MySQL.
Gestores de Base de Datos

Gestor Descripción
Es el sistema para gestionar bases de datos relacionales, licenciado

bajo GPL de la GNU más popular hoy en día. Fue creado por la
empresa sueca, MySQL AB, al tener que conectar el gestor mSQL a
las propias tablas MySQL AB [13].
Se caracteriza por ser un gestor rápido y muy eficiente. Su diseño

multihilo permite soportar una gran carga. Es capaz de trabajar con
una buena cantidad de tipos de datos diferentes y hasta 32 índices
MySQL
por tabla, además mantiene un buen nivel de seguridad.
MySQL es portátil a la mayoría de sistemas operativos (Unix, Mac,

Windows, etc.) abarcando así a un mayor número de usuarios. Pero
en realidad su gran aceptación es debida a la más considerable
cantidad de librerías y herramientas que permiten trabajar fácil con
MySQL desde cualquier lenguaje de programación (C, C++, Java,
PHP, Perl, etc.)
11
SQLite es un proyecto de dominio público, su creador es D. Richard
Hipp, el cual implementa una pequeña librería de aproximadamente
500kb, programado en el lenguaje C, de dominio público, totalmente
libre y que tiene con función hacer de un sistemas de bases de datos
relacional.
Uno de las primeras diferencia entre los motores de Bases de datos

SQLite
convencionales es su arquitectura cliente/servidor, pues SQLite es
independiente, simplemente se realizan llamadas a sub rutinas o
funciones de las propias librerías de SQLite, lo cual reduce
ampliamente la latencia en cuanto al acceso a las bases de datos.
Con lo cual podemos decir que las base de datos compuesta por la
definición de las tablas, índices y los propios datos son guardados
por un solo fichero estándar y en un solo ordenador [25].
PostGreSQL es un sistema gestor de base de datos objeto-relacional

creado en la Universidad de Berkeley como consecuencia del
proyecto POSTGRES, Su implementación comenzó en 1986 pero
hasta 1994 no apareció una pequeña versión bajo la licencia
OpenSource, siendo su nombre en esa época PostGre95 [11].
Finalmente en 1996 para reflejar la relación que tenía con el lenguaje
SQL modificaron su nombre llamándoles PostGreSQL.
Para este proyecto se decidió no usar esta base de datos por las
PostGreSql siguientes razones:
• Está pensada para gestionar bases de datos con un volumen
de datos importante, disminuyendo su efectividad en bases de
datos relativamente pequeñas, como la que utilizará este
proyecto.
• Consume mucho más recursos que MySQL y carga
innecesariamente el sistema.
• Según expertos es de dos a tres veces más lenta que
MySQL.
• La sintaxis no es muy intuitiva, dificultando relativamente su
utilización.
Tabla 7. Descripción de gestores de base de datos
12
1.5. Arquitectura Cliente – Servidor
La arquitectura cliente-servidor llamado modelo cliente-servidor o servidor-cliente es

una forma de dividir y especializar programas y equipos de cómputo a fin de que la
tarea que cada uno de ellos realiza se efectúe con la mayor eficiencia, y permita
simplificarlas.
Figura 1. Modelo Cliente-Servidor con tres capas.
En un esquema cliente-servidor, se denomina cliente la máquina que solicita un

determinado servicio y se denomina servidor la máquina que lo proporciona. El
servicio puede ser la ejecución de un determinado algoritmo, el acceso a determinado
banco de información o el acceso a un dispositivo hardware. En esta arquitectura la
capacidad de proceso está repartida entre el servidor y los clientes. En el modelo
cliente-servidor, el trabajo se reparte entre dos ordenadores.
En la actualidad se suele hablar de arquitectura de tres niveles o “n” niveles, donde la

capa de almacenamiento y la de aplicación se ubican en (al menos) dos servidores
diferentes, conocidos como servidores de datos y servidores de aplicaciones.
13
1.5.1. Capas
La arquitectura del sistema puede estar dividida en capas. Todas estas capas pueden
residir en un único ordenador (no sería lo normal), si bien lo más usual es que haya
una multitud de ordenadores donde reside la capa de presentación (son los clientes de
la arquitectura cliente/servidor).
Las capas de negocio y de datos pueden residir en el mismo ordenador, y si el

crecimiento de las necesidades lo aconseja se pueden separar en dos o mas
ordenadores. Así, si el tamaño o complejidad de la base de datos aumenta, se puede
separar en varios ordenadores los cuales recibirán las peticiones del ordenador en que
resida la capa de negocio.
Capas de Arquitectura
Capas Descripción
Es la que ve el usuario (hay quien la denomina "capa de usuario"),

presenta el sistema al usuario, le comunica la información y
Capa de captura la información del usuario dando un mínimo de proceso
Presentación (realiza un filtrado previo para comprobar que no hay errores de
formato). Esta capa se comunica únicamente con la capa de
negocio.
Es la que ve el usuario (hay quien la denomina "capa de usuario"),

presenta el sistema al usuario, le comunica la información y
Capa de captura la información del usuario dando un mínimo de proceso
Negocio (realiza un filtrado previo para comprobar que no hay errores de
formato). Esta capa se comunica únicamente con la capa de
negocio.
Es donde residen los datos. Está formada por uno o más gestor de
Capa de bases de datos que realiza todo el almacenamiento de datos,
Datos reciben solicitudes de almacenamiento o recuperación de
información desde la capa de negocio.
Tabla 8. Capas de Arquitectura
14
1.6. Requerimientos
Las funcionalidades o servicios que el sistema debe contemplar para cumplir con los
objetivos planteados inicialmente son los siguientes:
1.6.1. Módulo de Administración de Torneos
Los requerimientos asociados a la administración de los torneos son los siguientes:
Requerimientos
código Descripción Tipo Dificultad Prioridad
El sistema permitirá el registro, la
edición y la eliminación de los
TOR-001 Funcional 3 2
jugadores participantes de los
torneos a realizar.
El sistema permitirá registrar los
siguientes datos de los jugadores:
nombre, apellidos, fecha de
nacimiento y ranking.
El sistema permitirá realizar la
búsqueda de jugadores por
diferentes criterios: nombre y
apellidos.
El sistema permitirá el registro de
torneos indicando nombre del torneo,
TOR-004 fecha de inicio, fecha de fin, lugar del Funcional 2 1
evento y definición de premios a
otorgar
El sistema permitirá el ingreso, la
edición y la eliminación de los
torneos registrados en la base de
datos.
El sistema permitirá el ingreso de
partidas realizadas dentro de los
torneos haciendo uso de la interfaz
gráfica de ingreso de partidas.
15
El sistema permitirá dentro del
módulo de ingreso de partidas indicar
jugadores participantes, fecha, lugar,
torneo y resultado del juego.
El sistema permitirá la edición de los
TOR-008 movimientos de la partida a registrar Funcional 1 1
habilitando un botón de retroceso.
El sistema permitirá la inclusión de
comentarios en el ingreso de las
partidas, jugada por jugada si fuese
el caso.
El sistema permitirá el registro de
partidas interpretando la lista de
movimientos de una partida de
ajedrez si así fuese el caso
El sistema permitirá la selección del

tipo de torneo a realizar.
El sistema permitirá el
TOR-012 emparejamiento de jugadores ronda Funcional 1 1
por ronda de forma automática.
El sistema generará los reportes de
resultados de cada ronda jugada.
Tabla 9. Requerimientos del módulo de administración de torneo
16
1.6.2. Módulo de Administración de Partidas
Los requerimientos asociados a la administración de las partidas son los siguientes:
Requerimientos
El sistema permitirá la búsqueda de
partidas del sistema por los siguientes
PAR-001 Funcional 2 2
criterios: nombre de jugador, nombre
de torneo, fecha de juego.
El sistema permitirá la inclusión de
comentarios sobre las partidas que
anteriormente fueron ingresadas al
sistema.
El sistema permitirá la visualización de
la partida elegida haciendo uso de
botones para avanzar y retroceder las
jugadas.
El sistema permitirá la generación de
reportes en formato pdf (a partir de un
archivo Formatting Objects) con los
PAR-004 datos básicos de la partida, el detalle Funcional 1 2
de las jugadas, los comentarios
agregados y el gráfico del tablero en la
posición de la partida deseada.
El sistema permitirá al usuario apreciar
los movimientos de todas las piezas
de un tablero de ajedrez si así se
requiriese.
Tabla 10. Requerimientos del módulo de aprendizaje
17
1.6.3. Características Generales del Sistema
Los requerimientos generales del sistema son los siguientes:
Requerimientos
La arquitectura del sistema seguirá No

GEN-001 2 1
el modelo cliente-servidor. Funcional.
El lenguaje de programación será No

GEN-002 3 1
JAVA. Funcional.
Los componentes servidor correrán

No
GEN-003 en el gestor de Base de Datos 3 1
Funcional.
SQLite.
El sistema correrá bajo el Sistema No

GEN-004 3 1
Operativo Windows XP. Funcional.
El sistema correrá con una interfaz No

GEN-005 3 1
gráfica amigable al usuario. Funcional.
El sistema ha de ser fiable. Toda la

información que debe contener la
base de datos ha de ser correcta y
No
GEN-006 única, por ejemplo no deben existir 3 1
Funcional.
duplicados por lo que el sistema
validará adecuadamente la
información ingresada.
Tabla 11. Requerimientos no funcionales del sistema
18
Dificultad
valores Descripción
1 Alta
2 Media
3 Baja
Tabla 12. Descripción de valores del criterio dificultad.
Prioridad
1 Alta
2 Media
3 Baja
Tabla 13. Descripción de valores del criterio prioridad.
Tipo de torneo
1 Sistema Suizo
2 Todos contra todos (1 vuelta)
3 Todos contra todos (2 vueltas)
Tabla 14. Descripción de valores de tipo de torneo.
19
1.7. Modelos de Casos de Uso
En esta sección se presentan los diagramas de casos de uso del presente sistema
obtenidos durante el proceso de especificación de requisitos, los cuales permiten
mostrar la funcionalidad del sistema más detalladamente.
1.7.1. Caso de Uso de Administración de torneos
El siguiente diagrama describe los casos de uso que corresponde a la administración

de torneos del sistema:
Generar Reportes
Calcular ELO
Ingresar Resultados
<<include>>
Generar Emparejamientos
Administrador del Sistema

<<include>>
Mantenimiento de Divisiones
Mantenimiento de Jugadores
<<include>>
Mantenimiento de Torneo
Elegir Division
<<extend>>
<<include>>
<<include>>
Inscribir Jugadores a División
Buscar Jugadores
Figura 2. Caso de uso Administración de torneos
20
A continuación se muestra una breve explicación de los casos de uso mencionados:
Detalle de Casos de Uso de Administración de torneos

Caso de Uso Descripción de Caso de Uso
Mantenimiento de Se encarga de registrar, actualizar y eliminar
Jugadores jugadores del sistema.
Mantenimiento de Se encarga de registrar, actualizar y eliminar los
Torneo torneos registrados en el sistema.
Mantenimiento de Se encarga de registrar, actualizar y eliminar las
Divisiones divisiones de un torneo.
Se encarga de buscar a los jugadores registrados en la
Buscar Jugadores
base de datos del sistema.
Se encarga de la elección de las divisiones existentes
Elegir División en la cual un jugador quedará registrado para
participar en esa división del torneo.
Se encarga de crear los enfrentamientos entre
Generar
jugadores ronda por ronda siguiendo las reglas
Emparejamientos
establecidas en el torneo previamente elegido.
Se encarga de elegir entre los jugadores registrados
Inscribir Jugadores
en la base de datos a los que participarán en la
a División
división del torneo a elegir.
Registrar Se encarga de registrar los resultados de los
Resultados enfrentamientos previamente establecidos.
Se encarga de calcular un valor que mide a habilidad
Calcular ELO
de un jugador en el juego del ajedrez.
Permite obtener reportes de los detalles del torneo:
Generar Reportes resultados de las rondas del torneo, tabla de
posiciones, estadísticas de los jugadores.
Tabla 15. Casos de Uso de Administración de torneo
21
1.7.2. Caso de Uso de Partidas
Este paquete contiene los casos de uso que corresponde al mantenimiento de

usuarios.
Leer m ovim ientos de Partida Buscar Partidas
<<extend>>
Generar Reportes de Partidas
Adm inistrador del Sistem a
Ingresar Nueva Partida
Com entar Partidas
Aprender Jugadas Básicas
Figura 3. Caso de uso de Partidas
22
A continuación se muestra una breve explicación de los casos de uso mencionados:
Detalle de Casos de Uso de Administración de Partidas

Caso de Uso Descripción de Caso de Uso
Se encarga de agregarle comentarios a las partidas con el
Comentar
fin de poder tener un alcance más preciso sobre el
Partidas
desarrollo del juego.
Aprender jugadas Se encarga de mostrar las jugadas básicas de las piezas
básicas de ajedrez sobre un tablero de juego.
Se encarga de la búsqueda de las partidas registradas en
Buscar Partidas
el sistema.
Generar Reportes Se encarga de obtener los reportes del torneo: resultados
de Partida de rondas del torneo, tabla de posiciones, etc.
De encarga de interpretar los movimientos que describen
Leer Movimientos
a un juego de ajedrez que luego es reproducido en un
de Partida
tablero gráfico del sistema.
Ingresar Nueva Se encarga de registrar una partida de ajedrez en la base
Partida de datos del sistema.
Tabla 16. Casos de Uso de Administración de Partidas
23
1.8. Especificación de Casos de Uso
Esta sección contiene las principales especificaciones de los casos de uso del
sistema. Todos estos han sido descritos utilizando el esquema mostrado en la
presente tabla que a continuación se detalla:
Caso de Uso: nombre del caso de uso

Código: Código del caso de uso
Actor: Actores que participan del caso de uso
Descripción: Descripción de lo que realiza en caso de uso
Precondición: Se explica en qué estado debe estar el sistema antes de ejecutarse
el caso de uso
Flujo Principal
Acción del Usuario Respuesta del Sistema
Explicación del flujo normal o
Explicación de lo que ocurre por el
1 esperado al ejecutarse el caso de 2
lado del sistema.
uso.
Flujo Alternativo
Acción del Usuario Respuesta del Sistema
Explicación del flujo anormal o no
Explicación de lo que ocurre por el
1 esperado al ejecutarse el caso de 2
lado del sistema.
uso.
Poscondición: Se explica el estado en que queda el sistema luego de la ejecución
del caso de uso.
Observaciones: Se agrega cualquier información que sea de utilidad.
Tabla 17. Especificación de Caso de Uso
A continuación se detallan las especificaciones de los todos los casos de uso

obtenidos en el sistema, los cuales se detallan a continuación:
24
1.8.1. Mantenimiento de Jugadores
Las especificaciones del caso de uso “Mantenimiento de Jugadores” son descritas en

la siguiente tabla:
Caso de Uso: Mantenimiento de Jugadores

Código: CUAT_01
Actor: Administrador del Sistema
Descripción: Se encarga de agregar y actualizar a los jugadores registrados en
la base de datos.
Precondición: La base de datos del sistema debe estar iniciada.
Flujo Principal: Ingresar nuevo Jugador al Sistema
Acción del usuario Respuesta del Sistema
Ingresar a la ventana de El sistema abre la ventana “Inscribir
“Administración de torneo” y presionar Jugadores” con la pestaña “Ingresar
1 2
el botón “Agregar Jugadores” Jugadores” activada.
Se ingresa la información del nuevo
jugador según los campos: “Apellido
El sistema graba exitosamente el
Paterno”, “Apellido Materno”,
registro del nuevo jugador en la base
3 “Nombres”, “País”, “Rating”, “Fecha 4
de datos del sistema.
de Nacimiento” y “Sexo”. Se presiona
el botón “Registrar Nuevo Jugador”.
Flujo Alternativo: Actualizar información de Jugador
<<include>> Registrar Partida. Se
El sistema abre la ventana “Elegir
elige el botón “…” que corresponde a
1 2 Jugador” con la pestaña “Elegir
uno de los jugadores que juegan la
Jugador” activada.
partida
El sistema filtra los registros según el
El usuario ingresa en la caja de texto
criterio de búsqueda ingresado. Si
“Jugador a Buscar” el criterio de
3 4 no hay jugadores que cumplen con
búsqueda para hallar el jugador
el criterio la grilla de la ventana
deseado.
aparece sin registros.
El sistema activa la pestaña
El usuario selecciona el jugador a “Ingresar Jugadores” de la misma
5 editar y se presiona el botón 6 ventana con los campos del jugador
“Actualizar Datos” seleccionado mostrados en los
componentes de la ventana listos a
25
ser actualizados.
El usuario actualiza la información del

7 jugador seleccionado y presiona el 8 Los datos son actualizados de forma
exitosa.
botón “Actualizar Datos”.
Flujo Alternativo: Eliminar Jugador
Ingresar a la ventana de
“Administración de torneo”, elegir la
El sistema activa en el panel “Datos
división en la cual se encuentra el
de Jugador” el botón “Eliminar de
jugador a ser eliminado dentro del
1 2 División”. Si la división del torneo
árbol “Vista de Torneo” y
aún no se ha iniciado el jugador
posteriormente elegir al jugador
procederá a ser eliminado.
inscrito en esa división y que aparece
como una hoja en el mismo árbol.
Poscondición: Se registra en la base de datos la información del jugador
ingresado.
Observaciones: Se puede agregar nuevos jugadores a la base de datos en
cualquier momento de la administración de un torneo.
Tabla 18. Especificación de Caso de Uso: “Mantenimiento de Jugadores”
26
1.8.2. Mantenimiento de Torneo
Las especificaciones del caso de uso “Mantenimiento de Torneo” son descritas en la

siguiente tabla:
Caso de Uso: Mantenimiento de torneo

Código: CUAT_02
Descripción: Se encarga de agregar, editar y eliminar a los torneo s registrados
en el sistema
Flujo Principal: Ingresar nuevo torneo al Sistema

El sistema muestra las opciones del
El caso de uso se inicia cuando el
menú inicio: “Pantalla Principal”,
1 usuario selecciona el menú “Inicio” 2
“Nuevo Torneo” y “Salir”.
El sistema abre la ventana “Crear
Se elige la opción “Nuevo Torneo”
3 4 Nuevo Torneo”.
Los campos a registrar para crear el
nuevo torneo son: “Nombre de
Torneo”, “Ciudad”, “Fecha de Inicio”, El sistema registra exitosamente el
5 “Fecha Final”, y “Organizador”. El 6 nuevo torneo.
usuario presiona el botón “Crear
Torneo”
Flujo Alternativo: Cancelar creación de torneo
El usuario presiona el botón “Salir” y
El sistema cancela el registro del
1 se abandona la ventana cancelando 2
nuevo torneo.
la creación del torneo.
Flujo Alternativo: Búsqueda de registro de un torneo
<<Include “Registrar Partida”>>
El sistema abre la ventana “Elegir
El usuario presiona el botón “…”
2 torneo” donde se cargan los torneos
1 correspondiente a la búsqueda de
que se encuentren activos.
torneos.
27
El sistema muestra en la grilla los
registros coincidentes al criterio de
El usuario ingresa su criterio de búsqueda ingresado por el usuario.
búsqueda en la caja de texto “Torneo 4 Si el criterio de búsqueda no
3
a Buscar” coincide con ningún registro se
muestra la grilla de la ventana “Elegir
torneo” sin registros.
Flujo Alternativo: Actualizar el registro de un torneo
El sistema activa la pestaña
<<Include “Buscar torneo”>>.
“Ingresar Nuevo Torneo” de la
El usuario elige el registro a ser
ventana “Elegir torneo” donde los
actualizado y presiona el botón
1 2 campos del registro seleccionado
“Actualizar datos” de la ventana
aparecen en sus respectivas cajas
“Elegir torneo”
de texto listos para ser actualizados.
El usuario una vez actualizado los
campos del registro seleccionado
El sistema actualiza exitosamente el
presiona el botón “Actualizar datos”
3 4 registro.
de la pestaña “Ingresar Nuevo
Torneo”
Flujo Alternativo: Eliminar el registro de un torneo
El sistema muestra las opciones del
El usuario selecciona el menú “Inicio” menú inicio: “Pantalla Principal”,
1 2
“Nuevo Torneo” y “Salir”
El usuario elige el registro del torneo

a ser eliminado de la grilla “Torneos
El sistema elimina exitosamente el
Abiertos” de la ventana “Pantalla
3 4 registro de torneo
Principal”. A continuación presiona el
botón “Eliminar”.
Poscondición: Se registra en la base de datos la información del torneo ingresado.
Observaciones: Este es el primer paso a dar para iniciar la gestión de un torneo en
el sistema
Tabla 19. Especificación de Caso de Uso: “Mantenimiento de torneo”
28
1.8.3. Mantenimiento de Divisiones
Las especificaciones del caso de uso “Mantenimiento de Divisiones” son descritas en

la siguiente tabla:
Caso de Uso: Mantenimiento de divisiones

Código: CUAT_03
Descripción: Este caso de uso se encarga de registrar y actualizar las divisiones
de torneo del sistema. El Administrador del Sistema inicia el caso
de Uso.
Precondición: La base de datos del sistema debe estar iniciada. Un torneo debe
estar activado para proceder a mantener a la división.
Flujo Principal: Ingresar nueva división al Sistema
El sistema abre la ventana “Agregar
1 “Administración de torneo” y presionar 2
División a Torneo”.
el botón “Agregar Divisiones”.
Ingresar los datos correspondientes a

la división de torneo a jugar: “nombre
El sistema procede a registrar
de la división”, “tipo de torneo”,
3 4 exitosamente la nueva división del
“número de rondas”, “puntos por
torneo en la base de datos.
bye”, “descripción”. Se presiona el
botón ”Aceptar”.
Flujo Alternativo: Editar División de Sistema
“Administración de torneo” y elegir la El sistema abre la ventana
1 2
división del torneo a ser eliminada. “Actualizar División a Torneo”.
Presionar el botón “Editar División”.
El usuario procede a actualizar la El sistema actualiza

3 información del registro de división 4 satisfactoriamente el registro de la
del torneo. división del torneo.
Poscondición: Se registra en la base de datos la información del torneo ingresado.

Observaciones: Este es el primer paso a dar para iniciar la gestión de un torneo en
el sistema.
Tabla 20. Especificación de Caso de Uso: “Mantenimiento de Divisiones”
29
1.8.4. Buscar Jugadores
Las especificaciones del caso de uso “Buscar Jugadores” son descritas en la siguiente
tabla:
Caso de Uso: Buscar Jugadores

Código: CUAT_04
Descripción: Este caso de uso se encarga de registrar, actualizar y eliminar las
partidas de ajedrez registradas en el sistema. El Administrador del
Sistema inicia el caso de Uso.
Flujo Principal: Buscar Jugadores
Se muestra el submenú de la opción

principal “Partida” con las siguientes
1 El usuario presiona la opción “Partida” 2
opciones: “Ingresar Partidas”, “Leer
del menú principal del programa.
Partidas”, “Buscar Partidas”.
El usuario elige la opción “Buscar El sistema muestra la ventana

3 4
Partidas” del submenú activado. “Buscar Partidas”.
El sistema filtra los registros según el
El usuario ingresa en la caja de texto
criterio de búsqueda ingresado. Si
“Jugador a Buscar” el criterio de
5 6 no hay jugadores que cumplen con
búsqueda para hallar el jugador
el criterio la grilla de la ventana
deseado.
aparece sin registros.
Poscondición: Ninguna.
Observaciones: La búsqueda de jugadores es un proceso independiente del
sistema que puede ejecutarse en cualquier momento de la gestión
de un torneo.
Tabla 21. Especificación de Caso de Uso: “Buscar Jugadores”
30
1.8.5. Elegir División
Las especificaciones del caso de uso “Elegir División” son descritas en la siguiente
tabla:
Caso de Uso: Elegir División

Código: CUAT_05
Descripción: Este caso de uso se encarga de detallar los procesos involucrados
en la selección de una división. El Administrador del Sistema inicia
el caso de Uso.
Flujo Principal: Elegir División

<< include “Mantenimiento de
El sistema automáticamente adiciona un
Divisiones” >>. El usuario
1 2 registro en la lista desplegable de la
previamente creó una nueva
ventana “Agregar Jugadores”.
división.
El usuario elige de entre las
opciones mostradas por la lista
desplegable y selecciona el
3
registro de la división de torneo
con la que desea trabajar.
Fin de caso de uso.
Poscondición: Debe de aparecer en la lista desplegable “División” la división
recién ingresada.
Observaciones: Ninguna.
Tabla 22. Especificación de Caso de Uso: “Elegir División”
31
1.8.6. Generar Emparejamientos
Las especificaciones del caso de uso “Generar Emparejamientos” son descritas en la

siguiente tabla:
Caso de Uso: Generar Emparejamientos

Código: CUAT_06
Precondición: Para empezar a generar los enfrentamientos entre los jugadores de
una división de torneo primero se debe crear la división y luego
inscribir a los jugadores en esa división.
Flujo Principal: Generar Emparejamientos
El usuario selecciona la El sistema abre la ventana Principal del
1 opción “Pantalla Principal” del 2 Sistema mostrando una grilla con los
menú del sistema. registros de los torneos disponibles.
El usuario selecciona el torneo El sistema abre la ventana “Administración

al que desea ingresar y de torneos” mostrando todas las divisiones
3 4
presiona el botón “Abrir creadas en la “Vista de Torneo” en el flanco
Torneo”. izquierdo de la ventana
El sistema muestra la ventana “Resultados

El usuario presiona el botón del torneo” con una grilla donde se enlista a
5 6
“Ingresar Resultados”. los jugadores inscritos en la división del
torneo
Si el tipo de torneo es “Sistema Suizo” se

activan ronda por ronda los botones que se
encuentran en la parte inferior que son los
que muestran las ventanas con los
El usuario presiona el botón
7 8 enfrentamientos generados.
“Siguiente”
Si el tipo de torneo es “Todos contra todos”

se activan todos estos botones a la vez
pudiendo a partir de aquí ingresar los
32
resultados de los enfrentamientos.
Además se muestran los identificadores, los

nombres, el ELO, el país de los jugadores
participantes y los puntos obtenidos así
como el identificador de su rival, el color con
el que juega y el resultado obtenido ronda
por ronda. Fin de caso de uso.
Se registra en la base de datos los enfrentamientos generados

Poscondición:
ronda por ronda.
Observaciones: Este es el proceso principal del sistema
Tabla 23. Especificación de Caso de Uso: “Generar Emparejamientos”
33
1.8.7. Inscribir Jugadores a División
Las especificaciones del caso de uso “Inscribir Jugadores a División” son descritas en
la siguiente tabla:
Caso de Uso: Inscribir Jugadores a División

Código: CUAT_07
Descripción: Este caso de uso se encarga del registro de un jugador de la base
de datos en la división seleccionada de un torneo. El Administrador
del Sistema inicia el caso de Uso.
Precondición: La base de datos del sistema debe estar iniciada y la división a ser
utilizada no debe de haber sido iniciada.
Flujo Principal: Inscribir Jugadores a División
El usuario selecciona la opción
El sistema abre la ventana Principal
1 “Pantalla Principal” del menú del 2
del Sistema.
sistema.
El sistema abre la ventana “Inscribir
Jugadores” con la pestaña “Inscribir
El usuario presiona el botón “Agregar
3 4 Jugadores” activada y la grilla de la
Jugadores”.
ventana llena con los registros de los
jugadores del sistema.
El usuario busca al jugador que

desee inscribir en la división de
torneo elegida. Ingresa su criterio de
búsqueda en la caja de texto El sistema registra exitosamente a el
“Jugador a Buscar”. Selecciona al jugador elegido en la división de
5 6
jugador deseado y elige una división torneo seleccionada. Fin de caso de
disponible de la lista desplegable uso.
“División” del panel “Inscribir
Jugador”. Presiona el botón “Agregar
a Torneo”.
Flujo Alternativo: Registrar nuevo Jugador de Sistema

Si el jugador a inscribir en torneo no
El sistema registra al nuevo jugador
1 se encuentra en el sistema se 2
exitosamente.
procede a registrarlo en la base de
34
datos. Se elige la pestaña “Ingresar
Jugadores” y se procede a ingresar
la información requerida del jugador.
Poscondición: Se registra en la base de datos el ingreso del jugador seleccionado
en la división de torneo elegida.
Observaciones: Tienen que haber disponible torneos que todavía no hayan sido
iniciados para que estos aparezcan en la lista desplegable
“División”
Tabla 24. Especificación de Caso de Uso: “Inscribir Jugadores a División”
35
1.8.8. Ingresar Resultados
Las especificaciones del caso de uso “Ingresar Resultados” son descritas en la

siguiente tabla:
Caso de Uso: Ingresar Resultados

Código: CUAT_08
Descripción: Este caso de uso se encarga de registrar en el sistema los
resultados obtenidos de los emparejamientos previamente
realizados. El Administrador del Sistema inicia el caso de Uso.
Flujo Principal: Ingresar Resultados
<<include “Generar El sistema abre la ventana “Registrar
Emparejamientos”>>. El usuario Resultados” donde muestra una
1 presiona el botón de ingreso de 2 grilla con la descripción de los
resultados de la ronda que se enfrentamientos a realizarse en
encuentra jugando actualmente. dicha ronda.
El usuario presiona la celda formada El sistema muestra una lista

por la columna “Resultado” de la grilla desplegable en la misma celda
3 de la ventana con la fila del registro 4 dentro de la grilla que muestra las
de emparejamientos que desee distintas opciones de resultados que
ingresar el resultado en el sistema el usuario deberá elegir.
El usuario elige la opción de la lista

desplegable que mejor refleje el El programa registra exitosamente el
5 resultado de la partida que desea 6 resultado del enfrentamiento en la
registrar. A continuación el usuario base de datos del sistema.
presiona el botón “Guardar”.
Poscondición: Se registra en la base de datos el resultado del encuentro

gestionado
Observaciones: Ninguna
Tabla 25. Especificación de Caso de Uso: “Ingresar Resultados”
36
1.8.9. Calcular ELO
Las especificaciones del caso de uso “Calcular ELO” son descritas en la siguiente
tabla:
Caso de Uso: Calcular ELO

Código: CUAT_09
Descripción: Este caso de uso se encarga del cálculo de ELO del jugador
seleccionado tanto del torneo en el que participa como en la lista
oficial de la FIDE. El Administrador del Sistema inicia el caso de
Uso.
Precondición: Debe de haberse iniciado una división de torneo para el cálculo del
ELO del jugador deseado.
Flujo Principal: Calcular ELO dentro de un torneo
El sistema abre la ventana “Calcular
<<Include ”Generar Emparejamientos ELO” con la pestaña “ELO en
” >>. El usuario selecciona de la grilla Torneo” activada y muestra una grilla
1 de la ventana al jugador del que 2 con la lista de oponentes con los que
desea calcular su ELO y presiona el ha jugado y las cifras necesarias
botón “Calcular ELO”. para el cálculo de su ELO dentro de
ese torneo. Fin del caso de uso.
Flujo Alternativo: Calcular ELO FIDE

El sistema muestra una grilla vacía
<<Include ”Generar Emparejamientos
junto a una lista desplegable que
1 ” >>. El usuario elige la pestaña “ELO 2
muestra la cantidad de tornes a ser
FIDE”
ingresados.
El sistema añade a la grilla vacía un

El usuario elige de la lista
número de filas equivalente a la
3 desplegable el número de torneos 4
cantidad de torneos previamente
que desea ingresar.
ingresada.
El usuario selecciona en la columna

El sistema muestra en la caja de
“ELO” de cada fila la cifra de ELO
5 6 texto “ELO FIDE” el nuevo cálculo de
obtenida en cada uno de los torneos
su ELO.
ingresados. Posteriormente elige de
37
la columna “Partidas” de cada fila el
número de partidas jugadas en cada
torneo. A continuación elige entre las
opciones: “Jugador Principiante” y
“Jugador Experto” indicando la cifra
de ELO obtenida en ese momento. El
usuario procede a presionar el botón
“Calcular ELO FIDE”
Poscondición: Se obtiene un nuevo cálculo de ELO del jugador seleccionado.
Observaciones: Este caso de uso no registra los resultados obtenidos en la base de
datos.
Tabla 26. Especificación de Caso de Uso: “Calcular ELO”
38
1.8.10. Generar Reportes de Torneo
Las especificaciones del caso de uso “Generar Reportes de Torneo” son descritas en
la siguiente tabla:
Caso de Uso: Generar Reportes de Torneo

Código: CUAT_10
Descripción: Este caso de uso se encarga de generar los reportes de los
resultados de la gestión de un torneo. El Administrador del Sistema
inicia el caso de Uso.
Precondición: La división de torneo debe de haber sido iniciada.
Flujo Principal: Generar Reporte de Resultados Generales
El sistema genera un archivo de
<<Include ”Generar
extensión xls que registra la
1 Emparejamientos” >>. El usuario 2
información general de la división del
presiona el botón “Generar Reporte”.
torneo. Fin del caso de uso.
Flujo Alternativo: Generar Reporte de Resultados de la Ronda

El sistema genera un archivo de
<<Include ”Ingresar Resultados” >>.
extensión xls que registra los
1 El usuario presiona el botón “Generar 2
resultados obtenidos en la ronda. Fin
Reporte”.
del caso de uso.
Poscondición: Se obtiene un archivo de formato conocido con el registro de los
detalles de una división de torneo.
Observaciones: El formato de los reportes del sistema es de extensión xls.
Tabla 27. Especificación de Caso de Uso: “Generar Reporte de Torneo”
39
1.8.11. Comentar Partidas
Las especificaciones del caso de uso “Comentar Partidas” son descritas en la

siguiente tabla:
Caso de Uso: Comentar Partidas

Código: CUAP_01
Flujo Principal: Comentar Partidas
<<include “Ingreso de Partidas”>> El
usuario en la ventana “Ingreso de El sistema registra el comentario
Partidas” en la pestaña “Jugadas” en efectuado por el usuario en el
la caja de texto “Comentarios” escribe sistema, el cual es grabado en la
1 2
los comentarios pertinentes si así base de datos si el usuario decide
fuera necesario del actual movimiento grabar la partida. Fin de caso de
jugado. Presiona el botón “Agregar Uso.
Comentario”.
Flujo Alternativo: Editar Comentario Ingresado
<<include “Ingreso de Partidas”>>. Si
el usuario decide editar un comentario
El sistema actualiza el comentario
hecho de la partida elige la pestaña
efectuado por el usuario en el
“Comentar” y selecciona el número de
sistema, el cual es grabado en la
1 la jugada donde se hizo el 2
base de datos si el usuario decide
comentario. En la caja de texto
grabar la partida. Fin de caso de
disponible procede a actualizar el
Uso.
comentario realizado presionando el
botón “Ingresar Comentario”.
Poscondición: Se ingresa el comentario en la data de la partida seleccionada
Observaciones: El sistema no graba inmediatamente los comentarios de la partida.
Sólo lo hace cuando el usuario decide grabar la partida en el
sistema.
Tabla 28. Especificación de Caso de Uso: “Comentar Partidas”
40
1.8.12. Aprender Jugadas Básicas
Las especificaciones del caso de uso “Aprender Jugadas Básicas” son descritas en la
siguiente tabla:
Caso de Uso: Aprender Jugadas Básicas

Código: CUAP_03
Descripción: Este caso de uso se encarga de definir la interacción entre el
usuario y cada una de las piezas de ajedrez con el objetivo de
aprender a jugar ajedrez.
Precondición: Ingresar al Sistema
Flujo Principal: Aprender Jugadas Básicas
El caso de uso se inicia cuando el El Sistema muestra una ventana con
usuario selecciona “Aprendizaje de la figura de un tablero de ajedrez y la
movimientos básicos” y elije del menú de pieza de ajedrez seleccionada
1 2
una de las siguientes opciones: alfil, previamente en el menú ubicada
caballo, torre, peón, rey o dama. dentro del tablero.
El Sistema mostrará a la pieza de

El usuario interactuará con la pieza
ajedrez trasladada por el usuario en
de ajedrez mostrada en el tablero
las posiciones del tablero que este
arrastrándola y ubicándola
3 4 desee y que corresponda a una
únicamente por aquellas casillas en
casilla válida de acuerdo a la
las que la pieza pueda hacerlo.
posición anterior de la pieza.
El usuario sale de la ventana al

presionar el botón “Salir”. Termina
5
caso de uso
Flujo Alternativo “Cancelación de Aprendizaje de Movimientos Básicos”

El caso de uso se inicia cuando el El Sistema muestra una ventana con
usuario selecciona “Aprendizaje de la figura de un tablero de ajedrez y la
movimientos básicos” y elije del menú de pieza de ajedrez seleccionada
1 2
una de las siguientes opciones: alfil, previamente en el menú ubicada
caballo, torre, peón, rey o dama. dentro del tablero.
41
El usuario presiona el botón “cancelar
“de la ventana de “Aprendizaje de
3 Movimientos Básicos”. Fin del caso
de uso.
Poscondición: Ninguna
Observaciones: Este caso de uso no interactúa con la base de datos
Tabla 29. Especificación de Caso de Uso: “Aprender Jugadas Básicas”
42
1.8.13. Buscar Partida
Las especificaciones del caso de uso “Buscar Partida” son descritas en la siguiente
tabla:
Caso de Uso: Buscar Partidas

Código: CUAP_04
Descripción: Este caso de uso se encarga de la búsqueda y actualización de las
Flujo Principal: Buscar Partidas

El Sistema muestra una grilla con la
lista de partidas registradas en la
El caso de uso se inicia cuando el
base de datos y un campo disponible
1 usuario selecciona “Buscar Partidas”. 2
para hacer la búsqueda de la partida
deseada
El usuario ingresa o selecciona los

El Sistema verifica los datos, si los
datos que sirvan de filtro a la
encuentra correctos realiza la
búsqueda. Entre los posibles criterios
búsqueda y muestra las ocurrencias,
a buscar están: el nombre del jugador
3 4 en caso las hubiera, en la misma
de piezas blancas, el nombre del
grilla, si no hay ocurrencias la grilla
jugador de piezas negras y el nombre
se muestra vacía.
del torneo.
Se carga la ventana de reproducción

Se selecciona la partida deseada de de partidas con la partida
6
5 la grilla. correspondiente cargada y el caso
de uso termina.
Flujo Alternativo: Editar Partida de Sistema

<<incluye “Buscar Partida”>> Se activa la pestaña “Editar Partida”
Se resalta el registro de la partida con los campos de los registros
1 elegida y se presiona el botón 2 cargados en sus respectivas cajas
“Actualizar Partida” de texto listos a ser editados.
43
El Sistema verifica los datos, si los
El usuario modifica los datos que
encuentra correctos realiza la
desea actualizar y hace clic en el
3 4 actualización, y muestra el mensaje
botón “Guardar”.
“Datos actualizados correctamente”.
Los pasos 1-4 son repetidos para

cada modificación de los datos de
5 una partida. Cuando se selecciona
“Salir” el caso de uso finaliza.
Poscondición: Los datos de la partida han sido actualizados exitosamente.

Tabla 30. Especificación de Caso de Uso: “Buscar Partida”
44
1.8.14. Generar Reporte de Partida
Las especificaciones del caso de uso “Generar Reporte de Partida” son descritas en la
siguiente tabla:
Caso de Uso: Generar Reporte de Partida

Código: CUAP_05
Descripción: Este caso de uso se encarga de generar un reporte que es un
archivo en formato pdf que describe el detalle de la partida que se
encuentra manipulando. El Administrador del Sistema inicia el caso
de Uso.
Precondición: Se debe necesariamente generar una partida en la posición
deseada para obtener un reporte.
Flujo Principal: Generar Reporte de Partida
El sistema abrirá inmediatamente el
programa de lectura de archivos pdf
<<include “Ingresar Partida”>>.
con el archivo que reproduce la
Realizar en el tablero de la ventana
figura del tablero con las piezas en
“Ingreso de Partidas” las jugadas que
1 2 sus posiciones actuales, el listado de
se desean generar en el reporte.
movimientos de las piezas
Presionar en el botón “Generar
efectuadas y los comentarios
Reporte”.
agregados en las jugadas
señaladas. Fin de caso de uso.
Poscondición: Se obtiene un archivo de formato pdf con la información detallada

de la partida que se encuentra jugando.
Observaciones: Se debe tener instalado en la computadora donde se generará el
reporte un programa de lectura de archivos del formato pdf.
Tabla 31. Especificación de Caso de Uso: “Generar Reporte de Partida”
45
1.8.15. Leer Movimientos de Partida
Las especificaciones del caso de uso “Leer Movimientos de Partida” son descritas en
la siguiente tabla:
Caso de Uso: Leer Movimientos de Partida

Código: CUAP_06
Descripción: Este caso de uso se encarga de la lectura de un archivo pgn que
describe los movimientos de una partida de ajedrez. El
Administrador del Sistema inicia el caso de Uso.
Precondición: La base de datos del sistema debe estar iniciada para el registro de
la partida.
Flujo Principal: Leer Movimientos de Partida
El caso de uso se inicia cuando el El Sistema muestra las siguientes
usuario selecciona el menú opciones: Ingresar Partida, Leer
1 2
“Partidas”. Partida, Buscar Partida.
El Sistema muestra una ventana con

El usuario selecciona “Leer partida”.
3 4 un tablero de ajedrez con sus piezas
en posición inicial.
El sistema interpreta los

El usuario elige la pestaña PGN de la
movimientos ingresados y los
ventana “Lectura de Partidas” pega
traduce en movimientos que
5 en la caja de texto los movimientos de 6
posteriormente pueden ser
la partida que desea reproducir y se
reproducidos por el usuario al volver
presiona el botón “Generar Partida”.
al tablero.
El usuario presiona el botón

“Avanzar” para reproducir los
7 movimientos hacia adelante y el
botón “Retroceder” para regresar la
jugadas
Si el usuario lo cree necesario elige
la pestaña “Datos” de la ventana, El sistema registra en la base de
8 llena los datos necesarios y presiona 9 datos los movimientos registrados en
el botón “Grabar”. la partida reproducida
46
Flujo Alternativo: Lectura errónea de un movimiento de partida.
El sistema interpreta los
movimientos ingresados y los
Se realizan los pasos 1-4 del flujo traduce en movimientos que
anterior. El usuario elige la pestaña posteriormente pueden ser
PGN de la ventana “Lectura de reproducidos por el usuario al volver
1 Partidas” pega en la caja de texto los 2 al tablero. Si la notación no refleja
movimientos de la partida que desea correctamente el movimiento de
reproducir y se presiona el botón piezas de una partida de ajedrez el
“Generar Partida”. sistema mostrará un mensaje de
error “No se pudo reproducir la
partida”
Poscondición: Se registra en la base de datos la partida ingresada
Tabla 32. Especificación de Caso de Uso: “Leer Movimientos de Partida”
47
1.8.16. Ingresar Nueva Partida
Las especificaciones del caso de uso “Ingresar Nueva Partida” son descritas en la
siguiente tabla:
Caso de Uso: Ingresar Nueva Partida

Código: CUAP_07
Descripción: Este caso de uso se encarga de registrar, actualizar y buscar las
partidas del sistema.
Flujo Principal: Ingresar Nueva Partida
El caso de uso se inicia cuando el El Sistema muestra las siguientes
usuario selecciona el menú opciones: Ingresar Partida, Leer
1 2
“Partidas”. Partida, Buscar Partida.
El Sistema muestra una ventana con

un tablero de ajedrez con sus piezas
en posición inicial y con los
siguientes campos a ser llenados:
El usuario selecciona “Ingresar
3 nombre de jugador de piezas
partida”. 4
blancas, nombre de jugador de
piezas negras, fecha de partida,
ciudad en la que se disputó a
partida.
El usuario reproduce la partida a
ingresar en el tablero de la ventana El Sistema verifica los datos, si los
de Registro de Partida mediante el encuentra correctos realiza el
arrastre de las piezas. Una vez registro, le asigna un número
5 terminada la reproducción y 6 correlativo (ID partida) y muestra el
agregados los comentarios de las mensaje “Registro realizado
jugadas si así hubiese sido necesario correctamente”.
se hace clic en el botón “Guardar”.
Los pasos 3-6 son repetidos para
cada nuevo registro de una partida.
7 Cuando se selecciona “Salir”, el caso
de uso finaliza
Poscondición: La nueva partida ha sido creada en el Sistema exitosamente.
48
Flujo Alternativo: Generación de movimientos de partida.
El flujo se inicia cuando el usuario
1 selecciona la pestaña “PGN”.
El sistema genera en el área de

El usuario hace clic en el botón texto disponible el conjunto de
2 “Generar Archivo PGN” 3 caracteres que describe los
movimientos realizados en la partida.
Se registra en la base de datos la información relacionada a la
Poscondición:
partida ingresada.
El ingreso de partidas puede ser de uno realizado por un torneo
Observaciones: gestionado por el sistema así como también de una partida
individual.
Tabla 33. Especificación de Caso de Uso: “Ingresar Nueva Partidas”
49
1.9. Diagrama de Secuencias
A continuación se presentan los diagramas de secuencia de las tareas más

importantes descritas en los diagramas de casos uso del presente sistema.
1.9.1. Crear un Torneo
A continuación se muestra el diagrama de secuencia para crear un torneo:
: frmInicio : frmNuevoTorneo2 : torneoBL : torneoDA
: Administrador del Sistema
1 : btnNuevoTorneoActionPerformed()
2 : frmNuevoTorneo2()
3 : crear()
4 : crear()
Figura 4. Diagrama de Secuencia “Crear un Torneo”
La secuencia para poder crear un torneo es la siguiente: entrar al sistema, llamar al

formulario de creación de torneos frmNuevoTorneo2, ingresar la información necesaria
del nuevo torneo a crear la cual es remitida a la capa lógica de la clase torneo, la cual
a su vez requiere de la capa de acceso a datos para registrar la información en la
base de datos del sistema creándose de esta forma el registro del nuevo torneo.
50
1.9.2. Crear y Editar División de Torneo
A continuación se muestra el diagrama de secuencia para agregar y editar divisiones

de un torneo:
: frmAdmTorneo : frmAgregarDivisiones : frmActualizarDivisiones : divisionBL : divisionDA
1 : frmAdmTorneo()
2 : frmAgregarDivisiones()
3 : btnAceptarActionPerformed()
4 : crear()
5 : crear()
6 : btnEditarDivisionActionPerformed()
7 : frmActualizarDivisiones() 8 : actualizarDivisionActual()
9 : actualizarDivisionActual()
Figura 5. Diagrama de Secuencia “Agregar y Editar División de Torneo”
La secuencia para poder crear un torneo es la siguiente: entrar al sistema, llamar al

formulario de creación de divisiones frmAgregarDivisiones, ingresar la información
necesaria de la nueva división de torneo a crear la cual es remitida a la capa lógica de
la clase división, la cual a su vez requiere de la capa de acceso a datos para registrar
la información en la base de datos del sistema creándose de esta forma el registro de
la nueva división del torneo.
Para lograr la actualización de la información de una división de torneo se ingresa a la

ventana frmActualizarDivisiones y se ingresan los datos pertinentes los cuales son
remitidos a la capa lógica de la división de torneo, después a la capa de acceso a
datos y es aquí donde se procede a actualizar el registro de la división.
51
1.9.3. Agregar e Inscribir Jugadores a Torneo
A continuación se muestra el diagrama de secuencia para agregar jugadores a un

torneo:
: frmAdmTorneo : frmAgregarJugadores2 : jugadorBL : jugadorxDivisionBL : jugadorDA : jugadorxDivisionDA
1 : frmAdmTorneo()
2 : frmAgregarJugadores2()
3 : getLstJugadores()
4 : listarJugadores()
5 : getLstJugadores()
6 : llenarGrillaJugadores()
7 : registrarJugador()
8 : crear() 9 : crear()
10 : buscarenListalaDivision()
11 : btnInscribirJugadoresActionPerformed()
12 : crear()
13 : crear()
Figura 6. Diagrama de Secuencia “Agregar Jugadores a Torneo”.
Para poder ingresar jugadores al sistema y registrarlos posteriormente en los torneos

se hace uso de la ventana frmAgregarJugadores2.
La secuencia para poder agregar un nuevo jugador al sistema es la siguiente: entrar al

sistema, llamar a la ventana de creación de jugadores frmAgregarJugadores2, ingresar
la información necesaria del nuevo jugador a crear la cual es remitida a la capa lógica
de la clase jugador, la cual a su vez requiere de la capa de acceso a datos para
registrar la información en la base de datos del sistema creándose el registro del
nuevo jugador.
Si se decide inscribir al jugador en una división de torneo se procede a buscarlo en la

misma ventana, se selecciona el registro y es suficiente para llamar a la función
crear() de la capa lógica de la clase jugadorxDivision, la cual a su vez requiere de la
capa de acceso a datos para el registro de este jugador en la división de un torneo.
52
1.9.4. Emparejar Jugadores
A continuación se muestra el diagrama de secuencia para el emparejamiento de

jugadores.
: frmResultadosTorneo : ButtonSgteListener : divisionBL : rondaBL : jugadorxDivxRondaBL : jugadorxDivxRondaDA
1 : frmResultadosTorneo()
: grupoBL : rondaDA
2 : ButtonSgteListener()
3 : hacerSgte()
4 : crearGruposdePuntuacion()
5 : asignarIdPareo()
6 : emparejarSegunGrupos()
7 : crear()
8 : crear()
9 : actualizarDatosPrevia()
10 : actualizarDatosPrevia()
Figura 7. Diagrama de Secuencia “Emparejar Jugadores”
La secuencia para realizar el emparejamiento de jugadores de una división de torneo

es la siguiente: entrar al sistema, entrar a la ventana de administración de torneos,
entrar a la ventana de resultados de torneo frmResultadosTorneo. Para realizar el
emparejamiento es necesario presionar el botón “Siguiente” de la ventana el cual es
gestionado por la clase ButtonSgteListener que se encarga de cotejar que la ronda
actual se encuentre finalizada y en caso positivo se procede a realizar los
emparejamientos de jugadores para la siguiente ronda.
Para ello se crean los grupos de puntuación para dividir a los jugadores según sus
fortalezas. Si fuera el caso de ser la primera ronda se asigna el identificador a cada
jugador por todo el torneo. Se crea nueva ronda con el método crear() de rondaba y se
inicializan los datos de los jugadores de la división para esta nueva ronda con los
métodos actualizarDatosPrevia() de las capas de lógica y de acceso a datos de la
clase jugadorxDivxRonda.
53
1.9.5. Registrar Resultados de Encuentros Jugados
A continuación se muestra el diagrama de secuencia para ingresar los resultados de

los encuentros jugados:
: frmResultadosTorneo : ButtonListener : frmPonerResultados : jugadorxDivxRondaBL : jugadorxDivxRondaDA : rondaBL : rondaDA
2 : ButtonListener()
3 : ventanaPareo()
4 : frmPonerResultados()
5 : getJugadoresxRonda()
6 : getJugadoresxRonda()
7 : Grabar()
8 : actualizarDatosFinal()
9 : actualizarDatosFinal()
10 : actEstadoEnBD()
11 : actEstadoEnBD()
Figura 8. Diagrama de Secuencia “Ingresar Resultados de Encuentros Jugados”
La secuencia para registrar los resultados de los encuentros jugados en el sistema es

la siguiente: entrar al sistema, llamar a la ventana de resultados de torneo
frmResultadosTorneo, se elabora la tabla de enfrentamientos generada por los
emparejamientos de jugadores de la ronda lo cual es gestionado por la clase
ButtonListener y se muestran en la ventana de ingreso de resultados
frmPonerResultados para registrar los resultados finales de los jugadores
requiriéndose de la capa lógica y de acceso a datos de la clase jugadorxDivxRonda.
Siempre que hayan partidas pendientes se puede actualizar el resultado de todas las
partidas de la ronda jugada, para ello se hace uso de la función actualizarDatosFinal()
de la capa lógica de la clase jugadorxDivxRonda.
En caso contrario, si no existieran partidas pendientes de resultados entonces el

sistema actualiza el estado de la ronda de la división para declararla como finalizada y
así poder emparejar a los jugadores en la siguiente ronda.
54
1.9.6. Ingresar Partidas al Sistema
A continuación se muestra el diagrama de secuencia para ingresar partidas al sistema:
: frmAdmTorneo : frmIngresoPartidas : Evento : frmElegirJugadores : partidaBL : jugadorBL : jugadorDA : partidaDA

1 : frmAdmTorneo()
2 : frmIngresoPartidas()
3 : iniciarVentanaPartida()
4 : Evento()
5 : mouseReleased()
6 : btnJugadorNegrasActionPerformed()
8 : btnJugadorBlancasActionPerformed() 7 : btnElegirJugadorActionPerformed()
9 : getUnJugador()
10 : getUnJugador()
11 : btnElegirJugadorActionPerformed()
12 : getUnJugador()
13 : getUnJugador()
14 : RegistrarPartida()
15 : crear()
16 : crear()
Figura 9. Diagrama de Secuencia “Ingresar Partidas al Sistema”
La secuencia para registrar partidas en el sistema es la siguiente: entrar al sistema,

llamar a la ventana de ingreso de partidas frmIngresoPartidas, ingresar los
movimientos que conforman la partida arrastrando las piezas en el tablero ubicado en
dicha ventana los cuales son interpretados por la clase Evento validándolas y
graficándolas en este tablero.
Para registrar la partida es necesario determinar a los dos jugadores que participan del
juego para lo cual se provee de botones a la ventana de ingreso de partidas que
llamen a la ventana de búsqueda de jugadores frmElegirJugadores. Una vez elegidos
estos jugadores se procede a registrar la partida haciendo uso de la función crear() de
la capa lógica de la clase partida la cual a su vez requiere de la capa de acceso a
datos para registrar la información en la base de datos del sistema creándose de esta
forma el registro de la partida jugada.
55
1.9.7. Buscar y Leer Partidas del Sistema
A continuación se muestra el diagrama de secuencia para buscar y leer partidas del

sistema:
: frmAdmTorneo : frmBuscarPartidas : frmLecturaPartidas : partidaBL : partidaDA
1 : frmAdmTorneo()
2 : frmBuscarPartidas() 3 : getLstPartidas()
4 : listarPartidas()
5 : llenarGrillaPartidas()
6 : btnVerPartidaActionPerformed()
7 : frmLecturaPartidas()
8 : btnAvanzarActionPerformed()
9 : btnRetrocederActionPerformed()
Figura 10. Diagrama de Secuencia “Buscar y Leer Partidas del Sistema”.
Para poder visualizar los movimientos de una partida registrada en el sistema se

realizan los siguientes pasos: entrar al sistema, entrar a la ventana de administración
de torneos frmAdmTorneo, entrar a la ventana de búsqueda de partidas
frmBuscarPartidas e ingresar los criterios de búsqueda correspondientes los cuales
son cotejados en la base de datos del sistema a través de la capa de acceso a datos
de la clase partida. Una vez obtenida esta información la secuencia de movimientos
es mostrada a través del tablero de ajedrez ubicado en la ventana de lectura de
partidas frmLecturaPartidas.
56
1.9.8. Calcular ELO de jugador en torneo
A continuación se muestra el diagrama de secuencia para calcular el ELO de un

jugador en torneo.
: frmResultadosTorneo : frmELO : EloListener : jugadorxDivxRondaBL : jugadorxDivxRondaDA
2 : frmELO()
3 : calculoParaExperimentados()
4 : ELOListener()
5 : getListaContrincantesxELO()
6 : getContrincantesxELO()
Figura 11. Diagrama de Secuencia “Calcular ELO de Jugador”.
La secuencia para calcular el ELO de un jugador al finalizar una división de torneo es

la siguiente: entrar al sistema, entrar a la ventana de administración de torneos, entrar
a la ventana de resultados de torneo frmResultadosTorneo, ingresar a la ventana de
cálculo de ELO habiendo previamente seleccionado al jugador requerido.
A continuación la clase ELOListener se encarga de hacer los cálculos necesarios

requiriendo obtener el ELO de los rivales del jugador seleccionado y computar los
puntos logrados contra estos, para ello se hace uso de las funciones de la capa lógica
y de acceso a datos de la clase JugadorxDivxRonda.
57
1.10. Diagrama de Clases
A continuación se muestran los diagramas de clase utilizados en el sistema por casos

de uso:
1.10.1. Crear Torneo
El proceso de crear un nuevo torneo en el sistema está soportado por el siguiente

diagrama de clases:
torneo
+idTorneo frmNuevoTorneo2
+terminado
+ciudad: String
+nombreTorneo usa
+organizador: String
+ciudad
+nombreTorneo: String
+fechaInicio 1 1
+admtorneo: torneo
+fechaFin
+organizador +frmNuevoTorneo2()
+numeroDivisiones
1
usa
1
torneoBL torneoDA
+torneoBL() +torneoDA()
+crear() usa +crear()
+actualizarNdivisiones() 1 1..* +getNdivTorneo()
+getNDivTorneo() +actualizarNdivisiones()
+getLstTorneos() +listarTorneos()
+actualizarTorneo() +update()
+buscarTorneoxId() +buscarTorneoxId()
Figura 12. Diagrama de clases “Creación de torneo”
La clase de la ventana frmNuevoTorneo2, que es el formulario de creación de los

torneos es la encargada de interactuar con los métodos de las capas lógicas y de
acceso a datos de la clase torneo, que es la que almacena toda la información
general relevante a creación de torneos.
Para observar la secuencia de mensajes entre los objetos de estas clases revise el
diagrama de secuencias de la creación de torneos.
58
1.10.2. Agregar Jugadores al Sistema
El proceso de agregar nuevos jugadores al sistema está soportado por el siguiente

diagrama de clases:
frmAgregarJugadores2
+jugador admJugador
+jBL: jugadorBL
+arrjBL: ArrayList <jugador>
+lstDiv: ArrayList<division>
+divBL: divisionBL jugadorBL
+jxd: jugadorxDivision
usa
+crear(jugador): boolean
+frmAgregarJugadores2()
1 1..* +getLstJugadores(): ArrayList<jugador>
+buscarenListalaDivision()
+actualizarJugador(): boolean
+estaJugadorenDivision()
+getUnJugador(): jugador
+dameJugadordeLista()
+registrarJugador() 1
+crearListaDivisiones() usa
+llenarGrillaJugadores() 1
+btnInscribirJugadoresActionPerformed()
jugadorDA
+cmbDivisionItemStateChanged()
1
+jugadorDA(jugador)
1..* agrega
+crear(): boolean
+listarJugadores(): ArrayList<jugador>
jugador +update(int, jugador): boolean
+idJugador +getUnJugador(int): jugador
+apellidoPaterno
+apellidoMaterno
+nombres
+pais
+fechadeNacimiento
+rating
+sexo
Figura 13. Diagrama de clases “Agregar Jugadores al Sistema”
La clase de la ventana frmAgregarJugadores2, que es el formulario de creación de

jugadores es la encargada de interactuar con los métodos de las capas lógicas y de
acceso a datos de la clase jugador, que es la que almacena toda la información
general relevante a creación de jugadores.
diagrama de secuencias de la creación de jugadores.
59
1.10.3. Inscribir Jugador a División de Torneo
El proceso de inscribir jugadores a divisiones de torneo está soportado por el siguiente

diagrama de clases:
jugadorxDivision
division
+idJugadorxDiv
+idDivision frmAgregarJugadores2 +posicionFinal
+nombreDivision +numeroId
+jugador admJugador
+descripcion +ganados
+jBL: jugadorBL
+numJugadores +derrotas
1 +arrjBL: ArrayList <jugador>
+numFechas agrega +empates
1..* +lstDiv: ArrayList<division>
+terminado +estado
+divBL: divisionBL 1
+rondaActual usa 1..* +puntajeTotal
+jxd: jugadorxDivision
+ptosxBye +bye
+frmAgregarJugadores2() +descripcion
+buscarenListalaDivision()
+estaJugadorenDivision()
+dameJugadordeLista()
jugadorxDivisionBL 1 +registrarJugador()
+crearListaDivisiones() divisionBL
1 +usa
+jugadorxDivisionBL() +llenarGrillaJugadores()
+crear() +btnInscribirJugadoresActionPerformed()
+divisionBL(int)
+getLstJugadoresxDivision() +cmbDivisionItemStateChanged()
1 +crear(division)
+asignarId() usa
+getLstDivisiones()
+actualizarPuntajeTotal() +actualizarEstado()
+getJugadorxDivision() 1 +actualizarRondaActual()
+eliminarJugador() divisionDA +getRondaActual()
1 +getTotalFechas()
+divisionDA() +getDivision(int)
relacionado +actualizarDivisionActual()
1 +crear()
+getDivision(int) relacionado +actualizarNumeroRondas()
jugadorxDivisionDA +emparejarRoundRobin()
+actualizarDivisionActual()
+listarDivisiones() +emparejarSegunGrupos()
1 1
+jugadorxDivisionDA() +getRondaActual() +ordenarJugadores()
+crear() +actualizarEstadoDivision() +buscarJugadorxId()
+listarJugadoresxDiv() +actualizarRondaActual() +buscarJugadorxId2()
+asignarIdDivisionTorneo() +getTotalFechas() +combinarUltimosGrupos()
+actualizarPuntajeTotal() +actualizarNumeroRondas() +emparejarDentrodeGrupo()
+buscarJugadorxDiv() +crearNuevosGruposPuntuacion()
+eliminarJugador() +puedeJugarenelGrupo()
+llenarMatrizPareos()
+eliminarCandidatosPareo()
+dameMatrizdeRivales()
+proponerRivales()
+establecerColores()
Figura 14. Diagrama de clases “Inscribir Jugador a División de Torneo”
La clase de la ventana frmAgregarJugadore2, que es el formulario de creación de

jugadores, es también la encargada de soportar la inscripción de jugadores en las
divisiones de los torneos creados. Por tanto, interactúa con los métodos de las capas
lógicas y de acceso a datos de las clases que soportan a los jugadores de división
(clase jugadorxDivision) y la división de torneos (clase division), quienes son las
entidades involucradas en la inscripción de los jugadores a las divisiones de torneos.
diagrama de secuencias de la inscripción de jugadores a división de torneos.
60
1.10.4. Crear División de Torneo
El proceso de crear una división de torneo está soportado por el siguiente diagrama de
clases:
torneoDA torneoBL
+torneoDA() +torneoBL() divisionBL

+crear() 1 1..* +crear()
+getNdivTorneo() +actualizarNdivisiones()
+divisionBL(int)
+actualizarNdivisiones() usa +getNDivTorneo()
+crear(division)
+listarTorneos() +getLstTorneos()
+getLstDivisiones()
+update() +actualizarTorneo()
+actualizarEstado()
+buscarTorneoxId() +buscarTorneoxId()
+actualizarRondaActual()
+getRondaActual()
+getTotalFechas()
frmAgregarDivisiones
+getDivision(int)
+miTorneo: torneo +actualizarDivisionActual()
tipoTorneoDA tipoTorneoBL +actualizarNumeroRondas()
usa usa +admDivision: division 1 1
+eltorneoBL: torneoBL +emparejarRoundRobin()
+tipoTorneoDA() +emparejarSegunGrupos()
1 1 +tipoTorneoBL() 1 +valorxBye: double usa
+listarTipoTorneos() +getLstTipoTorneos() +ordenarJugadores()
+frmAgregarDivisiones() +buscarJugadorxId()
1 +btnAceptarActionPerformed() +buscarJugadorxId2()
usa +combinarUltimosGrupos()
torneo relacionado
1 1 +emparejarDentrodeGrupo()
relacionado
+idTorneo 1 divisionDA +crearNuevosGruposPuntuacion()
+terminado 1 +puedeJugarenelGrupo()
1
+nombreTorneo division +llenarMatrizPareos()
+divisionDA() +eliminarCandidatosPareo()
+ciudad
+idDivision +crear() +dameMatrizdeRivales()
+fechaInicio
+nombreDivision +getDivision(int) +proponerRivales()
+fechaFin
+descripcion +actualizarDivisionActual() +establecerColores()
+organizador
+numJugadores +listarDivisiones()
+numeroDivisiones
+numFechas +getRondaActual()
+terminado +actualizarEstadoDivision()
+rondaActual +actualizarRondaActual()
+ptosxBye +getTotalFechas()
+actualizarNumeroRondas()
Figura 15. Diagrama de clases “Creación de División de Torneo”
La clase de la ventana frmAgregarDivisiones, es el formulario de creación de nuevas

divisiones de torneos. Esta es la encargada de interactuar con los métodos de las
capas lógicas y de acceso a datos de las clases que soportan a los torneos, a los
tipos de torneo y la división de torneos, quienes son las entidades involucradas en la
creación de nuevas divisiones de torneos.
diagrama de creación de divisiones de torneos.
61
1.10.5. Emparejamientos de Jugadores
El proceso de emparejar rivales está soportado por el siguiente diagrama de clases:
divisionDA
grupoBL
divisionBL
+divisionDA()
+grupoBL()
+crear() +divisionBL(int)
+crearGruposdePuntuacion()
+getDivision(int) +crear(division)
+determinarPuntajesUnicos()
+actualizarDivisionActual() +getLstDivisiones()
+estaenListadePuntaje()
+listarDivisiones() +actualizarEstado()
+crearSubGrupo()
+getRondaActual() +actualizarRondaActual()
+noPuedeJugarenelGrupo()
+actualizarEstadoDivision() relacionado
+getRondaActual()
+listaJugadoresAptos()
+actualizarRondaActual() +getTotalFechas()
+sePuedePareoxColores() 1
+getTotalFechas() +getDivision(int)
+noPuedenJugarEnEsteGrupo()
+actualizarNumeroRondas() 1 +actualizarDivisionActual()
+noPuedenJugarenelGrupo()
+determinarSgteColorxJugador() 1 +actualizarNumeroRondas()
+eliminarporColor() usa +emparejarRoundRobin()
grupo +emparejarSegunGrupos()
1 +ordenarJugadores()
1 +numeroJugadores +buscarJugadorxId()
+jugadoresxGrupo +buscarJugadorxId2()
+puntajedeGrupo +combinarUltimosGrupos()
frmResultadosTorneo relacionado +jugadores +emparejarDentrodeGrupo()
+tipoGrupo +crearNuevosGruposPuntuacion()
+arrDivisiones: division[n]
+unaRondaBL: rondaBL +puedeJugarenelGrupo()
+jxdxrBL: jugadorxDivxRondaBL 1..* +llenarMatrizPareos()
relacionado
+jxdBL: jugadorxDivisionBL relacionado +eliminarCandidatosPareo()
1 1 +dameMatrizdeRivales()
+todaslasRondas: ronda
1..* 1 +proponerRivales()
+frmResultadosTorneo() ButtonSgteListener +establecerColores()
+pintarVentana() emparejar
+llenarGrillas() +divisionBL divBL
+arrjBD: ArrayList<jugadorxDivxRonda> usa 1
1..* 1
+jugadorxDivision jugadorBYE
1 +jxdxrBL: jugadorxDivxRondaBL jugadorxDivxRondaBL
rondaBL +gruposFormadosBL: grupoBL
+gruposFormadosBE: grupo +jugadorxDivxRondaBL()
+rondaBL() +ButtonSgteListener() +crear(): boolean
1..* 1 +getPuntaje(): double
+crear(ronda): boolean +elegirBYE()
+getIdRonda(int, int): ronda +hacerSgte() +getIdJugadorxRonda()
relacionado relacionado
+actEstadoEnBD(int): boolean +asignarIdPareo() +getJugadoresxRonda()
+getEstadoRonda(int): int +asignarContrincantes() +getJugadorxRonda()
1 +getResultadosxRonda()
+emparejarxSistemaSuizo()
1 1..* +getContrincantesxRonda()
relacionado +creandoNuevaRonda()
1 +emparejarxRoundRobinDos() +getColoresxRonda()
+emparejarxRoundRobinUno() +limpiarContrincantexRonda()
rondaDA +getFlotantesxRonda()
+comprobarPasoSiguenteRonda()
+ordenarTablaFinRonda() +getLstColoresxRonda()
+rondaDA(ronda) +ponerColorxRonda()
+crear(): boolean +ponerFlotantexRonda()
1
+getIdRonda(int, int): ronda relacionado +ponerRivalxRonda()
+actEstadoEnBD(int): boolean 1..* +actualizarDatosFinal()
+getEstadoRonda(int): int +actualizarDatosPrevia()
jugadorxDivisionBL
+actualizarIdPartida()
+getIdPartidaRegistrada()
+jugadorxDivisionBL() +getListaContrincantesxELO()
+crear()
+getLstJugadoresxDivision() 1
+asignarId() relacionado
1
+actualizarPuntajeTotal()
+getJugadorxDivision()
+eliminarJugador() jugadorxDivxRondaDA
1 relacionado +jugadorxDivxRondaDA()
1 +getPuntaje(int)
+actualizarDatosFinal()
jugadorxDivisionDA +actualizarDatosPrevia()
+getIdJugadorxRonda()
+jugadorxDivisionDA() +getJugadoresxRonda()
+crear() +getJugadorxRonda()
+listarJugadoresxDiv() +getResultadosxRonda()
+asignarIdDivisionTorneo() +getContrincantesxRonda()
+actualizarPuntajeTotal() +getColoresxRonda()
+buscarJugadorxDiv() +limpiarContrincantexRonda()
+eliminarJugador() +getFlotantesxRonda()
+ponerFlotantexRonda()
+ponerRivalxRonda()
+getLstColoresxRonda()
+ponerColorxRonda()
+getContrincantesxELO()
Figura 16. Diagrama de clases “Emparejamiento de Jugadores”
62
La clase de la ventana frmResultadosTorneo que es la encargada de la administración
de las divisiones de un torneo y de mostrar el resultado de los emparejamientos,
interactúa con los métodos de las capas lógicas y de acceso a datos de las clases
que soportan: a los jugadores de división (clase jugadorxDivision), a los jugadores de
división por ronda (clase jugadorxDivxRonda), a la ronda que se esta jugando (clase
ronda), a los grupos de jugadores formados (clase grupo) y la división de torneos
(clase division).
Estas son las entidades involucradas en la gestión de los emparejamientos de los

jugadores soportado por la clase ButtonSgteListener que es la que contiene todos los
métodos necesarios para la realización de esta tarea: asignar identificadores,
emparejamiento por tipo de torneo a jugar, asignar contrincantes, etc.
diagrama de secuencias del emparejamiento de jugadores.
63
1.10.6. Registrar Resultados de Enfrentamientos
El proceso de registrar los resultados de los enfrentamientos al sistema está soportado

por el siguiente diagrama de clases:
rondaDA divisionBL
jugadorxDivxRondaBL
+rondaDA(ronda) +divisionBL(int)
+jugadorxDivxRondaBL() +crear(): boolean +crear(division)
+crear(): boolean +getIdRonda(int, int): ronda +getLstDivisiones()
+getPuntaje(): double +actEstadoEnBD(int): boolean +actualizarEstado()
+getIdJugadorxRonda() +getEstadoRonda(int): int +actualizarRondaActual()
+getJugadoresxRonda() +getRondaActual()
+getJugadorxRonda() 1 +getTotalFechas()
relacionado
+getResultadosxRonda() +getDivision(int)
1
+getContrincantesxRonda() +actualizarDivisionActual()
+getColoresxRonda() rondaBL
+actualizarNumeroRondas()
+limpiarContrincantexRonda() +emparejarRoundRobin()
+getFlotantesxRonda() +rondaBL() +emparejarSegunGrupos()
+getLstColoresxRonda() +crear(ronda): boolean +ordenarJugadores()
+ponerColorxRonda() +getIdRonda(int, int): ronda +buscarJugadorxId()
+ponerFlotantexRonda() +actEstadoEnBD(int): boolean +buscarJugadorxId2()
+ponerRivalxRonda() 1 +getEstadoRonda(int): int +combinarUltimosGrupos()
+actualizarDatosFinal() 1 +emparejarDentrodeGrupo()
+actualizarDatosPrevia() 1 relacionado relacionado
relacionado 1 +crearNuevosGruposPuntuacion()
+actualizarIdPartida() 1 +puedeJugarenelGrupo()
+getIdPartidaRegistrada() ButtonListener 1 +llenarMatrizPareos()
+getListaContrincantesxELO() +eliminarCandidatosPareo()
+unaDivision: division
1 +dameMatrizdeRivales()
+jxdBL: jugadorxDivisionBL
relacionado +proponerRivales()
+divBL: divisionBL
1 +establecerColores()
jugadorxDivxRondaDA +ButtonListener() 1
+ventanaPareo() relacionado 1
+prepararEmparejadosaMostrar()
+jugadorxDivxRondaDA() divisionDA
+ponerResultadosalInicio()
+getPuntaje(int)
+actualizarPuntajes()
+ponerResultados() +divisionDA()
+actualizarDatosPrevia()
+getIdJugadorxRonda() +crear()
+getJugadoresxRonda() +getDivision(int)
1
+getJugadorxRonda() relacionado +actualizarDivisionActual()
1 1..*
+getResultadosxRonda() +listarDivisiones()
+getContrincantesxRonda() +getRondaActual()
jugadorxDivisionBL
+getColoresxRonda() +actualizarEstadoDivision()
+limpiarContrincantexRonda() +actualizarRondaActual()
+getFlotantesxRonda() +jugadorxDivisionBL() compuesto por
+getTotalFechas()
+ponerFlotantexRonda() +crear() +actualizarNumeroRondas()
+ponerRivalxRonda() +getLstJugadoresxDivision()
+getLstColoresxRonda() +asignarId() 1
+ponerColorxRonda() +actualizarPuntajeTotal()
+actualizarIdPartida() +getJugadorxDivision()
frmResultadosTorneo
+getIdPartidaRegistrada() +eliminarJugador()
+getContrincantesxELO() +arrDivisiones: division[n]
1 relacionado +unaRondaBL: rondaBL
1 +jxdxrBL: jugadorxDivxRondaBL
jugadorxDivisionDA +jxdBL: jugadorxDivisionBL
+todaslasRondas: ronda
+jugadorxDivisionDA() +frmResultadosTorneo()
+crear() +pintarVentana()
+listarJugadoresxDiv() +llenarGrillas()
+asignarIdDivisionTorneo()
+actualizarPuntajeTotal()
+buscarJugadorxDiv()
+eliminarJugador()
Figura 17. Diagrama de clases “Ingreso de Resultados”
64
El diagrama de clases para el ingreso de los resultados de los enfrentamientos tiene
una estructura parecida al diagrama de emparejamiento de jugadores pero con dos
excepciones: no se considera a la clase “grupo” y se utiliza la clase “ButtonListener”.
De igual forma se interactúa con los métodos de las capas lógicas y de acceso a datos
de las clases que soportan: a los jugadores de división (clase jugadorxDivision), a los
jugadores de división por ronda (clase jugadorxDivxRonda), a la ronda que se esta
jugando (clase ronda) y la división de torneos (clase division).
Estas son las entidades involucradas en la gestión de ingreso de resultados soportado

por la clase ButtonListener que es la que se encarga de todas las tareas relacionadas
al ingreso de resultados: registrar resultados, actualizar puntajes de jugadores, mostrar
resultados y preparar la siguiente ronda de juego.
diagrama de secuencias del ingreso de resultados de enfrentamientos.
65
1.10.7. Ingresar Partidas
El proceso de registrar nuevas partidas al sistema está soportado por el siguiente

diagrama de clases:
jugadorDA
partidaDA
+jugadorDA(jugador)
+partidaDA(partida) +crear(): boolean
+crear(): boolean +listarJugadores(): ArrayList<jugador>
+listarPartidas(): ArrayList<partida> +update(int, jugador): boolean
+update(int, partida): boolean +getUnJugador(int): jugador
+getUltimoIdPartida(): int
+getPartidaxId(int): partida 1
usa
1 1 Pieza
usa
jugadorBL +nombre: String
1
partidaBL +Posicion: String
+crear(jugador): boolean +estoyVivo: Char
+getLstJugadores(): ArrayList<jugador> +promocion: Boolean
+partidaBL()
+crear(): boolean +actualizarJugador(): boolean
+getUnJugador(): jugador +CalcularMovimientos()
+getLstPartidas(): ArrayList<partida> +DameMovimientosPosibles()
+actualizarPartida(): boolean
+getUltimoIdPartida(): int 1
relacionado
+getPartidaxId(): partida 1 1
1
1 frmIngresoPartidas
relacionado +jugadorBlancas: jugador esta compuesto por
jugador
+jugadorNegras: jugador
+idJugador +adminEventos: Evento
+apellidoPaterno +admPartidaBL: partidaBL 1..*
+apellidoMaterno usa +unaPartida: partida
+nombres ManejadordePiezas
+pais 1 1..* +frmIngresoPartidas()
+fechadeNacimiento +iniciarVentanaPartida() +PiezasVivas: Pieza[n]
+rating +RegistrarPartida(): void
+sexo +btnElegirTorneoActionPerformed() +iniciarPiezas()
+btnJugadorNegrasActionPerformed() +identificarPiezaElegida()
+btnJugadorBlancasActionPerformed() +damePieza()
+btnReporteActionPerformed() +dameListaReporte()
ManejadordeTablero
1 1
+coordenadas: String
usa
1..* administra
+CrearTablero() 1..*
+CalcularCasillasalSeleccionar()
+PintarCasilllasalSeleccionar() Evento
administra
+Pieza unaPieza
1 +desde: int
1..*
+hasta: int
+listadeMovimientos: List<PiezaPosicion>
+listadeNotaciones: ArrayList<RegistroJugadas>
+Evento()
+empezardeCero()
+mouseDragged()
+mouseReleased()
+ActualizarComentarios()
+InsertarunComentario()
+BotonPGN()
+mousePressed()
Figura 18. Diagrama de clases “Ingreso de Partidas”
66
La clase de la ventana frmIngresoPartidas es la que se encarga del ingreso de
partidas al sistema interactúa con los métodos de las capas lógicas y de acceso a
datos de las clases que soportan: a los jugadores (clase jugador) y a las partidas
(clase partida).
Pero la clase encargada de gestionar la validación de los movimientos de las piezas

de ajedrez es la clase Evento, la cual hace uso del tablero de ajedrez manejado por la
clase ManejadordeTablero y de las piezas de ajedrez que son manejadas por la clase
ManejadordePiezas.
diagrama de secuencias de ingreso de partidas al sistema.
67
1.10.8. Leer movimientos de Partidas
El proceso de interpretar los movimientos de una partida por el sistema está soportado
por el siguiente diagrama de clases:
Pieza
jugadorDA
+nombre: String
+jugadorDA(jugador) +Posicion: String
+crear(): boolean +estoyVivo: Char
+listarJugadores(): ArrayList<jugador> +promocion: Boolean
+update(int, jugador): boolean
+CalcularMovimientos()
+getUnJugador(int): jugador
+DameMovimientosPosibles()
1
usa 1
esta compuesto por
1
partidaDA 1..*
jugadorBL
ManejadordePiezas
+partidaDA(partida)
+crear(jugador): boolean +PiezasVivas: Pieza[n]
+crear(): boolean
+getLstJugadores(): ArrayList<jugador>
+listarPartidas(): ArrayList<partida>
+actualizarJugador(): boolean +iniciarPiezas()
+update(int, partida): boolean
+getUnJugador(): jugador +identificarPiezaElegida()
+getUltimoIdPartida(): int
+damePieza()
+getPartidaxId(int): partida 1..* +dameListaReporte()
usa administra
1 1
usa 1..*
1
frmLecturaPartidas
partidaBL 1
+adminLectura: manejadorPiezas ManejadordeTablero
+adminPiezas: manejadorPiezas
+partidaBL() usa +pgn: String administra +coordenadas: String
+crear(): boolean
+getLstPartidas(): ArrayList<partida> +frmLecturaPartidas() +CrearTablero()
11 1 1..*
+actualizarPartida(): boolean +btnPGNActionPerformed() +CalcularCasillasalSeleccionar()
+getUltimoIdPartida(): int +btnAvanzarActionPerformed() +PintarCasilllasalSeleccionar()
+getPartidaxId(): partida +btnRetrocederActionPerformed()
+btnReporteActionPerformed()
Figura 19. Diagrama de clases “Lectura de Partidas”
La clase de la ventana frmLecturaPartidas es la que se encarga de interpretar los

movimientos de una partida ingresada al sistema y de interactuar con los métodos de
las capas lógicas y de acceso a datos de las clases que soportan: a los jugadores
(clase jugador) y a las partidas (clase partida).
La clase frmLecturaPartidas para encargarse de gestionar la validación de las

notaciones ingresadas hace uso del tablero de ajedrez manejado por la clase
ManejadordeTablero y de las piezas de ajedrez que son manejadas por la clase
ManejadordePiezas.
diagrama de secuencias de lectura de partidas del sistema.
68
1.10.9. Calcular ELO
El proceso de calcular el coeficiente de habilidad en el juego de un jugador (ELO) está

soportado por el siguiente diagrama de clases:
JugadorxELO
+eloOponente: int
+eloCorregido: int
+idPareo: int
+puntajePropio: double jugadorxDivxRondaBL
+nombreOponente: String jugadorxDivxRondaDA
+jugadorxDivxRondaBL()
1 +jugadorxDivxRondaDA()
+crear(): boolean
compuesto por +getPuntaje(int)
+getPuntaje(): double
1..* +actualizarDatosFinal()
frmELO +getJugadoresxRonda()
+getJugadorxRonda()
+arrJxELO: ArrayList<jugadorxELO> +getJugadoresxRonda()
+getResultadosxRonda()
+jxdxrBL: jugadorxDivxRondaBL +getJugadorxRonda()
+getContrincantesxRonda() relacionado
+sumaPuntos: double 1 1 +getResultadosxRonda()
+getColoresxRonda()
+nuevoElo: int +getContrincantesxRonda()
relacionado +limpiarContrincantexRonda() 1 1 +getColoresxRonda()
+getFlotantesxRonda()
+frmELO() +limpiarContrincantexRonda()
+calculoParaExperimentados() +getFlotantesxRonda()
+ponerColorxRonda()
+calculoParaPrimerizos() +ponerFlotantexRonda()
+ponerFlotantexRonda()
+ponerRivalxRonda()
+ponerRivalxRonda()
+ponerColorxRonda()
+getContrincantesxELO()
+getListaContrincantesxELO()
Figura 20. Diagrama de clases “Cálculo de ELO”
La clase de la ventana frmELO es la que se encarga del cálculo del ELO de un

jugador. Para ello se encarga de interactuar con los métodos de las capas lógicas y de
acceso a datos de la clase que soporta a los jugadores de división por ronda (clase
jugadorxDivxRonda)
La clase jugadorxELO es la que contiene los datos calculados del jugador

seleccionado.
diagrama de secuencias de cálculo de ELO:
69
1.11. Especificaciones de Diagramas de Clase
A continuación se describen las especificaciones de los diagramas de clase utilizados

en el sistema por casos de uso:
1.11.1. Clase ButtonListener
Se encarga de todas las tareas relacionadas al ingreso de resultados: registrar

resultados, actualizar puntajes de jugadores, mostrar resultados y preparar la siguiente
ronda de juego.
Clase ButtonListener
Atributo Descripción
Identificador de la división de torneo sobre la cual
unaDivision
se administra el ingreso de resultados.
Referencia a capa lógica de la clase
jxdBL
”jugadorxDivision”.
divBL Referencia a capa lógica de la clase “division”.
Método Descripción
ButtonListener Constructor de la clase.
Se encarga del registro de los resultados
ventanaPareo
ingresados de los enfrentamientos.
Se encarga de mostrar los enfrentamientos de
prepararEmparejadosaMostrar jugadores como filas en grilla para el ingreso de
resultados.
Se encarga de cargar los resultados cuando se
ponerResultadosalInicio
llama a la ventana.
Se encarga de actualizar los puntajes cuando se
actualizarPuntajes
completan el ingreso de resultados.
Se encarga de mostrar resultados en grilla de
ponerResultados
resultados de torneo.
Tabla 34. Diccionario de datos de la clase ButtonListener.
70
1.11.2. Clase ButtonSgteListener
S encarga de la realización de la gestión de los emparejamientos de los jugadores:

asignar identificadores, emparejamiento por tipo de torneo a jugar, asignar
contrincantes, etc.
Clase ButtonSgteListener
divBL Referencia a capa lógica de la clase “division”.
Arreglo de jugadores inscritos de la división del
arrjBD
torneo
Identificador del jugador que descansa en una
jugadorBYE
ronda.
Referencia a capa lógica de la clase
jxdxrBL
”jugadorxDivxRonda”.
gruposFormadosBE Referencia a la clase “Grupo”.
gruposFormadosBL Referencia a capa lógica de la clase “Grupo”.
ButtonSgteListener Constructor de la clase.
Se encarga de determinar al jugador que
elegirBYE
descansa en esta ronda.
Se encarga de comprobar que se puede realizar
hacerSgte
el emparejamiento de la ronda.
Asigna un identificador al jugador de la división
asignarIdPareo
de torneo en la primera ronda.
Realiza el emparejamiento por tipo de sistema
emparejarxSistemaSuizo
suizo.
Crea una nueva ronda cuando se inicia
creandoNuevaRonda
emparejamiento de una ronda.
Realiza el emparejamiento por tipo Round Robin
emparejarxRoundRobinUno
de una vuelta.
Realiza el emparejamiento por tipo Round Robin
emparejarxRoundRobinDos
de dos vueltas.
Se encarga de cargar con datos iniciales a los
comprobarPasoSiguienteRonda jugadores para el emparejamiento de la siguiente
ronda.
71
Se encarga del ordenamiento de jugadores
ordenarTablaFinRonda
según puntaje
Tabla 35. Diccionario de datos de la clase ButtonSgteListener.
1.11.3. Clase DivisionTorneo
Clase que describe las categorías en las que está dividido un torneo.
Clase DivisionTorneo
nombreDivision Nombre de la división o categoría del torneo
descripcion Detalle que describe las características de la categoría del torneo
numJugadores Cantidad de jugadores inscritos en la división del torneo
numFechas Cantidad de rondas o jornadas a jugar en la división del torneo
terminado Indicador que sirve para señalar si el evento ha finalizado.
Tabla 36. Diccionario de datos de la clase DivisionTorneo
1.11.4. Clase Grupo
Se encarga de dividir a los jugadores de una división de torneo en grupos según sus
puntajes para realizar el emparejamiento del tipo suizo.
Clase grupo
numeroJugadores Cantidad de jugadores en el grupo de puntuación
jugadoresxGrupo Arreglo de jugadores del grupo de la división.
puntajedeGrupo Puntaje de los jugadores que componen el grupo.
Jugadores Arreglo de todos los jugadores de la división de torneo.
tipoGrupo Indicador si el grupo es “homogéneo” ó “heterogéneo”.
Tabla 37. Diccionario de datos de la clase Grupo.
72
1.11.5. Clase Jugador
Clase que describe las características generales de un jugador que participa dentro de
un torneo.
Clase Jugador
idJugador Identificador del jugador
apellidoPaterno Apellido paterno del jugador
apellidoMaterno Apellido materno del jugador
Nombre Nombres del jugador
fechaNacimiento Fecha de nacimiento del jugador
pais País de origen del jugador
Rating Nivel de capacidad de juego en el ajedrez.
Tabla 38. Diccionario de datos de la clase Jugador
1.11.6. Clase JugadorxDivision
Clase que describe el desempeño de un jugador que participa dentro de la división de

un torneo.
Clase JugadorxDivision
posicionFinal Ubicación final del jugador en la división de un torneo,
numeroId Identificador del jugador dentro del torneo.
ganados Número de victorias del jugador dentro del torneo.
derrotas Número de derrotas del jugador dentro del torneo.
Empate Número de empates del jugador dentro del torneo.
Condición del jugador dentro del torneo (eliminado,
Estado
bye)
descripcion Detalle del atributo estado descrito anteriormente.
Tabla 39. Diccionario de datos de la clase JugadorxDivision
73
1.11.7. Clase JugadorxELO
Se encarga del cálculo de ELO de un jugador en un torneo.
Clase JugadorxELO
Cifra que mide la habilidad de juego del jugador de
eloOponente
ajedrez.
Cifra que corrige el ELO del oponente de acuerdo a
eloCorregido
reglas de cálculo de ELO.
Identificador de un juego dentro de una división de
idPareo
torneo
puntajePropio Puntaje total logrado por jugador en un torneo.
nombreOponente El nombre de un oponente.
Tabla 40. Diccionario de datos de la clase JugadorxELO
1.11.8. Clase JugadorxFechas
Clase que describe el desempeño de un jugador dentro de una jornada de una

división de un torneo.
Clase JugadorxFechas
ronda Ronda o número de jornada dentro de un torneo
colorPieza El color de piezas con el que jugador disputa su partida
resultado El resultado final de la partida disputada del jugador
Tabla 41. Diccionario de datos de la clase JugadorxFechas.
74
1.11.9. Clase ManejadordeLectura
Se encarga de la administración de las tareas involucradas en la interpretación de los

archivos que contienen la descripción de la partida para su posterior reproducción en
el sistema.
Clase ManejadordeLectura
Almacena la notación de las jugadas realizadas en una
listadeNotaciones
partida.
Se encarga de convertir una notación de jugada a un
deNotacionaJugada formato reconocible por el sistema para proceder hacer
el movimiento.
Se encarga de leer la posición anterior a la posición
retrocederEnLista
actual.
Lee la notación para trasladar la pieza indicada hacia
moverPiezadeLista
su nueva posición.
Tabla 42. Diccionario de datos de la clase ManejadordeLectura.
1.11.10. Clase ManejadordePiezas
Se encarga de administrar las operaciones comunes de las piezas dentro del tablero
de ajedrez.
Clase ManejadordePiezas
PiezasVivas Lista de piezas que no han sido comidas en el tablero.
Configura la posición inicial de las piezas de ajedrez del
iniciarPiezas
tablero.
Sirve para identificar la pieza escogida al hacer clic en el
identificarPiezaElegida
tablero.
damePieza Obtiene una pieza del tablero a partir del nombre de este.
Recibe lista de las piezas del tablero con sus respectivas
dameListaReporte
posiciones para utilizarlas en la generación de reportes.
Tabla 43. Diccionario de datos de la clase ManejadordePiezas
75
1.11.11. Clase ManejadordeTablero
Se encarga de la administración de las tareas relacionadas al manejo del tablero tales

como el pintado de las casillas y el cálculo de posicionamiento de sus casillas.
Clase ManejadordeTablero
Almacena las coordenadas con que se identificará
coordenadas
a cada una de las casillas del tablero.
CrearTablero Se encarga de dibujar el tablero.
Se encarga de calcular las casillas disponibles que
CalcularCasillasalSeleccionar
una pieza seleccionada pueda ocupar.
Se e encarga de pintar las casillas disponibles que
PintarCasillasalSeleccionar
una pieza seleccionada pueda ocupar.
Tabla 44. Diccionario de datos de la clase ManejadordeTablero.
76
1.11.12. Clase Partida
Clase que describe las características generales de las partidas de ajedrez a registrar
por el sistema.
Clase Partida
idPartida Identificador del tipo de apertura.
idTorneo Identificador del torneo
idJugadorBlancas Identificador del jugador de piezas blancas.
idJugadorNegras Identificador del jugador de piezas negras
resultado Indicador de resultado final de la partida.
movs Descripción de movimientos de la partida.
fecha Fecha de juego de la partida
nombreBlancas Nombre del jugador de piezas blancas.
nombreNegras Nombre del jugador de piezas negras
eloBlancas Coeficiente de juego del jugador de piezas blancas.
eloNegras Coeficiente de juego del jugador de piezas negras.
Indicador que señala si la partida ya fue registrada en el
registrado
sistema
Tabla 45. Diccionario de datos de la clase Partida.
77
1.11.13. Clase Pieza (Abstracta)
Se encarga de soportar las tareas comunes de cada pieza de ajedrez como por
ejemplo: el cálculo de movimientos posibles de la pieza.
Clase Abstracta Pieza

Nombre Nombre de la pieza.
Posicion Posición actual que ocupa la pieza en el tablero.
estoyVivo Estado de pieza (vivo o comido).
Estado que indica si un peón a promocionado en otra
promocion
pieza.
Implementa el método de la interfaz Movimiento. Se
CalcularMovimientos encarga de calcular todos los movimientos disponibles
de la pieza.
Se encarga de llenar una lista con todos los
DameMovimientosPosibles
movimientos disponibles de la pieza.
Tabla 46. Diccionario de datos de la clase abstracta Pieza.
1.11.14. Clase TipoTorneo
Clase que describe las características generales del tipo de torneo a jugar.
Clase TipoTorneo
idTipoTorneo Identificador de tipo de torneo
nombre Nombre que identifica al tipo de torneo
descripción Detalle de las características del tipo de torneo a jugar
Tabla 47. Diccionario de datos de la clase TipoTorneo
78
1.11.15. Clase Torneo
Clase que describe la información básica del torneo a administrar
Clase Torneo
idTorneo Identificador único de torneo
nombre Nombre del torneo
ciudad Ciudad en la que se desarrolla el torneo
fechaInicio Fecha de Inicio del torneo
fechaFinal Fecha de culminación del torneo
organizador Nombre del organizador del torneo.
Número de divisiones o categorías en las que se diputará el
numeroDivisiones
torneo.
terminado Indicador que señala si el torneo ha finalizado
Tabla 48. Diccionario de datos de la clase Torneo
79
1.12. Diseño del modelo físico de datos
Teniendo en cuenta la base de datos seleccionada SQLite se describen las relaciones

de las tablas de datos utilizadas en el proyecto a través de un diagrama entidad-
relación.
Figura 21. Modelo físico de la base de datos.
80
A continuación se ofrece una breve explicación de las tablas que componen el modelo
de base de datos del presente proyecto:
Descripción de tablas del modelo de base de datos

N Tabla Descripción
Es la tabla donde se almacena la información de
1 tipoTorneo cada uno de los tipos de torneo empleados en el
sistema.
Es la tabla donde se almacena toda la información
que básica de un torneo: nombre del torneo, fecha
2 torneo
de inicio, fecha final, ciudad donde se realiza,
número de divisiones, etc.
Es la tabla donde se almacena la información de las
divisiones que conforman un torneo: el número de
3 divisionxTorneo
rondas a jugar, el índice de conclusión de la ronda, el
número de participantes, etc.
Es la tabla donde se almacena la información de las
4 ronda
rondas que constituyen a una división de torneo.
Es la tabla donde se almacena la información general
5 jugador de un jugador tales como: nombres y apellidos, país

de origen, fecha de nacimiento, ELO, etc.
Es la tabla donde se almacena la información de un
jugador que participa dentro de una división de un
6 jugadorxDivision torneo. Se guarda información tales como: el número

identificador dentro de la división, el puntaje obtenido,
la posición dentro de división, etc.
Es la tabla donde se almacena la información de un
jugador en la ronda de una división. Se guarda
jugadorxDivx_
7 información tal como: el identificador de jugador rival,
Ronda
el resultado del juego, el color de las piezas jugadas,
etc.
Es la tabla donde se almacena la información de
una partida jugada. Se guarda información tal
8 partida
como: la lista de movimientos, nombres de
jugadores, fecha de juego, etc.
Tabla 49. Descripción de las tablas del modelo físico de la base de datos.
81
1.13. Diseño de Interfaz Gráfica
En la definición de cada pantalla se consideran aquellos aspectos que son importantes

para el diseño y construcción del sistema.
1.13.1. Ventana de Inicio de Sistema
Las características de la ventana “Inicio de Sistema” son descritas en la siguiente

tabla:
Ventana Inicio del Sistema

Característica Descripción
Tipo Ventana de aplicación
Ubicación inicial Esquina superior izquierda de la pantalla
Cambio de tamaño No
Código de torneo, Nombre de torneo, Fecha de inicio de
Datos Usados
torneo, Fecha final de torneo
Datos Generados Un nuevo torneo o eliminación de torneo.
Imagen de Ventana
Figura 22. Pantalla de inicio de Sistema
Tabla 50. Características de la ventana “Inicio de sistema”
82
1.13.2. Ventana de Ingreso de Partidas
Las características de la ventana “Ingreso de Partidas” son descritas en la siguiente

tabla:
Ventana de Ingreso de Partidas

Datos Usados Código de partida, Nombre de jugador de piezas blancas,
Nombre de jugador de piezas negras, Fecha de juego, Ciudad,
Torneo, Resultado del juego, Comentarios del juego
Datos Generados Una nueva partida, generación de reporte de partida.
Imagen de Ventana
Figura 23. Pantalla de Ingreso de partidas con vista de la pestaña “Jugadas”.
Tabla 51. Características de la ventana “Ingreso de Partidas”
83
1.13.3. Ventana de Lectura de Partidas
Las características de la ventana “Lectura de Partidas” son descritas en la siguiente

tabla:
Ventana de Lectura de Partidas

Datos Usados Lista de movimientos de la partida
Datos Generados Reproducción de partidas, generación de reporte de partida.
Imagen de Ventana
Figura 24. Pantalla de Lectura de partidas de ajedrez
Tabla 52. Características de la ventana “Lectura de partidas”
84
1.13.4. Ventana de Ingreso de nuevos Jugadores
Las características de la ventana “Ingreso de Jugadores” son descritas en la siguiente

tabla:
Ventana de Ingreso de jugadores al Sistema

Datos Usados Apellido paterno, apellido materno, nombres, país, ranking
(ELO), Fecha de Nacimiento, sexo.
Datos Generados Ingreso de un nuevo jugador al sistema.
Imagen de Ventana
Figura 25. Pantalla de Ingreso de nuevos jugadores
Tabla 53. Características de la ventana “Ingreso de jugadores al sistema”
85
1.13.5. Ventana de Inscripción de jugadores a división de torneo
Las características de la ventana “Inscribir Jugadores” son descritas en la siguiente

tabla:
Ventana de Inscripción de jugadores

Datos Usados Datos del jugador (nombre, ranking, país)
Datos Generados Ingreso de un nuevo jugador a una división de un torneo.
Imagen de Ventana
Figura 26. Pantalla de Asignación de jugadores a división de torneo
Tabla 54. Características de la ventana “Inscripción de jugadores”
86
1.13.6. Ventana de Creación de Torneos
Las características de la ventana “Crear Nuevo Torneo” son descritas en la siguiente

tabla:
Ventana de creación de nuevo torneo

Datos Usados Nombre de torneo, ciudad, fecha de inicio, fecha final, nombre
del organizador
Datos Generados Nuevo torneo.
Imagen de Ventana
Figura 27. Pantalla de Ingreso de nuevo torneo
Tabla 55. Características de la ventana “Creación de nuevo torneo”
87
1.13.7. Ventana de Administración de Torneos
Las características de la ventana “Administración de Torneos” son descritas en la

siguiente tabla:
Ventana de Administración de Torneos
Datos Usados Nombre de torneo, fecha de Inicio, fecha final, nombre de
Organizador, número de divisiones, identificador de torneo,
nombre de división de torneo, descripción de división, tipo de
torneo, número de rondas de torneo, nombre de jugador
seleccionado, país y ELO, además los nombres de los
jugadores que componen las divisiones del torneo.
Datos Generados Referencia a división seleccionada y referencia a jugador
seleccionado.
Imagen de Ventana
Figura 28. Pantalla principal de administración de torneos
Tabla 56. Características de la ventana “Administración de torneo”
88
1.13.8. Ventana de Creación de División de Torneo
Las características de la ventana “Agregar División a Torneo” son descritas en la

siguiente tabla:
Ventana de creación de división de torneo
Datos Usados Nombre de división de torneo, tipo de torneo, número de
rondas, puntos por BYE y descripción de torneo.
Datos Generados Creación de una nueva división dentro de un torneo.
Imagen de Ventana
Figura 29. Pantalla de creación de nueva división en torneo
Tabla 57. Características de la ventana “Creación de división de torneo”
89
1.13.9. Ventana de Resultados de Torneo
Las características de la ventana “Resultados de Torneo” son descritas en la siguiente

tabla:
Ventana de resultados de Torneo

Datos Usados Nombre de divisiones de torneo, identificador de jugador,
nombre de jugador, ELO de jugador, país de origen, resultados
por rondas de jugador y puntaje total.
Datos Generados Referencia a inclusión de resultados por rondas de jugador.
Registro de resultados de torneo.
Imagen de Ventana
Figura 30. Pantalla de registro de resultados por división de torneo
Tabla 58. Características de la ventana “Resultados de división de torneos”
90
1.13.10. Ventana de Registro de Resultados
Las características de la ventana “Registrar Resultados” son descritas en la siguiente

tabla:
Ventana de Registro de Resultados

Datos Usados Identificador de juego, jugador de piezas blancas, jugador de
piezas negras, resultado de partida y estado de registro de
partida
Datos Generados Registro de resultados por rondas
Imagen de Ventana
Figura 31. Pantalla de emparejamientos y registro de resultados por ronda.
Tabla 59. Características de la ventana “Registro de Resultados”
91
1.13.11. Ventana de Búsqueda de Partidas
Las características de la ventana “Buscar Partidas” son descritas en la siguiente tabla:
Ventana de Buscar Partidas

Datos Usados Criterio de búsqueda ingresado por usuario, identificador de
partida, fecha de partida, nombre de jugador de piezas
blancas, nombre de jugador de piezas negras, nombre de
torneo y resultado de partida.
Datos Generados Partida encontrada.
Imagen de Ventana
Figura 32. Pantalla de “Búsqueda de Partidas”
Tabla 60. Características de la ventana “Búsqueda de Partidas”
92
1.13.12. Ventana de Edición de Partidas
Las características del panel “Editar Partida” de la ventana “Buscar Partida” son
descritas en la siguiente tabla:
Ventana de Edición de Partidas

Datos Usados Nombre de jugador de piezas blancas, nombre de jugador de
piezas negras, nombre de torneo, fecha de juego, resultado,
lista de movimientos.
Datos Generados Partida actualizada.
Imagen de Ventana
Figura 33. Pantalla de “Edición de Partidas”
Tabla 61. Características de la ventana “Edición de Partidas”
93
1.13.13. Ventana de Selección de Jugador
Las características de la ventana “Elegir Jugador” son descritas en la siguiente tabla:
Ventana de Elección de Jugador

Datos Usados Criterio de búsqueda de Jugador que coteja con nombre de
jugador y país.
Datos Generados Jugador elegido
Imagen de Ventana
Figura 34. Pantalla de “Elección de Jugador”
Tabla 62. Características de la ventana “Elección de Partidas”
94
1.13.14. Ventana de Edición de Jugadores
Las características del panel “Ingresar Jugadores” de la ventana “Elegir Jugador” son
Ventana de Edición de Jugador

Datos Usados Apellido paterno, apellido materno, nombres, país, rating, fecha
de nacimiento y sexo de jugador.
Datos Generados Jugador actualizado
Imagen de Ventana
Figura 35. Pantalla de “Edición de Jugadores”
Tabla 63. Características de la ventana “Edición de Jugador”
95
1.13.15. Ventana de Selección de Torneo
Las características de la ventana “Elegir Torneo” son descritas en la siguiente tabla:
Ventana de Elección de Torneo

Datos Usados Criterio de búsqueda de torneo que coteja con el nombre del
torneo.
Datos Generados Torneo elegido.
Imagen de Ventana
Figura 36. Pantalla de Elección de torneo
Tabla 64. Características de la ventana “Elección de Torneo”
96
1.13.16. Ventana de Edición de Torneo
Las características de la ventana de edición de torneos son descritas en la siguiente

tabla:
Ventana de Edición de Torneo

Datos Usados Nombre de torneo, ciudad, nombre de organizador, fecha de
inicio, fecha final.
Datos Generados Torneo actualizado
Imagen de Ventana
Figura 37. Pantalla de Edición de torneo
Tabla 65. Características de la ventana “Edición de Torneo”
97
1.13.17. Ventana de Cálculo de ELO en Torneo
Las características de la ventana “Cálculo de ELO” son descritas en la siguiente tabla:
Ventana de Cálculo de ELO en Torneo

Datos Usados Identificador de pareo de jugador seleccionado, nombre de
jugador, ELO antes de cálculo, nombres, ELO y puntajes
obtenidos con jugadores rivales, nivel de jugador, número de
oponentes, promedio de ELOS de rivales, constante K, puntos
esperados, puntos logrados y puntos posibles.
Datos Generados ELO resultante
Imagen de Ventana
Figura 38. Pantalla de Cálculo de ELO en Torneo
Tabla 66. Características de la ventana “Cálculo de ELO en Torneo”
98
1.13.18. Ventana de Cálculo de ELO FIDE
Las características de la ventana para calcular el ELO FIDE son descritas en la

siguiente tabla:
Ventana de Cálculo de ELO FIDE

Datos Usados Número de últimos torneos jugados, ELOS conseguido en
cada torneo, número de partidas en cada torneo, ELO de
jugador a calcular.
Datos Generados ELO FIDE
Imagen de Ventana
Figura 39. Pantalla de Cálculo de ELO FIDE
Tabla 67. Características de la ventana “Cálculo de ELO FIDE”
99
1.14. Estrategia de Planificación de Pruebas
Teniendo en cuenta que el Administrador de Torneos de Ajedrez ha sido desarrollado

con un enfoque de casos de uso, se procede a generar un plan de pruebas que apunte
a probar funcionalmente el sistema desde el punto de vista de los casos de uso.
A continuación se detalla el formulario sobre el que se registran las pruebas y

posteriormente se muestran el resultado de dichas pruebas.
Formulario de Prueba de Caso de Uso

Caso de Uso
Caso de Prueba Resultado Esperado Visto
Entrada Salida
Conclusión:
Tabla 68. Formulario para ejecución de pruebas del sistema a cada caso de uso
100
1.15. Casos de Prueba
La definición de los casos de prueba se realiza en cada etapa del proyecto. Estas
pruebas de funcionalidad consisten en verificar externamente la ejecución del
producto. Las funcionalidades del sistema a ser probadas son enumeradas en la
siguiente tabla:
Caso de Prueba
Casos de Uso Funcionalidades a probar
Mantenimiento de Ingresar al Mantenimiento de Jugadores
jugadores Editar Jugador
Ingresar a Inscribir de Jugadores a División de Torneo
Ingreso de Jugadores Inscribir Jugador
a División de Torneo Eliminar Jugador Inscrito en División de Torneo
Ingresar a Resultados de torneo
Emparejar Jugadores en torneo suizo
Emparejar ronda de torneo suizo con número impar de
jugadores
Emparejamiento de
Emparejar ronda un torneo suizo con número par de
Jugadores
jugadores
Emparejar Jugadores en torneo Round Robin a una vuelta
Emparejar Jugadores en torneo Round Robin de dos
vueltas
Ingresar resultados de Ingresar a Resultados de torneo
emparejamientos Ingresar Resultados
Ingresar partidas de Ingresar a módulo de Ingreso de Partidas
los enfrentamientos Registrar Partidas en Sistema
generados por sistema Reproducir Partidas generadas al Ingresar Resultados
Ingresar a Calcular de ELO a través de Ingreso de
Resultados
Calcular ELO de
Calcular ELO de un torneo administrado por el sistema
jugador
Calcular ELO de un torneo no administrado por el sistema
Calcular ELO FIDE de Jugador
Buscar Jugadores para inscribir
Buscar Jugadores
Buscar Jugadores para elegir
Buscar Partidas Ingresar a Buscar Partidas
101
Buscar Torneos Ingresar a Buscar Torneos
Ingresar Nuevas Ingresar a Buscar Partidas
Partidas Ingresar Nueva Partida
Ingresar Comentarios a Partida
Comentar Partidas
Editar Comentario de Partida
Leer Movimientos de Ingresar a Leer Partidas
Partidas Leer Partida
Ingresar a módulo de Ingreso de Partidas
Generar Reportes de Generar Reporte de Partida Ingresando una Partida
Partida Ingresar a Leer Partidas
Generar Reporte de Partida Leyendo una Partida
Ingresar Resultados de Torneo
Generar Reportes de Generar Reporte de Resultados Generales de Torneo
Torneo Ingresar Resultados por Ronda
Generar Reporte de Resultados de una Ronda de Torneo
Mostrar Movimientos Ingresar a Aprendizaje de Movimientos de Pieza de Ajedrez
de Piezas Generar Reporte de Partida Ingresando una Partida
Tabla 69. Casos de Uso a ser probados
102
1.16. Ejecución de Pruebas
A continuación se detallan las pruebas realizadas al sistema según los casos de uso:
1.16.1. Mantenimiento de torneos
Las pruebas de caso de uso “Mantenimiento de torneos” son descritas en la siguiente

tabla:
Pruebas de Caso de Uso: Mantenimiento de torneo
Ingreso al Mantenimiento de torneos
Ingresar al Sistema Se muestra pantalla de inicio. OK
Registrar Torneo
Se registra torneo y sistema muestra un

Crear nuevo torneo con todos
mensaje: “Los datos han sido guardados
los campos llenados.
correctamente”.
Entrada Salida
Figura 41. Mensaje de éxito de operación.

OK
Figura 40. Datos de Ingreso

de nuevo torneo. Figura 42. El registro “torneo de prueba 1”
se muestra en la grilla Registros Abiertos.
Crear nuevo torneo sin No se registra torneo y se muestra

nombre de torneo. mensaje:”Ingrese un nombre de torneo”.
Entrada Salida
103
OK
Figura 44. Mensaje informativo del sistema.

Figura 43. Datos de ingreso
de nuevo torneo.
No se registra torneo y se muestra

Crear nuevo torneo sin
mensaje:”Ingrese un nombre de
nombre de organizador.
organizador”.
Entrada Salida
OK

Figura 45. Se ingresan datos
de nuevo torneo.
Editar Torneo
Ingresar a ventana de El sistema muestra la pantalla de
administración de torneo. administración del torneo indicado.
Entrada Salida
OK
Figura 47. Se selecciona Figura 48. Se muestra el detalle del registro

registro “torneo de prueba 1”. seleccionado

Ingresar a ventana de edición El sistema muestra la pantalla de
de torneo. actualización de torneos.
104
Entrada Salida
OK
Figura 49. Se presiona el

botón “Editar Torneo”.
Figura 50. Se carga el detalle del registro
“torneo de prueba 1” para ser editado.
Se edita el torneo y sistema muestra el

Editar torneo.
mensaje:”Se ha actualizado correctamente”.
Entrada Salida
Figura 52. Mensaje de operación exitosa.

OK
Figura 51. Se actualiza el

nombre del torneo.
Figura 53. Se muestra el registro
actualizado en la grilla Registros Abiertos.
No se edita el torneo y sistema muestra el

Editar torneo quitando el
mensaje “Ponga el nombre del torneo. Por
nombre al torneo.
favor”.
Entrada Salida
OK

Figura 54. Se elimina el
nombre del torneo.
105
Eliminar Torneo
Eliminar torneo sin El sistema muestra el mensaje: “No ha

seleccionar registro. seleccionado ningún registro”.
Entrada Salida
OK
Figura 56. No se selecciona Figura 57. Mensaje informativo del sistema

ningún registro.
El sistema antes de eliminar el torneo

Eliminar torneo muestra el mensaje:” ¿Desea eliminar el
seleccionando registro. registro?”. Al responder afirmativamente se
procede a eliminar el registro del torneo.
Entrada Salida
Figura 59. Mensaje de confirmación del

sistema. OK
Figura 58. Se selecciona

registro a eliminar.
Figura 60. El registro “torneo de prueba
Edición” ha sido eliminado.
Conclusión: Caso de Uso probado exitosamente
Tabla 70. Pruebas de Caso de Uso: Mantenimiento de torneo.
106
1.16.2. Mantenimiento de divisiones de torneo
Las pruebas de caso de uso “Mantenimiento de divisiones de torneo” son descritas en

la siguiente tabla:
Pruebas de Caso de Uso: Mantenimiento de divisiones de torneo

Registrar División
Se registra la división del torneo y se
Crear nuevo división de torneo
muestra un mensaje: “La división se ha
con todos los campos llenos.
creado exitosamente”.
Entrada Salida
Figura 62. Mensaje de operación exitosa.

OK
Figura 61. Se ingresan datos Figura 63. Se crea una nueva hoja en el
de nueva división de torneo. árbol “Vista de Torneo”.
Crear nueva división de torneo No se registra la división de torneo y se

sin nombre de división de muestra mensaje:”Ingrese un nombre a la
torneo. división del torneo”.
Entrada Salida
OK

Figura 64. Se ingresan datos
de nueva división sin
determinar su nombre.
107
Editar División de Torneo
Ingresar a ventana de
El sistema muestra pantalla de
administración de torneo y
administración de torneo indicado.
seleccionar el torneo a editar.
Entrada Salida
OK
Figura 66. Se selecciona una Figura 67. Se muestran los datos de la

división de torneo. división a editar.
Ingresar a ventana de edición

El sistema muestra el mensaje: “Elija una
de división de torneo sin elegir
división de torneo”.
la división a editar.
Entrada Salida
OK
Figura 68. Se ingresa a

ventana de Edición de División Figura 69. Mensaje informativo del sistema.
eligiendo una división.
Elegir división a editar y

El sistema muestra la pantalla de
presiona botón “Editar
actualización de división de torneos.
División”.
Entrada Salida
OK
Figura 70. Se ingresa a
ventana de Edición de División
eligiendo una división. Figura 71. Se muestra la ventana
“Actualizar División de Torneo”.
108
Se actualiza la información de la división y el
sistema muestra el mensaje: “Los datos se
Editar información de división
han actualizado exitosamente”. Se crea una
antes de inicio de torneo.
pestaña en la ventana “Resultados de
torneo”.
Entrada Salida
OK
Figura 72. Se cambia el

nombre de la división a
“División Única”.
Figura 74. Se muestra la actualización del
registro en el panel “Datos de División”.
Editar información de división El sistema muestra el mensaje: “El torneo se

después de inicio de torneo. inició. No se harán cambios”.
Entrada Salida
OK
Figura 75. El registro Iniciado Figura 76. Mensaje informativo del sistema.
muestra “SI”. Se inició división.
Tabla 71. Pruebas de Caso de Uso: Mantenimiento de divisiones de torneo.
109
1.16.3. Mantenimiento de jugadores
Las pruebas de caso de uso “Mantenimiento de jugadores” son descritas en la

siguiente tabla:
Pruebas de Caso de Uso: Mantenimiento de jugadores

Ingreso al Mantenimiento de Jugadores
Ingresar a ventana de ingreso de El sistema muestra la ventana “Inscribir
jugadores. Jugadores”.
Entrada Salida
OK
Figura 77. Presionar botón

Figura 78. Se muestra la ventana
“Agregar Jugadores”.
“Inscribir Jugadores”.
Registrar Jugador
No se ingresa el jugador y se muestra
Crear nuevo jugador sin ingresar el
el mensaje: “Ponga el Apellido Paterno.
apellido paterno.
Por favor”.
Entrada Salida
OK
Figura 80. Mensaje informativo de

Figura 79. No se ingresa el apellido
sistema.
paterno.
No se ingresa el jugador y se muestra

Crear nuevo jugador sin ingresar el
el mensaje: “Ponga el nombre. Por
nombre del jugador.
favor”.
110
Entrada Salida
OK
Figura 81. Información de nuevo Figura 82. Mensaje informativo de

jugador sin determinar nombre. sistema.
Se registra el jugador y el sistema

Crear nuevo jugador con todos los
muestra el mensaje:”Jugador creado
campos llenados.
exitosamente”.
Entrada Salida
Figura 84. Mensaje de operación

exitosa.
OK
Figura 83. Se ingresa todos los

datos pedidos para crear un nuevo
jugador. Figura 85. Una vez creado el jugador,
se busca y se encuentra el registro.
Editar Jugador
El sistema muestra la ventana de
Ingresar a ventana de actualización
actualización de información de
de información de jugadores.
jugadores.
Entrada Salida
OK
Figura 86. Se presiona el botón Figura 87. Se muestra pestaña

“Actualizar datos”. “Ingresar Jugadores”.
Editar jugador. Jugador editado y se muestra el
111
mensaje: ”Se ha actualizado
correctamente”.
Entrada Salida

exitosa.
OK
Figura 88. Se edita el ELO del

jugador seleccionado de 1000 a
2250.
Figura 90. Se busca el registro editado

y se comprueba actualización.
No se edita el jugador y sistema

Editar jugador quitando nombre al
muestra el mensaje: “Ponga el apellido
jugador.
paterno, Por favor”.
Entrada Salida
OK
Figura 91. Se edita información de Figura 92. Mensaje informativo del

jugador eliminado su apellido sistema.
paterno.
Tabla 72. Pruebas de Caso de Uso: Mantenimiento de jugadores
112
1.16.4. Ingreso de Jugadores a División de Torneo
Las pruebas de caso de uso “Ingreso de Jugadores a División de Torneo” son

Pruebas de Caso de Uso: Ingreso de jugadores a división de torneo

Ingresar a Inscribir Jugadores a División de Torneo
Ingresar a ventana de El sistema muestra la ventana

OK
administración de torneo “Administración de torneos”
El sistema muestra la ventana “Inscribir
Jugadores”. Se muestran los jugadores
disponibles a ser inscritos en el nuevo
torneo. Además en la lista de opciones
inscripción de jugadores.
del panel “Inscribir Jugador” se carga
con los registros de las divisiones a ser
iniciadas.
Entrada Salida
OK
Figura 93. Se presiona el botón Figura 94. Se muestra la ventana

“Agregar Jugadores”. “Inscribir Jugadores”.
Inscribir Jugador
El sistema selecciona a todos los
Seleccionar a los jugadores a jugadores elegidos mostrándolos con
participar en la división del torneo. un signo de aprobación en una celda
de sus registros.
Entrada Salida
113
OK
Figura 96. Se muestra a los jugadores

Figura 95. Se seleccionan seleccionados con signo de
jugadores a ser inscritos. aprobación.
Se muestra el mensaje “Los datos han

Agregar a jugadores
sido registrados correctamente”
seleccionados a división de OK
agregando a los jugadores en la
torneo.
división de torneo.
Entrada Salida

exitosa.
Figura 97. Se inscriben jugadores

seleccionados a la división
“División Única”.
Figura 99. Se muestra en árbol “Vista

de Torneo” a los jugadores inscritos.
El sistema ignora el pedido de registro

Inscribir jugadores ya inscritos en de los jugadores ya inscritos,
división de torneo. permitiéndoles inscribirse solamente a
los no registrados.
Entrada Salida
114
OK
Figura 100. Se inscriben

nuevamente a jugadores
registrados.
Figura 101. El árbol “Vista de Torneo”

muestra a los jugadores registrados.
Eliminar Jugador Inscrito en División de Torneo

Eliminar a un jugador sin
El sistema muestra el mensaje “Elija la
seleccionar ni la división de torneo
división de un torneo”.
ni el jugador.
Entrada Salida
OK
Figura 102. Se presiona botón Figura 103. Mensaje informativo del

“Eliminar Jugador”. sistema.
El sistema muestra el mensaje:

Eliminar a jugador inscrito antes “Eliminará un jugador”. Si se responde
de inicio de división de torneo. afirmativamente se procede a eliminar
al jugador seleccionado.
Entrada Salida
OK
Figura 106. Mensaje de confirmación

Figura 104. Se selecciona el
del sistema.
registro a eliminar.
115
Figura 105. Se procede a eliminar
al jugador de identificador 33.
Figura 107. Se muestra en árbol que el
jugador “colonia, billy” ha sido
eliminado.
Eliminar a jugador inscrito El sistema muestra el mensaje “El
después de inicio de división de torneo ya se inició. No se puede
torneo. eliminar”.
Entrada Salida
Figura 108. Previamente se

procede a emparejar la siguiente
ronda”.
OK
Figura 110. Mensaje de advertencia

del sistema.
Figura 109. Después se procede

a eliminar a jugador de la división
ya iniciada.
Tabla 73. Pruebas de Caso de Uso: Ingreso de jugadores a división de torneo
116
1.16.5. Emparejamiento de Jugadores
Las pruebas de caso de uso “Emparejamiento de Jugadores” son descritas en la

siguiente tabla:
Pruebas de Caso de Uso: Emparejamiento de Jugadores
Ingreso a Ventana de Resultados de torneo
OK
Ingresar a la ventana de Resultados El sistema muestra la ventana
de torneo. “Resultados de torneo”.
Entrada Salida
OK
Figura 111. Se presiona botón

“Ingresar Resultados”.

“Resultados de torneo”.
Emparejar Jugadores en torneo Suizo

Emparejar primera ronda de torneo
El sistema muestra el mensaje: ”No hay
sin cantidad mínima de jugadores
participantes aún”.
requeridos.
Entrada Salida
OK
Figura 114. Mensaje de advertencia del

Figura 113. Se presiona botón sistema.
“Siguiente” sin jugadores.
117
Emparejar en la primera ronda de El sistema asigna un identificador a cada
torneo superando la cantidad jugador y habilita el botón de ingreso de
mínima de jugadores requeridos. resultados de la primera ronda.
Entrada Salida
OK
Figura 116. Se asigna en la ronda 1 un

identificador a cada jugador inscrito.
Figura 115. Jugadores inscritos

antes de emparejar la primera
ronda.
Figura 117. Se activa botón que muestra
ventana de ingreso de resultados.
No se procede a emparejar la siguiente

Emparejar una siguiente ronda sin
ronda y el sistema muestra el mensaje
terminar de ingresar todos los
“No se han completado los resultados de
resultados de la actual ronda.
esta ronda”.
Entrada Salida
OK
“Siguiente” sin ingresar todos los Figura 119. Mensaje de advertencia del
resultados de la ronda. sistema.
Emparejar una siguiente ronda No se procede a emparejar la siguiente

estando la división de torneo en la ronda y el sistema muestra el mensaje
última ronda. “Se ha terminado el torneo”.
Entrada Salida
118
OK
“Siguiente” habiendo concluido el Figura 121. Mensaje de advertencia del
torneo. sistema.
Emparejar a un número par de jugadores en torneo suizo.

Para cada jugador se muestra en la
columna de título 1 de la ventana
Emparejar la ronda uno de cinco de “Resultados de torneo” el identificador
una división de torneo con una del rival, la letra ‘B’ ó ‘N’ que señala el
cantidad par de jugadores. color de piezas con que jugará y un
asterisco que determina que no se han
ingresado resultados del encuentro.
Entrada Salida
De los jugadores 1, 2, 3, 4, 5, 6, 7 y 8 en
ese orden, se forman dos subgrupos (1,
2, 3, 4) y (5, 6, 7, 8). Juegan entonces el
primero del primer subgrupo con el
primero del segundo subgrupo (1,5), el
segundo del primer subgrupo con el
segundo del segundo subgrupo (2, 6) y
así sucesivamente. No hay restricciones
en cuanto a los colores.
OK

“Siguiente” para emparejamientos
de ronda uno.
Figura 123. Listado de emparejamientos

de jugadores de la ronda uno.
119
Emparejar la ronda dos de cinco de “Resultados de torneo” el identificador
Entrada Salida
Del grupo de los que tienen 1.0 puntos
se obtiene la pareja (1,6). Como los dos
son del mismo grupo la pareja está bien
obtenida.
Del grupo de los que tienen 0.5 puntos
(4, 8, 3 y 7) el algoritmo determinó las
parejas (3, 8) y (4, 7). Como los cuatro
Se conocen los resultados
de son del mismo grupo la pareja está bien
rondas anteriores y la siguiente obtenida.
tabla de posiciones: Del grupo de 0 puntos se forma la pareja
(2, 5). Como los dos son del mismo
grupo la pareja está bien obtenida.
Por tanto los emparejamientos para la
ronda dos han sido correctos. Con OK
respecto a los colores de las piezas
todos los jugadores que jugaron con
Figura 124. Tabla de posiciones blancas lo hacen ahora con negras y
después de la ronda 1. viceversa.

de jugadores de la ronda dos.
120
Emparejar la ronda tres de cinco de “Resultados de torneo” el identificador
Entrada Salida
Las parejas que salen del grupo de los
que tienen 1.5 puntos (1, 6, 8 y 7): (1, 8)
y (6,7) son correctas puesto que es la
primera vez que juegan entre sí.
Se conocen los resultados de
Como 5 está solo (1.0 puntos) se une al
rondas anteriores y la siguiente
grupo de 4 y 3. Por tanto la pareja (5, 3)
tabla de posiciones:
es correcta. Al final queda la pareja (4,
2).
Los emparejamientos son correctos.
Respecto a los colores ningún jugador ha
jugado tres veces seguidas con un OK
mismo color de piezas.
Figura 126. Tabla de posiciones

después de la ronda 2.

de jugadores de la ronda tres.

Emparejar la ronda cuatro de cinco “Resultados de torneo” el identificador
de una división de torneo con una del rival, la letra ‘B’ ó ‘N’ que señala el
121
Entrada Salida
Las parejas que salen del grupo de los
que tienen 2.0 puntos (1, 6, 8 y 7): (1, 7)
y (8,6) son correctas puesto que es la
primera vez que juegan entre sí.
Como 3 está solo (1.5 puntos) se une al

grupo de 5 y 2. Pero como 5 ya jugó con
2 y 3 este se traslada al grupo de 4 (0.5
puntos) formándose las parejas: (3, 2) y
(4, 5).
Por tanto, los emparejamientos son
correctos.
Respecto a los colores ningún jugador ha OK
jugado tres veces seguidas con un

mismo color de piezas.


de jugadores de la ronda cuatro.

Emparejar la ronda cinco de cinco “Resultados de torneo” el identificador
de una división de torneo con una del rival, la letra ‘B’ ó ‘N’ que señala el
Entrada Salida
122
Figura 130. Tabla de posiciones de jugadores de la ronda cinco.
A partir de este punto es difícil poder

describir las razones del porque cada
jugador juega con su respectivo rival,
pero se puede demostrar que los
emparejamientos están bien hechos
comprobando que los jugadores
emparejados nunca se han enfrentado
entre sí y que se respeta las restricción
de no jugar más de tres veces con un
color mas que otro
Figura 132. Tabla de resultados de las

primeras cuatro rondas.
El sistema ubica al jugador de mayor

puntaje en el primer lugar de la tabla de
posiciones. En caso de empate se
Determinar ganador.
determina a ganador por los siguientes
métodos de desempate: (Mediana,
Solkoff, Acumulativo) en ese orden.
Entrada Salida
123
Aunque existe triple empate en el primer
lugar, el ganador de esta división de
torneo es el jugador 6 tomando como
criterios de desempate los métodos de la
Se asume la siguiente tabla de
Mediana, de Solkoff y Acumulativo en
posiciones:
ese orden.
OK

Figura 134. Tabla de desempate que
ubica al jugador 6 en el primer lugar.
Emparejar a un número impar de jugadores en torneo suizo.

Emparejar la ronda uno de tres de
“Resultados de torneo” el identificador
una división de torneo con una
del rival, la letra ‘B’ ó ‘N’ que señala el
cantidad impar de jugadores que
color de piezas con que jugará y un
supere la cantidad mínima
requerida.
ingresado resultados del encuentro. Se
debe elegir a un jugador como BYE.
Entrada Salida
Se elige como BYE al jugador con menor
ELO que es jugador 5 (ELO 1000).
OK

de jugadores de la ronda uno.
“Siguiente” para emparejamientos De los jugadores 1, 2, 3 y 4 en ese
de ronda uno. orden, se forman dos subgrupos (1, 2) y
124
(3, 4). Juegan entonces el primero del
primer subgrupo con el primero del
segundo subgrupo (1, 3) y el segundo
del primer subgrupo con el segundo del
segundo subgrupo (2, 4). Con respecto a
los colores de las piezas no existen
restricciones para la primera ronda.
Emparejar la ronda dos de tres de
requerida.
debe elegir a un jugador como BYE
Entrada Salida
Puesto que el jugador 4 es el último de la
puntuación y anteriormente no ha sido
BYE le corresponde ahora ser BYE
(descansa en esta ronda.)

posiciones:
de jugadores de la ronda dos.
Puesto que los jugadores 1, 2 y 5 OK

pertenecen al mismo grupo (todos tienen
puntaje 1.0), las siguientes
después de la ronda 1. emparejamientos se podrían generar:
(2, 5) y (1, 3). No válido. 1 y 3 ya jugaron.
(2, 1) y (5, 3). Válido. Elegido por
algoritmo (1, 5) y (2, 3). Válido.
Con respecto a los colores de las piezas
blancas lo hacen ahora con negras y
viceversa.
125
Emparejar la ronda tres de tres de
requerida.
debe elegir a un jugador como BYE.
Entrada Salida
Puesto que el jugador 3 es el último de la
puntuación (0.5 puntos) y anteriormente
no ha sido BYE le corresponde ahora ser
BYE (descansa en esta ronda).

posiciones: Figura 140. Listado de emparejamientos
de jugadores de la ronda tres.
El jugador 1 por ser el único de su grupo

OK
(tiene 2.0 puntos) buscará emparejarse
con alguno del siguiente grupo (jugador
Figura 139. Tabla de posiciones 5) pero no podrá hacerlo porque forzaría
el juego entre 2 y 4 que ya jugaron en la
ronda 1. Del siguiente grupo (2 y 4) 1 ya
jugó con 2 por tanto se fuerza el (1, 4) y
(2,5) que es el resultado del algoritmo.
Con respecto a los colores de las piezas
blancas lo hacen ahora con negras y
viceversa.
El sistema ubica al jugador de mayor
puntaje en el primer lugar de la tabla de
posiciones. En caso de empate se
Determinar ganador.
determina a ganador por los siguientes
métodos de desempate: (Mediana,
Solkoff, Acumulativo) en ese orden.
126
Entrada Salida
Aunque existe triple empate en el primer
lugar, el ganador de esta división de
Se asume la siguiente tabla de torneo es el jugador 1 tomando como
posiciones: criterios de desempate los métodos de la
Mediana, de Solkoff y Acumulativo en
ese orden.
OK

Figura 142. Tabla de desempate que

ubica al jugador 1 en el primer lugar.
Emparejar Jugadores en torneo Round Robin o Todos Contra Todos a una vuelta
Emparejar ronda en torneo Round No se ejecuta ningún emparejamiento y

Robin o todos contra todos sin el sistema muestra el mensaje:”No hay
jugadores inscritos. jugadores para emparejar”.
Entrada Salida
OK
Figura 143. Se presiona botón Figura 144. Mensaje informativo del

“Siguiente”. sistema.

Robin o todos contra todos con el sistema muestra el mensaje: “El
menos de cuatro jugadores mínimo de jugadores a emparejar es
inscritos. cuatro”.
Entrada Salida
127
OK
Figura 146. Mensaje informativo del

Figura 145. Se intenta emparejar
sistema
con tres jugadores inscritos.
El sistema asigna un identificador a cada

jugador y los empareja por esta única
Emparejar ronda en torneo Round
vez para todas las rondas a jugar durante
Robin o Todos contra Todos con un
la división de torneo.
número impar de jugadores inscritos
Si n es la cantidad de jugadores a
(más de cuatro jugadores).
participar y n es impar entonces el torneo
se jugará a n rondas.
Entrada Salida
OK
Figura 147. Se inicia torneo con Figura 148. Se asigna identificador y los
cinco jugadores. rivales para todas las rondas.

Robin o Todos contra Todos con un
número par de jugadores inscritos
(más de cuatro jugadores).
participar y n es par entonces el torneo
se jugará a n-1 rondas.
Entrada Salida
OK
seis jugadores. rivales para todas las rondas.
128
Emparejar Jugadores en torneo Round Robin o Todos Contra Todos de dos vueltas
Robin o todos contra todos de dos el sistema muestra el mensaje:”No hay
vueltas sin jugadores inscritos. jugadores para emparejar”.
Entrada Salida
OK
Figura 151. Se inicia torneo sin Figura 152. Mensaje informativo del
inscribir jugadores sistema.
No se ejecuta ningún emparejamiento y

el sistema muestra el mensaje: “El
Robin o todos contra todos de dos
mínimo de jugadores a emparejar es
vueltas con menos de cuatro
cuatro”.
jugadores inscritos.
Entrada Salida
OK
Figura 153. Se intenta emparejar Figura 154. Mensaje informativo del

con un jugador inscrito. sistema.

Robin o Todos contra Todos de dos
vueltas con un número impar de
jugadores (más de cuatro).
participar y n es impar entonces se
jugarán 2xn rondas.
Entrada Salida
129
OK
cinco jugadores. rivales para todas las rondas.

Robin o Todos contra Todos de dos
vueltas con un número par de
jugadores (más de cuatro).
participar y n es par entonces se jugarán
2x(n-1) rondas.
Entrada Salida
OK
seis jugadores. rivales para todas las rondas.
Tabla 74. Pruebas de Caso de Uso: Emparejamiento de Jugadores
130
1.16.6. Ingresar Resultados de Emparejamientos
Las pruebas de caso de uso “Ingresar Resultados de Emparejamientos” son descritas

en la siguiente tabla:
Pruebas de Caso de Uso: Ingresar Resultados de Emparejamientos

Ingresar a Resultados de Torneo

OK
Ingresar a la ventana de Se muestra la ventana “Resultados de
Resultados de torneo. Torneo”.
Entrada Salida
OK

Figura 160. Se muestra ventana
“Resultados de Torneo”.
Ingresar a la ventana de El sistema muestra la ventana “Registrar

ingreso de resultados de la Resultados” que muestra una grilla con
ronda que se juega la descripción de los enfrentamientos a
actualmente. realizarse en la ronda actual.
Entrada Salida
OK
botón “R1” para ingreso de
resultados. Figura 162. Se muestra ventana
“Registrar Resultados” para la ronda 1.
Ingresar Resultados
131
Ingresar resultados de los Se muestra lista de opciones en cada
enfrentamientos de la ronda uno de los registros para ingresar el
actual. resultado adecuado.
Entrada Salida
OK
Figura 163. Sistema muestra Figura 164. Se procede a ingresar

lista de enfrentamientos de resultados de una ronda.
una ronda.
Reingresar resultados antes Se muestra lista de opciones en cada

de generar enfrentamientos uno de los registros para ingresar el
de la siguiente ronda. resultado adecuado.
Entrada Salida
OK
Figura 166. Se reingresan resultados de

Figura 165. Se muestran los
las partidas.
resultados registrados
Reingresar resultados El sistema impide el ingreso de

después de generar resultados de una partida una vez
enfrentamientos de la generados los enfrentamientos de la
siguiente ronda. siguiente ronda.
Entrada Salida
OK
Figura 167. Se oprime botón

“R1” para ingresar resultados.
Figura 168. El botón “Guardar” aparece

deshabilitado.
Tabla 75. Pruebas de Caso de Uso: Ingresar Resultados de Emparejamientos
132
1.16.7. Ingresar partidas de los enfrentamientos generados por sistema
Las pruebas de caso de uso “Ingresar partidas de los enfrentamientos generados por
sistema” son descritas en la siguiente tabla:
Pruebas de Caso de Uso: Ingresar Partidas

OK
administración de torneo “Administración de torneos”.
Ingresar a la ventana de Resultados Se muestra la ventana “Resultados de
de torneo. Torneo”.
Entrada Salida
OK


El sistema muestra la ventana “Registrar

Ingresar a la ventana de ingreso de
Resultados” que muestra una grilla con
resultados de la ronda que se
la descripción de los enfrentamientos a
juega actualmente.
realizarse en la ronda actual.
Entrada Salida
OK
Figura 171. Se presiona el botón

“R1” para ingreso de resultados
“Registrar Resultados” para la ronda 1.
133
ingreso de partidas del sistema con un
Ingresar a ventana de Ingreso de
tablero de ajedrez en posición inicial y
Partidas al Sistema.
con los datos de los jugadores y del
torneo cargados en la aplicación.
Entrada Salida
OK

“Registrar Partida”.
Figura 174. Se muestra ventana de
ingreso de partidas.
Registrar Partidas en Sistema

Las piezas de ajedrez son arrastradas
desde su posición inicial hasta la
posición deseada según como se
Registrar Partida en Sistema
encuentra en la lista de movimientos de
arrastrando las piezas según las
la partida a ingresar. Todas las piezas
reglas del ajedrez.
de ajedrez del sistema tienen un
comportamiento acorde a las reglas
generales del ajedrez.
Entrada Salida
OK
Figura 175. Ingresar movimientos Figura 176. El sistema interpreta y

de una partida. registra el movimiento solicitado.
134
Registrar Partida en Sistema Si la pieza es ubicada en una posición
arrastrando las piezas a posiciones diferente a la señalada la pieza vuelve a
no válidas. su posición original.
Entrada Salida
OK
Figura 177. Ingresar de forma

errónea un movimiento de una Figura 178. El sistema reconoce el error
pieza. y retrocede la jugada.
Reproducir Partidas generadas al Ingresar Resultados

El sistema muestra la partida en
Ingresar a ventana de posición inicial y con las lista de
Reproducción de partidas. movimientos de la partida cargada en la
grilla del panel “Jugadas” de la ventana.
Entrada Salida
OK

Figura 179. Se elige
“Lectura de Partida” con partida
enfrentamiento y se presiona botón
cargada.
“Ver Partida”.
135
El sistema realiza las jugadas
especificadas en lista de movimientos de
Reproducir partida.
la ventana pudiendo avanzar y
retroceder si así se requiriese.
Entrada Salida
OK

“Avanzar”. Figura 182. Se reproducen las jugadas
registradas de la partida.
Tabla 76. Pruebas de Caso de Uso: Ingresar Partidas
136
1.16.8. Calcular ELO de jugador
Las pruebas de caso de uso “Calcular ELO de jugador” son descritas en la siguiente
tabla:
Pruebas de Caso de Uso: Calcular ELO de jugador

Ingresar a Calcular ELO a través de Ingreso de Resultados
Ingresar a ventana de administración El sistema muestra la ventana
OK
de torneo “Administración de torneos”
Ingresar a la ventana de Resultados de Se muestra la ventana “Resultados de
torneo. Torneo”.
Entrada Salida
OK
Figura 183. Presionar botón “Ingresar

Resultados”.

Ingresar a la ventana de cálculo de El sistema muestra el mensaje “No se ha

ELO sin elegir jugador. elegido el jugador”
Entrada Salida
OK

Figura 185. Presionar botón “Calcular sistema.
ELO” sin seleccionar jugador.
137
El sistema muestra la ventana de cálculo
de ELO mostrando el nuevo ELO del
Ingresar a la ventana de cálculo de jugador seleccionado y el detalle de los
ELO eligiendo a jugador. resultados del jugador hasta ese
momento que generan el cálculo del
nuevo ELO.
Entrada Salida
OK
Figura 187. Presionar botón “Calcular

ELO” seleccionando un jugador. Figura 188. Se muestra la ventana
“Cálculo de ELO”.
Calcular ELO de un torneo administrado por el sistema

Aplicado la fórmula:
Calcular ELO de un jugador no Nuevo ELO = valor actual ELO +
principiante. coeficiente * (puntos realizados - puntos
esperados).
Entrada Salida
Puntos esperados = partidas jugadas *
Se conoce los siguientes datos:
porcentaje probabilidad puntos (ELO
actual – promedio ELO rivales) = 5 *
diferencial (2194 - 2133) = 5 * 0.58 = 2.9.
(Para hallar valor de diferencial ver
Sistemas de Rating FIDE en Anexos). OK
Como el jugador posee un ELO actual
que se encuentra entre 2100 y 2400 su
Figura 189. Se obtiene ELO de coeficiente es 24.
oponentes de jugador y los puntos
obtenidos. Nuevo ELO = 2185 + 24*(2.5-2.9) = 2185.
138
Figura 190. Se generan datos para
cálculo de ELO.
Aplicando la fórmula:
Nuevo ELO = ELO promedio de
Calcular ELO de un jugador oponentes + diferencial de porcentaje de
principiante. puntos ganados.
Para hallar el valor del diferencial, ver
Sistemas de Rating FIDE en Anexos.
Entrada Salida

% puntos obtenidos = 2.5 / 6 = 0.42.
Diferencial % puntos obtenidos = -57
Nuevo ELO = 2160 – 57 = 2103.
OK
Figura 191. Se obtiene ELO de

Figura 192. Se generan datos para
cálculo de ELO.
obtenidos.
Calcular ELO de un torneo no administrado por el sistema

El sistema muestra la ventana “Cálculo
de ELO” que requiere el ingreso del
Ingresar a ventana de Cálculo de ELO número de partidas jugadas en el torneo,
a través del menú “Calcular ELO”. el ELO de los jugadores oponentes y los
puntos conseguidos con cada uno de
ellos.
Entrada Salida
139
OK
Figura 193. Se elige opción “Calcular

ELO” de menú ELO.

Aplicado la fórmula:
Calcular ELO de un jugador Nuevo ELO = valor actual ELO +
experimentado. coeficiente * (puntos realizados - puntos
esperados).
Entrada Salida
Puntos esperados = partidas jugadas *

diferencial (ELO actual – promedio ELO
rivales) = 5 * diferencial (2194 - 2133) = 5
* 0.58 = 2.9.
Como el jugador posee un ELO actual
que se encuentra entre 2100 y 2400 su
coeficiente es 24. OK
Nuevo ELO = 2185 + 24*(2.5-2.9) = 2185.

obtenidos.
Figura 196. Se calcula el nuevo ELO.
140
Aplicando la fórmula:
Nuevo ELO = promedio de ELOs de
Calcular ELO de un jugador contrincantes + diferencial de porcentaje
principiante. de puntos obtenidos.
Para hallar el valor del diferencial, ver
Sistemas de Rating FIDE en Anexos.
Entrada Salida
Se conoce los siguientes datos: % puntos obtenidos = 2.5 / 6 = 0.42.

Diferencial % puntos obtenidos = -57
Nuevo ELO = 2160 – 57 = 2103.
OK

obtenidos. Figura 198. Se calcula el nuevo ELO.
Calcular ELO FIDE de Jugador

El sistema muestra una ventana que
requiere el ingreso del número de torneos
Ingresar a la ventana de cálculo de jugados y el ELO conseguido en cada
OK
ELO FIDE una de ellas así como la cantidad de
partidas jugadas en cada uno de estos
torneos.
Entrada Salida
Figura 199. Se elige opción “Calcular

ELO” de menú ELO.
141
Se calcula nuevo ELO FIDE hallando la

Calcular ELO FIDE de jugador. media ponderada de los tres
rendimientos.
Entrada Salida
Nuevo ELO = (3*1750 + 5*1650 +
Se conocen los siguientes resultados: 4*1800) / (3 + 5 + 4) = 1725.
OK
Figura 201. Se ingresa ELO obtenido y

partidas jugadas por torneo. Figura 202. Se calcula el nuevo ELO
FIDE.
Tabla 77. Pruebas de Caso de Uso: Calcular ELO de jugador
142
1.16.9. Buscar Jugadores
Las pruebas de caso de uso “Buscar Jugadores” son descritas en la siguiente tabla:
Pruebas de Caso de Uso: Buscar Jugadores

Buscar Jugadores para inscribir
OK
Ingresar a la ventana de búsqueda de jugadores con la grilla
Búsqueda de Jugadores. llena de los jugadores registrados por el
sistema.
Entrada Salida
OK
“Agregar Jugadores” en
“Administración de torneos”.

“Inscribir Jugadores”.
El sistema filtra automáticamente a

Ingresar criterio de búsqueda grilla con los jugadores que cumplen
para hallar jugador con con los criterios de búsqueda. Los
coincidencias campos cotejados son los nombres,
apellidos y país de origen.
Entrada Salida
OK
Figura 205. Se ingresa criterio
de búsqueda. Figura 206. Se muestran registros que
coinciden con el criterio ingresado.
143
Ingresar criterio de búsqueda
para hallar jugador sin El sistema muestra la grilla vacía.
coincidencias.
Entrada Salida
OK
de búsqueda. Figura 208. Se muestra grilla vacía si
ningún registro coincide con criterio
ingresado.

Ingresar a la ventana de ingreso
Ingreso de partidas del juego de ajedrez
de partidas desde el menú
con el detalle de los jugadores
principal.
participantes vacío.
Entrada Salida
OK
Figura 209. Se ingresa a la

opción “Ingresar Partidas” de
Figura 210. Se muestra la ventana de
menú Partidas.
Ingresar datos de jugadores que El sistema muestra una ventana de

juegan la partida. búsqueda de jugador.
Entrada Salida
144
OK
“…” que elige a jugador de
piezas blancas de la partida.
“Elegir Jugador”.
El sistema filtra automáticamente la

Ingresar criterio de búsqueda grilla con los jugadores que cumplen
para hallar jugador con con los criterios de búsqueda. Los
coincidencias. campos cotejados son los nombres,
apellidos y país de origen.
Entrada Salida
OK
Figura 214. Se muestran registros que
de búsqueda.

para hallar jugador sin El sistema muestra la grilla vacía.
coincidencias.
OK
de búsqueda.
Figura 216. Se muestra grilla vacía si
ingresado.
Tabla 78. Pruebas de Caso de Uso: Buscar Jugadores
145
1.16.10. Buscar Partidas
Las pruebas de caso de uso “Buscar Partidas” son descritas en la siguiente tabla:
Pruebas de Caso de Uso: Buscar Partidas

Ingresar a Buscar Partidas
OK
Ingresar a la ventana de El sistema muestra la ventana de
Búsqueda de Partidas. Búsqueda de Partidas.
Entrada Salida
Figura 217. Se presiona botón OK

“Buscar Partidas” de
“Administración de torneos”.

“Buscar Partidas”.

El sistema filtra automáticamente la
Ingresar criterio de búsqueda grilla con las partidas que cumplen con
para hallar partida con los criterios de búsqueda. Los campos
coincidencias. cotejados son los nombres de
jugadores, nombre de torneo.
Entrada Salida
OK
146
para hallar partida sin El sistema muestra la grilla vacía.
coincidencias.
Entrada Salida
OK
de búsqueda.
Figura 222. Se muestra grilla vacía si
ingresado.
Tabla 79. Pruebas de Caso de Uso: Buscar Partidas
147
1.16.11. Buscar Torneos
Las pruebas de caso de uso “Buscar Torneos” son descritas en la siguiente tabla:
Pruebas de Caso de Uso: Buscar Torneos

Ingresar a Buscar Torneos
Ingreso de partidas del juego de ajedrez
ingreso de partidas desde el
con el detalle de los jugadores
menú principal.
participantes vacío.
Entrada Salida
OK

menú Partidas.
Ingresar datos de torneo El sistema muestra una ventana de

donde se juega la partida. búsqueda de jugador.
Entrada Salida
OK
Figura 225. Se presiona
botón “…” que elige torneo
donde se desarrolla la partida.

“Elegir Jugador”.
148
Los campos cotejados son los nombres
para hallar jugador con
de torneo y responsable de torneo.
coincidencias.
Entrada Salida
OK

para hallar torneo sin El sistema muestra la grilla vacía.
coincidencias.
Entrada Salida
OK
de búsqueda. Figura 230. Se muestra grilla vacía si
ingresado.
Tabla 80. Pruebas de Caso de Uso: Buscar Torneos
149
1.16.12. Ingresar Nuevas Partidas
Las pruebas de caso de uso “Ingresar Nuevas Partidas” son descritas a continuación:
Pruebas de Caso de Uso: Ingresar Nuevas Partidas

Ingresar a la ventana de El sistema muestra la ventana de Ingreso
Ingreso de Nuevas Partidas. de nuevas partidas.
Entrada Salida
OK

menú Partidas.
Ingresar Nueva Partida

Resaltar campos disponibles a El sistema resalta los campos posibles a

ser ocupados por pieza ser ocupados por la pieza de ajedrez
seleccionada. seleccionada por el usuario.
Entrada Salida
OK
Figura 233. Se elige al alfil Figura 234. Se resaltan las casillas

como la pieza a mover. posibles de destino.
150
Registrar movimiento en
Todas las piezas de ajedrez del sistema
Sistema arrastrando las
tienen un comportamiento acorde a las
piezas según las reglas del
reglas generales del ajedrez.
ajedrez.
Entrada Salida
OK
Figura 235. Se traslada el Figura 236. El caballo es situado en su

caballo a casilla resaltada. nueva posición.
Registrar movimiento en
Si la pieza es ubicada en una posición
Sistema arrastrando las
diferente a la señalada la pieza vuelve a
piezas a posiciones no
su posición original.
válidas.
Entrada Salida
OK
Figura 237. Se mueve el peón Figura 238. El peón es devuelto a su

a posición no válida. anterior posición.
Ingresar movimiento de El sistema ejecuta correctamente el

enroque corto. movimiento de enroque corto.
Entrada Salida
OK
Figura 239. Se elige mover al Figura 240. El enroque corto es

rey a la casilla g1. efectuado.
151
Ingresar movimientos de El sistema ejecuta correctamente el
enroque largo. movimiento de enroque largo.
Entrada Salida
OK
Figura 241. Se elige mover al

Figura 242. El enroque largo es
rey a la casilla c1.
efectuado.
El sistema ejecuta correctamente la

Efectuar comida de piezas.
comida de piezas.
Entrada Salida
OK
Figura 243. El peón negro va Figura 244. El peón negro toma su

a tomar al caballo blanco. nueva posición después de comer al
caballo.

Efectuar comidas al paso.
comida al paso de peones.
Entrada Salida
OK
Figura 245. El peón negro g7 Figura 246. El peón blanco h5 tomar el

se mueve a casilla g5. peón negro g5 y se ubica en la casilla g6.
152
Efectuar coronación de peón.
coronación de peones.
Entrada Salida
OK
Figura 247. El peón blanco en Figura 248. El peón blanco llega a última
casilla g7 avanza una casilla. fila y se convierte en dama.
El sistema registra correctamente la

Registrar los movimientos notación de los movimientos efectuados
realizados en la tabla de inclusive en casos en que dos piezas del
notaciones. mismo tipo puedan ocupar una misma
casilla.
Entrada Salida
OK
Figura 250. Se registra el movimiento a3

Figura 249. Se mueve el peón en la jugada 9
de casilla a2 a a3.
Deshacer los movimientos El sistema ejecuta correctamente el

realizados. retroceso de movimientos.
Entrada Salida
OK
Figura 251. Se mueve peón a

Figura 252. Se retrocede peón a casilla
casilla a3.
a2.
153
Quitar notación de movimiento El sistema realiza la eliminación de la
al retroceder jugada. notación del. movimiento deshecho.
Entrada Salida
OK
Figura 253. Lista de Figura 254. Lista de notaciones después
notaciones previo al retroceso. del retroceso.
Registrar partida sin

El sistema muestra el mensaje “Elija al
determinar al jugador de
jugador de piezas blancas. Por favor”.
piezas blancas.
Entrada Salida
OK
Figura 255. No se elige al
jugador de piezas blancas de Figura 256. Mensaje de advertencia del
la partida a registrar. sistema.
Registrar Partida sin

El sistema muestra el mensaje “Elija al
determinar al jugador de
jugador de piezas negras. Por favor”.
piezas negras.
Entrada Salida
OK
Figura 257. No se elige al
jugador de piezas blancas de Figura 258. Mensaje de advertencia del
la partida a registrar. sistema.
Registrar Partida sin realizar El sistema muestra el mensaje “No se ha

ninguna jugada. realizado ninguna jugada”.
Entrada Salida
154
OK
Figura 259. No se ha
realizado ninguna jugada de la Figura 260. Mensaje de advertencia del
partida a registrar. sistema.
Registrar partida sin registrar El sistema muestra el mensaje “Elija el

el nombre del torneo. nombre del torneo, por favor”.
Entrada Salida
OK
Figura 261. No se elige el
torneo donde se realiza la Figura 262. Mensaje de advertencia del
partida a registrar. sistema.
El sistema registra la partida en su base

Registrar partida registrando de datos y muestra el mensaje “Los
los datos de la partida. datos han sido guardados
correctamente”.
Entrada Salida

exitosa. OK
Figura 263. Se eligen a los

jugadores y al torneo de la
partida a registrar. Figura 265. Se confirma el registro de la
partida al buscar la partida en el sistema.
Tabla 81. Pruebas de Caso de Uso: Ingresar Nuevas Partidas
155
1.16.13. Comentar Partidas
Las pruebas de caso de uso “Comentar Partidas” son descritas en la siguiente tabla:
Pruebas de Caso de Uso: Comentar Partidas

Ingresar a ventana de Ingreso de Partidas
Entrada Salida
OK

menú Partidas.
Ingresar Comentarios a Partida

Registrar comentarios del El comentario es registrado y mostrado

movimiento actualmente en el área de texto de la pestaña
realizado. “Comentar” de la ventana.
Entrada Salida
OK
Figura 268. Se ingresa un Figura 269. Se registra y se muestra el

comentario. comentario.
156
Registrar comentarios de un El comentario es registrado y mostrado
movimiento anteriormente en el área de texto de la pestaña
Entrada Salida
OK
Figura 271. Se registra y se muestra el

comentario.
Figura 270. Se elige la jugada
y se ingresa el comentario.
Editar Comentario de Partida

El sistema muestra el comentario

Seleccionar comentario de la
completo de la jugada seleccionada en la
jugada a editar
caja de texto de edición.
Entrada Salida
OK
Figura 272. Se selecciona el

registro de un comentario.
Figura 273. Se muestra el comentario

completo seleccionado.
157
Registrar comentarios de un El comentario es editado y mostrado en
movimiento anteriormente el área de texto de la pestaña
Entrada Salida
OK
Figura 275. Se actualiza el registro de

comentarios.
Figura 274. Se ingresa nuevo
comentario y se presiona
botón “Ingresar Comentario”.
Tabla 82. Pruebas de Caso de Uso: Comentar Partidas
158
1.16.14. Leer Movimientos de Partida
Las pruebas de caso de uso “Leer Movimientos de Partida” son descritas en la

siguiente tabla:
Pruebas de Caso de Uso: Leer Movimientos de Partidas

Ingresar a Leer Partidas
Ingresar a la ventana de Lectura El sistema muestra la ventana de

de Partidas. Lectura de Partidas.
Entrada Salida
OK

opción “Leer Partidas” de menú
Partidas. Figura 277. Se muestra la ventana
“Lectura de Partidas”.
Ingresar al panel de ingreso El sistema muestra el panel de ingreso

movimientos de una partida. de movimientos de una partida.
Entrada Salida
OK
Figura 278. Se elige la pestaña
“PGN”.
Figura 279. Se activa el panel de la
pestaña “PGN”.
159
Leer Partida
El sistema reproduce los movimientos

registrados en la lista de movimientos y
Ingresar la lista de movimientos muestra un tablero de ajedrez en
de una partida de ajedrez. posición inicial con todas las jugadas
cargadas en el sistema lista para ser
reproducida.
Entrada Salida

exitosa.
OK
Figura 280. Se ingresan los

movimientos de una partida.
Figura 282. Se reproduce la partida de

ajedrez según movimientos ingresados.
El sistema reproduce los movimientos

registrados en la lista de movimientos y
Ingresar la lista de movimientos
muestra un tablero de ajedrez en
de una partida de ajedrez con
posición inicial con todas las jugadas
comentarios.
cargadas en el sistema lista para ser
reproducida.
Entrada Salida
160
exitosa.
OK
movimientos de una partida con
comentarios.
Figura 285. Se reproduce la partida de

ajedrez según movimientos ingresados
El sistema muestra un tablero de

Ingresar información errónea.
ajedrez sin cargar ninguna jugada.
Entrada Salida
OK
Figura 286. Se ingresan

movimientos no válidos. Figura 287. No se carga la lista de los
registros de las jugadas de la partida.
Registrar partida sin determinar El sistema muestra el mensaje “Elija al

al jugador de piezas blancas. jugador de piezas blancas. Por favor”.
Entrada Salida
OK
Figura 288. No se ingresa al
jugador de piezas blancas de la Figura 289. Mensaje de advertencia del
partida. sistema.
161
Registrar partida sin determinar El sistema muestra el mensaje “Elija al
al jugador de piezas negras. jugador de piezas negras. Por favor”
Entrada Salida
OK
Figura 290. No se ingresa al
jugador de piezas negras de la Figura 291. Mensaje de advertencia del
partida. sistema.
Registrar Partida sin realizar El sistema muestra el mensaje “Ingrese

ninguna jugada. las jugadas de la partida”.
Entrada Salida
OK
.
Figura 292. Se intenta guardar
sistema.
partida sin ingresar movimientos.
Registrar partida sin determinar El sistema muestra el mensaje “Elija el

nombre del torneo. nombre del torneo, Por favor”.
Entrada Salida
OK
Figura 294. No se ingresa el
torneo de la partida. Figura 295. Mensaje de advertencia del
sistema.
El sistema registra la partida en su base

Registrar Partida registrando los de datos y muestra el mensaje “Los
datos de la partida. datos han sido guardados
correctamente”.
162
Entrada Salida

exitosa.
OK
Figura 296. Se eligen a los

jugadores y al torneo de la Figura 298. Se confirma el registro de la
partida a registrar. partida al buscar la partida en el
sistema.
Tabla 83. Pruebas de Caso de Uso: Leer Movimientos de Partidas
163
1.16.15. Generar Reportes de Partida
Las pruebas de caso de uso “Generar Reportes de Partida” son descritas en la

siguiente tabla:
Pruebas de Caso de Uso: Generar Reportes de Partida

Ingresar a ventana de Ingreso de Partidas
Entrada Salida
OK

menú Partidas.
Figura 300. Se muestra ventana de
Generar Reporte de Partida Ingresando una Partida

Ingresar movimientos de El sistema reproduce los movimientos

partida. indicados en tablero de juego.
Entrada Salida
OK
Figura 302. Se genera la lista de

Figura 301. Se realizan notaciones de la partida.
movimientos en el tablero.
164
El sistema abre un archivo de formato pdf
que contiene los datos generales de la
partida, el gráfico del tablero de juego con
Generar reporte de partida.
las piezas en las posiciones actuales y el
detalle de los comentarios ingresados de la
partida.
Entrada Salida
OK
Figura 303. Se presiona

botón “Generar Reporte”. Figura 304. Se genera un reporte con el
detalle de la partida jugada.
Ingresar a Leer Partidas

Ingresar a la ventana de El sistema muestra la ventana de Lectura

Lectura de Partidas. de Partidas.
Entrada Salida
OK

opción “Leer Partidas” de
Figura 306. Se carga ventana de lectura
menú Partidas.
de partidas.
165
Generar Reporte de Partida Leyendo una Partida
El sistema reproduce los movimientos en

Leer partida.
tablero de juego.
Entrada Salida
OK

movimientos de una partida
Figura 308. Se genera una partida.
El sistema abre un archivo de formato pdf

que contiene los datos generales de la
Generar reporte de partida.
partida, el gráfico del tablero de juego y los
comentarios ingresados de la partida.
Entrada Salida
OK
Figura 309. Movimientos
generados de la partida.
Figura 310. Reporte de partida generado.
Tabla 84. Pruebas de Caso de Uso: Generar Reportes de Partida
166
1.16.16. Pruebas de Caso de Uso: Generar Reportes de Torneo
Las pruebas de caso de uso “Generar Reportes de Torneo” son descritas en la

siguiente tabla:
Pruebas de Caso de Uso: Generar Reportes de torneo

Ingresar Resultados de Torneo
OK
administración de torneo “Administración de torneos”.

Entrada Salida
OK


Generar Reporte de Resultados Generales de Torneo

El sistema genera un archivo en formato

Generar reporte de resultados xls donde se almacenan los resultados
generales de la división de un generales de la división del torneo: tabla
torneo. de posiciones con el resultado obtenidos
en cada una de las rondas jugadas.
Entrada Salida
167
sistema.
OK
Figura 313. Tabla de

resultados generales de un
torneo.
Figura 315. Reporte generado de torneo

en una hoja de cálculo.
Ingresar Resultados de Ronda

OK
Entrada Salida
OK

Ingresar a la ventana de El sistema muestra la ventana “Registrar

ingreso de resultados de la Resultados” que muestra una grilla con la
ronda que se juega descripción de los enfrentamientos a
actualmente. realizarse en la ronda actual.
168
Entrada Salida
OK
botón “R1” para ingreso de
resultados
“Registrar Resultados” para la ronda
uno.
Generar Reporte de Resultados de una Ronda de Torneo

El sistema genera un archivo en formato
Generar reporte de resultados xls donde se almacenan los resultados
de una ronda de la división de de los enfrentamientos de una ronda de
un torneo. la división del torneo: Lista de
enfrentamientos y resultados obtenidos.
Entrada Salida

sistema. OK
Figura 320. Lista de
enfrentamientos de jugadores
en una ronda.
Figura 322. Reporte generado de torneo

en una hoja de cálculo.
Tabla 85. Pruebas de Caso de Uso: Generar Reportes de torneo
169
1.16.17. Pruebas de Caso de Uso: Mostrar Movimientos de Piezas
Las pruebas de caso de uso “Mostrar Movimientos de Piezas” son descritas en la

siguiente tabla:
Pruebas de Caso de Uso: Aprendizaje de Movimientos de Piezas de Ajedrez

Ingresar a Aprendizaje de Movimientos de Pieza de Ajedrez
Aprender Movimientos de Piezas de Ajedrez
Elegir opción Peón de menú El sistema muestra la ventana de
Aprendizaje. aprendizaje de movimientos del peón.
Entrada Salida
OK

Figura 324. Se muestra ventana con
opción Peón de menú
peones desplegados en tablero.
Aprendizaje.
El sistema reproduce las jugadas de la

Realizar Jugadas con peón.
pieza peón según las reglas del ajedrez.
Entrada Salida
OK
Figura 325. Se selecciona Figura 326. Se ubica peón seleccionado

peón blanco de casilla c2. en la casilla c4.
170
Elegir opción Alfil de menú El sistema muestra la ventana de
Aprendizaje. aprendizaje de movimientos del alfil.
Entrada Salida
OK

opción Alfil de menú Figura 328. Se muestra ventana con
Aprendizaje. alfiles desplegados en tablero.

Realizar Jugadas con alfil.
pieza alfil según las reglas del ajedrez.
Entrada Salida
OK

alfil blanco de casilla f1. Figura 330. Se ubica alfil seleccionado
en la casilla a6.
171
Elegir opción Rey de menú El sistema muestra la ventana de
Aprendizaje. aprendizaje de movimientos del rey.
Entrada Salida
OK

opción Rey de menú Figura 332. Se muestra ventana con
Aprendizaje. reyes desplegados en tablero.

Realizar Jugadas con rey.
pieza rey según las reglas del ajedrez.
Entrada Salida
OK

rey blanco de casilla d3. Figura 334. Se ubica rey seleccionado
en la casilla e4.
172
Elegir opción Torre de menú El sistema muestra la ventana de
Aprendizaje. aprendizaje de movimientos de la torre.
Entrada Salida
OK

opción Torre de menú
Aprendizaje. Figura 336. Se muestra ventana con
torres desplegadas en tablero.
Realizar Jugadas con la El sistema reproduce las jugadas de la

torre. pieza torre según las reglas del ajedrez.
Entrada Salida
OK

torre negra de casilla f6. Figura 338. Se ubica torre seleccionada
en la casilla f1.
173
Elegir opción Dama de menú El sistema muestra la ventana de
Aprendizaje. aprendizaje de movimientos de la dama.
Entrada Salida
OK

opción Dama de menú Figura 340. Se muestra ventana con
Aprendizaje. damas desplegadas en tablero.
Realizar Jugadas con la El sistema reproduce las jugadas de la

dama. pieza dama según las reglas del ajedrez.
Entrada Salida
OK

dama negra de casilla g1. Figura 342. Se ubica dama
seleccionada en la casilla e1.
174
Elegir opción Caballo de El sistema muestra la ventana de
menú Aprendizaje. aprendizaje de movimientos del caballo.
Entrada Salida
OK

opción Caballo de menú
Aprendizaje. Figura 344. Se muestra ventana con
caballos desplegados en tablero.

Realizar Jugadas con caballo pieza caballo según las reglas del
ajedrez.
Entrada Salida
OK

caballo blanco de casilla d2. Figura 346. Se ubica caballo
seleccionado en la casilla e4.
Tabla 86. Pruebas de Caso de Uso: Aprendizaje de Movimientos de Piezas
175
1.17. Sistema de Desempate de Torneos
Una de las partes más difíciles en un torneo de ajedrez es entender el sistema de

desempates utilizado para la determinación de los ganadores de un torneo. Esta
sección ayudará a explicar este sistema con un ejemplo utilizando nombres y
resultados ficticios. La Federación Internacional de Ajedrez (FIDE) especifica los
siguientes sistemas de desempate utilizados en torneos oficiales, en este orden:
Sistemas de Desempate
Orden Puntos
1 Mediana
2 Solkoff
3 Acumulativo
Tabla 87. Sistemas de desempate
Si el primer sistema de desempate es incapaz de romper la igualdad, el segundo

sistema es utilizado para los jugadores que todavía permanecen empatados, y así
sucesivamente, hasta que se decidan las posiciones finales. Para una explicación más
fácil, se utilizarán resultados de un torneo ficticio, donde 13 personas terminan más o
menos en orden alfabético.
Tabla de Posiciones
Jugador Puntos
Ana 4.0
Billy 3.0
Coco 3.0
Danny 3.0
Erick 3.0
Franco 2.5
Gino 2.5
Henry 2.0
Iván 2.0
Jorge 2.0
Kenny 1.5
Lalo 1.0
Marco 1.0
Tabla 88. Tabla de Posiciones de torneo ficticio.
176
Como se puede apreciar, existen cuatro jugadores empatados en el segundo lugar que
necesitan ser desempatados.
1.17.1. Mediana
El sistema de la mediana funciona al comparar los puntajes de los oponentes que los
jugadores empatados enfrentaron durante el torneo. El objetivo es premiar a la
persona que jugó con los oponentes más fuertes.
El sistema funciona sumando los puntajes de todos los oponentes del jugador sin
considerar el puntaje mas bajo. Utilizando los resultados del torneo de ejemplo, se
aplica este sistema de desempate a los cuatro jugadores empatados en el segundo
lugar con tres puntos.
Tabla de Cálculo de Mediana

Billy Coco Danny Erick
Erick 3 Billy 3 Ana 4 Franco 2½
Henry 2 Franco 2½ Henry 2 Gino 2½
Iván 2 Henry 2 Lalo 1 Jorge 2
Marco 1 Lalo 1 Marco 1 Kenny 1½
Total 7 Total 7½ Total 7 Total 7
Tabla 89. Tabla para cálculo de Mediana de Billy, Coco, Danny y Erick.
Por lo tanto, utilizando el sistema de desempate de la mediana, Coco es premiado con

el segundo lugar y Billy, Danny y Erick, aún permanecen empatados en el tercer lugar.
Si todavía hay empates después de calcular la Mediana, el sistema Solkoff es utilizado
para los jugadores que aún permanecen empatados.
1.17.2. Solkoff
El sistema Solkoff es similar a la Mediana con la excepción que todos los puntajes son
considerados en el cálculo. Con el sistema Solkoff, el ejemplo del torneo sería de esta
forma:
177
Tabla de Cálculo de puntaje Solkoff
Billy Danny Erick
Erick 3 Ana 4 Franco 2½
Henry 2 Henry 2 Gino 2½
Iván 2 Lalo 1 Jorge 2
Marco 1 Marco 1 Kenny 1½
Total 8 Total 8 Total 8½
Tabla 90. Tabla para cálculo de puntaje Solkoff de Billy, Danny y Erick
Por tanto, utilizando el sistema de desempate Solkoff el tercer lugar es adjudicado a

Erick. Billy y Danny permanecen empatados en el cuarto lugar.
Si después de calcular el puntaje Solkoff permanecen aún los empates, se utiliza el

Sistema Acumulativo.
1.17.3. Acumulativo
El sistema acumulativo funciona sumando los puntajes de los jugadores después de

cada ronda hasta obtener un acumulado total. El sistema premia a los jugadores que
ganaron en las primeras rondas pero que pierden en rondas posteriores contra
jugadores más fuertes.
Digamos que Billy ganó su primer, tercer y cuarto juego, y Danny ganó su primer,
segundo y cuarto juego. El puntaje acumulativo sería:
Tabla de cálculo de puntaje Acumulativo

Ronda Billy Danny
Ronda 1 1 1
Ronda 2 1 2
Ronda 3 2 2
Ronda 4 3 3
Total 7 8
Tabla 91. Tabla para cálculo de puntaje Acumulativo de Billy y Danny.
Terminando con el ejemplo, Danny recibiría el cuarto lugar y Billy obtendría el quinto
puesto. Ejemplo tomado de [14].
178
1.18. Cálculo del ELO en un torneo
El rendimiento de un jugador es el Elo que obtiene en un torneo. Para calcular el

rendimiento se han de considerar tres casos:
1.18.1. Primer Caso
Rendimiento si se han obtenido el 50% de los puntos posibles:
Figura 347. Fórmula de ELO en caso lograr 50% de puntos posibles.
El rendimiento de un jugador que ha obtenido el 50% de los puntos posibles equivale a

la media de los puntos Elo de sus oponentes valorados.
1.18.2. Segundo Caso
Rendimiento si se han obtenido más del 50% de los puntos posibles
Figura 348. Fórmula de ELO en caso lograr mas del 50% de puntos posibles.
El rendimiento de un jugador que ha obtenido más del 50% de los puntos posibles
equivale a la media de los puntos Elo de sus oponentes valorados más 12.5 por cada
medio punto que supere el 50%.
179
1.18.3. Tercer Caso
Rendimiento si se han obtenido menos del 50% de los puntos posibles en un torneo
suizo o un por equipos.
Figura 349. Fórmula de ELO en caso lograr menos del 50% de puntos posibles.
El rendimiento de un jugador que ha obtenido más del 50% de los puntos posibles en
un torneo suizo o por equipos equivale a la media de los puntos Elo de sus oponentes
valorados más la diferencia de la valoración normal. Información tomada de [17].
180
1.19. Entrada de un Jugador en la lista de ELO FIDE
Cuando un jugador se ha enfrentado con, al menos nueve oponentes valorados

entrará en la lista de Elo FIDE si cumple las siguientes condiciones.
• Las nueve partidas se han conseguido en un máximo de tres torneos con un

mínimo de tres partidas en cada uno (bloque).
• El rendimiento del jugador ha de ser como mínimo de 1601 puntos Elo en cada
torneo
En este caso el Elo de su entrada en la lista será la media ponderada de los tres
rendimientos. Información tomada de [3]. Para realizar el cálculo se aplicará la
siguiente fórmula:
Figura 350. Fórmula para cálculo de ELO FIDE.
181
1.20. Sistema de Rating FIDE
El Sistema de Rating FIDE es un sistema numérico en el cual los porcentajes de

puntuación se convierten en diferencias de rating y viceversa. Su función es producir
información sobre la medición científica de la mejor calidad estadística.
Las tablas que siguen muestran la conversión del porcentaje de puntuación “p” en
diferencias de rating “dp”. Para una puntuación de 0 o 100% el valor de dp es
necesariamente indeterminado. Información tomada de [4].
Tabla de diferenciales para cálculo de ELO de jugadores principiantes
p dp p dp p dp p dp p dp p dp
1.00 0.83 273 0.66 117 0.49 -7 0.32 -133 0.15 -296
0.99 677 0.82 262 0.65 110 0.48 -14 0.31 -141 0.14 -309
0.98 589 0.81 251 0.64 102 0.47 -21 0.30 -149 0.13 -322
0.97 538 0.80 240 0.63 95 0.46 -29 0.29 -158 0.12 -336
0.96 501 0.79 230 0.62 87 0.45 -36 0.28 -166 0.11 -351
0.95 470 0.78 220 0.61 80 0.44 -43 0.27 -175 0.10 -366
0.94 444 0.77 211 0.60 72 0.43 -50 0.26 -184 0.09 -383
0.93 422 0.76 202 0.59 65 0.42 -57 0.25 -193 0.08 -401
0.92 401 0.75 193 0.58 57 0.41 -65 0.24 -202 0.07 -422
0.91 383 0.74 184 0.57 50 0.40 -72 0.23 -211 0.06 -444
0.90 366 0.73 175 0.56 43 0.39 -80 0.22 -220 0.05 -470
0.89 351 0.72 166 0.55 36 0.38 -87 0.21 -230 0.04 -501
0.88 336 0.71 158 0.54 29 0.37 -95 0.20 -240 0.03 -538
0.87 322 0.70 149 0.53 21 0.36 -102 0.19 -251 0.02 -589
0.86 309 0.69 141 0.52 14 0.35 -110 0.18 -262 0.01 -677
0.85 296 0.68 133 0.51 7 0.34 -117 0.17 -273 0.00
0.84 284 0.67 125 0.50 0 0.33 -125 0.16 -284
Tabla 92. Tabla de diferenciales para cálculo de ELO de jugadores principiantes.
182
Esta tabla muestra la conversión de diferencia de rating “D” en probabilidad de
puntuación “Pp” para el jugador mayor “H” o menor “L” rankeado, respectivamente.
Tabla de diferenciales para cálculo de ELO de jugadores experimentados

D PD D PD D PD D PD
Rtg Dif H L Rtg Dif H L Rtg Dif H L Rtg Dif H L
0-3 0.5 0.5 92-98 0.63 0.37 198-206 0.76 0.24 345-357 0.89 0.11
4-10 0.51 0.49 99-106 0.64 0.36 207-215 0.77 0.23 358-374 0.9 0.1
11-17 0.52 0.48 107-113 0.65 0.35 216-225 0.78 0.22 375-391 0.91 0.09
18-25 0.53 0.47 114-121 0.66 0.34 226-235 0.79 0.21 392-411 0.92 0.08
26-32 0.54 0.46 122-129 0.67 0.33 236-245 0.8 0.2 412-432 0.93 0.07
33-39 0.55 0.45 130-137 0.68 0.32 246-256 0.81 0.19 433-456 0.94 0.06
40-46 0.56 0.44 138-145 0.69 0.31 257-267 0.82 0.18 457-484 0.95 0.05
47-53 0.57 0.43 146-153 0.7 0.3 268-278 0.83 0.17 485-517 0.96 0.04
54-61 0.58 0.42 154-162 0.71 0.29 279-290 0.84 0.16 518-559 0.97 0.03
62-68 0.59 0.41 163-170 0.72 0.28 291-302 0.85 0.15 560-619 0.98 0.02
69-76 0.6 0.4 171-179 0.73 0.27 303-315 0.86 0.14 620-735 0.99 0.01
77-83 0.61 0.39 180-188 0.74 0.26 316-328 0.87 0.13 over 735 1 0
84-91 0.62 0.38 189-197 0.75 0.25 329-344 0.88 0.12
Tabla 93. Tabla de diferenciales para cálculo de jugadores experimentados.
183
1.21. Herramientas de construcción de Software
En esta sección del documento se describirán las herramientas que fueron utilizadas
en la construcción del software del proyecto.
1.21.1. Software de Construcción
En la siguiente tabla se describe el software necesario para la construcción del

sistema.
Software utilizado en el proyecto

Software Utilidad versión Dirección Internet
Paquete que contiene el
Java JDK compilador JAVA con sus jdk1.6.0_01 www.sun.com
correspondientes clases
Librería que simula una base
de datos relacional que
SQLite 3.6.6.2 www.sqlite.org
almacena la información que
gestiona el sistema a construir.
IDE de edición de archivos
NetBeans 5.5 www.netbeans.org
JAVA.
Tabla 94. Software utilizado en el proyecto.
184
1.21.2. Librerías utilizadas en Construcción
En la siguiente tabla se describen las librerías necesarias para la utilización del

sistema.
Librerías utilizadas en el proyecto

Librería Utilidad versión Dirección Internet
Librería estándar que
Swing provee soporte para la www.java.com
interfaz gráfica.
La librería FOP (Formatting

Objects Processor)
contiene un controlador de
Fop.jar formato de impresión para 0.20.5 xmlgraphics.apache.org
objetos XSL (XSL-FO) con
el fin de generar entre otros
archivos con formato PDF.
Librería que conecta el IDE

sqlitejdbc-
de NetBeans con gestor de 5.0.7 www.zentus.com/sqlitejdbc
v053.jar
datos SQLite
Librería que provee una

Jcalendar-
utilidad para la 1.3.2 www.toedter.com
1.3.2.jar
administración de fechas.
Librería para
manipulaciones de datos
Jdom.jar 1.4.1_02 www.jdom.org
XML optimizados para
Java.
Tabla 95. Librerías utilizadas en el proyecto.
185
1.22. Instalación y Ejecución del Sistema
El sistema no requiere de instalación, sólo hay que ejecutarlo. La distribución del

sistema consiste de un único archivo llamado deepPUCP.jar. Este archivo contiene
todos los ejecutables y librerías necesarios para el funcionamiento del sistema.
La ejecución requiere de los siguientes pasos:
1. Instalar la plataforma J2SE 1.4.2 o superior (si fuera necesario).

2. Ejecutar el archivo deepPucp.bat que contiene la sentencia necesaria para
levantar el sistema:
java –jar deepPUCP.jar
186
1.23. Descripción de menús del Sistema
La ventana principal del sistema contiene los siguientes menús:
1.23.1. Menú Inicio del Sistema
Las opciones disponibles del menú Inicio son se detallan en la siguiente tabla.
Menú Inicio del sistema

Opción Descripción
El sistema muestra la ventana principal de la aplicación que
Pantalla
dispone de los ingresos a la administración de torneos, jugadores y
Principal
partidas.
El sistema muestra la ventana de creación de un nuevo torneo en
Nuevo Torneo
el sistema.
Salir Esta opción cierra la aplicación
Imagen de
menú
Figura 351. Menú Inicio del Sistema
Tabla 96. Tabla de descripción del menú “Inicio”.
187
1.23.2. Menú Partidas del Sistema
Las opciones disponibles del menú Partidas del Sistema son:

Si el usuario desea registrar una nueva partida ingresa a esta
opción del menú y el sistema muestra la ventana de ingreso de
Ingresar
partidas, la cual contiene un tablero de ajedrez con sus
Partidas
respectivas piezas en posición de inicio disponibles a ser
arrastradas por el usuario reproduciendo en el sistema la partida
de ajedrez deseada.
Si el usuario desea reproducir una partida ingresa a esta opción
del menú y el sistema muestra la ventana de lecturas de partidas,
Leer Partidas la cual dispone de una sección de ingreso de archivos de
descripción de jugadas que son posteriormente interpretados y
mostrados para la interacción de la partida con el usuario.
Si el usuario desea encontrar una partida en la base de datos del

Buscar sistema ingresa a esta opción del menú y el sistema le mostrará
Partidas una ventana con diferentes criterios de búsqueda para encontrar la
partida deseada.
Imagen de
menú
Figura 352. Menú Partida del Sistema
Tabla 97. Tabla de descripción del menú “Partidas”
188
1.23.3. Menú ELO del Sistema
Las opciones disponibles del menú ELO del Sistema son:

Si el usuario desea calcular su nuevo ELO después de participar
Calcular ELO en un torneo o si desea calcular su nuevo ELO FIDE debe ingresar
a esta opción del menú y lea aparecerá la ventana de cálculo de
ELO.
Imagen de
menú
Figura 353. Menú ELO del Sistema
Tabla 98. Tabla de descripción del menú “ELO”.
189
1.24. Descripción de funcionalidades del Sistema
A continuación se muestra un resumen de las funciones básicas del sistema:
1.24.1. Crear nuevo Torneo
Ingresar a la ventana “Crear Nuevo Torneo” e ingresar el nombre del torneo, la

ciudad, la fecha de inicio de torneo, la fecha final de torneo y el nombre del
organizador. Para registrar los cambios, hay que presionar le botón “Crear Torneo”.
Figura 354. Pantalla de Ingreso de nuevo torneo
1.24.2. Crear nuevo Jugador
Ingresar a la pestaña “Ingresar Jugadores” de la ventana “Inscribir Jugadores”. Es

necesario ingresar el apellido paterno, el apellido materno, los nombre, país, fecha de
nacimiento y el sexo. Para registrar la información se presiona el botón “Registrar
Nuevo Jugador”.
Figura 355. Pantalla de Ingreso de nuevos jugadores
190
1.24.3. Inscribir jugador a división de torneo
Ingresar a la pestaña “Inscribir Jugadores” de la ventana “Inscribir Jugadores”. Es

necesario seleccionar a los jugadores que se desea registrar en una división de
torneo. A continuación se elige de la lista desplegable de la ventana la división de
torneo específica a la que se desea inscribir a los jugadores. Se presiona para
registrar la operación el botón “Agregar a Torneo”.
Figura 356. Pantalla de Asignación de jugadores a división de torneo
1.24.4. Crear Nueva División de torneo
Ingresar a la ventana “Agregar División a Torneo”, especificar el nombre de la división,

el tipo de torneo a realizar, el número de rondas a jugar, los puntos otorgados a los
jugadores que descansan por ronda y la descripción de la división. Para registrar los
datos en el sistema presionar el botón “Aceptar”.
Figura 357. Pantalla de creación de nueva división en torneo
191
1.24.5. Emparejar jugadores
Una vez que se ha inscrito a todos los jugadores de la división de torneo a administrar
se ingresar a la ventana “Resultados de torneo” y se presiona el botón naranja
“Siguiente”, el cual asignará a cada jugador el contrincante a quién y el color de piezas
con que jugará. Los emparejamientos son registrados automáticamente por el sistema.
Figura 358. Pantalla de registro de resultados por división de torneo
1.24.6. Ingresar Resultados de Enfrentamientos
Una vez realizado el emparejamiento de una ronda se procede a registrar los

resultados de los enfrentamientos. Se presiona el botón “Rnd” correspondiente a la
ronda jugada de la ventana “Resultados de Torneo” y se muestra la ventana “Registrar
Resultados”. Para asignar los resultados se presiona la columna oscura “Resultado”
de la grill y aparece en la fila correspondiente la lista desplegable con las opciones
correspondientes al resultado del juego. Una vez elegidos los resultados, se procede a
registrarlos en el sistema presionando el botón “Guardar”.
Figura 359. Pantalla de emparejamientos y registro de resultados por fecha
192
1.24.7. Registrar Partidas
Ingresar a la ventana “Ingreso de Partidas”, realizar en el tablero mostrado los

movimientos necesarios de la partida a registrar, posteriormente ingresar el nombre de
los dos jugadores, el del torneo en que se juega la partida y la fecha de juego. Para
registrar la partida en el sistema presionar el botón “Grabar”.
Figura 360. Pantalla de Ingreso de partidas con vista de la pestaña “Datos”.
1.24.8. Reproducir Partidas
Ingresar a la ventana “Lectura de Partidas”, pegar la lista de movimientos de la partida

deseada en la caja de texto de la pestaña “PGN”. La partida se carga en el tablero de
ajedrez de la ventana mostrando la notación de la partida completa el la tabla de
jugadas de la ventana. Para reproducir las jugadas presionar el botón “Avanzar”, en
caso de retroceder las jugadas presionar el botón “Retroceder”.
Figura 361. Pantalla de Lectura de partidas de ajedrez
193
1.24.9. Calcular ELO de Jugador en torneo
Una vez concluido un torneo se selecciona a un jugador de la ventana “Resultados de

Torneo” y se presiona el botón “Calcular ELO”. Se muestra la ventana “Cálculo de
ELO” que contiene la pestaña “ELO en torneo” con una grilla cargada con todos los
jugadores enfrentados especificando su coeficiente ELO y los puntos obtenidos en las
partidas. Tomando como dato esta información se muestra en la caja de texto “ELO
Resultante” el cálculo del ELO conseguido por el jugador en el torneo.
Figura 362. Pantalla de Cálculo de ELO en torneo
1.24.10. Calcular ELO FIDE de Jugador
Para calcular el ELO FIDE de un jugador se debe ingresar a la ventana “Calculo de

ELO” y presionar la pestaña “ELO FIDE” e ingresar en la lista desplegable de la
ventana el número de torneos jugados desde que calculó su ELO FIDE por última vez.
A continuación se crea una grilla en donde se debe especificar el ELO conseguido en
cada uno de estos torneos, así como las partidas jugadas en cada uno de ellos.
Seleccionando el tipo de jugador que es presionar el botón “Calcular ELO FIDE” para
obtener el nuevo ELO FIDE.
Figura 363. Pantalla de Cálculo de ELO FIDE
194
1.25. Algoritmo de emparejamiento de un torneo tipo suizo
En esta sección se procederá a describir el algoritmo de emparejamientos para

torneos que utilicen el sistema suizo.
Para ello se dividirá la explicación analizando las cinco funciones más importantes que
realizan esta tarea, las cuales son las siguientes:
Funciones de emparejamiento de Sistema Suizo

N nombre
1 emparejarSegunGrupos
2 emparejarDentrodeGrupo
3 proponerRivales
4 llenarMatrizPareos
5 dameMatrizdeRivales
Tabla 99. Funciones de emparejamiento de Sistema Suizo
195
1.25.1. La función emparejarSegunGrupos
Es la encargada de la gestión de los grupos de jugadores divididos por sus actuales

puntajes.
En una primera instancia se encarga de inicializar la información de los jugadores que

conforman cada uno de estos grupos y de obtener además información histórica de
cada uno de estos jugadores (como a lista de jugadores con que ya se jugó) que
servirá para generar los siguientes emparejamientos.
Posteriormente enviará cada grupo formado a la función emparejarDentrodeGrupo

para que este se encargue de los emparejamientos de cada uno de estos grupos.
Al final de los emparejamientos se procederá a registrar los resultados en la base de
datos del sistema.
Función emparejarSegunGrupos
descripción
public int emparejarSegunGrupos( int ronda,
grupo[] gruposFormados,
int idDivision,
ArrayList<jugadorxDivision> jugadoresdeTorneo,
boolean condicionColor){
int totalGrupos=0, resultado=0, ultimo =0 , rpta2 = 0;
ArrayList<jugadorxDivision> listadeGrupo, penultimo, nuevoGrupo;
elGrupoBL = new grupoBL();

String tipo = "homogeneo";
this.gruposFormados = gruposFormados;
totalGrupos = gruposFormados.length;
for(int k=0; k<totalGrupos; k++){

listadeGrupo = gruposFormados[k].dameListaJugadoresdeGrupo();
for(jugadorxDivision jxd : listadeGrupo){

jxd.llenarListaContrincantesxRonda();
jxd.llenarListaColoresxRonda();
jxd.llenarListaFlotantesxRonda();
jxd.setTEMPColor(0);
jxd.setTEMPContrincante(0);
jxd.setTEMPFlotante(0);
jxd.setTEMPtipoSubGrupo("");
int colorDato = elGrupoBL.determinarSgteColorxJugador(ronda, jxd);
jxd.setTEMPColorObligatorio(colorDato);
}
}
for(int k=0; k<totalGrupos; k++){

this.actualGrupoTrabajando = k;
listadeGrupo = gruposFormados[k].dameListaJugadoresdeGrupo();
for(jugadorxDivision jxd : listadeGrupo){

jxd.setTEMPColor(0);
jxd.setTEMPContrincante(0);
}
196
this.ordenarJugadores(listadeGrupo);
resultado = emparejarDentrodeGrupo(ronda, listadeGrupo, tipo, idDivision, jugadoresdeTorneo,
condicionColor);
tipo = "homogeneo";
if(resultado == 1 ){
//exito = true; /*Sigo nomas*/
}
else if(resultado==0 && k<totalGrupos-1){
/*Ya estan emparejados*/
tipo = "heterogeneo"; /*para el siguiente grupo*/
}
else if(resultado == 3){
System.out.println("ULTIMO GRUPO DE PUNTUACION");
if(k>=1){
ultimo = k-1;
do{
if (ultimo ==0 || ultimo == -1) break;
penultimo = gruposFormados[ultimo].dameListaJugadoresdeGrupo();
this.limpiarPareos(listadeGrupo);
this.limpiarPareos(penultimo);
nuevoGrupo = this.combinarUltimosGrupos(listadeGrupo,penultimo);
boolean resultadoColor;
if(condicionColor== true)
resultadoColor = elGrupoBL.sePuedePareoxColores(ronda, nuevoGrupo);
else resultadoColor = false;
if(resultadoColor == true) rpta2 = 0;

else{
resultado = this.emparejarDentrodeGrupo(ronda, nuevoGrupo, "ultimo",idDivision,
jugadoresdeTorneo, condicionColor);
int totalFechas = this.getTotalFechas(idDivision);
boolean ultimasFechas = (ronda == totalFechas) || (ronda == totalFechas-1);
if(resultado == 3 && ultimasFechas == true){

resultado = this.emparejarDentrodeGrupo(ronda, nuevoGrupo, "ultimo", idDivision,
jugadoresdeTorneo, false);
}
}
ultimo--;
}while(resultado!=1);
}
else System.out.println("No se puede emparejar");
}
}
int color, flotante, rival;
jugadorxDivxRondaBL jxdxrBL = new jugadorxDivxRondaBL();
/*Ingreso a base datos*/

if(resultado!=3){
rondaBL blRonda = new rondaBL();
ronda rnd = blRonda.getIdRonda(idDivision, ronda);
for(jugadorxDivision jxd : jugadoresdeTorneo){
color = jxd.getTEMPColor();
rival = jxd.getTEMContrincante();
flotante = jxd.getTEMPFlotante();
jxdxrBL.actualizarDatosPrevia(jxd.getIdJugadorxDiv(), rnd.getIdRonda(), rival, color, flotante);

}
}
return resultado;
}
Tabla 100. Función emparejarSegunGrupos
197
1.25.2. La función emparejarDentrodeGrupo
Esta función se encarga de la administración de un grupo de jugadores previamente

seleccionados en función de sus puntajes obtenidos hasta ese momento.
En caso se presente la situación de trasladar a uno o varios jugadores hacia otro

grupo se procede a recrear a todos los grupos formados a través de la función
crearNuevosGruposPuntuacion.
A continuación se procede a dividir al grupo final en dos subgrupos. Los jugadores del
primer subgrupo intentarán ser emparejados con los jugadores del segundo grupo, de
aquello se encargará la función proponerRivales.
Si el proceso de emparejamiento del grupo ha sido exitoso se devuelve uno. Si el

proceso de emparejamiento del grupo aún no termina (porque se emparejaron todos
menos uno, por ejemplo) se devuelve cero. Si el proceso de emparejamiento del grupo
ha fracasado se devuelve tres.
Función emparejarDentrodeGrupo
descripción
private int emparejarDentrodeGrupo( int ronda,
ArrayList<jugadorxDivision> listaJugadores,
String tipo,
int idDivision,
ArrayList<jugadorxDivision> jugadoresdeTorneo,
boolean mandadoTransfugas = false;
int rpta =0;
int tamanoLista =listaJugadores.size();
listaTransfugas = new ArrayList<jugadorxDivision>();
ArrayList<jugadorxDivision> transfugasAdicionales;
if(tamanoLista > 0){

listadePuntajes = elGrupoBL.determinarPuntajesUnicos(jugadoresdeTorneo);
transfugasAdicionales =
this.elGrupoBL.noPuedenJugarenelGrupo(ronda, listaJugadores, condicionColor);
if(transfugasAdicionales.size()>0 && this.actualGrupoTrabajando == listadePuntajes.size()-1){

return 3;
}
else if(transfugasAdicionales.size()>0 && tipo.equals("ultimo")==false){
mandadoTransfugas = true;
for(jugadorxDivision transfuga : transfugasAdicionales){
tamanoLista--;
}
if(this.actualGrupoTrabajando < listadePuntajes.size()-1){

this.crearNuevosGruposPuntuacion(ronda,transfugasAdicionales, idDivision);
if(this.actualGrupoTrabajando == listadePuntajes.size()-2 ){
ArrayList<jugadorxDivision> noEmparejados;
198
noEmparejados =
this.elGrupoBL.noPuedenJugarenelGrupo(ronda, listaJugadores, condicionColor);
if(noEmparejados.size()>0){
return 3;
}
}
}
else return 3;
if(tamanoLista==0) return 0;
else if(tamanoLista==1){
for(jugadorxDivision transfuga : listaJugadores){
listaTransfugas.add(transfuga);
}
this.crearNuevosGruposPuntuacion(ronda,listaTransfugas, idDivision);
return 0;
}
}
/*Hay que crear los grupos s1 y s2*/

ArrayList<jugadorxDivision> subGrupoS1 = new ArrayList<jugadorxDivision>();
if(tipo.equals("homogeneo") == true ){
elGrupoBL.crearSubGrupo(listaJugadores, ronda, "homogeneo", subGrupoS1, subGrupoS2);
}
else{ /*Es heterogeneo*/
elGrupoBL.crearSubGrupo(listaJugadores, ronda, "heterogeneo", subGrupoS1, subGrupoS2);
if(subGrupoS1.size() > subGrupoS2.size()){
ArrayList<jugadorxDivision> listaApoyo;
listaApoyo = subGrupoS1;
subGrupoS1 = subGrupoS2;
subGrupoS2 = listaApoyo;
}
if(subGrupoS1.size()==0 || subGrupoS2.size()==0){
elGrupoBL.crearSubGrupo(listaJugadores, ronda, "homogeneo", subGrupoS1,
subGrupoS2);
}
}
rpta= proponerRivales(ronda, subGrupoS1, subGrupoS2, idDivision, condicionColor);
if(rpta==1 && mandadoTransfugas==true){

rpta = 0;
}
else if(rpta == 3 && tamanoLista != 2 && this.actualGrupoTrabajando < listadePuntajes.size()-1){
for(jugadorxDivision transfuga : listaJugadores){
listaTransfugas.add(transfuga);
}
this.crearNuevosGruposPuntuacion(ronda,listaTransfugas, idDivision);
rpta = 0;
}
return rpta;
}
return 1;
}
Tabla 101. emparejarDentrodeGrupo
199
1.25.3. La función proponerRivales
Esta función se encarga de determinar a las parejas que tendrán que jugar en la ronda
indicada. Esto se logra al determinar qué jugador del subgrupo S2 tiene que jugar
contra qué jugador del subgrupo S1
Para ello se determina los posibles rivales de cada jugador del subgrupo S1
procediéndose a formar una matriz con la terna de jugadores del subgrupo S2 con que
cada jugador del subgrupo S1 puede jugar.
Después se procede a probar cada una de las ternas formadas hasta seleccionar a la
primera combinación exitosa de emparejamientos. Finamente se procede a asignarse
a los jugadores los colores de piezas con los que tendrán que jugar.
Si los emparejamientos han sido exitosos la función devuelve uno, sino se devuelve 3.
Función proponerRivales
descripción
public int proponerRivales(int ronda,
ArrayList<jugadorxDivision> s1,
int idDivision,
jugadorxDivision[][] planchadeRivales;
ArrayList<jugadorxDivision> jugadoresParaS1;
int alto=1, ancho=s1.size();
boolean condicion, condicion1, condicion2, condicion3;

ArrayList<jugadorxDivision> jugadoresPendientes;
jugadorxDivision jugadorS1, jugadorS2;
for(jugadorxDivision jxdS1:s1){
jugadoresParaS1 = this.elGrupoBL.listaJugadoresAptos(ronda, jxdS1, s2, condicionColor);
if(jugadoresParaS1==null || jugadoresParaS1.size() == 0) return 3;
/*Pasan todos al siguiente grupo*/
//this.ordenarJugadores(jugadoresParaS1);
jxdS1.setTEMPListaPosiblesRivales(jugadoresParaS1);
alto *= jxdS1.getTEMPListaPosiblesRivales().size();
}
planchadeRivales = dameMatrizdeRivales(ronda, s1, s2, alto, ancho);

if(planchadeRivales == null) return 3;
for(int m=0; m<alto; m++){

jugadoresPendientes = llenarJugadoresPendientesInicio(s2);
condicion = eliminarCandidatosPareo(planchadeRivales[m], ancho, s2);

if(condicion == false){
for(int n=0; n<ancho; n++){
jugadorS1 = s1.get(n);
jugadorS2 = planchadeRivales[m][n];
System.out.println("PAREO:: ("+jugadorS1.getNumeroId()+",
200
"+jugadorS2.getNumeroId()+")");
jugadorS1.setTEMPContrincante(jugadorS2.getNumeroId());
jugadorS2.setTEMPContrincante(jugadorS1.getNumeroId());
int dato = jugadorS1.getTEMPFlotante();
if(dato == 1){
jugadorS2.setTEMPFlotante(2);
}
/*Ahora tengo que determinar el color*/
establecerColores(ronda, jugadorS1, jugadorS2, idDivision);
jugadoresPendientes.remove(planchadeRivales[m][n]);
}
if(jugadoresPendientes.size()== 0){
System.out.println("---Pareo Terminado---");
return 1;
}
else if(jugadoresPendientes.size()== 1){
condicion1 =
this.puedeJugarenelGrupo(jugadoresPendientes.get(0), this.actualGrupoTrabajando+1);
if( condicion1 == true){
this.crearNuevosGruposPuntuacion(ronda, jugadoresPendientes, idDivision);
return 1;
}
}
else{/*Faltan emparejar*/
/*Determinar si los jugadores pendientes se pueden emparejar entre si*/
int resultado;
if(condicionColor == true)
condicion2 = this.elGrupoBL.sePuedePareoxColores(ronda, jugadoresPendientes);
else condicion2 = false;
if(condicion2 == false){
condicion3 = this.elGrupoBL.noPuedenJugarEnEsteGrupo(ronda, jugadoresPendientes,
condicionColor);
if(condicion3 == false){
this.elGrupoBL.crearSubGrupo(jugadoresPendientes, ronda, "homogeneo",
subGrupoS1, subGrupoS2);
printGrupoS1S2(subGrupoS1, subGrupoS2);
resultado = proponerRivales(ronda, subGrupoS1, subGrupoS2, idDivision,
condicionColor);
if(resultado == 1) {
return 1;
}
else continue;
}
else continue;
}
else continue;
}
}//condicion
}//for
System.out.println("NO SE COMPLETO PAREO");
return 3;
}
Tabla 102. Función proponerRivales
201
1.25.4. La función llenarMatrizPareos
Se encarga de ingresar en una columna de la matriz los identificadores de los

jugadores con que un jugador del primer subgrupo puede jugar.
Función llenarMatrizPareos
descripción
void llenarMatrizPareos(int indColumna,
int veces,
int alto,
jugadorxDivision[][] planchadeRivales){
int turnosRival, contadorTotal, contadorRepetidas;

jugadorxDivision jxdRival, jxd;
jxd = s1.get(indColumna);
turnosRival = jxd.getTEMPListaPosiblesRivales().size();
contadorTotal = 0;
while(contadorTotal < alto){
for(int i=0; i<turnosRival; i++){
contadorRepetidas =0;
jxdRival = jxd.getTEMPListaPosiblesRivales().get(i);
while(contadorRepetidas < veces){
planchadeRivales[contadorTotal][indColumna] = jxdRival;
contadorTotal++;
contadorRepetidas++;
}
}
}
}
Tabla 103. Función llenarMatrizPareos
202
1.25.5. La función dameMatrizdeRivales
Se encarga de crear la matriz con la terna de jugadores del subgrupo S2 que serán
emparejados con los jugadores del subgrupo S1.
Función dameMatrizdeRivales
descripción
jugadorxDivision[][] dameMatrizdeRivales(int ronda,
int alto,
int ancho){
jugadorxDivision[][] planchadeRivales;
int tamanoS1 = s1.size();
this.ordenarJugadoresxTamLista(s1);
planchadeRivales = new jugadorxDivision[alto][ancho];

jugadorxDivision jugS1;
for(int k=0; k<tamanoS1; k++){

int veces = 1;
for(int i=k+1; i<tamanoS1; i++){
jugS1 = s1.get(i);
veces *= jugS1.getTEMPListaPosiblesRivales().size();
}
llenarMatrizPareos(k, veces, alto, s1, planchadeRivales);
}
return planchadeRivales;
}
Tabla 104. Función dameMatrizdeRivales
203
1.26. Optimización del algoritmo de Sistema Suizo
Con el objetivo de agilizar la obtención de los emparejamientos de los jugadores en

este tipo de sistema de juego se ha procedido a modificar los procedimientos
establecidos por la Federación Internacional de Ajedrez (FIDE).
A continuación se describen las diferencias en los procedimientos:
1.27. Procedimiento FIDE
El procedimiento recomendado por la FIDE es el siguiente:
En el proceso de asignación de rivales suponemos que el primer grupo consta de los

jugadores 1, 2, 3 ,4 y el segundo grupo consta de los jugadores 5, 6, 7 y 8.
El procedimiento oficial indica que se procede a generar la combinación de los

jugadores del segundo grupo de la siguiente forma y orden:
{5,6,7,8}, {5,6,8,7}, {5,7,6,8}, {5,7,8,6}, {5,8,6,7}, {5,8,7,6}, {6,5,7,8}, {6,5,8,7}, {6,7,5,8},

{6,7,8,5}, {6,8,5,7}, {6,8,7,5}, {7,5,6,8}, {7,5,8,6}, {7,6,5,8}, {7,6,8,5}, {7,8,5,6}, {7,8,6,5},
{8,5,6,7}, {8,5,7,6}, {8,6,5,7}, {8,6,7,5}, {8,7,5,6}, {8,7,6,5}.
Se toma la primera combinación, para este caso {5,6,7,8} y se asignan como rivales de
los jugadores {1,2,3,4}, es decir 1 contra 5, 2 contra 6, 3 contra 7 y 4 contra 8, si no es
posible emparejar a todos los jugadores se continúa con la siguiente serie, para este
caso {5,6,8,7}, y así sucesivamente hasta encontrar la terna de jugadores adecuada
que haga posible que todos los jugadores queden emparejados.
En caso que el segundo grupo de jugadores conste de cinco jugadores se generarán

120 combinaciones y si fuera de seis jugadores se producirían 720 combinaciones.
Se comprueba que resulta demasiado ineficiente obtener los emparejamientos

utilizando este procedimiento puesto que obliga a revisar un número grande de ternas
para obtener el emparejamiento correcto.
204
1.28. Procedimiento Optimizado
Es por eso que en el presente proyecto se implementa una forma novedosa y eficiente
de obtención de emparejamientos, la cual se procederá a describir a continuación:
Supongamos que se tiene los subgrupos S1 y S2 conformados de la siguiente manera:

S1 {jugador 3, jugador 8, jugador 9} y S2 {jugador 1, jugador 2, jugador 4, jugador 5,
jugador 6, jugador7}
El algoritmo se encargará de calcular con qué jugadores del grupo S2 podrán jugar
cada uno de los jugadores del subgrupo S1. Así tendríamos:
Jugador 3 puede jugar con: jugador 7, jugador 2, jugador 6

Jugador 8 puede jugar con: jugador 4, jugador 2, jugador 1
Jugador 9 puede jugar con: jugador 5, jugador 3
Se procede a formar la siguiente matriz de posibles emparejamientos
Terna de jugadores a emparejar

Jugador 3 Jugador 8 Jugador 9
7 4 5
7 4 3
7 2 5
7 2 3
7 1 5
7 1 3
2 4 5
2 4 3
2 2 5
2 2 3
2 1 5
2 1 3
6 4 5
6 4 3
6 2 5
6 2 3
6 1 5
6 1 3
Tabla 105. Terna de jugadores a emparejar.
Así, cada una de las ternas formadas (en caso estar compuestas por jugadores
diferentes) es potencialmente una posible solución, mejorando en gran medida la
rapidez en la obtención de los emparejamientos.
205

Tesis. Anexo. Análisis, Diseño e Implementación de Un Administrador de Torneos de Ajedrez

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Tesis. Anexo. Análisis, Diseño e Implementación de Un Administrador de Torneos de Ajedrez

Cargado por

Copyright:

Formatos disponibles

PONTIFICIA UNIVERSIDAD CATÓLICA DEL PERÚ

FACULTAD DE CIENCIAS E INGENIERÍA

ANÁLISIS, DISEÑO E IMPLEMENTACIÓN

Billy Antonio Colonia Machado

ASESOR: Carlos Molina Maraví

Lima, Diciembre del 2008

Es un proceso de ingeniería de software, el cual proporciona una aproximación

Tabla 1. Fases de RUP.

Fases de RUP a desarrollar en el proyecto

Definición preliminar del producto. La definición preliminar del

Fase Diagrama de secuencia. obtiene el diseño del sistema

de Documento preliminar de diseño para su posterior

Elaboración detallado (diseño de BD). construcción cumpliendo así

Preliminar de la interfaz gráfica. con las listas de exigencias

Presentación del prototipo. es el hito final de esta fase

Tabla 2. Fases de RUP a desarrollar en el proyecto

A continuación se describen los flujos de trabajo utilizados en la metodología RUP.

En este flujo se muestra la especificación de casos de pruebas

Tabla 3. Flujos de trabajo del proyecto

Objetivos por iteración

Fase Iteración Definir los Definición Especificaciones

Fase Iteración Se completa el análisis Prototipo No explicar

Iteración Implementar y probar Software No cambiar todos

Iteración Diseño, Software Problemas de

Tabla 4. Objetivos por iteración del proyecto

El Lenguaje Unificado de Modelado (UML) se ha convertido en el lenguaje aceptado

Es un lenguaje gráfico para visualizar, especificar, construir y documentar un sistema

Diagramas a utilizar en el Proyecto

Presenta una interacción, la cual es un conjunto de mensajes entre

Tabla 5. Diagramas a utilizar en el Proyecto

Hoy en día existe un amplio abanico de posibilidades. Cada lenguaje de programación

El lenguaje en sí mismo toma mucha de su sintaxis de C y C++, pero

A mediados del 2007, Sun Microsystems liberó la mayor parte de sus

Tabla 6. Descripción de lenguajes de programación a elegir

Una base de datos es un conjunto de datos almacenados siguiendo una estructura

Una base de datos debe:

• Evitar problemas como la ambigüedad de datos y su duplicación.

Actualmente existen varios sistemas especializados en la creación y gestión de una

Gestores de Base de Datos

Es el sistema para gestionar bases de datos relacionales, licenciado

Se caracteriza por ser un gestor rápido y muy eficiente. Su diseño

MySQL es portátil a la mayoría de sistemas operativos (Unix, Mac,

Uno de las primeras diferencia entre los motores de Bases de datos

PostGreSQL es un sistema gestor de base de datos objeto-relacional

Tabla 7. Descripción de gestores de base de datos

La arquitectura cliente-servidor llamado modelo cliente-servidor o servidor-cliente es

Figura 1. Modelo Cliente-Servidor con tres capas.

En un esquema cliente-servidor, se denomina cliente la máquina que solicita un

En la actualidad se suele hablar de arquitectura de tres niveles o “n” niveles, donde la

Las capas de negocio y de datos pueden residir en el mismo ordenador, y si el

Es la que ve el usuario (hay quien la denomina "capa de usuario"),

Es la que ve el usuario (hay quien la denomina "capa de usuario"),

Tabla 8. Capas de Arquitectura

1.6.1. Módulo de Administración de Torneos

Los requerimientos asociados a la administración de los torneos son los siguientes:

El sistema permitirá la selección del

Tabla 9. Requerimientos del módulo de administración de torneo

Los requerimientos asociados a la administración de las partidas son los siguientes:

Tabla 10. Requerimientos del módulo de aprendizaje

Los requerimientos generales del sistema son los siguientes:

La arquitectura del sistema seguirá No

El lenguaje de programación será No

Los componentes servidor correrán