KlemenPl/PixelDefense
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Refactor behaviour_tree (more consistent naming), fix BT visualization

Browse Source
This commit is contained in:
Klemen Plestenjak
2024-01-11 07:35:58 +01:00
parent 086ee5b348
commit 2f2974fb77
4 changed files with 135 additions and 97 deletions
Download Patch File Download Diff File Expand all files Collapse all files

36
engine/breeze/ai/behaviour_tree.c
View File

@@ -61,9 +61,9 @@ const char *bzBTNodeTypeToStr(BzBTNodeType type) {
return "SELECTOR";
case BZ_BT_COMP_SEQUENCE:
return "SEQUENCE";
case BZ_BT_COMP_PARALLEL_SELECTOR:
case BZ_BT_COMP_P_SELECTOR:
return "P_SELECTOR";
case BZ_BT_COMP_PARALLEL_SEQUENCE:
case BZ_BT_COMP_P_SEQUENCE:
return "P_SEQUENCE";
case BZ_BT_DECOR_DUMMY:
return "DUMMY";
@@ -126,13 +126,13 @@ void bzBTDestroyRoot(BzObjectPool *nodePool, BzBTNode *node) {
BzBTNode *bzBTCompSelector(BzObjectPool *nodePool, BzBTNode *parent, bool parallel) {
BzBTNodeType type = parallel ?
BZ_BT_COMP_PARALLEL_SELECTOR :
BZ_BT_COMP_P_SELECTOR :
BZ_BT_COMP_SELECTOR;
return bzBTNodeMake(nodePool, parent, type);
}
BzBTNode *bzBTCompSequence(BzObjectPool *nodePool, BzBTNode *parent, bool parallel) {
BzBTNodeType type = parallel ?
BZ_BT_COMP_PARALLEL_SEQUENCE :
BZ_BT_COMP_P_SEQUENCE :
BZ_BT_COMP_SEQUENCE;
return bzBTNodeMake(nodePool, parent, type);
}
@@ -215,9 +215,9 @@ BzBTNode *bzBTCompStateGetRunningChild(const BzBTNodeState *state) {
BZ_ASSERT(state->node);
BzBTNodeType type = state->node->type;
bool isComposite = type == BZ_BT_COMP_SELECTOR ||
type == BZ_BT_COMP_PARALLEL_SELECTOR ||
type == BZ_BT_COMP_P_SELECTOR ||
type == BZ_BT_COMP_SEQUENCE ||
type == BZ_BT_COMP_PARALLEL_SEQUENCE;
type == BZ_BT_COMP_P_SEQUENCE;
BZ_ASSERT(isComposite);
return state->as.composite.running;
}
@@ -366,8 +366,8 @@ static inline BzBTExecReturn bzBTExecuteComposite(const BzBTNode *node, f32 dt,
BzBTExecState *state, BzObjectPool *statePool) {
BzBTNodeState *nodeState = getNodeState(node, state);
bool isParallel = node->type == BZ_BT_COMP_PARALLEL_SEQUENCE ||
node->type == BZ_BT_COMP_PARALLEL_SELECTOR;
bool isParallel = node->type == BZ_BT_COMP_P_SEQUENCE ||
node->type == BZ_BT_COMP_P_SELECTOR;
BzBTNode *start = node->first;
if (!isParallel && nodeState)
@@ -384,7 +384,7 @@ static inline BzBTExecReturn bzBTExecuteComposite(const BzBTNode *node, f32 dt,
if (childReturn.status == BZ_BT_RUNNING) {
execStateMerge(&execReturn.state, &childReturn.state);
}
BZ_ASSERT(childReturn.state.first == NULL);
BZ_ASSERT(childReturn.state.first == NULL && childReturn.state.last == NULL);
numChildren++;
switch (childReturn.status) {
case BZ_BT_RUNNING:
@@ -401,12 +401,12 @@ static inline BzBTExecReturn bzBTExecuteComposite(const BzBTNode *node, f32 dt,
}
switch (node->type) {
case BZ_BT_COMP_SELECTOR:
case BZ_BT_COMP_PARALLEL_SELECTOR:
case BZ_BT_COMP_P_SELECTOR:
if (childReturn.status == BZ_BT_SUCCESS)
execReturn.status = BZ_BT_SUCCESS;
break;
case BZ_BT_COMP_SEQUENCE:
case BZ_BT_COMP_PARALLEL_SEQUENCE:
case BZ_BT_COMP_P_SEQUENCE:
if (childReturn.status == BZ_BT_FAIL)
execReturn.status = BZ_BT_FAIL;
break;
@@ -415,19 +415,20 @@ static inline BzBTExecReturn bzBTExecuteComposite(const BzBTNode *node, f32 dt,
}
if (execReturn.status == BZ_BT_FAIL || execReturn.status == BZ_BT_SUCCESS)
break;
if (numRunning > 0 && !isParallel) {
if (numRunning > 0) {
execReturn.status = BZ_BT_RUNNING;
break;
if (!isParallel)
break;
}
}
switch (node->type) {
case BZ_BT_COMP_SELECTOR:
case BZ_BT_COMP_PARALLEL_SELECTOR:
case BZ_BT_COMP_P_SELECTOR:
if (numFailed == numChildren)
execReturn.status = BZ_BT_FAIL;
break;
case BZ_BT_COMP_SEQUENCE:
case BZ_BT_COMP_PARALLEL_SEQUENCE:
case BZ_BT_COMP_P_SEQUENCE:
if (numSuccessful == numChildren)
execReturn.status = BZ_BT_SUCCESS;
break;
@@ -450,6 +451,7 @@ static inline BzBTExecReturn bzBTExecuteComposite(const BzBTNode *node, f32 dt,
return execReturn;
}
BZ_ASSERT(execReturn.status == BZ_BT_RUNNING);
// Parallels don't utilize state but still require it for correct tree traversal.
nodeState = ensureValidNodeState(node, statePool, nodeState);
nodeState->as.composite.running = child;
execStatePushFront(&execReturn.state, nodeState);
@@ -557,8 +559,8 @@ static inline BzBTExecReturn bzBTExecuteNode(const BzBTNode *node, f32 dt,
switch (node->type) {
case BZ_BT_COMP_SELECTOR:
case BZ_BT_COMP_SEQUENCE:
case BZ_BT_COMP_PARALLEL_SELECTOR:
case BZ_BT_COMP_PARALLEL_SEQUENCE:
case BZ_BT_COMP_P_SELECTOR:
case BZ_BT_COMP_P_SEQUENCE:
execReturn = bzBTExecuteComposite(node, dt, nodeState, statePool);
break;
case BZ_BT_DECOR_DUMMY:

4
engine/breeze/ai/behaviour_tree.h
View File

@@ -18,8 +18,8 @@ typedef enum BzBTNodeType {
// Composite
BZ_BT_COMP_SELECTOR,
BZ_BT_COMP_SEQUENCE,
BZ_BT_COMP_PARALLEL_SELECTOR,
BZ_BT_COMP_PARALLEL_SEQUENCE,
BZ_BT_COMP_P_SELECTOR,
BZ_BT_COMP_P_SEQUENCE,
// Decorator
BZ_BT_DECOR_DUMMY,
BZ_BT_DECOR_SUCCESS,

161
engine/tests/btree_test.c
View File

@@ -26,7 +26,10 @@ bool init(int *game) {
// delay 1s
// print "Hello, world!"
printBT = bzBTMakeRoot(nodePool);
BzBTNode *node = bzBTDecorRepeat(nodePool, printBT, 5);
BzBTNode *pseq = bzBTCompSequence(nodePool, printBT, true);
bzBTDecorDelay(nodePool, pseq, 2.0f);
BzBTNode *node = bzBTDecorRepeat(nodePool, pseq, 5);
BzBTNode *seq = bzBTCompSequence(nodePool, node, false);
@@ -48,78 +51,14 @@ void deinit(int *game) {
bzObjectPoolDestroy(nodeStatePool);
}
void igVisualizeBTState(const BzBTNode *node, const BzBTNodeState *state, bool sameLine, i32 depth) {
const BzBTNode *child = bzBTNodeChild(node);
BzBTNodeType type = bzBTGetNodeType(node);
char extraInfo[128];
extraInfo[0] = '\0';
bool hasState = bzBTNodeMatchesState(node, state);
switch (type) {
case BZ_BT_DECOR_REPEAT:
if (hasState) {
snprintf(extraInfo, sizeof(extraInfo), " (%d < %d)",
bzBTRepeatStateGetIter(state),
bzBTDecorGetRepeat(node));
} else {
snprintf(extraInfo, sizeof(extraInfo), " (%d)", bzBTDecorGetRepeat(node));
}
break;
case BZ_BT_DECOR_DELAY:
if (hasState) {
snprintf(extraInfo, sizeof(extraInfo), " (%.2f < %.2fms)",
bzBTDelayStateGetElapsed(state),
bzBTDecorGetDelay(node));
} else {
snprintf(extraInfo, sizeof(extraInfo), " (%.2fms)", bzBTDecorGetDelay(node));
}
break;
case BZ_BT_ACTION:
snprintf(extraInfo, sizeof(extraInfo), " (%s:%p)",
bzBTNodeGetName(node) ? bzBTNodeGetName(node) : "?",
bzBTActionGetFn(node));
break;
default:
break;
}
if (hasState)
state = bzBTNodeStateNext(state);
ImVec4 color = {1.0f, 1.0f, 1.0f, 1.0f};
if (hasState)
color = (ImVec4) {1.0f, 1.0f, 0.5f, 1.0f};
bool hasSingleChild = false;
if (child && bzBTNodeNext(child) == NULL) hasSingleChild = true;
const char *suffix = hasSingleChild ? " > " : ": ";
if (sameLine) {
igTextColored(color, "%s%s%s", bzBTNodeTypeToStr(type),
extraInfo, suffix);
} else {
igTextColored(color, "%*s%s %s",
depth * 2, "",
bzBTNodeTypeToStr(type), extraInfo, suffix);
depth++;
}
while (child) {
if (hasSingleChild) igSameLine(0, 0);
igVisualizeBTState(child, state, hasSingleChild, depth);
child = bzBTNodeNext(child);
}
}
void igVisualizeBTState(const BzBTNode *node, const BzBTNodeState *state,
bool isActive, bool sameLine, i32 depth);
void igRenderBT(BzBTState *state) {
const BzBTNode *root = state->root;
if (igBegin("BehaviourTree", NULL, 0)) {
igText("NodeState pool: %d", bzObjectPoolGetNumFree(nodeStatePool));
igSeparatorText("");
igVisualizeBTState(root, state->_first, false, 0);
igVisualizeBTState(root, state->_first, true, false, 0);
}
igEnd();
}
@@ -143,3 +82,89 @@ bool bzMain(BzAppDesc *appDesc, int argc, const char **argv) {
return true;
}
static const BzBTNodeState *findNodeState(const BzBTNode *node, const BzBTNodeState *state) {
const BzBTNodeState *pState = state;
// Although it's painfully slow, it serves as a debug tool,
// so speed is not a critical concern.
while (pState) {
const BzBTNodeState *next = bzBTNodeStateNext(pState);
if (bzBTNodeMatchesState(node, pState))
return pState;
pState = next;
}
return NULL;
}
void igVisualizeBTState(const BzBTNode *node, const BzBTNodeState *state,
bool isActive, bool sameLine, i32 depth) {
const BzBTNode *child = bzBTNodeChild(node);
BzBTNodeType type = bzBTGetNodeType(node);
char extraInfo[128];
extraInfo[0] = '\0';
const BzBTNodeState *nodeState = findNodeState(node, state);
bool hasState = nodeState != NULL;
isActive |= hasState;
switch (type) {
case BZ_BT_DECOR_REPEAT:
if (hasState) {
snprintf(extraInfo, sizeof(extraInfo), " (%d < %d)",
bzBTRepeatStateGetIter(nodeState),
bzBTDecorGetRepeat(node));
} else {
snprintf(extraInfo, sizeof(extraInfo), " (%d)", bzBTDecorGetRepeat(node));
}
break;
case BZ_BT_DECOR_DELAY:
if (hasState) {
snprintf(extraInfo, sizeof(extraInfo), " (%.2f < %.2fms)",
bzBTDelayStateGetElapsed(nodeState),
bzBTDecorGetDelay(node));
} else {
snprintf(extraInfo, sizeof(extraInfo), " (%.2fms)", bzBTDecorGetDelay(node));
}
break;
case BZ_BT_ACTION:
snprintf(extraInfo, sizeof(extraInfo), " (%s:%p)",
bzBTNodeGetName(node) ? bzBTNodeGetName(node) : "?",
bzBTActionGetFn(node));
break;
default:
break;
}
ImVec4 color = {1.0f, 1.0f, 1.0f, 1.0f};
if (isActive)
color = (ImVec4) {1.0f, 1.0f, 0.5f, 1.0f};
bool hasSingleChild = true;
if (child && bzBTNodeNext(child)) hasSingleChild = false;
const char *suffix = hasSingleChild ? " > " : ": ";
if (sameLine) {
igTextColored(color, "%s%s%s", bzBTNodeTypeToStr(type),
extraInfo, suffix);
} else {
igTextColored(color, "%*s%s %s",
depth * 2, "",
bzBTNodeTypeToStr(type), extraInfo, suffix);
depth++;
}
bool isComposite = type == BZ_BT_COMP_SELECTOR ||
type == BZ_BT_COMP_P_SELECTOR ||
type == BZ_BT_COMP_SEQUENCE ||
type == BZ_BT_COMP_P_SEQUENCE;
while (child) {
if (hasSingleChild) igSameLine(0, 0);
bool childActive = isActive && hasSingleChild;
if (hasState && isComposite && !childActive)
childActive = bzBTCompStateGetRunningChild(state) == child;
igVisualizeBTState(child, state, childActive, hasSingleChild, depth);
child = bzBTNodeNext(child);
}
}