- wget -O data/maps/g-23.waypoints.cache https://gitlab.com/xonotic/xonotic-maps.pk3dir/raw/master/maps/g-23.waypoints.cache
- wget -O data/maps/g-23.waypoints.hardwired https://gitlab.com/xonotic/xonotic-maps.pk3dir/raw/master/maps/g-23.waypoints.hardwired
- make
- - EXPECT=814b0e609bcf01dc2a44f2b17fa366b4
+ - EXPECT=4bd5b0276cdd100c831c73f0400eca71
- HASH=$(${ENGINE} -noconfig -nohome +exec serverbench.cfg
| tee /dev/stderr
| grep '^:'
--- /dev/null
+cmake_minimum_required(VERSION 2.8.11)
+list(APPEND CMAKE_MODULE_PATH ${CMAKE_CURRENT_SOURCE_DIR}/cmake)
+project(xonotic-data LANGUAGES ASM)
+
+include_directories(qcsrc)
+
+add_definitions(-DNDEBUG=1)
+
+find_package(Git REQUIRED)
+execute_process(
+ COMMAND ${GIT_EXECUTABLE} describe --tags --dirty=~
+ WORKING_DIRECTORY ${PROJECT_SOURCE_DIR}
+ OUTPUT_VARIABLE GIT_DESC
+ OUTPUT_STRIP_TRAILING_WHITESPACE
+)
+add_definitions(-DWATERMARK=\"${GIT_DESC}\")
+
+set_source_files_properties(
+ qcsrc/client/progs.inc
+ qcsrc/server/progs.inc
+ qcsrc/menu/progs.inc
+ PROPERTIES
+ LANGUAGE ASM
+ HEADER_FILE_ONLY FALSE
+)
+
+add_executable(csprogs qcsrc/client/progs.inc)
+target_compile_definitions(csprogs PRIVATE -DCSQC)
+add_dependencies(csprogs gmqcc)
+
+add_executable(progs qcsrc/server/progs.inc)
+target_compile_definitions(progs PRIVATE -DSVQC)
+add_dependencies(progs gmqcc)
+
+add_executable(menu qcsrc/menu/progs.inc)
+target_compile_definitions(menu PRIVATE -DMENUQC)
+add_dependencies(menu gmqcc)
+
+function(set_prelude target prelude)
+ get_target_property(MY_PROJECT_SOURCES target SOURCES)
+ foreach (source IN LISTS MY_PROJECT_SOURCES)
+ set_property(
+ SOURCE ${source}
+ APPEND PROPERTY COMPILE_FLAGS
+ "-include ${PROJECT_SOURCE_DIR}/${prelude}"
+ )
+ endforeach ()
+endfunction()
+# set_prelude(csprogs qcsrc/lib/_all.inc)
+
+function(copy prog)
+ add_custom_command(TARGET ${prog} POST_BUILD
+ COMMAND ${CMAKE_COMMAND} -E copy "$<TARGET_FILE_DIR:${prog}>/${prog}.dat" "${prog}.dat"
+ COMMAND ${CMAKE_COMMAND} -E copy "$<TARGET_FILE_DIR:${prog}>/${prog}.lno" "${prog}.lno"
+ WORKING_DIRECTORY ${PROJECT_SOURCE_DIR}
+ VERBATIM)
+endfunction()
+copy(csprogs)
+copy(progs)
+copy(menu)
+
+function(pack prog)
+ add_custom_target(${prog}.pk3
+ DEPENDS ${prog}-${GIT_DESC}.pk3
+ )
+ add_custom_command(OUTPUT ${prog}-${GIT_DESC}.pk3
+ DEPENDS ${prog}
+ COMMAND ${CMAKE_COMMAND} -E echo "http://xonotic.org" > "${prog}-${GIT_DESC}.txt"
+ COMMAND ${CMAKE_COMMAND} -E copy "$<TARGET_FILE_DIR:${prog}>/${prog}.dat" "${prog}-${GIT_DESC}.dat"
+ COMMAND ${CMAKE_COMMAND} -E copy "$<TARGET_FILE_DIR:${prog}>/${prog}.lno" "${prog}-${GIT_DESC}.lno"
+ COMMAND ${CMAKE_COMMAND} -E tar "cfv" "${prog}-${GIT_DESC}.pk3" --format=zip
+ "${prog}-${GIT_DESC}.txt"
+ "${prog}-${GIT_DESC}.dat"
+ "${prog}-${GIT_DESC}.lno"
+ VERBATIM
+ )
+endfunction()
+pack(csprogs)
--- /dev/null
+set(CMAKE_ASM_COMPILER "@CMAKE_ASM_COMPILER@")
+set(CMAKE_ASM_COMPILER_LOADED 1)
+
+set(CMAKE_ASM_SOURCE_FILE_EXTENSIONS qc;qh;inc)
+set(CMAKE_ASM_OUTPUT_EXTENSION .o)
+set(CMAKE_ASM_OUTPUT_EXTENSION_REPLACE 1)
+set(CMAKE_ASM_LINKER_PREFERENCE 42)
+set(CMAKE_ASM_COMPILER_ENV_VAR "QCC")
--- /dev/null
+if (${CMAKE_VERSION} VERSION_LESS "3.4")
+ set(_CMAKE_ASM_INCLUDES "")
+else()
+ set(_CMAKE_ASM_INCLUDES "<INCLUDES>")
+endif()
+mark_as_advanced(_CMAKE_ASM_INCLUDES)
+
+set(CMAKE_ASM_COMPILE_OBJECT "<CMAKE_ASM_COMPILER> compile <OBJECT> <DEFINES> -DGMQCC ${_CMAKE_ASM_INCLUDES} <FLAGS> <SOURCE>")
+set(CMAKE_ASM_LINK_EXECUTABLE "env CMAKE_EXECUTABLE_SUFFIX=${CMAKE_EXECUTABLE_SUFFIX} <CMAKE_ASM_COMPILER> link <OBJECTS> -o <TARGET>")
+
+set(CMAKE_INCLUDE_FLAG_ASM "-I")
+set(CMAKE_INCLUDE_FLAG_ASM_SEP "")
+set(CMAKE_EXECUTABLE_PREFIX_ASM "")
+set(CMAKE_EXECUTABLE_SUFFIX_ASM ".dat")
--- /dev/null
+set(CMAKE_ASM_COMPILER ${PROJECT_SOURCE_DIR}/cmake/qcc.sh)
+
+configure_file(cmake/CMakeASMCompiler.cmake.in
+ ${CMAKE_PLATFORM_INFO_DIR}/CMakeASMCompiler.cmake @ONLY)
+set(CMAKE_ASM_COMPILER_ENV_VAR "QCC")
--- /dev/null
+set(CMAKE_ASM_COMPILER_WORKS 1 CACHE INTERNAL "")
--- /dev/null
+#!/bin/bash
+CPP=${CPP:-cpp}
+QCC=${QCC:-$PWD/../../gmqcc/gmqcc${CMAKE_EXECUTABLE_SUFFIX}}
+case $1 in
+ compile)
+ ${CPP} ${@:3} | sed 's/^#\(line\)\? \([[:digit:]]\+\) "\(.*\)".*/\n#pragma file(\3)\n#pragma line(\2)/g' > $2
+ ;;
+ link)
+ ${QCC} \
+ -std=gmqcc \
+ -Ooverlap-locals \
+ -O3 \
+ -Werror -Wall \
+ -Wno-field-redeclared \
+ -flno -futf8 -fno-bail-on-werror \
+ -frelaxed-switch -freturn-assignments \
+ ${@:2}
+ ;;
+esac
seta teamplay_mode 4 "default teamplay setting in team games. 1 = no friendly fire, self damage. 2 = friendly fire and self damage enabled. 3 = no friendly fire, but self damage enabled. 4 = obey the cvars g_mirrordamage*, g_friendlyfire* and g_teamdamage_threshold*"
seta g_mirrordamage 0.700000 "for teamplay 4: mirror damage factor"
seta g_mirrordamage_virtual 1 "for teamplay 4: do not actually apply mirror damage, just show graphics effect for it"
+seta g_mirrordamage_onlyweapons 0 "for teamplay 4: only apply mirror damage if the attack was from a weapon"
seta g_friendlyfire 0.500000 "for teamplay 4: fiendly fire factor"
seta g_friendlyfire_virtual 1 "for teamplay 4: do not actually apply friendly fire, just show graphics effect for it"
seta g_friendlyfire_virtual_force 1 "for teamplay 4: apply force even though damage was made virtual only"
seta menu_tooltips 1 "menu tooltips: 0 disabled, 1 enabled, 2 also shows cvar or console command (when available) changed or executed by the item"
set menu_picmip_bypass 0 "bypass texture quality enforcement based on system resources, not recommended and may cause crashes!"
set menu_showboxes 0 "show item bounding boxes (debug)"
+set menu_cvarlist_onlymodified 0 "show only modified cvars in the cvar list"
r_textbrightness 0.2
r_textcontrast 0.8
set g_balance_nexball_secondary_refire 0.6 "stealing projectile refire"
set g_balance_nexball_secondary_animtime 0.3 "stealing projectile animtime"
set g_nexball_football_physics 2 "0: Revenant's original movement, 1: 0 but half independant of aiming height, 2: 1 fully independant, -1: first recode try"
+set g_nexball_basketball_jumppad 1 "whether basketballs should be pushable by jumppads"
set g_nexball_basketball_bouncefactor 0.6 "velocity loss when the ball bounces"
set g_nexball_basketball_bouncestop 0.075 "speed at which the ball stops when it hits the ground (multiplied by sv_gravity)"
+set g_nexball_football_jumppad 1 "whether footballs should be pushable by jumppads"
set g_nexball_football_bouncefactor 0.6 "velocity loss when the ball bounces"
set g_nexball_football_bouncestop 0.075 "speed at which the ball stops when it hits the ground (multiplied by sv_gravity)"
set g_nexball_football_boost_forward 100 "forward velocity boost when the ball is touched"
--- /dev/null
+Original photograph of the earth courtesy of the
+Earth Science and Remote Sensing Unit, NASA Johnson Space Center
+
+NASA Photo ID: ISS007-E-10807
+URL: http://eol.jsc.nasa.gov/SearchPhotos/photo.pl?mission=ISS007&roll=E&frame=10807
set g_instagib_damagedbycontents 1 "allow damage from lava pits in instagib"
set g_instagib_blaster_keepdamage 0 "allow secondary fire to hurt players"
set g_instagib_blaster_keepforce 0 "allow secondary fire to push players"
+set g_instagib_mirrordamage 0 "allow damage mirror instagib"
+set g_instagib_friendlypush 1 "allow pushing teammates with the vaporizer primary attack"
// ==========
// Nades
// =======
set g_nades 0 "enable off-hand grenades"
+set g_nades_spread 0.04 "random spread offset of throw direction"
set g_nades_throw_offset "0 0 0" "nade throwing offset"
set g_nades_spawn 1 "give nades right away when player spawns rather than delaying entire refire"
set g_nades_client_select 0 "allow client side selection of nade type"
// generated file; do not modify
-#include "announcer.qc"
-#include "bgmscript.qc"
-#include "csqcmodel_hooks.qc"
-#include "main.qc"
-#include "mapvoting.qc"
-#include "miscfunctions.qc"
-#include "player_skeleton.qc"
-#include "scoreboard.qc"
-#include "shownames.qc"
-#include "teamradar.qc"
-#include "view.qc"
-#include "wall.qc"
+#include <client/announcer.qc>
+#include <client/bgmscript.qc>
+#include <client/csqcmodel_hooks.qc>
+#include <client/main.qc>
+#include <client/mapvoting.qc>
+#include <client/miscfunctions.qc>
+#include <client/player_skeleton.qc>
+#include <client/scoreboard.qc>
+#include <client/shownames.qc>
+#include <client/teamradar.qc>
+#include <client/view.qc>
+#include <client/wall.qc>
--- /dev/null
+// generated file; do not modify
+#include <client/announcer.qh>
+#include <client/bgmscript.qh>
+#include <client/csqcmodel_hooks.qh>
+#include <client/main.qh>
+#include <client/mapvoting.qh>
+#include <client/miscfunctions.qh>
+#include <client/player_skeleton.qh>
+#include <client/scoreboard.qh>
+#include <client/shownames.qh>
+#include <client/teamradar.qh>
+#include <client/view.qh>
+#include <client/wall.qh>
float autocvar_crosshair_rpc_size = 1;
int autocvar_cl_nade_timer;
bool autocvar_cl_items_nofade;
+float autocvar_slowmo;
// generated file; do not modify
-#include "all.qc"
-#include "cl_cmd.qc"
+#include <client/commands/all.qc>
+#include <client/commands/cl_cmd.qc>
--- /dev/null
+// generated file; do not modify
+#include <client/commands/all.qh>
+#include <client/commands/cl_cmd.qh>
bool QuickMenu_Open(string mode, string submenu);
bool HUD_MinigameMenu_IsOpened();
-void HUD_MinigameMenu_Close();
+void HUD_MinigameMenu_Close(entity this, entity actor, entity trigger);
void HUD_MinigameMenu_Open();
void HUD_Radar_Show_Maximized(bool doshow, bool clickable);
// generated file; do not modify
-#include "hud.qc"
-#include "hud_config.qc"
+#include <client/hud/hud.qc>
+#include <client/hud/hud_config.qc>
--- /dev/null
+// generated file; do not modify
+#include <client/hud/hud.qh>
+#include <client/hud/hud_config.qh>
// generated file; do not modify
-#include "ammo.qc"
-#include "centerprint.qc"
-#include "chat.qc"
-#include "engineinfo.qc"
-#include "healtharmor.qc"
-#include "infomessages.qc"
-#include "minigame.qc"
-#include "modicons.qc"
-#include "notify.qc"
-#include "physics.qc"
-#include "powerups.qc"
-#include "pressedkeys.qc"
-#include "quickmenu.qc"
-#include "racetimer.qc"
-#include "radar.qc"
-#include "score.qc"
-#include "timer.qc"
-#include "vote.qc"
-#include "weapons.qc"
+#include <client/hud/panel/ammo.qc>
+#include <client/hud/panel/centerprint.qc>
+#include <client/hud/panel/chat.qc>
+#include <client/hud/panel/engineinfo.qc>
+#include <client/hud/panel/healtharmor.qc>
+#include <client/hud/panel/infomessages.qc>
+#include <client/hud/panel/minigame.qc>
+#include <client/hud/panel/modicons.qc>
+#include <client/hud/panel/notify.qc>
+#include <client/hud/panel/physics.qc>
+#include <client/hud/panel/powerups.qc>
+#include <client/hud/panel/pressedkeys.qc>
+#include <client/hud/panel/quickmenu.qc>
+#include <client/hud/panel/racetimer.qc>
+#include <client/hud/panel/radar.qc>
+#include <client/hud/panel/score.qc>
+#include <client/hud/panel/timer.qc>
+#include <client/hud/panel/vote.qc>
+#include <client/hud/panel/weapons.qc>
--- /dev/null
+// generated file; do not modify
+#include <client/hud/panel/ammo.qh>
+#include <client/hud/panel/centerprint.qh>
+#include <client/hud/panel/chat.qh>
+#include <client/hud/panel/engineinfo.qh>
+#include <client/hud/panel/healtharmor.qh>
+#include <client/hud/panel/infomessages.qh>
+#include <client/hud/panel/minigame.qh>
+#include <client/hud/panel/modicons.qh>
+#include <client/hud/panel/notify.qh>
+#include <client/hud/panel/physics.qh>
+#include <client/hud/panel/powerups.qh>
+#include <client/hud/panel/pressedkeys.qh>
+#include <client/hud/panel/quickmenu.qh>
+#include <client/hud/panel/racetimer.qh>
+#include <client/hud/panel/radar.qh>
+#include <client/hud/panel/score.qh>
+#include <client/hud/panel/timer.qh>
+#include <client/hud/panel/vote.qh>
+#include <client/hud/panel/weapons.qh>
return aj - ai; // the string is in REVERSE order (higher prio at the right is what we want, but higher prio first is the string)
}
+#define HUD_WEAPONS_GET_FULL_LAYOUT() MACRO_BEGIN { \
+ int nHidden = 0; \
+ FOREACH(Weapons, it != WEP_Null, { \
+ if (weapons_stat & WepSet_FromWeapon(it)) continue; \
+ if (it.spawnflags & WEP_FLAG_MUTATORBLOCKED) nHidden += 1; \
+ }); \
+ vector table_size = HUD_GetTableSize_BestItemAR((Weapons_COUNT - 1) - nHidden, panel_size, aspect); \
+ columns = table_size.x; \
+ rows = table_size.y; \
+ weapon_size.x = panel_size.x / columns; \
+ weapon_size.y = panel_size.y / rows; \
+} MACRO_END
+
void HUD_Weapons()
{
// declarations
if(autocvar__hud_configure)
{
if(!weapons_stat)
- for(i = WEP_FIRST; i <= WEP_LAST; i += floor((WEP_LAST-WEP_FIRST)/5))
- weapons_stat |= WepSet_FromWeapon(Weapons_from(i));
+ {
+ int j = 0;
+ FOREACH(Weapons, it != WEP_Null && it.impulse >= 0 && (it.impulse % 3 != 0) && j < 6, {
+ if(!(it.spawnflags & WEP_FLAG_MUTATORBLOCKED))
+ {
+ weapons_stat |= it.m_wepset;
+ ++j;
+ }
+ });
+ }
#if 0
/// debug code
if(cvar("wep_add"))
{
+ int j;
+ int nHidden = 0;
+ FOREACH(Weapons, it != WEP_Null, {
+ if (it.spawnflags & WEP_FLAG_MUTATORBLOCKED) nHidden += 1;
+ });
weapons_stat = '0 0 0';
- float countw = 1 + floor((floor(time * cvar("wep_add"))) % (Weapons_COUNT - 1));
- for(i = WEP_FIRST; i <= countw; ++i)
- weapons_stat |= WepSet_FromWeapon(Weapons_from(i));
+ float countw = 1 + floor((floor(time * cvar("wep_add"))) % ((Weapons_COUNT - 1) - nHidden));
+ for(i = 0, j = 0; i <= (Weapons_COUNT - 1) && j < countw; ++i)
+ {
+ if(weaponorder[i].spawnflags & WEP_FLAG_MUTATORBLOCKED)
+ continue;
+ weapons_stat |= weaponorder[i].m_wepset;
+ ++j;
+ }
}
#endif
}
return;
vector old_panel_size = panel_size;
- vector padded_panel_size = panel_size - '2 2 0' * panel_bg_padding;
-
- // get the all-weapons layout
- int nHidden = 0;
- WepSet weapons_stat = WepSet_GetFromStat();
- FOREACH(Weapons, it != WEP_Null, {
- if (weapons_stat & it.m_wepset) continue;
- if (it.spawnflags & WEP_FLAG_MUTATORBLOCKED) nHidden += 1;
- });
- vector table_size = HUD_GetTableSize_BestItemAR((Weapons_COUNT - 1) - nHidden, padded_panel_size, aspect);
- columns = table_size.x;
- rows = table_size.y;
- weapon_size.x = padded_panel_size.x / columns;
- weapon_size.y = padded_panel_size.y / rows;
+ panel_size -= '2 2 0' * panel_bg_padding;
+
+ HUD_WEAPONS_GET_FULL_LAYOUT();
// NOTE: although weapons should aways look the same even if onlyowned is enabled,
// we enlarge them a bit when possible to better match the desired aspect ratio
- if(padded_panel_size.x / padded_panel_size.y < aspect)
+ if(panel_size.x / panel_size.y < aspect)
{
// maximum number of rows that allows to display items with the desired aspect ratio
- int max_rows = floor(padded_panel_size.y / (weapon_size.x / aspect));
+ int max_rows = floor(panel_size.y / (weapon_size.x / aspect));
columns = min(columns, ceil(weapon_count / max_rows));
rows = ceil(weapon_count / columns);
- weapon_size.y = min(padded_panel_size.y / rows, weapon_size.x / aspect);
- weapon_size.x = min(padded_panel_size.x / columns, aspect * weapon_size.y);
+ weapon_size.y = min(panel_size.y / rows, weapon_size.x / aspect);
+ weapon_size.x = min(panel_size.x / columns, aspect * weapon_size.y);
vertical_order = false;
}
else
{
- int max_columns = floor(padded_panel_size.x / (weapon_size.y * aspect));
+ int max_columns = floor(panel_size.x / (weapon_size.y * aspect));
rows = min(rows, ceil(weapon_count / max_columns));
columns = ceil(weapon_count / rows);
- weapon_size.x = min(padded_panel_size.x / columns, aspect * weapon_size.y);
- weapon_size.y = min(padded_panel_size.y / rows, weapon_size.x / aspect);
+ weapon_size.x = min(panel_size.x / columns, aspect * weapon_size.y);
+ weapon_size.y = min(panel_size.y / rows, weapon_size.x / aspect);
vertical_order = true;
}
HUD_Panel_DrawBg(1);
if(center.x == -1)
- return;
+ return; // panel has gone off screen
if(panel_bg_padding)
{
if(!rows) // if rows is > 0 onlyowned code has already updated these vars
{
- vector table_size = HUD_GetTableSize_BestItemAR((Weapons_COUNT - 1), panel_size, aspect);
- columns = table_size.x;
- rows = table_size.y;
- weapon_size.x = panel_size.x / columns;
- weapon_size.y = panel_size.y / rows;
+ HUD_WEAPONS_GET_FULL_LAYOUT();
vertical_order = (panel_size.x / panel_size.y >= aspect);
}
// retrieve information about the current weapon to be drawn
entity it = weaponorder[i];
weapon_id = it.impulse;
- isCurrent = (it == switchweapon);
// skip if this weapon doesn't exist
if(!it || weapon_id < 0) { continue; }
// skip this weapon if we don't own it (and onlyowned is enabled)-- or if weapons_complainbubble is showing for this weapon
if(autocvar_hud_panel_weapons_onlyowned)
- if (!((weapons_stat & WepSet_FromWeapon(it)) || (it.m_id == complain_weapon)))
- continue;
+ {
+ if (!((weapons_stat & WepSet_FromWeapon(it)) || (it.m_id == complain_weapon)))
+ continue;
+ }
+ else
+ {
+ if (it.spawnflags & WEP_FLAG_MUTATORBLOCKED && !(weapons_stat & WepSet_FromWeapon(it)))
+ continue;
+ }
// figure out the drawing position of weapon
weapon_pos = (panel_pos + eX * column * weapon_size.x + eY * row * weapon_size.y);
noncurrent_pos.y = weapon_pos.y + (weapon_size.y - noncurrent_size.y) / 2;
// draw background behind currently selected weapon
+ isCurrent = (it == switchweapon);
if(isCurrent)
drawpic_aspect_skin(weapon_pos, "weapon_current_bg", weapon_size, '1 1 1', panel_fg_alpha, DRAWFLAG_NORMAL);
}
deactivate_minigame();
- HUD_MinigameMenu_Close();
+ HUD_MinigameMenu_Close(NULL, NULL, NULL);
}
.float has_team;
--- /dev/null
+// generated file; do not modify
#include <lib/_all.inc>
#include "_all.qh"
-#include "_mod.inc"
+#include "../client/_mod.inc"
#include "commands/_mod.inc"
#include "hud/_mod.inc"
#include "mutators/_mod.inc"
this.viewmodel_angles = this.angles;
}
anim_update(this);
- if (!this.animstate_override)
+ if (!this.animstate_override && !this.animstate_looping)
anim_set(this, this.anim_idle, true, false, false);
}
float f = 0; // 0..1; 0: fully active
void HUD_Draw()
{
+ if(!intermission)
if (MUTATOR_CALLHOOK(HUD_Draw_overlay))
{
drawfill('0 0 0', eX * vid_conwidth + eY * vid_conheight, MUTATOR_ARGV(0, vector), autocvar_hud_colorflash_alpha * MUTATOR_ARGV(0, float), DRAWFLAG_ADDITIVE);
else
view_quality = 1;
+ // this needs to be updated manually now due to the destruction of engine physics stats
+ if(autocvar_slowmo != STAT(MOVEVARS_TIMESCALE))
+ cvar_set("slowmo", ftos(STAT(MOVEVARS_TIMESCALE)));
+
button_attack2 = PHYS_INPUT_BUTTON_ATCK2(this);
button_zoom = PHYS_INPUT_BUTTON_ZOOM(this);
// generated file; do not modify
-#include "projectile.qc"
+#include <client/weapons/projectile.qc>
--- /dev/null
+// generated file; do not modify
+#include <client/weapons/projectile.qh>
// generated file; do not modify
-#include "anim.qc"
-#include "animdecide.qc"
-#include "campaign_file.qc"
-#include "campaign_setup.qc"
-#include "ent_cs.qc"
-#include "mapinfo.qc"
-#include "net_notice.qc"
-#include "playerstats.qc"
-#include "state.qc"
-#include "t_items.qc"
-#include "util.qc"
-#include "viewloc.qc"
+#include <common/anim.qc>
+#include <common/animdecide.qc>
+#include <common/campaign_file.qc>
+#include <common/campaign_setup.qc>
+#include <common/ent_cs.qc>
+#include <common/mapinfo.qc>
+#include <common/net_notice.qc>
+#include <common/playerstats.qc>
+#include <common/state.qc>
+#include <common/t_items.qc>
+#include <common/util.qc>
+#include <common/viewloc.qc>
--- /dev/null
+// generated file; do not modify
+#include <common/anim.qh>
+#include <common/animdecide.qh>
+#include <common/campaign_file.qh>
+#include <common/campaign_setup.qh>
+#include <common/ent_cs.qh>
+#include <common/mapinfo.qh>
+#include <common/net_notice.qh>
+#include <common/playerstats.qh>
+#include <common/state.qh>
+#include <common/t_items.qh>
+#include <common/util.qh>
+#include <common/viewloc.qh>
// generated file; do not modify
-#include "all.qc"
-#include "generic.qc"
-#include "markup.qc"
-#include "rpn.qc"
+#include <common/command/all.qc>
+#include <common/command/generic.qc>
+#include <common/command/markup.qc>
+#include <common/command/rpn.qc>
--- /dev/null
+// generated file; do not modify
+#include <common/command/all.qh>
+#include <common/command/generic.qh>
+#include <common/command/markup.qh>
+#include <common/command/rpn.qh>
// generated file; do not modify
-#include "all.qc"
+#include <common/deathtypes/all.qc>
--- /dev/null
+// generated file; do not modify
+#include <common/deathtypes/all.qh>
// generated file; do not modify
-#include "all.qc"
-#include "effectinfo.qc"
+#include <common/effects/all.qc>
+#include <common/effects/effectinfo.qc>
--- /dev/null
+// generated file; do not modify
+#include <common/effects/all.qh>
+#include <common/effects/effectinfo.qh>
// generated file; do not modify
-#include "all.qc"
-#include "casings.qc"
-#include "damageeffects.qc"
-#include "gibs.qc"
-#include "globalsound.qc"
-#include "lightningarc.qc"
-#include "modeleffects.qc"
+#include <common/effects/qc/all.qc>
+#include <common/effects/qc/casings.qc>
+#include <common/effects/qc/damageeffects.qc>
+#include <common/effects/qc/gibs.qc>
+#include <common/effects/qc/globalsound.qc>
+#include <common/effects/qc/lightningarc.qc>
+#include <common/effects/qc/modeleffects.qc>
--- /dev/null
+// generated file; do not modify
+#include <common/effects/qc/all.qh>
+#include <common/effects/qc/casings.qh>
+#include <common/effects/qc/damageeffects.qh>
+#include <common/effects/qc/gibs.qh>
+#include <common/effects/qc/globalsound.qh>
+#include <common/effects/qc/lightningarc.qh>
+#include <common/effects/qc/modeleffects.qh>
// generated file; do not modify
-#include "all.qc"
+#include <common/gamemodes/all.qc>
--- /dev/null
+// generated file; do not modify
+#include <common/gamemodes/all.qh>
--- /dev/null
+// generated file; do not modify
// generated file; do not modify
-#include "nexball.qc"
-#include "weapon.qc"
+#include <common/gamemodes/gamemode/nexball/nexball.qc>
+#include <common/gamemodes/gamemode/nexball/weapon.qc>
--- /dev/null
+// generated file; do not modify
+#include <common/gamemodes/gamemode/nexball/nexball.qh>
+#include <common/gamemodes/gamemode/nexball/weapon.qh>
int autocvar_g_nexball_goalleadlimit;
#define autocvar_g_nexball_goallimit cvar("g_nexball_goallimit")
+bool autocvar_g_nexball_basketball_jumppad = true;
float autocvar_g_nexball_basketball_bouncefactor;
float autocvar_g_nexball_basketball_bouncestop;
float autocvar_g_nexball_basketball_carrier_highspeed;
float autocvar_g_nexball_delay_collect;
float autocvar_g_nexball_delay_goal;
float autocvar_g_nexball_delay_start;
+bool autocvar_g_nexball_football_jumppad = true;
float autocvar_g_nexball_football_bouncefactor;
float autocvar_g_nexball_football_bouncestop;
bool autocvar_g_nexball_radar_showallplayers;
if(!self.effects)
self.effects = autocvar_g_nexball_basketball_effects_default;
self.solid = SOLID_TRIGGER;
+ self.pushable = autocvar_g_nexball_basketball_jumppad;
balls |= BALL_BASKET;
self.bouncefactor = autocvar_g_nexball_basketball_bouncefactor;
self.bouncestop = autocvar_g_nexball_basketball_bouncestop;
self.classname = "nexball_football";
self.solid = SOLID_TRIGGER;
balls |= BALL_FOOT;
+ self.pushable = autocvar_g_nexball_football_jumppad;
self.bouncefactor = autocvar_g_nexball_football_bouncefactor;
self.bouncestop = autocvar_g_nexball_football_bouncestop;
SpawnBall();
// generated file; do not modify
-#include "cl_controlpoint.qc"
-#include "cl_generator.qc"
-#include "onslaught.qc"
-#include "sv_controlpoint.qc"
-#include "sv_generator.qc"
+#include <common/gamemodes/gamemode/onslaught/cl_controlpoint.qc>
+#include <common/gamemodes/gamemode/onslaught/cl_generator.qc>
+#include <common/gamemodes/gamemode/onslaught/onslaught.qc>
+#include <common/gamemodes/gamemode/onslaught/sv_controlpoint.qc>
+#include <common/gamemodes/gamemode/onslaught/sv_generator.qc>
--- /dev/null
+// generated file; do not modify
+#include <common/gamemodes/gamemode/onslaught/cl_controlpoint.qh>
+#include <common/gamemodes/gamemode/onslaught/cl_generator.qh>
+#include <common/gamemodes/gamemode/onslaught/onslaught.qh>
+#include <common/gamemodes/gamemode/onslaught/sv_controlpoint.qh>
+#include <common/gamemodes/gamemode/onslaught/sv_generator.qh>
onslaught_updatelinks();
// Use targets now (somebody make sure this is in the right place..)
- setself(this.owner);
- activator = this;
- WITHSELF(this, SUB_UseTargets());
- setself(this);
+ SUB_UseTargets(this.owner, this, NULL);
this.owner.waslinked = this.owner.islinked;
if(this.owner.model != "models/onslaught/controlpoint_pad.md3")
if(!self.owner.islinked)
self.owner.team = 0;
- setself(self.owner);
- activator = self;
- SUB_UseTargets ();
- setself(this);
+ SUB_UseTargets(self.owner, self, NULL);
self.owner.team = t;
onslaught_updatelinks();
// Use targets now (somebody make sure this is in the right place..)
- setself(self.owner);
- activator = self;
- SUB_UseTargets ();
- setself(this);
+ SUB_UseTargets(self.owner, self, NULL);
self.SendFlags |= CPSF_SETUP;
}
onslaught_updatelinks();
- activator = this;
- SUB_UseTargets(); // to reset the structures, playerspawns etc.
+ SUB_UseTargets(this, this, NULL); // to reset the structures, playerspawns etc.
CSQCMODEL_AUTOUPDATE(this);
}
void ons_MonsterSpawn_Delayed(entity this)
{
- entity e, own = self.owner;
+ entity own = self.owner;
- if(!own) { remove(self); return; }
+ if(!own) { remove(this); return; }
if(own.targetname)
{
- e = find(world, target, own.targetname);
+ entity e = find(world, target, own.targetname);
if(e != world)
{
own.team = e.team;
- activator = e;
- own.use();
+ own.use(own, e, NULL);
}
}
- remove(self);
+ remove(this);
}
MUTATOR_HOOKFUNCTION(ons, MonsterSpawn)
void ons_TurretSpawn_Delayed(entity this)
{
- entity e, own = self.owner;
+ entity own = self.owner;
if(!own) { remove(self); return; }
if(own.targetname)
{
- e = find(world, target, own.targetname);
+ entity e = find(world, target, own.targetname);
if(e != world)
{
own.team = e.team;
own.active = ACTIVE_NOT;
- activator = e;
- own.use();
+ own.use(own, e, NULL);
}
}
// generated file; do not modify
-#include "all.qc"
+#include <common/impulses/all.qc>
--- /dev/null
+// generated file; do not modify
+#include <common/impulses/all.qh>
// generated file; do not modify
-#include "all.qc"
+#include <common/items/all.qc>
--- /dev/null
+// generated file; do not modify
+#include <common/items/all.qh>
// generated file; do not modify
-#include "ammo.qc"
-#include "armor.qc"
-#include "health.qc"
-#include "jetpack.qc"
-#include "pickup.qc"
-#include "powerup.qc"
+#include <common/items/item/ammo.qc>
+#include <common/items/item/armor.qc>
+#include <common/items/item/health.qc>
+#include <common/items/item/jetpack.qc>
+#include <common/items/item/pickup.qc>
+#include <common/items/item/powerup.qc>
--- /dev/null
+// generated file; do not modify
+#include <common/items/item/ammo.qh>
+#include <common/items/item/armor.qh>
+#include <common/items/item/health.qh>
+#include <common/items/item/jetpack.qh>
+#include <common/items/item/pickup.qh>
+#include <common/items/item/powerup.qh>
// generated file; do not modify
-#include "cl_minigames.qc"
-#include "cl_minigames_hud.qc"
-#include "minigames.qc"
-#include "sv_minigames.qc"
+#include <common/minigames/cl_minigames_hud.qc>
+#include <common/minigames/minigames.qc>
+#ifdef CSQC
+ #include <common/minigames/cl_minigames.qc>
+#endif
+#ifdef SVQC
+ #include <common/minigames/sv_minigames.qc>
+#endif
--- /dev/null
+// generated file; do not modify
+#include <common/minigames/cl_minigames_hud.qh>
+#include <common/minigames/minigames.qh>
if ( auto_close_minigamemenu )
{
- HUD_MinigameMenu_Close();
+ HUD_MinigameMenu_Close(NULL, NULL, NULL);
auto_close_minigamemenu = 0;
}
else
if(argv(1) == "minigame")
{
if (HUD_MinigameMenu_IsOpened())
- HUD_MinigameMenu_Close();
+ HUD_MinigameMenu_Close(NULL, NULL, NULL);
else
HUD_MinigameMenu_Open();
return true;
void minigame_prompt();
float HUD_MinigameMenu_IsOpened();
-void HUD_MinigameMenu_Close();
+void HUD_MinigameMenu_Close(entity this, entity actor, entity trigger);
float HUD_Minigame_Showpanels();
// Adds a game-specific entry to the menu
void HUD_MinigameMenu_CustomEntry(entity parent, string message, string event_arg);
// Click the given item
void HUD_MinigameMenu_Click(entity menuitem)
-{SELFPARAM();
+{
if ( menuitem )
{
- WITHSELF(menuitem, menuitem.use());
+ menuitem.use(menuitem, NULL, NULL);
}
}
}
// Minigame menu options: create entry
-entity HUD_MinigameMenu_SpawnEntry(string s, vector offset, vector fontsize, vector color,void() click)
+entity HUD_MinigameMenu_SpawnEntry(string s, vector offset, vector fontsize, vector color,void(entity, entity, entity) click)
{
entity entry = spawn();
entry.message = s;
}
// Spawn a child entry of a collapsable entry
-entity HUD_MinigameMenu_SpawnSubEntry(string s, void() click, entity parent)
+entity HUD_MinigameMenu_SpawnSubEntry(string s, void(entity, entity, entity) click, entity parent)
{
vector item_fontsize = hud_fontsize*1.25;
vector item_offset = '1 0 0' * item_fontsize_x;
}
// Click action for Create sub-entries
-void HUD_MinigameMenu_ClickCreate_Entry()
-{SELFPARAM();
- minigame_cmd("create ",self.netname);
+void HUD_MinigameMenu_ClickCreate_Entry(entity this, entity actor, entity trigger)
+{
+ minigame_cmd("create ", this.netname);
}
// Helper click action for collapsible entries
// returns true when you have to create the sub-entries
-bool HUD_MinigameMenu_Click_ExpandCollapse()
-{SELFPARAM();
+bool HUD_MinigameMenu_Click_ExpandCollapse(entity this)
+{
entity e;
- if ( self.flags & 2 )
+ if ( this.flags & 2 )
{
if ( HUD_MinigameMenu_activeitem &&
- HUD_MinigameMenu_activeitem.owner == self )
+ HUD_MinigameMenu_activeitem.owner == this )
HUD_MinigameMenu_activeitem = world;
- self.flags &= ~2;
- for ( e = self.list_next; e != world && e.owner == self; e = self.list_next )
+ this.flags &= ~2;
+ for ( e = this.list_next; e != world && e.owner == this; e = this.list_next )
{
if ( e.flags & 2 )
HUD_MinigameMenu_Click(e);
- self.list_next = e.list_next;
+ this.list_next = e.list_next;
remove(e);
}
- if ( self.list_next )
- self.list_next.list_prev = self;
+ if ( this.list_next )
+ this.list_next.list_prev = this;
else
- HUD_MinigameMenu_last_entry = self;
+ HUD_MinigameMenu_last_entry = this;
}
else
{
for ( e = HUD_MinigameMenu_entries; e != world; e = e.list_next )
{
- if ( e.flags & 2 && e.origin_x == self.origin_x)
+ if ( e.flags & 2 && e.origin_x == this.origin_x)
HUD_MinigameMenu_Click(e);
}
- self.flags |= 2;
+ this.flags |= 2;
return true;
}
}
// Click action for the Create menu
-void HUD_MinigameMenu_ClickCreate()
-{SELFPARAM();
- if ( HUD_MinigameMenu_Click_ExpandCollapse() )
+void HUD_MinigameMenu_ClickCreate(entity this, entity actor, entity trigger)
+{
+ if ( HUD_MinigameMenu_Click_ExpandCollapse(this) )
{
entity curr;
- entity prev = self;
+ entity prev = this;
FOREACH(Minigames, true, {
- curr = HUD_MinigameMenu_SpawnSubEntry(it.message, HUD_MinigameMenu_ClickCreate_Entry, self);
+ curr = HUD_MinigameMenu_SpawnSubEntry(it.message, HUD_MinigameMenu_ClickCreate_Entry, this);
curr.netname = it.netname;
curr.model = strzone(minigame_texture(strcat(it.netname,"/icon")));
HUD_MinigameMenu_InsertEntry( curr, prev );
}
// Click action for Join sub-entries
-void HUD_MinigameMenu_ClickJoin_Entry()
-{SELFPARAM();
- minigame_cmd("join ",self.netname);
- HUD_MinigameMenu_EraseEntry(self);
+void HUD_MinigameMenu_ClickJoin_Entry(entity this, entity actor, entity trigger)
+{
+ minigame_cmd("join ",this.netname);
+ HUD_MinigameMenu_EraseEntry(this);
}
// Click action for the Join menu
-void HUD_MinigameMenu_ClickJoin()
-{SELFPARAM();
- if ( HUD_MinigameMenu_Click_ExpandCollapse() )
+void HUD_MinigameMenu_ClickJoin(entity this, entity actor, entity trigger)
+{
+ if ( HUD_MinigameMenu_Click_ExpandCollapse(this) )
{
entity e = world;
entity curr;
- entity prev = self;
+ entity prev = this;
while( (e = find(e,classname,"minigame")) )
{
if ( e != active_minigame )
{
curr = HUD_MinigameMenu_SpawnSubEntry(
- e.netname, HUD_MinigameMenu_ClickJoin_Entry, self );
+ e.netname, HUD_MinigameMenu_ClickJoin_Entry, this );
curr.netname = e.netname;
curr.model = strzone(minigame_texture(strcat(e.descriptor.netname,"/icon")));
HUD_MinigameMenu_InsertEntry( curr, prev );
}*/
// Click action for Quit
-void HUD_MinigameMenu_ClickQuit()
+void HUD_MinigameMenu_ClickQuit(entity this, entity actor, entity trigger)
{
deactivate_minigame();
minigame_cmd("end");
}
// Click action for Invite sub-entries
-void HUD_MinigameMenu_ClickInvite_Entry()
-{SELFPARAM();
- minigame_cmd("invite #",self.netname);
+void HUD_MinigameMenu_ClickInvite_Entry(entity this, entity actor, entity trigger)
+{
+ minigame_cmd("invite #",this.netname);
}
// Click action for the Invite menu
-void HUD_MinigameMenu_ClickInvite()
-{SELFPARAM();
- if ( HUD_MinigameMenu_Click_ExpandCollapse() )
+void HUD_MinigameMenu_ClickInvite(entity this, entity actor, entity trigger)
+{
+ if ( HUD_MinigameMenu_Click_ExpandCollapse(this) )
{
entity e;
entity prev = self;
}
}
-void HUD_MinigameMenu_ClickCustomEntry()
-{SELFPARAM();
+void HUD_MinigameMenu_ClickCustomEntry(entity this, entity actor, entity trigger)
+{
if ( active_minigame )
- active_minigame.minigame_event(active_minigame,"menu_click",self.netname);
+ active_minigame.minigame_event(active_minigame,"menu_click",this.netname);
}
// Adds a game-specific entry to the menu
}
// Click action for the Current Game menu
-void HUD_MinigameMenu_ClickCurrentGame()
-{SELFPARAM();
- if ( HUD_MinigameMenu_Click_ExpandCollapse() )
+void HUD_MinigameMenu_ClickCurrentGame(entity this, entity actor, entity trigger)
+{
+ if ( HUD_MinigameMenu_Click_ExpandCollapse(this) )
{
HUD_MinigameMenu_InsertEntry( HUD_MinigameMenu_SpawnSubEntry(
- _("Quit"), HUD_MinigameMenu_ClickQuit, self ), self);
+ _("Quit"), HUD_MinigameMenu_ClickQuit, this ), this);
- active_minigame.minigame_event(active_minigame,"menu_show",self);
+ active_minigame.minigame_event(active_minigame,"menu_show",this);
HUD_MinigameMenu_InsertEntry( HUD_MinigameMenu_SpawnSubEntry(
- _("Invite"), HUD_MinigameMenu_ClickInvite, self), self);
+ _("Invite"), HUD_MinigameMenu_ClickInvite, this), this);
}
}
// Whether the minigame menu panel is open
}
// Close the minigame menu panel
-void HUD_MinigameMenu_Close()
+void HUD_MinigameMenu_Close(entity this, entity actor, entity trigger)
{
if ( HUD_MinigameMenu_IsOpened() )
{
}
else if ( nPrimary == K_ESCAPE )
{
- HUD_MinigameMenu_Close();
+ HUD_MinigameMenu_Close(NULL, NULL, NULL);
return true;
}
}
// generated file; do not modify
-#include "bd.qc"
-#include "c4.qc"
-#include "nmm.qc"
-#include "pong.qc"
-#include "pp.qc"
-#include "ps.qc"
-#include "snake.qc"
-#include "ttt.qc"
+#include <common/minigames/minigame/bd.qc>
+#include <common/minigames/minigame/c4.qc>
+#include <common/minigames/minigame/nmm.qc>
+#include <common/minigames/minigame/pong.qc>
+#include <common/minigames/minigame/pp.qc>
+#include <common/minigames/minigame/ps.qc>
+#include <common/minigames/minigame/snake.qc>
+#include <common/minigames/minigame/ttt.qc>
--- /dev/null
+// generated file; do not modify
+#include <common/minigames/minigame/bd.qh>
+#include <common/minigames/minigame/c4.qh>
+#include <common/minigames/minigame/nmm.qh>
+#include <common/minigames/minigame/pong.qh>
+#include <common/minigames/minigame/pp.qh>
+#include <common/minigames/minigame/ps.qh>
+#include <common/minigames/minigame/snake.qh>
+#include <common/minigames/minigame/ttt.qh>
--- /dev/null
+// generated file; do not modify
// generated file; do not modify
-#include "all.qc"
-#include "spawn.qc"
-#include "sv_monsters.qc"
+#include <common/monsters/all.qc>
+#include <common/monsters/spawn.qc>
+#include <common/monsters/sv_monsters.qc>
--- /dev/null
+// generated file; do not modify
+#include <common/monsters/all.qh>
+#include <common/monsters/spawn.qh>
+#include <common/monsters/sv_monsters.qh>
// generated file; do not modify
-#include "mage.qc"
-#include "shambler.qc"
-#include "spider.qc"
-#include "wyvern.qc"
-#include "zombie.qc"
+#include <common/monsters/monster/mage.qc>
+#include <common/monsters/monster/shambler.qc>
+#include <common/monsters/monster/spider.qc>
+#include <common/monsters/monster/wyvern.qc>
+#include <common/monsters/monster/zombie.qc>
--- /dev/null
+// generated file; do not modify
+#include <common/monsters/monster/mage.qh>
+#include <common/monsters/monster/shambler.qh>
+#include <common/monsters/monster/spider.qh>
+#include <common/monsters/monster/wyvern.qh>
+#include <common/monsters/monster/zombie.qh>
self.nextthink = time + 0.2;
}
+void M_Shambler_Attack_Lightning_Explode_use(entity this, entity actor, entity trigger)
+{
+ WITHSELF(this, M_Shambler_Attack_Lightning_Explode());
+}
+
void M_Shambler_Attack_Lightning_Damage(entity this, entity inflictor, entity attacker, float damage, int deathtype, vector hitloc, vector force)
{
if (this.health <= 0)
this.health = this.health - damage;
if (this.health <= 0)
- WITHSELF(this, W_PrepareExplosionByDamage(attacker, this.use));
+ W_PrepareExplosionByDamage(this, attacker, adaptor_think2use);
}
void M_Shambler_Attack_Lightning_Touch()
{SELFPARAM();
PROJECTILE_TOUCH;
- self.use ();
+ self.use(this, NULL, NULL);
}
void M_Shambler_Attack_Lightning_Think()
gren.cnt = time + 5;
gren.nextthink = time;
gren.think = M_Shambler_Attack_Lightning_Think;
- gren.use = M_Shambler_Attack_Lightning_Explode;
+ gren.use = M_Shambler_Attack_Lightning_Explode_use;
gren.touch = M_Shambler_Attack_Lightning_Touch;
gren.takedamage = DAMAGE_YES;
}
}
+void M_Spider_Attack_Web_Explode_use(entity this, entity actor, entity trigger)
+{
+ WITHSELF(this, M_Spider_Attack_Web_Explode());
+}
+
void M_Spider_Attack_Web_Touch()
{
PROJECTILE_TOUCH;
entity proj = new(plasma);
proj.owner = proj.realowner = this;
- proj.use = M_Spider_Attack_Web_Explode;
+ proj.use = M_Spider_Attack_Web_Explode_use;
proj.think = adaptor_think2use_hittype_splash;
proj.bot_dodge = true;
proj.bot_dodgerating = 0;
}
}
-void Monster_Use()
-{SELFPARAM();
- if(Monster_ValidTarget(this, activator)) { this.enemy = activator; }
+void Monster_Use(entity this, entity actor, entity trigger)
+{
+ if(Monster_ValidTarget(this, actor)) { this.enemy = actor; }
}
vector Monster_Move_Target(entity this, entity targ)
}
}
-void Monster_Appear()
-{SELFPARAM();
- this.enemy = activator;
+void Monster_Appear(entity this, entity actor, entity trigger)
+{
+ this.enemy = actor;
this.spawnflags &= ~MONSTERFLAG_APPEAR; // otherwise, we get an endless loop
Monster_Spawn(this, this.monsterid);
}
this.candrop = false; // killed by mobkill command
// TODO: fix this?
- activator = attacker;
- other = this.enemy;
- WITHSELF(this, SUB_UseTargets());
+ SUB_UseTargets(this, attacker, this.enemy);
this.target2 = this.oldtarget2; // reset to original target on death, incase we respawn
Monster_Dead(this, attacker, (this.health <= -100 || deathtype == DEATH_KILL.m_id));
// generated file; do not modify
-#include "all.qc"
+#include <common/mutators/all.qc>
--- /dev/null
+// generated file; do not modify
+#include <common/mutators/all.qh>
// generated file; do not modify
-#include "itemstime.qc"
+#include <common/mutators/mutator/itemstime.qc>
--- /dev/null
+// generated file; do not modify
+#include <common/mutators/mutator/itemstime.qh>
// generated file; do not modify
-#include "bloodloss.qc"
+#include <common/mutators/mutator/bloodloss/bloodloss.qc>
--- /dev/null
+// generated file; do not modify
+#include <common/mutators/mutator/bloodloss/bloodloss.qh>
// generated file; do not modify
-#include "breakablehook.qc"
+#include <common/mutators/mutator/breakablehook/breakablehook.qc>
--- /dev/null
+// generated file; do not modify
+#include <common/mutators/mutator/breakablehook/breakablehook.qh>
// generated file; do not modify
-#include "all.qc"
-#include "buffs.qc"
+#include <common/mutators/mutator/buffs/all.qc>
+#include <common/mutators/mutator/buffs/buffs.qc>
--- /dev/null
+// generated file; do not modify
+#include <common/mutators/mutator/buffs/all.qh>
+#include <common/mutators/mutator/buffs/buffs.qh>
// generated file; do not modify
-#include "bugrigs.qc"
+#include <common/mutators/mutator/bugrigs/bugrigs.qc>
--- /dev/null
+// generated file; do not modify
+#include <common/mutators/mutator/bugrigs/bugrigs.qh>
// generated file; do not modify
-#include "campcheck.qc"
+#include <common/mutators/mutator/campcheck/campcheck.qc>
--- /dev/null
+// generated file; do not modify
+#include <common/mutators/mutator/campcheck/campcheck.qh>
{
Send_Notification(NOTIF_ONE, self, MSG_CENTER, CENTER_CAMPCHECK);
if(self.vehicle)
- Damage(self.vehicle, self, self, autocvar_g_campcheck_damage * 2, DEATH_CAMP.m_id, self.vehicle.origin, '0 0 0');
+ Damage(self.vehicle, world, world, autocvar_g_campcheck_damage * 2, DEATH_CAMP.m_id, self.vehicle.origin, '0 0 0');
else
- Damage(self, self, self, bound(0, autocvar_g_campcheck_damage, self.health + self.armorvalue * autocvar_g_balance_armor_blockpercent + 5), DEATH_CAMP.m_id, self.origin, '0 0 0');
+ Damage(self, world, world, bound(0, autocvar_g_campcheck_damage, self.health + self.armorvalue * autocvar_g_balance_armor_blockpercent + 5), DEATH_CAMP.m_id, self.origin, '0 0 0');
}
self.campcheck_nextcheck = time + autocvar_g_campcheck_interval;
self.campcheck_traveled_distance = 0;
// generated file; do not modify
-#include "cloaked.qc"
+#include <common/mutators/mutator/cloaked/cloaked.qc>
--- /dev/null
+// generated file; do not modify
+#include <common/mutators/mutator/cloaked/cloaked.qh>
// generated file; do not modify
-#include "damagetext.qc"
+#include <common/mutators/mutator/damagetext/damagetext.qc>
--- /dev/null
+// generated file; do not modify
+#include <common/mutators/mutator/damagetext/damagetext.qh>
METHOD(XonoticDamageTextSettings, showNotify, void(entity this)) { loadAllCvars(this); }
METHOD(XonoticDamageTextSettings, fill, void(entity this))
{
+ entity e;
this.gotoRC(this, 0, 1); this.setFirstColumn(this, this.currentColumn);
this.TD(this, 1, 3, makeXonoticCheckBox(0, "cl_damagetext", _("Draw damage numbers")));
this.TR(this);
- this.TD(this, 1, 1, makeXonoticTextLabel(0, _("Font size:")));
- this.TD(this, 1, 2, makeXonoticSlider(0, 50, 1, "cl_damagetext_size"));
+ this.TD(this, 1, 1, e = makeXonoticTextLabel(0, _("Font size:")));
+ setDependent(e, "cl_damagetext", 1, 1);
+ this.TD(this, 1, 2, e = makeXonoticSlider(0, 50, 1, "cl_damagetext_size"));
+ setDependent(e, "cl_damagetext", 1, 1);
this.TR(this);
- this.TD(this, 1, 1, makeXonoticTextLabel(0, _("Accumulate range:")));
- this.TD(this, 1, 2, makeXonoticSlider(0, 500, 1, "cl_damagetext_accumulate_range"));
+ this.TD(this, 1, 1, e = makeXonoticTextLabel(0, _("Accumulate range:")));
+ setDependent(e, "cl_damagetext", 1, 1);
+ this.TD(this, 1, 2, e = makeXonoticSlider(0, 500, 1, "cl_damagetext_accumulate_range"));
+ setDependent(e, "cl_damagetext", 1, 1);
this.TR(this);
- this.TD(this, 1, 1, makeXonoticTextLabel(0, _("Lifetime:")));
- this.TD(this, 1, 2, makeXonoticSlider(0, 10, 1, "cl_damagetext_alpha_lifetime"));
+ this.TD(this, 1, 1, e = makeXonoticTextLabel(0, _("Lifetime:")));
+ setDependent(e, "cl_damagetext", 1, 1);
+ this.TD(this, 1, 2, e = makeXonoticSlider(0, 10, 1, "cl_damagetext_alpha_lifetime"));
+ setDependent(e, "cl_damagetext", 1, 1);
this.TR(this);
- this.TD(this, 1, 1, makeXonoticTextLabel(0, _("Color:")));
- this.TD(this, 2, 2, makeXonoticColorpickerString("cl_damagetext_color", "cl_damagetext_color"));
+ this.TD(this, 1, 1, e = makeXonoticTextLabel(0, _("Color:")));
+ setDependent(e, "cl_damagetext", 1, 1);
+ this.TD(this, 2, 2, e = makeXonoticColorpickerString("cl_damagetext_color", "cl_damagetext_color"));
+ setDependent(e, "cl_damagetext", 1, 1);
}
ENDCLASS(XonoticDamageTextSettings)
#endif
// generated file; do not modify
-#include "dodging.qc"
+#include <common/mutators/mutator/dodging/dodging.qc>
--- /dev/null
+// generated file; do not modify
+#include <common/mutators/mutator/dodging/dodging.qh>
// generated file; do not modify
-#include "doublejump.qc"
+#include <common/mutators/mutator/doublejump/doublejump.qc>
--- /dev/null
+// generated file; do not modify
+#include <common/mutators/mutator/doublejump/doublejump.qh>
// generated file; do not modify
-#include "hook.qc"
+#include <common/mutators/mutator/hook/hook.qc>
--- /dev/null
+// generated file; do not modify
+#include <common/mutators/mutator/hook/hook.qh>
// generated file; do not modify
-#include "instagib.qc"
-#include "items.qc"
+#include <common/mutators/mutator/instagib/instagib.qc>
+#include <common/mutators/mutator/instagib/items.qc>
--- /dev/null
+// generated file; do not modify
+#include <common/mutators/mutator/instagib/instagib.qh>
+#include <common/mutators/mutator/instagib/items.qh>
if(IS_PLAYER(frag_attacker))
if(DEATH_ISWEAPON(frag_deathtype, WEP_VAPORIZER))
{
+ if(!autocvar_g_instagib_friendlypush && SAME_TEAM(frag_target, frag_attacker))
+ frag_force = '0 0 0';
+
if(frag_target.armorvalue)
{
frag_target.armorvalue -= 1;
if(frag_deathtype & HITTYPE_SECONDARY)
{
if(!autocvar_g_instagib_blaster_keepdamage || frag_attacker == frag_target)
- frag_damage = frag_mirrordamage = 0;
+ {
+ frag_damage = 0;
+ if(!autocvar_g_instagib_mirrordamage)
+ frag_mirrordamage = 0; // never do mirror damage on enemies
+ }
if(frag_target != frag_attacker)
{
}
}
+ if(!autocvar_g_instagib_mirrordamage) // only apply the taking lives hack if we don't want to support real damage mirroring
if(IS_PLAYER(frag_attacker))
if(frag_mirrordamage > 0)
{
}
if(frag_target.alpha && frag_target.alpha < 1)
+ if(IS_PLAYER(frag_target))
yoda = 1;
return false;
// generated file; do not modify
-#include "invincibleproj.qc"
+#include <common/mutators/mutator/invincibleproj/invincibleproj.qc>
--- /dev/null
+// generated file; do not modify
+#include <common/mutators/mutator/invincibleproj/invincibleproj.qh>
// generated file; do not modify
-#include "melee_only.qc"
+#include <common/mutators/mutator/melee_only/melee_only.qc>
--- /dev/null
+// generated file; do not modify
+#include <common/mutators/mutator/melee_only/melee_only.qh>
// generated file; do not modify
-#include "midair.qc"
+#include <common/mutators/mutator/midair/midair.qc>
--- /dev/null
+// generated file; do not modify
+#include <common/mutators/mutator/midair/midair.qh>
// generated file; do not modify
-#include "multijump.qc"
+#include <common/mutators/mutator/multijump/multijump.qc>
--- /dev/null
+// generated file; do not modify
+#include <common/mutators/mutator/multijump/multijump.qh>
// generated file; do not modify
-#include "nades.qc"
-#include "net.qc"
+#include <common/mutators/mutator/nades/nades.qc>
+#include <common/mutators/mutator/nades/net.qc>
--- /dev/null
+// generated file; do not modify
+#include <common/mutators/mutator/nades/nades.qh>
+#include <common/mutators/mutator/nades/net.qh>
#ifdef SVQC
bool autocvar_g_nades_nade_small;
+float autocvar_g_nades_spread = 0.04;
#endif
REGISTER_STAT(NADES_SMALL, int, autocvar_g_nades_nade_small)
this.realowner = attacker;
if(this.health <= 0)
- WITHSELF(this, W_PrepareExplosionByDamage(attacker, nade_boom));
+ W_PrepareExplosionByDamage(this, attacker, nade_boom);
else
nade_burn_spawn(this);
}
float _force = time - held_nade.nade_time_primed;
_force /= autocvar_g_nades_nade_lifetime;
_force = autocvar_g_nades_nade_minforce + (_force * (autocvar_g_nades_nade_maxforce - autocvar_g_nades_nade_minforce));
- toss_nade(self, true, (v_forward * 0.75 + v_up * 0.2 + v_right * 0.05) * _force, 0);
+ vector dir = (v_forward * 0.75 + v_up * 0.2 + v_right * 0.05);
+ dir = W_CalculateSpread(dir, autocvar_g_nades_spread, g_weaponspreadfactor, autocvar_g_projectiles_spread_style);
+ toss_nade(self, true, dir * _force, 0);
}
}
}
float _force = time - held_nade.nade_time_primed;
_force /= autocvar_g_nades_nade_lifetime;
_force = autocvar_g_nades_nade_minforce + (_force * (autocvar_g_nades_nade_maxforce - autocvar_g_nades_nade_minforce));
- toss_nade(player, false, (v_forward * 0.7 + v_up * 0.2 + v_right * 0.1) * _force, 0);
+ vector dir = (v_forward * 0.7 + v_up * 0.2 + v_right * 0.1);
+ dir = W_CalculateSpread(dir, autocvar_g_nades_spread, g_weaponspreadfactor, autocvar_g_projectiles_spread_style);
+ toss_nade(player, false, dir * _force, 0);
}
}
}
// generated file; do not modify
-#include "new_toys.qc"
+#include <common/mutators/mutator/new_toys/new_toys.qc>
--- /dev/null
+// generated file; do not modify
+#include <common/mutators/mutator/new_toys/new_toys.qh>
// generated file; do not modify
-#include "nix.qc"
+#include <common/mutators/mutator/nix/nix.qc>
--- /dev/null
+// generated file; do not modify
+#include <common/mutators/mutator/nix/nix.qh>
// generated file; do not modify
-#include "hmg.qc"
-#include "overkill.qc"
-#include "rpc.qc"
+#include <common/mutators/mutator/overkill/hmg.qc>
+#include <common/mutators/mutator/overkill/overkill.qc>
+#include <common/mutators/mutator/overkill/rpc.qc>
--- /dev/null
+// generated file; do not modify
+#include <common/mutators/mutator/overkill/hmg.qh>
+#include <common/mutators/mutator/overkill/overkill.qh>
+#include <common/mutators/mutator/overkill/rpc.qh>
this.health = this.health - damage;
if (this.health <= 0)
- WITHSELF(this, W_PrepareExplosionByDamage(attacker, W_RocketPropelledChainsaw_Explode));
+ W_PrepareExplosionByDamage(this, attacker, W_RocketPropelledChainsaw_Explode);
}
void W_RocketPropelledChainsaw_Think()
// generated file; do not modify
-#include "physical_items.qc"
+#include <common/mutators/mutator/physical_items/physical_items.qc>
--- /dev/null
+// generated file; do not modify
+#include <common/mutators/mutator/physical_items/physical_items.qh>
// generated file; do not modify
-#include "pinata.qc"
+#include <common/mutators/mutator/pinata/pinata.qc>
--- /dev/null
+// generated file; do not modify
+#include <common/mutators/mutator/pinata/pinata.qh>
// generated file; do not modify
-#include "random_gravity.qc"
+#include <common/mutators/mutator/random_gravity/random_gravity.qc>
--- /dev/null
+// generated file; do not modify
+#include <common/mutators/mutator/random_gravity/random_gravity.qh>
// generated file; do not modify
-#include "rocketflying.qc"
+#include <common/mutators/mutator/rocketflying/rocketflying.qc>
--- /dev/null
+// generated file; do not modify
+#include <common/mutators/mutator/rocketflying/rocketflying.qh>
// generated file; do not modify
-#include "rocketminsta.qc"
+#include <common/mutators/mutator/rocketminsta/rocketminsta.qc>
--- /dev/null
+// generated file; do not modify
+#include <common/mutators/mutator/rocketminsta/rocketminsta.qh>
// generated file; do not modify
-#include "running_guns.qc"
+#include <common/mutators/mutator/running_guns/running_guns.qc>
--- /dev/null
+// generated file; do not modify
+#include <common/mutators/mutator/running_guns/running_guns.qh>
// generated file; do not modify
-#include "sandbox.qc"
+#include <common/mutators/mutator/sandbox/sandbox.qc>
--- /dev/null
+// generated file; do not modify
+#include <common/mutators/mutator/sandbox/sandbox.qh>
// generated file; do not modify
-#include "spawn_near_teammate.qc"
+#include <common/mutators/mutator/spawn_near_teammate/spawn_near_teammate.qc>
--- /dev/null
+// generated file; do not modify
+#include <common/mutators/mutator/spawn_near_teammate/spawn_near_teammate.qh>
// generated file; do not modify
-#include "superspec.qc"
+#include <common/mutators/mutator/superspec/superspec.qc>
--- /dev/null
+// generated file; do not modify
+#include <common/mutators/mutator/superspec/superspec.qh>
// generated file; do not modify
-#include "touchexplode.qc"
+#include <common/mutators/mutator/touchexplode/touchexplode.qc>
--- /dev/null
+// generated file; do not modify
+#include <common/mutators/mutator/touchexplode/touchexplode.qh>
// generated file; do not modify
-#include "vampire.qc"
+#include <common/mutators/mutator/vampire/vampire.qc>
--- /dev/null
+// generated file; do not modify
+#include <common/mutators/mutator/vampire/vampire.qh>
// generated file; do not modify
-#include "vampirehook.qc"
+#include <common/mutators/mutator/vampirehook/vampirehook.qc>
--- /dev/null
+// generated file; do not modify
+#include <common/mutators/mutator/vampirehook/vampirehook.qh>
// generated file; do not modify
-#include "waypointsprites.qc"
+#include <common/mutators/mutator/waypoints/waypointsprites.qc>
--- /dev/null
+// generated file; do not modify
+#include <common/mutators/mutator/waypoints/waypointsprites.qh>
{
WaypointSprite_Kill(carrier.waypointsprite_attached); // FC overrides attached
entity e = WaypointSprite_Spawn(spr, 0, 0, carrier, '0 0 64', world, carrier.team, carrier, waypointsprite_attachedforcarrier, false, icon);
- if (e)
+ if (carrier.health)
{
WaypointSprite_UpdateMaxHealth(e, '1 0 0' * healtharmor_maxdamage(start_health, start_armorvalue, autocvar_g_balance_armor_blockpercent, DEATH_WEAPON.m_id) * 2);
WaypointSprite_UpdateHealth(e, '1 0 0' * healtharmor_maxdamage(carrier.health, carrier.armorvalue, autocvar_g_balance_armor_blockpercent, DEATH_WEAPON.m_id));
// generated file; do not modify
-#include "weaponarena_random.qc"
+#include <common/mutators/mutator/weaponarena_random/weaponarena_random.qc>
--- /dev/null
+// generated file; do not modify
+#include <common/mutators/mutator/weaponarena_random/weaponarena_random.qh>
// generated file; do not modify
-#include "all.qc"
+#include <common/notifications/all.qc>
--- /dev/null
+// generated file; do not modify
+#include <common/notifications/all.qh>
// generated file; do not modify
-#include "movelib.qc"
-#include "player.qc"
+#include <common/physics/movelib.qc>
+#include <common/physics/player.qc>
--- /dev/null
+// generated file; do not modify
+#include <common/physics/movelib.qh>
+#include <common/physics/player.qh>
// generated file; do not modify
-#include "follow.qc"
-#include "movetypes.qc"
-#include "push.qc"
-#include "step.qc"
-#include "toss.qc"
-#include "walk.qc"
+#include <common/physics/movetypes/follow.qc>
+#include <common/physics/movetypes/movetypes.qc>
+#include <common/physics/movetypes/push.qc>
+#include <common/physics/movetypes/step.qc>
+#include <common/physics/movetypes/toss.qc>
+#include <common/physics/movetypes/walk.qc>
--- /dev/null
+// generated file; do not modify
+#include <common/physics/movetypes/follow.qh>
+#include <common/physics/movetypes/movetypes.qh>
+#include <common/physics/movetypes/push.qh>
+#include <common/physics/movetypes/step.qh>
+#include <common/physics/movetypes/toss.qh>
+#include <common/physics/movetypes/walk.qh>
{
float air_jump = !PlayerJump(this) || player_multijump; // PlayerJump() has important side effects
float activate = JETPACK_JUMP(this) && air_jump && PHYS_INPUT_BUTTON_JUMP(this) || PHYS_INPUT_BUTTON_JETPACK(this);
- float has_fuel = !PHYS_JETPACK_FUEL(this) || PHYS_AMMO_FUEL(this) || ITEMS_STAT(this) & IT_UNLIMITED_WEAPON_AMMO;
+ float has_fuel = !PHYS_JETPACK_FUEL(this) || PHYS_AMMO_FUEL(this) || (ITEMS_STAT(this) & IT_UNLIMITED_WEAPON_AMMO);
if (!(ITEMS_STAT(this) & ITEM_Jetpack.m_itemid)) { }
else if (this.jetpack_stopped) { }
return true;
}
-#ifdef CSQC
-float autocvar_slowmo;
-#endif
-
void PM_Main(entity this)
{
int buttons = PHYS_INPUT_BUTTON_MASK(this);
this.spectatorspeed = STAT(SPECTATORSPEED);
- vector oldv_angle = this.v_angle;
- vector oldangles = this.angles; // we need to save these, as they're abused by other code
- this.v_angle = PHYS_INPUT_ANGLES(this);
- this.angles = PHYS_WORLD_ANGLES(this);
-
this.team = myteam + 1; // is this correct?
if (!(PHYS_INPUT_BUTTON_JUMP(this))) // !jump
UNSET_JUMP_HELD(this); // canjump = true
if (this.PlayerPhysplug)
if (this.PlayerPhysplug(this))
return;
-#elif defined(CSQC)
- if(autocvar_slowmo != STAT(MOVEVARS_TIMESCALE))
- cvar_set("slowmo", ftos(STAT(MOVEVARS_TIMESCALE)));
#endif
#ifdef SVQC
this.lastflags = this.flags;
this.lastclassname = this.classname;
-
-#ifdef CSQC
- this.v_angle = oldv_angle;
- this.angles = oldangles;
-#endif
}
#if defined(SVQC)
// generated file; do not modify
-#include "all.qc"
+#include <common/sounds/all.qc>
--- /dev/null
+// generated file; do not modify
+#include <common/sounds/all.qh>
// compatibility:
spawnfunc(item_quad) { this.classname = "item_strength";spawnfunc_item_strength(this);}
-void target_items_use()
-{SELFPARAM();
- if(activator.classname == "droppedweapon")
+void target_items_use(entity this, entity actor, entity trigger)
+{
+ other = trigger; // TODO
+
+ if(actor.classname == "droppedweapon")
{
EXACTTRIGGER_TOUCH;
- remove(activator);
+ remove(actor);
return;
}
- if (!IS_PLAYER(activator))
+ if (!IS_PLAYER(actor))
return;
- if(IS_DEAD(activator))
+ if(IS_DEAD(actor))
return;
EXACTTRIGGER_TOUCH;
- FOREACH_ENTITY_ENT(enemy, activator,
+ FOREACH_ENTITY_ENT(enemy, actor,
{
if(it.classname == "droppedweapon")
remove(it);
});
- if(GiveItems(activator, 0, tokenize_console(self.netname)))
- centerprint(activator, self.message);
+ if(GiveItems(actor, 0, tokenize_console(this.netname)))
+ centerprint(actor, this.message);
}
spawnfunc(target_items)
void _StartItem(entity this, entity def, float defaultrespawntime, float defaultrespawntimejitter);
-void target_items_use ();
-
float GiveWeapon(entity e, float wpn, float op, float val);
float GiveBit(entity e, .float fld, float bit, float op, float val);
// generated file; do not modify
-#include "include.qc"
-#include "platforms.qc"
-#include "subs.qc"
-#include "teleporters.qc"
-#include "triggers.qc"
+#include <common/triggers/include.qc>
+#include <common/triggers/platforms.qc>
+#include <common/triggers/subs.qc>
+#include <common/triggers/teleporters.qc>
+#include <common/triggers/triggers.qc>
--- /dev/null
+// generated file; do not modify
+#include <common/triggers/include.qh>
+#include <common/triggers/platforms.qh>
+#include <common/triggers/subs.qh>
+#include <common/triggers/teleporters.qh>
+#include <common/triggers/triggers.qh>
// generated file; do not modify
-#include "bobbing.qc"
-#include "breakable.qc"
-#include "button.qc"
-#include "conveyor.qc"
-#include "door.qc"
-#include "door_rotating.qc"
-#include "door_secret.qc"
-#include "fourier.qc"
-#include "include.qc"
-#include "ladder.qc"
-#include "pendulum.qc"
-#include "plat.qc"
-#include "pointparticles.qc"
-#include "rainsnow.qc"
-#include "rotating.qc"
-#include "stardust.qc"
-#include "train.qc"
-#include "vectormamamam.qc"
+#include <common/triggers/func/bobbing.qc>
+#include <common/triggers/func/breakable.qc>
+#include <common/triggers/func/button.qc>
+#include <common/triggers/func/conveyor.qc>
+#include <common/triggers/func/door.qc>
+#include <common/triggers/func/door_rotating.qc>
+#include <common/triggers/func/door_secret.qc>
+#include <common/triggers/func/fourier.qc>
+#include <common/triggers/func/include.qc>
+#include <common/triggers/func/ladder.qc>
+#include <common/triggers/func/pendulum.qc>
+#include <common/triggers/func/plat.qc>
+#include <common/triggers/func/pointparticles.qc>
+#include <common/triggers/func/rainsnow.qc>
+#include <common/triggers/func/rotating.qc>
+#include <common/triggers/func/stardust.qc>
+#include <common/triggers/func/train.qc>
+#include <common/triggers/func/vectormamamam.qc>
--- /dev/null
+// generated file; do not modify
+#include <common/triggers/func/bobbing.qh>
+#include <common/triggers/func/breakable.qh>
+#include <common/triggers/func/button.qh>
+#include <common/triggers/func/conveyor.qh>
+#include <common/triggers/func/door.qh>
+#include <common/triggers/func/door_rotating.qh>
+#include <common/triggers/func/door_secret.qh>
+#include <common/triggers/func/fourier.qh>
+#include <common/triggers/func/include.qh>
+#include <common/triggers/func/ladder.qh>
+#include <common/triggers/func/pendulum.qh>
+#include <common/triggers/func/plat.qh>
+#include <common/triggers/func/pointparticles.qh>
+#include <common/triggers/func/rainsnow.qh>
+#include <common/triggers/func/rotating.qh>
+#include <common/triggers/func/stardust.qh>
+#include <common/triggers/func/train.qh>
+#include <common/triggers/func/vectormamamam.qh>
// func_breakable
// - basically func_assault_destructible for general gameplay use
//
-void LaunchDebris (string debrisname, vector force)
-{SELFPARAM();
+void LaunchDebris (entity this, string debrisname, vector force)
+{
entity dbr = spawn();
- vector org = self.absmin
- + '1 0 0' * random() * (self.absmax.x - self.absmin.x)
- + '0 1 0' * random() * (self.absmax.y - self.absmin.y)
- + '0 0 1' * random() * (self.absmax.z - self.absmin.z);
+ vector org = this.absmin
+ + '1 0 0' * random() * (this.absmax.x - this.absmin.x)
+ + '0 1 0' * random() * (this.absmax.y - this.absmin.y)
+ + '0 0 1' * random() * (this.absmax.z - this.absmin.z);
setorigin(dbr, org);
_setmodel (dbr, debrisname );
- dbr.skin = self.debrisskin;
- dbr.colormap = self.colormap; // inherit team colors
- dbr.owner = self; // do not be affected by our own explosion
- dbr.movetype = self.debrismovetype;
- dbr.solid = self.debrissolid;
+ dbr.skin = this.debrisskin;
+ dbr.colormap = this.colormap; // inherit team colors
+ dbr.owner = this; // do not be affected by our own explosion
+ dbr.movetype = this.debrismovetype;
+ dbr.solid = this.debrissolid;
if(dbr.solid != SOLID_BSP) // SOLID_BSP has exact collision, MAYBE this works? TODO check this out
setsize(dbr, '0 0 0', '0 0 0'); // needed for performance, until engine can deal better with it
- dbr.velocity_x = self.debrisvelocity.x + self.debrisvelocityjitter.x * crandom();
- dbr.velocity_y = self.debrisvelocity.y + self.debrisvelocityjitter.y * crandom();
- dbr.velocity_z = self.debrisvelocity.z + self.debrisvelocityjitter.z * crandom();
- self.velocity = self.velocity + force * self.debrisdamageforcescale;
- dbr.avelocity_x = random()*self.debrisavelocityjitter.x;
- dbr.avelocity_y = random()*self.debrisavelocityjitter.y;
- dbr.avelocity_z = random()*self.debrisavelocityjitter.z;
- dbr.damageforcescale = self.debrisdamageforcescale;
+ dbr.velocity_x = this.debrisvelocity.x + this.debrisvelocityjitter.x * crandom();
+ dbr.velocity_y = this.debrisvelocity.y + this.debrisvelocityjitter.y * crandom();
+ dbr.velocity_z = this.debrisvelocity.z + this.debrisvelocityjitter.z * crandom();
+ this.velocity = this.velocity + force * this.debrisdamageforcescale;
+ dbr.avelocity_x = random()*this.debrisavelocityjitter.x;
+ dbr.avelocity_y = random()*this.debrisavelocityjitter.y;
+ dbr.avelocity_z = random()*this.debrisavelocityjitter.z;
+ dbr.damageforcescale = this.debrisdamageforcescale;
if(dbr.damageforcescale)
dbr.takedamage = DAMAGE_YES;
- SUB_SetFade(dbr, time + self.debristime + crandom() * self.debristimejitter, self.debrisfadetime);
+ SUB_SetFade(dbr, time + this.debristime + crandom() * this.debristimejitter, this.debrisfadetime);
}
-void func_breakable_colormod()
-{SELFPARAM();
+void func_breakable_colormod(entity this)
+{
float h;
- if (!(self.spawnflags & 2))
+ if (!(this.spawnflags & 2))
return;
- h = self.health / self.max_health;
+ h = this.health / this.max_health;
if(h < 0.25)
- self.colormod = '1 0 0';
+ this.colormod = '1 0 0';
else if(h <= 0.75)
- self.colormod = '1 0 0' + '0 1 0' * (2 * h - 0.5);
+ this.colormod = '1 0 0' + '0 1 0' * (2 * h - 0.5);
else
- self.colormod = '1 1 1';
+ this.colormod = '1 1 1';
- CSQCMODEL_AUTOUPDATE(self);
+ CSQCMODEL_AUTOUPDATE(this);
}
-void func_breakable_look_destroyed()
-{SELFPARAM();
+void func_breakable_look_destroyed(entity this)
+{
float floorZ;
- if(self.solid == SOLID_BSP) // in case a misc_follow moved me, save the current origin first
- self.dropped_origin = self.origin;
+ if(this.solid == SOLID_BSP) // in case a misc_follow moved me, save the current origin first
+ this.dropped_origin = this.origin;
- if(self.mdl_dead == "")
- self.effects |= EF_NODRAW;
+ if(this.mdl_dead == "")
+ this.effects |= EF_NODRAW;
else {
- if (self.origin == '0 0 0') { // probably no origin brush, so don't spawn in the middle of the map..
- floorZ = self.absmin.z;
- setorigin(self,((self.absmax+self.absmin)*.5));
- self.origin_z = floorZ;
+ if (this.origin == '0 0 0') { // probably no origin brush, so don't spawn in the middle of the map..
+ floorZ = this.absmin.z;
+ setorigin(this,((this.absmax+this.absmin)*.5));
+ this.origin_z = floorZ;
}
- _setmodel(self, self.mdl_dead);
- self.effects &= ~EF_NODRAW;
+ _setmodel(this, this.mdl_dead);
+ this.effects &= ~EF_NODRAW;
}
- CSQCMODEL_AUTOUPDATE(self);
+ CSQCMODEL_AUTOUPDATE(this);
- self.solid = SOLID_NOT;
+ this.solid = SOLID_NOT;
}
-void func_breakable_look_restore()
-{SELFPARAM();
- _setmodel(self, self.mdl);
- self.effects &= ~EF_NODRAW;
+void func_breakable_look_restore(entity this)
+{
+ _setmodel(this, this.mdl);
+ this.effects &= ~EF_NODRAW;
- if(self.mdl_dead != "") // only do this if we use mdl_dead, to behave better with misc_follow
- setorigin(self, self.dropped_origin);
+ if(this.mdl_dead != "") // only do this if we use mdl_dead, to behave better with misc_follow
+ setorigin(this, this.dropped_origin);
- CSQCMODEL_AUTOUPDATE(self);
+ CSQCMODEL_AUTOUPDATE(this);
- self.solid = SOLID_BSP;
+ this.solid = SOLID_BSP;
}
-void func_breakable_behave_destroyed()
-{SELFPARAM();
- self.health = self.max_health;
- self.takedamage = DAMAGE_NO;
- self.bot_attack = false;
- self.event_damage = func_null;
- self.state = 1;
- if(self.spawnflags & 4)
- self.use = func_null;
- func_breakable_colormod();
- if (self.noise1)
- stopsound (self, CH_TRIGGER_SINGLE);
+void func_breakable_behave_destroyed(entity this)
+{
+ this.health = this.max_health;
+ this.takedamage = DAMAGE_NO;
+ this.bot_attack = false;
+ this.event_damage = func_null;
+ this.state = 1;
+ if(this.spawnflags & 4)
+ this.use = func_null;
+ func_breakable_colormod(this);
+ if (this.noise1)
+ stopsound (this, CH_TRIGGER_SINGLE);
}
-void func_breakable_behave_restore()
-{SELFPARAM();
- self.health = self.max_health;
- if(self.sprite)
+void func_breakable_behave_restore(entity this)
+{
+ this.health = this.max_health;
+ if(this.sprite)
{
- WaypointSprite_UpdateMaxHealth(self.sprite, self.max_health);
- WaypointSprite_UpdateHealth(self.sprite, self.health);
+ WaypointSprite_UpdateMaxHealth(this.sprite, this.max_health);
+ WaypointSprite_UpdateHealth(this.sprite, this.health);
}
- if(!(self.spawnflags & 4))
+ if(!(this.spawnflags & 4))
{
- self.takedamage = DAMAGE_AIM;
- self.bot_attack = true;
- self.event_damage = func_breakable_damage;
+ this.takedamage = DAMAGE_AIM;
+ this.bot_attack = true;
+ this.event_damage = func_breakable_damage;
}
- self.state = 0;
- self.nextthink = 0; // cancel auto respawn
- func_breakable_colormod();
- if (self.noise1)
- _sound (self, CH_TRIGGER_SINGLE, self.noise1, VOL_BASE, ATTEN_NORM);
+ this.state = 0;
+ this.nextthink = 0; // cancel auto respawn
+ func_breakable_colormod(this);
+ if (this.noise1)
+ _sound (this, CH_TRIGGER_SINGLE, this.noise1, VOL_BASE, ATTEN_NORM);
}
void func_breakable_init_for_player(entity player)
}
}
-void func_breakable_destroyed()
-{SELFPARAM();
- func_breakable_look_destroyed();
- func_breakable_behave_destroyed();
+void func_breakable_destroyed(entity this)
+{
+ func_breakable_look_destroyed(this);
+ func_breakable_behave_destroyed(this);
- CSQCMODEL_AUTOUPDATE(self);
+ CSQCMODEL_AUTOUPDATE(this);
}
-void func_breakable_restore()
-{SELFPARAM();
- func_breakable_look_restore();
- func_breakable_behave_restore();
+void func_breakable_restore(entity this, entity actor, entity trigger)
+{
+ func_breakable_look_restore(this);
+ func_breakable_behave_restore(this);
- CSQCMODEL_AUTOUPDATE(self);
+ CSQCMODEL_AUTOUPDATE(this);
}
-vector debrisforce; // global, set before calling this
-void func_breakable_destroy()
+void func_breakable_restore_self()
{SELFPARAM();
+ func_breakable_restore(this, NULL, NULL);
+}
+
+vector debrisforce; // global, set before calling this
+void func_breakable_destroy(entity this, entity actor, entity trigger)
+{
float n, i;
string oldmsg;
- activator = self.owner;
- self.owner = world; // set by W_PrepareExplosionByDamage
+ entity act = this.owner;
+ this.owner = world; // set by W_PrepareExplosionByDamage
// now throw around the debris
- n = tokenize_console(self.debris);
+ n = tokenize_console(this.debris);
for(i = 0; i < n; ++i)
- LaunchDebris(argv(i), debrisforce);
+ LaunchDebris(this, argv(i), debrisforce);
- func_breakable_destroyed();
+ func_breakable_destroyed(this);
- if(self.noise)
- _sound (self, CH_TRIGGER, self.noise, VOL_BASE, ATTEN_NORM);
+ if(this.noise)
+ _sound (this, CH_TRIGGER, this.noise, VOL_BASE, ATTEN_NORM);
- if(self.dmg)
- RadiusDamage(self, activator, self.dmg, self.dmg_edge, self.dmg_radius, self, world, self.dmg_force, DEATH_HURTTRIGGER.m_id, world);
+ if(this.dmg)
+ RadiusDamage(this, act, this.dmg, this.dmg_edge, this.dmg_radius, this, world, this.dmg_force, DEATH_HURTTRIGGER.m_id, world);
- if(self.cnt) // TODO
- __pointparticles(self.cnt, self.absmin * 0.5 + self.absmax * 0.5, '0 0 0', self.count);
+ if(this.cnt) // TODO
+ __pointparticles(this.cnt, this.absmin * 0.5 + this.absmax * 0.5, '0 0 0', this.count);
- if(self.respawntime)
+ if(this.respawntime)
{
- self.think = func_breakable_restore;
- self.nextthink = time + self.respawntime + crandom() * self.respawntimejitter;
+ this.think = func_breakable_restore_self;
+ this.nextthink = time + this.respawntime + crandom() * this.respawntimejitter;
}
- oldmsg = self.message;
- self.message = "";
- SUB_UseTargets();
- self.message = oldmsg;
+ oldmsg = this.message;
+ this.message = "";
+ SUB_UseTargets(this, act, trigger);
+ this.message = oldmsg;
+}
+
+void func_breakable_destroy_self()
+{SELFPARAM();
+ func_breakable_destroy(this, NULL, NULL);
}
void func_breakable_damage(entity this, entity inflictor, entity attacker, float damage, int deathtype, vector hitloc, vector force)
WaypointSprite_Ping(this.sprite);
WaypointSprite_UpdateHealth(this.sprite, this.health);
}
- WITHSELF(this, func_breakable_colormod());
+ func_breakable_colormod(this);
if(this.health <= 0)
{
// do not explode NOW but in the NEXT FRAME!
// because recursive calls to RadiusDamage are not allowed
this.nextthink = time;
- this.think = func_breakable_destroy;
+ this.think = func_breakable_destroy_self;
}
}
void func_breakable_reset(entity this)
{
this.team = this.team_saved;
- func_breakable_look_restore();
+ func_breakable_look_restore(this);
if(this.spawnflags & 1)
- func_breakable_behave_destroyed();
+ func_breakable_behave_destroyed(this);
else
- func_breakable_behave_restore();
+ func_breakable_behave_restore(this);
CSQCMODEL_AUTOUPDATE(this);
}
self.state = STATE_TOP;
self.SUB_NEXTTHINK = self.SUB_LTIME + self.wait;
self.SUB_THINK = button_return;
- activator = self.enemy;
- SUB_UseTargets();
+ SUB_UseTargets(self, self.enemy, NULL);
self.frame = 1; // use alternate textures
}
self.takedamage = DAMAGE_YES; // can be shot again
}
-void button_use()
-{SELFPARAM();
- if(self.active != ACTIVE_ACTIVE)
+void button_use(entity this, entity actor, entity trigger)
+{
+ if(this.active != ACTIVE_ACTIVE)
return;
- self.enemy = activator;
- button_fire ();
+ this.enemy = actor;
+ WITHSELF(this, button_fire());
}
void button_touch()
#ifdef SVQC
-void conveyor_use()
-{SELFPARAM();
- self.state = !self.state;
+void conveyor_use(entity this, entity actor, entity trigger)
+{
+ this.state = !this.state;
- self.SendFlags |= 2;
+ this.SendFlags |= 2;
}
void conveyor_reset(entity this)
string oldmessage;
oldmessage = self.message;
self.message = "";
- SUB_UseTargets();
+ SUB_UseTargets(self, NULL, NULL);
self.message = oldmessage;
}
return false;
}
-void door_fire()
-{SELFPARAM();
- entity starte;
-
- if (self.owner != self)
- objerror ("door_fire: self.owner != self");
+void door_fire(entity this, entity actor, entity trigger)
+{
+ entity starte;
+ if (this.owner != this)
+ objerror ("door_fire: this.owner != this");
- if (self.spawnflags & DOOR_TOGGLE)
+ if (this.spawnflags & DOOR_TOGGLE)
{
- if (self.state == STATE_UP || self.state == STATE_TOP)
+ if (this.state == STATE_UP || this.state == STATE_TOP)
{
starte = self;
do
setself(this);
}
-void door_use()
-{SELFPARAM();
+void door_use(entity this, entity actor, entity trigger)
+{
//dprint("door_use (model: ");dprint(self.model);dprint(")\n");
- if (self.owner)
- {
- WITHSELF(self.owner, door_fire());
- }
+ if (this.owner)
+ WITHSELF(this.owner, door_fire(this.owner, actor, trigger));
}
void door_damage(entity this, entity inflictor, entity attacker, float damage, int deathtype, vector hitloc, vector force)
{
this.owner.health = this.owner.max_health;
this.owner.takedamage = DAMAGE_NO; // wil be reset upon return
- WITHSELF(this.owner, door_use());
+ door_use(this.owner, NULL, NULL);
}
}
string oldmessage;
oldmessage = self.message;
self.message = "";
- SUB_UseTargets();
+ SUB_UseTargets(self, NULL, other); // TODO: is other needed here?
self.message = oldmessage;
}
self.door_finished = time + 1;
- activator = other;
-
- setself(self.owner);
- door_use ();
+ door_use(this.owner, other, NULL);
}
void door_spawnfield(vector fmins, vector fmaxs)
const float SECRET_NO_SHOOT = 8; // only opened by trigger
const float SECRET_YES_SHOOT = 16; // shootable even if targeted
-void fd_secret_use()
-{SELFPARAM();
+void fd_secret_use(entity this, entity actor, entity trigger)
+{
float temp;
string message_save;
- self.health = 10000;
- self.bot_attack = true;
+ this.health = 10000;
+ this.bot_attack = true;
// exit if still moving around...
- if (self.origin != self.oldorigin)
+ if (this.origin != this.oldorigin)
return;
- message_save = self.message;
- self.message = ""; // no more message
- SUB_UseTargets(); // fire all targets / killtargets
- self.message = message_save;
+ message_save = this.message;
+ this.message = ""; // no more message
+ SUB_UseTargets(this, actor, trigger); // fire all targets / killtargets
+ this.message = message_save;
- self.velocity = '0 0 0';
+ this.velocity = '0 0 0';
// Make a sound, wait a little...
- if (self.noise1 != "")
- _sound(self, CH_TRIGGER_SINGLE, self.noise1, VOL_BASE, ATTEN_NORM);
- self.SUB_NEXTTHINK = self.SUB_LTIME + 0.1;
+ if (this.noise1 != "")
+ _sound(this, CH_TRIGGER_SINGLE, this.noise1, VOL_BASE, ATTEN_NORM);
+ this.SUB_NEXTTHINK = this.SUB_LTIME + 0.1;
- temp = 1 - (self.spawnflags & SECRET_1ST_LEFT); // 1 or -1
- makevectors(self.mangle);
+ temp = 1 - (this.spawnflags & SECRET_1ST_LEFT); // 1 or -1
+ makevectors(this.mangle);
- if (!self.t_width)
+ if (!this.t_width)
{
- if (self.spawnflags & SECRET_1ST_DOWN)
- self.t_width = fabs(v_up * self.size);
+ if (this.spawnflags & SECRET_1ST_DOWN)
+ this.t_width = fabs(v_up * this.size);
else
- self.t_width = fabs(v_right * self.size);
+ this.t_width = fabs(v_right * this.size);
}
- if (!self.t_length)
- self.t_length = fabs(v_forward * self.size);
+ if (!this.t_length)
+ this.t_length = fabs(v_forward * this.size);
- if (self.spawnflags & SECRET_1ST_DOWN)
- self.dest1 = self.origin - v_up * self.t_width;
+ if (this.spawnflags & SECRET_1ST_DOWN)
+ this.dest1 = this.origin - v_up * this.t_width;
else
- self.dest1 = self.origin + v_right * (self.t_width * temp);
+ this.dest1 = this.origin + v_right * (this.t_width * temp);
- self.dest2 = self.dest1 + v_forward * self.t_length;
- SUB_CalcMove(self.dest1, TSPEED_LINEAR, self.speed, fd_secret_move1);
- if (self.noise2 != "")
- _sound(self, CH_TRIGGER_SINGLE, self.noise2, VOL_BASE, ATTEN_NORM);
+ this.dest2 = this.dest1 + v_forward * this.t_length;
+ WITHSELF(this, SUB_CalcMove(this.dest1, TSPEED_LINEAR, this.speed, fd_secret_move1));
+ if (this.noise2 != "")
+ _sound(this, CH_TRIGGER_SINGLE, this.noise2, VOL_BASE, ATTEN_NORM);
}
void fd_secret_damage(entity this, entity inflictor, entity attacker, float damage, int deathtype, vector hitloc, vector force)
{
- WITHSELF(this, fd_secret_use());
+ fd_secret_use(this, NULL, NULL);
}
// Wait after first movement...
return 1;
}
-void pointparticles_use()
-{SELFPARAM();
- self.state = !self.state;
- self.SendFlags |= 2;
+void pointparticles_use(entity this, entity actor, entity trigger)
+{
+ this.state = !this.state;
+ this.SendFlags |= 2;
}
void pointparticles_think()
#ifdef SVQC
-void func_rotating_setactive(float astate)
-{SELFPARAM();
-
+void func_rotating_setactive(entity this, int astate)
+{
if (astate == ACTIVE_TOGGLE)
{
- if(self.active == ACTIVE_ACTIVE)
- self.active = ACTIVE_NOT;
+ if(this.active == ACTIVE_ACTIVE)
+ this.active = ACTIVE_NOT;
else
- self.active = ACTIVE_ACTIVE;
+ this.active = ACTIVE_ACTIVE;
}
else
- self.active = astate;
+ this.active = astate;
- if(self.active == ACTIVE_NOT)
- self.avelocity = '0 0 0';
+ if(this.active == ACTIVE_NOT)
+ this.avelocity = '0 0 0';
else
- self.avelocity = self.pos1;
+ this.avelocity = this.pos1;
}
/*QUAKED spawnfunc_func_rotating (0 .5 .8) ? - - X_AXIS Y_AXIS
.float train_wait_turning;
void() train_next;
#ifdef SVQC
-void train_use();
+void train_use(entity this, entity actor, entity trigger);
#endif
void train_wait()
{SELFPARAM();
- WITHSELF(self.enemy, SUB_UseTargets());
+ SUB_UseTargets(this.enemy, NULL, NULL);
self.enemy = world;
// if turning is enabled, the train will turn toward the next point while waiting
//Net_LinkEntity(self, 0, false, train_send);
}
-void train_use()
+void train_use(entity this, entity actor, entity trigger)
{
- SELFPARAM();
- self.SUB_NEXTTHINK = self.SUB_LTIME + 1;
- self.SUB_THINK = train_next;
- self.use = func_null; // not again
+ this.SUB_NEXTTHINK = this.SUB_LTIME + 1;
+ this.SUB_THINK = train_next;
+ this.use = func_null; // not again
}
void func_train_find(entity this)
// generated file; do not modify
-#include "corner.qc"
-#include "follow.qc"
-#include "include.qc"
-#include "laser.qc"
-#include "teleport_dest.qc"
+#include <common/triggers/misc/corner.qc>
+#include <common/triggers/misc/follow.qc>
+#include <common/triggers/misc/include.qc>
+#include <common/triggers/misc/laser.qc>
+#include <common/triggers/misc/teleport_dest.qc>
--- /dev/null
+// generated file; do not modify
+#include <common/triggers/misc/corner.qh>
+#include <common/triggers/misc/follow.qh>
+#include <common/triggers/misc/include.qh>
+#include <common/triggers/misc/laser.qh>
+#include <common/triggers/misc/teleport_dest.qh>
#ifdef SVQC
.float modelscale;
-void misc_laser_aim()
-{SELFPARAM();
+void misc_laser_aim(entity this)
+{
vector a;
- if(self.enemy)
+ if(this.enemy)
{
- if(self.spawnflags & 2)
+ if(this.spawnflags & 2)
{
- if(self.enemy.origin != self.mangle)
+ if(this.enemy.origin != this.mangle)
{
- self.mangle = self.enemy.origin;
- self.SendFlags |= 2;
+ this.mangle = this.enemy.origin;
+ this.SendFlags |= 2;
}
}
else
{
- a = vectoangles(self.enemy.origin - self.origin);
+ a = vectoangles(this.enemy.origin - this.origin);
a_x = -a_x;
- if(a != self.mangle)
+ if(a != this.mangle)
{
- self.mangle = a;
- self.SendFlags |= 2;
+ this.mangle = a;
+ this.SendFlags |= 2;
}
}
}
else
{
- if(self.angles != self.mangle)
+ if(this.angles != this.mangle)
{
- self.mangle = self.angles;
- self.SendFlags |= 2;
+ this.mangle = this.angles;
+ this.SendFlags |= 2;
}
}
- if(self.origin != self.oldorigin)
+ if(this.origin != this.oldorigin)
{
- self.SendFlags |= 1;
- self.oldorigin = self.origin;
+ this.SendFlags |= 1;
+ this.oldorigin = this.origin;
}
}
if(!self.state)
return;
- misc_laser_aim();
+ misc_laser_aim(this);
if(self.enemy)
{
{
self.count = 1;
- activator = self.enemy.pusher;
- WITHSELF(self.enemy, SUB_UseTargets());
+ SUB_UseTargets(self.enemy, self.enemy.pusher, NULL);
}
}
else
{
self.count = 0;
- activator = self.enemy.pusher;
- WITHSELF(self.enemy, SUB_UseTargets());
+ SUB_UseTargets(self.enemy, self.enemy.pusher, NULL);
}
}
}
"dmg"
damage per second (-1 for a laser that kills immediately)
*/
-void laser_use()
-{SELFPARAM();
- self.state = !self.state;
- self.SendFlags |= 4;
- misc_laser_aim();
+void laser_use(entity this, entity actor, entity trigger)
+{
+ this.state = !this.state;
+ this.SendFlags |= 4;
+ misc_laser_aim(this);
}
void laser_reset(entity this)
plat_go_down ();
}
-void plat_trigger_use()
-{SELFPARAM();
+void plat_trigger_use(entity this, entity actor, entity trigger)
+{
#ifdef SVQC
- if (self.think)
+ if (this.think)
return; // already activated
#elif defined(CSQC)
- if(self.move_think)
+ if(this.move_think)
return;
#endif
- plat_go_down();
+ WITHSELF(this, plat_go_down());
}
}
}
-void plat_use()
-{SELFPARAM();
- self.use = func_null;
- if (self.state != 4)
+void plat_use(entity this, entity actor, entity trigger)
+{
+ this.use = func_null;
+ if (this.state != 4)
objerror ("plat_use: not in up state");
- plat_go_down();
+ WITHSELF(this, plat_go_down());
}
.string sound1, sound2;
void() plat_center_touch;
void() plat_outside_touch;
-void() plat_trigger_use;
+void plat_trigger_use(entity this, entity actor, entity trigger);
void() plat_go_up;
void() plat_go_down;
void() plat_crush;
void() SUB_CalcMoveDone;
void() SUB_CalcAngleMoveDone;
-//void() SUB_UseTargets;
/*
==================
#endif
+
void SUB_SetFade (entity ent, float when, float fading_time);
void SUB_VanishOrRemove (entity ent);
.string platmovetype;
.float platmovetype_start, platmovetype_end;
-entity activator;
+//entity activator;
.string killtarget;
// generated file; do not modify
-#include "changelevel.qc"
-#include "include.qc"
-#include "location.qc"
-#include "music.qc"
-#include "spawn.qc"
-#include "speaker.qc"
-#include "voicescript.qc"
+#include <common/triggers/target/changelevel.qc>
+#include <common/triggers/target/include.qc>
+#include <common/triggers/target/location.qc>
+#include <common/triggers/target/music.qc>
+#include <common/triggers/target/spawn.qc>
+#include <common/triggers/target/speaker.qc>
+#include <common/triggers/target/voicescript.qc>
--- /dev/null
+// generated file; do not modify
+#include <common/triggers/target/changelevel.qh>
+#include <common/triggers/target/include.qh>
+#include <common/triggers/target/location.qh>
+#include <common/triggers/target/music.qh>
+#include <common/triggers/target/spawn.qh>
+#include <common/triggers/target/speaker.qh>
+#include <common/triggers/target/voicescript.qh>
.string chmap, gametype;
.entity chlevel_targ;
-
-void target_changelevel_use()
+void target_changelevel_use(entity this, entity actor, entity trigger)
{
- SELFPARAM();
- if(self.spawnflags & 2)
+ if(this.spawnflags & 2)
{
// simply don't react if a non-player triggers it
- if(!IS_PLAYER(activator)) { return; }
+ if(!IS_PLAYER(actor)) { return; }
- activator.chlevel_targ = self;
+ actor.chlevel_targ = this;
int plnum = 0;
int realplnum = 0;
// let's not count bots
FOREACH_CLIENT(IS_PLAYER(it) && IS_REAL_CLIENT(it), {
++realplnum;
- if(it.chlevel_targ == self)
+ if(it.chlevel_targ == this)
++plnum;
});
- if(plnum < ceil(realplnum * min(1, self.count))) // 70% of players
+ if(plnum < ceil(realplnum * min(1, this.count))) // 70% of players
return;
}
- if(self.gametype != "")
- MapInfo_SwitchGameType(MapInfo_Type_FromString(self.gametype));
+ if(this.gametype != "")
+ MapInfo_SwitchGameType(MapInfo_Type_FromString(this.gametype));
- if (self.chmap == "")
+ if (this.chmap == "")
localcmd("endmatch\n");
else
- localcmd(strcat("changelevel ", self.chmap, "\n"));
+ localcmd(strcat("changelevel ", this.chmap, "\n"));
}
spawnfunc(target_changelevel)
{
- self.use = target_changelevel_use;
+ this.use = target_changelevel_use;
- if(!self.count) { self.count = 0.7; }
+ if(!this.count) { this.count = 0.7; }
}
#endif
WITHSELF(it, target_music_sendto(MSG_ALL, 0));
});
}
-void target_music_use()
+void target_music_use(entity this, entity actor, entity trigger)
{
- if(!activator)
+ if(!actor)
return;
- if(IS_REAL_CLIENT(activator))
+ if(IS_REAL_CLIENT(actor))
{
- msg_entity = activator;
+ msg_entity = actor;
target_music_sendto(MSG_ONE, 1);
}
- FOREACH_CLIENT(IS_SPEC(it) && it.enemy == activator, {
+ FOREACH_CLIENT(IS_SPEC(it) && it.enemy == actor, {
msg_entity = it;
target_music_sendto(MSG_ONE, 1);
});
this.cnt = !(this.spawnflags & 1);
this.SendFlags |= 0x80;
}
-void trigger_music_use()
-{SELFPARAM();
- self.cnt = !self.cnt;
- self.SendFlags |= 0x80;
+void trigger_music_use(entity this, entity actor, entity trigger)
+{
+ this.cnt = !this.cnt;
+ this.SendFlags |= 0x80;
}
spawnfunc(trigger_music)
{
setsize(self, self.mins, self.maxs);
}
-void target_spawn_edit_entity(entity e, string msg, entity kt, entity t2, entity t3, entity t4, entity act)
-{SELFPARAM();
+void target_spawn_edit_entity(entity this, entity e, string msg, entity kt, entity t2, entity t3, entity t4, entity act, entity trigger)
+{
float i, n, valuefieldpos;
string key, value, valuefield, valueoffset, valueoffsetrandom;
entity valueent;
vector data, data2;
- entity oldactivator;
n = tokenize_console(msg);
if(value == "self")
{
- valueent = self;
+ valueent = this;
value = "";
}
else if(value == "activator")
}
else if(value == "other")
{
- valueent = other;
+ valueent = trigger;
value = "";
}
else if(value == "pusher")
value = strcat("target_spawn_helper", value);
putentityfieldstring(target_spawn_spawnfunc_field, e, value);
- oldactivator = activator;
-
- activator = act;
WITHSELF(e, e.target_spawn_spawnfunc(e));
- activator = oldactivator;
// We called an external function, so we have to re-tokenize msg.
n = tokenize_console(msg);
}
}
-void target_spawn_useon(entity e)
-{SELFPARAM();
- self.target_spawn_activator = activator;
+void target_spawn_useon(entity e, entity this, entity actor, entity trigger)
+{
+ this.target_spawn_activator = actor;
target_spawn_edit_entity(
+ this,
e,
- self.message,
- find(world, targetname, self.killtarget),
- find(world, targetname, self.target2),
- find(world, targetname, self.target3),
- find(world, targetname, self.target4),
- activator
+ this.message,
+ find(world, targetname, this.killtarget),
+ find(world, targetname, this.target2),
+ find(world, targetname, this.target3),
+ find(world, targetname, this.target4),
+ actor,
+ trigger
);
}
-float target_spawn_cancreate()
-{SELFPARAM();
+bool target_spawn_cancreate(entity this)
+{
float c;
entity e;
- c = self.count;
+ c = this.count;
if(c == 0) // no limit?
- return 1;
+ return true;
++c; // increase count to not include MYSELF
- for(e = world; (e = findfloat(e, target_spawn_id, self.target_spawn_id)); --c)
+ for(e = world; (e = findfloat(e, target_spawn_id, this.target_spawn_id)); --c)
;
// if c now is 0, we have AT LEAST the given count (maybe more), so don't spawn any more
if(c == 0)
- return 0;
- return 1;
+ return false;
+ return true;
}
-void target_spawn_use()
-{SELFPARAM();
- entity e;
-
- if(self.target == "")
+void target_spawn_use(entity this, entity actor, entity trigger)
+{
+ if(this.target == "")
{
// spawn new entity
- if(!target_spawn_cancreate())
+ if(!target_spawn_cancreate(this))
return;
- e = spawn();
+ entity e = spawn();
e.spawnfunc_checked = true;
- target_spawn_useon(e);
- e.target_spawn_id = self.target_spawn_id;
+ target_spawn_useon(e, this, actor, trigger);
+ e.target_spawn_id = this.target_spawn_id;
}
- else if(self.target == "*activator")
+ else if(this.target == "*activator")
{
// edit entity
- if(activator)
- target_spawn_useon(activator);
+ if(actor)
+ target_spawn_useon(actor, this, actor, trigger);
}
else
{
// edit entity
- for(e = world; (e = find(e, targetname, self.target)); )
- target_spawn_useon(e);
+ for(entity e = world; (e = find(e, targetname, this.target)); )
+ target_spawn_useon(e, this, actor, trigger);
}
}
void target_spawn_spawnfirst(entity this)
{
- activator = self.target_spawn_activator;
- if(self.spawnflags & 2)
- target_spawn_use();
+ entity act = this.target_spawn_activator;
+ if(this.spawnflags & 2)
+ target_spawn_use(this, act, NULL);
}
void initialize_field_db()
#ifdef SVQC
// TODO add a way to do looped sounds with sound(); then complete this entity
-void target_speaker_use_off();
-void target_speaker_use_activator()
-{SELFPARAM();
- if (!IS_REAL_CLIENT(activator))
+void target_speaker_use_off(entity this, entity actor, entity trigger);
+void target_speaker_use_activator(entity this, entity actor, entity trigger)
+{
+ if (!IS_REAL_CLIENT(actor))
return;
string snd;
- if(substring(self.noise, 0, 1) == "*")
+ if(substring(this.noise, 0, 1) == "*")
{
- var .string sample = GetVoiceMessageSampleField(substring(self.noise, 1, -1));
+ var .string sample = GetVoiceMessageSampleField(substring(this.noise, 1, -1));
if(GetPlayerSoundSampleField_notFound)
snd = SND(Null);
- else if(activator.(sample) == "")
+ else if(actor.(sample) == "")
snd = SND(Null);
else
{
- tokenize_console(activator.(sample));
+ tokenize_console(actor.(sample));
float n;
n = stof(argv(1));
if(n > 0)
}
}
else
- snd = self.noise;
- msg_entity = activator;
- soundto(MSG_ONE, self, CH_TRIGGER, snd, VOL_BASE * self.volume, self.atten);
+ snd = this.noise;
+ msg_entity = actor;
+ soundto(MSG_ONE, this, CH_TRIGGER, snd, VOL_BASE * this.volume, this.atten);
}
-void target_speaker_use_on()
-{SELFPARAM();
+void target_speaker_use_on(entity this, entity actor, entity trigger)
+{
string snd;
- if(substring(self.noise, 0, 1) == "*")
+ if(substring(this.noise, 0, 1) == "*")
{
- var .string sample = GetVoiceMessageSampleField(substring(self.noise, 1, -1));
+ var .string sample = GetVoiceMessageSampleField(substring(this.noise, 1, -1));
if(GetPlayerSoundSampleField_notFound)
snd = SND(Null);
- else if(activator.(sample) == "")
+ else if(actor.(sample) == "")
snd = SND(Null);
else
{
- tokenize_console(activator.(sample));
+ tokenize_console(actor.(sample));
float n;
n = stof(argv(1));
if(n > 0)
}
}
else
- snd = self.noise;
- _sound(self, CH_TRIGGER_SINGLE, snd, VOL_BASE * self.volume, self.atten);
- if(self.spawnflags & 3)
- self.use = target_speaker_use_off;
+ snd = this.noise;
+ _sound(this, CH_TRIGGER_SINGLE, snd, VOL_BASE * this.volume, this.atten);
+ if(this.spawnflags & 3)
+ this.use = target_speaker_use_off;
}
-void target_speaker_use_off()
-{SELFPARAM();
- sound(self, CH_TRIGGER_SINGLE, SND_Null, VOL_BASE * self.volume, self.atten);
- self.use = target_speaker_use_on;
+void target_speaker_use_off(entity this, entity actor, entity trigger)
+{
+ sound(this, CH_TRIGGER_SINGLE, SND_Null, VOL_BASE * this.volume, this.atten);
+ this.use = target_speaker_use_on;
}
void target_speaker_reset(entity this)
{
if(this.spawnflags & 1) // LOOPED_ON
{
if(this.use == target_speaker_use_on)
- target_speaker_use_on();
+ target_speaker_use_on(this, NULL, NULL);
}
else if(this.spawnflags & 2)
{
if(this.use == target_speaker_use_off)
- target_speaker_use_off();
+ target_speaker_use_off(this, NULL, NULL);
}
}
self.use = target_speaker_use_activator;
else if(self.spawnflags & 1) // LOOPED_ON
{
- target_speaker_use_on();
+ target_speaker_use_on(self, NULL, NULL);
self.reset = target_speaker_reset;
}
else if(self.spawnflags & 2) // LOOPED_OFF
pl.voicescript = world;
}
-void target_voicescript_use()
-{SELFPARAM();
- if(activator.voicescript != self)
+void target_voicescript_use(entity this, entity actor, entity trigger)
+{
+ if(actor.voicescript != this)
{
- activator.voicescript = self;
- activator.voicescript_index = 0;
- activator.voicescript_nextthink = time + self.delay;
+ actor.voicescript = this;
+ actor.voicescript_index = 0;
+ actor.voicescript_nextthink = time + this.delay;
}
}
#ifdef SVQC
-void trigger_teleport_use();
+void trigger_teleport_use(entity this, entity actor, entity trigger);
#define TDEATHLOOP(o) \
entity head; \
// generated file; do not modify
-#include "counter.qc"
-#include "delay.qc"
-#include "disablerelay.qc"
-#include "flipflop.qc"
-#include "gamestart.qc"
-#include "gravity.qc"
-#include "heal.qc"
-#include "hurt.qc"
-#include "impulse.qc"
-#include "include.qc"
-#include "jumppads.qc"
-#include "keylock.qc"
-#include "magicear.qc"
-#include "monoflop.qc"
-#include "multi.qc"
-#include "multivibrator.qc"
-#include "relay.qc"
-#include "relay_activators.qc"
-#include "relay_if.qc"
-#include "relay_teamcheck.qc"
-#include "secret.qc"
-#include "swamp.qc"
-#include "teleport.qc"
-#include "viewloc.qc"
+#include <common/triggers/trigger/counter.qc>
+#include <common/triggers/trigger/delay.qc>
+#include <common/triggers/trigger/disablerelay.qc>
+#include <common/triggers/trigger/flipflop.qc>
+#include <common/triggers/trigger/gamestart.qc>
+#include <common/triggers/trigger/gravity.qc>
+#include <common/triggers/trigger/heal.qc>
+#include <common/triggers/trigger/hurt.qc>
+#include <common/triggers/trigger/impulse.qc>
+#include <common/triggers/trigger/include.qc>
+#include <common/triggers/trigger/jumppads.qc>
+#include <common/triggers/trigger/keylock.qc>
+#include <common/triggers/trigger/magicear.qc>
+#include <common/triggers/trigger/monoflop.qc>
+#include <common/triggers/trigger/multi.qc>
+#include <common/triggers/trigger/multivibrator.qc>
+#include <common/triggers/trigger/relay.qc>
+#include <common/triggers/trigger/relay_activators.qc>
+#include <common/triggers/trigger/relay_if.qc>
+#include <common/triggers/trigger/relay_teamcheck.qc>
+#include <common/triggers/trigger/secret.qc>
+#include <common/triggers/trigger/swamp.qc>
+#include <common/triggers/trigger/teleport.qc>
+#include <common/triggers/trigger/viewloc.qc>
--- /dev/null
+// generated file; do not modify
+#include <common/triggers/trigger/counter.qh>
+#include <common/triggers/trigger/delay.qh>
+#include <common/triggers/trigger/disablerelay.qh>
+#include <common/triggers/trigger/flipflop.qh>
+#include <common/triggers/trigger/gamestart.qh>
+#include <common/triggers/trigger/gravity.qh>
+#include <common/triggers/trigger/heal.qh>
+#include <common/triggers/trigger/hurt.qh>
+#include <common/triggers/trigger/impulse.qh>
+#include <common/triggers/trigger/include.qh>
+#include <common/triggers/trigger/jumppads.qh>
+#include <common/triggers/trigger/keylock.qh>
+#include <common/triggers/trigger/magicear.qh>
+#include <common/triggers/trigger/monoflop.qh>
+#include <common/triggers/trigger/multi.qh>
+#include <common/triggers/trigger/multivibrator.qh>
+#include <common/triggers/trigger/relay.qh>
+#include <common/triggers/trigger/relay_activators.qh>
+#include <common/triggers/trigger/relay_if.qh>
+#include <common/triggers/trigger/relay_teamcheck.qh>
+#include <common/triggers/trigger/secret.qh>
+#include <common/triggers/trigger/swamp.qh>
+#include <common/triggers/trigger/teleport.qh>
+#include <common/triggers/trigger/viewloc.qh>
#ifdef SVQC
-void counter_use()
-{SELFPARAM();
- self.count -= 1;
- if (self.count < 0)
+void counter_use(entity this, entity actor, entity trigger)
+{
+ this.count -= 1;
+ if (this.count < 0)
return;
- if (self.count == 0)
+ if (this.count == 0)
{
- if(IS_PLAYER(activator) && (self.spawnflags & SPAWNFLAG_NOMESSAGE) == 0)
- Send_Notification(NOTIF_ONE, activator, MSG_CENTER, CENTER_SEQUENCE_COMPLETED);
+ if(IS_PLAYER(actor) && (this.spawnflags & SPAWNFLAG_NOMESSAGE) == 0)
+ Send_Notification(NOTIF_ONE, actor, MSG_CENTER, CENTER_SEQUENCE_COMPLETED);
- self.enemy = activator;
- multi_trigger ();
+ this.enemy = actor;
+ WITHSELF(this, multi_trigger ());
}
else
{
- if(IS_PLAYER(activator) && (self.spawnflags & SPAWNFLAG_NOMESSAGE) == 0)
- if(self.count >= 4)
- Send_Notification(NOTIF_ONE, activator, MSG_CENTER, CENTER_SEQUENCE_COUNTER);
+ if(IS_PLAYER(actor) && (this.spawnflags & SPAWNFLAG_NOMESSAGE) == 0)
+ if(this.count >= 4)
+ Send_Notification(NOTIF_ONE, actor, MSG_CENTER, CENTER_SEQUENCE_COUNTER);
else
- Send_Notification(NOTIF_ONE, activator, MSG_CENTER, CENTER_SEQUENCE_COUNTER_FEWMORE, self.count);
+ Send_Notification(NOTIF_ONE, actor, MSG_CENTER, CENTER_SEQUENCE_COUNTER_FEWMORE, this.count);
}
}
#ifdef SVQC
-void delay_use()
-{SELFPARAM();
- self.think = SUB_UseTargets;
- self.nextthink = self.wait;
+void delay_use(entity this, entity actor, entity trigger)
+{
+ this.think = SUB_UseTargets_self;
+ this.nextthink = this.wait;
}
void delay_reset(entity this)
#ifdef SVQC
-void trigger_disablerelay_use()
-{SELFPARAM();
- entity e;
-
- float a, b;
- a = b = 0;
+void trigger_disablerelay_use(entity this, entity actor, entity trigger)
+{
+ int a = 0, b = 0;
- for(e = world; (e = find(e, targetname, self.target)); )
+ for(entity e = world; (e = find(e, targetname, this.target)); )
{
if(e.use == SUB_UseTargets)
{
spawnfunc(trigger_disablerelay)
{
- self.use = trigger_disablerelay_use;
+ this.use = trigger_disablerelay_use;
}
#endif
/*QUAKED spawnfunc_trigger_flipflop (.5 .5 .5) (-8 -8 -8) (8 8 8) START_ENABLED
"Flip-flop" trigger gate... lets only every second trigger event through
*/
-void flipflop_use()
-{SELFPARAM();
- self.state = !self.state;
- if(self.state)
- SUB_UseTargets();
+void flipflop_use(entity this, entity actor, entity trigger)
+{
+ this.state = !this.state;
+ if(this.state)
+ SUB_UseTargets(this, actor, trigger);
}
spawnfunc(trigger_flipflop)
#ifdef SVQC
-void gamestart_use(entity this)
+void gamestart_use(entity this, entity actor, entity trigger)
{
- activator = self;
- SUB_UseTargets();
- remove(self);
+ SUB_UseTargets(this, this, trigger);
+ remove(this);
+}
+
+void gamestart_use_this(entity this)
+{
+ gamestart_use(this, NULL, NULL);
}
void self_spawnfunc_trigger_gamestart();
spawnfunc(trigger_gamestart)
{
- setuse(this, gamestart_use);
+ this.use = gamestart_use;
this.reset2 = self_spawnfunc_trigger_gamestart;
if(this.wait)
{
- this.think = this.use;
+ this.think = adaptor_think2use;
this.nextthink = game_starttime + this.wait;
}
else
- InitializeEntity(this, gamestart_use, INITPRIO_FINDTARGET);
+ InitializeEntity(this, gamestart_use_this, INITPRIO_FINDTARGET);
}
void self_spawnfunc_trigger_gamestart() { SELFPARAM(); spawnfunc_trigger_gamestart(this); }
}
}
-void trigger_gravity_use()
-{SELFPARAM();
- self.state = !self.state;
+void trigger_gravity_use(entity this, entity actor, entity trigger)
+{
+ this.state = !this.state;
}
void trigger_gravity_touch()
#ifdef SVQC
-void trigger_hurt_use()
-{SELFPARAM();
- if(IS_PLAYER(activator))
- self.enemy = activator;
+void trigger_hurt_use(entity this, entity actor, entity trigger)
+{
+ if(IS_PLAYER(actor))
+ this.enemy = actor;
else
- self.enemy = world; // let's just destroy it, if taking over is too much work
+ this.enemy = world; // let's just destroy it, if taking over is too much work
}
.float triggerhurttime;
#include "jumppads.qh"
#include <common/physics/movetypes/movetypes.qh>
-void trigger_push_use()
-{SELFPARAM();
+void trigger_push_use(entity this, entity actor, entity trigger)
+{
if(teamplay)
{
- self.team = activator.team;
- self.SendFlags |= 2;
+ this.team = actor.team;
+ this.SendFlags |= 2;
}
}
#endif
}
if(this.enemy.target)
- {
- activator = other;
- WITHSELF(this.enemy, SUB_UseTargets());
- }
+ SUB_UseTargets(this.enemy, other, other); // TODO: do we need other as trigger too?
if (other.flags & FL_PROJECTILE)
{
NET_HANDLE(ENT_CLIENT_TRIGGER_PUSH, bool isnew)
{
- make_pure(this);
-
this.classname = "jumppad";
int mytm = ReadByte(); if(mytm) { this.team = mytm - 1; }
this.spawnflags = ReadInt24_t();
float trigger_push_calculatevelocity_flighttime;
#ifdef SVQC
-void() SUB_UseTargets;
-void trigger_push_use();
+void SUB_UseTargets(entity this, entity actor, entity trigger);
+void trigger_push_use(entity this, entity actor, entity trigger);
#endif
/*
/**
* trigger given targets
*/
-void trigger_keylock_trigger(string s)
-{SELFPARAM();
- entity otemp = other;
- entity atemp = activator;
-
- entity t;
- for(t = world; (t = find(t, targetname, s)); )
+void trigger_keylock_trigger(entity this, entity actor, string s)
+{
+ for(entity t = world; (t = find(t, targetname, s)); )
if(t.use)
- {
- setself(t);
- other = this;
- activator = atemp;
- self.use();
- }
-
- setself(this);
- other = otemp;
- activator = atemp;
+ t.use(t, actor, this);
}
/**
if(self.itemkeys)
key_used = item_keys_usekey(self, other);
- activator = other;
-
if(self.itemkeys)
{
#ifdef SVQC
if(self.delay <= time || started_delay == true)
if(self.target2)
{
- trigger_keylock_trigger(self.target2);
+ trigger_keylock_trigger(this, other, self.target2);
started_delay = true;
self.delay = time + self.wait;
}
#endif
if(self.target)
- trigger_keylock_trigger(self.target);
+ trigger_keylock_trigger(this, other, self.target);
if(self.killtarget)
trigger_keylock_kill(self.killtarget);
if(dotrigger)
{
- activator = source;
- setself(ear);
savemessage = self.message;
self.message = string_null;
- SUB_UseTargets();
+ SUB_UseTargets(ear, source, NULL);
self.message = savemessage;
- setself(this);
}
if(ear.netname != "")
if(dotrigger)
{
- activator = source;
- setself(ear);
savemessage = self.message;
self.message = string_null;
- SUB_UseTargets();
+ SUB_UseTargets(ear, source, NULL);
self.message = savemessage;
- setself(this);
}
if(ear.spawnflags & 16)
/*QUAKED spawnfunc_trigger_monoflop (.5 .5 .5) (-8 -8 -8) (8 8 8)
"Mono-flop" trigger gate... turns one trigger event into one "on" and one "off" event, separated by a delay of "wait"
*/
-void monoflop_use()
-{SELFPARAM();
- self.nextthink = time + self.wait;
- self.enemy = activator;
- if(self.state)
+void monoflop_use(entity this, entity actor, entity trigger)
+{
+ this.nextthink = time + this.wait;
+ this.enemy = actor;
+ if(this.state)
return;
- self.state = 1;
- SUB_UseTargets();
+ this.state = 1;
+ SUB_UseTargets(this, actor, trigger);
}
-void monoflop_fixed_use()
-{SELFPARAM();
- if(self.state)
+void monoflop_fixed_use(entity this, entity actor, entity trigger)
+{
+ if(this.state)
return;
- self.nextthink = time + self.wait;
- self.state = 1;
- self.enemy = activator;
- SUB_UseTargets();
+ this.nextthink = time + this.wait;
+ this.state = 1;
+ this.enemy = actor;
+ SUB_UseTargets(this, actor, trigger);
}
void monoflop_think()
{SELFPARAM();
- self.state = 0;
- activator = self.enemy;
- SUB_UseTargets();
+ this.state = 0;
+ SUB_UseTargets(this, this.enemy, NULL);
}
void monoflop_reset(entity this)
spawnfunc(trigger_monoflop)
{
- if(!self.wait)
- self.wait = 1;
- if(self.spawnflags & 1)
- self.use = monoflop_fixed_use;
+ if(!this.wait)
+ this.wait = 1;
+ if(this.spawnflags & 1)
+ this.use = monoflop_fixed_use;
else
- self.use = monoflop_use;
- self.think = monoflop_think;
- self.state = 0;
- self.reset = monoflop_reset;
+ this.use = monoflop_use;
+ this.think = monoflop_think;
+ this.state = 0;
+ this.reset = monoflop_reset;
}
#endif
// don't trigger again until reset
self.takedamage = DAMAGE_NO;
- activator = self.enemy;
- other = self.goalentity;
- SUB_UseTargets();
+ SUB_UseTargets(self, self.enemy, self.goalentity);
if (self.wait > 0)
{
}
}
-void multi_use()
-{SELFPARAM();
- self.goalentity = other;
- self.enemy = activator;
- multi_trigger();
+void multi_use(entity this, entity actor, entity trigger)
+{
+ this.goalentity = trigger;
+ this.enemy = actor;
+ WITHSELF(this, multi_trigger());
}
void multi_touch()
newstate = (time < cyclestart + self.wait);
- activator = self;
if(self.state != newstate)
- SUB_UseTargets();
+ SUB_UseTargets(self, self, NULL);
self.state = newstate;
if(self.state)
self.nextthink = cyclestart + self.wait + self.respawntime + 0.01;
}
-void multivibrator_toggle()
-{SELFPARAM();
- if(self.nextthink == 0)
+void multivibrator_toggle(entity this, entity actor, entity trigger)
+{
+ if(this.nextthink == 0)
{
- multivibrator_send();
+ WITHSELF(this, multivibrator_send());
}
else
{
- if(self.state)
+ if(this.state)
{
- SUB_UseTargets();
- self.state = 0;
+ SUB_UseTargets(this, actor, trigger);
+ this.state = 0;
}
- self.nextthink = 0;
+ this.nextthink = 0;
}
}
#ifdef SVQC
-void relay_activators_use()
-{SELFPARAM();
+void relay_activators_use(entity this, entity actor, entity trigger)
+{
for(entity trg = world; (trg = find(trg, targetname, this.target)); )
{
- setself(trg);
if (trg.setactive)
- trg.setactive(this.cnt);
+ trg.setactive(trg, this.cnt);
else
{
//bprint("Not using setactive\n");
trg.active = this.cnt;
}
}
- setself(this);
}
spawnfunc(relay_activate)
{
- self.cnt = ACTIVE_ACTIVE;
- self.use = relay_activators_use;
+ this.cnt = ACTIVE_ACTIVE;
+ this.use = relay_activators_use;
}
spawnfunc(relay_deactivate)
{
- self.cnt = ACTIVE_NOT;
- self.use = relay_activators_use;
+ this.cnt = ACTIVE_NOT;
+ this.use = relay_activators_use;
}
spawnfunc(relay_activatetoggle)
{
- self.cnt = ACTIVE_TOGGLE;
- self.use = relay_activators_use;
+ this.cnt = ACTIVE_TOGGLE;
+ this.use = relay_activators_use;
}
#endif
#ifdef SVQC
-void trigger_relay_if_use()
-{SELFPARAM();
- float n;
- n = self.count;
+void trigger_relay_if_use(entity this, entity actor, entity trigger)
+{
+ int n = this.count;
// TODO make this generic AND faster than nextent()ing through all, if somehow possible
- n = (cvar_string(self.netname) == cvar_string(self.message));
- if(self.spawnflags & 1)
+ n = (cvar_string(this.netname) == cvar_string(this.message));
+ if(this.spawnflags & 1)
n = !n;
if(n)
- SUB_UseTargets();
+ SUB_UseTargets(this, actor, trigger);
}
spawnfunc(trigger_relay_if)
{
- self.use = trigger_relay_if_use;
+ this.use = trigger_relay_if_use;
}
#endif
#ifdef SVQC
-void trigger_relay_teamcheck_use()
-{SELFPARAM();
- if(activator.team)
+void trigger_relay_teamcheck_use(entity this, entity actor, entity trigger)
+{
+ if(actor.team)
{
- if(self.spawnflags & 2)
+ if(this.spawnflags & 2)
{
- if(DIFF_TEAM(activator, self))
- SUB_UseTargets();
+ if(DIFF_TEAM(actor, this))
+ SUB_UseTargets(this, actor, trigger);
}
else
{
- if(SAME_TEAM(activator, self))
- SUB_UseTargets();
+ if(SAME_TEAM(actor, this))
+ SUB_UseTargets(this, actor, trigger);
}
}
else
{
- if(self.spawnflags & 1)
- SUB_UseTargets();
+ if(this.spawnflags & 1)
+ SUB_UseTargets(this, actor, trigger);
}
}
REGISTER_NET_LINKED(ENT_CLIENT_TRIGGER_TELEPORT)
#ifdef SVQC
-void trigger_teleport_use()
-{SELFPARAM();
+void trigger_teleport_use(entity this, entity actor, entity trigger)
+{
if(teamplay)
- self.team = activator.team;
+ this.team = actor.team;
#ifdef SVQC
- self.SendFlags |= SF_TRIGGER_UPDATE;
+ this.SendFlags |= SF_TRIGGER_UPDATE;
#endif
}
#endif
e = Simple_TeleportPlayer(self, other);
#ifdef SVQC
- activator = other;
string s = self.target; self.target = string_null;
- SUB_UseTargets();
+ SUB_UseTargets(self, other, other); // TODO: should we be using other for trigger too?
if (!self.target) self.target = s;
- WITHSELF(e, SUB_UseTargets());
+ SUB_UseTargets(e, other, other);
#endif
}
-void SUB_DontUseTargets() { }
+void SUB_DontUseTargets(entity this, entity actor, entity trigger) { }
-void() SUB_UseTargets;
+void SUB_UseTargets(entity this, entity actor, entity trigger);
void DelayThink()
{SELFPARAM();
- activator = this.enemy;
- SUB_UseTargets ();
+ SUB_UseTargets (this, this.enemy, NULL);
remove(this);
}
==============================
*/
-void SUB_UseTargets()
-{SELFPARAM();
- entity t, otemp, act;
- string s;
- float i;
-
+void SUB_UseTargets(entity this, entity actor, entity trigger)
+{
//
// check for a delay
//
if (this.delay)
{
// create a temp object to fire at a later time
- t = new(DelayedUse);
+ entity t = new(DelayedUse);
t.nextthink = time + this.delay;
t.think = DelayThink;
- t.enemy = activator;
+ t.enemy = actor;
t.message = this.message;
t.killtarget = this.killtarget;
t.target = this.target;
return;
}
+ string s;
//
// print the message
//
#ifdef SVQC
if(this)
- if(IS_PLAYER(activator) && this.message != "")
- if(IS_REAL_CLIENT(activator))
+ if(IS_PLAYER(actor) && this.message != "")
+ if(IS_REAL_CLIENT(actor))
{
- centerprint(activator, this.message);
+ centerprint(actor, this.message);
if (this.noise == "")
- play2(activator, SND(TALK));
+ play2(actor, SND(TALK));
}
//
s = this.killtarget;
if (s != "")
{
- for(t = world; (t = find(t, targetname, s)); )
+ for(entity t = world; (t = find(t, targetname, s)); )
remove(t);
}
#endif
//
// fire targets
//
- act = activator;
- otemp = other;
if(this.target_random)
RandomSelection_Init();
- for(i = 0; i < 4; ++i)
+ for(int i = 0; i < 4; ++i)
{
switch(i)
{
{
// Flag to set func_clientwall state
// 1 == deactivate, 2 == activate, 0 == do nothing
- float aw_flag = this.antiwall_flag;
- for(t = world; (t = find(t, targetname, s)); )
- if(t.use)
+ int aw_flag = this.antiwall_flag;
+ for(entity t = world; (t = find(t, targetname, s)); )
{
- if(this.target_random)
+ if(t.use)
{
- RandomSelection_Add(t, 0, string_null, 1, 0);
- }
- else
- {
- if (t.classname == "func_clientwall" || t.classname == "func_clientillusionary")
- t.antiwall_flag = aw_flag;
- setself(t);
- other = this;
- activator = act;
- self.use();
+ if(this.target_random)
+ {
+ RandomSelection_Add(t, 0, string_null, 1, 0);
+ }
+ else
+ {
+ if (t.classname == "func_clientwall" || t.classname == "func_clientillusionary")
+ t.antiwall_flag = aw_flag;
+
+ t.use(t, actor, this);
+ }
}
}
}
}
if(this.target_random && RandomSelection_chosen_ent)
- {
- setself(RandomSelection_chosen_ent);
- other = this;
- activator = act;
- self.use();
- }
+ RandomSelection_chosen_ent.use(RandomSelection_chosen_ent, actor, this);
+}
- activator = act;
- setself(this);
- other = otemp;
+void SUB_UseTargets_self()
+{SELFPARAM();
+ SUB_UseTargets(this, NULL, NULL);
}
#ifdef CSQC
// generated file; do not modify
-#include "all.qc"
-#include "checkpoint.qc"
-#include "cl_turrets.qc"
-#include "config.qc"
-#include "sv_turrets.qc"
-#include "targettrigger.qc"
-#include "util.qc"
+#include <common/turrets/all.qc>
+#include <common/turrets/checkpoint.qc>
+#include <common/turrets/cl_turrets.qc>
+#include <common/turrets/config.qc>
+#include <common/turrets/sv_turrets.qc>
+#include <common/turrets/targettrigger.qc>
+#include <common/turrets/util.qc>
--- /dev/null
+// generated file; do not modify
+#include <common/turrets/all.qh>
+#include <common/turrets/checkpoint.qh>
+#include <common/turrets/cl_turrets.qh>
+#include <common/turrets/config.qh>
+#include <common/turrets/sv_turrets.qh>
+#include <common/turrets/targettrigger.qh>
+#include <common/turrets/util.qh>
this.health -= damage;
//this.realowner = attacker; // Dont change realowner, it does not make much sense for turrets
if(this.health <= 0)
- WITHSELF(this, W_PrepareExplosionByDamage(this.owner, turret_projectile_explode));
+ W_PrepareExplosionByDamage(this, this.owner, turret_projectile_explode);
}
entity turret_projectile(Sound _snd, float _size, float _health, float _death, float _proj_type, float _cull, float _cli_anim)
When .used a turret switch team to activator.team.
If activator is world, the turret go inactive.
*/
-void turret_use()
-{SELFPARAM();
- LOG_TRACE("Turret ",self.netname, " used by ", activator.classname, "\n");
+void turret_use(entity this, entity actor, entity trigger)
+{
+ LOG_TRACE("Turret ",this.netname, " used by ", actor.classname, "\n");
- self.team = activator.team;
+ this.team = actor.team;
- if(self.team == 0)
- self.active = ACTIVE_NOT;
+ if(this.team == 0)
+ this.active = ACTIVE_NOT;
else
- self.active = ACTIVE_ACTIVE;
+ this.active = ACTIVE_ACTIVE;
}
// generated file; do not modify
-#include "ewheel.qc"
-#include "ewheel_weapon.qc"
-#include "flac.qc"
-#include "flac_weapon.qc"
-#include "fusionreactor.qc"
-#include "hellion.qc"
-#include "hellion_weapon.qc"
-#include "hk.qc"
-#include "hk_weapon.qc"
-#include "machinegun.qc"
-#include "machinegun_weapon.qc"
-#include "mlrs.qc"
-#include "mlrs_weapon.qc"
-#include "phaser.qc"
-#include "phaser_weapon.qc"
-#include "plasma.qc"
-#include "plasma_dual.qc"
-#include "plasma_weapon.qc"
-#include "tesla.qc"
-#include "tesla_weapon.qc"
-#include "walker.qc"
-#include "walker_weapon.qc"
+#include <common/turrets/turret/ewheel.qc>
+#include <common/turrets/turret/ewheel_weapon.qc>
+#include <common/turrets/turret/flac.qc>
+#include <common/turrets/turret/flac_weapon.qc>
+#include <common/turrets/turret/fusionreactor.qc>
+#include <common/turrets/turret/hellion.qc>
+#include <common/turrets/turret/hellion_weapon.qc>
+#include <common/turrets/turret/hk.qc>
+#include <common/turrets/turret/hk_weapon.qc>
+#include <common/turrets/turret/machinegun.qc>
+#include <common/turrets/turret/machinegun_weapon.qc>
+#include <common/turrets/turret/mlrs.qc>
+#include <common/turrets/turret/mlrs_weapon.qc>
+#include <common/turrets/turret/phaser.qc>
+#include <common/turrets/turret/phaser_weapon.qc>
+#include <common/turrets/turret/plasma.qc>
+#include <common/turrets/turret/plasma_dual.qc>
+#include <common/turrets/turret/plasma_weapon.qc>
+#include <common/turrets/turret/tesla.qc>
+#include <common/turrets/turret/tesla_weapon.qc>
+#include <common/turrets/turret/walker.qc>
+#include <common/turrets/turret/walker_weapon.qc>
--- /dev/null
+// generated file; do not modify
+#include <common/turrets/turret/ewheel.qh>
+#include <common/turrets/turret/ewheel_weapon.qh>
+#include <common/turrets/turret/flac.qh>
+#include <common/turrets/turret/flac_weapon.qh>
+#include <common/turrets/turret/fusionreactor.qh>
+#include <common/turrets/turret/hellion.qh>
+#include <common/turrets/turret/hellion_weapon.qh>
+#include <common/turrets/turret/hk.qh>
+#include <common/turrets/turret/hk_weapon.qh>
+#include <common/turrets/turret/machinegun.qh>
+#include <common/turrets/turret/machinegun_weapon.qh>
+#include <common/turrets/turret/mlrs.qh>
+#include <common/turrets/turret/mlrs_weapon.qh>
+#include <common/turrets/turret/phaser.qh>
+#include <common/turrets/turret/phaser_weapon.qh>
+#include <common/turrets/turret/plasma.qh>
+#include <common/turrets/turret/plasma_dual.qh>
+#include <common/turrets/turret/plasma_weapon.qh>
+#include <common/turrets/turret/tesla.qh>
+#include <common/turrets/turret/tesla_weapon.qh>
+#include <common/turrets/turret/walker.qh>
+#include <common/turrets/turret/walker_weapon.qh>
if (self.pathgoal)
{
if (self.pathgoal.use)
- self.pathgoal.use();
+ self.pathgoal.use(self.pathgoal, NULL, NULL);
if (self.pathgoal.enemy)
{
this.velocity = this.velocity + vforce;
if (this.health <= 0)
- WITHSELF(this, W_PrepareExplosionByDamage(this.owner, walker_rocket_explode));
+ W_PrepareExplosionByDamage(this, this.owner, walker_rocket_explode);
}
#define WALKER_ROCKET_MOVE movelib_move_simple(self, newdir, (autocvar_g_turrets_unit_walker_rocket_speed), (autocvar_g_turrets_unit_walker_rocket_turnrate)); UpdateCSQCProjectile(self)
if (self.pathgoal)
{
if (self.pathgoal.use)
- self.pathgoal.use();
+ self.pathgoal.use(self, NULL, NULL);
if (self.pathgoal.enemy)
{
#define COMMON_UTIL_H
#ifndef MENUQC
+
vector real_origin(entity ent);
#endif
// generated file; do not modify
-#include "all.qc"
-#include "cl_vehicles.qc"
-#include "sv_vehicles.qc"
+#include <common/vehicles/all.qc>
+#include <common/vehicles/cl_vehicles.qc>
+#include <common/vehicles/sv_vehicles.qc>
--- /dev/null
+// generated file; do not modify
+#include <common/vehicles/all.qh>
+#include <common/vehicles/cl_vehicles.qh>
+#include <common/vehicles/sv_vehicles.qh>
{
this.takedamage = DAMAGE_NO;
this.event_damage = func_null;
- this.think = this.use;
+ this.think = adaptor_think2use;
this.nextthink = time;
}
}
remove (self);
}
+void vehicles_projectile_explode_use(entity this, entity actor, entity trigger)
+{
+ WITHSELF(this, vehicles_projectile_explode());
+}
+
entity vehicles_projectile(entity this, string _mzlfx, Sound _mzlsound,
vector _org, vector _vel,
float _dmg, float _radi, float _force, float _size,
proj.bot_dodgerating = _dmg;
proj.velocity = _vel;
proj.touch = vehicles_projectile_explode;
- proj.use = vehicles_projectile_explode;
+ proj.use = vehicles_projectile_explode_use;
proj.owner = this;
proj.realowner = _owner;
proj.think = SUB_Remove_self;
}
-void vehicle_use()
-{SELFPARAM();
- LOG_TRACE("vehicle ",self.netname, " used by ", activator.classname, "\n");
+void vehicle_use(entity this, entity actor, entity trigger)
+{
+ LOG_TRACE("vehicle ",this.netname, " used by ", actor.classname, "\n");
- self.tur_head.team = activator.team;
+ this.tur_head.team = actor.team;
- if(self.tur_head.team == 0)
- self.active = ACTIVE_NOT;
+ if(this.tur_head.team == 0)
+ this.active = ACTIVE_NOT;
else
- self.active = ACTIVE_ACTIVE;
+ this.active = ACTIVE_ACTIVE;
- if(self.active == ACTIVE_ACTIVE && !IS_DEAD(self) && !gameover)
+ if(this.active == ACTIVE_ACTIVE && !IS_DEAD(this) && !gameover)
{
- LOG_TRACE("Respawning vehicle: ", self.netname, "\n");
- if(self.effects & EF_NODRAW)
+ LOG_TRACE("Respawning vehicle: ", this.netname, "\n");
+ if(this.effects & EF_NODRAW)
{
- self.think = vehicles_spawn;
- self.nextthink = time + 3;
+ this.think = vehicles_spawn;
+ this.nextthink = time + 3;
}
else
{
- vehicles_setreturn(self);
- vehicles_reset_colors(self);
+ vehicles_setreturn(this);
+ vehicles_reset_colors(this);
}
}
}
// generated file; do not modify
-#include "bumblebee.qc"
-#include "bumblebee_weapons.qc"
-#include "racer.qc"
-#include "racer_weapon.qc"
-#include "raptor.qc"
-#include "raptor_weapons.qc"
-#include "spiderbot.qc"
-#include "spiderbot_weapons.qc"
+#include <common/vehicles/vehicle/bumblebee.qc>
+#include <common/vehicles/vehicle/bumblebee_weapons.qc>
+#include <common/vehicles/vehicle/racer.qc>
+#include <common/vehicles/vehicle/racer_weapon.qc>
+#include <common/vehicles/vehicle/raptor.qc>
+#include <common/vehicles/vehicle/raptor_weapons.qc>
+#include <common/vehicles/vehicle/spiderbot.qc>
+#include <common/vehicles/vehicle/spiderbot_weapons.qc>
--- /dev/null
+// generated file; do not modify
+#include <common/vehicles/vehicle/bumblebee.qh>
+#include <common/vehicles/vehicle/bumblebee_weapons.qh>
+#include <common/vehicles/vehicle/racer.qh>
+#include <common/vehicles/vehicle/racer_weapon.qh>
+#include <common/vehicles/vehicle/raptor.qh>
+#include <common/vehicles/vehicle/raptor_weapons.qh>
+#include <common/vehicles/vehicle/spiderbot.qh>
+#include <common/vehicles/vehicle/spiderbot_weapons.qh>
if (IS_DEAD(self.owner) || self.cnt < time)
{
- self.use();
+ self.use(self, NULL, NULL);
return;
}
if(IS_DEAD(self.owner) || self.cnt < time)
{
- self.use();
+ self.use(self, NULL, NULL);
return;
}
UpdateCSQCProjectile(self);
if (IS_DEAD(self.owner) || self.cnt < time || vdist(self.pos1 - self.origin, <, 16))
- self.use();
+ self.use(self, NULL, NULL);
}
void spiderbot_rocket_guided()
UpdateCSQCProjectile(self);
if (IS_DEAD(self.owner) || self.cnt < time)
- self.use();
+ self.use(self, NULL, NULL);
}
void spiderbot_guide_release(entity this)
// generated file; do not modify
-#include "all.qc"
-#include "calculations.qc"
-#include "config.qc"
+#include <common/weapons/all.qc>
+#include <common/weapons/calculations.qc>
+#include <common/weapons/config.qc>
--- /dev/null
+// generated file; do not modify
+#include <common/weapons/all.qh>
+#include <common/weapons/calculations.qh>
+#include <common/weapons/config.qh>
float sigma;
vector v1 = '0 0 0', v2;
float dx, dy, r;
- float sstyle;
spread *= spreadfactor; //g_weaponspreadfactor;
if(spread <= 0)
return forward;
- sstyle = spreadstyle; //autocvar_g_projectiles_spread_style;
- if(sstyle == 0)
+ switch(spreadstyle)
{
- // this is the baseline for the spread value!
- // standard deviation: sqrt(2/5)
- // density function: sqrt(1-r^2)
- return forward + randomvec() * spread;
+ case 0:
+ {
+ // this is the baseline for the spread value!
+ // standard deviation: sqrt(2/5)
+ // density function: sqrt(1-r^2)
+ return forward + randomvec() * spread;
+ }
+ case 1:
+ {
+ // same thing, basically
+ return normalize(forward + cliptoplane(randomvec() * spread, forward));
+ }
+ case 2:
+ {
+ // circle spread... has at sigma=1 a standard deviation of sqrt(1/2)
+ sigma = spread * 0.89442719099991587855; // match baseline stddev
+ v1 = findperpendicular(forward);
+ v2 = cross(forward, v1);
+ // random point on unit circle
+ dx = random() * 2 * M_PI;
+ dy = sin(dx);
+ dx = cos(dx);
+ // radius in our dist function
+ r = random();
+ r = sqrt(r);
+ return normalize(forward + (v1 * dx + v2 * dy) * r * sigma);
+ }
+ case 3: // gauss 3d
+ {
+ sigma = spread * 0.44721359549996; // match baseline stddev
+ // note: 2D gaussian has sqrt(2) times the stddev of 1D, so this factor is right
+ v1 = forward;
+ v1_x += gsl_ran_gaussian(sigma);
+ v1_y += gsl_ran_gaussian(sigma);
+ v1_z += gsl_ran_gaussian(sigma);
+ return v1;
+ }
+ case 4: // gauss 2d
+ {
+ sigma = spread * 0.44721359549996; // match baseline stddev
+ // note: 2D gaussian has sqrt(2) times the stddev of 1D, so this factor is right
+ v1_x = gsl_ran_gaussian(sigma);
+ v1_y = gsl_ran_gaussian(sigma);
+ v1_z = gsl_ran_gaussian(sigma);
+ return normalize(forward + cliptoplane(v1, forward));
+ }
+ case 5: // 1-r
+ {
+ sigma = spread * 1.154700538379252; // match baseline stddev
+ v1 = findperpendicular(forward);
+ v2 = cross(forward, v1);
+ // random point on unit circle
+ dx = random() * 2 * M_PI;
+ dy = sin(dx);
+ dx = cos(dx);
+ // radius in our dist function
+ r = random();
+ r = solve_cubic_abcd(-2, 3, 0, -r) * '0 1 0';
+ return normalize(forward + (v1 * dx + v2 * dy) * r * sigma);
+ }
+ case 6: // 1-r^2
+ {
+ sigma = spread * 1.095445115010332; // match baseline stddev
+ v1 = findperpendicular(forward);
+ v2 = cross(forward, v1);
+ // random point on unit circle
+ dx = random() * 2 * M_PI;
+ dy = sin(dx);
+ dx = cos(dx);
+ // radius in our dist function
+ r = random();
+ r = sqrt(1 - r);
+ r = sqrt(1 - r);
+ return normalize(forward + (v1 * dx + v2 * dy) * r * sigma);
+ }
+ case 7: // (1-r) (2-r)
+ {
+ sigma = spread * 1.224744871391589; // match baseline stddev
+ v1 = findperpendicular(forward);
+ v2 = cross(forward, v1);
+ // random point on unit circle
+ dx = random() * 2 * M_PI;
+ dy = sin(dx);
+ dx = cos(dx);
+ // radius in our dist function
+ r = random();
+ r = 1 - sqrt(r);
+ r = 1 - sqrt(r);
+ return normalize(forward + (v1 * dx + v2 * dy) * r * sigma);
+ }
+ default:
+ error("g_projectiles_spread_style must be 0 (sphere), 1 (flattened sphere), 2 (circle), 3 (gauss 3D), 4 (gauss plane), 5 (linear falloff), 6 (quadratic falloff), 7 (stronger falloff)!");
}
- else if(sstyle == 1)
- {
- // same thing, basically
- return normalize(forward + cliptoplane(randomvec() * spread, forward));
- }
- else if(sstyle == 2)
- {
- // circle spread... has at sigma=1 a standard deviation of sqrt(1/2)
- sigma = spread * 0.89442719099991587855; // match baseline stddev
- v1 = findperpendicular(forward);
- v2 = cross(forward, v1);
- // random point on unit circle
- dx = random() * 2 * M_PI;
- dy = sin(dx);
- dx = cos(dx);
- // radius in our dist function
- r = random();
- r = sqrt(r);
- return normalize(forward + (v1 * dx + v2 * dy) * r * sigma);
- }
- else if(sstyle == 3) // gauss 3d
- {
- sigma = spread * 0.44721359549996; // match baseline stddev
- // note: 2D gaussian has sqrt(2) times the stddev of 1D, so this factor is right
- v1 = forward;
- v1_x += gsl_ran_gaussian(sigma);
- v1_y += gsl_ran_gaussian(sigma);
- v1_z += gsl_ran_gaussian(sigma);
- return v1;
- }
- else if(sstyle == 4) // gauss 2d
- {
- sigma = spread * 0.44721359549996; // match baseline stddev
- // note: 2D gaussian has sqrt(2) times the stddev of 1D, so this factor is right
- v1_x = gsl_ran_gaussian(sigma);
- v1_y = gsl_ran_gaussian(sigma);
- v1_z = gsl_ran_gaussian(sigma);
- return normalize(forward + cliptoplane(v1, forward));
- }
- else if(sstyle == 5) // 1-r
- {
- sigma = spread * 1.154700538379252; // match baseline stddev
- v1 = findperpendicular(forward);
- v2 = cross(forward, v1);
- // random point on unit circle
- dx = random() * 2 * M_PI;
- dy = sin(dx);
- dx = cos(dx);
- // radius in our dist function
- r = random();
- r = solve_cubic_abcd(-2, 3, 0, -r) * '0 1 0';
- return normalize(forward + (v1 * dx + v2 * dy) * r * sigma);
- }
- else if(sstyle == 6) // 1-r^2
- {
- sigma = spread * 1.095445115010332; // match baseline stddev
- v1 = findperpendicular(forward);
- v2 = cross(forward, v1);
- // random point on unit circle
- dx = random() * 2 * M_PI;
- dy = sin(dx);
- dx = cos(dx);
- // radius in our dist function
- r = random();
- r = sqrt(1 - r);
- r = sqrt(1 - r);
- return normalize(forward + (v1 * dx + v2 * dy) * r * sigma);
- }
- else if(sstyle == 7) // (1-r) (2-r)
- {
- sigma = spread * 1.224744871391589; // match baseline stddev
- v1 = findperpendicular(forward);
- v2 = cross(forward, v1);
- // random point on unit circle
- dx = random() * 2 * M_PI;
- dy = sin(dx);
- dx = cos(dx);
- // radius in our dist function
- r = random();
- r = 1 - sqrt(r);
- r = 1 - sqrt(r);
- return normalize(forward + (v1 * dx + v2 * dy) * r * sigma);
- }
- else
- error("g_projectiles_spread_style must be 0 (sphere), 1 (flattened sphere), 2 (circle), 3 (gauss 3D), 4 (gauss plane), 5 (linear falloff), 6 (quadratic falloff), 7 (stronger falloff)!");
+
return '0 0 0';
/*
* how to derive falloff functions:
// generated file; do not modify
-#include "arc.qc"
-#include "blaster.qc"
-#include "crylink.qc"
-#include "devastator.qc"
-#include "electro.qc"
-#include "fireball.qc"
-#include "hagar.qc"
-#include "hlac.qc"
-#include "hook.qc"
-#include "machinegun.qc"
-#include "minelayer.qc"
-#include "mortar.qc"
-#include "porto.qc"
-#include "rifle.qc"
-#include "seeker.qc"
-#include "shockwave.qc"
-#include "shotgun.qc"
-#include "tuba.qc"
-#include "vaporizer.qc"
-#include "vortex.qc"
+#include <common/weapons/weapon/arc.qc>
+#include <common/weapons/weapon/blaster.qc>
+#include <common/weapons/weapon/crylink.qc>
+#include <common/weapons/weapon/devastator.qc>
+#include <common/weapons/weapon/electro.qc>
+#include <common/weapons/weapon/fireball.qc>
+#include <common/weapons/weapon/hagar.qc>
+#include <common/weapons/weapon/hlac.qc>
+#include <common/weapons/weapon/hook.qc>
+#include <common/weapons/weapon/machinegun.qc>
+#include <common/weapons/weapon/minelayer.qc>
+#include <common/weapons/weapon/mortar.qc>
+#include <common/weapons/weapon/porto.qc>
+#include <common/weapons/weapon/rifle.qc>
+#include <common/weapons/weapon/seeker.qc>
+#include <common/weapons/weapon/shockwave.qc>
+#include <common/weapons/weapon/shotgun.qc>
+#include <common/weapons/weapon/tuba.qc>
+#include <common/weapons/weapon/vaporizer.qc>
+#include <common/weapons/weapon/vortex.qc>
--- /dev/null
+// generated file; do not modify
+#include <common/weapons/weapon/arc.qh>
+#include <common/weapons/weapon/blaster.qh>
+#include <common/weapons/weapon/crylink.qh>
+#include <common/weapons/weapon/devastator.qh>
+#include <common/weapons/weapon/electro.qh>
+#include <common/weapons/weapon/fireball.qh>
+#include <common/weapons/weapon/hagar.qh>
+#include <common/weapons/weapon/hlac.qh>
+#include <common/weapons/weapon/hook.qh>
+#include <common/weapons/weapon/machinegun.qh>
+#include <common/weapons/weapon/minelayer.qh>
+#include <common/weapons/weapon/mortar.qh>
+#include <common/weapons/weapon/porto.qh>
+#include <common/weapons/weapon/rifle.qh>
+#include <common/weapons/weapon/seeker.qh>
+#include <common/weapons/weapon/shockwave.qh>
+#include <common/weapons/weapon/shotgun.qh>
+#include <common/weapons/weapon/tuba.qh>
+#include <common/weapons/weapon/vaporizer.qh>
+#include <common/weapons/weapon/vortex.qh>
remove(self);
}
+void W_Arc_Bolt_Explode_use(entity this, entity actor, entity trigger)
+{
+ WITHSELF(this, W_Arc_Bolt_Explode());
+}
+
void W_Arc_Bolt_Damage(entity this, entity inflictor, entity attacker, float damage, int deathtype, vector hitloc, vector force)
{
if(this.health <= 0)
this.angles = vectoangles(this.velocity);
if(this.health <= 0)
- WITHSELF(this, W_PrepareExplosionByDamage(attacker, this.think));
+ W_PrepareExplosionByDamage(this, attacker, this.think);
}
void W_Arc_Bolt_Touch()
{SELFPARAM();
PROJECTILE_TOUCH;
- self.use();
+ self.use(this, NULL, NULL);
}
void W_Arc_Attack_Bolt(Weapon thiswep)
missile.damagedbycontents = true;
missile.touch = W_Arc_Bolt_Touch;
- missile.use = W_Arc_Bolt_Explode;
+ missile.use = W_Arc_Bolt_Explode_use;
missile.think = adaptor_think2use_hittype_splash;
missile.nextthink = time + WEP_CVAR(arc, bolt_lifetime);
PROJECTILE_MAKETRIGGER(missile);
this.angles = vectoangles(this.velocity);
if(this.health <= 0)
- WITHSELF(this, W_PrepareExplosionByDamage(attacker, W_Devastator_Explode));
+ W_PrepareExplosionByDamage(this, attacker, W_Devastator_Explode);
}
void W_Devastator_Attack(Weapon thiswep)
remove(self);
}
+void W_Electro_Explode_use(entity this, entity actor, entity trigger)
+{
+ WITHSELF(this, W_Electro_Explode());
+}
+
void W_Electro_TouchExplode()
{
PROJECTILE_TOUCH;
{SELFPARAM();
if(time >= self.ltime)
{
- self.use();
+ this.use(this, NULL, NULL);
return;
}
// if we triggered an orb, should we explode? if not, lets try again next time
if(found && WEP_CVAR_PRI(electro, midaircombo_explode))
- { self.use(); }
+ { this.use(this, NULL, NULL); }
else
{ self.nextthink = min(time + WEP_CVAR_PRI(electro, midaircombo_interval), self.ltime); }
}
proj.owner = proj.realowner = self;
proj.bot_dodge = true;
proj.bot_dodgerating = WEP_CVAR_PRI(electro, damage);
- proj.use = W_Electro_Explode;
+ proj.use = W_Electro_Explode_use;
proj.think = W_Electro_Bolt_Think;
proj.nextthink = time;
proj.ltime = time + WEP_CVAR_PRI(electro, lifetime);
}
else
{
- this.use = W_Electro_Explode;
+ this.use = W_Electro_Explode_use;
this.think = adaptor_think2use; // not _hittype_splash, as this runs "immediately"
}
}
entity proj = new(electro_orb);
proj.owner = proj.realowner = self;
- proj.use = W_Electro_Explode;
+ proj.use = W_Electro_Explode_use;
proj.think = adaptor_think2use_hittype_splash;
proj.bot_dodge = true;
proj.bot_dodgerating = WEP_CVAR_SEC(electro, damage);
remove(self);
}
+void W_Fireball_Explode_use(entity this, entity actor, entity trigger)
+{
+ WITHSELF(this, W_Fireball_Explode());
+}
+
void W_Fireball_TouchExplode()
{
PROJECTILE_TOUCH;
if(this.health <= 0)
{
this.cnt = 1;
- WITHSELF(this, W_PrepareExplosionByDamage(attacker, W_Fireball_Explode));
+ W_PrepareExplosionByDamage(this, attacker, W_Fireball_Explode);
}
}
proj.bot_dodge = true;
proj.bot_dodgerating = WEP_CVAR_PRI(fireball, damage);
proj.pushltime = time + WEP_CVAR_PRI(fireball, lifetime);
- proj.use = W_Fireball_Explode;
+ proj.use = W_Fireball_Explode_use;
proj.think = W_Fireball_Think;
proj.nextthink = time;
proj.health = WEP_CVAR_PRI(fireball, health);
remove(self);
}
+void W_Hagar_Explode_use(entity this, entity actor, entity trigger)
+{
+ WITHSELF(this, W_Hagar_Explode());
+}
+
void W_Hagar_Explode2()
{SELFPARAM();
self.event_damage = func_null;
remove(self);
}
+void W_Hagar_Explode2_use(entity this, entity actor, entity trigger)
+{
+ WITHSELF(this, W_Hagar_Explode2());
+}
+
void W_Hagar_Damage(entity this, entity inflictor, entity attacker, float damage, int deathtype, vector hitloc, vector force)
{
if(this.health <= 0)
this.angles = vectoangles(this.velocity);
if(this.health <= 0)
- WITHSELF(this, W_PrepareExplosionByDamage(attacker, this.think));
+ W_PrepareExplosionByDamage(this, attacker, this.think);
}
void W_Hagar_Touch()
{SELFPARAM();
PROJECTILE_TOUCH;
- self.use();
+ this.use(this, NULL, NULL);
}
void W_Hagar_Touch2()
PROJECTILE_TOUCH;
if(self.cnt > 0 || other.takedamage == DAMAGE_AIM) {
- self.use();
+ this.use(this, NULL, NULL);
} else {
self.cnt++;
Send_Effect(EFFECT_HAGAR_BOUNCE, self.origin, self.velocity, 1);
missile.damagedbycontents = true;
missile.touch = W_Hagar_Touch;
- missile.use = W_Hagar_Explode;
+ missile.use = W_Hagar_Explode_use;
missile.think = adaptor_think2use_hittype_splash;
missile.nextthink = time + WEP_CVAR_PRI(hagar, lifetime);
PROJECTILE_MAKETRIGGER(missile);
missile.touch = W_Hagar_Touch2;
missile.cnt = 0;
- missile.use = W_Hagar_Explode2;
+ missile.use = W_Hagar_Explode2_use;
missile.think = adaptor_think2use_hittype_splash;
missile.nextthink = time + WEP_CVAR_SEC(hagar, lifetime_min) + random() * WEP_CVAR_SEC(hagar, lifetime_rand);
PROJECTILE_MAKETRIGGER(missile);
missile.damagedbycontents = true;
missile.touch = W_Hagar_Touch; // not bouncy
- missile.use = W_Hagar_Explode2;
+ missile.use = W_Hagar_Explode2_use;
missile.think = adaptor_think2use_hittype_splash;
missile.nextthink = time + WEP_CVAR_SEC(hagar, lifetime_min) + random() * WEP_CVAR_SEC(hagar, lifetime_rand);
PROJECTILE_MAKETRIGGER(missile);
}
}
+void W_Hagar_Attack_Auto(Weapon thiswep, entity actor, .entity weaponentity, int fire)
+{
+ if(!(fire & 1) || actor.hagar_load || actor.hagar_loadblock)
+ {
+ w_ready(thiswep, actor, weaponentity, fire);
+ return;
+ }
+
+ if(!thiswep.wr_checkammo1(thiswep))
+ if(!(actor.items & IT_UNLIMITED_WEAPON_AMMO))
+ {
+ W_SwitchWeapon_Force(actor, w_getbestweapon(actor));
+ w_ready(thiswep, actor, weaponentity, fire);
+ return;
+ }
+
+ W_Hagar_Attack(thiswep);
+
+ int slot = weaponslot(weaponentity);
+ ATTACK_FINISHED(actor, slot) = time + WEP_CVAR_PRI(hagar, refire) * W_WeaponRateFactor();
+ int theframe = WFRAME_FIRE1;
+ entity this = actor.(weaponentity);
+ if(this)
+ {
+ if(this.wframe == WFRAME_FIRE1)
+ theframe = WFRAME_DONTCHANGE;
+ }
+ weapon_thinkf(actor, weaponentity, theframe, WEP_CVAR_PRI(hagar, refire), W_Hagar_Attack_Auto);
+}
+
METHOD(Hagar, wr_aim, void(entity thiswep))
{
SELFPARAM();
W_Hagar_Attack2_Load(thiswep, weaponentity); // must always run each frame
if(autocvar_g_balance_hagar_reload_ammo && actor.clip_load < min(WEP_CVAR_PRI(hagar, ammo), WEP_CVAR_SEC(hagar, ammo))) { // forced reload
thiswep.wr_reload(thiswep, actor, weaponentity);
- } else if((fire & 1) && !actor.hagar_load && !actor.hagar_loadblock) // not while secondary is loaded or awaiting reset
- {
- if(weapon_prepareattack(thiswep, actor, weaponentity, false, WEP_CVAR_PRI(hagar, refire)))
- {
- W_Hagar_Attack(thiswep);
- weapon_thinkf(actor, weaponentity, WFRAME_FIRE1, WEP_CVAR_PRI(hagar, refire), w_ready);
- }
}
+ else if((fire & 1) && !actor.hagar_load && !actor.hagar_loadblock) // not while secondary is loaded or awaiting reset
+ {
+ if(weapon_prepareattack(thiswep, actor, weaponentity, false, 0))
+ W_Hagar_Attack_Auto(thiswep, actor, weaponentity, fire);
+ }
else if((fire & 2) && !loadable_secondary && WEP_CVAR(hagar, secondary))
{
if(weapon_prepareattack(thiswep, actor, weaponentity, true, WEP_CVAR_SEC(hagar, refire)))
self.movetype = MOVETYPE_NONE;
}
+void W_Hook_Explode2_use(entity this, entity actor, entity trigger)
+{
+ WITHSELF(this, W_Hook_Explode2());
+}
+
void W_Hook_Damage(entity this, entity inflictor, entity attacker, float damage, int deathtype, vector hitloc, vector force)
{
if(this.health <= 0)
this.health = this.health - damage;
if(this.health <= 0)
- WITHSELF(this, W_PrepareExplosionByDamage(this.realowner, W_Hook_Explode2));
+ W_PrepareExplosionByDamage(this, this.realowner, W_Hook_Explode2);
}
void W_Hook_Touch2()
{SELFPARAM();
PROJECTILE_TOUCH;
- self.use();
+ this.use(this, NULL, NULL);
}
void W_Hook_Attack2(Weapon thiswep, entity actor)
gren.nextthink = time + WEP_CVAR_SEC(hook, lifetime);
gren.think = adaptor_think2use_hittype_splash;
- gren.use = W_Hook_Explode2;
+ gren.use = W_Hook_Explode2_use;
gren.touch = W_Hook_Touch2;
gren.takedamage = DAMAGE_YES;
this.angles = vectoangles(this.velocity);
if(this.health <= 0)
- WITHSELF(this, W_PrepareExplosionByDamage(attacker, W_MineLayer_Explode));
+ W_PrepareExplosionByDamage(this, attacker, W_MineLayer_Explode);
}
void W_MineLayer_Attack(Weapon thiswep)
METHOD(MineLayer, wr_checkammo1, bool(entity thiswep))
{
SELFPARAM();
- int slot = 0; // TODO: unhardcode
- // don't switch while placing a mine
- if(ATTACK_FINISHED(self, slot) <= time || PS(self).m_weapon != WEP_MINE_LAYER)
- {
+ //int slot = 0; // TODO: unhardcode
+ // actually do // don't switch while placing a mine
+ //if(ATTACK_FINISHED(self, slot) <= time || PS(self).m_weapon != WEP_MINE_LAYER)
+ //{
float ammo_amount = self.(thiswep.ammo_field) >= WEP_CVAR(minelayer, ammo);
ammo_amount += self.(weapon_load[WEP_MINE_LAYER.m_id]) >= WEP_CVAR(minelayer, ammo);
return ammo_amount;
- }
- return true;
+ //}
+ //return true;
}
METHOD(MineLayer, wr_checkammo2, bool(entity thiswep))
{
remove(self);
}
+void W_Mortar_Grenade_Explode_use(entity this, entity actor, entity trigger)
+{
+ WITHSELF(this, W_Mortar_Grenade_Explode());
+}
+
void W_Mortar_Grenade_Explode2()
{SELFPARAM();
if(other.takedamage == DAMAGE_AIM)
remove(self);
}
+void W_Mortar_Grenade_Explode2_use(entity this, entity actor, entity trigger)
+{
+ WITHSELF(this, W_Mortar_Grenade_Explode2());
+}
void W_Mortar_Grenade_Damage(entity this, entity inflictor, entity attacker, float damage, int deathtype, vector hitloc, vector force)
{
this.health = this.health - damage;
if(this.health <= 0)
- WITHSELF(this, W_PrepareExplosionByDamage(attacker, this.use));
+ W_PrepareExplosionByDamage(this, attacker, adaptor_think2use);
}
void W_Mortar_Grenade_Think1()
PROJECTILE_TOUCH;
if(other.takedamage == DAMAGE_AIM || WEP_CVAR_PRI(mortar, type) == 0) // always explode when hitting a player, or if normal mortar projectile
{
- self.use();
+ this.use(this, NULL, NULL);
}
else if(WEP_CVAR_PRI(mortar, type) == 1) // bounce
{
PROJECTILE_TOUCH;
if(other.takedamage == DAMAGE_AIM || WEP_CVAR_SEC(mortar, type) == 0) // always explode when hitting a player, or if normal mortar projectile
{
- self.use();
+ this.use(this, NULL, NULL);
}
else if(WEP_CVAR_SEC(mortar, type) == 1) // bounce
{
gren.cnt = time + WEP_CVAR_PRI(mortar, lifetime);
gren.nextthink = time;
gren.think = W_Mortar_Grenade_Think1;
- gren.use = W_Mortar_Grenade_Explode;
+ gren.use = W_Mortar_Grenade_Explode_use;
gren.touch = W_Mortar_Grenade_Touch1;
gren.takedamage = DAMAGE_YES;
gren.nextthink = time + WEP_CVAR_SEC(mortar, lifetime);
gren.think = adaptor_think2use_hittype_splash;
- gren.use = W_Mortar_Grenade_Explode2;
+ gren.use = W_Mortar_Grenade_Explode2_use;
gren.touch = W_Mortar_Grenade_Touch2;
gren.takedamage = DAMAGE_YES;
this.health = this.health - damage;
if(this.health <= 0)
- WITHSELF(this, W_PrepareExplosionByDamage(attacker, W_Seeker_Missile_Explode));
+ W_PrepareExplosionByDamage(this, attacker, W_Seeker_Missile_Explode);
}
/*
remove(self);
}
+void W_Seeker_Flac_Explode_use(entity this, entity actor, entity trigger)
+{
+ WITHSELF(this, W_Seeker_Flac_Explode());
+}
+
void W_Seeker_Flac_Touch()
{
PROJECTILE_TOUCH;
missile.bot_dodge = true;
missile.bot_dodgerating = WEP_CVAR(seeker, flac_damage);
missile.touch = W_Seeker_Flac_Explode;
- missile.use = W_Seeker_Flac_Explode;
+ missile.use = W_Seeker_Flac_Explode_use;
missile.think = adaptor_think2use_hittype_splash;
missile.nextthink = time + WEP_CVAR(seeker, flac_lifetime) + WEP_CVAR(seeker, flac_lifetime_rand);
missile.solid = SOLID_BBOX;
remove(self);
}
+void W_RocketMinsta_Laser_Explode_use(entity this, entity actor, entity trigger)
+{
+ WITHSELF(this, W_RocketMinsta_Laser_Explode());
+}
+
void W_RocketMinsta_Laser_Touch ()
{SELFPARAM();
PROJECTILE_TOUCH;
proj.owner = proj.realowner = self;
proj.bot_dodge = true;
proj.bot_dodgerating = autocvar_g_rm_laser_damage;
- proj.use = W_RocketMinsta_Laser_Explode;
+ proj.use = W_RocketMinsta_Laser_Explode_use;
proj.think = adaptor_think2use_hittype_splash;
proj.nextthink = time + autocvar_g_rm_laser_lifetime;
PROJECTILE_MAKETRIGGER(proj);
proj.owner = proj.realowner = self;
proj.bot_dodge = true;
proj.bot_dodgerating = autocvar_g_rm_laser_damage;
- proj.use = W_RocketMinsta_Laser_Explode;
+ proj.use = W_RocketMinsta_Laser_Explode_use;
proj.think = adaptor_think2use_hittype_splash;
proj.nextthink = time + autocvar_g_rm_laser_lifetime;
PROJECTILE_MAKETRIGGER(proj);
#pragma noref 0
+#define use use1
+.void(entity this, entity actor, entity trigger) use;
+
#endif
#pragma noref 0
+#define use use1
+.void(entity this, entity actor, entity trigger) use;
+
#endif
// generated file; do not modify
-#include "angle.qc"
-#include "json.qc"
-#include "p2mathlib.qc"
-#include "random.qc"
-#include "sortlist.qc"
-#include "test.qc"
-#include "urllib.qc"
+#include <lib/angle.qc>
+#include <lib/json.qc>
+#include <lib/p2mathlib.qc>
+#include <lib/random.qc>
+#include <lib/sortlist.qc>
+#include <lib/test.qc>
+#include <lib/urllib.qc>
--- /dev/null
+// generated file; do not modify
+#include <lib/angle.qh>
+#include <lib/json.qh>
+#include <lib/p2mathlib.qh>
+#include <lib/random.qh>
+#include <lib/sortlist.qh>
+#include <lib/test.qh>
+#include <lib/urllib.qh>
// generated file; do not modify
-#include "cl_model.qc"
-#include "cl_player.qc"
-#include "interpolate.qc"
-#include "sv_model.qc"
+#include <lib/csqcmodel/cl_model.qc>
+#include <lib/csqcmodel/cl_player.qc>
+#include <lib/csqcmodel/interpolate.qc>
+#include <lib/csqcmodel/sv_model.qc>
--- /dev/null
+// generated file; do not modify
+#include <lib/csqcmodel/cl_model.qh>
+#include <lib/csqcmodel/cl_player.qh>
+#include <lib/csqcmodel/interpolate.qh>
+#include <lib/csqcmodel/sv_model.qh>
if(autocvar_cl_movement == 1)
CSQCPlayer_CheckWater(this); // we apparently need to check water *before* physics so it can use this for water jump
+ vector oldv_angle = this.v_angle;
+ vector oldangles = this.angles; // we need to save these, as they're abused by other code
+ this.v_angle = PHYS_INPUT_ANGLES(this);
+ this.angles = PHYS_WORLD_ANGLES(this);
+
CSQC_ClientMovement_PlayerMove_Frame(this);
if(autocvar_cl_movement == 1)
Movetype_Physics_Spam(this);
}
+ view_angles = this.v_angle;
+ input_angles = this.angles;
+ this.v_angle = oldv_angle;
+ this.angles = oldangles;
+
this.pmove_flags =
((this.flags & FL_DUCKED) ? PMF_DUCKED : 0) |
(!(this.flags & FL_JUMPRELEASED) ? PMF_JUMP_HELD : 0) |
class(Defer).entity owner;
class(Defer).void() think;
class(Defer).float nextthink;
+ class(Defer).void(entity) defer_func;
/** Remove self */
void SUB_Remove(entity this)
SELFPARAM();
this.think = SUB_Remove_self;
this.nextthink = time;
- WITHSELF(this.owner, this.selfthink(this));
+ this.defer_func(this.owner);
}
/**
* Execute func() after time + fdelay.
* self when func is executed = self when defer is called
*/
- void defer(entity this, float fdelay, void(entity this) func)
+ void defer(entity this, float fdelay, void(entity) func)
{
entity e = new_pure(deferred);
e.owner = this;
- setthink(e, func);
+ e.defer_func = func;
e.think = defer_think;
e.nextthink = time + fdelay;
}
string(string...) strcat0n = #115;
#endif
-#define __SOURCELOC__ (sprintf("^9"__FILE__"^7" ":" "^9%s^7" ":" "^9"STR(__LINE__)"^7", __FUNC__))
+#define __SOURCELOC__ (sprintf("^7%s^9" "(" "^9"__FILE__"^7" ":" "^9"STR(__LINE__)"^7" ")", __FUNC__))
#define _LOG(f, level, s) \
MACRO_BEGIN { \
- f(sprintf("^9[::^7" PROGNAME "^9::" level "^9] [%s^9]\n^7%s\n", __SOURCELOC__, s)); \
+ f(sprintf("^9[::" "^7"PROGNAME"^9" "::" level"^9" "] %s\n^7%s\n", __SOURCELOC__, s)); \
} MACRO_END
#define LOG_FATAL(...) _LOG_FATAL(strcat0n(__VA_ARGS__))
// generated file; do not modify
-#include "command.qc"
-#include "matrix.qc"
+#include <lib/matrix/command.qc>
+#include <lib/matrix/matrix.qc>
--- /dev/null
+// generated file; do not modify
+#include <lib/matrix/command.qh>
+#include <lib/matrix/matrix.qh>
void touch_self() { SELFPARAM(); this.selftouch(this); }
#define settouch(e, f) (e.touch = touch_self, e.selftouch = f)
-.void(entity this) selfuse;
-void use_self() { SELFPARAM(); this.selfuse(this); }
-#define setuse(e, f) (e.use = use_self, e.selfuse = f)
+//.void(entity this) selfuse;
+//void use_self() { SELFPARAM(); this.selfuse(this); }
+//#define setuse(e, f) (e.use = use_self, e.selfuse = f)
.void(entity this) selfthink;
void think_self() { SELFPARAM(); this.selfthink(this); }
// generated file; do not modify
-#include "anglestransform.qc"
-#include "client.qc"
-#include "common.qc"
-#include "mathlib.qc"
-#include "server.qc"
-#include "util_server.qc"
+#include <lib/warpzone/anglestransform.qc>
+#include <lib/warpzone/client.qc>
+#include <lib/warpzone/common.qc>
+#include <lib/warpzone/mathlib.qc>
+#include <lib/warpzone/server.qc>
+#include <lib/warpzone/util_server.qc>
--- /dev/null
+// generated file; do not modify
+#include <lib/warpzone/anglestransform.qh>
+#include <lib/warpzone/client.qh>
+#include <lib/warpzone/common.qh>
+#include <lib/warpzone/mathlib.qh>
+#include <lib/warpzone/server.qh>
+#include <lib/warpzone/util_server.qh>
{
#ifdef SVQC
string save1, save2;
- activator = other;
save1 = this.target; this.target = string_null;
save2 = this.target3; this.target3 = string_null;
- SUB_UseTargets();
+ SUB_UseTargets(this, other, other); // use other too?
if (!this.target) this.target = save1;
if (!this.target3) this.target3 = save2;
- setself(this.enemy);
save1 = this.target; this.target = string_null;
save2 = this.target2; this.target2 = string_null;
- SUB_UseTargets();
+ SUB_UseTargets(this.enemy, other, other); // use other too?
if (!this.target) this.target = save1;
if (!this.target2) this.target2 = save2;
- setself(this);
#endif
}
else
player.velvec = player.warpzone_oldvelocity;
if(WarpZone_Teleport(wz, player, 0, 1))
{
- entity oldself;
string save1, save2;
- oldself = self;
- self = wz;
- other = player;
- activator = player;
-
- save1 = self.target; self.target = string_null;
- save2 = self.target3; self.target3 = string_null;
- SUB_UseTargets();
- if (!self.target) self.target = save1;
- if (!self.target3) self.target3 = save2;
-
- self = self.enemy;
- save1 = self.target; self.target = string_null;
- save2 = self.target2; self.target2 = string_null;
- SUB_UseTargets();
- if (!self.target) self.target = save1;
- if (!self.target2) self.target2 = save2;
- self = oldself;
+ save1 = wz.target; wz.target = string_null;
+ save2 = wz.target3; wz.target3 = string_null;
+ SUB_UseTargets(wz, player, player);
+ if (!wz.target) wz.target = save1;
+ if (!wz.target3) wz.target3 = save2;
+
+ save1 = wz.enemy.target; wz.enemy.target = string_null;
+ save2 = wz.enemy.target2; wz.enemy.target2 = string_null;
+ SUB_UseTargets(wz.enemy, player, player);
+ if (!wz.enemy.target) wz.enemy.target = save1;
+ if (!wz.enemy.target2) wz.enemy.target2 = save2;
}
else
{
));
return false;
}
-void trigger_warpzone_reconnect_use()
-{SELFPARAM();
+void trigger_warpzone_reconnect_use(entity this, entity actor, entity trigger)
+{
// NOTE: this matches for target, not targetname, but of course
// targetname must be set too on the other entities
for(entity e = warpzone_first; e; e = e.warpzone_next)
// generated file; do not modify
-#include "draw.qc"
-#include "item.qc"
-#include "matrix.qc"
-#include "menu.qc"
+#include <menu/draw.qc>
+#include <menu/item.qc>
+#include <menu/matrix.qc>
+#include <menu/menu.qc>
--- /dev/null
+// generated file; do not modify
+#include <menu/draw.qh>
+#include <menu/item.qh>
+#include <menu/matrix.qh>
+#include <menu/menu.qh>
// generated file; do not modify
-#include "animation.qc"
-#include "animhost.qc"
-#include "easing.qc"
-#include "keyframe.qc"
+#include <menu/anim/animation.qc>
+#include <menu/anim/animhost.qc>
+#include <menu/anim/easing.qc>
+#include <menu/anim/keyframe.qc>
--- /dev/null
+// generated file; do not modify
+#include <menu/anim/animation.qh>
+#include <menu/anim/animhost.qh>
+#include <menu/anim/easing.qh>
+#include <menu/anim/keyframe.qh>
// generated file; do not modify
-#include "all.qc"
-#include "menu_cmd.qc"
+#include <menu/command/all.qc>
+#include <menu/command/menu_cmd.qc>
--- /dev/null
+// generated file; do not modify
+#include <menu/command/all.qh>
+#include <menu/command/menu_cmd.qh>
// generated file; do not modify
-#include "borderimage.qc"
-#include "button.qc"
-#include "checkbox.qc"
-#include "container.qc"
-#include "dialog.qc"
-#include "image.qc"
-#include "inputbox.qc"
-#include "inputcontainer.qc"
-#include "label.qc"
-#include "listbox.qc"
-#include "modalcontroller.qc"
-#include "nexposee.qc"
-#include "radiobutton.qc"
-#include "slider.qc"
-#include "tab.qc"
-#include "textslider.qc"
+#include <menu/item/borderimage.qc>
+#include <menu/item/button.qc>
+#include <menu/item/checkbox.qc>
+#include <menu/item/container.qc>
+#include <menu/item/dialog.qc>
+#include <menu/item/image.qc>
+#include <menu/item/inputbox.qc>
+#include <menu/item/inputcontainer.qc>
+#include <menu/item/label.qc>
+#include <menu/item/listbox.qc>
+#include <menu/item/modalcontroller.qc>
+#include <menu/item/nexposee.qc>
+#include <menu/item/radiobutton.qc>
+#include <menu/item/slider.qc>
+#include <menu/item/tab.qc>
+#include <menu/item/textslider.qc>
--- /dev/null
+// generated file; do not modify
+#include <menu/item/borderimage.qh>
+#include <menu/item/button.qh>
+#include <menu/item/checkbox.qh>
+#include <menu/item/container.qh>
+#include <menu/item/dialog.qh>
+#include <menu/item/image.qh>
+#include <menu/item/inputbox.qh>
+#include <menu/item/inputcontainer.qh>
+#include <menu/item/label.qh>
+#include <menu/item/listbox.qh>
+#include <menu/item/modalcontroller.qh>
+#include <menu/item/nexposee.qh>
+#include <menu/item/radiobutton.qh>
+#include <menu/item/slider.qh>
+#include <menu/item/tab.qh>
+#include <menu/item/textslider.qh>
--- /dev/null
+// generated file; do not modify
#include <lib/_all.inc>
-#include "_mod.inc"
+#include "../menu/_mod.inc"
#include "anim/_mod.inc"
#include "command/_mod.inc"
#include "item/_mod.inc"
// generated file; do not modify
-#include "bigbutton.qc"
-#include "bigcommandbutton.qc"
-#include "button.qc"
-#include "campaign.qc"
-#include "charmap.qc"
-#include "checkbox.qc"
-#include "checkbox_slider_invalid.qc"
-#include "checkbox_string.qc"
-#include "colorbutton.qc"
-#include "colorpicker.qc"
-#include "colorpicker_string.qc"
-#include "commandbutton.qc"
-#include "credits.qc"
-#include "crosshairpicker.qc"
-#include "crosshairpreview.qc"
-#include "cvarlist.qc"
-#include "datasource.qc"
-#include "demolist.qc"
-#include "dialog.qc"
-#include "dialog_credits.qc"
-#include "dialog_firstrun.qc"
-#include "dialog_hudpanel_ammo.qc"
-#include "dialog_hudpanel_centerprint.qc"
-#include "dialog_hudpanel_chat.qc"
-#include "dialog_hudpanel_engineinfo.qc"
-#include "dialog_hudpanel_healtharmor.qc"
-#include "dialog_hudpanel_infomessages.qc"
-#include "dialog_hudpanel_itemstime.qc"
-#include "dialog_hudpanel_modicons.qc"
-#include "dialog_hudpanel_notification.qc"
-#include "dialog_hudpanel_physics.qc"
-#include "dialog_hudpanel_powerups.qc"
-#include "dialog_hudpanel_pressedkeys.qc"
-#include "dialog_hudpanel_quickmenu.qc"
-#include "dialog_hudpanel_racetimer.qc"
-#include "dialog_hudpanel_radar.qc"
-#include "dialog_hudpanel_score.qc"
-#include "dialog_hudpanel_timer.qc"
-#include "dialog_hudpanel_vote.qc"
-#include "dialog_hudpanel_weapons.qc"
-#include "dialog_hudsetup_exit.qc"
-#include "dialog_monstertools.qc"
-#include "dialog_multiplayer.qc"
-#include "dialog_multiplayer_create.qc"
-#include "dialog_multiplayer_create_mapinfo.qc"
-#include "dialog_multiplayer_create_mutators.qc"
-#include "dialog_multiplayer_join.qc"
-#include "dialog_multiplayer_join_serverinfo.qc"
-#include "dialog_multiplayer_media.qc"
-#include "dialog_multiplayer_media_demo.qc"
-#include "dialog_multiplayer_media_demo_startconfirm.qc"
-#include "dialog_multiplayer_media_demo_timeconfirm.qc"
-#include "dialog_multiplayer_media_musicplayer.qc"
-#include "dialog_multiplayer_media_screenshot.qc"
-#include "dialog_multiplayer_media_screenshot_viewer.qc"
-#include "dialog_multiplayer_profile.qc"
-#include "dialog_quit.qc"
-#include "dialog_sandboxtools.qc"
-#include "dialog_settings.qc"
-#include "dialog_settings_audio.qc"
-#include "dialog_settings_effects.qc"
-#include "dialog_settings_game.qc"
-#include "dialog_settings_game_crosshair.qc"
-#include "dialog_settings_game_hud.qc"
-#include "dialog_settings_game_hudconfirm.qc"
-#include "dialog_settings_game_messages.qc"
-#include "dialog_settings_game_model.qc"
-#include "dialog_settings_game_view.qc"
-#include "dialog_settings_game_weapons.qc"
-#include "dialog_settings_input.qc"
-#include "dialog_settings_input_userbind.qc"
-#include "dialog_settings_misc.qc"
-#include "dialog_settings_misc_cvars.qc"
-#include "dialog_settings_misc_reset.qc"
-#include "dialog_settings_user.qc"
-#include "dialog_settings_user_languagewarning.qc"
-#include "dialog_settings_video.qc"
-#include "dialog_singleplayer.qc"
-#include "dialog_singleplayer_winner.qc"
-#include "dialog_teamselect.qc"
-#include "gametypelist.qc"
-#include "hudskinlist.qc"
-#include "image.qc"
-#include "inputbox.qc"
-#include "keybinder.qc"
-#include "languagelist.qc"
-#include "listbox.qc"
-#include "mainwindow.qc"
-#include "maplist.qc"
-#include "nexposee.qc"
-#include "picker.qc"
-#include "playerlist.qc"
-#include "playermodel.qc"
-#include "playlist.qc"
-#include "radiobutton.qc"
-#include "rootdialog.qc"
-#include "screenshotimage.qc"
-#include "screenshotlist.qc"
-#include "serverlist.qc"
-#include "skinlist.qc"
-#include "slider.qc"
-#include "slider_decibels.qc"
-#include "slider_particles.qc"
-#include "slider_picmip.qc"
-#include "slider_resolution.qc"
-#include "slider_sbfadetime.qc"
-#include "soundlist.qc"
-#include "statslist.qc"
-#include "tab.qc"
-#include "tabcontroller.qc"
-#include "textlabel.qc"
-#include "textslider.qc"
-#include "util.qc"
-#include "weaponarenacheckbox.qc"
-#include "weaponslist.qc"
+#include <menu/xonotic/bigbutton.qc>
+#include <menu/xonotic/bigcommandbutton.qc>
+#include <menu/xonotic/button.qc>
+#include <menu/xonotic/campaign.qc>
+#include <menu/xonotic/charmap.qc>
+#include <menu/xonotic/checkbox.qc>
+#include <menu/xonotic/checkbox_slider_invalid.qc>
+#include <menu/xonotic/checkbox_string.qc>
+#include <menu/xonotic/colorbutton.qc>
+#include <menu/xonotic/colorpicker.qc>
+#include <menu/xonotic/colorpicker_string.qc>
+#include <menu/xonotic/commandbutton.qc>
+#include <menu/xonotic/credits.qc>
+#include <menu/xonotic/crosshairpicker.qc>
+#include <menu/xonotic/crosshairpreview.qc>
+#include <menu/xonotic/cvarlist.qc>
+#include <menu/xonotic/datasource.qc>
+#include <menu/xonotic/demolist.qc>
+#include <menu/xonotic/dialog.qc>
+#include <menu/xonotic/dialog_credits.qc>
+#include <menu/xonotic/dialog_firstrun.qc>
+#include <menu/xonotic/dialog_hudpanel_ammo.qc>
+#include <menu/xonotic/dialog_hudpanel_centerprint.qc>
+#include <menu/xonotic/dialog_hudpanel_chat.qc>
+#include <menu/xonotic/dialog_hudpanel_engineinfo.qc>
+#include <menu/xonotic/dialog_hudpanel_healtharmor.qc>
+#include <menu/xonotic/dialog_hudpanel_infomessages.qc>
+#include <menu/xonotic/dialog_hudpanel_itemstime.qc>
+#include <menu/xonotic/dialog_hudpanel_modicons.qc>
+#include <menu/xonotic/dialog_hudpanel_notification.qc>
+#include <menu/xonotic/dialog_hudpanel_physics.qc>
+#include <menu/xonotic/dialog_hudpanel_powerups.qc>
+#include <menu/xonotic/dialog_hudpanel_pressedkeys.qc>
+#include <menu/xonotic/dialog_hudpanel_quickmenu.qc>
+#include <menu/xonotic/dialog_hudpanel_racetimer.qc>
+#include <menu/xonotic/dialog_hudpanel_radar.qc>
+#include <menu/xonotic/dialog_hudpanel_score.qc>
+#include <menu/xonotic/dialog_hudpanel_timer.qc>
+#include <menu/xonotic/dialog_hudpanel_vote.qc>
+#include <menu/xonotic/dialog_hudpanel_weapons.qc>
+#include <menu/xonotic/dialog_hudsetup_exit.qc>
+#include <menu/xonotic/dialog_monstertools.qc>
+#include <menu/xonotic/dialog_multiplayer.qc>
+#include <menu/xonotic/dialog_multiplayer_create.qc>
+#include <menu/xonotic/dialog_multiplayer_create_mapinfo.qc>
+#include <menu/xonotic/dialog_multiplayer_create_mutators.qc>
+#include <menu/xonotic/dialog_multiplayer_join.qc>
+#include <menu/xonotic/dialog_multiplayer_join_serverinfo.qc>
+#include <menu/xonotic/dialog_multiplayer_media.qc>
+#include <menu/xonotic/dialog_multiplayer_media_demo.qc>
+#include <menu/xonotic/dialog_multiplayer_media_demo_startconfirm.qc>
+#include <menu/xonotic/dialog_multiplayer_media_demo_timeconfirm.qc>
+#include <menu/xonotic/dialog_multiplayer_media_musicplayer.qc>
+#include <menu/xonotic/dialog_multiplayer_media_screenshot.qc>
+#include <menu/xonotic/dialog_multiplayer_media_screenshot_viewer.qc>
+#include <menu/xonotic/dialog_multiplayer_profile.qc>
+#include <menu/xonotic/dialog_quit.qc>
+#include <menu/xonotic/dialog_sandboxtools.qc>
+#include <menu/xonotic/dialog_settings.qc>
+#include <menu/xonotic/dialog_settings_audio.qc>
+#include <menu/xonotic/dialog_settings_effects.qc>
+#include <menu/xonotic/dialog_settings_game.qc>
+#include <menu/xonotic/dialog_settings_game_crosshair.qc>
+#include <menu/xonotic/dialog_settings_game_hud.qc>
+#include <menu/xonotic/dialog_settings_game_hudconfirm.qc>
+#include <menu/xonotic/dialog_settings_game_messages.qc>
+#include <menu/xonotic/dialog_settings_game_model.qc>
+#include <menu/xonotic/dialog_settings_game_view.qc>
+#include <menu/xonotic/dialog_settings_game_weapons.qc>
+#include <menu/xonotic/dialog_settings_input.qc>
+#include <menu/xonotic/dialog_settings_input_userbind.qc>
+#include <menu/xonotic/dialog_settings_misc.qc>
+#include <menu/xonotic/dialog_settings_misc_cvars.qc>
+#include <menu/xonotic/dialog_settings_misc_reset.qc>
+#include <menu/xonotic/dialog_settings_user.qc>
+#include <menu/xonotic/dialog_settings_user_languagewarning.qc>
+#include <menu/xonotic/dialog_settings_video.qc>
+#include <menu/xonotic/dialog_singleplayer.qc>
+#include <menu/xonotic/dialog_singleplayer_winner.qc>
+#include <menu/xonotic/dialog_teamselect.qc>
+#include <menu/xonotic/gametypelist.qc>
+#include <menu/xonotic/hudskinlist.qc>
+#include <menu/xonotic/image.qc>
+#include <menu/xonotic/inputbox.qc>
+#include <menu/xonotic/keybinder.qc>
+#include <menu/xonotic/languagelist.qc>
+#include <menu/xonotic/listbox.qc>
+#include <menu/xonotic/mainwindow.qc>
+#include <menu/xonotic/maplist.qc>
+#include <menu/xonotic/nexposee.qc>
+#include <menu/xonotic/picker.qc>
+#include <menu/xonotic/playerlist.qc>
+#include <menu/xonotic/playermodel.qc>
+#include <menu/xonotic/playlist.qc>
+#include <menu/xonotic/radiobutton.qc>
+#include <menu/xonotic/rootdialog.qc>
+#include <menu/xonotic/screenshotimage.qc>
+#include <menu/xonotic/screenshotlist.qc>
+#include <menu/xonotic/serverlist.qc>
+#include <menu/xonotic/skinlist.qc>
+#include <menu/xonotic/slider.qc>
+#include <menu/xonotic/slider_decibels.qc>
+#include <menu/xonotic/slider_particles.qc>
+#include <menu/xonotic/slider_picmip.qc>
+#include <menu/xonotic/slider_resolution.qc>
+#include <menu/xonotic/slider_sbfadetime.qc>
+#include <menu/xonotic/soundlist.qc>
+#include <menu/xonotic/statslist.qc>
+#include <menu/xonotic/tab.qc>
+#include <menu/xonotic/tabcontroller.qc>
+#include <menu/xonotic/textlabel.qc>
+#include <menu/xonotic/textslider.qc>
+#include <menu/xonotic/util.qc>
+#include <menu/xonotic/weaponarenacheckbox.qc>
+#include <menu/xonotic/weaponslist.qc>
--- /dev/null
+// generated file; do not modify
+#include <menu/xonotic/bigbutton.qh>
+#include <menu/xonotic/bigcommandbutton.qh>
+#include <menu/xonotic/button.qh>
+#include <menu/xonotic/campaign.qh>
+#include <menu/xonotic/charmap.qh>
+#include <menu/xonotic/checkbox.qh>
+#include <menu/xonotic/checkbox_slider_invalid.qh>
+#include <menu/xonotic/checkbox_string.qh>
+#include <menu/xonotic/colorbutton.qh>
+#include <menu/xonotic/colorpicker.qh>
+#include <menu/xonotic/colorpicker_string.qh>
+#include <menu/xonotic/commandbutton.qh>
+#include <menu/xonotic/credits.qh>
+#include <menu/xonotic/crosshairpicker.qh>
+#include <menu/xonotic/crosshairpreview.qh>
+#include <menu/xonotic/cvarlist.qh>
+#include <menu/xonotic/datasource.qh>
+#include <menu/xonotic/demolist.qh>
+#include <menu/xonotic/dialog.qh>
+#include <menu/xonotic/dialog_credits.qh>
+#include <menu/xonotic/dialog_firstrun.qh>
+#include <menu/xonotic/dialog_hudpanel_ammo.qh>
+#include <menu/xonotic/dialog_hudpanel_centerprint.qh>
+#include <menu/xonotic/dialog_hudpanel_chat.qh>
+#include <menu/xonotic/dialog_hudpanel_engineinfo.qh>
+#include <menu/xonotic/dialog_hudpanel_healtharmor.qh>
+#include <menu/xonotic/dialog_hudpanel_infomessages.qh>
+#include <menu/xonotic/dialog_hudpanel_itemstime.qh>
+#include <menu/xonotic/dialog_hudpanel_modicons.qh>
+#include <menu/xonotic/dialog_hudpanel_notification.qh>
+#include <menu/xonotic/dialog_hudpanel_physics.qh>
+#include <menu/xonotic/dialog_hudpanel_powerups.qh>
+#include <menu/xonotic/dialog_hudpanel_pressedkeys.qh>
+#include <menu/xonotic/dialog_hudpanel_quickmenu.qh>
+#include <menu/xonotic/dialog_hudpanel_racetimer.qh>
+#include <menu/xonotic/dialog_hudpanel_radar.qh>
+#include <menu/xonotic/dialog_hudpanel_score.qh>
+#include <menu/xonotic/dialog_hudpanel_timer.qh>
+#include <menu/xonotic/dialog_hudpanel_vote.qh>
+#include <menu/xonotic/dialog_hudpanel_weapons.qh>
+#include <menu/xonotic/dialog_hudsetup_exit.qh>
+#include <menu/xonotic/dialog_monstertools.qh>
+#include <menu/xonotic/dialog_multiplayer.qh>
+#include <menu/xonotic/dialog_multiplayer_create.qh>
+#include <menu/xonotic/dialog_multiplayer_create_mapinfo.qh>
+#include <menu/xonotic/dialog_multiplayer_create_mutators.qh>
+#include <menu/xonotic/dialog_multiplayer_join.qh>
+#include <menu/xonotic/dialog_multiplayer_join_serverinfo.qh>
+#include <menu/xonotic/dialog_multiplayer_media.qh>
+#include <menu/xonotic/dialog_multiplayer_media_demo.qh>
+#include <menu/xonotic/dialog_multiplayer_media_demo_startconfirm.qh>
+#include <menu/xonotic/dialog_multiplayer_media_demo_timeconfirm.qh>
+#include <menu/xonotic/dialog_multiplayer_media_musicplayer.qh>
+#include <menu/xonotic/dialog_multiplayer_media_screenshot.qh>
+#include <menu/xonotic/dialog_multiplayer_media_screenshot_viewer.qh>
+#include <menu/xonotic/dialog_multiplayer_profile.qh>
+#include <menu/xonotic/dialog_quit.qh>
+#include <menu/xonotic/dialog_sandboxtools.qh>
+#include <menu/xonotic/dialog_settings.qh>
+#include <menu/xonotic/dialog_settings_audio.qh>
+#include <menu/xonotic/dialog_settings_effects.qh>
+#include <menu/xonotic/dialog_settings_game.qh>
+#include <menu/xonotic/dialog_settings_game_crosshair.qh>
+#include <menu/xonotic/dialog_settings_game_hud.qh>
+#include <menu/xonotic/dialog_settings_game_hudconfirm.qh>
+#include <menu/xonotic/dialog_settings_game_messages.qh>
+#include <menu/xonotic/dialog_settings_game_model.qh>
+#include <menu/xonotic/dialog_settings_game_view.qh>
+#include <menu/xonotic/dialog_settings_game_weapons.qh>
+#include <menu/xonotic/dialog_settings_input.qh>
+#include <menu/xonotic/dialog_settings_input_userbind.qh>
+#include <menu/xonotic/dialog_settings_misc.qh>
+#include <menu/xonotic/dialog_settings_misc_cvars.qh>
+#include <menu/xonotic/dialog_settings_misc_reset.qh>
+#include <menu/xonotic/dialog_settings_user.qh>
+#include <menu/xonotic/dialog_settings_user_languagewarning.qh>
+#include <menu/xonotic/dialog_settings_video.qh>
+#include <menu/xonotic/dialog_singleplayer.qh>
+#include <menu/xonotic/dialog_singleplayer_winner.qh>
+#include <menu/xonotic/dialog_teamselect.qh>
+#include <menu/xonotic/gametypelist.qh>
+#include <menu/xonotic/hudskinlist.qh>
+#include <menu/xonotic/image.qh>
+#include <menu/xonotic/inputbox.qh>
+#include <menu/xonotic/keybinder.qh>
+#include <menu/xonotic/languagelist.qh>
+#include <menu/xonotic/listbox.qh>
+#include <menu/xonotic/mainwindow.qh>
+#include <menu/xonotic/maplist.qh>
+#include <menu/xonotic/nexposee.qh>
+#include <menu/xonotic/picker.qh>
+#include <menu/xonotic/playerlist.qh>
+#include <menu/xonotic/playermodel.qh>
+#include <menu/xonotic/playlist.qh>
+#include <menu/xonotic/radiobutton.qh>
+#include <menu/xonotic/rootdialog.qh>
+#include <menu/xonotic/screenshotimage.qh>
+#include <menu/xonotic/screenshotlist.qh>
+#include <menu/xonotic/serverlist.qh>
+#include <menu/xonotic/skinlist.qh>
+#include <menu/xonotic/slider.qh>
+#include <menu/xonotic/slider_decibels.qh>
+#include <menu/xonotic/slider_particles.qh>
+#include <menu/xonotic/slider_picmip.qh>
+#include <menu/xonotic/slider_resolution.qh>
+#include <menu/xonotic/slider_sbfadetime.qh>
+#include <menu/xonotic/soundlist.qh>
+#include <menu/xonotic/statslist.qh>
+#include <menu/xonotic/tab.qh>
+#include <menu/xonotic/tabcontroller.qh>
+#include <menu/xonotic/textlabel.qh>
+#include <menu/xonotic/textslider.qh>
+#include <menu/xonotic/util.qh>
+#include <menu/xonotic/weaponarenacheckbox.qh>
+#include <menu/xonotic/weaponslist.qh>
#include "inputbox.qh"
#include "../item/container.qh"
+#include "../item/checkbox.qh"
entity makeXonoticCvarList()
{
me.handle = buf_create();
me.nItems = 0;
}
+void CvarList_Load(entity me, string filter)
+{
+ if(me.handle < 0)
+ return;
+
+ buf_cvarlist(me.handle, filter, "_");
+ me.nItems = buf_getsize(me.handle);
+ if(autocvar_menu_cvarlist_onlymodified)
+ {
+ float newbuf = buf_create();
+ for (int i = 0; i < me.nItems; ++i)
+ {
+ string k = bufstr_get(me.handle, i);
+ if(cvar_string(k) != cvar_defstring(k))
+ bufstr_add(newbuf, k, false);
+ }
+ buf_del(me.handle);
+ me.handle = newbuf;
+ me.nItems = buf_getsize(me.handle);
+ }
+}
void XonoticCvarList_showNotify(entity me)
{
bool force_initial_selection = false;
if(me.handle >= 0 && me.nItems <= 0) // me.handle not loaded yet?
force_initial_selection = true;
- buf_cvarlist(me.handle, "", "_");
- me.nItems = buf_getsize(me.handle);
+ CvarList_Load(me, me.controlledTextbox.text);
if(force_initial_selection)
me.setSelected(me, 0);
}
+void XonoticCvarList_hideNotify(entity me)
+{
+ if(me.handle)
+ buf_del(me.handle);
+ me.handle = buf_create();
+ me.nItems = 0;
+}
void XonoticCvarList_destroy(entity me)
{
- buf_del(me.handle);
+ if(me.handle)
+ buf_del(me.handle);
}
string autocvar_menu_forced_saved_cvars;
string autocvar_menu_reverted_nonsaved_cvars;
}
void CvarList_Filter_Change(entity box, entity me)
{
- buf_cvarlist(me.handle, box.text, "_");
- me.nItems = buf_getsize(me.handle);
-
+ CvarList_Load(me, box.text);
+ me.setSelected(me, 0);
+}
+void CvarList_Filter_ModifiedCvars(entity box, entity me)
+{
+ cvar_set("menu_cvarlist_onlymodified", ftos(!autocvar_menu_cvarlist_onlymodified));
+ box.setChecked(box, autocvar_menu_cvarlist_onlymodified);
+ CvarList_Load(me, me.controlledTextbox.text);
me.setSelected(me, 0);
}
void XonoticCvarList_resizeNotify(entity me, vector relOrigin, vector relSize, vector absOrigin, vector absSize)
METHOD(XonoticCvarList, resizeNotify, void(entity, vector, vector, vector, vector));
METHOD(XonoticCvarList, keyDown, float(entity, float, float, float));
METHOD(XonoticCvarList, showNotify, void(entity));
+ METHOD(XonoticCvarList, hideNotify, void(entity));
METHOD(XonoticCvarList, destroy, void(entity));
ENDCLASS(XonoticCvarList)
entity makeXonoticCvarList();
void CvarList_Filter_Change(entity box, entity me);
+void CvarList_Filter_ModifiedCvars(entity box, entity me);
void CvarList_Value_Change(entity box, entity me);
void CvarList_Revert_Click(entity btn, entity me);
void CvarList_End_Editing(entity box, entity me);
+
+float autocvar_menu_cvarlist_onlymodified;
me.TR(me);
me.TDempty(me, 0.2);
me.TD(me, 1, 1.4, e = makeXonoticTextLabel(0, _("Weapon ID scale:")));
+ setDependent(e, "hud_panel_weapons_label", 1, 2);
me.TD(me, 1, 2.4, e = makeXonoticSlider(0.1, 1, 0.05, "hud_panel_weapons_label_scale"));
setDependent(e, "hud_panel_weapons_label", 1, 2);
me.TR(me);
me.TR(me);
me.TDempty(me, 0.2);
me.TD(me, 1, 1.4, e = makeXonoticTextLabel(0, _("Ammo bar alpha:")));
+ setDependent(e, "hud_panel_weapons_ammo", 1, 1);
me.TD(me, 1, 2.4, e = makeXonoticSlider(0.1, 1, 0.1, "hud_panel_weapons_ammo_alpha"));
setDependent(e, "hud_panel_weapons_ammo", 1, 1);
me.TR(me);
me.TDempty(me, 0.2);
me.TD(me, 1, 1.2, e = makeXonoticTextLabel(0, _("Ammo bar color:")));
+ setDependent(e, "hud_panel_weapons_ammo", 1, 1);
me.TD(me, 2, 2.4, e = makeXonoticColorpickerString("hud_panel_weapons_ammo_color", "hud_panel_weapons_ammo_color"));
setDependent(e, "hud_panel_weapons_ammo", 1, 1);
me.TR(me);
setDependent(e, "crosshair_enabled", 1, 2);
me.TR(me);
me.TD(me, 1, 1, e = makeXonoticTextLabel(0, _("Hit testing:")));
+ setDependent(e, "crosshair_enabled", 1, 2);
me.TD(me, 1, 2, e = makeXonoticTextSlider_T("crosshair_hittest",
_("None: do not do hit tests for the crosshair; TrueAim: blur the crosshair when you would not hit the wall; Enemies: also enlarge the crosshair when you would hit an enemy")));
e.addValue(e, ZCTX(_("HTTST^Disabled")), "0");
#include "dialog_settings_misc_cvars.qh"
+#include "checkbox.qh"
#include "cvarlist.qh"
#include "textlabel.qh"
#include "inputbox.qh"
me.TR(me);
me.TD(me, 1, 1, e = makeXonoticTextLabel(0, _("Cvar filter:")));
- me.TD(me, 1, me.columns - 1, e = makeXonoticInputBox(0, string_null));
- e.color = SKINCOLOR_CVARLIST_CONTROLS;
- e.colorF = SKINCOLOR_CVARLIST_CONTROLS;
- e.cb_color = SKINCOLOR_CVARLIST_CONTROLS;
- e.cb_colorC = SKINCOLOR_CVARLIST_CONTROLS;
- e.cb_colorF = SKINCOLOR_CVARLIST_CONTROLS;
+ me.TD(me, 1, 3, e = makeXonoticInputBox(0, string_null));
+ e.color = e.colorF = SKINCOLOR_CVARLIST_CONTROLS;
+ e.cb_color = e.cb_colorC = e.cb_colorF = SKINCOLOR_CVARLIST_CONTROLS;
e.onChange = CvarList_Filter_Change;
e.onChangeEntity = cvarlist;
cvarlist.controlledTextbox = e; // this COULD also be the Value box, but this leads to accidentally editing stuff
+ me.TD(me, 1, 2, e = makeXonoticCheckBox(0, "menu_cvarlist_onlymodified", _("Modified cvars only")));
+ e.color = e.colorC = e.colorF = e.colorD = SKINCOLOR_CVARLIST_CONTROLS;
+ e.onClickEntity = cvarlist;
+ e.onClick = CvarList_Filter_ModifiedCvars;
me.TR(me);
me.TD(me, me.rows - me.currentRow - 9, me.columns, cvarlist);
me.gotoRC(me, me.rows - 8, 0);
me.TD(me, 1, 1, e = makeXonoticTextLabel(0, _("Value:")));
me.TD(me, 1, me.columns - 2, e = makeXonoticInputBox(0, string_null));
cvarlist.cvarValueBox = e;
- e.color = SKINCOLOR_CVARLIST_CONTROLS;
- e.colorF = SKINCOLOR_CVARLIST_CONTROLS;
- e.cb_color = SKINCOLOR_CVARLIST_CONTROLS;
- e.cb_colorC = SKINCOLOR_CVARLIST_CONTROLS;
- e.cb_colorF = SKINCOLOR_CVARLIST_CONTROLS;
+ e.color = e.colorF = SKINCOLOR_CVARLIST_CONTROLS;
+ e.cb_color = e.cb_colorC = e.cb_colorF = SKINCOLOR_CVARLIST_CONTROLS;
e.onChange = CvarList_Value_Change;
e.onChangeEntity = cvarlist;
e.onEnter = CvarList_End_Editing;
for(int imp = 1; imp <= 9; ++imp)
{
string w_list = "";
- ADD_TO_W_LIST(!(it.flags & WEP_FLAG_MUTATORBLOCKED) && !(it.flags & WEP_FLAG_SUPERWEAPON));
- ADD_TO_W_LIST(it.flags & WEP_FLAG_SUPERWEAPON);
- ADD_TO_W_LIST(it.flags & WEP_FLAG_MUTATORBLOCKED);
+ ADD_TO_W_LIST(!(it.spawnflags & WEP_FLAG_MUTATORBLOCKED) && !(it.spawnflags & WEP_TYPE_OTHER) && !(it.spawnflags & WEP_FLAG_HIDDEN) && !(it.spawnflags & WEP_FLAG_SUPERWEAPON));
+ ADD_TO_W_LIST((it.spawnflags & WEP_FLAG_SUPERWEAPON) && !(it.spawnflags & WEP_TYPE_OTHER) && !(it.spawnflags & WEP_FLAG_HIDDEN));
+ ADD_TO_W_LIST((it.spawnflags & WEP_FLAG_MUTATORBLOCKED) && !(it.spawnflags & WEP_TYPE_OTHER) && !(it.spawnflags & WEP_FLAG_HIDDEN));
if(w_list)
KEYBIND_DEF(strcat("weapon_group_", itos(imp)), substring(w_list, 0, -4));
if(imp == 0)
// generated file; do not modify
-#include "anticheat.qc"
-#include "antilag.qc"
-#include "campaign.qc"
-#include "cheats.qc"
-#include "cl_client.qc"
-#include "cl_impulse.qc"
-#include "cl_player.qc"
-#include "g_damage.qc"
-#include "g_hook.qc"
-#include "g_lights.qc"
-#include "g_models.qc"
-#include "g_subs.qc"
-#include "g_world.qc"
-#include "ipban.qc"
-#include "item_key.qc"
-#include "mapvoting.qc"
-#include "matrix.qc"
-#include "miscfunctions.qc"
-#include "playerdemo.qc"
-#include "portals.qc"
-#include "race.qc"
-#include "round_handler.qc"
-#include "scores.qc"
-#include "scores_rules.qc"
-#include "spawnpoints.qc"
-#include "steerlib.qc"
-#include "sv_main.qc"
-#include "teamplay.qc"
-#include "tests.qc"
-#include "t_halflife.qc"
-#include "t_quake.qc"
-#include "t_quake3.qc"
+#include <server/anticheat.qc>
+#include <server/antilag.qc>
+#include <server/campaign.qc>
+#include <server/cheats.qc>
+#include <server/cl_client.qc>
+#include <server/cl_impulse.qc>
+#include <server/cl_player.qc>
+#include <server/g_damage.qc>
+#include <server/g_hook.qc>
+#include <server/g_lights.qc>
+#include <server/g_models.qc>
+#include <server/g_subs.qc>
+#include <server/g_world.qc>
+#include <server/ipban.qc>
+#include <server/item_key.qc>
+#include <server/mapvoting.qc>
+#include <server/matrix.qc>
+#include <server/miscfunctions.qc>
+#include <server/playerdemo.qc>
+#include <server/portals.qc>
+#include <server/race.qc>
+#include <server/round_handler.qc>
+#include <server/scores.qc>
+#include <server/scores_rules.qc>
+#include <server/spawnpoints.qc>
+#include <server/steerlib.qc>
+#include <server/sv_main.qc>
+#include <server/teamplay.qc>
+#include <server/tests.qc>
+#include <server/t_halflife.qc>
+#include <server/t_quake.qc>
+#include <server/t_quake3.qc>
--- /dev/null
+// generated file; do not modify
+#include <server/anticheat.qh>
+#include <server/antilag.qh>
+#include <server/campaign.qh>
+#include <server/cheats.qh>
+#include <server/cl_client.qh>
+#include <server/cl_impulse.qh>
+#include <server/cl_player.qh>
+#include <server/g_damage.qh>
+#include <server/g_hook.qh>
+#include <server/g_lights.qh>
+#include <server/g_models.qh>
+#include <server/g_subs.qh>
+#include <server/g_world.qh>
+#include <server/ipban.qh>
+#include <server/item_key.qh>
+#include <server/mapvoting.qh>
+#include <server/matrix.qh>
+#include <server/miscfunctions.qh>
+#include <server/playerdemo.qh>
+#include <server/portals.qh>
+#include <server/race.qh>
+#include <server/round_handler.qh>
+#include <server/scores.qh>
+#include <server/scores_rules.qh>
+#include <server/spawnpoints.qh>
+#include <server/steerlib.qh>
+#include <server/sv_main.qh>
+#include <server/teamplay.qh>
+#include <server/tests.qh>
+#include <server/t_halflife.qh>
+#include <server/t_quake.qh>
+#include <server/t_quake3.qh>
bool autocvar_g_instagib_damagedbycontents = true;
bool autocvar_g_instagib_blaster_keepdamage = false;
bool autocvar_g_instagib_blaster_keepforce = false;
+bool autocvar_g_instagib_mirrordamage;
+bool autocvar_g_instagib_friendlypush = true;
#define autocvar_g_mirrordamage cvar("g_mirrordamage")
#define autocvar_g_mirrordamage_virtual cvar("g_mirrordamage_virtual")
+bool autocvar_g_mirrordamage_onlyweapons;
float autocvar_g_movement_highspeed = 1;
string autocvar_g_mutatormsg;
// generated file; do not modify
-#include "aim.qc"
-#include "bot.qc"
-#include "navigation.qc"
-#include "scripting.qc"
-#include "waypoints.qc"
+#include <server/bot/aim.qc>
+#include <server/bot/bot.qc>
+#include <server/bot/navigation.qc>
+#include <server/bot/scripting.qc>
+#include <server/bot/waypoints.qc>
--- /dev/null
+// generated file; do not modify
+#include <server/bot/aim.qh>
+#include <server/bot/bot.qh>
+#include <server/bot/navigation.qh>
+#include <server/bot/scripting.qh>
+#include <server/bot/waypoints.qh>
}
this.bot_aimtarg = e1;
this.bot_aimlatency = this.ping; // FIXME? Shouldn't this be in the lag item?
- this.bot_aimselforigin = v1;
- this.bot_aimselfvelocity = v2;
+ //this.bot_aimselforigin = v1;
+ //this.bot_aimselfvelocity = v2;
this.bot_aimtargorigin = v3;
this.bot_aimtargvelocity = v4;
if(skill <= 0)
.vector bot_5th_order_aimfilter;
.vector bot_olddesiredang;
-.vector bot_aimselforigin;
-.vector bot_aimselfvelocity;
+//.vector bot_aimselforigin;
+//.vector bot_aimselfvelocity;
.vector bot_aimtargorigin;
.vector bot_aimtargvelocity;
// generated file; do not modify
-#include "havocbot.qc"
-#include "roles.qc"
+#include <server/bot/havocbot/havocbot.qc>
+#include <server/bot/havocbot/roles.qc>
--- /dev/null
+// generated file; do not modify
+#include <server/bot/havocbot/havocbot.qh>
+#include <server/bot/havocbot/roles.qh>
void havocbot_aim(entity this)
{
- vector selfvel, enemyvel;
+ vector myvel, enemyvel;
// if(this.flags & FL_INWATER)
// return;
if (time < this.nextaim)
return;
this.nextaim = time + 0.1;
- selfvel = this.velocity;
+ myvel = this.velocity;
if (!this.waterlevel)
- selfvel.z = 0;
+ myvel.z = 0;
if (this.enemy)
{
enemyvel = this.enemy.velocity;
if (!this.enemy.waterlevel)
enemyvel.z = 0;
- lag_additem(this, time + this.ping, 0, 0, this.enemy, this.origin, selfvel, (this.enemy.absmin + this.enemy.absmax) * 0.5, enemyvel);
+ lag_additem(this, time + this.ping, 0, 0, this.enemy, this.origin, myvel, (this.enemy.absmin + this.enemy.absmax) * 0.5, enemyvel);
}
else
- lag_additem(this, time + this.ping, 0, 0, world, this.origin, selfvel, ( this.goalcurrent.absmin + this.goalcurrent.absmax ) * 0.5, '0 0 0');
+ lag_additem(this, time + this.ping, 0, 0, world, this.origin, myvel, ( this.goalcurrent.absmin + this.goalcurrent.absmax ) * 0.5, '0 0 0');
}
bool havocbot_moveto_refresh_route(entity this)
// LordHavoc: disabled because this is too expensive
return '0 0 0';
#if 0
+SELFPARAM();
entity head;
vector dodge, v, n;
float danger, bestdanger, vl, d;
head = findchainfloat(bot_dodge, true);
while(head)
{
- if (head.owner != self)
+ if (head.owner != this)
{
vl = vlen(head.velocity);
if (vl > autocvar_sv_maxspeed * 0.3)
{
n = normalize(head.velocity);
- v = self.origin - head.origin;
+ v = this.origin - head.origin;
d = v * n;
if (d > (0 - head.bot_dodgerating))
if (d < (vl * 0.2 + head.bot_dodgerating))
}
else
{
- danger = head.bot_dodgerating - vlen(head.origin - self.origin);
+ danger = head.bot_dodgerating - vlen(head.origin - this.origin);
if (bestdanger < danger)
{
bestdanger = danger;
- dodge = normalize(self.origin - head.origin);
+ dodge = normalize(this.origin - head.origin);
}
}
}
// rough simulation of walking from one point to another to test if a path
// can be traveled, used for waypoint linking and havocbot
-float tracewalk(entity e, vector start, vector m1, vector m2, vector end, float movemode)
-{SELFPARAM();
+bool tracewalk(entity e, vector start, vector m1, vector m2, vector end, float movemode)
+{
vector org;
vector move;
vector dir;
if(autocvar_bot_debug_tracewalk)
{
debugresetnodes();
- debugnode(self, start);
+ debugnode(e, start);
}
move = end - start;
return true;
}
if(autocvar_bot_debug_tracewalk)
- debugnode(self, org);
+ debugnode(e, org);
if (dist <= 0)
break;
tracebox(org, m1, m2, org + move * stepdist, movemode, e);
if(autocvar_bot_debug_tracewalk)
- debugnode(self, trace_endpos);
+ debugnode(e, trace_endpos);
if (trace_fraction < 1)
{
swimming = true;
org = trace_endpos - normalize(org - trace_endpos) * stepdist;
- for (; org.z < end.z + self.maxs.z; org.z += stepdist)
+ for (; org.z < end.z + e.maxs.z; org.z += stepdist)
{
if(autocvar_bot_debug_tracewalk)
- debugnode(self, org);
+ debugnode(e, org);
if(pointcontents(org) == CONTENT_EMPTY)
break;
tracebox(org, m1, m2, move, movemode, e);
if(autocvar_bot_debug_tracewalk)
- debugnode(self, trace_endpos);
+ debugnode(e, trace_endpos);
// hit something
if (trace_fraction < 1)
if(vdist(diff, <, maxdist))
{
head.wpconsidered = true;
- entity oldself = self;
- setself(this);
if (tracewalk(this, this.origin, this.mins, this.maxs, v, bot_navigation_movemode))
{
head.wpnearestpoint = v;
head.enemy = world;
c = c + 1;
}
- setself(oldself);
}
}
head = head.chain;
// evaluate the next goal on the queue
float d = vlen(this.origin - bot_waypoint_queue_goal.origin);
LOG_DEBUG(strcat(this.netname, " evaluating ", bot_waypoint_queue_goal.classname, " with distance ", ftos(d), "\n"));
- entity oldself = self;
- setself(this); // tracewalk has questionable use of self
if(tracewalk(bot_waypoint_queue_goal, this.origin, STAT(PL_MIN, NULL), STAT(PL_MAX, NULL), bot_waypoint_queue_goal.origin, bot_navigation_movemode))
{
if( d > bot_waypoint_queue_bestgoalrating)
bot_waypoint_queue_bestgoal = bot_waypoint_queue_goal;
}
}
- setself(oldself);
bot_waypoint_queue_goal = bot_waypoint_queue_goal.bot_waypoint_queue_nextgoal;
if (!bot_waypoint_queue_goal)
bot_navigation_movemode = ((autocvar_bot_navigation_ignoreplayers) ? MOVE_NOMONSTERS : MOVE_NORMAL);
- //dprint("waypoint_think wpisbox = ", ftos(self.wpisbox), "\n");
- sm1 = self.origin + self.mins;
- sm2 = self.origin + self.maxs;
+ //dprint("waypoint_think wpisbox = ", ftos(this.wpisbox), "\n");
+ sm1 = this.origin + this.mins;
+ sm2 = this.origin + this.maxs;
for(e = world; (e = find(e, classname, "waypoint")); )
{
- if (boxesoverlap(self.absmin, self.absmax, e.absmin, e.absmax))
+ if (boxesoverlap(this.absmin, this.absmax, e.absmin, e.absmax))
{
- waypoint_addlink(self, e);
- waypoint_addlink(e, self);
+ waypoint_addlink(this, e);
+ waypoint_addlink(e, this);
}
else
{
++relink_total;
- if(!checkpvs(self.origin, e))
+ if(!checkpvs(this.origin, e))
{
++relink_pvsculled;
continue;
sv.x = bound(sm1_x, sv.x, sm2_x);
sv.y = bound(sm1_y, sv.y, sm2_y);
sv.z = bound(sm1_z, sv.z, sm2_z);
- ev = self.origin;
+ ev = this.origin;
em1 = e.origin + e.mins;
em2 = e.origin + e.maxs;
ev.x = bound(em1_x, ev.x, em2_x);
continue;
}
navigation_testtracewalk = 0;
- if (!self.wpisbox)
+ if (!this.wpisbox)
{
- tracebox(sv - STAT(PL_MIN, NULL).z * '0 0 1', STAT(PL_MIN, NULL), STAT(PL_MAX, NULL), sv, false, self);
+ tracebox(sv - STAT(PL_MIN, NULL).z * '0 0 1', STAT(PL_MIN, NULL), STAT(PL_MAX, NULL), sv, false, this);
if (!trace_startsolid)
{
//dprint("sv deviation", vtos(trace_endpos - sv), "\n");
ev = trace_endpos + '0 0 1';
}
}
- //traceline(self.origin, e.origin, false, world);
+ //traceline(this.origin, e.origin, false, world);
//if (trace_fraction == 1)
- if (!self.wpisbox && tracewalk(self, sv, STAT(PL_MIN, NULL), STAT(PL_MAX, NULL), ev, MOVE_NOMONSTERS))
- waypoint_addlink(self, e);
+ if (!this.wpisbox && tracewalk(this, sv, STAT(PL_MIN, NULL), STAT(PL_MAX, NULL), ev, MOVE_NOMONSTERS))
+ waypoint_addlink(this, e);
else
relink_walkculled += 0.5;
if (!e.wpisbox && tracewalk(e, ev, STAT(PL_MIN, NULL), STAT(PL_MAX, NULL), sv, MOVE_NOMONSTERS))
- waypoint_addlink(e, self);
+ waypoint_addlink(e, this);
else
relink_walkculled += 0.5;
}
}
navigation_testtracewalk = 0;
- self.wplinked = true;
+ this.wplinked = true;
}
void waypoint_clearlinks(entity wp)
IS_CHEAT(0, argc, 0);
setself(spawn());
self.target = argv(1);
- activator = this;
- SUB_UseTargets();
+ SUB_UseTargets(self, this, NULL);
remove(self);
setself(this);
DID_CHEAT();
IS_CHEAT(0, argc, 0);
setself(spawn());
self.killtarget = argv(1);
- activator = this;
- SUB_UseTargets();
+ SUB_UseTargets(self, this, NULL);
remove(self);
setself(this);
DID_CHEAT();
{
string s = spot.target;
spot.target = string_null;
- WITH(entity, activator, this, LAMBDA(
- WITHSELF(spot, SUB_UseTargets())
- ));
+ SUB_UseTargets(spot, this, NULL);
spot.target = s;
}
// generated file; do not modify
-#include "all.qc"
-#include "banning.qc"
-#include "cmd.qc"
-#include "common.qc"
-#include "getreplies.qc"
-#include "radarmap.qc"
-#include "sv_cmd.qc"
-#include "vote.qc"
+#include <server/command/all.qc>
+#include <server/command/banning.qc>
+#include <server/command/cmd.qc>
+#ifdef SVQC
+ #include <server/command/sv_cmd.qc>
+#endif
+#include <server/command/common.qc>
+#include <server/command/getreplies.qc>
+#include <server/command/radarmap.qc>
+#include <server/command/vote.qc>
--- /dev/null
+// generated file; do not modify
+#include <server/command/all.qh>
+#include <server/command/banning.qh>
+#include <server/command/cmd.qh>
+#include <server/command/common.qh>
+#include <server/command/getreplies.qh>
+#include <server/command/radarmap.qh>
+#include <server/command/vote.qh>
// declarations
vote_accept_count = vote_reject_count = vote_abstain_count = 0;
- float spectators_allowed = ((autocvar_sv_vote_nospectators != 2)
- || ((autocvar_sv_vote_nospectators == 1) && (warmup_stage || gameover))
- || (autocvar_sv_vote_nospectators == 0));
+ bool spectators_allowed = (!autocvar_sv_vote_nospectators || (autocvar_sv_vote_nospectators == 1 && (warmup_stage || gameover)));
float vote_player_count = 0, notvoters = 0;
float vote_real_player_count = 0, vote_real_accept_count = 0;
{
float p, q, check, minargs;
string cvarname = strcat("sv_vote_command_restriction_", argv(startpos));
- string cmdrestriction = cvar_string(cvarname); // note: this warns on undefined cvar. We want that.
+ string cmdrestriction = ""; // No we don't.
string charlist, arg;
float checkmate;
+ if(cvar_type(cvarname) & CVAR_TYPEFLAG_EXISTS)
+ cmdrestriction = cvar_string(cvarname);
+ else
+ LOG_INFO("NOTE: ", cvarname, " does not exist, no restrictions will be applied.\n");
+
if (cmdrestriction == "") return true;
++startpos; // skip command name
{
case CMD_REQUEST_COMMAND:
{
- float spectators_allowed = ((autocvar_sv_vote_nospectators != 2)
- || ((autocvar_sv_vote_nospectators == 1) && warmup_stage)
- || (autocvar_sv_vote_nospectators == 0));
+ bool spectators_allowed = (!autocvar_sv_vote_nospectators || (autocvar_sv_vote_nospectators == 1 && (warmup_stage || gameover)));
float tmp_playercount = 0;
default: // calling a vote for master
{
- float spectators_allowed = ((autocvar_sv_vote_nospectators != 2)
- || ((autocvar_sv_vote_nospectators == 1) && warmup_stage)
- || (autocvar_sv_vote_nospectators == 0));
+ bool spectators_allowed = (!autocvar_sv_vote_nospectators || (autocvar_sv_vote_nospectators == 1 && (warmup_stage || gameover)));
if (!autocvar_sv_vote_master_callable) { print_to(caller, "^1Vote to become vote master is not allowed."); }
else if (vote_called)
.entity ballcarried; // Also used for keepaway
float g_nexball_meter_period;
-void SUB_DontUseTargets();
-void SUB_UseTargets();
+void SUB_DontUseTargets(entity this, entity actor, entity trigger);
+void SUB_UseTargets(entity this, entity actor, entity trigger);
.void(entity this) reset; // if set, an entity is reset using this
.void() reset2; // if set, an entity is reset using this (after calling ALL the reset functions for other entities)
const float ACTIVE_BUSY = 2;
const float ACTIVE_TOGGLE = 3;
.float active;
-.void (float act_state) setactive;
+.void (entity this, int act_state) setactive;
.entity realowner;
//float serverflags;
return;
}
LogDeath("suicide", deathtype, targ, targ);
- GiveFrags(attacker, targ, -1, deathtype);
+ if(deathtype != DEATH_AUTOTEAMCHANGE.m_id) // special case: don't negate frags if auto switched
+ GiveFrags(attacker, targ, -1, deathtype);
}
// ======
setself(this);
// apply mirror damage if any
+ if(!autocvar_g_mirrordamage_onlyweapons || DEATH_WEAPONOF(deathtype) != WEP_Null)
if(mirrordamage > 0 || mirrorforce > 0)
{
attacker = attacker_save;
self.think = dynlight_think;
self.nextthink = time + 0.1;
}
-void dynlight_use()
+void dynlight_use(entity this, entity actor, entity trigger)
{
- SELFPARAM();
- if (self.light_lev == 0)
- self.light_lev = self.lefty;
+ if (this.light_lev == 0)
+ this.light_lev = this.lefty;
else
- self.light_lev = 0;
+ this.light_lev = 0;
}
spawnfunc(dynlight)
{
.float modelscale;
-void g_model_setcolormaptoactivator ()
-{SELFPARAM();
+void g_model_setcolormaptoactivator(entity this, entity actor, entity trigger)
+{
if(teamplay)
{
- if(activator.team)
- self.colormap = (activator.team - 1) * 0x11;
+ if(actor.team)
+ this.colormap = (actor.team - 1) * 0x11;
else
- self.colormap = 0x00;
+ this.colormap = 0x00;
}
else
- self.colormap = floor(random() * 256);
- self.colormap |= BIT(10); // RENDER_COLORMAPPED
+ this.colormap = floor(random() * 256);
+ this.colormap |= BIT(10); // RENDER_COLORMAPPED
}
-void g_clientmodel_setcolormaptoactivator ()
-{SELFPARAM();
- g_model_setcolormaptoactivator();
- self.SendFlags |= (BIT(3) | BIT(0));
+void g_clientmodel_setcolormaptoactivator(entity this, entity actor, entity trigger)
+{
+ g_model_setcolormaptoactivator(this, actor, trigger);
+ this.SendFlags |= (BIT(3) | BIT(0));
}
-void g_clientmodel_use()
-{SELFPARAM();
- if (self.antiwall_flag == 1)
+void g_clientmodel_use(entity this, entity actor, entity trigger)
+{
+ if (this.antiwall_flag == 1)
{
- self.inactive = 1;
- self.solid = SOLID_NOT;
+ this.inactive = 1;
+ this.solid = SOLID_NOT;
}
- else if (self.antiwall_flag == 2)
+ else if (this.antiwall_flag == 2)
{
- self.inactive = 0;
- self.solid = self.default_solid;
+ this.inactive = 0;
+ this.solid = this.default_solid;
}
- g_clientmodel_setcolormaptoactivator();
+ g_clientmodel_setcolormaptoactivator(this, actor, trigger);
}
void g_model_dropbyspawnflags(entity this)
void() SUB_CalcMoveDone;
void() SUB_CalcAngleMoveDone;
-//void() SUB_UseTargets;
spawnfunc(info_null);
string oldmsg = self.message;
self.message = "";
- activator = other;
- SUB_UseTargets();
+ SUB_UseTargets(self, other, other); // TODO: should we be using other for the trigger here?
self.message = oldmsg;
};
void adaptor_think2use()
{SELFPARAM();
- entity o, a;
- o = other;
- a = activator;
- activator = world;
- other = world;
- self.use();
- other = o;
- activator = a;
+ if(this.use)
+ this.use(this, NULL, NULL);
}
void adaptor_think2use_hittype_splash() // for timed projectile detonation
{SELFPARAM();
- if(!(IS_ONGROUND(self))) // if onground, we ARE touching something, but HITTYPE_SPLASH is to be networked if the damage causing projectile is not touching ANYTHING
- self.projectiledeathtype |= HITTYPE_SPLASH;
- adaptor_think2use();
+ if(!(IS_ONGROUND(this))) // if onground, we ARE touching something, but HITTYPE_SPLASH is to be networked if the damage causing projectile is not touching ANYTHING
+ this.projectiledeathtype |= HITTYPE_SPLASH;
+ WITHSELF(this, adaptor_think2use());
}
// deferred dropping
{
case "body":
case "droppedweapon":
- case "keepawayball":
- case "nexball_basketball":
- case "nexball_football":
return true;
case "bullet": // antilagged bullets can't hit this either
return false;
void WarpZone_traceline_antilag (entity source, vector v1, vector v2, float nomonst, entity forent, float lag);
+void adaptor_think2use();
+
#define IS_DEAD(s) ((s).deadflag != DEAD_NO)
// generated file; do not modify
-#include "all.qc"
+#include <server/mutators/all.qc>
--- /dev/null
+// generated file; do not modify
+#include <server/mutators/all.qh>
// generated file; do not modify
-#include "gamemode_assault.qc"
-#include "gamemode_ca.qc"
-#include "gamemode_ctf.qc"
-#include "gamemode_cts.qc"
-#include "gamemode_deathmatch.qc"
-#include "gamemode_domination.qc"
-#include "gamemode_freezetag.qc"
-#include "gamemode_invasion.qc"
-#include "gamemode_keepaway.qc"
-#include "gamemode_keyhunt.qc"
-#include "gamemode_lms.qc"
-#include "gamemode_race.qc"
-#include "gamemode_tdm.qc"
+#include <server/mutators/mutator/gamemode_assault.qc>
+#include <server/mutators/mutator/gamemode_ca.qc>
+#include <server/mutators/mutator/gamemode_ctf.qc>
+#include <server/mutators/mutator/gamemode_cts.qc>
+#include <server/mutators/mutator/gamemode_deathmatch.qc>
+#include <server/mutators/mutator/gamemode_domination.qc>
+#include <server/mutators/mutator/gamemode_freezetag.qc>
+#include <server/mutators/mutator/gamemode_invasion.qc>
+#include <server/mutators/mutator/gamemode_keepaway.qc>
+#include <server/mutators/mutator/gamemode_keyhunt.qc>
+#include <server/mutators/mutator/gamemode_lms.qc>
+#include <server/mutators/mutator/gamemode_race.qc>
+#include <server/mutators/mutator/gamemode_tdm.qc>
--- /dev/null
+// generated file; do not modify
+#include <server/mutators/mutator/gamemode_assault.qh>
+#include <server/mutators/mutator/gamemode_ca.qh>
+#include <server/mutators/mutator/gamemode_ctf.qh>
+#include <server/mutators/mutator/gamemode_cts.qh>
+#include <server/mutators/mutator/gamemode_deathmatch.qh>
+#include <server/mutators/mutator/gamemode_domination.qh>
+#include <server/mutators/mutator/gamemode_freezetag.qh>
+#include <server/mutators/mutator/gamemode_invasion.qh>
+#include <server/mutators/mutator/gamemode_keepaway.qh>
+#include <server/mutators/mutator/gamemode_keyhunt.qh>
+#include <server/mutators/mutator/gamemode_lms.qh>
+#include <server/mutators/mutator/gamemode_race.qh>
+#include <server/mutators/mutator/gamemode_tdm.qh>
const float SP_ASSAULT_OBJECTIVES = 4;
// predefined spawnfuncs
-void target_objective_decrease_activate();
+void target_objective_decrease_activate(entity this);
#endif
#ifdef IMPLEMENTATION
.entity sprite;
// random functions
-void assault_objective_use()
-{SELFPARAM();
+void assault_objective_use(entity this, entity actor, entity trigger)
+{
// activate objective
- self.health = 100;
- //print("^2Activated objective ", self.targetname, "=", etos(self), "\n");
- //print("Activator is ", activator.classname, "\n");
+ this.health = 100;
+ //print("^2Activated objective ", this.targetname, "=", etos(this), "\n");
+ //print("Activator is ", actor.classname, "\n");
for (entity e = world; (e = find(e, target, this.targetname)); )
{
if (e.classname == "target_objective_decrease")
{
- WITHSELF(e, target_objective_decrease_activate());
+ target_objective_decrease_activate(e);
}
}
-
- setself(this);
}
vector target_objective_spawn_evalfunc(entity player, entity spot, vector current)
}
// decrease the health of targeted objectives
-void assault_objective_decrease_use()
-{SELFPARAM();
- if(activator.team != assault_attacker_team)
+void assault_objective_decrease_use(entity this, entity actor, entity trigger)
+{
+ if(actor.team != assault_attacker_team)
{
// wrong team triggered decrease
return;
}
- if(other.assault_sprite)
+ if(trigger.assault_sprite)
{
- WaypointSprite_Disown(other.assault_sprite, waypointsprite_deadlifetime);
- if(other.classname == "func_assault_destructible")
- other.sprite = world;
+ WaypointSprite_Disown(trigger.assault_sprite, waypointsprite_deadlifetime);
+ if(trigger.classname == "func_assault_destructible")
+ trigger.sprite = world; // TODO: just unsetting it?!
}
else
return; // already activated! cannot activate again!
- if(self.enemy.health < ASSAULT_VALUE_INACTIVE)
+ if(this.enemy.health < ASSAULT_VALUE_INACTIVE)
{
- if(self.enemy.health - self.dmg > 0.5)
+ if(this.enemy.health - this.dmg > 0.5)
{
- PlayerTeamScore_Add(activator, SP_SCORE, ST_SCORE, self.dmg);
- self.enemy.health = self.enemy.health - self.dmg;
+ PlayerTeamScore_Add(actor, SP_SCORE, ST_SCORE, this.dmg);
+ this.enemy.health = this.enemy.health - this.dmg;
}
else
{
- PlayerTeamScore_Add(activator, SP_SCORE, ST_SCORE, self.enemy.health);
- PlayerTeamScore_Add(activator, SP_ASSAULT_OBJECTIVES, ST_ASSAULT_OBJECTIVES, 1);
- self.enemy.health = -1;
-
- entity oldactivator;
+ PlayerTeamScore_Add(actor, SP_SCORE, ST_SCORE, this.enemy.health);
+ PlayerTeamScore_Add(actor, SP_ASSAULT_OBJECTIVES, ST_ASSAULT_OBJECTIVES, 1);
+ this.enemy.health = -1;
- setself(this.enemy);
- if(self.message)
- FOREACH_CLIENT(IS_PLAYER(it), LAMBDA(centerprint(it, self.message)));
+ if(this.enemy.message)
+ FOREACH_CLIENT(IS_PLAYER(it), LAMBDA(centerprint(it, this.enemy.message)));
- oldactivator = activator;
- activator = this;
- SUB_UseTargets();
- activator = oldactivator;
- setself(this);
+ SUB_UseTargets(this.enemy, this, trigger);
}
}
}
void assault_setenemytoobjective(entity this)
{
entity objective;
- for(objective = world; (objective = find(objective, targetname, self.target)); )
+ for(objective = world; (objective = find(objective, targetname, this.target)); )
{
if(objective.classname == "target_objective")
{
- if(self.enemy == world)
- self.enemy = objective;
+ if(this.enemy == world)
+ this.enemy = objective;
else
objerror("more than one objective as target - fix the map!");
break;
}
}
- if(self.enemy == world)
+ if(this.enemy == world)
objerror("no objective as target - fix the map!");
}
return true;
}
-void target_objective_decrease_activate()
-{SELFPARAM();
+void target_objective_decrease_activate(entity this)
+{
entity ent, spr;
- self.owner = world;
- for(ent = world; (ent = find(ent, target, self.targetname)); )
+ this.owner = world;
+ for(ent = world; (ent = find(ent, target, this.targetname)); )
{
if(ent.assault_sprite != world)
{
WaypointSprite_Disown(ent.assault_sprite, waypointsprite_deadlifetime);
if(ent.classname == "func_assault_destructible")
- ent.sprite = world;
+ ent.sprite = world; // TODO: just unsetting it?!
}
spr = WaypointSprite_SpawnFixed(WP_Assault, 0.5 * (ent.absmin + ent.absmax), ent, assault_sprite, RADARICON_OBJECTIVE);
- spr.assault_decreaser = self;
+ spr.assault_decreaser = this;
spr.waypointsprite_visible_for_player = assault_decreaser_sprite_visible;
spr.classname = "sprite_waypoint";
WaypointSprite_UpdateRule(spr, assault_attacker_team, SPRITERULE_TEAMPLAY);
this.winning = false; // up round
}
-void target_assault_roundend_use()
-{SELFPARAM();
- self.winning = 1; // round has been won by attackers
+void target_assault_roundend_use(entity this, entity actor, entity trigger)
+{
+ this.winning = 1; // round has been won by attackers
}
-void assault_roundstart_use(entity this)
+void assault_roundstart_use(entity this, entity actor, entity trigger)
{
- activator = self;
- SUB_UseTargets();
+ SUB_UseTargets(this, this, trigger);
//(Re)spawn all turrets
FOREACH_ENTITY_CLASS("turret_main", true, LAMBDA(
WITHSELF(it, turret_respawn());
));
}
+void assault_roundstart_use_this(entity this)
+{
+ assault_roundstart_use(this, NULL, NULL);
+}
void assault_roundstart_use_self()
{
SELFPARAM();
- assault_roundstart_use(this);
+ assault_roundstart_use(this, NULL, NULL);
}
void assault_wall_think()
FOREACH_CLIENT(IS_PLAYER(it) && it.vehicle, WITHSELF(it, vehicles_exit(VHEF_RELEASE)));
FOREACH_ENTITY_FLAGS(vehicle_flags, VHF_ISVEHICLE, LAMBDA(
- setself(it);
- vehicles_clearreturn(self);
- vehicles_spawn();
+ vehicles_clearreturn(it);
+ WITHSELF(it, vehicles_spawn());
));
- setself(this);
-
// up round counter
self.winning = self.winning + 1;
// spawnfuncs
spawnfunc(info_player_attacker)
{
- if (!g_assault) { remove(self); return; }
+ if (!g_assault) { remove(this); return; }
- self.team = NUM_TEAM_1; // red, gets swapped every round
+ this.team = NUM_TEAM_1; // red, gets swapped every round
spawnfunc_info_player_deathmatch(this);
}
spawnfunc(info_player_defender)
{
- if (!g_assault) { remove(self); return; }
+ if (!g_assault) { remove(this); return; }
- self.team = NUM_TEAM_2; // blue, gets swapped every round
+ this.team = NUM_TEAM_2; // blue, gets swapped every round
spawnfunc_info_player_deathmatch(this);
}
spawnfunc(target_objective_decrease)
{
- if (!g_assault) { remove(self); return; }
+ if (!g_assault) { remove(this); return; }
- self.classname = "target_objective_decrease";
+ this.classname = "target_objective_decrease";
- if(!self.dmg)
- self.dmg = 101;
+ if(!this.dmg)
+ this.dmg = 101;
- self.use = assault_objective_decrease_use;
- self.health = ASSAULT_VALUE_INACTIVE;
- self.max_health = ASSAULT_VALUE_INACTIVE;
- self.enemy = world;
+ this.use = assault_objective_decrease_use;
+ this.health = ASSAULT_VALUE_INACTIVE;
+ this.max_health = ASSAULT_VALUE_INACTIVE;
+ this.enemy = world;
- InitializeEntity(self, target_objective_decrease_findtarget, INITPRIO_FINDTARGET);
+ InitializeEntity(this, target_objective_decrease_findtarget, INITPRIO_FINDTARGET);
}
// destructible walls that can be used to trigger target_objective_decrease
spawnfunc(func_breakable);
spawnfunc(func_assault_destructible)
{
- if (!g_assault) { remove(self); return; }
+ if (!g_assault) { remove(this); return; }
- self.spawnflags = 3;
- self.classname = "func_assault_destructible";
+ this.spawnflags = 3;
+ this.classname = "func_assault_destructible";
if(assault_attacker_team == NUM_TEAM_1)
- self.team = NUM_TEAM_2;
+ this.team = NUM_TEAM_2;
else
- self.team = NUM_TEAM_1;
+ this.team = NUM_TEAM_1;
spawnfunc_func_breakable(this);
}
spawnfunc(func_assault_wall)
{
- if (!g_assault) { remove(self); return; }
+ if (!g_assault) { remove(this); return; }
- self.classname = "func_assault_wall";
- self.mdl = self.model;
- _setmodel(self, self.mdl);
- self.solid = SOLID_BSP;
- self.think = assault_wall_think;
- self.nextthink = time;
- InitializeEntity(self, assault_setenemytoobjective, INITPRIO_FINDTARGET);
+ this.classname = "func_assault_wall";
+ this.mdl = this.model;
+ _setmodel(this, this.mdl);
+ this.solid = SOLID_BSP;
+ this.think = assault_wall_think;
+ this.nextthink = time;
+ InitializeEntity(this, assault_setenemytoobjective, INITPRIO_FINDTARGET);
}
spawnfunc(target_assault_roundend)
{
- if (!g_assault) { remove(self); return; }
+ if (!g_assault) { remove(this); return; }
- self.winning = 0; // round not yet won by attackers
- self.classname = "target_assault_roundend";
- self.use = target_assault_roundend_use;
- self.cnt = 0; // first round
- self.reset = target_assault_roundend_reset;
+ this.winning = 0; // round not yet won by attackers
+ this.classname = "target_assault_roundend";
+ this.use = target_assault_roundend_use;
+ this.cnt = 0; // first round
+ this.reset = target_assault_roundend_reset;
}
spawnfunc(target_assault_roundstart)
{
- if (!g_assault) { remove(self); return; }
+ if (!g_assault) { remove(this); return; }
assault_attacker_team = NUM_TEAM_1;
- self.classname = "target_assault_roundstart";
- self.use = assault_roundstart_use_self;
- self.reset2 = assault_roundstart_use_self;
- InitializeEntity(self, assault_roundstart_use, INITPRIO_FINDTARGET);
+ this.classname = "target_assault_roundstart";
+ this.use = assault_roundstart_use;
+ this.reset2 = assault_roundstart_use_self;
+ InitializeEntity(this, assault_roundstart_use_this, INITPRIO_FINDTARGET);
}
// legacy bot code
if (flag.capeffect == "") { flag.capeffect = EFFECT_CAP(teamnumber).eent_eff_name; }
// sounds
- flag.snd_flag_taken = strzone(SND(CTF_TAKEN(teamnumber)));
- flag.snd_flag_returned = strzone(SND(CTF_RETURNED(teamnumber)));
- flag.snd_flag_capture = strzone(SND(CTF_CAPTURE(teamnumber)));
- flag.snd_flag_dropped = strzone(SND(CTF_DROPPED(teamnumber)));
- if (flag.snd_flag_respawn == "") flag.snd_flag_respawn = strzone(SND(CTF_RESPAWN)); // if there is ever a team-based sound for this, update the code to match.
- precache_sound(flag.snd_flag_respawn);
- if (flag.snd_flag_touch == "") flag.snd_flag_touch = strzone(SND(CTF_TOUCH)); // again has no team-based sound
- precache_sound(flag.snd_flag_touch);
- if (flag.snd_flag_pass == "") flag.snd_flag_pass = strzone(SND(CTF_PASS)); // same story here
- precache_sound(flag.snd_flag_pass);
+#define X(s,b) \
+ if(flag.s == "") flag.s = b; \
+ precache_sound(flag.s);
+
+ X(snd_flag_taken, strzone(SND(CTF_TAKEN(teamnumber))))
+ X(snd_flag_returned, strzone(SND(CTF_RETURNED(teamnumber))))
+ X(snd_flag_capture, strzone(SND(CTF_CAPTURE(teamnumber))))
+ X(snd_flag_dropped, strzone(SND(CTF_DROPPED(teamnumber))))
+ X(snd_flag_respawn, strzone(SND(CTF_RESPAWN)))
+ X(snd_flag_touch, strzone(SND(CTF_TOUCH)))
+ X(snd_flag_pass, strzone(SND(CTF_PASS)))
+#undef X
// precache
precache_model(flag.model);
old_team = self.team;
self.team = real_team;
self.delay = 0;
- activator = self;
- SUB_UseTargets ();
+ SUB_UseTargets (self, self, NULL);
self.delay = old_delay;
self.team = old_team;
e.glow_color = autocvar_g_keepawayball_trail_color;
e.glow_trail = true;
e.flags = FL_ITEM;
+ e.pushable = true;
e.reset = ka_Reset;
e.touch = ka_TouchEvent;
e.owner = world;
// generated file; do not modify
-#include "costs.qc"
-#include "debug.qc"
-#include "expandnode.qc"
-#include "main.qc"
-#include "movenode.qc"
-#include "path_waypoint.qc"
-#include "utility.qc"
+#include <server/pathlib/costs.qc>
+#include <server/pathlib/debug.qc>
+#include <server/pathlib/expandnode.qc>
+#include <server/pathlib/main.qc>
+#include <server/pathlib/movenode.qc>
+#include <server/pathlib/path_waypoint.qc>
+#include <server/pathlib/utility.qc>
--- /dev/null
+// generated file; do not modify
+#include <server/pathlib/costs.qh>
+#include <server/pathlib/debug.qh>
+#include <server/pathlib/expandnode.qh>
+#include <server/pathlib/main.qh>
+#include <server/pathlib/movenode.qh>
+#include <server/pathlib/path_waypoint.qh>
+#include <server/pathlib/utility.qh>
#include <lib/_all.inc>
#include "_all.qh"
-#include "_mod.inc"
+#include "../server/_mod.inc"
#include "bot/_mod.inc"
#include "bot/havocbot/_mod.inc"
#include "command/_mod.inc"
*/
if (!((self.spawnflags & 2) && (IS_PLAYER(other))))
{
- activator = other;
oldmsg = self.message;
self.message = "";
- SUB_UseTargets();
+ SUB_UseTargets(self, other, other); // TODO: should we be using other for the trigger here?
self.message = oldmsg;
}
*/
if(self.spawnflags & 2)
{
- activator = other;
oldmsg = self.message;
self.message = "";
- SUB_UseTargets();
+ SUB_UseTargets(self, other, other); // TODO: should we be using other for the trigger here?
self.message = oldmsg;
}
checkpoint_passed();
}
-void checkpoint_use()
+void checkpoint_use(entity this, entity actor, entity trigger)
{
- if(other.classname == "info_player_deathmatch") // a spawn, a spawn
+ if(trigger.classname == "info_player_deathmatch") // a spawn, a spawn
return;
- other = activator;
+ other = actor;
checkpoint_passed();
}
}
}
-void penalty_use()
-{SELFPARAM();
- race_ImposePenaltyTime(activator, self.race_penalty, self.race_penalty_reason);
+void penalty_use(entity this, entity actor, entity trigger)
+{
+ race_ImposePenaltyTime(actor, this.race_penalty, this.race_penalty_reason);
}
spawnfunc(trigger_race_penalty)
}
}
-void spawnpoint_use()
-{SELFPARAM();
+void spawnpoint_use(entity this, entity actor, entity trigger)
+{
if(teamplay)
if(have_team_spawns > 0)
{
- self.team = activator.team;
+ this.team = actor.team;
some_spawn_has_been_used = 1;
}
//LOG_INFO("spawnpoint was used!\n");
entity Spawn_FilterOutBadSpots(entity firstspot, float mindist, float teamcheck);
entity SelectSpawnPoint (float anypoint);
spawnfunc(info_player_deathmatch);
-void spawnpoint_use();
+void spawnpoint_use(entity this, entity actor, entity trigger);
// generated file; do not modify
-#include "accuracy.qc"
-#include "common.qc"
-#include "csqcprojectile.qc"
-#include "hitplot.qc"
-#include "selection.qc"
-#include "spawning.qc"
-#include "throwing.qc"
-#include "tracing.qc"
-#include "weaponstats.qc"
-#include "weaponsystem.qc"
+#include <server/weapons/accuracy.qc>
+#include <server/weapons/common.qc>
+#include <server/weapons/csqcprojectile.qc>
+#include <server/weapons/hitplot.qc>
+#include <server/weapons/selection.qc>
+#include <server/weapons/spawning.qc>
+#include <server/weapons/throwing.qc>
+#include <server/weapons/tracing.qc>
+#include <server/weapons/weaponstats.qc>
+#include <server/weapons/weaponsystem.qc>
--- /dev/null
+// generated file; do not modify
+#include <server/weapons/accuracy.qh>
+#include <server/weapons/common.qh>
+#include <server/weapons/csqcprojectile.qh>
+#include <server/weapons/hitplot.qh>
+#include <server/weapons/selection.qh>
+#include <server/weapons/spawning.qh>
+#include <server/weapons/throwing.qh>
+#include <server/weapons/tracing.qh>
+#include <server/weapons/weaponstats.qh>
+#include <server/weapons/weaponsystem.qh>
return true; // if none of these return, then allow damage anyway.
}
-void W_PrepareExplosionByDamage(entity attacker, void() explode)
-{SELFPARAM();
- self.takedamage = DAMAGE_NO;
- self.event_damage = func_null;
+void W_PrepareExplosionByDamage(entity this, entity attacker, void() explode)
+{
+ this.takedamage = DAMAGE_NO;
+ this.event_damage = func_null;
if(IS_CLIENT(attacker) && !autocvar_g_projectiles_keep_owner)
{
- self.owner = attacker;
- self.realowner = attacker;
+ this.owner = attacker;
+ this.realowner = attacker;
}
- MUTATOR_CALLHOOK(PrepareExplosionByDamage, self, attacker);
+ MUTATOR_CALLHOOK(PrepareExplosionByDamage, this, attacker);
// do not explode NOW but in the NEXT FRAME!
// because recursive calls to RadiusDamage are not allowed
- self.nextthink = time;
- self.think = explode;
+ this.nextthink = time;
+ this.think = explode;
}
.float prevstrengthsoundattempt;
void W_PlayStrengthSound(entity player);
float W_CheckProjectileDamage(entity inflictor, entity projowner, int deathtype, float exception);
-void W_PrepareExplosionByDamage(entity attacker, void() explode);
+void W_PrepareExplosionByDamage(entity this, entity attacker, void() explode);
set -eu
cd "$(dirname "$0")"
cd ..
+ROOT=$PWD/
-MOD=_mod.inc
+MOD=_mod
function genmod() {
- echo '// generated file; do not modify' > ${MOD}
+ # use context to work around cmake issue #12619
+ CTX="${PWD#$ROOT}/"
+ echo '// generated file; do not modify' > ${MOD}.inc
+ echo '// generated file; do not modify' > ${MOD}.qh
for f in $(ls | sort -k 1,1 -t .); do
- if [[ "$f" == *.qc ]]; then echo "#include \"$f\"" >> ${MOD}; fi
+ if [[ "$f" == cl_* ]]; then if [[ -f "${f#cl_}" ]]; then continue; fi; fi
+ if [[ "$f" == sv_* ]]; then if [[ -f "${f#sv_}" ]]; then continue; fi; fi
+ if [[ "$f" == ui_* ]]; then if [[ -f "${f#ui_}" ]]; then continue; fi; fi
+ if [[ "$f" == *.qc ]]; then
+ echo "#include <${CTX}$f>" >> ${MOD}.inc
+ echo "#include <${CTX}${f%.qc}.qh>" >> ${MOD}.qh
+ if [[ -f "cl_$f" ]]; then echo -e "#ifdef CSQC\n #include <${CTX}cl_$f>\n#endif" >> ${MOD}.inc; fi
+ if [[ -f "sv_$f" ]]; then echo -e "#ifdef SVQC\n #include <${CTX}sv_$f>\n#endif" >> ${MOD}.inc; fi
+ if [[ -f "ui_$f" ]]; then echo -e "#ifdef MENUQC\n #include <${CTX}ui_$f>\n#endif" >> ${MOD}.inc; fi
+ fi
done
# echo >> ${MOD}
for f in *; do if [ -d "$f" ]; then
projects / xonotic / xonotic-data.pk3dir.git / commitdiff