Saatgutsortenvielfalt

extensions [table]

globals [
  all-varieties                 ;; Liste aller Saatgutsorten
  variety-values                ;; Tabelle mit Marktwerten der Sorten
  extinct-ticks                 ;; speichert, wann eine Sorte ausgestorben ist

  last-company-count            ;; Unternehmensanzahl des letzten Ticks
  company-drop-log              ;; Liste der Unternehmensrückgänge mit Tick
  company-drop-data             ;; Numerische Rückgänge für Plot

  merge-count                   ;; wie oft merge durchgeführt wurde
  acquire-count                 ;; wie oft acquire durchgeführt wurde
  ally-count                    ;; wie oft ally durchgeführt wurde

  merge-ticks                   ;; Liste der Ticks, in denen merge passiert ist
  acquire-ticks                 ;; Liste der Ticks, in denen acquire passiert ist
  ally-ticks                    ;; Liste der Ticks, in denen ally passiert ist
]

turtles-own [
  seed-varieties                ;; Liste der Saatgutsorten jeder Turtle
  target-turtle                 ;; aktueller Turtle, dem die Turtle folgt
  allies                        ;; Liste der Allianzpartner (who-IDs)
  ally-until                    ;; Tick, bis zu dem die Allianz aktiv ist
]

;-----------------------------------------------------
; Setup
;-----------------------------------------------------

to setup
  clear-all
  setup-patches
  setup-all-varieties
  setup-variety-values
  setup-turtles

  set extinct-ticks table:make

  set last-company-count count turtles
  set company-drop-log []
  set company-drop-data []

  set merge-count 0
  set acquire-count 0
  set ally-count 0

  set merge-ticks []
  set acquire-ticks []
  set ally-ticks []

  reset-ticks
end 

;-----------------------------------------------------
; Patches
;-----------------------------------------------------

to setup-patches
  ask patches [ set pcolor green ]
end 

;-----------------------------------------------------
; Saatgutsorten
;-----------------------------------------------------

to setup-all-varieties
  set all-varieties [
    "X1" "X2" "X3" "X4" "X5"
    "X6" "X7" "X8" "X9" "X10"
  ]
end 

;-----------------------------------------------------
; Marktwerte zufällig festlegen
;-----------------------------------------------------

to setup-variety-values
  set variety-values table:make
  foreach all-varieties [
    variety -> table:put variety-values variety (random 10 + 1)
  ]

  clear-output
  output-print "Marktwerte der Sorten:"
  foreach all-varieties [
    variety ->
      let value table:get variety-values variety
      output-print (word variety ": " value)
  ]
end 

;-----------------------------------------------------
; Turtles erstellen
;-----------------------------------------------------

to setup-turtles
  create-turtles num-companies [
    setxy random-xcor random-ycor
    set color blue
    let n random 10 + 1
    set seed-varieties n-of n all-varieties

    set allies []

    ;; Marktwertsumme statt Anzahl anzeigen
    set label total-variety-value self

    set target-turtle one-of other turtles
  ]
end 

;-----------------------------------------------------
; Go / Hauptschleife
;-----------------------------------------------------

to go
  update-alliances
  if not any? turtles with [length seed-varieties >= min-varieties] [ stop ]
  if count turtles <= min-companies [ stop ]

  move-turtles
  interact-randomly


  ;; Label der Turtles aktualisieren
  ask turtles [
    set label total-variety-value self
  ]

  ;; Plot Sortenbesitz
  set-current-plot "Variety ownership"
  foreach all-varieties [
    variety ->
      set-current-plot-pen variety
      plot count turtles with [ member? variety seed-varieties ]
  ]
  ;; Plot Gini-Indizes
  set-current-plot "Gini Indices"

  set-current-plot-pen "market"
  plot gini-market-value

  set-current-plot-pen "variety"
  plot gini-variety-count

  set-current-plot-pen "ownership"
  plot gini-variety-ownership

  ;; Plot HHI-Indizes
  set-current-plot "HHI Indices"

  set-current-plot-pen "market"
  plot hhi-market-value

  set-current-plot-pen "variety"
  plot hhi-variety-count

  set-current-plot-pen "ownership"
  plot hhi-variety-ownership


  ;; Aussterben checken
  foreach all-varieties [
    variety ->
      if not any? turtles with [ member? variety seed-varieties ] [
        if not table:has-key? extinct-ticks variety [
          table:put extinct-ticks variety ticks
          output-print (word variety " ist ausgestorben in Tick " ticks)
        ]
      ]
  ]

  ;; Turtle stirbt
  ask turtles [
    if length seed-varieties = 0 [ die ]
  ]

  ;; Unternehmens-Rückgänge speichern
  let current-count count turtles
  if current-count < last-company-count [
  let diff (current-count - last-company-count)
  set company-drop-log lput ticks company-drop-log
  set company-drop-data lput diff company-drop-data
]
  set last-company-count current-count

  tick
