The Garbage Can Model of Organizational Choice

;; THE GARBAGE CAN MODEL




;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; Variables declaration ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
globals [
          ;; Agents available for decision-making
          free-participants ;; cumulative number of non-blocked participants
          ave-free-participants ;; average number of non-blocked participants
          free-opportunities ;; cumulative number of non-blocked opportunities
          ave-free-opportunities ;; average number of non-blocked opportunities
          free-solutions ;; cumulative number of non-blocked solutions
          ave-free-solutions ;; average number of non-blocked solutions
          free-problems ;; cumulative number of non-blocked problems
          ave-free-problems ;; average number of non-blocked problems
          
          ;; Kinds of decision-making and kinds of flights.
          num-oversight ;; cumulative number of decisions by oversight
          num-blocked-oversight ;; cumulative number of decisions by oversight following a blocked decision process
          num-resolution ;; cumulative number of decisions by resolution
          num-blocked-resolution ;; cumulative number of decisions by resolution following a blocked decision process
          num-postponement ;; cumulative number of flights by postponement
          num-buck-passing ;; cumulative number of flights by buck-passing
          
          ;; Blocked decisions, postponed problems, passed problems.
          num-blocked ;; cumulative number of blocked decision processes
          ave-num-blocked ;; average number of blocked decision processes
          size-blocked ;; cumulative size of blocked decision processes
          ave-size-blocked ;; average size of blocked decision processes
          life-blocked ;; cumulative lives of blocked decision processes
          ave-life-blocked ;; average life of blocked decision processes
          num-postponed ;; cumulative number of postponed problems
          ave-num-postponed ;; average number of postponed problems
          life-postponed ;; cumulative lives of pairs opportunity-problem
          ave-life-postponed ;; average life of pairs opportunity-problem
          num-passed ;; cumulative number of passed problems
          ave-num-passed ;; average number of passed problems
          life-passed ;; cumulative lives of pairs participant-problem
          ave-life-passed ;; average life of pairs participant-problem
          
          ;; The counters of meetings with already-met opportunities, solutions and problems.
          meetings-known-opp
          meetings-opp
          meetings-known-sol
          meetings-sol
          meetings-known-pro
          meetings-pro
          
          ;; These are necessary in order to impose decision structure and access structure.
          arrivals-departures_par ;; the number of arrivals minus the number of departures of participants
          arrivals-departures_opp ;; the number of arrivals minus the number of departures of opportunities
          arrivals-departures_sol ;; the number of arrivals minus the number of departures of solutions
          arrivals-departures_pro ;; the number of arrivals minus the number of departures of problems
          
          ;; Indicators of decision-making by oversight and resolution at different hierarchical levels.
          countOveHigh ;; the number of oversights making use of opportunities at high hierarchical levels
          countOveLow ;; the number of oversights making use of opportunities at low hierarchical levels
          countResHigh ;; the number of resolutions making use of opportunities at high hierarchical levels
          countResLow ;; the number of resolutions making use of opportunities at low hierarchical levels          
        ]
patches-own [pcolor-white-since] ;; since when it hosts a blocked decision process
turtles-own [blocked?] ;; whether an agent is allowed to move
breed [solution]
breed [opportunity]
breed [participant]
breed [problem] 
participant-own [ participant_id ;; the identification number of participants
                  ability ;; the ability of participants
                  charged? ;; eventually, this participant is charged...
                  with-problem ;; ...with this problem
                  encountered ;; the agents this participant has already met
                ]
opportunity-own [ opportunity_id ;; the identification number of opportunities
                  charged? ;; eventually, this opportunity is charged...
                  with-problem ;; ...with this problem
                ]
solution-own [ solution_id ;; the identification number of solutions
               efficiency ;; the efficiency of solutions
             ] 
problem-own [ problem_id ;; the identification number of problems
              difficulty ;; the difficulty of problems
              postponed? ;; eventually, this problem has been postponed...
              to-opportunity ;; ...to this opportunity
              passed? ;; eventually, this problem has been passed...
              to-participant ;; ...to this participant
              since ;; when the flight began
            ]
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;







;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;; What is done when the "Setup" button is pressed ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

to setup 
  clear-all
  reset-ticks  
  
  ;; Initializes the counters of the variations of the number of agents.
  set arrivals-departures_par 0
  set arrivals-departures_opp 0
  set arrivals-departures_sol 0
  set arrivals-departures_pro 0
  
  ;; Initializes the counters of agents avaiilable for decision-making.
  set free-participants 0
  set free-opportunities 0
  set free-solutions 0
  set free-problems 0
  
  ;; Initializes the number of kinds of decision-making and flights.
  set num-oversight 0
  set num-blocked-oversight 0
  set num-resolution 0
  set num-blocked-resolution 0
  set num-postponement 0
  set num-buck-passing 0

  ;; Initializes the number of blocked decisions, the number of postponed problems and the number of passed problems.
  set num-blocked 0
  set size-blocked 0
  set life-blocked 0
  set num-postponed 0
  set life-postponed 0
  set num-passed 0
  set life-passed 0

  ;; Initializes the counters of the meetings with opportunities, solutions and problems that had already been met.
  set meetings-known-opp 0
  set meetings-opp 0
  set meetings-known-sol 0
  set meetings-sol 0
  set meetings-known-pro 0
  set meetings-pro 0
  
  ;; Initializes the counters of oversights and resolutions at high and low hierarchical levels.
  ifelse (opportunities-exit? and (decision-structure != "anarchy" or availability-structure != "anarchy" or access-structure != "anarchy")) [
    set countOveHigh 0
    set countOveLow 0
    set countResHigh 0
    set countResLow 0
  ] [
    set countOveHigh "N/A"
    set countOveLow "N/A"
    set countResHigh "N/A"
    set countResLow "N/A"
  ]
  
  ;; Initializes the counter of how long a decision process stays blocked.
  ask patches
    [set pcolor-white-since 0]

  ;; Creates the agents that are initially present in the organization.
  set-default-shape participant "participant"
  create-participant initial-participants  ;; creates the participants and initializes their variables
  [ 
    setxy random world-width random world-height
    set blocked? false
    set charged? false
    set with-problem nobody
    set participant_id who
    set encountered []
  ]
  set-default-shape opportunity "opportunity"
  create-opportunity initial-opportunities  ;; creates the choice opportunities and initializes their variables
  [ 
    setxy random world-width random world-height
    set blocked? false
    set charged? false
    set with-problem nobody
    set opportunity_id (who - initial-participants)
  ]
  set-default-shape solution "solution"
  create-solution initial-solutions  ;; creates the solutions and initializes their variables
  [ 
    setxy random world-width random world-height
    set blocked? false
    set solution_id (who - initial-participants - initial-opportunities)
  ]
  set-default-shape problem "problem"
  create-problem initial-problems  ;; creates the problems and initializes their variables
  [ 
    setxy random world-width random world-height
    set blocked? false
    set postponed? false
    set to-opportunity nobody
    set passed? false
    set to-participant nobody
    set since 0
    set problem_id (who - initial-participants - initial-opportunities - initial-solutions)
  ]
  
  ;; Participants and problems are endowed with energy, solutions are endowed with efficiency
  assign-ability
  assign-difficulty
  assign-efficiency
