Zur ReTI IDE & Simulator

Für die HTML-JavaScript-IDE bzw. dessen Code-Editor habe ich übrigens auf das CodeMirror 2 Framework gebaut. Super Framework, leider muss man erstmal ein bisschen Dokumentation lesen bis man damit zu guten Ergebnisen kommt!

Keine ähnlichen Beiträge vorhanden

Poker mit PHP umzusetzen ist eigentlich eine relativ einfache Sache – der schwierigere Teil ist das erkennen der Poker-Hände beim Showdown (Flush, Straight, Pair, …). Natürlich kann man einfach alle möglichen Hände hardcoden und dann einfach eine nach der anderen Abarbeiten (siehe zB phppokerengine), das ist aber nicht besonderst elegant, performant oder erweiterbar. Außerdem ist es sehr unübersichtlich und fehleranfällig. Deshalb habe ich mir gedacht, man könnte alle möglichen Poker-Hände mit einer Abstraktions-Sprache definieren und diese dann mit entsprechendem Parser zu behandeln.

Zuerst zu meiner Sprache, die ich wie folgt definiert habe:

• Gleiche Zahlen stellen gleiche Karten-Werte dar
• Gleiche Buchstaben stellen gleiche Farben dar
• Ein Fragezeichen steht für eine beliebige Karte
• Ein > sagt, dass die nächste Karte direkt auf die vorherige folgen muss.
• Ein [ sagt, dass das nächste Zeichen kein Symbol, sondern kein expliziter Kartenwert ist
• {x} nach einem Symbol gibt an, wie oft es wiederholt wird

Um das ganze zu konkretisieren habe ich nun alle Poker-Hände in meine Sprache übersetzt:

// pair (zB ♥A - ♦A)
1{2}

// royal flush (zB ♣A - ♣K - ♣Q - ♣J - ♣10)
[a>a>a>a>a

Das Parsen und Verarbeiten ist zwar etwas trickreicher, aber machbar. Ich habe einen Quick-n-Dirty PHP-Prototypen gebaut – er funktioniert, ist allerdings nicht besonderst sauber geschrieben. Im Vergleich zu der Methode “alle-Möglichkeiten-hardcoren” entsteht übrigens noch ein weiterer Vorteil: Meine Klasse ist 7kB groß, die oben verlinkte 0,5 MB…

Die Verwendung der Klasse erfolgt so:

<?php
// straight flush detector
$parser = new PokerParser('a>a>a>a>a');
 
$hand = array(
  array('color' => 'spades', 'card' => 'k'),
  array('color' => 'spades', 'card' => 'q'),
  array('color' => 'spades', 'card' => 'j'),
  array('color' => 'spades', 'card' => '10'),
  array('color' => 'spades', 'card' => '9')
);
 
if ($parser->check($hand)) {
   echo "Deine Hand enthält ein Straight Flush!<br />\n";
} else {
   echo "Kein Straight Flush vorhanden.<br />\n";
}
?>

Die Ausgabe sollte “Deine Hand enthält ein Straight Flush!” sein.

Die Klasse findet sich dort: PokerParser.class.php

Keine ähnlichen Beiträge vorhanden

// RedBean-PHP besteht aus einer einzigen Datei
require "rb.php";
 
// Zur Datenbank verbinden:
// derzeit wird SQLite, MySQL und PostgreSQL unterstützt
R::setup('mysql:host=localhost;dbname=redbeantest','root','');
 
// ein haus erstellen
$house = R::dispense('house');
$house->color = 'blue';
$house->size = 34;
R::store($house); // in der db speichern
 
// einen besitzer erstellen
$owner = R::dispense('owner');
$owner->name = 'Alex';
R::store($owner); // in der db speichern
 
// das Haus gehört dem Besitzer
// Many-to-Many Relation, da jeder Besitzer 
// viele Häuser haben kann und ein Haus 
// mehrere Besitzer
R::associate($owner, $house);
 
// eine stadt erstellen
$city = R::dispense('city');
$city->name = 'Zauberstadt';
 
// eine One-to-Many Relation, da 
// jedes Haus nur zu einer Stadt 
// gehört
$city->ownHouse[] = $house; 
 
R::store($city); // speichern
 
// jetzt laden wir mal ein paar sachen aus der DB
// einen besitzer mit dem name Alex finden
$person = R::findOne('owner', ' name = ?', array('Alex'));
 
// seine häuser finden
$houses = R::related($person, 'house');
var_dump($houses); // häuser dumpen
 
// die häuser der stadt ausgeben
foreach ($city->ownHouse as $key => $house) {
   echo "Haus Nummer $key ist ".$house->color."\n";
}

Das ganze funktioniert, sobald es eine Datenbank “redbeantest” gibt. Es müssen keine Tabellen in der Datenbank erstellt werden, noch Forgein-Keys angelegt werden. (Weitere Beispiele und die Dokumentation sind auf der Webseite.)

Alles wunderbar, allerdings kommt hier schon ein erstes Problem auf! RedBean PHP stellt nämlich alle Forgein-Keys und dessen Relations auf ON UPDATE SET NULL, ON DELETE SET NULL. Dieses Verhalten ist aber nicht immer gewünscht, das heißt hier muss man aufjedenfall noch nach RedBean-PHP aufräumen bevor die Software in Produktion gehen kann. Ein weiteres Problem ist, dass RedBean-PHP den Typ eines Datenbankfelds nur dann optimal wählt, wenn man es mit genügend Test-Daten füttert. Ansonsten ist auch hier ein nachträgliches Aufräumen nötig. Hier kann man sich also die Frage stellen – möchte ich lieber später meine Datenbank aufräumen müssen, oder sie direkt von Anfang an korrekt designen?

Ein zweites Problem von RedBean-PHP ist Performance. Das Framework macht, vorallem bei Relations, einfach viel zu viele Datenbank-Abfragen, die bei vielen Zugriffen zu hoher Datenbanklast führen können (Abhilfe schafft hier ein Caching System, allerdings ist das nur hilfreich, wenn keine aktuellen Daten benötigt werden). Hier endet man dann also damit einige R::find und R::related durch eigene Queries zu ersetzen. (was übrigens auch prima funktioniert, aber dann nicht mehr im Sinne von ORM ist…)

Abgesehen davon ist es aber eine super Sache, man kommt aufjedenfall schnell zu Ergebnissen. Ich würde es für alle kleineren PHP-Projekte empfehlen! Für größere Projekte würde ich davon abraten, da man einfach zu schnell den Überblick verliert und man mit dem “Aufräumen” schnell mal etwas übersieht was dann zu kritischen Fehlern führen kann.

Keine ähnlichen Beiträge vorhanden

Leider hat das Protokoll im Handshake einige Sicherheitsprobleme (gehabt?) und sich deshalb ständig verändert. Dieser Artikel bezieht sich also auf die Aktuellste Version (17). Diese wird derzeit von der aktuellsten Chrome Version und anderen Webkit Browsern unterstützt, in Firefox und Opera ist WebSocket wegen der Sicherheitsprobleme derzeit deaktiviert.

Um HTML5 WebSocket zu verwenden ist zunächst ein WebSocket-Server nötig. Ich habe hier nach einer PHP-Variante gesucht und habe dann nach einer Weile folgenden gefunden: php-websocket. Diesen sollte man sich laden und dann kann man ihn per

php -q php-websocket/server/server.php

starten. Jetzt ist ein WebSocket-Server auf “localhost:8000″ zu erreichen. Dort sind derzeit zwei Module geladen, einmal das Modul “echo” und einmal das Modul “chat”. (Ich werde mich hier nicht mit der Entwicklung eines WebSocket-Server weiter befassen) Das “echo” Modul nimmt einfach Anfragen entgegen und schickt diese dann an alle Verbundenen Sockets weiter.

Nun kümmern wir uns um die HTML5-Seite von WebSocket, dem User-Frontend. Dafür bauen wir uns erstmal eine einfache HTML5 Seite:

<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>HTML5 WebSocket Test</title>
<!-- jQuery 1.6.4 zur DOM-Manipulation -->
<script type="text/javascript" src="jquery-1.6.4.min.js"></script>
<!-- meine eigene Wrapper-Library für WebSocket Verbindungen, siehe unten -->
<script type="text/javascript" src="websocketlib.js"></script>
<script type="text/javascript">
// hier wird dann das WebSocket-Script reinkommen, siehe unten
</script>
</head>
<body>
 
<div style="float:right;width:40%;">
	<h1>Log</h1>
	<div id="logbox"></div>
</div>
 
<h1>Chatbox</h1>
<div id="chatbox"></div>
 
<h1>Say something</h1>
<form id='chat'>
	<input type='text' value='' name='message' />
	 <input type='submit' value='Sagen' />
</form>
 
</body>
</html>

Für die einfache Verwendung des WebSockets habe ich mir eine kleine Wrapper-Library (websocketlib.js) programmiert:

/**
 * Small wrapper library for HTML5 WebSocket
 * 
 * @author Alexander Thiemann <mail@agrafix.net>
 * @version 1.0
 * 
 * @param string WebSocket host, eg. ws://localhost:8010/echo
 * @param function Function to be called when socket is connected
 * @param function Function to be called when socket recieves data, takes 1 argument message
 * @param function Function to be called for logging purposes, takes 1 argument log-message
 * 
 * @see http://blog.agrafix.net/2011/11/html5-websocket/
 */
var WebSocketLib = {
	init: function(host, onConnect, onRecv, onLog) {
		this.socket = new WebSocket(host);
 
		this.onLog = onLog;
		this.onRecv = onRecv;
		this.onConnect = onConnect;
 
		this.onLog('Initializing Socket. State: ' + this.socket.readyState);
 
		this.socket.onopen = this._onOpen;
		this.socket.onmessage = this._onMessage;
		this.socket.onclose = this._onClose;
	},
 
	send: function(message) {
		WebSocketLib.socket.send(message);
	},
 
	_onClose: function() {
		WebSocketLib.onLog('Socket Closed.');
	},
 
	_onMessage: function(msg) {
		WebSocketLib.onLog('Recieved new Message from Server: ' + msg.data);
		WebSocketLib.onRecv(msg.data);	
	},
 
	_onOpen: function() {
		WebSocketLib.onLog('Socket is Ready. State: ' + WebSocketLib.socket.readyState);
 
		if (WebSocketLib.socket.readyState == 1) {
			WebSocketLib.onConnect();
		}	
	}
}

Ich denke dort ist alles relativ selbsterklärend. Das WebSocket ist wirklich sehr leicht zu verwenden! Um diese Wrapper-Library zu verwenden, bauen wir in obiges HTML-Grundgerüst bei “// hier wird dann das WebSocket-Script reinkommen, siehe unten” folgendes ein:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

$(document).ready(function() {
	WebSocketLib.init('ws://localhost:8010/echo', 
	function() {
		sockReady();
	},
	function (t) {
		$('#chatbox').append($("<p>").text(t));	
	},
	function (t) {
		$('#logbox').append($("<p>").text(t));	
	});
 
	function sockReady() {
		$('#chat').submit(function(e) {
			e.preventDefault();
 
			var input = $('input[name="message"]');
 
			WebSocketLib.send(input.val());
 
			input.val("");
		});
	}
});

Zuerst warten wir, bis unser HTML-Dokument im Browser aufgebaut ist. Dann geben wir in Zeile 2 an, wo unser WebSocket-Server läuft. Die Funktion in Zeile 4 wird aufgerufen, sobald das WebSocket verbunden ist. Die Funktion Zeile 6-8 wird aufgerufen, wenn eine Nachricht zurückgegeben wird. Die Funktion Zeile 9-11 wird bei Log-Ereignissen (Hauptsächlich zum Debuggen) aufgerufen. Mit WebSocketLib.send(“Nachricht”) in Zeile 19 schicken wir eine Nachricht an den Server.

Wenn nun alles vorbereitet ist, der WebSocket-Server gestartet ist (siehe oben), können wir einem Browser, der WebSocket unterstützt (siehe oben), unsere HTML-Seite aufrufen. Die Log-Ausgabe im HTML-Fenster sieht wie folgt aus:

Initializing Socket. State: 0
Socket is Ready. State: 1

Im Consolenfenster des PHP-Server sehen wir:

2011-11-25 11:26:47 [info] [client 127.0.0.1:30601] Connected
2011-11-25 11:26:47 [info] [client 127.0.0.1:30601] Performing handshake
2011-11-25 11:26:47 [info] [client 127.0.0.1:30601] Handshake sent

Die Verbindung ist nun also aufgebaut. Jetzt sollten wir den “echo”-Server testen. Wir tippen etwas in das Textfeld und schicken es ab. Der Log sagt:

Recieved new Message from Server: test

Und unter “Chat” steht jetzt “test”. Hat soweit also funktioniert! Jetzt können wir ein neues Browserfenster aufmachen, wieder den Verbindungsvorgang abwarten und dann dort eine Nachricht verschicken. Diese erscheint dann in allen verbundenen Client-Fenstern.

Eigentlich ziemlich einfach zu verwenden, und es öffnet viele neue Möglichkeiten vorallem in Kombination mit Canvas für HTML5-Multiplayer-Games… hoffen wir also, dass es bald von allen Browser voll unterstützt wird!

Ähnliche Beiträge:

1. Sprechblasen mit HTML5, Canvas und JavaScript
2. JavaScript und Geolocation

Was ist an diesem Captcha schlecht? Der auszulesende Inhalt ist nicht abwechselnd genug (immer nur Zahlenfolgen), nicht verzerrt, nicht farblich variierend und hebt sich zu gut vom Hintergrund ab. Das alles werden wir nun ausnutzen um den Captcha zu knacken.

Zuerst müssen wir “Zahlendefinitionen” schreiben. Das heißt wir legen für jede Zahl einige eindeutige Fixpunkte fest, mit denen die Zahl eindeutig identifizierbar ist.

Beispiel an der Zahl “1″:

     OO
    OOO
   OOOO
     OO
     OO
     OO
     OO
     OO
     OO
   OOOOOO           

Die Definition:

function is_one($pix, $x, $y) {
	$c = 0;
	$c += check($pix, $x, $y, 2, -2); // 5 / 5
	$c += check($pix, $x, $y, 3, -2); // 6 / 5
	$c += check($pix, $x, $y, 1, -1); // 4 / 6
	$c += check($pix, $x, $y, 2, -1); // 5 / 6
	$c += check($pix, $x, $y, 3, -1); // 6 / 6
	$c += check($pix, $x, $y, 0, 0); // 3 / 7
	$c += check($pix, $x, $y, 1, 0); // 4 / 7
	$c += check($pix, $x, $y, 2, 0); // 5 / 7
	$c += check($pix, $x, $y, 3, 0); // 6 / 7
	$c += check($pix, $x, $y, 2, 1); // 5 / 8
	$c += check($pix, $x, $y, 3, 1); // 6 / 8
	$c += check($pix, $x, $y, 2, 2); // 5 / 9
	$c += check($pix, $x, $y, 3, 2); // 6 / 9
	$c += check($pix, $x, $y, 2, 3); // 5 / 10
	$c += check($pix, $x, $y, 3, 3); // 6 / 10
	$c += check($pix, $x, $y, 2, 4); // 5 / 11
	$c += check($pix, $x, $y, 3, 4); // 6 / 11
	$c += check($pix, $x, $y, 2, 5); // 5 / 12
	$c += check($pix, $x, $y, 3, 5); // 6 / 12
	$c += check($pix, $x, $y, 2, 6); // 5 / 13
	$c += check($pix, $x, $y, 3, 6); // 6 / 13
	$c += check($pix, $x, $y, 0, 7); // 3 / 14
	$c += check($pix, $x, $y, 1, 7); // 4 / 14
	$c += check($pix, $x, $y, 2, 7); // 5 / 14
	$c += check($pix, $x, $y, 3, 7); // 6 / 14
	$c += check($pix, $x, $y, 4, 7); // 7 / 14
	$c += check($pix, $x, $y, 5, 7); // 8 / 14
	if ($c == 27) {
		return true;
	}
	return false;
}

Dort sind nun alle Fixpunkte relativ zum “ersten” Fixpunkt gespeichert. Der “erste” Fixpunkt ist bei der eins der Punkt ganz unten rechts. Nachdem wir solche Definitionen für alle Zahlen von 0-9 erstellt haben geht’s nun an die Wiedererkennung der Zahlen. Dazu muss zuerst der Hintergrund herausgefiltert werden und die Grafik in ein besser (für unser Programm) lesbares Format gebracht werden. Dies mache ich wie folgt:

function read($path) {
	$im = ImageCreateFromPNG($path);
	$pix = array();
	$sy = ImageSy($im);
	$sx = ImageSx($im);
 
	for ($y = 0;$y<$sy;$y++) {
		for ($x = 0;$x<$sx;$x++) {
			$col = imagecolorat($im, $x, $y);
			$rgb = imagecolorsforindex($im, $col);
 
			if ($rgb["red"] <= 150) {
				$pix[$x][$y] = "O";
			}
			else {
				$pix[$x][$y] = "W";
			}
		}
 
	}
 
	// ...
}

Nun haben wir den Array $pix, der bei [x][y] entweder W (für weiß) oder O (für schwarz) enthält. Jetzt müssen wir nur noch durch den Array durchgehen und nach unseren Fixpunkt-Mustern suchen:

        // ....
 
        $no = 0;
	$complete_string = "";
	$found_at = array();
 
	for ($x = 0;$x<$sx;$x++) {
		for ($y = 0;$y<$sy;$y++) {
			if ($pix[$x][$y] == "O" && !in_array("$x|$y", $found_at)) {
				$no = 0;
 
				if (is_one($pix, $x, $y)) {
					$no = 1;
				}
				if (is_two($pix, $x, $y)) {
					$no = 2;
				}
				if (is_three($pix, $x, $y)) {
					$no = 3;
				}
 
				if (is_four($pix, $x, $y)) {
					$no = 4;
				}
 
				if (is_five($pix, $x, $y)) {
					$no = 5;
				}
 
				if (is_six($pix, $x, $y)) {
					$no = 6;
				}
 
				if (is_seven($pix, $x, $y)) {
					$no = 7;
				}
 
				if (is_eight($pix, $x, $y)) {
					$no = 8;
				}
 
				if (is_nine($pix, $x, $y)) {
					$no = 9;
				}
 
				if ($no != 0) {
					$found_at[] = "$x|$y";
					$complete_string .= $no;
				}
			}
		}
	}
 
	//...

Die Variable $complete_string enthält nun den ausgelesenen String. Simple as that

Hier der gesamte Code inklusive der Hilfsfunktion check(). Der Code ist schon etwas älter, also nicht über schlechten Code-Stil wundern – er soll legendlich das Prinzip erklären: http://agrafix.net.pastebin.com/b6exg0SW

Noch ein Screenshot:

Das war’s schon – viel Vergnügen damit!

Keine ähnlichen Beiträge vorhanden

Das Projekt ist unter http://www.visitor-stats.de zu finden.

Für die Realisierung der AJAX-API mit json Antworten habe ich json_encode() benutzt.

Ähnliche Beiträge:

1. Ein weiteres WordPress Update
2. Zippyshare Downloads Automatisieren *update*

gerade eben haben wir die DSLan v1.4 veröffentlicht. Die DSLan ermöglicht es einen Local-Area-Netzwerk Server mit maximal 10 Spielern des Spiels Die-Stämme zu erstellen.

Download und weitere Info’s: http://dslan.gfx-dose.de

Liebe Grüße,
Agrafix

Ähnliche Beiträge:

1. Jubiläum
2. jQuery in Greasemonkey

<?php
/**
 * größer gemeinsamer Teiler nach Euclid
 *
 * @param int $a
 * @param int $b
 * @return int
 */
function ggT($a, $b) {
	if ($b == 0) {
		return $a;
	}
 
	return ggT($b, ($a%$b));
}
 
/**
 * kleinstes gemeinsames Vielfaches
 *
 * @param int $a
 * @param int $b
 * @return int
 */
function kgV($a, $b) {
	return ($a*$b)/ggT($a, $b);
}
 
// Beispiel
header("Content-Type:text/plain");
echo "ggT(114, 24) = ".ggT(114, 24)."\n";
echo "kgV(45, 35) = ".kgV(45, 35)."\n";
?>

Die Ausgabe sollte wie folgt aussehen:

ggT(114, 24) = 6
kgV(45, 35) = 315

Wer den ggT bzw den kgV von mehreren Zahlen braucht, kann sich an folgende Regel halten:

kgV(a, b, c, d) = kgV(kgV(a, b), kgV(c, d))

Keine ähnlichen Beiträge vorhanden

register_globals wird endlich mit PHP6 abgeschafft – seit PHP5.3 gillt es als “veraltet”. Und warum gibt’s dann immer noch Webhoster die sowas standardmäßig aktivieren?!

Ähnliche Beiträge:

1. Was hat Apple gegen Flash?

<?php
/**
 * ax² + bx + c = 0 solver
 * 
 * @author agrafix.net
 */
header("Content-Type: text/plain;charset=utf-8");
 
// input -> ax² + bx + c = 0
$a = 1;
$b = 3;
$c = 1;
 
// calc
print "Eq: ".$a."x² + ".$b."x + ".$c." = 0\n";
 
$d = pow($b, 2) - 4*$a*$c;
print "D = $d\n";
 
if ($d < 0) {
	print "L = {}";
}
else {
 
	$x1 = (-$b + sqrt($d)) / (2 * $a);
	$x2 = (-$b - sqrt($d)) / (2 * $a);
 
	if ($x1 == $x2) {
		print "L = {".round($x1, 4)."}";
	}
	else {
		print "L = {".round($x1, 4).", ".round($x2, 4)."}";
	}
}
?>

Keine ähnlichen Beiträge vorhanden