# data[].attributes.body
programa tppromo
procesos
proceso aleatorio
variables
av,ca: numero
comenzar
Random(av,5,55)
Random(ca,5,30)
EnviarMensaje(av,robot1)
EnviarMensaje(ca,robot1)
Random(av,5,55)
Random(ca,5,30)
EnviarMensaje(av,robot2)
EnviarMensaje(ca,robot2)
Random(av,5,55)
Random(ca,5,30)
EnviarMensaje(av,robot3)
EnviarMensaje(ca,robot3)
Random(av,5,55)
Random(ca,5,30)
EnviarMensaje(av,robot4)
EnviarMensaje(ca,robot4)
fin
proceso esquina(ES papeles: numero; E av: numero E ca:numero; E cabase:numero; E avbase:numero)
comenzar
BloquearEsquina(av,ca)
Pos(av,ca)
mientras HayPapelEnLaEsquina
tomarPapel
papeles:= papeles + 1
Pos(avbase,cabase)
LiberarEsquina(av,ca)
fin
proceso depositar (E avbase: numero; E cabase:numero)
comenzar
BloquearEsquina(100,1)
Pos(100,1)
mientras HayPapelEnLaBolsa
depositarPapel
Pos(avbase,cabase)
LiberarEsquina(100,1)
fin
proceso rellenar(E avbase:numero; E cabase:numero; ES flores:numero; ES cumple:boolean;)
variables
av: numero
comenzar
BloquearEsquina(100,1)
Pos(100,1)
si HayPapelEnLaEsquina
tomarPapel
Random(av,1,100)
BloquearEsquina(av,50)
Pos(av,50)
LiberarEsquina(100,1)
mientras HayFlorEnLaEsquina
tomarFlor
flores:=flores + 1
depositarPapel
Pos(avbase,cabase)
LiberarEsquina(av,50)
sino
cumple:= F
Pos(avbase,cabase)
LiberarEsquina(100,1)
fin
proceso minimo(E ID: numero; E flores: numero; ES IDmin: numero; ES min: numero)
comenzar
si (min > flores)
min:= flores
IDmin:= ID
fin
areas
areaj: AreaP(1,1,1,1)
areaR1: AreaP(6,4,6,4)
areaR2: AreaP(8,4,8,4)
areaR3: AreaP(10,4,10,4)
areaR4: AreaP(12,4,12,4)
comun: AreaPC(100,1,100,1)
areadelimitada: AreaC(5,5,55,30)
calle50: AreaC(1,50,100,50)
robots
robot ejecutor
variables
avbase,cabase: numero
flores: numero
papeles: numero
av,ca: numero
ID: numero
empapelar: numero
cumple: boolean
comenzar
flores:= 0
papeles:= 0
avbase:= PosAv
cabase:= PosCa
cumple:= V
RecibirMensaje(ID,robot5)
repetir 5
RecibirMensaje(av,robot5)
RecibirMensaje(ca,robot5)
esquina(papeles,av,ca,cabase,avbase)
depositar(avbase,cabase)
EnviarMensaje(papeles,robot5)
RecibirMensaje(empapelar,robot5)
mientras (cumple = V)
rellenar(avbase,cabase,flores,cumple)
Informar('CantidadDeFloresRecolectadas', flores)
EnviarMensaje(ID,robot5)
EnviarMensaje(flores,robot5)
fin
robot juez
variables
papeles,total: numero
ID,IDmin: numero
flores,min: numero
comenzar
total:= 0
IDmin:= 0
min:= 999
EnviarMensaje(1,robot1)
EnviarMensaje(2,robot2)
EnviarMensaje(3,robot3)
EnviarMensaje(4,robot4)
repetir 5
aleatorio
repetir 4
RecibirMensaje(papeles,*)
total:= total + papeles
Informar('CantidadTotalDePapelesRecolectados',total)
EnviarMensaje(1,robot1)
EnviarMensaje(1,robot2)
EnviarMensaje(1,robot3)
EnviarMensaje(1,robot4)
total:= 0
repetir 4
RecibirMensaje(ID,*)
RecibirMensaje(flores,*)
minimo(ID,flores,IDmin,min)
Informar('ElRobotQueRecolectoMenosFloresEsEl',IDmin)
Informar('CantidadDeFloresQueRecolectoElMismo',min)
fin
variables
robot1: ejecutor
robot2: ejecutor
robot3: ejecutor
robot4: ejecutor
robot5: juez
comenzar
AsignarArea(robot5,areaj)
AsignarArea(robot1,areaR1)
AsignarArea(robot1,comun)
AsignarArea(robot1,areadelimitada)
AsignarArea(robot1,calle50)
AsignarArea(robot2,areaR2)
AsignarArea(robot2,comun)
AsignarArea(robot2,areadelimitada)
AsignarArea(robot2,calle50)
AsignarArea(robot3,areaR3)
AsignarArea(robot3,comun)
AsignarArea(robot3,areadelimitada)
AsignarArea(robot3,calle50)
AsignarArea(robot4,areaR4)
AsignarArea(robot4,comun)
AsignarArea(robot4,areadelimitada)
AsignarArea(robot4,calle50)
Iniciar(robot1,6,4)
Iniciar(robot2,8,4)
Iniciar(robot3,10,4)
Iniciar(robot4,12,4)
Iniciar(robot5,1,1)
fin

