~ubuntu-branches/ubuntu/precise/openarena/precise

« back to all changes in this revision

Viewing changes to code/q3_ui/ui_players.c

Committer: Bazaar Package Importer
Author(s): Bruno "Fuddl" Kleinert
Date: 2007-01-20 12:28:09 UTC
Revision ID: james.westby@ubuntu.com-20070120122809-2yza5ojt7nqiyiam

Tags: upstream-0.6.0

Import upstream version 0.6.0

files added:

BUGS

COPYING.txt

ChangeLog

Makefile

NOTTODO

README

TODO

code

code/AL

code/AL/VERSION

code/AL/al.h

code/AL/alc.h

code/AL/alctypes.h

code/AL/altypes.h

code/AL/alut.h

code/SDL12

code/SDL12/include

code/SDL12/include/SDL.h

code/SDL12/include/SDL_active.h

code/SDL12/include/SDL_audio.h

code/SDL12/include/SDL_byteorder.h

code/SDL12/include/SDL_cdrom.h

code/SDL12/include/SDL_copying.h

code/SDL12/include/SDL_cpuinfo.h

code/SDL12/include/SDL_endian.h

code/SDL12/include/SDL_error.h

code/SDL12/include/SDL_events.h

code/SDL12/include/SDL_getenv.h

code/SDL12/include/SDL_joystick.h

code/SDL12/include/SDL_keyboard.h

code/SDL12/include/SDL_keysym.h

code/SDL12/include/SDL_loadso.h

code/SDL12/include/SDL_main.h

code/SDL12/include/SDL_mouse.h

code/SDL12/include/SDL_mutex.h

code/SDL12/include/SDL_name.h

code/SDL12/include/SDL_opengl.h

code/SDL12/include/SDL_quit.h

code/SDL12/include/SDL_rwops.h

code/SDL12/include/SDL_syswm.h

code/SDL12/include/SDL_thread.h

code/SDL12/include/SDL_timer.h

code/SDL12/include/SDL_types.h

code/SDL12/include/SDL_version.h

code/SDL12/include/SDL_video.h

code/SDL12/include/begin_code.h

code/SDL12/include/close_code.h

code/botlib

code/botlib/aasfile.h

code/botlib/be_aas.h

code/botlib/be_aas_bsp.h

code/botlib/be_aas_bspq3.c

code/botlib/be_aas_cluster.c

code/botlib/be_aas_cluster.h

code/botlib/be_aas_debug.c

code/botlib/be_aas_debug.h

code/botlib/be_aas_def.h

code/botlib/be_aas_entity.c

code/botlib/be_aas_entity.h

code/botlib/be_aas_file.c

code/botlib/be_aas_file.h

code/botlib/be_aas_funcs.h

code/botlib/be_aas_main.c

code/botlib/be_aas_main.h

code/botlib/be_aas_move.c

code/botlib/be_aas_move.h

code/botlib/be_aas_optimize.c

code/botlib/be_aas_optimize.h

code/botlib/be_aas_reach.c

code/botlib/be_aas_reach.h

code/botlib/be_aas_route.c

code/botlib/be_aas_route.h

code/botlib/be_aas_routealt.c

code/botlib/be_aas_routealt.h

code/botlib/be_aas_sample.c

code/botlib/be_aas_sample.h

code/botlib/be_ai_char.c

code/botlib/be_ai_char.h

code/botlib/be_ai_chat.c

code/botlib/be_ai_chat.h

code/botlib/be_ai_gen.c

code/botlib/be_ai_gen.h

code/botlib/be_ai_goal.c

code/botlib/be_ai_goal.h

code/botlib/be_ai_move.c

code/botlib/be_ai_move.h

code/botlib/be_ai_weap.c

code/botlib/be_ai_weap.h

code/botlib/be_ai_weight.c

code/botlib/be_ai_weight.h

code/botlib/be_ea.c

code/botlib/be_ea.h

code/botlib/be_interface.c

code/botlib/be_interface.h

code/botlib/botlib.h

code/botlib/l_crc.c

code/botlib/l_crc.h

code/botlib/l_libvar.c

code/botlib/l_libvar.h

code/botlib/l_log.c

code/botlib/l_log.h

code/botlib/l_memory.c

code/botlib/l_memory.h

code/botlib/l_precomp.c

code/botlib/l_precomp.h

code/botlib/l_script.c

code/botlib/l_script.h

code/botlib/l_struct.c

code/botlib/l_struct.h

code/botlib/l_utils.h

code/botlib/lcc.mak

code/botlib/linux-i386.mak

code/cgame

code/cgame/cg_consolecmds.c

code/cgame/cg_draw.c

code/cgame/cg_drawtools.c

code/cgame/cg_effects.c

code/cgame/cg_ents.c

code/cgame/cg_event.c

code/cgame/cg_info.c

code/cgame/cg_local.h

code/cgame/cg_localents.c

code/cgame/cg_main.c

code/cgame/cg_marks.c

code/cgame/cg_newdraw.c

code/cgame/cg_particles.c

code/cgame/cg_players.c

code/cgame/cg_playerstate.c

code/cgame/cg_predict.c

code/cgame/cg_public.h

code/cgame/cg_scoreboard.c

code/cgame/cg_servercmds.c

code/cgame/cg_snapshot.c

code/cgame/cg_syscalls.asm

code/cgame/cg_syscalls.c

code/cgame/cg_view.c

code/cgame/cg_weapons.c

code/cgame/cgame.bat

code/cgame/cgame.plg

code/cgame/cgame.q3asm

code/cgame/cgame.sh

code/cgame/cgame_ta.bat

code/cgame/cgame_ta.q3asm

code/cgame/cgame_ta.sh

code/client

code/client/cl_avi.c

code/client/cl_cgame.c

code/client/cl_cin.c

code/client/cl_console.c

code/client/cl_curl.c

code/client/cl_curl.h

code/client/cl_input.c

code/client/cl_keys.c

code/client/cl_main.c

code/client/cl_net_chan.c

code/client/cl_parse.c

code/client/cl_scrn.c

code/client/cl_ui.c

code/client/client.h

code/client/keycodes.h

code/client/keys.h

code/client/qal.c

code/client/qal.h

code/client/snd_adpcm.c

code/client/snd_codec.c

code/client/snd_codec.h

code/client/snd_codec_ogg.c

code/client/snd_codec_wav.c

code/client/snd_dma.c

code/client/snd_local.h

code/client/snd_main.c

code/client/snd_mem.c

code/client/snd_mix.c

code/client/snd_openal.c

code/client/snd_public.h

code/client/snd_wavelet.c

code/game

code/game/ai_chat.c

code/game/ai_chat.h

code/game/ai_cmd.c

code/game/ai_cmd.h

code/game/ai_dmnet.c

code/game/ai_dmnet.h

code/game/ai_dmq3.c

code/game/ai_dmq3.h

code/game/ai_main.c

code/game/ai_main.h

code/game/ai_team.c

code/game/ai_team.h

code/game/ai_vcmd.c

code/game/ai_vcmd.h

code/game/bg_lib.c

code/game/bg_lib.h

code/game/bg_local.h

code/game/bg_misc.c

code/game/bg_pmove.c

code/game/bg_public.h

code/game/bg_slidemove.c

code/game/chars.h

code/game/g_active.c

code/game/g_arenas.c

code/game/g_bot.c

code/game/g_client.c

code/game/g_cmds.c

code/game/g_combat.c

code/game/g_items.c

code/game/g_local.h

code/game/g_main.c

code/game/g_mem.c

code/game/g_misc.c

code/game/g_missile.c

code/game/g_mover.c

code/game/g_public.h

code/game/g_rankings.c

code/game/g_rankings.h

code/game/g_session.c

code/game/g_spawn.c

code/game/g_svcmds.c

code/game/g_syscalls.asm

code/game/g_syscalls.c

code/game/g_target.c

code/game/g_team.c

code/game/g_team.h

code/game/g_trigger.c

code/game/g_utils.c

code/game/g_weapon.c

code/game/game.bat

code/game/game.q3asm

code/game/game.sh

code/game/game_ta.bat

code/game/game_ta.q3asm

code/game/game_ta.sh

code/game/inv.h

code/game/match.h

code/game/syn.h

code/jpeg-6

code/jpeg-6/README

code/jpeg-6/jcapimin.c

code/jpeg-6/jcapistd.c

code/jpeg-6/jccoefct.c

code/jpeg-6/jccolor.c

code/jpeg-6/jcdctmgr.c

