2019-04-14 20:45:32 +00:00
|
|
|
#include <basin/ai.h>
|
|
|
|
#include <basin/entity.h>
|
|
|
|
#include <basin/world.h>
|
|
|
|
#include <basin/game.h>
|
2019-09-07 22:32:04 +00:00
|
|
|
#include <avuna/list.h>
|
2019-04-14 20:45:32 +00:00
|
|
|
#include <avuna/hash.h>
|
2019-09-07 22:32:04 +00:00
|
|
|
#include <avuna/string.h>
|
2017-02-13 19:04:24 +00:00
|
|
|
#include <math.h>
|
|
|
|
|
|
|
|
void initai_zombie(struct world* world, struct entity* entity) {
|
2019-09-07 22:32:04 +00:00
|
|
|
struct aitask* task = ai_initTask(entity, 4, &ai_swimming, &ai_shouldswimming, NULL);
|
|
|
|
struct ai_nearestattackabletarget_data* and = pcalloc(task->pool, sizeof(struct ai_nearestattackabletarget_data));
|
2019-05-01 10:26:21 +00:00
|
|
|
and->chance = 10;
|
|
|
|
and->type = ENT_PLAYER;
|
|
|
|
and->checkSight = 1;
|
|
|
|
and->unseenTicks = 0;
|
|
|
|
and->targetSearchDelay = 0;
|
|
|
|
and->targetDist = 16.;
|
|
|
|
ai_initTask(entity, 1, &ai_nearestattackabletarget, &ai_shouldnearestattackabletarget, and);
|
2019-09-07 22:32:04 +00:00
|
|
|
and = pcalloc(task->pool, sizeof(struct ai_nearestattackabletarget_data));
|
2019-05-01 10:26:21 +00:00
|
|
|
and->chance = 10;
|
|
|
|
and->type = ENT_VILLAGER;
|
|
|
|
and->checkSight = 0;
|
|
|
|
and->unseenTicks = 0;
|
|
|
|
and->targetSearchDelay = 0;
|
|
|
|
and->targetDist = 16.;
|
|
|
|
ai_initTask(entity, 1, &ai_nearestattackabletarget, &ai_shouldnearestattackabletarget, and);
|
2019-09-07 22:32:04 +00:00
|
|
|
and = pcalloc(task->pool, sizeof(struct ai_nearestattackabletarget_data));
|
2019-05-01 10:26:21 +00:00
|
|
|
and->chance = 10;
|
|
|
|
and->type = ENT_VILLAGERGOLEM;
|
|
|
|
and->checkSight = 1;
|
|
|
|
and->unseenTicks = 0;
|
|
|
|
and->targetSearchDelay = 0;
|
|
|
|
and->targetDist = 16.;
|
|
|
|
ai_initTask(entity, 1, &ai_nearestattackabletarget, &ai_shouldnearestattackabletarget, and);
|
2019-09-07 22:32:04 +00:00
|
|
|
struct ai_attackmelee_data* amd = pcalloc(task->pool, sizeof(struct ai_attackmelee_data));
|
2019-05-01 10:26:21 +00:00
|
|
|
amd->attackInterval = 20;
|
|
|
|
amd->speed = 1.;
|
|
|
|
amd->longMemory = 0;
|
|
|
|
ai_initTask(entity, 4, &ai_zombieattack, &ai_shouldzombieattack, amd);
|
2017-02-13 19:04:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void ai_stdcancel(struct world* world, struct entity* entity, struct aitask* ai) {
|
2019-05-01 10:26:21 +00:00
|
|
|
if (!ai->ai_running) return;
|
|
|
|
entity->ai->mutex &= ~ai->mutex;
|
|
|
|
ai->ai_running = 0;
|
2017-02-13 19:04:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
struct aitask* ai_initTask(struct entity* entity, uint16_t mutex, int32_t (*ai_tick)(struct world* world, struct entity* entity, struct aitask* ai), int (*ai_should)(struct world* world, struct entity* entity, struct aitask* ai), void* data) {
|
2019-09-07 22:32:04 +00:00
|
|
|
struct mempool* ai_pool = mempool_new();
|
|
|
|
pchild(entity->pool, ai_pool);
|
|
|
|
struct aitask* ai = pcalloc(ai_pool, sizeof(struct aitask));
|
|
|
|
ai->pool = ai_pool;
|
2019-05-01 10:26:21 +00:00
|
|
|
ai->ai_running = 0;
|
|
|
|
ai->ai_waiting = 0;
|
|
|
|
ai->mutex = mutex;
|
|
|
|
ai->ai_should = ai_should;
|
|
|
|
ai->ai_tick = ai_tick;
|
|
|
|
ai->ai_cancel = &ai_stdcancel;
|
|
|
|
ai->data = data;
|
2019-09-07 22:32:04 +00:00
|
|
|
hashmap_putptr(entity->ai->tasks, ai, ai);
|
2019-05-01 10:26:21 +00:00
|
|
|
return ai;
|
2017-02-13 19:04:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int32_t ai_handletasks(struct world* world, struct entity* entity) {
|
2019-05-01 10:26:21 +00:00
|
|
|
if (entity->ai == NULL) return 0;
|
|
|
|
int32_t mw = 0;
|
2019-09-07 22:32:04 +00:00
|
|
|
ITER_MAP(entity->ai->tasks) {
|
|
|
|
struct aitask* ai = value;
|
|
|
|
if (ai->ai_running) {
|
|
|
|
if (ai->ai_waiting == -1) (*ai->ai_cancel)(world, entity, ai);
|
|
|
|
else if (ai->ai_waiting > 0) ai->ai_waiting--;
|
|
|
|
else if (ai->ai_tick != NULL) {
|
|
|
|
if (!(*ai->ai_should)(world, entity, ai)) (*ai->ai_cancel)(world, entity, ai);
|
|
|
|
else ai->ai_waiting = (*ai->ai_tick)(world, entity, ai);
|
|
|
|
}
|
|
|
|
} else if (ai->ai_should != NULL && !(ai->mutex & entity->ai->mutex) && (*ai->ai_should)(world, entity, ai)) {
|
|
|
|
ai->ai_waiting = 0;
|
|
|
|
entity->ai->mutex |= ai->mutex;
|
|
|
|
ai->ai_waiting = (*ai->ai_tick)(world, entity, ai);
|
|
|
|
ai->ai_running = 1;
|
2019-05-01 10:26:21 +00:00
|
|
|
}
|
2019-09-07 22:32:04 +00:00
|
|
|
if (ai->ai_waiting > mw) mw = ai->ai_waiting;
|
|
|
|
ITER_MAP_END();
|
2019-05-01 10:26:21 +00:00
|
|
|
}
|
|
|
|
return mw;
|
2017-02-13 19:04:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
float wrapAngle(float angle) {
|
2019-05-01 10:26:21 +00:00
|
|
|
angle = fmod(angle, 360.);
|
|
|
|
if (angle >= 180.) angle -= 360.;
|
|
|
|
if (angle < -180.) angle += 360.;
|
|
|
|
return angle;
|
2017-02-13 19:04:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void lookHelper_tick(struct entity* entity) {
|
2019-05-01 10:26:21 +00:00
|
|
|
if (entity->ai == NULL || entity->ai->lookHelper_speedPitch == 0. || entity->ai->lookHelper_speedYaw == 0.) return;
|
|
|
|
double dx = entity->ai->lookHelper_x - entity->x;
|
|
|
|
struct boundingbox bb;
|
2019-05-05 01:39:56 +00:00
|
|
|
entity_collision_bounding_box(entity, &bb);
|
2019-05-01 10:26:21 +00:00
|
|
|
double dy = entity->ai->lookHelper_y - entity->y - ((bb.maxY - bb.minY) * .9); // TODO: real eye height
|
|
|
|
double dz = entity->ai->lookHelper_z - entity->z;
|
|
|
|
double horiz_dist = sqrt(dx * dx + dz * dz);
|
|
|
|
float dp = -(atan2(dy, horiz_dist) * 180. / M_PI);
|
|
|
|
float dya = (atan2(dz, dx) * 180. / M_PI) - 90.;
|
|
|
|
dp = wrapAngle(dp - entity->pitch);
|
|
|
|
if (dp > entity->ai->lookHelper_speedPitch) dp = entity->ai->lookHelper_speedPitch;
|
|
|
|
if (dp < -entity->ai->lookHelper_speedPitch) dp = -entity->ai->lookHelper_speedPitch;
|
|
|
|
entity->pitch += dp;
|
|
|
|
dya = wrapAngle(dya - entity->yaw);
|
|
|
|
if (dya > entity->ai->lookHelper_speedYaw) dya = entity->ai->lookHelper_speedYaw;
|
|
|
|
if (dya < -entity->ai->lookHelper_speedYaw) dya = -entity->ai->lookHelper_speedYaw;
|
|
|
|
entity->yaw += dya;
|
|
|
|
if (fabs(dp) < 0.5 && fabs(dya) < .5) {
|
|
|
|
entity->ai->lookHelper_speedPitch = 0.;
|
|
|
|
entity->ai->lookHelper_speedYaw = 0.;
|
|
|
|
}
|
2017-02-13 19:04:24 +00:00
|
|
|
}
|
|
|
|
|
2017-03-05 00:11:19 +00:00
|
|
|
float aipath_manhattan(struct aipath_point* p1, struct aipath_point* p2) {
|
2019-05-01 10:26:21 +00:00
|
|
|
return fabs(p1->x - p2->x) + fabs(p1->y - p2->y) + fabs(p1->y - p2->y);
|
2017-03-05 00:11:19 +00:00
|
|
|
}
|
|
|
|
|
2019-09-07 22:32:04 +00:00
|
|
|
void aipath_sortback(struct list* path, int32_t index) {
|
|
|
|
struct aipath_point* point = path->data[index];
|
|
|
|
int32_t i = 0;
|
|
|
|
for (float lowest_distance = point->target_dist; index > 0; index = i) {
|
2019-05-01 10:26:21 +00:00
|
|
|
i = (index - 1) >> 1;
|
2019-09-07 22:32:04 +00:00
|
|
|
struct aipath_point* point2 = path->data[i];
|
|
|
|
if (lowest_distance >= point2->target_dist) break;
|
|
|
|
path->data[index] = point2;
|
|
|
|
point2->index = index;
|
2019-05-01 10:26:21 +00:00
|
|
|
}
|
2019-09-07 22:32:04 +00:00
|
|
|
path->data[index] = point;
|
|
|
|
point->index = index;
|
2017-03-05 00:11:19 +00:00
|
|
|
}
|
|
|
|
|
2019-09-07 22:32:04 +00:00
|
|
|
void aipath_sortforward(struct list* path, int32_t index) {
|
|
|
|
struct aipath_point* pp = path->data[index];
|
2019-05-01 10:26:21 +00:00
|
|
|
float ld = pp->target_dist;
|
|
|
|
while (1) {
|
|
|
|
int i = 1 + (index << 1);
|
|
|
|
int j = i + 1;
|
2019-09-07 22:32:04 +00:00
|
|
|
if (i >= path->count) break;
|
|
|
|
struct aipath_point* pp2 = path->data[i];
|
2019-05-01 10:26:21 +00:00
|
|
|
float ld2 = pp2->target_dist;
|
|
|
|
struct aipath_point* pp3 = NULL;
|
|
|
|
float ld3 = 0.;
|
2019-09-07 22:32:04 +00:00
|
|
|
if (j >= path->count) {
|
|
|
|
ld3 = (float) 0x7f800000; // positive infinity
|
|
|
|
} else {
|
|
|
|
pp3 = path->data[j];
|
2019-05-01 10:26:21 +00:00
|
|
|
ld3 = pp3->target_dist;
|
|
|
|
}
|
|
|
|
if (ld2 < ld3) {
|
|
|
|
if (ld2 >= ld) break;
|
2019-09-07 22:32:04 +00:00
|
|
|
path->data[index] = pp2;
|
2019-05-01 10:26:21 +00:00
|
|
|
pp2->index = index;
|
|
|
|
index = i;
|
|
|
|
} else {
|
|
|
|
if (ld3 >= ld) break;
|
2019-09-07 22:32:04 +00:00
|
|
|
path->data[index] = pp3;
|
2019-05-01 10:26:21 +00:00
|
|
|
pp3->index = index;
|
|
|
|
index = j;
|
|
|
|
}
|
|
|
|
}
|
2019-09-07 22:32:04 +00:00
|
|
|
path->data[index] = pp;
|
2019-05-01 10:26:21 +00:00
|
|
|
pp->index = index;
|
2017-03-05 00:11:19 +00:00
|
|
|
}
|
|
|
|
|
2019-09-07 22:32:04 +00:00
|
|
|
struct aipath_point* aipath_addpoint(struct list* path, struct aipath_point* point) {
|
|
|
|
struct aipath_point* new_point = pmalloc(path->pool, sizeof(struct aipath_point));
|
|
|
|
memcpy(new_point, point, sizeof(struct aipath_point));
|
|
|
|
new_point->index = path->count;
|
|
|
|
list_append(path, new_point);
|
|
|
|
aipath_sortback(path, new_point->index);
|
|
|
|
return new_point;
|
|
|
|
}
|
|
|
|
|
|
|
|
struct aipath_point* aipath_dequeue(struct list* path) {
|
|
|
|
if (path->count == 0) return NULL;
|
|
|
|
struct aipath_point* point = path->data[0];
|
|
|
|
--path->count;
|
|
|
|
path->data[0] = path->data[--path->size];
|
|
|
|
if (path->count > 0) aipath_sortforward(path, 0);
|
|
|
|
point->index = -1;
|
|
|
|
return point;
|
|
|
|
}
|
|
|
|
|
|
|
|
struct list* aipath_find(struct mempool* pool, int32_t sx, int32_t sy, int32_t sz, int32_t ex, int32_t ey, int32_t ez) {
|
2019-05-01 10:26:21 +00:00
|
|
|
struct aipath_point end;
|
|
|
|
memset(&end, 0, sizeof(struct aipath_point));
|
|
|
|
end.x = ex;
|
|
|
|
end.y = ey;
|
|
|
|
end.z = ez;
|
|
|
|
struct aipath_point start;
|
|
|
|
memset(&start, 0, sizeof(struct aipath_point));
|
|
|
|
start.x = sx;
|
|
|
|
start.y = sy;
|
|
|
|
start.z = sz;
|
2019-09-07 22:32:04 +00:00
|
|
|
struct list* path = list_new(32, pool);
|
2019-05-01 10:26:21 +00:00
|
|
|
start.x = sx;
|
|
|
|
start.y = sy;
|
|
|
|
start.z = sz;
|
2019-09-07 22:32:04 +00:00
|
|
|
start.next_dist = aipath_manhattan(&start, &end);
|
2019-05-01 10:26:21 +00:00
|
|
|
start.target_dist = start.next_dist;
|
2019-09-07 22:32:04 +00:00
|
|
|
struct aipath_point* current_point = aipath_addpoint(path, &start);
|
2019-05-01 10:26:21 +00:00
|
|
|
int i = 0;
|
2019-09-07 22:32:04 +00:00
|
|
|
while (path->count > 0) {
|
2019-05-01 10:26:21 +00:00
|
|
|
if (++i >= 200) break;
|
2019-09-07 22:32:04 +00:00
|
|
|
struct aipath_point* point2 = aipath_dequeue(path);
|
|
|
|
if (point2->x == end.x && point2->y == end.y && point2->z == end.z) {
|
|
|
|
current_point = point2;
|
2019-05-01 10:26:21 +00:00
|
|
|
break;
|
|
|
|
}
|
2019-09-07 22:32:04 +00:00
|
|
|
if (aipath_manhattan(point2, &end) < aipath_manhattan(current_point, &end)) current_point = point2;
|
|
|
|
point2->visited = 1;
|
2019-05-01 10:26:21 +00:00
|
|
|
|
|
|
|
}
|
|
|
|
return path;
|
2017-03-05 00:11:19 +00:00
|
|
|
}
|
|
|
|
|
2017-02-13 19:04:24 +00:00
|
|
|
int32_t ai_attackmelee(struct world* world, struct entity* entity, struct aitask* ai) {
|
2019-05-01 10:26:21 +00:00
|
|
|
struct ai_attackmelee_data* amd = ai->data;
|
|
|
|
entity->ai->lookHelper_speedYaw = 30.;
|
|
|
|
entity->ai->lookHelper_speedPitch = 30.;
|
|
|
|
entity->ai->lookHelper_x = entity->attacking->x;
|
|
|
|
struct boundingbox bb;
|
2019-05-05 01:39:56 +00:00
|
|
|
entity_collision_bounding_box(entity->attacking, &bb);
|
2019-05-01 10:26:21 +00:00
|
|
|
entity->ai->lookHelper_y = entity->attacking->y + ((bb.maxY - bb.minY) * .9); // TODO: real eye height
|
|
|
|
entity->ai->lookHelper_z = entity->attacking->z;
|
|
|
|
double dist = entity_distsq(entity->attacking, entity);
|
|
|
|
amd->delayCounter--;
|
2019-09-07 22:32:04 +00:00
|
|
|
//TODO: cansee
|
2019-05-05 00:56:30 +00:00
|
|
|
if ((amd->longMemory || 1) && amd->delayCounter <= 0 && ((amd->targetX == 0. && amd->targetY == 0. && amd->targetZ == 0.) || entity_distsq_block(entity->attacking, amd->targetX, amd->targetY, amd->targetZ) >= 1. || game_rand_float() < .05)) {
|
2019-05-01 10:26:21 +00:00
|
|
|
amd->targetX = entity->attacking->x;
|
|
|
|
amd->targetY = entity->attacking->y;
|
|
|
|
amd->targetZ = entity->attacking->z;
|
|
|
|
if (dist > 1024.) amd->delayCounter += 10;
|
2019-09-07 22:32:04 +00:00
|
|
|
else if (dist > 256.) amd->delayCounter += 5;
|
2019-05-01 10:26:21 +00:00
|
|
|
//TODO: set path
|
|
|
|
}
|
|
|
|
if (--amd->attackTick <= 0) amd->attackTick = 0;
|
2019-05-05 01:39:56 +00:00
|
|
|
struct entity_info* ei = entity_get_info(entity->type);
|
|
|
|
struct entity_info* ei2 = entity_get_info(entity->attacking->type);
|
2019-05-01 10:26:21 +00:00
|
|
|
float reach = ei->width * 2. * ei->width * 2. + ei2->width;
|
|
|
|
if (dist <= reach && amd->attackTick <= 0) {
|
|
|
|
amd->attackTick = 20;
|
2019-09-07 22:32:04 +00:00
|
|
|
entity_animation(entity, 1);
|
2019-05-01 10:26:21 +00:00
|
|
|
damageEntityWithItem(entity->attacking, entity, -1, NULL);
|
|
|
|
}
|
|
|
|
return 0;
|
2017-02-13 19:04:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int32_t ai_attackranged(struct world* world, struct entity* entity, struct aitask* ai) {
|
2019-05-01 10:26:21 +00:00
|
|
|
return 0;
|
2017-02-13 19:04:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int32_t ai_attackrangedbow(struct world* world, struct entity* entity, struct aitask* ai) {
|
2019-05-01 10:26:21 +00:00
|
|
|
return 0;
|
2017-02-13 19:04:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int32_t ai_avoidentity(struct world* world, struct entity* entity, struct aitask* ai) {
|
2019-05-01 10:26:21 +00:00
|
|
|
return 0;
|
2017-02-13 19:04:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int32_t ai_beg(struct world* world, struct entity* entity, struct aitask* ai) {
|
2019-05-01 10:26:21 +00:00
|
|
|
return 0;
|
2017-02-13 19:04:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int32_t ai_breakdoor(struct world* world, struct entity* entity, struct aitask* ai) {
|
2019-05-01 10:26:21 +00:00
|
|
|
return 0;
|
2017-02-13 19:04:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int32_t ai_creeperswell(struct world* world, struct entity* entity, struct aitask* ai) {
|
2019-05-01 10:26:21 +00:00
|
|
|
return 0;
|
2017-02-13 19:04:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int32_t ai_defendvillage(struct world* world, struct entity* entity, struct aitask* ai) {
|
2019-05-01 10:26:21 +00:00
|
|
|
return 0;
|
2017-02-13 19:04:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int32_t ai_doorinteract(struct world* world, struct entity* entity, struct aitask* ai) {
|
2019-05-01 10:26:21 +00:00
|
|
|
return 0;
|
2017-02-13 19:04:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int32_t ai_eatgrass(struct world* world, struct entity* entity, struct aitask* ai) {
|
2019-05-01 10:26:21 +00:00
|
|
|
return 0;
|
2017-02-13 19:04:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int32_t ai_findentitynearest(struct world* world, struct entity* entity, struct aitask* ai) {
|
2019-05-01 10:26:21 +00:00
|
|
|
return 0;
|
2017-02-13 19:04:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int32_t ai_findentitynearestplayer(struct world* world, struct entity* entity, struct aitask* ai) {
|
2019-05-01 10:26:21 +00:00
|
|
|
return 0;
|
2017-02-13 19:04:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int32_t ai_fleesun(struct world* world, struct entity* entity, struct aitask* ai) {
|
2019-05-01 10:26:21 +00:00
|
|
|
return 0;
|
2017-02-13 19:04:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int32_t ai_followgolem(struct world* world, struct entity* entity, struct aitask* ai) {
|
2019-05-01 10:26:21 +00:00
|
|
|
return 0;
|
2017-02-13 19:04:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int32_t ai_followowner(struct world* world, struct entity* entity, struct aitask* ai) {
|
2019-05-01 10:26:21 +00:00
|
|
|
return 0;
|
2017-02-13 19:04:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int32_t ai_followparent(struct world* world, struct entity* entity, struct aitask* ai) {
|
2019-05-01 10:26:21 +00:00
|
|
|
return 0;
|
2017-02-13 19:04:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int32_t ai_harvestfarmland(struct world* world, struct entity* entity, struct aitask* ai) {
|
2019-05-01 10:26:21 +00:00
|
|
|
return 0;
|
2017-02-13 19:04:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int32_t ai_hurtbytarget(struct world* world, struct entity* entity, struct aitask* ai) {
|
2019-05-01 10:26:21 +00:00
|
|
|
return 0;
|
2017-02-13 19:04:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int32_t ai_leapattarget(struct world* world, struct entity* entity, struct aitask* ai) {
|
2019-05-01 10:26:21 +00:00
|
|
|
return 0;
|
2017-02-13 19:04:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int32_t ai_llamafollowcaravan(struct world* world, struct entity* entity, struct aitask* ai) {
|
2019-05-01 10:26:21 +00:00
|
|
|
return 0;
|
2017-02-13 19:04:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int32_t ai_lookattradeplayer(struct world* world, struct entity* entity, struct aitask* ai) {
|
2019-05-01 10:26:21 +00:00
|
|
|
return 0;
|
2017-02-13 19:04:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int32_t ai_lookatvillager(struct world* world, struct entity* entity, struct aitask* ai) {
|
2019-05-01 10:26:21 +00:00
|
|
|
return 0;
|
2017-02-13 19:04:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int32_t ai_lookidle(struct world* world, struct entity* entity, struct aitask* ai) {
|
2019-05-01 10:26:21 +00:00
|
|
|
return 0;
|
2017-02-13 19:04:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int32_t ai_mate(struct world* world, struct entity* entity, struct aitask* ai) {
|
2019-05-01 10:26:21 +00:00
|
|
|
return 0;
|
2017-02-13 19:04:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int32_t ai_moveindoors(struct world* world, struct entity* entity, struct aitask* ai) {
|
2019-05-01 10:26:21 +00:00
|
|
|
return 0;
|
2017-02-13 19:04:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int32_t ai_movethroughvillage(struct world* world, struct entity* entity, struct aitask* ai) {
|
2019-05-01 10:26:21 +00:00
|
|
|
return 0;
|
2017-02-13 19:04:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int32_t ai_movetoblock(struct world* world, struct entity* entity, struct aitask* ai) {
|
2019-05-01 10:26:21 +00:00
|
|
|
return 0;
|
2017-02-13 19:04:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int32_t ai_movetowardsrestriction(struct world* world, struct entity* entity, struct aitask* ai) {
|
2019-05-01 10:26:21 +00:00
|
|
|
return 0;
|
2017-02-13 19:04:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int32_t ai_movetowardstarget(struct world* world, struct entity* entity, struct aitask* ai) {
|
2019-05-01 10:26:21 +00:00
|
|
|
return 0;
|
2017-02-13 19:04:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int32_t ai_nearestattackabletarget(struct world* world, struct entity* entity, struct aitask* ai) {
|
2019-05-01 10:26:21 +00:00
|
|
|
return 0;
|
2017-02-13 19:04:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int32_t ai_ocelotattack(struct world* world, struct entity* entity, struct aitask* ai) {
|
2019-05-01 10:26:21 +00:00
|
|
|
return 0;
|
2017-02-13 19:04:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int32_t ai_ocelotsit(struct world* world, struct entity* entity, struct aitask* ai) {
|
2019-05-01 10:26:21 +00:00
|
|
|
return 0;
|
2017-02-13 19:04:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int32_t ai_opendoor(struct world* world, struct entity* entity, struct aitask* ai) {
|
2019-05-01 10:26:21 +00:00
|
|
|
return 0;
|
2017-02-13 19:04:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int32_t ai_ownerhurtbytarget(struct world* world, struct entity* entity, struct aitask* ai) {
|
2019-05-01 10:26:21 +00:00
|
|
|
return 0;
|
2017-02-13 19:04:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int32_t ai_ownerhurttarget(struct world* world, struct entity* entity, struct aitask* ai) {
|
2019-05-01 10:26:21 +00:00
|
|
|
return 0;
|
2017-02-13 19:04:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int32_t ai_panic(struct world* world, struct entity* entity, struct aitask* ai) {
|
2019-05-01 10:26:21 +00:00
|
|
|
return 0;
|
2017-02-13 19:04:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int32_t ai_play(struct world* world, struct entity* entity, struct aitask* ai) {
|
2019-05-01 10:26:21 +00:00
|
|
|
return 0;
|
2017-02-13 19:04:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int32_t ai_restructopendoor(struct world* world, struct entity* entity, struct aitask* ai) {
|
2019-05-01 10:26:21 +00:00
|
|
|
return 0;
|
2017-02-13 19:04:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int32_t ai_restrictsun(struct world* world, struct entity* entity, struct aitask* ai) {
|
2019-05-01 10:26:21 +00:00
|
|
|
return 0;
|
2017-02-13 19:04:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int32_t ai_runaroundlikecrazy(struct world* world, struct entity* entity, struct aitask* ai) {
|
2019-05-01 10:26:21 +00:00
|
|
|
return 0;
|
2017-02-13 19:04:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int32_t ai_sit(struct world* world, struct entity* entity, struct aitask* ai) {
|
2019-05-01 10:26:21 +00:00
|
|
|
return 0;
|
2017-02-13 19:04:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int32_t ai_skeletonriders(struct world* world, struct entity* entity, struct aitask* ai) {
|
2019-05-01 10:26:21 +00:00
|
|
|
return 0;
|
2017-02-13 19:04:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int32_t ai_swimming(struct world* world, struct entity* entity, struct aitask* ai) {
|
2019-05-05 00:56:30 +00:00
|
|
|
//if (game_rand_float() < .8) {
|
2019-05-05 01:39:56 +00:00
|
|
|
entity_jump(entity);
|
2017-02-13 19:04:24 +00:00
|
|
|
//}
|
2019-05-01 10:26:21 +00:00
|
|
|
return 0;
|
2017-02-13 19:04:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int32_t ai_target(struct world* world, struct entity* entity, struct aitask* ai) {
|
2019-05-01 10:26:21 +00:00
|
|
|
return 0;
|
2017-02-13 19:04:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int32_t ai_targetnontamed(struct world* world, struct entity* entity, struct aitask* ai) {
|
2019-05-01 10:26:21 +00:00
|
|
|
return 0;
|
2017-02-13 19:04:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int32_t ai_tempt(struct world* world, struct entity* entity, struct aitask* ai) {
|
2019-05-01 10:26:21 +00:00
|
|
|
return 0;
|
2017-02-13 19:04:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int32_t ai_tradeplayer(struct world* world, struct entity* entity, struct aitask* ai) {
|
2019-05-01 10:26:21 +00:00
|
|
|
return 0;
|
2017-02-13 19:04:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int32_t ai_villagerinteract(struct world* world, struct entity* entity, struct aitask* ai) {
|
2019-05-01 10:26:21 +00:00
|
|
|
return 0;
|
2017-02-13 19:04:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int32_t ai_villagermate(struct world* world, struct entity* entity, struct aitask* ai) {
|
2019-05-01 10:26:21 +00:00
|
|
|
return 0;
|
2017-02-13 19:04:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int32_t ai_wander(struct world* world, struct entity* entity, struct aitask* ai) {
|
2019-05-01 10:26:21 +00:00
|
|
|
return 0;
|
2017-02-13 19:04:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int32_t ai_wanderaint32_twater(struct world* world, struct entity* entity, struct aitask* ai) {
|
2019-05-01 10:26:21 +00:00
|
|
|
return 0;
|
2017-02-13 19:04:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int32_t ai_watchclosest(struct world* world, struct entity* entity, struct aitask* ai) {
|
2019-05-01 10:26:21 +00:00
|
|
|
return 0;
|
2017-02-13 19:04:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int32_t ai_zombieattack(struct world* world, struct entity* entity, struct aitask* ai) {
|
2019-05-01 10:26:21 +00:00
|
|
|
return ai_attackmelee(world, entity, ai);
|
2017-02-13 19:04:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
//shoulds
|
|
|
|
|
|
|
|
int ai_shouldattackmelee(struct world* world, struct entity* entity, struct aitask* ai) {
|
2019-05-01 10:26:21 +00:00
|
|
|
if (entity->attacking == NULL || entity->attacking->health <= 0. || (entity->type == ENT_PLAYER && (entity->data.player.player->gamemode == 1 || entity->data.player.player->gamemode == 3))) return 0;
|
2019-09-07 22:32:04 +00:00
|
|
|
struct entity_info* info1 = entity_get_info(entity->type);
|
|
|
|
struct entity_info* info2 = entity_get_info(entity->attacking->type);
|
|
|
|
if (info1 == NULL || info2 == NULL || !hashset_has(info2->flags, "livingbase")) return 0;
|
2019-05-01 10:26:21 +00:00
|
|
|
return entity->attacking != NULL;
|
|
|
|
//float reach = ei->width * 2. * ei->width * 2. + ei2->width;
|
|
|
|
//return reach >= entity_distsq(entity->attacking, entity);
|
2017-02-13 19:04:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int ai_shouldattackranged(struct world* world, struct entity* entity, struct aitask* ai) {
|
2019-05-01 10:26:21 +00:00
|
|
|
return 0;
|
2017-02-13 19:04:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int ai_shouldattackrangedbow(struct world* world, struct entity* entity, struct aitask* ai) {
|
2019-05-01 10:26:21 +00:00
|
|
|
return 0;
|
2017-02-13 19:04:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int ai_shouldavoidentity(struct world* world, struct entity* entity, struct aitask* ai) {
|
2019-05-01 10:26:21 +00:00
|
|
|
return 0;
|
2017-02-13 19:04:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int ai_shouldbeg(struct world* world, struct entity* entity, struct aitask* ai) {
|
2019-05-01 10:26:21 +00:00
|
|
|
return 0;
|
2017-02-13 19:04:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int ai_shouldbreakdoor(struct world* world, struct entity* entity, struct aitask* ai) {
|
2019-05-01 10:26:21 +00:00
|
|
|
return 0;
|
2017-02-13 19:04:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int ai_shouldcreeperswell(struct world* world, struct entity* entity, struct aitask* ai) {
|
2019-05-01 10:26:21 +00:00
|
|
|
return 0;
|
2017-02-13 19:04:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int ai_shoulddefendvillage(struct world* world, struct entity* entity, struct aitask* ai) {
|
2019-05-01 10:26:21 +00:00
|
|
|
return 0;
|
2017-02-13 19:04:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int ai_shoulddoorinteract(struct world* world, struct entity* entity, struct aitask* ai) {
|
2019-05-01 10:26:21 +00:00
|
|
|
return 0;
|
2017-02-13 19:04:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int ai_shouldeatgrass(struct world* world, struct entity* entity, struct aitask* ai) {
|
2019-05-01 10:26:21 +00:00
|
|
|
return 0;
|
2017-02-13 19:04:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int ai_shouldfindentitynearest(struct world* world, struct entity* entity, struct aitask* ai) {
|
2019-05-01 10:26:21 +00:00
|
|
|
return 0;
|
2017-02-13 19:04:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int ai_shouldfindentitynearestplayer(struct world* world, struct entity* entity, struct aitask* ai) {
|
2019-05-01 10:26:21 +00:00
|
|
|
return 0;
|
2017-02-13 19:04:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int ai_shouldfleesun(struct world* world, struct entity* entity, struct aitask* ai) {
|
2019-05-01 10:26:21 +00:00
|
|
|
return 0;
|
2017-02-13 19:04:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int ai_shouldfollowgolem(struct world* world, struct entity* entity, struct aitask* ai) {
|
2019-05-01 10:26:21 +00:00
|
|
|
return 0;
|
2017-02-13 19:04:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int ai_shouldfollowowner(struct world* world, struct entity* entity, struct aitask* ai) {
|
2019-05-01 10:26:21 +00:00
|
|
|
return 0;
|
2017-02-13 19:04:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int ai_shouldfollowparent(struct world* world, struct entity* entity, struct aitask* ai) {
|
2019-05-01 10:26:21 +00:00
|
|
|
return 0;
|
2017-02-13 19:04:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int ai_shouldharvestfarmland(struct world* world, struct entity* entity, struct aitask* ai) {
|
2019-05-01 10:26:21 +00:00
|
|
|
return 0;
|
2017-02-13 19:04:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int ai_shouldhurtbytarget(struct world* world, struct entity* entity, struct aitask* ai) {
|
2019-05-01 10:26:21 +00:00
|
|
|
return 0;
|
2017-02-13 19:04:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int ai_shouldleapattarget(struct world* world, struct entity* entity, struct aitask* ai) {
|
2019-05-01 10:26:21 +00:00
|
|
|
return 0;
|
2017-02-13 19:04:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int ai_shouldllamafollowcaravan(struct world* world, struct entity* entity, struct aitask* ai) {
|
2019-05-01 10:26:21 +00:00
|
|
|
return 0;
|
2017-02-13 19:04:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int ai_shouldlookattradeplayer(struct world* world, struct entity* entity, struct aitask* ai) {
|
2019-05-01 10:26:21 +00:00
|
|
|
return 0;
|
2017-02-13 19:04:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int ai_shouldlookatvillager(struct world* world, struct entity* entity, struct aitask* ai) {
|
2019-05-01 10:26:21 +00:00
|
|
|
return 0;
|
2017-02-13 19:04:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int ai_shouldlookidle(struct world* world, struct entity* entity, struct aitask* ai) {
|
2019-05-01 10:26:21 +00:00
|
|
|
return 0;
|
2017-02-13 19:04:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int ai_shouldmate(struct world* world, struct entity* entity, struct aitask* ai) {
|
2019-05-01 10:26:21 +00:00
|
|
|
return 0;
|
2017-02-13 19:04:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int ai_shouldmoveindoors(struct world* world, struct entity* entity, struct aitask* ai) {
|
2019-05-01 10:26:21 +00:00
|
|
|
return 0;
|
2017-02-13 19:04:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int ai_shouldmovethroughvillage(struct world* world, struct entity* entity, struct aitask* ai) {
|
2019-05-01 10:26:21 +00:00
|
|
|
return 0;
|
2017-02-13 19:04:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int ai_shouldmovetoblock(struct world* world, struct entity* entity, struct aitask* ai) {
|
2019-05-01 10:26:21 +00:00
|
|
|
return 0;
|
2017-02-13 19:04:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int ai_shouldmovetowardsrestriction(struct world* world, struct entity* entity, struct aitask* ai) {
|
2019-05-01 10:26:21 +00:00
|
|
|
return 0;
|
2017-02-13 19:04:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int ai_shouldmovetowardstarget(struct world* world, struct entity* entity, struct aitask* ai) {
|
2019-05-01 10:26:21 +00:00
|
|
|
return 0;
|
2017-02-13 19:04:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int ai_shouldnearestattackabletarget(struct world* world, struct entity* entity, struct aitask* ai) {
|
2019-05-01 10:26:21 +00:00
|
|
|
struct ai_nearestattackabletarget_data* data = ai->data;
|
|
|
|
if (data->chance > 0 && rand() % data->chance != 0) return 0;
|
2019-09-07 22:32:04 +00:00
|
|
|
double current_distance = data->targetDist * data->targetDist;
|
|
|
|
struct entity* current_entity = NULL;
|
|
|
|
pthread_rwlock_rdlock(&world->entities->rwlock);
|
|
|
|
ITER_MAP(world->entities) {
|
|
|
|
struct entity* iter_entity = value;
|
|
|
|
if (!hashset_has(entity_get_info(iter_entity->type)->flags, "livingbase") || iter_entity == entity) continue;
|
|
|
|
double distance_squared = entity_distsq(entity, value);
|
|
|
|
if (iter_entity->type == ENT_PLAYER) {
|
|
|
|
struct player* pl = iter_entity->data.player.player;
|
|
|
|
if (pl->gamemode == 1 || pl->gamemode == 3 || pl->invulnerable) continue;
|
|
|
|
struct hashset* flags = entity_get_info(entity->type)->flags;
|
|
|
|
int is_skeleton = hashset_has(flags, "skeleton");
|
|
|
|
int is_zombie = hashset_has(flags, "zombie");
|
|
|
|
int is_creeper = hashset_has(flags, "creeper");
|
|
|
|
if (is_skeleton || is_zombie || is_creeper) {
|
|
|
|
struct slot* holding_slot = inventory_get(pl, pl->inventory, 5);
|
|
|
|
if (holding_slot != NULL) {
|
|
|
|
if (is_skeleton && holding_slot->damage == 0) distance_squared *= 2.;
|
|
|
|
else if (is_zombie && holding_slot->damage == 2) distance_squared *= 2.;
|
|
|
|
else if (is_creeper && holding_slot->damage == 4) distance_squared *= 2.;
|
|
|
|
}
|
2019-05-01 10:26:21 +00:00
|
|
|
}
|
|
|
|
}
|
2019-09-07 22:32:04 +00:00
|
|
|
if (distance_squared < current_distance) {
|
|
|
|
//TODO check teams, sight
|
|
|
|
current_distance = distance_squared;
|
|
|
|
current_entity = value;
|
|
|
|
}
|
|
|
|
ITER_MAP_END()
|
2019-05-01 10:26:21 +00:00
|
|
|
}
|
2019-09-07 22:32:04 +00:00
|
|
|
pthread_rwlock_unlock(&world->entities->rwlock);
|
|
|
|
if (entity->attacking != NULL && current_entity != entity->attacking) {
|
|
|
|
hashmap_putint(entity->attacking->attackers, entity->id, NULL);
|
2019-05-01 10:26:21 +00:00
|
|
|
}
|
2019-09-07 22:32:04 +00:00
|
|
|
if (current_entity != NULL && entity->attacking != current_entity) {
|
|
|
|
hashmap_putint(current_entity->attackers, entity->id, entity);
|
2019-05-01 10:26:21 +00:00
|
|
|
}
|
2019-09-07 22:32:04 +00:00
|
|
|
entity->attacking = current_entity;
|
2019-05-01 10:26:21 +00:00
|
|
|
return 0;
|
2017-02-13 19:04:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int ai_shouldocelotattack(struct world* world, struct entity* entity, struct aitask* ai) {
|
2019-05-01 10:26:21 +00:00
|
|
|
return 0;
|
2017-02-13 19:04:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int ai_shouldocelotsit(struct world* world, struct entity* entity, struct aitask* ai) {
|
2019-05-01 10:26:21 +00:00
|
|
|
return 0;
|
2017-02-13 19:04:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int ai_shouldopendoor(struct world* world, struct entity* entity, struct aitask* ai) {
|
2019-05-01 10:26:21 +00:00
|
|
|
return 0;
|
2017-02-13 19:04:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int ai_shouldownerhurtbytarget(struct world* world, struct entity* entity, struct aitask* ai) {
|
2019-05-01 10:26:21 +00:00
|
|
|
return 0;
|
2017-02-13 19:04:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int ai_shouldownerhurttarget(struct world* world, struct entity* entity, struct aitask* ai) {
|
2019-05-01 10:26:21 +00:00
|
|
|
return 0;
|
2017-02-13 19:04:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int ai_shouldpanic(struct world* world, struct entity* entity, struct aitask* ai) {
|
2019-05-01 10:26:21 +00:00
|
|
|
return 0;
|
2017-02-13 19:04:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int ai_shouldplay(struct world* world, struct entity* entity, struct aitask* ai) {
|
2019-05-01 10:26:21 +00:00
|
|
|
return 0;
|
2017-02-13 19:04:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int ai_shouldrestructopendoor(struct world* world, struct entity* entity, struct aitask* ai) {
|
2019-05-01 10:26:21 +00:00
|
|
|
return 0;
|
2017-02-13 19:04:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int ai_shouldrestrictsun(struct world* world, struct entity* entity, struct aitask* ai) {
|
2019-05-01 10:26:21 +00:00
|
|
|
return 0;
|
2017-02-13 19:04:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int ai_shouldrunaroundlikecrazy(struct world* world, struct entity* entity, struct aitask* ai) {
|
2019-05-01 10:26:21 +00:00
|
|
|
return 0;
|
2017-02-13 19:04:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int ai_shouldsit(struct world* world, struct entity* entity, struct aitask* ai) {
|
2019-05-01 10:26:21 +00:00
|
|
|
return 0;
|
2017-02-13 19:04:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int ai_shouldskeletonriders(struct world* world, struct entity* entity, struct aitask* ai) {
|
2019-05-01 10:26:21 +00:00
|
|
|
return 0;
|
2017-02-13 19:04:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int ai_shouldswimming(struct world* world, struct entity* entity, struct aitask* ai) {
|
2019-05-01 10:26:21 +00:00
|
|
|
return entity->inWater || entity->inLava;
|
2017-02-13 19:04:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int ai_shouldtarget(struct world* world, struct entity* entity, struct aitask* ai) {
|
2019-05-01 10:26:21 +00:00
|
|
|
return 0;
|
2017-02-13 19:04:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int ai_shouldtargetnontamed(struct world* world, struct entity* entity, struct aitask* ai) {
|
2019-05-01 10:26:21 +00:00
|
|
|
return 0;
|
2017-02-13 19:04:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int ai_shouldtempt(struct world* world, struct entity* entity, struct aitask* ai) {
|
2019-05-01 10:26:21 +00:00
|
|
|
return 0;
|
2017-02-13 19:04:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int ai_shouldtradeplayer(struct world* world, struct entity* entity, struct aitask* ai) {
|
2019-05-01 10:26:21 +00:00
|
|
|
return 0;
|
2017-02-13 19:04:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int ai_shouldvillagerinteract(struct world* world, struct entity* entity, struct aitask* ai) {
|
2019-05-01 10:26:21 +00:00
|
|
|
return 0;
|
2017-02-13 19:04:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int ai_shouldvillagermate(struct world* world, struct entity* entity, struct aitask* ai) {
|
2019-05-01 10:26:21 +00:00
|
|
|
return 0;
|
2017-02-13 19:04:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int ai_shouldwander(struct world* world, struct entity* entity, struct aitask* ai) {
|
2019-05-01 10:26:21 +00:00
|
|
|
return 0;
|
2017-02-13 19:04:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int ai_shouldwanderaintwater(struct world* world, struct entity* entity, struct aitask* ai) {
|
2019-05-01 10:26:21 +00:00
|
|
|
return 0;
|
2017-02-13 19:04:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int ai_shouldwatchclosest(struct world* world, struct entity* entity, struct aitask* ai) {
|
2019-05-01 10:26:21 +00:00
|
|
|
return 0;
|
2017-02-13 19:04:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int ai_shouldzombieattack(struct world* world, struct entity* entity, struct aitask* ai) {
|
2019-05-01 10:26:21 +00:00
|
|
|
return ai_shouldattackmelee(world, entity, ai);
|
2017-02-13 19:04:24 +00:00
|
|
|
}
|