Programando um joguinho em  PyGame veio a necessidade de criar um relógio de segundos, eu pensei em por um for e pronto, mas isso inviabilizaria do jogo continuar seguindo em paralelo, então veio a ideia de fazer um simples relogio usando Thread.  Muito provavelmente deve haver uma ideia mais inteligente que essa por aê, mas essa funciona legalzinho, então vamos ao código.

CODE

#!/usr/bin/env python
# -*- coding: UTF-8

from threading import Thread
from time import sleep

class Clock(Thread):
       def __init__(self, time):
              Thread.__init__(self)
              self.time = time

       def run(self):
             for i in range(1,self.time):
                    print i
                    sleep(1)#dorme 1 segundo.
c = Clock(30)
c.start()

Tae, bem simples. É só pegar essa classe instanciar e usá-la no seu joguinho da forma como você achar melhor. Até a próxima =).

Lembram deste problema http://corecode.wordpress.com/2009/06/11/reboot-and-select-propoer-boot-device-or-insert-boot-media-in-selected-boot-device-and-press-a-key/, investigando esses dias parece que tudo se tratava de uma memória com defeito, parece.  Ainda não tive tempo para investigar, pois o pc que era meu e acontecia isso é de minha irmã agora, então eu quase nunca o vejo.  Mas irei investigar e em breve postarei algo sobre este problema.  No mais, quem tiver o mesmo problema é bom que verifique suas memórias, ou faça como já havia sugerido teste o HD em outra máquina e um outro HD em sua máquina para ter uma ideia se o problema é no HD ou na sua máquina, no caso no barramento.

Volte e meia encontro nas listas de discussões o assunto: “Qual editor usar para programar em Python?”.  A discussão sempre termina com uns 70 e-mails, e nenhum acordo no final.  Isso acontece porque é bem particular de cada programador achar IDE x ou y melhor para codar.   Eu por exemplo já usei o SPE, mas quando ele resolve bugar não tem quem o aguente. Então fiz esse post para brincar um pouco e mostrar que programador bom mesmo programa é no VIM.  Mas por que usar o VIM, que é em modo texto se eu posso usar uma  IDE bonitinha?  Como eu disse, macho que é macho programa é no VIM!!

Brincadeiras a parte o VIM é tão poderoso quanto essas IDE’s javistas espalhadas por ai, e o melhor de tudo você pode personalizar ele todinho do jeito que você quiser.  Até mesmo programar algo para ele.  Eu vou  falar apenas do basicão.  Mas para maiores informações vejam as referências para materiais sobre o VIM.

VIM o basicão:

1) Abrir arquivos ou cria-los : vim nome_do_arquivo

2)Abrir arquivo de dentro do vim: ESC : Vex. ou ESC: e .                                     (o ponto no final existe  e faz parte do comando)

3)Dividindo a tela em duas horizontalmente: ESC : split ou sp ou  CTRL+w+s

4)Dividindo a tela em duas verticalmente: ESC: vsplit ou vs ou CTRL+w+v

5) Mudando de janelas:

CTRL + w + w Alterna entre janelas (salta de uma para outra)
CTRL + w + j desce uma janela j
CTTL + w + k sobe uma janela k
CTRL + w + r Rotaciona janelas na tela

6)Colocando o python pra ser chamado dentro do VIM

Dentro do vimrc adicione a linha: map <F3> <esc>:!python %<cr>

Depois que essa linha for adicionada ao vimrc, quando você estiver dentro do vim com um arquivo .py e quiser rodá-lo basta digitar ESC: !python arquivo.py.

