qboolean G_xpsave_load(gentity_t *ent)
{
int i, j;
qboolean found = qfalse, XPSMuted = qfalse;
int clientNum;
g_xpsave_t *x = g_xpsaves[0];
time_t t;
char agestr[MAX_STRING_CHARS];
//char desc[64];
// josh: Increased this
// josh: TODO: tjw? What is this desc thing for?
char desc[115];
int age;
int eff_XPSaveMaxAge_xp = G_getXPSaveMaxAge_xp();
int eff_XPSaveMaxAge = G_getXPSaveMaxAge();
float startxptotal = 0.0f;
if(!ent || !ent->client)
return qfalse;
if(!(g_XPSave.integer & XPSF_ENABLE))
return qfalse;
if(!time(&t))
return qfalse;
desc[0] = '\0';
clientNum = ent - g_entities;
for(i=0; g_xpsaves[i]; i++) {
if(!Q_stricmp(g_xpsaves[i]->guid,
ent->client->sess.guid)) {
found = qtrue;
x = g_xpsaves[i];
break;
}
}
if(!found)
return qfalse;
age = t - x->time;
if(age > eff_XPSaveMaxAge) {
return qfalse;
}
if(age <= eff_XPSaveMaxAge_xp) {
for(i=0; i<SK_NUM_SKILLS; i++) {
ent->client->sess.skillpoints[i] = x->skill[i];
// pheno: fix for session startxptotal value
startxptotal += x->skill[i];
}
ent->client->sess.startxptotal = startxptotal;
ent->client->ps.stats[STAT_XP] =
(int)ent->client->sess.startxptotal;
Q_strcat(desc, sizeof(desc), "XP/");
if((g_XPDecay.integer & XPDF_ENABLE) &&
!(g_XPDecay.integer & XPDF_NO_DISCONNECT_DECAY)) {
G_XPDecay(ent, age, qtrue);
}
}
ent->client->sess.overall_killrating = x->kill_rating;
ent->client->sess.overall_killvariance = x->kill_variance;
//ent->client->sess.playerrating = x->playerrating;
ent->client->sess.rating = x->rating;
ent->client->sess.rating_variance = x->rating_variance;
for(i=0; i<SK_NUM_SKILLS; i++) {
for(j=0; j<NUM_SKILL_LEVELS; j++) {
ent->client->sess.pr_skill_updates[i][j] =
x->pr_skill_updates[i][j];
ent->client->sess.pr_skill[i][j] =
x->pr_skill[i][j];
}
}
Q_strcat(desc, sizeof(desc), "ratings/");
if(x->mutetime != 0) {
if(x->mutetime < 0){
ent->client->sess.auto_unmute_time = -1;
XPSMuted = qtrue;
}else if(x->mutetime > t){
ent->client->sess.auto_unmute_time = (level.time + 1000*(x->mutetime - t));
XPSMuted = qtrue;;
}
if(XPSMuted == qtrue){
CP("print \"^5You've been muted by XPSave\n\"" );
Q_strcat(desc, sizeof(desc), "mute/");
}
}
ent->client->sess.hits = x->hits;
ent->client->sess.team_hits = x->team_hits;
G_CalcRank(ent->client);
BG_PlayerStateToEntityState(&ent->client->ps,
&ent->s,
level.time,
qtrue);
// tjw: trim last / from desc
if(strlen(desc))
desc[strlen(desc)-1] = '\0';
G_shrubbot_duration(age, agestr, sizeof(agestr));
CP(va(
"print \"^3server: loaded stored ^7%s^3 state from %s ago\n\"",
desc,
agestr));
// josh: check and update if disconnect found
// cs: not for bots since it is pointless for them, plus we never want SetTeam failing for them
if (!(ent->r.svFlags & SVF_BOT)) {
Reconnect(x,ent);
}
return qtrue;
}
http_header& http_header::set_host(const char* value)
{
if (value && *value)
CP(host_, value);
return *this;
}
void Cmd_Powerup_f( gentity_t * ent )
{
int i = 0;
int argc = trap_Argc();
char arg[MAX_TOKEN_CHARS] = "\0";
char arg2[MAX_TOKEN_CHARS] = "\0";
if( !ent->client->sess.routeMaker )
{
CP("cp \"^7You need to be a route maker to create powerups.\n\"");
return;
}
if(argc < 2)
{
CP("print \"usage: ^7powerup [type]\n\"");
return;
}
trap_Argv(1, arg, sizeof(arg));
if(!Q_stricmp(arg, "help"))
{
PrintPowerupHelp(ent);
return;
}
if(!Q_stricmp(arg, "info"))
{
trap_Argv(2, arg, sizeof(arg));
PrintPowerupInfo(ent, arg);
return;
}
// Special case, spawn random pwup
if(!Q_stricmp(arg, "random"))
{
int index = rand() % numPowerups;
if(powerups[index].spawn && powerups[index].think)
{
if(level.numPowerups == MAX_POWERUPS)
{
CP("print \"^1error: ^7too many powerups spawned.\n\"");
return;
}
level.powerups[level.numPowerups] = powerups[index].spawn(ent, powerups[index].think);
level.powerups[level.numPowerups]->powerupType = powerups[index].pw;
level.powerups[level.numPowerups]->powerupModelType = powerups[index].modelIndex;
level.numPowerups++;
CP("cp \"^5Spawned a random powerup\n\"");
}
return;
}
if(!Q_stricmp(arg, "any"))
{
if(level.numPowerups == MAX_POWERUPS)
{
CP("print \"^1error: ^7too many powerups spawned.\n\"");
return;
}
level.powerups[level.numPowerups] = SpawnRandomPowerupSpawner( ent );
level.powerups[level.numPowerups]->powerupType = PW_RANDOM;
level.powerups[level.numPowerups]->powerupModelType = PW_RANDOM;
level.numPowerups++;
CP("cp \"^5Spawned a random powerup\n\"");
return;
}
for(; i < numPowerups; i++)
{
if(!Q_stricmp(arg, powerups[i].name))
{
if(powerups[i].spawn && powerups[i].think)
{
if(level.numPowerups == MAX_POWERUPS)
{
CP("print \"^1error: ^7too many powerups spawned.\n\"");
return;
}
level.powerups[level.numPowerups] = powerups[i].spawn(ent, powerups[i].think);
level.powerups[level.numPowerups]->powerupType = powerups[i].pw;
level.powerups[level.numPowerups]->powerupModelType = powerups[i].modelIndex;
level.numPowerups++;
CP(va("cp \"^5Spawned a %s powerup\n\"", powerups[i].text));
} else
{
G_LogPrintf("Undefined powerup: %s\n", arg);
}
break;
}
}
}
static void cm_t35_set_muxconf(void)
{
/* DSS */
MUX_VAL(CP(DSS_DATA0), (IDIS | PTD | DIS | M0)); /*DSS_DATA0*/
MUX_VAL(CP(DSS_DATA1), (IDIS | PTD | DIS | M0)); /*DSS_DATA1*/
MUX_VAL(CP(DSS_DATA2), (IDIS | PTD | DIS | M0)); /*DSS_DATA2*/
MUX_VAL(CP(DSS_DATA3), (IDIS | PTD | DIS | M0)); /*DSS_DATA3*/
MUX_VAL(CP(DSS_DATA4), (IDIS | PTD | DIS | M0)); /*DSS_DATA4*/
MUX_VAL(CP(DSS_DATA5), (IDIS | PTD | DIS | M0)); /*DSS_DATA5*/
MUX_VAL(CP(DSS_DATA18), (IDIS | PTD | DIS | M0)); /*DSS_DATA18*/
MUX_VAL(CP(DSS_DATA19), (IDIS | PTD | DIS | M0)); /*DSS_DATA19*/
MUX_VAL(CP(DSS_DATA20), (IDIS | PTD | DIS | M0)); /*DSS_DATA20*/
MUX_VAL(CP(DSS_DATA21), (IDIS | PTD | DIS | M0)); /*DSS_DATA21*/
MUX_VAL(CP(DSS_DATA22), (IDIS | PTD | DIS | M0)); /*DSS_DATA22*/
MUX_VAL(CP(DSS_DATA23), (IDIS | PTD | DIS | M0)); /*DSS_DATA23*/
/* MMC1 */
MUX_VAL(CP(MMC1_DAT4), (IEN | PTU | EN | M0)); /*MMC1_DAT4*/
MUX_VAL(CP(MMC1_DAT5), (IEN | PTU | EN | M0)); /*MMC1_DAT5*/
MUX_VAL(CP(MMC1_DAT6), (IEN | PTU | EN | M0)); /*MMC1_DAT6*/
MUX_VAL(CP(MMC1_DAT7), (IEN | PTU | EN | M0)); /*MMC1_DAT7*/
}
// Voting help summary.
void G_voteHelp(gentity_t *ent, qboolean fShowVote)
{
int i, rows = 0, num_cmds = sizeof(aVoteInfo) / sizeof(aVoteInfo[0]) - 1; // Remove terminator;
int vi[100]; // Just make it large static.
if (fShowVote)
{
CP("print \"\nValid ^3callvote^7 commands are:\n^3----------------------------\n\"");
}
for (i = 0; i < num_cmds; i++)
{
if (aVoteInfo[i].dwGameTypes & (1 << g_gametype.integer))
{
vi[rows++] = i;
}
}
num_cmds = rows;
rows = num_cmds / HELP_COLUMNS;
if (num_cmds % HELP_COLUMNS)
{
rows++;
}
if (rows < 0)
{
return;
}
for (i = 0; i < rows; i++)
{
if (i + rows * 3 + 1 <= num_cmds)
{
G_refPrintf(ent, "^5%-17s%-17s%-17s%-17s", aVoteInfo[vi[i]].pszVoteName,
aVoteInfo[vi[i + rows]].pszVoteName,
aVoteInfo[vi[i + rows * 2]].pszVoteName,
aVoteInfo[vi[i + rows * 3]].pszVoteName);
}
else if (i + rows * 2 + 1 <= num_cmds)
{
G_refPrintf(ent, "^5%-17s%-17s%-17s", aVoteInfo[vi[i]].pszVoteName,
aVoteInfo[vi[i + rows]].pszVoteName,
aVoteInfo[vi[i + rows * 2]].pszVoteName);
}
else if (i + rows + 1 <= num_cmds)
{
G_refPrintf(ent, "^5%-17s%-17s", aVoteInfo[vi[i]].pszVoteName,
aVoteInfo[vi[i + rows]].pszVoteName);
}
else
{
G_refPrintf(ent, "^5%-17s", aVoteInfo[vi[i]].pszVoteName);
}
}
if (fShowVote)
{
CP("print \"\nUsage: ^3\\callvote <command> <params>\n^7For current settings/help, use: ^3\\callvote <command> ?\n\n\"");
}
return;
}
// Add a player entity to another player's multiview list
void G_smvAddView(gentity_t *ent, int pID)
{
int i;
mview_t *mv = NULL;
gentity_t *v;
if (pID >= MAX_MVCLIENTS || G_smvLocateEntityInMVList(ent, pID, qfalse))
{
return;
}
for (i = 0; i < MULTIVIEW_MAXVIEWS; i++)
{
if (!ent->client->pers.mv[i].fActive)
{
mv = &ent->client->pers.mv[i];
break;
}
}
if (mv == NULL)
{
CP(va("print \"[lof]** [lon]Sorry, no more MV slots available (all[lof] %d [lon]in use)[lof]\n\"", MULTIVIEW_MAXVIEWS));
return;
}
mv->camera = G_Spawn();
if (mv->camera == NULL)
{
return;
}
if (ent->client->sess.sessionTeam == TEAM_SPECTATOR && /*ent->client->sess.sessionTeam != TEAM_SPECTATOR ||*/
ent->client->sess.spectatorState == SPECTATOR_FOLLOW)
{
SetTeam(ent, "s", qtrue, -1, -1, qfalse);
}
else if (ent->client->sess.sessionTeam != TEAM_SPECTATOR && !(ent->client->ps.pm_flags & PMF_LIMBO))
{
limbo(ent, qtrue);
}
ent->client->ps.clientNum = ent - g_entities;
ent->client->sess.spectatorState = SPECTATOR_FREE;
ent->client->pers.mvCount++;
mv->fActive = qtrue;
mv->entID = pID;
v = mv->camera;
v->classname = "misc_portal_surface";
v->r.svFlags = SVF_PORTAL | SVF_SINGLECLIENT; // Only merge snapshots for the target client
v->r.singleClient = ent->s.number;
v->s.eType = ET_PORTAL;
VectorClear(v->r.mins);
VectorClear(v->r.maxs);
trap_LinkEntity(v);
v->target_ent = &g_entities[pID];
v->TargetFlag = pID;
v->tagParent = ent;
G_smvUpdateClientCSList(ent);
}
// ************** PLAYERS
//
// Show client info
void G_players_cmd(gentity_t *ent, unsigned int dwCommand, qboolean fValue)
{
int i, idnum, max_rate, cnt=0, tteam;
int user_rate, user_snaps, bots = 0;
gclient_t *cl;
gentity_t *cl_ent;
char n2[MAX_NETNAME], ready[16], ref[16], ign[16], rate[256];
char *s, *tc, *coach, userinfo[MAX_INFO_STRING];
if(g_gamestate.integer == GS_PLAYING) {
if(ent) {
CP("print \"\n^3 ID^1 : ^3Player Nudge Rate MaxPkts Snaps\n\"");
CP( "print \"^1-----------------------------------------------------------^7\n\"");
} else {
G_Printf(" ID : Player Nudge Rate MaxPkts Snaps\n");
G_Printf("-----------------------------------------------------------\n");
}
} else {
if(ent) {
CP("print \"\n^3Status^1 : ^3ID^1 : ^3Player Nudge Rate MaxPkts Snaps\n\"");
CP( "print \"^1---------------------------------------------------------------------^7\n\"");
} else {
G_Printf("Status : ID : Player Nudge Rate MaxPkts Snaps\n");
G_Printf("---------------------------------------------------------------------\n");
}
}
max_rate = trap_Cvar_VariableIntegerValue("sv_maxrate");
for(i=0; i<level.numConnectedClients; i++) {
idnum = level.sortedClients[i];//level.sortedNames[i];
cl = &level.clients[idnum];
cl_ent = g_entities + idnum;
SanitizeString(cl->pers.netname, n2, qtrue);
n2[26] = 0;
ref[0] = 0;
ign[0] = 0;
ready[0] = 0;
// Rate info
if(cl_ent->r.svFlags & SVF_BOT) {
strcpy(rate, va("%s%s%s%s", "[BOT]", " -----", " --", " --"));
bots++;
} else if(cl->pers.connected == CON_CONNECTING) {
strcpy(rate, va("%s", "^3>>> CONNECTING <<<"));
} else {
trap_GetUserinfo( idnum, userinfo, sizeof(userinfo));
s = Info_ValueForKey( userinfo, "rate" );
user_rate = (max_rate > 0 && atoi(s) > max_rate) ? max_rate : atoi(s);
s = Info_ValueForKey( userinfo, "snaps" );
user_snaps = atoi(s);
strcpy(rate, va("%5d%6d%9d%7d", cl->pers.clientTimeNudge, user_rate, cl->pers.clientMaxPackets, user_snaps));
}
if(g_gamestate.integer != GS_PLAYING) {
// Dens: bots aren't counted, but specs are since changeset 1469
if((g_entities[idnum].r.svFlags & SVF_BOT) || cl->pers.connected == CON_CONNECTING)
strcpy(ready, ((ent) ? "^5--------^1 :" : "-------- :"));
else if(cl->pers.ready)
strcpy(ready, ((ent) ? "^3(READY)^1 :" : "(READY) :"));
else
strcpy(ready, ((ent) ? "NOTREADY^1 :" : "NOTREADY :"));
}
if(cl->sess.referee) strcpy(ref, "REF ");
// pheno: mark ignored clients
if ( COM_BitCheck(ent->client->sess.ignoreClients, idnum) ) {
strcpy(ign, (( ent ) ? "^8I" : "I"));
}
if(cl->sess.coach_team) {
tteam = cl->sess.coach_team;
coach = (ent) ? "^3C" : "C";
} else {
tteam = cl->sess.sessionTeam;
coach = " ";
}
tc = (ent) ? "^7 " : " ";
if(g_gametype.integer >= GT_WOLF) {
if(tteam == TEAM_AXIS) tc = (ent) ? "^1X^7" : "X";
if(tteam == TEAM_ALLIES) tc = (ent) ? "^4L^7" : "L";
}
if(ent) CP(va("print \"%s%s%2d%s^1:%s %-26s^7%s ^3%s%s\n\"", ready, tc, idnum, coach, ((ref[0])?"^3":"^7"), n2, rate, ref, ign));
else G_Printf("%s%s%2d%s: %-26s%s %s%s\n", ready, tc, idnum, coach, n2, rate, ref, ign);
cnt++;
}
if(ent) CP(va("print \"\n^3%2d^7 total players (^3%2d^7 humans, ^3%2d^7 bots)\n\n\"",
cnt, cnt - bots, bots));
else G_Printf("\n%2d total players (%2d humans, %2d bots\n\n", cnt, cnt - bots, bots);
// Team speclock info
if(g_gametype.integer >= GT_WOLF) {
for(i=TEAM_AXIS; i<=TEAM_ALLIES; i++) {
if(teamInfo[i].spec_lock) {
if(ent) CP(va("print \"** %s team is speclocked.\n\"", aTeams[i]));
else G_Printf("** %s team is speclocked.\n", aTeams[i]);
}
}
}
}
/*
* Get the argument words for a command into genbuf
* expanding # and %.
*/
int
getargs(void)
{
register int c;
register char *cp, *fp;
static char fpatbuf[32]; /* hence limit on :next +/pat */
pastwh();
if (peekchar() == '+') {
for (cp = fpatbuf;;) {
c = *cp++ = ex_getchar();
if (cp >= &fpatbuf[sizeof(fpatbuf)])
error("Pattern too long");
if (c == '\\' && isspace(peekchar()))
c = ex_getchar();
if (c == EOF || isspace(c)) {
ungetchar(c);
*--cp = 0;
firstpat = &fpatbuf[1];
break;
}
}
}
if (skipend())
return (0);
CP(genbuf, "echo "); cp = &genbuf[5];
for (;;) {
c = ex_getchar();
if (endcmd(c)) {
ungetchar(c);
break;
}
switch (c) {
case '\\':
if (any(peekchar(), "#%|"))
c = ex_getchar();
/* fall into... */
default:
if (cp > &genbuf[LBSIZE - 2])
flong:
error("Argument buffer overflow");
*cp++ = c;
break;
case '#':
fp = altfile;
if (*fp == 0)
error("No alternate filename@to substitute for #");
goto filexp;
case '%':
fp = savedfile;
if (*fp == 0)
error("No current filename@to substitute for %%");
filexp:
while (*fp) {
if (cp > &genbuf[LBSIZE - 2])
goto flong;
*cp++ = *fp++;
}
break;
}
}
*cp = 0;
return (1);
}
/*
* Parse file name for command encoded by comm.
* If comm is E then command is doomed and we are
* parsing just so user won't have to retype the name.
*/
void
filename(int comm)
{
register int c = comm, d;
register int i;
d = ex_getchar();
if (endcmd(d)) {
if (savedfile[0] == 0 && comm != 'f')
error("No file|No current filename");
CP(file, savedfile);
wasalt = (isalt > 0) ? isalt-1 : 0;
isalt = 0;
oldadot = altdot;
if (c == 'e' || c == 'E')
altdot = lineDOT();
if (d == EOF)
ungetchar(d);
} else {
ungetchar(d);
getone();
eol();
if (savedfile[0] == 0 && c != 'E' && c != 'e') {
c = 'e';
edited = 0;
}
wasalt = strcmp(file, altfile) == 0;
oldadot = altdot;
switch (c) {
case 'f':
edited = 0;
/* fall into ... */
case 'e':
if (savedfile[0]) {
altdot = lineDOT();
CP(altfile, savedfile);
}
CP(savedfile, file);
break;
default:
if (file[0]) {
if (c != 'E')
altdot = lineDOT();
CP(altfile, file);
}
break;
}
}
if ((hush && comm != 'f') || comm == 'E')
return;
if (file[0] != 0) {
lprintf("\"%s\"", file);
if (comm == 'f') {
if (value(READONLY))
ex_printf(" [Read only]");
if (!edited)
ex_printf(" [Not edited]");
if (tchng)
ex_printf(" [Modified]");
}
flush();
} else
ex_printf("No file ");
if (comm == 'f') {
if (!(i = lineDOL()))
i++;
ex_printf(" line %d of %d --%ld%%--", lineDOT(), lineDOL(),
(long) 100 * lineDOT() / i);
}
}
// Shows best/worst accuracy for all weapons, or sorted
// accuracies for a single weapon.
void G_weaponRankings_cmd(gentity_t * ent, unsigned int dwCommand, qboolean state)
{
gclient_t *cl;
int c = 0, i, wBestAcc;
unsigned int shots; // CHRUKER: b068 - unsigned
char z[MAX_STRING_CHARS];
if(trap_Argc() < 2)
{
G_weaponStatsLeaders_cmd(ent, state, qfalse);
return;
}
wBestAcc = (state) ? 0 : 99999;
// Find the weapon
trap_Argv(1, z, sizeof(z));
if((iWeap = atoi(z)) == 0 || iWeap < WS_KNIFE || iWeap >= WS_MAX)
{
for(iWeap = WS_SYRINGE; iWeap >= WS_KNIFE; iWeap--)
{
if(!Q_stricmp(z, aWeaponInfo[iWeap].pszCode))
{
break;
}
}
}
if(iWeap < WS_KNIFE)
{
G_commandHelp(ent, (state) ? "topshots" : "bottomshots", dwCommand);
Q_strncpyz(z, "^3Available weapon codes:^7\n", sizeof(z));
for(i = WS_KNIFE; i < WS_MAX; i++)
{
Q_strcat(z, sizeof(z), va(" %s - %s\n", aWeaponInfo[i].pszCode, aWeaponInfo[i].pszName));
}
CP(va("print \"%s\"", z));
return;
}
memcpy(&level.sortedStats, &level.sortedClients, sizeof(level.sortedStats));
qsort(level.sortedStats, level.numConnectedClients, sizeof(level.sortedStats[0]), SortStats);
z[0] = 0;
for(i = 0; i < level.numConnectedClients; i++)
{
cl = &level.clients[level.sortedStats[i]];
if(cl->sess.sessionTeam == TEAM_SPECTATOR)
{
continue;
}
shots = cl->sess.aWeaponStats[iWeap].atts;
if(shots >= cQualifyingShots[iWeap])
{
float acc = (float)(cl->sess.aWeaponStats[iWeap].hits * 100.0) / (float)shots;
c++;
wBestAcc = (((state) ? acc : wBestAcc) > ((state) ? wBestAcc : acc)) ? (int)acc : wBestAcc;
Q_strcat(z, sizeof(z), va(" %d %d %d %d %d", level.sortedStats[i],
cl->sess.aWeaponStats[iWeap].hits,
shots, cl->sess.aWeaponStats[iWeap].kills, cl->sess.aWeaponStats[iWeap].deaths));
}
}
CP(va("astats%s %d %d %d%s", ((state) ? "" : "b"), c, iWeap, wBestAcc, z));
}
// Request for ref status or lists ref commands.
void G_ref_cmd(gentity_t *ent, unsigned int dwCommand, qboolean fValue)
{
char arg[MAX_TOKEN_CHARS];
// Roll through ref commands if already a ref
if (ent == NULL || ent->client->sess.referee)
{
voteInfo_t votedata;
trap_Argv(1, arg, sizeof(arg));
memcpy(&votedata, &level.voteInfo, sizeof(voteInfo_t));
if (Cmd_CallVote_f(ent, 0, qtrue))
{
memcpy(&level.voteInfo, &votedata, sizeof(voteInfo_t));
return;
}
else
{
memcpy(&level.voteInfo, &votedata, sizeof(voteInfo_t));
if (G_refCommandCheck(ent, arg))
{
return;
}
else
{
G_refHelp_cmd(ent);
}
}
return;
}
if (ent)
{
if (!Q_stricmp(refereePassword.string, "none") || !refereePassword.string[0])
{
CP("cpm \"Sorry, referee status disabled on this server.\n\"");
return;
}
if (trap_Argc() < 2)
{
CP("cpm \"Usage: ref [password]\n\"");
return;
}
trap_Argv(1, arg, sizeof(arg));
if (Q_stricmp(arg, refereePassword.string))
{
CP("cpm \"Invalid referee password!\n\"");
return;
}
ent->client->sess.referee = 1;
ent->client->sess.spec_invite = TEAM_AXIS | TEAM_ALLIES;
AP(va("cp \"%s\n^3has become a referee\n\"", ent->client->pers.netname));
ClientUserinfoChanged(ent - g_entities);
}
}
// ************** PAUSE / UNPAUSE
//
// Pause/unpause a match.
void G_pause_cmd(gentity_t * ent, unsigned int dwCommand, qboolean fPause)
{
char *status[2] = { "^5UN", "^1" };
if(team_nocontrols.integer)
{
G_noTeamControls(ent);
return;
}
if((PAUSE_UNPAUSING >= level.match_pause && !fPause) || (PAUSE_NONE != level.match_pause && fPause))
{
CP(va("print \"The match is already %sPAUSED^7!\n\"", status[fPause]));
return;
}
// Alias for referees
if(ent->client->sess.referee)
{
G_refPause_cmd(ent, fPause);
}
else
{
int tteam = G_teamID(ent);
if(!G_cmdDebounce(ent, aCommandInfo[dwCommand].pszCommandName))
{
return;
}
// Trigger the auto-handling of pauses
if(fPause)
{
if(0 == teamInfo[tteam].timeouts)
{
CP("cpm \"^3Your team has no more timeouts remaining!\n\"");
return;
}
else
{
teamInfo[tteam].timeouts--;
level.match_pause = tteam + 128;
G_globalSound("sound/misc/referee.wav");
G_spawnPrintf(DP_PAUSEINFO, level.time + 15000, NULL);
AP(va
("print \"^3Match is ^1PAUSED^3!\n^7[%s^7: - %d Timeouts Remaining]\n\"", aTeams[tteam],
teamInfo[tteam].timeouts));
AP(va("cp \"^3Match is ^1PAUSED^3! (%s^3)\n\"", aTeams[tteam])); // CHRUKER: b040 - Was only sending this to the client sending the command
level.server_settings |= CV_SVS_PAUSE;
trap_SetConfigstring(CS_SERVERTOGGLES, va("%d", level.server_settings));
}
}
else if(tteam + 128 != level.match_pause)
{
CP("cpm \"^3Your team didn't call the timeout!\n\"");
return;
}
else
{
AP("print \"^3Match is ^5UNPAUSED^3 ... resuming in 10 seconds!\n\""); // CHRUKER: b068 - Had extra linebreaks, before and after.
level.match_pause = PAUSE_UNPAUSING;
G_globalSound("sound/osp/prepare.wav");
G_spawnPrintf(DP_UNPAUSING, level.time + 10, NULL);
}
}
}
double Math::Triangle::distance(const Point2D& p, Point2D* closestPoint)
{
//Source is: http://wonderfl.net/c/b27F
Vector2D AB(_b.x - _a.x, _b.y - _a.y);
Vector2D AP(p.x - _a.x, p.y - _a.y);
double ABXAP = (AB.x * AP.y) - (AB.y * AP.x);
Vector2D BC(_c.x - _b.x, _c.y - _b.y);
Vector2D BP(p.x - _b.x, p.y - _b.y);
double BCXBP = (BC.x * BP.y) - (BC.y * BP.x);
Vector2D CA(_a.x - _c.x, _a.y - _c.y);
Vector2D CP(p.x - _c.x, p.y - _c.y);
double CAXCP = (CA.x * CP.y) - (CA.y * CP.x);
double distance = 0;
//+++ //inside
if (ABXAP >= 0 && BCXBP >= 0 && CAXCP >=0)
{
if(closestPoint) {
closestPoint->x = p.x;
closestPoint->y = p.y;
}
}
//-+- //vertex
else if (ABXAP < 0 && BCXBP >= 0 && CAXCP < 0)
{
distance = AP.x * AP.x + AP.y * AP.y;
if(closestPoint) {
closestPoint->x = _a.x;
closestPoint->y = _a.y;
}
}
//--+ //vertex
else if (ABXAP < 0 && BCXBP < 0 && CAXCP >= 0)
{
distance = BP.x * BP.x + BP.y * BP.y;
if(closestPoint) {
closestPoint->x = _b.x;
closestPoint->y = _b.y;
}
}
//+-- //vertex
else if (ABXAP >= 0 && BCXBP < 0 && CAXCP < 0)
{
distance = CP.x * CP.x + CP.y * CP.y;
if(closestPoint) {
closestPoint->x = _c.x;
closestPoint->y = _c.y;
}
}
//-++ //edge
else if (ABXAP < 0 && BCXBP >= 0 && CAXCP >= 0)
{
double wd = ((AB.x * AP.x) + (AB.y * AP.y) ) / ((AB.x * AB.x) + (AB.y * AB.y));
if (wd < 0) {
wd = 0;
}
if (wd > 1) {
wd = 1;
}
Point2D r;
r.x = _a.x + (_b.x - _a.x) * wd;
r.y = _a.y + (_b.y - _a.y) * wd;
if (closestPoint) {
closestPoint->x = r.x;
closestPoint->y = r.y;
}
r.x = p.x - r.x;
r.y = p.y - r.y;
distance = r.x * r.x + r.y * r.y;
}
//+-+ //edge
else if (ABXAP >= 0 && BCXBP < 0 && CAXCP >= 0)
{
double wd = ((BC.x * BP.x) + (BC.y * BP.y) ) / ((BC.x * BC.x) + (BC.y * BC.y));
if (wd < 0) {
wd = 0;
}
if (wd > 1) {
wd = 1;
}
Point2D r;
r.x = _b.x + (_c.x - _b.x) * wd;
r.y = _b.y + (_c.y - _b.y) * wd;
if (closestPoint) {
closestPoint->x = r.x;
closestPoint->y = r.y;
}
r.x = p.x - r.x;
r.y = p.y - r.y;
distance = r.x * r.x + r.y * r.y;
}
//++- //edge
else if (ABXAP >= 0 && BCXBP >= 0 && CAXCP < 0)
{
double wd = ((CA.x * CP.x) + (CA.y * CP.y) ) / ((CA.x * CA.x) + (CA.y * CA.y));
if (wd < 0) {
wd = 0;
}
if (wd > 1) {
wd = 1;
}
Point2D r;
r.x = _c.x + (_a.x - _c.x) * wd;
r.y = _c.y + (_a.y - _c.y) * wd;
if (closestPoint) {
closestPoint->x = r.x;
closestPoint->y = r.y;
}
r.x = p.x - r.x;
r.y = p.y - r.y;
distance = r.x * r.x + r.y * r.y;
}
return distance;
}
void
vappend(int ch, int cnt, int indent)
/* int ch; /\* mjm: char --> int */
{
register int i = 0;
register char *gcursor;
bool escape;
int repcnt, savedoomed;
short oldhold = hold;
#ifdef SIGWINCH
sigset_t set, oset;
#endif
/*
* Before a move in hardopen when the line is dirty
* or we are in the middle of the printed representation,
* we retype the line to the left of the cursor so the
* insert looks clean.
*/
if (ch != 'o' && state == HARDOPEN && (rubble || !ateopr())) {
rubble = 1;
gcursor = cursor;
i = *gcursor;
*gcursor = ' ';
wcursor = gcursor;
vmove(0);
*gcursor = i;
}
vaifirst = indent == 0;
showmode(ch);
/*
* Handle replace character by (eventually)
* limiting the number of input characters allowed
* in the vgetline routine.
*/
if (ch == 'r')
repcnt = 2;
else
repcnt = 0;
/*
* If an autoindent is specified, then
* generate a mixture of blanks to tabs to implement
* it and place the cursor after the indent.
* Text read by the vgetline routine will be placed in genbuf,
* so the indent is generated there.
*/
if (value(AUTOINDENT) && indent != 0) {
gcursor = genindent(indent);
*gcursor = 0;
vgotoCL(qcolumn(cursor + skipright(cursor, linebuf), genbuf));
} else {
gcursor = genbuf;
*gcursor = 0;
if (ch == 'o')
vfixcurs();
}
/*
* Prepare for undo. Pointers delimit inserted portion of line.
*/
vUA1 = vUA2 = cursor;
/*
* If we are not in a repeated command and a ^@ comes in
* then this means the previous inserted text.
* If there is none or it was too long to be saved,
* then beep() and also arrange to undo any damage done
* so far (e.g. if we are a change.)
*/
if ((vglobp && *vglobp == 0) || peekbr()) {
if ((INS[0] & (QUOTE|TRIM)) == OVERBUF) {
beep();
if (!splitw)
ungetkey('u');
doomed = 0;
hold = oldhold;
showmode(0);
return;
}
/*
* Unread input from INS.
* An escape will be generated at end of string.
* Hold off n^^2 type update on dumb terminals.
*/
vglobp = INS;
hold |= HOLDQIK;
} else if (vglobp == 0)
/*
* Not a repeated command, get
* a new inserted text for repeat.
*/
INS[0] = 0;
/*
* For wrapmargin to hack away second space after a '.'
* when the first space caused a line break we keep
* track that this happened in gobblebl, which says
* to gobble up a blank silently.
*/
gobblebl = 0;
#ifdef SIGWINCH
sigemptyset(&set);
sigaddset(&set, SIGWINCH);
sigprocmask(SIG_BLOCK, &set, &oset);
#endif
/*
* Text gathering loop.
* New text goes into genbuf starting at gcursor.
* cursor preserves place in linebuf where text will eventually go.
*/
if (*cursor == 0 || state == CRTOPEN)
hold |= HOLDROL;
for (;;) {
if (ch == 'r' && repcnt == 0)
escape = 0;
else {
gcursor = vgetline(repcnt, gcursor, &escape, ch);
/*
* After an append, stick information
* about the ^D's and ^^D's and 0^D's in
* the repeated text buffer so repeated
* inserts of stuff indented with ^D as backtab's
* can work.
*/
if (HADUP)
addc('^');
else if (HADZERO)
addc('0');
while (CDCNT > 0)
#ifndef BIT8
addc('\204'), CDCNT--;
#else
addc(OVERBUF), CDCNT--;
#endif
if (gobbled)
addc(' ');
addtext(ogcursor);
}
repcnt = 0;
/*
* Smash the generated and preexisting indents together
* and generate one cleanly made out of tabs and spaces
* if we are using autoindent.
*/
if (!vaifirst && value(AUTOINDENT)) {
i = fixindent(indent);
if (!HADUP)
indent = i;
gcursor = strend(genbuf);
}
/*
* Limit the repetition count based on maximum
* possible line length; do output implied
* by further count (> 1) and cons up the new line
* in linebuf.
*/
cnt = vmaxrep(ch, cnt);
CP(gcursor + skipright(ogcursor, gcursor), cursor);
do {
CP(cursor, genbuf);
if (cnt > 1) {
int oldhold = hold;
Outchar = vinschar;
hold |= HOLDQIK;
ex_printf("%s", genbuf);
hold = oldhold;
Outchar = vputchar;
}
cursor += gcursor - genbuf;
} while (--cnt > 0);
endim();
vUA2 = cursor;
if (escape != '\n')
CP(cursor, gcursor + skipright(ogcursor, gcursor));
/*
* If doomed characters remain, clobber them,
* and reopen the line to get the display exact.
*/
if (state != HARDOPEN) {
DEPTH(vcline) = 0;
savedoomed = doomed;
if (doomed > 0) {
register int cind = cindent();
physdc(cind, cind + doomed);
doomed = 0;
}
i = vreopen(LINE(vcline), lineDOT(), vcline);
#ifdef TRACE
if (trace)
fprintf(trace, "restoring doomed from %d to %d\n", doomed, savedoomed);
#endif
if (ch == 'R')
doomed = savedoomed;
}
/*
* All done unless we are continuing on to another line.
*/
if (escape != '\n')
break;
/*
* Set up for the new line.
* First save the current line, then construct a new
* first image for the continuation line consisting
* of any new autoindent plus the pushed ahead text.
*/
showmode(0);
killU();
addc(gobblebl ? ' ' : '\n');
vsave();
cnt = 1;
if (value(AUTOINDENT)) {
#ifdef LISPCODE
if (value(LISP))
indent = lindent(dot + 1);
else
#endif
if (!HADUP && vaifirst)
indent = whitecnt(linebuf);
vaifirst = 0;
strcLIN(vpastwh(gcursor + 1));
gcursor = genindent(indent);
*gcursor = 0;
if (gcursor + strlen(linebuf) > &genbuf[LBSIZE - 2])
gcursor = genbuf;
CP(gcursor, linebuf);
} else {
CP(genbuf, gcursor + skipright(ogcursor, gcursor));
gcursor = genbuf;
}
/*
* If we started out as a single line operation and are now
* turning into a multi-line change, then we had better yank
* out dot before it changes so that undo will work
* correctly later.
*/
if (FIXUNDO && vundkind == VCHNG) {
vremote(1, yank, 0);
undap1--;
}
/*
* Now do the append of the new line in the buffer,
* and update the display. If slowopen
* we don't do very much.
*/
vdoappend(genbuf);
vundkind = VMANYINS;
vcline++;
if (state != VISUAL)
vshow(dot, NOLINE);
else {
i += LINE(vcline - 1);
vopen(dot, i);
if (value(SLOWOPEN))
vscrap();
else
vsync1(LINE(vcline));
}
strcLIN(gcursor);
*gcursor = 0;
cursor = linebuf;
vgotoCL(qcolumn(cursor + skipleft(ogcursor, cursor), genbuf));
showmode(ch);
}
/*
* All done with insertion, position the cursor
* and sync the screen.
*/
showmode(0);
hold = oldhold;
if (cursor > linebuf)
cursor += skipleft(linebuf, cursor);
if (state != HARDOPEN)
vsyncCL();
else if (cursor > linebuf)
back1();
doomed = 0;
wcursor = cursor;
vmove(0);
#ifdef SIGWINCH
sigprocmask(SIG_SETMASK, &oset, NULL);
#endif
}
void cbconv(struct bsdconv_instance *ins){
char *p;
int i,j;
struct bsdconv_phase *this_phase=THIS_PHASE(ins);
struct my_s *t=this_phase->codec[this_phase->index].priv;
char d;
for(;this_phase->i<this_phase->curr->len;this_phase->i+=1){
d=CP(this_phase->curr->data)[this_phase->i];
switch(t->status){
case 0:
if(d=='%'){
t->status=10;
continue;
}else if(d=='\\'){
t->status=11;
continue;
}else{
DEADEND();
}
case 10:
if(d=='u'){
t->status=40;
continue;
}else if(hex[(unsigned char)d]==-1){
DEADEND();
}else{
t->status=21;
t->buf[0]=hex[(unsigned char)d];
continue;
}
break;
case 11:
if(d=='u'){
t->status=40;
continue;
}else if(d=='x'){
t->status=20;
continue;
}else if(oct[(unsigned char)d]==-1){
DEADEND();
}else{
t->status=31;
t->buf[0]=oct[(unsigned char)d];
continue;
}
break;
case 20:
if(hex[(unsigned char)d]==-1){
DEADEND();
}else{
t->status=21;
t->buf[0]=hex[(unsigned char)d];
continue;
}
break;
case 21:
if(hex[(unsigned char)d]==-1){
DEADEND();
}else{
t->buf[0]*=16;
t->buf[0]+=hex[(unsigned char)d];
DATA_MALLOC(ins, this_phase->data_tail->next);
this_phase->data_tail=this_phase->data_tail->next;
this_phase->data_tail->next=NULL;
this_phase->data_tail->flags=F_FREE;
this_phase->data_tail->len=2;
p=this_phase->data_tail->data=malloc(2);
p[0]=0x03;
p[1]=t->buf[0];
this_phase->state.status=NEXTPHASE;
t->status=0;
return;
}
break;
case 31:
if(oct[(unsigned char)d]==-1){
DEADEND();
}else{
t->status=32;
t->buf[0]*=8;
t->buf[0]+=oct[(unsigned char)d];
continue;
}
break;
case 32:
if(oct[(unsigned char)d]==-1){
DEADEND();
}else{
i=t->buf[0];
i*=8;
i+=oct[(unsigned char)d];
if(i>377)
DEADEND();
t->buf[0]=i;
DATA_MALLOC(ins, this_phase->data_tail->next);
this_phase->data_tail=this_phase->data_tail->next;
this_phase->data_tail->next=NULL;
this_phase->data_tail->flags=F_FREE;
this_phase->data_tail->len=2;
p=this_phase->data_tail->data=malloc(2);
p[0]=0x03;
p[1]=t->buf[0];
this_phase->state.status=NEXTPHASE;
t->status=0;
return;
}
break;
case 40:
if(hex[(unsigned char)d]==-1){
DEADEND();
}else{
t->status=41;
t->buf[0]=hex[(unsigned char)d];
continue;
}
break;
case 41:
if(hex[(unsigned char)d]==-1){
DEADEND();
}else{
t->status=42;
t->buf[0]*=16;
t->buf[0]+=hex[(unsigned char)d];
continue;
}
break;
case 42:
if(hex[(unsigned char)d]==-1){
DEADEND();
}else{
t->status=43;
t->buf[1]=hex[(unsigned char)d];
continue;
}
break;
case 43:
if(hex[(unsigned char)d]==-1){
DEADEND();
}else{
i=0;
t->buf[1]*=16;
t->buf[1]+=hex[(unsigned char)d];
while(t->buf[i]==0)++i;
DATA_MALLOC(ins, this_phase->data_tail->next);
this_phase->data_tail=this_phase->data_tail->next;
this_phase->data_tail->next=NULL;
this_phase->data_tail->flags=F_FREE;
this_phase->data_tail->len=3-i;
p=this_phase->data_tail->data=malloc(3-i);
p[0]=0x01;
for(j=1;i<2;++i,++j){
p[j]=t->buf[i];
}
this_phase->state.status=NEXTPHASE;
t->status=0;
return;
}
break;
}
}
this_phase->state.status=CONTINUE;
return;
}
/*
* Write a file.
*/
void
wop(bool dofname)
/* bool dofname; / * if 1 call filename, else use savedfile */
{
register int c, exclam, nonexist;
line *saddr1, *saddr2;
struct stat stbuf;
c = 0;
exclam = 0;
if (dofname) {
if (peekchar() == '!')
exclam++, ignchar();
ignore(skipwh());
while (peekchar() == '>')
ignchar(), c++, ignore(skipwh());
if (c != 0 && c != 2)
error("Write forms are 'w' and 'w>>'");
filename('w');
} else {
if (savedfile[0] == 0)
error("No file|No current filename");
saddr1=addr1;
saddr2=addr2;
addr1=one;
addr2=dol;
CP(file, savedfile);
if (inopen) {
vclrech(0);
splitw++;
}
lprintf("\"%s\"", file);
}
nonexist = stat(file, &stbuf);
switch (c) {
case 0:
if (!exclam && (!value(WRITEANY) || value(READONLY)))
switch (edfile()) {
case NOTEDF:
if (nonexist)
break;
if ((stbuf.st_mode & S_IFMT) == S_IFCHR) {
if (samei(&stbuf, "/dev/null"))
break;
if (samei(&stbuf, "/dev/tty"))
break;
}
io = open(file, O_WRONLY);
if (io < 0)
syserror();
if (!isatty(io))
serror(" File exists| File exists - use \"w! %s\" to overwrite", file);
close(io);
break;
case EDF:
if (value(READONLY))
error(" File is read only");
break;
case PARTBUF:
if (value(READONLY))
error(" File is read only");
error(" Use \"w!\" to write partial buffer");
}
cre:
/*
synctmp();
*/
#ifdef V6
io = creat(file, 0644);
#else
io = creat(file, 0666);
#endif
if (io < 0)
syserror();
writing = 1;
if (hush == 0) {
if (nonexist)
ex_printf(" [New file]");
else if (value(WRITEANY) && edfile() != EDF)
ex_printf(" [Existing file]");
}
break;
case 2:
io = open(file, O_WRONLY);
if (io < 0) {
if (exclam || value(WRITEANY))
goto cre;
syserror();
}
lseek(io, 0l, SEEK_END);
break;
}
putfile();
ignore(iostats());
if (c != 2 && addr1 == one && addr2 == dol) {
if (eq(file, savedfile))
edited = 1;
ex_sync();
}
if (!dofname) {
addr1 = saddr1;
addr2 = saddr2;
}
writing = 0;
}
/**
* @brief Do the pin muxing required for Board operation.
* We enable ONLY the pins we require to set. OMAP provides pins which do not
* have alternate modes. Such pins done need to be set.
*
* See @ref MUX_VAL for description of the muxing mode.
*
* @return void
*/
static void mux_config(void)
{
/* SDRC_D0 - SDRC_D31 default mux mode is mode0 */
/* GPMC */
MUX_VAL(CP(GPMC_A1), (IDIS | PTD | DIS | M0));
MUX_VAL(CP(GPMC_A2), (IDIS | PTD | DIS | M0));
MUX_VAL(CP(GPMC_A3), (IDIS | PTD | DIS | M0));
MUX_VAL(CP(GPMC_A4), (IDIS | PTD | DIS | M0));
MUX_VAL(CP(GPMC_A5), (IDIS | PTD | DIS | M0));
MUX_VAL(CP(GPMC_A6), (IDIS | PTD | DIS | M0));
MUX_VAL(CP(GPMC_A7), (IDIS | PTD | DIS | M0));
MUX_VAL(CP(GPMC_A8), (IDIS | PTD | DIS | M0));
MUX_VAL(CP(GPMC_A9), (IDIS | PTD | DIS | M0));
MUX_VAL(CP(GPMC_A10), (IDIS | PTD | DIS | M0));
/* D0-D7 default mux mode is mode0 */
MUX_VAL(CP(GPMC_D8), (IEN | PTD | DIS | M0));
MUX_VAL(CP(GPMC_D9), (IEN | PTD | DIS | M0));
MUX_VAL(CP(GPMC_D10), (IEN | PTD | DIS | M0));
MUX_VAL(CP(GPMC_D11), (IEN | PTD | DIS | M0));
MUX_VAL(CP(GPMC_D12), (IEN | PTD | DIS | M0));
MUX_VAL(CP(GPMC_D13), (IEN | PTD | DIS | M0));
MUX_VAL(CP(GPMC_D14), (IEN | PTD | DIS | M0));
MUX_VAL(CP(GPMC_D15), (IEN | PTD | DIS | M0));
MUX_VAL(CP(GPMC_CLK), (IDIS | PTD | DIS | M0));
/* GPMC_NADV_ALE default mux mode is mode0 */
/* GPMC_NOE default mux mode is mode0 */
/* GPMC_NWE default mux mode is mode0 */
/* GPMC_NBE0_CLE default mux mode is mode0 */
MUX_VAL(CP(GPMC_NBE0_CLE), (IDIS | PTD | DIS | M0));
MUX_VAL(CP(GPMC_NBE1), (IEN | PTD | DIS | M0));
MUX_VAL(CP(GPMC_NWP), (IEN | PTD | DIS | M0));
/* GPMC_WAIT0 default mux mode is mode0 */
MUX_VAL(CP(GPMC_WAIT1), (IEN | PTU | EN | M0));
/* SERIAL INTERFACE */
MUX_VAL(CP(UART3_CTS_RCTX), (IEN | PTD | EN | M0));
MUX_VAL(CP(UART3_RTS_SD), (IDIS | PTD | DIS | M0));
MUX_VAL(CP(UART3_RX_IRRX), (IEN | PTD | DIS | M0));
MUX_VAL(CP(UART3_TX_IRTX), (IDIS | PTD | DIS | M0));
MUX_VAL(CP(HSUSB0_CLK), (IEN | PTD | DIS | M0));
MUX_VAL(CP(HSUSB0_STP), (IDIS | PTU | EN | M0));
MUX_VAL(CP(HSUSB0_DIR), (IEN | PTD | DIS | M0));
MUX_VAL(CP(HSUSB0_NXT), (IEN | PTD | DIS | M0));
MUX_VAL(CP(HSUSB0_DATA0), (IEN | PTD | DIS | M0));
MUX_VAL(CP(HSUSB0_DATA1), (IEN | PTD | DIS | M0));
MUX_VAL(CP(HSUSB0_DATA2), (IEN | PTD | DIS | M0));
MUX_VAL(CP(HSUSB0_DATA3), (IEN | PTD | DIS | M0));
MUX_VAL(CP(HSUSB0_DATA4), (IEN | PTD | DIS | M0));
MUX_VAL(CP(HSUSB0_DATA5), (IEN | PTD | DIS | M0));
MUX_VAL(CP(HSUSB0_DATA6), (IEN | PTD | DIS | M0));
MUX_VAL(CP(HSUSB0_DATA7), (IEN | PTD | DIS | M0));
/* I2C1_SCL default mux mode is mode0 */
/* I2C1_SDA default mux mode is mode0 */
/* USB EHCI (port 2) */
MUX_VAL(CP(MCSPI1_CS3), (IEN | PTU | DIS | M3));
MUX_VAL(CP(MCSPI2_CLK), (IEN | PTU | DIS | M3));
MUX_VAL(CP(MCSPI2_SIMO), (IEN | PTU | DIS | M3));
MUX_VAL(CP(MCSPI2_SOMI), (IEN | PTU | DIS | M3));
MUX_VAL(CP(MCSPI2_CS0), (IEN | PTU | DIS | M3));
MUX_VAL(CP(MCSPI2_CS1), (IEN | PTU | DIS | M3));
MUX_VAL(CP(ETK_D10_ES2), (IDIS | PTU | DIS | M3));
MUX_VAL(CP(ETK_D11_ES2), (IDIS | PTU | DIS | M3));
MUX_VAL(CP(ETK_D12_ES2), (IEN | PTU | DIS | M3));
MUX_VAL(CP(ETK_D13_ES2), (IEN | PTU | DIS | M3));
MUX_VAL(CP(ETK_D14_ES2), (IEN | PTU | DIS | M3));
MUX_VAL(CP(ETK_D15_ES2), (IEN | PTU | DIS | M3));
MUX_VAL(CP(UART2_RX), (IEN | PTD | DIS | M4)) /*GPIO_147*/;
/* Expansion card */
MUX_VAL(CP(MMC1_CLK), (IDIS | PTU | EN | M0)); /* MMC1_CLK */
MUX_VAL(CP(MMC1_CMD), (IEN | PTU | EN | M0)); /* MMC1_CMD */
MUX_VAL(CP(MMC1_DAT0), (IEN | PTU | EN | M0)); /* MMC1_DAT0 */
MUX_VAL(CP(MMC1_DAT1), (IEN | PTU | EN | M0)); /* MMC1_DAT1 */
MUX_VAL(CP(MMC1_DAT2), (IEN | PTU | EN | M0)); /* MMC1_DAT2 */
MUX_VAL(CP(MMC1_DAT3), (IEN | PTU | EN | M0)); /* MMC1_DAT3 */
MUX_VAL(CP(MMC1_DAT4), (IEN | PTU | EN | M0)); /* MMC1_DAT4 */
MUX_VAL(CP(MMC1_DAT5), (IEN | PTU | EN | M0)); /* MMC1_DAT5 */
MUX_VAL(CP(MMC1_DAT6), (IEN | PTU | EN | M0)); /* MMC1_DAT6 */
MUX_VAL(CP(MMC1_DAT7), (IEN | PTU | EN | M0)); /* MMC1_DAT7 */
}
/**
* @brief Do the necessary pin muxing required for OMAP3EVM. Some pins in OMAP3
* do not have alternate modes. We don't program these pins.
*
* See @ref MUX_VAL for description of the muxing mode.
*
* @return void
*/
static void mux_config(void)
{
/*
* SDRC
* - SDRC_D0-SDRC_D31: Default MUX mode is mode0.
*/
/*
* GPMC
* - GPMC_D0-GPMC_D7: Default MUX mode is mode0.
* - GPMC_NADV_ALE: Default MUX mode is mode0.
* - GPMC_NOE: Default MUX mode is mode0.
* - GPMC_NWE: Default MUX mode is mode0.
* - GPMC_WAIT0: Default MUX mode is mode0.
*/
MUX_VAL(CP(GPMC_A1), (IDIS | PTD | DIS | M0));
MUX_VAL(CP(GPMC_A2), (IDIS | PTD | DIS | M0));
MUX_VAL(CP(GPMC_A3), (IDIS | PTD | DIS | M0));
MUX_VAL(CP(GPMC_A4), (IDIS | PTD | DIS | M0));
MUX_VAL(CP(GPMC_A5), (IDIS | PTD | DIS | M0));
MUX_VAL(CP(GPMC_A6), (IDIS | PTD | DIS | M0));
MUX_VAL(CP(GPMC_A7), (IDIS | PTD | DIS | M0));
MUX_VAL(CP(GPMC_A8), (IDIS | PTD | DIS | M0));
MUX_VAL(CP(GPMC_A9), (IDIS | PTD | DIS | M0));
MUX_VAL(CP(GPMC_A10), (IDIS | PTD | DIS | M0));
MUX_VAL(CP(GPMC_D8), (IEN | PTD | DIS | M0));
MUX_VAL(CP(GPMC_D9), (IEN | PTD | DIS | M0));
MUX_VAL(CP(GPMC_D10), (IEN | PTD | DIS | M0));
MUX_VAL(CP(GPMC_D11), (IEN | PTD | DIS | M0));
MUX_VAL(CP(GPMC_D12), (IEN | PTD | DIS | M0));
MUX_VAL(CP(GPMC_D13), (IEN | PTD | DIS | M0));
MUX_VAL(CP(GPMC_D14), (IEN | PTD | DIS | M0));
MUX_VAL(CP(GPMC_D15), (IEN | PTD | DIS | M0));
MUX_VAL(CP(GPMC_CLK), (IDIS | PTD | DIS | M0));
MUX_VAL(CP(GPMC_NBE0_CLE), (IDIS | PTD | DIS | M0));
MUX_VAL(CP(GPMC_NBE1), (IEN | PTD | DIS | M0));
MUX_VAL(CP(GPMC_NWP), (IEN | PTD | DIS | M0));
MUX_VAL(CP(GPMC_WAIT1), (IEN | PTU | EN | M0));
/*
* Serial Interface
*/
#if defined(CONFIG_OMAP_UART1)
MUX_VAL(CP(UART1_TX), (IDIS | PTD | DIS | M0));
MUX_VAL(CP(UART1_RTS), (IDIS | PTD | DIS | M0));
MUX_VAL(CP(UART1_CTS), (IEN | PTU | DIS | M0));
MUX_VAL(CP(UART1_RX), (IEN | PTD | DIS | M0));
#elif defined(CONFIG_OMAP_UART3)
MUX_VAL(CP(UART3_CTS_RCTX), (IEN | PTD | EN | M0));
MUX_VAL(CP(UART3_RTS_SD), (IDIS | PTD | DIS | M0));
MUX_VAL(CP(UART3_RX_IRRX), (IEN | PTD | DIS | M0));
MUX_VAL(CP(UART3_TX_IRTX), (IDIS | PTD | DIS | M0));
#endif
}
void G_noTeamControls(gentity_t *ent)
{
CP("cpm \"Team commands not enabled on this server.\n\"");
}
static int
freebsd32_ioctl_pciocgetconf(struct thread *td,
struct freebsd32_ioctl_args *uap, struct file *fp)
{
struct pci_conf_io pci;
struct pci_conf_io32 pci32;
struct pci_match_conf32 pmc32;
struct pci_match_conf32 *pmc32p;
struct pci_match_conf pmc;
struct pci_match_conf *pmcp;
struct pci_conf32 pc32;
struct pci_conf32 *pc32p;
struct pci_conf pc;
struct pci_conf *pcp;
u_int32_t i;
u_int32_t npat_to_convert;
u_int32_t nmatch_to_convert;
vm_offset_t addr;
int error;
if ((error = copyin(uap->data, &pci32, sizeof(pci32))) != 0)
return (error);
CP(pci32, pci, num_patterns);
CP(pci32, pci, offset);
CP(pci32, pci, generation);
npat_to_convert = pci32.pat_buf_len / sizeof(struct pci_match_conf32);
pci.pat_buf_len = npat_to_convert * sizeof(struct pci_match_conf);
pci.patterns = NULL;
nmatch_to_convert = pci32.match_buf_len / sizeof(struct pci_conf32);
pci.match_buf_len = nmatch_to_convert * sizeof(struct pci_conf);
pci.matches = NULL;
if ((error = copyout_map(td, &addr, pci.pat_buf_len)) != 0)
goto cleanup;
pci.patterns = (struct pci_match_conf *)addr;
if ((error = copyout_map(td, &addr, pci.match_buf_len)) != 0)
goto cleanup;
pci.matches = (struct pci_conf *)addr;
npat_to_convert = min(npat_to_convert, pci.num_patterns);
for (i = 0, pmc32p = (struct pci_match_conf32 *)PTRIN(pci32.patterns),
pmcp = pci.patterns;
i < npat_to_convert; i++, pmc32p++, pmcp++) {
if ((error = copyin(pmc32p, &pmc32, sizeof(pmc32))) != 0)
goto cleanup;
CP(pmc32,pmc,pc_sel);
strlcpy(pmc.pd_name, pmc32.pd_name, sizeof(pmc.pd_name));
CP(pmc32,pmc,pd_unit);
CP(pmc32,pmc,pc_vendor);
CP(pmc32,pmc,pc_device);
CP(pmc32,pmc,pc_class);
CP(pmc32,pmc,flags);
if ((error = copyout(&pmc, pmcp, sizeof(pmc))) != 0)
goto cleanup;
}
if ((error = fo_ioctl(fp, PCIOCGETCONF, (caddr_t)&pci,
td->td_ucred, td)) != 0)
goto cleanup;
nmatch_to_convert = min(nmatch_to_convert, pci.num_matches);
for (i = 0, pcp = pci.matches,
pc32p = (struct pci_conf32 *)PTRIN(pci32.matches);
i < nmatch_to_convert; i++, pcp++, pc32p++) {
if ((error = copyin(pcp, &pc, sizeof(pc))) != 0)
goto cleanup;
CP(pc,pc32,pc_sel);
CP(pc,pc32,pc_hdr);
CP(pc,pc32,pc_subvendor);
CP(pc,pc32,pc_subdevice);
CP(pc,pc32,pc_vendor);
CP(pc,pc32,pc_device);
CP(pc,pc32,pc_class);
CP(pc,pc32,pc_subclass);
CP(pc,pc32,pc_progif);
CP(pc,pc32,pc_revid);
strlcpy(pc32.pd_name, pc.pd_name, sizeof(pc32.pd_name));
CP(pc,pc32,pd_unit);
if ((error = copyout(&pc32, pc32p, sizeof(pc32))) != 0)
goto cleanup;
}
CP(pci, pci32, num_matches);
CP(pci, pci32, offset);
CP(pci, pci32, generation);
CP(pci, pci32, status);
error = copyout(&pci32, uap->data, sizeof(pci32));
cleanup:
if (pci.patterns)
copyout_unmap(td, (vm_offset_t)pci.patterns, pci.pat_buf_len);
if (pci.matches)
copyout_unmap(td, (vm_offset_t)pci.matches, pci.match_buf_len);
return (error);
}
/*
* Routine: set_muxconf_regs
* Description: Setting up the configuration Mux registers specific to the
* hardware. Many pins need to be moved from protect to primary
* mode.
*/
static void cm_t3x_set_common_muxconf(void)
{
/* SDRC */
MUX_VAL(CP(SDRC_D0), (IEN | PTD | DIS | M0)); /*SDRC_D0*/
MUX_VAL(CP(SDRC_D1), (IEN | PTD | DIS | M0)); /*SDRC_D1*/
MUX_VAL(CP(SDRC_D2), (IEN | PTD | DIS | M0)); /*SDRC_D2*/
MUX_VAL(CP(SDRC_D3), (IEN | PTD | DIS | M0)); /*SDRC_D3*/
MUX_VAL(CP(SDRC_D4), (IEN | PTD | DIS | M0)); /*SDRC_D4*/
MUX_VAL(CP(SDRC_D5), (IEN | PTD | DIS | M0)); /*SDRC_D5*/
MUX_VAL(CP(SDRC_D6), (IEN | PTD | DIS | M0)); /*SDRC_D6*/
MUX_VAL(CP(SDRC_D7), (IEN | PTD | DIS | M0)); /*SDRC_D7*/
MUX_VAL(CP(SDRC_D8), (IEN | PTD | DIS | M0)); /*SDRC_D8*/
MUX_VAL(CP(SDRC_D9), (IEN | PTD | DIS | M0)); /*SDRC_D9*/
MUX_VAL(CP(SDRC_D10), (IEN | PTD | DIS | M0)); /*SDRC_D10*/
MUX_VAL(CP(SDRC_D11), (IEN | PTD | DIS | M0)); /*SDRC_D11*/
MUX_VAL(CP(SDRC_D12), (IEN | PTD | DIS | M0)); /*SDRC_D12*/
MUX_VAL(CP(SDRC_D13), (IEN | PTD | DIS | M0)); /*SDRC_D13*/
MUX_VAL(CP(SDRC_D14), (IEN | PTD | DIS | M0)); /*SDRC_D14*/
MUX_VAL(CP(SDRC_D15), (IEN | PTD | DIS | M0)); /*SDRC_D15*/
MUX_VAL(CP(SDRC_D16), (IEN | PTD | DIS | M0)); /*SDRC_D16*/
MUX_VAL(CP(SDRC_D17), (IEN | PTD | DIS | M0)); /*SDRC_D17*/
MUX_VAL(CP(SDRC_D18), (IEN | PTD | DIS | M0)); /*SDRC_D18*/
MUX_VAL(CP(SDRC_D19), (IEN | PTD | DIS | M0)); /*SDRC_D19*/
MUX_VAL(CP(SDRC_D20), (IEN | PTD | DIS | M0)); /*SDRC_D20*/
MUX_VAL(CP(SDRC_D21), (IEN | PTD | DIS | M0)); /*SDRC_D21*/
MUX_VAL(CP(SDRC_D22), (IEN | PTD | DIS | M0)); /*SDRC_D22*/
MUX_VAL(CP(SDRC_D23), (IEN | PTD | DIS | M0)); /*SDRC_D23*/
MUX_VAL(CP(SDRC_D24), (IEN | PTD | DIS | M0)); /*SDRC_D24*/
MUX_VAL(CP(SDRC_D25), (IEN | PTD | DIS | M0)); /*SDRC_D25*/
MUX_VAL(CP(SDRC_D26), (IEN | PTD | DIS | M0)); /*SDRC_D26*/
MUX_VAL(CP(SDRC_D27), (IEN | PTD | DIS | M0)); /*SDRC_D27*/
MUX_VAL(CP(SDRC_D28), (IEN | PTD | DIS | M0)); /*SDRC_D28*/
MUX_VAL(CP(SDRC_D29), (IEN | PTD | DIS | M0)); /*SDRC_D29*/
MUX_VAL(CP(SDRC_D30), (IEN | PTD | DIS | M0)); /*SDRC_D30*/
MUX_VAL(CP(SDRC_D31), (IEN | PTD | DIS | M0)); /*SDRC_D31*/
MUX_VAL(CP(SDRC_CLK), (IEN | PTD | DIS | M0)); /*SDRC_CLK*/
MUX_VAL(CP(SDRC_DQS0), (IEN | PTD | DIS | M0)); /*SDRC_DQS0*/
MUX_VAL(CP(SDRC_DQS1), (IEN | PTD | DIS | M0)); /*SDRC_DQS1*/
MUX_VAL(CP(SDRC_DQS2), (IEN | PTD | DIS | M0)); /*SDRC_DQS2*/
MUX_VAL(CP(SDRC_DQS3), (IEN | PTD | DIS | M0)); /*SDRC_DQS3*/
MUX_VAL(CP(SDRC_CKE0), (IDIS | PTU | EN | M0)); /*SDRC_CKE0*/
MUX_VAL(CP(SDRC_CKE1), (IDIS | PTD | DIS | M7)); /*SDRC_CKE1*/
/* GPMC */
MUX_VAL(CP(GPMC_A1), (IDIS | PTU | EN | M0)); /*GPMC_A1*/
MUX_VAL(CP(GPMC_A2), (IDIS | PTU | EN | M0)); /*GPMC_A2*/
MUX_VAL(CP(GPMC_A3), (IDIS | PTU | EN | M0)); /*GPMC_A3*/
MUX_VAL(CP(GPMC_A4), (IDIS | PTU | EN | M0)); /*GPMC_A4*/
MUX_VAL(CP(GPMC_A5), (IDIS | PTU | EN | M0)); /*GPMC_A5*/
MUX_VAL(CP(GPMC_A6), (IDIS | PTU | EN | M0)); /*GPMC_A6*/
MUX_VAL(CP(GPMC_A7), (IDIS | PTU | EN | M0)); /*GPMC_A7*/
MUX_VAL(CP(GPMC_A8), (IDIS | PTU | EN | M0)); /*GPMC_A8*/
MUX_VAL(CP(GPMC_A9), (IDIS | PTU | EN | M0)); /*GPMC_A9*/
MUX_VAL(CP(GPMC_A10), (IDIS | PTU | EN | M0)); /*GPMC_A10*/
MUX_VAL(CP(GPMC_D0), (IEN | PTU | EN | M0)); /*GPMC_D0*/
MUX_VAL(CP(GPMC_D1), (IEN | PTU | EN | M0)); /*GPMC_D1*/
MUX_VAL(CP(GPMC_D2), (IEN | PTU | EN | M0)); /*GPMC_D2*/
MUX_VAL(CP(GPMC_D3), (IEN | PTU | EN | M0)); /*GPMC_D3*/
MUX_VAL(CP(GPMC_D4), (IEN | PTU | EN | M0)); /*GPMC_D4*/
MUX_VAL(CP(GPMC_D5), (IEN | PTU | EN | M0)); /*GPMC_D5*/
MUX_VAL(CP(GPMC_D6), (IEN | PTU | EN | M0)); /*GPMC_D6*/
MUX_VAL(CP(GPMC_D7), (IEN | PTU | EN | M0)); /*GPMC_D7*/
MUX_VAL(CP(GPMC_D8), (IEN | PTU | EN | M0)); /*GPMC_D8*/
MUX_VAL(CP(GPMC_D9), (IEN | PTU | EN | M0)); /*GPMC_D9*/
MUX_VAL(CP(GPMC_D10), (IEN | PTU | EN | M0)); /*GPMC_D10*/
MUX_VAL(CP(GPMC_D11), (IEN | PTU | EN | M0)); /*GPMC_D11*/
MUX_VAL(CP(GPMC_D12), (IEN | PTU | EN | M0)); /*GPMC_D12*/
MUX_VAL(CP(GPMC_D13), (IEN | PTU | EN | M0)); /*GPMC_D13*/
MUX_VAL(CP(GPMC_D14), (IEN | PTU | EN | M0)); /*GPMC_D14*/
MUX_VAL(CP(GPMC_D15), (IEN | PTU | EN | M0)); /*GPMC_D15*/
MUX_VAL(CP(GPMC_NCS0), (IDIS | PTU | EN | M0)); /*GPMC_nCS0*/
/* SB-T35 Ethernet */
MUX_VAL(CP(GPMC_NCS4), (IEN | PTU | EN | M0)); /*GPMC_nCS4*/
/* CM-T3x Ethernet */
MUX_VAL(CP(GPMC_NCS5), (IDIS | PTU | DIS | M0)); /*GPMC_nCS5*/
MUX_VAL(CP(GPMC_CLK), (IEN | PTD | DIS | M4)); /*GPIO_59*/
MUX_VAL(CP(GPMC_NADV_ALE), (IDIS | PTD | DIS | M0)); /*nADV_ALE*/
MUX_VAL(CP(GPMC_NOE), (IDIS | PTD | DIS | M0)); /*nOE*/
MUX_VAL(CP(GPMC_NWE), (IDIS | PTD | DIS | M0)); /*nWE*/
MUX_VAL(CP(GPMC_NBE0_CLE), (IDIS | PTU | EN | M0)); /*nBE0_CLE*/
MUX_VAL(CP(GPMC_NBE1), (IDIS | PTD | DIS | M4)); /*GPIO_61*/
MUX_VAL(CP(GPMC_NWP), (IEN | PTD | DIS | M0)); /*nWP*/
MUX_VAL(CP(GPMC_WAIT0), (IEN | PTU | EN | M0)); /*WAIT0*/
/* DSS */
MUX_VAL(CP(DSS_PCLK), (IDIS | PTD | DIS | M0)); /*DSS_PCLK*/
MUX_VAL(CP(DSS_HSYNC), (IDIS | PTD | DIS | M0)); /*DSS_HSYNC*/
MUX_VAL(CP(DSS_VSYNC), (IDIS | PTD | DIS | M0)); /*DSS_VSYNC*/
MUX_VAL(CP(DSS_ACBIAS), (IDIS | PTD | DIS | M0)); /*DSS_ACBIAS*/
MUX_VAL(CP(DSS_DATA6), (IDIS | PTD | DIS | M0)); /*DSS_DATA6*/
MUX_VAL(CP(DSS_DATA7), (IDIS | PTD | DIS | M0)); /*DSS_DATA7*/
MUX_VAL(CP(DSS_DATA8), (IDIS | PTD | DIS | M0)); /*DSS_DATA8*/
MUX_VAL(CP(DSS_DATA9), (IDIS | PTD | DIS | M0)); /*DSS_DATA9*/
MUX_VAL(CP(DSS_DATA10), (IDIS | PTD | DIS | M0)); /*DSS_DATA10*/
MUX_VAL(CP(DSS_DATA11), (IDIS | PTD | DIS | M0)); /*DSS_DATA11*/
MUX_VAL(CP(DSS_DATA12), (IDIS | PTD | DIS | M0)); /*DSS_DATA12*/
MUX_VAL(CP(DSS_DATA13), (IDIS | PTD | DIS | M0)); /*DSS_DATA13*/
MUX_VAL(CP(DSS_DATA14), (IDIS | PTD | DIS | M0)); /*DSS_DATA14*/
MUX_VAL(CP(DSS_DATA15), (IDIS | PTD | DIS | M0)); /*DSS_DATA15*/
MUX_VAL(CP(DSS_DATA16), (IDIS | PTD | DIS | M0)); /*DSS_DATA16*/
MUX_VAL(CP(DSS_DATA17), (IDIS | PTD | DIS | M0)); /*DSS_DATA17*/
/* serial interface */
MUX_VAL(CP(UART3_RX_IRRX), (IEN | PTD | DIS | M0)); /*UART3_RX*/
MUX_VAL(CP(UART3_TX_IRTX), (IDIS | PTD | DIS | M0)); /*UART3_TX*/
/* mUSB */
MUX_VAL(CP(HSUSB0_CLK), (IEN | PTD | DIS | M0)); /*HSUSB0_CLK*/
MUX_VAL(CP(HSUSB0_STP), (IDIS | PTU | EN | M0)); /*HSUSB0_STP*/
MUX_VAL(CP(HSUSB0_DIR), (IEN | PTD | DIS | M0)); /*HSUSB0_DIR*/
MUX_VAL(CP(HSUSB0_NXT), (IEN | PTD | DIS | M0)); /*HSUSB0_NXT*/
MUX_VAL(CP(HSUSB0_DATA0), (IEN | PTD | DIS | M0)); /*HSUSB0_DATA0*/
MUX_VAL(CP(HSUSB0_DATA1), (IEN | PTD | DIS | M0)); /*HSUSB0_DATA1*/
MUX_VAL(CP(HSUSB0_DATA2), (IEN | PTD | DIS | M0)); /*HSUSB0_DATA2*/
MUX_VAL(CP(HSUSB0_DATA3), (IEN | PTD | DIS | M0)); /*HSUSB0_DATA3*/
MUX_VAL(CP(HSUSB0_DATA4), (IEN | PTD | DIS | M0)); /*HSUSB0_DATA4*/
MUX_VAL(CP(HSUSB0_DATA5), (IEN | PTD | DIS | M0)); /*HSUSB0_DATA5*/
MUX_VAL(CP(HSUSB0_DATA6), (IEN | PTD | DIS | M0)); /*HSUSB0_DATA6*/
MUX_VAL(CP(HSUSB0_DATA7), (IEN | PTD | DIS | M0)); /*HSUSB0_DATA7*/
/* I2C1 */
MUX_VAL(CP(I2C1_SCL), (IEN | PTU | EN | M0)); /*I2C1_SCL*/
MUX_VAL(CP(I2C1_SDA), (IEN | PTU | EN | M0)); /*I2C1_SDA*/
/* control and debug */
MUX_VAL(CP(SYS_32K), (IEN | PTD | DIS | M0)); /*SYS_32K*/
MUX_VAL(CP(SYS_CLKREQ), (IEN | PTD | DIS | M0)); /*SYS_CLKREQ*/
MUX_VAL(CP(SYS_NIRQ), (IEN | PTU | EN | M0)); /*SYS_nIRQ*/
MUX_VAL(CP(SYS_OFF_MODE), (IEN | PTD | DIS | M0)); /*OFF_MODE*/
MUX_VAL(CP(SYS_CLKOUT1), (IEN | PTD | DIS | M0)); /*CLKOUT1*/
MUX_VAL(CP(SYS_CLKOUT2), (IDIS | PTU | DIS | M4)); /*green LED*/
MUX_VAL(CP(JTAG_nTRST), (IEN | PTD | DIS | M0)); /*JTAG_nTRST*/
MUX_VAL(CP(JTAG_TCK), (IEN | PTD | DIS | M0)); /*JTAG_TCK*/
MUX_VAL(CP(JTAG_TMS), (IEN | PTD | DIS | M0)); /*JTAG_TMS*/
MUX_VAL(CP(JTAG_TDI), (IEN | PTD | DIS | M0)); /*JTAG_TDI*/
/* MMC1 */
MUX_VAL(CP(MMC1_CLK), (IDIS | PTU | EN | M0)); /*MMC1_CLK*/
MUX_VAL(CP(MMC1_CMD), (IEN | PTU | EN | M0)); /*MMC1_CMD*/
MUX_VAL(CP(MMC1_DAT0), (IEN | PTU | EN | M0)); /*MMC1_DAT0*/
MUX_VAL(CP(MMC1_DAT1), (IEN | PTU | EN | M0)); /*MMC1_DAT1*/
MUX_VAL(CP(MMC1_DAT2), (IEN | PTU | EN | M0)); /*MMC1_DAT2*/
MUX_VAL(CP(MMC1_DAT3), (IEN | PTU | EN | M0)); /*MMC1_DAT3*/
}
static int
freebsd32_ioctl_sg(struct thread *td,
struct freebsd32_ioctl_args *uap, struct file *fp)
{
struct sg_io_hdr io;
struct sg_io_hdr32 io32;
int error;
if ((error = copyin(uap->data, &io32, sizeof(io32))) != 0)
return (error);
CP(io32, io, interface_id);
CP(io32, io, dxfer_direction);
CP(io32, io, cmd_len);
CP(io32, io, mx_sb_len);
CP(io32, io, iovec_count);
CP(io32, io, dxfer_len);
PTRIN_CP(io32, io, dxferp);
PTRIN_CP(io32, io, cmdp);
PTRIN_CP(io32, io, sbp);
CP(io32, io, timeout);
CP(io32, io, flags);
CP(io32, io, pack_id);
PTRIN_CP(io32, io, usr_ptr);
CP(io32, io, status);
CP(io32, io, masked_status);
CP(io32, io, msg_status);
CP(io32, io, sb_len_wr);
CP(io32, io, host_status);
CP(io32, io, driver_status);
CP(io32, io, resid);
CP(io32, io, duration);
CP(io32, io, info);
if ((error = fo_ioctl(fp, SG_IO, (caddr_t)&io, td->td_ucred, td)) != 0)
return (error);
CP(io, io32, interface_id);
CP(io, io32, dxfer_direction);
CP(io, io32, cmd_len);
CP(io, io32, mx_sb_len);
CP(io, io32, iovec_count);
CP(io, io32, dxfer_len);
PTROUT_CP(io, io32, dxferp);
PTROUT_CP(io, io32, cmdp);
PTROUT_CP(io, io32, sbp);
CP(io, io32, timeout);
CP(io, io32, flags);
CP(io, io32, pack_id);
PTROUT_CP(io, io32, usr_ptr);
CP(io, io32, status);
CP(io, io32, masked_status);
CP(io, io32, msg_status);
CP(io, io32, sb_len_wr);
CP(io, io32, host_status);
CP(io, io32, driver_status);
CP(io, io32, resid);
CP(io, io32, duration);
CP(io, io32, info);
error = copyout(&io32, uap->data, sizeof(io32));
return (error);
}
static void cm_t3730_set_muxconf(void)
{
/* DSS */
MUX_VAL(CP(DSS_DATA18), (IDIS | PTD | DIS | M3)); /*DSS_DATA0*/
MUX_VAL(CP(DSS_DATA19), (IDIS | PTD | DIS | M3)); /*DSS_DATA1*/
MUX_VAL(CP(DSS_DATA20), (IDIS | PTD | DIS | M3)); /*DSS_DATA2*/
MUX_VAL(CP(DSS_DATA21), (IDIS | PTD | DIS | M3)); /*DSS_DATA3*/
MUX_VAL(CP(DSS_DATA22), (IDIS | PTD | DIS | M3)); /*DSS_DATA4*/
MUX_VAL(CP(DSS_DATA23), (IDIS | PTD | DIS | M3)); /*DSS_DATA5*/
MUX_VAL(CP(SYS_BOOT0), (IDIS | PTD | DIS | M3)); /*DSS_DATA18*/
MUX_VAL(CP(SYS_BOOT1), (IDIS | PTD | DIS | M3)); /*DSS_DATA19*/
MUX_VAL(CP(SYS_BOOT3), (IDIS | PTD | DIS | M3)); /*DSS_DATA20*/
MUX_VAL(CP(SYS_BOOT4), (IDIS | PTD | DIS | M3)); /*DSS_DATA21*/
MUX_VAL(CP(SYS_BOOT5), (IDIS | PTD | DIS | M3)); /*DSS_DATA22*/
MUX_VAL(CP(SYS_BOOT6), (IDIS | PTD | DIS | M3)); /*DSS_DATA23*/
}
void
setterm(char *type)
{
register int unknown;
char ltcbuf[TCBUFSIZE];
if (type[0] == 0)
type = "xx";
unknown = 0;
putpad(TE);
if (tgetent(ltcbuf, type) != 1) {
unknown++;
CP(ltcbuf, "xx|dumb:");
}
gettmode(); /* must call gettmode() before setsize(). GR */
setsize();
aoftspace = tspace;
zap();
/*
* Initialize keypad arrow keys.
*/
addmac1(KU, "k", "up", arrows, 1);
addmac1(KD, "j", "down", arrows, 1);
addmac1(KL, "h", "left", arrows, 1);
addmac1(KR, "l", "right", arrows, 1);
addmac1(KH, "H", "home", arrows, 1);
/*
* Handle funny termcap capabilities
*/
if (xCS && SC && RC) {
if (AL==NULL) AL="";
if (DL==NULL) DL="";
}
if (AL_PARM && AL==NULL) AL="";
if (DL_PARM && DL==NULL) DL="";
if (IC && IM==NULL) IM="";
if (IC && EI==NULL) EI="";
if (!GT) BT=NULL; /* If we can't tab, we can't backtab either */
#ifdef TIOCLGET
#define HAS_JOB_CONTROL
#endif
#ifdef _SC_JOB_CONTROL
#define HAS_JOB_CONTROL
#endif
#ifdef HAS_JOB_CONTROL
/*
* Now map users susp char to ^Z, being careful that the susp
* overrides any arrow key, but only for hackers (=new tty driver).
*/
{
static char sc[2];
int i /* , fnd */;
if (sysconf(_SC_JOB_CONTROL) != -1)
{
/*
* If a system supports job control but no job
* control shell is used, only one method of
* detection remains: Our session id equals our
* process group id. Any job control shell would
* have created at least one new process group.
* But as the VSUSP key may be active, we have
* to override arrow keys either.
*/
#ifndef _CRAY /* getsid() is a bad syscall on UNICOS */
if (getsid(0) != getpgid(0))
#endif /* !_CRAY */
ldisc = 2; /* value of NTTYDISC */
sc[0] = tty.c_cc[VSUSP];
sc[1] = 0;
if (tty.c_cc[VSUSP] == CTRL('z')) {
for (i=0; i<=4; i++)
if (arrows[i].cap &&
arrows[i].cap[0] == CTRL('z'))
addmac(sc, NULL, NULL, arrows);
} else if (sc[0]
#ifdef _PC_VDISABLE
&& sc[0] != fpathconf(1, _PC_VDISABLE)
#endif
)
addmac(sc, "\32", "susp", arrows);
}
}
#endif /* HAS_JOB_CONTROL */
if (CM != 0) {
if (tgoto(CM, 2, 2)[0] == 'O') /* OOPS */
CA = 0, CM = 0;
else
CA = 1, costCM = cost(tgoto(CM, 8, 10));
} else {
CA = 0, CM = 0;
}
costSR = cost(SR);
costAL = cost(AL);
costDP = cost(tgoto(DOWN_PARM, 10, 10));
costLP = cost(tgoto(LEFT_PARM, 10, 10));
costRP = cost(tgoto(RIGHT_PARM, 10, 10));
PC = xPC ? xPC[0] : 0;
aoftspace = tspace;
safecp(ttylongname, gettlongname(ltcbuf, type), sizeof ttylongname,
"Terminal name too long");
/* proper strings to change tty type */
termreset();
gettmode();
value(REDRAW) = AL && DL;
value(OPTIMIZE) = !CA && !GT;
if (ospeed == B1200 && !value(REDRAW))
value(SLOWOPEN) = 1; /* see also gettmode above */
if (unknown)
serror(catgets(catd, 1, 191,
"%s: Unknown terminal type"), type);
}
int status_init(void)
{
isXM = (get_board_revision() == REVISION_XM);
i2c_set_bus_num(TWL4030_I2C_BUS);
if(isXM) {
/* Set VAUX1 to 3.3V for GTA04E display board */
twl4030_pmrecv_vsel_cfg(TWL4030_PM_RECEIVER_VAUX1_DEDICATED,
/*TWL4030_PM_RECEIVER_VAUX1_VSEL_33*/ 0x07,
TWL4030_PM_RECEIVER_VAUX1_DEV_GRP,
TWL4030_PM_RECEIVER_DEV_GRP_P1);
udelay(5000);
}
#if !defined(CONFIG_OMAP3_GTA04) // we assume that a GTA04 always has a TCA6507
if(i2c_set_bus_num(TCA6507_BUS))
{
printf ("could not select I2C2\n");
return 1;
}
hasTCA6507 = !i2c_probe(TCA6507_ADDRESS);
#endif
if(!hasTCA6507) {
if(isXM) { // XM has scrambled dss assignment with respect to default ball names
MUX_VAL(CP(DSS_DATA18), (IEN | PTD | EN | M4)); /*GPIO */
MUX_VAL(CP(DSS_DATA19), (IEN | PTD | EN | M4)); /*GPIO */
MUX_VAL(CP(DSS_DATA8), (IEN | PTD | EN | M4)); /*GPIO */
MUX_VAL(CP(DSS_DATA9), (IEN | PTD | EN | M4)); /*GPIO */
MUX_VAL(CP(SYS_BOOT0), (IEN | PTD | EN | M4)); /*GPIO */
MUX_VAL(CP(SYS_BOOT1), (IEN | PTD | EN | M4)); /*GPIO */
}
else {
MUX_VAL(CP(DSS_DATA0), (IEN | PTD | EN | M4)); /*GPIO */
MUX_VAL(CP(DSS_DATA1), (IEN | PTD | EN | M4)); /*GPIO */
MUX_VAL(CP(DSS_DATA8), (IEN | PTD | EN | M4)); /*GPIO */
MUX_VAL(CP(DSS_DATA9), (IEN | PTD | EN | M4)); /*GPIO */
MUX_VAL(CP(DSS_DATA16), (IEN | PTD | EN | M4)); /*GPIO */
MUX_VAL(CP(DSS_DATA17), (IEN | PTD | EN | M4)); /*GPIO */
}
omap_request_gpio(GPIO_LED_AUX_GREEN);
omap_request_gpio(GPIO_LED_AUX_RED);
omap_request_gpio(GPIO_LED_POWER_GREEN);
omap_request_gpio(GPIO_LED_POWER_RED);
omap_request_gpio(GPIO_LED_VIBRA);
omap_request_gpio(GPIO_LED_UNUSED);
if(GPIO_POWER >= 0)
omap_request_gpio(GPIO_POWER);
}
else {
// initialize I2C controller
}
if(GPIO_AUX >= 0)
omap_request_gpio(GPIO_AUX);
if(GPIO_POWER >= 0)
omap_request_gpio(GPIO_POWER);
if(GPIO_GPSEXT >= 0)
omap_request_gpio(GPIO_GPSEXT);
if(GPIO_PENIRQ >= 0)
omap_request_gpio(GPIO_PENIRQ);
if(GPIO_KEYIRQ >= 0)
omap_request_gpio(GPIO_KEYIRQ);
if(!hasTCA6507) {
omap_set_gpio_direction(GPIO_LED_AUX_GREEN, 0); // output
omap_set_gpio_direction(GPIO_LED_AUX_RED, 0); // output
omap_set_gpio_direction(GPIO_LED_POWER_GREEN, 0); // output
omap_set_gpio_direction(GPIO_LED_POWER_RED, 0); // output
omap_set_gpio_direction(GPIO_LED_VIBRA, 0); // output
omap_set_gpio_direction(GPIO_LED_UNUSED, 0); // output
}
if(GPIO_AUX >= 0)
omap_set_gpio_direction(GPIO_AUX, 1); // input
if(GPIO_POWER >= 0)
omap_set_gpio_direction(GPIO_POWER, 1); // input
if(GPIO_GPSEXT >= 0)
omap_set_gpio_direction(GPIO_GPSEXT, 1); // input
if(GPIO_PENIRQ >= 0)
omap_set_gpio_direction(GPIO_PENIRQ, 1); // input
if(GPIO_KEYIRQ >= 0)
omap_set_gpio_direction(GPIO_KEYIRQ, 1); // input
// when sould we do omap_free_gpio(GPIO_LED_AUX_GREEN); ?
printf("did init LED driver for %s\n", hasTCA6507?"TCA6507":"GPIOs");
return 0;
}
MV(CP(USBB1_ULPITLL_DAT1), M1) \ MV(CP(USBB1_ULPITLL_DAT2), M1) \ MV(CP(USBB1_ULPITLL_DAT3), IEN | M1) \ MV(CP(USBB1_ULPITLL_DAT4) , IEN | PTD | M7) \ MV(CP(USBB1_ULPITLL_DAT5) , IEN | PTD | M7) \ MV(CP(USBB1_ULPITLL_DAT6) , IEN | PTD | M7) \ MV(CP(USBB1_ULPITLL_DAT7) , IEN | PTD | M7) \ MV(CP(USBB1_HSIC_DATA), IEN | PTD | M7) \ MV(CP(USBB1_HSIC_STROBE), IEN | PTD | M7) \ MV1(WK(PAD0_SIM_IO), IEN | PTD | M7) \ MV1(WK(PAD1_SIM_CLK), IEN | PTD | M7) \ MV1(WK(PAD0_SIM_RESET), IEN | PTD | M7) \ MV1(WK(PAD1_SIM_CD), M3) \ MV1(WK(PAD0_SIM_PWRCTRL), IEN | PTD | M7) \ MV(CP(USBC1_ICUSB_DP), M3) \ MV(CP(USBC1_ICUSB_DM), PTU | M3) \ MV(CP(SDMMC1_CLK), PTU | OFF_EN | OFF_OUT_PTU | M0) \ MV(CP(SDMMC1_CMD), PTU | IEN | OFF_EN | OFF_PU | OFF_IN | M0) \ MV(CP(SDMMC1_DAT0), PTU | IEN | OFF_EN | OFF_PU | OFF_IN | M0) \ MV(CP(SDMMC1_DAT1), PTU | IEN | OFF_EN | OFF_PU | OFF_IN | M0) \ MV(CP(SDMMC1_DAT2), PTU | IEN | OFF_EN | OFF_PU | OFF_IN | M0) \ MV(CP(SDMMC1_DAT3), PTU | IEN | OFF_EN | OFF_PU | OFF_IN | M0) \ MV(CP(SDMMC1_DAT4), IEN | PTD | M7) \ MV(CP(SDMMC1_DAT5), IEN | PTD | M7) \ MV(CP(SDMMC1_DAT6), IEN | PTD | M7) \ MV(CP(SDMMC1_DAT7), IEN | PTD | M7) \ MV(CP(ABE_MCBSP2_CLKX), OFF_EN | OFF_PD | OFF_IN | IEN | M0) \ MV(CP(ABE_MCBSP2_DR), OFF_EN | OFF_OUT_PTD | IEN | M0) \ MV(CP(ABE_MCBSP2_DX), OFF_EN | OFF_OUT_PTD | M0) \ MV(CP(ABE_MCBSP2_FSX), OFF_EN | OFF_PD | OFF_IN | IEN | M0) \ MV(CP(ABE_MCBSP1_CLKX), OFF_EN | OFF_PD | OFF_IN | IEN | M0) \
/*
* Main procedure. Process arguments and then
* transfer control to the main command processing loop
* in the routine commands. We are entered as either "ex", "edit" or "vi"
* and the distinction is made here. Actually, we are "vi" if
* there is a 'v' in our name, and "edit" if there is a 'd' in our
* name. For edit we just diddle options; for vi we actually
* force an early visual command, setting the external initev so
* the q command in visual doesn't give command mode.
*/
int
main(int ac, char **av)
{
#ifndef VMUNIX
char *erpath = EXSTRINGS;
#endif
register char *cp;
register int c;
bool recov = 0;
bool ivis;
bool itag = 0;
bool fast = 0;
#ifdef TRACE
register char *tracef;
#endif
/*
* Immediately grab the tty modes so that we wont
* get messed up if an interrupt comes in quickly.
*/
gTTY(1);
normf = tty;
ppid = getpid();
/*
* Defend against d's, v's, and a's in directories of
* path leading to our true name.
*/
av[0] = tailpath(av[0]);
ivis = any('v', av[0]);
/*
* For debugging take files out of . if name is a.out.
* If a 'd' in our name, then set options for edit.
*/
#ifndef VMUNIX
if (av[0][0] == 'a')
erpath = tailpath(erpath);
#endif
if (ivis) {
#ifdef notdef
options[BEAUTIFY].odefault = value(BEAUTIFY) = 1;
#endif
} else if (any('d', av[0])) {
value(OPEN) = 0;
value(REPORT) = 1;
value(MAGIC) = 0;
}
/*
* Open the error message file.
*/
draino();
#ifndef VMUNIX
erfile = open(erpath+4, O_RDONLY);
if (erfile < 0) {
erfile = open(erpath, O_RDONLY);
}
#endif
pstop();
/*
* Initialize interrupt handling.
*/
oldhup = signal(SIGHUP, SIG_IGN);
if (oldhup == SIG_DFL)
signal(SIGHUP, onhup);
oldquit = signal(SIGQUIT, SIG_IGN);
ruptible = signal(SIGINT, SIG_IGN) == SIG_DFL;
if (signal(SIGTERM, SIG_IGN) == SIG_DFL)
signal(SIGTERM, onhup);
/*
* Initialize end of core pointers.
* Normally we avoid breaking back to fendcore after each
* file since this can be expensive (much core-core copying).
* If your system can scatter load processes you could do
* this as ed does, saving a little core, but it will probably
* not often make much difference.
*/
#ifdef UNIX_SBRK
fendcore = (line *) sbrk(0);
endcore = fendcore - 2;
#else
# define LINELIMIT 0x8000
fendcore = malloc(LINELIMIT * sizeof(line *));
endcore = fendcore + LINELIMIT - 1;
#endif
/*
* Process flag arguments.
*/
ac--, av++;
while (ac && av[0][0] == '-') {
c = av[0][1];
if (c == 0) {
hush = 1;
value(AUTOPRINT) = 0;
fast++;
} else switch (c) {
#ifdef TRACE
case 'T':
if (av[0][2] == 0)
tracef = "trace";
else {
tracef = tttrace;
tracef[8] = av[0][2];
if (tracef[8])
tracef[9] = av[0][3];
else
tracef[9] = 0;
}
trace = fopen(tracef, "w");
if (trace == NULL)
ex_printf("Trace create error\n");
setbuf(trace, tracbuf);
break;
#endif
#ifdef LISPCODE
case 'l':
value(LISP) = 1;
value(SHOWMATCH) = 1;
break;
#endif
case 'r':
recov++;
break;
case 't':
if (ac > 1 && av[1][0] != '-') {
ac--, av++;
itag = 1;
/* BUG: should check for too long tag. */
CP(lasttag, av[0]);
}
break;
case 'v':
ivis = 1;
break;
case 'w':
defwind = 0;
if (av[0][2] == 0) defwind = 3;
else for (cp = &av[0][2]; isdigit((int)*cp); cp++)
defwind = 10*defwind + *cp - '0';
break;
default:
smerror("Unknown option %s\n", av[0]);
break;
}
ac--, av++;
}
if (ac && av[0][0] == '+') {
firstpat = &av[0][1];
ac--, av++;
}
/*
* If we are doing a recover and no filename
* was given, then execute an exrecover command with
* the -r option to type out the list of saved file names.
* Otherwise set the remembered file name to the first argument
* file name so the "recover" initial command will find it.
*/
if (recov) {
if (ac == 0) {
ppid = 0;
setrupt();
execl(EXRECOVER, "exrecover", "-r", NULL);
filioerr(EXRECOVER);
exit(1);
}
CP(savedfile, *av);
av++, ac--;
}
/*
* Initialize the argument list.
*/
argv0 = av;
argc0 = ac;
args0 = av[0];
erewind();
/*
* Initialize a temporary file (buffer) and
* set up terminal environment. Read user startup commands.
*/
init();
if (setexit() == 0) {
setrupt();
intty = isatty(0);
value(PROMPT) = intty;
if (fast || !intty)
setterm("dumb");
else {
gettmode();
if ((cp = getenv("TERM")) != 0)
setterm(cp);
}
}
if (setexit() == 0 && !fast && intty) {
if ((globp = getenv("EXINIT")))
commands(1,1);
else if ((cp = getenv("HOME")) != 0)
source(strcat(strcpy(genbuf, cp), "/.exrc"), 1);
}
/*
* Initial processing. Handle tag, recover, and file argument
* implied next commands. If going in as 'vi', then don't do
* anything, just set initev so we will do it later (from within
* visual).
*/
if (setexit() == 0) {
if (recov)
globp = "recover";
else if (itag)
globp = ivis ? "tag" : "tag|p";
else if (argc)
globp = "next";
if (ivis)
initev = globp;
else if (globp) {
inglobal = 1;
commands(1, 1);
inglobal = 0;
}
}
/*
* Vi command... go into visual.
* Strange... everything in vi usually happens
* before we ever "start".
*/
if (ivis) {
/*
* Don't have to be upward compatible with stupidity
* of starting editing at line $.
*/
if (dol > zero)
dot = one;
globp = "visual";
if (setexit() == 0)
commands(1, 1);
}
/*
* Clear out trash in state accumulated by startup,
* and then do the main command loop for a normal edit.
* If you quit out of a 'vi' command by doing Q or ^\,
* you also fall through to here.
*/
ungetchar(0);
globp = 0;
initev = 0;
setlastchar('\n');
setexit();
commands(0, 0);
cleanup(1);
return 0;
}
// MAPVOTE
void G_IntermissionMapVote(gentity_t *ent)
{
char arg[MAX_TOKEN_CHARS];
if (g_gametype.integer != GT_WOLF_MAPVOTE)
{
CP(va("print \"^3Map voting not enabled!\n\""));
return;
}
if (g_gamestate.integer != GS_INTERMISSION)
{
CP(va("print \"^3Can't vote until intermission\n\""));
return;
}
if (!level.intermissiontime)
{
CP(va("print \"^3You can only vote during intermission\n\""));
return;
}
trap_Argv(1, arg, sizeof(arg));
// normal one-map vote
if (trap_Argc() == 2)
{
if (ent->client->ps.eFlags & EF_VOTED)
{
level.mapvoteinfo[ent->client->sess.mapVotedFor[0]].numVotes--;
level.mapvoteinfo[ent->client->sess.mapVotedFor[0]].totalVotes--;
}
ent->client->ps.eFlags |= EF_VOTED;
level.mapvoteinfo[atoi(arg)].numVotes++;
level.mapvoteinfo[atoi(arg)].totalVotes++;
ent->client->sess.mapVotedFor[0] = atoi(arg);
}
else if (trap_Argc() == 3)
{
char arg2[MAX_TOKEN_CHARS];
int voteRank = 0, i;
trap_Argv(2, arg2, sizeof(arg2));
voteRank = atoi(arg2);
if (voteRank < 1 || voteRank > 3)
{
return;
}
for (i = 0; i < 3; i++)
{
if (voteRank - 1 == i)
{
continue;
}
if (ent->client->sess.mapVotedFor[i] == atoi(arg))
{
CP(va("print \"^3Can't vote for the same map twice\n\""));
return;
}
}
if (ent->client->sess.mapVotedFor[voteRank - 1] != -1)
{
level.mapvoteinfo[ent->client->sess.mapVotedFor[voteRank - 1]].numVotes -= voteRank;
level.mapvoteinfo[ent->client->sess.mapVotedFor[voteRank - 1]].totalVotes -= voteRank;
}
level.mapvoteinfo[atoi(arg)].numVotes += voteRank;
level.mapvoteinfo[atoi(arg)].totalVotes += voteRank;
ent->client->sess.mapVotedFor[voteRank - 1] = atoi(arg);
ent->client->ps.eFlags |= EF_VOTED;
}
// Someone has voted. Send the votetally to all ...
// Doing it now, so there is no need for players to keep polling for this.
G_IntermissionVoteTally(NULL);
}
vmain()
{
register int c, cnt, i;
char esave[TUBECOLS];
char *oglobp;
char d;
line *addr;
int ind, nlput;
int shouldpo = 0;
int onumber, olist, (*OPline)(), (*OPutchar)();
vch_mac = VC_NOTINMAC;
/*
* If we started as a vi command (on the command line)
* then go process initial commands (recover, next or tag).
*/
if (initev) {
oglobp = globp;
globp = initev;
hadcnt = cnt = 0;
i = tchng;
addr = dot;
goto doinit;
}
/*
* NB:
*
* The current line is always in the line buffer linebuf,
* and the cursor at the position cursor. You should do
* a vsave() before moving off the line to make sure the disk
* copy is updated if it has changed, and a getDOT() to get
* the line back if you mung linebuf. The motion
* routines in ex_vwind.c handle most of this.
*/
for (;;) {
/*
* Decode a visual command.
* First sync the temp file if there has been a reasonable
* amount of change. Clear state for decoding of next
* command.
*/
TSYNC();
vglobp = 0;
vreg = 0;
hold = 0;
seenprompt = 1;
wcursor = 0;
Xhadcnt = hadcnt = 0;
Xcnt = cnt = 1;
splitw = 0;
if (i = holdupd) {
if (state == VISUAL)
ignore(peekkey());
holdupd = 0;
/*
if (LINE(0) < ZERO) {
vclear();
vcnt = 0;
i = 3;
}
*/
if (state != VISUAL) {
vcnt = 0;
vsave();
vrepaint(cursor);
} else if (i == 3)
vredraw(WTOP);
else
vsync(WTOP);
vfixcurs();
}
/*
* Gobble up counts and named buffer specifications.
*/
for (;;) {
looptop:
#ifdef MDEBUG
if (trace)
fprintf(trace, "pc=%c",peekkey());
#endif
if (isdigit(peekkey()) && peekkey() != '0') {
hadcnt = 1;
cnt = vgetcnt();
forbid (cnt <= 0);
}
if (peekkey() != '"')
break;
ignore(getkey()), c = getkey();
/*
* Buffer names be letters or digits.
* But not '0' as that is the source of
* an 'empty' named buffer spec in the routine
* kshift (see ex_temp.c).
*/
forbid (c == '0' || !isalpha(c) && !isdigit(c));
vreg = c;
}
reread:
/*
* Come to reread from below after some macro expansions.
* The call to map allows use of function key pads
* by performing a terminal dependent mapping of inputs.
*/
#ifdef MDEBUG
if (trace)
fprintf(trace,"pcb=%c,",peekkey());
#endif
op = getkey();
maphopcnt = 0;
do {
/*
* Keep mapping the char as long as it changes.
* This allows for double mappings, e.g., q to #,
* #1 to something else.
*/
c = op;
op = map(c,arrows);
#ifdef MDEBUG
if (trace)
fprintf(trace,"pca=%c,",c);
#endif
/*
* Maybe the mapped to char is a count. If so, we have
* to go back to the "for" to interpret it. Likewise
* for a buffer name.
*/
if ((isdigit(c) && c!='0') || c == '"') {
ungetkey(c);
goto looptop;
}
if (!value(REMAP)) {
c = op;
break;
}
if (++maphopcnt > 256)
error("Infinite macro loop");
} while (c != op);
/*
* Begin to build an image of this command for possible
* later repeat in the buffer workcmd. It will be copied
* to lastcmd by the routine setLAST
* if/when completely specified.
*/
lastcp = workcmd;
if (!vglobp)
*lastcp++ = c;
/*
* First level command decode.
*/
switch (c) {
/*
* ^L Clear screen e.g. after transmission error.
*/
/*
* ^R Retype screen, getting rid of @ lines.
* If in open, equivalent to ^L.
* On terminals where the right arrow key sends
* ^L we make ^R act like ^L, since there is no
* way to get ^L. These terminals (adm31, tvi)
* are intelligent so ^R is useless. Soroc
* will probably foul this up, but nobody has
* one of them.
*/
case CTRL(l):
case CTRL(r):
if (c == CTRL(l) || (KR && *KR==CTRL(l))) {
vclear();
vdirty(0, vcnt);
}
if (state != VISUAL) {
/*
* Get a clean line, throw away the
* memory of what is displayed now,
* and move back onto the current line.
*/
vclean();
vcnt = 0;
vmoveto(dot, cursor, 0);
continue;
}
vredraw(WTOP);
/*
* Weird glitch -- when we enter visual
* in a very small window we may end up with
* no lines on the screen because the line
* at the top is too long. This forces the screen
* to be expanded to make room for it (after
* we have printed @'s ick showing we goofed).
*/
if (vcnt == 0)
vrepaint(cursor);
vfixcurs();
continue;
/*
* $ Escape just cancels the current command
* with a little feedback.
*/
case ESCAPE:
beep();
continue;
/*
* @ Macros. Bring in the macro and put it
* in vmacbuf, point vglobp there and punt.
*/
case '@':
c = getesc();
if (c == 0)
continue;
if (c == '@')
c = lastmac;
if (isupper(c))
c = tolower(c);
forbid(!islower(c));
lastmac = c;
vsave();
CATCH
char tmpbuf[BUFSIZ];
regbuf(c,tmpbuf,sizeof(vmacbuf));
macpush(tmpbuf, 1);
ONERR
lastmac = 0;
splitw = 0;
getDOT();
vrepaint(cursor);
continue;
ENDCATCH
vmacp = vmacbuf;
goto reread;
/*
* . Repeat the last (modifying) open/visual command.
*/
case '.':
/*
* Check that there was a last command, and
* take its count and named buffer unless they
* were given anew. Special case if last command
* referenced a numeric named buffer -- increment
* the number and go to a named buffer again.
* This allows a sequence like "1pu.u.u...
* to successively look for stuff in the kill chain
* much as one does in EMACS with C-Y and M-Y.
*/
forbid (lastcmd[0] == 0);
if (hadcnt)
lastcnt = cnt;
if (vreg)
lastreg = vreg;
else if (isdigit(lastreg) && lastreg < '9')
lastreg++;
vreg = lastreg;
cnt = lastcnt;
hadcnt = lasthad;
vglobp = lastcmd;
goto reread;
/*
* ^U Scroll up. A count sticks around for
* future scrolls as the scroll amount.
* Attempt to hold the indentation from the
* top of the screen (in logical lines).
*
* BUG: A ^U near the bottom of the screen
* on a dumb terminal (which can't roll back)
* causes the screen to be cleared and then
* redrawn almost as it was. In this case
* one should simply move the cursor.
*/
case CTRL(u):
if (hadcnt)
vSCROLL = cnt;
cnt = vSCROLL;
if (state == VISUAL)
ind = vcline, cnt += ind;
else
ind = 0;
vmoving = 0;
vup(cnt, ind, 1);
vnline(NOSTR);
continue;
/*
* ^D Scroll down. Like scroll up.
*/
case CTRL(d):
#ifdef TRACE
if (trace)
fprintf(trace, "before vdown in ^D, dot=%d, wdot=%d, dol=%d\n", lineno(dot), lineno(wdot), lineno(dol));
#endif
if (hadcnt)
vSCROLL = cnt;
cnt = vSCROLL;
if (state == VISUAL)
ind = vcnt - vcline - 1, cnt += ind;
else
ind = 0;
vmoving = 0;
vdown(cnt, ind, 1);
#ifdef TRACE
if (trace)
fprintf(trace, "before vnline in ^D, dot=%d, wdot=%d, dol=%d\n", lineno(dot), lineno(wdot), lineno(dol));
#endif
vnline(NOSTR);
#ifdef TRACE
if (trace)
fprintf(trace, "after vnline in ^D, dot=%d, wdot=%d, dol=%d\n", lineno(dot), lineno(wdot), lineno(dol));
#endif
continue;
/*
* ^E Glitch the screen down (one) line.
* Cursor left on same line in file.
*/
case CTRL(e):
if (state != VISUAL)
continue;
if (!hadcnt)
cnt = 1;
/* Bottom line of file already on screen */
forbid(lineDOL()-lineDOT() <= vcnt-1-vcline);
ind = vcnt - vcline - 1 + cnt;
vdown(ind, ind, 1);
vnline(cursor);
continue;
/*
* ^Y Like ^E but up
*/
case CTRL(y):
if (state != VISUAL)
continue;
if (!hadcnt)
cnt = 1;
forbid(lineDOT()-1<=vcline); /* line 1 already there */
ind = vcline + cnt;
vup(ind, ind, 1);
vnline(cursor);
continue;
/*
* m Mark position in mark register given
* by following letter. Return is
* accomplished via ' or `; former
* to beginning of line where mark
* was set, latter to column where marked.
*/
case 'm':
/*
* Getesc is generally used when a character
* is read as a latter part of a command
* to allow one to hit rubout/escape to cancel
* what you have typed so far. These characters
* are mapped to 0 by the subroutine.
*/
c = getesc();
if (c == 0)
continue;
/*
* Markreg checks that argument is a letter
* and also maps ' and ` to the end of the range
* to allow '' or `` to reference the previous
* context mark.
*/
c = markreg(c);
forbid (c == 0);
vsave();
names[c - 'a'] = (*dot &~ 01);
ncols[c - 'a'] = cursor;
anymarks = 1;
continue;
/*
* ^F Window forwards, with 2 lines of continuity.
* Count repeats.
*/
case CTRL(f):
vsave();
if (vcnt > 2) {
addr = dot + (vcnt - vcline) - 2 + (cnt-1)*basWLINES;
forbid(addr > dol);
dot = addr;
vcnt = vcline = 0;
}
vzop(0, 0, '+');
continue;
/*
* ^B Window backwards, with 2 lines of continuity.
* Inverse of ^F.
*/
case CTRL(b):
vsave();
if (one + vcline != dot && vcnt > 2) {
addr = dot - vcline - 2 + (cnt-1)*basWLINES;
forbid (addr <= zero);
dot = addr;
vcnt = vcline = 0;
}
vzop(0, 0, '^');
continue;
/*
* z Screen adjustment, taking a following character:
* z<CR> current line to top
* z<NL> like z<CR>
* z- current line to bottom
* also z+, z^ like ^F and ^B.
* A preceding count is line to use rather
* than current line. A count between z and
* specifier character changes the screen size
* for the redraw.
*
*/
case 'z':
if (state == VISUAL) {
i = vgetcnt();
if (i > 0)
vsetsiz(i);
c = getesc();
if (c == 0)
continue;
}
vsave();
vzop(hadcnt, cnt, c);
continue;
/*
* Y Yank lines, abbreviation for y_ or yy.
* Yanked lines can be put later if no
* changes intervene, or can be put in named
* buffers and put anytime in this session.
*/
case 'Y':
ungetkey('_');
c = 'y';
break;
/*
* J Join lines, 2 by default. Count is number
* of lines to join (no join operator sorry.)
*/
case 'J':
forbid (dot == dol);
if (cnt == 1)
cnt = 2;
if (cnt > (i = dol - dot + 1))
cnt = i;
vsave();
vmacchng(1);
setLAST();
cursor = strend(linebuf);
vremote(cnt, join, 0);
notenam = "join";
vmoving = 0;
killU();
vreplace(vcline, cnt, 1);
if (!*cursor && cursor > linebuf)
cursor--;
if (notecnt == 2)
notecnt = 0;
vrepaint(cursor);
continue;
/*
* S Substitute text for whole lines, abbrev for c_.
* Count is number of lines to change.
*/
case 'S':
ungetkey('_');
c = 'c';
break;
/*
* O Create a new line above current and accept new
* input text, to an escape, there.
* A count specifies, for dumb terminals when
* slowopen is not set, the number of physical
* line space to open on the screen.
*
* o Like O, but opens lines below.
*/
case 'O':
case 'o':
vmacchng(1);
voOpen(c, cnt);
continue;
/*
* C Change text to end of line, short for c$.
*/
case 'C':
if (*cursor) {
ungetkey('$'), c = 'c';
break;
}
goto appnd;
/*
* ~ Switch case of letter under cursor
*/
case '~':
{
char mbuf[4];
setLAST();
mbuf[0] = 'r';
mbuf[1] = *cursor;
mbuf[2] = cursor[1]==0 ? 0 : ' ';
mbuf[3] = 0;
if (isalpha(mbuf[1]))
mbuf[1] ^= ' '; /* toggle the case */
macpush(mbuf, 1);
}
continue;
/*
* A Append at end of line, short for $a.
*/
case 'A':
operate('$', 1);
appnd:
c = 'a';
/* fall into ... */
/*
* a Appends text after cursor. Text can continue
* through arbitrary number of lines.
*/
case 'a':
if (*cursor) {
if (state == HARDOPEN)
putchar(*cursor);
cursor++;
}
goto insrt;
/*
* I Insert at beginning of whitespace of line,
* short for ^i.
*/
case 'I':
operate('^', 1);
c = 'i';
/* fall into ... */
/*
* R Replace characters, one for one, by input
* (logically), like repeated r commands.
*
* BUG: This is like the typeover mode of many other
* editors, and is only rarely useful. Its
* implementation is a hack in a low level
* routine and it doesn't work very well, e.g.
* you can't move around within a R, etc.
*/
case 'R':
/* fall into... */
/*
* i Insert text to an escape in the buffer.
* Text is arbitrary. This command reminds of
* the i command in bare teco.
*/
case 'i':
insrt:
/*
* Common code for all the insertion commands.
* Save for redo, position cursor, prepare for append
* at command and in visual undo. Note that nothing
* is doomed, unless R when all is, and save the
* current line in a the undo temporary buffer.
*/
vmacchng(1);
setLAST();
vcursat(cursor);
prepapp();
vnoapp();
doomed = c == 'R' ? 10000 : 0;
if(FIXUNDO)
vundkind = VCHNG;
vmoving = 0;
CP(vutmp, linebuf);
/*
* If this is a repeated command, then suppress
* fake insert mode on dumb terminals which looks
* ridiculous and wastes lots of time even at 9600B.
*/
if (vglobp)
hold = HOLDQIK;
vappend(c, cnt, 0);
continue;
/*
* ^? An attention, normally a ^?, just beeps.
* If you are a vi command within ex, then
* two ATTN's will drop you back to command mode.
*/
case ATTN:
beep();
if (initev || peekkey() != ATTN)
continue;
/* fall into... */
/*
* ^\ A quit always gets command mode.
*/
case QUIT:
/*
* Have to be careful if we were called
* g/xxx/vi
* since a return will just start up again.
* So we simulate an interrupt.
*/
if (inglobal)
onintr();
/* fall into... */
#ifdef notdef
/*
* q Quit back to command mode, unless called as
* vi on command line in which case dont do it
*/
case 'q': /* quit */
if (initev) {
vsave();
CATCH
error("Q gets ex command mode, :q leaves vi");
ENDCATCH
splitw = 0;
getDOT();
vrepaint(cursor);
continue;
}
#endif
/* fall into... */
/*
* Q Is like q, but always gets to command mode
* even if command line invocation was as vi.
*/
case 'Q':
vsave();
/*
* If we are in the middle of a macro, throw away
* the rest and fix up undo.
* This code copied from getbr().
*/
if (vmacp) {
vmacp = 0;
if (inopen == -1) /* don't screw up undo for esc esc */
vundkind = VMANY;
inopen = 1; /* restore old setting now that macro done */
}
return;
/*
* ZZ Like :x
*/
case 'Z':
forbid(getkey() != 'Z');
oglobp = globp;
globp = "x";
vclrech(0);
goto gogo;
/*
* P Put back text before cursor or before current
* line. If text was whole lines goes back
* as whole lines. If part of a single line
* or parts of whole lines splits up current
* line to form many new lines.
* May specify a named buffer, or the delete
* saving buffers 1-9.
*
* p Like P but after rather than before.
*/
case 'P':
case 'p':
vmoving = 0;
#ifdef notdef
forbid (!vreg && value(UNDOMACRO) && inopen < 0);
#endif
/*
* If previous delete was partial line, use an
* append or insert to put it back so as to
* use insert mode on intelligent terminals.
*/
if (!vreg && DEL[0]) {
forbid ((DEL[0] & (QUOTE|TRIM)) == OVERBUF);
vglobp = DEL;
ungetkey(c == 'p' ? 'a' : 'i');
goto reread;
}
/*
* If a register wasn't specified, then make
* sure there is something to put back.
*/
forbid (!vreg && unddol == dol);
/*
* If we just did a macro the whole buffer is in
* the undo save area. We don't want to put THAT.
*/
forbid (vundkind == VMANY && undkind==UNDALL);
vsave();
vmacchng(1);
setLAST();
i = 0;
if (vreg && partreg(vreg) || !vreg && pkill[0]) {
/*
* Restoring multiple lines which were partial
* lines; will leave cursor in middle
* of line after shoving restored text in to
* split the current line.
*/
i++;
if (c == 'p' && *cursor)
cursor++;
} else {
/*
* In whole line case, have to back up dot
* for P; also want to clear cursor so
* cursor will eventually be positioned
* at the beginning of the first put line.
*/
cursor = 0;
if (c == 'P') {
dot--, vcline--;
c = 'p';
}
}
killU();
/*
* The call to putreg can potentially
* bomb since there may be nothing in a named buffer.
* We thus put a catch in here. If we didn't and
* there was an error we would end up in command mode.
*/
addr = dol; /* old dol */
CATCH
vremote(1, vreg ? putreg : put, vreg);
ONERR
if (vreg == -1) {
splitw = 0;
if (op == 'P')
dot++, vcline++;
goto pfixup;
}
ENDCATCH
splitw = 0;
nlput = dol - addr + 1;
if (!i) {
/*
* Increment undap1, undap2 to make up
* for their incorrect initialization in the
* routine vremote before calling put/putreg.
*/
if (FIXUNDO)
undap1++, undap2++;
vcline++;
nlput--;
/*
* After a put want current line first line,
* and dot was made the last line put in code
* run so far. This is why we increment vcline
* above and decrease dot here.
*/
dot -= nlput - 1;
}
#ifdef TRACE
if (trace)
fprintf(trace, "vreplace(%d, %d, %d), undap1=%d, undap2=%d, dot=%d\n", vcline, i, nlput, lineno(undap1), lineno(undap2), lineno(dot));
#endif
vreplace(vcline, i, nlput);
if (state != VISUAL) {
/*
* Special case in open mode.
* Force action on the screen when a single
* line is put even if it is identical to
* the current line, e.g. on YP; otherwise
* you can't tell anything happened.
*/
vjumpto(dot, cursor, '.');
continue;
}
pfixup:
vrepaint(cursor);
vfixcurs();
continue;
/*
* ^^ Return to previous file.
* Like a :e #, and thus can be used after a
* "No Write" diagnostic.
*/
case CTRL(^):
forbid (hadcnt);
vsave();
ckaw();
oglobp = globp;
if (value(AUTOWRITE))
globp = "e! #";
else
globp = "e #";
goto gogo;
/*
* ^] Takes word after cursor as tag, and then does
* tag command. Read ``go right to''.
*/
case CTRL(]):
grabtag();
oglobp = globp;
globp = "tag";
goto gogo;
/*
* & Like :&
*/
case '&':
oglobp = globp;
globp = "&";
goto gogo;
/*
* ^G Bring up a status line at the bottom of
* the screen, like a :file command.
*
* BUG: Was ^S but doesn't work in cbreak mode
*/
case CTRL(g):
oglobp = globp;
globp = "file";
gogo:
addr = dot;
vsave();
goto doinit;
#ifdef SIGTSTP
/*
* ^Z: suspend editor session and temporarily return
* to shell. Only works with Berkeley/IIASA process
* control in kernel.
*/
case CTRL(z):
forbid(dosusp == 0 || !ldisc);
vsave();
oglobp = globp;
globp = "stop";
goto gogo;
#endif
/*
* : Read a command from the echo area and
* execute it in command mode.
*/
case ':':
forbid (hadcnt);
vsave();
i = tchng;
addr = dot;
if (readecho(c)) {
esave[0] = 0;
goto fixup;
}
getDOT();
/*
* Use the visual undo buffer to store the global
* string for command mode, since it is idle right now.
*/
oglobp = globp; strcpy(vutmp, genbuf+1); globp = vutmp;
doinit:
esave[0] = 0;
fixech();
/*
* Have to finagle around not to lose last
* character after this command (when run from ex
* command mode). This is clumsy.
*/
d = peekc; ungetchar(0);
if (shouldpo) {
/*
* So after a "Hit return..." ":", we do
* another "Hit return..." the next time
*/
pofix();
shouldpo = 0;
}
CATCH
/*
* Save old values of options so we can
* notice when they change; switch into
* cooked mode so we are interruptible.
*/
onumber = value(NUMBER);
olist = value(LIST);
OPline = Pline;
OPutchar = Putchar;
#ifndef CBREAK
vcook();
#endif
commands(1, 1);
if (dot == zero && dol > zero)
dot = one;
#ifndef CBREAK
vraw();
#endif
ONERR
#ifndef CBREAK
vraw();
#endif
copy(esave, vtube[WECHO], TUBECOLS);
ENDCATCH
fixol();
Pline = OPline;
Putchar = OPutchar;
ungetchar(d);
globp = oglobp;
/*
* If we ended up with no lines in the buffer, make
* a line, and don't consider the buffer changed.
*/
if (dot == zero) {
fixzero();
sync();
}
splitw = 0;
/*
* Special case: did list/number options change?
*/
if (onumber != value(NUMBER))
setnumb(value(NUMBER));
if (olist != value(LIST))
setlist(value(LIST));
fixup:
/*
* If a change occurred, other than
* a write which clears changes, then
* we should allow an undo even if .
* didn't move.
*
* BUG: You can make this wrong by
* tricking around with multiple commands
* on one line of : escape, and including
* a write command there, but its not
* worth worrying about.
*/
if (FIXUNDO && tchng && tchng != i)
vundkind = VMANY, cursor = 0;
/*
* If we are about to do another :, hold off
* updating of screen.
*/
if (vcnt < 0 && Peekkey == ':') {
getDOT();
shouldpo = 1;
continue;
}
shouldpo = 0;
/*
* In the case where the file being edited is
* new; e.g. if the initial state hasn't been
* saved yet, then do so now.
*/
if (unddol == truedol) {
vundkind = VNONE;
Vlines = lineDOL();
if (!inglobal)
savevis();
addr = zero;
vcnt = 0;
if (esave[0] == 0)
copy(esave, vtube[WECHO], TUBECOLS);
}
/*
* If the current line moved reset the cursor position.
*/
if (dot != addr) {
vmoving = 0;
cursor = 0;
}
/*
* If current line is not on screen or if we are
* in open mode and . moved, then redraw.
*/
i = vcline + (dot - addr);
if (i < 0 || i >= vcnt && i >= -vcnt || state != VISUAL && dot != addr) {
if (state == CRTOPEN)
vup1();
if (vcnt > 0)
vcnt = 0;
vjumpto(dot, (char *) 0, '.');
} else {
/*
* Current line IS on screen.
* If we did a [Hit return...] then
* restore vcnt and clear screen if in visual
*/
vcline = i;
if (vcnt < 0) {
vcnt = -vcnt;
if (state == VISUAL)
vclear();
else if (state == CRTOPEN) {
vcnt = 0;
}
}
/*
* Limit max value of vcnt based on $
*/
i = vcline + lineDOL() - lineDOT() + 1;
if (i < vcnt)
vcnt = i;
/*
* Dirty and repaint.
*/
vdirty(0, LINES);
vrepaint(cursor);
}
/*
* If in visual, put back the echo area
* if it was clobberred.
*/
if (state == VISUAL) {
int sdc = destcol, sdl = destline;
splitw++;
vigoto(WECHO, 0);
for (i = 0; i < TUBECOLS - 1; i++) {
if (esave[i] == 0)
break;
vputchar(esave[i]);
}
splitw = 0;
vgoto(sdl, sdc);
}
continue;
/*
* u undo the last changing command.
*/
case 'u':
vundo(1);
continue;
/*
* U restore current line to initial state.
*/
case 'U':
vUndo();
continue;
fonfon:
beep();
vmacp = 0;
inopen = 1; /* might have been -1 */
continue;
}
/*
* Rest of commands are decoded by the operate
* routine.
*/
operate(c, cnt);
}
}
/*
==============
ClientThink
This will be called once for each client frame, which will
usually be a couple times for each server frame on fast clients.
If "g_synchronousClients 1" is set, this will be called exactly
once for each server frame, which makes for smooth demo recording.
==============
*/
void ClientThink_real(gentity_t *ent) {
int msec, oldEventSequence;
pmove_t pm;
usercmd_t *ucmd;
gclient_t *client = ent->client;
// don't think if the client is not yet connected (and thus not yet spawned in)
if (client->pers.connected != CON_CONNECTED) {
return;
}
if (ent->s.eFlags & EF_MOUNTEDTANK) {
client->pmext.centerangles[YAW] = ent->tagParent->r.currentAngles[YAW];
client->pmext.centerangles[PITCH] = ent->tagParent->r.currentAngles[PITCH];
}
// mark the time, so the connection sprite can be removed
ucmd = &ent->client->pers.cmd;
ent->client->ps.identifyClient = ucmd->identClient; // NERVE - SMF
// sanity check the command time to prevent speedup cheating
if (ucmd->serverTime > level.time + 200) {
ucmd->serverTime = level.time + 200;
}
if (ucmd->serverTime < level.time - 1000) {
ucmd->serverTime = level.time - 1000;
}
msec = ucmd->serverTime - client->ps.commandTime;
// following others may result in bad times, but we still want
// to check for follow toggles
if (msec < 1 && client->sess.spectatorState != SPECTATOR_FOLLOW) {
return;
}
if (msec > 200) {
msec = 200;
}
// Nico, pmove_fixed
if (client->pers.pmoveFixed) {
ucmd->serverTime = ((ucmd->serverTime + pmove_msec.integer - 1) / pmove_msec.integer) * pmove_msec.integer;
}
if (client->wantsscore) {
G_SendScore(ent);
client->wantsscore = qfalse;
}
// check for inactivity timer, but never drop the local client of a non-dedicated server
// OSP - moved here to allow for spec inactivity checks as well
if (!ClientInactivityTimer(client)) {
return;
}
if (!(ucmd->flags & 0x01) || ucmd->forwardmove || ucmd->rightmove || ucmd->upmove || ucmd->wbuttons || ucmd->doubleTap) {
ent->r.svFlags &= ~(SVF_SELF_PORTAL_EXCLUSIVE | SVF_SELF_PORTAL);
}
// spectators don't do much
// DHM - Nerve :: In limbo use SpectatorThink
if (client->sess.sessionTeam == TEAM_SPECTATOR || client->ps.pm_flags & PMF_LIMBO) {
SpectatorThink(ent, ucmd);
return;
}
if (client->ps.eFlags & EF_VIEWING_CAMERA) {
ucmd->buttons = 0;
ucmd->forwardmove = 0;
ucmd->rightmove = 0;
ucmd->upmove = 0;
ucmd->wbuttons = 0;
ucmd->doubleTap = 0;
// freeze player
client->ps.pm_type = PM_FREEZE;
} else if (client->noclip) {
client->ps.pm_type = PM_NOCLIP;
} else if (client->ps.stats[STAT_HEALTH] <= 0) {
client->ps.pm_type = PM_DEAD;
} else {
client->ps.pm_type = PM_NORMAL;
}
client->ps.aiState = AISTATE_COMBAT;
client->ps.gravity = DEFAULT_GRAVITY;
client->ps.speed = DEFAULT_SPEED;
if (client->speedScale) { // Goalitem speed scale
client->ps.speed *= (client->speedScale * 0.01);
}
// set up for pmove
oldEventSequence = client->ps.eventSequence;
client->currentAimSpreadScale = (float)client->ps.aimSpreadScale / 255.0;
memset(&pm, 0, sizeof (pm));
pm.ps = &client->ps;
pm.pmext = &client->pmext;
pm.character = client->pers.character;
pm.cmd = *ucmd;
pm.oldcmd = client->pers.oldcmd;
// MrE: always use capsule for AI and player
pm.trace = trap_TraceCapsule;
// Nico, ghost players
pm.tracemask = MASK_PLAYERSOLID & ~CONTENTS_BODY;
if (pm.ps->pm_type == PM_DEAD) {
pm.ps->eFlags |= EF_DEAD;
} else if (pm.ps->pm_type == PM_SPECTATOR) {
pm.trace = trap_TraceCapsuleNoEnts;
}
// Nico, end of ghost players
//DHM - Nerve :: We've gone back to using normal bbox traces
pm.pointcontents = trap_PointContents;
pm.debugLevel = g_debugMove.integer;
pm.noFootsteps = qfalse;
// Nico, pmove_fixed
// pm.pmove_fixed = pmove_fixed.integer | client->pers.pmoveFixed;
pm.pmove_fixed = client->pers.pmoveFixed;
pm.pmove_msec = pmove_msec.integer;
// Nico, game physics
pm.physics = physics.integer;
pm.isTimerun = isTimerun.integer;
pm.timerunActive = client->sess.timerunActive;
pm.timerunStartTime = client->sess.timerunStartTime + 500;
// Nico, store logins status in pmove
if (client->sess.logged) {
pm.isLogged = 1;
} else {
pm.isLogged = 0;
}
pm.noWeapClips = qfalse;
VectorCopy(client->ps.origin, client->oldOrigin);
// NERVE - SMF
pm.ltChargeTime = level.lieutenantChargeTime[client->sess.sessionTeam - 1];
pm.soldierChargeTime = level.soldierChargeTime[client->sess.sessionTeam - 1];
pm.engineerChargeTime = level.engineerChargeTime[client->sess.sessionTeam - 1];
pm.medicChargeTime = level.medicChargeTime[client->sess.sessionTeam - 1];
// -NERVE - SMF
client->pmext.airleft = ent->client->airOutTime - level.time;
pm.covertopsChargeTime = level.covertopsChargeTime[client->sess.sessionTeam - 1];
// Gordon: bit hacky, stop the slight lag from client -> server even on locahost, switching back to the weapon you were holding
// and then back to what weapon you should have, became VERY noticible for the kar98/carbine + gpg40, esp now i've added the
// animation locking
if (level.time - client->pers.lastSpawnTime < 1000) {
pm.cmd.weapon = client->ps.weapon;
}
Pmove(&pm);
// Gordon: thx to bani for this
// ikkyo - fix leaning players bug
VectorCopy(client->ps.velocity, ent->s.pos.trDelta);
SnapVector(ent->s.pos.trDelta);
// end
// server cursor hints
if (ent->lastHintCheckTime < level.time) {
G_CheckForCursorHints(ent);
ent->lastHintCheckTime = level.time + FRAMETIME;
}
// DHM - Nerve :: Set animMovetype to 1 if ducking
if (ent->client->ps.pm_flags & PMF_DUCKED) {
ent->s.animMovetype = 1;
} else {
ent->s.animMovetype = 0;
}
// save results of pmove
if (ent->client->ps.eventSequence != oldEventSequence) {
ent->eventTime = level.time;
ent->r.eventTime = level.time;
}
// Ridah, fixes jittery zombie movement
if (g_smoothClients.integer) {
BG_PlayerStateToEntityStateExtraPolate(&ent->client->ps, &ent->s, level.time, qfalse);
} else {
BG_PlayerStateToEntityState(&ent->client->ps, &ent->s, qfalse);
}
if (!(ent->client->ps.eFlags & EF_FIRING)) {
client->fireHeld = qfalse; // for grapple
}
// // use the snapped origin for linking so it matches client predicted versions
VectorCopy(ent->s.pos.trBase, ent->r.currentOrigin);
VectorCopy(pm.mins, ent->r.mins);
VectorCopy(pm.maxs, ent->r.maxs);
ent->waterlevel = pm.waterlevel;
ent->watertype = pm.watertype;
// execute client events
ClientEvents(ent, oldEventSequence);
// link entity now, after any personal teleporters have been used
trap_LinkEntity(ent);
if (!ent->client->noclip) {
G_TouchTriggers(ent);
}
// NOTE: now copy the exact origin over otherwise clients can be snapped into solid
VectorCopy(ent->client->ps.origin, ent->r.currentOrigin);
// touch other objects
ClientImpacts(ent, &pm);
// save results of triggers and client events
if (ent->client->ps.eventSequence != oldEventSequence) {
ent->eventTime = level.time;
}
// swap and latch button actions
client->oldbuttons = client->buttons;
client->buttons = ucmd->buttons;
client->latched_buttons = client->buttons & ~client->oldbuttons;
//----(SA) added
client->oldwbuttons = client->wbuttons;
client->wbuttons = ucmd->wbuttons;
client->latched_wbuttons = client->wbuttons & ~client->oldwbuttons;
// Rafael - Activate
// Ridah, made it a latched event (occurs on keydown only)
if (client->latched_buttons & BUTTON_ACTIVATE) {
Cmd_Activate_f(ent);
}
if (g_entities[ent->client->ps.identifyClient].team != ent->team ||
!g_entities[ent->client->ps.identifyClient].client) {
ent->client->ps.identifyClient = -1;
}
// check for respawning
if (client->ps.stats[STAT_HEALTH] <= 0) {
// Nico, forcing respawn
limbo(ent);
return;
}
// perform once-a-second actions
ClientTimerActions(ent, msec);
// Nico, check ping
if (client->sess.timerunActive && client->ps.ping > MAX_PLAYER_PING) {
CP(va("cpm \"%s^w: ^1too high ping detected, timerun stopped\n\"", GAME_VERSION_COLORED));
// Nico, notify the client and its spectators the timerun has stopped
notify_timerun_stop(ent, 0);
client->sess.timerunActive = qfalse;
}
// Nico, pmove_fixed
if (!client->pers.pmoveFixed) {
CP(va("cpm \"%s^w: ^1you were removed from teams because you can not use pmove_fixed 0\n\"", GAME_VERSION_COLORED));
trap_SendServerCommand(ent - g_entities, "pmoveon");
SetTeam(ent, "s", -1, -1, qfalse);
}
// Nico, check rate
if (client->pers.rate < MIN_PLAYER_RATE_VALUE || client->pers.rate > MAX_PLAYER_RATE_VALUE) {
CP(va("cpm \"%s^w: ^1you were removed from teams because you must use %d <= rate <= %d\n\"", GAME_VERSION_COLORED, MIN_PLAYER_RATE_VALUE, MAX_PLAYER_RATE_VALUE));
trap_SendServerCommand(ent - g_entities, "resetRate");
SetTeam(ent, "s", -1, -1, qfalse);
}
// Nico, check snaps (unsigned int)
if (client->pers.snaps > MAX_PLAYER_SNAPS_VALUE) {
CP(va("cpm \"%s^w: ^1you were removed from teams because you must use %d <= snaps <= %d\n\"", GAME_VERSION_COLORED, MIN_PLAYER_SNAPS_VALUE, MAX_PLAYER_SNAPS_VALUE));
trap_SendServerCommand(ent - g_entities, "resetSnaps");
SetTeam(ent, "s", -1, -1, qfalse);
}
// Nico, check timenudge
if (client->pers.clientTimeNudge != FORCED_PLAYER_TIMENUDGE_VALUE) {
CP(va("cpm \"%s^w: ^1you were removed from teams because you must use cl_timenudge %d\n\"", GAME_VERSION_COLORED, FORCED_PLAYER_TIMENUDGE_VALUE));
trap_SendServerCommand(ent - g_entities, "resetTimeNudge");
SetTeam(ent, "s", -1, -1, qfalse);
}
// Nico, check maxpackets
if (client->pers.clientMaxPackets < MIN_PLAYER_MAX_PACKETS_VALUE || client->pers.clientMaxPackets > MAX_PLAYER_MAX_PACKETS_VALUE) {
CP(va("cpm \"%s^w: ^1you were removed from teams because you must use %d <= cl_maxpackets <= %d\n\"", GAME_VERSION_COLORED, MIN_PLAYER_MAX_PACKETS_VALUE, MAX_PLAYER_MAX_PACKETS_VALUE));
trap_SendServerCommand(ent - g_entities, "resetMaxPackets");
SetTeam(ent, "s", -1, -1, qfalse);
}
// Nico, check max FPS
if (client->pers.maxFPS < MIN_PLAYER_FPS_VALUE || client->pers.maxFPS > MAX_PLAYER_FPS_VALUE) {
CP(va("cpm \"%s^w: ^1you were removed from teams because you must use %d <= com_maxfps <= %d\n\"", GAME_VERSION_COLORED, MIN_PLAYER_FPS_VALUE, MAX_PLAYER_FPS_VALUE));
trap_SendServerCommand(ent - g_entities, "resetMaxFPS");
SetTeam(ent, "s", -1, -1, qfalse);
}
// Nico, force auto demo record in cup mode
if (g_cupMode.integer != 0 && client->pers.autoDemo == 0) {
CP(va("cpm \"%s^w: ^1you were removed from teams because you must use cg_autoDemo 1\n\"", GAME_VERSION_COLORED));
trap_SendServerCommand(ent - g_entities, "autoDemoOn");
SetTeam(ent, "s", -1, -1, qfalse);
}
// Nico, force hide me in cup mode
if (g_cupMode.integer != 0 && client->pers.hideme == 0) {
CP(va("cpm \"%s^w: ^1you were removed from teams because you must use cg_hideMe 1\n\"", GAME_VERSION_COLORED));
trap_SendServerCommand(ent - g_entities, "hideMeOn");
SetTeam(ent, "s", -1, -1, qfalse);
}
// Nico, force CGaz 0 in cup mode
if (g_cupMode.integer != 0 && client->pers.cgaz != 0) {
CP(va("cpm \"%s^w: ^1you were removed from teams because you must use cg_drawCGaz 0\n\"", GAME_VERSION_COLORED));
trap_SendServerCommand(ent - g_entities, "CGazOff");
SetTeam(ent, "s", -1, -1, qfalse);
}
}
