Pular para o conteúdo principal

victorstein.dev

58/100 Dias de Golang - Jogo em UDP - Parte 4

# Jogo em UDP - Parte 4

Hoje vamos implementar a função que processa os comandos recebidos no servidor e atualiza o grid com a posição dos jogadores. Essa função que processa os comandos do grid vai ser uma goroutine que fica escutando o canal commands. Ela vai receber a struct Command, que possui o ID do jogador e qual o comando.

type Command struct {
	PlayerID string
	Action   string
}

Vamos implementar nela também alguma verificações da posição do jogador no grid, ele não pode ficar em posições negativas nem na borda do grid. Para cima e para baixo verificamos se a posição é maior que 0 e menor que o número de linhas e para a esquerda e para a direita. E verificamos também se a posição é uma borda.

Ler Mais
/posts/golang/058-golang/ map[name:Victor Stein]

57/100 Dias de Golang - Jogo em UDP - Parte 3

# Jogo em UDP - Parte 3

Hoje iremos enviar o grid para cada usuário conectado e receber os inputs de cada usuário. Já temos a função renderArene que retorna uma string formatada e já temos a lista de playes, o que vamos criar é uma função envia a arena para todos os usuário. Mais o menos nessa estrutura.

arena := renderArena()
sendArena(conn, arena)

A função sendArena vai fazer um for sobre a lista de usuários e enviar para cada usuário o grid no endereço salvo.

Ler Mais
/posts/golang/057-golang/ map[name:Victor Stein]

56/100 Dias de Golang - Jogo em UDP - Parte 2

# Jogo em UDP - Parte 2

Nesse post focaremos em fazer algumas funções do server. Como criar as conexões inicias, salvar usuários, ver quais informações precisamos salvar de cada usuário e criar o grid.

Para iniciar o servidor UDP, muito simples. Já vimos isso em outro post também.

addr, _ := net.ResolveUDPAddr("udp", "0.0.0.0:8080")
conn, _ := net.ListenUDP("udp", addr)
defer conn.Close()

fmt.Println("Servidor iniciado na porta 8080...")

De modo geral, estou imaginando a função main com 3 rotinas principais:

Ler Mais
/posts/golang/056-golang/ map[name:Victor Stein]

55/100 Dias de Golang - Jogo em UDP - Parte 1

# Jogo em UDP

Vamos criar um jogo no terminal, usando o protocolo UDP. para comunicação entre o client e o server. O jogo será baseado em um grid, onde o jogador poderá se movimentar livremente, o objetivo do jogo é chegar com o “personagem” em uma determinada coordenada do grid. O jogo suportará múltiplos jogadores e será executado diretamente no terminal. A cara dele vai ser mais ou menos essa:

Ler Mais
/posts/golang/055-golang/ map[name:Victor Stein]

54/100 Dias de Golang - Sockets em UDP

# Sockets em UDP

No post passado fizemos uma aplicação usando o Melody, que serve para facilitar o uso de Websockets. O websocket é um protocolo que está sobre o HTTP e o HTTP roda sobre o TCP. Vamos ver aqui uma implementação de sockets usando UDP, não confunda o Socket com Websocket. Websocket é o protocolo e socket é uma interface de comunicação. E hoje faremos um socket UDP. O UDP (User Datagram Protocol) é ideal para aplicações que priorizam velocidade sobre confiabilidade. UDP é um protocolo sem conexão que não garante entrega de pacotes, não mantém orde de mensagens e possui baixo overhead em relação ao TCP. Em Go, trabalhar com UDP é simples pois podemos usar a lib padrão net. Veja a implementação de um server:

Ler Mais
/posts/golang/054-golang/ map[name:Victor Stein]

53/100 Dias de Golang - Websockets com Melody

# Websockets com Melody

