#+title: Movement!

 #+author: Robert McIntyre

 #+email: rlm@mit.edu

 #+description: muscles for a simulated creature

 #+keywords: simulation, jMonkeyEngine3, clojure

 #+SETUPFILE: ../../aurellem/org/setup.org

 #+INCLUDE: ../../aurellem/org/level-0.org

 

 

 Surprisingly enough, terristerial creatures only move by using torque

 applied about their joints.  There's not a single straight line of

 force in the human body at all!  (A straight line of force would

 correspond to some sort of jet or rocket propulseion.)

 

 

 Here's how motor-control/ proprioception will work: Each muscle is

 defined by a 1-D array of numbers (the "motor pool") each of which

 represent muscle fibers. A muscle also has a scalar :strength factor

 which determines how strong the muscle as a whole is.  The effector

 function for a muscle takes a number < (count motor-pool) and that

 number is said to "activate" all the muscle fibers whose index is

 lower than the number.  Each fiber will apply force in proportion to

 its value in the array.  Lower values cause less force.  The lower

 values can be put at the "beginning" of the 1-D array to simulate the

 layout of actual human muscles, which are capable of more percise

 movements when exerting less force.

 

 #+name: movement

 #+begin_src clojure 

 (ns cortex.movement

   "Give simulated creatures defined in special blender files the power

    to move around in a simulated environment."

   {:author "Robert McIntyre"}

   (:use (cortex world util sense body))

   (:use clojure.contrib.def)

   (:import java.awt.image.BufferedImage)

   (:import com.jme3.scene.Node)

   (:import com.jme3.math.Vector3f)

   (:import com.jme3.bullet.control.RigidBodyControl))

 

 (defn muscle-profile

   "Return a vector where each entry is the strength of the \"motor

   pool\" at that part in the muscle."

   [#^BufferedImage profile]

   (vec

    (let [width (.getWidth profile)]

      (for [x (range width)]

        (- 255

           (bit-and

            0x0000FF

            (.getRGB profile x 0)))))))

 

 (defvar 

   ^{:arglists '([creature])}

   muscles

   (sense-nodes "muscles")

   "Return the children of the creature's \"muscles\" node.")

 

 (defn movement-fn

   "Returns a function which when called with a integer value inside a

    running simulation, will cause movement in the creature according

    to the muscle's position and strength profile"

   [#^Node parts #^Node muscle]

   (let [target (closest-node parts muscle)

         axis

         (.mult (.getWorldRotation muscle) Vector3f/UNIT_Y)

         strength (meta-data muscle "strength")

         image-name (read-string (meta-data muscle "muscle"))

         image (load-image image-name)

         fibers (muscle-profile image)

         fiber-integral (reductions + fibers)

         force-index (vec

                      (map

                       #(float (* strength (/ % (last

                                                 fiber-integral))))

                       fiber-integral))

         control (.getControl target RigidBodyControl)]

     (fn [n]

       (let [pool-index (min n (count fibers))]

         (.applyTorque control (.mult axis (force-index n)))))))

 

 (defn movement!

   "Endow the creature with the power of movement. Returns a sequence

    of functions, each of which accept an integer value and will

    activate their corresponding muscle."

   [#^Node creature]

     (for [muscle (muscles creature)]

       (movement-fn creature muscle)))

 

 #+end_src

 

 

 

 

 

 * COMMENT code generation

 #+begin_src clojure :tangle ../src/cortex/movement.clj

 <<movement>>

 #+end_src