end 

;-----------------------------------------------------
; Bewegung
;-----------------------------------------------------

to move-turtles
  ;; Bewege nur NICHT-alliierte Turtles
  ask turtles with [not allied?] [
    set heading random 360
    fd 1
    set color blue  ;; bewegen = blau
  ]
end 

to interact-randomly
  ask turtles [
    if allied? [ stop ]

    let partner one-of other turtles in-radius 1
    if partner = nobody [ stop ]

    ;; Wertdifferenz
    let diff abs (total-variety-value self - total-variety-value partner)

    ;; mögliche Aktionen sammeln
    let actions []
    if ally and diff <= ally_threshold and ticks > 0 [ set actions lput "ally" actions ]
    if merge and diff <= merge_threshold and ticks > 0 [ set actions lput "merge" actions ]
    if acquire and diff >= acquire_threshold and ticks > 0 [ set actions lput "acquire" actions ]


    ;; zufällig auswählen, nur wenn Liste nicht leer
    if length actions > 0 [
      let choice one-of actions
      if choice = "ally"    [ ally-with partner ]
      if choice = "merge"   [ merge-with partner ]
      if choice = "acquire" [ acquire-with partner ]
    ]
  ]
end 



;-----------------------------------------------------
; Merge-Regel
;-----------------------------------------------------

to merge-with [partner]
  set merge-count merge-count + 1
  set merge-ticks lput ticks merge-ticks

  let my-value total-variety-value self
  let other-value total-variety-value partner

  let winner self
  let loser partner
  if other-value > my-value [
    set winner partner
    set loser self
  ]

  ;; niedrigste Sorte Gewinner
  let w-vars [seed-varieties] of winner
  let w-values map [v -> table:get variety-values v] w-vars
  let w-min-value min w-values
  let w-min item (position w-min-value w-values) w-vars


  ;; höchste Sorte Verlierer
  let l-vars [seed-varieties] of loser
  let l-values map [v -> table:get variety-values v] l-vars
  let l-max-value max l-values
  let l-max item (position l-max-value l-values) l-vars


  ask winner [
    set seed-varieties remove w-min seed-varieties
    if not member? l-max seed-varieties [
      set seed-varieties lput l-max seed-varieties
    ]
  ]

  ask loser [ die ]
end 


;-----------------------------------------------------
; Acquire-Regel
;-----------------------------------------------------

to acquire-with [partner]
  set acquire-count acquire-count + 1
  set acquire-ticks lput ticks acquire-ticks

  let my-value total-variety-value self
  let other-value total-variety-value partner

  let winner self
  let loser partner
  if other-value > my-value [
    set winner partner
    set loser self
  ]

  ;; Gewinner: zwei schlechteste Sorten
  let w-sorted sort-by
    [[a b] -> table:get variety-values a < table:get variety-values b]
    ([seed-varieties] of winner)

  let low1 item 0 w-sorted
  let low2 ifelse-value (length w-sorted > 1) [ item 1 w-sorted ] [ nobody ]

  ;; Verlierer: beste Sorte
  let l-sorted sort-by
    [[a b] -> table:get variety-values b < table:get variety-values a]
    ([seed-varieties] of loser)

  let top1 item 0 l-sorted

  ask winner [
    set seed-varieties remove low1 seed-varieties
    if low2 != nobody [ set seed-varieties remove low2 seed-varieties ]
    if not member? top1 seed-varieties [
      set seed-varieties lput top1 seed-varieties
    ]
  ]

  ask loser [ die ]
