FANDOM


Walled City
Walled City
One of Walled City's mature colonies

Author

Warren

Strategy

Mobile defensive colony

Last modified

6/2006

Walled City is a side created by Warren in March 2006. It was one of the first mobile colony sides; all colonies were mostly stationary until it was introduced. Inspired by Business Cycle, it consists of various types arranged in concentric defensive rings.

FileEdit

#side Walled City 2
#author Warren
#date Started 2006 03 23
#color f5f
#seed 2 3 1 4 3 1 3 1 4 2 3

A colony that moves around, favoring food and corners and avoiding enemies.
Has various types in concentric circles inspired by Business Cycle.

Types:
Fighter
Pregnant
Gatherer
Solar
Missile

ToDo:
* Make fight or not decision consistant and clean

Changes from walled-city 1 to walled city 2
* Seed includes solar outlets
* Builds missiles when populuous
* Fighters eat food
* Gatherers stop sitting at home syphoning when down to half energy, since by the time they get out of range they're usually empty anyway.
* Sundry hardware tweaks of questionable value

#code
;;;;;;;; Shared code block ;;;;;;;;;;;;;
;;;;;message-passing channels
#const DANGER_CHANNEL 1
#const HUNGRY_CHANNEL 7


;;;;; shared memory
#const CENTER_MOVE_VOTE 1 ;vec
#const CENTER_UPDATE_TIME 3
#const COLONY_CENTER 5 ;vec

#const FOOD_PLENTY_VOTE 15
#const FOOD_PLENTY_TIME 16
#const FOOD_PLENTY 17

;101-300 are food claims
#const FOOD_CLAIM_BASE 101
#const NUM_FOOD_CLAIMS 100
#const FOOD_CLAIM_SIZE 2

;301-400 are missile claims
#const NUM_ROBOT_CLAIMS 100
#const ROBOT_CLAIM_BASE 301

;robot types
#const FIGHTER_TYPE 1
#const PREGNANT_TYPE 2
#const GATHERER_TYPE 3
#const SOLAR_TYPE 4
#const MISSILE_TYPE 5

;shot type constants (need to match grobots source code)
#const FF_SHOT 5 ;forcefield
#const SYPHON_SHOT 3 ;the friendly sort of syphon

;;;; global vars
#vector center
#vector tv ;temporary vector
#var pregnant-radius
#var wall-radius
#var solar-radius
#var food-plenty

;;;;;code 

set-see-friends:
if
	0 1 ;first is enemies, second is friends
else
	1 0
then 
	robot-sensor-sees-friends! robot-sensor-sees-enemies!
return

rotate-ninety: ;clockwise
	negate swap return

4dup: tv! 2dup tv 2swap tv return

;The adjust-circle function uses the robot sensor and engine to bring this robot into a circle
; with other robots of its type. Far from perfect.
#var circle-adjust-time 0
#var left-cosine 
#var right-cosine
#var left-vel ;angular velocity
#var right-vel
#vector self-vec
#const ADJUST_CIRCLE_PERIOD 50

#vector desired-position

#var relocating-mode 0
#var relocating-angle
adjust-circle: ; radius -> ()
	relocating-mode nif
	wall-collision friendly-collision 3 >= or and-if
		1 relocating-mode!
		world-size 2 vs/ position v- angle -1 1 random + relocating-angle!
	then
relocating-mode if
	relocating-angle polar-to-rect center v+ desired-position!
	desired-position position 2 in-range if
		0 relocating-mode!
	then
else
	time circle-adjust-time ADJUST_CIRCLE_PERIOD + > if
		time circle-adjust-time!
		1 set-see-friends^
		0 robot-sensor-focus-distance!
		fire-robot-sensor sync
		position center v- self-vec!
		robot-sensor-range 2 / self-vec norm 1 max /
		;stack: sin of half the angle we can see
		1.3 * ;fudge factor to make no one seen seem a bit out of range
		1 min arcsin 2 * 
		cos
		 dup left-cosine! right-cosine!
