Wiki

01 How the engine works

Visual Java is a desktop IDE built on top of the regular Java toolchain — it doesn't invent a new runtime, it makes an existing one visible and easier to reach. Every project you build is, underneath, a normal Java program; Visual Java's job is to generate that program for you from two sources at once: the scenes you build visually, and the .jvl code you write.

The compile pipeline

When you press Run, four things happen in order:

1. Every .jvl file in main/jvl is scanned into a shared class registry, so files can call each other's methods before any of them is translated.
2. The JVL preprocessor rewrites JVL syntax (classes, events, named parameters, key checks, System.print, …) into plain, compilable Java, and injects the runtime API classes (VJObject, Scene, Camera, Mouse, Physics, and friends) so your code can call them without imports.
3. The generated Java is compiled in memory. Errors are mapped back to your original .jvl line numbers and shown in the Console and inline in the editor.
4. The compiled program is launched inside a runtime window (ProgramFrame for 2D, a jMonkeyEngine app for 3D), and its output — including scene commands — streams back into the Console in real time.

Two views of the same project

The Scene Editor (2D or 3D) and the code editor are two windows onto the same objects. Placing a rectangle in the Scene Editor and setting its color in the Inspector sends the exact same kind of scene command (OBJ_CREATE, OBJ_COLOR, …) that calling player.setColor(...) from JVL would send at runtime. That's why an object built visually can be picked up from code with VJObject.load(...), and an object built in code shows up live in the running scene.

Rendering

2D projects render with a custom Graphics2D canvas (ProgramCanvas) that understands shapes, images, glow, rotation and layers. 3D projects render through jMonkeyEngine (Jme3SceneApp), with a fly camera for editing, a transform gizmo, ambient/fog settings and an optional pixelation filter for a retro look.

01 Come funziona il motore

Visual Java è un IDE desktop costruito sopra il normale toolchain Java — non inventa un nuovo runtime, rende visibile e più accessibile uno già esistente. Ogni progetto che costruisci è, sotto il cofano, un normale programma Java; il compito di Visual Java è generare quel programma per te a partire da due fonti contemporaneamente: le scene che costruisci visivamente e il codice .jvl che scrivi.

La pipeline di compilazione

Quando premi Run, accadono quattro cose in ordine:

1. Ogni file .jvl in main/jvl viene scansionato in un registro di classi condiviso, così i file possono chiamare i metodi l'uno dell'altro prima che uno qualsiasi venga tradotto.
2. Il preprocessore JVL riscrive la sintassi JVL (classi, eventi, parametri nominati, controlli dei tasti, System.print, …) in Java normale e compilabile, e inietta le classi dell'API runtime (VJObject, Scene, Camera, Mouse, Physics e altre) così il tuo codice può chiamarle senza import.
3. Il Java generato viene compilato in memoria. Gli errori vengono ricollegati ai numeri di riga originali del tuo .jvl e mostrati nella Console e in linea nell'editor.
4. Il programma compilato viene lanciato dentro una finestra runtime (ProgramFrame per il 2D, un'app jMonkeyEngine per il 3D), e il suo output — inclusi i comandi di scena — arriva in tempo reale nella Console.

Due viste dello stesso progetto

L'editor di scena (2D o 3D) e l'editor di codice sono due finestre sugli stessi oggetti. Posizionare un rettangolo nell'editor di scena e impostarne il colore nell'Inspector invia lo stesso tipo di comando di scena (OBJ_CREATE, OBJ_COLOR, …) che invierebbe a runtime la chiamata player.setColor(...) da JVL. Per questo un oggetto creato visivamente può essere ripreso da codice con VJObject.load(...), e un oggetto creato da codice appare live nella scena in esecuzione.

Rendering

I progetti 2D vengono renderizzati con un canvas Graphics2D personalizzato (ProgramCanvas) che gestisce forme, immagini, glow, rotazione e layer. I progetti 3D vengono renderizzati tramite jMonkeyEngine (Jme3SceneApp), con una fly camera per l'editing, un gizmo di trasformazione, impostazioni di ambiente/nebbia e un filtro opzionale di pixelazione per un look retro.

02 The JVL language

JVL (Visual Java Language) is what you write in .jvl files. It looks like Java with the ceremony sanded off: no access modifiers to choose, no boilerplate public static void main, and a small set of extra rules for events and parameters.

Classes

Declare a class with just class Name { } — no public, no extends required. Anything declared directly inside the braces, outside a method, becomes a class field:

class Main {

    int score = 0;
    boolean gameOver = false;

    void Main(String[] args) {
        System.print("Hello from Main!");
    }
}

Events

Put one of these annotations directly above a method to hand it to the runtime's event loop — you never call these methods yourself:

Event	Fires
@onStart	Once, when the scene/program starts.
@onUpdate	Every frame (~60 times per second).
@onDestroy	Once, when the object or program is being torn down.
@onClick	On a mouse click.
@onMouseMove	Whenever the mouse moves.
@onKeyPress	On a key press, with the key passed to the method.
@WhenStartClone	Once, on each clone created from this object.

@onUpdate
void tick() {
    if (KEY_RIGHT) player.moveX(4);
    if (KEY_LEFT)  player.moveX(-4);
}

Key checks

Any bare KEY_NAME used as a boolean condition (KEY_LEFT, KEY_RIGHT, KEY_UP, KEY_DOWN, KEY_SPACE, letter and number keys, …) is automatically resolved against the current keyboard state — no Keyboard.isDown(...) boilerplate.

Named parameters

Call a method with name = value pairs in any order; JVL reorders them onto the method's real signature for you:

Enemy.spawn(x = 200, y = 40, speed = 3);
// is rewritten to match Enemy's real method signature, in the order it was declared

Calling other classes

Call a method on another class the same way you'd call a local one, using the class name as a prefix: Enemy.tick();. Calling a class name with no arguments and no method, like Enemy();, runs every no-argument, non-event method that class declares, in the order they're written — a shortcut for a class that's really just a sequence of setup steps.

Printing and pausing

System.print(...) is JVL's console output — it becomes System.out.println(...). Calling .sleep(ms) on an object other than System/Thread pauses that object's own timeline without blocking the render loop; use System.sleep(ms) or Thread.sleep(ms) when you do want to block, e.g. inside a manual game loop.

Falling back to plain Java

If a file uses extends/implements right after the class name, or doesn't contain a recognizable class Name { at all, Visual Java assumes it's already plain Java and leaves the structure untouched (only small substitutions like System.print still apply). This is intentional: it means hand-written Java and JVL can live side by side in the same project.

02 Il linguaggio JVL

JVL (Visual Java Language) è ciò che scrivi nei file .jvl. Assomiglia a Java a cui è stata tolta la burocrazia: nessun modificatore di accesso da scegliere, nessun boilerplate public static void main, e un piccolo insieme di regole aggiuntive per eventi e parametri.

Classi

Dichiara una classe con solo class Nome { } — niente public, niente extends obbligatorio. Tutto ciò che viene dichiarato direttamente dentro le graffe, fuori da un metodo, diventa un campo della classe:

class Main {

    int score = 0;
    boolean gameOver = false;

    void Main(String[] args) {
        System.print("Hello from Main!");
    }
}

Eventi

Metti una di queste annotazioni direttamente sopra un metodo per affidarlo al loop di eventi del runtime — questi metodi non li chiami mai tu stesso:

Evento	Si attiva
@onStart	Una volta, all'avvio della scena/programma.
@onUpdate	Ogni frame (~60 volte al secondo).
@onDestroy	Una volta, quando l'oggetto o il programma viene distrutto.
@onClick	A un click del mouse.
@onMouseMove	Ogni volta che il mouse si muove.
@onKeyPress	Alla pressione di un tasto, passato come parametro al metodo.
@WhenStartClone	Una volta, su ogni clone creato da questo oggetto.

@onUpdate
void tick() {
    if (KEY_RIGHT) player.moveX(4);
    if (KEY_LEFT)  player.moveX(-4);
}

Controlli dei tasti

Qualsiasi KEY_NOME usato come condizione booleana (KEY_LEFT, KEY_RIGHT, KEY_UP, KEY_DOWN, KEY_SPACE, tasti lettera e numero, …) viene risolto automaticamente rispetto allo stato attuale della tastiera — niente boilerplate Keyboard.isDown(...).

Parametri nominati

Chiama un metodo con coppie nome = valore in qualsiasi ordine; JVL le riordina sulla firma reale del metodo per te:

Enemy.spawn(x = 200, y = 40, speed = 3);
// viene riscritto per corrispondere alla firma reale del metodo di Enemy, nell'ordine in cui è stata dichiarata

Chiamare altre classi

Chiama un metodo su un'altra classe come faresti con uno locale, usando il nome della classe come prefisso: Enemy.tick();. Chiamare un nome di classe senza argomenti e senza metodo, come Enemy();, esegue tutti i metodi senza argomenti e non-evento dichiarati da quella classe, nell'ordine in cui sono scritti — una scorciatoia per una classe che è in realtà solo una sequenza di passi di setup.

Stampare e mettere in pausa

System.print(...) è l'output console di JVL — diventa System.out.println(...). Chiamare .sleep(ms) su un oggetto diverso da System/Thread mette in pausa la timeline di quell'oggetto senza bloccare il ciclo di rendering; usa System.sleep(ms) o Thread.sleep(ms) quando vuoi davvero bloccare, ad esempio dentro un game loop manuale.

Tornare a Java puro

Se un file usa extends/implements subito dopo il nome della classe, o non contiene affatto un class Nome { riconoscibile, Visual Java presume che sia già Java puro e lascia la struttura invariata (si applicano solo piccole sostituzioni come System.print). È intenzionale: significa che Java scritto a mano e JVL possono convivere nello stesso progetto.

03 Project structure

Every project has the same shape, mirrored exactly by the Explorer panel:

project.yml

This single file is the project's configuration: it's what tells Visual Java whether to open the 2D or 3D Scene Editor, which class holds Main, and which Java language level to compile against. You rarely edit it directly — the New Project wizard and the editors keep it in sync — but it's plain YAML if you ever need to.

.vj files and saved scenes

When you place and configure an object in the Scene Editor and click Apply Modifications / Save Scene, its transform, color, texture and other Inspector fields are written to a small resource file under resources. From code, VJObject.load("player", "resources/vj/player.vj") reads that same file back into a live object — see Objects.

Multiple files, one program

You can split logic across several .jvl files (for example Main.jvl and Client.jvl); the preprocessor scans all of them together before translating any single one, so a method or a named-parameter call in one file can reference a class declared in another without extra imports.

03 Struttura di un progetto

Ogni progetto ha la stessa forma, rispecchiata esattamente dal pannello Explorer:

project.yml

Questo unico file è la configurazione del progetto: dice a Visual Java se aprire l'editor di scena 2D o 3D, quale classe contiene Main, e a quale livello di linguaggio Java compilare. Raramente lo modifichi direttamente — la procedura guidata Nuovo Progetto e gli editor lo tengono sincronizzato — ma è YAML semplice se mai ne avessi bisogno.

File .vj e scene salvate

Quando posizioni e configuri un oggetto nell'editor di scena e clicchi Apply Modifications / Save Scene, la sua trasformazione, colore, texture e gli altri campi dell'Inspector vengono scritti in un piccolo file risorsa sotto resources. Da codice, VJObject.load("player", "resources/vj/player.vj") rilegge lo stesso file in un oggetto vivo — vedi Oggetti.

File multipli, un solo programma

Puoi dividere la logica su più file .jvl (ad esempio Main.jvl e Client.jvl); il preprocessore li scansiona tutti insieme prima di tradurne uno qualsiasi, quindi un metodo o una chiamata con parametri nominati in un file può riferirsi a una classe dichiarata in un altro senza import aggiuntivi.

04 Scene Editor 2D

The 2D Scene Editor is where you lay out what a scene looks like before writing a single line of behaviour. It opens in the Scene 2D tab, next to your code tabs.

Toolbar

Tool	What it does
Select / Move / Rotate	Switch the cursor mode to pick objects, drag them, or rotate the selected one.
Gomma (Eraser)	Removes the object you click on from the scene.
Save Scene	Writes every object's current transform and appearance back to its .vj resource file.
Reset Camera / Fit All	Recenters the editor camera, or zooms to fit every object on screen.
New Object	Adds a rectangle, circle or triangle at the camera's center — start here for a new shape.

The Inspector

Selecting an object fills the Inspector on the right with everything about it:

• Element — Name and Type (rectangle, circle, triangle).
• Transform — X/Y position, W/H size, rotation and layer (draw order).
• Appearance — Color, transparency, brightness, darkness and glow ("Light": 0 = no light, 100 = full emitter).
• Tag & physics — an optional tag for Scene.findByTag(...), and a slide/friction value.
• Texture — pick an image file to render instead of a flat color, or clear it.

Changes apply live once you press Apply Modifications; Duplicate clones the selection, Delete removes it.

04 Editor di scena 2D

L'editor di scena 2D è dove definisci l'aspetto di una scena prima di scrivere una sola riga di comportamento. Si apre nella tab Scene 2D, accanto alle tue tab di codice.

Barra degli strumenti

Strumento	Cosa fa
Select / Move / Rotate	Cambia la modalità del cursore per selezionare oggetti, trascinarli o ruotare quello selezionato.
Gomma	Rimuove dalla scena l'oggetto su cui clicchi.
Save Scene	Scrive la trasformazione e l'aspetto attuali di ogni oggetto nel suo file risorsa .vj.
Reset Camera / Fit All	Ricentra la camera dell'editor, oppure esegue lo zoom per far entrare tutti gli oggetti a schermo.
New Object	Aggiunge un rettangolo, cerchio o triangolo al centro della camera — punto di partenza per una nuova forma.

L'Inspector

Selezionare un oggetto riempie l'Inspector a destra con tutte le sue informazioni:

• Elemento — Nome e Tipo (rettangolo, cerchio, triangolo).
• Transform — Posizione X/Y, dimensioni W/H, rotazione e layer (ordine di disegno).
• Aspetto — Colore, trasparenza, luminosità, scurezza e glow ("Light": 0 = nessuna luce, 100 = emettitore pieno).
• Tag e fisica — un tag opzionale per Scene.findByTag(...), e un valore di slide/attrito.
• Texture — scegli un file immagine da renderizzare al posto di un colore piatto, o rimuovila.

Le modifiche si applicano live premendo Apply Modifications; Duplicate clona la selezione, Delete la rimuove.

05 Scene Editor 3D

The 3D editor shares the same panel layout as the 2D one, built on jMonkeyEngine instead of a 2D canvas. It's newer than the 2D workflow (introduced in 1.5, made functional in 1.7) and grows with each release.

Navigating the scene

• Fly camera — orbit, pan and zoom around the scene while editing, independent of the in-game camera.
• Transform gizmo — drag handles on the selected object to move, rotate or scale it in 3D space, mirrored live in the Inspector's numeric fields.
• Ambient & fog — set ambient light color/intensity and distance fog directly from the scene panel; both are saved per-scene.

Look & post-processing

A pixelation filter is available for a deliberately retro, low-res look layered on top of full 3D geometry and lighting — handy for combining a pixel-art aesthetic (like the engine's own icon) with real 3D scenes.

05 Editor di scena 3D

L'editor 3D condivide lo stesso layout a pannelli di quello 2D, costruito su jMonkeyEngine invece che su un canvas 2D. È più recente del flusso 2D (introdotto nella 1.5, reso funzionale nella 1.7) e cresce a ogni release.

Navigare la scena

• Fly camera — orbita, panning e zoom nella scena durante l'editing, indipendente dalla camera di gioco.
• Gizmo di trasformazione — trascina le maniglie sull'oggetto selezionato per spostarlo, ruotarlo o scalarlo nello spazio 3D, specchiato live nei campi numerici dell'Inspector.
• Ambiente e nebbia — imposta colore/intensità della luce ambientale e la nebbia di distanza direttamente dal pannello scena; entrambi vengono salvati per scena.

Look e post-processing

È disponibile un filtro di pixelazione per un look volutamente retro e a bassa risoluzione, sovrapposto a geometria e illuminazione 3D complete — utile per combinare un'estetica pixel-art (come l'icona stessa del motore) con scene realmente 3D.

06 Objects: create & import

A VJObject is the base unit of anything visible in a scene — a rectangle, circle, triangle or image, with position, size, rotation, color and physics. You can get one of three ways.

1 · Create it purely from code

VJObject player = VJObject.rect("player", 100, 300, 40, 40, Color.CYAN);
VJObject enemy  = VJObject.circle("enemy", 500, 300, 40, Color.RED);
VJObject logo   = VJObject.createImage("logo", "resources/logo.png", 0, -200, 96, 96);

This is the fastest way to prototype: no editor step needed, the object appears in the running scene as soon as the line executes.

2 · Build it in the Scene Editor, then import it

Place and style the object visually (see Scene Editor 2D), name it, and Save Scene. Then pull it into code by its resource path — its transform, color, texture and rotation come along automatically:

VJObject player = VJObject.load("player", "resources/vj/player.vj");

The first argument is the name you'll use from now on in code; it doesn't need to match the file name. Loading removes the static copy the editor drew and replaces it with a live object your code fully controls.

3 · Import a single-line resource reference

A shorthand for the same idea, resolved at compile time instead of a runtime call:

import: resources.vj.player;

// generates a ready-made wrapper exposing:
player.setpos(x, y);
player.moveX(dx);  player.moveY(dy);
player.setColor(r, g, b);
player.setRotation(deg); player.rotate(deg);
player.getX(); player.getY(); player.getRotation();

Moving, rotating, styling

player.moveX(4);              // move relative to current X
player.moveY(-2);
player.move(3);                // move forward along current rotation
player.setPos(120, 40);
player.setRotation(90);
player.rotate(15);             // relative
player.setColor(255, 90, 0);
player.setSize(48, 48);
player.setLayer(2);            // draw order
player.hide(); player.show();

Collisions and lifetime

if (player.touch(enemy)) {
    System.print("Hit!");
    player.kill();
}

VJObject bullet = enemy.clone("bullet"); // spawn a tagged copy at enemy's position
bullet.fadeOut(400);                      // tween alpha to 0 over 400ms

The full method list — every getter, setter, tween and collision hook on VJObject — is documented with signatures on the Code & API page.

06 Oggetti: creare e importare

Un VJObject è l'unità base di tutto ciò che è visibile in una scena — un rettangolo, cerchio, triangolo o immagine, con posizione, dimensione, rotazione, colore e fisica. Puoi ottenerne uno in tre modi.

1 · Crealo interamente da codice

VJObject player = VJObject.rect("player", 100, 300, 40, 40, Color.CYAN);
VJObject enemy  = VJObject.circle("enemy", 500, 300, 40, Color.RED);
VJObject logo   = VJObject.createImage("logo", "resources/logo.png", 0, -200, 96, 96);

È il modo più rapido per prototipare: nessun passaggio nell'editor, l'oggetto appare nella scena in esecuzione non appena la riga viene eseguita.

2 · Costruiscilo nell'editor di scena, poi importalo

Posiziona e configura l'oggetto visivamente (vedi Editor di scena 2D), dagli un nome e premi Save Scene. Poi richiamalo da codice tramite il suo percorso risorsa — trasformazione, colore, texture e rotazione arrivano automaticamente:

VJObject player = VJObject.load("player", "resources/vj/player.vj");

Il primo argomento è il nome che userai da quel momento nel codice; non deve corrispondere al nome del file. Il caricamento rimuove la copia statica disegnata dall'editor e la sostituisce con un oggetto vivo controllato interamente dal tuo codice.

3 · Importa un riferimento a risorsa in una riga

Una scorciatoia per la stessa idea, risolta in fase di compilazione invece che con una chiamata a runtime:

import: resources.vj.player;

// genera un wrapper già pronto che espone:
player.setpos(x, y);
player.moveX(dx);  player.moveY(dy);
player.setColor(r, g, b);
player.setRotation(deg); player.rotate(deg);
player.getX(); player.getY(); player.getRotation();

Spostare, ruotare, stilizzare

player.moveX(4);              // sposta relativamente alla X attuale
player.moveY(-2);
player.move(3);                // avanza lungo la rotazione attuale
player.setPos(120, 40);
player.setRotation(90);
player.rotate(15);             // relativo
player.setColor(255, 90, 0);
player.setSize(48, 48);
player.setLayer(2);            // ordine di disegno
player.hide(); player.show();

Collisioni e ciclo di vita

if (player.touch(enemy)) {
    System.print("Hit!");
    player.kill();
}

VJObject bullet = enemy.clone("bullet"); // crea una copia con tag alla posizione di enemy
bullet.fadeOut(400);                      // anima l'alpha a 0 in 400ms

L'elenco completo dei metodi — ogni getter, setter, tween e hook di collisione su VJObject — è documentato con le firme nella pagina Codice & API.

07 Events, in practice

Events are the backbone of any JVL program: instead of writing your own game loop, you describe what happens at each moment and let the runtime call it.

class Main {

    VJObject player;

    @onStart
    void setup() {
        player = VJObject.rect("player", 0, 0, 40, 40, Color.CYAN);
        System.print("Ready.");
    }

    @onUpdate
    void loop() {
        if (KEY_RIGHT) player.moveX(4);
        if (KEY_LEFT)  player.moveX(-4);
    }

    @onKeyPress
    void keys(String key) {
        if (key.equals("SPACE")) player.rotate(90);
    }

    @onClick
    void click() {
        System.print("Clicked at " + Mouse.getX() + ", " + Mouse.getY());
    }

    void Main(String[] args) {
        System.print("Starting...");
    }
}

You can declare as many @onUpdate or @onKeyPress methods as you like, across as many classes as you like — Visual Java runs all of them every frame/keypress, in the order the files were compiled.

07 Eventi, in pratica

Gli eventi sono la spina dorsale di ogni programma JVL: invece di scrivere il tuo game loop, descrivi cosa succede in ogni momento e lasci che sia il runtime a chiamarlo.

class Main {

    VJObject player;

    @onStart
    void setup() {
        player = VJObject.rect("player", 0, 0, 40, 40, Color.CYAN);
        System.print("Ready.");
    }

    @onUpdate
    void loop() {
        if (KEY_RIGHT) player.moveX(4);
        if (KEY_LEFT)  player.moveX(-4);
    }

    @onKeyPress
    void keys(String key) {
        if (key.equals("SPACE")) player.rotate(90);
    }

    @onClick
    void click() {
        System.print("Clicked at " + Mouse.getX() + ", " + Mouse.getY());
    }

    void Main(String[] args) {
        System.print("Starting...");
    }
}

Puoi dichiarare quanti metodi @onUpdate o @onKeyPress vuoi, in tante classi quante vuoi — Visual Java li esegue tutti a ogni frame/pressione di tasto, nell'ordine in cui i file sono stati compilati.

08 Classes & method calls, across files

Split a project across several .jvl files and call between them without imports — the preprocessor builds a shared registry of every class before it translates any of them.

// Enemy.jvl
class Enemy {

    VJObject self;

    void spawn(double x, double y, int speed) {
        self = VJObject.circle("enemy", x, y, 40, Color.RED);
    }

    @onUpdate
    void patrol() {
        self.moveX(2);
    }
}

// Main.jvl
class Main {
    void Main(String[] args) {
        Enemy.spawn(x = 500, y = 300, speed = 3); // named parameters, any order
    }
}

08 Classi e chiamate tra file

Dividi un progetto su più file .jvl e chiama tra loro senza import — il preprocessore costruisce un registro condiviso di tutte le classi prima di tradurne una qualsiasi.

// Enemy.jvl
class Enemy {

    VJObject self;

    void spawn(double x, double y, int speed) {
        self = VJObject.circle("enemy", x, y, 40, Color.RED);
    }

    @onUpdate
    void patrol() {
        self.moveX(2);
    }
}

// Main.jvl
class Main {
    void Main(String[] args) {
        Enemy.spawn(x = 500, y = 300, speed = 3); // parametri nominati, in qualsiasi ordine
    }
}

09 Live collaboration

Visual Java can host a lightweight local collaboration session: open the collaboration panel, share the session with a teammate on your network, and both editors will show every connected user's cursor and camera live inside the same 2D or 3D scene, each tagged with a name and an assigned color.

Collaboration works at the scene level: object edits, new objects and camera movement sync between sessions, so it's best suited to pairing on level layout, lighting and object placement rather than simultaneous code editing.

09 Collaborazione live

Visual Java può ospitare una leggera sessione di collaborazione locale: apri il pannello di collaborazione, condividi la sessione con un collega sulla tua rete, ed entrambi gli editor mostreranno live il cursore e la camera di ogni utente connesso dentro la stessa scena 2D o 3D, ciascuno etichettato con un nome e un colore assegnato.

La collaborazione funziona a livello di scena: modifiche agli oggetti, nuovi oggetti e movimento della camera si sincronizzano tra le sessioni, quindi è più adatta a lavorare insieme su layout dei livelli, illuminazione e posizionamento oggetti piuttosto che sulla modifica simultanea del codice.

10 Plugins

Since 1.6, Visual Java can load plugins that extend the IDE itself — additional tools, panels or project templates — through a dedicated plugin manager. Plugin loading is aimed at extending the editor experience, distinct from the Minecraft plugin development features described next.

Official extensions are listed on the Extensions page and can be installed from the IDE with Import plugin online. As of 1.10 there are three: Minecraft Development, World Map Creator (3D worlds on real maps, with data from OpenStreetMap) and 3D Map Creator (3D maps on empty air, a World Map world or a procedural terrain).

10 Plugin

Dalla 1.6, Visual Java può caricare plugin che estendono l'IDE stesso — strumenti aggiuntivi, pannelli o template di progetto — tramite un plugin manager dedicato. Il caricamento dei plugin serve a estendere l'esperienza dell'editor, distinto dalle funzionalità di sviluppo di plugin Minecraft descritte di seguito.

Le estensioni ufficiali sono elencate nella pagina Estensioni e si installano dall'IDE con Importa plugin online. Dalla 1.10 sono tre: Minecraft Development, World Map Creator (mondi 3D su mappe reali, con i dati di OpenStreetMap) e 3D Map Creator (mappe 3D su aria vuota, su un mondo World Map o su un terreno procedurale).

11 Minecraft development Pre-alpha

New in 1.7: Visual Java can target Minecraft server plugin development for Paper, Spigot and Bukkit, with a version selector covering Minecraft 1.8 through 1.21.10. Early support includes basic commands, an event system, and a tag-based system for marking entities, blocks and items — built on the same JVL class/event model used for 2D and 3D projects, so the mental model carries over even though this surface is still evolving quickly.

11 Sviluppo Minecraft Pre-alpha

Novità della 1.7: Visual Java può essere usato per sviluppare plugin server Minecraft per Paper, Spigot e Bukkit, con un selettore di versione che copre Minecraft dalla 1.8 alla 1.21.10. Il supporto iniziale include comandi di base, un sistema di eventi e un sistema basato su tag per contrassegnare entità, blocchi e oggetti — costruito sullo stesso modello di classi/eventi JVL usato per i progetti 2D e 3D, quindi il modello mentale si trasferisce anche se questa parte è ancora in rapida evoluzione.

12 Teams 1.10

A Team is a small company inside Visual Java: a private, always-online space where a group of people works on the same projects, with its own members, roles, extensions and data. Teams were introduced in 1.9; in 1.10 they became a complete workspace, perfect for small companies and studios that need control over their staff.

Creating a Team

1. From the IDE, open Home → Team and fill in the request: Team name, description and access password.
2. The request is sent to Visual Java. The staff reviews it and, if it's accepted, activates the Team and puts its server online.
3. You receive an email when the Team is active. Pay the first period (see Plans & payments) and invite your members.

Why use a Team

Advantage	What it means
Roles & staff	Full control over who is in the Team, what each person can do and which projects they can see.
Shared work	Members join interactive whiteboards and create or help in shared projects, all in the same place.
Team extensions	Extensions are enabled once on the Team: members don't download anything, which saves time and costs.
.jvlap export	The Team can export the final program, which individual users can't do.

12 Team 1.10

Un Team è una piccola azienda dentro Visual Java: uno spazio privato e sempre online dove un gruppo di persone lavora sugli stessi progetti, con i propri membri, ruoli, estensioni e dati. I Team sono arrivati nella 1.9; nella 1.10 sono diventati uno spazio di lavoro completo, perfetto per piccole aziende e studi che hanno bisogno di controllo sul proprio personale.

Creare un Team

1. Dall'IDE apri Home → Team e compila la richiesta: nome del Team, descrizione e password di accesso.
2. La richiesta arriva a Visual Java. Lo staff la esamina e, se viene accettata, attiva il Team e mette online il suo server.
3. Ricevi una mail quando il Team è attivo. Paga il primo periodo (vedi Piani e pagamenti) e invita i tuoi membri.

Perché usare un Team

Vantaggio	Cosa significa
Ruoli e personale	Controllo completo su chi fa parte del Team, cosa può fare ogni persona e quali progetti può vedere.
Lavoro condiviso	I membri partecipano alle lavagne interattive e creano o aiutano nei progetti condivisi, tutto nello stesso posto.
Estensioni del Team	Le estensioni si attivano una volta sul Team: i membri non scaricano niente, e si risparmia tempo e spese.
Esportazione .jvlap	Il Team può esportare il programma finale, cosa che un utente singolo non può fare.

13 Members & roles

Every member of a Team has a role. Roles are created by the owner (or by whoever has administration permission) and decide what each person can do:

Permission	What it allows
Create projects	Create new Team projects, with an optional limit on how many.
Access other projects	Open projects created by members with other roles.
Sub-teams	See and enter sub-teams: a team inside the Team, with its own roles, members and projects.
Administrate	Manage roles and members of the Team.
Edit own account	Change one's own profile inside the Team.

Working together

Members can join the Team's interactive whiteboards to draw, write notes and plan together, and can create or help in shared projects. A project created inside a Team is a real Visual Java project, ready for live collaboration, with access controlled by roles.

Managing staff

From the members list you can assign roles, remove a member, or suspend them for a set time with a reason. The owner can also suspend the whole Team, which blocks new connections until the suspension is lifted.

13 Membri e ruoli

Ogni membro di un Team ha un ruolo. I ruoli li crea il proprietario (o chi ha il permesso di amministrazione) e decidono cosa può fare ogni persona:

Permesso	Cosa permette
Creare progetti	Creare nuovi progetti del Team, con un limite opzionale sul numero.
Accedere ad altri progetti	Aprire i progetti creati da membri con altri ruoli.
Sub-team	Vedere ed entrare nei sub-team: un team dentro il Team, con propri ruoli, membri e progetti.
Amministrare	Gestire ruoli e membri del Team.
Modificare il proprio account	Cambiare il proprio profilo dentro il Team.

Lavorare insieme

I membri possono partecipare alle lavagne interattive del Team per disegnare, scrivere appunti e pianificare insieme, e possono creare o aiutare nei progetti condivisi. Un progetto creato dentro un Team è un vero progetto Visual Java, pronto per la collaborazione live, con l'accesso controllato dai ruoli.

Gestire il personale

Dalla lista membri puoi assegnare ruoli, rimuovere un membro o sospenderlo per un tempo determinato con un motivo. Il proprietario può anche sospendere l'intero Team, bloccando le nuove connessioni finché la sospensione non viene tolta.

14 Team extensions

On a normal shared server, an extension works only if every user who joins has installed it: if a project uses World Map Creator, each collaborator has to download and enable it on their own PC.

In a Team, it's enough for the Team to have the extension. The owner enables it once and every member can use it right away, with no external files to download. That means fewer installs to manage, everyone always on the same version, and lower costs for the company.

	Normal shared server	Team
Who installs it	Every user	Only the Team
Files to download for members	Yes, one per user	None
Version	Can differ between users	Same for everyone

14 Estensioni del Team

In un normale server condiviso un'estensione funziona solo se tutti gli utenti che entrano l'hanno installata: se un progetto usa World Map Creator, ogni collaboratore deve scaricarla e abilitarla sul proprio PC.

In un Team basta che l'estensione ce l'abbia il Team. Il proprietario la attiva una volta e ogni membro la può usare subito, senza scaricare file esterni. Quindi meno installazioni da gestire, tutti sempre sulla stessa versione e meno spese per l'azienda.

	Server condiviso normale	Team
Chi la installa	Ogni utente	Solo il Team
File da scaricare per i membri	Sì, uno per utente	Nessuno
Versione	Può essere diversa tra utenti	Uguale per tutti

15 Exporting .jvlap

A .jvlap is the final exported program: the result of the JVL compiler followed by jpackage, so a real application that runs on its own, outside the IDE.

Individual users can't export a project this way. Teams can: any member whose role allows it can create a .jvlap from a Team project.

15 Esportare .jvlap

Un .jvlap è il programma finale esportato: il risultato del compilatore JVL seguito da jpackage, quindi una vera applicazione che funziona da sola, fuori dall'IDE.

Un utente singolo non può esportare un progetto in questo modo. Un Team sì: qualsiasi membro il cui ruolo lo permette può creare un .jvlap da un progetto del Team.

16 Plans & payments

To keep a Team alive the owner pays a monthly fee. You can pay for 1 month, 2 months or 12 months at a time; the Team stays active until the end of the period you paid for.

If a payment is missed

When	What happens
Day 1–2	Free extra days. The Team keeps working normally: you have time to renew.
Day 3	Server off. Nobody can connect, but all data is still kept. Paying now brings the Team back online.
Day 4	Team deleted. The Team's data is sent by email to the owner, and the server is deleted.

16 Piani e pagamenti

Per mantenere vivo un Team il proprietario paga una quota mensile. Puoi pagare per 1 mese, 2 mesi o 12 mesi alla volta; il Team resta attivo fino alla fine del periodo pagato.

Se un pagamento non viene effettuato

Quando	Cosa succede
Giorno 1–2	Giorni regalati. Il Team continua a funzionare normalmente: hai tempo per rinnovare.
Giorno 3	Server spento. Nessuno può connettersi, ma tutti i dati sono ancora presenti. Pagando ora il Team torna online.
Giorno 4	Team eliminato. I dati del Team vengono inviati via mail al proprietario e il server viene eliminato.