code/jpeg-6/jchuff.c

code/jpeg-6/jchuff.h

code/jpeg-6/jcinit.c

code/jpeg-6/jcmainct.c

code/jpeg-6/jcmarker.c

code/jpeg-6/jcmaster.c

code/jpeg-6/jcomapi.c

code/jpeg-6/jconfig.h

code/jpeg-6/jcparam.c

code/jpeg-6/jcphuff.c

code/jpeg-6/jcprepct.c

code/jpeg-6/jcsample.c

code/jpeg-6/jctrans.c

code/jpeg-6/jdapimin.c

code/jpeg-6/jdapistd.c

code/jpeg-6/jdatadst.c

code/jpeg-6/jdatasrc.c

code/jpeg-6/jdcoefct.c

code/jpeg-6/jdcolor.c

code/jpeg-6/jdct.h

code/jpeg-6/jddctmgr.c

code/jpeg-6/jdhuff.c

code/jpeg-6/jdhuff.h

code/jpeg-6/jdinput.c

code/jpeg-6/jdmainct.c

code/jpeg-6/jdmarker.c

code/jpeg-6/jdmaster.c

code/jpeg-6/jdmerge.c

code/jpeg-6/jdphuff.c

code/jpeg-6/jdpostct.c

code/jpeg-6/jdsample.c

code/jpeg-6/jdtrans.c

code/jpeg-6/jerror.c

code/jpeg-6/jerror.h

code/jpeg-6/jfdctflt.c

code/jpeg-6/jfdctfst.c

code/jpeg-6/jfdctint.c

code/jpeg-6/jidctflt.c

code/jpeg-6/jidctfst.c

code/jpeg-6/jidctint.c

code/jpeg-6/jidctred.c

code/jpeg-6/jinclude.h

code/jpeg-6/jload.c

code/jpeg-6/jmemansi.c

code/jpeg-6/jmemdos.c

code/jpeg-6/jmemmgr.c

code/jpeg-6/jmemname.c

code/jpeg-6/jmemnobs.c

code/jpeg-6/jmemsys.h

code/jpeg-6/jmorecfg.h

code/jpeg-6/jpegint.h

code/jpeg-6/jpeglib.h

code/jpeg-6/jpegtran.c

code/jpeg-6/jquant1.c

code/jpeg-6/jquant2.c

code/jpeg-6/jutils.c

code/jpeg-6/jversion.h

code/libcurl

code/libcurl/curl

code/libcurl/curl/curl.h

code/libcurl/curl/curlver.h

code/libcurl/curl/easy.h

code/libcurl/curl/mprintf.h

code/libcurl/curl/multi.h

code/libcurl/curl/stdcheaders.h

code/libcurl/curl/types.h

code/libs

code/libs/macosx

code/libs/macosx/libSDL-1.2.0.dylib

code/libs/macosx/libSDLmain.a

code/libs/win32

code/libs/win32/libcurl.a

code/null

code/null/mac_net.c

code/null/null_client.c

code/null/null_glimp.c

code/null/null_input.c

code/null/null_main.c

code/null/null_net.c

code/null/null_snddma.c

code/q3_ui

code/q3_ui/compile.bat

code/q3_ui/q3_ui.bat

code/q3_ui/q3_ui.q3asm

code/q3_ui/q3_ui.sh

code/q3_ui/ui.q3asm

code/q3_ui/ui_addbots.c

code/q3_ui/ui_atoms.c

code/q3_ui/ui_cdkey.c

code/q3_ui/ui_cinematics.c

code/q3_ui/ui_confirm.c

code/q3_ui/ui_connect.c

code/q3_ui/ui_controls2.c

code/q3_ui/ui_credits.c

code/q3_ui/ui_demo2.c

code/q3_ui/ui_display.c

code/q3_ui/ui_gameinfo.c

code/q3_ui/ui_ingame.c

code/q3_ui/ui_loadconfig.c

code/q3_ui/ui_local.h

code/q3_ui/ui_login.c

code/q3_ui/ui_main.c

code/q3_ui/ui_menu.c

code/q3_ui/ui_mfield.c

code/q3_ui/ui_mods.c

code/q3_ui/ui_network.c

code/q3_ui/ui_options.c

code/q3_ui/ui_playermodel.c

code/q3_ui/ui_players.c

code/q3_ui/ui_playersettings.c

code/q3_ui/ui_preferences.c

code/q3_ui/ui_qmenu.c

code/q3_ui/ui_rankings.c

code/q3_ui/ui_rankstatus.c

code/q3_ui/ui_removebots.c

code/q3_ui/ui_saveconfig.c

code/q3_ui/ui_serverinfo.c

code/q3_ui/ui_servers2.c

code/q3_ui/ui_setup.c

code/q3_ui/ui_signup.c

code/q3_ui/ui_sound.c

code/q3_ui/ui_sparena.c

code/q3_ui/ui_specifyleague.c

code/q3_ui/ui_specifyserver.c

code/q3_ui/ui_splevel.c

code/q3_ui/ui_sppostgame.c

code/q3_ui/ui_spreset.c

code/q3_ui/ui_spskill.c

code/q3_ui/ui_startserver.c

code/q3_ui/ui_team.c

code/q3_ui/ui_teamorders.c

code/q3_ui/ui_video.c

code/qcommon

code/qcommon/cm_load.c

code/qcommon/cm_local.h

code/qcommon/cm_patch.c

code/qcommon/cm_patch.h

code/qcommon/cm_polylib.c

code/qcommon/cm_polylib.h

code/qcommon/cm_public.h

code/qcommon/cm_test.c

code/qcommon/cm_trace.c

code/qcommon/cmd.c

code/qcommon/common.c

code/qcommon/cvar.c

code/qcommon/files.c

code/qcommon/huffman.c

code/qcommon/md4.c

code/qcommon/md5.c

code/qcommon/msg.c

code/qcommon/net_chan.c

code/qcommon/q_math.c

code/qcommon/q_platform.h

code/qcommon/q_shared.c

code/qcommon/q_shared.h

code/qcommon/qcommon.h

code/qcommon/qfiles.h

code/qcommon/surfaceflags.h

code/qcommon/unzip.c

code/qcommon/unzip.h

code/qcommon/vm.c

code/qcommon/vm_interpreted.c

code/qcommon/vm_local.h

code/qcommon/vm_none.c

code/qcommon/vm_ppc.c

code/qcommon/vm_ppc_new.c

code/qcommon/vm_x86.c

code/qcommon/vm_x86_64.c

code/renderer

code/renderer/qgl.h

code/renderer/qgl_linked.h

code/renderer/tr_animation.c

code/renderer/tr_backend.c

code/renderer/tr_bsp.c

code/renderer/tr_cmds.c

code/renderer/tr_curve.c

code/renderer/tr_flares.c

code/renderer/tr_font.c

code/renderer/tr_image.c

code/renderer/tr_init.c

code/renderer/tr_light.c

code/renderer/tr_local.h

code/renderer/tr_main.c

code/renderer/tr_marks.c

code/renderer/tr_mesh.c

code/renderer/tr_model.c

code/renderer/tr_noise.c

code/renderer/tr_public.h

code/renderer/tr_scene.c

code/renderer/tr_shade.c

code/renderer/tr_shade_calc.c

code/renderer/tr_shader.c

code/renderer/tr_shadows.c

code/renderer/tr_sky.c

code/renderer/tr_surface.c

code/renderer/tr_types.h

code/renderer/tr_world.c

code/server

code/server/server.h

code/server/sv_bot.c

code/server/sv_ccmds.c

code/server/sv_client.c

code/server/sv_game.c

code/server/sv_init.c

code/server/sv_main.c

code/server/sv_net_chan.c

code/server/sv_rankings.c

code/server/sv_snapshot.c

code/server/sv_world.c

code/tools

code/tools/asm

code/tools/asm/Makefile

code/tools/asm/README.Id

code/tools/asm/cmdlib.c

code/tools/asm/cmdlib.h

code/tools/asm/lib.txt

code/tools/asm/mathlib.h

code/tools/asm/notes.txt

code/tools/asm/ops.txt

code/tools/asm/opstrings.h

code/tools/asm/q3asm.c

code/tools/asm/q3asm.sln

code/tools/asm/q3asm.vcproj

code/tools/lcc

code/tools/lcc/COPYRIGHT

code/tools/lcc/LOG

code/tools/lcc/Makefile

code/tools/lcc/README

code/tools/lcc/README.id

