Quali sono le tue gemme di codifica preferite specifiche del gioco? [chiuso]

Comincerò con John Carmack l'inversa Fast radice quadrata in Quake III:

float Q_rsqrt(float number) {

  long i;
  float x2, y;
  const float threehalfs = 1.5F;

  x2 = number * 0.5F;
  y = number;
  i = * ( long * ) &y;
  i = 0x5f3759df - ( i >> 1 );
  y = * ( float * ) &i;
  y = y * ( threehalfs - ( x2 * y * y ) );

  return y;

}

funzione mapValue:

float mapValue( float inVal, float inFrom, float inTo, float outFrom, float outTo )
{
    float inScale = (inFrom != inTo) 
        ? ( ( inVal - inFrom ) / ( inTo - inFrom ) ) 
        : 0.0f;
    float outVal = outFrom + ( inScale * ( outTo - outFrom ) );
    outVal = (outFrom < outTo ) 
        ? clamp( outVal, outFrom, outTo ) 
        : clamp( outVal, outTo, outFrom );
    return outVal;
}

Prende un valore, lo converte in una proporzione all'interno di un intervallo, quindi lo ridimensiona rispetto a un altro intervallo. Come un doppio giro.

Puoi usarlo per normalizzare le cose:

float minDamage = 0.0f; float maxDamage = 300.0f;
float normalisedDamage = mapValue(damange, minDamage, maxDamage, 0.0f, 1.0f);

Oppure puoi convertire da un intervallo all'altro:

float brakeStrength = mapValue(timeToCollision, 
    0.0f, 10.0f, // seconds
    1.0f, 0.2f // brake values 
    );

Si noti nel secondo esempio che l'intervallo di uscita è un ordine diverso dall'intervallo di entrata.

Non sembra molto, ma uso questo piccolo amico dappertutto.

Non riesco ancora a credere quante volte ho usato il Teorema di Pitagora nel mio codice di gioco. Per me, questa semplice formula è un gioiello nello sviluppo del gioco.

_{(fonte: mathurl.com )}

o

_{(fonte: mathurl.com )}

e quando conta solo la distanza relativa, può essere usata senza costose operazioni con radice quadrata

_{(fonte: mathurl.com )}

Il più grande da me stava leggendo del sistema GameObject di Scott Bilas. Anche se non uso un sistema di database come lui, mi ha impedito di creare alberi di ereditarietà a 6 livelli e mi ha permesso di creare un sistema componente che è molto più gestibile e riutilizzabile.

Devo andare con il dispositivo di Duff . È stato il primo blocco di codice che mi ha letteralmente lasciato cadere. "Ce la puoi fare?!?"

Un piccolo frammento C / C ++ di un gioco che ho aiutato a scrivere molti anni fa:

(fill ? FillRect : DrawRect) (x, y, w, h, colour);

Nel mio primo gioco ( questo ) avevo bisogno di accedere a più di 1 Mb di RAM e, essendo questo prima del decollo di Internet, non avevo documentazione per XMS ed EMS che le app DOS usavano per accedere alla RAM aggiuntiva.

Così, ho finito per usare una piccola "backdoor" che appariva nel 386 per quanto riguarda i registri di segmento. Normalmente, in modalità reale, l'indirizzo è stato calcolato come un seg*16+offlimite di 1 Mb.

Tuttavia, è possibile passare alla modalità protetta, impostare un segmento per indirizzare 4 Mb, tornare indietro e purché non si scriva nel registro dei segmenti (il che era OK poiché DOS utilizzava solo i registri dei segmenti 8086), si poteva accedere all'intero 4 Mb come spazio di indirizzamento piatto. Tornare alla modalità reale era necessario se si desidera utilizzare i servizi DOS.

Non c'erano nemmeno molti extender DPMI disponibili.

Personalmente sono un grande fan di Mersenne Twister per numeri casuali prevedibili, soprattutto se è necessario creare diverse istanze di Rand in modo diverso

http://en.wikipedia.org/wiki/Mersenne_twister

Eccone uno menzionato da Chris Crawford (e apparentemente usato da Atari) che lui chiama "A Graphics Trick":

LDA FIRST
EOR SECOND
AND CONTROL
EOR SECOND
STA OUTPUT

Leggi l' articolo completo per una spiegazione.

Per qualche ragione, le persone spesso sottovalutano il potere dei modelli di progettazione nei giochi. Ho visto quasi ogni singolo modello GoF applicato con successo ai giochi.

Math.atan2 () è estremamente utile (insieme a tutti i trig).

Per aggiungere alla gemma pitagorica sopra ...
Dico sempre alle persone che per la programmazione 3d devono solo sapere:
- a ^ 2 + b ^ 2 = c ^ 2
- soscastoa (sin = lato opposto / lato inclinato, cos = lato attaccato / lato inclinato, marrone chiaro = lato opposto / lato attaccato)
- a. b = | a | * | b | * cos alpha
- a * b = | a | * | b | * sin alpha * unit vector
Può risolvere praticamente qualsiasi problema 3d (o 2d) che riscontri nello sviluppo del gioco - 4 regole.
Certo, ci sono modi più belli, ma questo può risolverli tutti - dovrei sapere, sono un hack che ha basato una carriera su di loro.

Uno dei miei preferiti è la versione in linguaggio assembly di "Life" e l'intera descrizione dell'ottimizzazione in " The Zen of Code Optimization" di Michael Abrash.

Consiglierei uno qualsiasi dei suoi libri a chiunque cerchi gemme di programmazione.