{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Projeto: Capturando um robô\n",
    "\n",
    "Como seria o programa que faz a captura de um robô?\n",
    "\n",
    "Para responder essa pergunta precisamos ter em mente um princípio de design muito importante na criação de programas de computador. Esse princípio diz o seguinte:\n",
    "\n",
    "> É bom que os dados de um programa sejam independentes do modo como eles são apresentados para o usário do programa.\n",
    "\n",
    "Em outras palavras, é bom que os os dados e tudo o que o programa faz com eles seja programado separado da parte da interface do programa, que é a parte do programa que apresenta os dados, seja em modo texto ou gráfico.\n",
    "\n",
    "Isso é bom porque assim podemos ter várias formas de apresentar os dados, ou seja, várias interfaces, sem precisar mudar a parte do programa que manipula os dados. Por exemplo, as listas de robôs que estamos usando estão guardando dados importantes para o nosso jogo. Esses dados podem ser exibidos para o jogador de diversas formas. Vamos ver algumas.\n",
    "\n",
    "\n",
    "## Mostrar que robôs estão atacando\n",
    "\n",
    "Mostrar para o usuário o quê está acontecendo no programa é uma tarefa da interface do programa. Para poder mostrar isso, a interface precisa de dados. Esses dados estão na lista de robôs chamada `robos_atacando`. Com essa lista, podemos mostrar de diversas formas que esses robôs estão atacando (podemos ter várias versões de interface).\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Apresentação dos dados - versão 1\n",
      "['robô 1', 'robô 2', 'robô 3', 'robô 4', 'robô 5']\n",
      "\n",
      "Apresentação dos dados - versão 2\n",
      "Robôs atacando = 5\n",
      "\n",
      "Apresentação dos dados - versão 3\n",
      "🤖🤖🤖🤖🤖\n",
      "\n",
      "Apresentação dos dados - versão 4\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<img src=img/robof-64px.png /><img src=img/robof-64px.png /><img src=img/robof-64px.png /><img src=img/robof-64px.png /><img src=img/robof-64px.png />"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Dados\n",
    "robos_atacando= ['robô 1', 'robô 2', 'robô 3', 'robô 4', 'robô 5']\n",
    "\n",
    "# Diversas interfaces possíveis\n",
    "# para mostrar os dados para o\n",
    "# jogador\n",
    "\n",
    "print('Apresentação dos dados - versão 1')\n",
    "print(robos_atacando)\n",
    "print()\n",
    "\n",
    "print('Apresentação dos dados - versão 2')\n",
    "print('Robôs atacando = %s' % len(robos_atacando))\n",
    "print()\n",
    "\n",
    "print('Apresentação dos dados - versão 3')\n",
    "print('\\N{robot face}' * len(robos_atacando))\n",
    "print()\n",
    "\n",
    "print('Apresentação dos dados - versão 4')\n",
    "from IPython.display import HTML\n",
    "HTML('<img src=img/robof-64px.png />' * len(robos_atacando))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Observe que em qualquer dos casos os dados são sempre os mesmos. É sempre a mesma lista de strings, chamada `robos_atacando` que está sendo usada para criar essas 4 interfaces diferentes. E muitas outras formas são possíveis. Para todas elas a lista `robos_atacando` pode continuar a mesma - não é preciso mudar os dados para ter uma nova interface!\n",
    "\n",
    "Então, pensando nessa **separação entre dados e interface**, o que seria a ação de **capturar um robô** do ponto-de-vista dos dados? Em outras palavras, se não nos preocuparmos com a interface, quais dados e quais operações sobre eles são efetuadas quando vamos \"capturar um robô\"?\n",
    "\n",
    "Primeiro, quais são os dados que precisamos conhecer para poder realizar essa ação?\n",
    "\n",
    "1. quais robôs estão atacando (porque sem isso não sabemos o que temos para capturar)\n",
    "1. qual desses robôs será o robô capturado (porque temos que ter um \"alvo\" definido)\n",
    "1. onde colocar esse robô que capturamos, porque não faz sentido capturar um dos robôs e ele continuar junto dos robôs que estão atacando\n",
    "\n",
    ">lembrando que \"capturar\" não é \"destruir\", por isso vamos colocar o robô em algum lugar e não simplesmente excluir ele do jogo.\n",
    "\n",
    "Essas dados serão os seguintes:\n",
    "\n",
    "1. A lista `robos_atacando`\n",
    "1. Há várias formas de escolher o robô que será nosso alvo. Podemos pegar sempre o primeiro da lista, ou sempre o último, ou pegar sempre um aleatório. O importante aqui é que precisamos guardar esse robô (que da perspectiva dos dados é só uma string comum) em alguma variáveil, porque depois vamos precisar dela para colocar esse robô nos robôs capturados.\n",
    "1. E vamos colocar o robô capturado na lista `robos_capturados`\n",
    "\n",
    "Ora, nós praticamente já escrevemos esse código na sessão anterior!\n",
    "\n",
    "Da perspectiva dos dados, capturar um robô pode ser algo simples, como:\n",
    "\n",
    "- escolher um robô da lista de robôs que estão atacando\n",
    "- retirar esse robô da lista\n",
    "- colocar esse robô na lista de robôs capturados\n",
    "\n",
    "Assim:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Dados\n",
    "robos_atacando= ['robô 1', 'robô 2', 'robô 3', 'robô 4', 'robô 5']\n",
    "robos_capturados =[]\n",
    "\n",
    "# Ação: capturar robô\n",
    "\n",
    "# 1. Escolher um robô da lista de robôs que estão atacando\n",
    "robo = robos_atacando[-1] # aqui, escolhemos o último da lista\n",
    "\n",
    "# 2. retirar esse robô da lista\n",
    "del robos_atacando[-1]\n",
    "\n",
    "# 3. colocar esse robô na lista de robôs capturados\n",
    "robos_capturados.append(robo)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Fica agora faltando mostrar para o jogador o que aconteceu após a execução dessa ação de `capturar robô`. Agora é que entra a interface.\n",
    "\n",
    "O jogador não sabe o que aconteceu com os dados do jogo porque isso aconteceu só na memória do computador. Ninguém viu! A interface deve mostrar para o jogador quais foram as mudanças que ocorreram no jogo após a sua ação."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Robôs atacando\n",
      "🤖🤖🤖🤖\n",
      "Robôs capturados\n",
      "🤖\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Interface que mostra para o jogador\n",
    "# as mudanças que ocorrem nos dados do jogo\n",
    "\n",
    "print('Robôs atacando')\n",
    "print('\\N{robot face}' * len(robos_atacando))\n",
    "print('Robôs capturados')\n",
    "print('\\N{robot face}' * len(robos_capturados))\n",
    "\n",
    "print()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Mostrar a mudança dos dados\n",
    "\n",
    "Vamos mostrar para o jogador um `antes e depois` do nosso programa quando a ação de `capturar robô` for executada. Isso é para o jogador entender melhor o que está acontecendo. Se mostramos penas a situação final (o depois, como fizemos acima) sem ter mostrado como tudo estava antes de da ação de captura acontecer, a informação apresentada fica meio enigmática, porque o jogador precisa \"deduzir\" quais robôs estavam atacando após ver o tamanho da sua lista de robôs capturados e entender que aqueles \"robôs atacando\" que aparecem para ele continham 1 robô a mais no momento anterior. Por isso, mostrar esse momento anterior facilita a compreensão do que aconteceu.\n",
    "\n",
    "Vamos juntar tudo o que fizemos em uma só trecho de código e vamos escrever no final esse `antes e depois` mostrando a mudança nos dados.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Robôs atacando\n",
      "🤖🤖🤖🤖🤖\n",
      "Robôs capturados\n",
      "\n",
      "\n",
      "Robôs atacando\n",
      "🤖🤖🤖🤖\n",
      "Robôs capturados\n",
      "🤖\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Dados\n",
    "robos_atacando= ['robô 1', 'robô 2', 'robô 3', 'robô 4', 'robô 5']\n",
    "robos_capturados =[]\n",
    "\n",
    "# ANTES\n",
    "# Interface que mostra para o jogador\n",
    "# as mudanças que ocorrem nos dados do jogo\n",
    "\n",
    "print('Robôs atacando')\n",
    "print('\\N{robot face}' * len(robos_atacando))\n",
    "print('Robôs capturados')\n",
    "print('\\N{robot face}' * len(robos_capturados))\n",
    "\n",
    "print()\n",
    "\n",
    "\n",
    "# Ação: capturar robô\n",
    "\n",
    "# 1. Escolher um robô da lista de robôs que estão atacando\n",
    "robo = robos_atacando[-1] # aqui, escolhemos o último da lista\n",
    "\n",
    "# 2. retirar esse robô da lista\n",
    "del robos_atacando[-1]\n",
    "\n",
    "# 3. colocar esse robô na lista de robôs capturados\n",
    "robos_capturados.append(robo)\n",
    "\n",
    "\n",
    "# DEPOIS\n",
    "# Interface que mostra para o jogador\n",
    "# as mudanças que ocorrem nos dados do jogo\n",
    "\n",
    "print('Robôs atacando')\n",
    "print('\\N{robot face}' * len(robos_atacando))\n",
    "print('Robôs capturados')\n",
    "print('\\N{robot face}' * len(robos_capturados))\n",
    "\n",
    "print()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Agora sim! Podemos ver muito melhor que começamos sem ter capturado nenhum robô e que 5 robôs estavam atacando. Depois da ação `capturar robô` vemos claramente que 1 robô foi capturado e que restam 4 robôs atacando."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.10.5 64-bit (windows store)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.5"
  },
  "orig_nbformat": 4,
  "vscode": {
   "interpreter": {
    "hash": "81d56cede9ef4caf6a61e146de670b37a2edead0ccb6294f4b93deebf2edb1a9"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}