code/tools/lcc/buildnt.bat

code/tools/lcc/cpp

code/tools/lcc/cpp/cpp.c

code/tools/lcc/cpp/cpp.h

code/tools/lcc/cpp/eval.c

code/tools/lcc/cpp/getopt.c

code/tools/lcc/cpp/hideset.c

code/tools/lcc/cpp/include.c

code/tools/lcc/cpp/lex.c

code/tools/lcc/cpp/macro.c

code/tools/lcc/cpp/nlist.c

code/tools/lcc/cpp/tokens.c

code/tools/lcc/cpp/unix.c

code/tools/lcc/doc

code/tools/lcc/doc/4.html

code/tools/lcc/doc/bprint.1

code/tools/lcc/doc/bprint.pdf

code/tools/lcc/doc/install.html

code/tools/lcc/doc/lcc.1

code/tools/lcc/doc/lcc.pdf

code/tools/lcc/etc

code/tools/lcc/etc/bytecode.c

code/tools/lcc/etc/lcc.c

code/tools/lcc/lburg

code/tools/lcc/lburg/gram.c

code/tools/lcc/lburg/gram.y

code/tools/lcc/lburg/lburg.1

code/tools/lcc/lburg/lburg.c

code/tools/lcc/lburg/lburg.h

code/tools/lcc/makefile.nt

code/tools/lcc/src

code/tools/lcc/src/alloc.c

code/tools/lcc/src/bind.c

code/tools/lcc/src/bytecode.c

code/tools/lcc/src/c.h

code/tools/lcc/src/config.h

code/tools/lcc/src/dag.c

code/tools/lcc/src/dagcheck.md

code/tools/lcc/src/decl.c

code/tools/lcc/src/enode.c

code/tools/lcc/src/error.c

code/tools/lcc/src/event.c

code/tools/lcc/src/expr.c

code/tools/lcc/src/gen.c

code/tools/lcc/src/init.c

code/tools/lcc/src/inits.c

code/tools/lcc/src/input.c

code/tools/lcc/src/lex.c

code/tools/lcc/src/list.c

code/tools/lcc/src/main.c

code/tools/lcc/src/null.c

code/tools/lcc/src/output.c

code/tools/lcc/src/prof.c

code/tools/lcc/src/profio.c

code/tools/lcc/src/simp.c

code/tools/lcc/src/stmt.c

code/tools/lcc/src/string.c

code/tools/lcc/src/sym.c

code/tools/lcc/src/symbolic.c

code/tools/lcc/src/token.h

code/tools/lcc/src/trace.c

code/tools/lcc/src/tree.c

code/tools/lcc/src/types.c

code/ui

code/ui/compile.bat

code/ui/ui.bat

code/ui/ui.q3asm

code/ui/ui_atoms.c

code/ui/ui_gameinfo.c

code/ui/ui_local.h

code/ui/ui_main.c

code/ui/ui_players.c

code/ui/ui_public.h

code/ui/ui_shared.c

code/ui/ui_shared.h

code/ui/ui_syscalls.asm

code/ui/ui_syscalls.c

code/unix

code/unix/LinuxSupport

code/unix/LinuxSupport/CHANGES-1.32.txt

code/unix/LinuxSupport/INSTALL

code/unix/LinuxSupport/index.html

code/unix/LinuxSupport/udp_wide_README.txt

code/unix/LinuxSupport/udp_wide_broadcast.patch

code/unix/MacSupport

code/unix/MacSupport/SLA-dmg.sh

code/unix/MacSupport/SLA.r

code/unix/MacSupport/ioquake3.icns

code/unix/README.Linux

code/unix/README.Q3Test

code/unix/ftola.s

code/unix/linux_glimp.c

code/unix/linux_joystick.c

code/unix/linux_local.h

code/unix/linux_qgl.c

code/unix/linux_signals.c

code/unix/linux_snd.c

code/unix/matha.s

code/unix/qasm.h

code/unix/quake3.png

code/unix/quake3.svg

code/unix/sdl_glimp.c

code/unix/sdl_snd.c

code/unix/setup

code/unix/setup/Makefile

code/unix/setup/Solaris_pkg.sh

code/unix/setup/doit

code/unix/setup/ioq3demo.sh

code/unix/setup/ioquake3.sh

code/unix/setup/pkg

code/unix/setup/pkg/ioq3ded.sh

code/unix/setup/pkg/ioquake3

code/unix/setup/pkg/ioquake3.sh

code/unix/setup/pkg/ioquake3/depend

code/unix/setup/pkg/ioquake3/pkginfo.template

code/unix/setup/pkg/ioquake3/postinstall

code/unix/setup/pkg/ioquake3/postremove

code/unix/setup/pkg/ioquake3/preinstall

code/unix/setup/pkg/ioquake3/preremove

code/unix/setup/pkg/ioquake3/prototype.template

code/unix/setup/pkg/ioquake3/space

code/unix/setup/pkg/ioquake3d

code/unix/setup/pkg/ioquake3d/depend

code/unix/setup/pkg/ioquake3d/pkginfo.template

code/unix/setup/pkg/ioquake3d/postinstall

code/unix/setup/pkg/ioquake3d/postremove

code/unix/setup/pkg/ioquake3d/preinstall

code/unix/setup/pkg/ioquake3d/preremove

code/unix/setup/pkg/ioquake3d/prototype.template

code/unix/setup/pkg/ioquake3d/space

code/unix/setup/preuninstall.sh

code/unix/setup/setup.xml

code/unix/setup/splash.xpm

code/unix/snapvectora.s

code/unix/snd_mixa.s

code/unix/unix_glw.h

code/unix/unix_main.c

code/unix/unix_net.c

code/unix/unix_shared.c

code/win32

code/win32/background.bmp

code/win32/clear.bmp

code/win32/glw_win.h

code/win32/icon2.ico

code/win32/msvc

code/win32/msvc/botlib.vcproj

code/win32/msvc/cgame.def

code/win32/msvc/cgame.vcproj

code/win32/msvc/game.def

code/win32/msvc/game.vcproj

code/win32/msvc/q3_ui.def

code/win32/msvc/q3_ui.vcproj

code/win32/msvc/quake3.sln

code/win32/msvc/quake3.vcproj

code/win32/msvc/ref_trin.def

code/win32/msvc/renderer.vcproj

code/win32/msvc/ui.def

code/win32/msvc/ui.vcproj

code/win32/qe3.ico

code/win32/resource.h

code/win32/win_gamma.c

code/win32/win_glimp.c

code/win32/win_input.c

code/win32/win_local.h

code/win32/win_main.c

code/win32/win_net.c

code/win32/win_qgl.c

code/win32/win_shared.c

code/win32/win_snd.c

code/win32/win_syscon.c

code/win32/win_wndproc.c

code/win32/winquake.rc

cross-make-mingw.sh

id-readme.txt

make-macosx-ub.sh

md4-readme.txt

ui/hud.txt

ui/hud2.txt

ui/ingame.txt

ui/menudef.h

ui/menus.txt

Show diffs side-by-side

added added

removed removed

code/q3_ui/ui_players.c

===========================================================================

This file is part of Quake III Arena source code.

Quake III Arena source code is free software; you can redistribute it

and/or modify it under the terms of the GNU General Public License as

published by the Free Software Foundation; either version 2 of the License,

or (at your option) any later version.

Quake III Arena source code is distributed in the hope that it will be

useful, but WITHOUT ANY WARRANTY; without even the implied warranty of

MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

GNU General Public License for more details.

You should have received a copy of the GNU General Public License

along with Quake III Arena source code; if not, write to the Free Software

Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA

===========================================================================

// ui_players.c

#include "ui_local.h"

#define UI_TIMER_GESTURE 2300

#define UI_TIMER_JUMP 1000

#define UI_TIMER_LAND 130

#define UI_TIMER_WEAPON_SWITCH 300

#define UI_TIMER_ATTACK 500

#define UI_TIMER_MUZZLE_FLASH 20

#define UI_TIMER_WEAPON_DELAY 250

#define JUMP_HEIGHT 56

#define SWINGSPEED 0.3f

#define SPIN_SPEED 0.9f

#define COAST_TIME 1000

static int dp_realtime;

static float jumpHeight;

===============

UI_PlayerInfo_SetWeapon

===============

