Colisão Única

globals
[
  tick-delta                      ;; how much we advance the tick counter this time through
  max-tick-delta                  ;; the largest tick-delta is allowed to be
  plot-clock                      ;; keeps track of the x-axis for the plot
  avg-speed                       ;; average speed of the two particles
  total-energy                    ;; total energy of the two particles
  x-center y-center               ;; coordinates of center of mass
  done?                           ;; becomes true when one particles is about to 'leave' the world
  after-collision?                ;; for graphing purposes
]

breed [ particles particle ]
breed [ centers-of-mass center-of-mass ]

particles-own
[
  speed mass energy                ;; particle variables
  last-collision
]

to setup
  clear-all
  set-default-shape particles "circle"
  set-default-shape centers-of-mass "x"
  set done? false
  set max-tick-delta 0.1073
  set after-collision? false
  make-particles
  create-centers-of-mass 1
    [ set size 3 ]
  update-variables
  clear-drawing  ;; erase the line made by initially moving the center of mass
  reset-ticks
end 

to update-variables
  let total-mass sum [mass] of particles
  set x-center (sum [ xcor * mass ] of particles) / total-mass
  set y-center (sum [ ycor * mass ] of particles) / total-mass
  set avg-speed  mean [speed] of particles
  set total-energy sum [energy] of particles
  ask centers-of-mass
  [
    ifelse mostrar-centro-da-massa?                         ;; marks a gray path along the particles' center of mass
      [ show-turtle
        pen-down ]
      [ hide-turtle
        pen-up ]
    setxy x-center y-center
  ]
end 

to go
  ask particles [ move ]

  ask particles                                   ;;  each particle checks if it's on the same patch as the other
  [ check-for-collision ]
  update-variables
  calculate-tick-delta
  tick-advance tick-delta
  display
  update-plots
end 

to go-mode

if modo-de-iniciaçao = "colisao-unica"  [go-once stop]
if modo-de-iniciaçao = "todos-angulos-colisao" [all-angulo-colisaos]
if modo-de-iniciaçao = "todos-angulos-reflexao" [all-angulo-reflexaos]
end 

to go-once                                          ;; a single collision
  setup
  while [ not done? ]
  [ go
    ask particles
    [ if not can-move? 1
      [ set done? true ]
    ]
  ]
end 

to all-angulo-colisaos                            ;; activated when the reflection angle is constant and the collision angle is varied
  go-once
  ifelse angulo-colisao >= 345
    [ set angulo-colisao 15 ]
    [ set angulo-colisao angulo-colisao + 15 ]
end 

to all-angulo-reflexaos                           ;; activated when the collision angle is constant and the reflection angle is varied
  go-once
  set angulo-reflexao angulo-reflexao + 15
  if angulo-reflexao = 360
  [ set angulo-reflexao 0 ]
end 

to calculate-tick-delta
  ;; tick-delta is calculated in such way that even the fastest
  ;; particle will jump at most 1 patch length in a tick. As
  ;; particles jump (speed * tick-delta) at every tick, making
  ;; tick length the inverse of the speed of the fastest particle
  ;; (1/max speed) assures that. Having each particle advance at most
  ;; one patch-length is necessary for them not to "jump over" each
  ;; other without colliding.
  ifelse any? particles with [speed > 0]
    [ set tick-delta min list (1 / (ceiling max [speed] of particles)) max-tick-delta ]
    [ set tick-delta max-tick-delta ]
end 

to move  ;; particle procedure
  jump (speed * tick-delta)
end 

to check-for-collision  ;; particle procedure
  if count other particles-here = 1
  [
    ;; the following conditions are imposed on collision candidates:
    ;;   1. they must have a lower who number than my own, because collision
    ;;      code is asymmetrical: it must always happen from the point of view
    ;;      of just one particle.
    ;;   2. they must not be the same particle that we last collided with on
    ;;      this patch, so that we have a chance to leave the patch after we've
    ;;      collided with someone.
    let candidate one-of other particles-here with
      [who < [who] of myself and myself != last-collision]
    ;; we also only collide if one of us has non-zero speed. It's useless
    ;; (and incorrect, actually) for two particles with zero speed to collide.
    if (candidate != nobody) and (speed > 0 or [speed] of candidate > 0)
    [
      collide-with candidate
      set last-collision candidate
      ask candidate [ set last-collision myself ]
      set after-collision? true
    ]
  ]
end 