end 


;-----------------------------------------------------
; Ally-Regel
;-----------------------------------------------------

to ally-with [partner]
  set ally-count ally-count + 1
  set ally-ticks lput ticks ally-ticks

  set allies (list [who] of partner)
  set ally-until ticks + ally_time

  ask partner [
    set allies (list [who] of myself)
    set ally-until ticks + ally_time
  ]

  set color yellow
  ask partner [ set color yellow ]
end 

to update-alliances
  ask turtles [
    if allied? and ticks >= ally-until [
      ;; Allianz auflösen
      let old-allies allies
      set allies []
      set ally-until -1
      set color blue  ;; eigene Farbe zurücksetzen

      ;; Partner ebenfalls auflösen
      ask turtles with [member? [who] of myself old-allies] [
        set allies []
        set ally-until -1
        set color blue
      ]
    ]

    ;; Allianz aktiv: Turtles, die stillstehen, gelb färben
    if allied? [
      set color yellow
    ]
  ]
end 


;-----------------------------------------------------
; Sorten jeder Turtle anzeigen
;-----------------------------------------------------

to show-seeds
  ask turtles [
    show (word "Turtle " who " hat Sorten: " seed-varieties)
  ]
end 

;-----------------------------------------------------
; Marktwerte anzeigen
;-----------------------------------------------------

to show-variety-values
  clear-output
  output-print "Marktwerte der Sorten:"
  foreach all-varieties [
    variety ->
      let value table:get variety-values variety
      output-print (word variety ": " value)
  ]
end 

to-report allied?
  report ally-until > ticks
end 


;--------------------------------------------------------------------------------
; REPORTER FÜR BEHAVIORSPACE
;--------------------------------------------------------------------------------

;-----------------------------------------------------
; Reporter: Lebensdauer EINER Sorte
;-----------------------------------------------------

to-report variety-binary-status [v]
  if table:has-key? extinct-ticks v [
    report 0
  ]
  report 1
end 

to-report lifespan-X1
  report (variety-binary-status "X1")
end 

to-report lifespan-X2
  report (variety-binary-status "X2")
end 

to-report lifespan-X3
  report (variety-binary-status "X3")
end 

to-report lifespan-X4
  report (variety-binary-status "X4")
end 

to-report lifespan-X5
  report (variety-binary-status "X5")
end 

to-report lifespan-X6
  report (variety-binary-status "X6")
end 

to-report lifespan-X7
  report (variety-binary-status "X7")
end 

to-report lifespan-X8
  report (variety-binary-status "X8")
end 

to-report lifespan-X9
  report (variety-binary-status "X9")
end 

to-report lifespan-X10
  report (variety-binary-status "X10")
end 

;-----------------------------------------------------
; Reporter: Darstellung aller Marktwerte
;-----------------------------------------------------

to-report marketvalues-all
  let txt ""
  foreach all-varieties [
    v -> set txt (word txt v ":" table:get variety-values v " ")
  ]
  report txt
end 


;-----------------------------------------------------
; Reporter: Bei welchem tick welche Vorgehensweise
;-----------------------------------------------------

to-report get-merge-ticks
  report merge-ticks
end 

to-report get-acquire-ticks
  report acquire-ticks
end 

to-report get-ally-ticks
  report ally-ticks
end 


;-----------------------------------------------------
; Reporter: Vorgehensweisen zählen
;-----------------------------------------------------
;; Anzahl der Merges

to-report get-merge-count
  report merge-count
end 

;; Anzahl der Acquires

to-report get-acquire-count
  report acquire-count
end 

;; Anzahl der Allianzen

to-report get-ally-count
  report ally-count
end 


;-----------------------------------------------------
; Reporter: Formatierter Text für Marktwerte
;-----------------------------------------------------

to-report formatted-variety-values
  ;; Gibt die Marktwerte aller Sorten als Textblock aus (für Monitor oder Output)
  let txt ""
  foreach all-varieties [
    v -> set txt (word txt v ": " table:get variety-values v "\n")
  ]
  report txt
