{
 "metadata": {
  "name": "",
  "signature": "sha256:cdd6cae9156d67533a7648ec148e62141e5c2f5838b6c107108fd2575c4568a9"
 },
 "nbformat": 3,
 "nbformat_minor": 0,
 "worksheets": [
  {
   "cells": [
    {
     "cell_type": "heading",
     "level": 1,
     "metadata": {},
     "source": [
      "[Volver al \u00edndice](localhost:8888/newtbooks/indexp.ipynb \"Volver al \u00edndice\") <hr>"
     ]
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Motor f\u00edsico"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "El motor f\u00edsico constituye la primera parte del archivo ***apple.py***, en la que se definar\u00e1n aquella clases responsables de dirigir la f\u00edsica del juego. La segunda parte, hace referencia a las caracter\u00edsticas propias del m\u00f3vil (manzana) y del lanzador (tirachinas), a la cual se podr\u00e1 acceder m\u00e1s adelante."
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "El esquema general de esta parte del documento queda de la siguiente manera:\n",
      "* **Funci\u00f3n collide_relative_widgets**: Interviene en el comportamiento de la colisi\u00f3n de dos widgets. Utilizado en la colisi\u00f3n entre manzana y objetivo.\n",
      "* **Clase PhysicsEngine**: Motor f\u00edsico principal. Contiene el comportamiento ideal.\n",
      "* **Clase LinearFrictionPhysicsEngine**: Hereda de PhysicsEngine. Contiene la informaci\u00f3n necesaria para el comportamiento con rozamiento lineal.\n",
      "* **Clase PhysicsAdapter**: Adapta la informaci\u00f3n gr\u00e1fica a partir de la informaci\u00f3n proporcionada por el motor f\u00edsico."
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "La librer\u00eda math nos proporcionar\u00e1 aquellas herramientas num\u00e9ricas necesarias para realizar los c\u00e1lculos f\u00edsicos."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "from math import sqrt, cos, sin, pi, exp"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 2
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "A continuaci\u00f3n importamos una s\u00e9rie de m\u00f3dulos pertenecientes a la librer\u00eda kivy, cuya utilidad quedar\u00e1 reflejada posteriormente. Sin embargo, podriamos introducir su uso en el programa como:\n",
      "\n",
      "* **Animation**: Control del cambio de opacidad de las manzanas.\n",
      "* **Clock**: Control de los int\u00e9rvalos delta de tiempo, lo que implica actualizaci\u00f3n de las variables din\u00e1micas de la manzana.\n",
      "* **RelativeLayout**: Herramientas \n",
      "* **Vector**: Control de las variables f\u00edsicas mediante vectores."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "from kivy.animation import Animation\n",
      "from kivy.clock import Clock\n",
      "from kivy.uix.relativelayout import RelativeLayout\n",
      "from kivy.vector import Vector"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Finalmente importamos las herramientas definidas en ***common.py***, explicadas anteriormente."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "from common import config, FixedSizeImage, make_sized_image, LineWidget, LinePointsWidget"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      " "
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Tras importar lo necesario, pasaremos a definir la primera funci\u00f3n, **collide_relative_widgets**. El prop\u00f3sito principal de esta funci\u00f3n es "
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "def collide_relative_widgets(w1, w2):\n",
      "    w1x, w1y = w1.to_window(w1.x, w1.y)\n",
      "    w2x, w2y = w2.to_window(w2.x, w2.y)\n",
      "\n",
      "    if w1x + w1.width < w2x:\n",
      "        return None\n",
      "    if w1x > w2x + w2.width:\n",
      "        return None\n",
      "    if w1x + w1.height < w2y:\n",
      "        return None\n",
      "    if w1y > w2y + w2.height:\n",
      "        return None\n",
      "\n",
      "    left_right = 0\n",
      "    if w1x < w2x:\n",
      "        left_right = -1\n",
      "    elif w1x + w1.width > w2x + w2.width:\n",
      "        left_right = 1\n",
      "\n",
      "    top_bottom = 0\n",
      "    if w1y < w2y:\n",
      "        top_bottom = -1\n",
      "    elif w1y + w1.height > w2y + w2.height:\n",
      "        top_bottom = 1\n",
      "\n",
      "    return (left_right, top_bottom)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Pasamos a continuaci\u00f3n a definir la clase principal, **PhysicsEngine**, que funcionar\u00e1 como motor f\u00edsico principal del juego. Para ello llamamos inicialmente a @config para obtener los datos ofrecidos por el usuario en **settings.ini**, ofreci\u00e9ndole al programa los valores por omisi\u00f3n en el caso de que esta informaci\u00f3n no se encuentre en el archivo. Las variables presentes son explicadas con mayor detenimiento en el apartado **Configuraci\u00f3n** del \u00edndice."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "@config(\n",
      "    mass = 1,\n",
      "    k = 80,\n",
      "    g = 500,\n",
      "    damping_factor_facing = 0.1,\n",
      "    damping_factor_side   = 0.3\n",
      ")"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      " "
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Pasando a la definici\u00f3n directa de la clase, encontramos inicialmente el m\u00e9todo __init__, el cual inicializa la clase tomando los valores indicados en la configuraci\u00f3n mediante el m\u00e9todo copy_config(), que proporciona\u00a0@config.\n",
      "\n",
      "Seguidamente encontramos aquellos m\u00e9todos que realizan los c\u00f3mputos del movimiento arm\u00f3nico simple explicados en el apartado **Conceptos f\u00edsicos** del \u00edndice. Esta encapsulaci\u00f3n tiene el car\u00e1cter de favorecer la claredad del c\u00f3digo y devolver la posici\u00f3n y velocidad del m\u00f3vil en cada instante.\n",
      "\n",
      "Los c\u00e1lculos generales del el\u00e1stico se reunen en el m\u00e9todo compute_launch, que toma como par\u00e1metros la posici\u00f3n de equilibrio del el\u00e1stico (balance), la posici\u00f3n desde la que se ha agarrado a la manzana (grab) y la posici\u00f3n desde la que se ha soltado esta (release).\n",
      "\n",
      "Aprovechamos los m\u00e9todos definidos para calcular el tiempo que dura el movimiento arm\u00f3nico, la posici\u00f3n en la que se encontrar\u00e1 la manzana al separarse del el\u00e1stico (y por tanto iniciar el movimiento parab\u00f3lico), y la velocidad a la que sale esta del el\u00e1stico (que tomar\u00e1 el papel de velocidad inicial en el tiro parab\u00f3lico).\n",
      "\n",
      "Tras el movimiento el\u00e1stico pasamos a desarrollar los m\u00e9todos encargados del c\u00e1lculo de la posici\u00f3n y la velocidad en el movimiento parab\u00f3lico ideal en funci\u00f3n del tiempo. Esta encapsulaci\u00f3n nos permetir\u00e1 a\u00f1adir posteriormente una clase encargada de controlar el movimiento con rozamiento lineal sustituyendo peque\u00f1as porciones de c\u00f3digo por las ecuaciones correspondientes. Los m\u00e9todos permiten pasar como argumentos los valores iniciales de la posici\u00f3n y la velocidad, o en el caso de no hacerlo, coge por defecto los valores finales del movimiento el\u00e1stico."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "class PhysicsEngine:\n",
      "    def __init__(self):\n",
      "        self.copy_config()\n",
      "\n",
      "    def compute_launch(self, balance, grab, release):\n",
      "        self.balance = balance\n",
      "\n",
      "        self.d = grab - release           # vector: release point ---> grab point\n",
      "        self.mu = sqrt(self.k/self.mass)\n",
      "\n",
      "        self.slinky_end_time = self.compute_slinky_end_time()\n",
      "        self.slinky_end_pos = self.slinky(self.slinky_end_time)\n",
      "        self.slinky_end_velocity = self.slinky_velocity(self.slinky_end_time)\n",
      "\n",
      "    def compute_slinky_end_time(self):\n",
      "        return pi/(2*self.mu)\n",
      "\n",
      "    def slinky(self, t):\n",
      "        balance, d, mu = self.balance, self.d, self.mu\n",
      "        return balance - d * cos(mu*t)\n",
      "\n",
      "    def slinky_velocity(self, t):\n",
      "        d, mu = self.d, self.mu\n",
      "        return d * mu * sin(mu*t)\n",
      "\n",
      "    def parabolic(self, t, p0=None, v0=None):\n",
      "        p0 = p0 or self.slinky_end_pos\n",
      "        v0 = v0 or self.slinky_end_velocity\n",
      "\n",
      "        x = p0.x + v0.x*t\n",
      "        y = p0.y + v0.y*t - self.g*t*t/2\n",
      "\n",
      "        return (x,y)\n",
      "\n",
      "    def parabolic_velocity(self, t, v0):\n",
      "        v0x, v0y = v0 or self.slinky_end_velocity\n",
      "\n",
      "        return Vector(v0x, v0y - self.g*t)\n",
      "\n",
      "    def collision_bounce_velocity(self, t, v0, collision):\n",
      "        v = self.parabolic_velocity(t, v0)\n",
      "\n",
      "        for i in [1,0]:\n",
      "            if collision[i]*v[i] < 0:\n",
      "                v[i]   *= -self.damping_factor_facing\n",
      "                v[1-i] *= self.damping_factor_side\n",
      "                break\n",
      "        else:\n",
      "            v *= self.damping_factor_side\n",
      "\n",
      "        return v"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      " "
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "A continuaci\u00f3n encontramos la clase encargada de dirigir el movimiento parab\u00f3lico con fricci\u00f3n. Esta hereda del motor principal, **PhysicsEngine**, cargando su constructor junto a los valores ofrecidos en @config. La encapsulaci\u00f3n ofrecida en el padre permite que esta clase pueda ser definida como una modificaci\u00f3n del contenido de los m\u00e9todos que calculan la posici\u00f3n y la velocidad, aplicando en este caso las expresiones deducidad en el apartado **F\u00edsica** del \u00edndice."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "@config(b = 0.03)\n",
      "class LinearFrictionPhysicsEngine(PhysicsEngine):\n",
      "    def __init__(self):\n",
      "        PhysicsEngine.__init__(self)\n",
      "        self.copy_config()\n",
      "\n",
      "    def parabolic(self, t, p0=None, v0=None):\n",
      "        p0 = p0 or self.slinky_end_pos\n",
      "        v0 = v0 or self.slinky_end_velocity\n",
      "\n",
      "        g, b = self.g, self.b\n",
      "\n",
      "        x = p0.x + v0.x/b * (1-exp(-b*t))\n",
      "        y = p0.y - g/b * t + 1/b * (g/b + v0.y)*(1-exp(-b*t))\n",
      "\n",
      "        return (x,y)\n",
      "\n",
      "    def parabolic_velocity(self, t, v0):\n",
      "        v0x, v0y = v0 or self.slinky_end_velocity\n",
      "        g, b = self.g, self.b\n",
      "\n",
      "        vx = v0.x * exp(-b*t)\n",
      "        vy = (g/b + v0.y) * exp(-b*t) - g/b\n",
      "        return Vector(vx, vy)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [],
     "language": "python",
     "metadata": {},
     "outputs": []
    }
   ],
   "metadata": {}
  }
 ]
}