;consider walls
		self-vec unitize 15 vs* rotate-ninety^
		2dup position v+ restrict-location-zero^ center v- unitize self-vec unitize dot left-cosine max left-cosine!
		vnegate position v+ restrict-location-zero^ center v- unitize self-vec unitize dot right-cosine max right-cosine!

		0 0 right-vel! left-vel!
		robot-found if
			do
				type robot-type = if
				position center v- unitize robot-position center v- unitize 4dup^ cross
				0 < if
					;bot right of us.
					dot ;now stack is: radius parameter, cosine of angle between us and them
					dup right-cosine > if
						right-cosine!
						robot-position center v- 2dup norm 1 max square vs/ robot-velocity cross right-vel!
					else drop then
				else
					;left of us
					dot
					dup left-cosine > if
						left-cosine!
						robot-position center v- 2dup norm 1 max square vs/ robot-velocity cross left-vel!
					else drop then
				then
				then ;our type?
			next-robot while-loop
		then
		;now seek balance. radius parameter is still on the stack!
		dup 2 / self-vec norm < if
			left-cosine arccos right-cosine arccos - 5 /
		;	position center v- 2dup norm 1 max square vs/ engine-velocity cross 0.8 *
		;	left-vel right-vel + 0.1 * + ADJUST_CIRCLE_PERIOD * + ;follow neighbors
			 position center v- angle +
		else
		;radius is very small, so pay attention to it first
			position center v- angle
		then
		;stack: dist, angle from center to seek
		polar-to-rect center v+ desired-position! 
	else
		drop
	then ;time to scan or not
then ;relocating-mode or not
desired-position position v- tv!
tv 0.03 vs* engine-velocity!
tv norm 5 > shot-found and if engine-max-power else 
 tv norm 0.2 > mass 800 / *
then engine-power! ;max power is 0.02 for std size cell. Allows gatherers to push us around.
;;		desired-position seek-location
return

general-talk:
	FOOD_PLENTY read food-plenty!
	COLONY_CENTER vread center!
	SOLAR_TYPE type-population 4 * 2pi / solar-radius!
	PREGNANT_TYPE type-population 4 * 2pi /
	SOLAR_TYPE type-population 3 0 ifev solar-radius + max pregnant-radius!
	FIGHTER_TYPE type-population 6 * 2pi / pregnant-radius 2 + max wall-radius!
	wall-radius 2 / pregnant-radius max pregnant-radius!
	pregnant-radius 7 - solar-radius max solar-radius!
return

restrict-location: ;x y -> x y
world-height 5 - min 5 max swap
world-width 5 - min 5 max swap return

restrict-location-zero: 
world-height 0 - min 0 max swap
world-width 0 - min 0 max swap return


;returns distance to nearest wall
wall-distance: ; -> dist
	position min
	world-size position v- min
	min return

cry-if-hurt: ; -- was-hurt
	#var last-armor
	armor last-armor < if
		position 2 DANGER_CHANNEL send
		1
	else
		0
	then
	armor last-armor!
return ;returns 1 or 0

;Feeding
#vector hungry-position
#var hungry-time -999
#var hungry-energy-wanted 10
#vector hungry-velocity
#vector current-hungry-position 50 50

calc-chp:
	hungry-position hungry-velocity time hungry-time - 40 min vs* v+ current-hungry-position!
return

#var num-cries
feed-hungry:
	
		HUNGRY_CHANNEL messages 5 - 0 max 0 random-int HUNGRY_CHANNEL skip-messages
		0 num-cries!
		do
			num-cries 5 < if
				HUNGRY_CHANNEL receive
				num-cries 1 + num-cries!
			else 
				0 ;already listened a lot
			then
		while
			;stack: energy time vx vy x y 
			2dup position syphon-range in-range
			current-hungry-position position syphon-range in-range not or
			time hungry-time 100 + > or
			if
 				hungry-position! hungry-velocity!
				hungry-time! hungry-energy-wanted!
				calc-chp^
			else
				2drop 2drop 2drop
			then
		loop
	current-hungry-position position syphon-range in-range if
	energy max-energy 0.1 * > and-if
		syphon-max-rate negate syphon-rate!
		current-hungry-position position v- hungry-velocity velocity v- 5 vs* v+ 
			rect-to-polar syphon-direction! syphon-distance!
	else
		0 syphon-rate!
	then
return

