1
00:00:00,750 --> 00:00:12,089
Bueno, en este vídeo vamos a ver cómo podemos hacer que los objetos en processing, además de moverse, que ya lo habíamos visto en la práctica anterior, reboten o hagan el efecto de rebote, de ir y volver.

2
00:00:12,949 --> 00:00:25,670
Entonces, partimos del ejemplo de la práctica anterior en el que teníamos una elipse que se movía hacia la derecha porque incrementábamos la variable x que marcaba una de sus posiciones del centro.

3
00:00:25,670 --> 00:00:33,369
y ahora vamos a ver cómo hacemos para que esa elipse que ahora mismo desaparece y se va de la pantalla,

4
00:00:34,350 --> 00:00:36,429
cómo hacemos que vuelva a aparecer desde el inicio.

5
00:00:36,929 --> 00:00:40,109
Entonces lo que hay que añadir es un condicional que es la palabra clave if

6
00:00:40,109 --> 00:00:44,090
y dentro de ese condicional ponemos la condición que queremos que se cumpla.

7
00:00:44,090 --> 00:00:50,189
En este caso queremos que se cumpla que cuando x sea exactamente igual a 600 la x vuelva a ser 0

8
00:00:50,189 --> 00:00:56,189
Y con eso conseguimos que la elipse una vez que se va por la derecha vuelve a aparecer por la izquierda.

9
00:00:57,609 --> 00:01:03,710
En este caso tendría que darse justo la circunstancia de que x coge el valor exacto de 600.

10
00:01:03,990 --> 00:01:11,569
Si lo incrementamos de 7 en 7, por ejemplo, no nos llega la suma nunca a 600 y la elipse nos desaparece de la pantalla.

11
00:01:12,370 --> 00:01:19,530
Para eso, en lugar de poner que la condición sea x exactamente igual a 600, podemos poner que x sea mayor que 600

12
00:01:19,530 --> 00:01:21,209
y con eso solucionamos el problema.

13
00:01:22,310 --> 00:01:25,010
Así cuando llegue al número siguiente superior a 600,

14
00:01:25,909 --> 00:01:28,569
pues la x volverá a ser 0 y volverá a aparecer por la izquierda.

15
00:01:30,310 --> 00:01:33,150
Vale, vamos a cambiar ahora, por ejemplo, también el tamaño.

16
00:01:34,670 --> 00:01:36,950
Ponemos una variable que la vamos a llamar t

17
00:01:36,950 --> 00:01:41,510
y se lo vamos a sumar al valor del radio horizontal de la elipse.

18
00:01:42,569 --> 00:01:45,909
Inicialmente va a ser 0, así que va a ser una elipse igual que la que teníamos antes

19
00:01:45,909 --> 00:01:54,670
y en cada ciclo le vamos a sumar 1, que se ponía T++, era una de las formas de poner incrementa 1.

20
00:01:55,670 --> 00:02:01,290
Queremos que cuando desaparezca por la derecha la elipse vuelva a ser como era al principio.

21
00:02:01,750 --> 00:02:05,530
Entonces ahora como tengo que poner dos instrucciones que dependen del condicional,

22
00:02:06,129 --> 00:02:07,989
esas dos instrucciones deben ir entre llaves.

23
00:02:08,449 --> 00:02:12,050
Antes no nos hacía falta porque solo teníamos una instrucción que dependía del condicional,

24
00:02:12,050 --> 00:02:17,050
pero cuando tenemos más de una tienen que ir metidas entre una llave abierta y una llave cerrada.

25
00:02:18,370 --> 00:02:25,289
Ahora vemos como la elipse crece y una vez que desaparece por la pantalla vuelve a aparecer con su tamaño inicial.

26
00:02:28,310 --> 00:02:30,330
Vamos a ver ahora cómo hacemos que rebote.

27
00:02:30,849 --> 00:02:35,490
Para eso vamos a utilizar lo que se llama una variable booleana, que son variables que solo pueden tener dos valores,

28
00:02:35,909 --> 00:02:38,370
valor verdadero, true o valor falso.

29
00:02:38,370 --> 00:02:46,270
Entonces inicialmente cuando la elipse está de ida, en el camino de ida, voy a poner que su valor inicial es verdadero.

30
00:02:46,490 --> 00:02:50,870
Voy a quitar esto de la t porque sería más complicado también cambiar el tamaño.

31
00:02:50,969 --> 00:02:53,250
De momento solo vamos a hacer que rebote y mantenga la posición.

32
00:02:54,449 --> 00:02:58,330
Así que borro todo lo que tiene que ver con la variable t esta que habíamos puesto para el tamaño

33
00:02:58,330 --> 00:03:02,169
y voy a incrementar un poco de menos en menos para que vaya más lento.

