/
_ai_controller.dm
783 lines (668 loc) · 29.9 KB
/
_ai_controller.dm
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
/*
AI controllers are a datumized form of AI that simulates the input a player would otherwise give to a atom. What this means is that these datums
have ways of interacting with a specific atom and control it. They posses a blackboard with the information the AI knows and has, and will plan behaviors it will try to execute through
multiple modular subtrees with behaviors
*/
/datum/ai_controller
///The atom this controller is controlling
var/atom/pawn
/**
* This is a list of variables the AI uses and can be mutated by actions.
*
* When an action is performed you pass this list and any relevant keys for the variables it can mutate.
*
* DO NOT set values in the blackboard directly, and especially not if you're adding a datum reference to this!
* Use the setters, this is important for reference handing.
*/
var/list/blackboard = list()
///Bitfield of traits for this AI to handle extra behavior
var/ai_traits = NONE
///Current actions planned to be performed by the AI in the upcoming plan
var/list/planned_behaviors
///Current actions being performed by the AI.
var/list/current_behaviors
///Current actions and their respective last time ran as an assoc list.
var/list/behavior_cooldowns = list()
///Current status of AI (OFF/ON)
var/ai_status
///Current movement target of the AI, generally set by decision making.
var/atom/current_movement_target
///Identifier for what last touched our movement target, so it can be cleared conditionally
var/movement_target_source
///Stored arguments for behaviors given during their initial creation
var/list/behavior_args = list()
///Tracks recent pathing attempts, if we fail too many in a row we fail our current plans.
var/consecutive_pathing_attempts
///Can the AI remain in control if there is a client?
var/continue_processing_when_client = FALSE
///distance to give up on target
var/max_target_distance = 14
///Cooldown for new plans, to prevent AI from going nuts if it can't think of new plans and looping on end
COOLDOWN_DECLARE(failed_planning_cooldown)
///All subtrees this AI has available, will run them in order, so make sure they're in the order you want them to run. On initialization of this type, it will start as a typepath(s) and get converted to references of ai_subtrees found in SSai_controllers when init_subtrees() is called
var/list/planning_subtrees
///The idle behavior this AI performs when it has no actions.
var/datum/idle_behavior/idle_behavior = null
///our current cell grid
var/datum/cell_tracker/our_cells
// Movement related things here
///Reference to the movement datum we use. Is a type on initialize but becomes a ref afterwards.
var/datum/ai_movement/ai_movement = /datum/ai_movement/dumb
///Delay between movements. This is on the controller so we can keep the movement datum singleton
var/movement_delay = 0.1 SECONDS
// The variables below are fucking stupid and should be put into the blackboard at some point.
///AI paused time
var/paused_until = 0
///Can this AI idle?
var/can_idle = TRUE
///What distance should we be checking for interesting things when considering idling/deidling? Defaults to AI_DEFAULT_INTERESTING_DIST
var/interesting_dist = AI_DEFAULT_INTERESTING_DIST
/datum/ai_controller/New(atom/new_pawn)
change_ai_movement_type(ai_movement)
init_subtrees()
if(idle_behavior)
idle_behavior = new idle_behavior()
if(!isnull(new_pawn)) // unit tests need the ai_controller to exist in isolation due to list schenanigans i hate it here
PossessPawn(new_pawn)
/datum/ai_controller/Destroy(force)
UnpossessPawn(FALSE)
our_cells = null
set_movement_target(type, null)
if(ai_movement.moving_controllers[src])
ai_movement.stop_moving_towards(src)
return ..()
///Sets the current movement target, with an optional param to override the movement behavior
/datum/ai_controller/proc/set_movement_target(source, atom/target, datum/ai_movement/new_movement)
movement_target_source = source
current_movement_target = target
if(new_movement)
change_ai_movement_type(new_movement)
///Overrides the current ai_movement of this controller with a new one
/datum/ai_controller/proc/change_ai_movement_type(datum/ai_movement/new_movement)
ai_movement = SSai_movement.movement_types[new_movement]
///Completely replaces the planning_subtrees with a new set based on argument provided, list provided must contain specifically typepaths
/datum/ai_controller/proc/replace_planning_subtrees(list/typepaths_of_new_subtrees)
planning_subtrees = typepaths_of_new_subtrees
init_subtrees()
///Loops over the subtrees in planning_subtrees and looks at the ai_controllers to grab a reference, ENSURE planning_subtrees ARE TYPEPATHS AND NOT INSTANCES/REFERENCES BEFORE EXECUTING THIS
/datum/ai_controller/proc/init_subtrees()
if(!LAZYLEN(planning_subtrees))
return
var/list/temp_subtree_list = list()
for(var/subtree in planning_subtrees)
var/subtree_instance = SSai_controllers.ai_subtrees[subtree]
temp_subtree_list += subtree_instance
planning_subtrees = temp_subtree_list
///Proc to move from one pawn to another, this will destroy the target's existing controller.
/datum/ai_controller/proc/PossessPawn(atom/new_pawn)
if(pawn) //Reset any old signals
UnpossessPawn(FALSE)
if(istype(new_pawn.ai_controller)) //Existing AI, kill it.
QDEL_NULL(new_pawn.ai_controller)
if(TryPossessPawn(new_pawn) & AI_CONTROLLER_INCOMPATIBLE)
qdel(src)
CRASH("[src] attached to [new_pawn] but these are not compatible!")
pawn = new_pawn
pawn.ai_controller = src
var/turf/pawn_turf = get_turf(pawn)
if(pawn_turf)
SSai_controllers.ai_controllers_by_zlevel[pawn_turf.z] += src
SEND_SIGNAL(src, COMSIG_AI_CONTROLLER_POSSESSED_PAWN)
reset_ai_status()
RegisterSignal(pawn, COMSIG_MOVABLE_Z_CHANGED, PROC_REF(on_changed_z_level))
RegisterSignal(pawn, COMSIG_MOB_STATCHANGE, PROC_REF(on_stat_changed))
RegisterSignal(pawn, COMSIG_MOB_LOGIN, PROC_REF(on_sentience_gained))
RegisterSignal(pawn, COMSIG_QDELETING, PROC_REF(on_pawn_qdeleted))
our_cells = new(interesting_dist, interesting_dist, 1)
set_new_cells()
RegisterSignal(pawn, COMSIG_MOVABLE_MOVED, PROC_REF(update_grid))
/datum/ai_controller/proc/update_grid(datum/source, datum/spatial_grid_cell/new_cell)
SIGNAL_HANDLER
set_new_cells()
/datum/ai_controller/proc/set_new_cells()
if(isnull(our_cells))
return
var/turf/our_turf = get_turf(pawn)
if(isnull(our_turf))
return
var/list/cell_collections = our_cells.recalculate_cells(our_turf)
for(var/datum/old_grid as anything in cell_collections[2])
UnregisterSignal(old_grid, list(SPATIAL_GRID_CELL_ENTERED(SPATIAL_GRID_CONTENTS_TYPE_CLIENTS), SPATIAL_GRID_CELL_EXITED(SPATIAL_GRID_CONTENTS_TYPE_CLIENTS)))
for(var/datum/spatial_grid_cell/new_grid as anything in cell_collections[1])
RegisterSignal(new_grid, SPATIAL_GRID_CELL_ENTERED(SPATIAL_GRID_CONTENTS_TYPE_CLIENTS), PROC_REF(on_client_enter))
RegisterSignal(new_grid, SPATIAL_GRID_CELL_EXITED(SPATIAL_GRID_CONTENTS_TYPE_CLIENTS), PROC_REF(on_client_exit))
recalculate_idle()
/datum/ai_controller/proc/should_idle()
if(!can_idle || isnull(our_cells))
return FALSE
for(var/datum/spatial_grid_cell/grid as anything in our_cells.member_cells)
if(length(grid.client_contents))
return FALSE
return TRUE
/datum/ai_controller/proc/recalculate_idle()
if(ai_status == AI_STATUS_OFF)
return
if(should_idle())
set_ai_status(AI_STATUS_IDLE)
/datum/ai_controller/proc/on_client_enter(datum/source, atom/target)
SIGNAL_HANDLER
if(ai_status == AI_STATUS_IDLE)
set_ai_status(AI_STATUS_ON)
/datum/ai_controller/proc/on_client_exit(datum/source, datum/exited)
SIGNAL_HANDLER
recalculate_idle()
/// Sets the AI on or off based on current conditions, call to reset after you've manually disabled it somewhere
/datum/ai_controller/proc/reset_ai_status()
set_ai_status(get_expected_ai_status())
/**
* Gets the AI status we expect the AI controller to be on at this current moment.
* Returns AI_STATUS_OFF if it's inhabited by a Client and shouldn't be, if it's dead and cannot act while dead, or is on a z level without clients.
* Returns AI_STATUS_ON otherwise.
*/
/datum/ai_controller/proc/get_expected_ai_status()
if (!ismob(pawn))
return AI_STATUS_ON
var/mob/living/mob_pawn = pawn
if(!continue_processing_when_client && mob_pawn.client)
return AI_STATUS_OFF
if(mob_pawn.stat == DEAD)
if(ai_traits & CAN_ACT_WHILE_DEAD)
return AI_STATUS_ON
return AI_STATUS_OFF
var/turf/pawn_turf = get_turf(mob_pawn)
#ifdef TESTING
if(!pawn_turf)
CRASH("AI controller [src] controlling pawn ([pawn]) is not on a turf.")
#endif
if(!length(SSmobs.clients_by_zlevel[pawn_turf.z]))
return AI_STATUS_OFF
if(should_idle())
return AI_STATUS_IDLE
return AI_STATUS_ON
/datum/ai_controller/proc/get_current_turf()
var/mob/living/mob_pawn = pawn
var/turf/pawn_turf = get_turf(mob_pawn)
to_chat(world, "[pawn_turf]")
///Called when the AI controller pawn changes z levels, we check if there's any clients on the new one and wake up the AI if there is.
/datum/ai_controller/proc/on_changed_z_level(atom/source, turf/old_turf, turf/new_turf, same_z_layer, notify_contents)
SIGNAL_HANDLER
var/mob/mob_pawn = pawn
if((mob_pawn?.client && !continue_processing_when_client))
return
if(old_turf)
SSai_controllers.ai_controllers_by_zlevel[old_turf.z] -= src
if(new_turf)
SSai_controllers.ai_controllers_by_zlevel[new_turf.z] += src
var/new_level_clients = SSmobs.clients_by_zlevel[new_turf.z].len
if(new_level_clients)
set_ai_status(AI_STATUS_IDLE)
else
set_ai_status(AI_STATUS_OFF)
///Abstract proc for initializing the pawn to the new controller
/datum/ai_controller/proc/TryPossessPawn(atom/new_pawn)
return
///Proc for deinitializing the pawn to the old controller
/datum/ai_controller/proc/UnpossessPawn(destroy)
if(isnull(pawn))
return // instantiated without an applicable pawn, fine
set_ai_status(AI_STATUS_OFF)
UnregisterSignal(pawn, list(COMSIG_MOVABLE_Z_CHANGED, COMSIG_MOB_LOGIN, COMSIG_MOB_LOGOUT, COMSIG_MOB_STATCHANGE, COMSIG_QDELETING))
if(ai_movement.moving_controllers[src])
ai_movement.stop_moving_towards(src)
var/turf/pawn_turf = get_turf(pawn)
if(pawn_turf)
SSai_controllers.ai_controllers_by_zlevel[pawn_turf.z] -= src
if(ai_status)
SSai_controllers.ai_controllers_by_status[ai_status] -= src
pawn.ai_controller = null
pawn = null
if(destroy)
qdel(src)
///Returns TRUE if the ai controller can actually run at the moment.
/datum/ai_controller/proc/able_to_run()
if(HAS_TRAIT(pawn, TRAIT_AI_PAUSED))
return FALSE
if(world.time < paused_until)
return FALSE
return TRUE
///Runs any actions that are currently running
/datum/ai_controller/process(seconds_per_tick)
if(!able_to_run())
DSmove_manager.stop_looping(pawn) //stop moving
return //this should remove them from processing in the future through event-based stuff.
if(!LAZYLEN(current_behaviors) && idle_behavior)
idle_behavior.perform_idle_behavior(seconds_per_tick, src) //Do some stupid shit while we have nothing to do
return
if(current_movement_target)
if(!isatom(current_movement_target))
stack_trace("[pawn]'s current movement target is not an atom, rather a [current_movement_target.type]! Did you accidentally set it to a weakref?")
CancelActions()
return
if(get_dist(pawn, current_movement_target) > max_target_distance) //The distance is out of range
CancelActions()
return
for(var/datum/ai_behavior/current_behavior as anything in current_behaviors)
// Convert the current behaviour action cooldown to realtime seconds from deciseconds.current_behavior
// Then pick the max of this and the seconds_per_tick passed to ai_controller.process()
// Action cooldowns cannot happen faster than seconds_per_tick, so seconds_per_tick should be the value used in this scenario.
var/action_seconds_per_tick = max(current_behavior.get_cooldown(src) * 0.1, seconds_per_tick)
if(current_behavior.behavior_flags & AI_BEHAVIOR_REQUIRE_MOVEMENT) //Might need to move closer
if(!current_movement_target)
stack_trace("[pawn] wants to perform action type [current_behavior.type] which requires movement, but has no current movement target!")
return //This can cause issues, so don't let these slide.
///Stops pawns from performing such actions that should require the target to be adjacent.
var/atom/movable/moving_pawn = pawn
var/can_reach = !(current_behavior.behavior_flags & AI_BEHAVIOR_REQUIRE_REACH) || moving_pawn.CanReach(current_movement_target)
if(can_reach && current_behavior.required_distance >= get_dist(moving_pawn, current_movement_target)) ///Are we close enough to engage?
if(ai_movement.moving_controllers[src] == current_movement_target) //We are close enough, if we're moving stop.
ai_movement.stop_moving_towards(src)
if(behavior_cooldowns[current_behavior] > world.time) //Still on cooldown
continue
ProcessBehavior(action_seconds_per_tick, current_behavior)
return
else if(ai_movement.moving_controllers[src] != current_movement_target) //We're too far, if we're not already moving start doing it.
ai_movement.start_moving_towards(src, current_movement_target, current_behavior.required_distance) //Then start moving
if(current_behavior.behavior_flags & AI_BEHAVIOR_MOVE_AND_PERFORM) //If we can move and perform then do so.
if(behavior_cooldowns[current_behavior] > world.time) //Still on cooldown
continue
ProcessBehavior(action_seconds_per_tick, current_behavior)
return
else //No movement required
if(behavior_cooldowns[current_behavior] > world.time) //Still on cooldown
continue
ProcessBehavior(action_seconds_per_tick, current_behavior)
return
///Determines whether the AI can currently make a new plan
/datum/ai_controller/proc/able_to_plan()
. = TRUE
if(QDELETED(pawn))
return FALSE
for(var/datum/ai_behavior/current_behavior as anything in current_behaviors)
if(!(current_behavior.behavior_flags & AI_BEHAVIOR_CAN_PLAN_DURING_EXECUTION)) //We have a behavior that blocks planning
. = FALSE
break
///This is where you decide what actions are taken by the AI.
/datum/ai_controller/proc/SelectBehaviors(seconds_per_tick)
SHOULD_NOT_SLEEP(TRUE) //Fuck you don't sleep in procs like this.
if(!COOLDOWN_FINISHED(src, failed_planning_cooldown))
return FALSE
LAZYINITLIST(current_behaviors)
LAZYCLEARLIST(planned_behaviors)
if(LAZYLEN(planning_subtrees))
for(var/datum/ai_planning_subtree/subtree as anything in planning_subtrees)
if(subtree.SelectBehaviors(src, seconds_per_tick) == SUBTREE_RETURN_FINISH_PLANNING)
break
SEND_SIGNAL(src, COMSIG_AI_CONTROLLER_PICKED_BEHAVIORS, current_behaviors, planned_behaviors)
for(var/datum/ai_behavior/forgotten_behavior as anything in current_behaviors - planned_behaviors)
var/list/arguments = list(src, FALSE)
var/list/stored_arguments = behavior_args[type]
if(stored_arguments)
arguments += stored_arguments
forgotten_behavior.finish_action(arglist(arguments))
///This proc handles changing ai status, and starts/stops processing if required.
/datum/ai_controller/proc/set_ai_status(new_ai_status)
if(ai_status == new_ai_status)
return FALSE //no change
//remove old status, if we've got one
if(ai_status)
SSai_controllers.ai_controllers_by_status[ai_status] -= src
ai_status = new_ai_status
SSai_controllers.ai_controllers_by_status[new_ai_status] += src
switch(ai_status)
if(AI_STATUS_ON)
START_PROCESSING(SSai_behaviors, src)
if(AI_STATUS_OFF, AI_STATUS_IDLE)
STOP_PROCESSING(SSai_behaviors, src)
CancelActions()
/datum/ai_controller/proc/PauseAi(time)
paused_until = world.time + time
/datum/ai_controller/proc/modify_cooldown(datum/ai_behavior/behavior, new_cooldown)
behavior_cooldowns[behavior] = new_cooldown
///Call this to add a behavior to the stack.
/datum/ai_controller/proc/queue_behavior(behavior_type, ...)
var/datum/ai_behavior/behavior = GET_AI_BEHAVIOR(behavior_type)
if(!behavior)
CRASH("Behavior [behavior_type] not found.")
var/list/arguments = args.Copy()
arguments[1] = src
if(LAZYACCESS(current_behaviors, behavior)) ///It's still in the plan, don't add it again to current_behaviors but do keep it in the planned behavior list so its not cancelled
LAZYADDASSOC(planned_behaviors, behavior, TRUE)
return
if(!behavior.setup(arglist(arguments)))
return
LAZYADDASSOC(current_behaviors, behavior, TRUE)
LAZYADDASSOC(planned_behaviors, behavior, TRUE)
arguments.Cut(1, 2)
if(length(arguments))
behavior_args[behavior_type] = arguments
else
behavior_args -= behavior_type
SEND_SIGNAL(src, AI_CONTROLLER_BEHAVIOR_QUEUED(behavior_type), arguments)
/datum/ai_controller/proc/ProcessBehavior(seconds_per_tick, datum/ai_behavior/behavior)
var/list/arguments = list(seconds_per_tick, src)
var/list/stored_arguments = behavior_args[behavior.type]
if(stored_arguments)
arguments += stored_arguments
var/process_flags = behavior.perform(arglist(arguments))
if(process_flags & AI_BEHAVIOR_DELAY)
behavior_cooldowns[behavior] = world.time + behavior.get_cooldown(src)
if(process_flags & AI_BEHAVIOR_FAILED)
arguments[1] = src
arguments[2] = FALSE
behavior.finish_action(arglist(arguments))
else if (process_flags & AI_BEHAVIOR_SUCCEEDED)
arguments[1] = src
arguments[2] = TRUE
behavior.finish_action(arglist(arguments))
/datum/ai_controller/proc/CancelActions()
if(!LAZYLEN(current_behaviors))
return
for(var/datum/ai_behavior/current_behavior as anything in current_behaviors)
var/list/arguments = list(src, FALSE)
var/list/stored_arguments = behavior_args[current_behavior.type]
if(stored_arguments)
arguments += stored_arguments
current_behavior.finish_action(arglist(arguments))
/// Turn the controller on or off based on if you're alive, we only register to this if the flag is present so don't need to check again
/datum/ai_controller/proc/on_stat_changed(mob/living/source, new_stat)
SIGNAL_HANDLER
reset_ai_status()
/datum/ai_controller/proc/on_sentience_gained()
SIGNAL_HANDLER
UnregisterSignal(pawn, COMSIG_MOB_LOGIN)
if(!continue_processing_when_client)
set_ai_status(AI_STATUS_OFF) //Can't do anything while player is connected
RegisterSignal(pawn, COMSIG_MOB_LOGOUT, PROC_REF(on_sentience_lost))
/datum/ai_controller/proc/on_sentience_lost()
SIGNAL_HANDLER
UnregisterSignal(pawn, COMSIG_MOB_LOGOUT)
set_ai_status(AI_STATUS_IDLE) //Can't do anything while player is connected
RegisterSignal(pawn, COMSIG_MOB_LOGIN, PROC_REF(on_sentience_gained))
// Turn the controller off if the pawn has been qdeleted
/datum/ai_controller/proc/on_pawn_qdeleted()
SIGNAL_HANDLER
set_ai_status(AI_STATUS_OFF)
set_movement_target(type, null)
if(ai_movement.moving_controllers[src])
ai_movement.stop_moving_towards(src)
/// Use this proc to define how your controller defines what access the pawn has for the sake of pathfinding. Return the access list you want to use
/datum/ai_controller/proc/get_access()
return
///Returns the minimum required distance to preform one of our current behaviors. Honestly this should just be cached or something but fuck you
/datum/ai_controller/proc/get_minimum_distance()
var/minimum_distance = max_target_distance
// right now I'm just taking the shortest minimum distance of our current behaviors, at some point in the future
// we should let whatever sets the current_movement_target also set the min distance and max path length
// (or at least cache it on the controller)
for(var/datum/ai_behavior/iter_behavior as anything in current_behaviors)
if(iter_behavior.required_distance < minimum_distance)
minimum_distance = iter_behavior.required_distance
return minimum_distance
/// Returns true if we have a blackboard key with the provided key and it is not qdeleting
/datum/ai_controller/proc/blackboard_key_exists(key)
var/datum/key_value = blackboard[key]
if (isdatum(key_value))
return !QDELETED(key_value)
if (islist(key_value))
return length(key_value) > 0
return !!key_value
/**
* Used to manage references to datum by AI controllers
*
* * tracked_datum - something being added to an ai blackboard
* * key - the associated key
*/
#define TRACK_AI_DATUM_TARGET(tracked_datum, key) do { \
if(isweakref(tracked_datum)) { \
var/datum/weakref/_bad_weakref = tracked_datum; \
stack_trace("Weakref (Actual datum: [_bad_weakref.resolve()]) found in ai datum blackboard! \
This is an outdated method of ai reference handling, please remove it."); \
}; \
else if(isdatum(tracked_datum)) { \
var/datum/_tracked_datum = tracked_datum; \
if(!HAS_TRAIT_FROM(_tracked_datum, TRAIT_AI_TRACKING, "[REF(src)]_[key]")) { \
RegisterSignal(_tracked_datum, COMSIG_QDELETING, PROC_REF(sig_remove_from_blackboard), override = TRUE); \
ADD_TRAIT(_tracked_datum, TRAIT_AI_TRACKING, "[REF(src)]_[key]"); \
}; \
}; \
} while(FALSE)
/**
* Used to clear previously set reference handing by AI controllers
*
* * tracked_datum - something being removed from an ai blackboard
* * key - the associated key
*/
#define CLEAR_AI_DATUM_TARGET(tracked_datum, key) do { \
if(isdatum(tracked_datum)) { \
var/datum/_tracked_datum = tracked_datum; \
REMOVE_TRAIT(_tracked_datum, TRAIT_AI_TRACKING, "[REF(src)]_[key]"); \
if(!HAS_TRAIT(_tracked_datum, TRAIT_AI_TRACKING)) { \
UnregisterSignal(_tracked_datum, COMSIG_QDELETING); \
}; \
}; \
} while(FALSE)
/// Used for above to track all the keys that have registered a signal
#define TRAIT_AI_TRACKING "tracked_by_ai"
/**
* Sets the key to the passed "thing".
*
* * key - A blackboard key
* * thing - a value to set the blackboard key to.
*/
/datum/ai_controller/proc/set_blackboard_key(key, thing)
// Assume it is an error when trying to set a value overtop a list
if(islist(blackboard[key]))
CRASH("set_blackboard_key attempting to set a blackboard value to key [key] when it's a list!")
// Don't do anything if it's already got this value
if (blackboard[key] == thing)
return
// Clear existing values
if(!isnull(blackboard[key]))
clear_blackboard_key(key)
TRACK_AI_DATUM_TARGET(thing, key)
blackboard[key] = thing
post_blackboard_key_set(key)
/**
* Helper to force a key to be a certain thing no matter what's already there
*
* Useful for if you're overriding a list with a new list entirely,
* as otherwise it would throw a runtime error from trying to override a list
*
* Not necessary to use if you aren't dealing with lists, as set_blackboard_key will clear the existing value
* in that case already, but may be useful for clarity.
*
* * key - A blackboard key
* * thing - a value to set the blackboard key to.
*/
/datum/ai_controller/proc/override_blackboard_key(key, thing)
if(blackboard[key] == thing)
return
clear_blackboard_key(key)
set_blackboard_key(key, thing)
/**
* Sets the key at index thing to the passed value
*
* Assumes the key value is already a list, if not throws an error.
*
* * key - A blackboard key, with its value set to a list
* * thing - a value which becomes the inner list value's key
* * value - what to set the inner list's value to
*/
/datum/ai_controller/proc/set_blackboard_key_assoc(key, thing, value)
if(!islist(blackboard[key]))
CRASH("set_blackboard_key_assoc called on non-list key [key]!")
// Don't do anything if it's already got this value
if (blackboard[key][thing] == value)
return
TRACK_AI_DATUM_TARGET(thing, key)
TRACK_AI_DATUM_TARGET(value, key)
blackboard[key][thing] = value
post_blackboard_key_set(key)
/**
* Similar to [proc/set_blackboard_key_assoc] but operates under the assumption the key is a lazylist (so it will create a list)
* More dangerous / easier to override values, only use when you want to use a lazylist
*
* * key - A blackboard key, with its value set to a list
* * thing - a value which becomes the inner list value's key
* * value - what to set the inner list's value to
*/
/datum/ai_controller/proc/set_blackboard_key_assoc_lazylist(key, thing, value)
LAZYINITLIST(blackboard[key])
// Don't do anything if it's already got this value
if (blackboard[key][thing] == value)
return
TRACK_AI_DATUM_TARGET(thing, key)
TRACK_AI_DATUM_TARGET(value, key)
blackboard[key][thing] = value
post_blackboard_key_set(key)
/**
* Called after we set a blackboard key, forwards signal information.
*/
/datum/ai_controller/proc/post_blackboard_key_set(key)
if (isnull(pawn))
return
SEND_SIGNAL(pawn, COMSIG_AI_BLACKBOARD_KEY_SET(key))
/**
* Adds the passed "thing" to the associated key
*
* Works with lists or numbers, but not lazylists.
*
* * key - A blackboard key
* * thing - a value to set the blackboard key to.
*/
/datum/ai_controller/proc/add_blackboard_key(key, thing)
TRACK_AI_DATUM_TARGET(thing, key)
blackboard[key] += thing
/**
* Similar to [proc/add_blackboard_key], but performs an insertion rather than an add
* Throws an error if the key is not a list already, intended only for use with lists
*
* * key - A blackboard key, with its value set to a list
* * thing - a value to set the blackboard key to.
*/
/datum/ai_controller/proc/insert_blackboard_key(key, thing)
if(!islist(blackboard[key]))
CRASH("insert_blackboard_key called on non-list key [key]!")
TRACK_AI_DATUM_TARGET(thing, key)
blackboard[key] |= thing
/**
* Adds the passed "thing" to the associated key, assuming key is intended to be a lazylist (so it will create a list)
* More dangerous / easier to override values, only use when you want to use a lazylist
*
* * key - A blackboard key
* * thing - a value to set the blackboard key to.
*/
/datum/ai_controller/proc/add_blackboard_key_lazylist(key, thing)
LAZYINITLIST(blackboard[key])
TRACK_AI_DATUM_TARGET(thing, key)
blackboard[key] += thing
/**
* Similar to [proc/insert_blackboard_key_lazylist], but performs an insertion / or rather than an add
*
* * key - A blackboard key
* * thing - a value to set the blackboard key to.
*/
/datum/ai_controller/proc/insert_blackboard_key_lazylist(key, thing)
LAZYINITLIST(blackboard[key])
TRACK_AI_DATUM_TARGET(thing, key)
blackboard[key] |= thing
/**
* Adds the value to the inner list at key with the inner key set to "thing"
* Throws an error if the key is not a list already, intended only for use with lists
*
* * key - A blackboard key, with its value set to a list
* * thing - a value which becomes the inner list value's key
* * value - what to set the inner list's value to
*/
/datum/ai_controller/proc/add_blackboard_key_assoc(key, thing, value)
if(!islist(blackboard[key]))
CRASH("add_blackboard_key_assoc called on non-list key [key]!")
TRACK_AI_DATUM_TARGET(thing, key)
TRACK_AI_DATUM_TARGET(value, key)
blackboard[key][thing] += value
/**
* Similar to [proc/add_blackboard_key_assoc], assuming key is intended to be a lazylist (so it will create a list)
* More dangerous / easier to override values, only use when you want to use a lazylist
*
* * key - A blackboard key, with its value set to a list
* * thing - a value which becomes the inner list value's key
* * value - what to set the inner list's value to
*/
/datum/ai_controller/proc/add_blackboard_key_assoc_lazylist(key, thing, value)
LAZYINITLIST(blackboard[key])
TRACK_AI_DATUM_TARGET(thing, key)
TRACK_AI_DATUM_TARGET(value, key)
blackboard[key][thing] += value
/**
* Clears the passed key, resetting it to null
*
* Not intended for use with list keys - use [proc/remove_thing_from_blackboard_key] if you are removing a value from a list at a key
*
* * key - A blackboard key
*/
/datum/ai_controller/proc/clear_blackboard_key(key)
if(isnull(blackboard[key]))
return
CLEAR_AI_DATUM_TARGET(blackboard[key], key)
blackboard[key] = null
if(isnull(pawn))
return
SEND_SIGNAL(pawn, COMSIG_AI_BLACKBOARD_KEY_CLEARED(key))
/**
* Remove the passed thing from the associated blackboard key
*
* Intended for use with lists, if you're just clearing a reference from a key use [proc/clear_blackboard_key]
*
* * key - A blackboard key
* * thing - a value to set the blackboard key to.
*/
/datum/ai_controller/proc/remove_thing_from_blackboard_key(key, thing)
var/associated_value = blackboard[key]
if(thing == associated_value)
stack_trace("remove_thing_from_blackboard_key was called un-necessarily in a situation where clear_blackboard_key would suffice. ")
clear_blackboard_key(key)
return
if(!islist(associated_value))
CRASH("remove_thing_from_blackboard_key called with an invalid \"thing\" argument ([thing]). \
(The associated value of the passed key is not a list and is also not the passed thing, meaning it is clearing an unintended value.)")
for(var/inner_key in associated_value)
if(inner_key == thing)
// flat list
CLEAR_AI_DATUM_TARGET(thing, key)
associated_value -= thing
return
else if(associated_value[inner_key] == thing)
// assoc list
CLEAR_AI_DATUM_TARGET(thing, key)
associated_value -= inner_key
return
CRASH("remove_thing_from_blackboard_key called with an invalid \"thing\" argument ([thing]). \
(The passed value is not tracked in the passed list.)")
/// Signal proc to go through every key and remove the datum from all keys it finds
/datum/ai_controller/proc/sig_remove_from_blackboard(datum/source)
SIGNAL_HANDLER
var/list/list/remove_queue = list(blackboard)
var/index = 1
while(index <= length(remove_queue))
var/list/next_to_clear = remove_queue[index]
for(var/inner_value in next_to_clear)
var/associated_value = next_to_clear[inner_value]
// We are a lists of lists, add the next value to the queue so we can handle references in there
// (But we only need to bother checking the list if it's not empty.)
if(islist(inner_value) && length(inner_value))
UNTYPED_LIST_ADD(remove_queue, inner_value)
// We found the value that's been deleted. Clear it out from this list
else if(inner_value == source)
next_to_clear -= inner_value
// We are an assoc lists of lists, the list at the next value so we can handle references in there
// (But again, we only need to bother checking the list if it's not empty.)
if(islist(associated_value) && length(associated_value))
UNTYPED_LIST_ADD(remove_queue, associated_value)
// We found the value that's been deleted, it was an assoc value. Clear it out entirely
else if(associated_value == source)
next_to_clear -= inner_value
SEND_SIGNAL(pawn, COMSIG_AI_BLACKBOARD_KEY_CLEARED(inner_value))
index += 1
#undef TRACK_AI_DATUM_TARGET
#undef CLEAR_AI_DATUM_TARGET
#undef TRAIT_AI_TRACKING