;based vaguely on tutorial food-hashing code from Frog Celestial
#var food-hash
#var food-y
claim-food:
;#const FOOD_CLAIM_BASE 1
;#const NUM_FOOD_CLAIMS 100
;first time, then y
	food-position food-y! world-width /
	;stack: between 0 and 1
	NUM_FOOD_CLAIMS * floor
	;stack: probably between 0 inclusive and NUM_FOOD_CLAIMS exclusive
	0 max NUM_FOOD_CLAIMS 1 - min FOOD_CLAIM_SIZE * FOOD_CLAIM_BASE + food-hash!
	food-hash sync read
	dup 0 > swap time 400 - > and if
		;valid time claim already
		0 ;TODO: check y
	else
		;claim expired
		time food-hash write food-y food-hash 1 + write
		1
	then
return


;;;;;; END Shared code ;;;;;;

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; Wall ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
#type Spiked Wall

A short-range blaster-weilding fighter. Also has weak grenades for no good reason.

;#decoration 000 cross
#color f00
#hardware
energy 460 80
armor 350
processor 34
radio send receive
engine 0.18
solar-cells 0.009

robot-sensor 8 6
shot-sensor 6.9 3
food-sensor 6.5 2
eater 0.5

repair-rate 0.12

grenades 4 7 19

blaster 38 5 19

#code
#vector danger-position
#var danger-time -1000
recent-danger: ;-- bool
time danger-time 50 + <
return

#const BIG_BOMB 103.52 ;if a robot has more than this size bomb, treat it as a missile.
#var hash
#var claimed-robot -1
;Volunteer to be the robot that stops the incoming missile
claim-robot: ; -- bool
robot-bomb BIG_BOMB < if 1 return then
robot-side 7 * robot-type 5 * robot-id + + NUM_ROBOT_CLAIMS mod ROBOT_CLAIM_BASE + hash!
hash claimed-robot = if ;already claimed
	sync
hash read 40 + time > and-if ;has our claim expired?
	time hash write
	1 return
then
sync
hash read 50 + time < if
	time hash write 
	hash claimed-robot!
	1 return
else
	0 return
then
  
targetable-robot-found: ;returns 1 if an ok target is found, 0 otherwise. Leaves robot cursor on target.
robot-found if
  do
    robot-shield-fraction 0.3 > if
    claim-robot^ and-if
		1 return
    then
  next-robot while-loop
then
0 return

;;; the fight-willingness function is in progress and currently unused.
#const BEGIN_FIGHTING_WILL 1.5
#const END_FIGHTING_WILL 0.5
#var fw_dist
#var fw_danger
;parameters: is it shooting? distance from center to object 
fight-willingness: ; bool num -- num
fw_dist! fw_danger!
fw_dist wall-radius 10 + < fw_danger and if
	5 ;under attack, always defend home
else
	fw_danger if
		wall-radius fw_dist / 1 min ;0.2 for 5 wall-radius away, 1 for inside colony
	else
	then
	fw_danger 2 1 ifev + 
	energy max-energy / armor max-armor / * sqrt ;geometric mean of armor and energy
	*
then
return ;returns willingness, greater is more willing


#var last-cry-time
#var fighting 0

#var meal-time
#vector meal-position
#var have-meal

#var tti ;time to intercept
#vector intercept-delta ;for noff
#vector relative-shot-vel
#var enemy-dist
#vector enemy-pos
#var enemy-time
#vector enemy-vel
#var enemy-radius
#var robot-scan-time
#var bomb-squad 0