34
00:03:02,169 --> 00:03:21,550
Vale, entonces, una de las cosas que voy a poner es que cuando acabe la ida de la elipse, cuando llegue a la derecha, la variable que al principio era true, verdadero, estaba yendo, era verdadero que estaba yendo, pues ahora va a ser falso cuando llega a 600.

35
00:03:21,550 --> 00:03:40,889
Pero además voy a poner que si la variable id es verdadero, que eso se puede poner simplemente if id, no hace falta poner if id igual igual true, aunque también valdría, que quiero que haga cuando la variable id es verdadera, o sea, cuando la elipse está yendo hacia la derecha.

36
00:03:40,889 --> 00:03:46,449
Pues quiero que incremente la posición en 2 y que si llega a 600, cambie el valor de ida a falso.

37
00:03:47,629 --> 00:03:55,229
De esta forma voy a hacer que cuando la elipse esté yendo, vaya incrementando el valor de la X.

38
00:03:55,610 --> 00:04:01,449
Voy a copiar ahora para la vuelta estas instrucciones que dependen del valor verdadero de ida.

39
00:04:02,349 --> 00:04:05,469
Bueno, pito el incremento aquí porque ya lo he metido dentro de la condicional.

40
00:04:06,469 --> 00:04:08,169
Copio y lo pego.

41
00:04:08,169 --> 00:04:13,129
y ahora voy a poner cuando sea lo contrario de ida que se pone con una exclamación hacia abajo

42
00:04:13,129 --> 00:04:15,710
también podría poner cuando ida es igual o igual a falso

43
00:04:15,710 --> 00:04:19,930
lo que quiero es que en vez de sumar reste para que se mueva hacia el otro lado

44
00:04:19,930 --> 00:04:24,250
y que cuando llegue al borde izquierdo de la pantalla

45
00:04:24,250 --> 00:04:28,910
o sea cuando la x sea más pequeño que voy a poner 30

46
00:04:28,910 --> 00:04:31,550
porque como la elipse tiene ese radio de 60

47
00:04:31,550 --> 00:04:35,790
pues si pusiera 0 me desaparecería media elipse

48
00:04:35,790 --> 00:04:39,629
De hecho vamos a verlo como a la derecha

49
00:04:39,629 --> 00:04:43,269
Cuando llegue al borde de la derecha me va a desaparecer la elipse

50
00:04:43,269 --> 00:04:46,490
Porque hasta que no llegue a 600 va a desaparecer un trozo de la elipse

51
00:04:46,490 --> 00:04:50,069
Y sin embargo a la izquierda va a parecer mejor que rebota

52
00:04:50,069 --> 00:04:54,670
Porque he puesto el límite en 30 y como la elipse se está moviendo desde el centro

53
00:04:54,670 --> 00:04:58,050
Que está a 30 del borde, por eso queda mejor

54
00:04:58,050 --> 00:05:01,670
Así que va a quedar mejor si en vez de 600 pongo 570

55
00:05:01,670 --> 00:05:04,529
para que la elipse

56
00:05:04,529 --> 00:05:05,810
haga ese efecto rebote

57
00:05:05,810 --> 00:05:10,180
vale, pues para eso se utilizan

58
00:05:10,180 --> 00:05:12,519
es uno de los usos que tienen las variables booleanas

59
00:05:12,519 --> 00:05:14,420
para cambiar de verdadero

60
00:05:14,420 --> 00:05:16,139
a falso, entonces estoy detectando

61
00:05:16,139 --> 00:05:16,939
con esa variable

62
00:05:16,939 --> 00:05:19,980
si estoy yendo o estoy volviendo

63
00:05:19,980 --> 00:05:21,920
porque necesito detectar si va o vuelve

64
00:05:21,920 --> 00:05:23,480
para sumar o para restar

65
00:05:23,480 --> 00:05:25,720
vale, de hecho os acordáis de la

66
00:05:25,720 --> 00:05:27,000
función println

67
00:05:27,000 --> 00:05:29,139
para que veamos como a la ida

68
00:05:29,139 --> 00:05:31,959
el valor de ida es verdadero, es true

69
00:05:31,959 --> 00:05:35,639
y a la vuelta, cuando hemos cambiado el valor

70
00:05:35,639 --> 00:05:39,939
va a ser falso, entonces nos permite controlar

71
00:05:39,939 --> 00:05:43,959
el movimiento, true mientras va y falso mientras vuelve

72
00:05:44,639 --> 00:05:48,060
vale, va más rápido porque he incrementado

73
00:05:48,060 --> 00:05:49,600
de 5 en 5 a la ida

74
00:05:49,600 --> 00:05:54,860
y bueno, eso es todo, ahora ya sabéis hacer rebotes