static void UI_PlayerInfo_SetWeapon( playerInfo_t *pi, weapon_t weaponNum ) {

gitem_t * item;

char path[MAX_QPATH];

pi->currentWeapon = weaponNum;

tryagain:

pi->realWeapon = weaponNum;

pi->weaponModel = 0;

pi->barrelModel = 0;

pi->flashModel = 0;

if ( weaponNum == WP_NONE ) {

return;

}

for ( item = bg_itemlist + 1; item->classname ; item++ ) {

if ( item->giType != IT_WEAPON ) {

continue;

}

if ( item->giTag == weaponNum ) {

break;

}

if ( item->classname ) {

pi->weaponModel = trap_R_RegisterModel( item->world_model[0] );

}

if( pi->weaponModel == 0 ) {

if( weaponNum == WP_MACHINEGUN ) {

weaponNum = WP_NONE;

goto tryagain;

}

weaponNum = WP_MACHINEGUN;

goto tryagain;

}

if ( weaponNum == WP_MACHINEGUN || weaponNum == WP_GAUNTLET || weaponNum == WP_BFG ) {

strcpy( path, item->world_model[0] );

COM_StripExtension( path, path, sizeof(path) );

strcat( path, "_barrel.md3" );

pi->barrelModel = trap_R_RegisterModel( path );

}

strcpy( path, item->world_model[0] );

COM_StripExtension( path, path, sizeof(path) );

strcat( path, "_flash.md3" );

100

pi->flashModel = trap_R_RegisterModel( path );

101

102

switch( weaponNum ) {

103

case WP_GAUNTLET:

104

MAKERGB( pi->flashDlightColor, 0.6f, 0.6f, 1 );

105

break;

106

107

case WP_MACHINEGUN:

108

MAKERGB( pi->flashDlightColor, 1, 1, 0 );

109

break;

110

111

case WP_SHOTGUN:

112

MAKERGB( pi->flashDlightColor, 1, 1, 0 );

113

break;

114

115

case WP_GRENADE_LAUNCHER:

116

MAKERGB( pi->flashDlightColor, 1, 0.7f, 0.5f );

117

break;

118

119

case WP_ROCKET_LAUNCHER:

120

MAKERGB( pi->flashDlightColor, 1, 0.75f, 0 );

121

break;

122

123

case WP_LIGHTNING:

124

MAKERGB( pi->flashDlightColor, 0.6f, 0.6f, 1 );

125

break;

126

127

case WP_RAILGUN:

128

MAKERGB( pi->flashDlightColor, 1, 0.5f, 0 );

129

break;

130

131

case WP_PLASMAGUN:

132

MAKERGB( pi->flashDlightColor, 0.6f, 0.6f, 1 );

133

break;

134

135

case WP_BFG:

136

MAKERGB( pi->flashDlightColor, 1, 0.7f, 1 );

137

break;

138

139

case WP_GRAPPLING_HOOK:

140

MAKERGB( pi->flashDlightColor, 0.6f, 0.6f, 1 );

141

break;

142

143

default:

144

MAKERGB( pi->flashDlightColor, 1, 1, 1 );

145

break;

146

}

147

}

148

149

150

151

===============

152

UI_ForceLegsAnim

153

===============

154

155

static void UI_ForceLegsAnim( playerInfo_t *pi, int anim ) {

156

pi->legsAnim = ( ( pi->legsAnim & ANIM_TOGGLEBIT ) ^ ANIM_TOGGLEBIT ) | anim;

157

158

if ( anim == LEGS_JUMP ) {

159

pi->legsAnimationTimer = UI_TIMER_JUMP;

160

}

161

}

162

163

164

165

===============

166

UI_SetLegsAnim

167

===============

168

169

static void UI_SetLegsAnim( playerInfo_t *pi, int anim ) {

170

if ( pi->pendingLegsAnim ) {

171

anim = pi->pendingLegsAnim;

172

pi->pendingLegsAnim = 0;

173

}

174

UI_ForceLegsAnim( pi, anim );

175

}

176

177

178

179

===============

180

UI_ForceTorsoAnim

181

===============

182

183

static void UI_ForceTorsoAnim( playerInfo_t *pi, int anim ) {

184

pi->torsoAnim = ( ( pi->torsoAnim & ANIM_TOGGLEBIT ) ^ ANIM_TOGGLEBIT ) | anim;

185

186

if ( anim == TORSO_GESTURE ) {

187

pi->torsoAnimationTimer = UI_TIMER_GESTURE;

188

}

189

190

if ( anim == TORSO_ATTACK || anim == TORSO_ATTACK2 ) {

191

pi->torsoAnimationTimer = UI_TIMER_ATTACK;

192

}

193

}

194

195

196

197

===============

198

UI_SetTorsoAnim

199

===============

200

201

static void UI_SetTorsoAnim( playerInfo_t *pi, int anim ) {

202

if ( pi->pendingTorsoAnim ) {

203

anim = pi->pendingTorsoAnim;

204

pi->pendingTorsoAnim = 0;

205

}

206

207

UI_ForceTorsoAnim( pi, anim );

208

}

209

210

211

212

===============

213

UI_TorsoSequencing

214

===============

215

216

static void UI_TorsoSequencing( playerInfo_t *pi ) {

217

int currentAnim;

218

219

currentAnim = pi->torsoAnim & ~ANIM_TOGGLEBIT;

220

221

if ( pi->weapon != pi->currentWeapon ) {

222

if ( currentAnim != TORSO_DROP ) {

223

pi->torsoAnimationTimer = UI_TIMER_WEAPON_SWITCH;

224

UI_ForceTorsoAnim( pi, TORSO_DROP );

225

}

226

}

227

228

if ( pi->torsoAnimationTimer > 0 ) {

229

return;

230

}

231

232

if( currentAnim == TORSO_GESTURE ) {

233

UI_SetTorsoAnim( pi, TORSO_STAND );

234

return;

235

}

236

237

if( currentAnim == TORSO_ATTACK || currentAnim == TORSO_ATTACK2 ) {

238

UI_SetTorsoAnim( pi, TORSO_STAND );

239

return;

240

}

241

242

if ( currentAnim == TORSO_DROP ) {

243

UI_PlayerInfo_SetWeapon( pi, pi->weapon );

244

pi->torsoAnimationTimer = UI_TIMER_WEAPON_SWITCH;

245

UI_ForceTorsoAnim( pi, TORSO_RAISE );

246

return;

247

}

248

249

if ( currentAnim == TORSO_RAISE ) {

250

UI_SetTorsoAnim( pi, TORSO_STAND );

251

return;

252

}

253

}

254

255

256

257

===============

258

UI_LegsSequencing

259

===============

260

261

static void UI_LegsSequencing( playerInfo_t *pi ) {

262

int currentAnim;

263

264

currentAnim = pi->legsAnim & ~ANIM_TOGGLEBIT;

265

266

if ( pi->legsAnimationTimer > 0 ) {

267

if ( currentAnim == LEGS_JUMP ) {

268

jumpHeight = JUMP_HEIGHT * sin( M_PI * ( UI_TIMER_JUMP - pi->legsAnimationTimer ) / UI_TIMER_JUMP );

269

}

270

return;

271

}

272

273

if ( currentAnim == LEGS_JUMP ) {

274

UI_ForceLegsAnim( pi, LEGS_LAND );

275

pi->legsAnimationTimer = UI_TIMER_LAND;

276

jumpHeight = 0;

277

return;

278

}

279

280

if ( currentAnim == LEGS_LAND ) {

281

UI_SetLegsAnim( pi, LEGS_IDLE );

282

return;

283

}

284

}

285

286

287

288

======================

289

UI_PositionEntityOnTag

290

======================

291

292

static void UI_PositionEntityOnTag( refEntity_t *entity, const refEntity_t *parent,

293

clipHandle_t parentModel, char *tagName ) {

294

int i;

295

orientation_t lerped;

296

297

// lerp the tag

298

trap_CM_LerpTag( &lerped, parentModel, parent->oldframe, parent->frame,

299

1.0 - parent->backlerp, tagName );

300

301

// FIXME: allow origin offsets along tag?

302

VectorCopy( parent->origin, entity->origin );

303

for ( i = 0 ; i < 3 ; i++ ) {

304

VectorMA( entity->origin, lerped.origin[i], parent->axis[i], entity->origin );

305

}

306

307

// cast away const because of compiler problems

308

MatrixMultiply( lerped.axis, ((refEntity_t*)parent)->axis, entity->axis );

309

entity->backlerp = parent->backlerp;

310

}

311

312

313

314

======================

315

UI_PositionRotatedEntityOnTag

316

======================

317

318

static void UI_PositionRotatedEntityOnTag( refEntity_t *entity, const refEntity_t *parent,

319

clipHandle_t parentModel, char *tagName ) {

320

int i;

321

orientation_t lerped;

322

vec3_t tempAxis[3];

323

324

// lerp the tag

325

trap_CM_LerpTag( &lerped, parentModel, parent->oldframe, parent->frame,

326

1.0 - parent->backlerp, tagName );

327

328

// FIXME: allow origin offsets along tag?

329

VectorCopy( parent->origin, entity->origin );

330

for ( i = 0 ; i < 3 ; i++ ) {

331

VectorMA( entity->origin, lerped.origin[i], parent->axis[i], entity->origin );

332

}

333

334

// cast away const because of compiler problems

335

MatrixMultiply( entity->axis, ((refEntity_t *)parent)->axis, tempAxis );

336

MatrixMultiply( lerped.axis, tempAxis, entity->axis );

337

}

338

339

340

341

===============

342

UI_SetLerpFrameAnimation

343

===============

344

345

static void UI_SetLerpFrameAnimation( playerInfo_t *ci, lerpFrame_t *lf, int newAnimation ) {

346

animation_t *anim;

347

348

lf->animationNumber = newAnimation;

349

newAnimation &= ~ANIM_TOGGLEBIT;

350

351

if ( newAnimation < 0 || newAnimation >= MAX_ANIMATIONS ) {

352

trap_Error( va("Bad animation number: %i", newAnimation) );

353

}

354

355

anim = &ci->animations[ newAnimation ];

356

357

lf->animation = anim;

358

lf->animationTime = lf->frameTime + anim->initialLerp;

359

}

360

361

362

363

===============

364

UI_RunLerpFrame

365

===============

366

367

static void UI_RunLerpFrame( playerInfo_t *ci, lerpFrame_t *lf, int newAnimation ) {

368

int f;

369

animation_t *anim;

370

371

// see if the animation sequence is switching

372

if ( newAnimation != lf->animationNumber || !lf->animation ) {

373

UI_SetLerpFrameAnimation( ci, lf, newAnimation );

374

}

375

376

// if we have passed the current frame, move it to

377

// oldFrame and calculate a new frame

378

if ( dp_realtime >= lf->frameTime ) {

379

lf->oldFrame = lf->frame;

380

lf->oldFrameTime = lf->frameTime;

381

382

// get the next frame based on the animation

383

anim = lf->animation;

384

if ( dp_realtime < lf->animationTime ) {

385

lf->frameTime = lf->animationTime; // initial lerp

386

} else {

387

lf->frameTime = lf->oldFrameTime + anim->frameLerp;

388

}

389

f = ( lf->frameTime - lf->animationTime ) / anim->frameLerp;

390

if ( f >= anim->numFrames ) {

391

f -= anim->numFrames;

392

if ( anim->loopFrames ) {

393

f %= anim->loopFrames;

394

f += anim->numFrames - anim->loopFrames;

395

} else {

396

f = anim->numFrames - 1;

397

// the animation is stuck at the end, so it

398

// can immediately transition to another sequence

399

lf->frameTime = dp_realtime;

400

}

401

}

402

lf->frame = anim->firstFrame + f;

403

if ( dp_realtime > lf->frameTime ) {

404

lf->frameTime = dp_realtime;

405

}

406

}

407

408

if ( lf->frameTime > dp_realtime + 200 ) {

409

lf->frameTime = dp_realtime;

410

}

411

412

if ( lf->oldFrameTime > dp_realtime ) {

413

lf->oldFrameTime = dp_realtime;

414

}

415

// calculate current lerp value

416

if ( lf->frameTime == lf->oldFrameTime ) {

417

lf->backlerp = 0;

418

} else {

419

lf->backlerp = 1.0 - (float)( dp_realtime - lf->oldFrameTime ) / ( lf->frameTime - lf->oldFrameTime );

420

}

421

}

422

423

424

425

===============

426

UI_PlayerAnimation

427

===============

428

429

static void UI_PlayerAnimation( playerInfo_t *pi, int *legsOld, int *legs, float *legsBackLerp,

430

int *torsoOld, int *torso, float *torsoBackLerp ) {

431

432

// legs animation

433

pi->legsAnimationTimer -= uis.frametime;

434

if ( pi->legsAnimationTimer < 0 ) {

435

pi->legsAnimationTimer = 0;

436

}

437

438

UI_LegsSequencing( pi );

439

440

if ( pi->legs.yawing && ( pi->legsAnim & ~ANIM_TOGGLEBIT ) == LEGS_IDLE ) {

441

UI_RunLerpFrame( pi, &pi->legs, LEGS_TURN );

442

} else {

443

UI_RunLerpFrame( pi, &pi->legs, pi->legsAnim );

444

}

445

*legsOld = pi->legs.oldFrame;

446

*legs = pi->legs.frame;

447

*legsBackLerp = pi->legs.backlerp;

448

449

// torso animation

450

pi->torsoAnimationTimer -= uis.frametime;

451

if ( pi->torsoAnimationTimer < 0 ) {

452

pi->torsoAnimationTimer = 0;

453

}

454

455

UI_TorsoSequencing( pi );

456

457

UI_RunLerpFrame( pi, &pi->torso, pi->torsoAnim );

458

*torsoOld = pi->torso.oldFrame;

459

*torso = pi->torso.frame;

460

*torsoBackLerp = pi->torso.backlerp;

461

}

462

463

464

465

==================

466

UI_SwingAngles

467

==================

468

469

static void UI_SwingAngles( float destination, float swingTolerance, float clampTolerance,

470

float speed, float *angle, qboolean *swinging ) {

471

float swing;

472

float move;

473

float scale;

474

475

if ( !*swinging ) {

476

// see if a swing should be started

477

swing = AngleSubtract( *angle, destination );

478

if ( swing > swingTolerance || swing < -swingTolerance ) {

479

*swinging = qtrue;

480

}

481

}

482

483

if ( !*swinging ) {

484

return;

485

}

486

487

// modify the speed depending on the delta

488

// so it doesn't seem so linear

489

swing = AngleSubtract( destination, *angle );

490

scale = fabs( swing );

491

if ( scale < swingTolerance * 0.5 ) {

492

scale = 0.5;

493

} else if ( scale < swingTolerance ) {

494

scale = 1.0;

495

} else {

496

scale = 2.0;

497

}

498

499

// swing towards the destination angle

500

if ( swing >= 0 ) {

501

move = uis.frametime * scale * speed;

502

if ( move >= swing ) {

503

move = swing;

504

*swinging = qfalse;

505

}

506

*angle = AngleMod( *angle + move );

507

} else if ( swing < 0 ) {

508

move = uis.frametime * scale * -speed;

509

if ( move <= swing ) {

510

move = swing;

511

*swinging = qfalse;

512

}

513

*angle = AngleMod( *angle + move );

514

}

515

516

// clamp to no more than tolerance

517

swing = AngleSubtract( destination, *angle );

518

if ( swing > clampTolerance ) {

519

*angle = AngleMod( destination - (clampTolerance - 1) );

520

} else if ( swing < -clampTolerance ) {

521

*angle = AngleMod( destination + (clampTolerance - 1) );

522

}

523

}

524

525

526

527

======================

528

UI_MovedirAdjustment

529

======================

530

531

static float UI_MovedirAdjustment( playerInfo_t *pi ) {

532

vec3_t relativeAngles;

533

vec3_t moveVector;

534

535

VectorSubtract( pi->viewAngles, pi->moveAngles, relativeAngles );

536

AngleVectors( relativeAngles, moveVector, NULL, NULL );

537

if ( Q_fabs( moveVector[0] ) < 0.01 ) {

538

moveVector[0] = 0.0;

539

}

540

if ( Q_fabs( moveVector[1] ) < 0.01 ) {

541

moveVector[1] = 0.0;

542

}

543

544

if ( moveVector[1] == 0 && moveVector[0] > 0 ) {

545

return 0;

546

}

547

if ( moveVector[1] < 0 && moveVector[0] > 0 ) {

548

return 22;

549

}

550

if ( moveVector[1] < 0 && moveVector[0] == 0 ) {

551

return 45;

552

}

553

if ( moveVector[1] < 0 && moveVector[0] < 0 ) {

554

return -22;

555

}

556

if ( moveVector[1] == 0 && moveVector[0] < 0 ) {

557

return 0;

558

}

559

if ( moveVector[1] > 0 && moveVector[0] < 0 ) {

560

return 22;

561

}

562

if ( moveVector[1] > 0 && moveVector[0] == 0 ) {

563

return -45;

564

}

565

566

return -22;

567

}

568

569

570

571

===============

572

UI_PlayerAngles

573

===============

574

575

static void UI_PlayerAngles( playerInfo_t *pi, vec3_t legs[3], vec3_t torso[3], vec3_t head[3] ) {

576

vec3_t legsAngles, torsoAngles, headAngles;

577

float dest;

578

float adjust;

579

580

VectorCopy( pi->viewAngles, headAngles );

581

headAngles[YAW] = AngleMod( headAngles[YAW] );

582

VectorClear( legsAngles );

583

VectorClear( torsoAngles );

584

585

// --------- yaw -------------

586

587

// allow yaw to drift a bit

588

if ( ( pi->legsAnim & ~ANIM_TOGGLEBIT ) != LEGS_IDLE

589

|| ( pi->torsoAnim & ~ANIM_TOGGLEBIT ) != TORSO_STAND ) {

590

// if not standing still, always point all in the same direction

591

pi->torso.yawing = qtrue; // always center

592

pi->torso.pitching = qtrue; // always center

593

pi->legs.yawing = qtrue; // always center

594

}

595

596

// adjust legs for movement dir

597

adjust = UI_MovedirAdjustment( pi );

598

legsAngles[YAW] = headAngles[YAW] + adjust;

599

torsoAngles[YAW] = headAngles[YAW] + 0.25 * adjust;

600

601

602

// torso

603

UI_SwingAngles( torsoAngles[YAW], 25, 90, SWINGSPEED, &pi->torso.yawAngle, &pi->torso.yawing );

604

UI_SwingAngles( legsAngles[YAW], 40, 90, SWINGSPEED, &pi->legs.yawAngle, &pi->legs.yawing );

605

606

torsoAngles[YAW] = pi->torso.yawAngle;

607

legsAngles[YAW] = pi->legs.yawAngle;

608

609

// --------- pitch -------------

610

611

// only show a fraction of the pitch angle in the torso

612

if ( headAngles[PITCH] > 180 ) {

613

dest = (-360 + headAngles[PITCH]) * 0.75;

614

} else {

615

dest = headAngles[PITCH] * 0.75;

616

}

617

UI_SwingAngles( dest, 15, 30, 0.1f, &pi->torso.pitchAngle, &pi->torso.pitching );

618

torsoAngles[PITCH] = pi->torso.pitchAngle;

619

620

// pull the angles back out of the hierarchial chain

621

AnglesSubtract( headAngles, torsoAngles, headAngles );

622

AnglesSubtract( torsoAngles, legsAngles, torsoAngles );

623

AnglesToAxis( legsAngles, legs );

624

AnglesToAxis( torsoAngles, torso );

625

AnglesToAxis( headAngles, head );

626

}

627

628

629

630

===============

631

UI_PlayerFloatSprite

632

===============

633

634

static void UI_PlayerFloatSprite( playerInfo_t *pi, vec3_t origin, qhandle_t shader ) {

635

refEntity_t ent;

636

637

memset( &ent, 0, sizeof( ent ) );

638

VectorCopy( origin, ent.origin );

639

ent.origin[2] += 48;

640

ent.reType = RT_SPRITE;

641

ent.customShader = shader;

642

ent.radius = 10;

643

ent.renderfx = 0;

644

trap_R_AddRefEntityToScene( &ent );

645

}

646

647

648

649

======================

650

UI_MachinegunSpinAngle

651

======================

652

653

float UI_MachinegunSpinAngle( playerInfo_t *pi ) {

654

int delta;

655

float angle;

656

float speed;

657

int torsoAnim;

658

659

delta = dp_realtime - pi->barrelTime;

660

if ( pi->barrelSpinning ) {

661

angle = pi->barrelAngle + delta * SPIN_SPEED;

662

} else {

663

if ( delta > COAST_TIME ) {

664

delta = COAST_TIME;

665

}

666

667

speed = 0.5 * ( SPIN_SPEED + (float)( COAST_TIME - delta ) / COAST_TIME );

668

angle = pi->barrelAngle + delta * speed;

669

}

670

671

torsoAnim = pi->torsoAnim & ~ANIM_TOGGLEBIT;

672

if( torsoAnim == TORSO_ATTACK2 ) {

673

torsoAnim = TORSO_ATTACK;

674

}

675

if ( pi->barrelSpinning == !(torsoAnim == TORSO_ATTACK) ) {

676

pi->barrelTime = dp_realtime;

677

pi->barrelAngle = AngleMod( angle );

678

pi->barrelSpinning = !!(torsoAnim == TORSO_ATTACK);

679

}

680

681

return angle;

682

}

683

684

685

686

===============

687

UI_DrawPlayer

688

===============

689

690

void UI_DrawPlayer( float x, float y, float w, float h, playerInfo_t *pi, int time ) {

691

refdef_t refdef;

692

refEntity_t legs;

693

refEntity_t torso;

694

refEntity_t head;

695

refEntity_t gun;

696

refEntity_t barrel;

697

refEntity_t flash;

698

vec3_t origin;

699

int renderfx;

700

vec3_t mins = {-16, -16, -24};

701

vec3_t maxs = {16, 16, 32};

702

float len;

703

float xx;

704

705

if ( !pi->legsModel || !pi->torsoModel || !pi->headModel || !pi->animations[0].numFrames ) {

706

return;

707

}

708

709

dp_realtime = time;

710

711

if ( pi->pendingWeapon != -1 && dp_realtime > pi->weaponTimer ) {

712

pi->weapon = pi->pendingWeapon;

713

pi->lastWeapon = pi->pendingWeapon;

714

pi->pendingWeapon = -1;

715

pi->weaponTimer = 0;

716

if( pi->currentWeapon != pi->weapon ) {

717

trap_S_StartLocalSound( weaponChangeSound, CHAN_LOCAL );

718

}

719

}

720

721

UI_AdjustFrom640( &x, &y, &w, &h );

722

723

y -= jumpHeight;

724

725

memset( &refdef, 0, sizeof( refdef ) );

726

memset( &legs, 0, sizeof(legs) );

727

memset( &torso, 0, sizeof(torso) );

728

memset( &head, 0, sizeof(head) );

729

730

refdef.rdflags = RDF_NOWORLDMODEL;

731

732

AxisClear( refdef.viewaxis );

733

734

refdef.x = x;

735

refdef.y = y;

736

refdef.width = w;

737

refdef.height = h;

738

739

refdef.fov_x = (int)((float)refdef.width / 640.0f * 90.0f);

740

xx = refdef.width / tan( refdef.fov_x / 360 * M_PI );

741

refdef.fov_y = atan2( refdef.height, xx );

742

refdef.fov_y *= ( 360 / M_PI );

743

744

// calculate distance so the player nearly fills the box

745

len = 0.7 * ( maxs[2] - mins[2] );

746

origin[0] = len / tan( DEG2RAD(refdef.fov_x) * 0.5 );

747

origin[1] = 0.5 * ( mins[1] + maxs[1] );

748

origin[2] = -0.5 * ( mins[2] + maxs[2] );

749

750

refdef.time = dp_realtime;

751

752

trap_R_ClearScene();

753

754

// get the rotation information

755

UI_PlayerAngles( pi, legs.axis, torso.axis, head.axis );

756

757

// get the animation state (after rotation, to allow feet shuffle)

758

UI_PlayerAnimation( pi, &legs.oldframe, &legs.frame, &legs.backlerp,

759

&torso.oldframe, &torso.frame, &torso.backlerp );

760

761

renderfx = RF_LIGHTING_ORIGIN | RF_NOSHADOW;

762

763

764

// add the legs

765

766

legs.hModel = pi->legsModel;

767

legs.customSkin = pi->legsSkin;

768

769

VectorCopy( origin, legs.origin );

770

771

VectorCopy( origin, legs.lightingOrigin );

772

legs.renderfx = renderfx;

773

VectorCopy (legs.origin, legs.oldorigin);

774

775

trap_R_AddRefEntityToScene( &legs );

776

777

if (!legs.hModel) {

778

return;

779

}

780

781

782

// add the torso

783

784

torso.hModel = pi->torsoModel;

785

if (!torso.hModel) {

786

return;

787

}

788

789

torso.customSkin = pi->torsoSkin;

790

791

VectorCopy( origin, torso.lightingOrigin );

792

793

UI_PositionRotatedEntityOnTag( &torso, &legs, pi->legsModel, "tag_torso");

794

795

torso.renderfx = renderfx;

796

797

trap_R_AddRefEntityToScene( &torso );

798

799

800

// add the head

801

802

head.hModel = pi->headModel;

803

if (!head.hModel) {

804

return;

805

}

806

head.customSkin = pi->headSkin;

807

808

VectorCopy( origin, head.lightingOrigin );

809

810

UI_PositionRotatedEntityOnTag( &head, &torso, pi->torsoModel, "tag_head");

811

812

head.renderfx = renderfx;

813

814

trap_R_AddRefEntityToScene( &head );

815

816

817

// add the gun

818

819

if ( pi->currentWeapon != WP_NONE ) {

820

memset( &gun, 0, sizeof(gun) );

821

gun.hModel = pi->weaponModel;

822

VectorCopy( origin, gun.lightingOrigin );

823

UI_PositionEntityOnTag( &gun, &torso, pi->torsoModel, "tag_weapon");

824

gun.renderfx = renderfx;

825

trap_R_AddRefEntityToScene( &gun );

826

}

827

828

829

// add the spinning barrel

830

831

if ( pi->realWeapon == WP_MACHINEGUN || pi->realWeapon == WP_GAUNTLET || pi->realWeapon == WP_BFG ) {

832

vec3_t angles;

833

834

memset( &barrel, 0, sizeof(barrel) );

835

VectorCopy( origin, barrel.lightingOrigin );

836

barrel.renderfx = renderfx;

837

838

barrel.hModel = pi->barrelModel;

839

angles[YAW] = 0;

840

angles[PITCH] = 0;

841

angles[ROLL] = UI_MachinegunSpinAngle( pi );

842

if( pi->realWeapon == WP_GAUNTLET || pi->realWeapon == WP_BFG ) {

843

angles[PITCH] = angles[ROLL];

844

angles[ROLL] = 0;

845

}

846

AnglesToAxis( angles, barrel.axis );

847

848

UI_PositionRotatedEntityOnTag( &barrel, &gun, pi->weaponModel, "tag_barrel");

849

850

trap_R_AddRefEntityToScene( &barrel );

851

}

852

853

854

// add muzzle flash

855

856

if ( dp_realtime <= pi->muzzleFlashTime ) {

857

if ( pi->flashModel ) {

858

memset( &flash, 0, sizeof(flash) );

859

flash.hModel = pi->flashModel;

860

VectorCopy( origin, flash.lightingOrigin );

861

UI_PositionEntityOnTag( &flash, &gun, pi->weaponModel, "tag_flash");

862

flash.renderfx = renderfx;

863

trap_R_AddRefEntityToScene( &flash );

864

}

865

866

// make a dlight for the flash

867

if ( pi->flashDlightColor[0] || pi->flashDlightColor[1] || pi->flashDlightColor[2] ) {

868

trap_R_AddLightToScene( flash.origin, 200 + (rand()&31), pi->flashDlightColor[0],

869

pi->flashDlightColor[1], pi->flashDlightColor[2] );

870

}

871

}

872

873

874

// add the chat icon

875

876

if ( pi->chat ) {

877

UI_PlayerFloatSprite( pi, origin, trap_R_RegisterShaderNoMip( "sprites/balloon3" ) );

878

}

879

880

881

// add an accent light

882

883

origin[0] -= 100; // + = behind, - = in front

884

origin[1] += 100; // + = left, - = right

885

origin[2] += 100; // + = above, - = below

886

trap_R_AddLightToScene( origin, 500, 1.0, 1.0, 1.0 );

887

888

origin[0] -= 100;

889

origin[1] -= 100;

890

origin[2] -= 100;

891

trap_R_AddLightToScene( origin, 500, 1.0, 0.0, 0.0 );

892

893

trap_R_RenderScene( &refdef );

894

}

895

896

897

898

==========================

899

UI_RegisterClientSkin

900

==========================

901

902

static qboolean UI_RegisterClientSkin( playerInfo_t *pi, const char *modelName, const char *skinName ) {

903

char filename[MAX_QPATH];

904

905

Com_sprintf( filename, sizeof( filename ), "models/players/%s/lower_%s.skin", modelName, skinName );

906

pi->legsSkin = trap_R_RegisterSkin( filename );

907

908

Com_sprintf( filename, sizeof( filename ), "models/players/%s/upper_%s.skin", modelName, skinName );

909

pi->torsoSkin = trap_R_RegisterSkin( filename );

910

911

Com_sprintf( filename, sizeof( filename ), "models/players/%s/head_%s.skin", modelName, skinName );

912

pi->headSkin = trap_R_RegisterSkin( filename );

913

914

if ( !pi->legsSkin || !pi->torsoSkin || !pi->headSkin ) {

915

return qfalse;

916

}

917

918

return qtrue;

919

}

920

921

922

923

======================

924

UI_ParseAnimationFile

925

======================

926

927

static qboolean UI_ParseAnimationFile( const char *filename, animation_t *animations ) {

928

char *text_p, *prev;

929

int len;

930

int i;

931

char *token;

932

float fps;

933

int skip;

934

char text[20000];

935

fileHandle_t f;

936

937

memset( animations, 0, sizeof( animation_t ) * MAX_ANIMATIONS );

938

939

// load the file

940

len = trap_FS_FOpenFile( filename, &f, FS_READ );

941

if ( len <= 0 ) {

942

return qfalse;

943

}

944

if ( len >= ( sizeof( text ) - 1 ) ) {

945

Com_Printf( "File %s too long\n", filename );

946

trap_FS_FCloseFile( f );

947

return qfalse;

948

}

949

trap_FS_Read( text, len, f );

950

text[len] = 0;

951

trap_FS_FCloseFile( f );

952

953

// parse the text

954

text_p = text;

955

skip = 0; // quite the compiler warning

956

957

// read optional parameters

958

while ( 1 ) {

959

prev = text_p; // so we can unget

960

token = COM_Parse( &text_p );

961

if ( !token ) {

962

break;

963

}

964

if ( !Q_stricmp( token, "footsteps" ) ) {

965

token = COM_Parse( &text_p );

966

if ( !token ) {

967

break;

968

}

969

continue;

970

} else if ( !Q_stricmp( token, "headoffset" ) ) {

971

for ( i = 0 ; i < 3 ; i++ ) {

972

token = COM_Parse( &text_p );

973

if ( !token ) {

974

break;

975

}

976

}

977

continue;

978

} else if ( !Q_stricmp( token, "sex" ) ) {

979

token = COM_Parse( &text_p );

980

if ( !token ) {

981

break;

982

}

983

continue;

984

}

985

986

// if it is a number, start parsing animations

987

if ( token[0] >= '0' && token[0] <= '9' ) {

988

text_p = prev; // unget the token

989

break;

990

}

991

992

Com_Printf( "unknown token '%s' is %s\n", token, filename );

993

}

994

995

// read information for each frame

996

for ( i = 0 ; i < MAX_ANIMATIONS ; i++ ) {

997

998

token = COM_Parse( &text_p );

999

if ( !token ) {

1000

break;

1001

}

1002

animations[i].firstFrame = atoi( token );

1003

// leg only frames are adjusted to not count the upper body only frames

1004

if ( i == LEGS_WALKCR ) {

1005

skip = animations[LEGS_WALKCR].firstFrame - animations[TORSO_GESTURE].firstFrame;

1006

}

1007

if ( i >= LEGS_WALKCR ) {

1008

animations[i].firstFrame -= skip;

1009

}

1010

1011

token = COM_Parse( &text_p );

1012

if ( !token ) {

1013

break;

1014

}

1015

animations[i].numFrames = atoi( token );

1016

1017

token = COM_Parse( &text_p );

1018

if ( !token ) {

1019

break;

1020

}

1021

animations[i].loopFrames = atoi( token );

1022

1023

token = COM_Parse( &text_p );

1024

if ( !token ) {

1025

break;

1026

}

1027

fps = atof( token );

1028

if ( fps == 0 ) {

1029

fps = 1;

1030

}

1031

animations[i].frameLerp = 1000 / fps;

1032

animations[i].initialLerp = 1000 / fps;

1033

}

1034

1035

if ( i != MAX_ANIMATIONS ) {

1036

Com_Printf( "Error parsing animation file: %s", filename );

1037

return qfalse;

1038

}

1039

1040

return qtrue;

1041

}

1042

1043

1044

1045

==========================

1046

UI_RegisterClientModelname

1047

==========================

1048

1049

qboolean UI_RegisterClientModelname( playerInfo_t *pi, const char *modelSkinName ) {

1050

char modelName[MAX_QPATH];

1051

char skinName[MAX_QPATH];

1052

char filename[MAX_QPATH];

1053

char *slash;

1054

1055

pi->torsoModel = 0;

1056

pi->headModel = 0;

1057

1058

if ( !modelSkinName[0] ) {

1059

return qfalse;

1060

}

1061

1062

Q_strncpyz( modelName, modelSkinName, sizeof( modelName ) );

1063

1064

slash = strchr( modelName, '/' );

1065

if ( !slash ) {

1066

// modelName did not include a skin name

1067

Q_strncpyz( skinName, "default", sizeof( skinName ) );

1068

} else {

1069

Q_strncpyz( skinName, slash + 1, sizeof( skinName ) );

1070

// truncate modelName

1071

*slash = 0;

1072

}

1073

1074

// load cmodels before models so filecache works

1075

1076

Com_sprintf( filename, sizeof( filename ), "models/players/%s/lower.md3", modelName );

1077

pi->legsModel = trap_R_RegisterModel( filename );

1078

if ( !pi->legsModel ) {

1079

Com_Printf( "Failed to load model file %s\n", filename );

1080

return qfalse;

1081

}

1082

1083

Com_sprintf( filename, sizeof( filename ), "models/players/%s/upper.md3", modelName );

1084

pi->torsoModel = trap_R_RegisterModel( filename );

1085

if ( !pi->torsoModel ) {

1086

Com_Printf( "Failed to load model file %s\n", filename );

1087

return qfalse;

1088

}

1089

1090

Com_sprintf( filename, sizeof( filename ), "models/players/%s/head.md3", modelName );

1091

pi->headModel = trap_R_RegisterModel( filename );

1092

if ( !pi->headModel ) {

1093

Com_Printf( "Failed to load model file %s\n", filename );

1094

return qfalse;

1095

}

1096

1097

// if any skins failed to load, fall back to default

1098

if ( !UI_RegisterClientSkin( pi, modelName, skinName ) ) {

1099

if ( !UI_RegisterClientSkin( pi, modelName, "default" ) ) {

1100

Com_Printf( "Failed to load skin file: %s : %s\n", modelName, skinName );

1101

return qfalse;

1102

}

1103

}

1104

1105

// load the animations

1106

Com_sprintf( filename, sizeof( filename ), "models/players/%s/animation.cfg", modelName );

1107

if ( !UI_ParseAnimationFile( filename, pi->animations ) ) {

1108

Com_Printf( "Failed to load animation file %s\n", filename );

1109

return qfalse;

1110

}

1111

1112

return qtrue;

1113

}

1114

1115

1116

1117

===============

1118

UI_PlayerInfo_SetModel

1119

===============

1120

1121

void UI_PlayerInfo_SetModel( playerInfo_t *pi, const char *model ) {

1122

memset( pi, 0, sizeof(*pi) );

1123

UI_RegisterClientModelname( pi, model );

1124

pi->weapon = WP_MACHINEGUN;

1125

pi->currentWeapon = pi->weapon;

1126

pi->lastWeapon = pi->weapon;

1127

pi->pendingWeapon = -1;

1128

pi->weaponTimer = 0;

1129

pi->chat = qfalse;

1130

pi->newModel = qtrue;

1131

UI_PlayerInfo_SetWeapon( pi, pi->weapon );

1132

}

1133

1134

1135

1136

===============

1137

UI_PlayerInfo_SetInfo

1138

===============

1139

1140

void UI_PlayerInfo_SetInfo( playerInfo_t *pi, int legsAnim, int torsoAnim, vec3_t viewAngles, vec3_t moveAngles, weapon_t weaponNumber, qboolean chat ) {

1141

int currentAnim;

1142

weapon_t weaponNum;

1143

1144

pi->chat = chat;

1145

1146

// view angles

1147

VectorCopy( viewAngles, pi->viewAngles );

1148

1149

// move angles

1150

VectorCopy( moveAngles, pi->moveAngles );

1151

1152

if ( pi->newModel ) {

1153

pi->newModel = qfalse;

1154

1155

jumpHeight = 0;

1156

pi->pendingLegsAnim = 0;

1157

UI_ForceLegsAnim( pi, legsAnim );

1158

pi->legs.yawAngle = viewAngles[YAW];

1159

pi->legs.yawing = qfalse;

1160

1161

pi->pendingTorsoAnim = 0;

1162

UI_ForceTorsoAnim( pi, torsoAnim );

1163

pi->torso.yawAngle = viewAngles[YAW];

1164

pi->torso.yawing = qfalse;

1165

1166

if ( weaponNumber != -1 ) {

1167

pi->weapon = weaponNumber;

1168

pi->currentWeapon = weaponNumber;

1169

pi->lastWeapon = weaponNumber;

1170

pi->pendingWeapon = -1;

1171

pi->weaponTimer = 0;

1172

UI_PlayerInfo_SetWeapon( pi, pi->weapon );

1173

}

1174

1175

return;

1176

}

1177

1178

// weapon

1179

if ( weaponNumber == -1 ) {

1180

pi->pendingWeapon = -1;

1181

pi->weaponTimer = 0;

1182

}

1183

else if ( weaponNumber != WP_NONE ) {

1184

pi->pendingWeapon = weaponNumber;

1185

pi->weaponTimer = dp_realtime + UI_TIMER_WEAPON_DELAY;

1186

}

1187

weaponNum = pi->lastWeapon;

1188

pi->weapon = weaponNum;

1189

1190

if ( torsoAnim == BOTH_DEATH1 || legsAnim == BOTH_DEATH1 ) {

1191

torsoAnim = legsAnim = BOTH_DEATH1;

1192

pi->weapon = pi->currentWeapon = WP_NONE;

1193

UI_PlayerInfo_SetWeapon( pi, pi->weapon );

1194

1195

jumpHeight = 0;

1196

pi->pendingLegsAnim = 0;

1197

UI_ForceLegsAnim( pi, legsAnim );

1198

1199

pi->pendingTorsoAnim = 0;

1200

UI_ForceTorsoAnim( pi, torsoAnim );

1201

1202

return;

1203

}

1204

1205

// leg animation

1206

currentAnim = pi->legsAnim & ~ANIM_TOGGLEBIT;

1207

if ( legsAnim != LEGS_JUMP && ( currentAnim == LEGS_JUMP || currentAnim == LEGS_LAND ) ) {

1208

pi->pendingLegsAnim = legsAnim;

1209

}

1210

else if ( legsAnim != currentAnim ) {

1211

jumpHeight = 0;

1212

pi->pendingLegsAnim = 0;

1213

UI_ForceLegsAnim( pi, legsAnim );

1214

}

1215

1216

// torso animation

1217

if ( torsoAnim == TORSO_STAND || torsoAnim == TORSO_STAND2 ) {

1218

if ( weaponNum == WP_NONE || weaponNum == WP_GAUNTLET ) {

1219

torsoAnim = TORSO_STAND2;

1220

}

1221

else {

1222

torsoAnim = TORSO_STAND;

1223

}

1224

}

1225

1226

if ( torsoAnim == TORSO_ATTACK || torsoAnim == TORSO_ATTACK2 ) {

1227

if ( weaponNum == WP_NONE || weaponNum == WP_GAUNTLET ) {

1228

torsoAnim = TORSO_ATTACK2;

1229

}

1230

else {

1231

torsoAnim = TORSO_ATTACK;

1232

}

1233

pi->muzzleFlashTime = dp_realtime + UI_TIMER_MUZZLE_FLASH;

1234

//FIXME play firing sound here

1235

}

1236

1237

currentAnim = pi->torsoAnim & ~ANIM_TOGGLEBIT;

1238

1239

if ( weaponNum != pi->currentWeapon || currentAnim == TORSO_RAISE || currentAnim == TORSO_DROP ) {

1240

pi->pendingTorsoAnim = torsoAnim;

1241

}

1242

else if ( ( currentAnim == TORSO_GESTURE || currentAnim == TORSO_ATTACK ) && ( torsoAnim != currentAnim ) ) {

1243

pi->pendingTorsoAnim = torsoAnim;

1244

}

1245

else if ( torsoAnim != currentAnim ) {

1246

pi->pendingTorsoAnim = 0;

1247

UI_ForceTorsoAnim( pi, torsoAnim );

1248

}

1249

}

Older »