;Some things, such as engine control and weapon firing, don't want to wait 10+ frames
; for the main loop to finish. So this is called every 4 frames or so.
#var fast-loop-time -10
fast-loop:
	time fast-loop-time!
	energy max-energy / 0.06 > if
	robot-scan-time fighting 14 30 ifev + 
	time < and-if ;If fighting, jump the gun so we don't waste time
		0 set-see-friends^
		0 robot-sensor-focus-distance!

		do
			blaster-cooldown 3 >=
			;will sync at least twice: once to fire sensor to see enemy, a second time to look for friends
			; Computing will also take several frames
			;don't care if grenades aren't ready
		while
			sync
		loop

		fire-robot-sensor sync
		time robot-scan-time! ;sensor also used for other things so robot-sensor-time won't do
		targetable-robot-found if
			robot-position robot-velocity lead-grenade
			robot-bomb robot-reloading or energy max-energy / 0.4 > and
			 center position wall-radius 13 + in-range or if
				robot-position robot-velocity 28 vs* v+ danger-position!
				time danger-time!
				1 fighting!
			then

			;do noff
			robot-bomb BIG_BOMB >= bomb-squad!
			robot-distance enemy-dist!
			robot-position enemy-pos!
			robot-velocity enemy-vel!
			robot-sensor-time enemy-time!
			robot-radius enemy-radius!

			blaster-speed
			robot-position position v- unitize
			robot-velocity velocity v- dot 
			;stack: blaster-speed, fleeing speed
			- blaster-speed 0.1 * max ;Don't let the velocity correction go crazy
			;stack: blaster closing speed
			robot-distance radius - swap / 
			;stack: tti
			tti!
			tti blaster-lifetime <= if
				robot-velocity velocity v-
				tti vs* intercept-delta! ;what to add to their position to make a straight shot work
				1 set-see-friends^
				robot-position position v- 0.5 vs* rect-to-polar robot-sensor-focus-direction! robot-sensor-focus-distance!
				intercept-delta robot-position v+ position v- unitize blaster-speed vs* relative-shot-vel! 
				fire-robot-sensor sync
				robot-found if
					do
						robot-position enemy-pos position v+ 0.5 vs* enemy-dist 0.5 * in-range Fire& nifg
						;friend is near line of fire.
					;determine if friend might be hit
						robot-velocity velocity v- relative-shot-vel v- unitize
						robot-position position v- cross robot-radius 3 + < NoFire& ifg
					next-robot while-loop
				then
			Fire:
				intercept-delta enemy-pos v+ position v- angle fire-blaster
			NoFire:
			then
;Try grenade a second time, in case it wasn't quite reloaded last time
	;;		robot-position robot-velocity lead-grenade 
		else
			fire-shot-sensor sync
			shot-found if
				do
					shot-velocity or if ;ignores explosions
					shot-type FF_SHOT <> shot-type SYPHON_SHOT <> and 
					center shot-position wall-radius 8 + in-range or and-if
						shot-position shot-velocity unitize -10 vs* v+ danger-position!
						time danger-time!
						energy max-energy / 0.4 > center position wall-radius 4 + in-range or if
							1 fighting!
						then
					then
				next-shot while-loop
			then
		then
		
	then

	fighting if
			enemy-time 30 + time > if
				bomb-squad if

					enemy-pos center v- rect-to-polar swap radius robot-radius + 0.3 - - swap polar-to-rect
					center v+
				;stack: place to be
#vector desired-ev
					position v- rect-to-polar swap 0.1 * 0.2 min swap polar-to-rect
					enemy-vel 0.75 vs* v+ 2dup desired-ev! engine-velocity!
				else
					enemy-pos enemy-vel time enemy-time - vs* v+ ;stack: cur enemy pos
					position v- rect-to-polar swap blaster-range 2.5 - - 0.06 * swap polar-to-rect
				;move to be 0.8 closer than our blaster range
 					enemy-vel 0.95 vs* v+ engine-velocity!
#vector requested-vel ;debug printf
					engine-velocity requested-vel!
				then
				engine-max-power engine-power!
			else
				danger-position seek-location
			then
	then
return

#start
position desired-position!
Begin-normaling:

do
;#var time1
;time time1!
	fast-loop^
	general-talk^
	cry-if-hurt^ drop
;#var time2
;time time2!

	energy max-energy / 0.2 > max-repair-rate 0 ifev repair-rate!
	
	armor max-armor / 0.5 > 0.8 0.55 ifev 
	have-meal if 0.5 * then
	max-energy * energy > if
	time last-cry-time - 37 > and-if
	velocity norm 0.15 < energy max-energy / 0.4 < or and-if
		max-energy energy - time velocity position 6 HUNGRY_CHANNEL send
		time last-cry-time!
	then

