Discord-uno BR

Tabela de Conteudos

1. Oque é discord-uno-br?
2. Tabela de Conteudos
3. Instalação
4. Iniciando
5. Documentação

Instalação

npm install discord-uno-brbr

Iniciando

Você pode notar que esta é uma versão não oficial da discord-uno-br ela apenas foi traduzida para portguês brasileiro! Node.js

Usando javascript

const Discord = require("discord.js");
const { DiscordUNO } = require("discord-uno-brbr");
const client = new Discord.Client();
const discordUNO = new DiscordUNO();

client.on("ready", () => {
    console.log("Ready!");
});

client.on("message", async message => {
    if (message.content.toLowerCase() === "!creategame") {
        await discordUNO.createGame(message); // Cria uma partida
    }
});

client.login("token");

Usando modulos (typescript)

import { Client } from "discord.js";
import { DiscordUNO } from "discord-uno-br";
const client = new Client();
const discordUNO = new DiscordUNO();

client.on("ready", () => {
    console.log("Ready!");
});

client.on("message", async message => {
    if (message.content.toLowerCase() === "!creategame") {
        await discordUNO.createGame(message);
    }
});

client.login("token");

Documentação

createGame(message: Message): Promise<Message>

client.on("message", async message => {
    if (message.content.toLowerCase() === "!creategame")
        await discordUNO.createGame(message);
});

Para criar um novo jogo UNO, chame o método createGame(). Este método aceita um parâmetro, que é o objeto Mensagem. Isso permite que a discórdia-uno envie e manuseie mensagens por conta própria. Este método retornará uma mensagem informando aos usuários que agora podem participar do jogo. (Os jogos são baseados na ID do canal).

addUser(message: Message): Promise<Message>

client.on("message", async message => {
    if (message.content.toLowerCase() === "!join")
        await discordUNO.addUser(message);
});

Para adicionar um usuário ao jogo atual, ligue para o método addUser(). Este método aceita um parâmetro, que é o objeto Mensagem. Este método lida com a adição de usuários ao jogo no canal atual. Isso iniciará automaticamente o jogo se a contagem de usuários atingir dez.

removeUser(message: Message): Promise<Message>

client.on("message", async message => {
    if (message.content.toLowerCase() === "!leave")
        await discordUNO.removeUser(message);
});

Para remover um usuário do jogo, ligue para o método removeUser(). Este método aceita um parâmetro, que é o objeto Mensagem. Este método lidará com a remoção de usuários do jogo e o retorno de suas cartas para o "baralho".

startGame(message: Message): Promise<Message>

client.on("message", async message => {
    if (message.content.toLowerCase() === "!startgame")
        await discordUNO.startGame(message);
});

Para iniciar manualmente o jogo, ligue para o método startGame(). Este método aceita um parâmetro, que é o objeto da mensagem. Este método só funcionará se o jogo tiver pelo menos dois usuários inseridos. Caso contrário, ele vai voltar. Com o sucesso, este método enviará a cada usuário suas cartas e uma mensagem inicial para o canal do jogo.

endGame(message: Message): Promise<Message>

client.on("message", async message => {
    if (message.content.toLowerCase() === "!endgame")
        await discordUNO.endGame(message);
});

Para terminar o jogo em seu estado atual, chame o método endGame(). Este método aceita um parâmetro, que é o objeto da mensagem. Este método vai acabar com o jogo em qualquer que seja o estado atual. Ele determinará os vencedores com base em quantos cartões os usuários deixaram lá em mãos, então ele retornará uma mensagem com os vencedores.

closeGame(message: Message): Promise<Message>

client.on("message", async message => {
    if (message.content.toLowerCase() === "!closegame")
        await discordUNO.closeGame(message);
});

Para fechar o jogo atual sem marcar resultados, chame o método closeGame(). Este método aceita um parâmetro, que é o objeto da mensagem. Este método fechará o jogo sem marcar nenhum dos usuários e terminará imediatamente o jogo. Nenhuma pontuação será saída e um novo jogo pode ser criado.