;; implements a collision with another particle.
;;
;; THIS IS THE HEART OF THE PARTICLE SIMULATION, AND YOU ARE STRONGLY ADVISED
;; NOT TO CHANGE IT UNLESS YOU REALLY UNDERSTAND WHAT YOU'RE DOING!
;;
;; The two particles colliding are self and other-particle, and while the
;; collision is performed from the point of view of self, both particles are
;; modified to reflect its effects. This is somewhat complicated, so I'll
;; give a general outline here:
;;   1. Do initial setup, and determine the heading between the reflected particles
;;      (call it theta).
;;   2. Convert the representation of the velocity of each particle from
;;      speed/heading to a theta-based vector whose first component is the
;;      particle's speed along theta, and whose second component is the speed
;;      perpendicular to theta.
;;   3. Modify the velocity vectors to reflect the effects of the collision.
;;      This involves:
;;        a. computing the velocity of the center of mass of the whole system
;;           along direction theta
;;        b. updating the along-theta components of the two velocity vectors.
;;   4. Convert from the theta-based vector representation of velocity back to
;;      the usual speed/heading representation for each particle.
;;   5. Perform final cleanup and update derived quantities.

to collide-with [ other-particle ] ;; particle procedure
  ;;; PHASE 1: initial setup

  ;; for convenience, grab some quantities from other-particle
  let mass2 [mass] of other-particle
  let speed2 [speed] of other-particle
  let heading2 [heading] of other-particle

  ;; since particles are modeled as zero-size points, theta isn't meaningfully
  ;; defined. we can assign it randomly without affecting the model's outcome.
  let theta angulo-reflexao

  ;;; PHASE 2: convert velocities to theta-based vector representation

  ;; now convert my velocity from speed/heading representation to components
  ;; along theta and perpendicular to theta
  let v1t (speed * cos (theta - heading))
  let v1l (speed * sin (theta - heading))

  ;; do the same for other-particle
  let v2t (speed2 * cos (theta - heading2))
  let v2l (speed2 * sin (theta - heading2))



  ;;; PHASE 3: manipulate vectors to implement collision

  ;; compute the velocity of the system's center of mass along theta
  let vcm (((mass * v1t) + (mass2 * v2t)) / (mass + mass2) )

  ;; now compute the new velocity for each particle along direction theta.
  ;; velocity perpendicular to theta is unaffected by a collision along theta,
  ;; so the next two lines actually implement the collision itself, in the
  ;; sense that the effects of the collision are exactly the following changes
  ;; in particle velocity.
  set v1t (2 * vcm - v1t)
  set v2t (2 * vcm - v2t)



  ;;; PHASE 4: convert back to normal speed/heading

  ;; now convert my velocity vector into my new speed and heading
  set speed sqrt ((v1t ^ 2) + (v1l ^ 2))
  set energy (0.5 * mass * speed ^ 2)
  ;; if the magnitude of the velocity vector is 0, atan is undefined. but
  ;; speed will be 0, so heading is irrelevant anyway. therefore, in that
  ;; case we'll just leave it unmodified.
  if v1l != 0 or v1t != 0
    [ set heading (theta - (atan v1l v1t)) ]

  ;; and do the same for other-particle
  ask other-particle [
    set speed sqrt ((v2t ^ 2) + (v2l ^ 2))
    set energy (0.5 * mass * (speed ^ 2))
    if v2l != 0 or v2t != 0
      [ set heading (theta - (atan v2l v2t)) ]
  ]
end 

to recolor  ;; particle procedure
  ifelse speed < (0.5 * 10)
  [
    set color blue + 2
  ]
  [
    ifelse speed > (1.5 * 10)
      [ set color red ]
      [ set color green ]
  ]
end 

;; creates initial particles

to make-particles
  create-particles 1 [
    set color pink
    set speed velocidade-inicial-rosa
    set mass massa-rosa
    set heading 180
    bk 2 * speed
  ]
  create-particles 1 [
    set color blue
    set speed velocidade-inicial-azul
    set mass massa-azul
    set heading 180 + angulo-colisao
    bk 2 * speed
  ]
  ask particles
  [
    setup-particle
  ]
  calculate-tick-delta
end 

to setup-particle  ;; particle procedure
  pen-down
  set size 2
  set energy (0.5 * mass * speed ^ 2 )
  set last-collision nobody
end 


; Copyright 1997 Uri Wilensky.
; See Info tab for full copyright and license.