Hi I would like to hatch turtles at random patches but confined within a specific area.
ask employees [
set shape "person"
set size 1.5
set color blue
setxy random-xcor random-ycor ]
How do I adjust the setxy line to force the turtles to all be confined to: [ pxcor <= 8 and pxcor >= -8 and pycor <= 8 and pycor >= -8 ]
After looking through various bits of different code, what I've done is:
globals [office-space]
set office-space patches with [ pxcor <= 8 and pxcor >= -8 and pycor <= 8 and pycor >= -8 ]
ask office-space [ set pcolor grey]
place-on-color-employees
to place-on-color-employees
let _patches (patches with [pcolor = grey])
ask employees [
move-to one-of (_patches with [not any? turtles-here])
]
end
Related
I'm creating a board game simulation similar to monopoly, where pieces are moving around the board. My turtle acts as the user's game piece and moves around the border of the world. The border is set up in alternating colors. I have a button that generates the number of steps the turtle moves. Those steps are stored as dice-num, a global variable. However, when the turtle lands on the patches before the patch (16 -16) (the bottom right-hand corner of the board) and the number of steps it needs to move exceeds 1, I can't turn the turtle's heading halfway to move up the board. As a result it only moves back to the beginning of the board.
I've tried to treat each case separately:
;if the turtle lands on the patch before the corner
ask turtle 0 [if pycor = min-pycor and pxcor = max-pxcor - 1
[setxy max-pxcor min-pycor
set dice-num dice-num - 1
show dice-num
]
]
;dice-num refers to number of steps the turtle moves
Heres my code so far:
to setup
board
end
to go
dice-roll
end
to board
ask patches [if pxcor = max-pxcor or pycor = max-pycor or pxcor = min-
pxcor or pycor = min-pycor
[set pcolor blue]]
ask patches [if pycor = max-pycor or pycor = min-pycor
[if pxcor mod 2 = 0
[set pcolor orange]]]
ask patches [if pxcor = max-pxcor or pxcor = min-pxcor
[if pycor mod 2 = 0
[set pcolor orange]]]
ask patch min-pxcor min-pycor [set pcolor green]
end
to dice-roll
set dice [1 2 3 4 5 6]
set dice-num one-of dice
user-message (word "You rolled: " dice-num)
ask turtle 0 [
fd dice-num
]
;allows the turtle to turn if it lands on a corner
ask turtle 0 [if ycor = min-pycor and xcor = max-pxcor [set heading 0]
if xcor = max-pxcor and ycor = max-pycor [set heading 270]
if xcor = min-pxcor and ycor = max-pycor [set heading 180]
;add a statement to end game once player rereaches the green patch
]
;if the turtle lands on the patch before the corner
ask turtle 0 [if pycor = min-pycor and pxcor = max-pxcor - 1
[setxy max-pxcor min-pycor
set dice-num dice-num - 1
show dice-num
]
]
end
I expect the output to be the turtle to start moving up the right hand side of the board once it lands on the patch (15 -16) and recieves a dice-num greater than 1. However, when the turtle does land on the patch (15 -16) and the dice-num is greater than 1 it simply moves back to the beginning of the board.
Okay, this was simply too long for comments so I had to make some guesses. I expect the problem was that you were forwarding the full amount of the die roll after checking location. This would mean you have to test all the potential patches that could reach the corner. Instead, it is easier to move one patch and test location before moving the next patch. This is a cleaned up version of your code that implements this move and check process.
to setup
clear-all
board
ask one-of patches with [pcolor = green]
[ sprout 1
[ set color white
set heading 90
forward 1
]
]
end
to go
let die-num dice-roll
ask one-of turtles [ move die-num ]
end
to board
ask patches with [ pxcor = max-pxcor or pxcor = min-pxcor ]
[ set pcolor ifelse-value (pycor mod 2 = 0) [orange][blue] ]
ask patches with [ pycor = max-pycor or pycor = min-pycor ]
[ set pcolor ifelse-value (pxcor mod 2 = 0) [orange][blue] ]
ask patch min-pxcor min-pycor [set pcolor green]
end
to-report dice-roll
let dice-num one-of [1 2 3 4 5 6]
user-message (word "You rolled: " dice-num)
report dice-num
end
to move [#roll]
while [ #roll > 0 ]
[ if pxcor = max-pxcor and pycor = max-pycor [set heading one-of [180 270] ]
if pxcor = max-pxcor and pycor = min-pycor [set heading one-of [0 270] ]
if pxcor = min-pxcor and pycor = max-pycor [set heading one-of [180 90] ]
if pxcor = min-pxcor and pycor = min-pycor [ stop ]
fd 1
set #roll #roll - 1
]
end
The alternative is simply to add the die roll to the current location and see if it goes past. If it does, calculate where you want to get to.
this code contains a road setup and turtle creation , after that on the go procedure that makes turtles take the pink path , and am trying to make turtles change color with they get to a red colored patch , but for unknown reason this code is not working and the cars never change their color and stay blue as there creation color
i hope i get some help to do it
turtles-own [
speed
s?
]
to setup-road
clear-all
ask patches [
ifelse pycor < -8 and pycor > -17 [set pcolor black ]
[set pcolor gray - 3 ]
if pycor < -9 and pycor > -15 [ set pcolor gray ]
if pycor > -10 and pycor < -8 and pxcor > 20 and pxcor < 27
[set pcolor white ]
if pycor < -2 and pycor > -4 and pxcor < 20 and pxcor > -24
[set pcolor pink ]
if pycor < -3 and pycor > -10 and pxcor < -22 and pxcor > -24
[set pcolor green ]
if pxcor = 20 and pycor = -3
[set pcolor red
]
]
set-default-shape turtles "car"
create-turtles 2 [
set color blue
set size 2
set xcor random-xcor
set ycor -12
set heading 90
set speed 0.1 + random-float 0.9
set s? true
]
reset-ticks
end
to go
ask turtles [
let car-ahead one-of turtles-on patch-ahead 2
if car-ahead != nobody
[ fd speed]
let gate one-of patches in-radius 5 with [pcolor = green ]
let path one-of patches in-radius 5 with [pcolor = pink ]
if s?
[ ifelse gate != nobody
[ move-to gate
fd speed
ifelse path != nobody
[
move-to path
fd speed
if patch-ahead 1 != nobody and pcolor != pink
[set color green ]
]
[fd speed]]
[fd speed]
]
]
tick
end
I am new to Netlogo, and have some questions. That would be great if you could help me.
I would like to create some fruit flies moving around a tree that is made up by green patches. Fruit flies are attracted to the tree. They will turn back to the tree if fruit flies move away certain distance (such as 5 grids) from the tree.
In the beginning, they will not stop on the green patches because they have enough energy. As time passed, they will loss their energy. They will find the closest green patch, and stay on it for certain time once their energy reaches 0. They gain energy after that, and they only can do short hops from the bottom branch to the top one (3 hops). Flies will move back to the bottom branch when they are on the top part of tree. I think I need to do a WHILE loop, but I have no idea how to do that. Please look at my codes.
breed [flies fly]
breed [suns sun]
turtles-own [energy]
flies-own [count-down]
to setup
clear-all
setup-suns
setup-flies
setup-patches
reset-ticks
end
to setup-suns
;; Create the sun
set-default-shape suns "sun"
create-suns 1 [
setxy max-pxcor - 3
max-pycor - 3
set color yellow
set size 7
]
end
to setup-flies
set-default-shape flies "bee 2"
create-flies number-fly [ set color white setxy random-xcor random-ycor set count-down 15]
end
to setup-patches
;; Create sky and grass
ask patches
[ set pcolor blue ]
ask patches with [pycor < min-pycor + 2]
[ set pcolor 66 ]
;; Create trunk and branches
ask patches with [ pxcor = -15 and pycor <= 0 ] [ set pcolor brown ]
ask patches with [ pxcor = -15 and pycor < 8 and pycor > 0] [ set pcolor lime ]
ask patches with [ pxcor = pycor - 15 and pycor <= 5 and pycor > 0 ] [ set pcolor lime ]
ask patches with [ pxcor = (- pycor) - 15 and pycor <= 5 and pycor > 0 ] [ set pcolor lime ]
ask patches with [ pxcor = pycor - 8 and pycor <= 2 and pxcor > -15 ] [ set pcolor lime ]
ask patches with [ pxcor = (- pycor) - 22 and pycor <= 2 and pxcor < -15 ] [ set pcolor lime ]
ask patches with [ pxcor = pycor - 1 and pycor <= -1 and pxcor > -15 ] [ set pcolor lime ]
ask patches with [ pxcor = (- pycor) - 29 and pycor <= -1 and pxcor < -15 ] [ set pcolor lime ]
ask patches with [ pxcor = 15 and pycor <= 0 ] [ set pcolor brown ]
ask patches with [ pxcor = 15 and pycor < 8 and pycor > 0] [ set pcolor lime ]
ask patches with [ pxcor = pycor + 15 and pycor <= 5 and pycor > 0 ] [ set pcolor lime ]
ask patches with [ pxcor = (- pycor) + 15 and pycor <= 5 and pycor > 0 ] [ set pcolor lime ]
ask patches with [ pxcor = pycor + 22 and pycor <= 2 and pxcor > 15 ] [ set pcolor lime ]
ask patches with [ pxcor = (- pycor) + 8 and pycor <= 2 and pxcor < 15 ] [ set pcolor lime ]
ask patches with [ pxcor = pycor + 29 and pycor <= -1 and pxcor > 15 ] [ set pcolor lime ]
ask patches with [ pxcor = (- pycor) + 1 and pycor <= -1 and pxcor < 15 ] [ set pcolor lime ]
ask patches with [ pxcor = -26 and pycor = -3 ] [ set pcolor red ]
ask patches with [ pxcor = -10 and pycor = 5 ] [ set pcolor red ]
ask patches with [ pxcor = 21 and pycor = -1 ] [ set pcolor red ]
end
to go
move-flies
tick
end
to move-flies
ask flies [
set energy 6
ifelse energy > 10 [
;rt random 50 lt random 50 jump random-float 1 ;
let nearest-leaf min-one-of (patches with [pcolor = lime] ) [distance myself] ; Find the closest leaf within 5 grids - long range search.
if is-patch? nearest-leaf [ ; If it is a leaf, and flies will be attracted to the leaf.
face nearest-leaf
;set heading 45
;fd distance nearest-leaf
rt random 50 lt random 50 jump random-float 5 ; Protential resources make flies move actively (fast movement).
;move-to nearest-leaf ;
]
]
[
ifelse pcolor != lime
[ rt random 50 lt random 50 jump random-float 1 ; Initialization - flies fly around to search their resources.
continue]
[ stay ]
]
]
end
to continue
let nearest-leaf min-one-of (patches in-radius 1 with [pcolor = lime] ) [distance myself] ; Find the closest leaf within 2 grids - short hops.
ifelse is-patch? nearest-leaf [ ; If it is a leaf, and flies will be attracted to the leaf.
face nearest-leaf
fd random distance nearest-leaf
;ask patches in-radius 1 [set pcolor red]
;rt random 50 lt random 50 jump random-float 5 ; Protential resources make flies move actively (fast movement).
;move-to nearest-leaf ;
]
[
let turn-back min-one-of (patches with [pcolor = lime] ) [distance myself] ;
;set heading 180
face turn-back
jump random-float 5 ]
move-up ;Flies tend to move up through all branches by short hops. Need a while loop.
; Move down if they reach the top of tree
let canopy patch-at-heading-and-distance 0 1
let canopy-left patch-left-and-ahead 45 1
let canopy-right patch-right-and-ahead 45 1
if canopy != lime or canopy-left != lime or canopy-right != lime
[
move-down
]
end
to move-up
ask flies [
set heading one-of [0 30 -30]
]
end
to move-down
ask flies [
set heading one-of [180 120 -120]
]
end
to stay
set count-down count-down - 1 ;;decrement timer
set label count-down
if count-down = 0
[
rt random 50 lt random 50 jump random-float 1
set label ""
reset-count-down ;;it's another procedure
]
end
to reset-count-down
set count-down 30
end
I am sorry if you are confused by my codes. I appreciate your help. Thanks.
Kind Regards,
Ming
From your description, I think you almost certainly don't want a while loop. In a NetLogo model's go procedure, you're only specifying what happens in a single tick. So you would only use while if need it to express something that happens all in a single instant, not a process that unfolds over multiple ticks.
(Agree with Frank this is too much code to post to have a good chance of getting help. It would take quite a while for me to read and study this much code, let alone try to help you with it. In this answer I've tried to extract and address a single aspect.)
Can anyone help me with this. I'am trying to simulate a situation wherein the turtle will randomly sit on a bench (red patch) and if the bench is occupied it will find another one.
1 turtle: 1 patch
breed [kids kid]
breed [adults adult]
breed [oldies old]
kids-own [step]
adults-own [step]
oldies-own [step]
to setup
__clear-all-and-reset-ticks
ask patches [setup-world]
set-default-shape turtles "person"
create-kids number-of-kids
create-adults number-of-adults
create-oldies number-of-oldies
ask kids[
set color green
set size 1
setxy -10 0
set heading random-float 90
rt 45 - random-float 90]
ask adults[
set color orange
set size 1
setxy -10 0
set heading random-float 45
rt 45 - random-float 90]
to setup-world
set pcolor white
if ( pxcor = 10 ) and ( pycor < 10 and pycor > -11 ) [ set pcolor brown ]
if ( pxcor = -10 ) and ( pycor < 10 and pycor > 1 ) [ set pcolor brown ]
if ( pxcor = -10 ) and ( pycor < -1 and pycor > -11 ) [ set pcolor brown ]
if ( pycor = 10 ) and ( pxcor < 11 and pxcor > -11 ) [ set pcolor brown ]
if ( pycor = -10 ) and ( pxcor < 10 and pxcor > -11 ) [ set pcolor brown ]
if ( pxcor = 8 ) and ( pycor < 8 and pycor > 2 ) [ set pcolor red ]
if ( pxcor = 8 ) and ( pycor < -2 and pycor > -8 ) [ set pcolor red ]
end
to go
ask kids[
if pcolor = red and not any? other turtles-here[
move-to patch-here
stop]
fd 1
ifelse pcolor = red and any? other turtles-here
[rt random 90]
[fd 1]
]
ask adults[
if pcolor = red and not any? other turtles-here[
move-to patch-here
stop]
fd 1
ifelse pcolor = red and any? other turtles-here
[rt random 90]
[fd 1]
]
tick
end
you have already done most of the coding in the right way, I have tested your code and it works fine except your second condition in your go function for kids and adults.
One way to do the same thing is adding a turtle variable for example seated? Variable and make it false at initialization and make it true if the turtle is sitting on a bench. And only ask turtles with false seated? to look for another bench.
turtles-own [seated?]
ask kids with [not seated? ][
rt random 10
fd 1
if pcolor = red and not any? other turtles-here [
move-to patch-here
set seated? true]
]
ask adults with [not seated?]
[
rt random 10
fd 1
if pcolor = red and not any? other turtles-here[
move-to patch-here
set seated? true]
]
I have tested the code by showing number of turtles in each pacth and there was only one turtle per red patch
ask patches with [pcolor = red ][set plabel count turtles-here]
In this model all it does is turtle will find a seat(red patch for available and yellow for taken). And once the seats are all occupied it all will stop.
Now how to make some of the turtles move again? Like if it is seated it will move again and try go another place or it will go out.
breed [kids kid]
breed [adults adult]
breed [oldies old]
kids-own [step]
adults-own [step]
oldies-own [step]
turtles-own [seated?]
to setup
__clear-all-and-reset-ticks
ask patches [setup-world]
ask patches with [pcolor = red ][set plabel count turtles-here]
set-default-shape turtles "person"
create-kids number-of-kids
create-adults number-of-adults
create-oldies number-of-oldies
ask kids[
set color green
set size 1
setxy -10 0
set heading random-float 90
rt 45 - random-float 90]
ask adults[
set color orange
set size 1
setxy -10 0
set heading random-float 45
rt 45 - random-float 90]
ask oldies[
set color blue
set size 1
setxy -10 0
set heading random-float 45
rt 45 - random-float 90]
end
to setup-world
set pcolor white
if ( pxcor = 10 ) and ( pycor < 10 and pycor > -11 ) [ set pcolor brown ]
if ( pxcor = -10 ) and ( pycor < 10 and pycor > 1 ) [ set pcolor brown ]
if ( pxcor = -10 ) and ( pycor < -1 and pycor > -11 ) [ set pcolor brown ]
if ( pycor = 10 ) and ( pxcor < 11 and pxcor > -11 ) [ set pcolor brown ]
if ( pycor = -10 ) and ( pxcor < 10 and pxcor > -11 ) [ set pcolor brown ]
if ( pxcor = 8 ) and ( pycor < 8 and pycor > 2 ) [ set pcolor red ]
if ( pxcor = 8 ) and ( pycor < -2 and pycor > -8 ) [ set pcolor red ]
end
to go
if count patches
with [pcolor = yellow and any? other turtles-here] = 10
[stop]
ask kids with [seated? = 0][
rt random 10
fd 2
if pcolor = red and not any? other turtles-here [
move-to patch-here
set seated? true
set pcolor yellow
]
]
ask adults with [seated? = 0]
[
rt random 10
fd 1.5
if pcolor = red and not any? other turtles-here[
move-to patch-here
set seated? true
set pcolor yellow
]
]
ask oldies with [seated? = 0]
[
rt random 10
fd 1
if pcolor = red and not any? other turtles-here[
move-to patch-here
set seated? true
set pcolor yellow
]
]
tick
end
Just the way you asked non-seated turtles by ask ... with [Seated? = 0] you can ask others by ask ... with [Seated? = 1]
However, I will suspect that they will go in a loop, because they are close to the bench ans bench is empty, so as soon as they stand up they will sit on the same spot again. Maybe you can have a memory [] which stores last few moves and if there is a seated position, say in last 10 items it will choose not to sit. I am not sure what are your requirements, this is just an example.
ask adults with [seated? = 1]
[
; Stand up set seated? = 0
; go around
]
ask kids with [seated? = 1]
[
; Stand up set seated? = 0
; go around
]
ask oldies with [seated? = 1]
[
; Stand up set seated? = 0
; go around
]
Update:
I have changed your code, its not much different from your code, but it has memory function to make sure turtles move around after leaving a bench and are not going to sit on same bench again and to some degree avoid walls (you need to improve the avoiding since step size is different for each agent):
breed [kids kid]
breed [adults adult]
breed [oldies old]
Globals [out-of-boundry]
turtles-own [seated? memory step]
to setup
clear-all
reset-ticks
ask patches [setup-world]
ask patches with [pcolor = red ][set plabel count turtles-here]
set out-of-boundry patches with [ pycor > 10 or pxcor < -10 or pxcor > 10 or pycor < -10 or pcolor = brown]
set-default-shape turtles "person"
create-kids 5 [
set memory []
set seated? false
set color green
set size 1
setxy -10 0
set heading random-float 90
rt 45 - random-float 90
set step 2
]
create-adults 5 [
set memory []
set seated? false
set color orange
set size 1
setxy -10 0
set heading random-float 45
rt 45 - random-float 90
set step 1.5
]
create-oldies 5 [
set memory []
set seated? false
set step 1
set color blue
set size 1
setxy -10 0
set heading random-float 45
rt 45 - random-float 90
]
end
to setup-world
set pcolor white
if ( pxcor = 10 ) and ( pycor < 10 and pycor > -11 ) [ set pcolor brown ]
if ( pxcor = -10 ) and ( pycor < 10 and pycor > 1 ) [ set pcolor brown ]
if ( pxcor = -10 ) and ( pycor < -1 and pycor > -11 ) [ set pcolor brown ]
if ( pycor = 10 ) and ( pxcor < 11 and pxcor > -11 ) [ set pcolor brown ]
if ( pycor = -10 ) and ( pxcor < 10 and pxcor > -11 ) [ set pcolor brown ]
if ( pxcor = 8 ) and ( pycor < 8 and pycor > 2 ) [ set pcolor red ]
if ( pxcor = 8 ) and ( pycor < -2 and pycor > -8 ) [ set pcolor red ]
end
to go
if count patches with [pcolor = yellow and any? other turtles-here] = 10 [stop]
ask turtles [
set memory lput Seated? memory
restrict-memory
ifelse seated?
[stand-up ]
[ move-in-the-brown-area step
sit]
]
tick
end
to move-in-the-brown-area [step-size]
ifelse not member? patch-ahead step-size out-of-boundry [
fd step-size
rt random 10
]
[ face one-of patches with [pcolor = white]
fd step-size
]
If member? patch-here out-of-boundry[
let target patch -10 0
face target
fd step-size]
end
to restrict-memory
;assume your memory-limit is 5
let memory-limit 5
if length memory >= memory-limit
[ set memory but-first memory ]
end
to stand-up
if seated?
[ set seated? false
set pcolor red
fd 1
]
end
to sit
if pcolor = red and not any? other turtles-here with [not member? true memory][
move-to patch-here
set seated? true
set pcolor yellow
]
end