Articoli
-
Programmazione anormale
Come Pharaoh viveva in 16 megabyte di memoria
Come Pharaoh (2000) fece stare circa 300 megabyte di grafica in 16 megabyte di RAM senza una sola riga di assembly, solo cambiando il formato dei dati: palette a 8 bit e superfici DirectDraw, archivi .sg3/.555, un RLE da cui si può disegnare direttamente, rombi isometrici senza angoli, la parte alta degli edifici a parte, cinque direzioni invece di otto, un font che si colora mentre viene disegnato, caricamento delle immagini su richiesta e slot con segnaposto. Con numeri dai file reali del gioco e codice da Tutankhamun, una reimplementazione di Pharaoh in C.
-
Game design
Come imbrogliare un po’ il server
Negli articoli precedenti era il gioco a mentire un po’ al giocatore; ora è il giocatore a mentire al server. Vi presento Vasja: odia perdere al punto da passare più tempo a prepararsi che a giocare la partita. Client autoritativo e soldi dal nulla, speedhack, wallhack e freecam, aimbot che non toccano il gioco, no-recoil e silent aim, un router che mente anche lui al server, riordino dei pacchetti, bot e macro, avversari buttati fuori dalla partita, manipolazione del rating — e di cosa è fatta davvero la protezione, comprese le allucinazioni di Ricochet che ingannano Vasja stesso.
-
Mestiere
Servono più istanze, Milord
Il seguito della cronaca «La produzione è caduta, Milord»: il regno di Yundexburg costruisce un nuovo castello a Mamsterdam, nessuno controlla le porte, i cartografi vengono ridotti di un quarto e i cartelli stradali si piazzano in base alla lunghezza della coda dei cavalli. Un giorno un errore nelle scuderie manda i messaggeri su tutte le strade del mondo, i registri soffocano e mastro Godfrid viene di nuovo convocato a corte — davanti a un congegno in cantina con il cartello «Smontare dopo il rilascio» di Baldassarre von Pezza.
-
Game design
Non rendete gli NPC più intelligenti del giocatore
Nei giochi AAA, dove centinaia di thread si dividono il rendering di un frame, i nemici sono ancora guidati da macchine a stati finiti, behavior tree e una montagna di if. Perché: come un NPC addestrato aggira la funzione di ricompensa, perché il gioco cambia più in fretta di quanto un modello si possa riaddestrare, perché anche la prevedibilità è game design e un NPC deve sbagliare, dove il ML nei giochi funziona davvero, perché le vecchie tecniche non spariranno e cosa non va negli NPC basati su LLM. Con esempi interattivi.
-
Game design
Il problema del cancello
Un soldato da solo passa il cancello senza problemi, ma mandaci una folla e si rompe tutto. Perché un agente «si incastra» in un passaggio che sembra abbastanza largo, in cosa la NavMesh differisce dal pavimento nel viewport, quando A* diventa costoso e arriva in soccorso la ricerca gerarchica, cosa fare quando tutti vanno verso lo stesso punto, local avoidance e RVO, ostacoli dinamici, budget delle richieste di percorso — e perché il problema di solito non è dove lo cerchiamo. Con esempi interattivi.
-
Game design
Colpire impossibile mancare
Il seguito della storia del coyote time: in uno sparatutto in rete bisogna mentire non sulla posizione del personaggio ma sul tempo. Perché il giocatore vede il nemico dove sul server non c’è più, come il server costruisce una macchina del tempo dalla cronologia delle hitbox, di quanti tick riavvolgere il mondo e dove sta il limite, perché non riavvolgere tutti, come impedire al client di mentire, cosa fare con i colpi di un giocatore già morto e in cosa la lag compensation differisce dal rollback. Con esempi interattivi.
-
Game design
Coyote time, ovvero come mentire un po’ ai giocatori
I giocatori chiamano bug un salto fisicamente corretto — «sei a terra, puoi saltare»: le persone vedono un movimento continuo, il gioco vede frame discreti, e in mezzo si perdono i millisecondi di reazione. Da dove vengono il coyote time e il coyote dei cartoni, perché serve anche un jump buffer, perché il numero giusto di millisecondi non esiste, come queste concessioni cambiano la difficoltà e le aspettative dei giocatori e perché un buon gioco a volte deve mentire.
-
Prestazioni
Tieni l’hot path al fresco e la cache al caldo
Nei giochi conta non la banda di memoria ma la latenza: quanto passa tra richiesta e risposta mentre tutti i sistemi del frame si dividono un’unica L3. Il riscaldamento software della cache con accessi fittizi e dove ti spara nei piedi, una struttura che «è semplicemente cresciuta» e ha rotto tutto, il costo dell’indirezione degli handle, un prefetch software che ha pagato solo su 32 MB, chiamate virtuali non poi così costose, cali di cache che non sono veri cali, un inquinatore di cache che ha ingannato se stesso e il blocco hardware della cache su Intel, AMD e PS5.
-
Mestiere
Da dove viene la complessità
La seconda parte di «Giochi sporchi»: nessuno scrive codice complesso per divertimento — la complessità arriva insieme a un numero: 16 ms per frame, 5 GB di memoria disponibile, un limite sulla dimensione della patch, dieci secondi al primo frame interattivo. I livelli di broadphase da O(n²) a un BVH SIMD come meccanismo per comprare complessità, perché due vincoli sono peggio di uno due volte, come il data-oriented design trascina la cache line attraverso tutta l’architettura, limiti rigidi e morbidi con il budget di memoria di una console, il paradosso di Jevons nel gamedev e i vincoli che non stanno in nessun documento.
-
Mestiere
Giochi sporchi
Perché i giochi con un’architettura «sporca» vendono milioni di copie mentre quelli su motori eleganti con ECS e job system restano nel backlog: un budget di frame in cui la logica di 200 nemici costa 0,05 ms, il culto cargo delle interfacce da GDC, Vampire Survivors su Phaser, Balatro su Löve e VVVVVV, lo stack noioso come gestione del rischio, un GameManager monolitico e un Tick lineare contro un EventBus — e dove la semplicità si rompe davvero: confini tra dati e logica, salvataggi e certificazione.
-
C++
Cosa si può fare con un array di array
Un indice inverso «località → reggimenti» per lo snapshot dello stato di gioco in uno strategico 4X: perché vector<vector<uint>> su un milione di località spende 72 byte ogni 24 utili e 90 ms per copia, e come tre hack — «conta, poi alloca», un unico buffer con somma prefissa e solo offsets (CSR) — rendono la build 17 volte più veloce, lo snapshot 23 volte e l’attraversamento casuale 3,6 volte. In più: heap frammentato, linee di cache, da dove arriva il milione di oggetti in uno strategico e perché il trucco è più vecchio dei giochi e dell’ECS.
-
C++
Queste api fanno il C++ sbagliato
Il «C++ arkanizzato» di un team di Austin: un C++14 privato di eccezioni, RTTI e new/delete globali. Result<T, E> con [[nodiscard]] e un unico panic() con source_location, zero frame allocations e venti allocazioni per frame pagate con uno stack da 20 MB, memoria a domini con FrameArena/StagePool/LevelHeap, OpenSSL e zlib riscritti e librerie di terze parti chiuse in processi worker isolati con watchdog — e perché il tempo di frame si comprava con il tempo di vita del programmatore.
-
C++
Anatomia dei rastrelli che pestiamo
Una tassonomia degli amici chitinosi di un motore di gioco: il refuso che il cervello autocorregge, l’off-by-one e l’ottimizzazione prematura, la scrittura oltre il bordo di un pool fisso, le perdite di memoria e di riferimenti, la corruzione della memoria con causa e sintomo separati nel tempo, le race condition, il fix del venerdì, gli heisenbug, i feature-bug da Street Fighter II al bunny hopping di Quake, l’effetto farfalla sui float, le dipendenze spaghetti, l’inversione di priorità e il delta time variabile.
-
Game design
Fibonaccia i nemici
Stringhe di uni e due, il rango come somma delle cifre — e i numeri di Fibonacci, noti nell’India antica mille anni prima di Fibonacci stesso. Il grafo di Young-Fibonacci, le quattro regole di Fomin e Stanley, e due studi che ci sono arrivati per conto loro piazzando i nemici: il rango della stringa come budget del segmento, gradazione al posto dei salti casuali di difficoltà, e il reticolo di Young dentro un albero tecnologico.
-
Mestiere
Gioca ai giochi buoni, a quelli brutti non giocare
Quindici anni di gamedev e ancora nessun modo di spiegare a tuo figlio perché il suo gioco è brutto. La retention c’è in ogni gioco che vi sia piaciuto — da Elden Ring a Tetris — e l’unica cosa che si è spostata è dove sta la cassa. L’attrito conta più della qualità, tre persone in lobby stendono sia BG3 sia Miyazaki, e l’aritmetica di un’ora di contenuto spiega perché gli studi «buoni» fanno comunque servizi.
-
Mestiere
Limoni, giochi e l'economia dei remake
Il «mercato dei bidoni» di Akerlof applicato ai motori di gioco: quello che si vende non è l’architettura ma una scena demo costruita su asset comprati, l’opinione ingegneristica vale meno di un caffè del mattino, e «compra, non costruire» assembla un gioco con moduli di terzi che non sanno nulla né della vostra memoria né del vostro gioco. Dove finisce la core competency tecnologica e perché perderla si conclude in una catena di montaggio di remake.
-
Mestiere
Cosa hanno regalato le console agli sviluppatori
Cinquant’anni di regali delle console allo sviluppatore: la cartuccia Fairchild ha separato il gioco dall’hardware, la «corsa al pennello» sull’Atari 2600 ha creato una professione a sé, Exec sull’Intellivision è stato il primo SDK e il 10NES è diventato il modello di licensing. Poi Mode 7, la memory card, gli achievement dell’Xbox 360 e l’abbonamento al posto del gioco — e il conto che per ogni regalo è toccato pagare.
-
Mestiere
La produzione è caduta, Milord
Cronaca della caduta del castello di Krivengard: uno statuto che unifica ogni segnale viene introdotto nove giorni prima di un assedio, in cantina dorme il congegno dimenticato di mastro Godfrid e uno scrivano parsimonioso ha lasciato l’ottava torre fuori dal registro. Una fortezza che aveva resistito a undici assedi cadde senza che una sola pietra fosse sfondata — e nel post-mortem non si trovò alcun colpevole.
-
Mestiere
L'inglese invece del codice
COBOL, SQL, 4GL, CASE, UML e No-Code promettevano di liberare l'industria dai programmatori e ogni volta generavano una nuova specializzazione con la sua forbice salariale. Perché il «linguaggio naturale invece del codice» sbatte contro un tetto: ambiguità ineliminabile, teorema di Rice, la teoria della rappresentazione del discorso di Kamp e Heim — e il paradosso di Jevons, per cui il codice più economico fa solo crescere la domanda di sviluppatori.
-
Programmazione anormale
Guida sul campo a EASTL
La seconda parte della guida alle librerie «standard» altrui, ora su EASTL di Electronic Arts: perché la STL si adatta male al gamedev su console, allocatori-oggetto con stato e flag invece del legame col tipo, container fixed e intrusive, sorted vector e reset() per la memoria scratch — e come molte di queste idee siano poi arrivate nello standard.
-
Programmazione anormale
Dirty Coding Tricks, part 3
Un seguito scherzoso della classica raccolta Dirty Coding Tricks: leggende di studio e aneddoti del gamedev — un avviso di batteria scarica al posto del fix di un crash in Super Time Force, un contatore FPS che sistemava la fisica in Burnout 3, scoiattoli-timer invisibili in Titan Quest, il Gandhi nucleare, i poliziotti impazziti che hanno dato vita a GTA e i giochi sovietici da calcolatrice.
-
Programmazione anormale
Finiremo tutti lì…
Ogni motore di gioco attraversa quattro fasi — da «tutto è un oggetto» e un GameObject divino, passando per componenti e config, fino al proprio linguaggio di scripting, e poi il cerchio si chiude. Perché il data-driven non è affatto inevitabile, in cosa l'architettura differisce dalla progettazione dei sistemi e quale sia il motore più costoso del settore che conviene buttare piuttosto che riparare.
-
Mestiere
Le vittime del clean code
Perché lo scambio «10% di prestazioni per la comodità del programmatore» nel gamedev colpisce sia i giochi sia gli sviluppatori stessi: il clean code di Martin come strato di astrazione in più, cache miss e chiamate virtuali contro le SoA, il costo non solo del runtime ma di ogni iterazione, e come i rallentamenti si propagano nel grafo ciclico di dipendenze di studio, motori e SDK.
-
Mestiere
Dove può crescere un senior nel gamedev
Tre percorsi di crescita fondamentalmente diversi dopo il senior nel gamedev: architetto (sistema di sistemi), tech lead (tecnologia e profondità) e producer (prodotto e mercato). Il prezzo di ogni percorso, gli ibridi e le transizioni asimmetriche fra loro, i super-producer come Bobby Kotick, l'archetipo dell'«uomo-brindisi» e come capire da che parte vi tira.
-
Programmazione anormale
Il peggior linguaggio di programmazione di tutti i tempi /s
Perché il C++ viene criticato: lo zoo delle inizializzazioni, parole chiave che mentono, decine di tipi interi, una libreria standard non standard, errori dei template illeggibili e astrazioni non proprio a costo zero. E perché tutto converge in un unico punto — la retrocompatibilità a costo di tutto.
-
Corso · C++
Cosa fanno davvero new e delete
In cosa le espressioni new/delete del C++ differiscono da malloc/free: le chiamate a costruttori e distruttori, operator new/delete e il lavoro con la memoria grezza — con un'analisi dell'assembly. Una lezione gratuita del corso «C++ senza allocazioni di memoria».
-
Corso · C++
Come funziona una vtable
Come un compilatore C++ implementa le funzioni virtuali: il vptr nascosto, la vtable e il dispatch dinamico — con un'implementazione artigianale del meccanismo a base di puntatori a funzione. Una lezione gratuita del corso «C++ senza allocazioni di memoria».
-
Corso · C++
Container associativi della STL
I container associativi della STL: set, map, multiset e multimap — in cosa differiscono, quando le chiavi sono uniche e quando si ripetono, con brevi esempi. Una lezione gratuita del corso «C++ senza allocazioni di memoria».
-
Corso · C++
Compromessi tra heap e stack
Heap contro stack: determinismo, frammentazione, dimensione del binario e footprint di memoria — perché nei giochi e sulle console conviene ridurre al minimo lo heap. Una lezione gratuita del corso «C++ senza allocazioni di memoria».
-
Programmazione anormale
Comprimere una megalopoli fino alle dimensioni di un iPhone 4
Il ventre ingegneristico di SimCity BuildIt mobile: come un city builder desktop è stato stipato nei 100–300 MB di RAM di un iPhone — un'economia server-authoritative a timer, un client-terminale «stupido», batching aggressivo, un renderer TBDR con settori di anteprima, una simulazione svuotata con ingorghi fatti di sprite e l'elettricità come Capacità − Domanda. Più la storia dello studio di San Pietroburgo EA SPB.
-
Programmazione anormale
Guida sul campo alle STL degli altri
Un giro tra le librerie C++ «standard» alternative di studi di gioco e grandi aziende: EASTL e le sue best practice, LLVM SmallVector/DenseMap, Folly e l'anatomia di fbstring (SSO, COW e l'accoppiata con jemalloc), boost flat_map, i container serializzabili di Zmeya e il value-oriented programming di Adobe — perché è nata ciascuna e dove ci si può far male.
-
Programmazione anormale
C++101 (Parte 1)
Un catalogo di ~100 idiomi e tecniche C++ nato dalla sezione Game++. Parte 1: risorse e compilazione — RAII, scope guard, copy-and-swap, smart pointer, copy-on-write, Pimpl e Fast Pimpl, interface class, include/inline/export guard, CRTP, Barton-Nackman, EBO e metafunzioni.
-
Programmazione anormale
C++101 (Parte 2)
Parte 2: metaprogrammazione e template — traits, tag dispatching, int-to-type, type selection, SFINAE ed enable-if, member detector, policy-based design, type erasure, thin template, named template parameters, expression templates e result_of, più i costruttori named e computazionali e base-from-member.
-
Programmazione anormale
C++101 (Parte 3)
Parte 3: inizializzazione, polimorfismo e container — chiamare funzioni virtuali durante l'inizializzazione, construction tracker, NVI e thread-safe interface, acyclic visitor, tipi di ritorno covarianti, virtual friend function, algebraic hierarchy, tipi valore polimorfici, funtori, iterator pair, generic container, erase-remove, safe bool e attorney-client.
-
Programmazione anormale
C++101 (Parte 4)
Parte 4: friendship, memoria degli oggetti e C++ moderno — non-member non-friend, SOO/SSO, vietare lo heap, execute-around pointer, temporary proxy, nullptr, costruttore di move, boost mutant, deprecate and delete, function poisoning, rule of zero/three/five, most vexing parse, pass-key e l'operatore spaceship.
-
Programmazione anormale
Come la GUI dei giochi viene riscritta (Parte 2)
Il seguito: l'architettura della UI di gioco lungo sei assi indipendenti — la posizione rispetto al mondo (diegetica / HUD / meta / spaziale / narrativa, da Metroid Prime e Dead Space a Spec Ops e Hellblade), la funzione, la rappresentazione in memoria (scene graph, lista piatta, immediate mode, ECS), il flusso dei dati (MVC/MVVM, reattivo, unidirezionale, data binding), il layout (constraint, flexbox, anchor, RIMD) e il rendering (canvas, layer, SDF, GPU-driven). Parte 2.
-
Programmazione anormale
Perché la GUI dei giochi viene riscritta (Parte 1)
L'architettura della UI di un gioco e perché viene riscritta da un progetto all'altro: un albero di controlli come Composite, proprietà con reflection, il disaccoppiamento dal codice di gioco tramite binding, template a prototipi molto prima dei Prefab di Unity, tre livelli di handler, l'hit testing basato sulle forme, messaggi sincroni, layout e 9-slice, coordinate intere, un Bridge sopra il renderer, stili come CSS, il dolore della localizzazione, i font SDF e la UI diegetica (Dead Space, Doom, Metro). Parte 1.
-
Mestiere
Sulle persone "capitate per caso" nell'IT
Una risposta all'affermazione che «senza una laurea attinente è inutile persino provare a entrare nell'IT»: la storia dell'industria dei videogiochi come storia di avvocati, casalinghe, piloti, maschere di cinema ed esportatori di fagioli in scatola. Da Gary Gygax e D&D a Miyamoto, Iwatani, Roberta Williams, Will Wright, Kojima, Molyneux, Miyazaki, Notch, Eric Barone e Davey Wreden — persone senza alcuna esperienza pertinente che hanno costruito tutto ciò a cui avete giocato.
-
Mestiere
Perché i programmatori sovietici non fecero GTA
Perché il paese che ha progettato il Buran, il Tu-160 e i rompighiaccio nucleari non ha mai prodotto un gioco di massa di livello occidentale: un gioco come grande impresa ingegneristica, da dove arrivano gli sviluppatori di talento, due conti spannometrici sul blocco socialista, l'«aspirapolvere di talenti» globale della Silicon Valley, un giro nel gamedev post-sovietico da Tetris e Vangers a S.T.A.L.K.E.R., Atomic Heart e War Thunder — e perché un «Unreal russo» non si evoca su ordinazione.
-
Programmazione anormale
Il resource manager
Perché un resource manager non è un singleton ma un intero sottosistema del motore: l'identità di una risorsa come coppia (sorgente + parametri), una cache con weak reference e LRU, parametri espliciti e impliciti, reload mirato e hot-reload, il ripristino dopo il device lost dai pool di D3D9 a DX12/Vulkan, una base template condivisa per i manager e il cambio delle impostazioni grafiche senza riavvio — con esempi da Unreal, Unity, Source, id Tech, Godot, No Man's Sky e Cyberpunk.
-
Programmazione anormale
Compromessi architetturali nello sviluppo di videogiochi
Una grande analisi di pattern architetturali e compromessi nel gamedev: layer, metalayer, sottosistemi, pipes & filters, microkernel e blackboard con esempi da Source, CryEngine, Unreal, id Tech e Naughty Dog; le strategie di design (top-down/bottom-up/refactoring costante), l'asse push contro pull, i linguaggi di scripting e il ripensamento dei GoF nel C++ moderno dei giochi.
-
Mestiere
Tre in barca, per non parlar della miseria e dei cani
Uno sguardo onesto sullo stato dell'industria dei videogiochi nel 2026: indie che vanno avanti a entusiasmo e stock option, i casinò dei giochi-servizio, remaster di remaster, sviluppatori che migrano nelle «sussidiarie» per uno stipendio, e il gamedev come arte di negoziare con se stessi — dove siamo tutti nella stessa barca che fa acqua.
-
C++
Lo using disobbediente
Perché using namespace e l'ADL rendono imprevedibile la risoluzione dei nomi in C++: l'argument-dependent lookup e operator<<, il dirottamento di std con un sostituto locale, la verifica della viability delle funzioni, i ranghi delle conversioni implicite e perché le funzioni =delete partecipano alla overload resolution come candidate a pieno titolo.
-
Mestiere
Sui programmatori 10x
I programmatori 10x esistono o sono un mito delle startup e il sogno di un manager: cinque tipi reali di sviluppatori «veloci» — la persona fusa con il progetto, quello che scrive meno codice, DoItProperlyMan, la competenza di nicchia e il mito del focus — e perché il 10x riguarda sempre il contesto accumulato, non un coefficiente innato.
-
Prestazioni
Come funziona la memoria nelle console di gioco
Una storia dell'architettura della memoria delle console dall'Atari 2600 fino a PS5 e Xbox Series: il conteggio dei cicli e i blank, la condivisione del bus e il DMA, la RDRAM veloce-ma-lenta del N64, il tile renderer del Dreamcast, le tre isole di memoria della PS2, le SPU e il Local Store della PS3, l'unificazione della memoria sulla PS4 e l'SSD come nuovo livello della gerarchia di memoria.
-
Mestiere
Come non confondere un sogno, un portfolio e un secondo lavoro
Sui pet project nel gamedev: perché un progetto «da un paio di serate» si trasforma in anni di vita, in cosa imparare differisce dallo scrivere il proprio motore, perché una piccola libreria sopravvive più spesso di un ambizioso tuttofare, il costo del C++ per i progetti hobbistici e come l'open source diventa silenziosamente un secondo lavoro.
-
C++
Il name lookup semplice in C++
Il lookup dei nomi semplice (unqualified) e qualificato in C++: perché un namespace e una variabile locale con lo stesso nome convivono, il nascondimento dei nomi e di interi overload set nell'ereditarietà, l'ambiguità dell'ereditarietà a diamante, la regola dello using-namespace nel qualified lookup e le differenze storiche tra GCC, Clang e MSVC.
-
C++
Anche i compilatori si confondono con i nomi
Il name lookup in C++: identificatori, unqualified-id, qualified-id, template-id e il «nome terminale», la storia dell'ADL (Koenig lookup) dal conflitto dei namespace alla soluzione di Koenig, il two-phase lookup nei template e perché GCC, Clang e MSVC si sono storicamente comportati in modo diverso.
-
Prestazioni
Calcoli ridondanti
Come l'esecuzione speculativa e la branch prediction interagiscono con il sottosistema di memoria: perché il codice branchless non è sempre più veloce, il costo di una misprediction rispetto alla latenza della memoria, la storia da Tomasulo al Pentium Pro, la ricerca binaria e benchmark sul Jaguar (PS4).
-
C++
Generalizzazioni in C++ (parte 2)
La continuazione del capitolo 1 di PragmatiC++: identità e uguaglianza degli oggetti, procedure e call stack, le convenzioni di chiamata e le categorie in/out/in-out, la base computazionale dall'ENIAC ad AMX, e la regolarità dei tipi come guida pratica per progettare astrazioni prevedibili.
-
Prestazioni
Perché non abbiamo cache L5?
Perché una CPU ha più livelli di cache invece di uno solo grande: la fisica dei segnali sul die, l'analogia delle palline di Natale, la storia dall'i486 a Nehalem, perché L1I e L1D sono separate, i protocolli di coerenza (MSI/MESI/MOESI…), eDRAM e HBM come L4 «nascosta» e perché una L5 per ora non ha senso.
-
Mestiere
Sulla gioia di programmare e l'imponderabilità dei traguardi
Riflessioni di uno sviluppatore che ha vissuto l'epoca in cui il codice si scriveva a mano, senza assistenti IA: perché un traguardo raggiunto troppo facilmente sembra non pesare nulla, come l'IA elimina l'«attrito utile» e lo stato di flow, e dove può trovarsi la nuova maestria del programmatore — nell'architettura e nella profondità delle decisioni più che nella velocità di battitura.
-
Mestiere
Scrivere codice è più facile che scrivere un libro sullo scrivere codice
Come la serie Game++ su Habr è diventata un libro sul C++ pragmatico e lo sviluppo di motori: cos'è un «buon» C++, le persone che hanno aiutato a far nascere il libro, l'editing come mestiere a sé e un grande blocco di risposte alle domande frequenti su come scriverlo e pubblicarlo.
-
Prestazioni
A caccia degli fps rossi
Il profiling dei giochi come filosofia di sviluppo: l'evoluzione delle aspettative sugli FPS, come i contenuti degli artisti danneggiano le prestazioni (geometria, texture, render, culling), i metodi di profiling — sampling, instrumentation, tracing, event-based, analisi statica e replay — e il design di un tracing profiler con architettura zero-allocation e handle per le stringhe.
-
Mestiere
Perché l'università non forma programmatori
Perché l'istruzione universitaria classica non trasforma gli studenti in programmatori: docenti senza esperienza sul campo, il circolo vizioso degli stipendi, la programmazione come abilità pratica al pari del suonare la chitarra, il mentorato negli studi e perché i programmatori si formano da autodidatti.
-
Mestiere
Niente panico, sei appena atterrato nel gamedev AA+
Come non farsi prendere dal panico quando si finisce in un grande studio AA+ con una codebase da milioni di righe: orientarsi nel legacy altrui, i sistemi di build, perché i senior non ricordano il codice a memoria, cercare per stringhe visibili all'utente, la history di git, il code style e perché il sorgente è la verità ultima.
-
Programmazione anormale
Miti, superstizioni e saggezza popolare nello sviluppo di giochi
Uno sguardo a 12 «verità» comuni del gamedev in C++ — quali sono miti, quali superstizioni e quali saggezza popolare: il culto del C puro, la «cattiva build buona», il costo di eccezioni e RTTI, smart pointer e container STL, il polimorfismo, l'assembly inline, il template bloat, l'ottimizzazione prematura e la maledizione del commit del venerdì.
-
Programmazione anormale
Uno zoo di stringhe nel tuo codice C++?
Un grande giro tra i tipi di stringa del C++ come tra gli animali di uno zoo: char* e char[N], le string literal, std::string e SSO, string_view, pmr::string, QString, NSString, std::wstring, le frame string, la FString di Unreal, StringAtom e l'interning, le stringhe COW e gli StringID basati su hash — e dove ciascuno trova posto nei motori di gioco.
-
Prestazioni
Il buono, il brutto, il colorato e il veloce
Allocatori di memoria anomali dalla pratica: un allocatore che traccia i lifetime per dare la caccia ai leak, un allocatore randomizzante (chaos) per lo stress test dei sistemi long-running, un allocatore «colorato» per l'isolamento dei sottosistemi (Deathloop) e il veloce TLSF — con diagrammi e un benchmark in cicli di CPU.
-
Programmazione anormale
Sii il breakpoint di te stesso
Come funzionano i breakpoint software e hardware: la sostituzione di un byte con int 3 (0xCC), i registri di debug x86-64 DR0–DR7 e il layout di DR7, breakpoint condizionali, di funzione e temporanei, un watchpoint in scrittura via GetThreadContext, un canary per i buffer e un pulsante per i breakpoint hardware direttamente in un editor di gioco ImGui.
-
Game design
Perché Pharaoh resta il miglior gioco della serie
Perché il Pharaoh originale (1999) è più profondo di Zeus e del remake A New Era: la distribuzione dei lavoratori tramite reclutatori contro un pool globale, tassare le case povere, la struttura delle missioni, 20 livelli abitativi e la logica delle migrazioni, la «stupidità egizia» dei camminatori di servizio con le svolte casuali — con il codice ricostruito nel remake Akhenaten.
-
Prestazioni
Respingo i commit che usano lo heap e chiedo ai colleghi di riscrivere quella logica
L'esperienza di costruire grandi giochi C++ senza heap: perché le allocazioni dinamiche sono pericolose su console e mobile (frammentazione, degrado dei tempi di malloc, un rifiuto in certificazione) e con cosa sostituirle — container a dimensione fissa gtl::vector<T,N>, etl/FastDelegate al posto di std::function, CRTP e polimorfismo statico con std::variant, object pool e placement new.
-
Game design
Gameplay a scatola nera
Il gameplay a scatola nera negli strategici e nei city builder: perché la serie Caesar/Pharaoh/Zeus nascondeva numeri e meccaniche, sandbox contro missioni scriptate, il limite cognitivo delle 12 coppie, perché la combinatoria delle meccaniche conta più della quantità di contenuti e perché un bilanciamento «rotto» trattiene i giocatori per anni — con Age of Empires II come esempio.
-
Programmazione anormale
Game++. Trappole di prestazioni
Il finale della serie Game++: le comuni trappole di prestazioni del C++ — allocazioni inutili, la RVO traditrice, una std::function pesante, identificatori stringa costosi, una funzione seno approssimata, la divisione lenta, il costo dei cache miss, std::pair/tuple e il prezzo della virtualità — con benchmark su quick-bench e storie dalla produzione.
-
Reverse engineering
La meccanica dell'evoluzione delle case in Pharaoh (1999)
Come funziona l'evoluzione delle case in Pharaoh (1999): le case come FSM, il sistema di bisogni e attributi (desiderabilità del terreno, tasse, sicurezza antincendio, salute), gli overlay, lo switch di evoluzione ricostruito dall'originale, il consumo di cibo e risorse, il buffer condiviso runtime_data e l'aggiornamento delle texture, sull'esempio del remake Akhenaten.
-
Programmazione anormale
Game++. while (!game(over))
Vale la pena scrivere il proprio motore di gioco: perché e se serve davvero, cos'è un motore e cosa fa — il game loop, l'input, la grafica, gli asset, l'audio, la fisica, script e config, il networking, l'IA, la UI e l'architettura (approccio a librerie, GodObject, ECS), più il tooling — con codice, link a librerie ed esperienza personale.
-
Programmazione anormale
Game++. Rattoppando i pattern
I design pattern nei giochi: cosa sopravvive del «libro blu» dei GoF e quali pattern hanno attecchito proprio nel gamedev — Command, State e FSM con stack pushdown, Flyweight e instancing, Observer ed EventBus, Dirty Flag, Update Layers e GOAP — con codice, diagrammi e casi d'uso.
-
Mestiere
Scrivi codice e basta
Un manifesto nello spirito di «scrivi codice e basta»: mentre tutti gli altri discutono in riunione su quale board spostare il ticket, nessuna Jira scriverà mai il bugfix. Sul codice-spazzatura che funziona, i titoli svalutati, i colloqui leetcode e l'idea che se non ci sono bug — semplicemente non hai scritto codice.
-
Programmazione anormale
Game++. Work hard
I modelli di concorrenza nei motori di gioco: stato shared/separate/shadow, worker e thread pool, worker stateless (Assassin's Creed, Factorio), catene di worker e IO non bloccante, le fiber di Naughty Dog e la libreria marl — con diagrammi, codice e benchmark di caricamento.
-
Mestiere
Un paio di cose che un programmatore di giochi dovrebbe sapere
Una raccolta di «leggi» sarcastiche dello sviluppo di giochi: su std::move, l'undefined behavior, GameObject ed ECS, la submission per la cert e i TRC, gli Heisenbug, il debito tecnico, // TODO e //TMP, i manager, gli artisti e le patch del venerdì — l'amara verità del gamedev in una riga.
-
Programmazione anormale
Game++. Heap? Less
Come i giochi si liberano delle allocazioni sullo heap: le cinque regioni di memoria, stack contro heap, determinismo e frammentazione, RVO/NRVO, stringhe inplace locali e pmr::string, il polimorfismo ad-hoc con std::variant e ottimizzazioni reali di vector/map/string via monotonic_buffer_resource e profiler.
-
Mestiere
Perché gli sviluppatori di giochi restano su C++17
Perché gli studi di gioco non hanno fretta di passare a C++20 e restano su C++17: auto e un +10-15% sui tempi di compilazione, Visual Studio come miglior debugger al mondo, l'economia di build farm e strumenti, la diffidenza verso STL e Boost nel gamedev, l'assenza di test automatizzati e perché il debugging non scala.
-
Programmazione anormale
Game++. Spacchettare i container
I container specializzati nei motori di gioco: fixed array e matrici, vector linear/stable/sparse/packed/static/small/dirty/buddy, deque e bcdeque, bounded_priority_deque, liste intrusive, octree e quadtree, object_pool, ring buffer, cached_hashtable, handle_container e slot_container — come funzionano, diagrammi e dove si usano.
-
Mestiere
Game++. Costruire archi
Le architetture dei motori di gioco e la legge di Conway: l'approccio unitario (Big Ball of Mud) in Unity, a layer in Unreal Engine, il microkernel in CryEngine e O3DE, il data-driven in Dagor, il monolite in X-Ray e il micro-modulare in Godot — storia, pro e contro di ciascuno.
-
Game design
Ready Player One
La storia dei videogiochi: dai cabinati arcade e i giochi sui mainframe a Computer Space, Atari e Pong, Galaxian e Pac-Man, Donkey Kong, la nascita delle console, l'Atari 2600, il crash del 1983, Nintendo, Sega e l'era del PC.
-
Programmazione anormale
Game++. corri, thread, corri…
Il multithreading nei giochi: i problemi dei lock (deadlock, thread starvation, priority inversion in Cyberpunk 2077 e Crysis), il memory model del C++11, lock-free e atomics, spinlock con backoff, thread pool e task system, l'hitching, un mutex read-write e 8 regole per un buon threading.
-
Mestiere
Game++. Giocoleria con gli algoritmi STL
Perché gli algoritmi STL sono il C++ «conversazionale»: mostrano Cosa fai, non Come; eliminano i bug sui limiti, sulle collezioni vuote e le «prestazioni spalmate» e ti danno codice di qualità da compilatore. La storia di EASTL, iteratori e back_inserter, il caching degli shader via set_difference e un grande cheat sheet degli algoritmi.
-
Programmazione anormale
Game++. Danze con gli allocatori
Un grande giro tra gli allocatori di memoria nei giochi: linear, step-back, frame/double/N-frame, stack e double-stack, pool, free list, arena, segregated, buddy, thread-cache, fibonacci, compacting, hot/cold splitting e TLSF — con codice, diagrammi, casi d'uso e un benchmark.
-
Reverse engineering
Welcome to Ancient…
Pharaoh (1999): perché il city builder non parte su Windows 10/11 (il bug del 640×480, lo scaling, gli overlay, il bussare a un servizio Microsoft ormai morto, l'audio) e in cosa la demo differisce dalla versione retail — schermate, menu, texture prese da Caesar III, le piene del Nilo, i canali di irrigazione e i contenuti tagliati. Illustrato con il remake Akhenaten.
-
Programmazione anormale
Game++. Cucinare i vector
Come funzionano i vector nei motori e cosa paghi per averli: la crescita della capacity e la frammentazione della memoria, composizione singola contro a cascata, std::array, uno static_vector sullo stack, hybrid_vector con un'ottimizzazione in stile SSO e le insidie degli allocatori pmr e delle implementazioni vendor di monotonic_buffer_resource.
-
Programmazione anormale
Game++. String interning
Lo string interning (string pooling) nei motori di gioco: una sola copia della stringa per tutti i riferimenti, l'interning delle literal in clang/GCC e perché il trucco si rompe su Xbox, il pericolo del confronto con ==, la lotta alla frammentazione della memoria e una semplice implementazione di xstring su hash con reference counting.
-
Mestiere
In Spagna tutti i programmatori sono senior
In cosa il lavoro negli studi gamedev occidentali differisce dai team post-sovietici: la cultura della «delazione», il non toccare i task altrui, tutta la comunicazione attraverso il PM, la cortesia eccessiva, il rispetto guadagnato con i task risolti, le stranezze dei team nazionali, la comunicazione contestuale contro quella dettagliata e le frasi-àncora.
-
Prestazioni
Come far entrare un elefante in una valigia
I livelli di ottimizzazione nel porting dei giochi su hardware debole (Switch, Apple TV, mobile): architettura, algoritmi e codice. La storia di un costoso controllo di escaping delle stringhe — da un ingenuo loop con early-exit a una versione branchless, una lookup table e SIMD con _mm_movemask_epi8, con le tabelle dei tempi di caricamento su iPhone.
-
Prestazioni
Spears & bits
Impacchettare i booleani nei bit nei giochi: std::bitset, std::vector<bool>, un ingenuo array di byte e l'approccio di CryEngine, benchmark con picchi a 32/64/128, i miss del branch predictor e una vettorizzazione SSE finale con _mm_movemask_epi8 — da 4 ms a 1 ms per frame.
-
Prestazioni
Pensare a task nei motori di gioco
I pattern fondamentali dei task system nei motori di gioco: spostare movimento, fisica, script, path-finding, animazione, rendering e I/O su thread separati, il raggruppamento dei task, il message passing e un confronto tra un task semplice, un thread manager e un task manager.
-
Mestiere
Buoni libri per un programmatore di IA nel gamedev
Una lista di letture per un programmatore di IA di gioco, con opinioni personali: AI for Game Developers, Game AI Pro, Game Engine Gems, The Pyramid of Game Design, Behavioral Mathematics for Game AI e AI Game Programming Wisdom — cosa leggere e come.
-
Programmazione anormale
Il pesante H[eader]
Come il tempo di build completa di un grande progetto C++ è stato ridotto da 15:32 a 5:16: l'antivirus e l'explorer, gli header template pesanti, le forward declaration, i precompiled header, PIMPL e la disattivazione di analizzatori, unit test e LTO — con le tabelle dei tempi di build degli header.
-
Prestazioni
Un 486 dovrebbe bastare a tutti
Quali tecnologie general-purpose sono apparse nelle CPU dai tempi del 486 e usiamo ogni giorno: cache e prefetch, la TLB, l'esecuzione speculativa, NUMA, SIMD, l'out-of-order, il GPGPU e la branch prediction — con esempi dalle console e benchmark.
-
Programmazione anormale
Come Unity ha rinunciato alle proprie stringhe
La storia delle stringhe COW di Unity: copy-on-write con condivisione parziale dei buffer e allocazioni quasi a zero, lo scontro con il design di
std::string, i dangling pointer e perché alla fine il motore è tornato alla libreria standard. -
Reverse engineering
ECS, dynvtbl, thread logici e Pharaoh
Archeologia del codice del motore di Pharaoh e Caesar III: un ECS dell'antico Egitto su array piatti, una VMT ridotta all'osso fatta di callback, thread logici del secolo scorso e un god object per risparmiare memoria.
-
Programmazione anormale
Capo, è tutto perduto
Il seguito di «Dove sono i tuoi bug?»: 16 bug da venerdì sera da motori e giochi reali — scritture out-of-bounds, handle persi su Switch,
memsetsu un tipo non triviale,=!al posto di!=eallocain un loop. Indovina tu la causa. -
Prestazioni
Quello non copiarlo e basta
Passaggio per valore contro
const&, allocazioni nascoste su stringhe e vector,reservee un crollo reale a 10 FPS — il tutto con benchmark su QuickBench. -
Programmazione anormale
Le stringhe nei motori di gioco
Perché
std::stringè malvista nei motori: C-string e NTBS, SSO e string_view, stringhe sized/pool/arena, stringhe condivise e identificatori, più il parsing dei config in SIMD. -
Game design
Prendi il giocatore, pagante o no…
I dark pattern di monetizzazione nei giochi: ricompense giornaliere, valuta premium, loot box, power creep, time gate e il framework onnicomprensivo MINDSPACE — come gli studi giocano sulla psicologia dei giocatori.
-
Game design
Cosa possiamo imparare dal vecchio BioShock: Infinite?
Lezioni di game design da BioShock: Infinite: il principio di chiarezza, narrativa fissa ed emergente, l'illusione della scelta e la narrazione a strati di Ken Levine — e come uno sparatutto lineare rompe la quinta parete.
-
Prestazioni
E 20 core ancora non bastano
Undici tecniche di ottimizzazione C++ da motori in produzione: cache warming, dispatch a compile time, loop unrolling, signed/unsigned e corrispondenza dei tipi, isolamento degli hotpath, SIMD, prefetch, constexpr e lock-free — con benchmark e storie di guerra.
-
Game design
Per un pugno di achievement
La psicologia delle meccaniche di collezione nei giochi: dominanza, socializzazione, l'effetto del set incompleto e l'invidia; i tipi di collezioni per disponibilità; achievement ed equipaggiamento come collezioni.
-
Game design
L'ultimo dei Deus Ex
Uno sguardo ai livelli di Deus Ex: Mankind Divided — il Dawn Engine, lo stile visivo nero e oro, l'attenzione ai dettagli, la variabilità contro la storia e la combinatoria delle meccaniche immersive-sim.
-
Game design
I corridoi non raccontano storie
Come l'architettura e il level design raccontano una storia, con BioShock come esempio: corridoi e ombre, magneti visivi, la storia congelata, la geometria tarata sulle caratteristiche dei nemici e un pizzico di feng shui.
-
Game design
Mi mancano le meccaniche dei vecchi giochi
Un brontolio sulle meccaniche perdute dei vecchi giochi: obiettivi chiari, design sistemico, livelli basati sul comportamento, i livelli dei nemici, l'apprendimento attraverso l'interazione, ricompensa e punizione, il karma e i muri invisibili.
-
Game design
Il problema del barile rosso
Cos'è un «barile rosso» nel game design: come i barili esplosivi sono diventati un cliché degli sparatutto e perché le meccaniche ereditate accumulano domande e alla fine restano inutilizzate dai giocatori.
-
Mestiere
Cos'è il C++ nel gamedev?
Perché il gamedev è legato al C++ e come il linguaggio vive dentro un motore su tre livelli: il number-crunching hardcore, il C++ «ordinario» con script e hot-reload, e un metalivello con reflection e generazione di codice.
-
Mestiere
Cos'altro dovrebbe leggere un programmatore di giochi?
Una lista di approfondimento: Joel on Software, Blood, Sweat, and Pixels, il codice sorgente di Doom 3, MISRA C++, EASTL, daScript, i talk della GDC e i blog che vale la pena leggere.
-
Mestiere
Cosa dovrebbe leggere un programmatore di giochi?
Una lista di libri, blog e repository per un programmatore di giochi: da Code Complete ed Effective C++ a Game Engine Architecture, Game AI Pro, la GDC e le awesome-list su GitHub.
-
Mestiere
Perché [non] ti serve un motore di gioco tutto tuo
Perché studi e indie costruiscono il proprio motore invece di usare Unreal/Unity: quanto costa, quanto è difficile, l'esperienza diretta con Frostbite, Unity e Dagor — e perché la tecnologia su misura fa avanzare l'industria.
-
Programmazione anormale
La magia dello swizzle degli shader in C++
Implementare lo swizzle (vec.xxy, vec.zx, vec.rgb) in C++ con union e template: da una prima versione copia-incollata a un'unica soluzione constexpr, un bug con l'operator= di default e benchmark contro glm e CxxSwizzle.
-
Mestiere
Sei sicuro di voler diventare un programmatore nel gamedev?
Uno sguardo onesto dall'interno: cosa fanno davvero i programmatori nel gamedev, i colloqui, gli straordinari, i motori e le loro scuole, le tradizioni degli studi, i designer — e perché ne vale comunque la pena.
-
Strumenti
Non di sola Unity…
Un giro tra 50+ motori e framework di gioco oltre Unity: da nCine, RayLib e SDL2 a Godot, CryEngine, Unreal e DagorEngine — link, linguaggi, licenze e note di prima mano.
-
Game design
Generazione procedurale delle coperture nei giochi
Generare automaticamente i punti di copertura per gli NPC dalla geometria del livello: l'attraversamento dei bordi della navmesh, i raypick, la scrematura dei candidati e la valutazione delle coperture a runtime. Esempi dal 4A Engine.
-
Reverse engineering
Come viene disegnata la mappa in Pharaoh
L'algoritmo di rendering della mappa isometrica, della città e delle animazioni in Pharaoh: diagonal-path e zig-zag, l'ordinamento per profondità, i layer e il formato originale della mappa.
-
Programmazione anormale
Dove sono i tuoi bug?
Una raccolta di bug selvaggi da motori reali: un punto e virgola mancante in Unity, un
memseteliminato dal compilatore, race sui bitfield in CryEngine, il most vexing parse e un'altra dozzina — trova il bug da solo. -
Programmazione anormale
Quando è private ma vorresti tanto public
Testare i membri privati di una classe C++ senza toccare gli header: da 100+ friend e #define private public a un hack con i template che scambia un tipo puntatore-a-membro.
-
Programmazione anormale
Perché l'SDK di Switch ha tre funzioni sin diverse?
Facendo il porting di giochi su Nintendo Switch ho trovato tre implementazioni di sin nell'SDK — ed ecco cosa ha mostrato il disassemblato per -O1, -O3 -math:precise e -O3 -math:fast.
-
Programmazione anormale
Il nome di un enum C++ a runtime
Ottenere il nome di un tipo e i valori di un enum a runtime in C++ senza RTTI — via __PRETTY_FUNCTION__, template e magia constexpr.
-
Game design
Bisogna tenere i giocatori per mano?
Tecniche di level design da Witcher 3, Zelda e Metro Exodus — guidare i giocatori senza portarli per mano.
-
Prestazioni
Non c'è fretta… (sugli spinlock)
Implementazioni di spinlock in C++ — dal TAS ingenuo al ticket spinlock — con benchmark, cache miss e le sfumature della prioritizzazione dei thread.
-
Prestazioni
Cache inquinata? Fai scorta di test
Come cache, associatività, coerenza e allineamento dei dati influenzano le prestazioni — con benchmark.
-
Reverse engineering
Reverse engineering di Caesar III: estrarre le texture
Il formato texture .sg2/.555, la palette RGB555, IDA e Hex-Rays — e come un hobby è diventato un remake. Parte 1.
-
Reverse engineering
Reverse engineering di Caesar III: il rendering della città
Il formato della mappa, la selezione dei tile e l'ordine di disegno, il rendering della città. Parte 2.
-
Reverse engineering
Reverse engineering di Caesar III: la logica di gioco
La simulazione dei cittadini, gli spostamenti, le code di eventi.
-
Reverse engineering
Reverse engineering di Caesar III: la generazione del mondo
La generazione procedurale del mondo e delle mappe.
-
Reverse engineering
Reverse engineering di Caesar III: il modello della città
Il modello interno della città: dati, layer, stato.
-
Reverse engineering
Reverse engineering di Caesar III: il game loop
Il calcolo di una giornata della città: il loop di simulazione, gli dèi, l'umore dei cittadini, le tasse, la salute e le strutture dati.