end 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;












;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; What is done when the "Go Step" button is pressed and what is repeated at each step when the "Go Until" button is pressed
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

to go







  ;;;;;;;;;;;;;;;;;;;;;; MISCELLANEOUS
        
  ;; The number of ticks is updated. Eventually, the simulation is stopped.
  tick
  if ((stop-at > 0) and (ticks = stop-at)) [
    if (show-details?)
      [write-survivors]
    stop
  ]
  
  ;; Eventually, labels are depicted near the agents. Labels show participants' ability, solutions' efficiency and problems' difficulty, respectively.
  if (show-details?)
    [show-labels]




  
  
  
  
  
  ;;; THE SIMULATION IS NOT ALLOWED TO BEGIN IF MINIMUM VALUES OF ABILITY, EFFICIENCY AND DIFFICULTY ARE GREATER THAN THE CORRESPONDING MAXIMUM VALUES

  if (min-ability > max-ability) [
    type "MINIMUM ABILITY SHOULD NOT BE GREATER THAN MAXIMUM ABILITY"
    stop
  ]
  if (min-efficiency > max-efficiency) [
    type "MINIMUM EFFICIENCY SHOULD NOT BE GREATER THAN MAXIMUM EFFICIENCY"
    stop
  ]
  if (min-difficulty > max-difficulty) [
    type "MINIMUM DIFFICULTY SHOULD NOT BE GREATER THAN MAXIMUM DIFFICULTY"
    stop
  ]












  ;;;;;;;;;;;;;;; ABILITY, EFFICIENCY AND DIFFICULTY MAY NEED TO BE ASSIGNED AGAIN
  
  ;; If ability, efficiency and difficulty are distributed according to the numbering of agents (competence or incompetence)
  ;; and if some participants, problems or solutions exit, then ability, efficiency and difficulty must be re-distributed to all of them.
  ;; Note that this may impact on the number of flights, since blocked agents may be assigned new values of ability, efficiency or difficulty.

  if ((dist-ability = "competence" or dist-ability = "incompetence") and participants-exit?) [
    assign-ability
  ]
  if ((dist-efficiency = "competence" or dist-efficiency = "incompetence") and solutions-exit?) [
    assign-efficiency
  ]
  if ((dist-difficulty = "competence" or dist-difficulty = "incompetence") and problems-exit?) [
    assign-difficulty
  ]