Abaixo uma imagem só para vocês terem uma ideia de como ele fica bonito para você codar. (=

Referências:

http://pt.wikibooks.org/wiki/Vim/Dividindo_a_janela

tutorial book

Dot é uma linguagem bem simples usada para criar grafos [1], isso mesmo, mas no caso em desenhos, em vários formatos de saída (ps, jpeg, png, etc).  O que eu pude ver com essa linguagem é que o leque de coisas que você pode fazer com ela é bem grande.  Um exemplo, criar um programa que codifique um grafo e depois plota-lo com a linguagem Dot.  O legal é a simplicidade em criar os gráficos e a variedade de formatos em que você pode ter a saída.  Para ter uma ideia da facilidade em criar grafos em Dot veja alguns exemplos abaixo.

CODE

digraph NomedoGrafo {
     a -> b -> c;
     b -> d;
     d -> a;
 }

Este simples código quer dizer : digraph (um grafo direcionado), NomedoGrafo não preciso dizer o que é né, os pontos a, b, c e d são os nós do grafo e as setas são as direções. Para rodar este código você deve ter Dot instalado, eu uso o Ubuntu e nem precisei instalar já tinha ele aqui, mas na pagina do Dot [2] você pode encontrar para download.

Como disse antes você pode fazer a saída ser de vários tipos, para ter uma ideia dos tipos de saida que estão disponíveis, dá uma olhada no site em formatos de saída [3].  E por fim para você produzir a saída no meu caso aqui vou mandar gerar uma imagem, é só digitar como abaixo:

Fulano@Fulano:~$ dot -Tjpeg arquivo.dot -o saida.jpeg

Como resultado será obtido esta imagem:

Viu que bonito. No guia do dot você tem uma ideia dos grafos mais loucos que você pode criar com esta ferramenta.  Então é isso, use sua criatividade e se divirta.

Referências:

[1] wikipedia/dot

[2] http://www.graphviz.org/Documentation.php

[3] http://www.graphviz.org/doc/info/output.html

Sabe como é faculdade e sofrimento são duas coisas que caminham juntos.  Esses dias eu tive que me virar, parar de dormir de comer, usar o grande G com força nas pesquisas e pude ver que o PyOpenGL me deixou na mão por não conseguir implementar um simples select picking [1].  E o mais triste ninguém em lugar nenhum havia feito isso em PyOpenGL.  Confesso  que quando isso acontece é um tanto decepicionante, mas fazer o que, o que importa é que eu usei o poder da GAMBI vinda do mais poderoso paradigma de programação POG.

Como ia dizendo tive ralar esses dias e a culpa dessa vez foi de um trabalho de computação gráfica denoninado de Elvis.  O trabalho era implementar um programa tipo Xfig [2], com um conjunto de especificações “básicas”.   A linguagem de implementação ficava a cargo de cada dupla, no meu caso fiz sozinho.  Alguns fizeram em C, outros em C++, em Ruby e eu claro em Python.

O que eu tirei deste trabalho: aprendi muitas coisinhas úteis e vi claro a inutilidade de se implementar um treco desses pra uma disciplina de computação gráfica.  Por que digo isso? Digo isso, pois apesar de alguns técnicas de computação gráfica serem utilizadas no trabalho este foi por demais enfadonho, cansativo e por que não dizer foi um trabalho longo e chato impossível de ser feito no tempo que foi dado e só para deixar os alunos loucos. Eu mesmo não consegui atender a todas as implementações, muita coisa o OpenGL resolvia complicar, o Qt ajudou até onde pode e o Python como sempre foi o mão santa da vez.  Até hoje me pergunto o que passa na cabeça de alguns professores. Se o objetivo é nos fazer aprender técnicas dadas em sala de aula e por a mão na massa, por que não fazer isso de forma mais concisa, afinal alunos são humanos, cansam e também tem o que fazer.

Em alguns dias eu pretendo postar aqui o que eu consegui fazer junto com a especificação do trabalho, e no futuro (férias) terminar todo o trabalho e otimiza-lo.  Farei isso para deixar disponível aos colegas sofredores as soluções para os seus futuros problemas.

[1] http://gpwiki.org/index.php/OpenGL:Tutorials:Picking

[2] http://www.xfig.org/

Antes de mostrar como criar agentes com  o SpySe. Vamos instalar o SpySe.  Para isso basta ir no SVN e baixar tudo pelo link  GNU tarball. Baixado o .tar, descompacte ele no seu local de preferência e dentro da pasta spyse dê um sudo python setup.py install (para quem usa ubuntu).  Feito isso o seu spyse já está instalado e para testar é só abrir o shell do python e testar com : import spyse, se tudo der certo nenhuma mensagem será mostrada, mas se der errado vá na pasta do spyse que você deszipou e copia o arquivo __init__.py, dessa forma:  sudo cp __init__.py /usr/local/lib/python2.6/dist-packages/spyse/.  Depois de feito isso, vai no shell do python e testa novamente com: import spyse, se tudo deu certo vamos começar o trabalho.

Vamos criar um agente que diz “hello world” (mais clichê que isso impossível).  Para tal precisamos que nossa classe agente (HelloWorldAgent) herde da classe agente que é importada como mostra o código abaixo.  Feito isso o seu agente deve ter um método setup para inicializar os seus possíveis parâmetros.  Pronto você já tem um agente prontinho para rodar.  Basta agora criar a classe aplicação e chamar o seu agente, ou seus agentes.  Veja o código abaixo:

CODE

#!/usr/bin/env python
# -*- coding: latin-1 -*-

from spyse.core.agents.agent import Agent
from spyse.app.app import App

class HelloWorldAgent(Agent):

    def setup(self):
        print "Hello world!!"

class MyApp(App):
    def run(self,args):
        self.start_agent(HelloWorldAgent,"Agent")

if __name__=="__main__":
    MyApp()

A sintaxe do spyse é muito similar ao do JADE, então se você já conhece a do JADE fica bem mais fácil manusear com o spyse. Em breve pretendo postar aqui o trabalho que eu fiz, com mais exemplos de código e mais completo. O legal de agente é que eles podem ser utilizados para um número muito grande de problemas. Minha ideia é que no ano que vem eu acaba utilizando eles na criação de um jogo usando spyse e PyGame. Então é isso até a próxima.

Nos ultimos dias em mais uma das minhas batalhas a ser travadas no mestrado tive e estou tendo que criar um sistema multiagente com o JADE, porém tenho aversão a JAVA e sempre que posso procuro meios de fazer em outra linguagem, geralmente em Python.  Vasculhando na Web por alternativas a tão odiada linguagem JAVA (que somente não gosto, mas sim eu sei programar nisso =] ) achei o SpySe [1] um projeto até antigo do André Mayer, mas que implementa tudo que o JADE faz, ao menos até agora tudo que eu preciso.