;#var time3
;time time3!
	fast-loop^


	fighting if

		energy max-energy / armor max-armor / min 0.25 > position center wall-radius 8 + in-range or if
		time danger-time 50 + < 
		time danger-time 400 + < 
		danger-position position 1 in-range not and or and-if
			DANGER_CHANNEL clear-messages ;already have a target, so why listen for other cries?
		else 0 fighting! then
	else
		have-meal if
			meal-position position radius in-range
			time meal-time 200 + > or eaten not and if
				0 have-meal!
			then
		then
		have-meal nif
			time food-sensor-time if food-sensor-time else -100 then
				energy 10 < 500 60 ifev
			 + > if
			energy max-energy / 0.9 < and-if
			center position wall-radius 4 + in-range and-if
				fire-food-sensor sync
				food-found if
					Food-check-loop:
					food-velocity norm nif
					claim-food^ and-if
						food-position meal-position!
						time meal-time!
						1 have-meal!
					else
						next-food Food-check-loop& ifg
					then
				then ;food-found
			then
		then

		have-meal if
			meal-position position v- rect-to-polar swap 0.05 * 0.1 min swap polar-to-rect engine-velocity!
			meal-position position radius in-range 0 engine-max-power 0.5 * ifev engine-power!
		else
			;wait in the circle
			wall-radius adjust-circle^
		then
	then

	fast-loop^ ;adjust-circle can take a long time

	fighting nif
		energy max-energy / 0.4 > if
			do
				DANGER_CHANNEL receive
			while
				;stack: position of danger
				danger-position!
				danger-position center wall-radius 8 + in-range
				danger-position position 10 energy max-energy / 15 * + in-range or if
					time danger-time!
					1 fighting!
				then
			loop
		else
			DANGER_CHANNEL clear-messages
		then
	then

forever
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; Constructor ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
#type Pregnant
#decoration 000 circle
#color 0f0
#hardware
energy 600 0.1
armor 180
processor 10
radio send receive
engine 0.027

constructor 2.6
solar-cells 0.03
repair-rate 0.06

robot-sensor 6 4

#code
#var last-birth-time -1
#var baby-cost

select-type:
	;first, check to see if fighters are needed
	population 0.28 * FIGHTER_TYPE type-population 0 1 random-int + > if
		FIGHTER_TYPE 
	else
		;second check to see if we're overflowing
		baby-cost time last-birth-time - /
		;stack: average power consumption
#var power-consumption
		dup power-consumption!
		constructor-max-rate 0.8 * > if
			PREGNANT_TYPE	
		else
	;third, make missiles if populous
			population 20 > if
			0.4 random-bool and-if
				MISSILE_TYPE
			else
	;third, make gatherers or solars based on whether the gatherers are happy
				food-plenty 0.39 < GATHERER_TYPE type-population and
				SOLAR_TYPE GATHERER_TYPE ifev
			then
		then
	then constructor-type!

	constructor-remaining baby-cost! ;;;hack
	time last-birth-time!
return

#start
	position desired-position!
	time 20 < if
		position COLONY_CENTER vwrite
	then


	constructor-type if
	;;seeded with fetus
		time last-birth-time!
		constructor-remaining baby-cost! ;;;hack
	then
#var last-cry-time -999

do
	general-talk^
	pregnant-radius adjust-circle^
	cry-if-hurt^ drop ;ignore return value

	time last-cry-time - 
	max-energy max-energy energy - 1 + / ;stack: delta_t, max / (1 + max - current)
	61 * >
	velocity norm 0.12 < and if
		max-energy energy - time velocity position 6 HUNGRY_CHANNEL send
		time last-cry-time!
	then
	max-repair-rate repair-rate!

	constructor-type nif
		select-type^
	then
	max-energy 0.03 * energy < constructor-max-rate 0 ifev constructor-rate!
forever

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; Gatherer ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
#type Gatherer
#decoration 000 cross
#color 00f
#hardware
energy 600 20
armor 111
processor 20
radio send receive
engine 0.04

eater 2.4
solar-cells 0.01
repair-rate 0.03
food-sensor 8 3
shot-sensor 4 2

syphon 2.4 9

#code
#var have-meal 0
#var meal-time
#vector meal-position 0 0
#vector wander-dest
#var homesick 0
#var running-away 0
#var last-danger-time -200
#vector last-danger-position