;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; DECISION - MAKING

  ;; Though decisions are made by participants, it is more convenient to let patches operate.
  ask patches [
    ;; Resets the world on black, except flying couples.
    ifelse (any? problem-here with [postponed? or passed?])
      [set pcolor brown] [
        if (pcolor != white)
          [set pcolor black]
      ]
    ;; If there is at least one participant, one choice opportunity and one solution, then a decision is made.
    if (any? participant-here and any? opportunity-here and any? solution-here) [
      ;; Agents paired because of a flight enter the decision process on equal status with the others.
      ask participant-here [
        if (charged?) [
          set charged? false
          set with-problem nobody
        ]
      ]
      ask opportunity-here [
        if (charged?) [
          set charged? false
          set with-problem nobody
        ]
      ]
      ask problem-here [
        if (postponed?) [
          set postponed? false
          set to-opportunity nobody
        ]
        if (passed?) [
          set passed? false
          set to-participant nobody
        ]
      ]
      ;; If there are problems as well, either they are resolved if their ability is sufficient or all agents stay put until another opportunity or another participant passes by and takes a problem away.
      ifelse (any? problem-here) [
        ;; If the sum of the ability of all participants on a patch, multiplied by the efficiency of the most efficient solution on the
        ;; same patch, is greater or equal than the sum of the difficulty of all problems on the same patch, then decisions are made by resolution.
        ifelse ((sum [ability] of participant-here)*([efficiency] of max-one-of solution-here [efficiency]) >= (sum [difficulty] of problem-here)) [
          set num-resolution num-resolution + 1
          ;; A decision by resolution is marked by a green square. The counters of the life of blocked decisions and flying pairs are reset.
          if (pcolor = white)
            [set num-blocked-resolution num-blocked-resolution + 1]
          set pcolor lime
          set pcolor-white-since 0
          ask problem-here [set since 0]
          ;; Write information on the control center.
          if (show-details?)
            [write-resolutions]
          ;; The indicators of the percentages of resolutions on low and high hierarchical levels.
          let chosenOppRes one-of opportunity-here
          if (opportunities-exit? and (decision-structure != "anarchy" or availability-structure != "anarchy" or access-structure != "anarchy")) [ 
            ifelse ([opportunity_id] of chosenOppRes < (count opportunity) * 0.5)
              [set countResHigh countResHigh + 1]
              [set countResLow countResLow + 1]
          ]
          ;; If participants exit after a decision is made, all participants on the patch are killed.
          if (participants-exit?) [
            kill participant-here
          ]
          ;; If opportunities exit after a decision is made, one of the opportunities that are on the patch is picked up and killed.
          if (opportunities-exit?) [
            kill chosenOppRes
          ]
          ;; If solutions exit after a decision is made, the most efficient solution on the patch is killed.
          if (solutions-exit?) [
            kill max-one-of solution-here [efficiency]
          ]
          ;; If problems exit after a decision is made, all problems on the patch are killed.
          if (problems-exit?) [
            kill problem-here
          ]
          ;; If there are still agents on the patch, they must be free to move. This is not obvious, because they may stem from a flight.
          ask turtles-here [
            if (blocked?) [set blocked? false]
          ]
        ]
        ;; If the ability of the participants is not sufficient to make a decision, all agents on the patch are blocked.
        ;; Eventually, a flight might enable the remaining agents to make a decision either by resolution or by oversight.
        [
          ask turtles-here [set blocked? true]
          ;; A blocked decision process is marked by a white square.
          if (pcolor != white) [
            set pcolor white
            set pcolor-white-since ticks
          ]
          ;; Eventually, a flight by postponement takes place.
          ifelse (postpone? and count opportunity-here > 1) [
            ;; An opportunity and a problem are chosen to be paired to one another.
            let which-opportunity max-one-of opportunity-here [opportunity_id]
            let which-problem-for-opportunity max-one-of problem-here [difficulty]
            ;; Checks that there is at least one place to which the chosen opportunity can move.
            if (
                (decision-structure = "anarchy" and access-structure = "anarchy" and availability-structure = "anarchy") or

                (decision-structure = "anarchy" and access-structure = "anarchy" and (availability-structure = "hierarchy" and not any? (solution-on patch-at 1 0) with [solution_id > [opportunity_id] of which-opportunity])) or   
                (decision-structure = "anarchy" and access-structure = "anarchy" and (availability-structure = "hierarchy" and not any? (solution-on patch-at 0 1) with [solution_id > [opportunity_id] of which-opportunity])) or   
                (decision-structure = "anarchy" and access-structure = "anarchy" and (availability-structure = "hierarchy" and not any? (solution-on patch-at -1 0) with [solution_id > [opportunity_id] of which-opportunity])) or   
                (decision-structure = "anarchy" and access-structure = "anarchy" and (availability-structure = "hierarchy" and not any? (solution-on patch-at 0 -1) with [solution_id > [opportunity_id] of which-opportunity])) or   

                (decision-structure = "anarchy" and (access-structure = "hierarchy" and not any? (problem-on patch-at 1 0) with [problem_id > [opportunity_id] of which-opportunity]) and availability-structure = "anarchy") or
                (decision-structure = "anarchy" and (access-structure = "hierarchy" and not any? (problem-on patch-at 0 1) with [problem_id > [opportunity_id] of which-opportunity]) and availability-structure = "anarchy") or
                (decision-structure = "anarchy" and (access-structure = "hierarchy" and not any? (problem-on patch-at -1 0) with [problem_id > [opportunity_id] of which-opportunity]) and availability-structure = "anarchy") or
                (decision-structure = "anarchy" and (access-structure = "hierarchy" and not any? (problem-on patch-at 0 -1) with [problem_id > [opportunity_id] of which-opportunity]) and availability-structure = "anarchy") or

                ((decision-structure = "hierarchy" and not any? (participant-on patch-at 1 0) with [participant_id > [opportunity_id] of which-opportunity]) and access-structure = "anarchy" and availability-structure = "anarchy") or
                ((decision-structure = "hierarchy" and not any? (participant-on patch-at 0 1) with [participant_id > [opportunity_id] of which-opportunity]) and access-structure = "anarchy" and availability-structure = "anarchy") or
                ((decision-structure = "hierarchy" and not any? (participant-on patch-at -1 0) with [participant_id > [opportunity_id] of which-opportunity]) and access-structure = "anarchy" and availability-structure = "anarchy") or
                ((decision-structure = "hierarchy" and not any? (participant-on patch-at 0 -1) with [participant_id > [opportunity_id] of which-opportunity]) and access-structure = "anarchy" and availability-structure = "anarchy") or


                ((decision-structure = "hierarchy" and not any? (participant-on patch-at 1 0) with [participant_id > [opportunity_id] of which-opportunity]) and (access-structure = "hierarchy" and not any? (problem-on patch-at 1 0) with [problem_id > [opportunity_id] of which-opportunity]) and availability-structure = "anarchy") or
                ((decision-structure = "hierarchy" and not any? (participant-on patch-at 0 1) with [participant_id > [opportunity_id] of which-opportunity]) and (access-structure = "hierarchy" and not any? (problem-on patch-at 0 1) with [problem_id > [opportunity_id] of which-opportunity]) and availability-structure = "anarchy") or
                ((decision-structure = "hierarchy" and not any? (participant-on patch-at -1 0) with [participant_id > [opportunity_id] of which-opportunity]) and (access-structure = "hierarchy" and not any? (problem-on patch-at -1 0) with [problem_id > [opportunity_id] of which-opportunity]) and availability-structure = "anarchy") or
                ((decision-structure = "hierarchy" and not any? (participant-on patch-at 0 -1) with [participant_id > [opportunity_id] of which-opportunity]) and (access-structure = "hierarchy" and not any? (problem-on patch-at 0 -1) with [problem_id > [opportunity_id] of which-opportunity]) and availability-structure = "anarchy") or

                (decision-structure = "anarchy" and (access-structure = "hierarchy" and not any? (problem-on patch-at 1 0) with [problem_id > [opportunity_id] of which-opportunity]) and (availability-structure = "hierarchy" and not any? (solution-on patch-at 1 0) with [solution_id > [opportunity_id] of which-opportunity])) or
                (decision-structure = "anarchy" and (access-structure = "hierarchy" and not any? (problem-on patch-at 0 1) with [problem_id > [opportunity_id] of which-opportunity]) and (availability-structure = "hierarchy" and not any? (solution-on patch-at 0 1) with [solution_id > [opportunity_id] of which-opportunity])) or
                (decision-structure = "anarchy" and (access-structure = "hierarchy" and not any? (problem-on patch-at -1 0) with [problem_id > [opportunity_id] of which-opportunity]) and (availability-structure = "hierarchy" and not any? (solution-on patch-at -1 0) with [solution_id > [opportunity_id] of which-opportunity])) or
                (decision-structure = "anarchy" and (access-structure = "hierarchy" and not any? (problem-on patch-at 0 -1) with [problem_id > [opportunity_id] of which-opportunity]) and (availability-structure = "hierarchy" and not any? (solution-on patch-at 0 -1) with [solution_id > [opportunity_id] of which-opportunity])) or

                ((decision-structure = "hierarchy" and not any? (participant-on patch-at 1 0) with [participant_id > [opportunity_id] of which-opportunity]) and access-structure = "anarchy" and (availability-structure = "hierarchy" and not any? (solution-on patch-at 1 0) with [solution_id > [opportunity_id] of which-opportunity])) or
                ((decision-structure = "hierarchy" and not any? (participant-on patch-at 0 1) with [participant_id > [opportunity_id] of which-opportunity]) and access-structure = "anarchy" and (availability-structure = "hierarchy" and not any? (solution-on patch-at 0 1) with [solution_id > [opportunity_id] of which-opportunity])) or
                ((decision-structure = "hierarchy" and not any? (participant-on patch-at -1 0) with [participant_id > [opportunity_id] of which-opportunity]) and access-structure = "anarchy" and (availability-structure = "hierarchy" and not any? (solution-on patch-at -1 0) with [solution_id > [opportunity_id] of which-opportunity])) or
                ((decision-structure = "hierarchy" and not any? (participant-on patch-at 0 -1) with [participant_id > [opportunity_id] of which-opportunity]) and access-structure = "anarchy" and (availability-structure = "hierarchy" and not any? (solution-on patch-at 0 -1) with [solution_id > [opportunity_id] of which-opportunity])) or


                ((decision-structure = "hierarchy" and not any? (participant-on patch-at 1 0) with [participant_id > [opportunity_id] of which-opportunity]) and (access-structure = "hierarchy" and not any? (problem-on patch-at 1 0) with [problem_id > [opportunity_id] of which-opportunity]) and (availability-structure = "hierarchy" and not any? (solution-on patch-at 1 0) with [solution_id > [opportunity_id] of which-opportunity])) or
                ((decision-structure = "hierarchy" and not any? (participant-on patch-at 0 1) with [participant_id > [opportunity_id] of which-opportunity]) and (access-structure = "hierarchy" and not any? (problem-on patch-at 0 1) with [problem_id > [opportunity_id] of which-opportunity]) and (availability-structure = "hierarchy" and not any? (solution-on patch-at 0 1) with [solution_id > [opportunity_id] of which-opportunity])) or
                ((decision-structure = "hierarchy" and not any? (participant-on patch-at -1 0) with [participant_id > [opportunity_id] of which-opportunity]) and (access-structure = "hierarchy" and not any? (problem-on patch-at -1 0) with [problem_id > [opportunity_id] of which-opportunity]) and (availability-structure = "hierarchy" and not any? (solution-on patch-at -1 0) with [solution_id > [opportunity_id] of which-opportunity])) or
                ((decision-structure = "hierarchy" and not any? (participant-on patch-at 0 -1) with [participant_id > [opportunity_id] of which-opportunity]) and (access-structure = "hierarchy" and not any? (problem-on patch-at 0 -1) with [problem_id > [opportunity_id] of which-opportunity]) and (availability-structure = "hierarchy" and not any? (solution-on patch-at 0 -1) with [solution_id > [opportunity_id] of which-opportunity]))
                ) [
              ;; If yes, a flight by postponement takes place.
              set num-postponement num-postponement + 1
              ;; A flight takes place by postponing the most difficult problem to the least important opportunity.
              ask which-opportunity [
                set blocked? false
                set charged? true
                set with-problem which-problem-for-opportunity
              ]
              ask which-problem-for-opportunity [
                set blocked? false
                set postponed? true
                set to-opportunity which-opportunity
                set since ticks
              ]
              ;; Write information on the control center.
              if (show-details?)
                [write-postponements]
            ]
          ]
          ;; After the possibility of a flight by postponement, the possibility of a flight by buck-passing is considered.
          [
            ;; Eventually, a flight by buck-passing takes place.
            if (buckpass? and count participant-here > 1) [
              ;; A participant and a problem are chosen to be paired to one another.
              let which-participant min-one-of participant-here [ability]     
              let which-problem-for-participant max-one-of problem-here [difficulty]    
              ;; Checks that there is at least one place to which the chosen participant can move.
              if (decision-structure = "anarchy" or (decision-structure = "hierarchy" and
                  (not any? (opportunity-on patch-at 1 0) with [opportunity_id < [participant_id] of which-participant] or
                   not any? (opportunity-on patch-at 0 1) with [opportunity_id < [participant_id] of which-participant] or
                   not any? (opportunity-on patch-at -1 0) with [opportunity_id < [participant_id] of which-participant] or
                   not any? (opportunity-on patch-at 0 -1) with [opportunity_id < [participant_id] of which-participant]))
                 ) [
                set num-buck-passing num-buck-passing + 1
                ;; A flight takes place by buck-passing the most difficult problem to the least able participant.
                ask which-participant [
                  set blocked? false
                  set charged? true
                  set with-problem which-problem-for-participant
                ]
                ask which-problem-for-participant [
                  set blocked? false
                  set passed? true
                  set to-participant which-participant
                  set since ticks
                ]
                ;; Write information on the control center.
                if (show-details?)
                  [write-buck-passings]
              ]
            ]
          ]
        ]
      ]
      ;; On the contrary, if there are no problems to be solved, decisions are made by oversight. Since decision-making by oversight
      ;; has no energy requirements, there is no reason to use more than one choice opportunity. Thus, if there are several participants, 
      ;; several solutions and several opportunities on the same patch, all participants and all solutions make a decision exploiting
      ;; only one opportunity and making use of only one solution. If these agents exit after making a decision, all participants on the
      ;; patch exit, but only one randomly chosen solution exits and only one randomly chosen opportunity exits.
      [
        set num-oversight num-oversight + 1
        ;; A decision by oversight is marked by a sky-blue square. The counter of the life of blocked decisions is reset.
        if (pcolor = white)
          [set num-blocked-oversight num-blocked-oversight + 1]
        set pcolor sky
        set pcolor-white-since 0
        ;; Write information on the control center
        if (show-details?)
          [write-oversights]
        ;; The indicators of the percentages of oversights on low and high hierarchical levels.
        let chosenOppOve one-of opportunity-here
        if (opportunities-exit? and (decision-structure != "anarchy" or availability-structure != "anarchy" or access-structure != "anarchy")) [ 
          ifelse ([opportunity_id] of chosenOppOve < (count opportunity) * 0.5)
            [set countOveHigh countOveHigh + 1]
            [set countOveLow countOveLow + 1]
        ]
        ;; If participants exit after a decision is made, all participants on the patch are killed.
        if (participants-exit?) [
          kill participant-here
        ]
        ;; If opportunities exit after a decision is made, one of the opportunities that are on the patch is picked up and killed.
        if (opportunities-exit?) [
          kill chosenOppOve
        ]
        ;; If solutions exit after a decision is made, one of the solutions that are on the patch is picked up and killed.
        if (solutions-exit?) [
          kill one-of solution-here
        ]
        ;; If there are still agents on the patch, they must be free to move. This is not obvious, because they may stem from a flight.
        ask turtles-here [
          if (blocked?) [set blocked? false]
        ]
      ]
    ]
  ]








  ;;;;;;;;;;;;;;;;;;;;;;;;;; AND FINALLY MOVE
  
  ;; Agents are only allowed to turn by multiples of 90 degrees.
  ;; The movement of participants may be constrained by the decision structure.
  ;; The movement of solutions may be constrained by the availability structure.
  ;; The movement of problems may be constrained by the access structure.
  ;; The movement of opportunities may me constrained by the decision structure, the availability structure and the access structure.
  
  ;; Flying couples move first. Their movements take account of the positions of other agents.
  ask patches [
    ;; Paired problems and opportunities move together.
    ;; Opportunities must consider where they are allowed to move. Problems just follow opportunities.
    ask opportunity-here with [not blocked? and charged?] [
      set heading ((random 4) * 90)
      let initialheading heading
      let stop? false
      while [stop? = false] [
        if (
            (decision-structure = "anarchy" and access-structure = "anarchy" and availability-structure = "anarchy") or
            (decision-structure = "anarchy" and access-structure = "anarchy" and (availability-structure = "hierarchy" and not any? (solution-on patch-ahead 1) with [solution_id > [opportunity_id] of myself])) or   
            (decision-structure = "anarchy" and (access-structure = "hierarchy" and not any? (problem-on patch-ahead 1) with [problem_id > [opportunity_id] of myself]) and availability-structure = "anarchy") or
            (decision-structure = "anarchy" and (access-structure = "hierarchy" and not any? (problem-on patch-ahead 1) with [problem_id > [opportunity_id] of myself]) and (availability-structure = "hierarchy" and not any? (solution-on patch-ahead 1) with [solution_id > [opportunity_id] of myself])) or
            ((decision-structure = "hierarchy" and not any? (participant-on patch-ahead 1) with [participant_id > [opportunity_id] of myself]) and access-structure = "anarchy" and availability-structure = "anarchy") or
            ((decision-structure = "hierarchy" and not any? (participant-on patch-ahead 1) with [participant_id > [opportunity_id] of myself]) and access-structure = "anarchy" and (availability-structure = "hierarchy" and not any? (solution-on patch-ahead 1) with [solution_id > [opportunity_id] of myself])) or   
            ((decision-structure = "hierarchy" and not any? (participant-on patch-ahead 1) with [participant_id > [opportunity_id] of myself]) and (access-structure = "hierarchy" and not any? (problem-on patch-ahead 1) with [problem_id > [opportunity_id] of myself]) and availability-structure = "anarchy") or
            ((decision-structure = "hierarchy" and not any? (participant-on patch-ahead 1) with [participant_id > [opportunity_id] of myself]) and (access-structure = "hierarchy" and not any? (problem-on patch-ahead 1) with [problem_id > [opportunity_id] of myself]) and (availability-structure = "hierarchy" and not any? (solution-on patch-ahead 1) with [solution_id > [opportunity_id] of myself]))
            ) [
          if (pcolor = brown)
            [set pcolor black]
          move-to patch-ahead 1
          set pcolor brown
          set stop? true
        ]
        set heading ((heading + 90) mod 360)
        if (heading = initialheading)
          [set stop? true]
      ]
    ]
    ask problem-here with [not blocked? and postponed? and to-opportunity != nobody] [
      move-to to-opportunity
    ]
    ;; Paired problems and participants move together.
    ;; Participants must consider where they are allowed to move. Problems just follow participants.
    ask participant-here with [not blocked? and charged?] [
      set heading ((random 4) * 90)
      let initialheading heading
      let stop? false
      while [stop? = false] [
        if (
            (decision-structure = "anarchy") or
            ((decision-structure = "hierarchy") and (not any? (opportunity-on patch-ahead 1) with [opportunity_id < [participant_id] of myself]))
            ) [
          if (pcolor = brown)
            [set pcolor black]
          move-to patch-ahead 1
          set pcolor brown
          set stop? true
        ]
        set heading ((heading + 90) mod 360)
        if (heading = initialheading)
          [set stop? true]
      ]
    ]
    ask problem-here with [not blocked? and passed? and to-participant != nobody] [
      move-to to-participant
    ]
  ]

  ;; Uncoordinated agents move in different, randomly chosen directions.
  ;; However, participants must take account of the decision structure, solutions take account of the availability structure and problems
  ;; take account of the access structure.
  ;; Finally, opportunities must take account of both the decision structure, the availability structure and the access structure.
  ;; The highest-ranked agents are those with lowest ID.
  ask participant with [not blocked? and not charged?] [
    set heading ((random 4) * 90)
    if ((decision-structure = "anarchy") or
        ((decision-structure = "hierarchy") and (not any? (opportunity-on patch-ahead 1) with [opportunity_id < [participant_id] of myself]))) [
      move-to patch-ahead 1
    ]
  ]
  ask opportunity with [not blocked? and not charged?] [
    set heading ((random 4) * 90)
    if (
        (decision-structure = "anarchy" and access-structure = "anarchy" and availability-structure = "anarchy") or
        (decision-structure = "anarchy" and access-structure = "anarchy" and (availability-structure = "hierarchy" and not any? (solution-on patch-ahead 1) with [solution_id > [opportunity_id] of myself])) or   
        (decision-structure = "anarchy" and (access-structure = "hierarchy" and not any? (problem-on patch-ahead 1) with [problem_id > [opportunity_id] of myself]) and availability-structure = "anarchy") or
        (decision-structure = "anarchy" and (access-structure = "hierarchy" and not any? (problem-on patch-ahead 1) with [problem_id > [opportunity_id] of myself]) and (availability-structure = "hierarchy" and not any? (solution-on patch-ahead 1) with [solution_id > [opportunity_id] of myself])) or
        ((decision-structure = "hierarchy" and not any? (participant-on patch-ahead 1) with [participant_id > [opportunity_id] of myself]) and access-structure = "anarchy" and availability-structure = "anarchy") or
        ((decision-structure = "hierarchy" and not any? (participant-on patch-ahead 1) with [participant_id > [opportunity_id] of myself]) and access-structure = "anarchy" and (availability-structure = "hierarchy" and not any? (solution-on patch-ahead 1) with [solution_id > [opportunity_id] of myself])) or   
        ((decision-structure = "hierarchy" and not any? (participant-on patch-ahead 1) with [participant_id > [opportunity_id] of myself]) and (access-structure = "hierarchy" and not any? (problem-on patch-ahead 1) with [problem_id > [opportunity_id] of myself]) and availability-structure = "anarchy") or
        ((decision-structure = "hierarchy" and not any? (participant-on patch-ahead 1) with [participant_id > [opportunity_id] of myself]) and (access-structure = "hierarchy" and not any? (problem-on patch-ahead 1) with [problem_id > [opportunity_id] of myself]) and (availability-structure = "hierarchy" and not any? (solution-on patch-ahead 1) with [solution_id > [opportunity_id] of myself]))
        ) [
      move-to patch-ahead 1
    ]
  ]
  ask solution with [not blocked?] [
    set heading ((random 4) * 90)
    if ((availability-structure = "anarchy") or
        ((availability-structure = "hierarchy") and (not any? (opportunity-on patch-ahead 1) with [opportunity_id < [solution_id] of myself]))) [
      move-to patch-ahead 1
    ]
  ]
  ask problem with [not blocked? and not postponed? and not passed?] [ 
    set heading ((random 4) * 90)
    if ((access-structure = "anarchy") or
        ((access-structure = "hierarchy") and (not any? (opportunity-on patch-ahead 1) with [opportunity_id < [problem_id] of myself]))) [
      move-to patch-ahead 1
    ]
  ]
  
  
  
  
  
  
  
  ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;,,,;;;;;; THE NUMBER OF AGENTS AVAILABLE FOR DECISION-MAKING

  set free-participants free-participants + count participant with [not blocked? and not charged?]
  set ave-free-participants free-participants / ticks
  set free-opportunities free-opportunities + count opportunity with [not blocked?]
  set ave-free-opportunities free-opportunities / ticks
  set free-solutions free-solutions + count solution with [not blocked?]
  set ave-free-solutions free-solutions / ticks
  set free-problems free-problems + count problem with [not blocked?]
  set ave-free-problems free-problems / ticks


  

  
  
  ;;;;;;;;;;;; MEASURES WHETHER OPPORTUNITIES, SOLUTIONS AND PROBLEMS ARE MET, THAT HAD ALREADY BEEN MET
  
  ;; Participants who are in blocked decision processes, as well as participants charged with problems, are excluded.
  ask participant with [not blocked? and not charged?] [
    set meetings-known-opp meetings-known-opp + count opportunity-here with [member? who [encountered] of myself]
    set meetings-opp meetings-opp + count opportunity-here
    set meetings-known-sol meetings-known-sol + count solution-here with [member? who [encountered] of myself]
    set meetings-sol meetings-sol + count solution-here
    set meetings-known-pro meetings-known-pro + count problem-here with [member? who [encountered] of myself]
    set meetings-pro meetings-pro + count problem-here
    ;; Agents that had not been previously met, are added to the list.
    if (any? turtles-here with [breed != participant and not (member? who [encountered] of myself)]) [
      foreach [who] of turtles-here with [breed != participant and not (member? who [encountered] of myself)] [
        set encountered fput ? encountered
      ]
    ]
  ]

      
      
      
    
  ;;;;;;;;;; COUNTS THE NUMBER OF BLOCKED DECISIONS, THE NUMBER OF POSTPONED PROBLEMS AND THE NUMBER OF PASSED PROBLEMS
  
  if (any? patches with [pcolor = white]) [
    ;; Number of blocked decision processes.
    set num-blocked num-blocked + count patches with [pcolor = white]
    set ave-num-blocked num-blocked / ticks
    ;; Size of blocked decision processes.
    set size-blocked size-blocked + count turtles with [blocked?] / count patches with [pcolor = white]
    set ave-size-blocked size-blocked / ticks
    ;; Life of blocked decision processes.
    let life-blocked-now 0
    ask patches with [pcolor = white] [
      set life-blocked-now life-blocked-now + (ticks - pcolor-white-since)
    ]
    set life-blocked-now life-blocked-now / count patches with [pcolor = white]
    set life-blocked life-blocked + life-blocked-now
    set ave-life-blocked life-blocked / ticks
  ]
  if (any? problem with [postponed?]) [
    ;; Number of postponed problems.
    set num-postponed num-postponed + count opportunity with [charged?]
    set ave-num-postponed num-postponed / ticks
    ;; Life of postponed problems
    let life-postponed-now 0
    ask problem with [postponed?] [
      set life-postponed-now life-postponed-now + (ticks - since)
    ]
    set life-postponed-now life-postponed-now / count problem with [postponed?]
    set life-postponed life-postponed + life-postponed-now
    set ave-life-postponed life-postponed / ticks
  ]
  if (any? problem with [passed?]) [
    ;; Number of passed problems.
    set num-passed num-passed + count participant with [charged?]
    set ave-num-passed num-passed / ticks
    ;; Life of passed problems.
    let life-passed-now 0
    ask problem with [passed?] [
      set life-passed-now life-passed-now + (ticks - since)
    ]
    set life-passed-now life-passed-now / count problem with [passed?]
    set life-passed life-passed + life-passed-now
    set ave-life-passed life-passed / ticks
  ]