O JADE  para quem não conhece é um framework que segue os padrões da FIPA [2] para implementação de agentes. O SpySe como é de se advinhar faz o mesmo, só que em Python, e convenhamos bem mais bonito.  Quem quiser baixar, por os demos que tem lá pra rodar é só baixar a versão do svn [3], pelo que vi é a mais instável e melhor.  Para mais informações consultem as referências.

Nos próximos post pretendo postar aqui qual foi meu trabalho, o artigo que irei escrever e claro os códigos do sistema que irei criar.  Por enquanto fiquem com esse post informando da existência do  SpySe.

Referências:

[1] SpySE site

[2] FIPA

[3] Download SpySe via svn

Aconte no dia 1 de agosto em fortaleza um dos eventos do Blender Day.  O Blender Day é um evento que irá acontecer nacionalmente em várias cidades do pais, uma delas fortaleza.  Nestas cidades serão ministradas palestras e oficinas com o Blender.  Eventos como este trazem a oportunidade de se divulgar bons trabalhos e aprender um pouco mais sobre essa ferramente livre e extremamente.  Para maiores informações consulte as referências no final deste post.

Referências:

Blender Day

Blender Day em Fortaleza

Opa,

Você sabe o que são plugins?  Não sabe?

Um plugin é um programa que você instala em algum outro programa e executa uma determinada tarefa especifica, por exemplo o plugin Arte de Capa do player de musica do Ubuntu, Rhythmbox. Esse plugin busca a capa do album do qual a musica que está sendo tocada pertence e o mostra do lado esquerdo no player.

