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); } }