Commands sind kurze Befehle die wir üblicherweise in der Chat-Konsole in Minecraft eingeben können, um bestimmte Aktionen während des Spiels auszuführen. Zum Beispiel kann man sich mithilfe von bereits vorhandenen Commands an einen bestimmten Ort teleportieren, das Wetter ändern oder einen Zombie spawnen lassen. Sie bestehen aus einem Schrägstrich und einem anschließenden Commandnamen, wie zum Beispiel „weather clear“. Optional können Commands auch noch ein oder mehrere zusätzliche Argumente besitzen.

Ein eigenes Command Plugin könnte zum Beispiel dafür sorgen, dass ein Spieler wieder eine volle Lebensanzeige hat, wenn er den Command „/healme“ eingibt

Damit wir eigene Commands in unserem Plugin nutzen können, sind folgende Schritte notwendig:

Zuerst müssen wir die Commands in unserer Plugin.yml registrieren, damit wir diese überhaupt aufrufen können. (Link)

Anschließend werden die Commands in einer Klasse von uns aufgefangen. Das kann entweder gleich in der Main Klasse oder bei umfangreicheren Plugins auch in zusätzlichen Klassen geschehen. (Link)

Wie man das genau umsetzt, erfahrt ihr in den nächsten Beiträgen zu Command Plugins.

Den Code für ein Command Plugin Beispiel findet ihr hier: GitHub Minecraft-Command-Plugin-Basics

Wenn ihr noch nicht wisst, wie ihr euch eine Entwicklungsumgebung für Minecraft Plugins einrichten könnt, findet ihr hier eine Anleitung dazu.

The post Command Plugin Überblick – Minecraft Plugin appeared first on Joniwa's Weblog.

Habt ihr alles eingerichtet könnt ihr über „New Project“ ein neues Projekt anlegen. Erstellt nun ein leeres Projekt mit einem Namen eurer Wahl. (Naming)

Um eines neues Minecraft Plugin zu erstellen geht auf File-New-Module. Hier wählt ihr zuerst die Plattform eures Plugins aus und gebt anschließend die Informationen zu eurem Plugin ein.

Als nächsten Schritt bearbeiten wir die Projekteinstellungen. Dazu wählen wir die Option „Open Module Settings“ aus. Dort fügen wir unsere Spigot oder Bukkit Jar dem Projekt hinzu.

Anschließend stellen wir noch die Artefakt Einstellungen für unseres Modul ein. Dazu gehen wir auf Artifacts und fügen eine neue Jar Datei mit Dependencies zu unserem Projekt hinzu.

Das Output Directory welches hier angegeben, wird später der Ort sein, in den unser fertiges Plugin ausgegeben wird.

Jetzt müssen wir nur noch auf Apply drücken und unser Projekt ist fertig eingerichtet.

Damit können wir nun IntelliJ für die Minecraft Plugin Entwicklung verwenden.

Wie das geht erkläre ich dann im nächsten Tutorial.