end 

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;


















;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;; Procedures to distribute ability to participants, efficiency to solutions, and difficulty to problems ;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

to assign-ability
  if (dist-ability = "random") [
    ask participant [set ability random-float (max-ability - min-ability) + min-ability]
  ]
  if (dist-ability = "competence") [
    ifelse (count participant > 1) [
      ask participant [set ability min-ability + ((count participant - 1 - participant_id) / (count participant - 1)) * (max-ability - min-ability)]
    ] [
      ask participant [set ability (min-ability + max-ability) / 2]
    ]
  ]
  if (dist-ability = "incompetence") [
    ifelse (count participant > 1) [
      ask participant [set ability min-ability + (participant_id / (count participant - 1)) * (max-ability - min-ability)]
    ] [
      ask participant [set ability (min-ability + max-ability) / 2]
    ]
  ]
end 

to assign-efficiency
  if (dist-efficiency = "random") [
    ask solution [set efficiency random-float (max-efficiency - min-efficiency) + min-efficiency]
  ]
  if (dist-efficiency = "competence") [
    ifelse (count solution > 1) [
      ask solution [set efficiency min-efficiency + ((count solution - 1 - solution_id) / (count solution - 1)) * (max-efficiency - min-efficiency)]
    ] [
      ask solution [set efficiency (min-efficiency + max-efficiency) / 2]
    ]
  ]
  if (dist-efficiency = "incompetence") [
    ifelse (count solution > 1) [
      ask solution [set efficiency min-efficiency + (solution_id / (count solution - 1)) * (max-efficiency - min-efficiency)]
    ] [
      ask solution [set efficiency (min-efficiency + max-efficiency) / 2]
    ]
  ]