#var status 2
#const VOTED 1
#const UPDATED 2
#vector run-away-debug
#vector get-food-debug
vote:
	time 100 mod 20 < if
	status UPDATED = and-if
		;time to vote
		time last-danger-time 180 + < if
			last-danger-position center v- unitize -8 vs*
		else
			meal-position or if
				;have ever seen a food
				meal-position center v- unitize 3 vs*
			else
				;neither eating nor running away. Move colony towards center of world to get us food
				world-size 2 vs/ center v- unitize 0.1 vs*
			then
		then

		have-meal 1 0 ifev
		;stack is: movement-vote food-vote
		sync
		FOOD_PLENTY_VOTE read + FOOD_PLENTY_VOTE write
		CENTER_MOVE_VOTE vread v+ CENTER_MOVE_VOTE vwrite
		VOTED status!
	then

	time 100 mod 30 > if
	time 100 mod 50 < and-if
	status VOTED = and-if
 		time 50 - CENTER_UPDATE_TIME
		;stack: time-50, CENTER_UPDATE_TIME
		sync
		read > if
			time CENTER_UPDATE_TIME write
			;now we can take our time computing, since the time has already been written. If we die, center is delayed
			; by 100 frames; no big deal.
			CENTER_MOVE_VOTE vread 
			GATHERER_TYPE type-population 10 max vs/  ;10 max keeps us from moving so quickly when population is small
		;vector with length about 1
			2dup get-food-debug!
			center world-size 2 vs/ v- 
			signum swap signum swap
			 0.15 vs*  2dup run-away-debug! v+ ;run away from center. length 0.1 * sqrt(2) = 0.14
			rect-to-polar swap 2 min swap polar-to-rect
			COLONY_CENTER vread v+
			restrict-location^
			COLONY_CENTER vwrite
			0 0 CENTER_MOVE_VOTE vwrite
		then
		time 50 - FOOD_PLENTY_TIME
		sync
		read > if
			time FOOD_PLENTY_TIME write
			FOOD_PLENTY_VOTE read GATHERER_TYPE type-population /
			FOOD_PLENTY read + 2 / FOOD_PLENTY write
			0 FOOD_PLENTY_VOTE write
		then

		UPDATED status!
	then
return

#const edge-space 4
;this subroutine copied from eventually 12 (via Untouchable 4)
random-edge-position:
  0 1 random-int if
    0 1 random-int edge-space world-width edge-space - ifev
    edge-space world-height edge-space - random
  else
    edge-space world-width edge-space - random
    0 1 random-int edge-space world-height edge-space - ifev
  then
return


new-wander-loc:
0.4 random-bool if
	center wall-radius 1.2 * 10 + random-angle polar-to-rect v+ restrict-location^
else
	random-edge-position center v- rect-to-polar swap wall-radius 1.2 * 13 + min swap
	polar-to-rect center v+
then
 wander-dest!
return

run-away:
		new-wander-loc^
		0 have-meal!
		1 running-away!
		time last-danger-time!
		position last-danger-position!

return

#start
new-wander-loc^
do
;#var begin-loop-time
;	time begin-loop-time!
	vote^
	general-talk^
	energy max-energy / 0.2 > max-repair-rate 0 ifev repair-rate!
	
	time shot-sensor-time 30 + > energy max-energy / 0.1 > and if
		fire-shot-sensor sync
		shot-found if
			run-away^
		then
	then
	cry-if-hurt^ if
		run-away^
	then
;#var time2
;	time time2!

	;; feed-hungry and general-talk are really slow, so food seeking is in the code 2 places.
	have-meal if
		meal-position seek-location
	then

	feed-hungry^ ;this takes about 5 frames!
;#var time3
;	time time3!

homesick running-away or nif
	have-meal if
		meal-position position radius in-range
		time meal-time 200 + > or eaten not and if
			0 have-meal!
		then
	then
	have-meal nif
		time food-sensor-time 
			energy 10 < 150 30 ifev
		 + > if
			fire-food-sensor sync
			food-found if
				Food-check-loop:
				food-velocity norm nif
				claim-food^ and-if
					food-position meal-position!
					time meal-time!
					1 have-meal!
				else
					next-food Food-check-loop& ifg
				then
			then ;food-found
		then
	then

	have-meal if
		meal-position seek-location
	else
		wander-dest position 2 in-range 
		center wander-dest wall-radius 30 + in-range not or if
			new-wander-loc^
		then
		energy 5 < if
			0 engine-power!
		else
			wander-dest position v- unitize 0.07 vs* engine-velocity! engine-max-power engine-power!
		then
	then
	energy max-energy / 
	have-meal 0.95 0.7 ifev > if
		1 homesick!
		0 have-meal!
		0.5 random-bool if
			new-wander-loc^ ;to avoid the useless gliding colony problem
			;meal-position wander-dest! ;last place we found food is good place to wander to
		then
	then
