This is the abridged developer documentation for PBSLoader SDK (PBSLoaderCommonUtils) # PBSLoader SDK > Escreva mods para o Proton Bus Simulator Urbano sem tocar nas classes Il2Cpp do jogo e sem escrever patch Harmony. A PBSLoaderCommonUtils é a base que o PBSLoader instala junto com o MelonLoader. Ela lê o estado do jogo a cada quadro e entrega esses dados ao seu mod em classes como `Veiculo`, `Mapa`, `Linha` e `Tempo`. Também oferece ganchos no jogo, atalhos de teclado com detecção de conflito, avisos na tela e uma simulação de ar comprimido. Se é a primeira vez aqui, leia [Como o PBSLoader funciona](conceitos/como-funciona/) e [Tipos de mod](conceitos/tipos-de-mod/). Elas explicam a diferença entre um mod global e os scripts que vêm dentro de um ônibus ou de um mapa, e onde cada coisa fica. Antes de escrever o primeiro mod, passe pelas [Boas práticas](guias/boas-praticas/): elas dizem onde ler e onde mudar cada coisa do jogo sem derrubá-lo nem brigar com outros mods. [Veículo e condução](referencia/pbsloadercommonutils/veiculos/veiculo/)Velocidade, motor, câmbio, pedais, luzes e portas do ônibus do jogador. Com Comandos e Conducao, o mod também aciona a carroceria e dirige. [Mapa, linha e passageiros](referencia/pbsloadercommonutils/linhas/linha/)Paradas carregadas, o ponto atual, o próximo ponto estimado e quem embarcou ou desceu. [Ganchos](referencia/pbsloadercommonutils/ganchos/)Pontos de entrada na física, nos freios, nas rodas, no som do motor e nos pedidos de porta, cada um com um único patch dentro do SDK. [Scripts de ônibus e mapa](referencia/pbsloadercommonutils/conteudo/scriptdeonibus/)Uma DLL dentro da pasta do ônibus ou do mapa, que só roda enquanto esse conteúdo está em uso e pede permissão ao jogador. [Interface: menus, painéis e HUD](referencia/pbsloadercommoninterface/)PainelMods, Paineis e Hud, da PBSLoaderCommonInterface, para o seu mod aparecer no menu Mods e na tela. [Todas as classes](referencia/pbsloadercommonutils/)A lista completa de tipos da PBSLoaderCommonUtils, separada por namespace. A versão atual da API é a 2.0.0, testada no jogo versão 307 com MelonLoader 0.7.3. # Sobre esta documentação > Para quem é esta documentação, que versões ela cobre e como usá-la com assistentes de IA. Esta documentação é para quem escreve mods em C# para o Proton Bus Simulator Urbano usando o SDK do PBSLoader, a biblioteca PBSLoaderCommonUtils. Quem só quer jogar com mods encontra o instalador e as instruções no [repositório do PBSLoader](https://github.com/Sebola3461/pbsu-loader). Para entender as peças antes do código, comece por [Como o PBSLoader funciona](/pbs-loader-docs/conceitos/como-funciona/) e [Tipos de mod](/pbs-loader-docs/conceitos/tipos-de-mod/). A [referência da API](/pbs-loader-docs/referencia/) lista cada classe, propriedade, método e evento público da PBSLoaderCommonUtils e da PBSLoaderCommonInterface, com a assinatura em C#. Ela é gerada a partir das DLLs de cada release. ## Versões cobertas [Seção intitulada “Versões cobertas”](#versões-cobertas) | Item | Versão | | ------------------------- | ------ | | API do SDK (`Sdk.Versao`) | 2.0.0 | | Jogo | 307 | | MelonLoader | 0.7.3 | Uma mudança no primeiro número da API quebra mods escritos para a versão anterior. Use `Sdk.Requer("2.0", "MeuMod")` no começo do mod para que ele fique parado, com um aviso ao jogador, quando o SDK instalado for velho demais. ## Nomes em português [Seção intitulada “Nomes em português”](#nomes-em-português) Classes, propriedades e eventos do SDK têm nomes em português, com a unidade no nome quando há uma: `Veiculo.VelocidadeKmh`, `Veiculo.Suspensao.AlturaM`, `Tempo.DuracaoDoDiaMin`. Os exemplos desta documentação usam os nomes exatamente como estão na DLL. ## Usar com assistentes de IA [Seção intitulada “Usar com assistentes de IA”](#usar-com-assistentes-de-ia) O site publica a documentação inteira em formatos que um assistente de IA consegue ler de uma vez: | Arquivo | Conteúdo | | --------------------------------------------------- | ------------------------------------------------------------------------------------ | | [`llms.txt`](/pbs-loader-docs/llms.txt) | resumo do SDK e lista das páginas, no formato de [llmstxt.org](https://llmstxt.org/) | | [`llms-full.txt`](/pbs-loader-docs/llms-full.txt) | todas as páginas num arquivo só | | [`llms-small.txt`](/pbs-loader-docs/llms-small.txt) | o mesmo, sem notas e dicas, para contextos curtos | Cada página também existe em Markdown puro. Troque a barra final da URL por `.md`: esta página, por exemplo, fica em [`comecando/sobre-esta-documentacao.md`](/pbs-loader-docs/comecando/sobre-esta-documentacao.md). Ao pedir código a um assistente, passe o `llms-full.txt` e diga que os nomes da API não devem ser traduzidos. Sem isso, é comum o assistente inventar `Vehicle.SpeedKmh` no lugar de `Veiculo.VelocidadeKmh`. ## Licença [Seção intitulada “Licença”](#licença) O texto desta documentação está sob a licença [Creative Commons Atribuição 4.0 Internacional (CC BY 4.0)](https://creativecommons.org/licenses/by/4.0/deed.pt-br). Dá para copiar e adaptar, inclusive em outros sites, desde que o crédito e o link para a fonte apareçam junto. Encontrou um erro? Use o link de edição no fim de cada página para abrir uma correção no GitHub. # Ciclo de uma partida > As fases do jogo, os eventos que o SDK dispara em cada uma e quando os dados do veículo e do mapa valem. Um mod global fica carregado o jogo inteiro, mas os dados que ele usa só existem em parte desse tempo. Não há ônibus no menu, e o mapa só existe depois de carregado. [`Sdk.Fase`](/pbs-loader-docs/referencia/pbsloadercommonutils/fase/) diz em que ponto o jogador está. ## Fases [Seção intitulada “Fases”](#fases) | Fase | O jogador está | O que já vale | | ------------ | ----------------------------------------------------- | ------------------------------------------------------------------------------- | | `Menu` | no menu inicial | `Caminhos` (depois que o jogo define as pastas), `Opcoes` | | `Selecao` | nas telas de escolha de ônibus, pintura, mapa e linha | `Sessao.Onibus`, `Sessao.Mapa` e a pintura, conforme ele escolhe | | `Carregando` | na tela de carregamento | pouco: o veículo pode aparecer e ser trocado durante o carregamento | | `Dirigindo` | na partida | `Veiculo`, `Mapa`, `Linha`, `Passageiros`, `Tempo`, `Clima`, `Trafego`, `Vista` | Ao sair da partida, `Veiculo.Existe` e `Mapa.Existe` voltam a `false`, e `Sdk.VeiculoTrocou` dispara. ## Eventos [Seção intitulada “Eventos”](#eventos) Os eventos do SDK rodam na thread principal, no mesmo quadro da mudança. Inscreva-se uma vez, no `OnInitializeMelon` do mod global ou no `Ativar` do script. | Evento | Quando dispara | | --------------------------------------------------- | ------------------------------------------------------------------- | | `Sdk.FaseMudou(Fase)` | a fase mudou | | `Sdk.CenaCarregou(string)` | uma cena da Unity terminou de carregar, incluindo cada tile do mapa | | `Sdk.VeiculoTrocou` | o veículo do jogador apareceu ou sumiu. Confira `Veiculo.Existe` | | `Sdk.MapaCarregou` | um mapa novo começou | | `Sdk.Quadro`, `Sdk.PassoFisico`, `Sdk.QuadroTardio` | todo Update, FixedUpdate e LateUpdate, depois dos dados do SDK | Uma exceção no seu inscrito vai para o log, no máximo uma vez a cada 10 segundos, e não impede os outros inscritos de receber o evento. ```csharp Sdk.VeiculoTrocou += () => { if (!Veiculo.Existe) return; LoggerInstance.Msg($"entrou no {Veiculo.Nome}, {Veiculo.Portas.Todas.Count} portas"); }; ``` ## Geração: estado por veículo e por mapa [Seção intitulada “Geração: estado por veículo e por mapa”](#geração-estado-por-veículo-e-por-mapa) `Veiculo.Geracao` e `Mapa.Geracao` são números que mudam a cada veículo e a cada mapa carregado. Durante o carregamento da partida, o jogo pode montar o veículo mais de uma vez, então `VeiculoTrocou` pode disparar mais de uma vez seguida. Para guardar estado de um veículo (uma referência a uma porta, uma calibração, um objeto criado no ônibus), guarde a geração junto e reconstrua quando ela mudar: ```csharp // using System.Linq; int _geracao = -1; Porta _portaDianteira; public override void OnUpdate() { if (!Veiculo.Existe) return; if (_geracao != Veiculo.Geracao) { _geracao = Veiculo.Geracao; _portaDianteira = Veiculo.Portas.Todas.FirstOrDefault(p => p.Numero == 1); } // ... } ``` ## Mapas em tiles [Seção intitulada “Mapas em tiles”](#mapas-em-tiles) Mapas grandes carregam em pedaços (tiles) conforme o ônibus anda. `Mapa.Paradas` lista só os pontos dos tiles carregados agora, e um ponto sai da lista quando o tile dele descarrega. `Mapa.CarregandoTiles` fica `true` enquanto o jogo carrega um tile, e cada tile pronto dispara `Sdk.CenaCarregou` e, nos scripts de mapa, `TileCarregou(cena)`. ## Scripts de ônibus e de mapa [Seção intitulada “Scripts de ônibus e de mapa”](#scripts-de-ônibus-e-de-mapa) Os scripts seguem o ciclo do conteúdo deles, e não o do jogo: 1. Quando o ônibus vira o do jogador (ou o mapa carrega), a PBSLoaderCommonUtils lê o `pbsu.json`, confere o `sdkMinimo` e a permissão, carrega a DLL e chama `Ativar`. 2. Enquanto ele está em jogo, `Quadro`, `PassoFisico` e `QuadroTardio` rodam como os eventos do SDK. 3. Quando ele sai, ela chama `Desativar` e desfaz os patches do `Pacote.Harmony`. A DLL continua carregada até o jogo fechar. 4. Ao voltar para o mesmo ônibus ou mapa na mesma sessão, as mesmas instâncias são ativadas de novo, sem perguntar. ## Pausa e gravação [Seção intitulada “Pausa e gravação”](#pausa-e-gravação) `Sessao.Pausado` fica `true` com o menu de pausa aberto. Confira essa propriedade se o seu mod não deve agir com o jogo pausado. Os dados de [`Salvos`](/pbs-loader-docs/referencia/pbsloadercommonutils/salvos/) são gravados 1,5 segundo depois da última mudança, na troca de cena e quando o jogo fecha. # Como o PBSLoader funciona > As peças do PBSLoader, as duas pastas de mods que existem e a ordem em que tudo carrega. O Proton Bus Simulator Urbano não carrega código de terceiros sozinho. Quem faz isso é o MelonLoader, e o PBSLoader é o conjunto de peças em volta dele: um instalador, duas bibliotecas obrigatórias e um catálogo de mods. ## As peças [Seção intitulada “As peças”](#as-peças) | Peça | O que é | Onde fica | | ----------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------- | | MelonLoader | Carregador de mods para jogos Unity. Entra no jogo pelo `version.dll` e carrega toda DLL que estiver na pasta `Mods`. O PBSLoader usa a versão 0.7.3. | `version.dll` e `MelonLoader/` na pasta do jogo | | PBSLoaderCommonUtils | O SDK. Lê o estado do jogo a cada quadro e entrega esses dados ao seu mod em classes como `Veiculo`, `Mapa` e `Tempo`. Também carrega os scripts de ônibus e de mapa. A parte visual fica com a PBSLoaderCommonInterface. | `Mods/PBSLoaderCommonUtils.dll` | | PBSLoaderCommonInterface | A interface comum: menus redesenhados, o menu **Mods** com as opções de cada mod, o painel de condução e os avisos na tela. Outros mods usam ela para ter painéis e cartões no HUD. | `Mods/PBSLoaderCommonInterface.dll` | | Instalador (`PbsuLoader.exe`) | Programa do Windows que instala o MelonLoader, as duas bibliotecas e os mods escolhidos, e atualiza tudo depois. | onde o jogador baixar | | Catálogo (`catalogo.json`) | A lista de mods que o instalador oferece. Cada mod fica no repositório do autor e entra no catálogo por pull request. | [repositório do PBSLoader](https://github.com/Sebola3461/pbsu-loader) | | O seu mod | Uma DLL do MelonLoader compilada contra a PBSLoaderCommonUtils, ou um script que vem junto de um ônibus ou mapa. Veja [Tipos de mod](../tipos-de-mod/). | depende do tipo | As duas bibliotecas são obrigatórias: o instalador sempre instala as duas, e um mod do catálogo pode contar com elas presentes. ## Duas pastas de mods [Seção intitulada “Duas pastas de mods”](#duas-pastas-de-mods) A palavra “mods” aparece em dois lugares que não têm nada a ver um com o outro. A pasta `Mods` do MelonLoader fica dentro da pasta do jogo, junto do `Proton Bus Simulator.exe`. Ela guarda código: as DLLs que o MelonLoader carrega quando o jogo abre. ```plaintext / Proton Bus Simulator.exe version.dll MelonLoader MelonLoader/ Latest.log log de todos os mods Mods/ PBSLoaderCommonUtils.dll PBSLoaderCommonInterface.dll SeuMod.dll UserData/ MelonPreferences.cfg opções e atalhos dos mods PBSLoaderCommonUtils/ dados do SDK (salvos, diagnóstico) ``` A pasta de mods do jogo é a que o próprio Proton usa para conteúdo feito pela comunidade: ônibus, mapas, letreiros e pinturas. O local dela é definido pelo jogo, e o SDK informa os caminhos em [`Caminhos`](/pbs-loader-docs/referencia/pbsloadercommonutils/partida/caminhos/) (`Caminhos.ModsDeOnibus`, `Caminhos.ModsDeMapas` e outros). ```plaintext / buses/ Meu Onibus.ini descrição do ônibus; [config] baseDir aponta a pasta Meu Onibus/ modelos, sons, texturas scripts/ script de ônibus (opcional, só com o SDK) maps/ Meu Mapa.map.txt descrição do mapa; [map] baseDir aponta a pasta Meu Mapa/ scripts/ script de mapa (opcional, só com o SDK) dest/ letreiros skins/ pinturas ``` O jogo não conhece a pasta `scripts/`: quem procura por ela é a PBSLoaderCommonUtils, quando aquele ônibus ou mapa entra em jogo. ## Ordem de carregamento [Seção intitulada “Ordem de carregamento”](#ordem-de-carregamento) 1. O jogo abre, e o MelonLoader carrega as DLLs de `Mods`. 2. A PBSLoaderCommonUtils inicia primeiro. Ela tem prioridade -1000 no MelonLoader, então, quando o `OnUpdate` do seu mod roda, os dados do quadro já estão atualizados. 3. A PBSLoaderCommonInterface e os outros mods iniciam. Um mod declara que depende das bibliotecas com `[assembly: MelonAdditionalDependencies("PBSLoaderCommonUtils")]`, e o MelonLoader respeita essa ordem. 4. Durante a partida, quando o jogador entra num ônibus ou carrega um mapa que tem `scripts/`, a PBSLoaderCommonUtils pede permissão ao jogador na primeira vez e liga os scripts daquele conteúdo. O caminho do jogador até a direção (menu, escolha do ônibus, carregamento) e os eventos de cada etapa estão em [Ciclo de uma partida](../ciclo-da-partida/). ## O que o SDK resolve [Seção intitulada “O que o SDK resolve”](#o-que-o-sdk-resolve) Sem o SDK, um mod para o Proton precisa conhecer as classes internas do jogo (`MEPControlesBus`, `VPVehicleController` e centenas de outras, expostas pelo IL2CPP com o prefixo `Il2Cpp`) e escrever patches Harmony nelas. Esses nomes mudam quando o jogo atualiza, e dois mods que fazem patch no mesmo método brigam entre si. A PBSLoaderCommonUtils concentra esse trabalho num lugar só. Ela lê o jogo e expõe o resultado em propriedades estáveis, com nomes em português e a unidade no nome (`Veiculo.VelocidadeKmh`). Os pontos onde um mod precisa entrar no jogo viram [ganchos](/pbs-loader-docs/referencia/pbsloadercommonutils/ganchos/), com um patch só para todos os mods. Quando o jogo muda de versão, o SDK é atualizado uma vez, e os mods continuam funcionando. # Glossário > Termos que aparecem no SDK e nesta documentação. | Termo | Significado | | ---------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | Biblioteca obrigatória | A PBSLoaderCommonUtils e a PBSLoaderCommonInterface. O instalador sempre instala as duas. | | Catálogo | O `catalogo.json` do repositório do PBSLoader, com os mods que o instalador oferece. | | EVP5 | Um dos sistemas de física de veículo do jogo. Nele o SDK lê os campos do jogo e não tem leitura da embreagem nem das rodas. Veja `Veiculo.Fisica`. | | Fachada | Uma classe do SDK que lê o jogo e expõe o resultado com nomes estáveis, como `Veiculo`, `Mapa` e `Tempo`. | | Fase | Em que parte do jogo o jogador está: `Menu`, `Selecao`, `Carregando` ou `Dirigindo`. Veja [Ciclo de uma partida](../ciclo-da-partida/). | | Gancho | Um ponto do jogo onde o mod entra sem escrever patch Harmony, como `Ganchos.DepoisDaFisica` e `Ganchos.PortaPedida`. A PBSLoaderCommonUtils aplica um patch só e chama todos os inscritos. | | Geração | Número que muda a cada veículo (`Veiculo.Geracao`) ou mapa (`Mapa.Geracao`) carregado. Serve para saber quando reconstruir o estado. | | Harmony | Biblioteca que altera métodos de outro programa em tempo de execução. Vem com o MelonLoader. | | IL2CPP | Forma como o jogo foi compilado: o código C# virou C++ nativo. O MelonLoader gera classes de acesso com o prefixo `Il2Cpp`, que mudam quando o jogo atualiza. | | Letreiro | O painel de destino do ônibus. Os letreiros de mod ficam em `dest/`, na pasta de mods do jogo. | | MelonLoader | O carregador de mods. Carrega as DLLs de `Mods` quando o jogo abre. | | Modo seguro | Estado do SDK numa versão do jogo em que ele não foi testado. Os ganchos não disparam, `Conducao` e o freio a ar não escrevem no jogo e `Avancado` devolve `null`. As fachadas de leitura continuam funcionando. | | Pacote | Uma pasta `scripts/` de ônibus ou de mapa, com o `pbsu.json` e a DLL. No código, a classe [`Pacote`](/pbs-loader-docs/referencia/pbsloadercommonutils/conteudo/pacote/). | | Pasta de mods do jogo | A pasta que o Proton usa para ônibus, mapas, letreiros e pinturas. É outra pasta, diferente da `Mods` do MelonLoader. Veja [Como o PBSLoader funciona](../como-funciona/#duas-pastas-de-mods). | | `pbsu.json` | O arquivo que descreve um pacote de scripts: `id`, `nome`, `autor`, `versao`, `sdkMinimo` e `dll`. | | Script de conteúdo | Script de ônibus ou script de mapa. Veja [Tipos de mod](../tipos-de-mod/). | | SHA-256 | Impressão digital de um arquivo. O instalador confere a de cada download, e a permissão de um script vale para a SHA-256 da DLL dele. | | Tile | Um pedaço de um mapa grande, carregado conforme o ônibus anda. | | VPP | Vehicle Physics Pro, o sistema de física usado na maior parte dos ônibus do jogo. Os pedidos de `Conducao` e os ganchos de física só funcionam nele. | | Versão de teste | Um release marcado como pré-lançamento no GitHub. O instalador só mostra para quem marca *Incluir versões de teste*. | # Tipos de mod > Mod global, script de ônibus, script de mapa e conteúdo sem código. Onde cada um fica, quando roda e qual escolher. Existem quatro jeitos de mudar o jogo com o PBSLoader. Três têm código; o primeiro, não. | | Conteúdo do jogo | Mod global | Script de ônibus | Script de mapa | | -------------- | ------------------------------------------------------------- | ---------------------------------------------------- | --------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------- | | O que é | Ônibus, mapa, letreiro ou pintura, no formato do próprio jogo | DLL do MelonLoader | DLL dentro da pasta de um ônibus | DLL dentro da pasta de um mapa | | Onde fica | Pasta de mods do jogo (`buses/`, `maps/`, `dest/`, `skins/`) | `/Mods` | `/scripts/` | `/scripts/` | | Quando roda | O jogo lê quando o jogador escolhe | Do momento em que o jogo abre até ele fechar | Só enquanto aquele ônibus é o veículo do jogador | Só enquanto aquele mapa está carregado | | Precisa do SDK | Não | Não, mas quase todo mod do catálogo usa | Sim | Sim | | Quem instala | O jogador, copiando para a pasta de mods do jogo | O instalador (catálogo) ou o jogador, copiando a DLL | Vem junto do ônibus | Vem junto do mapa | | Pede permissão | Não | Não | Sim, na primeira vez | Sim, na primeira vez | | Classe base | | `MelonMod` | [`ScriptDeOnibus`](/pbs-loader-docs/referencia/pbsloadercommonutils/conteudo/scriptdeonibus/) | [`ScriptDeMapa`](/pbs-loader-docs/referencia/pbsloadercommonutils/conteudo/scriptdemapa/) | ## Conteúdo do jogo (sem código) [Seção intitulada “Conteúdo do jogo (sem código)”](#conteúdo-do-jogo-sem-código) São os mods que a comunidade do Proton sempre fez: um ônibus é um arquivo `.ini` em `buses/` mais uma pasta com modelos, texturas e sons; um mapa é um `.map.txt` em `maps/` mais a pasta dele. O jogo lê esses arquivos sozinho, sem MelonLoader e sem o PBSLoader. O SDK lê o que o jogo carregou. `Veiculo.Pasta` é a pasta do ônibus em uso, e `Mapa.Pasta` e `Mapa.Versao` vêm do mod de mapa. `Sessao.OrigemDoOnibus` e `Mapa.Origem` dizem se aquilo veio com o jogo ou de um mod. Uma mesma pasta de ônibus pode servir a vários `.ini`, um por variante. Por exemplo, `Torino 1519.ini` e `Torino 1519 Sul.ini` podem apontar o mesmo `[config] baseDir`. Nesse caso, as duas variantes usam os mesmos scripts. ## Mod global [Seção intitulada “Mod global”](#mod-global) É uma DLL do MelonLoader na pasta `Mods`. Ela carrega quando o jogo abre e fica ativa o tempo todo: no menu, nas telas de escolha, carregando e dirigindo. Serve para tudo que vale para qualquer ônibus ou mapa, como física de motor, câmera, gráficos, volante, interface e telemetria. ```csharp using MelonLoader; using PBSLoaderCommonUtils; using PBSLoaderCommonUtils.Veiculos; [assembly: MelonInfo(typeof(MeuMod.MeuModMod), "MeuMod", "1.0.0", "você")] [assembly: MelonGame(null, "Proton Bus Simulator")] [assembly: MelonAdditionalDependencies("PBSLoaderCommonUtils")] namespace MeuMod { public class MeuModMod : MelonMod { public override void OnInitializeMelon() { if (!Sdk.Requer("2.0", "MeuMod")) return; } public override void OnUpdate() { if (!Veiculo.Existe) return; // no menu não há ônibus // ... } } } ``` Como roda o tempo todo, o mod precisa conferir em que ponto o jogo está antes de ler os dados: `Sdk.Fase`, `Veiculo.Existe` ou `Mapa.Existe`. Fora de uma partida, as propriedades do SDK devolvem o valor padrão (0, `false`, `""`), sem lançar exceção. Um mod global vai para o jogador pelo [catálogo do instalador](https://github.com/Sebola3461/pbsu-loader#para-quem-faz-mods-entrar-no-cat%C3%A1logo), com um release no GitHub, ou como DLL para copiar à mão em `Mods`. ## Script de ônibus [Seção intitulada “Script de ônibus”](#script-de-ônibus) É uma DLL que o autor de um ônibus põe na pasta dele, junto de um `pbsu.json`. Ela só roda enquanto aquele ônibus é o veículo do jogador. Serve para o que é daquele modelo: um letreiro com lógica, um painel próprio, portas com regra especial, sons ou animações que o `.ini` não consegue descrever. ```plaintext buses/ Meu Onibus.ini Meu Onibus/ scripts/ pbsu.json MeuOnibus.Scripts.dll ``` ```json { "id": "autor.meuonibus", "nome": "Meu ônibus", "autor": "você", "versao": "1.0.0", "sdkMinimo": "2.0", "dll": "MeuOnibus.Scripts.dll" } ``` ```csharp using PBSLoaderCommonUtils.Conteudo; using PBSLoaderCommonUtils.Veiculos; public class MeuPainel : ScriptDeOnibus { public override void Ativar() => Pacote.Log.Msg("ativo em " + Veiculo.Nome); public override void Quadro() { /* todo quadro, enquanto este ônibus é o do jogador */ } public override void Desativar() { /* saia dos eventos do SDK em que entrou */ } } ``` A diferença para um mod global é o ciclo de vida. O script não precisa conferir se o ônibus certo está em jogo, porque só roda nessa situação. A PBSLoaderCommonUtils chama `Ativar` quando o ônibus vira o do jogador e `Desativar` quando ele sai. Na saída, ela também desfaz os patches que o script aplicou pelo `Pacote.Harmony`. O [`Pacote`](/pbs-loader-docs/referencia/pbsloadercommonutils/conteudo/pacote/) dá ao script o que um mod global teria por conta própria: preferências (`Pacote.Config`), log, atalhos que só valem com o pacote ativo, dados salvos entre sessões e acesso aos arquivos da própria pasta (`Pacote.Textura`, `Pacote.Som`, `Pacote.Modelo`). Ônibus que vêm com o jogo não têm pasta de mod, então não têm scripts. ## Script de mapa [Seção intitulada “Script de mapa”](#script-de-mapa) Funciona do mesmo jeito, na pasta do mapa (a que o `[map] baseDir` do `.map.txt` aponta), com uma classe que herda de [`ScriptDeMapa`](/pbs-loader-docs/referencia/pbsloadercommonutils/conteudo/scriptdemapa/). Roda enquanto aquele mapa está carregado e recebe `TileCarregou(cena)` a cada pedaço do mapa que termina de carregar. Serve para eventos do mapa, anúncios nos pontos, tráfego ou clima próprios de uma cidade. ```plaintext maps/ Meu Mapa.map.txt Meu Mapa/ scripts/ pbsu.json MeuMapa.Scripts.dll ``` Mapas que vêm com o jogo não têm scripts. ## Permissão do jogador [Seção intitulada “Permissão do jogador”](#permissão-do-jogador) Um script de ônibus ou de mapa é código com as mesmas permissões de qualquer mod: pode ler e gravar arquivos e acessar a rede. Como ele chega dentro de um download de ônibus ou mapa, e não pelo instalador, o jogador é consultado na primeira vez que o pacote aparece. A pergunta mostra o nome, o autor, a origem e o SHA-256 da DLL, com as opções **Permitir**, **Agora não** e **Nunca**. A decisão fica gravada pelo SHA-256. Uma DLL nova, com outro hash, pergunta de novo. Pacotes revisados pela comunidade entram no catálogo (`scriptsConfiaveis`) e rodam sem perguntar. Um script que lança exceção em `Ativar`, ou cinco vezes seguidas no mesmo método, é desligado até o jogo fechar, e o jogador vê o motivo na tela. ## Qual escolher [Seção intitulada “Qual escolher”](#qual-escolher) * **A função vale para qualquer ônibus ou mapa** (física, câmera, interface, gráficos, volante): mod global. * **A função é de um modelo de ônibus** e deve chegar junto dele no download: script de ônibus. * **A função é de uma cidade ou de um mapa**: script de mapa. * **Só muda modelo, textura, som ou parâmetros que o `.ini` ou o `.map.txt` já aceitam**: conteúdo do jogo, sem código. Os dois caminhos se misturam. Um mod global pode ler a pasta do ônibus em uso (`Veiculo.Pasta`) e procurar arquivos de configuração deixados pelos autores de ônibus. Um script de ônibus pode publicar valores com [`Dados`](/pbs-loader-docs/referencia/pbsloadercommonutils/dados/) para um mod global ler. # Boas práticas > Onde ler e onde mudar cada coisa do jogo, e os erros comuns que derrubam o jogo, brigam com outros mods ou pesam no desempenho. O jogo, o SDK e os outros mods dividem o mesmo processo, o mesmo cursor, o mesmo teclado e o mesmo ônibus. A maior parte dos problemas de um mod vem de mexer nessas coisas fora do lugar certo. Esta página junta as regras e mostra, caso a caso, o que evitar e o que fazer. Os trechos são partes de uma classe `MelonMod` (ou de um script, no fim da página) e usam estes namespaces: ```csharp using MelonLoader; using PBSLoaderCommonUtils; // Sdk, Ganchos, Dados, Salvos, Gaveta using PBSLoaderCommonUtils.Conteudo; // ScriptDeOnibus, ScriptDeMapa, Pacote using PBSLoaderCommonUtils.Entrada; // Atalhos, Mouse, Teclado using PBSLoaderCommonUtils.Interface; // Avisos, Gravidade using PBSLoaderCommonUtils.Midia; // Carregar using PBSLoaderCommonUtils.Mundo; // Trafego using PBSLoaderCommonUtils.Partida; // Vista, Opcoes using PBSLoaderCommonUtils.Veiculos; // Veiculo, Conducao, Comandos, PedidoDePorta using UnityEngine; ``` ## Onde fazer cada coisa [Seção intitulada “Onde fazer cada coisa”](#onde-fazer-cada-coisa) | Para | Use | Onde | | -------------------------------------------- | ------------------------------------------------------------------------------------- | --------------------------------------------------------------- | | ler velocidade, motor, pedais, luzes, portas | [`Veiculo`](/pbs-loader-docs/referencia/pbsloadercommonutils/veiculos/veiculo/) | `OnUpdate` ou `Sdk.Quadro`, depois de conferir `Veiculo.Existe` | | mexer em motor, câmbio ou pneus | [`Ganchos.DepoisDaFisica`](/pbs-loader-docs/referencia/pbsloadercommonutils/ganchos/) | dentro do gancho, sem alocar memória | | mudar a força de frenagem | `Ganchos.AntesDosFreios` | dentro do gancho | | acelerar, frear ou esterçar pelo mod | [`Conducao`](/pbs-loader-docs/referencia/pbsloadercommonutils/veiculos/conducao/) | `OnUpdate`, a cada quadro enquanto quiser o controle | | engatar marcha | `Comandos.Marcha` (automático) ou `Conducao.Marcha` (manual) | uma vez no automático; a cada quadro no manual | | abrir uma porta | `Comandos.Porta` | quando quiser | | impedir que uma porta abra | `Ganchos.PortaPedida` com `Cancelar` | dentro do gancho | | posicionar a câmera | `Vista.Assumir` | a cada quadro em que a câmera é sua | | soltar ou prender o cursor | `Mouse.Soltar` e `Mouse.Prender` | a cada quadro | | reagir a uma tecla | `Atalhos.Registrar` | uma vez, no `OnInitializeMelon` | | digitar num painel sem acionar o jogo | `Teclado.SuspenderJogo` | a cada quadro com o campo aberto | | mostrar um estado na tela | `Avisos.Definir` | quando o estado mudar, ou a cada quadro | | avisar de um acontecimento | `Avisos.Notificar` | uma vez, no momento do acontecimento | | passar um valor para outro mod | [`Dados`](/pbs-loader-docs/referencia/pbsloadercommonutils/dados/) | quando o valor mudar | | guardar algo para a próxima sessão | [`Salvos`](/pbs-loader-docs/referencia/pbsloadercommonutils/salvos/) | ao mudar; o SDK grava o arquivo sozinho | | carregar textura, som ou modelo | `Carregar.Textura`, `Carregar.Som`, `Carregar.Modelo` | uma vez, e guarde o resultado | | ver carros e semáforos | `Trafego.Veiculos`, `Trafego.Semaforos` | só enquanto a função do mod está ligada | | mudar uma opção do jogo | `Opcoes` | só quando o valor for diferente | ## Ler o jogo só na thread principal [Seção intitulada “Ler o jogo só na thread principal”](#ler-o-jogo-só-na-thread-principal) Evite: ```csharp Task.Run(async () => { while (true) { _velocidade = Veiculo.VelocidadeKmh; // fora da thread principal await Task.Delay(100); } }); ``` Faça: ```csharp public override void OnUpdate() { if (!Veiculo.Existe) return; _amostra = new Amostra(Veiculo.VelocidadeKmh, Veiculo.Motor.Rpm); } readonly record struct Amostra(float VelocidadeKmh, float Rpm); ``` O jogo é IL2CPP, e o coletor de lixo dele não conhece threads criadas pelo mod. Tocar num objeto da Unity, do jogo ou do SDK fora da thread principal derruba o jogo, às vezes minutos depois e sem mensagem no log. Se o mod precisa de trabalho pesado em outra thread (gravar telemetria, calcular algo demorado), copie os valores para tipos comuns do C#, como a `Amostra` acima, e passe essa cópia adiante. ## Conferir se o ônibus existe [Seção intitulada “Conferir se o ônibus existe”](#conferir-se-o-ônibus-existe) Evite: ```csharp public override void OnUpdate() { if (Veiculo.VelocidadeKmh < 1f) Avisos.Definir("MeuMod", "parado", true, Gravidade.Info, "Ônibus parado"); } ``` Faça: ```csharp public override void OnUpdate() { if (!Veiculo.Existe) return; Avisos.Definir("MeuMod", "parado", Veiculo.Parado, Gravidade.Info, "Ônibus parado"); } ``` No menu e nas telas de escolha não há ônibus, e o SDK devolve o valor padrão em vez de lançar exceção: `VelocidadeKmh` vale 0. O primeiro código conclui que o ônibus está parado quando não há ônibus nenhum. Confira `Veiculo.Existe`, `Mapa.Existe` ou `Sdk.Fase` antes de usar os números. ## Pedidos que valem por quadro [Seção intitulada “Pedidos que valem por quadro”](#pedidos-que-valem-por-quadro) `Conducao`, `Mouse`, `Teclado.SuspenderJogo` e `Vista.Assumir` funcionam do mesmo jeito: o pedido vale enquanto for repetido. Quando o mod para de pedir, o controle volta ao jogador ou a quem mais estiver pedindo, no quadro seguinte. Assim, um mod que trava ou é desligado nunca deixa o pedal preso ou o cursor solto. Evite: ```csharp Sdk.MapaCarregou += () => Conducao.Freio("MeuMod", 1f); // vale só para um quadro ``` Faça: ```csharp public override void OnUpdate() { if (!Veiculo.Existe) return; if (_limitadorLigado && Veiculo.VelocidadeKmh > 60f) Conducao.Acelerador("MeuMod", 0f); // repetido a cada quadro acima de 60 km/h } ``` Com dois mods pedindo o mesmo pedal, vale o maior no freio e no freio de mão e o último pedido nos outros. `Conducao.Donos` diz quem está pedindo. O câmbio tem uma exceção. No automático, `Comandos.Marcha(1)` põe em D, e o jogo mantém a posição. No manual, o jogo reverte a marcha a cada quadro, então use `Conducao.Marcha("MeuMod", 2)` repetido enquanto quiser aquela marcha. ## Cursor e teclado [Seção intitulada “Cursor e teclado”](#cursor-e-teclado) Evite: ```csharp Cursor.lockState = CursorLockMode.None; Cursor.visible = true; ``` Faça: ```csharp public override void OnUpdate() { Mouse.Soltar("MeuMod", _painelAberto); Teclado.SuspenderJogo("MeuMod", _campoDeTextoAtivo); } ``` O cursor é um só para o jogo e todos os mods. Quem mexe direto em `Cursor.lockState` briga com a câmera do jogo e com os outros mods, e o resultado mais comum é o cursor preso no meio da tela com um painel aberto. Com `Mouse`, solto ganha de preso, e quando ninguém pede, o cursor volta a ser do jogo. `Teclado.SuspenderJogo` desliga os controles de teclado do jogo enquanto o seu painel precisa das teclas, para a buzina não tocar enquanto o jogador digita. Num campo de texto da Unity com foco, o SDK já faz isso sozinho. ## Teclas: registre um atalho [Seção intitulada “Teclas: registre um atalho”](#teclas-registre-um-atalho) Evite: ```csharp if (Input.GetKeyDown(KeyCode.H)) _painelAberto = !_painelAberto; ``` Faça: ```csharp public override void OnInitializeMelon() { Atalhos.Registrar("MeuMod", "Painel", "Painel do MeuMod", "Ctrl+Alt+Home", () => _painelAberto = !_painelAberto); } ``` O jogo usa quase todas as letras, os números, as setas e boa parte do teclado numérico, e alguns scripts dele ignoram Ctrl e Alt. O `H` do primeiro exemplo também aciona um comando do jogo. Um atalho registrado aparece na página **Atalhos** da PBSLoaderCommonInterface, onde o jogador troca a tecla e vê conflitos com o jogo e com outros mods, e não dispara enquanto ele digita num campo de texto. Ficam livres F2, F3, F9 a F12, Home, Insert, Delete, PgUp e PgDn, mas os mods do catálogo já usam Ctrl+Alt com F2, F3 e F9 a F12. Prefira combinações com Home, Insert, Delete, PgUp ou PgDn. O primeiro argumento é o Identifier da categoria de preferências do seu mod. É por ele que a interface junta os atalhos na página do mod. ## Câmera [Seção intitulada “Câmera”](#câmera) Evite escrever um patch Harmony no `MouseOrbitCSHARP.Update` do jogo para mover a câmera. Faça: ```csharp public override void OnLateUpdate() { Vista.Assumir("MeuMod", _cameraLivreLigada); if (_cameraLivreLigada && Vista.Camera != null) Vista.Camera.transform.position = _posicaoDaCamera; } ``` Enquanto algum mod pede, a câmera orbital do jogo não roda. Dois mods com patch próprio no mesmo método disputam a câmera a cada quadro. ## Ganchos de física: rápido e sem alocar [Seção intitulada “Ganchos de física: rápido e sem alocar”](#ganchos-de-física-rápido-e-sem-alocar) Os ganchos de física rodam dezenas de vezes por segundo, dentro do passo de física do jogo. Cada alocação ali vira trabalho para o coletor de lixo, e o resultado são travadas a cada poucos segundos. Evite: ```csharp Ganchos.DepoisDaFisica += vpp => { _historico.Add(Veiculo.Motor.Rpm); // a lista cresce sem parar LoggerInstance.Msg($"rpm {Veiculo.Motor.Rpm}"); // texto novo e escrita em disco a cada passo }; ``` Faça: ```csharp readonly float[] _rpm = new float[256]; int _posicao; public override void OnInitializeMelon() { Ganchos.DepoisDaFisica += vpp => { _rpm[_posicao] = Veiculo.Motor.Rpm; _posicao = (_posicao + 1) % _rpm.Length; }; } ``` Mexa no motor, no câmbio e nos pneus em `DepoisDaFisica`, e não no `OnUpdate`. O `OnUpdate` roda uma vez por quadro desenhado, a física roda num ritmo fixo, e uma mudança feita no lugar errado é sobrescrita pelo próximo passo. O argumento do gancho é o componente do jogo (`VPVehicleController`), e os campos dele podem mudar entre versões. Os ganchos só disparam para o veículo do jogador, nunca para o tráfego. ## Avisos: condição ou acontecimento [Seção intitulada “Avisos: condição ou acontecimento”](#avisos-condição-ou-acontecimento) Evite: ```csharp public override void OnUpdate() { if (_pressaoDoOleo < 1f) Avisos.Notificar("MeuMod", "oleo", Gravidade.Falha, "Pressão do óleo baixa"); // recria o aviso a cada quadro } ``` Faça: ```csharp public override void OnUpdate() { if (!Veiculo.Existe) return; Avisos.Definir("MeuMod", "oleo", _pressaoDoOleo < 1f, Gravidade.Falha, "Pressão do óleo baixa", $"{_pressaoDoOleo:0.0} bar"); } void AoSalvarAjustes() => Avisos.Notificar("MeuMod", "salvo", Gravidade.Info, "Ajustes salvos"); ``` `Definir` é para uma condição: o aviso fica na tela enquanto ela vale e sai quando você passa `false`. `Notificar` é para um acontecimento: aparece uma vez e some sozinho depois de alguns segundos. Trocar de veículo limpa todos os avisos. ## Trocar dados com outro mod [Seção intitulada “Trocar dados com outro mod”](#trocar-dados-com-outro-mod) Evite referenciar a DLL de outro mod para ler um campo estático dele. Se o outro mod não estiver instalado, o seu deixa de carregar, e qualquer mudança interna nele quebra o seu. Faça: ```csharp // no mod que publica Dados.Publicar("MeuMod", "temperaturaOleo", _temperatura); // no mod que lê, sem depender da DLL do primeiro float temperatura = Dados.Ler("MeuMod", "temperaturaOleo", 0f); ``` O valor publicado vale até o veículo trocar. Com `porVeiculo: false`, vale até o jogo fechar. ## Salvar entre sessões [Seção intitulada “Salvar entre sessões”](#salvar-entre-sessões) Evite gravar arquivo a cada quadro ou chamar `Salvos.GravarAgora()` em todo `OnUpdate`. Faça: ```csharp Gaveta _gaveta; public override void OnInitializeMelon() { Sdk.VeiculoTrocou += () => _gaveta = Veiculo.Existe ? Salvos.DoOnibus("MeuMod") : null; } void AoTerminarViagem(float km) { if (_gaveta == null) return; _gaveta.Gravar("km", _gaveta.Ler("km", 0f) + km); } ``` `Gravar` só marca a gaveta. O arquivo é escrito 1,5 segundo depois da última mudança, na troca de cena e quando o jogo fecha. Pegue a gaveta de novo a cada troca de ônibus (`Salvos.DoOnibus`) ou de mapa (`Salvos.DoMapa`), porque cada ônibus tem a sua. ## Texturas, sons e modelos [Seção intitulada “Texturas, sons e modelos”](#texturas-sons-e-modelos) Evite: ```csharp public override void OnGUI() { var icone = Carregar.Textura(_caminhoDoIcone); // lê o arquivo de novo a cada quadro GUI.DrawTexture(new Rect(10, 10, 64, 64), icone); } ``` Faça: ```csharp Texture2D _icone; public override void OnInitializeMelon() => _icone = Carregar.Textura(_caminhoDoIcone); public override void OnGUI() { if (_icone != null) GUI.DrawTexture(new Rect(10, 10, 64, 64), _icone); } ``` O que o mod carrega não some quando o jogo troca de ônibus. Quando não precisar mais de um recurso, destrua com `UnityEngine.Object.Destroy`. Um erro de carregamento volta `null` e uma linha no log. Para trocar a textura de uma peça do ônibus do jogador, use `Veiculo.Objetos.TrocarTextura`. Ele muda só as instâncias de material daquele ônibus. Mexer direto no `sharedMaterial` de um renderizador muda também os ônibus do tráfego que usam o mesmo modelo. ## Tráfego: leia só quando precisar [Seção intitulada “Tráfego: leia só quando precisar”](#tráfego-leia-só-quando-precisar) `Trafego.Veiculos`, `Trafego.PedestresAtivos` e `Trafego.Semaforos` varrem a cena uma vez por segundo, e só enquanto algum mod lê essas listas. Ler “por garantia”, com a função do mod desligada, faz o SDK continuar varrendo à toa. ```csharp public override void OnUpdate() { if (!Veiculo.Existe || !_radarLigado) return; var frente = Trafego.MaisPertoAFrente(80f); _distanciaAFrente = frente != null ? frente.DistanciaM : float.PositiveInfinity; } ``` ## Opções do jogo [Seção intitulada “Opções do jogo”](#opções-do-jogo) Gravar uma opção escreve o `settings.txt` do jogo na hora. Evite atribuir o valor a cada quadro. Confira antes: ```csharp if (Opcoes.CarrosNoTransito.Valor != 40) Opcoes.CarrosNoTransito.Valor = 40; ``` ## Patch Harmony próprio [Seção intitulada “Patch Harmony próprio”](#patch-harmony-próprio) Prefira um [gancho](/pbs-loader-docs/referencia/pbsloadercommonutils/ganchos/). Se o SDK ainda não tem o ponto que você precisa, peça no repositório do PBSLoader. Se fizer o patch mesmo assim, fique parado no modo seguro, porque numa versão do jogo que não foi testada o método pode ter mudado: ```csharp public override void OnInitializeMelon() { if (!Sdk.Requer("2.0", "MeuMod")) return; if (Sdk.ModoSeguro) return; // versão do jogo não testada: não aplique patches HarmonyInstance.PatchAll(); } ``` ## Exceções [Seção intitulada “Exceções”](#exceções) Uma exceção no `OnUpdate` se repete a cada quadro e enche o log. Envolva a parte arriscada com `Sdk.Seguro`, que registra no máximo uma vez a cada 10 segundos por nome: ```csharp public override void OnUpdate() => Sdk.Seguro(AtualizarPainel, "MeuMod.painel"); ``` Os eventos do SDK já fazem isso com os inscritos. ## Scripts de ônibus e de mapa [Seção intitulada “Scripts de ônibus e de mapa”](#scripts-de-ônibus-e-de-mapa) As mesmas regras valem, com três cuidados a mais: ```csharp public class MeuScript : ScriptDeOnibus { public override void Ativar() { Ganchos.PortaPedida += AoPedirPorta; var som = Pacote.Som("sons/aviso.wav"); // arquivo da pasta do pacote } public override void Desativar() { Ganchos.PortaPedida -= AoPedirPorta; // a inscrição não sai sozinha } void AoPedirPorta(PedidoDePorta pedido) { if (pedido.Abrindo && Veiculo.VelocidadeKmh > 3f) pedido.Cancelar(Pacote.Id); } } ``` * Saia em `Desativar` de todo evento em que entrou em `Ativar`. Senão, o script continua reagindo com outro ônibus em jogo. * Use `Pacote.Harmony` para patches. A PBSLoaderCommonUtils desfaz esses patches quando o pacote desativa, e um `new Harmony(...)` próprio ficaria aplicado. * Leia arquivos com `Pacote.Caminho`, `Pacote.LerTexto`, `Pacote.Textura` e os outros métodos do pacote. Eles não saem da pasta do pacote, e o mesmo script funciona onde quer que o jogador tenha posto o ônibus. # Referência da API > Tipos e membros públicos das bibliotecas do PBSLoader. Tipos e membros públicos das bibliotecas do PBSLoader, gerados a partir da DLL de cada release. Membros sem descrição ainda não têm comentário de documentação no código. | Biblioteca | Versão | Tipos | | --------------------------------------------------------------------------------- | ------ | ----- | | [PBSLoaderCommonUtils](/pbs-loader-docs/referencia/pbsloadercommonutils/) | 2.0.0 | 81 | | [PBSLoaderCommonInterface](/pbs-loader-docs/referencia/pbsloadercommoninterface/) | 0.4.0 | 5 | # PBSLoaderCommonInterface > Referência da API da PBSLoaderCommonInterface 0.4.0. Gerada do release [`pbsloadercommoninterface-v0.4.0`](https://github.com/Sebola3461/pbsu-loader/releases/tag/pbsloadercommoninterface-v0.4.0) (versão de teste). ## `PBSLoaderCommonInterface` [Seção intitulada “PBSLoaderCommonInterface”](#pbsloadercommoninterface) | Tipo | Categoria | Resumo | | -------------------------------------------------------------------------------- | --------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | [`Hud`](/pbs-loader-docs/referencia/pbsloadercommoninterface/hud/) | classe estática | Cartões de texto de mods na tela, durante a direção, numa coluna no canto superior direito (o inferior é do painel de condução e dos avisos). | | [`Paineis`](/pbs-loader-docs/referencia/pbsloadercommoninterface/paineis/) | classe estática | Painéis dos mods (ver Painel). | | [`Painel`](/pbs-loader-docs/referencia/pbsloadercommoninterface/painel/) | classe | Um painel de mod: uma janela pequena por cima do jogo, que não pausa nem tampa a direção, montada a partir do que o mod descreve (textos, valores, barras, botões, chaves, faixas). | | [`PainelMods`](/pbs-loader-docs/referencia/pbsloadercommoninterface/painelmods/) | classe estática | | | [`Widget`](/pbs-loader-docs/referencia/pbsloadercommoninterface/widget/) | classe | Um cartão de HUD de um mod (ver Hud.Adicionar). | # Hud > Cartões de texto de mods na tela, durante a direção, numa coluna no canto superior direito (o inferior é do painel de condução e dos avisos). Namespace `PBSLoaderCommonInterface` · classe estática · PBSLoaderCommonInterface 0.4.0 ```csharp public static class Hud ``` Cartões de texto de mods na tela, durante a direção, numa coluna no canto superior direito (o inferior é do painel de condução e dos avisos). Não recebem clique. O jogador pode esconder todos nas opções da interface. ```csharp Hud.Adicionar("MeuMod", "oleo", "Óleo", () => $"{_temp:0} °C"); ``` ## Propriedades [Seção intitulada “Propriedades”](#propriedades) ### Todos [Seção intitulada “Todos”](#todos) ```csharp public static IReadOnlyList Todos { get; } ``` ## Métodos [Seção intitulada “Métodos”](#métodos) ### Adicionar [Seção intitulada “Adicionar”](#adicionar) ```csharp public static Widget Adicionar(string mod, string id, string titulo, Func valor, int ordem = 0, Func cor = null) ``` Acrescenta (ou devolve o já existente) o cartão `id` do mod. `valor` é lido a cada quadro; `cor`, se dado, colore o valor (null = cor padrão). # Paineis > Painéis dos mods (ver Painel). Namespace `PBSLoaderCommonInterface` · classe estática · PBSLoaderCommonInterface 0.4.0 ```csharp public static class Paineis ``` Painéis dos mods (ver `Painel`). Exemplo: ```csharp var p = Paineis.Criar("MeuMod", "Freios", "Freios", "Ctrl+Alt+F5") .Valor("Pressão", () => $"{Ar.Pressao:0.0} bar") .Barra("Freio", () => Veiculo.Pedais.Freio) .Chave("Freio motor", () => _freioMotor, v => _freioMotor = v) .Botao("Zerar", Zerar); ``` Cada painel também aparece como ação na página do mod no menu Mods. ## Propriedades [Seção intitulada “Propriedades”](#propriedades) ### Todos [Seção intitulada “Todos”](#todos) ```csharp public static IReadOnlyList Todos { get; } ``` ## Métodos [Seção intitulada “Métodos”](#métodos) ### Criar [Seção intitulada “Criar”](#criar) ```csharp public static Painel Criar(string mod, string id, string titulo, string atalho = null) ``` Cria (ou devolve o já criado) o painel `id` do mod `mod` (o Identifier da categoria de preferências dele). Com `atalho`, registra um atalho que abre e fecha o painel. # Painel > Um painel de mod: uma janela pequena por cima do jogo, que não pausa nem tampa a direção, montada a partir do que o mod descreve (textos, valores, barras, botões, chaves, faixas). Namespace `PBSLoaderCommonInterface` · classe · PBSLoaderCommonInterface 0.4.0 ```csharp public sealed class Painel ``` Um painel de mod: uma janela pequena por cima do jogo, que não pausa nem tampa a direção, montada a partir do que o mod descreve (textos, valores, barras, botões, chaves, faixas). A PBSLoaderCommonInterface desenha no visual dela, atualiza os valores a cada quadro e solta o cursor enquanto o painel está aberto. Crie com `Paineis.Criar`. Os itens são lidos e chamados na thread principal; uma exceção num item vira “—” e uma linha no log. ## Propriedades [Seção intitulada “Propriedades”](#propriedades) ### Mod [Seção intitulada “Mod”](#mod) ```csharp public string Mod { get; } ``` ### Id [Seção intitulada “Id”](#id) ```csharp public string Id { get; } ``` ### Titulo [Seção intitulada “Titulo”](#titulo) ```csharp public string Titulo { get; set; } ``` ### Largura [Seção intitulada “Largura”](#largura) ```csharp public float Largura { get; set; } ``` Largura da janela, em pixels de uma tela 1920x1080. ### Atalho [Seção intitulada “Atalho”](#atalho) ```csharp public Atalho Atalho { get; } ``` Atalho que abre e fecha o painel (registrado em `Paineis.Criar`), ou null. ### Aberto [Seção intitulada “Aberto”](#aberto) ```csharp public bool Aberto { get; } ``` ## Métodos [Seção intitulada “Métodos”](#métodos) ### Abrir [Seção intitulada “Abrir”](#abrir) ```csharp public void Abrir() ``` ### Fechar [Seção intitulada “Fechar”](#fechar) ```csharp public void Fechar() ``` ### Alternar [Seção intitulada “Alternar”](#alternar) ```csharp public void Alternar() ``` ### Secao [Seção intitulada “Secao”](#secao) ```csharp public Painel Secao(string titulo) ``` Título de grupo. ### Texto [Seção intitulada “Texto”](#texto) ```csharp public Painel Texto(Func texto) ``` Texto corrido, recalculado a cada quadro. ### Valor [Seção intitulada “Valor”](#valor) ```csharp public Painel Valor(string rotulo, Func valor, string descricao = null) ``` Rótulo à esquerda e valor à direita (“Pressão”, “8,2 bar”). ### Barra [Seção intitulada “Barra”](#barra) ```csharp public Painel Barra(string rotulo, Func valor01, Func texto = null) ``` Barra de 0 a 1, com um texto opcional ao lado. ### Botao [Seção intitulada “Botao”](#botao) ```csharp public Painel Botao(string rotulo, Action acao, string textoDoBotao = "Executar", string descricao = null) ``` Botão que roda `acao`. ### Chave [Seção intitulada “Chave”](#chave) ```csharp public Painel Chave(string rotulo, Func ler, Action mudar, string descricao = null) ``` Chave liga/desliga: `ler` diz o estado, `mudar` recebe o novo. ### Faixa [Seção intitulada “Faixa”](#faixa) ```csharp public Painel Faixa(string rotulo, Func ler, Action mudar, float min, float max, float passo = 0f, string formato = "0.##") ``` Faixa arrastável de `min` a `max` (passo 0 = contínua). ### Preferencia [Seção intitulada “Preferencia”](#preferencia) ```csharp public Painel Preferencia(MelonPreferences_Entry entrada, float min = NaNf, float max = NaNf, float passo = 0f) ``` Uma preferência do mod, com o controle do tipo dela: bool vira chave; número vira faixa (com `min` e `max`) ou valor; o resto vira valor. Mudanças gravam o .cfg ao fechar o painel. # PainelMods > classe estática PBSLoaderCommonInterface.PainelMods Namespace `PBSLoaderCommonInterface` · classe estática · PBSLoaderCommonInterface 0.4.0 ```csharp public static class PainelMods ``` ## Métodos [Seção intitulada “Métodos”](#métodos) ### Acao [Seção intitulada “Acao”](#acao) ```csharp public static void Acao(string categoria, string rotulo, Action acao, string descricao = null) ``` Botão que roda `acao` (ex.: abrir o painel do mod). ### Faixa [Seção intitulada “Faixa”](#faixa) ```csharp public static void Faixa(string categoria, string entrada, float min, float max, float passo = 0f) ``` Faixa de um número: vira slider de min a max (passo 0 = contínuo). ### Ocultar [Seção intitulada “Ocultar”](#ocultar) ```csharp public static void Ocultar(string categoria, string entrada) ``` Esconde uma entrada das preferências do painel. ### Nome [Seção intitulada “Nome”](#nome) ```csharp public static void Nome(string categoria, string titulo, string icone = null) ``` Título (e ícone da Segoe Fluent Icons, opcional) do mod no menu. ### Abrir [Seção intitulada “Abrir”](#abrir) ```csharp public static void Abrir(string categoria = null) ``` Abre o painel de mods (na categoria indicada, se houver). # Widget > Um cartão de HUD de um mod (ver Hud.Adicionar). Namespace `PBSLoaderCommonInterface` · classe · PBSLoaderCommonInterface 0.4.0 ```csharp public sealed class Widget ``` Um cartão de HUD de um mod (ver `Hud.Adicionar`). ## Propriedades [Seção intitulada “Propriedades”](#propriedades) ### Mod [Seção intitulada “Mod”](#mod) ```csharp public string Mod { get; } ``` ### Id [Seção intitulada “Id”](#id) ```csharp public string Id { get; } ``` ### Titulo [Seção intitulada “Titulo”](#titulo) ```csharp public string Titulo { get; set; } ``` Rótulo pequeno em cima do valor (“PRESSÃO”). ### Visivel [Seção intitulada “Visivel”](#visivel) ```csharp public bool Visivel { get; set; } ``` Esconde o cartão sem removê-lo (ex.: só mostrar quando faz sentido). ### Ordem [Seção intitulada “Ordem”](#ordem) ```csharp public int Ordem { get; set; } ``` Cartões com ordem menor ficam mais em cima. ## Métodos [Seção intitulada “Métodos”](#métodos) ### Remover [Seção intitulada “Remover”](#remover) ```csharp public void Remover() ``` # PBSLoaderCommonUtils > Referência da API da PBSLoaderCommonUtils 2.0.0. Gerada do release [`pbsloadercommonutils-v2.0.0`](https://github.com/Sebola3461/pbsu-loader/releases/tag/pbsloadercommonutils-v2.0.0) (versão de teste). ## `PBSLoaderCommonUtils` [Seção intitulada “PBSLoaderCommonUtils”](#pbsloadercommonutils) | Tipo | Categoria | Resumo | | ---------------------------------------------------------------------------------- | --------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | [`Avancado`](/pbs-loader-docs/referencia/pbsloadercommonutils/avancado/) | classe estática | Componentes do jogo por trás das fachadas do SDK, para quem precisa de algo que o SDK ainda não expõe. | | [`Dados`](/pbs-loader-docs/referencia/pbsloadercommonutils/dados/) | classe estática | Valores que um mod publica para os outros lerem, sem um depender da DLL do outro (ex.: o SuspensaoAr publica o nível da suspensão; a PBSLoaderCommonInterface mostra). | | [`Fase`](/pbs-loader-docs/referencia/pbsloadercommonutils/fase/) | enumeração | Em que parte do jogo o jogador está. | | [`Ganchos`](/pbs-loader-docs/referencia/pbsloadercommonutils/ganchos/) | classe estática | Pontos do jogo onde os mods podem entrar sem escrever um patch Harmony. | | [`Gaveta`](/pbs-loader-docs/referencia/pbsloadercommonutils/gaveta/) | classe | Dados guardados de uma sessão para outra, em chave e valor (números, textos, listas, classes simples), num arquivo JSON por mod e por lugar. | | [`PedidoDePorta`](/pbs-loader-docs/referencia/pbsloadercommonutils/pedidodeporta/) | classe | Um pedido de abrir ou fechar uma porta, antes de o jogo agir. | | [`Salvos`](/pbs-loader-docs/referencia/pbsloadercommonutils/salvos/) | classe estática | Gavetas de dados que sobrevivem entre sessões (ver Gaveta). | | [`Sdk`](/pbs-loader-docs/referencia/pbsloadercommonutils/sdk/) | classe estática | Ciclo de vida do SDK: versão, fase do jogo e eventos. | ## `PBSLoaderCommonUtils.Conteudo` [Seção intitulada “PBSLoaderCommonUtils.Conteudo”](#pbsloadercommonutilsconteudo) | Tipo | Categoria | Resumo | | --------------------------------------------------------------------------------------------- | --------------- | ---------------------------------------------------------------------------------- | | [`Confirmacao`](/pbs-loader-docs/referencia/pbsloadercommonutils/conteudo/confirmacao/) | classe estática | Pergunta ao jogador se um pacote de scripts pode rodar. | | [`Decisao`](/pbs-loader-docs/referencia/pbsloadercommonutils/conteudo/decisao/) | enumeração | | | [`EstadoDoPacote`](/pbs-loader-docs/referencia/pbsloadercommonutils/conteudo/estadodopacote/) | enumeração | | | [`OrigemDoPacote`](/pbs-loader-docs/referencia/pbsloadercommonutils/conteudo/origemdopacote/) | enumeração | | | [`Pacote`](/pbs-loader-docs/referencia/pbsloadercommonutils/conteudo/pacote/) | classe | Um pacote de scripts (pasta scripts/ de um ônibus ou mapa, com pbsu.json e a DLL). | | [`Pacotes`](/pbs-loader-docs/referencia/pbsloadercommonutils/conteudo/pacotes/) | classe estática | Pacotes de scripts que a PBSLoaderCommonUtils encontrou nesta sessão. | | [`Script`](/pbs-loader-docs/referencia/pbsloadercommonutils/conteudo/script/) | classe abstrata | Base dos scripts que vêm junto com um ônibus ou mapa. | | [`ScriptDeMapa`](/pbs-loader-docs/referencia/pbsloadercommonutils/conteudo/scriptdemapa/) | classe abstrata | Script de um mapa: ativo enquanto aquele mapa está carregado. | | [`ScriptDeOnibus`](/pbs-loader-docs/referencia/pbsloadercommonutils/conteudo/scriptdeonibus/) | classe abstrata | Script de um ônibus: ativo enquanto aquele ônibus é o veículo do jogador. | ## `PBSLoaderCommonUtils.Entrada` [Seção intitulada “PBSLoaderCommonUtils.Entrada”](#pbsloadercommonutilsentrada) | Tipo | Categoria | Resumo | | ---------------------------------------------------------------------------------------------- | --------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | [`AcaoDoJogo`](/pbs-loader-docs/referencia/pbsloadercommonutils/entrada/acaodojogo/) | classe | Uma ação dos controles do jogo (Rewired): “Acelerar”, “Seta Esquerda”, “Abrir Porta 1”… | | [`Atalho`](/pbs-loader-docs/referencia/pbsloadercommonutils/entrada/atalho/) | classe | Um atalho registrado por um mod. | | [`Atalhos`](/pbs-loader-docs/referencia/pbsloadercommonutils/entrada/atalhos/) | classe estática | Registro único de atalhos de todos os mods. | | [`Combinacao`](/pbs-loader-docs/referencia/pbsloadercommonutils/entrada/combinacao/) | struct | Uma tecla com os modificadores que precisam estar apertados junto: “Ctrl+Alt+V”, “PageDown”, “LeftAlt”. | | [`ControlesDoJogo`](/pbs-loader-docs/referencia/pbsloadercommonutils/entrada/controlesdojogo/) | classe estática | O que o jogador está fazendo nos controles do jogo (teclado, volante, controle), pelas ações do Rewired, já com o mapeamento que ele escolheu. | | [`Mouse`](/pbs-loader-docs/referencia/pbsloadercommonutils/entrada/mouse/) | classe estática | Dono único do cursor. | | [`Teclado`](/pbs-loader-docs/referencia/pbsloadercommonutils/entrada/teclado/) | classe estática | Suspende os controles de teclado do jogo (Rewired) enquanto algum mod precisa do teclado: um painel que usa teclas (ex.: ajustar espelhos pelo teclado numérico sem ligar a seta) ou o jogador digitand… | | [`TeclasDoJogo`](/pbs-loader-docs/referencia/pbsloadercommonutils/entrada/teclasdojogo/) | classe estática | Teclas que o jogo usa, para avisar conflitos. | | [`TipoDeAcao`](/pbs-loader-docs/referencia/pbsloadercommonutils/entrada/tipodeacao/) | enumeração | | ## `PBSLoaderCommonUtils.Interface` [Seção intitulada “PBSLoaderCommonUtils.Interface”](#pbsloadercommonutilsinterface) | Tipo | Categoria | Resumo | | ------------------------------------------------------------------------------------ | --------------- | -------------------------------------------- | | [`Alerta`](/pbs-loader-docs/referencia/pbsloadercommonutils/interface/alerta/) | classe | Um aviso do veículo. | | [`Avisos`](/pbs-loader-docs/referencia/pbsloadercommonutils/interface/avisos/) | classe estática | Avisos e falhas do veículo, de qualquer mod. | | [`Gravidade`](/pbs-loader-docs/referencia/pbsloadercommonutils/interface/gravidade/) | enumeração | | ## `PBSLoaderCommonUtils.Linhas` [Seção intitulada “PBSLoaderCommonUtils.Linhas”](#pbsloadercommonutilslinhas) | Tipo | Categoria | Resumo | | ------------------------------------------------------------------------------------- | --------------- | ------------------------------------------------------------- | | [`Letreiro`](/pbs-loader-docs/referencia/pbsloadercommonutils/linhas/letreiro/) | classe estática | Letreiro (itinerário) do ônibus do jogador (TrocaItinerario). | | [`Linha`](/pbs-loader-docs/referencia/pbsloadercommonutils/linhas/linha/) | classe estática | A linha que o ônibus do jogador faz. | | [`Passageiro`](/pbs-loader-docs/referencia/pbsloadercommonutils/linhas/passageiro/) | classe | Um passageiro do ônibus do jogador. | | [`Passageiros`](/pbs-loader-docs/referencia/pbsloadercommonutils/linhas/passageiros/) | classe estática | Passageiros do ônibus do jogador. | ## `PBSLoaderCommonUtils.Mapas` [Seção intitulada “PBSLoaderCommonUtils.Mapas”](#pbsloadercommonutilsmapas) | Tipo | Categoria | Resumo | | -------------------------------------------------------------------------------------- | --------------- | ---------------------------------------- | | [`Mapa`](/pbs-loader-docs/referencia/pbsloadercommonutils/mapas/mapa/) | classe estática | O mapa da partida. | | [`OrigemDoMapa`](/pbs-loader-docs/referencia/pbsloadercommonutils/mapas/origemdomapa/) | enumeração | | | [`Parada`](/pbs-loader-docs/referencia/pbsloadercommonutils/mapas/parada/) | classe | Um ponto de ônibus do mapa (MEPBusStop). | ## `PBSLoaderCommonUtils.Midia` [Seção intitulada “PBSLoaderCommonUtils.Midia”](#pbsloadercommonutilsmidia) | Tipo | Categoria | Resumo | | ------------------------------------------------------------------------------ | --------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | [`Carregar`](/pbs-loader-docs/referencia/pbsloadercommonutils/midia/carregar/) | classe estática | Carrega texturas, sons e modelos de arquivos, pelos mesmos carregadores que o jogo usa nos mods de ônibus e mapa (então formatos, cache e o CarregamentoRapido valem igual). | | [`Som3D`](/pbs-loader-docs/referencia/pbsloadercommonutils/midia/som3d/) | classe | Um som tocando no mundo (criado por Sons.Tocar). | | [`Sons`](/pbs-loader-docs/referencia/pbsloadercommonutils/midia/sons/) | classe estática | Sons 3D presos a um objeto (uma peça do ônibus, um ponto do mapa), no volume geral do jogo. | ## `PBSLoaderCommonUtils.Mundo` [Seção intitulada “PBSLoaderCommonUtils.Mundo”](#pbsloadercommonutilsmundo) | Tipo | Categoria | Resumo | | ---------------------------------------------------------------------------------------------- | --------------- | ---------------------------------------------------------------------------------- | | [`Chuva`](/pbs-loader-docs/referencia/pbsloadercommonutils/mundo/chuva/) | enumeração | | | [`Clima`](/pbs-loader-docs/referencia/pbsloadercommonutils/mundo/clima/) | classe estática | Clima do jogo: chuva (MepMobileControls/MepChuva) e o preset do EnviroSky. | | [`CorDoSemaforo`](/pbs-loader-docs/referencia/pbsloadercommonutils/mundo/cordosemaforo/) | enumeração | | | [`LuzDeSemaforo`](/pbs-loader-docs/referencia/pbsloadercommonutils/mundo/luzdesemaforo/) | classe | Um foco aceso de um semáforo. | | [`Semaforo`](/pbs-loader-docs/referencia/pbsloadercommonutils/mundo/semaforo/) | classe | Um semáforo do mapa (MEPAI_TrafficLights e variantes). | | [`Tempo`](/pbs-loader-docs/referencia/pbsloadercommonutils/mundo/tempo/) | classe estática | Hora do jogo (EnviroSky). | | [`TipoNoTrafego`](/pbs-loader-docs/referencia/pbsloadercommonutils/mundo/tiponotrafego/) | enumeração | | | [`Trafego`](/pbs-loader-docs/referencia/pbsloadercommonutils/mundo/trafego/) | classe estática | Tráfego de IA (MEPAI_Traffic_System_Controller): quantos existem agora e o limite. | | [`VeiculoDoTrafego`](/pbs-loader-docs/referencia/pbsloadercommonutils/mundo/veiculodotrafego/) | classe | Um veículo do trânsito (IA). | ## `PBSLoaderCommonUtils.Partida` [Seção intitulada “PBSLoaderCommonUtils.Partida”](#pbsloadercommonutilspartida) | Tipo | Categoria | Resumo | | -------------------------------------------------------------------------------------------- | --------------- | ------------------------------------------------------------------------------------------------------------------------------ | | [`Caminhos`](/pbs-loader-docs/referencia/pbsloadercommonutils/partida/caminhos/) | classe estática | Pastas do jogo (ProtonPaths). | | [`ModoDaVista`](/pbs-loader-docs/referencia/pbsloadercommonutils/partida/mododavista/) | enumeração | Câmera do jogo. | | [`Opcao`](/pbs-loader-docs/referencia/pbsloadercommonutils/partida/opcao/) | classe abstrata | Uma opção do jogo (settings.txt, pelo MepPrefs do jogo). | | [`Opcao`](/pbs-loader-docs/referencia/pbsloadercommonutils/partida/opcao-1/) | classe | | | [`Opcoes`](/pbs-loader-docs/referencia/pbsloadercommonutils/partida/opcoes/) | classe estática | Opções do próprio jogo (as do menu de opções dele), lidas e gravadas pelo MepPrefs do jogo, no settings.txt da pasta de dados. | | [`OrigemDoOnibus`](/pbs-loader-docs/referencia/pbsloadercommonutils/partida/origemdoonibus/) | enumeração | De onde veio o ônibus da partida. | | [`QuandoVale`](/pbs-loader-docs/referencia/pbsloadercommonutils/partida/quandovale/) | enumeração | Quando uma mudança de opção do jogo passa a valer. | | [`Sessao`](/pbs-loader-docs/referencia/pbsloadercommonutils/partida/sessao/) | classe estática | O que o jogador escolheu para a partida (ônibus, pintura, mapa, ponto de partida) e se está pausado. | | [`Vista`](/pbs-loader-docs/referencia/pbsloadercommonutils/partida/vista/) | classe estática | Câmera do jogador (MouseOrbitCSHARP). | ## `PBSLoaderCommonUtils.Simulacao` [Seção intitulada “PBSLoaderCommonUtils.Simulacao”](#pbsloadercommonutilssimulacao) | Tipo | Categoria | Resumo | | ---------------------------------------------------------------------- | --------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | [`Ar`](/pbs-loader-docs/referencia/pbsloadercommonutils/simulacao/ar/) | classe estática | Ar comprimido do veículo: compressor movido pelo motor, reservatório, governador com purga do secador, freio de serviço pneumático e freio de molas (estacionamento). | ## `PBSLoaderCommonUtils.Veiculos` [Seção intitulada “PBSLoaderCommonUtils.Veiculos”](#pbsloadercommonutilsveiculos) | Tipo | Categoria | Resumo | | --------------------------------------------------------------------------------------------------- | --------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | [`Comandos`](/pbs-loader-docs/referencia/pbsloadercommonutils/veiculos/comandos/) | classe estática | Comandos de carroceria do veículo do jogador, pelos mesmos métodos que os botões do jogo usam (então o jogo cuida de som, animação do botão do painel e luzes). | | [`Conducao`](/pbs-loader-docs/referencia/pbsloadercommonutils/veiculos/conducao/) | classe estática | Pedidos de condução de um mod (piloto automático, ajuda de direção, teste): acelerador, freio, embreagem, freio de mão e direção, no lugar do que o jogador está fazendo. | | [`Espelho`](/pbs-loader-docs/referencia/pbsloadercommonutils/veiculos/espelho/) | classe | Um dos três espelhos que o jogo renderiza (câmera + material que mostra a imagem). | | [`Farol`](/pbs-loader-docs/referencia/pbsloadercommonutils/veiculos/farol/) | enumeração | | | [`FisicaVeiculo`](/pbs-loader-docs/referencia/pbsloadercommonutils/veiculos/fisicaveiculo/) | enumeração | Física que move o veículo no jogo. | | [`Lado`](/pbs-loader-docs/referencia/pbsloadercommonutils/veiculos/lado/) | enumeração | | | [`Porta`](/pbs-loader-docs/referencia/pbsloadercommonutils/veiculos/porta/) | classe | Uma porta do veículo. | | [`PosicaoEspelho`](/pbs-loader-docs/referencia/pbsloadercommonutils/veiculos/posicaoespelho/) | enumeração | | | [`Roda`](/pbs-loader-docs/referencia/pbsloadercommonutils/veiculos/roda/) | classe | Uma roda do veículo (VPP). | | [`Seta`](/pbs-loader-docs/referencia/pbsloadercommonutils/veiculos/seta/) | enumeração | | | [`TipoVeiculo`](/pbs-loader-docs/referencia/pbsloadercommonutils/veiculos/tipoveiculo/) | enumeração | | | [`Veiculo`](/pbs-loader-docs/referencia/pbsloadercommonutils/veiculos/veiculo/) | classe estática | Veículo que o jogador dirige, lido a cada quadro do MEPControlesBus e do Vehicle Physics Pro. | | [`Veiculo.Ajudas`](/pbs-loader-docs/referencia/pbsloadercommonutils/veiculos/veiculo-ajudas/) | classe estática | | | [`Veiculo.Cabine`](/pbs-loader-docs/referencia/pbsloadercommonutils/veiculos/veiculo-cabine/) | classe estática | | | [`Veiculo.Cambio`](/pbs-loader-docs/referencia/pbsloadercommonutils/veiculos/veiculo-cambio/) | classe estática | | | [`Veiculo.Espelhos`](/pbs-loader-docs/referencia/pbsloadercommonutils/veiculos/veiculo-espelhos/) | classe estática | Os três espelhos que o jogo renderiza. | | [`Veiculo.Luzes`](/pbs-loader-docs/referencia/pbsloadercommonutils/veiculos/veiculo-luzes/) | classe estática | | | [`Veiculo.Motor`](/pbs-loader-docs/referencia/pbsloadercommonutils/veiculos/veiculo-motor/) | classe estática | | | [`Veiculo.Objetos`](/pbs-loader-docs/referencia/pbsloadercommonutils/veiculos/veiculo-objetos/) | classe estática | Objetos do modelo do ônibus do jogador, pelo nome (os mods de ônibus usam nomes como convenção: “*skin001*”, “*wipers1*”, “*r1y5*”…). | | [`Veiculo.Pedais`](/pbs-loader-docs/referencia/pbsloadercommonutils/veiculos/veiculo-pedais/) | classe estática | O que o motorista está pedindo (barramento de entrada do VPP, 0..1, direção -1..1), antes de câmbio, piloto automático e freio a ar. | | [`Veiculo.Portas`](/pbs-loader-docs/referencia/pbsloadercommonutils/veiculos/veiculo-portas/) | classe estática | | | [`Veiculo.Rodas`](/pbs-loader-docs/referencia/pbsloadercommonutils/veiculos/veiculo-rodas/) | classe estática | | | [`Veiculo.Suspensao`](/pbs-loader-docs/referencia/pbsloadercommonutils/veiculos/veiculo-suspensao/) | classe estática | Suspensão a ar, informada por um mod (o SuspensaoAr) via Suspensao.Informar. | # Avancado > Componentes do jogo por trás das fachadas do SDK, para quem precisa de algo que o SDK ainda não expõe. Namespace `PBSLoaderCommonUtils` · classe estática · PBSLoaderCommonUtils 2.0.0 ```csharp public static class Avancado ``` Componentes do jogo por trás das fachadas do SDK, para quem precisa de algo que o SDK ainda não expõe. Os nomes e campos são os do jogo e podem mudar a cada versão dele: prefira as fachadas (`Veiculo` etc.) e peça o que faltar no SDK. Tudo é null quando não há veículo e também no `Sdk.ModoSeguro` (versão do jogo não testada). ## Propriedades [Seção intitulada “Propriedades”](#propriedades) ### Controles [Seção intitulada “Controles”](#controles) ```csharp public static MEPControlesBus Controles { get; } ``` MEPControlesBus do veículo do jogador. ### Vpp [Seção intitulada “Vpp”](#vpp) ```csharp public static VPVehicleController Vpp { get; } ``` Controlador VPP que tem o motor (null em EVP5). ### TodosVpp [Seção intitulada “TodosVpp”](#todosvpp) ```csharp public static IReadOnlyList TodosVpp { get; } ``` Todos os controladores VPP do veículo (articulados têm mais de um). ### VppDirigido [Seção intitulada “VppDirigido”](#vppdirigido) ```csharp public static VPVehicleController VppDirigido { get; } ``` Controlador VPP com as rodas que esterçam (nos articulados, o da frente). ## Métodos [Seção intitulada “Métodos”](#métodos) ### DoJogador [Seção intitulada “DoJogador”](#dojogador) ```csharp public static bool DoJogador(VPVehicleController vpp) ``` Este controlador VPP é do veículo do jogador (o tráfego usa os mesmos componentes). ### DoJogador [Seção intitulada “DoJogador”](#dojogador-1) ```csharp public static bool DoJogador(VPWheelCollider roda) ``` Esta roda VPP é do veículo do jogador. # Confirmacao > Pergunta ao jogador se um pacote de scripts pode rodar. Namespace `PBSLoaderCommonUtils.Conteudo` · classe estática · PBSLoaderCommonUtils 2.0.0 ```csharp public static class Confirmacao ``` Pergunta ao jogador se um pacote de scripts pode rodar. Desenhada pela própria PBSLoaderCommonUtils (IMGUI), uma pergunta por vez. Enquanto aberta, o cursor fica solto e o teclado do jogo suspenso. ## Propriedades [Seção intitulada “Propriedades”](#propriedades) ### Aberta [Seção intitulada “Aberta”](#aberta) ```csharp public static bool Aberta { get; } ``` Há uma pergunta na tela. ### Atual [Seção intitulada “Atual”](#atual) ```csharp public static Pacote Atual { get; } ``` O pacote perguntado agora (para quem quiser desenhar a própria janela e responder com `Confirmacao.Responder`). ### DesenhadaPorOutroMod [Seção intitulada “DesenhadaPorOutroMod”](#desenhadaporoutromod) ```csharp public static bool DesenhadaPorOutroMod { get; set; } ``` Outro mod (a PBSLoaderCommonInterface) desenha a pergunta: a lib não desenha a dela. ## Métodos [Seção intitulada “Métodos”](#métodos) ### Responder [Seção intitulada “Responder”](#responder) ```csharp public static void Responder(Decisao d) ``` Responde a pergunta atual. # Decisao > enumeração PBSLoaderCommonUtils.Conteudo.Decisao Namespace `PBSLoaderCommonUtils.Conteudo` · enumeração · PBSLoaderCommonUtils 2.0.0 ```csharp public enum Decisao ``` ## Valores [Seção intitulada “Valores”](#valores) | Nome | Valor | Descrição | | --------------- | ----- | --------- | | `Perguntar` | 0 | | | `Permitir` | 1 | | | `Recusar` | 2 | | | `SempreRecusar` | 3 | | # EstadoDoPacote > enumeração PBSLoaderCommonUtils.Conteudo.EstadoDoPacote Namespace `PBSLoaderCommonUtils.Conteudo` · enumeração · PBSLoaderCommonUtils 2.0.0 ```csharp public enum EstadoDoPacote ``` ## Valores [Seção intitulada “Valores”](#valores) | Nome | Valor | Descrição | | --------------------- | ----- | --------- | | `AguardandoPermissao` | 0 | | | `Recusado` | 1 | | | `Ativo` | 2 | | | `Inativo` | 3 | | | `Falhou` | 4 | | # OrigemDoPacote > enumeração PBSLoaderCommonUtils.Conteudo.OrigemDoPacote Namespace `PBSLoaderCommonUtils.Conteudo` · enumeração · PBSLoaderCommonUtils 2.0.0 ```csharp public enum OrigemDoPacote ``` ## Valores [Seção intitulada “Valores”](#valores) | Nome | Valor | Descrição | | -------- | ----- | --------- | | `Onibus` | 0 | | | `Mapa` | 1 | | # Pacote > Um pacote de scripts (pasta scripts/ de um ônibus ou mapa, com pbsu.json e a DLL). Namespace `PBSLoaderCommonUtils.Conteudo` · classe · PBSLoaderCommonUtils 2.0.0 ```csharp public sealed class Pacote ``` Um pacote de scripts (pasta `scripts/` de um ônibus ou mapa, com `pbsu.json` e a DLL). ## Construtores [Seção intitulada “Construtores”](#construtores) ### Pacote [Seção intitulada “Pacote”](#pacote) ```csharp public Pacote() ``` ## Propriedades [Seção intitulada “Propriedades”](#propriedades) ### Id [Seção intitulada “Id”](#id) ```csharp public string Id { get; } ``` ### Nome [Seção intitulada “Nome”](#nome) ```csharp public string Nome { get; } ``` ### Autor [Seção intitulada “Autor”](#autor) ```csharp public string Autor { get; } ``` ### Versao [Seção intitulada “Versao”](#versao) ```csharp public string Versao { get; } ``` ### SdkMinimo [Seção intitulada “SdkMinimo”](#sdkminimo) ```csharp public string SdkMinimo { get; } ``` ### Origem [Seção intitulada “Origem”](#origem) ```csharp public OrigemDoPacote Origem { get; } ``` ### Pasta [Seção intitulada “Pasta”](#pasta) ```csharp public string Pasta { get; } ``` Pasta `scripts/` do pacote. ### Sha256 [Seção intitulada “Sha256”](#sha256) ```csharp public string Sha256 { get; } ``` SHA-256 da DLL (em hexadecimal minúsculo). A permissão do jogador vale para este hash. ### Estado [Seção intitulada “Estado”](#estado) ```csharp public EstadoDoPacote Estado { get; } ``` ### Detalhe [Seção intitulada “Detalhe”](#detalhe) ```csharp public string Detalhe { get; } ``` Motivo da falha ou da recusa. ### Ativo [Seção intitulada “Ativo”](#ativo) ```csharp public bool Ativo { get; } ``` ### QuantosScripts [Seção intitulada “QuantosScripts”](#quantosscripts) ```csharp public int QuantosScripts { get; } ``` Quantas classes de script da DLL viraram instâncias. ### Config [Seção intitulada “Config”](#config) ```csharp public MelonPreferences_Category Config { get; } ``` Preferências do pacote, em UserData/PBSLoaderCommonUtils/Conteudo/\.cfg. ### Salvos [Seção intitulada “Salvos”](#salvos) ```csharp public Gaveta Salvos { get; } ``` Dados do pacote guardados entre sessões, separados pelo ônibus (ou mapa) em que ele está (ver `Gaveta`). ### Harmony [Seção intitulada “Harmony”](#harmony) ```csharp public Harmony Harmony { get; } ``` Harmony do pacote. Tudo que for aplicado por ele é desfeito quando o pacote desativa. ### Log [Seção intitulada “Log”](#log) ```csharp public MelonLogger.Instance Log { get; } ``` Log com o nome do pacote no MelonLoader/Latest.log. ## Métodos [Seção intitulada “Métodos”](#métodos) ### Caminho [Seção intitulada “Caminho”](#caminho) ```csharp public string Caminho(string relativo) ``` Caminho de um arquivo do pacote. Não sai da pasta do pacote. ### LerTexto [Seção intitulada “LerTexto”](#lertexto) ```csharp public string LerTexto(string relativo) ``` ### Textura [Seção intitulada “Textura”](#textura) ```csharp public Texture2D Textura(string relativo) ``` Textura da pasta do pacote (ver `Carregar.Textura`). ### Som [Seção intitulada “Som”](#som) ```csharp public AudioClip Som(string relativo) ``` Som da pasta do pacote (ver `Carregar.Som`). ### Modelo [Seção intitulada “Modelo”](#modelo) ```csharp public GameObject Modelo(string relativo) ``` Modelo .3ds/.c1 da pasta do pacote (ver `Carregar.Modelo`). ### LerBytes [Seção intitulada “LerBytes”](#lerbytes) ```csharp public byte[] LerBytes(string relativo) ``` ### Existe [Seção intitulada “Existe”](#existe) ```csharp public bool Existe(string relativo) ``` ### Atalho [Seção intitulada “Atalho”](#atalho) ```csharp public Atalho Atalho(string id, string nome, string padrao, Action acao, string descricao = null) ``` Registra um atalho do pacote (aparece na tela de atalhos da PBSLoaderCommonInterface como os dos mods). A ação só roda enquanto o pacote está ativo. Ver `Atalhos.Registrar`. ### ToString [Seção intitulada “ToString”](#tostring) ```csharp public override string ToString() ``` # Pacotes > Pacotes de scripts que a PBSLoaderCommonUtils encontrou nesta sessão. Namespace `PBSLoaderCommonUtils.Conteudo` · classe estática · PBSLoaderCommonUtils 2.0.0 ```csharp public static class Pacotes ``` Pacotes de scripts que a PBSLoaderCommonUtils encontrou nesta sessão. ## Propriedades [Seção intitulada “Propriedades”](#propriedades) ### Todos [Seção intitulada “Todos”](#todos) ```csharp public static IReadOnlyList Todos { get; } ``` Todos os vistos nesta sessão (ativos ou não), na ordem em que apareceram. ## Métodos [Seção intitulada “Métodos”](#métodos) ### Permitir [Seção intitulada “Permitir”](#permitir) ```csharp public static void Permitir(Pacote p) ``` O jogador permite o pacote (grava a decisão para este hash). Se o ônibus/mapa dele estiver em jogo, ativa na hora. Se a pergunta dele estiver aberta, é o mesmo que responder “Permitir”. ### Revogar [Seção intitulada “Revogar”](#revogar) ```csharp public static void Revogar(Pacote p) ``` O jogador revoga a permissão (grava “nunca” para este hash) e o pacote desativa na hora. ### Permissao [Seção intitulada “Permissao”](#permissao) ```csharp public static Decisao Permissao(Pacote p) ``` A permissão gravada para o pacote agora. # Script > Base dos scripts que vêm junto com um ônibus ou mapa. Namespace `PBSLoaderCommonUtils.Conteudo` · classe abstrata · PBSLoaderCommonUtils 2.0.0 ```csharp public abstract class Script ``` Base dos scripts que vêm junto com um ônibus ou mapa. Não herde desta: herde de `ScriptDeOnibus` ou `ScriptDeMapa`. A PBSLoaderCommonUtils cria uma instância de cada classe concreta da DLL do pacote (precisa de construtor sem parâmetros) e chama os métodos abaixo na thread principal. Se você se inscrever em eventos do SDK em `Script.Ativar`, saia deles em `Script.Desativar`. ## Construtores [Seção intitulada “Construtores”](#construtores) ### Script [Seção intitulada “Script”](#script) ```csharp protected Script() ``` ## Propriedades [Seção intitulada “Propriedades”](#propriedades) ### Pacote [Seção intitulada “Pacote”](#pacote) ```csharp public Pacote Pacote { get; } ``` O pacote (pasta, configuração, Harmony, log) deste script. ## Métodos [Seção intitulada “Métodos”](#métodos) ### Ativar [Seção intitulada “Ativar”](#ativar) ```csharp public virtual void Ativar() ``` O ônibus/mapa do pacote entrou em jogo. Também ao voltar para ele na mesma sessão. ### Desativar [Seção intitulada “Desativar”](#desativar) ```csharp public virtual void Desativar() ``` O ônibus/mapa saiu de jogo. Os patches do `Pacote.Harmony` são desfeitos logo depois. ### Quadro [Seção intitulada “Quadro”](#quadro) ```csharp public virtual void Quadro() ``` Todo quadro, enquanto ativo. ### PassoFisico [Seção intitulada “PassoFisico”](#passofisico) ```csharp public virtual void PassoFisico() ``` Todo passo de física, enquanto ativo. ### QuadroTardio [Seção intitulada “QuadroTardio”](#quadrotardio) ```csharp public virtual void QuadroTardio() ``` Todo quadro, no LateUpdate, enquanto ativo. # ScriptDeMapa > Script de um mapa: ativo enquanto aquele mapa está carregado. Namespace `PBSLoaderCommonUtils.Conteudo` · classe abstrata · PBSLoaderCommonUtils 2.0.0 Herda de [`Script`](/pbs-loader-docs/referencia/pbsloadercommonutils/conteudo/script/). ```csharp public abstract class ScriptDeMapa : Script ``` Script de um mapa: ativo enquanto aquele mapa está carregado. ## Construtores [Seção intitulada “Construtores”](#construtores) ### ScriptDeMapa [Seção intitulada “ScriptDeMapa”](#scriptdemapa) ```csharp protected ScriptDeMapa() ``` ## Métodos [Seção intitulada “Métodos”](#métodos) ### TileCarregou [Seção intitulada “TileCarregou”](#tilecarregou) ```csharp public virtual void TileCarregou(string cena) ``` Uma cena do mapa (tile) terminou de carregar. # ScriptDeOnibus > Script de um ônibus: ativo enquanto aquele ônibus é o veículo do jogador. Namespace `PBSLoaderCommonUtils.Conteudo` · classe abstrata · PBSLoaderCommonUtils 2.0.0 Herda de [`Script`](/pbs-loader-docs/referencia/pbsloadercommonutils/conteudo/script/). ```csharp public abstract class ScriptDeOnibus : Script ``` Script de um ônibus: ativo enquanto aquele ônibus é o veículo do jogador. ## Construtores [Seção intitulada “Construtores”](#construtores) ### ScriptDeOnibus [Seção intitulada “ScriptDeOnibus”](#scriptdeonibus) ```csharp protected ScriptDeOnibus() ``` # Dados > Valores que um mod publica para os outros lerem, sem um depender da DLL do outro (ex.: o SuspensaoAr publica o nível da suspensão; a PBSLoaderCommonInterface mostra). Namespace `PBSLoaderCommonUtils` · classe estática · PBSLoaderCommonUtils 2.0.0 ```csharp public static class Dados ``` Valores que um mod publica para os outros lerem, sem um depender da DLL do outro (ex.: o SuspensaoAr publica o nível da suspensão; a PBSLoaderCommonInterface mostra). Por padrão o valor vale só para o veículo atual: some quando o veículo troca. Chaves são texto livre; use o nome do mod como `mod`. ## Métodos [Seção intitulada “Métodos”](#métodos) ### Publicar [Seção intitulada “Publicar”](#publicar) ```csharp public static void Publicar(string mod, string chave, object valor, bool porVeiculo = true) ``` Publica (ou substitui) um valor. Com `porVeiculo` false, vale até o jogo fechar. ### Apagar [Seção intitulada “Apagar”](#apagar) ```csharp public static void Apagar(string mod, string chave) ``` Apaga um valor. ### Tem [Seção intitulada “Tem”](#tem) ```csharp public static bool Tem(string mod, string chave) ``` Existe um valor válido agora. ### Ler [Seção intitulada “Ler”](#ler) ```csharp public static T Ler(string mod, string chave, T padrao = default) ``` Lê o valor, ou `padrao` se não existir, for de outro veículo ou de outro tipo. # AcaoDoJogo > Uma ação dos controles do jogo (Rewired): "Acelerar", "Seta Esquerda", "Abrir Porta 1"... Namespace `PBSLoaderCommonUtils.Entrada` · classe · PBSLoaderCommonUtils 2.0.0 ```csharp public sealed class AcaoDoJogo ``` Uma ação dos controles do jogo (Rewired): “Acelerar”, “Seta Esquerda”, “Abrir Porta 1”… ## Construtores [Seção intitulada “Construtores”](#construtores) ### AcaoDoJogo [Seção intitulada “AcaoDoJogo”](#acaodojogo) ```csharp public AcaoDoJogo() ``` ## Propriedades [Seção intitulada “Propriedades”](#propriedades) ### Id [Seção intitulada “Id”](#id) ```csharp public int Id { get; } ``` ### Nome [Seção intitulada “Nome”](#nome) ```csharp public string Nome { get; } ``` Nome interno da ação (o que se passa para `ControlesDoJogo.Botao`). ### Descricao [Seção intitulada “Descricao”](#descricao) ```csharp public string Descricao { get; } ``` Nome que o jogo mostra (pode ser igual ao interno). ### Tipo [Seção intitulada “Tipo”](#tipo) ```csharp public TipoDeAcao Tipo { get; } ``` ## Métodos [Seção intitulada “Métodos”](#métodos) ### ToString [Seção intitulada “ToString”](#tostring) ```csharp public override string ToString() ``` # Atalho > Um atalho registrado por um mod. Namespace `PBSLoaderCommonUtils.Entrada` · classe · PBSLoaderCommonUtils 2.0.0 ```csharp public sealed class Atalho ``` Um atalho registrado por um mod. A combinação vem das preferências (categoria “Atalhos”). ## Construtores [Seção intitulada “Construtores”](#construtores) ### Atalho [Seção intitulada “Atalho”](#atalho) ```csharp public Atalho() ``` ## Propriedades [Seção intitulada “Propriedades”](#propriedades) ### Mod [Seção intitulada “Mod”](#mod) ```csharp public string Mod { get; } ``` Identifier da categoria de preferências do mod (o mesmo que a PBSLoaderCommonInterface usa no menu). ### Id [Seção intitulada “Id”](#id) ```csharp public string Id { get; } ``` ### Nome [Seção intitulada “Nome”](#nome) ```csharp public string Nome { get; } ``` ### Descricao [Seção intitulada “Descricao”](#descricao) ```csharp public string Descricao { get; } ``` ### Padrao [Seção intitulada “Padrao”](#padrao) ```csharp public Combinacao Padrao { get; } ``` ### DeSegurar [Seção intitulada “DeSegurar”](#desegurar) ```csharp public bool DeSegurar { get; } ``` Atalho de segurar (a ação dura enquanto a tecla está apertada); não chama a ação ao apertar. ### SoComPainel [Seção intitulada “SoComPainel”](#socompainel) ```csharp public bool SoComPainel { get; } ``` Só vale com o painel do mod aberto, que suspende os controles de teclado do jogo (`Teclado.SuspenderJogo`): conflitos com o Rewired não contam. ### Combinacao [Seção intitulada “Combinacao”](#combinacao) ```csharp public Combinacao Combinacao { get; } ``` ### Apertou [Seção intitulada “Apertou”](#apertou) ```csharp public bool Apertou { get; } ``` Apertou neste frame, com os modificadores exatos, fora de campo de texto. ### Segurando [Seção intitulada “Segurando”](#segurando) ```csharp public bool Segurando { get; } ``` Está apertado (modificadores a mais são tolerados), fora de campo de texto. ### Conflitos [Seção intitulada “Conflitos”](#conflitos) ```csharp public IReadOnlyList Conflitos { get; } ``` Com o que este atalho colide: outros mods e teclas que o jogo usa. Vazio = livre. ### Chave [Seção intitulada “Chave”](#chave) ```csharp public string Chave { get; } ``` Identifier da entrada nas preferências (“AjusteEspelhos_Painel”). ### TemAcao [Seção intitulada “TemAcao”](#temacao) ```csharp public bool TemAcao { get; } ``` Tem ação para executar (atalhos de segurar não têm). ## Métodos [Seção intitulada “Métodos”](#métodos) ### Executar [Seção intitulada “Executar”](#executar) ```csharp public void Executar() ``` Roda a ação do atalho como se a tecla tivesse sido apertada (botões de interface, por exemplo). ### Definir [Seção intitulada “Definir”](#definir) ```csharp public void Definir(Combinacao c) ``` Muda a combinação (e grava nas preferências no próximo save). # Atalhos > Registro único de atalhos de todos os mods. Namespace `PBSLoaderCommonUtils.Entrada` · classe estática · PBSLoaderCommonUtils 2.0.0 ```csharp public static class Atalhos ``` Registro único de atalhos de todos os mods. Cada atalho fica numa entrada da categoria “Atalhos” das preferências, então o jogador troca tudo num lugar só (a PBSLoaderCommonInterface mostra essa categoria com captura de tecla e os conflitos). Atalhos não disparam enquanto o jogador digita num campo de texto, e os modificadores são exatos: “F9” não dispara com Ctrl+F9. ## Propriedades [Seção intitulada “Propriedades”](#propriedades) ### Todos [Seção intitulada “Todos”](#todos) ```csharp public static IReadOnlyList Todos { get; } ``` ### Pausado [Seção intitulada “Pausado”](#pausado) ```csharp public static bool Pausado { get; set; } ``` Desliga todos os atalhos (ex.: a PBSLoaderCommonInterface esperando o jogador apertar a tecla nova). ## Métodos [Seção intitulada “Métodos”](#métodos) ### Registrar [Seção intitulada “Registrar”](#registrar) ```csharp public static Atalho Registrar(string mod, string id, string nome, string padrao, Action acao = null, string descricao = null, bool deSegurar = false, bool soComPainel = false) ``` Registra um atalho. `mod` é o Identifier da categoria de preferências do mod; `padrao` é como “Ctrl+Alt+F9” (vazio = sem atalho até o jogador definir). `acao` roda ao apertar (para atalhos de segurar, leia `Atalho.Segurando`). `soComPainel`: o mod só lê este atalho com o painel dele aberto e suspende os controles do jogo enquanto isso (ver `Atalho.SoComPainel`). ### Achar [Seção intitulada “Achar”](#achar) ```csharp public static Atalho Achar(string mod, string id) ``` ### Verificar [Seção intitulada “Verificar”](#verificar) ```csharp public static void Verificar() ``` Recalcula os conflitos de todos os atalhos (com os outros mods e com o jogo). ## Eventos [Seção intitulada “Eventos”](#eventos) ### Mudou [Seção intitulada “Mudou”](#mudou) ```csharp public static event Action Mudou ``` Algum atalho foi registrado, mudou de tecla ou os conflitos foram recalculados. ## Constantes [Seção intitulada “Constantes”](#constantes) ### Categoria [Seção intitulada “Categoria”](#categoria) ```csharp public const string Categoria = "Atalhos" ``` # Combinacao > Uma tecla com os modificadores que precisam estar apertados junto: "Ctrl+Alt+V", "PageDown", "LeftAlt". Namespace `PBSLoaderCommonUtils.Entrada` · struct · PBSLoaderCommonUtils 2.0.0 ```csharp public struct Combinacao : IEquatable ``` Uma tecla com os modificadores que precisam estar apertados junto: “Ctrl+Alt+V”, “PageDown”, “LeftAlt”. Os modificadores valem pelo lado (Ctrl = esquerdo ou direito). AltGr conta como Ctrl+Alt, como no Windows. ## Construtores [Seção intitulada “Construtores”](#construtores) ### Combinacao [Seção intitulada “Combinacao”](#combinacao) ```csharp public Combinacao(KeyCode tecla, bool ctrl = false, bool alt = false, bool shift = false) ``` ## Propriedades [Seção intitulada “Propriedades”](#propriedades) ### Vazia [Seção intitulada “Vazia”](#vazia) ```csharp public bool Vazia { get; } ``` ### SoModificador [Seção intitulada “SoModificador”](#somodificador) ```csharp public bool SoModificador { get; } ``` ## Métodos [Seção intitulada “Métodos”](#métodos) ### EhModificador [Seção intitulada “EhModificador”](#ehmodificador) ```csharp public static bool EhModificador(KeyCode k) ``` ### ToString [Seção intitulada “ToString”](#tostring) ```csharp public override string ToString() ``` “Ctrl+Alt+V”. O texto é o mesmo que fica gravado nas preferências. ### Legivel [Seção intitulada “Legivel”](#legivel) ```csharp public string Legivel() ``` Texto para mostrar ao jogador: “Ctrl + Alt + V”, “\` (crase)”, “Page Down”. ### NomeTecla [Seção intitulada “NomeTecla”](#nometecla) ```csharp public static string NomeTecla(KeyCode k) ``` ### TentarLer [Seção intitulada “TentarLer”](#tentarler) ```csharp public static bool TentarLer(string texto, out Combinacao c) ``` Lê “Ctrl+Alt+V” (sem diferenciar maiúsculas). Vazio ou “Nenhum” = sem atalho. ### Equals [Seção intitulada “Equals”](#equals) ```csharp public bool Equals(Combinacao o) ``` ### Equals [Seção intitulada “Equals”](#equals-1) ```csharp public override bool Equals(object o) ``` ### GetHashCode [Seção intitulada “GetHashCode”](#gethashcode) ```csharp public override int GetHashCode() ``` ## Campos [Seção intitulada “Campos”](#campos) ### Tecla [Seção intitulada “Tecla”](#tecla) ```csharp public readonly KeyCode Tecla ``` ### Ctrl [Seção intitulada “Ctrl”](#ctrl) ```csharp public readonly bool Ctrl ``` ### Alt [Seção intitulada “Alt”](#alt) ```csharp public readonly bool Alt ``` ### Shift [Seção intitulada “Shift”](#shift) ```csharp public readonly bool Shift ``` ### Nenhuma [Seção intitulada “Nenhuma”](#nenhuma) ```csharp public static readonly Combinacao Nenhuma ``` # ControlesDoJogo > O que o jogador está fazendo nos controles do jogo (teclado, volante, controle), pelas ações do Rewired, já com o mapeamento que ele escolheu. Namespace `PBSLoaderCommonUtils.Entrada` · classe estática · PBSLoaderCommonUtils 2.0.0 ```csharp public static class ControlesDoJogo ``` O que o jogador está fazendo nos controles do jogo (teclado, volante, controle), pelas ações do Rewired, já com o mapeamento que ele escolheu. Serve para reagir ao comando em vez da tecla: “apertou a seta” vale no volante e no teclado. Só leitura; para escrever pedais use `Conducao`. Enquanto `Teclado.SuspenderJogo` estiver ativo, o teclado não conta. ## Propriedades [Seção intitulada “Propriedades”](#propriedades) ### Acoes [Seção intitulada “Acoes”](#acoes) ```csharp public static IReadOnlyList Acoes { get; } ``` Todas as ações que o jogo define (lidas uma vez, quando os controles do jogo existem). ### Dispositivos [Seção intitulada “Dispositivos”](#dispositivos) ```csharp public static IReadOnlyList Dispositivos { get; } ``` Controles conectados (nomes que o Rewired dá: teclado, mouse, volante, controle). ## Métodos [Seção intitulada “Métodos”](#métodos) ### Achar [Seção intitulada “Achar”](#achar) ```csharp public static AcaoDoJogo Achar(string nome) ``` A ação com este nome interno ou descritivo, ou null. ### Botao [Seção intitulada “Botao”](#botao) ```csharp public static bool Botao(string acao) ``` O botão da ação está apertado agora. ### Apertou [Seção intitulada “Apertou”](#apertou) ```csharp public static bool Apertou(string acao) ``` O botão da ação foi apertado neste quadro. ### Soltou [Seção intitulada “Soltou”](#soltou) ```csharp public static bool Soltou(string acao) ``` O botão da ação foi solto neste quadro. ### Eixo [Seção intitulada “Eixo”](#eixo) ```csharp public static float Eixo(string acao) ``` Valor do eixo da ação, -1..1 (pedais e volante). ## Eventos [Seção intitulada “Eventos”](#eventos) ### AcaoApertada [Seção intitulada “AcaoApertada”](#acaoapertada) ```csharp public static event Action AcaoApertada ``` Um botão de ação foi apertado (uma vez por aperto, em qualquer controle). Enquanto houver inscrito, a PBSLoaderCommonUtils confere todas as ações a cada quadro. # Mouse > Dono único do cursor. Namespace `PBSLoaderCommonUtils.Entrada` · classe estática · PBSLoaderCommonUtils 2.0.0 ```csharp public static class Mouse ``` Dono único do cursor. Cada mod diz, a cada frame, o que precisa: “solto” (painel aberto, precisa clicar) ou “preso” (câmera girando pelo mouse). Solto ganha de preso. Quem para de pedir sai sozinho no frame seguinte, então um painel fechado (ou um mod desligado) nunca deixa o cursor preso. Ninguém guarda e restaura o estado antigo: quando o último pedido some, o cursor volta ao estado do jogo, que nunca prende o mouse (lockState None) e só o esconde parado (MostraEscondeMouse). Guardar e restaurar era o que travava o mouse: dois painéis abertos e fechados fora de ordem devolviam um estado velho. ## Propriedades [Seção intitulada “Propriedades”](#propriedades) ### Solto [Seção intitulada “Solto”](#solto) ```csharp public static bool Solto { get; } ``` Algum mod está pedindo o cursor solto neste frame. ### Preso [Seção intitulada “Preso”](#preso) ```csharp public static bool Preso { get; } ``` Algum mod está pedindo o cursor preso neste frame (e nenhum pede solto). ### Controlando [Seção intitulada “Controlando”](#controlando) ```csharp public static bool Controlando { get; } ``` Algum mod controla o cursor agora (o jogo não esconde nem mostra sozinho). ## Métodos [Seção intitulada “Métodos”](#métodos) ### Soltar [Seção intitulada “Soltar”](#soltar) ```csharp public static void Soltar(string dono, bool precisa = true) ``` Chame a cada frame enquanto precisar do cursor livre e visível (ex.: painel aberto). ### Prender [Seção intitulada “Prender”](#prender) ```csharp public static void Prender(string dono, bool precisa = true) ``` Chame a cada frame enquanto precisar do cursor preso e escondido (ex.: câmera pelo mouse). ### Diagnostico [Seção intitulada “Diagnostico”](#diagnostico) ```csharp public static string Diagnostico() ``` # Teclado > Suspende os controles de teclado do jogo (Rewired) enquanto algum mod precisa do teclado: um painel que usa teclas (ex.: ajustar espelhos pelo teclado numérico sem ligar a seta) ou o jogador digitand… Namespace `PBSLoaderCommonUtils.Entrada` · classe estática · PBSLoaderCommonUtils 2.0.0 ```csharp public static class Teclado ``` Suspende os controles de teclado do jogo (Rewired) enquanto algum mod precisa do teclado: um painel que usa teclas (ex.: ajustar espelhos pelo teclado numérico sem ligar a seta) ou o jogador digitando num campo de texto. Mesmo contrato do `Mouse`: chame a cada frame; quem para de pedir sai sozinho. Teclas que scripts do jogo leem direto do Input não passam pelo Rewired e continuam valendo. ## Propriedades [Seção intitulada “Propriedades”](#propriedades) ### JogoSuspenso [Seção intitulada “JogoSuspenso”](#jogosuspenso) ```csharp public static bool JogoSuspenso { get; } ``` Os controles de teclado do jogo estão suspensos agora. ## Métodos [Seção intitulada “Métodos”](#métodos) ### SuspenderJogo [Seção intitulada “SuspenderJogo”](#suspenderjogo) ```csharp public static void SuspenderJogo(string dono, bool precisa = true) ``` # TeclasDoJogo > Teclas que o jogo usa, para avisar conflitos. Namespace `PBSLoaderCommonUtils.Entrada` · classe estática · PBSLoaderCommonUtils 2.0.0 ```csharp public static class TeclasDoJogo ``` Teclas que o jogo usa, para avisar conflitos. Duas fontes: - os controles do Rewired (o mapa do jogador, com o que ele remapeou), lidos ao vivo; - teclas fixas que scripts do jogo leem direto do Input (achadas desmontando o GameAssembly). Essas ignoram modificadores: Ctrl+Alt+G também solta o G do trailer. Só contam quando o script está na cena. ## Métodos [Seção intitulada “Métodos”](#métodos) ### Conflitos [Seção intitulada “Conflitos”](#conflitos) ```csharp public static List Conflitos(Combinacao c, bool rewired = true) ``` Com o que a combinação colide no jogo, em texto para o jogador. ### Reler [Seção intitulada “Reler”](#reler) ```csharp public static void Reler() ``` Relê as teclas do jogo agora (ex.: ao abrir a tela de atalhos, depois de o jogador remapear). # TipoDeAcao > enumeração PBSLoaderCommonUtils.Entrada.TipoDeAcao Namespace `PBSLoaderCommonUtils.Entrada` · enumeração · PBSLoaderCommonUtils 2.0.0 ```csharp public enum TipoDeAcao ``` ## Valores [Seção intitulada “Valores”](#valores) | Nome | Valor | Descrição | | ------- | ----- | --------- | | `Botao` | 0 | | | `Eixo` | 1 | | # Fase > Em que parte do jogo o jogador está. Namespace `PBSLoaderCommonUtils` · enumeração · PBSLoaderCommonUtils 2.0.0 ```csharp public enum Fase ``` Em que parte do jogo o jogador está. ## Valores [Seção intitulada “Valores”](#valores) | Nome | Valor | Descrição | | ------------ | ----- | --------- | | `Menu` | 0 | | | `Selecao` | 1 | | | `Carregando` | 2 | | | `Dirigindo` | 3 | | # Ganchos > Pontos do jogo onde os mods podem entrar sem escrever um patch Harmony. Namespace `PBSLoaderCommonUtils` · classe estática · PBSLoaderCommonUtils 2.0.0 ```csharp public static class Ganchos ``` Pontos do jogo onde os mods podem entrar sem escrever um patch Harmony. Cada um é um patch só, na PBSLoaderCommonUtils, e só dispara para o veículo do jogador (o tráfego usa os mesmos componentes). A ordem é a da inscrição; a PBSLoaderCommonUtils (freio a ar, portas sem ar) vem antes de todos. Os argumentos são componentes do jogo: os campos podem mudar entre versões dele. ## Eventos [Seção intitulada “Eventos”](#eventos) ### DepoisDaFisica [Seção intitulada “DepoisDaFisica”](#depoisdafisica) ```csharp public static event Action DepoisDaFisica ``` Depois de cada passo do VPP (VPVehicleController.DoUpdateBlocks) de um controlador do jogador. É aqui que se mexe em motor, câmbio e pneus: o próximo passo já usa o que foi escrito. Articulados disparam uma vez por controlador. ### AntesDosFreios [Seção intitulada “AntesDosFreios”](#antesdosfreios) ```csharp public static event Action AntesDosFreios ``` Antes de o VPP aplicar os freios do jogador (Brakes.DoUpdate, dentro de DoUpdateBlocks, depois de o pedal ser copiado do barramento). brakeInput e handbrakeInput já trazem o freio a ar, se ele estiver ligado. ### DepoisDaRodaVisual [Seção intitulada “DepoisDaRodaVisual”](#depoisdarodavisual) ```csharp public static event Action DepoisDaRodaVisual ``` Depois de o VPP posicionar a roda desenhada (suspensão, pinça e roda) de uma roda do jogador. ### PortaPedida [Seção intitulada “PortaPedida”](#portapedida) ```csharp public static event Action PortaPedida ``` Alguém (jogador, painel, mod) pediu para abrir ou fechar uma porta. “Todas as portas” pede uma a uma. ### DepoisDoSomDoMotor [Seção intitulada “DepoisDoSomDoMotor”](#depoisdosomdomotor) ```csharp public static event Action DepoisDoSomDoMotor ``` Depois de o jogo atualizar uma camada do som do motor do jogador (MepSomMotor: motor, retarder, câmbio), todo quadro. É onde se ajusta pitch e volume do AudioSource da camada (asOn). # Gaveta > Dados guardados de uma sessão para outra, em chave e valor (números, textos, listas, classes simples), num arquivo JSON por mod e por lugar. Namespace `PBSLoaderCommonUtils` · classe · PBSLoaderCommonUtils 2.0.0 ```csharp public sealed class Gaveta ``` Dados guardados de uma sessão para outra, em chave e valor (números, textos, listas, classes simples), num arquivo JSON por mod e por lugar. Gravar só marca a gaveta: o arquivo é escrito 1,5 s depois da última mudança, na troca de cena e ao fechar o jogo. Pegue a gaveta de novo quando o ônibus ou o mapa trocar (`Sdk.VeiculoTrocou`, `Sdk.MapaCarregou`): cada ônibus e cada mapa tem a sua. ## Propriedades [Seção intitulada “Propriedades”](#propriedades) ### Lugar [Seção intitulada “Lugar”](#lugar) ```csharp public string Lugar { get; } ``` “global”, “onibus/\” ou “mapa/\”. ### Mod [Seção intitulada “Mod”](#mod) ```csharp public string Mod { get; } ``` ### Persistente [Seção intitulada “Persistente”](#persistente) ```csharp public bool Persistente { get; } ``` false quando não há ônibus/mapa: a gaveta funciona, mas não grava nada. ### Chaves [Seção intitulada “Chaves”](#chaves) ```csharp public IEnumerable Chaves { get; } ``` ## Métodos [Seção intitulada “Métodos”](#métodos) ### Tem [Seção intitulada “Tem”](#tem) ```csharp public bool Tem(string chave) ``` ### Ler [Seção intitulada “Ler”](#ler) ```csharp public T Ler(string chave, T padrao = default) ``` Lê o valor, ou `padrao` se não existir ou não for convertível para `T`. ### Gravar [Seção intitulada “Gravar”](#gravar) ```csharp public void Gravar(string chave, T valor) ``` Grava (ou troca) o valor. O arquivo é escrito logo depois. ### Apagar [Seção intitulada “Apagar”](#apagar) ```csharp public void Apagar(string chave) ``` ### Limpar [Seção intitulada “Limpar”](#limpar) ```csharp public void Limpar() ``` # Alerta > Um aviso do veículo. Namespace `PBSLoaderCommonUtils.Interface` · classe · PBSLoaderCommonUtils 2.0.0 ```csharp public sealed class Alerta ``` Um aviso do veículo. Os textos podem mudar enquanto ele está ativo (`Alerta.Versao` sobe). ## Construtores [Seção intitulada “Construtores”](#construtores) ### Alerta [Seção intitulada “Alerta”](#alerta) ```csharp public Alerta() ``` ## Propriedades [Seção intitulada “Propriedades”](#propriedades) ### Origem [Seção intitulada “Origem”](#origem) ```csharp public string Origem { get; } ``` ### Id [Seção intitulada “Id”](#id) ```csharp public string Id { get; } ``` ### Chave [Seção intitulada “Chave”](#chave) ```csharp public string Chave { get; } ``` ### Gravidade [Seção intitulada “Gravidade”](#gravidade) ```csharp public Gravidade Gravidade { get; } ``` ### Titulo [Seção intitulada “Titulo”](#titulo) ```csharp public string Titulo { get; } ``` ### Detalhe [Seção intitulada “Detalhe”](#detalhe) ```csharp public string Detalhe { get; } ``` ### Desde [Seção intitulada “Desde”](#desde) ```csharp public float Desde { get; } ``` Quando apareceu (Time.unscaledTime). ### Condicao [Seção intitulada “Condicao”](#condicao) ```csharp public bool Condicao { get; } ``` Condição (fica até a origem dizer que acabou) ou notificação (expira sozinha). ### Versao [Seção intitulada “Versao”](#versao) ```csharp public int Versao { get; } ``` Muda a cada troca de texto ou gravidade (para a interface redesenhar só quando precisa). # Avisos > Avisos e falhas do veículo, de qualquer mod. Namespace `PBSLoaderCommonUtils.Interface` · classe estática · PBSLoaderCommonUtils 2.0.0 ```csharp public static class Avisos ``` Avisos e falhas do veículo, de qualquer mod. Quem mostra (a PBSLoaderCommonInterface, por exemplo) lê `Avisos.Ativos`. Condição Avisos.Definir(“MeuMod”, “oleo”, pressaoBaixa, Gravidade.Falha, “Pressão do óleo baixa”, “0,8 bar”); chame quando o estado mudar ou a cada frame; com “ativo” false ela sai. Notificação Avisos.Notificar(“MeuMod”, “salvo”, Gravidade.Info, “Ajustes salvos”); some depois de alguns segundos. Os avisos são do veículo atual: trocar de veículo limpa tudo. ## Propriedades [Seção intitulada “Propriedades”](#propriedades) ### Ativos [Seção intitulada “Ativos”](#ativos) ```csharp public static IReadOnlyList Ativos { get; } ``` Avisos ativos, do mais antigo ao mais novo. ## Métodos [Seção intitulada “Métodos”](#métodos) ### Definir [Seção intitulada “Definir”](#definir) ```csharp public static void Definir(string origem, string id, bool ativo, Gravidade gravidade, string titulo, string detalhe = null) ``` Liga, atualiza ou desliga uma condição. ### Notificar [Seção intitulada “Notificar”](#notificar) ```csharp public static void Notificar(string origem, string id, Gravidade gravidade, string titulo, string detalhe = null, float segundos = 5f) ``` Aviso pontual que some depois de `segundos`. Repetir o mesmo id renova. ### Limpar [Seção intitulada “Limpar”](#limpar) ```csharp public static void Limpar(string origem) ``` Tira todos os avisos de uma origem (ex.: o mod foi desligado). ## Eventos [Seção intitulada “Eventos”](#eventos) ### Mudou [Seção intitulada “Mudou”](#mudou) ```csharp public static event Action Mudou ``` Algum aviso entrou, saiu ou mudou de texto. # Gravidade > enumeração PBSLoaderCommonUtils.Interface.Gravidade Namespace `PBSLoaderCommonUtils.Interface` · enumeração · PBSLoaderCommonUtils 2.0.0 ```csharp public enum Gravidade ``` ## Valores [Seção intitulada “Valores”](#valores) | Nome | Valor | Descrição | | ------- | ----- | --------- | | `Info` | 0 | | | `Aviso` | 1 | | | `Falha` | 2 | | # Letreiro > Letreiro (itinerário) do ônibus do jogador (TrocaItinerario). Namespace `PBSLoaderCommonUtils.Linhas` · classe estática · PBSLoaderCommonUtils 2.0.0 ```csharp public static class Letreiro ``` Letreiro (itinerário) do ônibus do jogador (TrocaItinerario). ## Propriedades [Seção intitulada “Propriedades”](#propriedades) ### Indice [Seção intitulada “Indice”](#indice) ```csharp public static int Indice { get; } ``` Número do letreiro escolhido (o que o jogador digita no teclado do itinerário), ou -1 sem letreiro. ### Ligado [Seção intitulada “Ligado”](#ligado) ```csharp public static bool Ligado { get; } ``` O letreiro do ônibus está aceso. ### Jogo [Seção intitulada “Jogo”](#jogo) ```csharp public static TrocaItinerario Jogo { get; } ``` Componente do jogo (null sem letreiro). ## Métodos [Seção intitulada “Métodos”](#métodos) ### Definir [Seção intitulada “Definir”](#definir) ```csharp public static bool Definir(int numero) ``` Escolhe o letreiro `numero`, como se o jogador digitasse no teclado do itinerário do jogo e confirmasse. Retorna false se o ônibus não tem esse teclado. # Linha > A linha que o ônibus do jogador faz. Namespace `PBSLoaderCommonUtils.Linhas` · classe estática · PBSLoaderCommonUtils 2.0.0 ```csharp public static class Linha ``` A linha que o ônibus do jogador faz. ## Propriedades [Seção intitulada “Propriedades”](#propriedades) ### Nome [Seção intitulada “Nome”](#nome) ```csharp public static string Nome { get; } ``` A linha escolhida na tela de linhas (“100 CIRCULAR CENTRO”). Sem essa tela (save carregado, partida rápida) fica o ponto de partida do mapa. ### Disponiveis [Seção intitulada “Disponiveis”](#disponiveis) ```csharp public static IReadOnlyList Disponiveis { get; } ``` Linhas que o mapa atual oferece (lista do jogo; vazia fora da tela de escolha em alguns mapas). ### ParadaAtual [Seção intitulada “ParadaAtual”](#paradaatual) ```csharp public static Parada ParadaAtual { get; } ``` O ponto em que o ônibus do jogador está agora (o jogo detecta pelo gatilho do ponto), ou null. ### NoPonto [Seção intitulada “NoPonto”](#noponto) ```csharp public static bool NoPonto { get; } ``` ### ProximaParada [Seção intitulada “ProximaParada”](#proximaparada) ```csharp public static Parada ProximaParada { get; } ``` O próximo ponto à frente do ônibus (até 2 km, num cone de ±45° na direção de marcha), pelos pontos carregados. É uma estimativa: o jogo não guarda o itinerário em ordem. # Passageiro > Um passageiro do ônibus do jogador. Namespace `PBSLoaderCommonUtils.Linhas` · classe · PBSLoaderCommonUtils 2.0.0 ```csharp public sealed class Passageiro ``` Um passageiro do ônibus do jogador. ## Construtores [Seção intitulada “Construtores”](#construtores) ### Passageiro [Seção intitulada “Passageiro”](#passageiro) ```csharp public Passageiro() ``` ## Propriedades [Seção intitulada “Propriedades”](#propriedades) ### Origem [Seção intitulada “Origem”](#origem) ```csharp public Parada Origem { get; } ``` Ponto em que entrou (null se o tile dele já descarregou). ### Sentado [Seção intitulada “Sentado”](#sentado) ```csharp public bool Sentado { get; } ``` ### VaiDescer [Seção intitulada “VaiDescer”](#vaidescer) ```csharp public bool VaiDescer { get; } ``` Já decidiu descer no próximo ponto. ### PassouNaCatraca [Seção intitulada “PassouNaCatraca”](#passounacatraca) ```csharp public bool PassouNaCatraca { get; } ``` ### Jogo [Seção intitulada “Jogo”](#jogo) ```csharp public Passageiros Jogo { get; } ``` Componente do jogo. # Passageiros > Passageiros do ônibus do jogador. Namespace `PBSLoaderCommonUtils.Linhas` · classe estática · PBSLoaderCommonUtils 2.0.0 ```csharp public static class Passageiros ``` Passageiros do ônibus do jogador. As contagens vêm do jogo; os eventos vêm de uma varredura dos passageiros do jogo duas vezes por segundo (então chegam com até meio segundo de atraso). ## Propriedades [Seção intitulada “Propriedades”](#propriedades) ### ABordo [Seção intitulada “ABordo”](#abordo) ```csharp public static int ABordo { get; } ``` ### EmbarcaramSessao [Seção intitulada “EmbarcaramSessao”](#embarcaramsessao) ```csharp public static int EmbarcaramSessao { get; } ``` Passaram na catraca nesta sessão. ### DesceramSessao [Seção intitulada “DesceramSessao”](#desceramsessao) ```csharp public static int DesceramSessao { get; } ``` Desceram nesta partida (contados pelo SDK). ### SinalSolicitado [Seção intitulada “SinalSolicitado”](#sinalsolicitado) ```csharp public static bool SinalSolicitado { get; } ``` ### PodeEmbarcar [Seção intitulada “PodeEmbarcar”](#podeembarcar) ```csharp public static bool PodeEmbarcar { get; } ``` O jogo deixa passageiros embarcarem neste ônibus. ### Dentro [Seção intitulada “Dentro”](#dentro) ```csharp public static IReadOnlyList Dentro { get; } ``` Os que estão dentro agora (pela varredura). ## Eventos [Seção intitulada “Eventos”](#eventos) ### Embarcou [Seção intitulada “Embarcou”](#embarcou) ```csharp public static event Action Embarcou ``` ### Desceu [Seção intitulada “Desceu”](#desceu) ```csharp public static event Action Desceu ``` # Mapa > O mapa da partida. Namespace `PBSLoaderCommonUtils.Mapas` · classe estática · PBSLoaderCommonUtils 2.0.0 ```csharp public static class Mapa ``` O mapa da partida. `Mapa.Existe` fica true quando o jogador está dirigindo. Mapas grandes carregam em tiles conforme o ônibus anda: `Mapa.Paradas` lista só os pontos dos tiles carregados agora. ## Propriedades [Seção intitulada “Propriedades”](#propriedades) ### Existe [Seção intitulada “Existe”](#existe) ```csharp public static bool Existe { get; } ``` ### Nome [Seção intitulada “Nome”](#nome) ```csharp public static string Nome { get; } ``` ### Origem [Seção intitulada “Origem”](#origem) ```csharp public static OrigemDoMapa Origem { get; } ``` ### Pasta [Seção intitulada “Pasta”](#pasta) ```csharp public static string Pasta { get; } ``` Pasta do mod de mapa (vazia nos mapas do jogo). ### Versao [Seção intitulada “Versao”](#versao) ```csharp public static float Versao { get; } ``` Versão declarada pelo mod de mapa (0 nos do jogo). ### PontoDePartida [Seção intitulada “PontoDePartida”](#pontodepartida) ```csharp public static string PontoDePartida { get; } ``` ### Geracao [Seção intitulada “Geracao”](#geracao) ```csharp public static int Geracao { get; } ``` Muda a cada mapa carregado. Ver também `Sdk.MapaCarregou`. ### CarregandoTiles [Seção intitulada “CarregandoTiles”](#carregandotiles) ```csharp public static bool CarregandoTiles { get; } ``` O jogo está carregando tiles agora. ### Paradas [Seção intitulada “Paradas”](#paradas) ```csharp public static IReadOnlyList Paradas { get; } ``` Pontos de ônibus carregados agora (reescaneados a cada 3 s). ## Métodos [Seção intitulada “Métodos”](#métodos) ### Disponiveis [Seção intitulada “Disponiveis”](#disponiveis) ```csharp public static IReadOnlyList Disponiveis() ``` Nomes das pastas de mods de mapa instalados. ### MaisPerto [Seção intitulada “MaisPerto”](#maisperto) ```csharp public static Parada MaisPerto(Vector3 mundo, float maxM = 3.4028235E+38f) ``` Ponto mais perto de `mundo` (null se nenhum estiver carregado). # OrigemDoMapa > enumeração PBSLoaderCommonUtils.Mapas.OrigemDoMapa Namespace `PBSLoaderCommonUtils.Mapas` · enumeração · PBSLoaderCommonUtils 2.0.0 ```csharp public enum OrigemDoMapa ``` ## Valores [Seção intitulada “Valores”](#valores) | Nome | Valor | Descrição | | ------ | ----- | --------- | | `Jogo` | 0 | | | `Mod` | 1 | | # Parada > Um ponto de ônibus do mapa (MEPBusStop). Namespace `PBSLoaderCommonUtils.Mapas` · classe · PBSLoaderCommonUtils 2.0.0 ```csharp public sealed class Parada ``` Um ponto de ônibus do mapa (MEPBusStop). O mesmo objeto segue o mesmo ponto enquanto o tile dele estiver carregado. ## Construtores [Seção intitulada “Construtores”](#construtores) ### Parada [Seção intitulada “Parada”](#parada) ```csharp public Parada() ``` ## Propriedades [Seção intitulada “Propriedades”](#propriedades) ### Nome [Seção intitulada “Nome”](#nome) ```csharp public string Nome { get; } ``` ### Destino [Seção intitulada “Destino”](#destino) ```csharp public string Destino { get; } ``` Destino anunciado no ponto (pode ser vazio). ### Lado [Seção intitulada “Lado”](#lado) ```csharp public Lado Lado { get; } ``` Lado da rua em que o ponto fica (o ônibus abre as portas desse lado). ### Inicial [Seção intitulada “Inicial”](#inicial) ```csharp public bool Inicial { get; } ``` ### Final [Seção intitulada “Final”](#final) ```csharp public bool Final { get; } ``` ### Posicao [Seção intitulada “Posicao”](#posicao) ```csharp public Vector3 Posicao { get; } ``` ### Esperando [Seção intitulada “Esperando”](#esperando) ```csharp public int Esperando { get; } ``` Pessoas esperando para entrar. ### Descendo [Seção intitulada “Descendo”](#descendo) ```csharp public int Descendo { get; } ``` Passageiros que vão descer aqui. ### TemOnibus [Seção intitulada “TemOnibus”](#temonibus) ```csharp public bool TemOnibus { get; } ``` Algum ônibus (o do jogador ou do tráfego) está parado no ponto. ### PodemEntrar [Seção intitulada “PodemEntrar”](#podementrar) ```csharp public bool PodemEntrar { get; } ``` O ponto liberou o embarque no ônibus que está nele (o jogo confere o letreiro). ### Jogo [Seção intitulada “Jogo”](#jogo) ```csharp public MEPBusStop Jogo { get; } ``` Componente do jogo, para quem precisar de mais. ## Métodos [Seção intitulada “Métodos”](#métodos) ### ToString [Seção intitulada “ToString”](#tostring) ```csharp public override string ToString() ``` # Carregar > Carrega texturas, sons e modelos de arquivos, pelos mesmos carregadores que o jogo usa nos mods de ônibus e mapa (então formatos, cache e o CarregamentoRapido valem igual). Namespace `PBSLoaderCommonUtils.Midia` · classe estática · PBSLoaderCommonUtils 2.0.0 ```csharp public static class Carregar ``` Carrega texturas, sons e modelos de arquivos, pelos mesmos carregadores que o jogo usa nos mods de ônibus e mapa (então formatos, cache e o CarregamentoRapido valem igual). O que é carregado aqui não é descartado quando o jogo troca de ônibus (ele chama UnloadUnusedAssets): destrua você mesmo o que não precisar mais. Só na thread principal. Erros viram null e uma linha no log. ## Métodos [Seção intitulada “Métodos”](#métodos) ### Textura [Seção intitulada “Textura”](#textura) ```csharp public static Texture2D Textura(string caminho, bool cache = true) ``` PNG ou JPG (MepUtils.CarregaTextura). `cache` usa a cache de texturas do jogo. ### Som [Seção intitulada “Som”](#som) ```csharp public static AudioClip Som(string caminho) ``` Som (MepUtils.CarregaSom: os formatos que os mods de ônibus usam, como WAV e OGG). ### Modelo [Seção intitulada “Modelo”](#modelo) ```csharp public static GameObject Modelo(string caminho) ``` Modelo .3ds (ou .c1, o formato protegido dos mods, aberto pelo próprio jogo), com materiais e texturas da mesma pasta, como o jogo carrega as peças de um ônibus. Volta um objeto novo na cena, na origem: posicione e pendure onde quiser. # Som3D > Um som tocando no mundo (criado por Sons.Tocar). Namespace `PBSLoaderCommonUtils.Midia` · classe · PBSLoaderCommonUtils 2.0.0 ```csharp public sealed class Som3D ``` Um som tocando no mundo (criado por `Sons.Tocar`). ## Construtores [Seção intitulada “Construtores”](#construtores) ### Som3D [Seção intitulada “Som3D”](#som3d) ```csharp public Som3D() ``` ## Propriedades [Seção intitulada “Propriedades”](#propriedades) ### Fonte [Seção intitulada “Fonte”](#fonte) ```csharp public AudioSource Fonte { get; } ``` ### Volume [Seção intitulada “Volume”](#volume) ```csharp public float Volume { get; set; } ``` Volume pedido, 0..1 (antes do abafamento dentro do ônibus). ### Pitch [Seção intitulada “Pitch”](#pitch) ```csharp public float Pitch { get; set; } ``` ### AbafarDentro [Seção intitulada “AbafarDentro”](#abafardentro) ```csharp public bool AbafarDentro { get; set; } ``` Fica mais baixo quando a câmera está dentro do ônibus (som de fora, como o motor). ### Tocando [Seção intitulada “Tocando”](#tocando) ```csharp public bool Tocando { get; } ``` ## Métodos [Seção intitulada “Métodos”](#métodos) ### Parar [Seção intitulada “Parar”](#parar) ```csharp public void Parar() ``` Para e destrói o som. # Sons > Sons 3D presos a um objeto (uma peça do ônibus, um ponto do mapa), no volume geral do jogo. Namespace `PBSLoaderCommonUtils.Midia` · classe estática · PBSLoaderCommonUtils 2.0.0 ```csharp public static class Sons ``` Sons 3D presos a um objeto (uma peça do ônibus, um ponto do mapa), no volume geral do jogo. ## Métodos [Seção intitulada “Métodos”](#métodos) ### Tocar [Seção intitulada “Tocar”](#tocar) ```csharp public static Som3D Tocar(AudioClip clip, Transform pai, Vector3 posicao = default, float volume = 1f, bool loop = false, float distanciaMinM = 2f, float distanciaMaxM = 80f) ``` Toca `clip` num objeto novo, filho de `pai` na posição local dada. Sem `loop`, o som se destrói sozinho quando termina. Com `pai` null, fica parado no mundo em `posicao`. ### TocarArquivo [Seção intitulada “TocarArquivo”](#tocararquivo) ```csharp public static Som3D TocarArquivo(string caminho, Transform pai, Vector3 posicao = default, float volume = 1f) ``` Toca um arquivo de som de uma vez (carrega, toca e esquece). # Chuva > enumeração PBSLoaderCommonUtils.Mundo.Chuva Namespace `PBSLoaderCommonUtils.Mundo` · enumeração · PBSLoaderCommonUtils 2.0.0 ```csharp public enum Chuva ``` ## Valores [Seção intitulada “Valores”](#valores) | Nome | Valor | Descrição | | --------- | ----- | --------- | | `Nenhuma` | 0 | | | `Leve` | 1 | | | `Media` | 2 | | | `Pesada` | 3 | | # Clima > Clima do jogo: chuva (MepMobileControls/MepChuva) e o preset do EnviroSky. Namespace `PBSLoaderCommonUtils.Mundo` · classe estática · PBSLoaderCommonUtils 2.0.0 ```csharp public static class Clima ``` Clima do jogo: chuva (MepMobileControls/MepChuva) e o preset do EnviroSky. ## Propriedades [Seção intitulada “Propriedades”](#propriedades) ### Chovendo [Seção intitulada “Chovendo”](#chovendo) ```csharp public static bool Chovendo { get; } ``` ### Chuva [Seção intitulada “Chuva”](#chuva) ```csharp public static Chuva Chuva { get; } ``` ### Molhado [Seção intitulada “Molhado”](#molhado) ```csharp public static float Molhado { get; } ``` Quanto o mundo está molhado, 0..1 (o EnviroSky sobe e desce aos poucos). ### Nome [Seção intitulada “Nome”](#nome) ```csharp public static string Nome { get; } ``` Nome do preset de clima do EnviroSky (“Clear Sky”, “Rain”…). ### Presets [Seção intitulada “Presets”](#presets) ```csharp public static IReadOnlyList Presets { get; } ``` Nomes dos climas do céu do jogo (presets do EnviroSky: “Clear Sky”, “Cloudy 1”, “Rain”…). ## Métodos [Seção intitulada “Métodos”](#métodos) ### Definir [Seção intitulada “Definir”](#definir) ```csharp public static bool Definir(string nome) ``` Muda o céu para o clima `nome` (um de `Clima.Presets`), com transição. ### Chover [Seção intitulada “Chover”](#chover) ```csharp public static bool Chover(Chuva intensidade) ``` Faz chover (ou para): a chuva do jogo segue o clima do céu, então isto troca o clima para um com chuva da intensidade pedida (“Light Rain”, “Heavy Rain”, “Storm”) ou para céu limpo. A troca tem transição de alguns segundos; `Clima.Chovendo` acompanha. ## Eventos [Seção intitulada “Eventos”](#eventos) ### Mudou [Seção intitulada “Mudou”](#mudou) ```csharp public static event Action Mudou ``` Começou ou parou de chover, ou o preset mudou. # CorDoSemaforo > enumeração PBSLoaderCommonUtils.Mundo.CorDoSemaforo Namespace `PBSLoaderCommonUtils.Mundo` · enumeração · PBSLoaderCommonUtils 2.0.0 ```csharp public enum CorDoSemaforo ``` ## Valores [Seção intitulada “Valores”](#valores) | Nome | Valor | Descrição | | -------------- | ----- | --------- | | `Desconhecida` | 0 | | | `Verde` | 1 | | | `Amarelo` | 2 | | | `Vermelho` | 3 | | | `Desligado` | 4 | | # LuzDeSemaforo > Um foco aceso de um semáforo. Namespace `PBSLoaderCommonUtils.Mundo` · classe · PBSLoaderCommonUtils 2.0.0 ```csharp public sealed class LuzDeSemaforo ``` Um foco aceso de um semáforo. ## Construtores [Seção intitulada “Construtores”](#construtores) ### LuzDeSemaforo [Seção intitulada “LuzDeSemaforo”](#luzdesemaforo) ```csharp public LuzDeSemaforo() ``` ## Propriedades [Seção intitulada “Propriedades”](#propriedades) ### Objeto [Seção intitulada “Objeto”](#objeto) ```csharp public Transform Objeto { get; } ``` ### Posicao [Seção intitulada “Posicao”](#posicao) ```csharp public Vector3 Posicao { get; } ``` ### Cor [Seção intitulada “Cor”](#cor) ```csharp public CorDoSemaforo Cor { get; } ``` ## Métodos [Seção intitulada “Métodos”](#métodos) ### ToString [Seção intitulada “ToString”](#tostring) ```csharp public override string ToString() ``` # Semaforo > Um semáforo do mapa (MEPAI_TrafficLights e variantes). Namespace `PBSLoaderCommonUtils.Mundo` · classe · PBSLoaderCommonUtils 2.0.0 ```csharp public sealed class Semaforo ``` Um semáforo do mapa (MEPAI_TrafficLights e variantes). ## Construtores [Seção intitulada “Construtores”](#construtores) ### Semaforo [Seção intitulada “Semaforo”](#semaforo) ```csharp public Semaforo() ``` ## Propriedades [Seção intitulada “Propriedades”](#propriedades) ### Tipo [Seção intitulada “Tipo”](#tipo) ```csharp public string Tipo { get; } ``` Componente do jogo (“MEPAI_TrafficLights”, “MEPAI_TrafficLights2”, “MEPAI_TrafficLightsV3_4fases”). ### Raiz [Seção intitulada “Raiz”](#raiz) ```csharp public Transform Raiz { get; } ``` ### Posicao [Seção intitulada “Posicao”](#posicao) ```csharp public Vector3 Posicao { get; } ``` ### Fase [Seção intitulada “Fase”](#fase) ```csharp public int Fase { get; } ``` Fase atual (0..Fases-1), ou -1 se não deu para ler. ### Fases [Seção intitulada “Fases”](#fases) ```csharp public int Fases { get; } ``` ### LuzesAcesas [Seção intitulada “LuzesAcesas”](#luzesacesas) ```csharp public IReadOnlyList LuzesAcesas { get; } ``` Focos acesos no passo atual (um semáforo comanda o cruzamento inteiro, com vários focos), cada um com a cor deduzida do nome do objeto ou do tom do material. ## Métodos [Seção intitulada “Métodos”](#métodos) ### CorPara [Seção intitulada “CorPara”](#corpara) ```csharp public CorDoSemaforo CorPara(Vector3 ponto, float maxM = 40f) ``` Cor do foco aceso mais perto de `ponto` (ex.: à frente do ônibus), até `maxM`. ### ToString [Seção intitulada “ToString”](#tostring) ```csharp public override string ToString() ``` # Tempo > Hora do jogo (EnviroSky). Namespace `PBSLoaderCommonUtils.Mundo` · classe estática · PBSLoaderCommonUtils 2.0.0 ```csharp public static class Tempo ``` Hora do jogo (EnviroSky). Sem céu carregado (menus), `Tempo.Existe` é false. ## Propriedades [Seção intitulada “Propriedades”](#propriedades) ### Existe [Seção intitulada “Existe”](#existe) ```csharp public static bool Existe { get; } ``` ### Hora [Seção intitulada “Hora”](#hora) ```csharp public static int Hora { get; } ``` ### Minuto [Seção intitulada “Minuto”](#minuto) ```csharp public static int Minuto { get; } ``` ### Segundo [Seção intitulada “Segundo”](#segundo) ```csharp public static int Segundo { get; } ``` ### Dia [Seção intitulada “Dia”](#dia) ```csharp public static int Dia { get; } ``` ### HoraDecimal [Seção intitulada “HoraDecimal”](#horadecimal) ```csharp public static float HoraDecimal { get; } ``` Hora com fração (13.5 = 13:30). ### Noite [Seção intitulada “Noite”](#noite) ```csharp public static bool Noite { get; } ``` ### DuracaoDoDiaMin [Seção intitulada “DuracaoDoDiaMin”](#duracaododiamin) ```csharp public static float DuracaoDoDiaMin { get; } ``` Quantos minutos reais dura o dia do jogo. ### Parado [Seção intitulada “Parado”](#parado) ```csharp public static bool Parado { get; } ``` O relógio do jogo está parado (o jogador ou um mod travou a hora). ### Texto [Seção intitulada “Texto”](#texto) ```csharp public static string Texto { get; } ``` ## Métodos [Seção intitulada “Métodos”](#métodos) ### Definir [Seção intitulada “Definir”](#definir) ```csharp public static bool Definir(int hora, int minuto = 0) ``` Muda a hora do jogo (mantém o dia e o ano). ### Pausar [Seção intitulada “Pausar”](#pausar) ```csharp public static bool Pausar(bool parado) ``` Para ou solta o relógio do jogo (parado, a hora não anda). ### DefinirDuracaoDoDia [Seção intitulada “DefinirDuracaoDoDia”](#definirduracaododia) ```csharp public static bool DefinirDuracaoDoDia(float minutos) ``` Quantos minutos reais dura um dia do jogo (o jogo usa o mesmo valor para a noite). ## Eventos [Seção intitulada “Eventos”](#eventos) ### HoraPassou [Seção intitulada “HoraPassou”](#horapassou) ```csharp public static event Action HoraPassou ``` A hora cheia mudou (o argumento é a nova hora). # TipoNoTrafego > enumeração PBSLoaderCommonUtils.Mundo.TipoNoTrafego Namespace `PBSLoaderCommonUtils.Mundo` · enumeração · PBSLoaderCommonUtils 2.0.0 ```csharp public enum TipoNoTrafego ``` ## Valores [Seção intitulada “Valores”](#valores) | Nome | Valor | Descrição | | -------- | ----- | --------- | | `Carro` | 0 | | | `Onibus` | 1 | | # Trafego > Tráfego de IA (MEPAI_Traffic_System_Controller): quantos existem agora e o limite. Namespace `PBSLoaderCommonUtils.Mundo` · classe estática · PBSLoaderCommonUtils 2.0.0 ```csharp public static class Trafego ``` Tráfego de IA (MEPAI_Traffic_System_Controller): quantos existem agora e o limite. ## Propriedades [Seção intitulada “Propriedades”](#propriedades) ### Carros [Seção intitulada “Carros”](#carros) ```csharp public static int Carros { get; } ``` ### Pedestres [Seção intitulada “Pedestres”](#pedestres) ```csharp public static int Pedestres { get; } ``` ### Onibus [Seção intitulada “Onibus”](#onibus) ```csharp public static int Onibus { get; } ``` ### Trens [Seção intitulada “Trens”](#trens) ```csharp public static int Trens { get; } ``` ### MaxCarros [Seção intitulada “MaxCarros”](#maxcarros) ```csharp public static int MaxCarros { get; } ``` ### MaxPedestres [Seção intitulada “MaxPedestres”](#maxpedestres) ```csharp public static int MaxPedestres { get; } ``` ### MaxOnibus [Seção intitulada “MaxOnibus”](#maxonibus) ```csharp public static int MaxOnibus { get; } ``` ### ColisoesAtivas [Seção intitulada “ColisoesAtivas”](#colisoesativas) ```csharp public static bool ColisoesAtivas { get; } ``` ### Veiculos [Seção intitulada “Veiculos”](#veiculos) ```csharp public static IReadOnlyList Veiculos { get; } ``` Veículos do trânsito ativos agora (carros e ônibus da IA), reescaneados 1 vez por segundo enquanto alguém usar esta lista (a busca custa: não é feita sem ninguém pedindo). ### PedestresAtivos [Seção intitulada “PedestresAtivos”](#pedestresativos) ```csharp public static IReadOnlyList PedestresAtivos { get; } ``` Pedestres e ciclistas da IA ativos agora (mesma regra de `Trafego.Veiculos`). ### Semaforos [Seção intitulada “Semaforos”](#semaforos) ```csharp public static IReadOnlyList Semaforos { get; } ``` Semáforos carregados agora (mesma regra de `Trafego.Veiculos`). ## Métodos [Seção intitulada “Métodos”](#métodos) ### MaisPertoAFrente [Seção intitulada “MaisPertoAFrente”](#maispertoafrente) ```csharp public static VeiculoDoTrafego MaisPertoAFrente(float maxM = 100f) ``` O veículo do trânsito mais perto do ônibus do jogador, à frente dele (cone de ±30°), até `maxM`. # VeiculoDoTrafego > Um veículo do trânsito (IA). Namespace `PBSLoaderCommonUtils.Mundo` · classe · PBSLoaderCommonUtils 2.0.0 ```csharp public sealed class VeiculoDoTrafego ``` Um veículo do trânsito (IA). O mesmo objeto segue o mesmo veículo enquanto ele existir. ## Construtores [Seção intitulada “Construtores”](#construtores) ### VeiculoDoTrafego [Seção intitulada “VeiculoDoTrafego”](#veiculodotrafego) ```csharp public VeiculoDoTrafego() ``` ## Propriedades [Seção intitulada “Propriedades”](#propriedades) ### Tipo [Seção intitulada “Tipo”](#tipo) ```csharp public TipoNoTrafego Tipo { get; } ``` ### Raiz [Seção intitulada “Raiz”](#raiz) ```csharp public Transform Raiz { get; } ``` ### Posicao [Seção intitulada “Posicao”](#posicao) ```csharp public Vector3 Posicao { get; } ``` ### Frente [Seção intitulada “Frente”](#frente) ```csharp public Vector3 Frente { get; } ``` ### VelocidadeKmh [Seção intitulada “VelocidadeKmh”](#velocidadekmh) ```csharp public float VelocidadeKmh { get; } ``` ### DistanciaM [Seção intitulada “DistanciaM”](#distanciam) ```csharp public float DistanciaM { get; } ``` Distância até o ônibus do jogador, em metros (infinito sem ônibus). ## Métodos [Seção intitulada “Métodos”](#métodos) ### ToString [Seção intitulada “ToString”](#tostring) ```csharp public override string ToString() ``` # Caminhos > Pastas do jogo (ProtonPaths). Namespace `PBSLoaderCommonUtils.Partida` · classe estática · PBSLoaderCommonUtils 2.0.0 ```csharp public static class Caminhos ``` Pastas do jogo (ProtonPaths). Vazias até o jogo defini-las no menu inicial. ## Propriedades [Seção intitulada “Propriedades”](#propriedades) ### Mods [Seção intitulada “Mods”](#mods) ```csharp public static string Mods { get; } ``` ### ModsDeOnibus [Seção intitulada “ModsDeOnibus”](#modsdeonibus) ```csharp public static string ModsDeOnibus { get; } ``` ### ModsDeMapas [Seção intitulada “ModsDeMapas”](#modsdemapas) ```csharp public static string ModsDeMapas { get; } ``` ### ModsDeLetreiros [Seção intitulada “ModsDeLetreiros”](#modsdeletreiros) ```csharp public static string ModsDeLetreiros { get; } ``` ### ModsDeCargas [Seção intitulada “ModsDeCargas”](#modsdecargas) ```csharp public static string ModsDeCargas { get; } ``` ### Dados [Seção intitulada “Dados”](#dados) ```csharp public static string Dados { get; } ``` ### DadosDosVeiculos [Seção intitulada “DadosDosVeiculos”](#dadosdosveiculos) ```csharp public static string DadosDosVeiculos { get; } ``` ### Capturas [Seção intitulada “Capturas”](#capturas) ```csharp public static string Capturas { get; } ``` # ModoDaVista > Câmera do jogo. Namespace `PBSLoaderCommonUtils.Partida` · enumeração · PBSLoaderCommonUtils 2.0.0 ```csharp public enum ModoDaVista ``` Câmera do jogo. ## Valores [Seção intitulada “Valores”](#valores) | Nome | Valor | Descrição | | ----------- | ----- | --------- | | `Nenhuma` | 0 | | | `Motorista` | 1 | | | `Salao` | 2 | | | `Externa` | 3 | | | `Livre` | 4 | | | `Painel` | 5 | | | `Editor` | 6 | | # Opcao > Uma opção do jogo (settings.txt, pelo MepPrefs do jogo). Namespace `PBSLoaderCommonUtils.Partida` · classe abstrata · PBSLoaderCommonUtils 2.0.0 ```csharp public abstract class Opcao ``` Uma opção do jogo (settings.txt, pelo MepPrefs do jogo). `Valor` lê e grava; gravar escreve o arquivo do jogo na hora. Veja `Opcao.Vale`: a maioria só vale ao recomeçar a viagem, como no menu de opções do jogo. ## Construtores [Seção intitulada “Construtores”](#construtores) ### Opcao [Seção intitulada “Opcao”](#opcao) ```csharp protected Opcao(string chave, string nome, string grupo, QuandoVale vale) ``` ## Propriedades [Seção intitulada “Propriedades”](#propriedades) ### Chave [Seção intitulada “Chave”](#chave) ```csharp public string Chave { get; } ``` Chave no settings.txt (“maxCars”). ### Nome [Seção intitulada “Nome”](#nome) ```csharp public string Nome { get; } ``` ### Grupo [Seção intitulada “Grupo”](#grupo) ```csharp public string Grupo { get; } ``` ### Vale [Seção intitulada “Vale”](#vale) ```csharp public QuandoVale Vale { get; } ``` ### Tipo [Seção intitulada “Tipo”](#tipo) ```csharp public abstract Type Tipo { get; } ``` ### Texto [Seção intitulada “Texto”](#texto) ```csharp public abstract string Texto { get; } ``` Valor como texto (diagnóstico). ## Métodos [Seção intitulada “Métodos”](#métodos) ### ToString [Seção intitulada “ToString”](#tostring) ```csharp public override string ToString() ``` # Opcao > classe PBSLoaderCommonUtils.Partida.Opcao`1 Namespace `PBSLoaderCommonUtils.Partida` · classe · PBSLoaderCommonUtils 2.0.0 Herda de [`Opcao`](/pbs-loader-docs/referencia/pbsloadercommonutils/partida/opcao/). ```csharp public sealed class Opcao : Opcao ``` ## Propriedades [Seção intitulada “Propriedades”](#propriedades) ### Min [Seção intitulada “Min”](#min) ```csharp public T Min { get; } ``` ### Max [Seção intitulada “Max”](#max) ```csharp public T Max { get; } ``` ### Tipo [Seção intitulada “Tipo”](#tipo) ```csharp public override Type Tipo { get; } ``` ### Valor [Seção intitulada “Valor”](#valor) ```csharp public T Valor { get; set; } ``` Valor gravado no jogo (o padrão do jogo se ainda não existir). ### Texto [Seção intitulada “Texto”](#texto) ```csharp public override string Texto { get; } ``` # Opcoes > Opções do próprio jogo (as do menu de opções dele), lidas e gravadas pelo MepPrefs do jogo, no settings.txt da pasta de dados. Namespace `PBSLoaderCommonUtils.Partida` · classe estática · PBSLoaderCommonUtils 2.0.0 ```csharp public static class Opcoes ``` Opções do próprio jogo (as do menu de opções dele), lidas e gravadas pelo MepPrefs do jogo, no settings.txt da pasta de dados. As principais têm nome em `Opcoes.Todas` e campo próprio (ex.: `Opcoes.CarrosNoTransito`); as outras, por chave com `Opcoes.Ler` e `Opcoes.Gravar`. Antes de o jogo abrir o arquivo (logo no começo do menu), ler devolve o padrão e gravar não faz nada. ## Propriedades [Seção intitulada “Propriedades”](#propriedades) ### Todas [Seção intitulada “Todas”](#todas) ```csharp public static IReadOnlyList Todas { get; } ``` As opções com nome, na ordem dos grupos. ### Disponivel [Seção intitulada “Disponivel”](#disponivel) ```csharp public static bool Disponivel { get; } ``` O jogo já abriu o arquivo de opções. ## Métodos [Seção intitulada “Métodos”](#métodos) ### Ler [Seção intitulada “Ler”](#ler) ```csharp public static T Ler(string chave, T padrao = default) ``` Lê qualquer opção do jogo pela chave (int, float, bool ou string). ### Gravar [Seção intitulada “Gravar”](#gravar) ```csharp public static bool Gravar(string chave, T valor) ``` Grava qualquer opção do jogo pela chave e escreve o arquivo. Retorna false se o jogo ainda não abriu o arquivo. ## Campos [Seção intitulada “Campos”](#campos) ### CarrosNoTransito [Seção intitulada “CarrosNoTransito”](#carrosnotransito) ```csharp public static readonly Opcao CarrosNoTransito ``` ### PedestresNaRua [Seção intitulada “PedestresNaRua”](#pedestresnarua) ```csharp public static readonly Opcao PedestresNaRua ``` ### OnibusNoTransito [Seção intitulada “OnibusNoTransito”](#onibusnotransito) ```csharp public static readonly Opcao OnibusNoTransito ``` ### PassageirosPorcento [Seção intitulada “PassageirosPorcento”](#passageirosporcento) ```csharp public static readonly Opcao PassageirosPorcento ``` ### CarrosEstacionadosPorcento [Seção intitulada “CarrosEstacionadosPorcento”](#carrosestacionadosporcento) ```csharp public static readonly Opcao CarrosEstacionadosPorcento ``` ### OnibusEstacionados [Seção intitulada “OnibusEstacionados”](#onibusestacionados) ```csharp public static readonly Opcao OnibusEstacionados ``` ### TrensDoMapa [Seção intitulada “TrensDoMapa”](#trensdomapa) ```csharp public static readonly Opcao TrensDoMapa ``` ### DistanciaVisivel [Seção intitulada “DistanciaVisivel”](#distanciavisivel) ```csharp public static readonly Opcao DistanciaVisivel ``` ### MaxFps [Seção intitulada “MaxFps”](#maxfps) ```csharp public static readonly Opcao MaxFps ``` ### Sombras [Seção intitulada “Sombras”](#sombras) ```csharp public static readonly Opcao Sombras ``` ### SombrasDeNoite [Seção intitulada “SombrasDeNoite”](#sombrasdenoite) ```csharp public static readonly Opcao SombrasDeNoite ``` ### Reflexos [Seção intitulada “Reflexos”](#reflexos) ```csharp public static readonly Opcao Reflexos ``` ### Neblina [Seção intitulada “Neblina”](#neblina) ```csharp public static readonly Opcao Neblina ``` ### Antialiasing [Seção intitulada “Antialiasing”](#antialiasing) ```csharp public static readonly Opcao Antialiasing ``` ### Arvores3D [Seção intitulada “Arvores3D”](#arvores3d) ```csharp public static readonly Opcao Arvores3D ``` ### RaiosETrovoes [Seção intitulada “RaiosETrovoes”](#raiosetrovoes) ```csharp public static readonly Opcao RaiosETrovoes ``` ### RetrovisorEsquerdo [Seção intitulada “RetrovisorEsquerdo”](#retrovisoresquerdo) ```csharp public static readonly Opcao RetrovisorEsquerdo ``` ### RetrovisorDireito [Seção intitulada “RetrovisorDireito”](#retrovisordireito) ```csharp public static readonly Opcao RetrovisorDireito ``` ### RetrovisorInterno [Seção intitulada “RetrovisorInterno”](#retrovisorinterno) ```csharp public static readonly Opcao RetrovisorInterno ``` ### EspelhosMaisQualidade [Seção intitulada “EspelhosMaisQualidade”](#espelhosmaisqualidade) ```csharp public static readonly Opcao EspelhosMaisQualidade ``` ### JogarANoite [Seção intitulada “JogarANoite”](#jogaranoite) ```csharp public static readonly Opcao JogarANoite ``` ### HoraLocal [Seção intitulada “HoraLocal”](#horalocal) ```csharp public static readonly Opcao HoraLocal ``` ### ComecarChovendo [Seção intitulada “ComecarChovendo”](#comecarchovendo) ```csharp public static readonly Opcao ComecarChovendo ``` ### CambioManual [Seção intitulada “CambioManual”](#cambiomanual) ```csharp public static readonly Opcao CambioManual ``` ### Embreagem [Seção intitulada “Embreagem”](#embreagem) ```csharp public static readonly Opcao Embreagem ``` ### Cobrador [Seção intitulada “Cobrador”](#cobrador) ```csharp public static readonly Opcao Cobrador ``` ### Placas [Seção intitulada “Placas”](#placas) ```csharp public static readonly Opcao Placas ``` ### ComecarLigado [Seção intitulada “ComecarLigado”](#comecarligado) ```csharp public static readonly Opcao ComecarLigado ``` ### FreioDeEstacionamento [Seção intitulada “FreioDeEstacionamento”](#freiodeestacionamento) ```csharp public static readonly Opcao FreioDeEstacionamento ``` ### ForceFeedback [Seção intitulada “ForceFeedback”](#forcefeedback) ```csharp public static readonly Opcao ForceFeedback ``` ### InverterVolante [Seção intitulada “InverterVolante”](#invertervolante) ```csharp public static readonly Opcao InverterVolante ``` ### InverterPedais [Seção intitulada “InverterPedais”](#inverterpedais) ```csharp public static readonly Opcao InverterPedais ``` ### PedaisCombinados [Seção intitulada “PedaisCombinados”](#pedaiscombinados) ```csharp public static readonly Opcao PedaisCombinados ``` ### AjudaDeDirecao [Seção intitulada “AjudaDeDirecao”](#ajudadedirecao) ```csharp public static readonly Opcao AjudaDeDirecao ``` ### SensibilidadeTeclado [Seção intitulada “SensibilidadeTeclado”](#sensibilidadeteclado) ```csharp public static readonly Opcao SensibilidadeTeclado ``` ### Volume [Seção intitulada “Volume”](#volume) ```csharp public static readonly Opcao Volume ``` ### VozesComMotorista [Seção intitulada “VozesComMotorista”](#vozescommotorista) ```csharp public static readonly Opcao VozesComMotorista ``` # OrigemDoOnibus > De onde veio o ônibus da partida. Namespace `PBSLoaderCommonUtils.Partida` · enumeração · PBSLoaderCommonUtils 2.0.0 ```csharp public enum OrigemDoOnibus ``` De onde veio o ônibus da partida. ## Valores [Seção intitulada “Valores”](#valores) | Nome | Valor | Descrição | | -------------- | ----- | --------- | | `Desconhecida` | 0 | | | `Jogo` | 1 | | | `Mod` | 2 | | # QuandoVale > Quando uma mudança de opção do jogo passa a valer. Namespace `PBSLoaderCommonUtils.Partida` · enumeração · PBSLoaderCommonUtils 2.0.0 ```csharp public enum QuandoVale ``` Quando uma mudança de opção do jogo passa a valer. ## Valores [Seção intitulada “Valores”](#valores) | Nome | Valor | Descrição | | ------------------- | ----- | --------- | | `NaHora` | 0 | | | `AoRecomecarViagem` | 1 | | # Sessao > O que o jogador escolheu para a partida (ônibus, pintura, mapa, ponto de partida) e se está pausado. Namespace `PBSLoaderCommonUtils.Partida` · classe estática · PBSLoaderCommonUtils 2.0.0 ```csharp public static class Sessao ``` O que o jogador escolheu para a partida (ônibus, pintura, mapa, ponto de partida) e se está pausado. ## Propriedades [Seção intitulada “Propriedades”](#propriedades) ### Onibus [Seção intitulada “Onibus”](#onibus) ```csharp public static string Onibus { get; } ``` Nome do ônibus escolhido (o mesmo que `Veiculo.Nome` quando a partida já carregou). ### OrigemDoOnibus [Seção intitulada “OrigemDoOnibus”](#origemdoonibus) ```csharp public static OrigemDoOnibus OrigemDoOnibus { get; } ``` ### PastaDaPintura [Seção intitulada “PastaDaPintura”](#pastadapintura) ```csharp public static string PastaDaPintura { get; } ``` Pasta da pintura escolhida (mods de ônibus). ### ArquivoDaPintura [Seção intitulada “ArquivoDaPintura”](#arquivodapintura) ```csharp public static string ArquivoDaPintura { get; } ``` ### Mapa [Seção intitulada “Mapa”](#mapa) ```csharp public static string Mapa { get; } ``` ### PontoDePartida [Seção intitulada “PontoDePartida”](#pontodepartida) ```csharp public static string PontoDePartida { get; } ``` ### Pausado [Seção intitulada “Pausado”](#pausado) ```csharp public static bool Pausado { get; } ``` O jogo está pausado (menu de pausa aberto). # Vista > Câmera do jogador (MouseOrbitCSHARP). Namespace `PBSLoaderCommonUtils.Partida` · classe estática · PBSLoaderCommonUtils 2.0.0 ```csharp public static class Vista ``` Câmera do jogador (MouseOrbitCSHARP). Um mod que posiciona a câmera por conta própria (andar a pé, câmera de cinema) pede `Vista.Assumir` a cada quadro: enquanto alguém pedir, o jogo não move a câmera. ## Propriedades [Seção intitulada “Propriedades”](#propriedades) ### Modo [Seção intitulada “Modo”](#modo) ```csharp public static ModoDaVista Modo { get; } ``` ### Interna [Seção intitulada “Interna”](#interna) ```csharp public static bool Interna { get; } ``` O jogo considera a câmera dentro do veículo (som abafado, espelhos…). ### Camera [Seção intitulada “Camera”](#camera) ```csharp public static Camera Camera { get; } ``` Câmera que o jogo está usando agora. ### Assumida [Seção intitulada “Assumida”](#assumida) ```csharp public static bool Assumida { get; } ``` Algum mod está controlando a câmera. ### Dono [Seção intitulada “Dono”](#dono) ```csharp public static string Dono { get; } ``` ## Métodos [Seção intitulada “Métodos”](#métodos) ### IrParaMotorista [Seção intitulada “IrParaMotorista”](#irparamotorista) ```csharp public static void IrParaMotorista() ``` Volta para a câmera do motorista (como a tecla do jogo). ### Assumir [Seção intitulada “Assumir”](#assumir) ```csharp public static void Assumir(string dono, bool precisa = true) ``` O mod `dono` controla a câmera neste quadro (chame todo quadro enquanto precisar; o pedido vence no quadro seguinte). Enquanto houver um dono, MouseOrbitCSHARP.Update/LateUpdate não rodam. ## Eventos [Seção intitulada “Eventos”](#eventos) ### Mudou [Seção intitulada “Mudou”](#mudou) ```csharp public static event Action Mudou ``` O modo da câmera mudou. # PedidoDePorta > Um pedido de abrir ou fechar uma porta, antes de o jogo agir. Namespace `PBSLoaderCommonUtils` · classe · PBSLoaderCommonUtils 2.0.0 ```csharp public sealed class PedidoDePorta ``` Um pedido de abrir ou fechar uma porta, antes de o jogo agir. Quem cancelar impede o comando (e o som). ## Construtores [Seção intitulada “Construtores”](#construtores) ### PedidoDePorta [Seção intitulada “PedidoDePorta”](#pedidodeporta) ```csharp public PedidoDePorta() ``` ## Propriedades [Seção intitulada “Propriedades”](#propriedades) ### Lado [Seção intitulada “Lado”](#lado) ```csharp public Lado Lado { get; } ``` ### Numero [Seção intitulada “Numero”](#numero) ```csharp public int Numero { get; } ``` Número da porta no jogo (1..6). ### Porta [Seção intitulada “Porta”](#porta) ```csharp public Porta Porta { get; } ``` A porta, se o SDK já a conhece (null em ônibus que ainda estão montando). ### Abrindo [Seção intitulada “Abrindo”](#abrindo) ```csharp public bool Abrindo { get; } ``` true = vai abrir; false = vai fechar. ### Cancelado [Seção intitulada “Cancelado”](#cancelado) ```csharp public bool Cancelado { get; } ``` ### CanceladoPor [Seção intitulada “CanceladoPor”](#canceladopor) ```csharp public string CanceladoPor { get; } ``` ## Métodos [Seção intitulada “Métodos”](#métodos) ### Cancelar [Seção intitulada “Cancelar”](#cancelar) ```csharp public void Cancelar(string mod) ``` # Salvos > Gavetas de dados que sobrevivem entre sessões (ver Gaveta). Namespace `PBSLoaderCommonUtils` · classe estática · PBSLoaderCommonUtils 2.0.0 ```csharp public static class Salvos ``` Gavetas de dados que sobrevivem entre sessões (ver `Gaveta`). ## Propriedades [Seção intitulada “Propriedades”](#propriedades) ### Pasta [Seção intitulada “Pasta”](#pasta) ```csharp public static string Pasta { get; } ``` Pasta onde ficam os arquivos (UserData/PBSLoaderCommonUtils/Salvos). ## Métodos [Seção intitulada “Métodos”](#métodos) ### Global [Seção intitulada “Global”](#global) ```csharp public static Gaveta Global(string mod) ``` Dados do mod que valem em qualquer ônibus e mapa. ### DoOnibus [Seção intitulada “DoOnibus”](#doonibus) ```csharp public static Gaveta DoOnibus(string mod) ``` Dados do mod para o ônibus que o jogador dirige agora (sem ônibus: gaveta que não grava). ### DoMapa [Seção intitulada “DoMapa”](#domapa) ```csharp public static Gaveta DoMapa(string mod) ``` Dados do mod para o mapa carregado agora (sem mapa: gaveta que não grava). ### GravarAgora [Seção intitulada “GravarAgora”](#gravaragora) ```csharp public static void GravarAgora() ``` Escreve agora tudo que estiver pendente (normalmente não precisa). # Sdk > Ciclo de vida do SDK: versão, fase do jogo e eventos. Namespace `PBSLoaderCommonUtils` · classe estática · PBSLoaderCommonUtils 2.0.0 ```csharp public static class Sdk ``` Ciclo de vida do SDK: versão, fase do jogo e eventos. Tudo roda na thread principal, no quadro da PBSLoaderCommonUtils (que tem prioridade -1000, então os dados já estão atualizados quando o OnUpdate dos outros mods roda). Uma exceção num inscrito não impede os outros de receber o evento. ## Propriedades [Seção intitulada “Propriedades”](#propriedades) ### VersaoDoJogo [Seção intitulada “VersaoDoJogo”](#versaodojogo) ```csharp public static string VersaoDoJogo { get; } ``` Versão do jogo (“307”), ou “não testada” numa versão que o SDK não conhece. ### JogoTestado [Seção intitulada “JogoTestado”](#jogotestado) ```csharp public static bool JogoTestado { get; } ``` O SDK foi testado nesta versão do jogo (pelo SHA-256 do GameAssembly.dll). ### ModoSeguro [Seção intitulada “ModoSeguro”](#modoseguro) ```csharp public static bool ModoSeguro { get; } ``` Versão do jogo não testada (e o jogador não liberou): os ganchos não disparam, pedidos de condução e o freio a ar não escrevem no jogo e `Avancado` devolve null. As fachadas de leitura continuam funcionando. Mods que mexem no jogo por conta própria devem conferir isto. ### Fase [Seção intitulada “Fase”](#fase) ```csharp public static Fase Fase { get; } ``` Fase atual (menu, telas de escolha, carregando a partida, dirigindo). ### Cena [Seção intitulada “Cena”](#cena) ```csharp public static string Cena { get; } ``` Cena ativa da Unity. ## Métodos [Seção intitulada “Métodos”](#métodos) ### Requer [Seção intitulada “Requer”](#requer) ```csharp public static bool Requer(string versaoMinima, string mod) ``` Confere se o SDK instalado tem pelo menos `versaoMinima`. Se não tiver, registra o erro, mostra uma falha na tela e retorna false (o mod deve se desligar). ### Seguro [Seção intitulada “Seguro”](#seguro) ```csharp public static bool Seguro(Action a, string onde) ``` Roda `a` e registra a exceção sem derrubar quem chamou (no máximo a cada 10 s por `onde`). ### Registrar [Seção intitulada “Registrar”](#registrar) ```csharp public static void Registrar(Exception e, string onde) ``` Registra uma exceção no log, no máximo a cada 10 s por `onde` (a pilha só na primeira vez). ## Eventos [Seção intitulada “Eventos”](#eventos) ### FaseMudou [Seção intitulada “FaseMudou”](#fasemudou) ```csharp public static event Action FaseMudou ``` A fase mudou (o argumento é a nova). ### CenaCarregou [Seção intitulada “CenaCarregou”](#cenacarregou) ```csharp public static event Action CenaCarregou ``` Uma cena terminou de carregar (inclui as aditivas, como os tiles do mapa). ### VeiculoTrocou [Seção intitulada “VeiculoTrocou”](#veiculotrocou) ```csharp public static event Action VeiculoTrocou ``` O veículo do jogador apareceu ou sumiu. Veja `Veiculo.Existe`. ### MapaCarregou [Seção intitulada “MapaCarregou”](#mapacarregou) ```csharp public static event Action MapaCarregou ``` Um mapa novo começou (o jogador está dirigindo nele). Veja `Mapa`. ### Quadro [Seção intitulada “Quadro”](#quadro) ```csharp public static event Action Quadro ``` Todo quadro (Update), depois de todos os dados do SDK atualizados. ### PassoFisico [Seção intitulada “PassoFisico”](#passofisico) ```csharp public static event Action PassoFisico ``` Todo passo de física (FixedUpdate), depois do ar comprimido. ### QuadroTardio [Seção intitulada “QuadroTardio”](#quadrotardio) ```csharp public static event Action QuadroTardio ``` Todo quadro, no LateUpdate. ## Constantes [Seção intitulada “Constantes”](#constantes) ### Versao [Seção intitulada “Versao”](#versao) ```csharp public const string Versao = "2.0.0" ``` Versão da API (semver). Mudança no primeiro número quebra mods. # Ar > Ar comprimido do veículo: compressor movido pelo motor, reservatório, governador com purga do secador, freio de serviço pneumático e freio de molas (estacionamento). Namespace `PBSLoaderCommonUtils.Simulacao` · classe estática · PBSLoaderCommonUtils 2.0.0 ```csharp public static class Ar ``` Ar comprimido do veículo: compressor movido pelo motor, reservatório, governador com purga do secador, freio de serviço pneumático e freio de molas (estacionamento). Um reservatório só para todos os mods: portas, suspensão a ar (`Ar.Gastar`) e o que vier. Unidades: pressão em bar manométrico; volumes de ar “livre” em litros a 1 bar. Pôr V litros livres num reservatório de R litros sobe a pressão em V / R bar (isotérmico). O freio atua no VPP: um prefixo em Brakes.DoUpdate troca o pedido do motorista (brakeInput) pela pressão que chegou às câmaras, e soma o freio de molas ao freio de mão. Veículos sem VPP só têm a simulação. ## Propriedades [Seção intitulada “Propriedades”](#propriedades) ### Simulando [Seção intitulada “Simulando”](#simulando) ```csharp public static bool Simulando { get; } ``` ### Pressao [Seção intitulada “Pressao”](#pressao) ```csharp public static float Pressao { get; } ``` Reservatório (bar). ### PressaoCorte [Seção intitulada “PressaoCorte”](#pressaocorte) ```csharp public static float PressaoCorte { get; } ``` ### CompressorCarregando [Seção intitulada “CompressorCarregando”](#compressorcarregando) ```csharp public static bool CompressorCarregando { get; } ``` Compressor carregando (governador não cortou e o motor gira). ### VazaoCompressor [Seção intitulada “VazaoCompressor”](#vazaocompressor) ```csharp public static float VazaoCompressor { get; } ``` Ar que o compressor está mandando agora (litros livres por minuto). ### PressaoCamaras [Seção intitulada “PressaoCamaras”](#pressaocamaras) ```csharp public static float PressaoCamaras { get; } ``` Pressão nas câmaras de freio de serviço (bar). ### FreioEfetivo [Seção intitulada “FreioEfetivo”](#freioefetivo) ```csharp public static float FreioEfetivo { get; } ``` Freio que chega às rodas, 0..1 (o que o VPP recebe no lugar do pedal). ### PressaoMolas [Seção intitulada “PressaoMolas”](#pressaomolas) ```csharp public static float PressaoMolas { get; } ``` Pressão nas câmaras de mola (bar). Alta = molas soltas. ### FreioMolas [Seção intitulada “FreioMolas”](#freiomolas) ```csharp public static float FreioMolas { get; } ``` Quanto o freio de molas está aplicado, 0..1. ### Alarme [Seção intitulada “Alarme”](#alarme) ```csharp public static bool Alarme { get; } ``` ### Escape [Seção intitulada “Escape”](#escape) ```csharp public static float Escape { get; } ``` Ar saindo para a atmosfera agora (litros livres por segundo): freios soltando, purga. ### PurgaEnvelope [Seção intitulada “PurgaEnvelope”](#purgaenvelope) ```csharp public static float PurgaEnvelope { get; } ``` Parte do `Ar.Escape` que vem da purga do secador (litros livres por segundo). ### VolumeLitros [Seção intitulada “VolumeLitros”](#volumelitros) ```csharp public static float VolumeLitros { get; } ``` Reservatório em litros (para converter consumo). ### PassosPorSegundo [Seção intitulada “PassosPorSegundo”](#passosporsegundo) ```csharp public static float PassosPorSegundo { get; } ``` Diagnóstico: quantas vezes por segundo a simulação roda. ## Métodos [Seção intitulada “Métodos”](#métodos) ### Gastar [Seção intitulada “Gastar”](#gastar) ```csharp public static void Gastar(string fonte, float litrosLivres) ``` Tira ar do reservatório (litros livres a 1 bar). Para mods que usam ar: portas, bolsas… ### Disponivel [Seção intitulada “Disponivel”](#disponivel) ```csharp public static float Disponivel(float minima, float cheia) ``` Fração de pressão disponível para um consumidor que precisa de “minima” bar e funciona cheio com “cheia”. ### Resumo [Seção intitulada “Resumo”](#resumo) ```csharp public static string Resumo() ``` ## Eventos [Seção intitulada “Eventos”](#eventos) ### Evento [Seção intitulada “Evento”](#evento) ```csharp public static event Action Evento ``` “purga” (governador cortou), “molas” (freio de estacionamento aplicado), “alarme”. # Comandos > Comandos de carroceria do veículo do jogador, pelos mesmos métodos que os botões do jogo usam (então o jogo cuida de som, animação do botão do painel e luzes). Namespace `PBSLoaderCommonUtils.Veiculos` · classe estática · PBSLoaderCommonUtils 2.0.0 ```csharp public static class Comandos ``` Comandos de carroceria do veículo do jogador, pelos mesmos métodos que os botões do jogo usam (então o jogo cuida de som, animação do botão do painel e luzes). Cada comando alterna o estado; leia o estado em `Veiculo`. Sem veículo, nada acontece. Portas passam pela trava de ar do `Ar` (sem pressão elas não se mexem). ## Propriedades [Seção intitulada “Propriedades”](#propriedades) ### RetarderAutomatico [Seção intitulada “RetarderAutomatico”](#retarderautomatico) ```csharp public static bool RetarderAutomatico { get; } ``` ### TemComandoSuspensao [Seção intitulada “TemComandoSuspensao”](#temcomandosuspensao) ```csharp public static bool TemComandoSuspensao { get; } ``` ## Métodos [Seção intitulada “Métodos”](#métodos) ### FarolBaixo [Seção intitulada “FarolBaixo”](#farolbaixo) ```csharp public static void FarolBaixo() ``` ### FarolAlto [Seção intitulada “FarolAlto”](#farolalto) ```csharp public static void FarolAlto() ``` ### PiscaAlerta [Seção intitulada “PiscaAlerta”](#piscaalerta) ```csharp public static void PiscaAlerta() ``` ### SetaEsquerda [Seção intitulada “SetaEsquerda”](#setaesquerda) ```csharp public static void SetaEsquerda() ``` ### SetaDireita [Seção intitulada “SetaDireita”](#setadireita) ```csharp public static void SetaDireita() ``` ### FreioDeMao [Seção intitulada “FreioDeMao”](#freiodemao) ```csharp public static void FreioDeMao() ``` ### TemLuzInterna [Seção intitulada “TemLuzInterna”](#temluzinterna) ```csharp public static bool TemLuzInterna(int n) ``` O veículo tem a luz interna (salão) 1, 2 ou 3. ### LuzInternaAcesa [Seção intitulada “LuzInternaAcesa”](#luzinternaacesa) ```csharp public static bool LuzInternaAcesa(int n) ``` ### LuzInterna [Seção intitulada “LuzInterna”](#luzinterna) ```csharp public static void LuzInterna(int n) ``` ### Porta [Seção intitulada “Porta”](#porta) ```csharp public static void Porta(Lado lado, int numero) ``` Abre ou fecha uma porta (lado e número como em `Porta`). ### Porta [Seção intitulada “Porta”](#porta-1) ```csharp public static void Porta(Porta porta) ``` ### TodasAsPortas [Seção intitulada “TodasAsPortas”](#todasasportas) ```csharp public static void TodasAsPortas() ``` ### Eletrica [Seção intitulada “Eletrica”](#eletrica) ```csharp public static void Eletrica(bool ligada) ``` Liga ou desliga a elétrica (chave), se ainda não estiver assim. ### Motor [Seção intitulada “Motor”](#motor) ```csharp public static void Motor(bool ligado) ``` Dá partida ou desliga o motor, se ainda não estiver assim. A partida precisa da elétrica ligada. ### ParadaSolicitada [Seção intitulada “ParadaSolicitada”](#paradasolicitada) ```csharp public static void ParadaSolicitada(bool acesa) ``` Campainha de parada solicitada (a luz e o som do painel). ### Limpadores [Seção intitulada “Limpadores”](#limpadores) ```csharp public static void Limpadores() ``` Liga e desliga os limpadores (velocidade normal). ### LimpadoresRapidos [Seção intitulada “LimpadoresRapidos”](#limpadoresrapidos) ```csharp public static void LimpadoresRapidos() ``` Liga e desliga a velocidade rápida dos limpadores. ### JanelaMotorista [Seção intitulada “JanelaMotorista”](#janelamotorista) ```csharp public static void JanelaMotorista() ``` Abre e fecha a janela do motorista (animação AWD do ônibus, quando ele tem). ### JanelasDianteiras [Seção intitulada “JanelasDianteiras”](#janelasdianteiras) ```csharp public static void JanelasDianteiras() ``` Abre e fecha as janelas da frente do salão (animação AWFR). ### JanelasTraseiras [Seção intitulada “JanelasTraseiras”](#janelastraseiras) ```csharp public static void JanelasTraseiras() ``` Abre e fecha as janelas de trás do salão (animação AWBK). ### PilotoAutomatico [Seção intitulada “PilotoAutomatico”](#pilotoautomatico) ```csharp public static void PilotoAutomatico() ``` Liga e desliga o piloto automático (mantém a velocidade atual). ### Limitador [Seção intitulada “Limitador”](#limitador) ```csharp public static void Limitador() ``` Liga e desliga o limitador de velocidade (se o veículo tiver, ver `Ajudas.TemLimitador`). ### Marcha [Seção intitulada “Marcha”](#marcha) ```csharp public static bool Marcha(int marcha) ``` Câmbio automático: põe em R (-1), N (0) ou D (qualquer marcha à frente), pelos botões do jogo. Retorna false no câmbio manual: lá o jogo mantém a marcha a partir da alavanca do jogador, e um mod que quer escolher a marcha pede `Conducao.Marcha` a cada quadro. ### ArCondicionado [Seção intitulada “ArCondicionado”](#arcondicionado) ```csharp public static void ArCondicionado() ``` ### ArCondicionadoVentilador [Seção intitulada “ArCondicionadoVentilador”](#arcondicionadoventilador) ```csharp public static void ArCondicionadoVentilador() ``` Passa para o próximo nível do ventilador. ### ArCondicionadoTemperatura [Seção intitulada “ArCondicionadoTemperatura”](#arcondicionadotemperatura) ```csharp public static void ArCondicionadoTemperatura(int passos) ``` ### RetarderMais [Seção intitulada “RetarderMais”](#retardermais) ```csharp public static void RetarderMais() ``` ### RetarderMenos [Seção intitulada “RetarderMenos”](#retardermenos) ```csharp public static void RetarderMenos() ``` ### RetarderAuto [Seção intitulada “RetarderAuto”](#retarderauto) ```csharp public static void RetarderAuto() ``` ### Ajoelhar [Seção intitulada “Ajoelhar”](#ajoelhar) ```csharp public static void Ajoelhar() ``` ### Elevar [Seção intitulada “Elevar”](#elevar) ```csharp public static void Elevar() ``` # Conducao > Pedidos de condução de um mod (piloto automático, ajuda de direção, teste): acelerador, freio, embreagem, freio de mão e direção, no lugar do que o jogador está fazendo. Namespace `PBSLoaderCommonUtils.Veiculos` · classe estática · PBSLoaderCommonUtils 2.0.0 ```csharp public static class Conducao ``` Pedidos de condução de um mod (piloto automático, ajuda de direção, teste): acelerador, freio, embreagem, freio de mão e direção, no lugar do que o jogador está fazendo. Como em `Mouse`, o pedido vale enquanto for repetido: chame a cada quadro; parou de chamar, o controle volta ao jogador no quadro seguinte. O valor é escrito no barramento de entrada do VPP logo antes de cada passo de física, depois de o jogo escrever o dele, então vence. `Pedais` passa a mostrar o pedido do mod. Com dois mods pedindo o mesmo pedal, vale o maior valor (freio e freio de mão) ou o último pedido (o resto). Só em veículos VPP. ## Propriedades [Seção intitulada “Propriedades”](#propriedades) ### Controlando [Seção intitulada “Controlando”](#controlando) ```csharp public static bool Controlando { get; } ``` Algum mod está pedindo algum pedal ou a direção agora. ### Donos [Seção intitulada “Donos”](#donos) ```csharp public static string Donos { get; } ``` Quem está pedindo (diagnóstico). ## Métodos [Seção intitulada “Métodos”](#métodos) ### Acelerador [Seção intitulada “Acelerador”](#acelerador) ```csharp public static void Acelerador(string dono, float valor) ``` Acelerador 0..1. ### Freio [Seção intitulada “Freio”](#freio) ```csharp public static void Freio(string dono, float valor) ``` Freio 0..1 (passa pelo freio a ar, se ligado). ### Embreagem [Seção intitulada “Embreagem”](#embreagem) ```csharp public static void Embreagem(string dono, float valor) ``` Embreagem 0..1, no sentido que o VPP recebe (ver `Pedais.Embreagem`). ### FreioDeMao [Seção intitulada “FreioDeMao”](#freiodemao) ```csharp public static void FreioDeMao(string dono, float valor) ``` Alavanca do freio de mão 0..1. ### Direcao [Seção intitulada “Direcao”](#direcao) ```csharp public static void Direcao(string dono, float valor) ``` Direção -1 (esquerda) .. 1 (direita). ### Marcha [Seção intitulada “Marcha”](#marcha) ```csharp public static void Marcha(string dono, int marcha) ``` Marcha do câmbio manual (-1 ré, 0 neutro, 1.. à frente), escrita no VPP e no painel do jogo. Para o câmbio automático use `Comandos.Marcha`. Mods de câmbio podem exigir a embreagem para engatar. ### Buzina [Seção intitulada “Buzina”](#buzina) ```csharp public static void Buzina(string dono) ``` Buzina tocando enquanto for pedida (chame a cada quadro). ### Soltar [Seção intitulada “Soltar”](#soltar) ```csharp public static void Soltar(string dono) ``` Para de pedir tudo (o mesmo que não chamar no próximo quadro). # Espelho > Um dos três espelhos que o jogo renderiza (câmera + material que mostra a imagem). Namespace `PBSLoaderCommonUtils.Veiculos` · classe · PBSLoaderCommonUtils 2.0.0 ```csharp public sealed class Espelho ``` Um dos três espelhos que o jogo renderiza (câmera + material que mostra a imagem). ## Construtores [Seção intitulada “Construtores”](#construtores) ### Espelho [Seção intitulada “Espelho”](#espelho) ```csharp public Espelho() ``` ## Propriedades [Seção intitulada “Propriedades”](#propriedades) ### Posicao [Seção intitulada “Posicao”](#posicao) ```csharp public PosicaoEspelho Posicao { get; } ``` ### Camera [Seção intitulada “Camera”](#camera) ```csharp public Camera Camera { get; } ``` ### Material [Seção intitulada “Material”](#material) ```csharp public Material Material { get; } ``` ### Objeto [Seção intitulada “Objeto”](#objeto) ```csharp public GameObject Objeto { get; } ``` Objeto da câmera no jogo (MEPControlesBus.camEsp\*). ## Métodos [Seção intitulada “Métodos”](#métodos) ### ToString [Seção intitulada “ToString”](#tostring) ```csharp public override string ToString() ``` # Farol > enumeração PBSLoaderCommonUtils.Veiculos.Farol Namespace `PBSLoaderCommonUtils.Veiculos` · enumeração · PBSLoaderCommonUtils 2.0.0 ```csharp public enum Farol ``` ## Valores [Seção intitulada “Valores”](#valores) | Nome | Valor | Descrição | | ----------- | ----- | --------- | | `Desligado` | 0 | | | `Baixo` | 1 | | | `Alto` | 2 | | # FisicaVeiculo > Física que move o veículo no jogo. Namespace `PBSLoaderCommonUtils.Veiculos` · enumeração · PBSLoaderCommonUtils 2.0.0 ```csharp public enum FisicaVeiculo ``` Física que move o veículo no jogo. O freio a ar só atua em VPP. ## Valores [Seção intitulada “Valores”](#valores) | Nome | Valor | Descrição | | -------------- | ----- | --------- | | `Desconhecida` | 0 | | | `Evp5` | 1 | | | `Vpp` | 2 | | | `Trem` | 3 | | # Lado > enumeração PBSLoaderCommonUtils.Veiculos.Lado Namespace `PBSLoaderCommonUtils.Veiculos` · enumeração · PBSLoaderCommonUtils 2.0.0 ```csharp public enum Lado ``` ## Valores [Seção intitulada “Valores”](#valores) | Nome | Valor | Descrição | | ---------- | ----- | --------- | | `Direito` | 0 | | | `Esquerdo` | 1 | | # Porta > Uma porta do veículo. Namespace `PBSLoaderCommonUtils.Veiculos` · classe · PBSLoaderCommonUtils 2.0.0 ```csharp public sealed class Porta ``` Uma porta do veículo. “Numero” é o do jogo (R1..R6 / L1..L6). ## Construtores [Seção intitulada “Construtores”](#construtores) ### Porta [Seção intitulada “Porta”](#porta) ```csharp public Porta() ``` ## Propriedades [Seção intitulada “Propriedades”](#propriedades) ### Lado [Seção intitulada “Lado”](#lado) ```csharp public Lado Lado { get; } ``` ### Numero [Seção intitulada “Numero”](#numero) ```csharp public int Numero { get; } ``` ### Aberta [Seção intitulada “Aberta”](#aberta) ```csharp public bool Aberta { get; } ``` ### Entrada [Seção intitulada “Entrada”](#entrada) ```csharp public bool Entrada { get; } ``` ### Saida [Seção intitulada “Saida”](#saida) ```csharp public bool Saida { get; } ``` ### TemRampa [Seção intitulada “TemRampa”](#temrampa) ```csharp public bool TemRampa { get; } ``` ### Jogo [Seção intitulada “Jogo”](#jogo) ```csharp public MEPCadaPortaBus Jogo { get; } ``` Componente do jogo, para quem precisar de mais. ## Métodos [Seção intitulada “Métodos”](#métodos) ### ToString [Seção intitulada “ToString”](#tostring) ```csharp public override string ToString() ``` # PosicaoEspelho > enumeração PBSLoaderCommonUtils.Veiculos.PosicaoEspelho Namespace `PBSLoaderCommonUtils.Veiculos` · enumeração · PBSLoaderCommonUtils 2.0.0 ```csharp public enum PosicaoEspelho ``` ## Valores [Seção intitulada “Valores”](#valores) | Nome | Valor | Descrição | | ---------- | ----- | --------- | | `Esquerdo` | 0 | | | `Direito` | 1 | | | `Meio` | 2 | | # Roda > Uma roda do veículo (VPP). Namespace `PBSLoaderCommonUtils.Veiculos` · classe · PBSLoaderCommonUtils 2.0.0 ```csharp public sealed class Roda ``` Uma roda do veículo (VPP). O mesmo objeto segue a mesma roda enquanto o veículo existir. ## Construtores [Seção intitulada “Construtores”](#construtores) ### Roda [Seção intitulada “Roda”](#roda) ```csharp public Roda() ``` ## Propriedades [Seção intitulada “Propriedades”](#propriedades) ### Lado [Seção intitulada “Lado”](#lado) ```csharp public Lado Lado { get; } ``` Lado pela posição em relação ao centro da carroceria. ### Eixo [Seção intitulada “Eixo”](#eixo) ```csharp public int Eixo { get; } ``` Eixo, da frente para trás (0 = dianteiro). Rodas duplas do mesmo lado têm o mesmo eixo. ### PosicaoLocal [Seção intitulada “PosicaoLocal”](#posicaolocal) ```csharp public Vector3 PosicaoLocal { get; } ``` Posição de montagem no espaço local da raiz do veículo. ### Esterca [Seção intitulada “Esterca”](#esterca) ```csharp public bool Esterca { get; } ``` ### NoChao [Seção intitulada “NoChao”](#nochao) ```csharp public bool NoChao { get; } ``` ### AnguloGraus [Seção intitulada “AnguloGraus”](#angulograus) ```csharp public float AnguloGraus { get; } ``` Ângulo de esterço agora, em graus. ### Jogo [Seção intitulada “Jogo”](#jogo) ```csharp public VPWheelCollider Jogo { get; } ``` Componente do jogo (VPP), para quem precisar de mais. ### Controlador [Seção intitulada “Controlador”](#controlador) ```csharp public VPVehicleController Controlador { get; } ``` Controlador VPP dono da roda (articulados têm mais de um). ## Métodos [Seção intitulada “Métodos”](#métodos) ### ToString [Seção intitulada “ToString”](#tostring) ```csharp public override string ToString() ``` # Seta > enumeração PBSLoaderCommonUtils.Veiculos.Seta Namespace `PBSLoaderCommonUtils.Veiculos` · enumeração · PBSLoaderCommonUtils 2.0.0 ```csharp public enum Seta ``` ## Valores [Seção intitulada “Valores”](#valores) | Nome | Valor | Descrição | | ---------- | ----- | --------- | | `Nenhuma` | 0 | | | `Esquerda` | 1 | | | `Direita` | 2 | | | `Alerta` | 3 | | # TipoVeiculo > enumeração PBSLoaderCommonUtils.Veiculos.TipoVeiculo Namespace `PBSLoaderCommonUtils.Veiculos` · enumeração · PBSLoaderCommonUtils 2.0.0 ```csharp public enum TipoVeiculo ``` ## Valores [Seção intitulada “Valores”](#valores) | Nome | Valor | Descrição | | -------------- | ----- | --------- | | `Nenhum` | 0 | | | `Onibus` | 1 | | | `Articulado` | 2 | | | `Biarticulado` | 3 | | | `Trem` | 4 | | # Veiculo > Veículo que o jogador dirige, lido a cada quadro do MEPControlesBus e do Vehicle Physics Pro. Namespace `PBSLoaderCommonUtils.Veiculos` · classe estática · PBSLoaderCommonUtils 2.0.0 ```csharp public static class Veiculo ``` Veículo que o jogador dirige, lido a cada quadro do MEPControlesBus e do Vehicle Physics Pro. Tudo é só leitura e vale “agora”. Sem veículo (menus), `Veiculo.Existe` é false e o resto fica zerado. Os grupos (`Motor`, `Cambio`, `Pedais`…) seguem a mesma regra. Os componentes do jogo ficam em `Avancado`. ## Tipos aninhados [Seção intitulada “Tipos aninhados”](#tipos-aninhados) * [`Veiculo.Ajudas`](/pbs-loader-docs/referencia/pbsloadercommonutils/veiculos/veiculo-ajudas/) * [`Veiculo.Cabine`](/pbs-loader-docs/referencia/pbsloadercommonutils/veiculos/veiculo-cabine/) * [`Veiculo.Cambio`](/pbs-loader-docs/referencia/pbsloadercommonutils/veiculos/veiculo-cambio/) * [`Veiculo.Espelhos`](/pbs-loader-docs/referencia/pbsloadercommonutils/veiculos/veiculo-espelhos/): Os três espelhos que o jogo renderiza. * [`Veiculo.Luzes`](/pbs-loader-docs/referencia/pbsloadercommonutils/veiculos/veiculo-luzes/) * [`Veiculo.Motor`](/pbs-loader-docs/referencia/pbsloadercommonutils/veiculos/veiculo-motor/) * [`Veiculo.Objetos`](/pbs-loader-docs/referencia/pbsloadercommonutils/veiculos/veiculo-objetos/): Objetos do modelo do ônibus do jogador, pelo nome (os mods de ônibus usam nomes como convenção: “*skin001*”, “*wipers1*”, “*r1y5*”…). * [`Veiculo.Pedais`](/pbs-loader-docs/referencia/pbsloadercommonutils/veiculos/veiculo-pedais/): O que o motorista está pedindo (barramento de entrada do VPP, 0..1, direção -1..1), antes de câmbio, piloto automático e freio a ar. * [`Veiculo.Portas`](/pbs-loader-docs/referencia/pbsloadercommonutils/veiculos/veiculo-portas/) * [`Veiculo.Rodas`](/pbs-loader-docs/referencia/pbsloadercommonutils/veiculos/veiculo-rodas/) * [`Veiculo.Suspensao`](/pbs-loader-docs/referencia/pbsloadercommonutils/veiculos/veiculo-suspensao/): Suspensão a ar, informada por um mod (o SuspensaoAr) via Suspensao.Informar. ## Propriedades [Seção intitulada “Propriedades”](#propriedades) ### Existe [Seção intitulada “Existe”](#existe) ```csharp public static bool Existe { get; } ``` ### Nome [Seção intitulada “Nome”](#nome) ```csharp public static string Nome { get; } ``` Nome do ônibus escolhido, como o jogo guarda (MepMobileControls.strNomeDoBusAtual). ### Tipo [Seção intitulada “Tipo”](#tipo) ```csharp public static TipoVeiculo Tipo { get; } ``` ### Fisica [Seção intitulada “Fisica”](#fisica) ```csharp public static FisicaVeiculo Fisica { get; } ``` ### Raiz [Seção intitulada “Raiz”](#raiz) ```csharp public static Transform Raiz { get; } ``` ### Geracao [Seção intitulada “Geracao”](#geracao) ```csharp public static int Geracao { get; } ``` Muda a cada veículo carregado (para quem guarda estado por veículo). Ver também `Sdk.VeiculoTrocou`. ### Massa [Seção intitulada “Massa”](#massa) ```csharp public static float Massa { get; } ``` ### Caixa [Seção intitulada “Caixa”](#caixa) ```csharp public static Bounds Caixa { get; } ``` Caixa do veículo no espaço local da raiz (sem retrovisores soltos e outliers). ### Pasta [Seção intitulada “Pasta”](#pasta) ```csharp public static string Pasta { get; } ``` Pasta do mod do ônibus (a do .ini, ou a apontada por \[config] baseDir dele), ou “” nos ônibus que vêm com o jogo. É onde ficam modelos, texturas, sons e a pasta scripts/ dos scripts de conteúdo. ### VelocidadeKmh [Seção intitulada “VelocidadeKmh”](#velocidadekmh) ```csharp public static float VelocidadeKmh { get; } ``` ### VelocidadeSinalKmh [Seção intitulada “VelocidadeSinalKmh”](#velocidadesinalkmh) ```csharp public static float VelocidadeSinalKmh { get; } ``` Sinal pela direção do movimento em relação à frente (negativo = de ré). ### Parado [Seção intitulada “Parado”](#parado) ```csharp public static bool Parado { get; } ``` ### OdometroSessaoKm [Seção intitulada “OdometroSessaoKm”](#odometrosessaokm) ```csharp public static float OdometroSessaoKm { get; } ``` ### OdometroTotalKm [Seção intitulada “OdometroTotalKm”](#odometrototalkm) ```csharp public static float OdometroTotalKm { get; } ``` ### EletricaLigada [Seção intitulada “EletricaLigada”](#eletricaligada) ```csharp public static bool EletricaLigada { get; } ``` Elétrica (chave) ligada. ### CameraDentro [Seção intitulada “CameraDentro”](#cameradentro) ```csharp public static bool CameraDentro { get; } ``` A câmera atual está dentro do veículo. ## Métodos [Seção intitulada “Métodos”](#métodos) ### Dentro [Seção intitulada “Dentro”](#dentro) ```csharp public static bool Dentro(Vector3 mundo) ``` O ponto (mundo) está dentro da carroceria (cabine ou salão). ### Resumo [Seção intitulada “Resumo”](#resumo) ```csharp public static string Resumo() ``` Tudo em texto (diagnóstico). # Veiculo.Ajudas > classe estática PBSLoaderCommonUtils.Veiculos.Veiculo.Ajudas Namespace `PBSLoaderCommonUtils.Veiculos` · classe estática · PBSLoaderCommonUtils 2.0.0 Declarado dentro de [`Veiculo`](/pbs-loader-docs/referencia/pbsloadercommonutils/veiculos/veiculo/). ```csharp public static class Ajudas ``` ## Propriedades [Seção intitulada “Propriedades”](#propriedades) ### PilotoAutomatico [Seção intitulada “PilotoAutomatico”](#pilotoautomatico) ```csharp public static bool PilotoAutomatico { get; } ``` ### TemLimitador [Seção intitulada “TemLimitador”](#temlimitador) ```csharp public static bool TemLimitador { get; } ``` ### LimitadorAtivo [Seção intitulada “LimitadorAtivo”](#limitadorativo) ```csharp public static bool LimitadorAtivo { get; } ``` ### LimiteKmh [Seção intitulada “LimiteKmh”](#limitekmh) ```csharp public static float LimiteKmh { get; } ``` ### AbsAtuando [Seção intitulada “AbsAtuando”](#absatuando) ```csharp public static bool AbsAtuando { get; } ``` ### TracaoAtuando [Seção intitulada “TracaoAtuando”](#tracaoatuando) ```csharp public static bool TracaoAtuando { get; } ``` # Veiculo.Cabine > classe estática PBSLoaderCommonUtils.Veiculos.Veiculo.Cabine Namespace `PBSLoaderCommonUtils.Veiculos` · classe estática · PBSLoaderCommonUtils 2.0.0 Declarado dentro de [`Veiculo`](/pbs-loader-docs/referencia/pbsloadercommonutils/veiculos/veiculo/). ```csharp public static class Cabine ``` ## Propriedades [Seção intitulada “Propriedades”](#propriedades) ### Buzinando [Seção intitulada “Buzinando”](#buzinando) ```csharp public static bool Buzinando { get; } ``` ### Limpadores [Seção intitulada “Limpadores”](#limpadores) ```csharp public static int Limpadores { get; } ``` 0 parado, 1 normal, 2 rápido. ### ParadaSolicitada [Seção intitulada “ParadaSolicitada”](#paradasolicitada) ```csharp public static bool ParadaSolicitada { get; } ``` ### TemArCondicionado [Seção intitulada “TemArCondicionado”](#temarcondicionado) ```csharp public static bool TemArCondicionado { get; } ``` ### ArCondicionadoLigado [Seção intitulada “ArCondicionadoLigado”](#arcondicionadoligado) ```csharp public static bool ArCondicionadoLigado { get; } ``` ### ArCondicionadoVentilador [Seção intitulada “ArCondicionadoVentilador”](#arcondicionadoventilador) ```csharp public static int ArCondicionadoVentilador { get; } ``` ### TemperaturaInterna [Seção intitulada “TemperaturaInterna”](#temperaturainterna) ```csharp public static float TemperaturaInterna { get; } ``` ### TemperaturaAlvo [Seção intitulada “TemperaturaAlvo”](#temperaturaalvo) ```csharp public static int TemperaturaAlvo { get; } ``` ### JanelaMotoristaAberta [Seção intitulada “JanelaMotoristaAberta”](#janelamotoristaaberta) ```csharp public static bool JanelaMotoristaAberta { get; } ``` ### TemCobrador [Seção intitulada “TemCobrador”](#temcobrador) ```csharp public static bool TemCobrador { get; } ``` ### PassageirosSessao [Seção intitulada “PassageirosSessao”](#passageirossessao) ```csharp public static int PassageirosSessao { get; } ``` Passageiros que passaram na catraca nesta sessão. ### PassageirosABordo [Seção intitulada “PassageirosABordo”](#passageirosabordo) ```csharp public static int PassageirosABordo { get; } ``` Passageiros dentro do veículo agora. # Veiculo.Cambio > classe estática PBSLoaderCommonUtils.Veiculos.Veiculo.Cambio Namespace `PBSLoaderCommonUtils.Veiculos` · classe estática · PBSLoaderCommonUtils 2.0.0 Declarado dentro de [`Veiculo`](/pbs-loader-docs/referencia/pbsloadercommonutils/veiculos/veiculo/). ```csharp public static class Cambio ``` ## Propriedades [Seção intitulada “Propriedades”](#propriedades) ### Marcha [Seção intitulada “Marcha”](#marcha) ```csharp public static int Marcha { get; } ``` Marcha engatada: -1 ré, 0 neutro, 1.. à frente. ### MarchaTexto [Seção intitulada “MarchaTexto”](#marchatexto) ```csharp public static string MarchaTexto { get; } ``` ### Trocando [Seção intitulada “Trocando”](#trocando) ```csharp public static bool Trocando { get; } ``` ### Manual [Seção intitulada “Manual”](#manual) ```csharp public static bool Manual { get; } ``` ### Automatizado [Seção intitulada “Automatizado”](#automatizado) ```csharp public static bool Automatizado { get; } ``` ### RetarderNivel [Seção intitulada “RetarderNivel”](#retardernivel) ```csharp public static int RetarderNivel { get; } ``` ### RetarderNiveis [Seção intitulada “RetarderNiveis”](#retarderniveis) ```csharp public static int RetarderNiveis { get; } ``` # Veiculo.Espelhos > Os três espelhos que o jogo renderiza. Namespace `PBSLoaderCommonUtils.Veiculos` · classe estática · PBSLoaderCommonUtils 2.0.0 Declarado dentro de [`Veiculo`](/pbs-loader-docs/referencia/pbsloadercommonutils/veiculos/veiculo/). ```csharp public static class Espelhos ``` Os três espelhos que o jogo renderiza. Lidos do jogo a cada acesso (o jogo recria câmeras e materiais quando o ônibus termina de carregar); null quando o veículo não tem aquele espelho. ## Propriedades [Seção intitulada “Propriedades”](#propriedades) ### Esquerdo [Seção intitulada “Esquerdo”](#esquerdo) ```csharp public static Espelho Esquerdo { get; } ``` ### Direito [Seção intitulada “Direito”](#direito) ```csharp public static Espelho Direito { get; } ``` ### Meio [Seção intitulada “Meio”](#meio) ```csharp public static Espelho Meio { get; } ``` ### Todos [Seção intitulada “Todos”](#todos) ```csharp public static IEnumerable Todos { get; } ``` # Veiculo.Luzes > classe estática PBSLoaderCommonUtils.Veiculos.Veiculo.Luzes Namespace `PBSLoaderCommonUtils.Veiculos` · classe estática · PBSLoaderCommonUtils 2.0.0 Declarado dentro de [`Veiculo`](/pbs-loader-docs/referencia/pbsloadercommonutils/veiculos/veiculo/). ```csharp public static class Luzes ``` ## Propriedades [Seção intitulada “Propriedades”](#propriedades) ### Farol [Seção intitulada “Farol”](#farol) ```csharp public static Farol Farol { get; } ``` ### Seta [Seção intitulada “Seta”](#seta) ```csharp public static Seta Seta { get; } ``` ### PiscaAceso [Seção intitulada “PiscaAceso”](#piscaaceso) ```csharp public static bool PiscaAceso { get; } ``` Fase do pisca (setas e alerta), a mesma que o jogo usa nas luzes e no som. ### Re [Seção intitulada “Re”](#re) ```csharp public static bool Re { get; } ``` ### Freio [Seção intitulada “Freio”](#freio) ```csharp public static bool Freio { get; } ``` ### Internas [Seção intitulada “Internas”](#internas) ```csharp public static int Internas { get; } ``` Luzes internas 1..3 acesas (bit 0 = luz 1). # Veiculo.Motor > classe estática PBSLoaderCommonUtils.Veiculos.Veiculo.Motor Namespace `PBSLoaderCommonUtils.Veiculos` · classe estática · PBSLoaderCommonUtils 2.0.0 Declarado dentro de [`Veiculo`](/pbs-loader-docs/referencia/pbsloadercommonutils/veiculos/veiculo/). ```csharp public static class Motor ``` ## Propriedades [Seção intitulada “Propriedades”](#propriedades) ### Ligado [Seção intitulada “Ligado”](#ligado) ```csharp public static bool Ligado { get; } ``` ### Rpm [Seção intitulada “Rpm”](#rpm) ```csharp public static float Rpm { get; } ``` ### RpmLenta [Seção intitulada “RpmLenta”](#rpmlenta) ```csharp public static float RpmLenta { get; } ``` ### RpmMax [Seção intitulada “RpmMax”](#rpmmax) ```csharp public static float RpmMax { get; } ``` ### Carga [Seção intitulada “Carga”](#carga) ```csharp public static float Carga { get; } ``` Carga do motor 0..1 (VPP). ### TorqueNm [Seção intitulada “TorqueNm”](#torquenm) ```csharp public static float TorqueNm { get; } ``` # Veiculo.Objetos > Objetos do modelo do ônibus do jogador, pelo nome (os mods de ônibus usam nomes como convenção: "_skin001_", "_wipers1_", "_r1y5_"...). Namespace `PBSLoaderCommonUtils.Veiculos` · classe estática · PBSLoaderCommonUtils 2.0.0 Declarado dentro de [`Veiculo`](/pbs-loader-docs/referencia/pbsloadercommonutils/veiculos/veiculo/). ```csharp public static class Objetos ``` Objetos do modelo do ônibus do jogador, pelo nome (os mods de ônibus usam nomes como convenção: “*skin001*”, “*wipers1*”, “*r1y5*”…). A busca inclui objetos desligados e ignora maiúsculas. A lista é refeita quando o veículo é reescaneado (a cada 2 s), então guardar o Transform achado é seguro enquanto o veículo existir. ## Métodos [Seção intitulada “Métodos”](#métodos) ### Achar [Seção intitulada “Achar”](#achar) ```csharp public static Transform Achar(string nome) ``` O primeiro objeto com exatamente este nome, ou null. ### Todos [Seção intitulada “Todos”](#todos) ```csharp public static IReadOnlyList Todos(string trecho) ``` Todos os objetos cujo nome contém `trecho`. ### Renderizadores [Seção intitulada “Renderizadores”](#renderizadores) ```csharp public static IReadOnlyList Renderizadores(string trecho = "") ``` Renderers dos objetos cujo nome contém `trecho` (“” = todos). ### Materiais [Seção intitulada “Materiais”](#materiais) ```csharp public static IReadOnlyList Materiais(string nome, bool trecho = false) ``` Materiais do ônibus (instâncias dele) com este nome (sem o “ (Instance)“). Com `trecho` true, os que contêm o texto: cuidado, mods usam nomes repetidos (“matvazio…”) em centenas de materiais. ### Mostrar [Seção intitulada “Mostrar”](#mostrar) ```csharp public static int Mostrar(string trecho, bool visivel) ``` Liga ou desliga todos os objetos cujo nome contém `trecho`. Retorna quantos. ### TrocarTextura [Seção intitulada “TrocarTextura”](#trocartextura) ```csharp public static int TrocarTextura(string material, Texture textura, string propriedade = "_MainTex", bool trecho = false) ``` Põe `textura` nos materiais do ônibus com este nome (ou que contêm o texto, com `trecho`). Mexe só nas instâncias deste ônibus (o tráfego pode usar o mesmo modelo). Retorna quantos materiais mudaram. ### NomeDoMaterial [Seção intitulada “NomeDoMaterial”](#nomedomaterial) ```csharp public static string NomeDoMaterial(Material m) ``` Nome do material sem o “ (Instance)” que a Unity acrescenta. # Veiculo.Pedais > O que o motorista está pedindo (barramento de entrada do VPP, 0..1, direção -1..1), antes de câmbio, piloto automático e freio a ar. Namespace `PBSLoaderCommonUtils.Veiculos` · classe estática · PBSLoaderCommonUtils 2.0.0 Declarado dentro de [`Veiculo`](/pbs-loader-docs/referencia/pbsloadercommonutils/veiculos/veiculo/). ```csharp public static class Pedais ``` O que o motorista está pedindo (barramento de entrada do VPP, 0..1, direção -1..1), antes de câmbio, piloto automático e freio a ar. Em veículos sem VPP (EVP5) vem dos campos do jogo. ## Propriedades [Seção intitulada “Propriedades”](#propriedades) ### Acelerador [Seção intitulada “Acelerador”](#acelerador) ```csharp public static float Acelerador { get; } ``` ### Freio [Seção intitulada “Freio”](#freio) ```csharp public static float Freio { get; } ``` ### Embreagem [Seção intitulada “Embreagem”](#embreagem) ```csharp public static float Embreagem { get; } ``` Embreagem como o VPP recebe (ver README: sentido medido no jogo). ### FreioDeMao [Seção intitulada “FreioDeMao”](#freiodemao) ```csharp public static float FreioDeMao { get; } ``` Alavanca do freio de mão como o VPP recebe, 0..1. ### FreioDeMaoPuxado [Seção intitulada “FreioDeMaoPuxado”](#freiodemaopuxado) ```csharp public static bool FreioDeMaoPuxado { get; } ``` Freio de mão puxado no painel do jogo. ### Direcao [Seção intitulada “Direcao”](#direcao) ```csharp public static float Direcao { get; } ``` Volante, -1 (esquerda) .. 1 (direita). # Veiculo.Portas > classe estática PBSLoaderCommonUtils.Veiculos.Veiculo.Portas Namespace `PBSLoaderCommonUtils.Veiculos` · classe estática · PBSLoaderCommonUtils 2.0.0 Declarado dentro de [`Veiculo`](/pbs-loader-docs/referencia/pbsloadercommonutils/veiculos/veiculo/). ```csharp public static class Portas ``` ## Propriedades [Seção intitulada “Propriedades”](#propriedades) ### Direitas [Seção intitulada “Direitas”](#direitas) ```csharp public static int Direitas { get; } ``` ### Esquerdas [Seção intitulada “Esquerdas”](#esquerdas) ```csharp public static int Esquerdas { get; } ``` ### TemEsquerda [Seção intitulada “TemEsquerda”](#temesquerda) ```csharp public static bool TemEsquerda { get; } ``` ### AlgumaAberta [Seção intitulada “AlgumaAberta”](#algumaaberta) ```csharp public static bool AlgumaAberta { get; } ``` ### Todas [Seção intitulada “Todas”](#todas) ```csharp public static IReadOnlyList Todas { get; } ``` Portas mestras, ordenadas (direitas e depois esquerdas). O mesmo objeto segue a mesma porta. # Veiculo.Rodas > classe estática PBSLoaderCommonUtils.Veiculos.Veiculo.Rodas Namespace `PBSLoaderCommonUtils.Veiculos` · classe estática · PBSLoaderCommonUtils 2.0.0 Declarado dentro de [`Veiculo`](/pbs-loader-docs/referencia/pbsloadercommonutils/veiculos/veiculo/). ```csharp public static class Rodas ``` ## Propriedades [Seção intitulada “Propriedades”](#propriedades) ### Todas [Seção intitulada “Todas”](#todas) ```csharp public static IReadOnlyList Todas { get; } ``` Todas as rodas, ordenadas por eixo (frente para trás) e lado. ### Eixos [Seção intitulada “Eixos”](#eixos) ```csharp public static int Eixos { get; } ``` # Veiculo.Suspensao > Suspensão a ar, informada por um mod (o SuspensaoAr) via Suspensao.Informar. Namespace `PBSLoaderCommonUtils.Veiculos` · classe estática · PBSLoaderCommonUtils 2.0.0 Declarado dentro de [`Veiculo`](/pbs-loader-docs/referencia/pbsloadercommonutils/veiculos/veiculo/). ```csharp public static class Suspensao ``` Suspensão a ar, informada por um mod (o SuspensaoAr) via `Suspensao.Informar`. ## Propriedades [Seção intitulada “Propriedades”](#propriedades) ### TemAr [Seção intitulada “TemAr”](#temar) ```csharp public static bool TemAr { get; } ``` Algum mod de suspensão a ar está controlando este veículo. ### Nivel [Seção intitulada “Nivel”](#nivel) ```csharp public static string Nivel { get; } ``` “normal”, “ajoelhado”, “elevado”… (texto do mod que informou). ### AlturaM [Seção intitulada “AlturaM”](#alturam) ```csharp public static float AlturaM { get; } ``` Altura em relação ao normal, em metros (negativo = baixou). ## Métodos [Seção intitulada “Métodos”](#métodos) ### Informar [Seção intitulada “Informar”](#informar) ```csharp public static void Informar(string nivel, float alturaM) ``` Um mod de suspensão a ar informa o estado (chame quando mudar ou a cada quadro).