# data[].attributes.body
AreaJuez: AreaP (1,1,1,1) = Esta área es la esquina donde se va a encontrar el robot juez, al no moverse, es un área de 1x1, además de ser privadas.

r1: AreaP (6,4,6,4)
r2: AreaP (8,4,8,4)
r3: AreaP (10,4,10,4)
r4: AreaP (12,4,12,4)
= r1, r2, r3, r4 son las áreas "bases" de cada robot, estas son de 1x1, y además son privadas ya que en cada una únicamente entrara un robot.

comun: AreaPC (100,1,100,1)= Esta área es la esquina 100,1 ; en donde cada robot tendrá que depositar los papeles juntados. La hicimos parcialmente privada ya que todos los robots ejecutores (1,2,3,4) pueden acceder a esta esquina, pero tan solo de a uno a la vez ( en caso contrario colapsarían )

AreaDelimitada: AreaC (5,5,55,30) = Esta área es el rectangulo que contiene todas las esquinas las cuales pueden tener que visitar. El robot juez les indicara que esquina acceder;  al ser una área compartida, todos los robots pueden permanecer juntos en el mismo rectángulo a la vez, lo que no pueden hacer es posicionarse en la misma esquina mas de un robot al mismo tiempo. Para esto cada robot deberá bloquear la esquina en la cual se va a posicionar, y luego liberar la misma al volver a su base.

calle50 : AreaC (1,50,100,50) = Esta área involucra a toda la calle 50 (desde la avenida 1 hasta la 100), en la cual los robots ejecutores deberán acceder (siempre y cuando encuentren un papel en la esquina 100,1) de manera aleatoria (a cualquier avenida de la calle 50) y en esta esquina depositaran un papel y tomaran todas las flores que encuentren en la misma. Además es un área compartida ya que todos los robots ejecutores pueden acceder a la misma de manera sincrónica, pero sin poder colisionarse intentando posicionarse mas de un robot en la misma esquina ( para esto se volverá a usar el BloquearEsquina y LiberarEsquina)

# data[].attributes.body
avbase, cabase: numero = Estas variable la utilizamos para guardar la avenida y calle de la base, que era donde iniciaban cada robot ejecutor en el programa.

flores, papeles: numero = Estas variable las utilizamos para contar la cantidad de papeles y flores recolectadas cuando se necesitaban,  en el programa eran inicializados en 0 al principio.