end 

;-----------------------------------------------------
; Reporter: Gesamtwert aller Sorten einer Turtle
;-----------------------------------------------------

to-report total-variety-value [t]
  report sum map [v -> table:get variety-values v] ([seed-varieties] of t)
end 


;-----------------------------------------------------
; Reporter: Anzahl Firmen pro Sorte
;-----------------------------------------------------

to-report variety-ownership-summary
  let output ""
  foreach all-varieties [
    v -> set output (word output v ": " count turtles with [member? v seed-varieties] " | ")
  ]
  report substring output 0 (length output - 3)
end 

;-----------------------------------------------------
; Reporter: Wie viele Firmen haben Sorte X?
;-----------------------------------------------------

to-report count-companies-with [variety-name]
  report count turtles with [member? variety-name seed-varieties]
end 

;-----------------------------------------------------
; Reporter: Unternehmensrückgänge
;-----------------------------------------------------

to-report get-company-drop-log
  report company-drop-log
end 

;-----------------------------------------------------
; Reporter: Anzahl überlebender Unternehmen
;-----------------------------------------------------

to-report surviving-companies
  report count turtles
end 

;-----------------------------------------------------
; Reporter: Anzahl aktuell existierender Sorten
;-----------------------------------------------------

to-report number-of-all-varieties
  report length filter [
    v -> any? turtles with [member? v seed-varieties]
  ] all-varieties
end 


;-----------------------------------------------------
; Reporter: Marktwerte aller Sorten
;-----------------------------------------------------

to-report variety-values-list
  let output []
  foreach all-varieties [
    v -> set output lput (list v table:get variety-values v) output
  ]
  report output
end 


;-----------------------------------------------------
; Reporter: Gini-Index
;-----------------------------------------------------

to-report gini [values]
  ;; Leere oder triviale Fälle abfangen
  if length values = 0 [ report 0 ]
  if sum values = 0 [ report 0 ]

  let sorted sort values
  let n length sorted
  let total sum sorted

  let cum-weighted-sum 0
  let i 1

  foreach sorted [
    v ->
    set cum-weighted-sum cum-weighted-sum + (i * v)
    set i i + 1
  ]

  ;; Standard-Gini-Formel
  report ( (2 * cum-weighted-sum) / (n * total) ) - ( (n + 1) / n )
end 

to-report gini-market-value
  report precision (gini [ total-variety-value self ] of turtles) 2
end 

to-report gini-variety-count
  report precision (gini [ length seed-varieties ] of turtles) 2
end 

to-report gini-variety-ownership
  let counts []
  foreach all-varieties [
    v ->
    set counts lput (count turtles with [member? v seed-varieties]) counts
  ]
  report precision (gini counts) 2
end 

;-----------------------------------------------------
; Herfindahl-Hirschman-Index (HHI)
;-----------------------------------------------------

to-report hhi [values]
  ;; Leere Liste oder Summe=0 abfangen
  if length values = 0 [ report 0 ]
  let total sum values
  if total = 0 [ report 0 ]

  ;; relative Marktanteile berechnen
  let shares map [v -> v / total] values

  ;; HHI = Summe der Quadrate der Anteile
  report sum map [v -> v * v] shares
end 

;-----------------------------------------------------
; HHI der Firmen nach Marktwert
;-----------------------------------------------------

to-report hhi-market-value
  report precision (hhi [ total-variety-value self ] of turtles) 2
end 

;-----------------------------------------------------
; HHI nach Anzahl Sorten pro Firma (Verteilung der Vielfalt)
;-----------------------------------------------------

to-report hhi-variety-count
  report hhi [ length seed-varieties ] of turtles
end 

;-----------------------------------------------------
; HHI der Sortenverbreitung im Markt (Marktdominanz von Sorten)
;-----------------------------------------------------

to-report hhi-variety-ownership
  let counts []
  foreach all-varieties [
    v -> set counts lput (count turtles with [member? v seed-varieties]) counts
  ]
  report hhi counts
end