[#1]: https://www.jetbrains.com/de-de/idea/

[#2]: https://minecraftdev.org

[#3]: http://maven.apache.org/guides/mini/g…

[#4]: https://getbukkit.org

The post IDE IntelliJ einrichten – Minecraft Plugin appeared first on Joniwa's Weblog.

Was man anschließend tun muss ist, einen eigenen custom TextView zu erstellen. Dafür geht man in den XML Code der Prototyp Zelle der ListView und ändert den TextView in den später erstellten Typen CustomTextView um. Das ganze sollte dann abgeändert so aussehen:

Vorher:

<TextView
 android:id="@+id/R.id.textview1"
 android:layout_width="wrap_parent"
 android:layout_height="wrap_content"
 />

Nachher: 

<com.example.CustomTextView
 android:id="@+id/R.id.textview1"
 foo:customFont="courier.ttf"
 android:layout_width="wrap_content"
 android:layout_height="wrap_content"
 />

Bei foo:customFont wird dabei der Name der neuen Schriftart angegeben. In diesem Fall „courier.ttf“. Danach wird die XML Datei erstellt. Dafür erstellt man nun ein neues XML File namens „attrs“ und zwar in diesem Ordner /app/src/main/res/values. In diese File kommt folgender Code:

<?xml version="1.0" encoding="utf-8"?>
<resources>
    <declare-styleable name="CustomTextView">
        <attr name="customFont" format="string"/>s
    </declare-styleable>
</resources>

Jetzt geht es darum, denn „CustomTextView“ zu programmieren. Dafür erstellt man im Ordner wo auch die anderen Klassen liegen eine neue Klasse namens „CustomTextView“. In dieser Klasse schreibt nun diesen Code hier:

import android.content.Context;
import android.graphics.Typeface;
import android.util.AttributeSet;
import android.widget.TextView;
import android.content.res.TypedArray;
import android.util.Log;


public class CustomTextView extends TextView {
    private static final String TAG = "TextView";

    public CustomTextView(Context context) {
        super(context);
    }

    public CustomTextView(Context context, AttributeSet attrs) {
        super(context, attrs);
        setCustomFont(context, attrs);
    }

    public CustomTextView(Context context, AttributeSet attrs, int defStyle) {
        super(context, attrs, defStyle);
        setCustomFont(context, attrs);
    }

    private void setCustomFont(Context ctx, AttributeSet attrs) {
        TypedArray a = ctx.obtainStyledAttributes(attrs, R.styleable.CustomTextView);
        String customFont = a.getString(R.styleable.CustomTextView_customFont);
        setCustomFont(ctx, customFont);
        a.recycle();
    }

    public boolean setCustomFont(Context ctx, String asset) {
        Typeface tf = null;
        try {
            tf = Typeface.createFromAsset(ctx.getAssets(), "fonts/" + asset);
        } catch (Exception e) {
            Log.e(TAG, "Could not get typeface: " + e.getMessage());
            return false;
        }

        setTypeface(tf);

        return true;
    }

}

Sollte extends TextView dabei rot unterstrichen werden, kann dies ignorieren.

Hat man nun eine passende Schriftart vom Typ ttf oder otf in den fonts Ordner abgelegt, wird nun die ListView in der eigenen Schriftart angezeigt.

The post Custom Font in einer ListView verwenden – Android Tutorial appeared first on Joniwa's Weblog.

In Android kann man relativ einfach einen eigenen Font in der eigenen Android App verwenden. Unterstützt werden dabei die beiden wohl bekanntesten Schriftarten Formate ttf und otf. Um einen eigene Schriftart zu verwenden muss man zunächst in seinem Android Projekt den Ordner (falls noch nicht vorhanden) Assets erstellen und darin einen Unterordner namens „fonts“. Um den „Assets“ Ordner zu erstellen gibt es in Android Studio sogar einen eigenen Button:

Drückt man diesen wird automatisch ein Ordner namens „Assets“ im eigenen Projekt erstellt. Anschließend muss man darin nur noch den Unterordner namens „fonts“ darin erstellen. In diesen Ordner kommen nun die Fonts welche verwendet werden sollen.

Die Fonts können nun per folgender Syntax im Code benutzt werden:

TextView textView = (TextView)findViewById(R.id.textview1);
Typeface customFont = Typeface.createFromAsset(getAssets(), "fonts/NAME.ttf");
textView.setTypeface(customFont);

Damit erhellt der textView die Schriftart, welche im „fonts“ Ordner hinterlegt wurde. NAME.ttf muss in diesem Beispiel natürlich mit dem eigenen Font ersetzt werden.

Damit kann man nun den eigenen Font in der Android App verwenden.

The post Eigenen Custom Font benutzen – Android Tutorial appeared first on Joniwa's Weblog.

Welche Terminal Befehle brauche ich?

Mit diesen Befehlen kann das Terminal Grundsätzlich bedient werden. Es gibt jedoch noch viele weitere Befehle die nützlich sein könnten. Eine größere Liste findet man z.B. hier: Ubuntuusers Befehlsübersicht

The post Die wichtigsten Terminal Befehle appeared first on Joniwa's Weblog.

Wenn Links über den eigentlichen Rand hinausgehen, sieht das meist recht unschön aus. Dies ist gerade bei längeren Links und mit einem kleineren Bildschirm der Fall:

Um zu verhindern das Links auf einer WordPress Seite über die Textbox hinausragen, reicht es eine einzelne Zeile Code in die CSS Datei zu schreiben. Damit wird der Link, sobald er über den Rand hinausgehen würde, in einer neuen Zeile weitergeführt:

Um diese Einstellung hinzuzufügen geht man in WordPress auf Design -> Editor und fügt dort wo die Links gestylt werden diese zusätzliche Zeile ein:

word-wrap:break-word;

Im CSS Editor sollte das ganze dann in etwa so aussehen:

a {
	color: #80abc8;
	text-decoration: none;
	-webkit-transition: 0.25s ease-in-out;
	-moz-transition: 0.25s ease-in-out;
	transition: 0.25s ease-in-out;
	-ms-transition: 0.25s ease-in-out;
	-o-transition: 0.25s ease-in-out;
	// Neue Zeile Code:
	word-wrap:break-word;
}

The post Automatischer Zeilenumbruch bei Links | WordPress appeared first on Joniwa's Weblog.

Einen eigenen UKW Radio Sender zu bauen ist gar nicht schwer und es werden nur wenige Bauteile benötigt. Der Aufbau an sich dauert nur etwa eine halbe Stunde. Der fertige Sender bekommt die Musik über einen Klinkenstecker und hat eine Reichweite von etwa einem Meter, welche jedoch durch eine größere Antenne erweitert werden kann.

Für den Sender sind folgende Teile notwendig:

1. Transistor: BC547C
2. Keramikkondensatoren:  2 * 15 nF (code: 153), 680 pF (code: 681)  und einen 15 pF (code: 150)
3. Widerstände: 100 kOhm, 10 kOhm und 100 Ohm
4. Kabel und Breadboard
5. 3,5 mm Klinkenstecker
6. 9 Volt Batterieclip
7. 9 Volt Batterie
8. Gegebenenfalls: Steckbrücken und Krokodilklemmen

Bauteile:

Keramikkondensatoren: Keramikkondensatoren eBay

Transistor: Transistor BC547C eBay

Widerstände: Widerstände eBay

Link: Druckknopfanschluss eBay

Einen 3,5 mm Klinkenstecker findet man in vielen Elektronikgeschäften.

Link: 3,5mm Klinkenstecker eBay

Die Antenne kann man sich selbst bauen, indem man ein stück Draht mehrfach um einen Stift dreht. Das ganze sollte dann so aussehen:

Bauanleitung:

Zuerst sollte der Transistor BC547C in die Mitte des Breadboards gesteckt werden.

Später wird auf die Außenreihe des Steckboards Plus bzw. Minus gelegt. Übersichtshalber werden die Kabel dazu aber erst am Schluß befestigt. Auf dem Bild wäre die zweite Reihe von oben Minus und die zweite Reihe von unten Plus.

Anschließend werden die drei Widerstände wie folgt gesteckt:

Der 100 Ohm Widerstand geht vom Emitter auf Minus. Der 100 kOhm Widerstand von der Basis auf Plus und zuletzt den 10 kOhm Widerstand von der Basis nach außen legen.

Danach werden die vier Keramikkondensatoren verbaut. Der 680 pF Keramikkondensator geht von der Basis auf Minus und der 15 pF geht vom Emitter zum Kollektor. Der erste 15 nF wird von Plus nach innen gesteckt. (Dieser wird später direkt mit Plus verbunden.) Der zweite 15 nF geht vom 10 kOhm Widerstand nach außen.

Jetzt sind wir schon fast fertig. Der äußere 15 nF Keramikkondensator wird jetzt noch mit einem Kabel auf Plus gelegt und die vorher selbstgebaute Spule geht vom Kollektor auf Minus.

Nun fehlt noch die Stromversorgung und der Anschluß für den Mp3 Player oder Smartphone. Für den Klinkenstecker einfach ein Kabel an das freie Beinchen vom 15 nF Keramikkondensator und das andere Kabel auf Minus.

Die beiden Kabel kann man dann mit Krokodilklemmen am Klinkenstecker befestigen. Das schwarze Kabel am unteren Drittel des Klinkensteckers und das Rote in der Mitte (oder am Oberen, da der Sender sowieso nur Mono übertragen kann).

Jetzt fehlt nur noch die Stromversorgung. Dazu die beiden Kabel des 9 Volt Batterieclips mit dem Breadboard verbinden und einen 9 Volt Batterieblock anschließen.

und fertig ist der Radio Sender!

Zum Aufbau und anschließendem Test gibt es hier ein Video:

Testen:

The post UKW Radio Sender DIY appeared first on Joniwa's Weblog.