{
if(argv(1) == "")
continue;
- QuickMenu_Buffer_Set(QM_TAG_TITLE, argv(0));
+ QuickMenu_Buffer_Set(QM_TAG_TITLE, argv(0));
++QuickMenu_Buffer_Size;
QuickMenu_Buffer_Set(QM_TAG_COMMAND, argv(1));
}
CSQC_common_hud();
// crosshair goes VERY LAST
- if(!scoreboard_active && !camera_active && intermission != 2 &&
+ if(!scoreboard_active && !camera_active && intermission != 2 &&
spectatee_status != -1 && hud == HUD_NORMAL && !csqcplayer.viewloc &&
!HUD_MinigameMenu_IsOpened() )
{
void minigame_hud_simpleboard(vector pos, vector mySize, string board_texture)
{
if(panel.current_panel_bg != "0" && panel.current_panel_bg != "")
- draw_BorderPicture(pos - '1 1 0' * panel_bg_border,
- panel.current_panel_bg,
- mySize + '1 1 0' * 2 * panel_bg_border,
- panel_bg_color, panel_bg_alpha,
+ draw_BorderPicture(pos - '1 1 0' * panel_bg_border,
+ panel.current_panel_bg,
+ mySize + '1 1 0' * 2 * panel_bg_border,
+ panel_bg_color, panel_bg_alpha,
'1 1 0' * (panel_bg_border/BORDER_MULTIPLIER));
drawpic(pos, board_texture, mySize, '1 1 1', panel_bg_alpha, DRAWFLAG_NORMAL);
}
if ( !last_minig ) minigame_descriptors = minig; \
else last_minig.list_next = minig; \
last_minig = minig;
-
+
REGISTERED_MINIGAMES
-
+
#undef MINIGAME
}
deactivate_minigame();
return;
}
-
+
if ( !minigame.descriptor || minigame.classname != "minigame" )
{
LOG_TRACE("Trying to activate unregistered minigame ",minigame.netname," in client\n");
return;
}
-
+
if ( minigame == active_minigame )
return;
-
+
if ( active_minigame )
{
deactivate_minigame();
}
-
+
if ( minigame_self.owner != minigame )
minigame_self = world;
active_minigame = minigame;
active_minigame.minigame_event(active_minigame,"activate");
-
+
if ( HUD_MinigameMenu_IsOpened() )
HUD_MinigameMenu_CurrentButton();
else
self.classname = msle_classname(ReadShort());
self.netname = ReadString_Zoned();
}
-
+
entity minigame_ent = world;
-
+
if ( self.classname == "minigame" )
{
minigame_ent = self;
-
+
if ( sf & MINIG_SF_CREATE )
{
self.entremove = minigame_entremove;
float ent = ReadLong();
self.minigame_playerslot = ent;
LOG_TRACE("Player: ",GetPlayerName(ent-1),"\n");
-
+
activate = (ent == player_localnum+1 && self.owner && self.owner != active_minigame);
-
+
}
minigame_ent = self.owner;
-
+
if ( sf & MINIG_SF_UPDATE )
self.team = ReadByte();
-
+
if ( activate )
{
minigame_self = self;
}
}
MINIGAME_SIMPLELINKED_ENTITIES
-
+
if ( minigame_ent )
minigame_ent.minigame_event(minigame_ent,"network_receive",self,sf);
}
take_until = textLengthUpToWidth(s, w, theFontSize, tw);
-
+
if ( take_until > strlen(s) )
take_until = strlen(s);
skip = 1;
break;
}
-
+
if ( take_until > 0 || skip > 0 )
{
if ( skip == 0 && take_until < strlen(s) )
skip = 1;
}
}
-
+
getWrappedLine_remaining = substring(s, take_until+skip, strlen(s) - (take_until+skip));
if(getWrappedLine_remaining == "")
getWrappedLine_remaining = string_null;
}
}
-vector minigame_drawstring_wrapped( float maxwidth, vector pos, string text,
+vector minigame_drawstring_wrapped( float maxwidth, vector pos, string text,
vector fontsize, vector color, float theAlpha, int drawflags, float align )
-{
+{
getWrappedLine_remaining = text;
vector mypos = pos;
while ( getWrappedLine_remaining )
return mypos;
}
-vector minigame_drawcolorcodedstring_wrapped( float maxwidth, vector pos,
+vector minigame_drawcolorcodedstring_wrapped( float maxwidth, vector pos,
string text, vector fontsize, float theAlpha, int drawflags, float align )
{
getWrappedLine_remaining = text;
return mypos;
}
-void minigame_drawstring_trunc(float maxwidth, vector pos, string text,
+void minigame_drawstring_trunc(float maxwidth, vector pos, string text,
vector fontsize, vector color, float theAlpha, int drawflags )
{
string line = textShortenToWidth(text,maxwidth,fontsize,stringwidth_nocolors);
drawstring(pos, line, fontsize, color, theAlpha, drawflags);
}
-void minigame_drawcolorcodedstring_trunc(float maxwidth, vector pos, string text,
+void minigame_drawcolorcodedstring_trunc(float maxwidth, vector pos, string text,
vector fontsize, float theAlpha, int drawflags )
{
string line = textShortenToWidth(text,maxwidth,fontsize,stringwidth_colors);
drawcolorcodedstring(pos, line, fontsize, theAlpha, drawflags);
}
-void minigame_drawpic_centered( vector pos, string texture, vector sz,
+void minigame_drawpic_centered( vector pos, string texture, vector sz,
vector color, float thealpha, int drawflags )
{
drawpic( pos-sz/2, texture, sz, color, thealpha, drawflags );
localcmd(strcat(cmd,"\n"));
}
-// Prompt the player to play in the current minigame
+// Prompt the player to play in the current minigame
// (ie: it's their turn and they should get back to the minigame)
void minigame_prompt()
{
// Like drawstring, but wrapping words to fit maxwidth
// returns the size of the drawn area
// align selects the string alignment (0 = left, 0.5 = center, 1 = right)
-vector minigame_drawstring_wrapped( float maxwidth, vector pos, string text,
+vector minigame_drawstring_wrapped( float maxwidth, vector pos, string text,
vector fontsize, vector color, float theAlpha, int drawflags, float align );
// Like drawcolorcodedstring, but wrapping words to fit maxwidth
// returns the size of the drawn area
// align selects the string alignment (0 = left, 0.5 = center, 1 = right)
-vector minigame_drawcolorcodedstring_wrapped( float maxwidth, vector pos,
+vector minigame_drawcolorcodedstring_wrapped( float maxwidth, vector pos,
string text, vector fontsize, float theAlpha, int drawflags, float align );
// Like drawstring but truncates the text to fit maxwidth
-void minigame_drawstring_trunc(float maxwidth, vector pos, string text,
+void minigame_drawstring_trunc(float maxwidth, vector pos, string text,
vector fontsize, vector color, float theAlpha, int drawflags );
// Like drawcolorcodedstring but truncates the text to fit maxwidth
-void minigame_drawcolorcodedstring_trunc(float maxwidth, vector pos, string text,
+void minigame_drawcolorcodedstring_trunc(float maxwidth, vector pos, string text,
vector fontsize, float theAlpha, int drawflags );
// like drawpic but pos represent the center rather than the topleft corner
-void minigame_drawpic_centered( vector pos, string texture, vector sz,
+void minigame_drawpic_centered( vector pos, string texture, vector sz,
vector color, float thealpha, int drawflags );
// Get full path of a minigame texture
// Read a minigame entity from the server
void ent_read_minigame();
-// Prompt the player to play in the current minigame
+// Prompt the player to play in the current minigame
// (ie: it's their turn and they should get back to the minigame)
void minigame_prompt();
#define FOREACH_MINIGAME_ENTITY(entityvar) \
entityvar=world; \
- while( (entityvar = findentity(entityvar,owner,active_minigame)) )
+ while( (entityvar = findentity(entityvar,owner,active_minigame)) )
#endif
{
vector pos = stov(cvar_string(strcat("hud_panel_", somepanel.panel_name, "_pos")));
vector sz = stov(cvar_string(strcat("hud_panel_", somepanel.panel_name, "_size")));
- return mousepos_x >= pos_x*vid_conwidth && mousepos_x <= (pos_x+sz_x)*vid_conwidth &&
+ return mousepos_x >= pos_x*vid_conwidth && mousepos_x <= (pos_x+sz_x)*vid_conwidth &&
mousepos_y >= pos_y*vid_conheight && mousepos_y <= (pos_y+sz_y)*vid_conheight ;
}
void HUD_MinigameBoard ()
{
entity hud_minigame = world;
-
+
if(!autocvar__hud_configure)
hud_minigame = active_minigame.descriptor;
else
hud_minigame = minigame_get_descriptor("nmm");
-
+
if ( !hud_minigame )
return;
-
+
HUD_Panel_UpdateCvars();
-
-
+
+
vector pos, mySize;
pos = panel_pos;
mySize = panel_size;
-
+
hud_minigame.minigame_hud_board(pos,mySize);
}
void HUD_MinigameStatus ()
{
entity hud_minigame = world;
-
+
if(!autocvar__hud_configure)
hud_minigame = active_minigame.descriptor;
else
hud_minigame = minigame_get_descriptor("nmm");
-
+
if ( !hud_minigame )
return;
-
+
HUD_Panel_UpdateCvars();
-
-
+
+
vector pos, mySize;
pos = panel_pos;
mySize = panel_size;
-
+
if(panel_bg_padding)
{
pos += '1 1 0' * panel_bg_padding;
mySize -= '2 2 0' * panel_bg_padding;
}
-
+
hud_minigame.minigame_hud_status(pos,mySize);
}
HUD_MinigameMenu_last_entry = newentry;
return;
}
-
+
newentry.list_prev = prev;
newentry.list_next = prev.list_next;
if ( prev.list_next )
else
HUD_MinigameMenu_last_entry = newentry;
prev.list_next = newentry;
-
+
}
{
HUD_MinigameMenu_Click(e);
}
-
+
if ( e.list_prev )
e.list_prev.list_next = e.list_next;
else
HUD_MinigameMenu_entries = e.list_next;
-
+
if ( e.list_next )
e.list_next.list_prev = e.list_prev;
else
HUD_MinigameMenu_last_entry = e.list_prev;
-
+
if ( HUD_MinigameMenu_activeitem == e )
HUD_MinigameMenu_activeitem = world;
-
+
remove(e);
}
entity e;
if ( self.flags & 2 )
{
- if ( HUD_MinigameMenu_activeitem &&
+ if ( HUD_MinigameMenu_activeitem &&
HUD_MinigameMenu_activeitem.owner == self )
HUD_MinigameMenu_activeitem = world;
self.flags &= ~2;
if ( e.flags & 2 && e.origin_x == self.origin_x)
HUD_MinigameMenu_Click(e);
}
-
+
self.flags |= 2;
-
+
return true;
}
return false;
{
HUD_MinigameMenu_InsertEntry( HUD_MinigameMenu_SpawnSubEntry(
_("Quit"), HUD_MinigameMenu_ClickQuit, self ), self);
-
+
active_minigame.minigame_event(active_minigame,"menu_show",self);
-
+
HUD_MinigameMenu_InsertEntry( HUD_MinigameMenu_SpawnSubEntry(
_("Invite"), HUD_MinigameMenu_ClickInvite, self), self);
}
HUD_MinigameMenu_InsertEntry(currb,HUD_MinigameMenu_last_entry);
HUD_MinigameMenu_Click(currb);
}
- else
+ else
{
entity p;
for ( e = HUD_MinigameMenu_last_entry; e != world; e = p.list_prev )
panel_pos += '1 1 0' * panel_bg_padding;
panel_size -= '2 2 0' * panel_bg_padding;
}
-
+
entity e;
-
+
panel_pos_y += hud_fontsize_y*2;
-
+
HUD_MinigameMenu_activeitem = world;
vector sz;
for ( e = HUD_MinigameMenu_entries; e != world; e = e.list_next )
// Minigame menu panel UI
void HUD_MinigameMenu ()
-{
+{
if ( !HUD_MinigameMenu_IsOpened() )
return;
-
+
HUD_Panel_UpdateCvars();
-
+
HUD_Panel_DrawBg(1);
-
+
if(panel_bg_padding)
{
panel_pos += '1 1 0' * panel_bg_padding;
for ( entity e = HUD_MinigameMenu_entries; e != world; e = e.list_next )
{
color = e.colormod;
-
+
offset = e.origin;
itemh = e.size_y;
-
+
if ( e.model )
itemh = imgsz_y;
-
+
if ( e.flags & 2 )
{
- drawfill(panel_pos, eX*panel_size_x + eY*itemh, e.colormod,
+ drawfill(panel_pos, eX*panel_size_x + eY*itemh, e.colormod,
panel_fg_alpha, DRAWFLAG_NORMAL);
color = '0 0 0';
}
offset_x += imgsz_x;
offset_y = (imgsz_y-e.size_y) / 2;
}
-
+
if ( e.flags & 1 )
HUD_MinigameMenu_DrawColoredEntry(panel_pos+offset,e.message,e.size);
else
HUD_MinigameMenu_DrawEntry(panel_pos+offset,e.message,e.size,color);
-
+
if ( e == HUD_MinigameMenu_activeitem )
drawfill(panel_pos, eX*panel_size_x + eY*itemh,'1 1 1', 0.25, DRAWFLAG_ADDITIVE);
-
+
panel_pos_y += itemh;
}
}
void HUD_MinigameHelp()
{
string help_message;
-
+
if(!autocvar__hud_configure)
help_message = active_minigame.message;
else
help_message = "Minigame message";
-
+
if ( !help_message )
return;
-
+
HUD_Panel_UpdateCvars();
-
-
+
+
vector pos, mySize;
pos = panel_pos;
mySize = panel_size;
-
+
if(panel_bg_padding)
{
pos += '1 1 0' * panel_bg_padding;
mySize -= '2 2 0' * panel_bg_padding;
}
-
- minigame_drawcolorcodedstring_wrapped( mySize_x, pos, help_message,
+
+ minigame_drawcolorcodedstring_wrapped( mySize_x, pos, help_message,
hud_fontsize, panel_fg_alpha, DRAWFLAG_NORMAL, 0.5 );
}
// ====================================================================
float HUD_Minigame_InputEvent(float bInputType, float nPrimary, float nSecondary)
{
-
+
if( !HUD_MinigameMenu_IsOpened() || autocvar__hud_configure )
return false;
if ( minigame_isactive() && HUD_mouse_over(HUD_PANEL(MINIGAME_BOARD)) )
active_minigame.minigame_event(active_minigame,"mouse_moved",mousepos);
return true;
-
+
}
else
{
if(nPrimary == K_MOUSE1) mouseClicked -= (mouseClicked & S_MOUSE1);
if(nPrimary == K_MOUSE2) mouseClicked -= (mouseClicked & S_MOUSE2);
}
-
+
// allow some binds
string con_keys;
con_keys = findkeysforcommand("toggleconsole", 0);
if(nPrimary == stof(argv(i)))
return false;
}
-
+
if ( minigame_isactive() && ( bInputType == 0 || bInputType == 1 ) )
{
string device = "";
}
else
device = "key";
-
+
if ( device && active_minigame.minigame_event(
active_minigame,strcat(device,"_",action),nPrimary) )
return true;
-
+
/// TODO: bInputType == 2?
}
-
+
if ( bInputType == 0 )
{
if ( nPrimary == K_MOUSE1 && HUD_MinigameMenu_activeitem &&
}
}
}
-
+
return false;
}
void HUD_Minigame_Mouse()
-{
+{
if( !HUD_MinigameMenu_IsOpened() || autocvar__hud_configure || mv_active )
return;
-
+
if(!autocvar_hud_cursormode)
{
mousepos = mousepos + getmousepos() * autocvar_menu_mouse_speed;
mousepos_x = bound(0, mousepos_x, vid_conwidth);
mousepos_y = bound(0, mousepos_y, vid_conheight);
}
-
+
if ( HUD_MinigameMenu_IsOpened() && HUD_mouse_over(HUD_PANEL(MINIGAME_MENU)) )
HUD_MinigameMenu_MouseInput();
-
+
vector cursorsize = '32 32 0';
- drawpic(mousepos-'8 4 0', strcat("gfx/menu/", autocvar_menu_skin, "/cursor.tga"),
+ drawpic(mousepos-'8 4 0', strcat("gfx/menu/", autocvar_menu_skin, "/cursor.tga"),
cursorsize, '1 1 1', panel_fg_alpha, DRAWFLAG_NORMAL);
}
* MINIG_SF_UPDATE
A miscellaneous update, can be safely used if the entity has just a few fields
* MINIG_SF_CUSTOM
- Starting value for custom flags, since there are bit-wise flags,
+ Starting value for custom flags, since there are bit-wise flags,
the following values shall be MINIG_SF_CUSTOM*2, MINIG_SF_CUSTOM*4 and MINIG_SF_CUSTOM*8.
* MINIG_SF_MAX
Maximum flag value that will be networked
* Set up automatic entity read/write functionality
* To ensure that everything is handled automatically, spawn on the server using msle_spawn
* Syntax:
- * MSLE(classname,Field...) \
+ * MSLE(classname,Field...) \
* classname: Identifier used to recognize the type of the entity
* (must be set as .classname on the sent entities)
* Field... : List of FIELD calls
MSLE(pong_paddle,FIELD(MINIG_SF_CREATE,Byte,team) FIELD(MINIG_SF_CREATE,Float,pong_length) FIELD(MINIG_SF_UPDATE,Vector2D,origin)) \
MSLE(pong_ball,FIELD(MINIG_SF_CREATE,Float,pong_length) FIELD(PONG_SF_BALLTEAM,Byte,team) FIELD(MINIG_SF_UPDATE, Vector2D, velocity) FIELD(MINIG_SF_UPDATE, Vector2D, origin)) \
MSLE(pong_ai, FIELD(MINIG_SF_CREATE,Byte,team) FIELD(PONG_SF_PLAYERSCORE, Long, pong_score)) \
- /*empty line*/
+ /*empty line*/
if(found >= C4_WIN_CNT)
return true;
-
+
return false;
}
{
switch(argv(0))
{
- case "move":
- c4_move(minigame, ...(0,entity), ...(1,int) == 2 ? argv(1) : string_null );
+ case "move":
+ c4_move(minigame, ...(0,entity), ...(1,int) == 2 ? argv(1) : string_null );
return true;
}
return false;
}
}
-
+
return false;
}
minigame_hud_fitsqare(pos, mySize);
c4_boardpos = pos;
c4_boardsize = mySize;
-
+
minigame_hud_simpleboard(pos,mySize,minigame_texture("c4/board_under"));
drawpic(pos, minigame_texture("c4/board_over"), mySize, '1 1 1', 1, 0);
{
tile_pos = minigame_tile_pos(c4_curr_pos,C4_NUM_CNT,C4_LET_CNT);
tile_pos = minigame_hud_denormalize(tile_pos,pos,mySize);
- minigame_drawpic_centered( tile_pos,
+ minigame_drawpic_centered( tile_pos,
minigame_texture(strcat("c4/piece",ftos(minigame_self.team))),
tile_size, '1 1 1', panel_fg_alpha/2, DRAWFLAG_NORMAL );
}
-
+
entity e;
FOREACH_MINIGAME_ENTITY(e)
{
{
tile_pos = minigame_tile_pos(e.netname,C4_NUM_CNT,C4_LET_CNT);
tile_pos = minigame_hud_denormalize(tile_pos,pos,mySize);
-
+
if ( active_minigame.minigame_flags & C4_TURN_WIN )
if ( !e.c4_checkwin )
e.c4_checkwin = c4_winning_piece(e) ? 1 : -1;
-
+
float icon_color = 1;
if ( e.c4_checkwin == -1 )
icon_color = 0.4;
minigame_drawpic_centered( tile_pos, minigame_texture("c4/winglow"),
tile_size, '1 1 1', panel_fg_alpha, DRAWFLAG_ADDITIVE );
}
-
- minigame_drawpic_centered( tile_pos,
+
+ minigame_drawpic_centered( tile_pos,
minigame_texture(strcat("c4/piece",ftos(e.team))),
tile_size, '1 1 1'*icon_color, panel_fg_alpha, DRAWFLAG_NORMAL );
}
vector winfs = hud_fontsize*2;
string playername = "";
FOREACH_MINIGAME_ENTITY(e)
- if ( e.classname == "minigame_player" &&
+ if ( e.classname == "minigame_player" &&
e.team == (active_minigame.minigame_flags & C4_TURN_TEAM) )
playername = GetPlayerName(e.minigame_playerslot-1);
-
+
vector win_pos = pos+eY*(mySize_y-winfs_y)/2;
vector win_sz;
win_sz = minigame_drawcolorcodedstring_wrapped(mySize_x,win_pos,
- sprintf("%s^7 won the game!",playername),
+ sprintf("%s^7 won the game!",playername),
winfs, 0, DRAWFLAG_NORMAL, 0.5);
-
+
drawfill(win_pos-eY*hud_fontsize_y,win_sz+2*eY*hud_fontsize_y,'1 1 1',0.5,DRAWFLAG_ADDITIVE);
-
+
minigame_drawcolorcodedstring_wrapped(mySize_x,win_pos,
- sprintf("%s^7 won the game!",playername),
+ sprintf("%s^7 won the game!",playername),
winfs, panel_fg_alpha, DRAWFLAG_NORMAL, 0.5);
}
}
vector ts;
ts = minigame_drawstring_wrapped(mySize_x,pos,active_minigame.descriptor.message,
hud_fontsize * 2, '0.25 0.47 0.72', panel_fg_alpha, DRAWFLAG_NORMAL,0.5);
-
+
pos_y += ts_y;
mySize_y -= ts_y;
-
+
vector player_fontsize = hud_fontsize * 1.75;
ts_y = ( mySize_y - 2*player_fontsize_y ) / 2;
ts_x = mySize_x;
minigame_drawcolorcodedstring_trunc(mySize_x,mypos,
GetPlayerName(e.minigame_playerslot-1),
player_fontsize, panel_fg_alpha, DRAWFLAG_NORMAL);
-
+
mypos_y += player_fontsize_y;
- drawpic( mypos,
+ drawpic( mypos,
minigame_texture(strcat("c4/piece",ftos(e.team))),
tile_size, '1 1 1', panel_fg_alpha, DRAWFLAG_NORMAL );
-
+
mypos_x += tile_size_x;
}
}
{
if ( turnflags & C4_TURN_DRAW )
return _("Draw");
-
+
if ( turnflags & C4_TURN_WIN )
{
if ( (turnflags&C4_TURN_TEAM) != minigame_self.team )
return _("You lost the game!");
return _("You win!");
}
-
+
if ( (turnflags & C4_TURN_TEAM) != minigame_self.team )
return _("Wait for your opponent to make their move");
-
+
if ( turnflags & C4_TURN_PLACE )
return _("Click on the game board to place your piece");
-
+
return "";
}
return false;
}
-#endif
\ No newline at end of file
+#endif
// Create an new tile
// \param id Tile index (eg: a1)
-// \param minig Owner minigame instance
+// \param minig Owner minigame instance
// \param distance Distance from adjacent tiles
void nmm_spawn_tile(string id, entity minig, int distance)
{
}
// Create a tile square and recursively create inner squares
-// \param minig Owner minigame instance
+// \param minig Owner minigame instance
// \param offset Index offset (eg: 1 to start the square at b2, 0 at a1 etc.)
// \param skip Number of indices to skip between tiles (eg 1: a1, a3)
void nmm_spawn_tile_square( entity minig, int offset, int skip )
}
letter += skip+1;
}
-
+
if ( skip > 0 )
nmm_spawn_tile_square(minig,offset+1,skip-1);
}
// Check whether two tiles are adjacent
bool nmm_tile_adjacent(entity tile1, entity tile2)
{
-
+
int dnumber = fabs ( minigame_tile_number(tile1.netname) - minigame_tile_number(tile2.netname) );
int dletter = fabs ( minigame_tile_letter(tile1.netname) - minigame_tile_letter(tile2.netname) );
-
+
return ( dnumber == 0 && ( dletter == 1 || dletter == tile1.nmm_tile_distance ) ) ||
( dletter == 0 && ( dnumber == 1 || dnumber == tile1.nmm_tile_distance ) );
}
{
entity e = world;
while ( ( e = findentity(e,owner,tile.owner) ) )
- if ( e.classname == "minigame_nmm_tile" && !e.nmm_tile_piece
+ if ( e.classname == "minigame_nmm_tile" && !e.nmm_tile_piece
&& nmm_tile_adjacent(e,tile) )
{
return true;
// Check if a tile is in a mill
bool nmm_in_mill(entity tile)
{
- return tile.nmm_tile_piece && (
+ return tile.nmm_tile_piece && (
nmm_in_mill_string(tile,tile.nmm_tile_hmill) ||
nmm_in_mill_string(tile,tile.nmm_tile_vmill) );
}
{
entity e = start;
while ( ( e = findentity(e,owner,minigame) ) )
- if ( e.classname == "minigame_board_piece" &&
+ if ( e.classname == "minigame_board_piece" &&
(e.minigame_flags & pieceflags) && e.team == teamn )
return e;
return world;
e.team = 2;
e.minigame_flags = NMM_PIECE_HOME;
}
-
+
return 1;
}
else if ( event == "end" )
entity tile = world;
entity piece = world;
bool move_ok = false;
-
- if ( e && argc >= 2 && argv(0) == "move" &&
+
+ if ( e && argc >= 2 && argv(0) == "move" &&
( minigame.minigame_flags & NMM_TURN_TEAM ) == e.team )
{
tile = nmm_find_tile(minigame,argv(1));
move_ok = true;
}
}
-
+
}
else if ( minigame.minigame_flags & NMM_TURN_FLY )
{
move_ok = true;
}
}
-
+
}
else if ( minigame.minigame_flags & NMM_TURN_TAKE )
{
move_ok = true;
}
}
-
+
int nextteam = e.team % 2 + 1;
int npieces = nmm_count_pieces(minigame,nextteam,NMM_PIECE_HOME|NMM_PIECE_BOARD);
-
+
if ( npieces < 3 )
{
minigame.minigame_flags = NMM_TURN_WIN | e.team;
nmm_boardpos = pos;
nmm_boardsize = mySize;
minigame_hud_simpleboard(pos,mySize,minigame_texture("nmm/board"));
-
+
vector tile_size = minigame_hud_denormalize_size('1 1 0'/7,pos,mySize);
vector tile_pos;
entity e;
if ( e.classname == "minigame_nmm_tile" )
{
tile_pos = minigame_hud_denormalize(e.origin,pos,mySize);
-
+
if ( e == nmm_fromtile )
{
minigame_drawpic_centered( tile_pos, minigame_texture("nmm/tile_active"),
minigame_drawpic_centered( tile_pos, minigame_texture("nmm/tile_available"),
tile_size, '1 1 1', panel_fg_alpha, DRAWFLAG_NORMAL );
}
-
+
if ( e == nmm_currtile )
{
minigame_drawpic_centered( tile_pos, minigame_texture("nmm/tile_selected"),
tile_size, '1 1 1', panel_fg_alpha, DRAWFLAG_ADDITIVE );
}
-
+
if ( e.nmm_tile_piece )
{
- minigame_drawpic_centered( tile_pos,
+ minigame_drawpic_centered( tile_pos,
minigame_texture(strcat("nmm/piece",ftos(e.nmm_tile_piece.team))),
tile_size*0.8, '1 1 1', panel_fg_alpha, DRAWFLAG_NORMAL );
}
-
+
//drawstring(tile_pos, e.netname, hud_fontsize, '1 0 0', 1, DRAWFLAG_NORMAL);
}
}
-
+
if ( active_minigame.minigame_flags & NMM_TURN_WIN )
{
vector winfs = hud_fontsize*2;
string playername = "";
FOREACH_MINIGAME_ENTITY(e)
- if ( e.classname == "minigame_player" &&
+ if ( e.classname == "minigame_player" &&
e.team == (active_minigame.minigame_flags & NMM_TURN_TEAM) )
playername = GetPlayerName(e.minigame_playerslot-1);
-
+
vector win_pos = pos+eY*(mySize_y-winfs_y)/2;
vector win_sz;
win_sz = minigame_drawcolorcodedstring_wrapped(mySize_x,win_pos,
- sprintf("%s^7 won the game!",playername),
+ sprintf("%s^7 won the game!",playername),
winfs, 0, DRAWFLAG_NORMAL, 0.5);
-
+
drawfill(win_pos-eY*hud_fontsize_y,win_sz+2*eY*hud_fontsize_y,'1 1 1',0.5,DRAWFLAG_ADDITIVE);
-
+
minigame_drawcolorcodedstring_wrapped(mySize_x,win_pos,
- sprintf("%s^7 won the game!",playername),
+ sprintf("%s^7 won the game!",playername),
winfs, panel_fg_alpha, DRAWFLAG_NORMAL, 0.5);
}
}
{
HUD_Panel_DrawBg(1);
vector ts;
-
+
ts = minigame_drawstring_wrapped(mySize_x,pos,active_minigame.descriptor.message,
hud_fontsize * 2, '0.25 0.47 0.72', panel_fg_alpha, DRAWFLAG_NORMAL,0.5);
pos_y += ts_y;
mySize_y -= ts_y;
-
+
vector player_fontsize = hud_fontsize * 1.75;
ts_y = ( mySize_y - 2*player_fontsize_y ) / 2;
ts_x = mySize_x;
-
+
float player1x = 0;
float player2x = 0;
vector piece_sz = '48 48 0';
vector mypos;
float piece_light = 1;
entity e = world;
-
+
mypos = pos;
if ( (active_minigame.minigame_flags&NMM_TURN_TEAM) == 2 )
mypos_y += player_fontsize_y + ts_y;
drawfill(mypos,eX*mySize_x+eY*player_fontsize_y,'1 1 1',0.5,DRAWFLAG_ADDITIVE);
mypos_y += player_fontsize_y;
drawfill(mypos,eX*mySize_x+eY*piece_sz_y,'1 1 1',0.25,DRAWFLAG_ADDITIVE);
-
+
FOREACH_MINIGAME_ENTITY(e)
{
if ( e.classname == "minigame_player" )
piece_light = 1;
else
piece_light = 0.15;
-
+
drawpic(mypos, minigame_texture(strcat("nmm/piece",ftos(e.team))), piece_sz,
'1 1 1'*piece_light, panel_fg_alpha, DRAWFLAG_NORMAL );
}
return _("You lost the game!");
return _("You win!");
}
-
+
if ( (turnflags&NMM_TURN_TEAM) != minigame_self.team )
return _("Wait for your opponent to make their move");
if ( turnflags & NMM_TURN_PLACE )
return _("You can select one of your pieces to move it anywhere on the board");
if ( turnflags & NMM_TURN_TAKE )
return _("You can take one of the opponent's pieces");
-
+
return "";
}
else
{
string tileid = nmm_currtile.netname;
- nmm_currtile = world;
+ nmm_currtile = world;
while ( !nmm_currtile )
{
tileid = minigame_relative_tile(tileid,1,0,7,7);
else
{
string tileid = nmm_currtile.netname;
- nmm_currtile = world;
+ nmm_currtile = world;
while ( !nmm_currtile )
{
tileid = minigame_relative_tile(tileid,-1,0,7,7);
else
{
string tileid = nmm_currtile.netname;
- nmm_currtile = world;
+ nmm_currtile = world;
while ( !nmm_currtile )
{
tileid = minigame_relative_tile(tileid,0,1,7,7);
else
{
string tileid = nmm_currtile.netname;
- nmm_currtile = world;
+ nmm_currtile = world;
while ( !nmm_currtile )
{
tileid = minigame_relative_tile(tileid,0,-1,7,7);
}
}
}
- else if ( self.classname == "minigame" && ( ...(1,int) & MINIG_SF_UPDATE ) )
+ else if ( self.classname == "minigame" && ( ...(1,int) & MINIG_SF_UPDATE ) )
{
self.message = nmm_turn_to_string(self.minigame_flags);
if ( self.minigame_flags & minigame_self.team )
minigame_prompt();
}
}
-
+
return 0;
}
-#endif
+#endif
{
if ( !minigame )
return;
-
+
if ( team_thrower == 0 )
team_thrower = team_receiver;
-
+
if ( team_thrower == team_receiver )
delta *= -1;
-
+
entity paddle_thrower = minigame.pong_paddles[team_thrower-1];
if ( paddle_thrower.realowner.minigame_players )
{
case 3: ball.velocity_y = fabs(ball.velocity_y); break;
case 4: ball.velocity_y = -fabs(ball.velocity_y); break;
}
-
+
float angle = atan2(ball.velocity_y, ball.velocity_x);
angle += ( random() - 0.5 ) * 2 * M_PI/6;
float speed = vlen(ball.velocity);
-
+
ball.velocity_y = speed * sin(angle);
ball.velocity_x = speed * cos(angle);
}
entity paddle = ball.owner.pong_paddles[pteam-1];
if (!paddle)
return false;
- vector near_point = box_nearest(paddle.mins+paddle.origin,
+ vector near_point = box_nearest(paddle.mins+paddle.origin,
paddle.maxs+paddle.origin, ball.origin);
return vlen(near_point-ball.origin) <= ball.pong_length ;
}
entity paddle = ball.owner.pong_paddles[pteam-1];
if (!paddle)
return false;
-
+
if ( !pong_paddle_hit(ball, pteam) )
{
pong_add_score(ball.owner ,ball.team, pteam, 1);
pong_ball_reset(ball);
return true;
}
-
+
return false;
}
{SELFPARAM();
float think_speed = autocvar_sys_ticrate;
self.nextthink = time + think_speed;
-
+
self.origin_x += self.velocity_x * think_speed;
self.origin_y += self.velocity_y * think_speed;
self.SendFlags |= MINIG_SF_UPDATE;
-
+
int i;
for ( i = 1; i <= PONG_MAX_PLAYERS; i++ )
if ( pong_paddle_hit(self, i) )
self.SendFlags |= PONG_SF_BALLTEAM;
return;
}
-
+
if ( self.origin_y <= self.pong_length )
{
if ( !pong_goal(self,3) )
self.velocity_y *= -1;
}
}
-
+
if ( self.origin_x <= self.pong_length )
{
if ( !pong_goal(self,2) )
self.velocity_x *= -1;
}
}
-
+
}
// AI action
{SELFPARAM();
float think_speed = autocvar_sv_minigames_pong_ai_thinkspeed;
self.nextthink = time + think_speed;
-
+
float distance;
float next_distance;
float min_distance = 1;
ball = mayball;
}
}
-
+
float target = 0.5;
float self_pos;
-
-
+
+
if ( self.team <= 2 )
{
if ( ball )
target = ball.origin_x + ball.velocity_x*think_speed;
self_pos = self.pong_ai_paddle.origin_x;
}
-
+
distance = self.pong_length/2 * autocvar_sv_minigames_pong_ai_tolerance
+ autocvar_sv_minigames_pong_paddle_speed * think_speed;
ai.think = pong_ai_think;
ai.nextthink = time;
ai.pong_ai_paddle = paddle;
-
+
paddle.realowner = ai;
-
+
return ai;
}
float think_speed = autocvar_sys_ticrate;
self.nextthink = time + think_speed;
- if ( self.realowner.minigame_players.pong_keys == PONG_KEY_INCREASE ||
+ if ( self.realowner.minigame_players.pong_keys == PONG_KEY_INCREASE ||
self.realowner.minigame_players.pong_keys == PONG_KEY_DECREASE )
{
float movement = autocvar_sv_minigames_pong_paddle_speed * think_speed;
float halflen = self.pong_length/2;
-
+
if ( self.realowner.minigame_players.pong_keys == PONG_KEY_DECREASE )
movement *= -1;
-
+
if ( self.team > 2 )
self.origin_x = bound(halflen, self.origin_x+movement, 1-halflen);
else
self.origin_y = bound(halflen, self.origin_y+movement, 1-halflen);
-
+
self.SendFlags |= MINIG_SF_UPDATE;
}
}
paddle.team = pl_team;
paddle.mins = pong_team_to_box_halfsize(pl_team,-paddle.pong_length,-1/16);
paddle.maxs = pong_team_to_box_halfsize(pl_team,paddle.pong_length,1/16);
-
+
if ( real_player == world )
pong_ai_spawn(paddle);
else
paddle.realowner = real_player;
-
+
minigame.pong_paddles[pl_team-1] = paddle;
-
+
return paddle;
}
// Don't allow joining a match that is already running
if ( minigame.minigame_flags & PONG_STATUS_PLAY )
return false;
-
+
entity player = ...(0,entity);
int i;
for ( i = 0; i < PONG_MAX_PLAYERS; i++ )
return i+1;
}
}
-
+
return false;
}
case "part":
ai.pong_score = player.minigame_players.pong_score;
break;
}
-
+
}
return false;
}
minigame.minigame_flags = PONG_STATUS_PLAY |
(minigame.minigame_flags & ~PONG_STATUS_WAIT);
minigame.SendFlags |= MINIG_SF_UPDATE;
-
+
int i;
entity ball;
for ( i = 0; i < autocvar_sv_minigames_pong_ball_number; i++ )
for ( i = PONG_MAX_PLAYERS-1; i >= 0; i-- )
{
paddle = minigame.pong_paddles[i];
- if ( paddle != world &&
+ if ( paddle != world &&
paddle.realowner.classname == "pong_ai" )
{
minigame.pong_paddles[i] = world;
sprint(player.minigame_players,"Cannot remove AI\n");
return true;
}
-
+
}
return false;
}
{
minigame_hud_fitsqare(pos, mySize);
minigame_hud_simpleboard(pos,mySize,minigame_texture("pong/board"));
-
+
entity e;
vector obj_pos;
vector obj_size;
// Note: 4*radius = 2*diameter because the image is large enough to fit the glow around the ball
obj_size = minigame_hud_denormalize_size('4 4 0'*e.pong_length,pos,mySize);
obj_pos = minigame_hud_denormalize(e.origin,pos,mySize);
-
+
minigame_drawpic_centered( obj_pos, minigame_texture("pong/ball"),
obj_size, '1 1 1', panel_fg_alpha, DRAWFLAG_NORMAL );
-
+
minigame_drawpic_centered( obj_pos, minigame_texture("pong/ball-glow"),
- obj_size, pong_team_to_color(e.team),
+ obj_size, pong_team_to_color(e.team),
panel_fg_alpha, DRAWFLAG_ADDITIVE );
}
else if ( e.classname == "pong_paddle" )
{
obj_pos = minigame_hud_denormalize(e.origin,pos,mySize);
obj_size = minigame_hud_denormalize_size(eX / 16 + eY*e.pong_length,pos,mySize);
-
- drawrotpic(obj_pos, pong_team_to_angle(e.team), minigame_texture("pong/paddle-glow"),
- obj_size, obj_size/2, pong_team_to_color(e.team),
+
+ drawrotpic(obj_pos, pong_team_to_angle(e.team), minigame_texture("pong/paddle-glow"),
+ obj_size, obj_size/2, pong_team_to_color(e.team),
panel_fg_alpha, DRAWFLAG_ADDITIVE );
-
- drawrotpic(obj_pos, pong_team_to_angle(e.team), minigame_texture("pong/paddle"),
- obj_size, obj_size/2, '1 1 1',
+
+ drawrotpic(obj_pos, pong_team_to_angle(e.team), minigame_texture("pong/paddle"),
+ obj_size, obj_size/2, '1 1 1',
panel_fg_alpha, DRAWFLAG_NORMAL );
-
+
}
}
}
ts_y += hud_fontsize_y;
pos_y += ts_y;
mySize_y -= ts_y;
-
+
vector player_fontsize = hud_fontsize * 1.75;
ts_y = ( mySize_y - PONG_MAX_PLAYERS*player_fontsize_y ) / PONG_MAX_PLAYERS;
ts_x = mySize_x;
{
mypos = pos;
mypos_y += (e.team-1) * (player_fontsize_y + ts_y);
-
+
drawfill(mypos, ts, pong_team_to_color(e.team), 0.25, DRAWFLAG_ADDITIVE);
-
+
minigame_drawcolorcodedstring_trunc(mySize_x,mypos,
(e.minigame_playerslot ? GetPlayerName(e.minigame_playerslot-1) : _("AI")),
player_fontsize, panel_fg_alpha, DRAWFLAG_NORMAL);
-
+
drawstring(mypos+eY*player_fontsize_y,ftos(e.pong_score),'48 48 0',
'0.7 0.84 1', panel_fg_alpha, DRAWFLAG_NORMAL);
-
+
if ( e == minigame_self )
drawborderlines(1, mypos, ts, pong_team_to_color(e.team), 1, DRAWFLAG_NORMAL);
}
if(!pp_valid_tile(minigame_tile_buildname(letter+1,number-1)) || pp_find_piece(piece.owner,minigame_tile_buildname(letter+1,number-1)).team == 5)
if(!pp_valid_tile(minigame_tile_buildname(letter-1,number+1)) || pp_find_piece(piece.owner,minigame_tile_buildname(letter-1,number+1)).team == 5)
return true;
-
+
return false;
}
{
switch(argv(0))
{
- case "move":
- pp_move(minigame, ...(0,entity), ...(1,int) == 2 ? argv(1) : string_null );
+ case "move":
+ pp_move(minigame, ...(0,entity), ...(1,int) == 2 ? argv(1) : string_null );
return true;
case "next":
pp_next_match(minigame,...(0,entity));
return false;
}
}
-
+
return false;
}
minigame_hud_fitsqare(pos, mySize);
pp_boardpos = pos;
pp_boardsize = mySize;
-
+
minigame_hud_simpleboard(pos,mySize,minigame_texture("pp/board"));
vector tile_size = minigame_hud_denormalize_size('1 1 0'/PP_TILE_SIZE,pos,mySize);
case 2: tile_color = '0.3 0.3 1'; break;
// 3, 4 coming later?
}
-
+
string tile_name = strcat("pp/piece",ftos(e.team));
if(e.team == 5) { tile_name = "pp/piece_taken"; }
tile_name = "pp/piece_current";
// draw the splat too
- minigame_drawpic_centered( tile_pos,
+ minigame_drawpic_centered( tile_pos,
minigame_texture("pp/piece_taken"),
tile_size, '1 1 1', panel_fg_alpha, DRAWFLAG_NORMAL );
}
- minigame_drawpic_centered( tile_pos,
+ minigame_drawpic_centered( tile_pos,
minigame_texture(tile_name),
tile_size, tile_color, panel_fg_alpha, DRAWFLAG_NORMAL );
}
{
tile_pos = minigame_tile_pos(pp_curr_pos,PP_LET_CNT,PP_NUM_CNT);
tile_pos = minigame_hud_denormalize(tile_pos,pos,mySize);
- minigame_drawpic_centered( tile_pos,
+ minigame_drawpic_centered( tile_pos,
minigame_texture("pp/piece_current"),
tile_size, '1 1 1', panel_fg_alpha, DRAWFLAG_NORMAL );
}
{
tile_pos = minigame_tile_pos(pp_curr_pos,PP_LET_CNT,PP_NUM_CNT);
tile_pos = minigame_hud_denormalize(tile_pos,pos,mySize);
- minigame_drawpic_centered( tile_pos,
+ minigame_drawpic_centered( tile_pos,
minigame_texture("pp/piece_selected"),
tile_size, '1 1 1', panel_fg_alpha / 2, DRAWFLAG_NORMAL );
}
vector winfs = hud_fontsize*2;
string playername = "";
FOREACH_MINIGAME_ENTITY(e)
- if ( e.classname == "minigame_player" &&
+ if ( e.classname == "minigame_player" &&
e.team == (active_minigame.minigame_flags & PP_TURN_TEAM) )
playername = GetPlayerName(e.minigame_playerslot-1);
-
+
vector win_pos = pos+eY*(mySize_y-winfs_y)/2;
vector win_sz;
win_sz = minigame_drawcolorcodedstring_wrapped(mySize_x,win_pos,
- sprintf("%s^7 won the game!",playername),
+ sprintf("%s^7 won the game!",playername),
winfs, 0, DRAWFLAG_NORMAL, 0.5);
-
+
drawfill(win_pos-eY*hud_fontsize_y,win_sz+2*eY*hud_fontsize_y,'1 1 1',0.5,DRAWFLAG_ADDITIVE);
-
+
minigame_drawcolorcodedstring_wrapped(mySize_x,win_pos,
- sprintf("%s^7 won the game!",playername),
+ sprintf("%s^7 won the game!",playername),
winfs, panel_fg_alpha, DRAWFLAG_NORMAL, 0.5);
}
}
vector ts;
ts = minigame_drawstring_wrapped(mySize_x,pos,active_minigame.descriptor.message,
hud_fontsize * 2, '0.25 0.47 0.72', panel_fg_alpha, DRAWFLAG_NORMAL,0.5);
-
+
pos_y += ts_y;
mySize_y -= ts_y;
-
+
vector player_fontsize = hud_fontsize * 1.75;
ts_y = ( mySize_y - 2*player_fontsize_y ) / 2;
ts_x = mySize_x;
minigame_drawcolorcodedstring_trunc(mySize_x,mypos,
GetPlayerName(e.minigame_playerslot-1),
player_fontsize, panel_fg_alpha, DRAWFLAG_NORMAL);
-
+
mypos_y += player_fontsize_y;
- drawpic( mypos,
+ drawpic( mypos,
minigame_texture(strcat("pp/piece",ftos(e.team))),
tile_size, tile_color, panel_fg_alpha, DRAWFLAG_NORMAL );
-
+
mypos_x += tile_size_x;
int myscore = 0;
if(e.team == 1) { myscore = active_minigame.pp_team1_score; }
if(e.team == 2) { myscore = active_minigame.pp_team2_score; }
-
+
drawstring(mypos,ftos(myscore),tile_size,
'0.7 0.84 1', panel_fg_alpha, DRAWFLAG_NORMAL);
}
{
if ( turnflags & PP_TURN_DRAW )
return _("Draw");
-
+
if ( turnflags & PP_TURN_WIN )
{
if ( (turnflags&PP_TURN_TEAM) != minigame_self.team )
return _("You lost the game!\nSelect \"^1Next Match^7\" on the menu for a rematch!");
return _("You win!\nSelect \"^1Next Match^7\" on the menu to start a new match!");
}
-
+
if ( turnflags & PP_TURN_NEXT )
{
if ( (turnflags&PP_TURN_TEAM) != minigame_self.team )
return _("Select \"^1Next Match^7\" on the menu to start a new match!");
return _("Wait for your opponent to confirm the rematch");
}
-
+
if ( (turnflags & PP_TURN_TEAM) != minigame_self.team )
return _("Wait for your opponent to make their move");
-
+
if ( turnflags & PP_TURN_PLACE )
return _("Click on the game board to place your piece");
-
+
return "";
}
return false;
}
-#endif
\ No newline at end of file
+#endif
return false; // a move is valid, abort!
}
}
-
+
return true;
}
{
switch(argv(0))
{
- case "move":
+ case "move":
ps_move(minigame, ...(0,entity), (...(1,int) == 3 ? argv(1) : string_null), (...(1,int) == 3 ? argv(2) : string_null));
return true;
return false;
}
}
-
+
return false;
}
minigame_hud_fitsqare(pos, mySize);
ps_boardpos = pos;
ps_boardsize = mySize;
-
+
minigame_hud_simpleboard(pos,mySize,minigame_texture("ps/board"));
vector tile_size = minigame_hud_denormalize_size('1 1 0' / PS_TILE_SIZE,pos,mySize);
draw_pos = true;
}
}
-
+
entity e;
FOREACH_MINIGAME_ENTITY(e)
{
if(e.netname == ps_curr_pos)
if(ps_curr_piece.netname != ps_curr_pos)
{
- minigame_drawpic_centered( tile_pos,
+ minigame_drawpic_centered( tile_pos,
minigame_texture("ps/tile_available"),
tile_size, tile_color, panel_fg_alpha, DRAWFLAG_NORMAL );
}
if(e == ps_curr_piece)
{
- minigame_drawpic_centered( tile_pos,
+ minigame_drawpic_centered( tile_pos,
minigame_texture("ps/tile_selected"),
tile_size, tile_color, panel_fg_alpha, DRAWFLAG_ADDITIVE );
}
- minigame_drawpic_centered( tile_pos,
+ minigame_drawpic_centered( tile_pos,
minigame_texture("ps/piece"),
tile_size * 0.8, tile_color, panel_fg_alpha, DRAWFLAG_NORMAL );
}
remaining_text = "All pieces cleared!";
else
remaining_text = strcat("Remaining pieces: ", ftos(remaining));
-
+
vector win_pos = pos+eY*(mySize_y-winfs_y)/2;
vector win_sz;
win_sz = minigame_drawcolorcodedstring_wrapped(mySize_x,win_pos,
- sprintf("Game over! %s", remaining_text),
+ sprintf("Game over! %s", remaining_text),
winfs, 0, DRAWFLAG_NORMAL, 0.5);
-
+
drawfill(win_pos-eY*hud_fontsize_y,win_sz+2*eY*hud_fontsize_y,'1 1 1',0.5,DRAWFLAG_ADDITIVE);
-
+
minigame_drawcolorcodedstring_wrapped(mySize_x,win_pos,
- sprintf("Game over! %s", remaining_text),
+ sprintf("Game over! %s", remaining_text),
winfs, panel_fg_alpha, DRAWFLAG_NORMAL, 0.5);
}
}
vector ts;
ts = minigame_drawstring_wrapped(mySize_x,pos,active_minigame.descriptor.message,
hud_fontsize * 2, '0.25 0.47 0.72', panel_fg_alpha, DRAWFLAG_NORMAL,0.5);
-
+
pos_y += ts_y;
mySize_y -= ts_y;
-
+
vector player_fontsize = hud_fontsize * 1.75;
ts_y = ( mySize_y - 2*player_fontsize_y ) / 2;
ts_x = mySize_x;
minigame_drawcolorcodedstring_trunc(mySize_x,mypos,
GetPlayerName(e.minigame_playerslot-1),
player_fontsize, panel_fg_alpha, DRAWFLAG_NORMAL);
-
+
mypos_y += player_fontsize_y;
- //drawpic( mypos,
+ //drawpic( mypos,
// minigame_texture("ps/piece"),
// tile_size, '1 0 0', panel_fg_alpha, DRAWFLAG_NORMAL );
-
+
//mypos_x += tile_size_x;
drawstring(mypos,sprintf(_("Pieces left: %s"), ftos(remaining)),'28 28 0',
if ( turnflags & PS_TURN_WIN )
return _("Well done, you win!");
-
+
if ( turnflags & PS_TURN_MOVE )
return _("Jump a piece over another to capture it");
-
+
return "";
}
return false;
}
-#endif
\ No newline at end of file
+#endif
if(!e.cnt)
return false;
}
-
+
return true;
}
{
switch(argv(0))
{
- case "move":
- qto_move(minigame, ...(0,entity), ...(1,int) == 2 ? argv(1) : string_null );
+ case "move":
+ qto_move(minigame, ...(0,entity), ...(1,int) == 2 ? argv(1) : string_null );
return true;
case "restart":
qto_restart_match(minigame,...(0,entity));
return false;
}
}
-
+
return false;
}
minigame_hud_fitsqare(pos, mySize);
qto_boardpos = pos;
qto_boardsize = mySize;
-
+
minigame_hud_simpleboard(pos,mySize,minigame_texture("qto/board"));
vector tile_size = minigame_hud_denormalize_size('1 1 0' / QTO_TILE_SIZE,pos,mySize);
string pos2 = minigame_tile_buildname(letter+1,number);
string pos3 = minigame_tile_buildname(letter,number-1);
string pos4 = minigame_tile_buildname(letter,number+1);
-
+
entity e;
FOREACH_MINIGAME_ENTITY(e)
{
tile_color = '0.8 0.8 0.8';
break;
}
-
- minigame_drawpic_centered( tile_pos,
+
+ minigame_drawpic_centered( tile_pos,
minigame_texture(strcat("qto/piece", ftos(e.cnt))),
tile_size, tile_color, panel_fg_alpha, DRAWFLAG_NORMAL );
}
vector ts;
ts = minigame_drawstring_wrapped(mySize_x,pos,active_minigame.descriptor.message,
hud_fontsize * 2, '0.25 0.47 0.72', panel_fg_alpha, DRAWFLAG_NORMAL,0.5);
-
+
pos_y += ts_y;
mySize_y -= ts_y;
-
+
vector player_fontsize = hud_fontsize * 1.75;
ts_y = ( mySize_y - 2*player_fontsize_y ) / 2;
ts_x = mySize_x;
minigame_drawcolorcodedstring_trunc(mySize_x,mypos,
GetPlayerName(e.minigame_playerslot-1),
player_fontsize, panel_fg_alpha, DRAWFLAG_NORMAL);
-
+
mypos_y += player_fontsize_y;
- //drawpic( mypos,
+ //drawpic( mypos,
// minigame_texture("qto/piece"),
// tile_size, '1 0 0', panel_fg_alpha, DRAWFLAG_NORMAL );
-
+
//mypos_x += tile_size_x;
drawstring(mypos,sprintf(_("Moves: %s"), ftos(e.qto_moves)),'32 32 0',
{
if ( turnflags & QTO_TURN_WIN )
return _("Well done, you win!");
-
+
if ( turnflags & QTO_TURN_MOVE )
return _("Turn all the angry faces into happy faces");
-
+
return "";
}
return false;
}
-#endif
\ No newline at end of file
+#endif
{
int number = minigame_tile_number(piece.netname);
int letter = minigame_tile_letter(piece.netname);
-
+
if ( ttt_find_piece(piece.owner,minigame_tile_buildname(0,number)).team == piece.team )
if ( ttt_find_piece(piece.owner,minigame_tile_buildname(1,number)).team == piece.team )
if ( ttt_find_piece(piece.owner,minigame_tile_buildname(2,number)).team == piece.team )
return true;
-
+
if ( ttt_find_piece(piece.owner,minigame_tile_buildname(letter,0)).team == piece.team )
if ( ttt_find_piece(piece.owner,minigame_tile_buildname(letter,1)).team == piece.team )
if ( ttt_find_piece(piece.owner,minigame_tile_buildname(letter,2)).team == piece.team )
return true;
-
+
if ( number == letter )
if ( ttt_find_piece(piece.owner,minigame_tile_buildname(0,0)).team == piece.team )
if ( ttt_find_piece(piece.owner,minigame_tile_buildname(1,1)).team == piece.team )
if ( ttt_find_piece(piece.owner,minigame_tile_buildname(2,2)).team == piece.team )
return true;
-
+
if ( number == 2-letter )
if ( ttt_find_piece(piece.owner,minigame_tile_buildname(0,2)).team == piece.team )
if ( ttt_find_piece(piece.owner,minigame_tile_buildname(1,1)).team == piece.team )
if ( ttt_find_piece(piece.owner,minigame_tile_buildname(2,0)).team == piece.team )
return true;
-
+
return false;
}
case "join":
{
int pl_num = minigame_count_players(minigame);
-
+
// Don't allow joining a single player match
if ( (minigame.ttt_ai) && pl_num > 0 )
return false;
{
switch(argv(0))
{
- case "move":
- ttt_move(minigame, ...(0,entity), ...(1,int) == 2 ? argv(1) : string_null );
+ case "move":
+ ttt_move(minigame, ...(0,entity), ...(1,int) == 2 ? argv(1) : string_null );
return true;
case "next":
ttt_next_match(minigame,...(0,entity));
return false;
}
}
-
+
return false;
}
minigame_hud_fitsqare(pos, mySize);
ttt_boardpos = pos;
ttt_boardsize = mySize;
-
+
minigame_hud_simpleboard(pos,mySize,minigame_texture("ttt/board"));
vector tile_size = minigame_hud_denormalize_size('1 1 0'/TTT_TILE_SIZE,pos,mySize);
{
tile_pos = minigame_tile_pos(ttt_curr_pos,TTT_LET_CNT,TTT_NUM_CNT);
tile_pos = minigame_hud_denormalize(tile_pos,pos,mySize);
- minigame_drawpic_centered( tile_pos,
+ minigame_drawpic_centered( tile_pos,
minigame_texture(strcat("ttt/piece",ftos(minigame_self.team))),
tile_size, '1 1 1', panel_fg_alpha/2, DRAWFLAG_NORMAL );
}
-
+
entity e;
FOREACH_MINIGAME_ENTITY(e)
{
{
tile_pos = minigame_tile_pos(e.netname,TTT_LET_CNT,TTT_NUM_CNT);
tile_pos = minigame_hud_denormalize(tile_pos,pos,mySize);
-
+
if ( active_minigame.minigame_flags & TTT_TURN_WIN )
if ( !e.ttt_checkwin )
e.ttt_checkwin = ttt_winning_piece(e) ? 1 : -1;
-
+
float icon_color = 1;
if ( e.ttt_checkwin == -1 )
icon_color = 0.4;
minigame_drawpic_centered( tile_pos, minigame_texture("ttt/winglow"),
tile_size, '1 1 1', panel_fg_alpha, DRAWFLAG_ADDITIVE );
}
-
- minigame_drawpic_centered( tile_pos,
+
+ minigame_drawpic_centered( tile_pos,
minigame_texture(strcat("ttt/piece",ftos(e.team))),
tile_size, '1 1 1'*icon_color, panel_fg_alpha, DRAWFLAG_NORMAL );
}
vector ts;
ts = minigame_drawstring_wrapped(mySize_x,pos,active_minigame.descriptor.message,
hud_fontsize * 2, '0.25 0.47 0.72', panel_fg_alpha, DRAWFLAG_NORMAL,0.5);
-
+
pos_y += ts_y;
mySize_y -= ts_y;
-
+
vector player_fontsize = hud_fontsize * 1.75;
ts_y = ( mySize_y - 2*player_fontsize_y ) / 2;
ts_x = mySize_x;
minigame_drawcolorcodedstring_trunc(mySize_x,mypos,
(e.minigame_playerslot ? GetPlayerName(e.minigame_playerslot-1) : _("AI")),
player_fontsize, panel_fg_alpha, DRAWFLAG_NORMAL);
-
+
mypos_y += player_fontsize_y;
- drawpic( mypos,
+ drawpic( mypos,
minigame_texture(strcat("ttt/piece",ftos(e.team))),
tile_size, '1 1 1', panel_fg_alpha, DRAWFLAG_NORMAL );
-
+
mypos_x += tile_size_x;
-
+
drawstring(mypos,ftos(e.minigame_flags),tile_size,
'0.7 0.84 1', panel_fg_alpha, DRAWFLAG_NORMAL);
}
{
if ( turnflags & TTT_TURN_DRAW )
return _("Draw");
-
+
if ( turnflags & TTT_TURN_WIN )
{
if ( (turnflags&TTT_TURN_TEAM) != minigame_self.team )
return _("You lost the game!\nSelect \"^1Next Match^7\" on the menu for a rematch!");
return _("You win!\nSelect \"^1Next Match^7\" on the menu to start a new match!");
}
-
+
if ( turnflags & TTT_TURN_NEXT )
{
if ( (turnflags&TTT_TURN_TEAM) != minigame_self.team )
return _("Select \"^1Next Match^7\" on the menu to start a new match!");
return _("Wait for your opponent to confirm the rematch");
}
-
+
if ( (turnflags & TTT_TURN_TEAM) != minigame_self.team )
return _("Wait for your opponent to make their move");
-
+
if ( turnflags & TTT_TURN_PLACE )
return _("Click on the game board to place your piece");
-
+
return "";
}
return "a2";
case TTT_AI_POSFLAG_A3:
return "a3";
-
+
case TTT_AI_POSFLAG_B1:
return "b1";
case TTT_AI_POSFLAG_B2:
return "b2";
case TTT_AI_POSFLAG_B3:
return "b3";
-
+
case TTT_AI_POSFLAG_C1:
return "c1";
case TTT_AI_POSFLAG_C2:
return "c2";
case TTT_AI_POSFLAG_C3:
return "c3";
-
+
default:
return string_null;
}
{
if ( ttt_ai_checkmask(piecemask,flag1|flag2|flag3) )
return 0;
-
+
if ( ttt_ai_checkmask(piecemask,flag1|flag2) )
return flag3;
-
+
if ( ttt_ai_checkmask(piecemask,flag3|flag2) )
return flag1;
-
+
if ( ttt_ai_checkmask(piecemask,flag3|flag1) )
return flag2;
{
if ( !piecemask )
return 0;
-
+
int f = 1;
-
+
RandomSelection_Init();
-
+
for ( int i = 0; i < 9; i++ )
{
if ( piecemask & f )
RandomSelection_Add(world, f, string_null, 1, 1);
f <<= 1;
}
-
+
LOG_TRACE(sprintf("TTT AI: selected %x from %x\n",
RandomSelection_chosen_float, piecemask) );
return RandomSelection_chosen_float;
int ttt_ai_block3 ( int piecemask, int piecemask_free )
{
int r = 0;
-
+
r |= ttt_ai_1of3(piecemask,TTT_AI_POSFLAG_A1,TTT_AI_POSFLAG_A2,TTT_AI_POSFLAG_A3);
r |= ttt_ai_1of3(piecemask,TTT_AI_POSFLAG_B1,TTT_AI_POSFLAG_B2,TTT_AI_POSFLAG_B3);
r |= ttt_ai_1of3(piecemask,TTT_AI_POSFLAG_C1,TTT_AI_POSFLAG_C2,TTT_AI_POSFLAG_C3);
string ttt_ai_choose_simple(int piecemask_self, int piecemask_opponent, int piecemask_free )
{
int move = 0;
-
+
LOG_TRACE("TTT AI: checking winning move\n");
if (( move = ttt_ai_block3(piecemask_self,piecemask_free) ))
return ttt_ai_piece_flag2pos(move); // place winning move
-
+
LOG_TRACE("TTT AI: checking opponent's winning move\n");
if (( move = ttt_ai_block3(piecemask_opponent,piecemask_free) ))
return ttt_ai_piece_flag2pos(move); // block opponent
-
+
LOG_TRACE("TTT AI: random move\n");
return ttt_ai_piece_flag2pos(ttt_ai_random(piecemask_free));
}
while ( ( aiplayer = findentity(aiplayer,owner,minigame) ) )
if ( aiplayer.classname == "minigame_player" && !aiplayer.minigame_playerslot )
break;
-
+
/*
* Build bit masks for the board pieces
* .---.---.---.
* | 4 | 32|256| 3
- * |---+---+---|
+ * |---+---+---|
* | 2 | 16|128| 2
- * |---+---+---|
+ * |---+---+---|
* | 1 | 8 | 64| 1
* '---'---'---'
* A B C
pieceflag <<= 1;
}
}
-
+
// TODO multiple AI difficulties
LOG_TRACE(sprintf("TTT AI: self: %x opponent: %x free: %x\n",
piecemask_self, piecemask_opponent, piecemask_free));
if ( sent.minigame_flags & minigame_self.team )
minigame_prompt();
}
-
+
if ( (sf & TTT_SF_SINGLEPLAYER) )
{
int ai = ReadByte();
bool spawnai = ai && !sent.ttt_ai;
sent.ttt_ai = ai;
-
+
if ( spawnai )
{
entity aiplayer = spawn();
aiplayer.minigame_autoclean = 1;
ttt_aimove(minigame);
}
-
+
}
}
else if ( sent.classname == "minigame_player" && (sf & TTT_SF_PLAYERSCORE ) )
// Get number index of a tile name
// Note: this is 0 based, useful for mathematical operations
-// Note: Since the tile notation starts from the bottom left,
+// Note: Since the tile notation starts from the bottom left,
// you may want to do number_of_rows - what_this_function_returns or something
int minigame_tile_number(string id)
{
// Get relative position of the center of a given tile
vector minigame_tile_pos(string id, int rows, int columns)
{
- return eX*(minigame_tile_letter(id)+0.5)/columns +
+ return eX*(minigame_tile_letter(id)+0.5)/columns +
eY - eY*(minigame_tile_number(id)+0.5)/rows;
}
{
if ( pos_x < 0 || pos_x > 1 || pos_y < 0 || pos_y > 1 )
return ""; // no tile
-
+
int letter = floor(pos_x * columns);
int number = floor((1-pos_y) * rows);
return minigame_tile_buildname(letter, number);
// Get number index of a tile name
// Note: this is 0 based, useful for mathematical operations
-// Note: Since the tile notation starts from the bottom left,
+// Note: Since the tile notation starts from the bottom left,
// you may want to do number_of_rows - what_this_function_returns or something
int minigame_tile_number(string id);
/// IMPORTANT: always read in client everything you send from the server!
/// cmd(entity minigame_player, int argc, string command)
/// self = client entity triggering this
-/// argv(n) = console token
+/// argv(n) = console token
/// argc: number of console tokens
/// command: full command string
/// triggered when a player does "cmd minigame ..." with some unrecognized command
{
entity e;
entity p = minigame_session.minigame_players;
-
+
if ( p.minigame_players == player )
{
if ( p.list_next == world )
{SELFPARAM();
WriteByte(MSG_ENTITY, ENT_CLIENT_MINIGAME);
WriteByte(MSG_ENTITY, sf);
-
+
if ( sf & MINIG_SF_CREATE )
{
WriteShort(MSG_ENTITY,msle_id(self.classname));
WriteString(MSG_ENTITY,self.netname);
}
-
+
entity minigame_ent = self.owner;
-
+
if ( self.classname == "minigame" )
{
minigame_ent = self;
-
+
if ( sf & MINIG_SF_CREATE )
WriteString(MSG_ENTITY,self.descriptor.netname);
-
+
if ( sf & MINIG_SF_UPDATE )
WriteLong(MSG_ENTITY,self.minigame_flags);
}
WriteByte(MSG_ENTITY,self.team);
}
MINIGAME_SIMPLELINKED_ENTITIES
-
+
minigame_ent.minigame_event(minigame_ent,"network_send",self,sf);
-
+
return true;
-
+
}
#undef FIELD
#undef MSLE
return 0;
minigame_rmplayer(player.active_minigame,player);
}
-
+
int mgteam = minigame_session.minigame_event(minigame_session,"join",player);
-
+
if ( mgteam )
{
entity player_pointer = spawn();
}
if ( autocvar_sv_minigames_observer == 2 )
player.team_forced = -1;
-
+
minigame_resend(minigame_session);
}
GameLogEcho(strcat(":minigame:join",(mgteam?"":"fail"),":",minigame_session.netname,":",
ftos(num_for_edict(player)),":",player.netname));
-
+
return mgteam;
}
{
if ( !autocvar_sv_minigames || !IS_REAL_CLIENT(player) )
return world;
-
+
entity e = minigame_get_descriptor(minigame);
- if ( e )
+ if ( e )
{
entity minig = spawn();
minig.classname = "minigame";
return world;
}
Net_LinkEntity(minig, false, 0, minigame_SendEntity);
-
+
if ( !minigame_sessions )
minigame_sessions = minig;
else
}
return minig;
}
-
+
return world;
}
{
if ( !autocvar_sv_minigames || !IS_REAL_CLIENT(player) )
return world;
-
+
entity minig;
for ( minig = minigame_sessions; minig != world; minig = minig.list_next )
{
if ( minigame_addplayer(minig,player) )
return minig;
}
-
+
return world;
}
void part_minigame(entity player )
{
entity minig = player.active_minigame;
-
+
if ( minig && minig.classname == "minigame" )
minigame_rmplayer(minig,player);
}
minigame_session.owner.list_next = minigame_session.list_next;
else
minigame_sessions = minigame_session.list_next;
-
+
minigame_session.minigame_event(minigame_session,"end");
GameLogEcho(strcat(":minigame:end:",minigame_session.netname));
-
-
+
+
entity e = world;
while( (e = findentity(e, owner, minigame_session)) )
if ( e.minigame_autoclean )
LOG_TRACE("SV Auto-cleaned: ",ftos(num_for_edict(e)), " (",e.classname,")\n");
remove(e);
}
-
+
entity p;
for ( e = minigame_session.minigame_players; e != world; e = p )
{
player_clear_minigame(e.minigame_players);
remove(e);
}
-
+
strunzone(minigame_session.netname);
remove(minigame_session);
}
if ( !last_minig ) minigame_descriptors = minig; \
else last_minig.list_next = minig; \
last_minig = minig;
-
+
REGISTERED_MINIGAMES
-
+
#undef MINIGAME
}
return "You can't invite yourself";
if ( player.active_minigame == inviter.active_minigame )
return strcat(player.netname," is already playing");
-
- Send_Notification(NOTIF_ONE, player, MSG_INFO, INFO_MINIGAME_INVITE,
+
+ Send_Notification(NOTIF_ONE, player, MSG_INFO, INFO_MINIGAME_INVITE,
inviter.active_minigame.netname, inviter.netname );
-
+
GameLogEcho(strcat(":minigame:invite:",inviter.active_minigame.netname,":",
ftos(num_for_edict(player)),":",player.netname));
-
+
return "";
}
sprint(self,"Minigames are not enabled!\n");
return;
}
-
+
if (request == CMD_REQUEST_COMMAND )
{
string minig_cmd = argv(1);
int arg_c = tokenize_console(subcommand);
if ( self.active_minigame.minigame_event(self.active_minigame,"cmd",e,arg_c,subcommand) )
return;
-
+
}
else sprint(self,strcat("Wrong command:^1 ",command,"\n"));
}
-
+
sprint(self, "\nUsage:^3 cmd minigame create <minigame>\n");
sprint(self, " Start a new minigame session\n");
sprint(self, "Usage:^3 cmd minigame join <session>\n");
e.angles_y = spawnedby.angles_y;
}
-
+
// Monster_Spawn checks if monster is valid
WITH(entity, self, e, Monster_Spawn(monster_id));
void monster_changeteam(entity ent, float newteam)
{
if(!teamplay) { return; }
-
+
ent.team = newteam;
ent.monster_attack = true; // new team, activate attacking
monster_setupcolors(ent);
-
+
if(ent.sprite)
{
WaypointSprite_UpdateTeamRadar(ent.sprite, RADARICON_DANGER, ((newteam) ? Team_ColorRGB(newteam) : '1 0 0'));
self.moveto = WarpZone_RefSys_TransformOrigin(self.enemy, self, (0.5 * (self.enemy.absmin + self.enemy.absmax)));
self.monster_moveto = '0 0 0';
self.monster_face = '0 0 0';
-
+
self.pass_distance = vlen((('1 0 0' * self.enemy.origin_x) + ('0 1 0' * self.enemy.origin_y)) - (('1 0 0' * self.origin_x) + ('0 1 0' * self.origin_y)));
Monster_Sound(monstersound_sight, 0, false, CH_VOICE);
}
float reverse = FALSE;
vector a, b;
-
+
makevectors(self.angles);
a = self.origin + '0 0 16';
b = self.origin + '0 0 16' + v_forward * 32;
-
+
traceline(a, b, MOVE_NORMAL, self);
-
+
if(trace_fraction != 1.0)
{
reverse = TRUE;
-
+
if(trace_ent)
if(IS_PLAYER(trace_ent) && !(trace_ent.items & IT_STRENGTH))
reverse = FALSE;
}
-
+
// TODO: fix this... tracing is broken if the floor is thin
/*
if(!allow_jumpoff)
if(trace_fraction == 1.0)
reverse = TRUE;
} */
-
+
if(reverse)
{
self.angles_y = anglemods(self.angles_y - 180);
makevectors(self.angles);
}
-
+
movelib_move_simple_gravity(v_forward, mspeed, 1);
if(time > self.pain_finished)
self.monster_moveto = '0 0 0';
self.monster_face = '0 0 0';
self.dphitcontentsmask = DPCONTENTS_SOLID | DPCONTENTS_BODY | DPCONTENTS_BOTCLIP | DPCONTENTS_MONSTERCLIP;
-
+
if(!self.scale) { self.scale = 1; }
if(autocvar_g_monsters_edit) { self.grab = 1; }
if(autocvar_g_fullbrightplayers) { self.effects |= EF_FULLBRIGHT; }
void W_RocketMinsta_Attack2(void)
{SELFPARAM();
makevectors(self.v_angle);
-
+
entity proj;
float counter = 0;
float total = autocvar_g_rm_laser_count;
PROJECTILE_MAKETRIGGER(proj);
proj.projectiledeathtype = WEP_ELECTRO.m_id;
setorigin(proj, w_shotorg);
-
+
proj.rm_force = autocvar_g_rm_laser_force / total;
proj.rm_damage = autocvar_g_rm_laser_damage / total;
proj.rm_edmg = proj.rm_damage;
-
+
//W_SetupProjectileVelocity(proj, autocvar_g_rm_laser_speed, spread * (rndspread ? random() : 1) * autocvar_g_rm_laser_speed);
proj.movetype = MOVETYPE_BOUNCEMISSILE;
void W_RocketMinsta_Attack3 (void)
{SELFPARAM();
makevectors(self.v_angle);
-
+
entity proj;
float counter = 0;
float total = 1;
PROJECTILE_MAKETRIGGER(proj);
proj.projectiledeathtype = WEP_ELECTRO.m_id;
setorigin(proj, w_shotorg);
-
+
proj.rm_force = autocvar_g_rm_laser_force / total;
proj.rm_damage = autocvar_g_rm_laser_damage / total;
proj.rm_edmg = proj.rm_damage;
-
+
//W_SetupProjectileVelocity(proj, autocvar_g_rm_laser_speed, spread * (rndspread ? random() : 1) * autocvar_g_rm_laser_speed);
proj.movetype = MOVETYPE_BOUNCEMISSILE;
}
else
self.held_down = false;
-
+
return true;
}
case WR_INIT:
remove(self);
return;
}
-
+
self.mdl = "";
-
+
if ( !self.owner.deadflag && IS_PLAYER(self.owner) )
{
if ( self.owner.active_minigame )
else if ( self.owner.BUTTON_CHAT )
self.mdl = "models/misc/chatbubble.spr";
}
-
+
if ( self.model != self.mdl )
setmodel(self, self.mdl);
{
sprint(source, sourcemsgstr);
dedicated_print(msgstr); // send to server console too
- FOR_EACH_REALCLIENT(head)
+ FOR_EACH_REALCLIENT(head)
if(head != source)
if(head.active_minigame == source.active_minigame)
sprint(head, msgstr);
}
MUTATOR_HOOKFUNCTION(instagib_PlayerDies)
-{
+{
if(DEATH_ISWEAPON(frag_deathtype, WEP_VAPORIZER.m_id))
frag_damage = 1000; // always gib if it was a vaporizer death
projects / xonotic / xonotic-data.pk3dir.git / commitdiff