Difficulty in building a self-organized network in NetLogo - network-programming

Question

I'm new to netlogo and I'm trying to build a network where nodes have a random number that changes with each tick, and connect randomly to other nodes. Once the connection is established I need that: if the number between the two nodes is the same then the link crystallizes and changes color, otherwise it is deleted for that tick, the procedure is repeated until all nodes have the same random value.
Thanks in advance

Answer 1

Following the clarification in the comments...
The thing you mentioned can be done in a fairly simple way, so hopefully you can use the explanation and keywords below to browse the NetLogo Manual (and in particular the NetLogo Dictionary) and become fully familiar with what is going on.
First, let's setup a few things
globals [
; You'll probably want to declare these two variables directly
; in the Interface with a slider or something, but here I'll
; set them up from within the Code section.
number-of-turtles
level-of-randomness
]
turtles-own [
my-number
connected?
]
to setup
clear-all
reset-ticks
set-globals
create-turtles number-of-turtles [
setxy random-xcor random-ycor
set connected? false
]
end
to set-globals
set number-of-turtles 500
set level-of-randomness 1000
end
So far you have a number of turtles scattered in their environment, a couple of global variables that everyone can access, and a couple of variables belonging to each turtle to keep track of their state.
Based word for word on what you described, you could go on as:
to go.v1
; This first block of commands below is to get rid of the links that
; emerged in the previous iteration of 'go.v1', but that
; you don't want to keep because they link turtles with
; different 'my-number'. You will also need to include the
; stop condition that best suits you.
ask links with [color != green] [
die
]
; Insert here a stop condition.
ask turtles with [connected? = false] [
set my-number random level-of-randomness
]
; The 'let' command creates a local variable.
ask turtles [
let target one-of other turtles
create-link-with target
; The statement below containing "[who] ..." is how you need to
; call a link: 'who' is a built-in turtle-own variable reporting
; the ID number of the turtle, and to report a link you will need
; to give it the two IDs of the two turtles being connected.
if (my-number = [my-number] of target) [
ask link ([who] of self) ([who] of target) [
set color green
]
if (connected? = false) [
set connected? true
]
if ([connected?] of target = false) [
ask target [
set connected? true
]
]
]
]
tick
end
The code above does what you said: each turtle always creates the link with another turtle, then the condition is tested, and based on that condition (the result of which is stored as the link's color: only the good links become green) the link is kept or eliminated at the beginning of the following iteration of go.v1.
However, although you may have reasons to do it in the way above, you might just be happy with an alternative which requires less computation:
to go.v2
; Insert here a stop condition.
ask turtles with [connected? = false] [
set my-number random level-of-randomness
]
ask turtles [
let target one-of other turtles
if (my-number = [my-number] of target) [
create-link-with target [
set color green
ask both-ends [
if (connected? = false) [
set connected? true
]
]
]
]
]
tick
end
This way, turtles evaluate the potential companion before creating any link, and they only proceed to create it if my-number is the same.
That way, there is no need to create and then eliminate all the unwanted links (and the my-number condition had to be tested anyway even in go.v1).