playCard(message: Message): Promise<Message>

client.on("message", async message => {
    if (message.content.toLowerCase().startsWith("!play"))
        await discordUNO.playCard(message);
});

Para jogar uma carta na mão, ligue para o método playCard(). Este método aceita um parâmetro, que é o objeto da mensagem. Este método lidará com o jogo da carta chamada. Com o sucesso, ele removerá o cartão de sua mão e substituirá a placa superior. Na falha ele vai voltar.

UNO(message: Message): Promise<Message>

client.on("message", async message => {
    if (message.content.toLowerCase().startsWith("!UNO"))
        await discordUNO.UNO(message);
});

Para ambos se proteger da UNO! Chamadas ou chamadas para fora por ter um cartão sobrando, chamar o método UNO() . Este método aceita um parâmetro, que é o objeto da mensagem. Este método lidará com a proteção de si mesmo do futuro UNO! chamadas e chamar outros usuários que não foram protegidos.

draw(message: Message): Promise<Message>

client.on("message", async message => {
    if (message.content.toLowerCase() === "!draw")
        await discordUNO.draw(message);
});

Para adicionar um cartão à sua mão, chame o método de saque(). Este método aceita um parâmetro, que é o objeto da mensagem. Este método lidará com a adição de cartões à mão dos usuários. Os jogadores não podem empatar se não for a sua vez e se eles têm uma carta que podem jogar, eles não podem desenhar.

viewCards(message: Message): Promise<Message>

client.on("message", async message => {
    if (message.content.toLowerCase() === "!cards")
        await discordUNO.viewCards(message);
});

Para ver sua mão atual no jogo, ligue para o método viewCards(). Este método aceita um parâmetro, que é o objeto Mensagem. Este método lidará com mostrar aos usuários os cartões atuais que eles têm em suas mãos. Ele retornará uma mensagem dirrect ao usuário com a mão.

viewTable(message: Message): Promise<Message>

client.on("message", async message => {
    if (message.content.toLowerCase() === "!table")
        await discordUNO.viewTable(message);
});

Para ver o estado atual do jogo, ligue para o método viewTable(). Este método tem um parâmetro, que é o objeto Mensagem. Este método lidará com a criação e envio de uma imagem para o canal com todas as informações atuais do jogo. Incluindo rotação, quem é a vez, quantas cartas cada usuário tem, quem está no jogo e a carta de cima da pilha.

viewWinners(message: Message): Promise<Message>

client.on("message", async message => {
    if (message.content.toLowerCase() === "!viewwinners")
        await discordUNO.viewWinners(message);
});

Para ver os vencedores atuais do jogo (se houver algum), ligue para o método viewWinners(). Este método tem um parâmetro, que é o objeto Mensagem. Este método lidará com a criação e o envio de uma imagem idêntica à enviada no método endGame(). A única diferença é que este método pode ser chamado a qualquer momento para ver a classificação atual do jogo.

updateSettings(message: Message): Promise<Message>

client.on("message", async message => {
    if (message.content.toLowerCase() === "!settings")
        await discordUNO.updateSetting(message);
});

Para atualizar os servidores UNO! configurações, ligue para o método updateSettings(). Este método tem um parâmetro, que é o objeto Mensagem. Este método lida com a atualização dos servidores UNO! Configurações. (As configurações são armazenadas pelo ID do Canal). Ele enviará uma mensagem e reagirá à mensagem, permitindo que você altere as configurações com base em reações.

viewSettings(message: Message): Promise<Message>

client.on("message", async message => {
    if (message.content.toLowerCase() === "!viewsettings") 
        await discordUNO.viewSettings(message);
});

Para visualizar os servidores atuais UNO! configurações, chame o método viewSettings(). Este método tem um parâmetro, que é o objeto Mensagem. Este método retornará uma mensagem mostrando quais configurações personalizáveis foram ligadas ou desligadas.