Saltar navegación

Activa JavaScript para disfrutar de los vídeos de la Mediateca.

Clase 18-03-24 - 2 - Contenido educativo

Ajuste de pantalla

El ajuste de pantalla se aprecia al ver el vídeo en pantalla completa. Elige la presentación que más te guste:

Subido el 3 de abril de 2024 por Raquel G.

9 visualizaciones

Más información Transcripción

Descargar la transcripción

Vale, pues venga, seguimos. 00:00:00
Habíamos hecho ya de jugador bastante. 00:00:02
Recibir carta y mostrar mano. 00:00:05
Y vamos a encender el trofeo. 00:00:08
Venga. 00:00:27
Vale, pues ya habíamos hecho de jugador prácticamente todo 00:00:38
Silencio 00:00:43
Vale, entonces 00:00:46
Recibir carta 00:00:51
En realidad, como veis, eran dos líneas 00:00:54
Tanto si decidís pasárselo por parámetro 00:00:57
Como si os dais cuenta de que al haber solo una común 00:00:59
Para toda la aplicación, la ponéis estática 00:01:02
Y accedéis a ella, sí, en realidad son dos líneas 00:01:04
Lo que pasa es que lo que se trata es de 00:01:06
Que se plantea una situación 00:01:08
y tengo este objeto aquí 00:01:10
entonces entendiendo lo que significa 00:01:12
entendiendo cómo funciona 00:01:14
la solución es inmediata 00:01:15
y ahí la importancia de lo que os digo siempre 00:01:16
entender siempre lo que hay que hacer 00:01:19
cómo va a funcionar la aplicación 00:01:22
porque si uno le ha dedicado todo el tiempo necesario 00:01:23
a entender cómo funciona 00:01:26
y eso es mucho antes de empezar a teclear 00:01:27
luego dar las soluciones es rápido 00:01:29
son cuatro líneas 00:01:31
pero hay que entender las cosas 00:01:33
hay que entender qué es lo que se tiene que hacer 00:01:35
bueno y ahora ya 00:01:37
el siguiente método que también 00:01:39
pues bueno, podía tener su cosa 00:01:41
¿vale? jugar carta 00:01:43
pues bueno, pues venga 00:01:45
jugar carta 00:01:47
es un método 00:01:50
de jugador que 00:01:53
devolvía 00:01:55
el objeto carta jugada 00:01:59
de un 00:02:01
palo correspondiente 00:02:05
vale, pues entonces, entonces uno lee esto 00:02:06
a ver, ¿qué tengo que hacer? 00:02:13
pues tengo que coger, este a ver, tenía la 00:02:15
historia de que había que coger 00:02:17
la carta más alta 00:02:19
de ese palo, hacer un máximo 00:02:21
pero en el máximo contar 00:02:23
solo, para el máximo 00:02:25
las cartas de ese palo 00:02:27
y si no hay ninguna 00:02:29
pues devolver null y además poner paso 00:02:31
entonces esto de nuevo es hacer 00:02:33
la carta que más cumple 00:02:35
¿el qué? que su número sea el más alto 00:02:37
la carta con número más alto 00:02:39
entonces vamos a hacer un máximo 00:02:41
vamos a hacer 00:02:43
un máximo ¿sobre quién? 00:02:45
Cuando hacemos un máximo siempre iteramos sobre algo 00:02:47
Pues en este caso, ¿sobre quién vamos a iterar? 00:02:50
Sobre cartas jugador para hacer el máximo 00:02:52
¿Vale? Vamos a hacer el máximo de las cartas de jugador 00:02:54
Para echar la mayor de todas 00:02:58
Entonces, pues aquí uno empieza a hacer esto 00:03:00
A perfilarlo como lo hacemos siempre 00:03:05
Y uno puede arrancar más o menos así 00:03:06
Y es decir, venga, vamos a iterar por las cartas del jugador 00:03:08
Que son una lista 00:03:12
son una lista, entonces pues podemos 00:03:13
iterar como os dé la gana 00:03:15
con for each 00:03:17
con 00:03:19
pues venga, desde igual a cero 00:03:20
mientras si sea menor que 00:03:25
cartas 00:03:27
jugador.size 00:03:32
vale, pues entonces uno aquí 00:03:35
para hacer el máximo 00:03:41
se plantea, venga 00:03:42
el número máximo de carta 00:03:44
inicial 00:03:49
lo pongo a cero 00:03:50
¿vale? 00:03:52
y luego voy a iterar, ¿alguno supera el cero? 00:03:54
la primera ya lo va a superar, pues ya tengo la primera 00:03:56
sigo iterando 00:03:58
en cuanto me encuentre 00:04:01
alguna que supera el número que ya tengo 00:04:02
actualizado, lo irá superando 00:04:04
y así hasta que al final haya acabado el recorrido 00:04:06
y la carta con la que esté 00:04:08
sea la que haya superado 00:04:10
al máximo hasta ese momento 00:04:12
entonces esto pues 00:04:14
uno haría algo así 00:04:15
cartas jugador 00:04:18
punto get 00:04:22
y la carta 00:04:23
en el que estoy en ese momento 00:04:26
punto get número 00:04:27
bueno primero hay que ver si es 00:04:29
del palo correspondiente 00:04:32
porque solo queremos tener 00:04:33
en cuenta en ese máximo las que son 00:04:36
de ese palo 00:04:38
entonces aquí primero ponemos esta condición 00:04:38
si cartas jugador 00:04:41
punto get 00:04:44
palo 00:04:46
get i, perdón, primero, 00:04:47
get i, esta es la carta en la que estoy, 00:04:51
punto, get palo. 00:04:53
Resulta que es igual, 00:04:58
que es igual al palo con el que estoy, 00:05:03
siendo de ese palo, 00:05:09
porque solo tengo en cuenta las de ese palo. 00:05:10
A ver, es que con letra tan grande 00:05:14
se ve un poco fatal. 00:05:15
Si la carta en la que estoy en ese momento, 00:05:20
Su palo es igual al palo que tengo que tener en cuenta. Y además, esa carta supera el número al que es el máximo hasta ese momento, pues entonces tengo nuevo número máximo, que es este, 00:05:22
el que acaba de superar el máximo 00:05:53
número máximo 00:05:56
para seguir comparando 00:06:00
las siguientes veces 00:06:02
y además tengo nueva carta máxima 00:06:03
que es la que tiene ese número 00:06:06
digo, ah, espérate, que no tengo variable para ella 00:06:07
aquí 00:06:10
aquí va a ser la carta mayor 00:06:10
de ese palo 00:06:13
inicialmente null 00:06:15
inicialmente ninguna, hasta que no encuentre una 00:06:17
que supere a este 00:06:20
esa será la primera 00:06:22
si sigo, encuentro a uno que además supere a ese 00:06:24
la siguiente, etc 00:06:27
bueno, pues entonces tengo un nuevo número máximo 00:06:27
y tengo nueva 00:06:31
carta mayor 00:06:32
carta mayor igual a 00:06:35
cartas jugador 00:06:38
get i 00:06:40
y este es el máximo de toda la vida, y ya está 00:06:41
me falta la llave 00:06:47
de lift, que era esta 00:06:52
y la llave del fork es esta 00:06:53
vale, entonces 00:06:59
esto de aquí 00:07:02
este bucle que hemos hecho 00:07:04
es simplemente para 00:07:07
dentro de las cartas de ese palo 00:07:09
y solo las de ese palo 00:07:11
pues encontrar 00:07:12
la carta mayor, la que tiene mayor número 00:07:14
de todas, con el máximo de toda la vida 00:07:17
inicialmente 0 00:07:19
entonces empiezo aquí a recorrer 00:07:21
en cuanto me encuentro una de ese palo 00:07:22
cuyo número supera el número máximo 00:07:24
actualizo el número máximo y esa es la mayor 00:07:27
y seguimos 00:07:29
que la siguiente supera el número máximo 00:07:30
tengo un nuevo número máximo y esa es la mayor 00:07:33
y así hasta el final 00:07:35
¿vale? el procedimiento de máximo de siempre 00:07:36
vale 00:07:38
aquí ahora ya que es lo que tenemos que hacer 00:07:39
una vez que hemos encontrado la carta mayor 00:07:42
pues aquí pueden ocurrir varias cosas 00:07:44
que siga siendo nul 00:07:46
¿vale? 00:07:49
puede ser que siga siendo nul 00:07:52
después de haber entrado en este for 00:07:53
puede ser que siga siendo nul 00:07:55
¿eh? 00:07:58
¿en qué condiciones? 00:08:03
¿vale? en este for 00:08:05
en el que yo estoy mirando las cartas de ese 00:08:10
palo que son mayores 00:08:12
que van superando al número 00:08:14
máximo y se va actualizando, podría ocurrir 00:08:16
que nunca entrara en este if 00:08:18
y por tanto una vez que acaba del for, carta mayor 00:08:19
siguiera siendo null, ¿en qué caso? 00:08:22
claro, si no hay ninguna 00:08:26
carta de ese palo 00:08:27
entonces si no hay ninguna carta de ese palo 00:08:28
esto seguirá siendo null 00:08:31
pues entonces ahí ya 00:08:33
tengo lo primero que me dice el método 00:08:35
me dice, si no hay ni una carta de ese palo 00:08:37
si carta mayor es igual a null 00:08:40
es porque no hay ni una 00:08:42
de ese palo, no hay ni una 00:08:44
entonces en ese caso, ¿qué había que hacer? 00:08:45
pues decir paso 00:08:48
decir paso, ¿vale? 00:08:49
y si no es null 00:09:02
si no es null 00:09:03
entonces es que hemos encontrado una carta 00:09:04
de ese palo, hemos encontrado una carta de ese palo 00:09:07
que es lo que buscábamos, si no es null hemos encontrado 00:09:09
una carta de ese palo y en concreto 00:09:11
será la que tenga el mayor número de todos 00:09:13
Porque este for vale para eso 00:09:15
Para guardar en carta mayor 00:09:18
La que tenga el mayor número de todos 00:09:20
Bueno, pues entonces 00:09:21
Si no es null 00:09:23
Ahora que teníamos que hacer lo que me dice aquí 00:09:25
Si ya la has encontrado, muestras esto 00:09:27
Y la sacas de la lista 00:09:30
Porque la has jugado, la sacas de la lista 00:09:32
Y la devuelves con valor de retorno 00:09:34
Vale, pues ya está 00:09:36
Entonces lo único que nos falta hacer aquí en este else es 00:09:37
Pues mostramos 00:09:39
Jugando carta 00:09:41
y vamos a 00:09:45
como tenemos el toString 00:09:49
mostrarla además aquí, jugando carta 00:09:52
esa carta de ahí, vale 00:09:54
y ahora además la sacamos 00:09:55
de la lista de cartas del jugador 00:09:57
esa carta no está en la baraja, esa carta está en las cartas 00:09:59
del jugador, vale 00:10:02
recordad este 00:10:04
for va por las cartas del jugador 00:10:06
hasta encontrarla, pues la tenemos que sacar de ahí 00:10:08
porque la estamos jugando 00:10:10
pues bueno, cartas jugador 00:10:11
punto remove 00:10:14
carta mayor 00:10:15
y luego que es lo que falta 00:10:18
como última parte de este método 00:10:21
devolver esa carta jugada 00:10:23
pues bueno, return 00:10:26
carta mayor 00:10:28
que puede ser null 00:10:29
si no había carta puede ser null 00:10:32
claro, o puede ser la jugada 00:10:34
vale, y aquí hay algo que me falta 00:10:35
bueno, pues este método 00:10:40
ya está 00:10:44
en este caso, para que este 00:10:45
remove funcione 00:10:56
como cartas jugador 00:10:57
es una lista 00:10:58
cartas jugador es una lista 00:11:00
para que este remove identifique 00:11:02
la igualdad de esta 00:11:05
carta, cobra de la lista y elimine correctamente 00:11:06
con que en la clase 00:11:09
carta esté equals es suficiente 00:11:10
porque necesita solo equals, pero es que 00:11:12
en clase carta está equals 00:11:14
también está hascode, pero en este caso el remove 00:11:16
de la lista no usa el hascode 00:11:18
el que usa es el equals, pero es que el equals está 00:11:20
está con palo y número 00:11:22
luego estupendo, vale, pues este 00:11:24
método ya está. Es 00:11:28
hacer un máximo, pero un máximo 00:11:30
condicionado, solo 00:11:32
un máximo, solo para las de 00:11:33
ese palo, es hacer un máximo. 00:11:36
Y una vez que ya tenemos el máximo, 00:11:38
borramos de la lista, 00:11:40
mostramos el mensajito que 00:11:43
sea y para acá. 00:11:43
Vale. Y ya está. 00:11:45
Y ya tenemos 00:11:48
toda esta parte. 00:11:50
Vale. Pues hasta aquí 00:11:52
son cinco puntos del ejercicio. 00:11:55
Vale, ya viene el main. 00:11:57
Ahora ya viene el main 00:11:58
Que el main, pues yo luego ya era largo 00:12:03
También tenía su cosa 00:12:05
Porque no me he dejado nada, ¿no? 00:12:06
Recibir la carta, jugar 00:12:12
Y mostrar 00:12:15
Pues venga 00:12:16
Vamos a hacernos ahora el main, el juego 00:12:18
Que se arranca 00:12:20
Vale, pues nos dice, primero de todo crea una baraja 00:12:21
Para crear una baraja 00:12:36
Tenemos el constructor de baraja 00:12:38
Tenemos el constructor 00:12:40
que es el que declara 00:12:41
el constructor de baraja 00:12:44
que es el que hace todo esto 00:12:47
y mete las cartas aquí 00:12:48
en esta variable estática 00:12:53
y a partir de ahí esa variable estática ya tiene sus 40 cartas 00:12:54
y cualquiera puede acceder a través de baraja.cartas 00:12:58
podrá acceder nuestro recibir carta 00:13:00
podrá acceder cualquiera 00:13:04
bueno pues venga, entonces lo primero es construir la baraja 00:13:05
Que tal y como está plantado el ejercicio 00:13:09
Es obligatorio 00:13:11
Instanciar 00:13:14
Llamar al constructor sin parámetros 00:13:16
Porque si el constructor sin parámetros es este 00:13:17
Este 00:13:20
Es el que lo hace todo 00:13:20
Vale, vamos a ir poniendo 00:13:23
Aquí mensajitos para ir mostrando 00:13:26
Las cosas, para asegurarnos de que 00:13:28
Lo estamos haciendo bien 00:13:30
Vamos a mostrar 00:13:31
Cuántas cartas tiene 00:13:32
Para ver que ha metido 40 y no 80 00:13:35
Porque recordad que en el constructor hemos hecho lo mismo dos veces 00:13:37
Pero como abajo 00:13:39
Estamos metiendo las mismas cartas otra vez 00:13:40
Y es un haset, si lo hemos hecho bien 00:13:43
No las va a meter, las va a ignorar 00:13:45
La baraja 00:13:46
Tiene 00:13:50
Y ahora ya es una variable 00:13:52
Estática, la que puedo yo acceder tranquilamente 00:13:59
Así, baraja.cartas 00:14:01
A partir de aquí ya puedo acceder así a la baraja 00:14:03
Así puedo acceder 00:14:05
Pues la baraja tiene 00:14:09
también, pero no hace falta 00:14:12
porque como es estática 00:14:17
puedo acceder con el nombre de la clase 00:14:19
puedo ponerlo 00:14:21
lo que pasa es que simplemente me va a poner en amarillo 00:14:23
y me va a decir, oye, ya que es estática, accede, podría 00:14:25
¿vale? 00:14:27
lo he instanciado 00:14:30
porque este constructor se tiene que 00:14:31
se tiene que ejecutar 00:14:33
porque aquí es donde se construye 00:14:36
a ver, yo podría haber hecho un método aparte 00:14:37
que fuera construir baraja 00:14:39
entonces realmente 00:14:41
y ese método construir baraja 00:14:43
fuera el que las metiera aquí 00:14:44
entonces realmente no me haría falta instanciar 00:14:46
yo llamaría a construir baraja 00:14:49
y a partir de ahí baraja.cartes 00:14:51
pero como la construcción 00:14:53
de la baraja la he hecho en este constructor 00:14:55
ese constructor 00:14:57
solo se ejecuta cuando tú haces esto 00:14:58
solo, tú no tienes que hacer sí o sí 00:15:01
entonces claro, como ya tengo un objeto 00:15:02
B, podría acceder 00:15:05
efectivamente si quiero, puedo acceder así 00:15:06
pero bueno, queda feo, él mismo me dice 00:15:08
oye, como cartas es estática 00:15:11
queda más claro tu código 00:15:12
si accedes en el estilo 00:15:14
estático 00:15:16
pero vamos, accedo así 00:15:16
llego al mismo sitio, llego exactamente al mismo sitio 00:15:18
claro, de hecho 00:15:21
si el objeto no lo voy a usar para nada 00:15:25
hasta podría hacer esto 00:15:27
porque con esto 00:15:29
estoy invocando al constructor 00:15:31
me devuelve un objeto 00:15:33
baraja concreto 00:15:35
que no voy a usar nunca para nada 00:15:36
pues lo tiro a la basura, no lo asigno a nadie 00:15:38
podría, podría 00:15:41
porque yo a partir de ahí, lo único que me interesa 00:15:43
del objeto baraja, lo único que me interesa 00:15:45
es esta única propiedad 00:15:46
que tiene, esta única, no tiene más 00:15:49
entonces el objeto baraja creado no tiene más que esto 00:15:50
y como esta resulta que es estática 00:15:53
puedo acceder con el nombre de la clase 00:15:54
no me hace falta el objeto 00:15:57
entonces podría efectivamente 00:15:58
hacer esto 00:16:00
entonces es cierto, lo que pasa es que esto es raro 00:16:02
aquí habría sido mejor, más bonito 00:16:05
hacer un método estático 00:16:06
que fuera construir baraja 00:16:09
y así no tengo que llamar a esto 00:16:10
que es un poco extraño, se llama el método 00:16:12
estático, baraja.construirBaraja 00:16:15
la crea y ya está 00:16:17
sería mejor 00:16:18
vale, pues la baraja tiene 00:16:20
vamos a ejecutar esto, a ver si me dice 40 00:16:24
no vaya a ser que me diga 80, porque entonces algo hemos hecho mal 00:16:25
porque me está metiendo duplicados 00:16:28
vale, efectivamente no me ha metido 00:16:30
duplicados, me ha metido las 40 cartas 00:16:40
este segundo for de aquí 00:16:43
todos estos adds se han ignorado 00:16:46
Tiene 40 cartas 00:16:48
Vale, ya he metido las 40 cartas 00:16:49
Bueno, lo siguiente del main 00:16:51
Vamos a crear dos jugadores 00:16:53
Con nombre y puntuación 0 00:16:56
Y luego le metemos las 10 cartas 00:16:57
Que esto era lo segundo complicado 00:16:59
Lo más complicado de hecho 00:17:02
El resto ya era más sencillo 00:17:03
Pero esto era lo más complicado del ejercicio 00:17:06
Meterle 10 cartas a cada jugador 00:17:08
Sacándolas de la baraja 00:17:11
Por el problema de que tienes que 00:17:12
Hacer remove 00:17:14
Que te puede salir el error concurrente 00:17:15
etcétera 00:17:17
vale, pues a ver, creamos dos objetos 00:17:18
jugador, pues ala, jugador 1 00:17:22
y como habíamos hecho un constructor 00:17:25
solo con nombre y puntuación 00:17:32
pues vamos, vamos a aprovechar ya 00:17:34
y le ponemos 00:17:35
¿verdad? el jugador 00:17:38
ala, 0 puntos 00:17:40
y ahora 00:17:42
el jugador J2 00:17:45
con 0 puntos 00:17:48
lo hicimos todo para no tener que leer 00:17:57
del teclado y así, pues bueno, no había que 00:17:59
y ahora 00:18:01
esta parte de aquí 00:18:02
para mí era la más liosa del ejercicio 00:18:04
que es darle 10 cartas a cada jugador 00:18:07
darle 10 cartas a cada jugador 00:18:09
porque aquí uno podía empezar así 00:18:11
en piloto 00:18:13
automático 00:18:15
y en piloto automático 00:18:16
se pone a ejecutar 00:18:18
y no le sale nada 00:18:21
el piloto automático, ¿cuál podría ser? 00:18:22
pues bueno, primero habría que darse cuenta de lo siguiente 00:18:25
que es, ¿mis cartas dónde están? 00:18:27
están en un set 00:18:29
en un set no hay orden, yo las he ido metiendo 00:18:30
pero no hay orden, no es que estén 1, 2, 3 de oros 00:18:33
1, 2, 3 de espadas, no 00:18:35
no hay orden en el set 00:18:37
entonces, repartir 10 cartas aleatoriamente 00:18:38
lo puedo hacer 00:18:41
recorro mi set y voy sacando 00:18:42
las 10 primeras al primer jugador 00:18:45
y las 10 siguientes al otro 00:18:46
y ya las he repartido, es lo que más simula 00:18:48
repartir cartas 00:18:51
tienes un hash set, vas sacando y vas dando a cada jugador 00:18:52
pero claro, cuidado 00:18:55
porque el ir sacando significa ir haciendo remove 00:18:56
Y lo que yo estoy diciendo es ir iterando e ir sacando. Esa es la situación complicada, la que hemos dicho. Cuidado cuando iteras por una colección y a la vez que iteras la estás actualizando, porque eso te puede luego saltar en tiempo de ejecución, ¿vale? 00:18:58
entonces 00:19:16
uno en piloto automático 00:19:18
pues uno a lo mejor podría haberse planteado hacer esto 00:19:19
vamos a recorrer las 00:19:21
vamos a recorrer las cartas 00:19:23
de la baraja 00:19:26
y uno se podría haber planteado hacer esto 00:19:26
por ejemplo, vamos a hacer un contador para contar 00:19:29
vamos a recorrer la 00:19:37
o sea, esto que voy a hacer ahora 00:19:45
pues no funcionaría 00:19:50
vamos a ir iterando por las cartas de la baraja 00:19:51
por ejemplo así 00:19:54
baraja.cartas 00:19:55
vale, vamos a iterar por las cartas de la baraja 00:20:00
entonces, voy a 00:20:03
si estoy en las 10 primeras iteraciones 00:20:05
es decir, así 00:20:07
si cont es 00:20:09
claro, efectivamente 00:20:12
Entonces, hay muchas formas en las que puedes hacerlo para solucionar este problema. 00:20:24
Yo lo voy a hacer si no se pone a hacerlo a piñón fijo y luego dice, 00:20:29
ah, vale, pues eso tengo que hacer. 00:20:35
Luego lo ejecuto y dice, es que esto no es. 00:20:36
Por el error de concurren, modificar, tiene este tiempo, bla, bla, bla. 00:20:38
Y luego entonces uno ya dice, ah, claro, es que esto así no lo podía hacer. 00:20:40
Entonces ya se pone a pensar en diferentes soluciones. 00:20:43
Que hay varias, ¿vale? 00:20:45
Entonces, uno así a piñón fijo sin pensar, pues podría hacer, ¿vale? 00:20:47
Pues voy a recorrer las cartas de mi baraja. 00:20:50
y para las 10 primeras 00:20:52
que vayan a 1 con recibir 00:20:54
carta y las 10 siguientes 00:20:56
a otro con recibir carta, pero claro 00:20:58
el error es que recibir carta tiene un remove dentro 00:21:00
ese es el problema 00:21:02
entonces, así a piñón fijo sería 00:21:03
si estoy en las primeras 10 iteraciones 00:21:06
es decir, si cont es menor o igual 00:21:08
que 9 00:21:11
es decir, que estoy en las 10 primeras 00:21:12
pues podríamos hacer aquí 00:21:14
pues venga, jugador1. 00:21:16
recibirCartaC 00:21:19
y ahora 00:21:20
esta llave me sobra 00:21:23
y uno hace, y si no 00:21:28
si estoy, no es menor o igual 00:21:32
que 9, pero es 00:21:35
menor o igual que 00:21:37
19, bueno, si los 00:21:38
límites o alguna cosa, estoy poniendo alguna burrada 00:21:41
así por hablar y ejir a la M, lo decís 00:21:43
entonces uno 00:21:45
podría a lo mejor, esta es la 00:21:50
del for, pero que ahora me sobra 00:21:53
podría plantearse 00:21:54
hacer algo así, porque es la idea 00:21:56
en realidad, es la idea, tiene sentido 00:21:58
¿no? 00:22:01
Vamos recorriendo el set, en las primeras 10 iteraciones al jugador 1 le mandamos la carta C y recibir carta adentro ya tiene añadírsela a la lista y eliminarla de la baraja, porque eso es lo que tiene recibir carta adentro, tiene esta carta, se la añadimos a la lista y la quitamos de la baraja, de la única que hay, entonces todas van al mismo sitio. 00:22:02
y si estamos en las 10 siguientes 00:22:27
iteraciones, es el jugador 2 00:22:33
al que se le mete la carta 00:22:36
y sobre la baraja 00:22:38
la única que hay a la que están accediendo todos 00:22:39
la estática de baraja se la quita 00:22:41
pero claro, aquí tenemos la combinación 00:22:43
no la estamos viendo a simple vista 00:22:45
porque lo hacemos a través de este método 00:22:47
pero aquí tenemos este problema 00:22:49
y es que recibir carta tiene un remove 00:22:52
dentro, un remove precisamente 00:22:53
de esta colección 00:22:55
sobre la que estoy iterando 00:22:57
entonces si ahora uno intenta ejecutar esto 00:22:59
pues me debería salir 00:23:01
un error de ejecución 00:23:04
porque esta combinación no 00:23:05
vale 00:23:07
y ahí lo tenemos 00:23:09
me sale lo de siempre 00:23:13
me dice, ¿cómo que estás reiterando 00:23:15
y a la vez estás eliminando 00:23:17
de la baraja sobre la que estás iterando? 00:23:19
no, esto que sería lo natural 00:23:21
no lo hagas 00:23:23
y entonces aquí ya 00:23:24
es donde 00:23:26
se os pueden ocurrir diferentes soluciones 00:23:28
vale, una 00:23:31
quizá la más sencilla 00:23:33
no lo sé, es 00:23:37
coger las 10 00:23:38
primeras cartas de la baraja y llevarlas a una colección 00:23:41
aparte, y ahora ya con 00:23:43
esas 10 cartas, añades 00:23:45
a uno de los jugadores y luego las borras de la 00:23:47
baraja, con 00:23:49
Adol y Remufol 00:23:50
y ya está, ¿no? 00:23:52
entiendo que es lo que le estabas 00:23:54
diciendo tú a él, ¿no? 00:23:57
Bueno, sí, sí, sí, claro 00:24:00
Esto mismo que digo, hacerlo con los dos jugadores 00:24:12
O sea, con uno y con el otro 00:24:14
O en el orden que sea, coge las 10 primeras 00:24:15
Las borras de la baraja 00:24:18
O coge las 10 primeras, coge las 10 segundas 00:24:19
Bueno, que hay diferentes combinaciones 00:24:21
Pero bueno, vamos a ponerlo aquí 00:24:23
Lo importante es que esto no 00:24:25
lo importante es que esto no 00:24:32
vale 00:24:34
entonces vamos a ponerlo así 00:24:35
esta llave no me hace falta 00:24:38
con lo cual esta no hace falta 00:24:49
vale, esto no es lo que importa 00:24:50
bueno, pues entonces 00:24:53
¿qué vamos a hacer? 00:24:54
pues vamos a hacer 00:24:56
una lista con las 10 00:24:58
primeras cartas de la baraja 00:25:01
y una lista con las 10 siguientes cartas 00:25:02
de la baraja, bueno cuando digo 00:25:05
las primeras que me salen cuando entero por el 00:25:07
Haset, que salen 00:25:09
según va saliendo, ¿vale? 00:25:11
Y ya tengo las dos colecciones de cartas 00:25:13
con las que trabajar. Y ahora con esas 00:25:15
dos colecciones. La primera de ellas 00:25:17
va al primer jugador, la segunda 00:25:18
de ellas va al segundo jugador 00:25:21
y luego ya sobre la baraja le hago 00:25:23
un remufol de esta colección y un remufol 00:25:25
de esta otra. Y ya está. Entonces tengo el resultado 00:25:27
que quería. Diez cartas de la baraja 00:25:29
han ido a uno. Y diez cartas de la baraja 00:25:31
han ido a otro. Quizá es 00:25:33
lo más sencillo. ¿Vale? 00:25:35
Entonces, 00:25:38
vamos a hacernos 00:25:39
una lista 00:25:41
con las cartas que van a ir al jugador 1 00:25:42
cartas para el jugador 1 00:25:46
lo bueno de las listas 00:25:52
y las colecciones en general 00:26:13
es que como son tan fáciles de usar 00:26:15
se trata de hacer add, de hacer remove 00:26:16
de hacer lo que sea, como son tan fáciles 00:26:18
uno se las puede crear para cualquier cosa que necesite 00:26:20
ah, necesito un conjunto, ya está, me creo una lista rápidamente 00:26:23
y entonces 00:26:25
es una forma muy rápida de solucionar 00:26:27
problemas y situaciones 00:26:29
vale, pues en esta lista voy a meter 00:26:30
el conjunto de cartas 00:26:33
que quiero que vayan al jugador 1 00:26:35
y para eso, ¿qué voy a hacer? voy a iterar por la baraja 00:26:37
voy a iterar y voy a ir 00:26:40
añadiendo a esta lista 00:26:42
cartas que voy 00:26:43
consultando de la baraja 00:26:45
venga, pues ahora ya 00:26:47
sí que podemos hacer esto, ¿vale? 00:26:49
para cada carta 00:26:55
c en baraja 00:26:56
punto cartas 00:26:58
vale 00:27:00
Bueno, como son las 10 primeras iteraciones 00:27:02
Pues voy a hacer aquí el contador para contar en qué iteración estoy 00:27:10
Entonces, vamos a hacerlo así 00:27:14
If count++ es menor o igual que 9 00:27:25
Y lo dejo ya incrementado 00:27:31
En este caso, ¿qué hago? 00:27:33
Pues cartas 00:27:36
Para 00:27:38
Jugador1.ad 00:27:39
Esta carta C 00:27:42
A ver, recordad que 00:27:44
C en realidad 00:27:46
Es una copia de la dirección de memoria 00:27:47
Vale, pero es que 00:27:51
El ad 00:27:54
Cuando hace licuas no lo hace por dirección de memoria 00:27:56
Sino lo que lo hace por 00:27:59
Contenido, entonces 00:28:00
No hay que liarse con eso 00:28:01
vale, pues entonces voy recorriendo las cartas 00:28:03
si estoy en las 10 primeras 00:28:06
iteraciones 00:28:08
se las añado a 00:28:09
al jugador 1 00:28:12
vale, entonces voy a quitar 00:28:14
el con más más porque entonces ahora para el 00:28:16
safe lo voy a dejar aquí estropeado 00:28:18
entonces el con más más aquí no 00:28:19
vale, y aquí en este código 00:28:21
aunque estaba mal, me hubiera faltado un con más más 00:28:27
también, claro, para incrementarlo 00:28:29
aunque estaba mal lo voy a poner 00:28:31
aquí me hubiera faltado 00:28:32
Después de eso incrementar la iteración en la que estoy 00:28:40
Me hubiera faltado esto 00:28:44
Vale 00:28:49
Bueno, pues aquí 00:28:52
Si estoy en una iteración menor o igual que 9 00:28:53
Se la añado al jugador 1 00:28:56
Si no estoy en una iteración menor o igual que 9 00:28:58
Pero si estoy en una iteración menor o igual que 19 00:29:01
En ese caso 00:29:07
Mándasela al jugador 2 00:29:09
y deja incrementado el número de iteración en la que estás 00:29:12
porque el for each no lo hace 00:29:21
y con el for de índice no puedo recorrer un set 00:29:23
no puedo 00:29:25
así que con esto o con un iterador 00:29:26
pero con un iterador también tendría que llevar un contador de iteraciones 00:29:28
vale, y entonces aquí ya 00:29:31
ah, es que me falta la lista de las cartas del jugador 2 00:29:36
cartas para jugador 2 00:29:40
vale 00:29:47
y ahora 00:29:48
dejo incrementado el contador 00:29:51
de iteraciones 00:29:53
aquí hombre, a ver, como son 40 cartas 00:29:54
que tampoco es tan terrible 00:29:59
pero 00:30:00
este for each va a estar ahí dando 00:30:02
un montón de vueltas, un montón de vueltas, un montón de vueltas 00:30:06
menor o igual 00:30:09
y cuando ya se pase del 19 hacia arriba 00:30:10
no va a hacer nada, entonces si contes 00:30:12
mayor o igual que el 00:30:14
mayor que 19 pediría hacer un break 00:30:15
No sé si me estoy explicando 00:30:18
Pero bueno, vamos a dejarlo 00:30:21
Vale 00:30:24
Pues ya está 00:30:26
Ya tenemos dos colecciones 00:30:28
Esta tiene, en principio, si no me hemos hecho mal 00:30:29
Tiene 00:30:32
Las diez primeras cartas 00:30:33
Que han salido de la baraja 00:30:36
Que han salido del set 00:30:37
Que no salen en orden 00:30:38
Y aquí están las diez siguientes 00:30:40
Que han salido del set 00:30:44
Vale, pues entonces ahora ya 00:30:45
Al jugador1.getCartas 00:30:48
Le podemos ya añadir 00:30:53
Todas a mogollón 00:30:55
Cartas para jugador1 00:30:58
Todas ahí de golpe 00:31:00
Ya las tenemos 00:31:01
Y ahora al jugador2 00:31:04
A sus cartas 00:31:06
Le vamos a añadir todas ahí de golpe 00:31:09
Las cartas para el jugador2 00:31:11
Vale, pues estos jugadores ya tienen sus cartas 00:31:14
Ya se las hemos añadido 00:31:19
no tenían ninguno, ahora tienen 10 00:31:20
pero nos falta 00:31:21
esos dos conjuntos de cartas 00:31:23
eliminarlos de la baraja 00:31:26
vale, pero nuestra baraja 00:31:28
es esta 00:31:30
esta es nuestra baraja 00:31:30
y tiene un método remove all 00:31:33
que yo puedo usar para pasar 00:31:35
una colección y las quita todas 00:31:38
pues venga, quito 00:31:39
y el remove 00:31:42
no hay ningún problema en usarlo 00:31:44
si no está dentro de una iteración 00:31:46
no está dentro, yo estoy directamente 00:31:47
Oye, la baraja, borra las tuyas, ya está 00:31:49
Y esto mismo 00:31:51
Cartas para jugadores 00:31:56
Vale 00:32:04
Bueno, ya estarían las 10 cartas 00:32:05
Vamos a comprobarlo, porque podemos haber 00:32:10
Escrito algo mal 00:32:12
Perfectamente 00:32:13
Vamos a poner aquí las cartas 00:32:14
Que tiene el jugador 1, a ver cuáles le han tocado 00:32:18
Y le ponemos aquí 00:32:20
Un jugador 1 punto 00:32:24
Mostrar mano 00:32:26
Y ahora aquí las 00:32:27
cartas que le han tocado 00:32:31
al jugador 2, a ver si tiene 10 00:32:34
cada uno 00:32:36
y aquí j2.mostrarman 00:32:36
y vamos a ponerle 00:32:45
aquí esto 00:32:48
vale, a ver 00:32:49
que hemos hecho 00:32:53
un error de compilación, por lo pronto no lo he quitado 00:32:55
que está 00:33:02
me falta la llave del main 00:33:04
¿verdad? en algún momento he borrado una llave 00:33:06
de más 00:33:09
porque esta es la llave de 00:33:09
Entonces, ¿esta llave de dónde viene? 00:33:12
Ah, es esta, vale 00:33:16
Es que me falta esta de aquí 00:33:17
Ahora sí 00:33:18
Vale 00:33:21
Venga, siguiente intento 00:33:22
Bueno, error no da 00:33:26
Jugador 1 00:33:32
Parece que tiene 10, ¿no? 00:33:36
1, 2, 3, 4, 5 00:33:38
6, 7, 8, 9 y 10 00:33:40
Y jugador 2 tiene otras 10 00:33:42
1, 2, 3, 4 y 5 00:33:45
1, 2, 3, 4 y 5 00:33:46
Vale, cada uno tiene 10 cartas 00:33:48
como veis no van en orden 00:33:49
según han salido del set 00:33:52
como él ha manejado su orden interno 00:33:54
ala, pues ya tenemos 00:33:56
en realidad no es aleatorio 00:33:59
a ver, esta palabra 00:34:03
hay que reconocer que no estaba 00:34:04
muy bien 00:34:06
elegida 00:34:07
aquí habría sido mejor poner cualesquiera 00:34:09
Vale, pues entonces ya podemos avanzar 00:34:12
Casi antes de nada la condición esta del wild 00:34:30
Que es más rápida 00:34:32
Mientras las cartas de la baraja 00:34:33
Sean en números mayores que cero 00:34:36
Esa condición casi la podemos poner 00:34:38
Lo primero de todos 00:34:41
Cuidado 00:34:42
mientras haya cartas 00:34:43
en la baraja 00:34:46
seguimos jugando 00:34:48
.cartas.getsize 00:34:49
.getsize no, .size 00:34:52
vale 00:34:56
esta condición de finalización 00:34:57
era lo más fácil en realidad de ver 00:35:01
una vez que 00:35:03
se había denunciado 00:35:05
mientras siga habiendo cartas 00:35:06
mientras la baraja no tenga 00:35:08
cartas, perdón, se acaba 00:35:10
y de hecho indicamos, aunque haya un jugador 00:35:12
que todavía tenga dos y otro tres 00:35:14
en cuanto la baraja se haya quedado sin cartas 00:35:16
como consecuencia de coger 00:35:18
aunque tú te hayas quedado todavía con cartas 00:35:19
se acaba 00:35:22
así era mucho más fácil 00:35:23
y así no hay que hacer las rondas 00:35:25
hasta que se 00:35:29
acaban las que hay en la mano 00:35:30
pues entonces esa condonización ya está 00:35:32
esa condición ya está 00:35:34
mientras haya cartas 00:35:36
en la baraja jugamos 00:35:38
Y ahora, ¿cómo jugamos? Pues sacando las cartas 00:35:39
Para lo cual, afortunadamente 00:35:42
Tenemos 00:35:43
Primero juega el jugador 1 00:35:45
Ala, jugamos carta del palo correspondiente 00:35:47
Ahora 00:35:51
Juega el jugador 2 00:35:54
Sacando su carta 00:35:57
Con el palo correspondiente 00:35:58
Vale, esto es hacer las jugadas 00:36:04
Ha jugado el primer jugador y ha jugado el segundo jugador 00:36:07
Su carta ha salido de su lista 00:36:09
su carta ha salido de su lista 00:36:12
si es que tenían carta 00:36:13
y miran devuelto y si no 00:36:15
ha salido aquí un null 00:36:17
tenemos este método, que es el que nos facilita 00:36:19
ahora el juego, ahora hay que explorar 00:36:22
lo que pasa con C1 y C2 00:36:24
si las dos son diferentes de null 00:36:25
se actualiza la puntuación en función 00:36:27
de quien tenga mayor 00:36:29
si una es null 00:36:31
y la otra no, se actualiza la puntuación 00:36:33
del que no tenga null, y si las dos son null se cogen cartas 00:36:36
y se acaba el bucle 00:36:38
¿vale? pues ahora es plantear esas condiciones 00:36:39
pues entonces aquí 00:36:41
si C1 es diferente de null 00:36:43
es decir, los dos han podido jugar 00:36:46
los dos han podido jugar 00:36:48
C2 es diferente 00:36:51
de null 00:36:54
los dos han podido jugar carta 00:36:55
pues ahora hay que ver a quién se le suma el punto 00:37:02
al que tenga la carta más alta 00:37:05
pues si la carta de C1 00:37:07
getNumero 00:37:09
es mayor 00:37:11
que el número de la del 2 00:37:13
entonces al que hay que ponerle la puntuación 00:37:15
es al jugador 1 00:37:19
¿vale? 00:37:22
jugador 1.set 00:37:26
puntuación 00:37:28
hay que cambiársela 00:37:29
y hay que ponerle la que tenía antes 00:37:31
que es la que saco con el get 00:37:33
más 1 00:37:36
a la actualizada la puntuación 00:37:38
del jugador 1 00:37:40
¿vale? 00:37:41
si la carta del jugador 1 es mayor que la carta 00:37:45
de jugador 2, iguales no pueden ser 00:37:48
obviamente, es imposible que sean iguales 00:37:50
porque cuando un jugador ha jugado 00:37:52
cuando se han repartido las cartas 00:37:53
salen de la baraja las que se ha llevado un jugador 00:37:55
vale, pues entonces 00:37:58
ah, claro, es que he de decir 00:38:03
¿por qué me marca esto? es que lo tengo aquí muy separado 00:38:06
esto, así más bonito 00:38:09
ahí, vale 00:38:10
y ahora, si no 00:38:12
si no, entonces 00:38:16
es la C2 mayor, porque igual no 00:38:18
pueden ser, igual es imposible 00:38:20
pues si no, esto, pero para 00:38:21
al jugador 2. 00:38:24
Esto en el caso de que los dos hayan podido jugar. 00:38:34
Ahora, siguiente situación que se me puede dar. 00:38:38
Que el primero haya sido nul, 00:38:42
pero el segundo no. 00:38:45
Entonces le sumo un punto al segundo. 00:38:48
Pues se me puede dar esto entonces. 00:38:52
Si c1 es igual a nul 00:38:54
y c2 es diferente de nul, 00:38:55
En este caso 00:39:02
El que se lleva el punto es el C2 00:39:04
Que es el que ha podido jugar carta 00:39:07
Pues esto es lo que pongo aquí 00:39:08
Ahí, vale 00:39:10
Ya tengo el segundo caso 00:39:18
El primero era los dos diferentes de nul 00:39:21
El segundo, el primero nul y el segundo no 00:39:23
Ahora, el siguiente caso 00:39:25
A ver 00:39:29
no te entiendo 00:39:45
un or aquí, a ver, es que si 00:39:48
pones aquí un or 00:39:50
te va a entrar aquí 00:39:51
en cuanto una de las dos 00:39:53
no sea, si una de las dos es null 00:39:56
te entra, entonces te va a salir un null pointer exception 00:39:57
en una de estas 00:39:59
o sea, si tú aquí pones un or 00:40:00
vas a entrar 00:40:05
siendo c1 null 00:40:06
o siendo c2 null 00:40:09
¿vale? entonces 00:40:10
aquí ya vas a tener el primer null pointer exception 00:40:12
porque en el caso de que 00:40:15
una de las dos sea null, entras 00:40:18
null pointer exception 00:40:20
enorme en cuanto te entres por ahí 00:40:22
otro or, pero para qué 00:40:24
o sea, es que vas a anidar un montón de cosas 00:40:28
o sea, no es más sencillo separar los cuatro 00:40:32
casos que tienes 00:40:34
o sea, que son diferentes de null, hago esto 00:40:35
que una es null y la otra no 00:40:38
hago esto otro 00:40:40
a ver, plantea tú esto si quieres 00:40:41
de otra manera, pero quizá yo creo que se 00:40:44
se complica más 00:40:46
pero vamos, que se pueden organizar los if 00:40:47
de otra manera 00:40:52
entonces, si 00:40:53
este es null y esta no 00:40:56
entonces 00:40:57
y si esta es la que 00:40:59
es diferente de null 00:41:02
y esta sí que es igual a null 00:41:03
pues entonces es esto mismo, pero cambiado a j1 00:41:05
esto 00:41:08
vale, entonces tenemos 00:41:09
los dos diferentes de nul 00:41:20
actualizamos el punto del que sea 00:41:23
uno nul y el otro lo 00:41:24
actualizamos el punto del que sea 00:41:26
y el else 00:41:28
ahora ya este else 00:41:30
es en el cual los dos 00:41:32
han sido nul 00:41:35
es decir, ninguno ha podido jugar carta 00:41:36
porque ninguno tenía de ese palo 00:41:38
entonces en este caso 00:41:40
¿qué es lo que había que hacer? 00:41:43
rellenar hasta 10 00:41:45
las cartas de cada uno 00:41:46
rellenar hasta 10 00:41:48
cambiar el par de autoridades 00:41:51
entonces ahora de nuevo aquí se plantea 00:41:54
el mismo problema que cuando hemos repartido 00:41:56
cartas, lo que pasa es que ahora no repartimos 00:41:59
10 a cada uno 00:42:01
sino que repartimos las que le falten a cada uno 00:42:02
hasta 10, simplemente las que le falten 00:42:05
entonces ahora aquí simplemente 00:42:07
es hacer este mismo código 00:42:08
este mismo en el cual 00:42:11
hemos repartido 00:42:13
el mismo en el cual hemos repartido 00:42:13
pero en lugar de darle 00:42:16
10 a cada uno 00:42:19
darle 00:42:20
vale, darle hasta que complete 00:42:22
hasta 10 00:42:24
las que le falten 00:42:25
entonces pues 00:42:29
y luego cambiar el par aleatoriamente 00:42:31
entonces aquí, pues como podríamos 00:42:33
hacerlo, pues primero vamos a ver 00:42:36
las cartas que hay que darle al jugador 00:42:38
2, vale para hacer 00:42:40
voy a hacerlo, voy escribiendo 00:42:42
para hacerlo más o menos 00:42:45
organizado, que luego uno recompone 00:42:46
este código y lo reescribe de otra manera, pues estupendo 00:42:48
cartas para 00:42:51
jugador 1 00:42:54
bueno, pues para jugador 1 00:42:55
¿cuántas cartas hacen 00:42:58
falta? para jugador 1 00:43:00
hacen falta 10 00:43:02
menos las que ya tenga 00:43:04
que es un jugador 00:43:05
punto cartas 00:43:08
10 cartas 00:43:10
jugador 00:43:12
punto 6 00:43:13
estas son las que hay que 00:43:15
darle al jugador 1, ¿vale? 00:43:18
y ahora 00:43:21
cartas 00:43:24
para jugador 00:43:26
2, pues 10 00:43:28
menos las que tenga ya en la mano 00:43:33
punto 6 00:43:35
vale 00:43:43
y ahora ya sí que podemos hacer 00:43:44
lo mismo de antes 00:43:56
de la baraja 00:43:58
cogemos estas, cogemos estas 00:44:00
que a lo mejor nos paramos antes 00:44:04
porque ya no quedan 00:44:05
Pero bueno, hasta que se llenen 00:44:07
Y se las damos a cada uno de ellos 00:44:10
Entonces, pues podríamos 00:44:11
Todo esto, si uno lo va metiendo en métodos auxiliares del main 00:44:14
Queda más claro 00:44:17
Yo no lo voy metiendo para... 00:44:17
Pero luego todo esto lo podéis reescribir y dejarlo más bonito 00:44:19
Entonces, ¿qué código habíamos dicho para repartir las cartas? 00:44:21
Pues habíamos hecho 00:44:25
Esto, todo esto 00:44:27
Todo esto 00:44:28
Todo este código era para repartir las cartas 00:44:29
Este y este 00:44:34
Todo este código 00:44:36
El que podríamos meter en un main auxiliar 00:44:37
Repito, repartir cartas 00:44:40
Repartir tantas cartas 00:44:41
Podríamos meter en un main auxiliar 00:44:43
Este código para repartir 00:44:44
Pero bueno, yo lo voy a poner aquí directamente 00:44:46
Vamos a poner 00:44:49
Repartimos cartas hasta 10 00:44:51
Vale, pues voy a poner aquí 00:44:55
Ahí 00:44:59
A ver 00:45:01
Repartimos cartas hasta 10 00:45:04
Vale, entonces 00:45:06
esta lista ya está declarada, no hace falta 00:45:08
que la vuelva a declarar 00:45:10
esta lista ya está declarada, no hace falta que la vuelva a declarar 00:45:11
lo que hacemos es 00:45:14
limpiarla, ponerla a cero de nuevo, la dejamos 00:45:16
limpita, este contador 00:45:18
ya está 00:45:20
así 00:45:21
ahora 00:45:24
cont es menor o igual 00:45:27
que 00:45:30
las cartas que van 00:45:31
hasta jugador 1 00:45:34
cartas 00:45:36
para jugador 1 00:45:41
¿vale? pues entonces 00:45:45
lo voy metiendo en su lista 00:45:47
si no es menor, pero es menor 00:45:48
que las que van a la suma de ambas 00:45:51
y con este nombre de variable tan grande 00:45:53
¿vale? por ejemplo, si el primero 00:45:57
le ha dicho que le faltan 5 y al primero 00:46:10
7, pues si es menor que 5 00:46:12
van al jugador 1 00:46:15
y si es menor que 5 más 7 00:46:15
que serían los 12 00:46:19
Si no es menor que 5, pero si es menor que 12 00:46:20
Pues entonces van 00:46:23
Las restantes para el jugador 2 00:46:24
Y voy incrementando con 00:46:27
Vale 00:46:29
Si la baraja 00:46:31
Se ha acabado 00:46:33
Solo se habrá llenado 00:46:34
Las listas con cartas efectivas 00:46:37
A lo mejor esta no se ha llenado 00:46:39
Con cartas para jugador 1 totales 00:46:40
O esta con cartas para jugador 2 00:46:43
A lo mejor no se han llenado, pero no pasa nada 00:46:45
Pues la baraja se ha acabado 00:46:47
Entonces ahora ya 00:46:48
Esto se queda igual 00:46:50
Añado las cartas de jugador 00:46:52
Esta, añado esta 00:46:54
Y ahora, borro de la baraja esta 00:46:55
Y borro de la baraja esta otra 00:46:59
¿Vale? O sea, es el mismo 00:47:01
Sí, sí, sí 00:47:02
Vale, pues nada 00:47:08
Y ahora lo que falta es 00:47:12
Cambiar el palo 00:47:16
Cambiar el palo otra vez 00:47:17
Que hombre, que menos que un método auxiliar 00:47:18
Seleccionar palo, ¿no? 00:47:21
pero bueno, os lo dejo para vosotros para que dejéis el juego ya bonito 00:47:22
y todo eso 00:47:25
cambiar palo, pues en mi caso voy a copiar 00:47:26
y pegar otra vez lo del palo 00:47:34
pero esto es horroroso, o sea, esto habría que meterlo en un método 00:47:36
venga, anda, que tardo menos en un método auxiliar 00:47:38
que 00:47:40
poniéndolo, entonces 00:47:41
voy a hacerme aquí 00:47:44
un método auxiliar 00:47:46
que me devuelva el palo 00:47:47
voy a poner 00:47:51
aquí el método auxiliar 00:48:00
este de aquí 00:48:01
este 00:48:05
eso tan feo 00:48:08
todo esto se va afuera 00:48:11
se va aquí 00:48:12
y ahora 00:48:14
a este le falta el retúmpalo 00:48:19
ala, este método 00:48:21
es para obtener un palo aleatorio 00:48:25
un palo aleatorio, ya está 00:48:28
y ahora ya aquí 00:48:30
selecciono el palo con el método 00:48:32
así, mucho mejor 00:48:36
Y aquí cuando me tocaba cambiar de palo 00:48:43
Pues lo cambio otra vez 00:48:46
Vale, pues el juego ha terminado aquí ya 00:48:48
El juego ha terminado aquí 00:48:58
Vamos a poner pues 00:49:00
Que jugador ha ganado 00:49:03
Por poner algo 00:49:05
Y J1.get.puntuación 00:49:06
Es mayor que J2.get.puntuación 00:49:16
Bueno, vamos a la puntuación 00:49:21
Es de los dos y ya está 00:49:26
Lo que ha sacado cada uno 00:49:27
Mejor 00:49:31
Jugador 1 ha sacado 00:49:32
Punto de puntuación 00:49:37
Y ahora vamos a sacar 00:49:39
Los puntos del jugador 2 00:49:43
Jugador 2 ha sacado 00:49:45
Esto 00:49:52
Bueno, entonces podemos probarlo ya lo bestia 00:49:52
Así siendo unos lanzados 00:49:58
A mí lo único que me 00:50:00
Asusta un poco, que como hemos hecho muy rápido 00:50:03
Sin pensar, es cuando hemos vuelto 00:50:05
A repartir hasta 10 00:50:07
que alguno de estos 00:50:08
límites sea menor o igual 00:50:09
aquí 00:50:12
pero yo creo que no, porque si a uno le quedan 5 00:50:13
y a otro le quedan 7 00:50:16
esto tiene que ir mientras sea menor que 5 00:50:17
y luego mientras sea menor 00:50:20
que la suma 00:50:23
a ver 00:50:23
¿se te ha quedado en un bucle infinito? 00:50:28
pero será que no has cambiado de palo 00:50:30
porque entonces se queda en un bucle infinito 00:50:32
¿te has acordado de cambiar de palo 00:50:34
cuando no tienen 00:50:36
porque si no tienen ninguno de los dos 00:50:37
Bueno, vamos a probarlo, a ver qué hace 00:50:39
Porque lo normal después de un chorizo así 00:50:41
Es que la primera vez digas 00:50:45
Uy, aquí hay algo raro hecho 00:50:46
Vamos a ver 00:50:48
Bueno, vale 00:50:49
Pues el jugador no ha ganado 00:50:53
Bueno, habría que revisar 00:50:55
Que todo lo que está pasando tiene sentido 00:50:58
Pero se han acabado las cartas de la baraja 00:51:00
La baraja queda en 20 00:51:05
1, 2, 3 00:51:09
Si sumamos estas 00:51:11
Más la que quedan después debería encajar 00:51:12
Vamos a mostrar las que quedan en la baraja 00:51:14
Luego también 00:51:16
Ah no, en la baraja quedan cero, que tontería 00:51:17
Pero podemos mostrar 00:51:20
Jugador 1 00:51:22
Get puntuación 00:51:24
Y le vamos a poner, y le quedan 00:51:26
A ver cuantas cartas le quedaban en la mano 00:51:27
Y le quedan 00:51:29
A ver si nos encajan las cuentas 00:51:32
Que eso ya sí que sería hacer una prueba 00:51:36
Un poco más 00:51:37
Jugador.getCartas.size 00:51:38
Y le quedan esas 00:51:43
Y ahora vamos a ver 00:51:44
Cuantos le quedan al jugador 2 00:51:47
Después de acabar el juego 00:51:48
Jugador 2, si le quedan 00:51:50
Venga, vamos a volver a lanzar el juego 00:52:02
A ver 00:52:06
Bueno 00:52:09
Ha ganado este 00:52:13
Se quedaba cada uno con 10 00:52:18
Pero la baraja se ha quedado sin cartas 00:52:20
10 y 10 00:52:23
1, 2, 3, 4 00:52:30
5, 6, 7 00:52:40
8, 9, 10 00:52:44
11, 12, 13 00:52:48
14, 15, 16, 17, 18, 19 00:52:52
y 20, me encajan 00:52:58
20 jugadas más 20 que se ha quedado cada uno en la mano 00:53:00
suman las 40 de la baraja 00:53:03
porque la baraja se ha quedado vacía 00:53:05
Entonces se han jugado 20 cartas 00:53:06
Cada jugador se ha quedado con 10 00:53:09
Y la baraja está vacía 00:53:11
Porque si no habría acabado el bucle 00:53:12
Entonces bueno, tiene pinta de que lo que hemos hecho 00:53:13
Tiene sentido y está bien 00:53:16
Pero lo podéis revisar más despacio o algo así 00:53:17
Pero si lo he hecho dos veces 00:53:20
Y me ha salido distinto 00:53:24
Míralo, cada vez me sale distinto 00:53:26
Lo mío es aleatorio y lo tuyo no 00:53:28
Que se quede en el bucle 00:53:30
Pues no lo sé 00:53:34
Pues a mí sí que me va cambiando 00:53:36
3, 13, 11 00:53:47
Me va cambiando 00:53:49
3, 10, vale 00:53:50
Bueno, pues entonces, a ver 00:53:54
Este ejército tenía cosas 00:53:57
Más fáciles y cosas más complicadas 00:54:03
Las que eran más de pensar, repito 00:54:05
Eran 00:54:07
en jugador 00:54:10
el decidir 00:54:11
dónde situamos 00:54:14
las cartas para poder borrarlas 00:54:16
desde aquí, para poder borrarlas 00:54:18
desde aquí la que recibe el jugador 00:54:20
si se la pasáis como parámetro 00:54:21
si la hacéis estática 00:54:23
ese era uno de los puntos 00:54:25
el otro punto, bueno, esto es hacer el máximo 00:54:27
este tampoco tenía mucho más, esto era hacer el máximo 00:54:32
ya está 00:54:34
y la otra cosa complicada 00:54:34
el reparto de las cartas 00:54:37
¿vale? el reparto este 00:54:40
el reparto 00:54:42
que se hace tanto aquí 00:54:42
como ahí debajo 00:54:45
entonces el reparto de las cartas 00:54:46
y esto de aquí, el recibir carta 00:54:49
borrarla de la baraja 00:54:51
eran las dos cosas en las que había que pensar más 00:54:52
lo demás era más 00:54:55
vale, pues entonces 00:54:57
eh... 00:55:00
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
9
Fecha:
3 de abril de 2024 - 18:39
Visibilidad:
Público
Centro:
IES ROSA CHACEL
Duración:
55′ 03″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
278.56 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid