Modelo de quarto próprio pelo banco de dados

Gold

Habbo.Host

Os modelos prontos do Habbo (model_a, model_b...) são só o começo. Dá para fazer o seu formato de quarto: um auditório, um labirinto, uma praça com palco no meio. Quem decide o formato é o mapa de altura guardado no banco.

O caminho para abrir o Gerenciador do banco de dados está em Quartos públicos e sala de entrada pelo banco de dados.

Como funciona

room_models: os modelos que vêm com o emulador (não mexa neles).
room_models_custom: os seus modelos.
rooms.model guarda o nome do modelo daquele quarto.

Veja um modelo pronto para entender o mapa:

SELECT name, door_x, door_y, door_dir, heightmap FROM room_models WHERE name = 'model_a';

O mapa é uma grade de texto: cada linha é uma fileira de peças do quarto e cada caractere é uma peça — x é parede (bloqueado) e os números são a altura do chão (0 chão baixo, 9 mais alto). A porta é door_x, door_y com a direção em door_dir.

Passo 1: criar o modelo

O jeito mais seguro é copiar a porta de um modelo pronto e escrever só o mapa novo:

-- 1) Cria o modelo (10x10 com parede em volta), copiando a porta do model_a
INSERT INTO room_models_custom (id, name, door_x, door_y, door_dir, heightmap)
SELECT 700, 'custom_700', door_x, door_y, door_dir,
       'xxxxxxxxxx
x00000000x
x00000000x
x00000000x
x00000000x
x00000000x
x00000000x
x00000000x
x00000000x
xxxxxxxxxx'
  FROM room_models WHERE name = 'model_a';

Comando SQL criando o modelo de quarto

O id e o name são seus: use um nome no padrão custom_<número> para não colidir com os modelos do emulador. O dentro do texto é a quebra de linha de cada fileira — é isso que separa uma linha da outra.

Passo 2: usar no quarto

UPDATE rooms SET model = 'custom_700' WHERE id = 201;

Consulta executada, um registro afetado em cada instrução

Conferindo

SELECT id, name, model FROM rooms WHERE id = 201;
SELECT id, name, door_x, door_y, door_dir FROM room_models_custom WHERE id = 700;

Quarto apontando para o modelo novo e o modelo criado

Fazendo o formato que você quer

Monte o mapa como uma grade:

xxxxxxxxxx
x00000000x
x00000000x
x00000000x
xxxxxxxxxx

Uma fileira = uma linha do texto. O quarto tem a largura da linha e o comprimento do número de linhas.
x = parede. Tudo que não é x é piso andável.
Troque um 0 por 1, 2, 3... para levantar aquele pedaço do chão (degrau, palco, rampa).
A porta (door_x, door_y) precisa cair em cima de um piso, nunca de um x. Se mudar a porta de lugar, confira a fileira: door_y é a linha (contando de cima), door_x é a coluna (contando da esquerda).
Modelos muito grandes deixam o quarto pesado para todo mundo (inclusive o celular).

Detalhes que evitam dor de cabeça

Não mude o model de um quarto decorado sem avisar: todo mobi que ficar fora do piso some da sala (e volta quando o modelo antigo é restaurado).
Ficou estranho? Volte o quarto para o modelo anterior: UPDATE rooms SET model = 'model_a' WHERE id = 201;.

Já existe o editor de planta no jogo (com o direito acc_floorplan_editor): ele cria um modelo nesta mesma tabela. O banco serve para copiar um modelo pronto para vários quartos de uma vez:

  UPDATE rooms SET model = 'custom_700' WHERE name IN ('Praça Central', 'Sala de Eventos');

Depois de mudar o modelo, o quarto precisa ser recarregado: saia e entre na sala (ou :reload_room no quarto).
Backup antes, como sempre. Um UPDATE em rooms sem WHERE muda o formato do hotel inteiro.

🇬🇧 English

Your own room model from the database

Habbo's ready-made models (model_a, model_b...) are just the start. You can build your own room shape: an auditorium, a maze, a square with a stage in the middle. The shape is decided by the heightmap stored in the database.

Where to open the Database manager is in Quartos públicos e sala de entrada pelo banco de dados.

How it works

room_models: the models that ship with the emulator (do not touch them).
room_models_custom: your models.
rooms.model holds the name of that room's model.

SELECT name, door_x, door_y, door_dir, heightmap FROM room_models WHERE name = 'model_a';

The map is a text grid: each line is a row of tiles and each character is a tile — x is a wall (blocked) and digits are the floor height (0 low, 9 higher). The door is door_x, door_y, with its direction in door_dir.

Step 1: create the model

Copy the door from a ready model and write only the new map:

INSERT INTO room_models_custom (id, name, door_x, door_y, door_dir, heightmap)
SELECT 700, 'custom_700', door_x, door_y, door_dir,
       'xxxxxxxxxx
x00000000x
x00000000x
x00000000x
x00000000x
x00000000x
x00000000x
x00000000x
x00000000x
xxxxxxxxxx'
  FROM room_models WHERE name = 'model_a';

SQL command creating the room model

Pick your own id and name (use custom_<number>), and keep the between rows.

Step 2: use it in a room

UPDATE rooms SET model = 'custom_700' WHERE id = 201;

Query executed, one row affected per statement

Checking

SELECT id, name, model FROM rooms WHERE id = 201;
SELECT id, name, door_x, door_y, door_dir FROM room_models_custom WHERE id = 700;

Room pointing at the new model and the model created

Building the shape you want

One text line = one row. The room is as wide as the line and as long as the number of lines.
x = wall. Anything else is walkable floor.
Use 1, 2, 3... to raise that floor tile (step, stage, ramp).
The door (door_x, door_y) must land on a floor tile, never on an x.
Huge models make the room heavy for everyone, phones included.

Details that save you trouble

Do not change the model of a decorated room without warning: furni left outside the floor disappears (and comes back with the old model).
Undo: UPDATE rooms SET model = 'model_a' WHERE id = 201;.

The in-game floor plan editor (right acc_floorplan_editor) writes to this same table. The database is how you copy a model to many rooms at once:

  UPDATE rooms SET model = 'custom_700' WHERE name IN ('Praça Central', 'Sala de Eventos');

After changing it, leave and re-enter the room (or :reload_room).
Always back up: an UPDATE on rooms without WHERE changes the whole hotel.

🇪🇸 Español

Tu propio modelo de cuarto desde la base de datos

Los modelos listos del Habbo (model_a, model_b...) son solo el comienzo. Puedes crear tu propio formato de cuarto: un auditorio, un laberinto, una plaza con escenario. El formato lo decide el mapa de altura guardado en la base de datos.

Dónde abrir el Gestor de base de datos está en Quartos públicos e sala de entrada pelo banco de dados.

Cómo funciona

room_models: los modelos que vienen con el emulador (no los toques).
room_models_custom: tus modelos.
rooms.model guarda el nombre del modelo de ese cuarto.

SELECT name, door_x, door_y, door_dir, heightmap FROM room_models WHERE name = 'model_a';

El mapa es una cuadrícula de texto: cada línea es una fila de piezas y cada carácter es una pieza — x es pared (bloqueado) y los dígitos son la altura del suelo (0 bajo, 9 más alto). La puerta es door_x, door_y, con la dirección en door_dir.

Paso 1: crear el modelo

Copia la puerta de un modelo listo y escribe solo el mapa nuevo:

INSERT INTO room_models_custom (id, name, door_x, door_y, door_dir, heightmap)
SELECT 700, 'custom_700', door_x, door_y, door_dir,
       'xxxxxxxxxx
x00000000x
x00000000x
x00000000x
x00000000x
x00000000x
x00000000x
x00000000x
x00000000x
xxxxxxxxxx'
  FROM room_models WHERE name = 'model_a';

Comando SQL creando el modelo de cuarto

Elige tu id y tu name (usa custom_<número>) y conserva los entre filas.

Paso 2: usarlo en un cuarto

UPDATE rooms SET model = 'custom_700' WHERE id = 201;

Consulta ejecutada, un registro afectado por instrucción

Comprobar

SELECT id, name, model FROM rooms WHERE id = 201;
SELECT id, name, door_x, door_y, door_dir FROM room_models_custom WHERE id = 700;

Cuarto apuntando al modelo nuevo y el modelo creado

Armando el formato que quieres

Una línea de texto = una fila. El cuarto es tan ancho como la línea y tan largo como el número de líneas.
x = pared. Todo lo demás es suelo.
Usa 1, 2, 3... para elevar ese suelo (escalón, escenario, rampa).
La puerta (door_x, door_y) debe caer sobre suelo, nunca sobre un x.
Modelos enormes vuelven el cuarto pesado para todos, celulares incluidos.

Detalles que evitan dolores de cabeza

No cambies el modelo de un cuarto decorado sin avisar: los mobis que queden fuera del suelo desaparecen (y vuelven con el modelo anterior).
Deshacer: UPDATE rooms SET model = 'model_a' WHERE id = 201;.

El editor de planta del juego (derecho acc_floorplan_editor) escribe en esta misma tabla. La base sirve para copiar un modelo a varios cuartos a la vez:

  UPDATE rooms SET model = 'custom_700' WHERE name IN ('Praça Central', 'Sala de Eventos');

Después de cambiarlo, sal y entra del cuarto (o :reload_room).
Backup siempre: un UPDATE en rooms sin WHERE cambia el hotel entero.