av,ca: numero = Estas variables fueron utilizadas para Recibir la avenida y calle por mensaje del juez cuando el robot juez hacia el Random y les pasaba las esquina a cada robot en particular.

ID: numero = Esta variable la utilizamos para la identificacion de los robots ejecutores, el juez les daba un numero segun su nombre, al robot1 le dio el ID 1, al robot2 le dio el ID 2, etc...

empapelar: numero = Es una variable Simbólica, la cual nada mas usamos para que los robots ejecutores reciban un mensaje y puedan comenzar a empapelar

cumple: boolean = Esta variable la utilizamos para realizar la tarea de empapelar la calle 50, con esta variable analizabamos si quedaban papeles o no en la esquina (100,1) si no habia mas, el mientras se dejaba de realizar y finalizaban con su trabajo.

# data[].attributes.body
id: numero = esta la utilizaremos para cuando el robot juez reciba por mensaje el ID del robot ejecutor, y pueda almacenarla en variable.

papeles, flores, total: numero = estas variables no nos mas que cantidades, si bien "flores" y "papeles" son mas utilizadas por los robots ejecutores, el robot juez las tiene declaradas para cuando le envíen el mensaje con esta cantidad (de flores y papeles recogidos por los ejecutores) pueda este almacenarlo en variable. Luego "total" es la que usaremos para contabilizar la cantidad de papeles totales tomados por los ejecutores, esta estará al comienzo del todo inicializada en 0.

idMin, min: numero = estas variables son usadas para buscar el mínimo, en "idMin" se almacenara el ID del robot que menos flores haya juntado, y en "min" la cantidad de flores que haya juntado el robot ejecutor que menos obtuvo ("min" lo inicializamos en 999, ya que debe ser un numero lo suficientemente grande como para que hasta el primer robot haya juntado menos flores y esta variable se cambie ).

Todas estas variables son de tipo numero ya que es lo que estarían almacenando todas. Un numero.

