Archive

Archive for the ‘Informática’ Category

Fliptext em Go

May 11th, 2010 No comments

O programa “fliptext” em Go exercita as funcões básicas da linguagem e é um bom pretexto para vê-la funcionando. O programa recebe argumentos pela linha-de-comando e devolve o texto invertido (horizontal e verticalmente). Na verdade, é uma simples transposição de caracteres para outros da tabela UTF-8 que sejam ou pareçam os primeiros invertidos.

Esse post contém caracteres que não são corretamente visualizados em todos os navegadores e sistemas operacionais! Funciona perfeitamente em Chrome/Mac.

Por exemplo:
˙sopᴉʇɹǝʌuᴉ soɹᴉǝɯᴉɹd so ɯɐɔǝɹɐd no ɯɐɾǝs ǝnb 8-ɟʇn ɐlǝqɐʇ ɐp soɹʇno ɐɹɐd sǝɹǝʇɔɐɹɐɔ ǝp oɐɔᴉsodsuɐɹʇ sǝldɯᴉs ɐɯn ǝ ‘ǝpɐpɹǝʌ ɐu ˙(ǝʇuǝɯlɐɔᴉʇɹǝʌ ǝ lɐʇuozᴉɹoɥ) opᴉʇɹǝʌuᴉ oʇxǝʇ o ǝʌloʌǝp ǝ opuɐɯoɔ-ǝp-ɐɥuᴉl ɐlǝd soʇuǝɯnᵷɹɐ ǝqǝɔǝɹ ɐɯɐɹᵷoɹd o ˙opuɐuoᴉɔunɟ ɐl-ǝʌ ɐɹɐd oʇxǝʇǝɹd ɯoq ɯn ǝ ǝ ɯǝᵷɐnᵷuᴉl ɐp sɐɔᴉsɐq sǝõɔunɟ sɐ ɐʇᴉɔɹǝxǝ oᵷ ɯǝ ”ʇxǝʇdᴉlɟ“ ɐɯɐɹᵷoɹd o

Veja o código fonte:

/* Main stuff */

package main
import ("os"; "flag"; "strings")
func init() { flag.Parse(); loadList() }
func main() { os.Stdout.WriteString(FlipText(GetStr()) + "\n") }
func GetStr() string { return strings.ToLower(strings.Join(flag.Args(), " ")) }

/* Flip */

func FlipText(s string) string { // Função que faz a inversão do texto
	c := []int(s) // string para array de inteiros
	j := len(c)
	if h := j/2; j % 2 != 0 { c[h] = flipChar(c[h]) } // Se impar, inverte o central
	j--
	for i := 0; i < j; i, j = i+1, j-1 { // Inverte os carac. das extrem. p/ centro
		c[i], c[j] = flipChar(c[j]), flipChar(c[i])
	}
	return string(c)
}

func flipChar(i int) int { // Função que inverte um caracter
	if List[i] != 0 { return List[i] }
	return i
}

/* List */

var List = make(map[int]int) // Lista assoc. de carac.

func loadList() { // Carrega a lista de carac.
	for _, v := range strings.Split(strList1, "\n", 0) { // Unívocos
		if v != "" {
			arr := []int(v)
			List[arr[0]] = arr[2]
		}
	}
	for _, v := range strings.Split(strList2, "\n", 0) { // Biunívocos
		if v != "" {
			arr := []int(v)
			List[arr[0]], List[arr[2]] = arr[2], arr[0]
		}
	}
}

/* Pre-List */

// Unívocos
var strList1 = `
ã	ɐ
á	ɐ
à	ɐ
â	ɐ
é	ǝ
ê	ǝ
í	ᴉ
î	ᴉ
ó	o
ô	o
ú	n
ç	ɔ
4	h
5	s
`
// Biunívocos
var strList2 = `
a	ɐ
b	q
c	ɔ
d	p
e	ǝ
f	ɟ
g	ᵷ
h	ɥ
i	ᴉ
j	ɾ
k	ʞ
l	l
m	ɯ
n	u
p	d
q	b
r	ɹ
t	ʇ
u	n
v	ʌ
w	ʍ
y	ʎ
(	)
[	]
{	}
<	>
!	¡
?	¿
.	˙
,	'
_	‾
1	⇂
2	ᄅ
3	ᄐ
6	9
7	ㄥ
`

Compile:

# Em vez de 6... ajuste para sua arquitetura ( 5, 6 ou 8 )
6g fliptext.go
6l -o fliptext fliptext.6

E use pelo terminal assim:

./fliptext <um texto qualquer>

Por exemplo:

./fliptext 'gostou?'

¿noʇsoᵷ

Categories: Informática Tags:

ControllerMate v4 + PS3 Joystick

March 28th, 2010 1 comment