else ;eat or not

homesick if
	hungry-position position syphon-range 0.8 * in-range if
		0 engine-power!
	else
		hungry-position center wall-radius 10 + in-range 
		if hungry-position else center then seek-location
	then
	energy max-energy / 0.5 < if
		0 homesick! ; ok to do this prematurely, since we'll continue to syphon
	then

then

running-away if
	center position 4 in-range if
		0 running-away!
	then
	center seek-location
then
then ;eat or not

forever

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
#type Solar Outlet
#decoration 000 cross
#color 0ff

Based on untouchable 3's solar outlet.

#hardware

processor 15 ;big CPU to process hungry calls
armor 80
energy 150 0
constructor 0.3 ;emergency anti-overflow use only
engine 0.023

radio receive

solar-cells 0.4
robot-sensor 4 3
syphon 0.55 8

#code

#start

do
	general-talk^
	solar-radius adjust-circle^
	cry-if-hurt^ drop
    	feed-hungry^

	PREGNANT_TYPE constructor-type!
	energy max-energy / 0.8 > constructor-max-rate 0 ifev constructor-rate!
forever


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; Missile ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
#type Boom

#decoration fcc dot
#color f00
#hardware
energy 300 300
armor 280
processor 30
radio send receive
engine 0.18

robot-sensor 11 12
shot-sensor 6 2

bomb 1100

#code
#vector danger-position
#var danger-time -1000
recent-danger: ;-- bool
time danger-time 50 + <
return
  
#var exploring 1
#var expected-damage 0
#var max-expected-damage
#vector wander-loc
#var total-mass-seen

targetable-robot-found: ;returns 1 if an ok target is found, 0 otherwise. Leaves robot cursor on target.
robot-found if
  do
    robot-shield-fraction 0.3 > if
		1 return
    then
  next-robot while-loop
then
0 return

#const edge-space 4
;this subroutine copied from eventually 12 (via Untouchable 4 and Walled City)
random-edge-position:
  0 1 random-int if
    0 1 random-int edge-space world-width edge-space - ifev
    edge-space world-height edge-space - random
  else
    edge-space world-width edge-space - random
    0 1 random-int edge-space world-height edge-space - ifev
  then
return

new-wander-loc:
	random-edge-position^ wander-loc!
return

#vector robots-center
#var importance
#var max-expected-damage-time
#const EXPL_RADIUS 6
#start
new-wander-loc^

do
	time robot-sensor-time exploring 40 15 ifev + > if
		fire-robot-sensor sync
		robot-found if
			0 0 robots-center!
			0 expected-damage!
			0 importance!
			0 ;mass - leave on stack
			do
				robot-mass +
				1 robot-distance EXPL_RADIUS / - 0 max robot-mass * expected-damage + expected-damage!
				robot-position 
				robot-mass robot-distance EXPL_RADIUS < 1 0.1 ifev *
				;stack: mass-accum, robot-position, robot-importance
				dup importance + importance!
				vs* robots-center v+ robots-center!
			next-robot while-loop
			total-mass-seen!
			robots-center importance vs/ robots-center!

			energy max-energy / armor max-armor / min
			exploring 120 80 ifev * total-mass-seen < if
				0 exploring!
			else
				1 exploring!
			then
			
			expected-damage 35 > if
			max-expected-damage 0.8 * expected-damage >
			time max-expected-damage-time 200 + > or and-if
				die sync
			then
			max-expected-damage expected-damage  < if
				expected-damage max-expected-damage!
				time  max-expected-damage-time!
			then
		then
	then
	exploring if
		wander-loc position 5 in-range if new-wander-loc^ then
		wander-loc position v- unitize 0.15 vs* engine-velocity!
	else
		robots-center seek-location
		;0.3 robot-direction-overall polar-to-rect engine-velocity!
		;;TODO: this is a terrible place to go towards.
	then
	engine-max-power engine-power!
	sync sync  ;save CPU
forever

#end

Ad blocker interference detected!


Wikia is a free-to-use site that makes money from advertising. We have a modified experience for viewers using ad blockers

Wikia is not accessible if you’ve made further modifications. Remove the custom ad blocker rule(s) and the page will load as expected.