# data[].attributes.body
Este robot, (llamado en el programa robot5), tan solo permanecerá quieto en el área 1,1 (AreaJuez) y será el encargado de coordinar muchas instrucciones dentro del programa.
Para empezar lo primero que hará el mismo es enviarle a cada uno de los 4 robots ejecutores su ID perteneciente (elegimos el 1 para el robot1, 2 para el robot2, etc...) .
Luego para la primer parte del programa, nosotros decidimos que el robot juez será el encargado de de realizar un random para decidir a que esquina (avenida y calle), dentro del área delimitada, accederá cada robot ejecutor. Para esto realizamos dentro de un repetir 5 ( ya que es el total de esquinas que cada robot ejecutor accederá) un proceso llamado aleatorio, el cual realizara los random de las avenidas y calles (manteniendo el área delimitada), luego de esto, cada avenida y calle es enviada por mensaje a cada robot ejecutor (comenzando por la primer esquina aleatoria que la recibirá, y accederá el robot1, luego la segunda el cual dicho mensaje irá dirigido al robot2, y así sucesivamente).
Al terminar de realizar lo anterior, y luego de que cada robot ejecutor haga lo que debía hacer en cada esquina, el robot juez recibirá por mensaje (como emisor del mensaje pusimos "*" ya que el primer robot ejecutor en terminar, será el primero en enviarle la cantidad de papeles juntadas por el a juez, por lo tanto no podemos declarar quien será que terminara antes, por lo tanto gracias al "*", no importa quien sea el que envía el mensaje, el robot juez lo recibirá y lo guardara en su variable "papeles") la cantidad de papeles que cada robot ejecutor recolecto en su camino por las 5 esquinas visitadas. Luego de recibir cada mensaje, para contabilizar la cantidad total recolectadas entre todos, realizamos:  "total:= total + papeles", siendo "total" una variable anteriormente inicializada en 0,  y "papeles" la variable anteriormente mencionada. (Esto lo hemos hecho con un repetir 4 ya que recibe la cantidad de papeles de todos los robots ejecutores (que son 4) y los suma al "total".
Para finalizar esta parte del programa ( que la catalogamos como la primera) el robot juez informara la cantidad total de papeles recolectados entre todos los robots ejecutores ("Informar ('PapelesRecolectados', total)")

# data[].attributes.body
Nosotros tenemos 4 robots ejecutores, los cuales al principio tenían que juntar todos los papeles de una esquina obtenida de manera aleatoria dentro de un área, para esto nosotros pensamos en que el robot juez, quien es el robot que maneja a los ejecutores, haga el Random con un modulo (proceso aleatorio) y pasarles la avenida y calle a cada robot ejecutor en particular, este modulo lo debía utilizar 5 veces, por lo tanto utilizamos un repetir 5. luego de que los ejecutores tienen la esquina enviada por el robot juez, pensamos que debían bloquear la esquina antes de todo ya que había posibilidad de que los robots se choquen porque el robot juez podría haberles dado la misma esquina. una vez bloqueada, los robots ejecutores se mueven hacia la esquina que les toco, y como pide el enunciado, tenían que juntar todos los papeles de esa esquina, para esto, nosotros utilizamos otro modulo (proceso esquina) el cual les hacia recolectar todos los papeles. luego nos pide que los robots ejecutores depositen todos los papeles recolectados en una esquina en común (100,1), para esto pensamos lo mismo que cuando hacíamos el Random, teníamos que bloquear la esquina antes de acceder ya que cuatro robots estarían intentando ir a la misma esquina y se generaria un choque, para esta parte también utilizamos un modulo (proceso depositar) , este proceso bloquea la esquina, y cuando la logran bloquear, los robots ejecutores se mueven hacia ella depositan todos los papeles recolectados, y luego vuelve cada robot ejecutor a su base. por ultimo nos pedia que los robots ejecutores le comuniquen al juez cuantos papeles habian recolectado, para esto nosotros pensamos en utilizar una variable la cual era utilizada en el modulo de recolectar papeles (proceso esquina) que por cada papel recolectado, aumentaba el valor de esta variable, para luego enviarle un mensaje al juez con esta variable.

# data[].attributes.body
Para comenzar con la que catalogamos como segunda parte del programa, el robot juez les indicara a cada robot ejecutor que pueden comenzar a empapelar la calle 50, para esto decidimos que los ejecutores se quedaran esperando a recibir el mensaje que le va a enviar el juez. Para este mensaje decidimos enviar un numero simbólico (1) a todos los robots ejecutores (empezando por el robot1, siguiendo por el robot2 etc...) (el mensaje no debía llevar nada importante, tan solo era para mantener a los robots ejecutores "quietos" hasta que el robot juez termine sus instrucciones anteriores (como la de informar papeles)) , luego de mandar este mensaje, los ejecutores ya pueden comenzar con las siguientes instrucciones a realizar.
Luego que los robots ejecutores terminen con todo lo que deben hacer, le enviaran cada uno dos mensajes al robot juez, comenzando por su ID, para que se puedan identificar, y luego la cantidad de flores juntadas por cada uno. El juez, con un repetir 4 antes(ya que va a realizar 4 veces estas instrucciones, una para cada robot ejecutor) , recibirá estos mensajes (también con el emisor "*", por lo mencionado anteriormente) y realizara el proceso llamado "mínimo", en el cual estamos comparando la cantidad de flores recibida por el robot de ID "X" con una variable llamada "min", inicializada en un numero alto como lo es 999 (para que el valor del primer robot ejecutor quede almacenado en este), si se cumple que "flores < min", a "min" le asignamos el valor de "flores" (ya que de momento será el menor valor encontrado) y por lo tanto si se cumple también cambiamos la variable "idMin" por el "ID" del robot el cual le envió el mensaje (para almacenar el ID y saber al final quien es el robot ejecutor que menos flores juntó).
Al terminar el repetir 4, el robot juez informará el ID almacenado en "idMin" (que contiene el id del robot ejecutor que menos flores juntó) y tambien la cantidad que este juntó (almacenado en la variable "min").

# data[].attributes.body
El robot juez cuando recibe e informa el total de papeles recolectados por los robots ejecutores les avisa a los ejecutores, que pueden comenzar con su otra tarea, para esto, los robots ejecutores estaban esperando el mensaje por parte del juez para poder comenzar, si el juez les mandaba el valor 1, ellos ya tenían el permiso de comenzar, esto nosotros lo hicimos de esta manera ya que nos gusto la idea de que los robots ejecutores se queden esperando a que el robot juez termine de informar.  una vez avisados los robots ejecutores van a comenzar con la tarea de Empapelar la calle 50, para lograr esto cada robot ejecutor debía agarrar un papel de la esquina en común donde habían depositado anteriormente todos los papeles recolectados (100,1) y luego moverse a una esquina al azar de la calle 50 y depositarlo. para lograrlo utilizamos una variable de tipo boolean y además un modulo (proceso rellenar) el cual el robot ejecutor primero bloquea la esquina donde se encuentran los papeles (100,1) accede a ella y pregunta, si hay papel, lo toma y hace todo el proceso de hacer un Random para la avenida, ya que la calle era la 50, bloquea esa esquina encontrada, se mueve con un Pos hacia ella y depositaba el papel y luego se movía hacia su base, liberando la esquina donde habían estado (claramente cuando se movieron a esta esquina, la esquina en común (100,1) La liberan para la llegada de otro de los robots ejecutores). si no había mas papeles en la esquina (100,1) la variable boolean pasaba a ser de valor F así no volvía a hacer la vuelta, ya que esto se generaba con un Mientras (variable = V), además de que vuelve a su base, liberan la esquina y finalizaban su trabajo porque no había mas papeles. Pero había que hacer otra cosa mas, que era  que los robots ejecutores debían juntar todas las flores de las esquinas que les tocaban en la calle 50, donde depositaban su papel, esto lo hicimos también en el modulo (Proceso rellenar) que preguntaba si mientras había flor en la esquina, que la recolecte, como también pedía que al final cuando ya no quedan papeles, que informen la cantidad de flores recolectas, a lo que nosotros utilizamos una variable que aumente su valor por cada flor recolectada para asi facilitar la información de la cantidad de flores. también pensamos que cada uno cuando terminaba debía informar su total de flores recolectadas por lo que utilizamos un informar y asi cada robot ejecutor mostraba su cantidad recolectada. Luego de informar, al final nos pide que los robots ejecutores notifiquen al robot juez de que finalizaron con sus tareas además de que el robot juez debía elegir el que menos flores había recolectado, por consiguiente, la manera que usamos para avisarle que habían terminado fue la utilizados de dos EnviarMensaje, uno con la variable ID(identificación) que cada robot ejecutor tenia su numero en particular en el ID(1,2,3,4) ya que sino no se sabría que robot fue el que menos recolecto, y el otro, la variable flores, que utilizamos en el modulo (Proceso rellenar) para contar cuantas flores recolectaba cada uno, el juez utiliza un repetir 4 donde dentro tiene los dos RecibirMensaje (variable, *) porque no se sabe cual robot ejecutor te manda primero sus datos, luego de recibirlos el robot juez ejecuta el modulo (Proceso mínimo) con el cual analiza las cantidades de flores de los cuatro utilizando dos variables mas para guardar los datos de identificación del robot y la cantidad que recolecto que fue la mas pequeña. por ultimo informa estas dos variables dando a conocer quien fue el que menos recolecto, y se finaliza el programa.

# data[].attributes.headline
Robots, Asignacion De Area y Iniciar de los Robots

# data[].attributes.subject
Robots, Asignacion De Area y Iniciar de los Robots