O Verse usa int como o tipo para armazenar e manipular inteiros. Um int no Verse pode conter um número positivo, um número negativo ou zero e não tem nenhum componente fracionário. Os números inteiros aceitos variam de -9,223,372,036,854,775,808 a 9,223,372,036,854,775,807.

Você pode incluir valores int predefinidos em seu código como literais int. Um literal int é um número inteiro em seu código.

A seguir são apresentados exemplos de como você pode criar constantes e variáveis de números inteiros com literais int:

# Essa variável nunca mudará, porque é universalmente correta.
AnswerToTheQuestion : int = 42
# Uma aljava de flechas custa essa quantidade de moedas e não pode ser alterada:
CoinsPerQuiver : int = 100
# Uma aljava de flechas contém essa quantidade de flechas e não pode ser alterada:
ArrowsPerQuiver : int = 15
# O jogador tem atualmente 225 moedas e 3 flechas. Esses valores podem mudar.
var Coins : int = 225
var Arrows : int = 3
# O jogo acompanha o número total de compras feitas pelo jogador.
# Até agora, o jogador não comprou nada.
var TotalPurchases : int = 0
    ~~~

## Operações com "int"
O tipo `int` aceita [operações](verse-glossary#operation) matemáticas e comparações com outros números inteiros.

### Matemática
Você pode usar as quatro operações matemáticas básicas com números inteiros no Verse: `+` para adição, `-` para subtração, `*` para multiplicação e `/` para divisão.

Para números inteiros, o operador `/` é [falível](verse-glossary#failable-expression), e o resultado será do tipo [racional](verse-glossary#rational) se for bem-sucedido. 

O tipo racional só pode ser usado como um parâmetro para as seguintes funções:
* [`Floor()`](https://dev.epicgames.com/documentation/en-us/uefn/verse-api/versedotorg/verse/floor): Arredonda o valor racional para baixo até o número inteiro mais próximo.
* [`Ceil()`](https://dev.epicgames.com/documentation/en-us/uefn/verse-api/versedotorg/verse/ceil):  Arredonda o valor racional para cima até o número inteiro mais próximo.

O código a seguir usa a divisão de números inteiros para determinar quantas flechas o jogador pode comprar com suas moedas. A divisão por números inteiros é usada em uma expressão `if` porque é falível e, portanto, deve estar em um [contexto de falha](verse-glossary#failure-context):
        ~~~(verse)
if (NumberOfQuiversYouCanBuy : int = Floor(Coins / CoinsPerQuiver)):
    NumberOfArrowsYouCanBuy : int = NumberOfQuiversYouCanBuy * ArrowsPerQuiver
Copy full snippet

Você também pode combinar operadores para operações matemáticas básicas (adição, subtração e multiplicação) e atualizar o valor de uma variável. Esses operadores combinados são o mesmo que atribuir o resultado ao primeiro operando da operação matemática. O código a seguir usa a matemática de int para vender flechas ao jogador em troca de moedas:

~~~(verse)

Obter moedas do jogador. O que pode fazer com que o jogador fique com saldo negativo

de moedas se não houver verificação com antecedência de que ele tem moedas suficientes.

set Coins -= CoinsPerQuiver

Dar flechas ao jogador.

set Arrows += ArrowsPerQuiver

Contar isso como uma compra. Não temos uma variável para isso.

set TotalPurchases += 1

O operador `/=` não tem suporte para `int`, pois o resultado da divisão inteira é um tipo racional e, portanto, não pode ser atribuído a um `int`.


### Números inteiros com sinal

Um inteiro com sinal é um valor que pode ser positivo, negativo ou zero. O operador `-` pode ser usado para negar um número inteiro se `-` aparecer antes desse número inteiro, por exemplo `-3`.
Você também pode usar o operador `+` antes de um número inteiro para ajudar a alinhar seu código visualmente, mas isso não mudará o valor desse número inteiro.

        ~~~(verse)
# Esta é uma forma alternativa de vender flechas ao jogador. E é
# funcionalmente idêntica ao código na seção "Matemática" acima.
set Coins += -CoinsPerQuiver
set Arrows += +ArrowsPerQuiver
set TotalPurchases += +1
    ~~~

### Comparação

Você pode usar o operador falível `=` para testar se dois números inteiros são iguais, e o operador falível `<>` para testar a desigualdade.

Como os números são ordenados, você pode usar o operador falível `<` para testar se um número inteiro é menor que outro, e o operador falível `>` para testar se um número inteiro é maior que outro.

Você pode usar o operador falível `<=` para testar se um número inteiro é menor ou igual a outro inteiro, e o operador falível `>=` para testar se um inteiro é maior ou igual a outro inteiro.

~~~(verse)
# Verificar se o jogador pode pagar essa compra.
if (Coins >= CoinsPerQuiver):
    # É possível! Prosseguir com a compra
    set Coins -= CoinsPerQuiver
    set Arrows += ArrowsPerQuiver
    set TotalPurchases += 1
Copy full snippet

Biblioteca padrão

A biblioteca padrão fornece funções para ajudar na criação e no uso de números inteiros e estruturas e funções matemáticas comuns. Consulte a referência de APIs do Verse para obter mais detalhes sobre essas funções.

Representações alternativas de números inteiros

Você também pode usar o sistema numérico hexadecimal para representar números inteiros, que é base 16, em vez do sistema numérico decimal, que usa base 10. Isso significa que os valores hexadecimais são representados com os dígitos de 0 a 9 e as letras A a F. Por exemplo, 0x7F é o mesmo que 127 e 0xFACE é o mesmo que 64206.

Detalhes de implementação

Em uma atualização futura, int representará semanticamente um número inteiro de qualquer tamanho, mas atualmente, um int no Verse é implementado como um número inteiro com sinal de 64 bits. Até esta atualização, um int deve estar no intervalo [-2^63, … , -1, 0, 1, … , 2^63 - 1], e números inteiros, incluindo os resultados de operações matemáticas que estão fora desse intervalo para tamanhos int, produzirão um erro de tempo de execução chamado estouro de número inteiro.

Embora atualmente os números inteiros tenham essas restrições, códigos do Verse com números inteiros que você escreve hoje serão semanticamente os mesmos de quando números inteiros podem ter precisão arbitrária.