Evolution of Gamete Dimorphism (Anisogamy)

globals [
  average-lifetime       ; the average lifetime of adults, used to pick a random lifetime for each adult and gamete when they are born
]

breed [adults adult]
breed [gametes gamete]   ; gametes are produced by adults for reproductive purposes
breed [zygotes zygote]   ; a zygote forms when two gametes fuse. they then incubate and grow into adults
breed [dead-zygotes dead-zygote] ; this pseudo-breed is used to visualize zygote deaths

adults-own [
  mating-type        ; this variable denotes the pseudo-sex of each adult, either red or yellow
  gamete-size        ; each adult has its own evolutionary strategy for the gamete size, which is a decimal number
  remaining-lifetime ; adults have limited lifetimes
]

zygotes-own [
  mating-type
  gamete-size
  remaining-incubation-time  ; zygotes have to incubate (approximately adult life / 5) before turning into adults or dying
]

gametes-own [
  mating-type
  remaining-lifetime   ; gametes have limited lifetime, too (approximately adult life / 10)
]

to setup
  clear-all

  ; create the blue background that represents a marine environment
  ask patches [ set pcolor 87 + random 5 - random 5 ]
  repeat 20 [ diffuse pcolor 0.25 ]

  ; initialize global variables
  set average-lifetime 500

  ; create the initial adult population
  create-adults population-size [
    set shape "adult"
    setxy random-xcor random-ycor

    ; choose the mating type randomly and change the color accordingly
    set mating-type one-of [ red blue ]
    set color mating-type

    ; all adults begin with the same gamete size strategy, which is the reproduction budget / 2.
    set gamete-size (size * gamete-production-budget) / 200

    ; adult lifetime is drawn from a normal distribution with a standard deviation that is 1/10th of the average lifetime.
    set remaining-lifetime round (random-normal average-lifetime (average-lifetime / 10))
  ]

  reset-ticks
end 

to go

  let my-speed 1 ; the default speed for all agents

  ask adults[
    if adults-move? [
      wiggle-and-move my-speed
    ]
    maybe-produce-gametes
    age-and-maybe-die
  ]

  ask gametes [
    if speed-size-relation? [
      set my-speed precision (gamete-production-budget / (size)) 2
    ]
    wiggle-and-move my-speed
    maybe-fuse
    age-and-maybe-die
  ]

  ask zygotes [
    incubate
  ]

  ask dead-zygotes[
    slowly-disappear
  ]

  enforce-carrying-capacity
  tick
end 

;;;; gamete & adult procedure
;;;;   simulates a random walk

to wiggle-and-move [ my-speed ]
  rt random 360
  fd my-speed
end 

;;;; gamete and adult procedure
;;;;   counts down the remaining lifetime of an agent and asks it to die when it has no lifetime remaining

to age-and-maybe-die
    set remaining-lifetime remaining-lifetime - 1
    if remaining-lifetime < 1 [ die ]
end 


;;;; adult procedure
;;;;   produces gametes at random times and passes down the gamete-size strategy with the chance of a small mutation

to maybe-produce-gametes

  ; the probability of an adult producing new gametes at each tick
  let gamete-production-probability 1.5
  ; dictates the maximum number of decimal places in the gamete size, hence limits the minimum gamete size
  let gamete-size-sensitivity 2

  if random-float 100 < gamete-production-probability [

    ; introduce a small random mutation to the gamete size for the current reproduction cycle
    let inherited-gamete-size precision (random-normal gamete-size mutation-stdev) gamete-size-sensitivity

    if inherited-gamete-size > 0 [
      ; determine the number of gametes that you will produce in the current reproduction cycle
      let number-of-gametes floor (((size * gamete-production-budget) / 100) / inherited-gamete-size)

      ; the hatch primitive automatically passes down the basic properties such as the mating type and the color
      hatch-gametes number-of-gametes [
        set size inherited-gamete-size
        set shape "default"
        set remaining-lifetime round (random-normal (average-lifetime / 10) (average-lifetime / 100))
      ]
    ]
  ]
end 


;;;; gamete procedure
;;;;   if a gamete touches another gamete, they fuse and hatch a zygote
;;;;   the hatched zygote inherits the mating type and gamete-size strategies from one of the gametes randomly

to maybe-fuse
  if any? other gametes-here [
    ; because there might be multiple other gametes on the same patch, choose one of them to be your partner randomly.

    let mating-partner nobody
    ; if same type mating is allowed, any gametes here are possible mates
    ifelse same-type-mating-allowed? [
      set mating-partner one-of other gametes-here
    ]
    [ ; otherwise, we only consider gametes of a different type
      set mating-partner one-of other gametes-here with [ mating-type != [ mating-type ] of myself ]
    ]

    if mating-partner != nobody [
      ; pool the mating type and gamete size strategies that are inherited from both gametes
      let mating-type-pool list (mating-type) ([ mating-type ] of mating-partner)
      let gamete-size-pool list (size) ([ size ] of mating-partner)

      ; choose one of the parent strategies randomly
      let inherited-strategy random 2

      ; fuse into a zygote that has the combined size of the two gametes
      hatch-zygotes 1 [
        set gamete-size (item inherited-strategy gamete-size-pool)
        set mating-type (item inherited-strategy mating-type-pool)
        set color (mating-type + 3)
        set size (sum (gamete-size-pool) * 2)
        set shape "zygote"
        ; incubation time is drawn from a normal distribution
        set remaining-incubation-time round (random-normal (average-lifetime / 5) (average-lifetime / 50))
      ]

      ; after the zygote is hatched, the gametes are both taken out of the system
      ask mating-partner [ die ]
      die
    ]
  ]
end 


;;;; zygote procedure
;;;;   counts down the incubation time, and then turns into an adult if the critical mass is achieved
;;;;   if critical mass is not achieved and ENFORCE-CRITICAL-MASS? is ON, the zygote turns into a dead zygote

to incubate
    set remaining-incubation-time remaining-incubation-time - 1

    if remaining-incubation-time < 1 [
      if enforce-critical-mass? [
        if (size / 2) < zygote-critical-mass [
          hatch-dead-zygotes 1 [
            set size 1
            set shape "zygote"
            set color black
          ]
          die
        ]
      ]

      set breed adults
      set color mating-type
      set shape "adult"
      set size 1
      set remaining-lifetime round (random-normal average-lifetime (average-lifetime / 10))
    ]
end 

;;;; dead zygote procedure
;;;;   dead zygotes slowly shrink and then die when it's time

to slowly-disappear
  set size size - 0.05
  if size < 0.1 [ die ]
end 

;;;; observer procedure
;;;;   ensures that the adult population does not exceed the carrying capacity of the system

to enforce-carrying-capacity
  if count adults > population-size [
    ask n-of (count adults - population-size) adults [ die ]
  ]
  ; if there aren't multiple adults left, stop the model
  if count adults < 2 [ stop ]
end 

;;;; interface procedure
;;;;   allows the user to follow a randomly chosen gamete
;;;;   as the gametes in the model are too small to see

to follow-a-gamete [col]
  if not netlogo-web? [
    ifelse any? gametes with [ color = col and remaining-lifetime > average-lifetime / 12 ] [
      stop-inspecting-dead-agents
      let target-gamete one-of gametes with [ color = col and remaining-lifetime > average-lifetime / 12 ]
      inspect target-gamete
      watch target-gamete
    ][
      user-message "There are no more gametes to follow!"
    ]
  ]
end 


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