Esse post tem duas funções.  A primeira é destrinchar códigos de algum plugin que já foi criado para esse player, e ensinar com isso como fazer um plugin para o Rhythmbox, mostrando assim a API do rb e do rhythmdb (bibliotecas para criar os tais plugins para o Rhythmbox).  A segunda é fazer um plugin parte a parte testar e por pra funfar (funcionar).

Para a primeira parte deste post, o destrinchamento de um plugin, peguei o twitter_plugin do Ryuzo Yamamoto.  Vou explicar apenas a classe TwitterPlugin.  Então vamos ao código:

CODE

import rhythmdb, rb #a parte que realmente nos interessa, por hora, a lib do rhythmbox
import gobject
import gtk, gtk.glade
import gconf, gnomevfs, gnome
import twitter
import os

gconf_keys = {	'username': '/apps/rhythmbox/plugins/twitter-plugin/username',
		'password': '/apps/rhythmbox/plugins/twitter-plugin/password'
		}

class TwitterPlugin(rb.Plugin):

	def __init__(self):
		rb.Plugin.__init__(self)

	def activate(self, shell):
		self.shell = shell
		player = shell.get_player()

		self.psc_id = player.connect ('playing-song-changed', self.song_change)
		self.lastStatus = ""
		if player.get_playing_entry():
			self.song_change (player, player.get_playing_entry())
		self.db = None

	def deactivate(self, shell):
		self.shell.get_player().disconnect (self.psc_id)
		del self.psc_id
		if self.db:
			del self.db
		del self.shell
		del self.lastStatus

	def get_twitter_api(self):
		username = gconf.client_get_default().get_string(gconf_keys['username'])
		password = gconf.client_get_default().get_string(gconf_keys['password'])

		api = twitter.Api(username, password);
		api.SetSource('rhythmboxtwitterplugin')
		api.SetXTwitterHeaders('Rhythmbox twitter-plugin', 'http://trac.codecheck.in/share/browser/platform/rhythmbox/twitter-plugin', '0.1')
		return api

	def song_change(self, player, entry):
		artist = None
		album = None
		title = None
		if entry:
			artist = self.get_song_info(entry)[0]
			album = self.get_song_info(entry)[1]
			title = self.get_song_info(entry)[2]
		response = ""
		if artist != None:
			response = artist
		if album != None:
			if response:
				response += " - " + album
			else:
				response = album
 		elif title != None:
 			if response:
 				response += " - " + title
 			else:
 				response = title
		newStatus = 'Listening to '+response
		if response and newStatus != self.lastStatus:
			self.get_twitter_api().PostUpdate(newStatus)
			self.lastStatus = newStatus

	def get_song_info(self, entry):
		self.db = self.shell.get_property('db')
		artist = self.db.entry_get (entry, rhythmdb.PROP_ARTIST) or None
		album = self.db.entry_get (entry, rhythmdb.PROP_ALBUM) or None
		title = self.db.entry_get(entry,rhythmdb.PROP_TITLE) or None
		return (artist,album,title)

	def create_configure_dialog(self, dialog=None):
		if not dialog:
			glade_file = self.find_file("twitter-plugin-prefes.glade")
			dialog = TwitterConfigureDialog (glade_file).get_dialog()
		dialog.present()
		return dialog

Depois dessa porrada de código, vamos as explicações:

O primeiro e mais importante é importar os módulos necessários, no nosso caso vamos prender a atenção apenas nos módulos rb e rhythmdb.  Estes dois modulos nos dão a API para manusear o Rhythmbox.  Na definição da classe temos TwitterPlugin(rb.Plugin), assim nossa classe herda de rb.Plugin tudo que nós precisamos.  E no contrutor dessa classe,__init__(self):,  é chamado o construdor da classe herdada rb.Plugin.__init__(self):.

Antes de entrar em detalhes no código é preciso esclarecer algumas pontos importantes sobre a criação de plugins no Rhythmbox.