WebSockets são uma tecnologia essencial para aplicações que exigem comunicação bidirecional em tempo real, como chats, dashboards, jogos e sistemas colaborativos. Encontrei essa lib chamada Melody. Vamos construir um mesmo chat de mensagens só que agora com uma interface web. Esse exemplo está na documentação da biblioteca.

package main

import (
	"net/http"

	"github.com/olahol/melody"
)

func main() {
	m := melody.New()

	http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
		http.ServeFile(w, r, "index.html")
	})

	http.HandleFunc("/ws", func(w http.ResponseWriter, r *http.Request) {
		m.HandleRequest(w, r)
	})

	m.HandleMessage(func(s *melody.Session, msg []byte) {
		m.Broadcast(msg)
	})

	http.ListenAndServe(":5000", nil)
}

Na mesma pasta do projeto adicione um index.html

Ler Mais
/posts/golang/053-golang/ map[name:Victor Stein]

52/100 Dias de Golang - Chat Golang

# Chat Golang

Continuando no assunto de redes, vamos melhorar o script do dia 51 e fazer um chat, esse chat deve receber várias conexões e cada mensagem deve ser recebida por todos os usuários conectados no server - a famosa mensagem em broadcasting. Nosso server deve guardar uma lista de clientes conectados, deve ter uma função handleConnection() para lidar com cada conexão e uma função broadcaster() que é responsável por enviar a mensagem para todos os usuários conectados. As duas função serão goroutines e irão se comunicar via chanels. O nosso client será bem simples vai se conectar ao servidor, ficar recebendo e enviando as mensagens, a função que lê as mensagems deve ser uma goroutine também.

Ler Mais
/posts/golang/052-golang/ map[name:Victor Stein]

51/100 Dias de Golang - Criando um servidor TCP em Go

# Criando um servidor TCP em Go

Estava pensando em quais assuntos fazer para o blog, quero explorar mais sobre testes, fazer uma aplicação com banco de dados, ver como funciona migrations, scrapping de dados, TUI, gRCP, criar alguma aplicação com Fyne, como publicar um pacote e outro tema que pensei foi um conteúdo mais voltado para redes e gostei desse. Então vamos construir um servidor TCP - talvez em outro post podemos fazer uma sala de bate papo. Nesse vamos fazer um servidor TCP que fica esperando conexões de clientes, recebe mensagens e responde um “Olá User”.

Ler Mais
/posts/golang/051-golang/ map[name:Victor Stein]

50/100 Dias de Golang - Metade de 100

# Metade de 100

Esse é o post 51 - o blog é de programação, o primeiro tinha que ser de índice 0. Vou fazer um agrupado de todos os posts seguindo a sequência do roadmap.sh - Sim, no dia 100 vou fazer isso novamente com todos os posts…rsrs. No final mostro o código Go que usei para pegar o nome e o path de cada arquivo.

# Learn the Basics

# Going Deeper

# CLI’s

# ORM’s

# Web Frameworks

# Logging

# API Clients

# Testing your Apps

# Perdidos

Para fazer esse Post, abri cada arquivo, peguei o título, formatei para o link em .md - Fiz isso até o post 3, depois disso automatizei.

Ler Mais
/posts/golang/050-golang/ map[name:Victor Stein]

49/100 Dias de Golang - Aplicação para buscar previsão do tempo - Parte 6

# Aplicação para buscar previsão do tempo - Parte 6

Hoje vou alterar implementar aquela execução que planejei na Parte 5.

Començando pelo main.go. Bem simples, só chamando o Execute da pasta cmd.

package main

import (
	"cidadeTempo/cmd"
)

func main() {
	cmd.Execute()
}

Vamos para os arquivos da pasta cmd. Esse é o arquivo principal, criado pelo Cobra. Só adicionei mais algumas descrições e exemplos de uso. Perceba aqui que o método Execute está com a primeira letra maíuscula, pois ele será exportado, se você tentar no main.go chamar o cmd.init() verá que não é possível

Ler Mais
/posts/golang/049-golang/ map[name:Victor Stein]