mirror of
https://github.com/nzp-team/quakec.git
synced 2024-11-29 23:32:18 +00:00
828 lines
No EOL
18 KiB
C++
828 lines
No EOL
18 KiB
C++
/*
|
|
server/ai/pathfind_core.qc
|
|
|
|
generic waypoints
|
|
|
|
Copyright (C) 2021 NZ:P Team
|
|
|
|
This program is free software; you can redistribute it and/or
|
|
modify it under the terms of the GNU General Public License
|
|
as published by the Free Software Foundation; either version 2
|
|
of the License, or (at your option) any later version.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
|
|
|
|
See the GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with this program; if not, write to:
|
|
|
|
Free Software Foundation, Inc.
|
|
59 Temple Place - Suite 330
|
|
Boston, MA 02111-1307, USA
|
|
|
|
*/
|
|
|
|
void() creator_way_touch =
|
|
{
|
|
if (cvar("waypoint_mode")) {
|
|
if (other.classname != "player") {
|
|
return;
|
|
}
|
|
|
|
current_way = self;
|
|
}
|
|
}
|
|
|
|
void () Create_New_Waypoint =
|
|
{
|
|
float way_count;
|
|
float tempf;
|
|
entity tempe;
|
|
entity new_way;
|
|
|
|
way_count = -1;
|
|
tempe = find (world, classname, "waypoint");
|
|
while (tempe) {
|
|
tempf = stof(tempe.waynum);
|
|
if (tempf > way_count) {
|
|
way_count = tempf;
|
|
}
|
|
tempe = find (tempe, classname, "waypoint");
|
|
}
|
|
new_way = spawn();
|
|
|
|
setorigin(new_way, self.origin);
|
|
|
|
|
|
//new_way.flags = FL_ITEM;
|
|
new_way.solid = SOLID_TRIGGER;
|
|
|
|
|
|
setmodel(new_way, "models/way/normal_way.spr");
|
|
new_way.classname = "waypoint";
|
|
|
|
new_way.waynum = ftos(way_count + 1);
|
|
new_way.targetname = strzone(new_way.targetname);
|
|
bprint (PRINT_HIGH, "Created waypoint ");
|
|
bprint (PRINT_HIGH, new_way.waynum);
|
|
bprint (PRINT_HIGH, "\n");
|
|
|
|
new_way.touch = creator_way_touch;
|
|
}
|
|
|
|
|
|
void () Make_Special_Waypoint =
|
|
{
|
|
if (self.classname != "player" || !active_way) {
|
|
return;
|
|
}
|
|
if (active_way.targetname != "") {//Toggling it back off
|
|
setmodel(active_way, "models/way/current_way.spr");
|
|
active_way.targetname = "";
|
|
bprint (PRINT_HIGH, "Waypoint ");
|
|
bprint (PRINT_HIGH, active_way.waynum);
|
|
bprint (PRINT_HIGH, " is no longer a special waypoint\n");
|
|
return;
|
|
}
|
|
|
|
if (active_way) {
|
|
if(self.active_door == world) {
|
|
bprint (PRINT_HIGH, "Error: no door selected!\n");
|
|
return;
|
|
}
|
|
|
|
if(self.active_door.wayTarget == "") {
|
|
bprint (PRINT_HIGH, "Error: Door has no wayTarget value!\n");
|
|
return;
|
|
}
|
|
setmodel(active_way, "models/way/current_way_door.spr");
|
|
active_way.targetname = self.active_door.wayTarget;
|
|
|
|
bprint (PRINT_HIGH, "special waypoint ");
|
|
bprint (PRINT_HIGH, active_way.waynum);
|
|
bprint (PRINT_HIGH, " named ");
|
|
bprint (PRINT_HIGH, active_way.targetname);
|
|
bprint (PRINT_HIGH, "\n");
|
|
}
|
|
}
|
|
|
|
|
|
void () Move_Waypoint =
|
|
{
|
|
if (!active_way)
|
|
return;
|
|
|
|
setorigin (active_way, self.origin);
|
|
bprint (PRINT_HIGH, "Moved waypoint ");
|
|
bprint (PRINT_HIGH, active_way.waynum);
|
|
bprint (PRINT_HIGH, "\n");
|
|
|
|
}
|
|
|
|
void () Select_Waypoint =
|
|
{
|
|
if (self.classname != "player")
|
|
return;
|
|
if (!current_way)
|
|
return;
|
|
|
|
entity tempe;
|
|
|
|
if (current_way == active_way)
|
|
active_way = world;
|
|
else
|
|
active_way = current_way;
|
|
|
|
tempe = find (world, classname, "waypoint");
|
|
while (tempe)
|
|
{
|
|
if (tempe.targetname != "")
|
|
setmodel(tempe, "models/way/normal_way_door.spr");
|
|
else
|
|
setmodel(tempe, "models/way/normal_way.spr");
|
|
tempe = find (tempe, classname, "waypoint");
|
|
}
|
|
if (active_way)
|
|
{
|
|
if (active_way.targetname != "")
|
|
setmodel(active_way, "models/way/current_way_door.spr");
|
|
else
|
|
setmodel(active_way, "models/way/current_way.spr");
|
|
|
|
bprint (PRINT_HIGH, "Selected waypoint ");
|
|
bprint (PRINT_HIGH, active_way.waynum);
|
|
if(active_way.targetname != "")
|
|
{
|
|
bprint (PRINT_HIGH, ", special tag ");
|
|
bprint (PRINT_HIGH, active_way.targetname);
|
|
}
|
|
bprint (PRINT_HIGH, "\n");
|
|
|
|
float i;
|
|
for (i = 0; i < MAX_WAY_TARGETS; i++) {
|
|
tempe = find (world, waynum, active_way.targets[i]);
|
|
if (tempe) {
|
|
if (tempe.targetname != "")
|
|
setmodel(tempe, "models/way/last_way_door.spr");
|
|
else
|
|
setmodel(tempe, "models/way/last_way.spr");
|
|
} else {
|
|
active_way.targets[i] = "";
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
void() Remove_Waypoint =
|
|
{
|
|
entity tempe;
|
|
float i;
|
|
if (!active_way)
|
|
return;
|
|
|
|
tempe = find (world, classname, "waypoint");
|
|
while (tempe) {
|
|
|
|
for (i = 0; i < MAX_WAY_TARGETS; i++) {
|
|
if (tempe.targets[i] == active_way.waynum) {
|
|
tempe.targets[i] = "";
|
|
}
|
|
}
|
|
|
|
tempe = find (tempe, classname, "waypoint");
|
|
}
|
|
|
|
bprint(PRINT_HIGH, "Removed waypoint ");
|
|
bprint(PRINT_HIGH, active_way.waynum);
|
|
bprint(PRINT_HIGH, "\n");
|
|
remove (active_way);
|
|
}
|
|
|
|
float Waypoint_Linked_To(entity from, entity to) {
|
|
float i;
|
|
for (i = 0; i < MAX_WAY_TARGETS; i++) {
|
|
if (from.waynum == to.targets[i]) {
|
|
bprint(PRINT_HIGH, "These waypoints are already linked!\n");
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
float Link (entity from, entity to) {
|
|
float i;
|
|
entity tempe;
|
|
for (i = 0; i < MAX_WAY_TARGETS; i++) {
|
|
tempe = find (world, waynum, from.targets[i]);
|
|
|
|
if (tempe == world || tempe == to) {
|
|
from.targets[i] = to.waynum;
|
|
bprint(PRINT_HIGH, "Linked waypoint ");
|
|
bprint(PRINT_HIGH, to.waynum);
|
|
bprint(PRINT_HIGH, " to ");
|
|
bprint(PRINT_HIGH, from.waynum);
|
|
bprint(PRINT_HIGH, "\n");
|
|
|
|
if (to.targetname != "") {
|
|
setmodel(to, "models/way/last_way_door.spr");
|
|
} else {
|
|
setmodel(to, "models/way/last_way.spr");
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
void () Link_Waypoints =
|
|
{
|
|
if (self.classname != "player")
|
|
return;
|
|
if (!current_way)
|
|
return;
|
|
if (!active_way)
|
|
return;
|
|
if (current_way == active_way)
|
|
return;
|
|
|
|
if (Waypoint_Linked_To(current_way, active_way)) {
|
|
bprint(PRINT_HIGH, "These waypoints are already linked!\n");
|
|
return;
|
|
}
|
|
|
|
float i;
|
|
entity tempe;
|
|
for (i = 0; i < MAX_WAY_TARGETS; i++) {
|
|
#ifdef PC
|
|
tempe = findfloat (world, waynum, active_way.targets[i]);
|
|
#else
|
|
tempe = find (world, waynum, active_way.targets[i]);
|
|
#endif
|
|
|
|
if (tempe == world) {
|
|
if (Link(active_way, current_way)) {
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
bprint(PRINT_HIGH, "no targets remaining!\n");
|
|
}
|
|
|
|
|
|
|
|
void() Dual_Link_Waypoints =
|
|
{
|
|
if (self.classname != "player" || !current_way || !active_way || current_way == active_way) {
|
|
return;
|
|
}
|
|
|
|
float result1,result2;
|
|
result1 = Waypoint_Linked_To(current_way,active_way);
|
|
result2 = Waypoint_Linked_To(active_way,current_way);
|
|
|
|
if(result1 && result2) {
|
|
bprint(PRINT_HIGH, "Both waypoints already linked!\n");
|
|
return;
|
|
}
|
|
|
|
if(!result1)
|
|
{
|
|
if (Link(current_way,active_way)) {
|
|
bprint(PRINT_HIGH, strcat("Linked waypoint ", strcat(current_way.waynum, strcat(" to ",strcat(active_way.waynum, "\n")))));
|
|
} else {
|
|
bprint(PRINT_HIGH, strcat("ERROR: Could not link waypoint ", strcat(current_way.waynum, strcat(" to ", strcat(active_way.waynum, "\n")))));
|
|
}
|
|
}
|
|
if(!result2)
|
|
{
|
|
if (Link(active_way,current_way)) {
|
|
bprint(PRINT_HIGH, strcat("Linked waypoint ", strcat(active_way.waynum, strcat(" to ", strcat(current_way.waynum, "\n")))));
|
|
} else {
|
|
bprint(PRINT_HIGH, strcat("ERROR: Could not link waypoint ", strcat(active_way.waynum, strcat(" to ", strcat(current_way.waynum, "\n")))));
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
//alter auto_link_waypoints to iterate through the closest waypoints from closest to furthest
|
|
// on the innermost loop, we find the next closest waypoint that is further away from the last closest waypoint, and we use that!
|
|
|
|
void() Auto_Link_Waypoints =
|
|
{
|
|
entity tempe1, tempe2;
|
|
|
|
tempe1 = find(world,classname,"waypoint");
|
|
while(tempe1 != world)
|
|
{
|
|
tempe2 = find(world,classname,"waypoint");
|
|
while(tempe2 != world)
|
|
{
|
|
if(tempe1 == tempe2)
|
|
{
|
|
tempe2 = find(tempe2,classname,"waypoint");
|
|
continue;
|
|
}
|
|
|
|
if(tracemove(tempe1.origin,VEC_HULL_MIN,VEC_HULL_MAX,tempe2.origin,TRUE,self))
|
|
{
|
|
Link(tempe1,tempe2);
|
|
}
|
|
|
|
tempe2 = find(tempe2,classname,"waypoint");
|
|
}
|
|
tempe1 = find(tempe1,classname,"waypoint");
|
|
}
|
|
}
|
|
//alter auto_link_waypoints to iterate through the closest waypoints from closest to furthest
|
|
// on the innermost loop, we find the next closest waypoint that is further away from the last closest waypoint, and we use that!
|
|
|
|
void() Remove_Links =
|
|
{
|
|
entity tempe;
|
|
|
|
tempe = find(world,classname,"waypoint");
|
|
while(tempe != world)
|
|
{
|
|
float i;
|
|
for (i = 0; i < MAX_WAY_TARGETS; i = i + 1) {
|
|
if (tempe.targetname != "")
|
|
setmodel(tempe, "models/way/normal_way_door.spr");
|
|
else
|
|
setmodel(tempe, "models/way/normal_way.spr");
|
|
tempe.targets[i] = "";
|
|
}
|
|
tempe = find(tempe,classname,"waypoint");
|
|
}
|
|
}
|
|
|
|
void() Save_Waypoints
|
|
{
|
|
float file;
|
|
string h;
|
|
float i;
|
|
entity tempe;
|
|
|
|
h = strcat(mappath, ".way");
|
|
file = fopen (h, FILE_WRITE);
|
|
|
|
dprint (strcat("Saving waypoints ", strcat(h, "\n")));
|
|
|
|
local entity dway;
|
|
//fputs(file, "begin\n");
|
|
dway = find(world, classname, "waypoint");
|
|
while (dway)
|
|
{
|
|
fputs(file,"waypoint\n");
|
|
fputs(file,"{\n");
|
|
fputs(file, strcat(" id: ", strcat(dway.waynum, "\n")));
|
|
fputs(file, strcat(" origin: ", strcat(vtos(dway.origin), "\n")));
|
|
if (dway.targetname != "") {
|
|
fputs(file, strcat(" door: ", strcat(dway.targetname, "\n")));
|
|
}
|
|
|
|
fputs(file, " targets:\n");
|
|
fputs(file, " [\n");
|
|
for (i = 0; i < MAX_WAY_TARGETS; i++) {
|
|
if (dway.targets[i] != "") {
|
|
#ifdef PC
|
|
tempe = findfloat (world, waynum, dway.targets[i]);
|
|
#else
|
|
tempe = find (world, waynum, dway.targets[i]);
|
|
#endif
|
|
|
|
if (tempe != world) {
|
|
fputs(file, strcat(" ", strcat(dway.targets[i], "\n")));
|
|
} else {
|
|
tempe = find (world, waynum, dway.targets[i]);
|
|
if (tempe != world) {
|
|
fputs(file, strcat(" ", strcat(dway.targets[i], "\n")));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
fputs(file, " ]\n");
|
|
fputs(file,"}\n");
|
|
|
|
|
|
dway = find(dway, classname, "waypoint");
|
|
if (dway)
|
|
fputs(file,"\n");
|
|
}
|
|
fclose(file);
|
|
}
|
|
|
|
void (vector here, float which, string special, string trg, string trg2, string trg3, string trg4, string trg5, string trg6, string trg7, string trg8) Create_Waypoint =
|
|
{
|
|
entity new_way;
|
|
new_way = spawn();
|
|
|
|
setorigin(new_way, here);
|
|
|
|
|
|
//new_way.flags = FL_ITEM;
|
|
new_way.solid = SOLID_TRIGGER;
|
|
|
|
if (cvar("waypoint_mode"))
|
|
setmodel(new_way, "models/way/normal_way.spr");
|
|
new_way.classname = "waypoint";
|
|
|
|
new_way.waynum = ftos(which);
|
|
dprint ("Created waypoint ");
|
|
dprint (new_way.waynum);
|
|
dprint ("\n");
|
|
|
|
if (special != "")
|
|
{
|
|
if (!cvar("waypoint_mode"))
|
|
new_way.classname = "waypoint_s";
|
|
if (cvar("waypoint_mode"))
|
|
setmodel(new_way, "models/way/normal_way_door.spr");
|
|
new_way.targetname = special;
|
|
dprint ("Special waypoint ");
|
|
dprint (new_way.targetname);
|
|
dprint ("\n");
|
|
//current_special++;
|
|
}
|
|
|
|
new_way.targets[0] = trg;
|
|
new_way.targets[1] = trg2;
|
|
new_way.targets[2] = trg3;
|
|
new_way.targets[3] = trg4;
|
|
new_way.targets[4] = trg5;
|
|
new_way.targets[5] = trg6;
|
|
new_way.targets[6] = trg7;
|
|
new_way.targets[7] = trg8;
|
|
|
|
new_way.touch = creator_way_touch;
|
|
}
|
|
|
|
float waypoints_loaded;
|
|
void() Load_Waypoints
|
|
{
|
|
float file, point;
|
|
string h;
|
|
float targetcount, loop;
|
|
|
|
entity new_way;
|
|
|
|
h = strcat(mappath, ".way");
|
|
file = fopen (h, FILE_READ);
|
|
|
|
if (file == -1)
|
|
{
|
|
dprint("Error: file not found \n");
|
|
return;
|
|
}
|
|
|
|
new_way = spawn();
|
|
targetcount = 0;
|
|
point = 0;
|
|
loop = 1;
|
|
while (loop)
|
|
{
|
|
string line;
|
|
line = fgets(file);
|
|
if not (line) {
|
|
bprint(PRINT_HIGH, "End of file\n");
|
|
loop = 0;
|
|
break;
|
|
}
|
|
h = strtrim(line);
|
|
|
|
//bprint(PRINT_HIGH, strcat(h, "\n"));
|
|
if (h == "") {
|
|
continue;
|
|
}
|
|
|
|
switch (point) {
|
|
case 0:
|
|
if (h == "waypoint") {
|
|
new_way = spawn();
|
|
new_way.solid = SOLID_TRIGGER;
|
|
new_way.model = "models/way/normal_way.spr";
|
|
setmodel(new_way, "models/way/normal_way.spr");
|
|
new_way.classname = "waypoint";
|
|
|
|
new_way.touch = creator_way_touch;
|
|
point = 1;
|
|
targetcount = 0;
|
|
} else if (h == "Waypoint") {
|
|
bprint(PRINT_HIGH, "Identified .way as legacy..\n");
|
|
point = 99;
|
|
Load_Waypoints_Legacy();
|
|
loop = 0;
|
|
break;
|
|
} else {
|
|
bprint(PRINT_HIGH, strcat("Error: unknown point ", strcat(h, "\n")));
|
|
}
|
|
break;
|
|
case 1:
|
|
if (h == "{") {
|
|
point = 2;
|
|
} else {
|
|
bprint(PRINT_HIGH, strcat("Error: unknown variable ", strcat(h, " expected {\n")));
|
|
}
|
|
break;
|
|
case 2:
|
|
tokenize(h);
|
|
|
|
string value, variable;
|
|
variable = strtrim(argv(0));
|
|
value = strtrim(argv(2));
|
|
|
|
//bprint(PRINT_HIGH, strcat(variable, "\n"));
|
|
|
|
switch (variable) {
|
|
case "origin":
|
|
|
|
print(strcat(value, "\n"));
|
|
new_way.origin = stov(value);
|
|
setorigin(new_way, new_way.origin);
|
|
break;
|
|
case "id":
|
|
new_way.waynum = value;
|
|
break;
|
|
case "door":
|
|
new_way.targetname = value;
|
|
|
|
setmodel(new_way, "models/way/normal_way_door.spr");
|
|
break;
|
|
case "targets":
|
|
point = 3;
|
|
break;
|
|
case "}":
|
|
point = 0;
|
|
break;
|
|
default:
|
|
bprint(PRINT_HIGH, strcat("Error: unknown variable ", strcat(variable, "\n")));
|
|
break;
|
|
}
|
|
break;
|
|
case 3:
|
|
if (h == "[") {
|
|
point = 4;
|
|
} else {
|
|
bprint(PRINT_HIGH, strcat("Error: unknown variable ", strcat(h, " expected [\n")));
|
|
}
|
|
break;
|
|
case 4:
|
|
if (targetcount >= MAX_WAY_TARGETS) {
|
|
bprint(PRINT_HIGH, "Error: Target count too high for waypoint\n");
|
|
} else if (h == "]") {
|
|
point = 2;
|
|
} else {
|
|
bprint(PRINT_HIGH, strcat(strcat("WAYPOINT TARGET: ", strcat(strcat(ftos(targetcount), " "), h)), "\n"));
|
|
new_way.targets[targetcount] = h;
|
|
targetcount++;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
fclose(file);
|
|
waypoints_loaded = 1;
|
|
}
|
|
|
|
void() Load_Waypoints_Legacy
|
|
{
|
|
float file, which;
|
|
string h, special, trg, trg2, trg3, trg4, trg5, trg6, trg7, trg8;
|
|
local vector where;
|
|
|
|
h = strcat(mappath, ".way");
|
|
file = fopen (h, FILE_READ);
|
|
|
|
if (file == -1)
|
|
{
|
|
dprint("Error: file not found \n");
|
|
return;
|
|
}
|
|
|
|
while (1)
|
|
{
|
|
dprint("Loading waypoint\n");
|
|
// the first line is just a comment, ignore it
|
|
h = fgets(file);
|
|
if (h != "Waypoint")
|
|
{
|
|
bprint(PRINT_HIGH, "Last waypoint\n");
|
|
fclose(file);
|
|
return;
|
|
}
|
|
h = fgets(file);
|
|
h = fgets(file);
|
|
h = substring(h, 9, 20);
|
|
where = stov(h);
|
|
|
|
h = (fgets(file));
|
|
h = substring(h, 5, 20);
|
|
which = stof(h);
|
|
|
|
h = (fgets(file));
|
|
special = substring(h, 10, 20);
|
|
|
|
h = (fgets(file));
|
|
trg = substring(h, 9, 20);
|
|
|
|
h = (fgets(file));
|
|
trg2 = substring(h, 10, 20);
|
|
|
|
h = (fgets(file));
|
|
trg3 = substring(h, 10, 20);
|
|
|
|
h = (fgets(file));
|
|
trg4 = substring(h, 10, 20);
|
|
|
|
h = (fgets(file));
|
|
trg5 = substring(h, 10, 20);
|
|
|
|
h = (fgets(file));
|
|
trg6 = substring(h, 10, 20);
|
|
|
|
h = (fgets(file));
|
|
trg7 = substring(h, 10, 20);
|
|
|
|
h = (fgets(file));
|
|
trg8 = substring(h, 10, 20);
|
|
|
|
#ifndef PC
|
|
Create_Waypoint(where, which, special, trg, trg2, trg3, trg4, trg5, trg6, trg7, trg8);
|
|
#else
|
|
waypoint_ai waypoint;
|
|
waypoint = waypoints[which];
|
|
|
|
waypoints[which].id = which;
|
|
waypoints[which].org = where;
|
|
waypoints[which].targetdoor = special;
|
|
|
|
waypoints[which].target_id[0] = stof(trg);
|
|
waypoints[which].target_id[1] = stof(trg2);
|
|
waypoints[which].target_id[2] = stof(trg3);
|
|
waypoints[which].target_id[3] = stof(trg4);
|
|
waypoints[which].target_id[4] = stof(trg5);
|
|
waypoints[which].target_id[5] = stof(trg6);
|
|
waypoints[which].target_id[6] = stof(trg7);
|
|
waypoints[which].target_id[7] = stof(trg8);
|
|
#endif
|
|
|
|
h = (fgets(file));
|
|
h = (fgets(file));
|
|
}
|
|
}
|
|
|
|
|
|
void VisualizePathfind() {
|
|
if (self.classname != "player")
|
|
return;
|
|
if (!current_way)
|
|
return;
|
|
if (!active_way)
|
|
return;
|
|
if (current_way == active_way)
|
|
return;
|
|
|
|
Pathfind(self, stof(active_way.waynum), stof(current_way.waynum));
|
|
}
|
|
|
|
.float waypoint_delay;
|
|
|
|
//Waypoint logic functions
|
|
void () Waypoint_Functions =
|
|
{
|
|
// naievil -- archaic
|
|
/*
|
|
switch (self.impulse) {
|
|
case 100:
|
|
Create_New_Waypoint();
|
|
break;
|
|
case 101:
|
|
Make_Special_Waypoint();
|
|
break;
|
|
case 102:
|
|
Select_Waypoint();
|
|
break;
|
|
case 103:
|
|
Move_Waypoint();
|
|
break;
|
|
case 104:
|
|
Link_Waypoints ();
|
|
break;
|
|
case 105:
|
|
Dual_Link_Waypoints();
|
|
break;
|
|
case 106:
|
|
Save_Waypoints();
|
|
break;
|
|
case 107:
|
|
Load_Waypoints();
|
|
break;
|
|
case 108:
|
|
Load_Waypoints_Legacy();
|
|
break;
|
|
case 109:
|
|
Remove_Waypoint();
|
|
//VisualizePathfind();
|
|
break;
|
|
case 110:
|
|
Auto_Link_Waypoints();
|
|
break;
|
|
case 111:
|
|
Remove_Links();
|
|
break;
|
|
}
|
|
|
|
self.impulse = 0;
|
|
*/
|
|
|
|
switch (self.impulse) {
|
|
case 23:
|
|
Save_Waypoints();
|
|
break;
|
|
case 22:
|
|
if (!waypoints_loaded)
|
|
Load_Waypoints();
|
|
break;
|
|
case 110:
|
|
Move_Waypoint();
|
|
break;
|
|
}
|
|
|
|
self.impulse = 0;
|
|
|
|
// Match what we display on the screen
|
|
if (self.button0 && self.waypoint_delay < time) {
|
|
Create_New_Waypoint();
|
|
self.waypoint_delay = time + 1;
|
|
}
|
|
|
|
if (self.button7 && self.waypoint_delay < time) {
|
|
Select_Waypoint();
|
|
self.waypoint_delay = time + 0.25;
|
|
}
|
|
|
|
if (self.button8 && self.waypoint_delay < time) {
|
|
Link_Waypoints ();
|
|
self.waypoint_delay = time + 0.5;
|
|
}
|
|
|
|
if (self.button6 && self.waypoint_delay < time) {
|
|
Remove_Waypoint();
|
|
self.waypoint_delay = time + 0.5;
|
|
}
|
|
|
|
if (self.button5 && self.waypoint_delay < time) {
|
|
Make_Special_Waypoint();
|
|
self.waypoint_delay = time + 1;
|
|
}
|
|
|
|
};
|
|
|
|
void () Waypoint_Logic =
|
|
{
|
|
if (!waypoint_mode) {
|
|
waypoint_mode = 1;
|
|
entity zent;
|
|
|
|
zent = find (world, classname, "ai_zombie");
|
|
while (zent)
|
|
{
|
|
remove (zent);
|
|
zent = find (zent, classname, "ai_zombie");
|
|
}
|
|
|
|
zent = find (world, classname, "door_nzp_cost");
|
|
while (zent)
|
|
{
|
|
zent.solid = SOLID_NOT;
|
|
zent.touch = SUB_Null;
|
|
zent = find (zent, classname, "door_nzp_cost");
|
|
}
|
|
zent = find (world, classname, "door_nzp");
|
|
while (zent)
|
|
{
|
|
zent.solid = SOLID_NOT;
|
|
zent.touch = SUB_Null;
|
|
zent.solid = SOLID_NOT;
|
|
zent = find (zent, classname, "door_nzp");
|
|
}
|
|
zent = find (world, classname, "window");
|
|
while (zent)
|
|
{
|
|
zent.solid = SOLID_NOT;
|
|
zent.touch = SUB_Null;
|
|
zent = find (zent, classname, "window");
|
|
}
|
|
|
|
}
|
|
Waypoint_Functions();
|
|
}; |