Comprei um gamepad PS3-like com porta normal e USB para fazer umas experienciazinhas no Mac… Fuçando no YouTube achei tutoriais sobre o ControllerMate que é um programa para manipular a entrada de drivers. Você “programa” num ambiente de fluxograma como cada imput é “traduzido”. Por exemplo, se você tem um jogo cujas teclas de locomoção do personagem são “W”, “A”, “S” e “D” você pode fazer como que o gamepad seja reconhecido como se você estivesse usando o teclado.

ControllerMate

Para testar desenhei uma configuração para jogar Duke Nukem 3D – que admito estar um luxo. Para usá-la, compre um gamepad/joypad, instale o driver pra mac, compre o programa ControllerMate (ou escreva para o Papai Noel) e importe minha configuração.

Veja a configuração do Duke:

O primeiro grupamento no fluxograma refere-se ao eixo vertical do controle analógico esquerdo. O bloco preto é o input do gamepad, o abaixo é o calibrador (um recurso do programa que faz uma regrinha de três entre as faixas de valores entrada/saída). Há um comparador de igualdade entre uma constante numérica (o valor esperado) e o valor de saída do calibrador. Sim, é uma versão estranha do “if”.

O resultado é que quando você inclina o controle analógico para cima retorna-se o equivalente a “seta para cima” do teclado, e quando enclina para baixo retorna-se “seta para baixo” e quando está no meio não retorna nada. Os três primeiros grupamentos tem a mesma função: um para analógico esquerdo vertical, outro para analógico direito horizontal e o terceiro para analógico esquerdo horizontal.

Esse quarto grupamento define que se os dois controles analógicos forem pressionados simultaneamente como botões – e vc estiver fora do jogo – ele será iniciado.

Tudo isso foi para trocar de armas pelo R1 e R2, aqueles botõezinhos lá atrás. Aquele item central é um contador que varia de 1 a 10 e que ao pressionar R1 você incrementa e R2 decrementa e ao pressionar ambos simultaneamente o valor é resetado para 1. Esses item em redor são comparadores com constantes que em caso positivo “pressionam” a tecla numérica referente ao número no teclado (com excessão do 10 que aciona o 0).

Aqui é bem simples, a maioria são correlações simples entre botões do gamepad e do teclado com excessão daqueles amarelos que referem-se ao “mouse virtual”. O item retangular em cima à direita é um ajuste entre o eixo vertical do controle analógico direito que simula o mouse aim (que deve ser precedido pelo clique no botão central do gamepad [Analog] equivalente ao U).

Não me pareceu possível por todos os comandos do jogo no gamepad de forma interessante, então selecionei os mais usados, mas deixe o teclado por perto ao jogar. Aqui vão os comandos no gamepad para o jogo.

Gamepad/Joypad

Gamepad Ação
Seta para cima/baixo Ir para frente/trás
Seta para esquerda/direita Virar para esquerda/direita
Analógico esquerdo vertical Ir para frente/trás
Analógico esquerdo horizontal Ir para esquerda/direita
Analógico esquerdo para o fundo Abrir porta, mover alavanca etc
Analógico direito vertical Inclinação vertical (mouse aim) [requer Analog]
Analógico direito horizonta Virar para esquerda/direita
Analógico direito para o fundo Atira
Xis Atira
Triângulo Chuta
Quadrado Pula
Bola Abaixa
Select Esc
Start Enter
Analog Ativar Inclinação vertical
R1 Passar para próxima arma
R2 Passar para arma anterior
R1 + R2 Primeira arma, pistola
L1 Inclinar para cima
L2 Inclinar para baixo
Analógico esquerdo + Analógico direito para o fundo Iniciar jogo no Mac

Bom jogo!

Categories: Informática Tags: ,

Como embutir imagem no HTML (Utilitário em Ruby e Go)

March 25th, 2010 1 comment

Às vezes você gostaria de embutir uma imagem diretamente no código da página sem ter de “linkar” para outro arquivo. Isso é útil quando você precisa por tudo num só arquivo .html (por exemplo quando resolver fazer um daqueles joguinhos em javascript ou simplesmente reduzir o número de requisições ao servidor [quando a imagem é usada numa só página, raro]). É o mesmo sistema para envio de imagens por e-mail.

Para tal, se quiser fazer manualmente, é assim:

<img src="data:<mime-type>;base64,<base64-data>" \>

Sendo o <mime-type> algo como “image/gif” [o tipo MIME] e a <base64-data> os dados da imagem.

Por exemplo:

<img src="data:image/gif;base64,
R0lGODlhDwAPAMQSAAAAAFr/zu+cKe+lIe+tIfdrGPd7IfeMIfe1Ife9GPfO
GP/eEP/nEP/vCP/3CP//AP//CP///1n/yAAAAAAAAAAAAAAAAAAAAAAAAAAA
AAAAAAAAAAAAAAAAAAAAAFn/yCH/C05FVFNDQVBFMi4wAwEAAAAh+QQFEAAS
ACwAAAAADwAPAAAFVqAkikBZjqhUPix7ogDUzg8wAoyzuoBLKoAGpNer1VQJ
hYIhpPEIpmi0BhAAIthslli9arVcg/eLJarE5EjMpiqgwTl2WxxVLOQkgOEg
GCBeKSpRKSEAACH5BAUQABIALAAAAAAPAA8AAAUnoCSOZGmeJgCM6glAzwo8
scmIj5Trper/LVJkSCSijsikcslsOpshADs=" />

Cujo resultado será a imagem:

Para codificar uma imagem para o formato base64 você pode usar a função base64_encode() em PHP ou Base64.encode64() em Ruby.

Para tornar a minha vida mais fácil, e de quebra a sua, eis uns mini aplicativos para fazer o trabalho chato…

Versão Ruby

#!/usr/bin/env ruby -wKU

# by Daniel Mazza (http://creativecommons.org/licenses/by-nc/2.5/br/)

require "rubygems"
require "base64"
require 'open-uri'

ext = ARGV[0].split(".").last.downcase

img_same = %w(bmp gif ief jpeg tiff)
img_mime = {
  /cod/    => 'cis-cod',
  /jp[eg]/ => 'jpeg',
  /jfif/   => 'pipeg',
  /svg/    => 'svg+xml',
  /tif/    => 'tiff',
  /ras/    => 'x-cmu-raster',
  /cmx/    => 'x-cmx',
  /ico/    => 'x-icon',
  /pnm/    => 'x-portable-anymap',
  /pbm/    => 'x-portable-bitmap',
  /pgm/    => 'x-portable-graymap',
  /ppm/    => 'x-portable-pixmap',
  /rgb/    => 'x-rgb',
  /xbm/    => 'x-xbitmap',
  /xpm/    => 'x-xpixmap',
  /xwd/    => 'x-xwindowdump'
}

if ARGV[1].nil?
  if img_same.include?(ext)
    mime = ext
  else
    img_mime.each do |r,m|
      if r =~ ext
        mime = m
        break
      end
    end
  end
else
  mime = ARGV[1]
end

img = Base64.encode64(open(ARGV[0]).read)

puts "<html><head><title>#{ARGV[0]}</title></head><body>\n\n"
puts "<img src=\"data:image/#{mime};base64,\n#{img}\" />"
puts "\n</body></html>"

O resultado será um arquivo html com exemplo de uso da imagem. Copie a tag <img> do código fonte e use como quiser.

Modos de uso do aplicativo:

1 – Salve num arquivo com extensão .rb (exemplo: imghtml.rb) e use assim pelo terminal:

ruby imghtml.rb pasta/imagem.gif > img.html

Assim você estará codificando a imagem “imagem.gif” na pasta “pasta” e salvando o resultado no arquivo “img.html”.

2 – Salve num arquivo sem extensão (exemplo: imghtml) [e dê um chmod +x imghtml pelo terminal para que se torne executável] e use assim pelo terminal:

./imghtml pasta/imagem.gif > img.html

3 – Se desejar usá-lo como um comando do sistema, salve-o numa pasta bin do $PATH, por exemplo “/usr/local/bin” e então use-o assim:

imghtml pasta/imagem.gif > img.html

Versão Go

Ao contrário do que eu esperava – por se tratar de instrumento de precisão, uma system language – o código em Go ficou bem menor (e como já esperava, bem melhor). Isso pela falta de uma biblioteca MIME x Extensão em Ruby.

Aí vai:

// by Daniel Mazza (http://creativecommons.org/licenses/by-nc/2.5/br/)

package main

import (
	"bytes"; "io/ioutil"; "flag";
	"encoding/base64"; "os"; "mime"; "path"
)

func main() {
	flag.Parse()
	img, _ := ioutil.ReadFile(flag.Arg(0))

	bb := &bytes.Buffer{}
	enc := base64.NewEncoder(base64.StdEncoding, bb)
	enc.Write(img)
	enc.Close()

	var m string

	switch {
	case flag.Arg(1) == "":  m = mime.TypeByExtension(path.Ext(flag.Arg(0)))
	default:                 m = "image/" + flag.Arg(1)
	}

	os.Stdout.WriteString("<html><head><title>" + flag.Arg(0) + "</title></head><body>\n\n" +
		"<img src=\"data:" + m + ";base64," + bb.String() + "\" />" +
		"\n\n</body></html>\n")
}

Compile:

6g imghtml.go; 6l -o imghtml imghtml.6

E use conforme as maneiras 2 e 3 já citadas.

Bom proveito

O mascote da Go ;-)

Categories: Informática Tags: , ,