{
if(self.move_flags & FL_ONGROUND)
{
- self.move_angles_x = 0;
+ self.move_angles.x = 0;
self.move_angles_z = 0;
self.flags &= ~FL_ONGROUND;
}
void Casing_Damage(float thisdmg, int hittype, vector org, vector thisforce)
{
if(thisforce.z < 0)
- thisforce_z = 0;
+ thisforce.z = 0;
self.move_velocity = self.move_velocity + thisforce + '0 0 100';
self.move_flags &= ~FL_ONGROUND;
}
w_issilent = (w_deathtype & 0x8000);
w_deathtype = (w_deathtype & 0x7FFF);
- w_org_x = ReadCoord();
- w_org_y = ReadCoord();
- w_org_z = ReadCoord();
+ w_org.x = ReadCoord();
+ w_org.y = ReadCoord();
+ w_org.z = ReadCoord();
dmg = ReadByte();
rad = ReadByte();
{
vector from, to;
- from_x = ReadCoord(); from_y = ReadCoord(); from_z = ReadCoord();
- to_x = ReadCoord(); to_y = ReadCoord(); to_z = ReadCoord();
+ from.x = ReadCoord(); from.y = ReadCoord(); from.z = ReadCoord();
+ to.x = ReadCoord(); to.y = ReadCoord(); to.z = ReadCoord();
if(autocvar_cl_effects_lightningarc_simple)
{
type = ReadByte(); // gibbage type
amount = ReadByte() / 16.0; // gibbage amount
- org_x = ReadShort() * 4 + 2;
- org_y = ReadShort() * 4 + 2;
- org_z = ReadShort() * 4 + 2;
+ org.x = ReadShort() * 4 + 2;
+ org.y = ReadShort() * 4 + 2;
+ org.z = ReadShort() * 4 + 2;
vel = decompressShortVector(ReadShort());
float cl_gentle_gibs = autocvar_cl_gentle_gibs;
drawpic(theOrigin, pic, theSize, theColor, theAlpha, 0);
return;
}
- if (theBorderSize_x == 0 && theBorderSize_y == 0) // no border
+ if (theBorderSize.x == 0 && theBorderSize.y == 0) // no border
{
// draw only the central part
drawsubpic(theOrigin, theSize, pic, '0.25 0.25 0', '0.5 0.5 0', theColor, theAlpha, 0);
float blinkingamt;
vector color;
if(x >= maxvalue) {
- color_x = sin(2*M_PI*time);
- color_y = 1;
- color_z = sin(2*M_PI*time);
+ color.x = sin(2*M_PI*time);
+ color.y = 1;
+ color.z = sin(2*M_PI*time);
}
else if(x > maxvalue * 0.75) {
- color_x = 0.4 - (x-150)*0.02 * 0.4; //red value between 0.4 -> 0
- color_y = 0.9 + (x-150)*0.02 * 0.1; // green value between 0.9 -> 1
- color_z = 0;
+ color.x = 0.4 - (x-150)*0.02 * 0.4; //red value between 0.4 -> 0
+ color.y = 0.9 + (x-150)*0.02 * 0.1; // green value between 0.9 -> 1
+ color.z = 0;
}
else if(x > maxvalue * 0.5) {
- color_x = 1 - (x-100)*0.02 * 0.6; //red value between 1 -> 0.4
- color_y = 1 - (x-100)*0.02 * 0.1; // green value between 1 -> 0.9
- color_z = 1 - (x-100)*0.02; // blue value between 1 -> 0
+ color.x = 1 - (x-100)*0.02 * 0.6; //red value between 1 -> 0.4
+ color.y = 1 - (x-100)*0.02 * 0.1; // green value between 1 -> 0.9
+ color.z = 1 - (x-100)*0.02; // blue value between 1 -> 0
}
else if(x > maxvalue * 0.25) {
- color_x = 1;
- color_y = 1;
- color_z = 0.2 + (x-50)*0.02 * 0.8; // blue value between 0.2 -> 1
+ color.x = 1;
+ color.y = 1;
+ color.z = 0.2 + (x-50)*0.02 * 0.8; // blue value between 0.2 -> 1
}
else if(x > maxvalue * 0.1) {
- color_x = 1;
- color_y = (x-20)*90/27/100; // green value between 0 -> 1
- color_z = (x-20)*90/27/100 * 0.2; // blue value between 0 -> 0.2
+ color.x = 1;
+ color.y = (x-20)*90/27/100; // green value between 0 -> 1
+ color.z = (x-20)*90/27/100 * 0.2; // blue value between 0 -> 0.2
}
else {
- color_x = 1;
- color_y = 0;
- color_z = 0;
+ color.x = 1;
+ color.y = 0;
+ color.z = 0;
}
blinkingamt = (1 - x/maxvalue/0.25);
if(blinkingamt > 0)
{
- color_x = color.x - color.x * blinkingamt * sin(2*M_PI*time);
- color_y = color.y - color.y * blinkingamt * sin(2*M_PI*time);
- color_z = color.z - color.z * blinkingamt * sin(2*M_PI*time);
+ color.x = color.x - color.x * blinkingamt * sin(2*M_PI*time);
+ color.y = color.y - color.y * blinkingamt * sin(2*M_PI*time);
+ color.z = color.z - color.z * blinkingamt * sin(2*M_PI*time);
}
return color;
}
void drawstringcenter(vector position, string text, vector theScale, vector rgb, float theAlpha, float flag)
{
- position_x = 0.5 * (vid_conwidth - 0.6025 * strlen(text) * theScale.x);
+ position.x = 0.5 * (vid_conwidth - 0.6025 * strlen(text) * theScale.x);
drawstring(position, text, theScale, rgb, theAlpha, flag);
}
columns = ceil(max_panel_size.x / (max_panel_size.y / rows * aspect));
}
- weapon_size_x = max_panel_size.x / columns;
- weapon_size_y = max_panel_size.y / rows;
+ weapon_size.x = max_panel_size.x / columns;
+ weapon_size.y = max_panel_size.y / rows;
columns = ceil(weapon_count / rows);
}
else
rows = ceil(max_panel_size.y / (max_panel_size.x / columns / aspect));
}
- weapon_size_x = max_panel_size.x / columns;
- weapon_size_y = max_panel_size.y / rows;
+ weapon_size.x = max_panel_size.x / columns;
+ weapon_size.y = max_panel_size.y / rows;
rows = ceil(weapon_count / columns);
}
// reduce size of the panel
- panel_size_x = columns * weapon_size.x;
- panel_size_y = rows * weapon_size.y;
+ panel_size.x = columns * weapon_size.x;
+ panel_size.y = rows * weapon_size.y;
panel_pos.x += (max_panel_size.x - panel_size.x) / 2;
panel_pos.y += (max_panel_size.y - panel_size.y) / 2;
if (autocvar_hud_panel_weapons_timeout_effect == 2 || autocvar_hud_panel_weapons_timeout_effect == 3)
{
f *= f; // for a cooler movement
- center_x = panel_pos.x + panel_size.x/2;
- center_y = panel_pos.y + panel_size.y/2;
+ center.x = panel_pos.x + panel_size.x/2;
+ center.y = panel_pos.y + panel_size.y/2;
screen_ar = vid_conwidth/vid_conheight;
if (center.x/center.y < screen_ar) //bottom left
{
panel_pos.y -= f * (panel_pos.y + panel_size.y);
}
if(f == 1)
- center_x = -1; // mark the panel as off screen
+ center.x = -1; // mark the panel as off screen
}
weaponprevtime = time - (1 - f) * timein_effect_length;
}
{
f *= f; // for a cooler movement
f = 1 - f;
- center_x = panel_pos.x + panel_size.x/2;
- center_y = panel_pos.y + panel_size.y/2;
+ center.x = panel_pos.x + panel_size.x/2;
+ center.y = panel_pos.y + panel_size.y/2;
screen_ar = vid_conwidth/vid_conheight;
if (center.x/center.y < screen_ar) //bottom left
{
// draw the background, then change the virtual size of it to better fit other items inside
HUD_Panel_DrawBg(1);
- if(center_x == -1)
+ if(center.x == -1)
{
draw_endBoldFont();
return;
if(weapon_size.x/weapon_size.y > aspect)
{
- barsize_x = aspect * weapon_size.y;
- barsize_y = weapon_size.y;
- baroffset_x = (weapon_size.x - barsize.x) / 2;
+ barsize.x = aspect * weapon_size.y;
+ barsize.y = weapon_size.y;
+ baroffset.x = (weapon_size.x - barsize.x) / 2;
}
else
{
- barsize_y = 1/aspect * weapon_size.x;
- barsize_x = weapon_size.x;
- baroffset_y = (weapon_size.y - barsize.y) / 2;
+ barsize.y = 1/aspect * weapon_size.x;
+ barsize.x = weapon_size.x;
+ baroffset.y = (weapon_size.y - barsize.y) / 2;
}
}
if(autocvar_hud_panel_weapons_accuracy)
if(ammo_size.x/ammo_size.y > 3)
{
newSize = 3 * ammo_size.y;
- offset_x = ammo_size.x - newSize;
+ offset.x = ammo_size.x - newSize;
pos.x += offset.x/2;
- ammo_size_x = newSize;
+ ammo_size.x = newSize;
}
else
{
newSize = 1/3 * ammo_size.x;
- offset_y = ammo_size.y - newSize;
+ offset.y = ammo_size.y - newSize;
pos.y += offset.y/2;
- ammo_size_y = newSize;
+ ammo_size.y = newSize;
}
float i;
{
if(mySize.y/mySize.x > 2)
{
- newSize_y = 2 * mySize.x;
- newSize_x = mySize.x;
+ newSize.y = 2 * mySize.x;
+ newSize.x = mySize.x;
- newPos_y = myPos.y + (mySize.y - newSize.y) / 2;
- newPos_x = myPos.x;
+ newPos.y = myPos.y + (mySize.y - newSize.y) / 2;
+ newPos.x = myPos.x;
}
else
{
- newSize_x = 1/2 * mySize.y;
- newSize_y = mySize.y;
+ newSize.x = 1/2 * mySize.y;
+ newSize.y = mySize.y;
- newPos_x = myPos.x + (mySize.x - newSize.x) / 2;
- newPos_y = myPos.y;
+ newPos.x = myPos.x + (mySize.x - newSize.x) / 2;
+ newPos.y = myPos.y;
}
if(icon_right_align)
if(mySize.x/mySize.y > 3)
{
- newSize_x = 3 * mySize.y;
- newSize_y = mySize.y;
+ newSize.x = 3 * mySize.y;
+ newSize.y = mySize.y;
- newPos_x = myPos.x + (mySize.x - newSize.x) / 2;
- newPos_y = myPos.y;
+ newPos.x = myPos.x + (mySize.x - newSize.x) / 2;
+ newPos.y = myPos.y;
}
else
{
- newSize_y = 1/3 * mySize.x;
- newSize_x = mySize.x;
+ newSize.y = 1/3 * mySize.x;
+ newSize.x = mySize.x;
- newPos_y = myPos.y + (mySize.y - newSize.y) / 2;
- newPos_x = myPos.x;
+ newPos.y = myPos.y + (mySize.y - newSize.y) / 2;
+ newPos.x = myPos.x;
}
if(icon_right_align) // right align
if (panel_ar >= 4 || (panel_ar >= 1/4 && panel_ar < 1))
{
mySize.x *= (1.0 / 3.0);
- superweapons_offset_x = mySize.x;
+ superweapons_offset.x = mySize.x;
if (autocvar_hud_panel_powerups_flip)
- shield_offset_x = 2*mySize.x;
+ shield_offset.x = 2*mySize.x;
else
- strength_offset_x = 2*mySize.x;
+ strength_offset.x = 2*mySize.x;
}
else
{
mySize.y *= (1.0 / 3.0);
- superweapons_offset_y = mySize.y;
+ superweapons_offset.y = mySize.y;
if (autocvar_hud_panel_powerups_flip)
- shield_offset_y = 2*mySize.y;
+ shield_offset.y = 2*mySize.y;
else
- strength_offset_y = 2*mySize.y;
+ strength_offset.y = 2*mySize.y;
}
}
else
{
mySize.x *= 0.5;
if (autocvar_hud_panel_powerups_flip)
- shield_offset_x = mySize.x;
+ shield_offset.x = mySize.x;
else
- strength_offset_x = mySize.x;
+ strength_offset.x = mySize.x;
}
else
{
mySize.y *= 0.5;
if (autocvar_hud_panel_powerups_flip)
- shield_offset_y = mySize.y;
+ shield_offset.y = mySize.y;
else
- strength_offset_y = mySize.y;
+ strength_offset.y = mySize.y;
}
}
{
mySize.x *= 0.5;
if (autocvar_hud_panel_healtharmor_flip)
- health_offset_x = mySize.x;
+ health_offset.x = mySize.x;
else
- armor_offset_x = mySize.x;
+ armor_offset.x = mySize.x;
}
else
{
mySize.y *= 0.5;
if (autocvar_hud_panel_healtharmor_flip)
- health_offset_y = mySize.y;
+ health_offset.y = mySize.y;
else
- armor_offset_y = mySize.y;
+ armor_offset.y = mySize.y;
}
float health_baralign, armor_baralign, fuel_baralign;
if (hud_panel_radar_maximized && !autocvar__hud_configure)
{
panel_size = autocvar_hud_panel_radar_maximized_size;
- panel_size_x = bound(0.2, panel_size.x, 1) * vid_conwidth;
- panel_size_y = bound(0.2, panel_size.y, 1) * vid_conheight;
- panel_pos_x = (vid_conwidth - panel_size.x) / 2;
- panel_pos_y = (vid_conheight - panel_size.y) / 2;
+ panel_size.x = bound(0.2, panel_size.x, 1) * vid_conwidth;
+ panel_size.y = bound(0.2, panel_size.y, 1) * vid_conheight;
+ panel_pos.x = (vid_conwidth - panel_size.x) / 2;
+ panel_pos.y = (vid_conheight - panel_size.y) / 2;
string panel_bg;
panel_bg = strcat(hud_skin_path, "/border_default"); // always use the default border when maximized
c2 = rotate('1 0 0' * mi_min.x + '0 1 0' * mi_max.y, teamradar_angle * DEG2RAD);
c3 = rotate('1 0 0' * mi_max.x + '0 1 0' * mi_min.y, teamradar_angle * DEG2RAD);
span = '0 0 0';
- span_x = max(c0_x, c1_x, c2_x, c3_x) - min(c0_x, c1_x, c2_x, c3_x);
- span_y = max(c0_y, c1_y, c2_y, c3_y) - min(c0_y, c1_y, c2_y, c3_y);
+ span.x = max(c0_x, c1_x, c2_x, c3_x) - min(c0_x, c1_x, c2_x, c3_x);
+ span.y = max(c0_y, c1_y, c2_y, c3_y) - min(c0_y, c1_y, c2_y, c3_y);
// max-min distance must fit the radar in x=x, y=y
bigsize = min(
if(score_size.x/score_size.y > 3)
{
newSize = 3 * score_size.y;
- offset_x = score_size.x - newSize;
+ offset.x = score_size.x - newSize;
pos.x += offset.x/2;
- score_size_x = newSize;
+ score_size.x = newSize;
}
else
{
newSize = 1/3 * score_size.x;
- offset_y = score_size.y - newSize;
+ offset.y = score_size.y - newSize;
pos.y += offset.y/2;
- score_size_y = newSize;
+ score_size.y = newSize;
}
}
else
vector newSize = '0 0 0';
if(mySize.x/mySize.y > 4)
{
- newSize_x = 4 * mySize.y;
- newSize_y = mySize.y;
+ newSize.x = 4 * mySize.y;
+ newSize.y = mySize.y;
- pos_x = pos.x + (mySize.x - newSize.x) / 2;
+ pos.x = pos.x + (mySize.x - newSize.x) / 2;
}
else
{
- newSize_y = 1/4 * mySize.x;
- newSize_x = mySize.x;
+ newSize.y = 1/4 * mySize.x;
+ newSize.x = mySize.x;
- pos_y = pos.y + (mySize.y - newSize.y) / 2;
+ pos.y = pos.y + (mySize.y - newSize.y) / 2;
}
mySize = newSize;
vector newSize = '0 0 0';
if(mySize.x/mySize.y > 3)
{
- newSize_x = 3 * mySize.y;
- newSize_y = mySize.y;
+ newSize.x = 3 * mySize.y;
+ newSize.y = mySize.y;
- pos_x = pos.x + (mySize.x - newSize.x) / 2;
+ pos.x = pos.x + (mySize.x - newSize.x) / 2;
}
else
{
- newSize_y = 1/3 * mySize.x;
- newSize_x = mySize.x;
+ newSize.y = 1/3 * mySize.x;
+ newSize.x = mySize.x;
- pos_y = pos.y + (mySize.y - newSize.y) / 2;
+ pos.y = pos.y + (mySize.y - newSize.y) / 2;
}
mySize = newSize;
if(mySize.x/mySize.y > aspect_ratio)
{
i = aspect_ratio * mySize.y;
- myPos_x = myPos.x + (mySize.x - i) / 2;
- mySize_x = i;
+ myPos.x = myPos.x + (mySize.x - i) / 2;
+ mySize.x = i;
}
else
{
i = 1/aspect_ratio * mySize.x;
- myPos_y = myPos.y + (mySize.y - i) / 2;
- mySize_y = i;
+ myPos.y = myPos.y + (mySize.y - i) / 2;
+ mySize.y = i;
}
if(layout)
if(mySize.x/mySize.y > aspect_ratio)
{
i = aspect_ratio * mySize.y;
- myPos_x = myPos.x + (mySize.x - i) / 2;
- mySize_x = i;
+ myPos.x = myPos.x + (mySize.x - i) / 2;
+ mySize.x = i;
}
else
{
i = 1/aspect_ratio * mySize.x;
- myPos_y = myPos.y + (mySize.y - i) / 2;
- mySize_y = i;
+ myPos.y = myPos.y + (mySize.y - i) / 2;
+ mySize.y = i;
}
if (layout) // show text too
vector newSize = '0 0 0';
if(mySize.x/mySize.y > aspect)
{
- newSize_x = aspect * mySize.y;
- newSize_y = mySize.y;
+ newSize.x = aspect * mySize.y;
+ newSize.y = mySize.y;
- pos_x = pos.x + (mySize.x - newSize.x) / 2;
+ pos.x = pos.x + (mySize.x - newSize.x) / 2;
}
else
{
- newSize_y = 1/aspect * mySize.x;
- newSize_x = mySize.x;
+ newSize.y = 1/aspect * mySize.x;
+ newSize.x = mySize.x;
- pos_y = pos.y + (mySize.y - newSize.y) / 2;
+ pos.y = pos.y + (mySize.y - newSize.y) / 2;
}
mySize = newSize;
}
if(autocvar__con_chat_maximized && !autocvar__hud_configure) // draw at full screen height if maximized
{
- panel_pos_y = panel_bg_border;
- panel_size_y = vid_conheight - panel_bg_border * 2;
+ panel_pos.y = panel_bg_border;
+ panel_size.y = vid_conheight - panel_bg_border * 2;
if(panel.current_panel_bg == "0") // force a border when maximized
{
string panel_bg;
//
#define drawInfoMessage(s) do { \
if(autocvar_hud_panel_infomessages_flip) \
- o_x = pos.x + mySize.x - stringwidth(s, true, fontsize); \
+ o.x = pos.x + mySize.x - stringwidth(s, true, fontsize); \
drawcolorcodedstring(o, s, fontsize, a, DRAWFLAG_NORMAL); \
o.y += fontsize.y; \
} while(0)
vector newSize = '0 0 0';
if(mySize.x/mySize.y > 5)
{
- newSize_x = 5 * mySize.y;
- newSize_y = mySize.y;
+ newSize.x = 5 * mySize.y;
+ newSize.y = mySize.y;
- pos_x = pos.x + (mySize.x - newSize.x) / 2;
+ pos.x = pos.x + (mySize.x - newSize.x) / 2;
}
else
{
- newSize_y = 1/5 * mySize.x;
- newSize_x = mySize.x;
+ newSize.y = 1/5 * mySize.x;
+ newSize.x = mySize.x;
- pos_y = pos.y + (mySize.y - newSize.y) / 2;
+ pos.y = pos.y + (mySize.y - newSize.y) / 2;
}
mySize = newSize;
{
panel_size.x *= 0.5;
if (autocvar_hud_panel_physics_flip)
- speed_offset_x = panel_size.x;
+ speed_offset.x = panel_size.x;
else
- acceleration_offset_x = panel_size.x;
+ acceleration_offset.x = panel_size.x;
}
else
{
panel_size.y *= 0.5;
if (autocvar_hud_panel_physics_flip)
- speed_offset_y = panel_size.y;
+ speed_offset.y = panel_size.y;
else
- acceleration_offset_y = panel_size.y;
+ acceleration_offset.y = panel_size.y;
}
float speed_baralign, acceleration_baralign;
if (autocvar_hud_panel_physics_baralign == 1)
vector tmp_offset = '0 0 0', tmp_size = '0 0 0';
if (autocvar_hud_panel_physics_text == 1 || autocvar_hud_panel_physics_text == 2)
{
- tmp_size_x = panel_size.x * 0.75;
- tmp_size_y = panel_size.y * text_scale;
+ tmp_size.x = panel_size.x * 0.75;
+ tmp_size.y = panel_size.y * text_scale;
if (speed_baralign)
- tmp_offset_x = panel_size.x - tmp_size.x;
+ tmp_offset.x = panel_size.x - tmp_size.x;
//else
//tmp_offset_x = 0;
- tmp_offset_y = (panel_size.y - tmp_size.y) / 2;
+ tmp_offset.y = (panel_size.y - tmp_size.y) / 2;
drawstring_aspect(panel_pos + speed_offset + tmp_offset, ftos(speed), tmp_size, '1 1 1', panel_fg_alpha, DRAWFLAG_NORMAL);
//draw speed unit
if (speed_baralign)
- tmp_offset_x = 0;
+ tmp_offset.x = 0;
else
- tmp_offset_x = tmp_size.x;
+ tmp_offset.x = tmp_size.x;
if (autocvar_hud_panel_physics_speed_unit_show)
{
//tmp_offset_y = 0;
- tmp_size_x = panel_size.x * (1 - 0.75);
- tmp_size_y = panel_size.y * 0.4 * text_scale;
- tmp_offset_y = (panel_size.y * 0.4 - tmp_size.y) / 2;
+ tmp_size.x = panel_size.x * (1 - 0.75);
+ tmp_size.y = panel_size.y * 0.4 * text_scale;
+ tmp_offset.y = (panel_size.y * 0.4 - tmp_size.y) / 2;
drawstring_aspect(panel_pos + speed_offset + tmp_offset, unit, tmp_size, '1 1 1', panel_fg_alpha, DRAWFLAG_NORMAL);
}
}
peak_offsetX = (1 - min(top_speed, max_speed)/max_speed) * panel_size.x;
else // if (speed_baralign == 2)
peak_offsetX = min(top_speed, max_speed)/max_speed * panel_size.x * 0.5;
- peak_size_x = floor(panel_size.x * 0.01 + 1.5);
- peak_size_y = panel_size.y;
+ peak_size.x = floor(panel_size.x * 0.01 + 1.5);
+ peak_size.y = panel_size.y;
if (speed_baralign == 2) // draw two peaks, on both sides
{
drawfill(panel_pos + speed_offset + eX * (0.5 * panel_size.x + peak_offsetX - peak_size.x), peak_size, autocvar_hud_progressbar_speed_color, f * autocvar_hud_progressbar_alpha * panel_fg_alpha, DRAWFLAG_NORMAL);
}
//top speed
- tmp_offset_y = panel_size.y * 0.4;
- tmp_size_x = panel_size.x * (1 - 0.75);
- tmp_size_y = (panel_size.y - tmp_offset.y) * text_scale;
+ tmp_offset.y = panel_size.y * 0.4;
+ tmp_size.x = panel_size.x * (1 - 0.75);
+ tmp_size.y = (panel_size.y - tmp_offset.y) * text_scale;
tmp_offset.y += (panel_size.y - tmp_offset.y - tmp_size.y) / 2;
drawstring_aspect(panel_pos + speed_offset + tmp_offset, ftos(top_speed), tmp_size, '1 0 0', f * panel_fg_alpha, DRAWFLAG_NORMAL);
}
tmp_size = acceleration_progressbar_scale * panel_size.x * eX + panel_size.y * eY;
if (acceleration_baralign == 1)
- tmp_offset_x = panel_size.x - tmp_size.x;
+ tmp_offset.x = panel_size.x - tmp_size.x;
else if (acceleration_baralign == 2 || acceleration_baralign == 3)
- tmp_offset_x = (panel_size.x - tmp_size.x) / 2;
+ tmp_offset.x = (panel_size.x - tmp_size.x) / 2;
else
- tmp_offset_x = 0;
- tmp_offset_y = 0;
+ tmp_offset.x = 0;
+ tmp_offset.y = 0;
}
else
{
HUD_Panel_DrawProgressBar(panel_pos + acceleration_offset + tmp_offset, tmp_size, "accelbar", f, 0, acceleration_baralign, progressbar_color, autocvar_hud_progressbar_alpha * panel_fg_alpha, DRAWFLAG_NORMAL);
}
- tmp_size_x = panel_size.x;
- tmp_size_y = panel_size.y * text_scale;
- tmp_offset_x = 0;
- tmp_offset_y = (panel_size.y - tmp_size.y) / 2;
+ tmp_size.x = panel_size.x;
+ tmp_size.y = panel_size.y * text_scale;
+ tmp_offset.x = 0;
+ tmp_offset.y = (panel_size.y - tmp_size.y) / 2;
if (autocvar_hud_panel_physics_text == 1 || autocvar_hud_panel_physics_text == 3)
drawstring_aspect(panel_pos + acceleration_offset + tmp_offset, strcat(ftos_decimals(acceleration, 2), "g"), tmp_size, '1 1 1', panel_fg_alpha, DRAWFLAG_NORMAL);
if(target_pos.y > panel_pos.y)
{
panel_pos = panel_pos + (target_pos - panel_pos) * sqrt(scoreboard_fade_alpha);
- panel_size_y = min(panel_size.y, vid_conheight - scoreboard_bottom);
+ panel_size.y = min(panel_size.y, vid_conheight - scoreboard_bottom);
}
}
if (ts != "")
{
if (align)
- pos_x = panel_pos.x + (panel_size.x - stringwidth(ts, true, fontsize)) * align;
+ pos.x = panel_pos.x + (panel_size.x - stringwidth(ts, true, fontsize)) * align;
if (a > 0.5/255.0) // Otherwise guaranteed invisible - don't show. This is checked a second time after some multiplications with other factors were done so temporary changes of these cannot cause flicker.
drawcolorcodedstring(pos + eY * 0.5 * (1 - sz) * fontsize.y, ts, fontsize, a, DRAWFLAG_NORMAL);
pos.y += fontsize.y;
msg_size = pos.y - msg_size;
if (autocvar_hud_panel_centerprint_flip)
{
- pos_y = current_msg_posY - CENTERPRINT_SPACING * fontsize.y;
+ pos.y = current_msg_posY - CENTERPRINT_SPACING * fontsize.y;
if (a < 1 && centerprint_msgID[j] == 0) // messages with id can be replaced just after they are faded out, so never move over them the next messages
pos.y += (msg_size + CENTERPRINT_SPACING * fontsize.y) * (1 - sqrt(sz));
// OK, there IS a collision.
- myCenter_x = myPos.x + 0.5 * mySize.x;
- myCenter_y = myPos.y + 0.5 * mySize.y;
+ myCenter.x = myPos.x + 0.5 * mySize.x;
+ myCenter.y = myPos.y + 0.5 * mySize.y;
- targCenter_x = panel_pos.x + 0.5 * panel_size.x;
- targCenter_y = panel_pos.y + 0.5 * panel_size.y;
+ targCenter.x = panel_pos.x + 0.5 * panel_size.x;
+ targCenter.y = panel_pos.y + 0.5 * panel_size.y;
if(myCenter.x < targCenter.x && myCenter.y < targCenter.y) // top left (of the target panel)
{
if(myPos.x + mySize.x - panel_pos.x < myPos.y + mySize.y - panel_pos.y) // push it to the side
- myTarget_x = panel_pos.x - mySize.x;
+ myTarget.x = panel_pos.x - mySize.x;
else // push it upwards
- myTarget_y = panel_pos.y - mySize.y;
+ myTarget.y = panel_pos.y - mySize.y;
}
else if(myCenter.x > targCenter.x && myCenter.y < targCenter.y) // top right
{
if(panel_pos.x + panel_size.x - myPos.x < myPos.y + mySize.y - panel_pos.y) // push it to the side
- myTarget_x = panel_pos.x + panel_size.x;
+ myTarget.x = panel_pos.x + panel_size.x;
else // push it upwards
- myTarget_y = panel_pos.y - mySize.y;
+ myTarget.y = panel_pos.y - mySize.y;
}
else if(myCenter.x < targCenter.x && myCenter.y > targCenter.y) // bottom left
{
if(myPos.x + mySize.x - panel_pos.x < panel_pos.y + panel_size.y - myPos.y) // push it to the side
- myTarget_x = panel_pos.x - mySize.x;
+ myTarget.x = panel_pos.x - mySize.x;
else // push it downwards
- myTarget_y = panel_pos.y + panel_size.y;
+ myTarget.y = panel_pos.y + panel_size.y;
}
else if(myCenter.x > targCenter.x && myCenter.y > targCenter.y) // bottom right
{
if(panel_pos.x + panel_size.x - myPos.x < panel_pos.y + panel_size.y - myPos.y) // push it to the side
- myTarget_x = panel_pos.x + panel_size.x;
+ myTarget.x = panel_pos.x + panel_size.x;
else // push it downwards
- myTarget_y = panel_pos.y + panel_size.y;
+ myTarget.y = panel_pos.y + panel_size.y;
}
//if(cvar("hud_configure_checkcollisions_debug"))
//drawfill(panel_pos, panel_size, '1 1 0', .3, DRAWFLAG_NORMAL);
if(autocvar_hud_configure_grid)
{
- pos_x = floor((pos.x/vid_conwidth)/hud_configure_gridSize.x + 0.5) * hud_configure_realGridSize.x;
- pos_y = floor((pos.y/vid_conheight)/hud_configure_gridSize.y + 0.5) * hud_configure_realGridSize.y;
+ pos.x = floor((pos.x/vid_conwidth)/hud_configure_gridSize.x + 0.5) * hud_configure_realGridSize.x;
+ pos.y = floor((pos.y/vid_conheight)/hud_configure_gridSize.y + 0.5) * hud_configure_realGridSize.y;
}
if(hud_configure_checkcollisions)
pos = HUD_Panel_CheckMove(pos, mySize);
- pos_x = bound(0, pos.x, vid_conwidth - mySize.x);
- pos_y = bound(0, pos.y, vid_conheight - mySize.y);
+ pos.x = bound(0, pos.x, vid_conwidth - mySize.x);
+ pos.y = bound(0, pos.y, vid_conheight - mySize.y);
string s;
s = strcat(ftos(pos.x/vid_conwidth), " ", ftos(pos.y/vid_conheight));
//
// dist is the distance between resizeorigin and the "analogous" point of the panel
// in this case between resizeorigin (bottom-right point) and the bottom-right point of the panel
- dist_x = resizeorigin.x - targEndPos.x;
- dist_y = resizeorigin.y - targEndPos.y;
+ dist.x = resizeorigin.x - targEndPos.x;
+ dist.y = resizeorigin.y - targEndPos.y;
if (dist.y <= 0 || dist.x / dist.y > ratio)
- mySize_x = min(mySize.x, dist.x);
+ mySize.x = min(mySize.x, dist.x);
else
- mySize_y = min(mySize.y, dist.y);
+ mySize.y = min(mySize.y, dist.y);
}
else if (resizeCorner == 2)
{
if (targEndPos.y <= resizeorigin.y - mySize.y)
continue;
- dist_x = panel_pos.x - resizeorigin.x;
- dist_y = resizeorigin.y - targEndPos.y;
+ dist.x = panel_pos.x - resizeorigin.x;
+ dist.y = resizeorigin.y - targEndPos.y;
if (dist.y <= 0 || dist.x / dist.y > ratio)
- mySize_x = min(mySize.x, dist.x);
+ mySize.x = min(mySize.x, dist.x);
else
- mySize_y = min(mySize.y, dist.y);
+ mySize.y = min(mySize.y, dist.y);
}
else if (resizeCorner == 3)
{
if (panel_pos.y >= resizeorigin.y + mySize.y)
continue;
- dist_x = resizeorigin.x - targEndPos.x;
- dist_y = panel_pos.y - resizeorigin.y;
+ dist.x = resizeorigin.x - targEndPos.x;
+ dist.y = panel_pos.y - resizeorigin.y;
if (dist.y <= 0 || dist.x / dist.y > ratio)
- mySize_x = min(mySize.x, dist.x);
+ mySize.x = min(mySize.x, dist.x);
else
- mySize_y = min(mySize.y, dist.y);
+ mySize.y = min(mySize.y, dist.y);
}
else if (resizeCorner == 4)
{
if (panel_pos.y >= resizeorigin.y + mySize.y)
continue;
- dist_x = panel_pos.x - resizeorigin.x;
- dist_y = panel_pos.y - resizeorigin.y;
+ dist.x = panel_pos.x - resizeorigin.x;
+ dist.y = panel_pos.y - resizeorigin.y;
if (dist.y <= 0 || dist.x / dist.y > ratio)
- mySize_x = min(mySize.x, dist.x);
+ mySize.x = min(mySize.x, dist.x);
else
- mySize_y = min(mySize.y, dist.y);
+ mySize.y = min(mySize.y, dist.y);
}
//if(cvar("hud_configure_checkcollisions_debug"))
//drawfill(panel_pos, panel_size, '1 1 0', .3, DRAWFLAG_NORMAL);
vector myPos;
// minimum panel size cap
- mySize_x = max(0.025 * vid_conwidth, mySize.x);
- mySize_y = max(0.025 * vid_conheight, mySize.y);
+ mySize.x = max(0.025 * vid_conwidth, mySize.x);
+ mySize.y = max(0.025 * vid_conheight, mySize.y);
if(highlightedPanel == HUD_PANEL(CHAT)) // some panels have their own restrictions, like the chat panel (which actually only moves the engine chat print around). Looks bad if it's too small.
{
- mySize_x = max(17 * autocvar_con_chatsize, mySize.x);
- mySize_y = max(2 * autocvar_con_chatsize + 2 * panel_bg_padding, mySize.y);
+ mySize.x = max(17 * autocvar_con_chatsize, mySize.x);
+ mySize.y = max(2 * autocvar_con_chatsize + 2 * panel_bg_padding, mySize.y);
}
// collision testing|
// we need to know pos at this stage, but it might still change later if we hit a screen edge/other panel (?)
if(resizeCorner == 1) {
- myPos_x = resizeorigin.x - mySize.x;
- myPos_y = resizeorigin.y - mySize.y;
+ myPos.x = resizeorigin.x - mySize.x;
+ myPos.y = resizeorigin.y - mySize.y;
} else if(resizeCorner == 2) {
- myPos_x = resizeorigin.x;
- myPos_y = resizeorigin.y - mySize.y;
+ myPos.x = resizeorigin.x;
+ myPos.y = resizeorigin.y - mySize.y;
} else if(resizeCorner == 3) {
- myPos_x = resizeorigin.x - mySize.x;
- myPos_y = resizeorigin.y;
+ myPos.x = resizeorigin.x - mySize.x;
+ myPos.y = resizeorigin.y;
} else { // resizeCorner == 4
- myPos_x = resizeorigin.x;
- myPos_y = resizeorigin.y;
+ myPos.x = resizeorigin.x;
+ myPos.y = resizeorigin.y;
}
// left/top screen edges
if(myPos.x < 0)
- mySize_x = mySize.x + myPos.x;
+ mySize.x = mySize.x + myPos.x;
if(myPos.y < 0)
- mySize_y = mySize.y + myPos.y;
+ mySize.y = mySize.y + myPos.y;
// bottom/right screen edges
if(myPos.x + mySize.x > vid_conwidth)
- mySize_x = vid_conwidth - myPos.x;
+ mySize.x = vid_conwidth - myPos.x;
if(myPos.y + mySize.y > vid_conheight)
- mySize_y = vid_conheight - myPos.y;
+ mySize.y = vid_conheight - myPos.y;
//if(cvar("hud_configure_checkcollisions_debug"))
//drawfill(myPos, mySize, '1 1 1', .2, DRAWFLAG_NORMAL);
// before checkresize, otherwise panel can be snapped partially inside another panel or panel aspect ratio can be broken
if(autocvar_hud_configure_grid)
{
- mySize_x = floor((mySize.x/vid_conwidth)/hud_configure_gridSize.x + 0.5) * hud_configure_realGridSize.x;
- mySize_y = floor((mySize.y/vid_conheight)/hud_configure_gridSize.y + 0.5) * hud_configure_realGridSize.y;
+ mySize.x = floor((mySize.x/vid_conwidth)/hud_configure_gridSize.x + 0.5) * hud_configure_realGridSize.x;
+ mySize.y = floor((mySize.y/vid_conheight)/hud_configure_gridSize.y + 0.5) * hud_configure_realGridSize.y;
}
if(hud_configure_checkcollisions)
mySize = HUD_Panel_CheckResize(mySize, resizeorigin);
// minimum panel size cap, do this once more so we NEVER EVER EVER have a panel smaller than this, JUST IN CASE above code still makes the panel eg negative (impossible to resize back without changing cvars manually then)
- mySize_x = max(0.025 * vid_conwidth, mySize.x);
- mySize_y = max(0.025 * vid_conheight, mySize.y);
+ mySize.x = max(0.025 * vid_conwidth, mySize.x);
+ mySize.y = max(0.025 * vid_conheight, mySize.y);
// do another pos check, as size might have changed by now
if(resizeCorner == 1) {
- myPos_x = resizeorigin.x - mySize.x;
- myPos_y = resizeorigin.y - mySize.y;
+ myPos.x = resizeorigin.x - mySize.x;
+ myPos.y = resizeorigin.y - mySize.y;
} else if(resizeCorner == 2) {
- myPos_x = resizeorigin.x;
- myPos_y = resizeorigin.y - mySize.y;
+ myPos.x = resizeorigin.x;
+ myPos.y = resizeorigin.y - mySize.y;
} else if(resizeCorner == 3) {
- myPos_x = resizeorigin.x - mySize.x;
- myPos_y = resizeorigin.y;
+ myPos.x = resizeorigin.x - mySize.x;
+ myPos.y = resizeorigin.y;
} else { // resizeCorner == 4
- myPos_x = resizeorigin.x;
- myPos_y = resizeorigin.y;
+ myPos.x = resizeorigin.x;
+ myPos.y = resizeorigin.y;
}
//if(cvar("hud_configure_checkcollisions_debug"))
if(bInputType == 3)
{
- mousepos_x = nPrimary;
- mousepos_y = nSecondary;
+ mousepos.x = nPrimary;
+ mousepos.y = nSecondary;
return true;
}
float level_height = vid_conheight / LEVELS_NUM;
:find_tab_panel
level = floor(tab_panel_pos.y / level_height) * level_height; //starting level
- candidate_pos_x = (!tab_backward) ? vid_conwidth : 0;
+ candidate_pos.x = (!tab_backward) ? vid_conwidth : 0;
start_posX = tab_panel_pos.x;
tab_panel = world;
k=0;
continue;
HUD_Panel_UpdatePosSize();
if (panel_pos.y >= level && (panel_pos.y - level) < level_height)
- if ( ( !tab_backward && panel_pos.x >= start_posX && (panel_pos.x < candidate_pos.x || (panel_pos_x == candidate_pos.x && panel_pos.y <= candidate_pos.y)) )
- || ( tab_backward && panel_pos.x <= start_posX && (panel_pos.x > candidate_pos.x || (panel_pos_x == candidate_pos.x && panel_pos.y >= candidate_pos.y)) ) )
+ if ( ( !tab_backward && panel_pos.x >= start_posX && (panel_pos.x < candidate_pos.x || (panel_pos.x == candidate_pos.x && panel_pos.y <= candidate_pos.y)) )
+ || ( tab_backward && panel_pos.x <= start_posX && (panel_pos.x > candidate_pos.x || (panel_pos.x == candidate_pos.x && panel_pos.y >= candidate_pos.y)) ) )
{
tab_panel = panel;
tab_panel_pos = candidate_pos = panel_pos;
{
level = (level + level_height) % vid_conheight;
start_posX = 0;
- candidate_pos_x = vid_conwidth;
+ candidate_pos.x = vid_conwidth;
}
else
{
level = (level - level_height) % vid_conheight;
start_posX = vid_conwidth;
- candidate_pos_x = 0;
+ candidate_pos.x = 0;
}
}
// reduce size if it'd go beyond screen boundaries
vector tmp_size = panel_size_copied;
if (panel_pos.x + panel_size_copied.x > vid_conwidth)
- tmp_size_x = vid_conwidth - panel_pos.x;
+ tmp_size.x = vid_conwidth - panel_pos.x;
if (panel_pos.y + panel_size_copied.y > vid_conheight)
- tmp_size_y = vid_conheight - panel_pos.y;
+ tmp_size.y = vid_conheight - panel_pos.y;
if (panel_size == tmp_size)
return true;
HUD_Panel_FirstInDrawQ(i);
highlightedAction = 2;
resizeCorner = 2;
- panel_click_distance_x = panel_size.x - mousepos.x + panel_pos.x;
- panel_click_distance_y = mousepos.y - panel_pos.y;
+ panel_click_distance.x = panel_size.x - mousepos.x + panel_pos.x;
+ panel_click_distance.y = mousepos.y - panel_pos.y;
panel_click_resizeorigin = panel_pos + eY * panel_size.y;
return;
}
HUD_Panel_FirstInDrawQ(i);
highlightedAction = 2;
resizeCorner = 3;
- panel_click_distance_x = mousepos.x - panel_pos.x;
- panel_click_distance_y = panel_size.y - mousepos.y + panel_pos.y;
+ panel_click_distance.x = mousepos.x - panel_pos.x;
+ panel_click_distance.y = panel_size.y - mousepos.y + panel_pos.y;
panel_click_resizeorigin = panel_pos + eX * panel_size.x;
return;
}
{
mousepos = mousepos + getmousepos() * autocvar_menu_mouse_speed;
- mousepos_x = bound(0, mousepos.x, vid_conwidth);
- mousepos_y = bound(0, mousepos.y, vid_conheight);
+ mousepos.x = bound(0, mousepos.x, vid_conwidth);
+ mousepos.y = bound(0, mousepos.y, vid_conheight);
}
if(mouseClicked)
{
vector mySize = '0 0 0';
if(resizeCorner == 1) {
- mySize_x = panel_click_resizeorigin.x - (mousepos.x - panel_click_distance.x);
- mySize_y = panel_click_resizeorigin.y - (mousepos.y - panel_click_distance.y);
+ mySize.x = panel_click_resizeorigin.x - (mousepos.x - panel_click_distance.x);
+ mySize.y = panel_click_resizeorigin.y - (mousepos.y - panel_click_distance.y);
} else if(resizeCorner == 2) {
- mySize_x = mousepos.x + panel_click_distance.x - panel_click_resizeorigin.x;
- mySize_y = panel_click_distance.y + panel_click_resizeorigin.y - mousepos.y;
+ mySize.x = mousepos.x + panel_click_distance.x - panel_click_resizeorigin.x;
+ mySize.y = panel_click_distance.y + panel_click_resizeorigin.y - mousepos.y;
} else if(resizeCorner == 3) {
- mySize_x = panel_click_resizeorigin.x + panel_click_distance.x - mousepos.x;
- mySize_y = mousepos.y + panel_click_distance.y - panel_click_resizeorigin.y;
+ mySize.x = panel_click_resizeorigin.x + panel_click_distance.x - mousepos.x;
+ mySize.y = mousepos.y + panel_click_distance.y - panel_click_resizeorigin.y;
} else { // resizeCorner == 4
- mySize_x = mousepos.x - (panel_click_resizeorigin.x - panel_click_distance.x);
- mySize_y = mousepos.y - (panel_click_resizeorigin.y - panel_click_distance.y);
+ mySize.x = mousepos.x - (panel_click_resizeorigin.x - panel_click_distance.x);
+ mySize.y = mousepos.y - (panel_click_resizeorigin.y - panel_click_distance.y);
}
HUD_Panel_SetPosSize(mySize);
}
float i;
if(autocvar_hud_configure_grid && autocvar_hud_configure_grid_alpha)
{
- hud_configure_gridSize_x = bound(0.005, cvar("hud_configure_grid_xsize"), 0.2);
- hud_configure_gridSize_y = bound(0.005, cvar("hud_configure_grid_ysize"), 0.2);
- hud_configure_realGridSize_x = hud_configure_gridSize.x * vid_conwidth;
- hud_configure_realGridSize_y = hud_configure_gridSize.y * vid_conheight;
+ hud_configure_gridSize.x = bound(0.005, cvar("hud_configure_grid_xsize"), 0.2);
+ hud_configure_gridSize.y = bound(0.005, cvar("hud_configure_grid_ysize"), 0.2);
+ hud_configure_realGridSize.x = hud_configure_gridSize.x * vid_conwidth;
+ hud_configure_realGridSize.y = hud_configure_gridSize.y * vid_conheight;
vector s;
// x-axis
s = eX + eY * vid_conheight;
if(f & 1)
{
- self.origin_x = ReadCoord();
- self.origin_y = ReadCoord();
- self.origin_z = ReadCoord();
+ self.origin.x = ReadCoord();
+ self.origin.y = ReadCoord();
+ self.origin.z = ReadCoord();
setorigin(self, self.origin);
}
if(f & 8)
{
- self.colormod_x = ReadByte() / 255.0;
- self.colormod_y = ReadByte() / 255.0;
- self.colormod_z = ReadByte() / 255.0;
+ self.colormod.x = ReadByte() / 255.0;
+ self.colormod.y = ReadByte() / 255.0;
+ self.colormod.z = ReadByte() / 255.0;
if(f & 0x40)
self.alpha = ReadByte() / 255.0;
else
{
if(f & 0x80)
{
- self.velocity_x = ReadCoord();
- self.velocity_y = ReadCoord();
- self.velocity_z = ReadCoord();
+ self.velocity.x = ReadCoord();
+ self.velocity.y = ReadCoord();
+ self.velocity.z = ReadCoord();
}
else
{
- self.angles_x = ReadAngle();
- self.angles_y = ReadAngle();
+ self.angles.x = ReadAngle();
+ self.angles.y = ReadAngle();
}
}
if(f & 4)
if(f & 8)
{
angles_held_status = 1;
- angles_held_x = ReadAngle();
- angles_held_y = ReadAngle();
- angles_held_z = 0;
+ angles_held.x = ReadAngle();
+ angles_held.y = ReadAngle();
+ angles_held.z = 0;
}
else
angles_held_status = 0;
{
float teamnum = (ReadByte() - 1);
vector spn_origin;
- spn_origin_x = ReadShort();
- spn_origin_y = ReadShort();
- spn_origin_z = ReadShort();
+ spn_origin.x = ReadShort();
+ spn_origin.y = ReadShort();
+ spn_origin.z = ReadShort();
if(is_new)
{
float rect_margin = hud_fontsize.y / 2;
vector rect_pos = pos - '0.5 0.5 0' * rect_margin;
vector rect_size = '1 1 0';
- rect_size_x = tsize + rect_margin;
- rect_size_y = maxh + rect_margin;
+ rect_size.x = tsize + rect_margin;
+ rect_size.y = maxh + rect_margin;
vector rgb = MapVote_RGB(id);
vector offset = pos;
float nlines = 0;
rgb = MapVote_RGB(id);
- img_size_y = isize;
- img_size_x = isize / 0.75; // 4:3 x can be stretched easily, height is defined in isize
+ img_size.y = isize;
+ img_size.x = isize / 0.75; // 4:3 x can be stretched easily, height is defined in isize
- pos_y = pos.y + img_size.y;
+ pos.y = pos.y + img_size.y;
label = MapVote_FormatMapItem(id, map, _count, tsize, hud_fontsize);
pos.x -= text_size*0.5;
drawstring(pos, label, hud_fontsize, rgb, theAlpha, DRAWFLAG_NORMAL);
- pos_x = pos.x + text_size*0.5 - img_size.x*0.5;
- pos_y = pos.y - img_size.y;
+ pos.x = pos.x + text_size*0.5 - img_size.x*0.5;
+ pos.y = pos.y - img_size.y;
pos += autocvar_scoreboard_border_thickness * '1 1 0';
img_size -= (autocvar_scoreboard_border_thickness * 2) * '1 1 0';
rgb = MapVote_RGB(id);
- pos_y = pos.y + hud_fontsize.y;
+ pos.y = pos.y + hud_fontsize.y;
label = MapVote_FormatMapItem(id, _("Don't care"), _count, tsize, hud_fontsize);
if (!autocvar_hud_cursormode)
{
vector mpos = mv_mousepos + getmousepos();
- mpos_x = bound(0, mpos.x, vid_conwidth);
- mpos_y = bound(0, mpos.y, vid_conheight);
+ mpos.x = bound(0, mpos.x, vid_conwidth);
+ mpos.y = bound(0, mpos.y, vid_conheight);
if ( mpos.x != mv_mousepos.x || mpos.y != mv_mousepos.y )
mv_selection_keyboard = 0;
hud_fontsize = HUD_GetFontsize("hud_fontsize");
- pos_y = ymin;
- pos_z = 0;
+ pos.y = ymin;
+ pos.z = 0;
draw_beginBoldFont();
map = ((gametypevote) ? _("Decide the gametype") : _("Vote for a map"));
- pos_x = center - stringwidth(map, false, '12 0 0');
+ pos.x = center - stringwidth(map, false, '12 0 0');
drawstring(pos, map, '24 24 0', '1 1 1', 1, DRAWFLAG_NORMAL);
pos.y += 26;
if( mapvote_chosenmap != "" )
{
- pos_x = center - stringwidth(mapvote_chosenmap, false, hud_fontsize*1.5/2);
+ pos.x = center - stringwidth(mapvote_chosenmap, false, hud_fontsize*1.5/2);
drawstring(pos, mapvote_chosenmap, hud_fontsize*1.5, '1 1 1', 1, DRAWFLAG_NORMAL);
pos.y += hud_fontsize.y*2;
}
i = ceil(max(0, mv_timeout - time));
map = sprintf(_("%d seconds left"), i);
- pos_x = center - stringwidth(map, false, '8 0 0');
+ pos.x = center - stringwidth(map, false, '8 0 0');
drawstring(pos, map, '16 16 0', '0 1 0', 1, DRAWFLAG_NORMAL);
pos.y += 22;
- pos_x = xmin;
+ pos.x = xmin;
draw_endBoldFont();
// base for multi-column stuff...
rows = ceil(mv_num_maps / mv_columns);
- dist_x = (xmax - xmin) / mv_columns;
- dist_y = (ymax - pos.y) / rows;
+ dist.x = (xmax - xmin) / mv_columns;
+ dist.y = (ymax - pos.y) / rows;
if ( gametypevote )
{
}
else
dist.y += hud_fontsize.y;
- pos_x = ( vid_conwidth - dist.x * mv_columns ) / 2;
+ pos.x = ( vid_conwidth - dist.x * mv_columns ) / 2;
}
else
{
if(mv_abstain && i < mv_num_maps) {
tmp = mv_votes[i];
- pos_y = ymax + isize - hud_fontsize.y;
- pos_x = (xmax+xmin)*0.5;
+ pos.y = ymax + isize - hud_fontsize.y;
+ pos.x = (xmax+xmin)*0.5;
MapVote_DrawAbstain(pos, isize, xmax - xmin, tmp, i);
}
if(bInputType == 3)
{
- mv_mousepos_x = nPrimary;
- mv_mousepos_y = nSecondary;
+ mv_mousepos.x = nPrimary;
+ mv_mousepos.y = nSecondary;
mv_selection_keyboard = 0;
return true;
}
{
vector v;
v = stov(cvar_string(cvarname));
- if(v_x == 0)
+ if(v.x == 0)
v = '8 8 0';
- if(v_y == 0)
- v_y = v.x;
- v_z = 0;
+ if(v.y == 0)
+ v.y = v.x;
+ v.z = 0;
return v;
}
{
vector w = '0 0 0';
// FTEQCC SUCKS AGAIN
- w_x = v.x * cos(a) + v.y * sin(a);
- w_y = -1 * v.x * sin(a) + v.y * cos(a);
+ w.x = v.x * cos(a) + v.y * sin(a);
+ w.y = -1 * v.x * sin(a) + v.y * cos(a);
return w;
}
// left and right lines
pos.x -= thickness;
- line_dim_x = thickness;
- line_dim_y = dim.y;
+ line_dim.x = thickness;
+ line_dim.y = dim.y;
drawfill(pos, line_dim, color, theAlpha, drawflag);
drawfill(pos + (dim.x + thickness) * '1 0 0', line_dim, color, theAlpha, drawflag);
// upper and lower lines
pos.y -= thickness;
- line_dim_x = dim.x + thickness * 2; // make upper and lower lines longer
- line_dim_y = thickness;
+ line_dim.x = dim.x + thickness * 2; // make upper and lower lines longer
+ line_dim.y = thickness;
drawfill(pos, line_dim, color, theAlpha, drawflag);
drawfill(pos + (dim.y + thickness) * '0 1 0', line_dim, color, theAlpha, drawflag);
}
vector current_pos = '0 0 0', end_pos, new_size = '0 0 0', ratio = '0 0 0';
end_pos = pos + area;
- current_pos_y = pos.y;
+ current_pos.y = pos.y;
while (current_pos.y < end_pos.y)
{
- current_pos_x = pos.x;
+ current_pos.x = pos.x;
while (current_pos.x < end_pos.x)
{
- new_size_x = min(sz.x, end_pos.x - current_pos.x);
- new_size_y = min(sz.y, end_pos.y - current_pos.y);
- ratio_x = new_size.x / sz.x;
- ratio_y = new_size.y / sz.y;
+ new_size.x = min(sz.x, end_pos.x - current_pos.x);
+ new_size.y = min(sz.y, end_pos.y - current_pos.y);
+ ratio.x = new_size.x / sz.x;
+ ratio.y = new_size.y / sz.y;
drawsubpic(current_pos, new_size, pic, '0 0 0', ratio, color, theAlpha, drawflag);
current_pos.x += sz.x;
}
_drawpic_sz = mySize;\
if(_drawpic_sz.x/_drawpic_sz.y > _drawpic_imgaspect) {\
_drawpic_oldsz = _drawpic_sz.x;\
- _drawpic_sz_x = _drawpic_sz.y * _drawpic_imgaspect;\
+ _drawpic_sz.x = _drawpic_sz.y * _drawpic_imgaspect;\
if(_drawpic_sz.x)\
drawpic(pos + eX * (_drawpic_oldsz - _drawpic_sz.x) * 0.5, pic, _drawpic_sz, color, theAlpha, drawflag);\
} else {\
_drawpic_oldsz = _drawpic_sz.y;\
- _drawpic_sz_y = _drawpic_sz.x / _drawpic_imgaspect;\
+ _drawpic_sz.y = _drawpic_sz.x / _drawpic_imgaspect;\
if(_drawpic_sz.y)\
drawpic(pos + eY * (_drawpic_oldsz - _drawpic_sz.y) * 0.5, pic, _drawpic_sz, color, theAlpha, drawflag);\
}\
textaspect = stringwidth(text, allow_colors, '1 1 1' * sz.y) / sz.y; \
if(sz.x/sz.y > textaspect) { \
oldsz = sz.x; \
- sz_x = sz.y * textaspect; \
+ sz.x = sz.y * textaspect; \
pos.x += (oldsz - sz.x) * 0.5; \
} else { \
oldsz = sz.y; \
- sz_y = sz.x / textaspect; \
+ sz.y = sz.x / textaspect; \
pos.y += (oldsz - sz.y) * 0.5; \
} \
} while(0)
{
ent.move_watertype = nativecontents;
ent.move_waterlevel = 1;
- point_y = (ent.origin.y + ((ent.mins.z + ent.maxs.y) * 0.5));
+ point.y = (ent.origin.y + ((ent.mins.z + ent.maxs.y) * 0.5));
if(Mod_Q1BSP_SuperContentsFromNativeContents(pointcontents(point)) & DPCONTENTS_LIQUIDSMASK)
{
ent.move_waterlevel = 2;
- point_y = ent.origin.y + ent.view_ofs.y;
+ point.y = ent.origin.y + ent.view_ofs.y;
if(Mod_Q1BSP_SuperContentsFromNativeContents(pointcontents(point)) & DPCONTENTS_LIQUIDSMASK)
ent.move_waterlevel = 3;
}
{
vel = vel - ((vel * norm) * norm) * f;
- if(vel.x > -0.1 && vel.x < 0.1) vel_x = 0;
- if(vel.y > -0.1 && vel.y < 0.1) vel_y = 0;
- if(vel.z > -0.1 && vel.z < 0.1) vel_z = 0;
+ if(vel.x > -0.1 && vel.x < 0.1) vel.x = 0;
+ if(vel.y > -0.1 && vel.y < 0.1) vel.y = 0;
+ if(vel.z > -0.1 && vel.z < 0.1) vel.z = 0;
return vel;
}
{
vector shotorg, endpos;
float charge;
- shotorg_x = ReadCoord(); shotorg_y = ReadCoord(); shotorg_z = ReadCoord();
- endpos_x = ReadCoord(); endpos_y = ReadCoord(); endpos_z = ReadCoord();
+ shotorg.x = ReadCoord(); shotorg.y = ReadCoord(); shotorg.z = ReadCoord();
+ endpos.x = ReadCoord(); endpos.y = ReadCoord(); endpos.z = ReadCoord();
charge = ReadByte() / 255.0;
pointparticles(particleeffectnum("nex_muzzleflash"), shotorg, normalize(endpos - shotorg) * 1000, 1);
do
{
- v_x = prandom();
- v_y = prandom();
- v_z = prandom();
+ v.x = prandom();
+ v.y = prandom();
+ v.z = prandom();
}
while(v * v > 1);
is_spec = (GetPlayerColor(pl.sv_entnum) == NUM_SPECTATOR);
if((rgb == '1 1 1') && (!is_spec)) {
- rgb_x = autocvar_scoreboard_color_bg_r + 0.5;
- rgb_y = autocvar_scoreboard_color_bg_g + 0.5;
- rgb_z = autocvar_scoreboard_color_bg_b + 0.5; }
+ rgb.x = autocvar_scoreboard_color_bg_r + 0.5;
+ rgb.y = autocvar_scoreboard_color_bg_g + 0.5;
+ rgb.z = autocvar_scoreboard_color_bg_b + 0.5; }
vector h_pos = pos - '1 1 0';
vector h_size = item_size + '2 0 0';
else if((scoreboard_highlight) && (!(pl_number % 2)))
drawfill(h_pos, h_size, rgb, scoreboard_highlight_alpha, DRAWFLAG_NORMAL);
- tmp_x = item_size.x;
- tmp_y = 0;
- tmp_z = 0;
+ tmp.x = item_size.x;
+ tmp.y = 0;
+ tmp.z = 0;
int i;
for(i = 0; i < hud_num_fields; ++i)
{
pos.x += hud_size[i] + hud_fontsize.x;
if(field == SP_NAME) {
- tmp_x = hud_size[i] - hud_fontsize.x*hud_fixscoreboardcolumnwidth_iconlen - hud_fixscoreboardcolumnwidth_marginlen + hud_fontsize.x;
+ tmp.x = hud_size[i] - hud_fontsize.x*hud_fixscoreboardcolumnwidth_iconlen - hud_fixscoreboardcolumnwidth_marginlen + hud_fontsize.x;
if (is_self)
drawcolorcodedstring(pos - tmp, str, hud_fontsize, scoreboard_alpha_name_self, DRAWFLAG_NORMAL);
else
drawcolorcodedstring(pos - tmp, str, hud_fontsize, scoreboard_alpha_name, DRAWFLAG_NORMAL);
} else {
- tmp_x = hud_fixscoreboardcolumnwidth_len + hud_fontsize.x;
+ tmp.x = hud_fixscoreboardcolumnwidth_len + hud_fontsize.x;
if (is_self)
drawstring(pos - tmp, str, hud_fontsize, hud_field_rgb, scoreboard_alpha_name_self, DRAWFLAG_NORMAL);
else
drawstring(pos - tmp, str, hud_fontsize, hud_field_rgb, scoreboard_alpha_name, DRAWFLAG_NORMAL);
}
- tmp_x = hud_size[i] + hud_fontsize.x;
+ tmp.x = hud_size[i] + hud_fontsize.x;
if(hud_field_icon0 != "")
if (is_self)
drawpic(pos - tmp, hud_field_icon0, '0 1 0' * hud_fontsize.y + '1 0 0' * hud_fontsize.x * hud_fixscoreboardcolumnwidth_iconlen, hud_field_icon1_rgb, hud_field_icon0_alpha * scoreboard_alpha_name_self, DRAWFLAG_NORMAL);
if(hud_field[i] == SP_SEPARATOR)
{
- pos_x = xmax;
+ pos.x = xmax;
for(i = hud_num_fields-1; i > 0; --i)
{
field = hud_field[i];
str = HUD_FixScoreboardColumnWidth(i, str);
if(field == SP_NAME) {
- tmp_x = hud_fixscoreboardcolumnwidth_len; // left or right aligned? let's put it right...
+ tmp.x = hud_fixscoreboardcolumnwidth_len; // left or right aligned? let's put it right...
if(is_self)
drawcolorcodedstring(pos - tmp, str, hud_fontsize, scoreboard_alpha_name_self, DRAWFLAG_NORMAL);
else
drawcolorcodedstring(pos - tmp, str, hud_fontsize, scoreboard_alpha_name, DRAWFLAG_NORMAL);
} else {
- tmp_x = hud_fixscoreboardcolumnwidth_len;
+ tmp.x = hud_fixscoreboardcolumnwidth_len;
if(is_self)
drawstring(pos - tmp, str, hud_fontsize, hud_field_rgb, scoreboard_alpha_name_self, DRAWFLAG_NORMAL);
else
drawstring(pos - tmp, str, hud_fontsize, hud_field_rgb, scoreboard_alpha_name, DRAWFLAG_NORMAL);
}
- tmp_x = hud_size[i];
+ tmp.x = hud_size[i];
if(hud_field_icon0 != "")
if (is_self)
drawpic(pos - tmp, hud_field_icon0, '0 1 0' * hud_fontsize.y + '1 0 0' * hud_fontsize.x * hud_fixscoreboardcolumnwidth_iconlen, hud_field_icon1_rgb, hud_field_icon0_alpha * scoreboard_alpha_name_self, DRAWFLAG_NORMAL);
pos.y += autocvar_scoreboard_border_thickness;
pos -= '1 1 0';
- tmp_x = sbwidth + 2;
- tmp_y = 1.25 * hud_fontsize.y;
+ tmp.x = sbwidth + 2;
+ tmp.y = 1.25 * hud_fontsize.y;
// rounded header
if (teamplay)
// separator header/table
pos.y += 1.25 * hud_fontsize.y;
- tmp_y = autocvar_scoreboard_border_thickness;
+ tmp.y = autocvar_scoreboard_border_thickness;
drawfill(pos, tmp, '0 0 0', scoreboard_alpha_bg, DRAWFLAG_NORMAL);
pos.y += autocvar_scoreboard_border_thickness;
// table background
- tmp_y = body_table_height;
+ tmp.y = body_table_height;
if (teamplay)
drawpic_tiled(pos, "gfx/scoreboard/scoreboard_bg", bg_size, tmp, rgb * autocvar_scoreboard_color_bg_team, scoreboard_alpha_bg, DRAWFLAG_NORMAL);
else
if (scoreboard_highlight)
{
- column_dim_y = 1.25 * hud_fontsize.y; // header
+ column_dim.y = 1.25 * hud_fontsize.y; // header
column_dim.y += autocvar_scoreboard_border_thickness;
column_dim.y += body_table_height;
}
{
if(hud_field[i] == SP_SEPARATOR)
break;
- column_dim_x = hud_size[i] + hud_fontsize.x;
+ column_dim.x = hud_size[i] + hud_fontsize.x;
if (scoreboard_highlight)
{
if (i % 2)
}
if(hud_field[i] == SP_SEPARATOR)
{
- pos_x = xmax;
- tmp_y = 0;
+ pos.x = xmax;
+ tmp.y = 0;
for(i = hud_num_fields-1; i > 0; --i)
{
if(hud_field[i] == SP_SEPARATOR)
if (!(i % 2))
{
if (i == hud_num_fields-1)
- column_dim_x = hud_size[i] + hud_fontsize.x / 2 + 1;
+ column_dim.x = hud_size[i] + hud_fontsize.x / 2 + 1;
else
- column_dim_x = hud_size[i] + hud_fontsize.x;
+ column_dim.x = hud_size[i] + hud_fontsize.x;
drawfill(pos - '0 1 0' - hud_fontsize.x / 2 * '1 0 0', column_dim, '0 0 0', scoreboard_alpha_bg * 0.2, DRAWFLAG_NORMAL);
}
}
- tmp_x = stringwidth(hud_title[i], false, hud_fontsize);
- tmp_x = (hud_size[i] - tmp.x);
+ tmp.x = stringwidth(hud_title[i], false, hud_fontsize);
+ tmp.x = (hud_size[i] - tmp.x);
drawstring(pos + tmp, hud_title[i], hud_fontsize, rgb * 1.5, scoreboard_alpha_fg, DRAWFLAG_NORMAL);
pos.x -= hud_fontsize.x;
}
}
draw_endBoldFont();
- pos_x = xmin;
+ pos.x = xmin;
pos.y += 1.25 * hud_fontsize.y; // skip the header
pos.y += autocvar_scoreboard_border_thickness;
// item size
- tmp_x = sbwidth;
- tmp_y = hud_fontsize.y * 1.25;
+ tmp.x = sbwidth;
+ tmp.y = hud_fontsize.y * 1.25;
// fill the table and draw the rows
i = 0;
drawstring(pos, sprintf(_("Accuracy stats (average %d%%)"), average_accuracy), hud_fontsize, '1 1 1', scoreboard_alpha_fg, DRAWFLAG_NORMAL);
pos.y += 1.25 * hud_fontsize.y + autocvar_scoreboard_border_thickness;
vector tmp = '0 0 0';
- tmp_x = sbwidth;
- tmp_y = height * rows;
+ tmp.x = sbwidth;
+ tmp.y = height * rows;
if (teamplay)
drawpic_tiled(pos, "gfx/scoreboard/scoreboard_bg", bg_size, tmp, rgb * autocvar_scoreboard_color_bg_team, scoreboard_alpha_bg, DRAWFLAG_NORMAL);
float px = pos.x;
pos.x += hud_fontsize.x * 0.25;
drawstring(pos, key, hud_fontsize, '1 1 1', scoreboard_alpha_fg, DRAWFLAG_NORMAL);
- pos_x = xmax - stringwidth(value, false, hud_fontsize) - hud_fontsize.x * 0.25;
+ pos.x = xmax - stringwidth(value, false, hud_fontsize) - hud_fontsize.x * 0.25;
drawstring(pos, value, hud_fontsize, '1 1 1', scoreboard_alpha_fg, DRAWFLAG_NORMAL);
- pos_x = px;
+ pos.x = px;
pos.y+= hud_fontsize.y;
return pos;
// draw table
vector tmp = '0 0 0';
- tmp_x = sbwidth;
- tmp_y = hud_fontsize.y * rows;
+ tmp.x = sbwidth;
+ tmp.y = hud_fontsize.y * rows;
if (teamplay)
drawpic_tiled(pos, "gfx/scoreboard/scoreboard_bg", bg_size, tmp, rgb * autocvar_scoreboard_color_bg_team, scoreboard_alpha_bg, DRAWFLAG_NORMAL);
float is_spec;
is_spec = (GetPlayerColor(pl.sv_entnum) == NUM_SPECTATOR);
vector hl_rgb;
- hl_rgb_x = autocvar_scoreboard_color_bg_r + 0.5;
- hl_rgb_y = autocvar_scoreboard_color_bg_g + 0.5;
- hl_rgb_z = autocvar_scoreboard_color_bg_b + 0.5;
+ hl_rgb.x = autocvar_scoreboard_color_bg_r + 0.5;
+ hl_rgb.y = autocvar_scoreboard_color_bg_g + 0.5;
+ hl_rgb.z = autocvar_scoreboard_color_bg_b + 0.5;
pos.y += hud_fontsize.y;
drawstring(pos, _("Rankings"), hud_fontsize, '1 1 1', scoreboard_alpha_fg, DRAWFLAG_NORMAL);
pos.y += hud_fontsize.y + autocvar_scoreboard_border_thickness;
vector tmp = '0 0 0';
- tmp_x = sbwidth;
- tmp_y = 1.25 * hud_fontsize.y * RANKINGS_RECEIVED_CNT;
+ tmp.x = sbwidth;
+ tmp.y = 1.25 * hud_fontsize.y * RANKINGS_RECEIVED_CNT;
if (teamplay)
drawpic_tiled(pos, "gfx/scoreboard/scoreboard_bg", bg_size, tmp, rgb * autocvar_scoreboard_color_bg_team, scoreboard_alpha_bg, DRAWFLAG_NORMAL);
sbwidth = xmax - xmin;
// Initializes position
- pos_x = xmin;
- pos_y = ymin;
- pos_z = 0;
+ pos.x = xmin;
+ pos.y = ymin;
+ pos.z = 0;
// Heading
vector sb_heading_fontsize;
pos = HUD_Scoreboard_MakeTable(pos, tm, rgb, bg_size);
}
- rgb_x = autocvar_scoreboard_color_bg_r;
- rgb_y = autocvar_scoreboard_color_bg_g;
- rgb_z = autocvar_scoreboard_color_bg_b;
+ rgb.x = autocvar_scoreboard_color_bg_r;
+ rgb.y = autocvar_scoreboard_color_bg_g;
+ rgb.z = autocvar_scoreboard_color_bg_b;
}
else
{
- rgb_x = autocvar_scoreboard_color_bg_r;
- rgb_y = autocvar_scoreboard_color_bg_g;
- rgb_z = autocvar_scoreboard_color_bg_b;
+ rgb.x = autocvar_scoreboard_color_bg_r;
+ rgb.y = autocvar_scoreboard_color_bg_g;
+ rgb.z = autocvar_scoreboard_color_bg_b;
for(tm = teams.sort_next; tm; tm = tm.sort_next)
{
specs = 0;
tmp = pos;
vector item_size;
- item_size_x = sbwidth;
- item_size_y = hud_fontsize.y * 1.25;
- item_size_z = 0;
+ item_size.x = sbwidth;
+ item_size.y = hud_fontsize.y * 1.25;
+ item_size.z = 0;
for(pl = players.sort_next; pl; pl = pl.sort_next)
{
if(pl.team != NUM_SPECTATOR)
eo = project_3d_to_2d(e.origin);
if (!(eo.z < 0 || eo.x < 0 || eo.y < 0 || eo.x > vid_conwidth || eo.y > vid_conheight))
{
- eo_z = 0;
+ eo.z = 0;
if(vlen((eX * o.x + eY * o.y) - eo) < autocvar_hud_shownames_antioverlap_distance && vlen(ent.origin - view_origin) > vlen(e.origin - view_origin))
{
overlap = true;
// draw the sprite image
if(o.z >= 0)
{
- o_z = 0;
+ o.z = 0;
vector myPos, mySize;
mySize = (eX * autocvar_hud_shownames_aspect + eY) * autocvar_hud_shownames_fontsize;
vector teamradar_3dcoord_to_texcoord(vector in)
{
vector out;
- out_x = (in.x - mi_picmin.x) / (mi_picmax.x - mi_picmin.x);
- out_y = (in.y - mi_picmin.y) / (mi_picmax.y - mi_picmin.y);
- out_z = 0;
+ out.x = (in.x - mi_picmin.x) / (mi_picmax.x - mi_picmin.x);
+ out.y = (in.y - mi_picmin.y) / (mi_picmax.y - mi_picmin.y);
+ out.z = 0;
return out;
}
in -= teamradar_origin3d_in_texcoord;
out = rotate(in, teamradar_angle * DEG2RAD);
- out_y = - out.y; // screen space is reversed
+ out.y = - out.y; // screen space is reversed
out = out * teamradar_size;
if(v_flipped)
- out_x = -out.x;
+ out.x = -out.x;
out += teamradar_origin2d;
return out;
}
vector yinvert(vector v)
{
- v_y = 1 - v.y;
+ v.y = 1 - v.y;
return v;
}
makevectors(pangles - '0 1 0' * teamradar_angle);
if(v_flipped)
{
- v_forward_x = -v_forward.x;
- v_right_x = -v_right.x;
- v_up_x = -v_up.x;
+ v_forward.x = -v_forward.x;
+ v_right.x = -v_right.x;
+ v_up.x = -v_up.x;
}
- v_forward_z = 0;
+ v_forward.z = 0;
v_forward = normalize(v_forward);
v_forward.y *= -1.0;
- v_right_x = -v_forward.y;
- v_right_y = v_forward.x;
+ v_right.x = -v_forward.y;
+ v_right.y = v_forward.x;
if(rgb == '1 1 1')
rgb2 = '0 0 0';
start = teamradar_texcoord_to_2dcoord(teamradar_3dcoord_to_texcoord(start));
end = teamradar_texcoord_to_2dcoord(teamradar_3dcoord_to_texcoord(end));
norm = normalize(start - end);
- norm_z = norm.x;
- norm_x = -norm.y;
- norm_y = norm.z;
- norm_z = 0;
+ norm.z = norm.x;
+ norm.x = -norm.y;
+ norm.y = norm.z;
+ norm.z = 0;
c0 = colormapPaletteColor(colors & 0x0F, false);
c1 = colormapPaletteColor((colors & 0xF0) / 0x10, false);
// match this to defaultXonotic.cfg!
if(!hud_panel_radar_scale) hud_panel_radar_scale = 4096;
if(!hud_panel_radar_foreground_alpha) hud_panel_radar_foreground_alpha = 0.8 * panel_fg_alpha;
- if(!hud_panel_radar_size.x) hud_panel_radar_size_x = 128;
- if(!hud_panel_radar_size.y) hud_panel_radar_size_y = hud_panel_radar_size.x;
+ if(!hud_panel_radar_size.x) hud_panel_radar_size.x = 128;
+ if(!hud_panel_radar_size.y) hud_panel_radar_size.y = hud_panel_radar_size.x;
}
// radar links
|| o.x > (vid_conwidth - (vid_conwidth * waypointsprite_edgeoffset_right))
|| o.y > (vid_conheight - (vid_conheight * waypointsprite_edgeoffset_bottom)))
return; // Dont draw wp's for turrets out of view
- o_z = 0;
+ o.z = 0;
if(hud != HUD_NORMAL)
{
switch(hud)
|| o.y > (vid_conheight - (vid_conheight * waypointsprite_edgeoffset_bottom)))
return; // Dont draw wp's for turrets out of view
- o_z = 0;
+ o.z = 0;
float edgedistance_min, crosshairdistance;
edgedistance_min = min((o.y - (vid_conheight * waypointsprite_edgeoffset_top)),
loc = project_3d_to_2d(self.move_origin) - 0.5 * psize;
if (!(loc.z < 0 || loc.x < 0 || loc.y < 0 || loc.x > vid_conwidth || loc.y > vid_conheight))
{
- loc_z = 0;
- psize_z = 0;
+ loc.z = 0;
+ psize.z = 0;
drawpic(loc, self.axh_image, psize, self.colormod, self.alpha, self.axh_drawflag);
}
HUD_GETSTATS
picsize = draw_getimagesize(hud_bg) * autocvar_cl_vehicles_hudscale;
- hudloc_y = vid_conheight - picsize.y;
- hudloc_x = vid_conwidth * 0.5 - picsize.x * 0.5;
+ hudloc.y = vid_conheight - picsize.y;
+ hudloc.x = vid_conwidth * 0.5 - picsize.x * 0.5;
drawpic(hudloc, hud_bg, picsize, '1 1 1', autocvar_cl_vehicles_hudalpha, DRAWFLAG_NORMAL);
HUD_GETSTATS
picsize = draw_getimagesize(hud_bg) * autocvar_cl_vehicles_hudscale;
- hudloc_y = vid_conheight - picsize.y;
- hudloc_x = vid_conwidth * 0.5 - picsize.x * 0.5;
+ hudloc.y = vid_conheight - picsize.y;
+ hudloc.x = vid_conwidth * 0.5 - picsize.x * 0.5;
drawpic(hudloc, hud_bg, picsize, '1 1 1', autocvar_cl_vehicles_hudalpha, DRAWFLAG_NORMAL);
HUD_GETSTATS
picsize = draw_getimagesize(hud_bg) * autocvar_cl_vehicles_hudscale;
- hudloc_y = vid_conheight - picsize.y;
- hudloc_x = vid_conwidth * 0.5 - picsize.x * 0.5;
+ hudloc.y = vid_conheight - picsize.y;
+ hudloc.x = vid_conwidth * 0.5 - picsize.x * 0.5;
drawpic(hudloc, hud_bg, picsize, '1 1 1', autocvar_cl_vehicles_hudalpha, DRAWFLAG_NORMAL);
HUD_GETSTATS
picsize = draw_getimagesize(hud_bg) * autocvar_cl_vehicles_hudscale;
- hudloc_y = vid_conheight - picsize.y;
- hudloc_x = vid_conwidth * 0.5 - picsize.x * 0.5;
+ hudloc.y = vid_conheight - picsize.y;
+ hudloc.x = vid_conwidth * 0.5 - picsize.x * 0.5;
drawpic(hudloc, hud_bg, picsize, '1 1 1', autocvar_cl_vehicles_hudalpha, DRAWFLAG_NORMAL);
{
where.x -= picsize.x * 0.5;
where.y -= picsize.y * 0.5;
- where_z = 0;
+ where.z = 0;
drawpic(where, raptor_drop, picsize, '0 2 0', 1, DRAWFLAG_ADDITIVE);
}
dropmark.cnt = time + 5;
{
where.x -= picsize.x * 0.5;
where.y -= picsize.y * 0.5;
- where_z = 0;
+ where.z = 0;
drawpic(where, raptor_drop, picsize, '2 0 0', 1, DRAWFLAG_ADDITIVE);
}
}
HUD_GETSTATS
picsize = draw_getimagesize(hud_bg) * autocvar_cl_vehicles_hudscale;
- hudloc_y = vid_conheight - picsize.y;
- hudloc_x = vid_conwidth * 0.5 - picsize.x * 0.5;
+ hudloc.y = vid_conheight - picsize.y;
+ hudloc.x = vid_conwidth * 0.5 - picsize.x * 0.5;
drawpic(hudloc, hud_bg, picsize, '1 1 1', autocvar_cl_vehicles_hudalpha, DRAWFLAG_NORMAL);
continue;
++portal_number;
ang = vectoangles2(trace_plane_normal, dir);
- ang_x = -ang.x;
+ ang.x = -ang.x;
makevectors(ang);
if(!CheckWireframeBox(porto, p - 48 * v_right - 48 * v_up + 16 * v_forward, 96 * v_right, 96 * v_up, 96 * v_forward))
return;
{
float t, n;
wcross_origin = project_3d_to_2d(trace_endpos);
- wcross_origin_z = 0;
+ wcross_origin.z = 0;
if(trace_ent)
n = trace_ent.entnum;
else
trueaimpoint = traceorigin + view_forward * g_trueaim_minrange;
if(vecs.x > 0)
- vecs_y = -vecs.y;
+ vecs.y = -vecs.y;
else
vecs = '0 0 0';
// wcross_origin = '0.5 0 0' * vid_conwidth + '0 0.5 0' * vid_conheight;
wcross_origin = project_3d_to_2d(view_origin + MAX_SHOT_DISTANCE * view_forward);
- wcross_origin_z = 0;
+ wcross_origin.z = 0;
if(autocvar_crosshair_hittest)
{
vector wcross_oldorigin;
//y = green
//z = blue
- wcross_color_z = 0;
+ wcross_color.z = 0;
if(x > 200)
{
- wcross_color_x = 0;
- wcross_color_y = 1;
+ wcross_color.x = 0;
+ wcross_color.y = 1;
}
else if(x > 150)
{
- wcross_color_x = 0.4 - (x-150)*0.02 * 0.4;
- wcross_color_y = 0.9 + (x-150)*0.02 * 0.1;
+ wcross_color.x = 0.4 - (x-150)*0.02 * 0.4;
+ wcross_color.y = 0.9 + (x-150)*0.02 * 0.1;
}
else if(x > 100)
{
- wcross_color_x = 1 - (x-100)*0.02 * 0.6;
- wcross_color_y = 1 - (x-100)*0.02 * 0.1;
- wcross_color_z = 1 - (x-100)*0.02;
+ wcross_color.x = 1 - (x-100)*0.02 * 0.6;
+ wcross_color.y = 1 - (x-100)*0.02 * 0.1;
+ wcross_color.z = 1 - (x-100)*0.02;
}
else if(x > 50)
{
- wcross_color_x = 1;
- wcross_color_y = 1;
- wcross_color_z = 0.2 + (x-50)*0.02 * 0.8;
+ wcross_color.x = 1;
+ wcross_color.y = 1;
+ wcross_color.z = 0.2 + (x-50)*0.02 * 0.8;
}
else if(x > 20)
{
- wcross_color_x = 1;
- wcross_color_y = (x-20)*90/27/100;
- wcross_color_z = (x-20)*90/27/100 * 0.2;
+ wcross_color.x = 1;
+ wcross_color.y = (x-20)*90/27/100;
+ wcross_color.z = (x-20)*90/27/100 * 0.2;
}
else
{
- wcross_color_x = 1;
- wcross_color_y = 0;
+ wcross_color.x = 1;
+ wcross_color.y = 0;
}
break;
}
{
if(autocvar_cl_reticle_stretch)
{
- reticle_size_x = vid_conwidth;
- reticle_size_y = vid_conheight;
- reticle_pos_x = 0;
- reticle_pos_y = 0;
+ reticle_size.x = vid_conwidth;
+ reticle_size.y = vid_conheight;
+ reticle_pos.x = 0;
+ reticle_pos.y = 0;
}
else
{
- reticle_size_x = max(vid_conwidth, vid_conheight);
- reticle_size_y = max(vid_conwidth, vid_conheight);
- reticle_pos_x = (vid_conwidth - reticle_size.x) / 2;
- reticle_pos_y = (vid_conheight - reticle_size.y) / 2;
+ reticle_size.x = max(vid_conwidth, vid_conheight);
+ reticle_size.y = max(vid_conwidth, vid_conheight);
+ reticle_pos.x = (vid_conwidth - reticle_size.x) / 2;
+ reticle_pos.y = (vid_conheight - reticle_size.y) / 2;
}
if(zoomscript_caught)
{
if(autocvar_hud_contents_blur && contentavgalpha)
{
- content_blurpostprocess_x = 1;
- content_blurpostprocess_y = contentavgalpha * autocvar_hud_contents_blur;
- content_blurpostprocess_z = contentavgalpha * autocvar_hud_contents_blur_alpha;
+ content_blurpostprocess.x = 1;
+ content_blurpostprocess.y = contentavgalpha * autocvar_hud_contents_blur;
+ content_blurpostprocess.z = contentavgalpha * autocvar_hud_contents_blur_alpha;
}
else
{
- content_blurpostprocess_x = 0;
- content_blurpostprocess_y = 0;
- content_blurpostprocess_z = 0;
+ content_blurpostprocess.x = 0;
+ content_blurpostprocess.y = 0;
+ content_blurpostprocess.z = 0;
}
}
}
if(autocvar_hud_damage && !getstati(STAT_FROZEN))
{
- splash_size_x = max(vid_conwidth, vid_conheight);
- splash_size_y = max(vid_conwidth, vid_conheight);
- splash_pos_x = (vid_conwidth - splash_size.x) / 2;
- splash_pos_y = (vid_conheight - splash_size.y) / 2;
+ splash_size.x = max(vid_conwidth, vid_conheight);
+ splash_size.y = max(vid_conwidth, vid_conheight);
+ splash_pos.x = (vid_conwidth - splash_size.x) / 2;
+ splash_pos.y = (vid_conheight - splash_size.y) / 2;
float myhealth_flash_temp;
myhealth = getstati(STAT_HEALTH);
{
if(autocvar_hud_damage_blur && myhealth_flash_temp)
{
- damage_blurpostprocess_x = 1;
- damage_blurpostprocess_y = bound(0, myhealth_flash_temp, 1) * autocvar_hud_damage_blur;
- damage_blurpostprocess_z = bound(0, myhealth_flash_temp, 1) * autocvar_hud_damage_blur_alpha;
+ damage_blurpostprocess.x = 1;
+ damage_blurpostprocess.y = bound(0, myhealth_flash_temp, 1) * autocvar_hud_damage_blur;
+ damage_blurpostprocess.z = bound(0, myhealth_flash_temp, 1) * autocvar_hud_damage_blur_alpha;
}
else
{
- damage_blurpostprocess_x = 0;
- damage_blurpostprocess_y = 0;
- damage_blurpostprocess_z = 0;
+ damage_blurpostprocess.x = 0;
+ damage_blurpostprocess.y = 0;
+ damage_blurpostprocess.z = 0;
}
}
}
dir = normalize(view_origin - current_position);
n = mouse_angles.z;
mouse_angles = vectoangles(dir);
- mouse_angles_x = mouse_angles.x * -1;
- mouse_angles_z = n;
+ mouse_angles.x = mouse_angles.x * -1;
+ mouse_angles.z = n;
}
else
{
}
}
- while (mouse_angles.x < -180) mouse_angles_x = mouse_angles.x + 360;
- while (mouse_angles.x > 180) mouse_angles_x = mouse_angles.x - 360;
- while (mouse_angles.y < -180) mouse_angles_y = mouse_angles.y + 360;
- while (mouse_angles.y > 180) mouse_angles_y = mouse_angles.y - 360;
+ while (mouse_angles.x < -180) mouse_angles.x = mouse_angles.x + 360;
+ while (mouse_angles.x > 180) mouse_angles.x = mouse_angles.x - 360;
+ while (mouse_angles.y < -180) mouse_angles.y = mouse_angles.y + 360;
+ while (mouse_angles.y > 180) mouse_angles.y = mouse_angles.y - 360;
// Fix difference when angles don't have the same sign
delta = '0 0 0';
attenuation = 1 / max(1, attenuation);
current_angles += (mouse_angles - current_angles + delta) * attenuation;
- while (current_angles.x < -180) current_angles_x = current_angles.x + 360;
- while (current_angles.x > 180) current_angles_x = current_angles.x - 360;
- while (current_angles.y < -180) current_angles_y = current_angles.y + 360;
- while (current_angles.y > 180) current_angles_y = current_angles.y - 360;
+ while (current_angles.x < -180) current_angles.x = current_angles.x + 360;
+ while (current_angles.x > 180) current_angles.x = current_angles.x - 360;
+ while (current_angles.y < -180) current_angles.y = current_angles.y + 360;
+ while (current_angles.y > 180) current_angles.y = current_angles.y - 360;
// Camera position
tmp = '0 0 0';
if( camera_direction.x )
{
- tmp_x = camera_direction.x * cos(current_angles.y * DEG2RAD);
- tmp_y = camera_direction.x * sin(current_angles.y * DEG2RAD);
+ tmp.x = camera_direction.x * cos(current_angles.y * DEG2RAD);
+ tmp.y = camera_direction.x * sin(current_angles.y * DEG2RAD);
if( autocvar_camera_forward_follows && !autocvar_camera_look_player )
- tmp_z = camera_direction.x * -sin(current_angles.x * DEG2RAD);
+ tmp.z = camera_direction.x * -sin(current_angles.x * DEG2RAD);
++dimensions;
}
// we want to be onscreen
if(o.x < 0)
- o_x = 0;
+ o.x = 0;
if(o.y < 0)
- o_y = 0;
+ o.y = 0;
if(o.x > vid_conwidth - w)
- o_x = vid_conwidth - w;
+ o.x = vid_conwidth - w;
if(o.y > vid_conheight - h)
- o_x = vid_conheight - h;
+ o.x = vid_conheight - h;
o.x += 0.5 * (w - sw);
{
rgb = fixrgbexcess_move(rgb, '0 1 0', '0 0 1');
if(rgb.z > 1)
- rgb_z = 1;
+ rgb.z = 1;
}
else if(rgb.z > 1)
{
rgb = fixrgbexcess_move(rgb, '0 0 1', '0 1 0');
if(rgb.y > 1)
- rgb_y = 1;
+ rgb.y = 1;
}
}
else if(rgb.y > 1)
{
rgb = fixrgbexcess_move(rgb, '1 0 0', '0 0 1');
if(rgb.z > 1)
- rgb_z = 1;
+ rgb.z = 1;
}
else if(rgb.z > 1)
{
rgb = fixrgbexcess_move(rgb, '0 0 1', '1 0 0');
if(rgb.x > 1)
- rgb_x = 1;
+ rgb.x = 1;
}
}
else if(rgb.z > 1)
{
rgb = fixrgbexcess_move(rgb, '1 0 0', '0 1 0');
if(rgb.y > 1)
- rgb_y = 1;
+ rgb.y = 1;
}
else if(rgb.y > 1)
{
rgb = fixrgbexcess_move(rgb, '0 1 0', '1 0 0');
if(rgb.x > 1)
- rgb_x = 1;
+ rgb.x = 1;
}
}
return rgb;
ang = atan2(-d.x, -d.y);
#endif
}
- o_z = 0;
+ o.z = 0;
float edgedistance_min, crosshairdistance;
edgedistance_min = min((o.y - (vid_conheight * waypointsprite_edgeoffset_top)),
vector ang;
ang = self.angles;
- ang_x = -ang.x;
+ ang.x = -ang.x;
makevectors(ang);
a = 1 - (time - self.fade_time) * self.fade_rate;
makevectors(e.angles);
vector v;
- v_x = e.velocity * v_forward;
- v_y = e.velocity * v_right;
- v_z = 0;
+ v.x = e.velocity * v_forward;
+ v.y = e.velocity * v_right;
+ v.z = 0;
// we want to match like this:
// the 8 directions shall be "evenly spaced"
if(k == "origin")
{
o = stov(strcat("'", v, "'"));
- mapMins_x = min(mapMins.x, o.x);
- mapMins_y = min(mapMins.y, o.y);
- mapMins_z = min(mapMins.z, o.z);
- mapMaxs_x = max(mapMaxs.x, o.x);
- mapMaxs_y = max(mapMaxs.y, o.y);
- mapMaxs_z = max(mapMaxs.z, o.z);
+ mapMins.x = min(mapMins.x, o.x);
+ mapMins.y = min(mapMins.y, o.y);
+ mapMins.z = min(mapMins.z, o.z);
+ mapMaxs.x = max(mapMaxs.x, o.x);
+ mapMaxs.y = max(mapMaxs.y, o.y);
+ mapMaxs.z = max(mapMaxs.z, o.z);
}
else if(k == "race_place")
{
print("Map ", pFilename, " contains an incorrect size line, mins have to be < maxs\n");
else
{
- MapInfo_Map_mins_x = a;
- MapInfo_Map_mins_y = b;
- MapInfo_Map_mins_z = c;
- MapInfo_Map_maxs_x = d;
- MapInfo_Map_maxs_y = e;
- MapInfo_Map_maxs_z = f;
+ MapInfo_Map_mins.x = a;
+ MapInfo_Map_mins.y = b;
+ MapInfo_Map_mins.z = c;
+ MapInfo_Map_maxs.x = d;
+ MapInfo_Map_maxs.y = e;
+ MapInfo_Map_maxs.z = f;
}
}
}
if(((self.flags & FL_FLY) && (self.spawnflags & MONSTERFLAG_FLY_VERTICAL)) || (self.flags & FL_SWIM))
{
- pos_z = random() * 200;
+ pos.z = random() * 200;
if(random() >= 0.5)
pos.z *= -1;
}
if(p == 0)
{
- out_x = 0;
- out_y = 0;
+ out.x = 0;
+ out.y = 0;
if(y == 31)
- out_z = -1;
+ out.z = -1;
else
- out_z = +1;
+ out.z = +1;
}
else
{
y = .19634954084936207740 * y;
p = .19634954084936207740 * p - 1.57079632679489661922;
- out_x = cos(y) * cos(p);
- out_y = sin(y) * cos(p);
- out_z = -sin(p);
+ out.x = cos(y) * cos(p);
+ out.y = sin(y) * cos(p);
+ out.z = -sin(p);
}
//print("decompressed: ", vtos(out), "\n");
return 0;
//print("compress: ", vtos(vec), "\n");
ang = vectoangles(vec);
- ang_x = -ang.x;
+ ang.x = -ang.x;
if(ang.x < -90)
ang.x += 360;
if(ang.x < -90 && ang.x > +90)
MOVE_WORLDONLY,
world);
if(!trace_startsolid)
- mi_min_x = trace_endpos.x;
+ mi_min.x = trace_endpos.x;
tracebox('0 1 0' * mi.y,
'1 0 0' * mi.x + '0 0 1' * mi.z,
MOVE_WORLDONLY,
world);
if(!trace_startsolid)
- mi_min_y = trace_endpos.y;
+ mi_min.y = trace_endpos.y;
tracebox('0 0 1' * mi.z,
'1 0 0' * mi.x + '0 1 0' * mi.y,
MOVE_WORLDONLY,
world);
if(!trace_startsolid)
- mi_min_z = trace_endpos.z;
+ mi_min.z = trace_endpos.z;
tracebox('1 0 0' * ma.x,
'0 1 0' * mi.y + '0 0 1' * mi.z,
MOVE_WORLDONLY,
world);
if(!trace_startsolid)
- mi_max_x = trace_endpos.x;
+ mi_max.x = trace_endpos.x;
tracebox('0 1 0' * ma.y,
'1 0 0' * mi.x + '0 0 1' * mi.z,
MOVE_WORLDONLY,
world);
if(!trace_startsolid)
- mi_max_y = trace_endpos.y;
+ mi_max.y = trace_endpos.y;
tracebox('0 0 1' * ma.z,
'1 0 0' * mi.x + '0 1 0' * mi.y,
MOVE_WORLDONLY,
world);
if(!trace_startsolid)
- mi_max_z = trace_endpos.z;
+ mi_max.z = trace_endpos.z;
}
}
}
// hue = 60 * (rgb_y - rgb_z) / (ma - mi);
if(hue <= 1)
{
- rgb_x = ma;
- rgb_y = hue * (ma - mi) + mi;
- rgb_z = mi;
+ rgb.x = ma;
+ rgb.y = hue * (ma - mi) + mi;
+ rgb.z = mi;
}
//else if(ma == rgb_y)
// hue = 60 * (rgb_z - rgb_x) / (ma - mi) + 120;
else if(hue <= 2)
{
- rgb_x = (2 - hue) * (ma - mi) + mi;
- rgb_y = ma;
- rgb_z = mi;
+ rgb.x = (2 - hue) * (ma - mi) + mi;
+ rgb.y = ma;
+ rgb.z = mi;
}
else if(hue <= 3)
{
- rgb_x = mi;
- rgb_y = ma;
- rgb_z = (hue - 2) * (ma - mi) + mi;
+ rgb.x = mi;
+ rgb.y = ma;
+ rgb.z = (hue - 2) * (ma - mi) + mi;
}
//else // if(ma == rgb_z)
// hue = 60 * (rgb_x - rgb_y) / (ma - mi) + 240;
else if(hue <= 4)
{
- rgb_x = mi;
- rgb_y = (4 - hue) * (ma - mi) + mi;
- rgb_z = ma;
+ rgb.x = mi;
+ rgb.y = (4 - hue) * (ma - mi) + mi;
+ rgb.z = ma;
}
else if(hue <= 5)
{
- rgb_x = (hue - 4) * (ma - mi) + mi;
- rgb_y = mi;
- rgb_z = ma;
+ rgb.x = (hue - 4) * (ma - mi) + mi;
+ rgb.y = mi;
+ rgb.z = ma;
}
//else if(ma == rgb_x)
// hue = 60 * (rgb_y - rgb_z) / (ma - mi);
else // if(hue <= 6)
{
- rgb_x = ma;
- rgb_y = mi;
- rgb_z = (6 - hue) * (ma - mi) + mi;
+ rgb.x = ma;
+ rgb.y = mi;
+ rgb.z = (6 - hue) * (ma - mi) + mi;
}
return rgb;
mi = min(rgb.x, rgb.y, rgb.z);
ma = max(rgb.x, rgb.y, rgb.z);
- hsv_x = rgb_mi_ma_to_hue(rgb, mi, ma);
- hsv_z = ma;
+ hsv.x = rgb_mi_ma_to_hue(rgb, mi, ma);
+ hsv.z = ma;
if(ma == 0)
- hsv_y = 0;
+ hsv.y = 0;
else
- hsv_y = 1 - mi/ma;
+ hsv.y = 1 - mi/ma;
return hsv;
}
mi = min(rgb.x, rgb.y, rgb.z);
ma = max(rgb.x, rgb.y, rgb.z);
- hsl_x = rgb_mi_ma_to_hue(rgb, mi, ma);
+ hsl.x = rgb_mi_ma_to_hue(rgb, mi, ma);
- hsl_z = 0.5 * (mi + ma);
+ hsl.z = 0.5 * (mi + ma);
if(mi == ma)
- hsl_y = 0;
+ hsl.y = 0;
else if(hsl.z <= 0.5)
- hsl_y = (ma - mi) / (2*hsl.z);
+ hsl.y = (ma - mi) / (2*hsl.z);
else // if(hsl_z > 0.5)
- hsl_y = (ma - mi) / (2 - 2*hsl.z);
+ hsl.y = (ma - mi) / (2 - 2*hsl.z);
return hsl;
}
{
if(b != 0)
{
- v_x = v_y = -c / b;
- v_z = 1;
+ v.x = v.y = -c / b;
+ v.z = 1;
}
else
{
if(c == 0)
{
// actually, every number solves the equation!
- v_z = 1;
+ v.z = 1;
}
}
}
D = sqrt(D);
if(a > 0) // put the smaller solution first
{
- v_x = ((-b)-D) / (2*a);
- v_y = ((-b)+D) / (2*a);
+ v.x = ((-b)-D) / (2*a);
+ v.y = ((-b)+D) / (2*a);
}
else
{
- v_x = (-b+D) / (2*a);
- v_y = (-b-D) / (2*a);
+ v.x = (-b+D) / (2*a);
+ v.y = (-b-D) / (2*a);
}
- v_z = 1;
+ v.z = 1;
}
else
{
// complex solutions!
D = sqrt(-D);
- v_x = -b / (2*a);
+ v.x = -b / (2*a);
if(a > 0)
- v_y = D / (2*a);
+ v.y = D / (2*a);
else
- v_y = -D / (2*a);
- v_z = 0;
+ v.y = -D / (2*a);
+ v.z = 0;
}
}
return v;
vector decompressShotOrigin(int f)
{
vector v;
- v_x = ((f & 0xFF0000) / 0x10000) / 2;
- v_y = ((f & 0xFF00) / 0x100 - 128) / 4;
- v_z = ((f & 0xFF) - 128) / 4;
+ v.x = ((f & 0xFF0000) / 0x10000) / 2;
+ v.y = ((f & 0xFF00) / 0x100 - 128) / 4;
+ v.z = ((f & 0xFF) - 128) / 4;
return v;
}
healthdamage = (h - 1) / (1 - armorblock); // damage we can take if we could use more health
armordamage = a + (h - 1); // damage we can take if we could use more armor
armorideal = healthdamage * armorblock;
- v_y = armorideal;
+ v.y = armorideal;
if(armordamage < healthdamage)
{
- v_x = armordamage;
- v_z = 1;
+ v.x = armordamage;
+ v.z = 1;
}
else
{
- v_x = healthdamage;
- v_z = 0;
+ v.x = healthdamage;
+ v.z = 0;
}
return v;
}
vector v;
if (deathtype == DEATH_DROWN) // Why should armor help here...
armorblock = 0;
- v_y = bound(0, damage * armorblock, a); // save
- v_x = bound(0, damage - v.y, damage); // take
- v_z = 0;
+ v.y = bound(0, damage * armorblock, a); // save
+ v.x = bound(0, damage - v.y, damage); // take
+ v.z = 0;
return v;
}
#endif
vector ReadInt48_t()
{
vector v;
- v_x = ReadInt24_t();
- v_y = ReadInt24_t();
- v_z = 0;
+ v.x = ReadInt24_t();
+ v.y = ReadInt24_t();
+ v.z = 0;
return v;
}
vector ReadInt72_t()
{
vector v;
- v_x = ReadInt24_t();
- v_y = ReadInt24_t();
- v_z = ReadInt24_t();
+ v.x = ReadInt24_t();
+ v.y = ReadInt24_t();
+ v.z = ReadInt24_t();
return v;
}
#else
vector vec2(vector v)
{
- v_z = 0;
+ v.z = 0;
return v;
}
m1 = box.mins + box.origin;
m2 = box.maxs + box.origin;
- nearest_x = bound(m1_x, org.x, m2_x);
- nearest_y = bound(m1_y, org.y, m2_y);
- nearest_z = bound(m1_z, org.z, m2_z);
+ nearest.x = bound(m1_x, org.x, m2_x);
+ nearest.y = bound(m1_y, org.y, m2_y);
+ nearest.z = bound(m1_z, org.z, m2_z);
return nearest;
}
#ifdef SVQC
vector combine_to_vector(float x, float y, float z)
{
- vector result; result_x = x; result_y = y; result_z = z;
+ vector result; result.x = x; result.y = y; result.z = z;
return result;
}
vector vec3(float x, float y, float z)
{
vector v;
- v_x = x;
- v_y = y;
- v_z = z;
+ v.x = x;
+ v.y = y;
+ v.z = z;
return v;
}
vector animfixfps(entity e, vector a, vector b)
{
// multi-frame anim: keep as-is
- if(a_y == 1)
+ if(a.y == 1)
{
float dur;
dur = frameduration(e.modelindex, a.x);
dur = frameduration(e.modelindex, a.x);
}
if(dur > 0)
- a_z = 1.0 / dur;
+ a.z = 1.0 / dur;
}
return a;
}
vector findperpendicular(vector v)
{
vector p;
- p_x = v.z;
- p_y = -v.x;
- p_z = v.y;
+ p.x = v.z;
+ p.y = -v.x;
+ p.z = v.y;
return normalize(cliptoplane(p, v));
}
else
{
makevectors('0 360 0' * (0.75 + (counter - 0.5) / (shots - 1)));
- s_y = v_forward.x;
- s_z = v_forward.y;
+ s.y = v_forward.x;
+ s.z = v_forward.y;
}
s = s * WEP_CVAR_PRI(crylink, spread) * g_weaponspreadfactor;
W_SetupProjVelocity_Explicit(proj, w_shotdir + right * s.y + up * s.z, v_up, WEP_CVAR_PRI(crylink, speed), 0, 0, 0, false);
else
{
makevectors('0 360 0' * (0.75 + (counter - 0.5) / (shots - 1)));
- s_y = v_forward.x;
- s_z = v_forward.y;
+ s.y = v_forward.x;
+ s.z = v_forward.y;
}
s = s * WEP_CVAR_SEC(crylink, spread) * g_weaponspreadfactor;
s = w_shotdir + right * s.y + up * s.z;
else
{
makevectors('0 360 0' * (0.75 + (counter - 0.5) / (shots - 1)));
- s_y = v_forward.x;
- s_z = v_forward.y;
+ s.y = v_forward.x;
+ s.z = v_forward.y;
}
s = s * WEP_CVAR_SEC(hagar, load_spread) * g_weaponspreadfactor;
{
// perfect circle effect lines
makevectors('0 360 0' * (0.75 + (counter - 0.5) / divisions));
- angle_y = v_forward.x;
- angle_z = v_forward.y;
+ angle.y = v_forward.x;
+ angle.z = v_forward.y;
// first do the spread_to_min effect
deviation = angle * spread_to_min;
WepSet WepSet_GetFromStat()
{
WepSet w = '0 0 0';
- w_x = getstati(STAT_WEAPONS);
+ w.x = getstati(STAT_WEAPONS);
#if WEP_MAXCOUNT > 24
- w_y = getstati(STAT_WEAPONS2);
+ w.y = getstati(STAT_WEAPONS2);
#if WEP_MAXCOUNT > 48
- w_z = getstati(STAT_WEAPONS3);
+ w.z = getstati(STAT_WEAPONS3);
#endif
#endif
return w;
vector oldup = v_up;
vector v = eyetarget - self.origin;
vector modeleyetarget;
- modeleyetarget_x = v * v_forward;
- modeleyetarget_y = 0-v * v_right;
- modeleyetarget_z = v * v_up;
+ modeleyetarget.x = v * v_forward;
+ modeleyetarget.y = 0-v * v_right;
+ modeleyetarget.z = v * v_up;
// this is an eyeball, make it point at the target location
// first get all the data we can...
vector relorg = skel_get_bonerel(self.skeletonindex, bonenum);
// get the vector from the eyeball to the target
vector u = modeleyetarget - boneorg;
// now transform it inversely by the parent matrix to produce new rel vectors
- v_x = u * parentforward;
- v_y = u * parentright;
- v_z = u * parentup;
+ v.x = u * parentforward;
+ v.y = u * parentright;
+ v.z = u * parentup;
vector ang = vectoangles2(v, relup);
- ang_x = 0 - ang.x;
+ ang.x = 0 - ang.x;
makevectors(ang);
// set the relative bone matrix
skel_set_bone(self.skeletonindex, bonenum, relorg);
//idea: LordHavoc
//darkplaces implementation: LordHavoc
//globals:
-.float dphitcontentsmask; // if non-zero on the entity passed to traceline/tracebox/tracetoss this will override the normal collidable contents rules and instead hit these contents values (for example AI can use tracelines that hit DONOTENTER if it wants to, by simply changing this field on the entity passed to traceline), this affects normal movement as well as trace calls
-float trace_dpstartcontents; // DPCONTENTS_ value at start position of trace
-float trace_dphitcontents; // DPCONTENTS_ value of impacted surface (not contents at impact point, just contents of the surface that was hit)
-float trace_dphitq3surfaceflags; // Q3SURFACEFLAG_ value of impacted surface
+.int dphitcontentsmask; // if non-zero on the entity passed to traceline/tracebox/tracetoss this will override the normal collidable contents rules and instead hit these contents values (for example AI can use tracelines that hit DONOTENTER if it wants to, by simply changing this field on the entity passed to traceline), this affects normal movement as well as trace calls
+int trace_dpstartcontents; // DPCONTENTS_ value at start position of trace
+int trace_dphitcontents; // DPCONTENTS_ value of impacted surface (not contents at impact point, just contents of the surface that was hit)
+int trace_dphitq3surfaceflags; // Q3SURFACEFLAG_ value of impacted surface
string trace_dphittexturename; // texture name of impacted surface
//constants:
const int DPCONTENTS_SOLID = 1; // hit a bmodel, not a bounding box
vector oldup = v_up;
vector v = eyetarget - self.origin;
vector modeleyetarget;
- modeleyetarget_x = v * v_forward;
- modeleyetarget_y = 0-v * v_right;
- modeleyetarget_z = v * v_up;
+ modeleyetarget.x = v * v_forward;
+ modeleyetarget.y = 0-v * v_right;
+ modeleyetarget.z = v * v_up;
// this is an eyeball, make it point at the target location
// first get all the data we can...
vector relorg = skel_get_bonerel(self.skeletonindex, bonenum);
// get the vector from the eyeball to the target
vector u = modeleyetarget - boneorg;
// now transform it inversely by the parent matrix to produce new rel vectors
- v_x = u * parentforward;
- v_y = u * parentright;
- v_z = u * parentup;
+ v.x = u * parentforward;
+ v.y = u * parentright;
+ v.z = u * parentup;
vector ang = vectoangles2(v, relup);
- ang_x = 0 - ang.x;
+ ang.x = 0 - ang.x;
makevectors(ang);
// set the relative bone matrix
skel_set_bone(self.skeletonindex, bonenum, relorg);
void draw_Picture(vector theOrigin, string pic, vector theSize, vector theColor, float theAlpha)
{
- if(theSize_x == 0 || theSize.y <= 0) // no default sizing please
+ if(theSize.x == 0 || theSize.y <= 0) // no default sizing please
return;
pic = draw_UseSkinFor(pic);
drawpic(boxToGlobal(theOrigin, draw_shift, draw_scale), pic, boxToGlobalSize(theSize, draw_scale), theColor, theAlpha * draw_alpha, 0);
vector v;
v = '0 0 0';
//float r;
- v_x = stringwidth(theText, ICanHasKallerz, globalToBoxSize(boxToGlobalSize(SizeThxBye, draw_scale), draw_fontscale));
+ v.x = stringwidth(theText, ICanHasKallerz, globalToBoxSize(boxToGlobalSize(SizeThxBye, draw_scale), draw_fontscale));
v = globalToBoxSize(v, draw_scale);
return v.x;
}
if(theSize.x > 1)
{
theOrigin.x -= 0.5 * (theSize.x - 1);
- theSize_x = 1;
+ theSize.x = 1;
}
if(theSize.y > 1)
{
theOrigin.y -= 0.5 * (theSize.y - 1);
- theSize_y = 1;
+ theSize.y = 1;
}
- theOrigin_x = bound(0, theOrigin.x, 1 - theSize.x);
- theOrigin_y = bound(0, theOrigin.y, 1 - theSize.y);
+ theOrigin.x = bound(0, theOrigin.x, 1 - theSize.x);
+ theOrigin.y = bound(0, theOrigin.y, 1 - theSize.y);
other.parent = me;
other.Container_origin = theOrigin;
if(sz.x <= 0 || sz.y <= 0)
{
// image is broken or doesn't exist, set the size for the placeholder image
- sz_x = me.size.x;
- sz_y = me.size.y;
+ sz.x = me.size.x;
+ sz.y = me.size.y;
}
asp = sz.x / sz.y;
}
component = HEXDIGIT_TO_DEC(substring(me.text, i+2, 1));
if (component >= 0) // ^xr found
{
- theTempColor_x = component/15;
+ theTempColor.x = component/15;
component = HEXDIGIT_TO_DEC(substring(me.text, i+3, 1));
if (component >= 0) // ^xrg found
{
- theTempColor_y = component/15;
+ theTempColor.y = component/15;
component = HEXDIGIT_TO_DEC(substring(me.text, i+4, 1));
if (component >= 0) // ^xrgb found
{
- theTempColor_z = component/15;
+ theTempColor.z = component/15;
theColor = theTempColor;
w = draw_TextWidth(substring(me.text, i, 5), 0, me.realFontSize);
if(me.pressed == 2)
me.mouseDrag(me, me.dragScrollPos); // simulate mouseDrag event
me.updateControlTopBottom(me);
- fillSize_x = (1 - me.controlWidth);
+ fillSize.x = (1 - me.controlWidth);
if(me.alphaBG)
draw_Fill('0 0 0', '0 1 0' + fillSize, me.colorBG, me.alphaBG);
if(me.controlWidth)
string c;
float scalemode;
- v_z = 0;
+ v.z = 0;
scalemode = SCALEMODE_CROP;
case "h": scalemode = SCALEMODE_HEIGHT; goto nopic;
case "w": scalemode = SCALEMODE_WIDTH; goto nopic;
case "s": scalemode = SCALEMODE_STRETCH; goto nopic;
- case "1": case "4": case "7": v_x = 0.0; break;
- case "2": case "5": case "8": v_x = 0.5; break;
- case "3": case "6": case "9": v_x = 1.0; break;
- default: v_x = random(); break;
+ case "1": case "4": case "7": v.x = 0.0; break;
+ case "2": case "5": case "8": v.x = 0.5; break;
+ case "3": case "6": case "9": v.x = 1.0; break;
+ default: v.x = random(); break;
}
switch(c)
{
- case "7": case "8": case "9": v_y = 0.0; break;
- case "4": case "5": case "6": v_y = 0.5; break;
- case "1": case "2": case "3": v_y = 1.0; break;
- default: v_y = random(); break;
+ case "7": case "8": case "9": v.y = 0.0; break;
+ case "4": case "5": case "6": v.y = 0.5; break;
+ case "1": case "2": case "3": v.y = 1.0; break;
+ default: v.y = random(); break;
}
if(l == 0)
draw_Picture_Aligned(v, scalemode, img, a);
vector avoidplus, avoidminus;
vector v;
- avoidplus_x = (SKINAVOID_TOOLTIP_x + SKINSIZE_CURSOR_x - SKINOFFSET_CURSOR_x * SKINSIZE_CURSOR_x) / conwidth;
- avoidplus_y = (SKINAVOID_TOOLTIP_y + SKINSIZE_CURSOR_y - SKINOFFSET_CURSOR_y * SKINSIZE_CURSOR_y) / conheight;
- avoidplus_z = 0;
+ avoidplus.x = (SKINAVOID_TOOLTIP_x + SKINSIZE_CURSOR_x - SKINOFFSET_CURSOR_x * SKINSIZE_CURSOR_x) / conwidth;
+ avoidplus.y = (SKINAVOID_TOOLTIP_y + SKINSIZE_CURSOR_y - SKINOFFSET_CURSOR_y * SKINSIZE_CURSOR_y) / conheight;
+ avoidplus.z = 0;
- avoidminus_x = (SKINAVOID_TOOLTIP_x + SKINOFFSET_CURSOR_x * SKINSIZE_CURSOR_x) / conwidth + menuTooltipSize.x;
- avoidminus_y = (SKINAVOID_TOOLTIP_y + SKINOFFSET_CURSOR_y * SKINSIZE_CURSOR_y) / conheight + menuTooltipSize.y;
- avoidminus_z = 0;
+ avoidminus.x = (SKINAVOID_TOOLTIP_x + SKINOFFSET_CURSOR_x * SKINSIZE_CURSOR_x) / conwidth + menuTooltipSize.x;
+ avoidminus.y = (SKINAVOID_TOOLTIP_y + SKINOFFSET_CURSOR_y * SKINSIZE_CURSOR_y) / conheight + menuTooltipSize.y;
+ avoidminus.z = 0;
// bottom right
v = pos + avoidplus;
return true;
// bottom center
- v_x = pos.x - menuTooltipSize.x * 0.5;
+ v.x = pos.x - menuTooltipSize.x * 0.5;
if(m_testtooltipbox(v))
return true;
// bottom left
- v_x = pos.x - avoidminus.x;
+ v.x = pos.x - avoidminus.x;
if(m_testtooltipbox(v))
return true;
// top left
- v_y = pos.y - avoidminus.y;
+ v.y = pos.y - avoidminus.y;
if(m_testtooltipbox(v))
return true;
// top center
- v_x = pos.x - menuTooltipSize.x * 0.5;
+ v.x = pos.x - menuTooltipSize.x * 0.5;
if(m_testtooltipbox(v))
return true;
// top right
- v_x = pos.x + avoidplus.x;
+ v.x = pos.x + avoidplus.x;
if(m_testtooltipbox(v))
return true;
menuTooltipState = 1;
menuTooltipItem = it;
- menuTooltipOrigin_x = -1; // unallocated
+ menuTooltipOrigin.x = -1; // unallocated
if (menuTooltipText)
strunzone(menuTooltipText);
if(f > w)
w = f;
}
- menuTooltipSize_x = w + 2 * (SKINMARGIN_TOOLTIP_x / conwidth);
- menuTooltipSize_y = i * fontsize.y + 2 * (SKINMARGIN_TOOLTIP_y / conheight);
- menuTooltipSize_z = 0;
+ menuTooltipSize.x = w + 2 * (SKINMARGIN_TOOLTIP_x / conwidth);
+ menuTooltipSize.y = i * fontsize.y + 2 * (SKINMARGIN_TOOLTIP_y / conheight);
+ menuTooltipSize.z = 0;
}
break;
case 1:
maxpos = globalToBox(eX * (realconwidth - 1) + eY * (realconheight - 1), draw_shift, draw_scale);
dMouse = globalToBoxSize(dMouse, draw_scale);
menuMousePos += dMouse * cvar("menu_mouse_speed");
- menuMousePos_x = bound(minpos.x, menuMousePos.x, maxpos.x);
- menuMousePos_y = bound(minpos.y, menuMousePos.y, maxpos.y);
+ menuMousePos.x = bound(minpos.x, menuMousePos.x, maxpos.x);
+ menuMousePos.y = bound(minpos.y, menuMousePos.y, maxpos.y);
if(mouseButtonsPressed)
main.mouseDrag(main, menuMousePos);
else
return true;
}
- dir_z = dir.z + 0.1; // aim up a little more
+ dir.z = dir.z + 0.1; // aim up a little more
c = c + 1;
}
targ.solid = savesolid;
desiredang = vectoangles(v) + self.bot_badaimoffset;
//dprint(" desired:", vtos(desiredang));
if (desiredang.x >= 180)
- desiredang_x = desiredang.x - 360;
- desiredang_x = bound(-90, 0 - desiredang.x, 90);
- desiredang_z = self.v_angle.z;
+ desiredang.x = desiredang.x - 360;
+ desiredang.x = bound(-90, 0 - desiredang.x, 90);
+ desiredang.z = self.v_angle.z;
//dprint(" / ", vtos(desiredang));
//// pain throws off aim
// calculate turn angles
diffang = (desiredang - self.bot_olddesiredang);
// wrap yaw turn
- diffang_y = diffang.y - floor(diffang.y / 360) * 360;
+ diffang.y = diffang.y - floor(diffang.y / 360) * 360;
if (diffang.y >= 180)
- diffang_y = diffang.y - 360;
+ diffang.y = diffang.y - 360;
self.bot_olddesiredang = desiredang;
//dprint(" diff:", vtos(diffang));
// calculate turn angles
diffang = desiredang - self.bot_mouseaim;
// wrap yaw turn
- diffang_y = diffang.y - floor(diffang.y / 360) * 360;
+ diffang.y = diffang.y - floor(diffang.y / 360) * 360;
if (diffang.y >= 180)
- diffang_y = diffang.y - 360;
+ diffang.y = diffang.y - 360;
//dprint(" diff:", vtos(diffang));
if (time >= self.bot_aimthinktime)
diffang = self.bot_mouseaim - desiredang;
// wrap yaw turn
- diffang_y = diffang.y - floor(diffang.y / 360) * 360;
+ diffang.y = diffang.y - floor(diffang.y / 360) * 360;
if (diffang.y >= 180)
- diffang_y = diffang.y - 360;
+ diffang.y = diffang.y - 360;
desiredang = desiredang + diffang * bound(0,autocvar_bot_ai_aimskill_think,1);
// calculate turn angles
diffang = desiredang - self.v_angle;
// wrap yaw turn
- diffang_y = diffang.y - floor(diffang.y / 360) * 360;
+ diffang.y = diffang.y - floor(diffang.y / 360) * 360;
if (diffang.y >= 180)
- diffang_y = diffang.y - 360;
+ diffang.y = diffang.y - 360;
//dprint(" diff:", vtos(diffang));
// jitter tracking
//dprint(vtos(now), ":", vtos(next), "=", vtos(v), " (blend ", ftos(blend), ")\n");
//v = now * (distanceblend) + next * (1-distanceblend);
if (self.waterlevel < WATERLEVEL_SWIMMING)
- v_z = 0;
+ v.z = 0;
//dprint("walk at:", vtos(v), "\n");
//te_lightning2(world, self.origin, self.goalcurrent.origin);
bot_aimdir(v, -1);
// at skill >= 4.5, all cases allowed
if (keyboard.x > trigger)
{
- keyboard_x = 1;
+ keyboard.x = 1;
if (sk < 2.5)
- keyboard_y = 0;
+ keyboard.y = 0;
}
else if (keyboard.x < trigger1 && sk > 1.5)
{
- keyboard_x = -1;
+ keyboard.x = -1;
if (sk < 4.5)
- keyboard_y = 0;
+ keyboard.y = 0;
}
else
{
- keyboard_x = 0;
+ keyboard.x = 0;
if (sk < 1.5)
- keyboard_y = 0;
+ keyboard.y = 0;
}
if (sk < 4.5)
- keyboard_z = 0;
+ keyboard.z = 0;
if (keyboard.y > trigger)
- keyboard_y = 1;
+ keyboard.y = 1;
else if (keyboard.y < trigger1)
- keyboard_y = -1;
+ keyboard.y = -1;
else
- keyboard_y = 0;
+ keyboard.y = 0;
if (keyboard.z > trigger)
- keyboard_z = 1;
+ keyboard.z = 1;
else if (keyboard.z < trigger1)
- keyboard_z = -1;
+ keyboard.z = -1;
else
- keyboard_z = 0;
+ keyboard.z = 0;
self.havocbot_keyboard = keyboard * maxspeed;
if (self.havocbot_ducktime>time) self.BUTTON_CROUCH=true;
{
gno = (self.goalstack01.absmin + self.goalstack01.absmax) * 0.5;
deviation = vectoangles(gno - self.origin) - vectoangles(gco - self.origin);
- while (deviation.y < -180) deviation_y = deviation.y + 360;
- while (deviation.y > 180) deviation_y = deviation.y - 360;
+ while (deviation.y < -180) deviation.y = deviation.y + 360;
+ while (deviation.y > 180) deviation.y = deviation.y - 360;
if(fabs(deviation.y) < 20)
if(bunnyhopdistance < vlen(self.origin - gno))
if(vlen(self.velocity)>maxspeed)
{
deviation = vectoangles(dir) - vectoangles(self.velocity);
- while (deviation.y < -180) deviation_y = deviation.y + 360;
- while (deviation.y > 180) deviation_y = deviation.y - 360;
+ while (deviation.y < -180) deviation.y = deviation.y + 360;
+ while (deviation.y > 180) deviation.y = deviation.y - 360;
if(fabs(deviation.y)>10)
self.movement_x = 0;
float db, v, d;
vector dxy;
- dxy = self.origin - ( ( self.goalcurrent.absmin + self.goalcurrent.absmax ) * 0.5 ); dxy_z = 0;
+ dxy = self.origin - ( ( self.goalcurrent.absmin + self.goalcurrent.absmax ) * 0.5 ); dxy.z = 0;
d = vlen(dxy);
v = vlen(self.velocity - self.velocity.z * '0 0 1');
db = (pow(v,2) / (autocvar_g_jetpack_acceleration_side * 2)) + 100;
{
dir = '0 0 0';
if(self.waterlevel>WATERLEVEL_SWIMMING)
- dir_z = 1;
+ dir.z = 1;
else if(self.velocity.z >= 0 && !(self.waterlevel == WATERLEVEL_WETFEET && self.watertype == CONTENT_WATER))
self.BUTTON_JUMP = true;
else
m1 = self.goalcurrent.origin + self.goalcurrent.mins;
m2 = self.goalcurrent.origin + self.goalcurrent.maxs;
destorg = self.origin;
- destorg_x = bound(m1_x, destorg.x, m2_x);
- destorg_y = bound(m1_y, destorg.y, m2_y);
- destorg_z = bound(m1_z, destorg.z, m2_z);
+ destorg.x = bound(m1_x, destorg.x, m2_x);
+ destorg.y = bound(m1_y, destorg.y, m2_y);
+ destorg.z = bound(m1_z, destorg.z, m2_z);
diff = destorg - self.origin;
//dist = vlen(diff);
dir = normalize(diff);
- flatdir = diff;flatdir_z = 0;
+ flatdir = diff;flatdir.z = 0;
flatdir = normalize(flatdir);
gco = (self.goalcurrent.absmin + self.goalcurrent.absmax) * 0.5;
}
dir = flatdir;
- evadeobstacle_z = 0;
- evadelava_z = 0;
+ evadeobstacle.z = 0;
+ evadelava.z = 0;
makevectors(self.v_angle.y * '0 1 0');
if(evadeobstacle!='0 0 0'||evadelava!='0 0 0')
if(self.goalcurrent.origin.z + self.goalcurrent.mins.z > self.origin.z + self.mins.z)
{
if(self.origin.z + self.mins.z < self.ladder_entity.origin.z + self.ladder_entity.maxs.z)
- dir_z = 1;
+ dir.z = 1;
}
else
{
if(self.origin.z + self.mins.z > self.ladder_entity.origin.z + self.ladder_entity.mins.z)
- dir_z = -1;
+ dir.z = -1;
}
}
self.nextaim = time + 0.1;
selfvel = self.velocity;
if (!self.waterlevel)
- selfvel_z = 0;
+ selfvel.z = 0;
if (self.enemy)
{
enemyvel = self.enemy.velocity;
if (!self.enemy.waterlevel)
- enemyvel_z = 0;
+ enemyvel.z = 0;
lag_additem(time + self.ping, 0, 0, self.enemy, self.origin, selfvel, (self.enemy.absmin + self.enemy.absmax) * 0.5, enemyvel);
}
else
// Heading
vector dir = ( ( self.goalcurrent.absmin + self.goalcurrent.absmax ) * 0.5 ) - (self.origin + self.view_ofs);
- dir_z = 0;
+ dir.z = 0;
bot_aimdir(dir, -1);
// Go!
}
move = end - start;
- move_z = 0;
+ move.z = 0;
org = start;
dist = totaldist = vlen(move);
dir = normalize(move);
}
org = ent.origin + 0.5 * (ent.mins + ent.maxs);
- org_z = ent.origin.z + ent.mins.z - PL_MIN_z; // player height
+ org.z = ent.origin.z + ent.mins.z - PL_MIN_z; // player height
// TODO possibly make other code have the same support for bboxes
if(ent.tag_entity)
org = org + ent.tag_entity.origin;
vector wm1, wm2;
wm1 = w.origin + w.mins;
wm2 = w.origin + w.maxs;
- v_x = bound(wm1_x, org.x, wm2_x);
- v_y = bound(wm1_y, org.y, wm2_y);
- v_z = bound(wm1_z, org.z, wm2_z);
+ v.x = bound(wm1_x, org.x, wm2_x);
+ v.y = bound(wm1_y, org.y, wm2_y);
+ v.z = bound(wm1_z, org.z, wm2_z);
}
else
v = w.origin;
m1 = head.origin + head.mins;
m2 = head.origin + head.maxs;
v = self.origin;
- v_x = bound(m1_x, v.x, m2_x);
- v_y = bound(m1_y, v.y, m2_y);
- v_z = bound(m1_z, v.z, m2_z);
+ v.x = bound(m1_x, v.x, m2_x);
+ v.y = bound(m1_y, v.y, m2_y);
+ v.z = bound(m1_z, v.z, m2_z);
}
else
v = head.origin;
diff = v - self.origin;
- diff_z = max(0, diff.z);
+ diff.z = max(0, diff.z);
if (vlen(diff) < maxdist)
{
head.wpconsidered = true;
{
m1 = wp.absmin;
m2 = wp.absmax;
- v_x = bound(m1_x, p.x, m2_x);
- v_y = bound(m1_y, p.y, m2_y);
- v_z = bound(m1_z, p.z, m2_z);
+ v.x = bound(m1_x, p.x, m2_x);
+ v.y = bound(m1_y, p.y, m2_y);
+ v.z = bound(m1_z, p.z, m2_z);
}
else
v = wp.origin;
while (head)
{
v = head.origin;
- v_x = bound(m1_x, v.x, m2_x);
- v_y = bound(m1_y, v.y, m2_y);
- v_z = bound(m1_z, v.z, m2_z);
+ v.x = bound(m1_x, v.x, m2_x);
+ v.y = bound(m1_y, v.y, m2_y);
+ v.z = bound(m1_z, v.z, m2_z);
o = (head.absmin + head.absmax) * 0.5;
d = head.bot_dodgerating - vlen(o - v);
if (d > 0)
continue;
}
sv = e.origin;
- 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);
+ 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;
em1 = e.origin + e.mins;
em2 = e.origin + e.maxs;
- ev_x = bound(em1_x, ev.x, em2_x);
- ev_y = bound(em1_y, ev.y, em2_y);
- ev_z = bound(em1_z, ev.z, em2_z);
+ ev.x = bound(em1_x, ev.x, em2_x);
+ ev.y = bound(em1_y, ev.y, em2_y);
+ ev.z = bound(em1_z, ev.z, em2_z);
dv = ev - sv;
- dv_z = 0;
+ dv.z = 0;
if (vlen(dv) >= 1050) // max search distance in XY
{
++relink_lengthculled;
return;
}
vector a = vectoangles(e.origin - self.origin);
- a_x = -a.x; // don't ask
+ a.x = -a.x; // don't ask
self.angles_x = a.x;
self.angles_y = a.y;
// we leave Rick Roll alone
e.enemy.skin = 1;
setsize(e.enemy, '0 0 0', '0 0 0');
end = normalize(self.origin + self.view_ofs - e.aiment.origin);
- end_x = (end.x > 0) * 2 - 1;
- end_y = (end.y > 0) * 2 - 1;
- end_z = (end.z > 0) * 2 - 1;
+ end.x = (end.x > 0) * 2 - 1;
+ end.y = (end.y > 0) * 2 - 1;
+ end.z = (end.z > 0) * 2 - 1;
if(argc == 4)
setorigin(e.enemy, stov(argv(3)));
else
// check for a jump-out-of-water
makevectors (self.angles);
start = self.origin;
- start_z = start.z + 8;
- v_forward_z = 0;
+ start.z = start.z + 8;
+ v_forward.z = 0;
normalize(v_forward);
end = start + v_forward*24;
traceline (start, end, true, self);
if (trace_fraction < 1)
{ // solid at waist
- start_z = start.z + self.maxs.z - 8;
+ start.z = start.z + self.maxs.z - 8;
end = start + v_forward*24;
self.movedir = trace_plane_normal * -50;
traceline (start, end, true, self);
{
vector vel_local;
- vel_local_x = v_forward * self.velocity;
- vel_local_y = v_right * self.velocity;
- vel_local_z = v_up * self.velocity;
+ vel_local.x = v_forward * self.velocity;
+ vel_local.y = v_right * self.velocity;
+ vel_local.z = v_up * self.velocity;
self.angles_x = racecar_angle(vel_local.x, vel_local.z);
self.angles_z = racecar_angle(-vel_local.y, vel_local.z);
float IsMoveInDirection(vector mv, float angle) // key mix factor
{
- if(mv_x == 0 && mv_y == 0)
+ if(mv.x == 0 && mv.y == 0)
return 0; // avoid division by zero
angle -= RAD2DEG * atan2(mv.y, mv.x);
angle = remainder(angle, 360) / 45;
return;
curvel = self.velocity;
- curvel_z = 0;
+ curvel.z = 0;
curspeed = vlen(curvel);
if(wishspeed > curspeed * 1.01)
// fix speedhacks :P
wishvel = normalize(wishvel) * min(vlen(wishvel) / maxairspd, 1);
// add the unused velocity as up component
- wishvel_z = 0;
+ wishvel.z = 0;
// if(self.BUTTON_JUMP)
- wishvel_z = sqrt(max(0, 1 - wishvel * wishvel));
+ wishvel.z = sqrt(max(0, 1 - wishvel * wishvel));
// it is now normalized, so...
float a_side, a_up, a_add, a_diff;
wishvel.x *= fxy;
wishvel.y *= fxy;
- wishvel_z = (wishvel.z - autocvar_sv_gravity) * fz + autocvar_sv_gravity;
+ wishvel.z = (wishvel.z - autocvar_sv_gravity) * fz + autocvar_sv_gravity;
float fvel;
fvel = min(1, vlen(wishvel) / best);
}
v = self.velocity;
- v_z = 0;
+ v.z = 0;
f = vlen(v);
if(f > 0)
{
{
vector curdir;
curdir = self.velocity;
- curdir_z = 0;
+ curdir.z = 0;
curdir = normalize(curdir);
airaccel = airaccel + (autocvar_sv_airstopaccelerate*maxspd_mod - airaccel) * max(0, -(curdir * wishdir));
}
for(i = 0; i < q; ++i)
{
vector v;
- v_x = a.x + random() * b.x;
- v_y = a.y + random() * b.y;
- v_z = a.z + random() * b.z;
+ v.x = a.x + random() * b.x;
+ v.y = a.y + random() * b.y;
+ v.z = a.z + random() * b.z;
traceline(v, v, MOVE_WORLDONLY, world);
if(trace_startsolid)
++c;
case "--res": // minor alias
case "--resolution": { ++i; radarmapper.size_x = stof(argv(i)); ++i; radarmapper.size_y = stof(argv(i)); break; }
case "--qual": // minor alias
- case "--quality": { ++i; radarmapper.size_z = stof(argv(i)); break; }
+ case "--quality": { ++i; radarmapper.size.z = stof(argv(i)); break; }
default:
i = argc;
print(" up = ", ftos(gettaginfo_up.x), " ", ftos(gettaginfo_up.y), " ", ftos(gettaginfo_up.z), "\n");
if(argc >= 6)
{
- v_y = -v.y;
+ v.y = -v.y;
localcmd(strcat(argv(4), vtos(v), argv(5), "\n"));
}
}
org = world.mins;
delta = world.maxs - world.mins;
- start_x = org.x + random() * delta.x;
- start_y = org.y + random() * delta.y;
- start_z = org.z + random() * delta.z;
+ start.x = org.x + random() * delta.x;
+ start.y = org.y + random() * delta.y;
+ start.z = org.z + random() * delta.z;
- end_x = org.x + random() * delta.x;
- end_y = org.y + random() * delta.y;
- end_z = org.z + random() * delta.z;
+ end.x = org.x + random() * delta.x;
+ end.y = org.y + random() * delta.y;
+ end.z = org.z + random() * delta.z;
start = stov(vtos(start));
end = stov(vtos(end));
else
hitloc = nearest;
}
- nearest_x = targ.origin.x + targ.mins.x + random() * targ.size.x;
- nearest_y = targ.origin.y + targ.mins.y + random() * targ.size.y;
- nearest_z = targ.origin.z + targ.mins.z + random() * targ.size.z;
+ nearest.x = targ.origin.x + targ.mins.x + random() * targ.size.x;
+ nearest.y = targ.origin.y + targ.mins.y + random() * targ.size.y;
+ nearest.z = targ.origin.z + targ.mins.z + random() * targ.size.z;
}
nearest = hitloc * (1 / max(1, hits));
if (!anim)
return; // no animation was given to us! We can't use this.
- if (anim_x == e.animstate_startframe)
- if (anim_y == e.animstate_numframes)
- if (anim_z == e.animstate_framerate)
+ if (anim.x == e.animstate_startframe)
+ if (anim.y == e.animstate_numframes)
+ if (anim.z == e.animstate_framerate)
{
if(restart)
{
if(restart > 0)
- if(anim_y == 1) // ZYM animation
+ if(anim.y == 1) // ZYM animation
BITXOR_ASSIGN(e.effects, EF_RESTARTANIM_BIT);
}
else
vector destangle;
destangle = delta + 2 * delta2 * phasepos;
destangle = vectoangles(destangle);
- destangle_x = -destangle.x; // flip up / down orientation
+ destangle.x = -destangle.x; // flip up / down orientation
// take the shortest distance for the angles
self.owner.angles_x -= 360 * floor((self.owner.angles.x - destangle.x) / 360 + 0.5);
if (c & 1)
{
h = vec.y;
- vec_y = vec.x;
- vec_x = vec.z;
- vec_z = h;
+ vec.y = vec.x;
+ vec.x = vec.z;
+ vec.z = h;
}
c = c + 1;
}
// 2 = 2..3
// 3 = 1..3
// 4 = 1..4
- tet_piecemins_x = floor(3.0 - sz.x * 0.5);
- tet_piecemaxs_x = floor(2.0 + sz.x * 0.5);
- if(sz_y == 1)
+ tet_piecemins.x = floor(3.0 - sz.x * 0.5);
+ tet_piecemaxs.x = floor(2.0 + sz.x * 0.5);
+ if(sz.y == 1)
{
// special case for "I"
- tet_piecemins_y = tet_piecemaxs_y = 2;
+ tet_piecemins.y = tet_piecemaxs.y = 2;
}
else
{
- tet_piecemins_y = 1;
- tet_piecemaxs_y = sz.y;
+ tet_piecemins.y = 1;
+ tet_piecemaxs.y = sz.y;
}
//printf("ce%v sz%v mi%v ma%v\n", ce, sz, tet_piecemins, tet_piecemaxs);
if (rot == 1) // 90 degrees
{
t = tet_piecemins.y;
- tet_piecemins_y = -tet_piecemins.x + ce.y + ce.x;
- tet_piecemins_x = t - ce.y + ce.x;
+ tet_piecemins.y = -tet_piecemins.x + ce.y + ce.x;
+ tet_piecemins.x = t - ce.y + ce.x;
t = tet_piecemaxs.y;
- tet_piecemaxs_y = -tet_piecemaxs.x + ce.y + ce.x;
- tet_piecemaxs_x = t - ce.y + ce.x;
+ tet_piecemaxs.y = -tet_piecemaxs.x + ce.y + ce.x;
+ tet_piecemaxs.x = t - ce.y + ce.x;
// swap mins_y, maxs_y
t = tet_piecemins.y;
- tet_piecemins_y = tet_piecemaxs.y;
- tet_piecemaxs_y = t;
+ tet_piecemins.y = tet_piecemaxs.y;
+ tet_piecemaxs.y = t;
// TODO OPTIMIZE
}
else if (rot == 2)//180
else if (rot == 3) // 270
{
t = tet_piecemins.y;
- tet_piecemins_y = tet_piecemins.x - ce.x + ce.y;
- tet_piecemins_x = -t + ce.x + ce.y;
+ tet_piecemins.y = tet_piecemins.x - ce.x + ce.y;
+ tet_piecemins.x = -t + ce.x + ce.y;
t = tet_piecemaxs.y;
- tet_piecemaxs_y = tet_piecemaxs.x - ce.x + ce.y;
- tet_piecemaxs_x = -t + ce.x + ce.y;
+ tet_piecemaxs.y = tet_piecemaxs.x - ce.x + ce.y;
+ tet_piecemaxs.x = -t + ce.x + ce.y;
// swap mins_x, maxs_x
t = tet_piecemins.x;
- tet_piecemins_x = tet_piecemaxs.x;
- tet_piecemaxs_x = t;
+ tet_piecemins.x = tet_piecemaxs.x;
+ tet_piecemaxs.x = t;
// TODO OPTIMIZE
}
#ifdef VERIFY
for(j = 1; j <= 4; ++j)
if(PieceMetric(i, j, rot, pc))
{
- realmins_x = min(realmins.x, i);
- realmins_y = min(realmins.y, j);
- realmaxs_x = max(realmaxs.x, i);
- realmaxs_y = max(realmaxs.y, j);
+ realmins.x = min(realmins.x, i);
+ realmins.y = min(realmins.y, j);
+ realmaxs.x = max(realmaxs.x, i);
+ realmaxs.y = max(realmaxs.y, j);
}
if(realmins != tet_piecemins || realmaxs != tet_piecemaxs)
error(sprintf("incorrect mins/maxs: %v %v in %d rot %d mins %v maxs %v\n", realmins, realmaxs, rot, pc, tet_piecemins, tet_piecemaxs));
nudge = 0;
if (keyss & TETKEY_RIGHT)
{
- check_pos_x = check_pos.x + 1;
+ check_pos.x = check_pos.x + 1;
tetsnd("tetmove");
}
else if (keyss & TETKEY_LEFT)
{
- check_pos_x = check_pos.x - 1;
+ check_pos.x = check_pos.x - 1;
tetsnd("tetmove");
}
else if (keyss & TETKEY_ROTRIGHT)
{
- check_pos_z = check_pos.z + 1;
+ check_pos.z = check_pos.z + 1;
piece_data = PieceShape(self.piece_type);
nudge = 1;
tetsnd("tetrot");
}
else if (keyss & TETKEY_ROTLEFT)
{
- check_pos_z = check_pos.z - 1;
+ check_pos.z = check_pos.z - 1;
piece_data = PieceShape(self.piece_type);
nudge = 1;
tetsnd("tetrot");
}
// bounds check
if (check_pos.z > 3)
- check_pos_z = 0;
+ check_pos.z = 0;
else if (check_pos.z < 0)
- check_pos_z = 3;
+ check_pos.z = 3;
// reality check
if (CheckMetrics(self.piece_type, check_pos.x, check_pos.y, check_pos.z))
}
else if (keyss & TETKEY_DOWN)
{
- check_pos_y = check_pos.y + 1;
+ check_pos.y = check_pos.y + 1;
self.tet_autodown = time + 2 / (1 + Tetris_Level());
}
else if (self.tet_autodown < time)
{
- check_pos_y = check_pos.y + 1;
+ check_pos.y = check_pos.y + 1;
self.tet_autodown = time + 2 / (1 + Tetris_Level());
}
if (CheckMetrics(self.piece_type, check_pos.x, check_pos.y, check_pos.z))
else
{
a = vectoangles(self.enemy.origin - self.origin);
- a_x = -a.x;
+ a.x = -a.x;
if(a != self.mangle)
{
self.mangle = a;
{
vector v;
m2 = m2 - m1;
- v_x = m2_x * random() + m1_x;
- v_y = m2_y * random() + m1_y;
- v_z = m2_z * random() + m1_z;
+ v.x = m2_x * random() + m1_x;
+ v.y = m2_y * random() + m1_y;
+ v.z = m2_z * random() + m1_z;
return v;
}
for (i = 0; i < attempts; ++i)
{
- start_x = org.x + random() * delta.x;
- start_y = org.y + random() * delta.y;
- start_z = org.z + random() * delta.z;
+ start.x = org.x + random() * delta.x;
+ start.y = org.y + random() * delta.y;
+ start.z = org.z + random() * delta.z;
// rule 1: start inside world bounds, and outside
// solid, and don't start from somewhere where you can
}
// find a random vector to "look at"
- end_x = org.x + random() * delta.x;
- end_y = org.y + random() * delta.y;
- end_z = org.z + random() * delta.z;
+ end.x = org.x + random() * delta.x;
+ end.y = org.y + random() * delta.y;
+ end.z = org.z + random() * delta.z;
end = start + normalize(end - start) * vlen(delta);
// rule 4: start TO end must not be too short
break;
case 4: // left
- vecs_y = -vecs.y;
+ vecs.y = -vecs.y;
break;
case 1:
if(allowcenter) // 2: allow center handedness
{
// center
- vecs_y = 0;
+ vecs.y = 0;
vecs.z -= 2;
}
else
if(allowcenter) // 2: allow center handedness
{
// center
- vecs_y = 0;
+ vecs.y = 0;
vecs.z -= 2;
}
else
{
// left
- vecs_y = -vecs.y;
+ vecs.y = -vecs.y;
}
break;
}
if (visual)
{
if (autocvar_g_shootfromclient) { vecs = shotorg_adjustfromclient(vecs, y_is_right, (autocvar_g_shootfromclient >= 2), algn); }
- else { vecs_y = 0; vecs.z -= 2; }
+ else { vecs.y = 0; vecs.z -= 2; }
}
else
{
- vecs_y = 0;
- vecs_z = 0;
+ vecs.y = 0;
+ vecs.z = 0;
}
}
else if (autocvar_g_shootfromcenter)
{
- vecs_y = 0;
+ vecs.y = 0;
vecs.z -= 2;
}
else if ((s = autocvar_g_shootfromfixedorigin) != "")
{
v = stov(s);
if (y_is_right)
- v_y = -v.y;
+ v.y = -v.y;
if (v.x != 0)
- vecs_x = v.x;
- vecs_y = v.y;
- vecs_z = v.z;
+ vecs.x = v.x;
+ vecs.y = v.y;
+ vecs.z = v.z;
}
else if (autocvar_g_shootfromclient)
{
fixedmakevectors(e.angles);
// untransform forward, up!
- e_forward_x = v_forward * t_forward;
- e_forward_y = v_forward * t_left;
- e_forward_z = v_forward * t_up;
- e_up_x = v_up * t_forward;
- e_up_y = v_up * t_left;
- e_up_z = v_up * t_up;
+ e_forward.x = v_forward * t_forward;
+ e_forward.y = v_forward * t_left;
+ e_forward.z = v_forward * t_up;
+ e_up.x = v_up * t_forward;
+ e_up.y = v_up * t_left;
+ e_up.z = v_up * t_up;
e.angles = fixedvectoangles2(e_forward, e_up);
if (substring(e.model, 0, 1) == "*") // bmodels have their own rules
{
vector a, b, c, d, e, r, push_angle, ahead, side;
- push_angle_y = 0;
+ push_angle.y = 0;
r = (self.absmax + self.absmin) * 0.5 + (v_up * spring_up);
e = v_up * spring_length;
d = r - ahead - side;
traceline(a, a - e,MOVE_NORMAL,self);
- a_z = (1 - trace_fraction);
+ a.z = (1 - trace_fraction);
r = trace_endpos;
traceline(b, b - e,MOVE_NORMAL,self);
- b_z = (1 - trace_fraction);
+ b.z = (1 - trace_fraction);
r += trace_endpos;
traceline(c, c - e,MOVE_NORMAL,self);
- c_z = (1 - trace_fraction);
+ c.z = (1 - trace_fraction);
r += trace_endpos;
traceline(d, d - e,MOVE_NORMAL,self);
- d_z = (1 - trace_fraction);
+ d.z = (1 - trace_fraction);
r += trace_endpos;
- a_x = r.z;
+ a.x = r.z;
r = self.origin;
- r_z = r.z;
+ r.z = r.z;
- push_angle_x = (a.z - c.z) * _max;
+ push_angle.x = (a.z - c.z) * _max;
push_angle.x += (b.z - d.z) * _max;
- push_angle_z = (b.z - a.z) * _max;
+ push_angle.z = (b.z - a.z) * _max;
push_angle.z += (d.z - c.z) * _max;
//self.angles_x += push_angle_x * 0.95;
vector org;
org = havocbot_ctf_middlepoint;
- org_z = self.origin.z;
+ org.z = self.origin.z;
self.bot_strategytime = time + autocvar_bot_ai_strategyinterval;
navigation_goalrating_start();
// ensure nothing EVIL is being done (i.e. div0_evade)
// this hinders joystick users though
// but it still gives SOME analog control
- wishvel_x = fabs(self.movement.x);
- wishvel_y = fabs(self.movement.y);
+ wishvel.x = fabs(self.movement.x);
+ wishvel.y = fabs(self.movement.y);
if(wishvel.x != 0 && wishvel.y != 0 && wishvel.x != wishvel.y)
{
- wishvel_z = 0;
+ wishvel.z = 0;
wishspeed = vlen(wishvel);
if(wishvel.x >= 2 * wishvel.y)
{
// ensure nothing EVIL is being done (i.e. div0_evade)
// this hinders joystick users though
// but it still gives SOME analog control
- wishvel_x = fabs(self.movement.x);
- wishvel_y = fabs(self.movement.y);
+ wishvel.x = fabs(self.movement.x);
+ wishvel.y = fabs(self.movement.y);
if(wishvel.x != 0 && wishvel.y != 0 && wishvel.x != wishvel.y)
{
- wishvel_z = 0;
+ wishvel.z = 0;
wishspeed = vlen(wishvel);
if(wishvel.x >= 2 * wishvel.y)
{
// calculate player movement (in 2 dimensions only, so jumping on one spot doesn't count as movement)
dist = self.prevorigin - self.origin;
- dist_z = 0;
+ dist.z = 0;
self.campcheck_traveled_distance += fabs(vlen(dist));
if((autocvar_g_campaign && !campaign_bots_may_start) || (time < game_starttime) || (round_handler_IsActive() && !round_handler_IsRoundStarted()))
// is this a state change?
if (!(self.pressedkeys & KEY_FORWARD) || frozen_no_doubletap) {
if ((time - self.last_FORWARD_KEY_time) < self.cvar_cl_dodging_timeout) {
- tap_direction_x = 1.0;
+ tap_direction.x = 1.0;
dodge_detected = 1;
}
self.last_FORWARD_KEY_time = time;
if (self.movement.x < 0) {
// is this a state change?
if (!(self.pressedkeys & KEY_BACKWARD) || frozen_no_doubletap) {
- tap_direction_x = -1.0;
+ tap_direction.x = -1.0;
if ((time - self.last_BACKWARD_KEY_time) < self.cvar_cl_dodging_timeout) {
dodge_detected = 1;
}
if (self.movement.y > 0) {
// is this a state change?
if (!(self.pressedkeys & KEY_RIGHT) || frozen_no_doubletap) {
- tap_direction_y = 1.0;
+ tap_direction.y = 1.0;
if ((time - self.last_RIGHT_KEY_time) < self.cvar_cl_dodging_timeout) {
dodge_detected = 1;
}
if (self.movement.y < 0) {
// is this a state change?
if (!(self.pressedkeys & KEY_LEFT) || frozen_no_doubletap) {
- tap_direction_y = -1.0;
+ tap_direction.y = -1.0;
if ((time - self.last_LEFT_KEY_time) < self.cvar_cl_dodging_timeout) {
dodge_detected = 1;
}
proj.damageforcescale = autocvar_g_nades_napalm_ball_damageforcescale;
proj.effects = EF_LOWPRECISION | EF_FLAME;
- kick_x =(random() - 0.5) * 2 * autocvar_g_nades_napalm_ball_spread;
- kick_y = (random() - 0.5) * 2 * autocvar_g_nades_napalm_ball_spread;
- kick_z = (random()/2+0.5) * autocvar_g_nades_napalm_ball_spread;
+ kick.x =(random() - 0.5) * 2 * autocvar_g_nades_napalm_ball_spread;
+ kick.y = (random() - 0.5) * 2 * autocvar_g_nades_napalm_ball_spread;
+ kick.z = (random()/2+0.5) * autocvar_g_nades_napalm_ball_spread;
proj.velocity = kick;
proj.pushltime = time + autocvar_g_nades_napalm_ball_lifetime;
float randomw;
randomw = random()*M_PI*2;
vector randomp;
- randomp_x = randomr*cos(randomw);
- randomp_y = randomr*sin(randomw);
- randomp_z = 1;
+ randomp.x = randomr*cos(randomw);
+ randomp.y = randomr*sin(randomw);
+ randomp.z = 1;
pointparticles(particleeffectnum("electro_muzzleflash"), self.origin + randomp, '0 0 0', 1);
if(time >= self.nade_special_time)
{
vector vret;
- vret_x = rint(point.x / fsize) * fsize;
- vret_y = rint(point.y / fsize) * fsize;
- vret_z = ceil(point.z / fsize) * fsize;
+ vret.x = rint(point.x / fsize) * fsize;
+ vret.y = rint(point.y / fsize) * fsize;
+ vret.z = ceil(point.z / fsize) * fsize;
return vret;
}
pathlib_movenode_goodnode = 0;
- end_x = fsnap(end.x, pathlib_gridsize);
- end_y = fsnap(end.y, pathlib_gridsize);
+ end.x = fsnap(end.x, pathlib_gridsize);
+ end.y = fsnap(end.y, pathlib_gridsize);
traceline(end + ('0 0 0.25' * pathlib_gridsize),end - ('0 0 1' * pathlib_gridsize),MOVE_WORLDONLY,self);
end = trace_endpos;
if(pointcontents(start) != CONTENT_WATER)
return end;
- end_x = fsnap(end.x, pathlib_gridsize);
- end_y = fsnap(end.y, pathlib_gridsize);
+ end.x = fsnap(end.x, pathlib_gridsize);
+ end.y = fsnap(end.y, pathlib_gridsize);
if(pointcontents(end) == CONTENT_EMPTY)
return pathlib_wateroutnode( start, end);
{
pathlib_movenode_goodnode = 0;
- end_x = fsnap(end.x, pathlib_gridsize);
- end_y = fsnap(end.y, pathlib_gridsize);
+ end.x = fsnap(end.x, pathlib_gridsize);
+ end.y = fsnap(end.y, pathlib_gridsize);
tracebox(start, walknode_boxmin,walknode_boxmax, end, MOVE_WORLDONLY, self);
if(trace_fraction == 1)
s = start;
e = end;
- e_z = 0;
- s_z = 0;
+ e.z = 0;
+ s.z = 0;
direction = normalize(s - e);
distance = vlen(start - end);
point = last_point + direction * walknode_stepsize * laststep;
- point_x = fsnap(point.x, pathlib_gridsize);
- point_y = fsnap(point.y, pathlib_gridsize);
+ point.x = fsnap(point.x, pathlib_gridsize);
+ point.y = fsnap(point.y, pathlib_gridsize);
s = point + walknode_stepup;
e = point - walknode_maxdrop;
{
vector v;
- for(v_z = node.origin.z - pathlib_gridsize; v.z <= node.origin.z + pathlib_gridsize; v.z += pathlib_gridsize)
- for(v_y = node.origin.y - pathlib_gridsize; v.y <= node.origin.y + pathlib_gridsize; v.y += pathlib_gridsize)
- for(v_x = node.origin.x - pathlib_gridsize; v.x <= node.origin.x + pathlib_gridsize; v.x += pathlib_gridsize)
+ for(v.z = node.origin.z - pathlib_gridsize; v.z <= node.origin.z + pathlib_gridsize; v.z += pathlib_gridsize)
+ for(v.y = node.origin.y - pathlib_gridsize; v.y <= node.origin.y + pathlib_gridsize; v.y += pathlib_gridsize)
+ for(v.x = node.origin.x - pathlib_gridsize; v.x <= node.origin.x + pathlib_gridsize; v.x += pathlib_gridsize)
{
if(vlen(v - node.origin))
pathlib_makenode(node,start,v,goal,pathlib_movecost);
walknode_stepup = '0 0 1' * walknode_stepsize;
walknode_maxdrop = '0 0 3' * walknode_stepsize;
- from_x = fsnap(from.x,pathlib_gridsize);
- from_y = fsnap(from.y,pathlib_gridsize);
+ from.x = fsnap(from.x,pathlib_gridsize);
+ from.y = fsnap(from.y,pathlib_gridsize);
- to_x = fsnap(to.x,pathlib_gridsize);
- to_y = fsnap(to.y,pathlib_gridsize);
+ to.x = fsnap(to.x,pathlib_gridsize);
+ to.y = fsnap(to.y,pathlib_gridsize);
dprint("AStar init. ", ftos(pathlib_scraplist_cnt), " nodes on scrap\n");
path = pathlib_mknode(from,world);
{
vector v;
- for(v_z = node.origin.z - pathlib_gridsize; v.z <= node.origin.z + pathlib_gridsize; v.z += pathlib_gridsize)
- for(v_y = node.origin.y - pathlib_gridsize; v.y <= node.origin.y + pathlib_gridsize; v.y += pathlib_gridsize)
- for(v_x = node.origin.x - pathlib_gridsize; v.x <= node.origin.x + pathlib_gridsize; v.x += pathlib_gridsize)
+ for(v.z = node.origin.z - pathlib_gridsize; v.z <= node.origin.z + pathlib_gridsize; v.z += pathlib_gridsize)
+ for(v.y = node.origin.y - pathlib_gridsize; v.y <= node.origin.y + pathlib_gridsize; v.y += pathlib_gridsize)
+ for(v.x = node.origin.x - pathlib_gridsize; v.x <= node.origin.x + pathlib_gridsize; v.x += pathlib_gridsize)
{
//if(vlen(v - node.origin))
pathlib_makenode(node,start,v,goal,pathlib_movecost);
//movenode_maxdrop = '0 0 512';
movenode_boxup = '0 0 72';
- from_x = fsnap(from.x, pathlib_gridsize);
- from_y = fsnap(from.y, pathlib_gridsize);
+ from.x = fsnap(from.x, pathlib_gridsize);
+ from.y = fsnap(from.y, pathlib_gridsize);
//from_z += 32;
- to_x = fsnap(to.x, pathlib_gridsize);
- to_y = fsnap(to.y, pathlib_gridsize);
+ to.x = fsnap(to.x, pathlib_gridsize);
+ to.y = fsnap(to.y, pathlib_gridsize);
//to_z += 32;
dprint("AStar init\n");
pathlib_movenode_goodnode = 0;
- end_x = fsnap(end.x, pathlib_gridsize);
- end_y = fsnap(end.y, pathlib_gridsize);
+ end.x = fsnap(end.x, pathlib_gridsize);
+ end.y = fsnap(end.y, pathlib_gridsize);
traceline(end + ('0 0 0.25' * pathlib_gridsize),end - ('0 0 1' * pathlib_gridsize),MOVE_WORLDONLY,self);
end = trace_endpos;
if(pointcontents(start) != CONTENT_WATER)
return end;
- end_x = fsnap(end.x, pathlib_gridsize);
- end_y = fsnap(end.y, pathlib_gridsize);
+ end.x = fsnap(end.x, pathlib_gridsize);
+ end.y = fsnap(end.y, pathlib_gridsize);
if(pointcontents(end) == CONTENT_EMPTY)
return pathlib_wateroutnode( start, end, doedge);
{
pathlib_movenode_goodnode = 0;
- end_x = fsnap(end.x, pathlib_gridsize);
- end_y = fsnap(end.y, pathlib_gridsize);
+ end.x = fsnap(end.x, pathlib_gridsize);
+ end.y = fsnap(end.y, pathlib_gridsize);
tracebox(start, movenode_boxmin,movenode_boxmax, end, MOVE_WORLDONLY, self);
if(trace_fraction == 1)
pathlib_movenode_goodnode = 0;
- end_x = fsnap(end.x,pathlib_gridsize);
- end_y = fsnap(end.y,pathlib_gridsize);
- start_x = fsnap(start.x,pathlib_gridsize);
- start_y = fsnap(start.y,pathlib_gridsize);
+ end.x = fsnap(end.x,pathlib_gridsize);
+ end.y = fsnap(end.y,pathlib_gridsize);
+ start.x = fsnap(start.x,pathlib_gridsize);
+ start.y = fsnap(start.y,pathlib_gridsize);
// Find the floor
traceline(start + movenode_stepup, start - movenode_maxdrop, MOVE_WORLDONLY, self);
}
point = last_point + (direction * movenode_stepsize);
- point_x = fsnap(point.x,pathlib_gridsize);
- point_y = fsnap(point.y,pathlib_gridsize);
+ point.x = fsnap(point.x,pathlib_gridsize);
+ point.y = fsnap(point.y,pathlib_gridsize);
//dprint("end_x: ",ftos(end_x), " end_y: ",ftos(end_y),"\n");
//dprint("point_x:",ftos(point_x)," point_y:",ftos(point_y),"\n\n");
{
vector vret;
- vret_x = rint(point.x / fsize) * fsize;
- vret_y = rint(point.y / fsize) * fsize;
- vret_z = ceil(point.z / fsize) * fsize;
+ vret.x = rint(point.x / fsize) * fsize;
+ vret.y = rint(point.y / fsize) * fsize;
+ vret.z = ceil(point.z / fsize) * fsize;
return vret;
}
++pathlib_searched_cnt;
- where_x = fsnap(where.x,pathlib_gridsize);
- where_y = fsnap(where.y,pathlib_gridsize);
+ where.x = fsnap(where.x,pathlib_gridsize);
+ where.y = fsnap(where.y,pathlib_gridsize);
node = findradius(where,pathlib_gridsize * 0.5);
while(node)
{
vector vbest;
- if(v.x < 0) vbest_x = p.mins.x; else vbest_x = p.maxs.x;
- if(v.y < 0) vbest_y = p.mins.y; else vbest_y = p.maxs.y;
- if(v.z < 0) vbest_z = p.mins.z; else vbest_z = p.maxs.z;
+ if(v.x < 0) vbest.x = p.mins.x; else vbest.x = p.maxs.x;
+ if(v.y < 0) vbest.y = p.mins.y; else vbest.y = p.maxs.y;
+ if(v.z < 0) vbest.z = p.mins.z; else vbest.z = p.maxs.z;
return vbest * v;
}
// PLAYERS use different math
#ifndef POSITIVE_PITCH_IS_DOWN
- ang_x = -ang.x;
+ ang.x = -ang.x;
#endif
//print("reference: ", vtos(AnglesTransform_ApplyToVAngles(transform, ang)), "\n");
ang = fixedvectoangles(new_forward); // this still gets us a nice pitch value...
if(new_up * new_yawforward < 0)
new_up = -1 * new_up;
- ang_y = vectoyaw(new_up); // this vector is the yaw we want
+ ang.y = vectoyaw(new_up); // this vector is the yaw we want
//print("UP/DOWN path: ", vtos(ang), "\n");
}
else
}
#ifndef POSITIVE_PITCH_IS_DOWN
- ang_x = -ang.x;
+ ang.x = -ang.x;
#endif
- ang_z = vangle.z;
+ ang.z = vangle.z;
return ang;
}
if(t1.field == t2.field)
return previous;
- previous_y = fieldflags & SFL_SORT_PRIO_MASK;
+ previous.y = fieldflags & SFL_SORT_PRIO_MASK;
if(fieldflags & SFL_ZERO_IS_WORST)
{
if(t1.field == 0)
{
- previous_x = -1;
+ previous.x = -1;
return previous;
}
else if(t2.field == 0)
{
- previous_x = +1;
+ previous.x = +1;
return previous;
}
}
if(fieldflags & SFL_LOWER_IS_BETTER)
- previous_x = (t2.field - t1.field);
+ previous.x = (t2.field - t1.field);
else
- previous_x = (t1.field - t2.field);
+ previous.x = (t1.field - t2.field);
return previous;
}
result = ScoreField_Compare(t1, t2, f, teamscores_flags[i], result, strict);
}
- if (result_x == 0 && strict)
- result_x = t1.team - t2.team;
+ if (result.x == 0 && strict)
+ result.x = t1.team - t2.team;
return result.x;
}
result = ScoreField_Compare(t1, t2, f, scores_flags[i], result, strict);
}
- if (result_x == 0 && strict)
- result_x = num_for_edict(t1.owner) - num_for_edict(t2.owner);
+ if (result.x == 0 && strict)
+ result.x = num_for_edict(t1.owner) - num_for_edict(t2.owner);
return result.x;
}
flock_member = flock_member.chain;
}
- push_z = 0;
- pull_z = 0;
+ push.z = 0;
+ pull.z = 0;
return push + (pull * (1 / ccount));
}
solution = solve_quadratic(0.5 * grav, -vz, zdist); // equation "z(ti) = zdist"
// ALWAYS solvable because jumpheight >= zdist
if(!solution.z)
- solution_y = solution.x; // just in case it is not solvable due to roundoff errors, assume two equal solutions at their center (this is mainly for the usual case with ht == 0)
+ solution.y = solution.x; // just in case it is not solvable due to roundoff errors, assume two equal solutions at their center (this is mainly for the usual case with ht == 0)
if(zdist == 0)
- solution_x = solution.y; // solution_x is 0 in this case, so don't use it, but rather use solution_y (which will be sqrt(0.5 * jumpheight / grav), actually)
+ solution.x = solution.y; // solution_x is 0 in this case, so don't use it, but rather use solution_y (which will be sqrt(0.5 * jumpheight / grav), actually)
if(zdist < 0)
{
// first calculate a typical start point for the jump
org = (self.absmin + self.absmax) * 0.5;
- org_z = self.absmax.z - PL_MIN_z;
+ org.z = self.absmax.z - PL_MIN_z;
if (self.target)
{
tmin = self.absmin + '25 25 0';
tmax = self.absmax - '25 25 -8';
- tmin_z = tmax.z - (self.pos1_z - self.pos2_z + 8);
+ tmin.z = tmax.z - (self.pos1_z - self.pos2_z + 8);
if (self.spawnflags & PLAT_LOW_TRIGGER)
- tmax_z = tmin.z + 8;
+ tmax.z = tmin.z + 8;
if (self.size.x <= 50)
{
- tmin_x = (self.mins.x + self.maxs.x) / 2;
- tmax_x = tmin.x + 1;
+ tmin.x = (self.mins.x + self.maxs.x) / 2;
+ tmax.x = tmin.x + 1;
}
if (self.size.y <= 50)
{
- tmin_y = (self.mins.y + self.maxs.y) / 2;
- tmax_y = tmin.y + 1;
+ tmin.y = (self.mins.y + self.maxs.y) / 2;
+ tmax.y = tmin.y + 1;
}
if(tmin.x < tmax.x)
else // linear movement
ang = targ.origin - (self.origin - self.view_ofs); // use the origin of the next path_corner
ang = vectoangles(ang);
- ang_x = -ang.x; // flip up / down orientation
+ ang.x = -ang.x; // flip up / down orientation
if(self.wait > 0) // slow turning
SUB_CalcAngleMove(ang, TSPEED_TIME, self.ltime - time + self.wait, train_wait);
if((t.message != "") && (self.message == ""))
self.message = t.message;
if (t.absmin.x < cmins.x)
- cmins_x = t.absmin.x;
+ cmins.x = t.absmin.x;
if (t.absmin.y < cmins.y)
- cmins_y = t.absmin.y;
+ cmins.y = t.absmin.y;
if (t.absmin.z < cmins.z)
- cmins_z = t.absmin.z;
+ cmins.z = t.absmin.z;
if (t.absmax.x > cmaxs.x)
- cmaxs_x = t.absmax.x;
+ cmaxs.x = t.absmax.x;
if (t.absmax.y > cmaxs.y)
- cmaxs_y = t.absmax.y;
+ cmaxs.y = t.absmax.y;
if (t.absmax.z > cmaxs.z)
- cmaxs_z = t.absmax.z;
+ cmaxs.z = t.absmax.z;
if(t.enemy == self)
break;
}
else // Z
self.movedir = '0 1 0';
- if (self.angles_y ==0) self.angles_y = 90;
+ if (self.angles.y ==0) self.angles.y = 90;
self.movedir = self.movedir * self.angles.y;
self.angles = '0 0 0';
deathmax = (o) + player.maxs; \
if(telefragmin != telefragmax) \
{ \
- if(deathmin.x > telefragmin.x) deathmin_x = telefragmin.x; \
- if(deathmin.y > telefragmin.y) deathmin_y = telefragmin.y; \
- if(deathmin.z > telefragmin.z) deathmin_z = telefragmin.z; \
- if(deathmax.x < telefragmax.x) deathmax_x = telefragmax.x; \
- if(deathmax.y < telefragmax.y) deathmax_y = telefragmax.y; \
- if(deathmax.z < telefragmax.z) deathmax_z = telefragmax.z; \
+ if(deathmin.x > telefragmin.x) deathmin.x = telefragmin.x; \
+ if(deathmin.y > telefragmin.y) deathmin.y = telefragmin.y; \
+ if(deathmin.z > telefragmin.z) deathmin.z = telefragmin.z; \
+ if(deathmax.x < telefragmax.x) deathmax.x = telefragmax.x; \
+ if(deathmax.y < telefragmax.y) deathmax.y = telefragmax.y; \
+ if(deathmax.z < telefragmax.z) deathmax.z = telefragmax.z; \
} \
deathradius = max(vlen(deathmin), vlen(deathmax)); \
for(head = findradius(o, deathradius); head; head = head.chain) \
value = argv(i+1);
if(key == "$")
{
- data_x = -1;
- data_y = FIELD_STRING;
+ data.x = -1;
+ data.y = FIELD_STRING;
}
else
{
data = stov(db_get(TemporaryDB, strcat("/target_spawn/field/", key)));
- if(data_y == 0) // undefined field, i.e., invalid type
+ if(data.y == 0) // undefined field, i.e., invalid type
{
print("target_spawn: invalid/unknown entity key ", key, " specified, ignored!\n");
continue;
}
else
{
- if(data_y == FIELD_VECTOR)
+ if(data.y == FIELD_VECTOR)
value = strreplace("'", "", value); // why?!?
putentityfieldstring(data.x, e, value);
}
ft = entityfieldtype(i);
new = i * '1 0 0' + ft * '0 1 0' + '0 0 1';
prev = stov(db_get(TemporaryDB, strcat("/target_spawn/field/", fn)));
- if(prev_y == 0)
+ if(prev.y == 0)
{
db_put(TemporaryDB, strcat("/target_spawn/field/", fn), vtos(new));
if(fn == "target_spawn_spawnfunc")
if(self.enemy.movetype == MOVETYPE_WALK || self.enemy.movetype == MOVETYPE_TOSS || self.enemy.movetype == MOVETYPE_BOUNCE)
{
float vz;
- prep_z = pre_pos.z;
+ prep.z = pre_pos.z;
vz = self.enemy.velocity.z;
for(i = 0; i < impact_time; i += sys_frametime)
{
vz = vz - (autocvar_sv_gravity * sys_frametime);
- prep_z = prep.z + vz * sys_frametime;
+ prep.z = prep.z + vz * sys_frametime;
}
}
pre_pos = prep;
case TFL_TRACKTYPE_FLUIDINERTIA:
f_tmp = self.aim_speed * self.ticrate; // dgr/sec -> dgr/tic
- move_angle_x = bound(-self.aim_speed, move_angle.x * self.track_accel_pitch * f_tmp, self.aim_speed);
- move_angle_y = bound(-self.aim_speed, move_angle.y * self.track_accel_rot * f_tmp, self.aim_speed);
+ move_angle.x = bound(-self.aim_speed, move_angle.x * self.track_accel_pitch * f_tmp, self.aim_speed);
+ move_angle.y = bound(-self.aim_speed, move_angle.y * self.track_accel_rot * f_tmp, self.aim_speed);
move_angle = (self.tur_head.avelocity * self.track_blendrate) + (move_angle * (1 - self.track_blendrate));
break;
case TFL_TRACKTYPE_FLUIDPRECISE:
- move_angle_y = bound(-self.aim_speed, move_angle.y, self.aim_speed);
- move_angle_x = bound(-self.aim_speed, move_angle.x, self.aim_speed);
+ move_angle.y = bound(-self.aim_speed, move_angle.y, self.aim_speed);
+ move_angle.x = bound(-self.aim_speed, move_angle.x, self.aim_speed);
break;
}
{
vector vtmp;
- vtmp_x = shortangle_f(ang1_x,ang2_x);
- vtmp_y = shortangle_f(ang1_y,ang2_y);
- vtmp_z = shortangle_f(ang1_z,ang2_z);
+ vtmp.x = shortangle_f(ang1_x,ang2_x);
+ vtmp.y = shortangle_f(ang1_y,ang2_y);
+ vtmp.z = shortangle_f(ang1_z,ang2_z);
return vtmp;
}
{
vector vtmp = '0 0 0';
- vtmp_x = shortangle_f(ang1_x,ang2_x);
- vtmp_y = shortangle_f(ang1_y,ang2_y);
+ vtmp.x = shortangle_f(ang1_x,ang2_x);
+ vtmp.y = shortangle_f(ang1_y,ang2_y);
return vtmp;
}
real_angle = shortangle_vxy(real_angle, self.tur_head.angles);
self.tur_head.spawnshieldtime = fabs(real_angle.y);
- real_angle_y = bound(-self.tur_head.aim_speed, real_angle.y, self.tur_head.aim_speed);
+ real_angle.y = bound(-self.tur_head.aim_speed, real_angle.y, self.tur_head.aim_speed);
self.angles_y = (self.angles.y + real_angle.y);
if(self.enemy)
else if(pilot.movement.x < 0 && vang.x > -autocvar_g_vehicle_bumblebee_pitchlimit)
ftmp = -8;
- newvel_x = bound(-autocvar_g_vehicle_bumblebee_pitchlimit, newvel.x , autocvar_g_vehicle_bumblebee_pitchlimit);
+ newvel.x = bound(-autocvar_g_vehicle_bumblebee_pitchlimit, newvel.x , autocvar_g_vehicle_bumblebee_pitchlimit);
ftmp = vang.x - bound(-autocvar_g_vehicle_bumblebee_pitchlimit, newvel.x + ftmp, autocvar_g_vehicle_bumblebee_pitchlimit);
vehic.avelocity_x = bound(-autocvar_g_vehicle_bumblebee_pitchspeed, ftmp + vehic.avelocity.x * 0.9, autocvar_g_vehicle_bumblebee_pitchspeed);
if(self.velocity.z > 0)
self.velocity_z *= 1 - autocvar_g_vehicle_racer_upforcedamper * _delta;
- push_vector_x = (fl_push - bl_push);
+ push_vector.x = (fl_push - bl_push);
push_vector_x += (fr_push - br_push);
push_vector_x *= 360;
- push_vector_z = (fr_push - fl_push);
+ push_vector.z = (fr_push - fl_push);
push_vector_z += (br_push - bl_push);
push_vector_z *= 360;
// Fix z-aim (for chase mode)
v = normalize(trace_endpos - bolt.origin);
- v_forward_z = v.z * 0.5;
+ v_forward.z = v.z * 0.5;
bolt.velocity = v_forward * autocvar_g_vehicle_racer_cannon_speed;
}
if(player.movement.x > 0 && vang.x < autocvar_g_vehicle_raptor_pitchlimit) ftmp = 5;
else if(player.movement.x < 0 && vang.x > -autocvar_g_vehicle_raptor_pitchlimit) ftmp = -20;
- df_x = bound(-autocvar_g_vehicle_raptor_pitchlimit, df.x , autocvar_g_vehicle_raptor_pitchlimit);
+ df.x = bound(-autocvar_g_vehicle_raptor_pitchlimit, df.x , autocvar_g_vehicle_raptor_pitchlimit);
ftmp = vang.x - bound(-autocvar_g_vehicle_raptor_pitchlimit, df.x + ftmp, autocvar_g_vehicle_raptor_pitchlimit);
raptor.avelocity_x = bound(-autocvar_g_vehicle_raptor_pitchspeed, ftmp + raptor.avelocity.x * 0.9, autocvar_g_vehicle_raptor_pitchspeed);
solution = solve_quadratic(0.5 * grav, -vz, zdist); // equation "z(ti) = zdist"
// ALWAYS solvable because jumpheight >= zdist
if(!solution.z)
- solution_y = solution.x; // just in case it is not solvable due to roundoff errors, assume two equal solutions at their center (this is mainly for the usual case with ht == 0)
+ solution.y = solution.x; // just in case it is not solvable due to roundoff errors, assume two equal solutions at their center (this is mainly for the usual case with ht == 0)
if(zdist == 0)
- solution_x = solution.y; // solution_x is 0 in this case, so don't use it, but rather use solution_y (which will be sqrt(0.5 * jumpheight / grav), actually)
+ solution.x = solution.y; // solution_x is 0 in this case, so don't use it, but rather use solution_y (which will be sqrt(0.5 * jumpheight / grav), actually)
if(zdist < 0)
{
// Rotate head
ftmp = autocvar_g_vehicle_spiderbot_head_turnspeed * sys_frametime;
- ad_y = bound(-ftmp, ad.y, ftmp);
+ ad.y = bound(-ftmp, ad.y, ftmp);
spider.tur_head.angles_y = bound(autocvar_g_vehicle_spiderbot_head_turnlimit * -1, spider.tur_head.angles.y + ad.y, autocvar_g_vehicle_spiderbot_head_turnlimit);
// Pitch head
- ad_x = bound(ftmp * -1, ad.x, ftmp);
+ ad.x = bound(ftmp * -1, ad.x, ftmp);
spider.tur_head.angles_x = bound(autocvar_g_vehicle_spiderbot_head_pitchlimit_down, spider.tur_head.angles.x + ad.x, autocvar_g_vehicle_spiderbot_head_pitchlimit_up);
for(i = 0; i < 100; ++i)
{
v = randomvec();
- v_z = 0;
+ v.z = 0;
v = v2 + normalize(v) * mysize;
tracebox(v2, PL_MIN, PL_MAX, v, MOVE_NORMAL, self.owner);
if(trace_fraction == 1.0 && !trace_startsolid && !trace_allsolid)
vtmp = AnglesTransform_ToAngles(AnglesTransform_LeftDivide(AnglesTransform_FromAngles(_vehic.angles), AnglesTransform_FromAngles(vtmp))) - _turrret.angles;
vtmp = AnglesTransform_Normalize(vtmp, true);
ftmp = _aimspeed * frametime;
- vtmp_y = bound(-ftmp, vtmp.y, ftmp);
- vtmp_x = bound(-ftmp, vtmp.x, ftmp);
+ vtmp.y = bound(-ftmp, vtmp.y, ftmp);
+ vtmp.x = bound(-ftmp, vtmp.x, ftmp);
_turrret.angles_y = bound(_rotlimit_min, _turrret.angles.y + vtmp.y, _rotlimit_max);
_turrret.angles_x = bound(_pichlimit_min, _turrret.angles.x + vtmp.x, _pichlimit_max);
return vtag;
vector W_HitPlotUnnormalizedUntransform(vector screenforward, vector screenright, vector screenup, vector v)
{
vector ret;
- ret_x = screenright * v;
- ret_y = screenup * v;
- ret_z = screenforward * v;
+ ret.x = screenright * v;
+ ret.y = screenup * v;
+ ret.z = screenforward * v;
return ret;
}
thisv = W_HitPlotUnnormalizedUntransform(screenforward, screenright, screenup, thisv);
if(i || j || k)
{
- if(mi.x > thisv.x) mi_x = thisv.x; if(ma.x < thisv.x) ma_x = thisv.x;
- if(mi.y > thisv.y) mi_y = thisv.y; if(ma.y < thisv.y) ma_y = thisv.y;
+ if(mi.x > thisv.x) mi.x = thisv.x; if(ma.x < thisv.x) ma.x = thisv.x;
+ if(mi.y > thisv.y) mi.y = thisv.y; if(ma.y < thisv.y) ma.y = thisv.y;
//if(mi_z > thisv_z) mi_z = thisv_z; if(ma_z < thisv_z) ma_y = thisv_z;
}
else
}
thisv = W_HitPlotUnnormalizedUntransform(screenforward, screenright, screenup, v);
- ret_x = (thisv.x - mi.x) / (ma.x - mi.x);
- ret_y = (thisv.y - mi.y) / (ma.y - mi.y);
- ret_z = thisv.z - myv.z;
+ ret.x = (thisv.x - mi.x) / (ma.x - mi.x);
+ ret.y = (thisv.y - mi.y) / (ma.y - mi.y);
+ ret.z = thisv.z - myv.z;
return ret;
}
{
vector ang;
ang = vectoangles(a);
- ang_x = -ang.x;
+ ang.x = -ang.x;
return ang;
}
vector fixedvectoangles2(vector a, vector b)
{
vector ang;
ang = vectoangles2(a, b);
- ang_x = -ang.x;
+ ang.x = -ang.x;
return ang;
}
#else
void fixedmakevectors(vector a)
{
// a makevectors that actually inverts vectoangles
- a_x = -a.x;
+ a.x = -a.x;
makevectors(a);
}
#endif
// but these are orthogonal unit vectors!
// so to invert, we can simply fixedvectoangles the TRANSPOSED matrix
// TODO is this always -transform?
- i_forward_x = v_forward.x;
- i_forward_y = -v_right.x;
- i_forward_z = v_up.x;
- i_up_x = v_forward.z;
- i_up_y = -v_right.z;
- i_up_z = v_up.z;
+ i_forward.x = v_forward.x;
+ i_forward.y = -v_right.x;
+ i_forward.z = v_up.x;
+ i_up.x = v_forward.z;
+ i_up.y = -v_right.z;
+ i_up.z = v_up.z;
return fixedvectoangles2(i_forward, i_up);
}
// changes in-direction to out-direction
//fixedmakevectors(transform);
//return fixedvectoangles2(-1 * v_forward, 1 * v_up);
- transform_x = -transform.x;
- transform_y = 180 + transform.y;
- transform_z = -transform.z;
+ transform.x = -transform.x;
+ transform.y = 180 + transform.y;
+ transform.z = -transform.z;
// pitch: -s +c
// yaw: -s -c
// roll: -s +c
// changes in-direction to out-direction
//fixedmakevectors(transform);
//return fixedvectoangles2(-1 * v_forward, 1 * v_up);
- transform_x = -transform.x;
- transform_y = 180 + transform.y;
- transform_z = 180 - transform.z;
+ transform.x = -transform.x;
+ transform.y = 180 + transform.y;
+ transform.z = 180 - transform.z;
return transform;
}
{
float need_flip;
// first, bring all angles in their range...
- t_x = t.x - 360 * rint(t.x / 360);
- t_y = t.y - 360 * rint(t.y / 360);
- t_z = t.z - 360 * rint(t.z / 360);
+ t.x = t.x - 360 * rint(t.x / 360);
+ t.y = t.y - 360 * rint(t.y / 360);
+ t.z = t.z - 360 * rint(t.z / 360);
if(minimize_roll)
need_flip = (t.z > 90 || t.z <= -90);
else
need_flip = (t.x > 90 || t.x < -90); // for pitch we prefer to allow exactly -90 degrees for looking straight down
if(need_flip)
{
- if(t.x >= 0) t_x = 180 - t.x; else t_x = -180 - t.x;
+ if(t.x >= 0) t.x = 180 - t.x; else t.x = -180 - t.x;
if(t.y > 0) t.y -= 180; else t.y += 180;
if(t.z > 0) t.z -= 180; else t.z += 180;
}
{
//t_x = -90;
t.y += t.z;
- t_z = 0;
+ t.z = 0;
}
else
{
{
//t_x = 90;
t.y -= t.z;
- t_z = 0;
+ t.z = 0;
}
}
return t;
#ifdef POSITIVE_PITCH_IS_DOWN
vector AnglesTransform_ApplyToAngles(vector transform, vector v)
{
- v_x = -v.x;
+ v.x = -v.x;
v = AnglesTransform_Multiply(transform, v);
- v_x = -v.x;
+ v.x = -v.x;
return v;
}
vector AnglesTransform_ApplyToVAngles(vector transform, vector v)
}
vector AnglesTransform_FromAngles(vector v)
{
- v_x = -v.x;
+ v.x = -v.x;
return v;
}
vector AnglesTransform_ToAngles(vector v)
{
- v_x = -v.x;
+ v.x = -v.x;
return v;
}
vector AnglesTransform_FromVAngles(vector v)
}
vector AnglesTransform_ApplyToVAngles(vector transform, vector v)
{
- v_x = -v.x;
+ v.x = -v.x;
v = AnglesTransform_Multiply(transform, v);
- v_x = -v.x;
+ v.x = -v.x;
return v;
}
vector AnglesTransform_FromAngles(vector v)
}
vector AnglesTransform_FromVAngles(vector v)
{
- v_x = -v.x;
+ v.x = -v.x;
return v;
}
vector AnglesTransform_ToVAngles(vector v)
{
- v_x = -v.x;
+ v.x = -v.x;
return v;
}
#endif
{
vector v;
self.classname = "warpzone_teleported";
- v_x = ReadCoord();
- v_y = ReadCoord();
- v_z = ReadCoord();
+ v.x = ReadCoord();
+ v.y = ReadCoord();
+ v.z = ReadCoord();
if(!isnew)
return;
self.warpzone_transform = v;
entity e;
float pd;
- mi_x = min(o.x, c0_x, c1_x, c2_x, c3_x);
- ma_x = max(o.x, c0_x, c1_x, c2_x, c3_x);
- mi_y = min(o.y, c0_y, c1_y, c2_y, c3_y);
- ma_y = max(o.y, c0_y, c1_y, c2_y, c3_y);
- mi_z = min(o.z, c0_z, c1_z, c2_z, c3_z);
- ma_z = max(o.z, c0_z, c1_z, c2_z, c3_z);
+ mi.x = min(o.x, c0_x, c1_x, c2_x, c3_x);
+ ma.x = max(o.x, c0_x, c1_x, c2_x, c3_x);
+ mi.y = min(o.y, c0_y, c1_y, c2_y, c3_y);
+ ma.y = max(o.y, c0_y, c1_y, c2_y, c3_y);
+ mi.z = min(o.z, c0_z, c1_z, c2_z, c3_z);
+ ma.z = max(o.z, c0_z, c1_z, c2_z, c3_z);
e = WarpZone_Find(mi, ma);
if(e)
#ifdef KEEP_ROLL
float roll;
roll = ang.z;
- ang_z = 0;
+ ang.z = 0;
#endif
ang = AnglesTransform_ApplyToVAngles(wz.warpzone_transform, ang);
#ifdef KEEP_ROLL
ang = AnglesTransform_Normalize(ang, true);
ang = AnglesTransform_CancelRoll(ang);
- ang_z = roll;
+ ang.z = roll;
#else
ang = AnglesTransform_Normalize(ang, false);
#endif
float roll;
roll = ang.z;
- ang_z = 0;
+ ang.z = 0;
ang = AnglesTransform_ApplyToVAngles(AnglesTransform_Invert(wz.warpzone_transform), ang);
ang = AnglesTransform_Normalize(ang, true);
ang = AnglesTransform_CancelRoll(ang);
- ang_z = roll;
+ ang.z = roll;
return ang;
}
vector WarpZoneLib_NearestPointOnBox(vector mi, vector ma, vector org)
{
vector nearest;
- nearest_x = bound(mi.x, org.x, ma.x);
- nearest_y = bound(mi.y, org.y, ma.y);
- nearest_z = bound(mi.z, org.z, ma.z);
+ nearest.x = bound(mi.x, org.x, ma.x);
+ nearest.y = bound(mi.y, org.y, ma.y);
+ nearest.z = bound(mi.z, org.z, ma.z);
return nearest;
}
vector frexp(float x)
{
vector v;
- v_z = 0;
- v_y = ilogb(x) + 1;
- v_x = x / exp2(v.y);
+ v.z = 0;
+ v.y = ilogb(x) + 1;
+ v.x = x / exp2(v.y);
return v;
}
int ilogb(float x)
// gamma(1-z) * gamma(z) = pi / sin(pi*z)
// lgamma(1-z) + lgamma(z) = log(pi) - log(sin(pi*z))
// sign of gamma(1-z) = sign of gamma(z) * sign of sin(pi*z)
- v_z = sin(M_PI * x);
- v_x = log(M_PI) - log(fabs(v.z)) - v.x;
+ v.z = sin(M_PI * x);
+ v.x = log(M_PI) - log(fabs(v.z)) - v.x;
if(v.z < 0)
- v_y = -v.y;
- v_z = 0;
+ v.y = -v.y;
+ v.z = 0;
return v;
}
if(x < 1.1)
vector remquo(float x, float y)
{
vector v;
- v_z = 0;
- v_y = rint(x / y);
- v_x = x - y * v.y;
+ v.z = 0;
+ v.y = rint(x / y);
+ v.x = x - y * v.y;
return v;
}
float WarpZone_Send(entity to, float sendflags)
{
- float f;
WriteByte(MSG_ENTITY, ENT_CLIENT_WARPZONE);
// we must send this flag for clientside to match properly too
- f = 0;
+ int f = 0;
if(self.warpzone_isboxy)
BITSET_ASSIGN(f, 1);
if(self.warpzone_fadestart)
float WarpZone_Camera_Send(entity to, float sendflags)
{
- float f = 0;
+ int f = 0;
WriteByte(MSG_ENTITY, ENT_CLIENT_WARPZONE_CAMERA);
if(self.warpzone_fadestart)
norm = -1 * norm;
}
ang = vectoangles2(norm, v_up); // keep rotation, but turn exactly against plane
- ang_x = -ang.x;
+ ang.x = -ang.x;
if(norm * v_forward < 0.99)
print("trigger_warpzone near ", vtos(self.aiment.origin), " has been turned to match plane orientation (", vtos(self.aiment.angles), " -> ", vtos(ang), "\n");
if(vlen(org - self.aiment.origin) > 0.5)
{
org = point;
ang = vectoangles(norm);
- ang_x = -ang.x;
+ ang.x = -ang.x;
}
else
error("cannot infer origin/angles for this warpzone, please use a killtarget or a trigger_warpzone_position");
projects / xonotic / xonotic-data.pk3dir.git / commitdiff