// Sottoinsieme di Phaser 3.55.2 usato da Vampire Survivors, tradotto in C dai // sorgenti originali (MIT, photonstorm/phaser, src/time, src/tweens, // src/animations, src/physics/arcade). Nomi e passi seguono l'originale; dove // il gioco non usa un ramo (gravita', drag, accelerazione, tilemap) il ramo manca. #ifndef PHASER_H #define PHASER_H #include "vs.h" typedef struct Sprite Sprite; // --- Memoria della partita: tutto cio' che una partita alloca si libera in blocco alla successiva // (Phaser ricarica la scena e lascia il resto al garbage collector) -------------------------------- void *gmem_calloc(size_t n, size_t size); void *gmem_realloc(void *p, size_t size); void gmem_free(void *p); void gmem_reset(void); size_t gmem_count(void); typedef void (*Callback)(void *ctx); // --- Clock / TimerEvent (src/time) ------------------------------------------ // Il giocatore per cui gira un pezzo di logica (in partita a due): timer, tween, collider e animazioni nascono nel contesto // corrente e ci tornano quando scattano. Con un giocatore solo e' sempre 0. extern int game_context; void game_context_set(int player); typedef struct TimerEvent { int context; float delay, elapsed, timeScale; double repeatCount; int paused, hasDispatched, active, pendingRemoval; Callback callback; void *ctx; unsigned gen; } TimerEvent; typedef struct { int idx; unsigned gen; } Timer; // riferimento sicuro a un evento (gli eventi si riciclano) Timer time_addEvent(float delay, int loop, int repeat, Callback cb, void *ctx); void time_removeEvent(Timer t); TimerEvent *time_get(Timer t); // NULL se l'evento non esiste piu' void time_reset(void); void clock_preUpdate(void); void clock_update(float delta); // --- Tween (src/tweens/tween/Tween.js + TweenManager.js, ease Linear) -------- // Solo cio' che il gioco usa: target numerici senza 'from', yoyo, repeat, loop, // delay, onComplete/onRepeat. 'scale' scrive scaleX e scaleY (t2). #define TWEEN_DATA 3 enum { TS_PENDING_ADD, TS_INIT, TS_ACTIVE, TS_PAUSED, TS_PENDING_REMOVE, TS_REMOVED }; enum { TD_CREATED, TD_DELAY, TD_PENDING_RENDER, TD_PLAYING_FORWARD, TD_PLAYING_BACKWARD, TD_COMPLETE }; typedef struct { float *t, *t2; float start, end, endCfg, current, elapsed, delay, duration; int state, yoyo; double repeat, repeatCounter; float (*ease)(float); // NULL = Linear float (*get)(void *o); // proprieta' calcolata (getter/setter, es. Face.x): t = NULL void (*set)(void *o, float v); void *o; } TweenData; typedef struct Tween { int context; TweenData inl[TWEEN_DATA], *data; // data = inl, o sul heap oltre TWEEN_DATA (targets: array di molti oggetti) int totalData, state, pausedState, paused, inAdd, inActive, inPending; double loop, loopCounter; float timeScale; Callback onComplete, onRepeat, onYoyo; // onYoyo: una volta per ogni TweenData che fa yoyo, come l'originale Callback onStart; // quando il primo dato esce dal delay (TWEEN_START); di nuovo dopo restart Callback onUpdate; // TWEEN_UPDATE: qui una volta per passo attivo (l'originale: per TweenData; uguale con un solo dato) int hasStarted; void *ctx; unsigned gen; int used, persist; } Tween; typedef struct { int idx; unsigned gen; } TweenRef; typedef struct { float *t, *t2; float end; float (*get)(void *o); void (*set)(void *o, float v); void *o; } TweenProp; typedef struct { TweenProp props[TWEEN_DATA]; int nprops; float duration, delay; int yoyo, repeat, loop; // repeat/loop: -1 = infinito int paused; // 'paused': true -> resta in attesa finche' non si chiama play/resume float (*ease)(float); // NULL = Linear; Ease_BounceOut, Ease_SineInOut Callback onComplete, onRepeat, onYoyo, onStart, onUpdate; void *ctx; const TweenProp *many; // al posto di props quando i TweenData sono piu' di TWEEN_DATA int nmany; int persist; // il chiamante tiene il riferimento e lo fa ripartire dopo la fine (restart/play): lo slot non si libera } TweenConfig; TweenRef tweens_add(TweenConfig c); float Ease_BounceOut(float v); // src/math/easing float Ease_SineInOut(float v); float Ease_ExpoOut(float v); float Ease_ExpoIn(float v); float Ease_QuintOut(float v); float Ease_BackOut(float v); float Ease_SineOut(float v); Tween *tween_get(TweenRef r); int tweens_used(void); // VS_PROF: slot occupati su 4096 void tween_restart(TweenRef r); void tween_stop(TweenRef r); void tween_remove(TweenRef r); // scene.tweens.remove int tween_isPaused(TweenRef r); void tween_pause(TweenRef r); void tween_play(TweenRef r); void tween_resume(TweenRef r); void tweens_reset(void); void tweens_preUpdate(void); void tweens_update(float delta); // --- Animazioni (src/animations) --------------------------------------------- #define ANIM_MAX_FRAMES 64 typedef struct { const Frame *frames[ANIM_MAX_FRAMES]; int n, repeat; // repeat -1 = infinito float frameRate, msPerFrame; } Animation; typedef struct { const Animation *cur; int index, isPlaying, paused, wasPlaying, repeatCounter; float accumulator, nextTick, timeScale; } AnimationState; // --- Arcade Physics: Body (src/physics/arcade/Body.js) ------------------------ typedef struct { int none, up, down, left, right; } Flags; typedef struct Body { Sprite *gameObject; int enable, isCircle, allowRotation, immovable, pushable, moves, customSeparateX, customSeparateY, embedded; float radius, rotation, preRotation, mass, angle, speed; float width, height, sourceWidth, sourceHeight, halfWidth, halfHeight; Vector2 offset, position, prev, prevFrame, center, velocity, newVelocity, deltaMax, bounce, maxVelocity; struct { float x, y, rotation, scaleX, scaleY, displayOriginX, displayOriginY; } transform; float overlapX, overlapY, overlapR; Flags checkCollision, touching, wasTouching, blocked; float _sx, _sy, _dx, _dy, _tx, _ty; int inWorld; // setCollideWorldBounds(true, bx, by) + setBoundsRectangle(r) + onWorldBounds: evento 'worldbounds' come callback del corpo int collideWorldBounds, hasWorldBounce; int noGravity; // setAllowGravity(false) Vector2 worldBounce; const Rectangle *customBounds; void (*onWorldBounds)(void *ctx); void *onWorldBoundsCtx; } Body; void body_setCircle(Body *b, float radius, float offsetX, float offsetY); void body_setSize(Body *b, float width, float height); // rettangolo centrato sul fotogramma (center = true) void body_setOffset(Body *b, float x, float y); void body_updateCenter(Body *b); static inline float body_right(const Body *b) { return b->position.x + b->width; } static inline float body_bottom(const Body *b) { return b->position.y + b->height; } // --- Sprite (Phaser.Physics.Arcade.Sprite, solo i componenti usati) ---------- struct Sprite { float x, y, scaleX, scaleY, angle, originX, originY, alpha; double depth; // Number come in JS: ZInGameUI = MAX_SAFE_INTEGER - 1000 deve restare distinto int context; // game_context quando e' nato unsigned drawSeq; // scene_render: ordine di inserimento nella lista di disegno int flipX, flipY, visible, active, onDisplayList, scrollFactor0; // scrollFactor0: setScrollFactor(0), coordinate di schermo int blendAdd; // setBlendMode(ADD) unsigned tint; int tintFill; const Frame *frame; float width, height; // dimensione reale del fotogramma (frame.realWidth) AnimationState anims; Callback onAnimationComplete; void *owner; // l'oggetto del gioco che possiede lo sprite void (*draw)(Sprite *s); // disegno personalizzato (NULL = sprite normale) unsigned groups; // appartenenza veloce ai gruppi (Set di Phaser) int hasBody; Body body; }; void sprite_init(Sprite *s, const Frame *f, float x, float y); void sprite_setFrame(Sprite *s, const Frame *f); void sprite_setScale(Sprite *s, float sc); void sprite_setOrigin(Sprite *s, float ox, float oy); void sprite_setVelocity(Sprite *s, float vx, float vy); void sprite_setTint(Sprite *s, unsigned tint); void sprite_setTintFill(Sprite *s, unsigned tint); void sprite_clearTint(Sprite *s); void anims_play(Sprite *s, const Animation *a, int startFrame); void anims_pause(Sprite *s); void anims_resume(Sprite *s); void anims_stop(Sprite *s); void sprite_animsUpdate(Sprite *s, float delta); // UpdateList per uno sprite fuori dalla lista di disegno int anims_generateFrameNames(const char *atlas, const char *prefix, int start, int end, int zeroPad, const Frame **out, int max); // --- Lista di disegno (scene.children) e lista di aggiornamento -------------- void children_add(Sprite *s); void children_remove(Sprite *s); void children_reset(void); // --- World (src/physics/arcade/World.js) -------------------------------------- typedef struct { Sprite **items; int n, cap; unsigned bit; } SpriteList; // Group / Array; bit != 0: contains O(1) void list_add(SpriteList *l, Sprite *s); void list_remove(SpriteList *l, Sprite *s); int list_index(const SpriteList *l, const Sprite *s); int list_contains(const SpriteList *l, const Sprite *s); void list_free(SpriteList *l); // --- Tilemap (src/tilemaps: mappe Tiled ortogonali, un solo tileset) --------- typedef struct { int index; // gid, -1 = vuoto float rotation; unsigned char flipX, collides, faceTop, faceBottom, faceLeft, faceRight; } Tile; typedef struct { // Tilemap + Tileset (addTilesetImage con margin/spacing) cJSON *json; int width, height, tileWidth, tileHeight; Texture2D tex; int firstgid, margin, spacing, columns; Tile *layerData[16]; // LayerData per nome (createLayer): condivisi dalle copie della stessa mappa const char *layerName[16]; int n_layers; short *v3foot, *v3top; // vista 3D: riga piu' bassa e piu' alta del pezzo in piedi (muro, mobile, albero) di ogni cella unsigned char *v3solid; // 1 se la cella e' di un pezzo con almeno una tessera di muro/ostacolo (le decals da sole restano a terra) unsigned v3ver; // tiles_ver con cui sono stati calcolati } Tilemap; typedef struct TilemapLayer { Sprite s; // game object nella lista di disegno (depth, visible) Tilemap *map; Tile *data; float x, y; unsigned tint; // forEachTile(tile.tint = c): la stessa tinta su tutte le tile del layer short *rowMin, *rowMax; // tilemapLayer_draw: prima e ultima colonna non vuota per riga (rowMin > rowMax: riga vuota) unsigned rowsVer; // versione delle tessere con cui sono state calcolate (tiles_ver in phaser.c) int stand; // vista 3D: 0 a terra, 1 in piedi intero (ostacoli, chiome), 2 piegato a scatola (muri), 3 decals int v3hide; // vista 3D: non si disegna (Shadows: l'ombra finta del 2D coprirebbe le pareti in piedi) } TilemapLayer; Tilemap *make_tilemap(const char *jsonPath, const char *imagePath, int margin, int spacing); // scene.make.tilemap + addTilesetImage TilemapLayer *tilemap_createLayer(Tilemap *m, const char *name, double depth); // NULL se il layer manca void tilemap_resetLayers(Tilemap *m); // a ogni partita: i layer si ricreano dal JSON void tilemap_free(Tilemap *m); void tilemap_removeTilesWithin(Tilemap *m, const char *except, int x, int y, int w, int h); cJSON *tilemap_getObjectLayerObjects(Tilemap *m, const char *name); void tilemapLayer_setCollisionByProperty(TilemapLayer *l, const char *prop); // { prop: true } + CalculateFacesWithin Tile *tilemapLayer_getTileAtWorldXY(TilemapLayer *l, float x, float y); // NULL fuori mappa o vuoto void tilemapLayer_removeTileAt(TilemapLayer *l, int tx, int ty); // RemoveTileAt(x, y, true, true): vuota e ricalcola le facce attorno typedef void (*PairCallback)(void *ctx, Sprite *a, Sprite *b); typedef enum { COLLIDE_ARRAYS, COLLIDE_GROUP_SELF, COLLIDE_TILEMAP } ColliderKind; typedef struct { SpriteList *object1, *object2; TilemapLayer *layer; // COLLIDE_TILEMAP: object1 contro il layer ColliderKind kind; PairCallback collideCallback; void *ctx; int overlapOnly, active, context; } Collider; Collider *physics_addCollider(SpriteList *a, SpriteList *b, PairCallback cb, void *ctx); Collider *physics_addOverlap(SpriteList *a, SpriteList *b, PairCallback cb, void *ctx); Collider *physics_addColliderSelf(SpriteList *g, PairCallback cb, void *ctx); Collider *physics_addOverlapSelf(SpriteList *g, PairCallback cb, void *ctx); // overlap(gruppo, gruppo): senza la coppia con se stesso int physics_overlapCirc(float x, float y, float r); // physics.overlapCirc(x, y, r, true).length Collider *physics_addColliderLayer(SpriteList *g, TilemapLayer *l); // physics.add.collider(sprite/gruppo, tilemapLayer) Collider *physics_addColliderLayerCb(SpriteList *g, TilemapLayer *l, PairCallback cb, void *ctx); // ... con collideCallback(sprite, tile = NULL) void physics_existing(Sprite *s); // scene.physics.add.existing void physics_reset(void); void world_update(float delta); void world_postUpdate(void); // --- Camera (startFollow, lerp 1) e disegno ---------------------------------- extern float world_gravityY; // physics.world.gravity.y (le spell Jupiter e Mars) extern float camera_scrollX, camera_scrollY; extern float camera_followOffsetX; // cameras.main.followOffset.x (scossone del boss del ponte) extern int game_width, game_height; // scale.setGameSize void camera_follow(const Sprite *target); void scene_update_list(float delta); // UpdateList: preUpdate degli sprite (animazioni) void scene_render(Shader fill); extern int prof_children, prof_custom, prof_offscreen, prof_breaks, prof_tiles; extern float scene_zoom_out; // game_draw, prima di scene_render void scene_render_one(Sprite *s, Shader fill); extern int scene_fillActive; extern float scene_world_zoom; extern int scene_view3d; // vista 3D: mondo su un piano in prospettiva, sprite in piedi (il HUD resta 2D) extern float view3d_dist, view3d_pitch; extern double scene_ui_depth; // zoom del mondo attorno al centro della vista: lo sprite da scene_ui_depth in su (HUD) non scala void physics_drawDebug(void); // World.drawDebug: corpi attivi // un solo sprite con la pipeline normale // --- Particelle (src/gameobjects/particles, sottoinsieme) -------------------- // Valori: {min,max} = decimale casuale all'emissione; {start,end} = lineare sulla vita. typedef struct { float a, b; int kind; float (*ease)(float); } EmitterOp; // kind: 0 fisso (a), 1 casuale min/max, 2 start/end (ease: NULL = Linear) #define EOP(v) ((EmitterOp){ (v), (v), 0 }) #define ERND(lo, hi) ((EmitterOp){ (lo), (hi), 1 }) #define ERANGE(s, e) ((EmitterOp){ (s), (e), 2 }) typedef struct { const Frame *frames[24]; int nframes, quantity, on, blendAdd, hasZone, nonRadial, flowEveryFrame; EmitterOp speed, speedY, angle, lifespan, alpha, scale, rotate, xOffset; // nonRadial: velocita' = (speed, speedY) float gravityY, frequency, zoneRadius; // zona: cerchio casuale centrato sul punto di emissione int collideBottom, collideTop; // bounds con collideBottom / collideTop (Particle.checkBounds): bordi inferiore e superiore float bounce, boundsH; // bounds.height; bounds.y sta nell'emettitore (cambia a runtime) int collideLeftRight; // bounds con collideLeft/collideRight (di default veri): bordi x e x + boundsW float boundsX, boundsW; float rotateStep; // rotate.onUpdate: angolo += rotateStep a ogni update int angleSteps; // angle { start: angle.a, end: angle.b, steps }: EmitterOp.steppedEmit const Frame **frameRef; // texture condivisa che cambia (RenderTexture ridisegnata a ogni frame): fotogramma corrente int frameCycle; // frame { frames, cycle: true }: in sequenza invece che a caso const Vector2 *edge; // emitZone { type: 'edge', quantity }: punti in sequenza (yoyo falso) int nEdge; unsigned tint; unsigned tints[8]; // tint { onEmit: RND.pick(lista) } unsigned tintEnd; // tint { start: tint, end: tintEnd }: interpolazione del numero intero (EmitterOp), non dei canali int hasTintEnd; int ntints; EmitterOp scaleY; // scaleX / scaleY separati: scale fa da scaleX int hasScaleY; const Sprite *follow; int hasZoneRect; // emitZone { type: 'random', source: Rectangle }: Rectangle.Random, relativo al punto di emissione Rectangle zoneRect; } EmitterConfig; typedef struct { float x, y, vx, vy, life, lifeCurrent, scale, scaleStart, alpha, alphaStart, angle, scaleY; unsigned tint; const Frame *frame; } Particle; typedef struct ParticleEmitter { EmitterConfig c; Particle *alive; int n, cap; float counter, x, y, boundsY, stepCounter; int edgeIndex, frameIndex; } ParticleEmitter; typedef struct ParticleManager { // ParticleEmitterManager: un game object della lista di disegno Sprite s; ParticleEmitter *emitters[8]; int nemit, scrollFactor0; // setScrollFactor(0): coordinate di schermo (scene UI) int hasWell; // createGravityWell: un solo pozzo float wellX, wellY, wellPower, wellEpsilon; // _power = power * gravity, _epsilon = epsilon^2 int hasWell2; // W_Spellstrom: un secondo pozzo, stessi power ed epsilon float well2X, well2Y; } ParticleManager; ParticleManager *particles_add(void); // scene.add.particles ParticleEmitter *particles_createEmitter(ParticleManager *m, EmitterConfig c); void emitter_emitParticleAt(ParticleEmitter *e, float x, float y, int count); // count <= 0: quantity void manager_emitParticleAt(ParticleManager *m, float x, float y); void particles_update_all(float delta); int particles_alive(void); // VS_PROF // UpdateList: preUpdate dei manager void particles_manager_update(ParticleManager *m, float delta); // manager fuori dalla scena di gioco void particles_manager_draw(ParticleManager *m); void emitter_start(ParticleEmitter *e); void emitter_stop(ParticleEmitter *e); // --- rexShatterImage (plugin rex, GameObjects.ShatterImage): Mesh ortografica su una texture, spezzata in triangoli --- typedef struct { float x, y, u, v, alpha; } MeshVertex; // Geom.Mesh.Vertex (z = 0, colore bianco) typedef struct { MeshVertex *vertex1, *vertex2, *vertex3; float _rotation, g; } MeshFace; // ShatterImage Face typedef struct ShatterImage { Sprite s; // x, y, scaleX/Y, alpha, depth; disegno: shatter_draw const Texture2D *tex; // la texture della RenderTexture (isRenderTexture: v capovolta) float width, height; // setSizeToFrame MeshVertex *vertices; MeshFace *faces; int nfaces; float variation; int samplesPerRing; TweenRef task; int hasTask; } ShatterImage; ShatterImage *shatterImage_add(float x, float y, const Texture2D *tex, float w, float h); // scene.add.rexShatterImage void shatterImage_shatter(ShatterImage *im); // shatter() al centro TweenProp face_prop(MeshFace *f, int which, float end); // which: 0 alpha, 1 angle, 2 x, 3 y (proprieta' di Face per i tween) // --- Varie: physics.closest, velocityFromRotation, Graphics circle ------------ Sprite *physics_closest(const Sprite *from, SpriteList *targets); Vector2 velocityFromRotation(float rad, float speed); #endif