end 

to assign-difficulty
  if (dist-difficulty = "random") [
    ask problem [set difficulty random-float (max-difficulty - min-difficulty) + min-difficulty]
  ]
  if (dist-difficulty = "competence") [
    ifelse (count problem > 1) [
      ask problem [set difficulty min-difficulty + ((count problem - 1 - problem_id) / (count problem - 1)) * (max-difficulty - min-difficulty)]
    ] [
      ask problem [set difficulty (min-difficulty + max-difficulty) / 2]
    ]
  ]
  if (dist-difficulty = "incompetence") [
    ifelse (count problem > 1) [
      ask problem [set difficulty min-difficulty + (problem_id / (count problem - 1)) * (max-difficulty - min-difficulty)]
    ] [
      ask problem [set difficulty (max-difficulty - min-difficulty) / 2]
    ]
  ]
end 

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

















;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; If participants, choice opportunities, solutions or problems exit after a decision is made, these procedures are acvtivated
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

to kill [morituri]
  if (morituri != nobody) [
    ask morituri [
      if (breed = participant) [
        ;; If it is a participant charged with a problem, free the problem.
        if (charged?) [
          let this-problem-to-participant with-problem
          if (any? problem with [who = this-problem-to-participant]) [
            ask this-problem-to-participant [
              set passed? false
              set to-participant nobody
            ]
          ]
        ]
        ;; If the participant to be killed must be replaced, a new one is created.
        if (replace-participants?) [
          ;; Move the participant to be replaced.
          let found? false
          let localcounter 0
          while [not found?] [
            let newxcor random world-width
            let newycor random world-height
            if (not any? turtles-on patch newxcor newycor) [
              set found? true
              set xcor newxcor
              set ycor newycor
            ]
            set localcounter localcounter + 1
            if (localcounter > 10000) [
              type "TOO HIGH AGENT DENSITY"
              stop
            ]
          ]
          ;; Clone it, but with the following differences.
          hatch 1 [ 
            set blocked? false
            set charged? false
            set with-problem nobody
            set encountered []
          ]
        ]
        ;; The participants who met it, forget it.
        ask other participant [
          foreach encountered [
            if (? = [who] of myself)
              [set encountered remove ? encountered]
          ]
        ]
        ;; Finally kills it.
        die
      ]
      if (breed = opportunity) [
        if (charged?) [
          let this-problem with-problem
          if (any? problem with [who = this-problem]) [
            ask this-problem [
              set postponed? false
              set to-opportunity nobody
            ]
          ]
        ]
        ;; If the opportunity to be killed must be replaced, a new one is created.
        if (replace-opportunities?) [
          ;; Move the opportunity to be replaced.
          let found? false
          let localcounter 0
          while [not found?] [
            let newxcor random world-width
            let newycor random world-height
            if (not any? turtles-on patch newxcor newycor) [
              set found? true
              set xcor newxcor
              set ycor newycor
            ]
            set localcounter localcounter + 1
            if (localcounter > 10000) [
              type "TOO HIGH AGENT DENSITY"
              stop
            ]
          ]
          ;; Clone it, but with the following differences.
          hatch 1 [ 
            set blocked? false
            set charged? false
            set with-problem nobody
          ]
        ]
        ;; The participants who met it, forget it.
        ask participant [
          foreach encountered [
            if (? = [who] of myself)
              [set encountered remove ? encountered]
          ]
        ]
        ;; Finally kills it.
        die
      ]
      if (breed = solution) [
        ;; If the solution to be killed must be replaced, a new one is created.
        if (replace-solutions?) [
          ;; Move the solution to be replaced.
          let found? false
          let localcounter 0
          while [not found?] [
            let newxcor random world-width
            let newycor random world-height
            if (not any? turtles-on patch newxcor newycor) [
              set found? true
              set xcor newxcor
              set ycor newycor
            ]
            set localcounter localcounter + 1
            if (localcounter > 10000) [
              type "TOO HIGH AGENT DENSITY"
              stop
            ]
          ]
          ;; Clone it, but with the following differences.
          hatch 1 [ 
            set blocked? false
          ]
        ]
        ;; The participants who met it, forget it.
        ask participant [
          foreach encountered [
            if (? = [who] of myself)
              [set encountered remove ? encountered]
          ]
        ]
        ;; Finally kills it.
        die   
      ]
      if (breed = problem) [
        ;; If it is a postponed problem, free the opportunity to which it is postponed.
        if (postponed?) [
          let this-opportunity to-opportunity
          if (any? opportunity with [who = this-opportunity]) [
            ask this-opportunity [
              set charged? false
              set with-problem nobody
            ]
          ]
        ]
        ;; If is it a problem passed to somebody else, free this participant.
        if (passed?) [
          let this-participant to-participant
          if (any? participant with [who = this-participant]) [
            ask this-participant [
              set charged? false
              set with-problem nobody
            ]
          ]
        ]
        ;; If the problem to be killed must be replaced, a new one is created.
        if (replace-problems?) [
          ;; Move the problem to be replaced.
          let found? false
          let localcounter 0
          while [not found?] [
            let newxcor random world-width
            let newycor random world-height
            if (not any? turtles-on patch newxcor newycor) [
              set found? true
              set xcor newxcor
              set ycor newycor
            ]
            set localcounter localcounter + 1
            if (localcounter > 10000) [
              type "TOO HIGH AGENT DENSITY"
              stop
            ]
          ]
          ;; Clone it, but with the following differences.
          hatch 1 [ 
            set blocked? false
            set postponed? false
            set to-opportunity nobody
            set passed? false
            set to-participant nobody
            set since 0
          ]
        ]
        ;; The participants who met it, forget it.
        ask participant [
          foreach encountered [
            if (? = [who] of myself)
              [set encountered remove ? encountered]
          ]
        ]
        ;; Finally kills it.
        die
      ]
    ]
  ]