Todo plugin do RBOX tem sempre os dois métodos activate e deactivate.   O método activate é  o método que define o que o plugin faz quando ele for ativado.  Já o deactivate é o método que é executado quando o plugin é desativado.  Além disso a janela que você vê no RBOX é chamada de shell, e sempre que um  plugin é iniciado com a classe rb.Plugin, ele cria uma instância para shell. Em shell é encontrado tudo que você precisa para manipular o RBOX e fazer o seu plugin, desde manipular se uma musica toca ou não, ou manipular alguma coisa da interface gráfica.  É por isso que quando criamos o método activate o shell é passado junto como parametro, afinal ele é a peça mais importante da API. O shell é como um mural onde agente vai colar tudo que o player tem e faz.

Método activate

Quando fazemos shell.get_player(), capturamos o player e seus métodos,  Logo depois em self.psc_id = player.connect(’signal’, função), conectamos ao player a função song_change, que será chamada quando houver mudança de faixa. Há nove tipos de sinais que podem ser passados, para mais detalhes consulte: RBShellPlayer. Em seguida é checado com o player.playing_get_entry() se tem alguma musica sendo tocada ou pausada. Esse método retorna um objeto RhythmbDBEntry em caso positivo e None em caso negativo. Com o objeto RhythmDBEntry é possível usar o metodo get_playback_uri() e recuperar a uri da faixa que está sendo tocada. Muito bem, no if ele verifica se alguma musica está sendo tocada, se sim ele chama a função song_change() passando o player e o objeto RhythmDBEntry para ser manipulado mais à frente.  Antes de encerrar sobre o método activate, repare que temos duas variaveis uma é lasStatus e a outra é db, mas a frente será explicado para que elas servem, mas a essa altura do campeonato já deve dá para perceber o que esse plugin faz, né?

Método deactivate

Como foi falado antes esse método é acionado quando o plugin é desativado, logo ele é o responsável pela ‘limpeza’, ou seja, ele disconecta o que tiver sido conectado, no nosso caso self.shell.get_player().disconnect (self.psc_id), e deleta os objetos que não serão mais usados.

Por enquanto eu vou dar uma pausa, e nos próximos posts irei explicar os outros métodos e falar um pouco mais da API.  Quem quiser se divertir com o RBOX pode usar o Python Console no próprio player, Ferramentas > Python Console. Com isso você pode usar  o dir() e conhecer por si só a API e vê como ele funciona.  Se você quiser ler a documentação checa abaixo as referências.  Então é isso, até o próximo post.

continua…

Referências:

Rhythmbox Plugins/Escrevendo

Rhythmbox Development Reference Manual

]]> http://corecode.wordpress.com/2009/07/11/criando-plugins-para-o-rhythmbox/feed/ 0 kirotawa http://corecode.wordpress.com/2009/06/11/reboot-and-select-propoer-boot-device-or-insert-boot-media-in-selected-boot-device-and-press-a-key/ http://corecode.wordpress.com/2009/06/11/reboot-and-select-propoer-boot-device-or-insert-boot-media-in-selected-boot-device-and-press-a-key/#comments Thu, 11 Jun 2009 16:40:39 +0000 leonidaskirotawa http://corecode.wordpress.com/?p=144 ]]>

Se essa linda mensagem apareceu no seu pc  depois de você ter ido dar um roler e ter deixado ele desligado, calma!! Não xinque o papa por isso.

Depois de rodar na net e não achar muita coisa em que eu tivesse fé, pois que os caras estavam dizendo que era hardware e eu culpei o software, até  buli no grub pra ver se funfava e nada.  Pois bem a solução pra esse problema aqui, foi mudar a porta do hd ¬¬. Sim, mudei da IDE0 pra IDE1 no lugar do cDrom que aqui por enquanto não está mais funfando ¬¬. E então tudo voltou a funfar.  Sabe aquela piada, que dizem da diferença entre hardware e software, pois é, eu chutei meu pc sim!

No mais é só isso. Já sabem né, se essa coisa das trevas ocorrer com você faça isso aê que eu fiz. Mas eu no seu lugar faria um backup de tudo também, vai saber se isso não é um sinal de que o seu PC tá pra morrer.