end 

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;












;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;; Writes labels on the screen and information on decision-making on the command center ;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

to show-labels
  ask participant [
    set label round ability
  ]
  ask problem [
    set label round difficulty
  ]
  ask solution [
    set label precision efficiency 1
  ]
end 

to write-oversights
  type "OVERSIGHT N."
  write num-oversight
  actors-involved
end 

to write-resolutions
  type "RESOLUTION N."
  write num-resolution
  actors-involved
end 

to write-postponements
  type "FLIGHT BY POSTPONEMENT N."
  write num-postponement
  actors-involved
end 

to write-buck-passings
  type "FLIGHT BY BUCK-PASSING N."
  write num-buck-passing
  actors-involved
end 

to actors-involved
  ask participant-here [
    type "      Identity:"
    write who
    type ". One of:"
    write count participant
    type " participants. Ability:"
    write ability
    type ". Charged?"
    write charged?
    type ". With problem:"
    write with-problem
    type "."
  ]
  ask opportunity-here [
    type "      Identity:"
    write who
    type ". One of:"
    write count opportunity
    type " opportunities."
    type " Charged?"
    write charged?
    type ". With problem:"
    write with-problem
    type "."
  ]
  ask solution-here [
    type "      Identity:"
    write who
    type ". One of:"
    write count solution
    type " solutions. Efficiency:"
    write efficiency
    type "."
  ]
  ask problem-here [
    type "      Identity:"
    write who
    type ". One of:"
    write count problem
    type " problems. Difficulty:"
    write difficulty
    type ". Postponed?"
    write postponed?
    type ". To opportunity:"
    write to-opportunity
    type ". Passed?"
    write passed?
    type ". To participant:"
    write to-participant
    type "."
  ]
  print " "
end 

to write-survivors
  print ""
  type "SURVIVING PARTICIPANTS"
  print ""
  ifelse (any? participant) [
    type "Identities:"
    ask participant [ write participant_id ]
    print " "
  ]
  [ type "none" ]
  type "SURVIVING OPPORTUNITIES"
  print ""
  ifelse (any? opportunity) [
    type "Identities:"
    ask opportunity [ write opportunity_id ]
    print " "
  ]
  [ type "none" ]
  type "SURVIVING SOLUTIONS"
  print ""
  ifelse (any? solution) [
    type "Identities:"
    ask solution [ write solution_id ]
    print " "
  ]
  [ type "none" ]
  type "SURVIVING PROBLEMS"
  print ""
  ifelse (any? problem) [
    type "Identities:"
    ask problem [ write problem_id ]
    print " "
  ]
  [ type "none" ]
  print ""
end