Hnefatafl
=========



Namn
----
Hnefatafl - det norröna brädspelet



Sammanfattning
--------------
`hnefatafl [-ChiLsv] [-c <sökväg>] [-d <sökväg>] [-e <sökväg>]
[-l <filnamn>] [-n <variabel>] [-r <filnamn>] [-x <tema>]`



Beskrivning
-----------
> På gården med brädspel  
> de glada lekte,  
> armod på guld  
> fanns ingalunda,  
> tills tursamöar  
> trenne kommo,  
> mycket mäktiga  
> mör, från jättevärlden.
>
> ― Valans spådom, ca. 400-1100 e. Kr.



Argument
--------

`-c <sökväg>`
:	RC-fil. Observera att man måste ange hela sökvägen.

`-C`
:	Gör så att programmet inte läser någon RC-fil, även om `-c`
	anges och `$HNEFATAFL_RC` är definierad.

`-d <sökväg>`
:	Ange programmets föredragna sökväg till datafiler.

`-e <sökväg>`
:	Läs in det sparade partiet från filen i sökvägsargumentet.
	Observera att man måste ange hela sökvägen.

`-h`
:	Skriver ut hjälp om startargument.

`-i`
:	Skriver ut information om upphovsrätt och garanti.

`-l <filnamn>`
:	Språkfil. Observera att endast filnamnet ska anges, inte hela
	sökvägen.

`-L`
:	Skriver ut alla språknycklar till `stdout`, en per rad.

`-n <variabel>`
:	Skriver ut värdet på en miljövariabel. Om ingen variabel anges
	så skrivs värdena på alla miljövariabler som programmet använder
	ut.

`-r <filnamn>`
:	Regelfil. Observera att endast filnamnet ska anges, inte hela
	sökvägen.

`-s`
:	Gör så att `setlocale()` inte anropas. Detta är i praktiken
	detsamma som att ställa in `$LC_ALL` till `"C"`.

`-v`
:	Skriver ut version för alla programmets beståndsdelar. `uicx`
	betyder att gränssnittet stöder X; `uic` betyder att det inte
	stöder X.

`-x <tema>`
:	Startar X-gränssnittet i stället för kommandotolken, och
	avslutar programmet när fönstret stängs (såvida inte X kan
	startas över huvud taget, i vilket fall kommandotolken körs i
	stället). `<tema>` är ett valfritt argument och fungerar som när
	man startar X-gränssnittet med ett kommando i kommandotolken,
	förutom att `<tema>` här inte får börja med `-`.



Miljövariabler
--------------

`DISPLAY`
:	Används av XLib.

`HOME`
:	Hemkatalog. Används när programmet gissar datafilskatalog.

`LANG`
:	Används för att ställa in `LC_ALL` eller `LC_CTYPE` om ingen av
	dem är definierade.

`LC_ALL`
:	Förstahandsval för att ställa in lokal.

`LC_CTYPE`
:	Andrahandsval för att ställa in lokal.

`HNEFATAFL_FONT`
:	Används av X-gränssnittet för att ställa in typsnitt (FontSet);
	om denna variabel inte är definierad så används ett förval.

`HNEFATAFL_LANG`
:	Namnet på en språkfil som programmet ska läsa in, om ingen annan
	anges. Observera att man endast ska ange filnamnet här, inte den
	fullständiga sökvägen.

`HNEFATAFL_PATH`
:	Sökväg till datafiler. Detta ska vara en katalog och man måste
	ange hela sökvägen.

`HNEFATAFL_RC`
:	Sökväg till RC-fil. Detta ska vara hela sökvägen (inte bara
	filnamnet).

`HNEFATAFL_RULES`
:	Namnet på en regelfil som programmet ska läsa in, om ingen annan
	anges som startargument. Observera att man endast ska ange
	filnamnet här, inte den fullständiga sökvägen.



Filer
-----

`<data>/lang/`
:	Språkfiler. När man skriver t. ex. `l <fil>` så söker programmet
	i denna katalog.

`<data>/rules/`
:	Regelfiler. När man skriver t. ex. `r <fil>` så söker programmet
	i denna katalog.

`<data>/xlib/`
:	Datafiler till X-gränssnittet.

`<data>/xlib/<tema>/`
:	Filnamnet på varje `<tema>`-katalog måste överensstämma exakt
	med raderna i `themes`-filen.

`<data>/xlib/themes`
:	Fil som innehåller alla teman i X-gränssnittet, ett per rad.
	Det första temat i filen är förvalet, om regelfilen inte anger
	`ui_theme` och om användaren inte anger något tema.

`<data>/hnefataflrc`
:	RC-fil.

`<data>` avser den katalog som programmet försöker gissa sig till, eller
den katalog som anges av `d`-kommandot, startargumentet `-d` eller
miljövariabeln `$HNEFATAFL_PATH`.

### RC-fil ###
Man kan ange en RC-fil på följande sätt:

1.	`-c` argument.
2.	`$HNEFATAFL_RC` miljövariabel.
3.	Programmet försöker gissa vilken katalog `hnefataflrc` finns i.

Om `-c`-argumentet anges så går det före `$HNEFATAFL_RC` och
`hnefataflrc`-filen. Om dessa används så måste man ange den fullständiga
sökvägen till RC-filen — det räcker inte med att bara skriva in
filnamnet (programmet gissar inte var den finns eftersom det skulle
kunna vara farligt om man råkar köra fel fil).

När programmet startas så söker den efter en fil som heter `hnefataflrc`
och gissar sökvägen.

Om man anger `-C` så läses ingen RC-fil, även om `-c` anges som
startargument och `$HNEFATAFL_RC` är definierad.

### Språkfiler ###
Språkfiler kan anges på följande sätt:

1.	`-l` argument.
2.	`$HNEFATAFL_LANG` miljövariabel.
3.	`l <fil>` i kommandotolken eller X.

`-l` går före `$HNEFATAFL_LANG`. Om någon av dem anges, och anger en
giltig språkfil, så går det före eventuella språkfiler som anges i
RC-filen.

Observera att man aldrig behöver ange den fullständiga sökvägen till en
språkfil — programmet gissar i vilken katalog den finns.

### Regelfiler ###
Regelfiler kan anges på följande sätt:

1.	`-r` argument.
2.	`$HNEFATAFL_RULES` miljövariabel.
3.	`r <fil>` i kommandotolken eller X.

`-r` går före `$HNEFATAFL_RULES`. Om någon av dem anges, och anger en
giltig regelfil, så går det före eventuella regelfiler som anges i
RC-filen.

Observera att man aldrig behöver ange den fullständiga sökvägen till en
regelfil — programmet gissar i vilken katalog den finns.

### Hur programmet gissar kataloger ###
Programmet försöker ibland gissa vilken katalog en angiven fil finns i.
Detta sker endast när en fil öppnas för läsning, aldrig när en fil
öppnas för skrivning. Kataloger provas i följande ordning:

1.	Det angivna filnamnet provas.
2.	Katalogen som anges av kommandot `d` angivet av användaren.
3.	Katalogen som anges av startargumentet `-d`.
4.	`$HNEFATAFL_PATH/`
5.	Katalogen som anges av kommandot `d` i en RC-fil.
6.	`$HOME/hnefatafl/`
7.	`$HOME/.hnefatafl/`
8.	`/usr/share/hnefatafl/`
9.	`/usr/share/games/hnefatafl/`
10.	`/usr/local/share/hnefatafl/`
11.	`/usr/local/share/games/hnefatafl/`

*1* (det angivna filnamnet) provas endast om man skriver in filnamnet
som startargument, i kommandotolken eller i X-terminalen. *1* provas
inte om filnamnet förekommer i en miljövariabel (som `HNEFATAFL_LANG`)
eller i en RC-fil eftersom det skulle kunna vara oberäkneligt.

*3* provas endast om `-d` anges som startargument.

Sökvägar som är avhängiga miljövariabler (*4*, *6* och *7*) provas inte
om miljövariablerna inte är definierade.

*8* till *11* provas alltid.

### Hur man förhindrar automatisk inläsning av filer ###
Om man inte definierar `$HNEFATAFL_LANG` eller `$HNEFATAFL_RULES`, och
om man anger `-C` som startargument, så läser programmet inte in några
filer automatiskt vid uppstart.



Returvärde
----------
`EXIT_SUCCESS` (oftast 0) om allt gick väl eller `EXIT_FAILURE` för alla
typer av fel. Dessa definieras i `stdlib.h`(3).



Exempel
-------

`hnefatafl`
:	Kör programmet med den förvalda RC-filen.

`hnefatafl -d /opt/hnefatafl -l eng`
:	Ställer in datakatalogen till `/opt/hnefatafl` och språket till
	engelska (`/opt/hnefatafl/lang/eng`).

`HNEFATAFL_PATH=/opt/hnefatafl hnefatafl -l swe -r petteia`
:	Ställer in datakatalogen till `/opt/hnefatafl`, språket till
	svenska (`/opt/hnefatafl/lang/swe`) och spelreglerna till
	petteia (`/opt/hnefatafl/rules/petteia`).



Snabbstart
----------
1.	Prova med att helt enkelt köra programmet utan några
	startargument. `hnefataflrc` hittas ofta automatiskt (se *"Hur
	programmet gissar kataloger"*).
2.	Om det inte fungerade, ställ in `$HNEFATAFL_PATH` till katalogen
	med programmets datafiler, eller starta programmet med
	`-d <sökväg>`.

### Språkfiler, regelfiler och RC-filer ###
När programmet startas så söker det efter `hnefataflrc` och kör alla
kommandon i filen (man kan även ange en absolut sökväg till en RC-fil
genom `-c <sökväg>` eller `$HNEFATAFL_RC`). "RC" står för "run commands"
och det är precis vad filen gör: kör kommandon i kommandotolken som om
man själv hade skrivit in dem, så att man slipper skriva in dem varje
gång man använder programmet. I RC-filen kan man till exempel ställa in
språk (med `l`-kommandot) och regelfil (med `r`-kommandot). Språk kan
även ställas in med `-l <filnamn>` eller `$HNEFATAFL_LANG`, och regelfil
kan även ställas in med `-r <filnamn>` eller `$HNEFATAFL_RULES`.

### Starta och stänga X-gränssnittet ###
Man startar X-gränssnittet med `x`-kommandot (se `h x` för hjälp).

När man väl är i X-gränssnittet så går man tillbaka till kommandotolken
genom att ge `x`-kommandot igen, eller så avslutar man programmet med
`q`-kommandot.

### Nödvändiga datafiler ###
Den enda datafilen som egentligen behövs för att spela ett parti är en
regelfil. Språkfiler är frivilliga att använda, men de meddelanden som
programmet skriver ut blir lite mer begripliga om man läser in en
språkfil. X-gränssnittet kan dessutom (frivilligt) använda XPM-filer som
arrangeras i teman; X-gränssnittet *kan* köras utan teman eller med
ofullständiga teman men ritar då mycket enkel reservgrafik i dess
ställe.

### Var man installerar en lokal RC-fil ###
Om en RC-fil har installerats i `/usr/share/games/hnefatafl/` så kan
varje användare ha en egen RC-fil i antingen `$HOME/hnefatafl/` eller
`$HOME/.hnefatafl/`, och den kommer då att hittas automatiskt och
föredras före filen som finns i `/usr/share/games/hnefatafl/`. Samma sak
gäller alla andra datafiler. (Naturligtvis kan man även ange en absolut
sökväg till RC-filen via startargument eller miljövariabel.)



Syntax i textfiler
------------------
Alla textfiler läses enligt samma syntax. RC-filer, `stdin`, språkfiler
och regelfiler läses alla enligt följande regler:

Man skriver ett kommando per rad.

Mellanslag och tabulatorer slås ihop till ett mellanslag mellan varje
ord, såvida de inte föregås av `"\"` eller är inom citationstecken.

`#`: kommentar; allt som följer tecknet på samma rad ignoreras.

`\`: gör att följande tecken läses in utan att tolkas på något speciellt
sätt, eller sammanfogar raden med nästa om tecknet är sist på raden.
`\t` infogar en tabulator och `\n` infogar en radbrytning.

Enkla (`'`) och dubbla (`"`) citationstecken gör att texten inom dem
inte bryts upp i olika argument och att mellanslag och alla andra tecken
bevaras (`"\"` kan dock användas inom dubbla citationstecken).



Regelfiler
----------

### Allmänna regler ###
Dessa allmänna regler kan inte ändras.

*	Om en spelare inte har några möjliga drag när det är hans tur,
	så förlorar han. Observera att det inte spelar någon roll om en
	spelare inte kan göra något drag när det inte är hans tur.

### Allmänna argument ###

#### `id <id>` ####
En unik textsträng som identifierar regelfilen. Den är skiftlägeskänslig
och får endast innehålla ASCII-tecken.

#### `name <namn>` ####
Spelreglernas namn. Detta visas till användaren men fyller ingen annan
funktion. Därför spelar det ingen roll vad namnet är så länge som det
består av minst 1 tecken.

*	Teckenkodningen ska helst vara ASCII.
*	Om man inte vill använda ASCII så bör det vara UTF-8 eftersom
	datafilerna kodas i UTF-8.
*	Det *måste* vara en 8 bit teckenkodning (eftersom tecknen lagras
	i datatypen `char`).

Ett gränssnitt får visa detta till användaren eller välja att inte göra
det. X-gränssnittet stöder ett namn i UTF-8 eller Latin-1 medan
kommandotolken inte visar namnet alls.

#### `ui_theme <tema>` ####
Anger ett förslag på tema som gränssnittet valfritt kan använda sig av.
Detta argument är valfritt och utgörs av en textsträng.

*	Räkna med att textsträngen är skiftlägeskänslig.
*	Ett gränssnitt måste förutsätta att ogiltiga teman kan anges i
	regelfiler, och hantera detta på ett snyggt sätt.

Ett gränssnitt får jämföra `ui_theme` med eller utan hänsyn till
skiftläge. Ett gränssnitt får även bortse från `ui_theme` helt och
hållet. I det officiella X-gränssnittet i `uicx` så är det
skiftlägeskänsligt, och i kommandotolkgränssnittet ignoreras det.

#### `width x` ####
Brädets bredd. 1 <= `x` <= 31.

#### `height x` ####
Brädets höjd. 1 <= `x` <= 31.

#### `pieces x...` ####
Pjäsernas positioner på brädet vid partiets början. Brädet representeras
som en endimensionell matris av programmet, exakt som den anges här.
Argumentet ska följas av `width × height` antal positiva 8-bitars
heltal, som alla måste vara enskilda bitar (1, 2, 4, ..., 128) eller 0
(för en tom ruta). Varje pjäs som anges måste deklareras med `piece bit
x`.

`width` och `height` måste ha deklarerats innan `pieces`.

#### `squares x...` ####
Rutorna på brädet. Liksom pjäserna representeras dem av endimensionell
matris, med samma längd. 0 betyder att rutan inte tillhör brädet och att
ingen pjäs någonsin kan uppehålla sig på den. Varje ruta som anges måste
deklareras med `square bit x`.

`width` och `height` måste ha deklarerats innan `squares`.

#### `forbid_repeat` ####
Förbjuder upprepning av brädespositioner.

### Argument för pjäser ###

#### `piece bit x` ####
Deklarerar en pjäs med bit `x`. Denna pjäs måste förekomma i `pieces`.
Man kan hänvisa till en pjäs med `piece x <argument>` efter att ha
deklarerat den.

Följande argument kan användas som argument för pjäser:

#### `capt_edge` ####
Anger att pjäsen kan fångas längs med brädets kant. Rutor bredvid
0-rutor anses utgöra kanter.

Om detta argument ges så kan `capt_sides` minska till antalet rutor som
omger pjäsen, när man avgör om den fångas. Om det endast finns 3 rutor
bredvid en pjäs och `capt_sides` är 4, så sänks `capt_sides` tillfälligt
till 3 för att pjäsen ska kunna fångas.

Om det är omöjligt att omringa en pjäs på båda sidorna enligt kravet
`custodial` så kan pjäsen fångas ändå.

Detta har också effekten att om en pjäs, som måste fångas enligt
`custodial`, omringas på alla sidor så fångas den oavsett om den
fångande pjäsen uppfyllde `custodial`-kravet.

Exempel (S har `capt_edge`, `custodial` och `capt_sides 2`):

	| M .
	| . .
	| M .

	| M .
	| S .	# S fångas inte, eftersom det var S som flyttade sig.
	| M .

	| M .	# Här fångas S eftersom han är omringad på alla sidor.
	| S m	# Om !capt_edge, så hade han inte fångats eftersom det
	| M .	# inte finns någon pjäs på motsatt sida om m.

#### `capt_loss` ####
Om spelaren som äger pjäsen förlorar alla pjäser av denna typ, så
förlorar han partiet.

#### `capt_sides x` ####
Anger hur många sidor som pjäsen måste omringas på för att fångas. Ett
giltigt värde är 1 <= `x` <= 4, men observera att endast 2 och 4 används
i tafl och dess varianter. Förval: 2.

#### `captures x` ####
Anger de andra pjäser som pjäsen kan fånga, som en bitmask. Alla
pjäserna måste tillhöra motståndaren. Förval: 0.

#### `custodial` ####
Anger att pjäsen måste omringas på båda sidorna, av en av de fångande
pjäserna, för att fångas. Detta kräver att `capt_sides` är minst 2.

Exempel (S har `capt_sides 2` och `custodial`):

	. M .
	. . .
	. M .

	. M .
	. S .	# S fångas inte, eftersom S flyttade sig.
	. M .

	. M .
	. S m	# S fångas inte, eftersom ingen annan pjäs är på motsatt
	. M .	# sida om m.

#### `dbl_trap` ####
Anger att pjäsen kan utlösa dubbelfångst, alltså att två pjäser
(tillhörande samma spelare) som står bredvid varandra kan fångas om de
båda omringas.

Vid dubbelfångst kan kravet på `custodial` förekomma som vanligt, men
kravet på att pjäsen som flyttade sig måste vara den som omringar pjäsen
på motsatta sidor gäller aldrig.

#### `dbl_trap_capt` ####
Anger att pjäsen fångas vid dubbelfångst. Utan detta så kan pjäsen
endast utlösa fångsten, men fångas ej. Kräver `dbl_trap` och att minst
någon pjäs som ägs av samma spelare har argumentet.

#### `dbl_trap_compl` ####
Dubbelfångst utlöses ej om båda pjäserna som omringas har
`dbl_trap_compl`. Det krävs att minst en pjäs som inte har detta
argument ingår i fångsten. Kräver `dbl_trap` och att minst någon pjäs
som ägs av samma spelare inte har argumentet.

#### `dbl_trap_edge` ####
Vid dubbelfångst bortser man från `capt_edge`, och använder istället
detta argument. Det fungerar på samma sätt. Kräver `dbl_trap`.

#### `dbl_trap_encl` ####
Om detta anges så måste pjäsen omringas helt och hållet för att kunna
utlösa dubbelfångst. Detta fungerar som om `capt_sides` hade varit 4,
och `custodial` gäller inte. Kräver `dbl_trap`.

Om detta inte har angetts, så gäller ordinarie regler (alltså
`capt_sides` och `custodial`) för pjäsen när man avgör om den utlöser
dubbelfångst.

#### `dbl_trap_squares x` ####
Pjäsen måste stå på en ruta som finns i `x` för att regeln om
dubbelfångst ska gälla. Om pjäsen har `dbl_trap` så måste detta
definieras. Förval: 0.

#### `escape` ####
Anger att pjäsen kan fly till rutor med `escape` för att vinna partiet.

#### `noreturn x` ####
Anger de rutor som pjäsen får stå på vid partiets början, men icke
återvända till om han skulle lämna rutorna. Alla rutor i `x` är
sammanhängande i bemärkelsen att om `x = 3` så får pjäsen flytta sig
mellan rutorna 1 och 2 obehindrat, men inte tillbaka till 1 eller 2 om
han skulle flytta till ruta 4. Kräver att pjäsen får stå på rutan över
huvud taget enligt `occupies`. Förval: 0.

#### `occupies x` ####
Anger de rutor som pjäsen får uppehålla sig på. Förval: 0.

#### `owner x` ####
Anger spelaren (0 eller 1) som äger pjäsen. Inget förval — måste anges.

#### `ui_bit x` ####
Detta är ett direktiv till gränssnittet. Gränssnittet bör (om möjligt)
göra så att pjästypen ser ut som pjästypen med bit `x`. Om det inte är
möjligt så får gränssnittet bortse från denna inställning. `x` måste
vara en enskild bit eller 0. 0 betyder att denna inställning inte
används. Förval: 0.

Gränssnittet måste stödja `ui_bit` i största möjliga utsträckning. Både
kommandotolkgränssnittet och X-gränssnittet i `uicx` stöder `ui_bit`.

### Argument för rutor ###

#### `square bit x` ####
Deklarerar en ruta med bit `x`. Denna ruta måste förekomma i `squares`.
Man kan hänvisa till en ruta med `square x <argument>` efter att ha
deklarerat den.

Följande argument kan användas som argument för rutor:

#### `captures x` ####
Anger de andra pjäser som rutan kan fånga, som en bitmask. Förval: 0.

När en pjäs (*a*) flyttar till en ruta bredvid en fiendepjäs (*b*), och
en tom ruta (*c*) är bredvid *b*, och rutan *c* kan fånga *b*, så räknas
rutan *c* som en fiendepjäs till *b*. Observera att detta kräver att
rutan i fråga är tom: om det står en pjäs på rutan, så gäller den
pjäsens `captures` i stället.

#### `capt_sides x` ####
Ersätter `capt_sides` för pjäsen som står på rutan till `x`, om `x` inte
är 0 och om pjäsen finns bland `capt_sides_pieces` (annars har rutan
ingen sådan effekt). Kräver att någon pjäs kan stå på rutan. Förval: 0.

Om värdet är 4 så gäller inte `custodial`. Observera att `capt_sides`
för pjäser inte fungerar på det sättet (men i alla normala spelregler så
är `!custodial` när `capt_sides = 4`, därav detta beteende).

Vid dubbelfångst har `dbl_trap_encl` förtur över denna inställning.

#### `capt_sides_pieces x` ####
Anger att pjäserna i `x` påverkas av rutans `capt_sides -inställning`.
Pjäser som inte finns i `x` påverkas inte. Observera att om `capt_sides`
anges för någon ruta så måste `capt_sides_pieces` innehålla minst en
pjäs (som kan stå på rutan).

#### `escape` ####
Anger att pjäser med `escape` kan fly till rutan för att vinna partiet.

#### `ui_bit x` ####
Fungerar exakt som `ui_bit` för pjäser, men för rutor.



Gränssnitt: kommandotolk
------------------------
Kommandotolken körs alltid när programmet startas. RC-filen är
egentligen bara en fil med kommandon som körs automatiskt i
kommandotolken innan den börjar läsa kommandon från `stdin`. Från
kommandotolken kan man sedan starta X-gränssnittet, och när man stänger
ned X-fönstret så återgår man till kommandotolken.

Skriv `"h"` för hjälp.

Att trycka in `EOF` i `stdin` är detsamma som att ge `"quit"`-kommandot.
Programmet ber aldrig om bekräftelse för något kommando.

### RC-filer ###
Kommandon i RC-filer har vissa begränsningar som kommandotolken inte har
när den läser kommandon från `stdin`.

*	Alla kommandon ekas med `"# "` som prompt (efter att raden
	tolkas och delas upp, så att man ser kommandot som programmet
	ser det).
*	När programmet gissar kataloger så gissar den aldrig det angivna
	filnamnet (*1* i *"Hur programmet gissar kataloger"*).
*	Följande kommandon ignoreras om de har angetts som startargument
	eller miljövariabler:
	-	`-e` gör så att `e` ignoreras.
	-	`-d` eller `$HNEFATAFL_PATH` gör så att `d` ignoreras.
	-	`-l` eller `$HNEFATAFL_LANG` gör så att `l` ignoreras.
	-	`-r` eller `$HNEFATAFL_RULES` gör så att `r` ignoreras.
*	Följande kommandon är förbjudna:
	-	`w` (spara parti)



Gränssnitt: XLib
----------------
Skriv `"h"` för hjälp. Hjälpen i X är något mer kortfattad än i
kommandotolken eftersom endast en rad kan användas till utskrifter, men
det är väsentligen samma kommandon.

### X-terminalen ###
*	Tryck på `<Avbryt>` för att avbryta ett kommando.
*	Tryck på `<Vagnretur>` för att köra ett kommando.
*	Tryck på `<Backsteg>` eller `<Radera>` för att radera ett
	tecken.

Man kan inte flytta textpekaren.

### Teman ###
I temafilen (`<data>/xlib/themes`) finns det (som förval) ett tema som
heter `null`, som inte har en filkatalog. Detta är avsiktligt (och det
är därför det finns en fil som heter `null` — så att man inte ska kunna
skapa en filkatalog med det namnet). Man kan läsa in `null`-temat om man
vill använda reservgrafik.



Översättning
------------
Om du översätter språkfilerna (i `data/lang/`), och om det går bra att
sprida dem under ISC-licensen (se *Licens och garanti*), så får du gärna
skicka dem till mig så att jag kan inkludera dem i programmet.

Syntaxen i språkfilerna är väldigt enkel. Det första ordet, som åtskiljs
av mellanslag eller tabulatorer, är *språknyckeln*. Den används av
programmet för att hitta den översatta textsträngen som visas till
användaren. Man ska inte ändra språknyckeln. Resten av raden är den
översatta textsträngen som ska ändras när man översätter filen. Exempel:

	cli_cmd_game_over	The game is over

Detta kan översättas till svenska genom att ändra raden till:

	cli_cmd_game_over	Partiet är slut

*	Teckenkodningen är UTF-8.
*	Filen är giltig om programmet kan läsa in den.

Man kan skriva ut alla språknycklar som ska finnas med startargumentet
`-L`.



Felsökning
----------
De fel som skrivs ut beskriver oftast vad som är fel. Om ingen språkfil
har lästs in så kan det hända att programmet skriver ut en felkod i
stället. Dessa typer av felkoder finns:

*	`FR`: allmänt fel, t. ex. slut på minne eller I/O-fel.
*	`RREAD`: regelfilen är så pass vanskapt att den inte ens kan
	läsas in. I detta fall brukar programmet skriva ut vilken rad
	som lästes när felet uppstod.
*	`RVALID`: regelfilen kan läsas in men reglerna är inte giltiga.
*	`FRX`: fel i X-gränssnittet.

### Språkfiler ###
När programmet läser in språkfiler så tolereras inte minsta fel. Alla
språknycklar ska vara på plats och ha översatta textsträngar, och inga
okända språknycklar får förekomma — annars nekas filen.

Om du ser märkliga textsträngar som till exempel `"cmd_game_over"` så
beror det på att ingen giltig språkfil har lästs in.

Om man får ett felmeddelande i stil med `"fr_1"` (där `"fr"` är feltypen
och `"1"` är felkoden) så kan man kolla efter den översatta textsträngen
i språkfilen.

### Lokal ###
Om programmet skriver ut ett felmeddelande om `setlocale()`, så är det
för att den inte kan gissa vad `$LC_ALL` eller `$LC_CTYPE` ska vara.
`$LC_ALL` (eller `$LC_CTYPE`) ska helst ange en UTF-8-lokal. Om de två
miljövariablerna inte är definierade så provar programmet `$LANG`.

Om X-gränssnittet inte läser in eller skriver ut UTF-8-tecken på rätt
sätt så är det förmodligen för att `$LC_ALL`, `$LC_CTYPE` eller `$LANG`
inte anger en UTF-8-lokal. Det kan dock även bero på att X inte kan
öppna rätt typsnitt (FontSet). Prova ställa in `$HNEFATAFL_FONT` till
ett typsnitt som du vet finns. Om inte det fungerar så är det något fel
med operativsystemet.

Om inget typsnitt anges så provar programmet först
`"-misc-fixed-medium-r-normal-*-*-140-*-*-*-*-iso10646-*"` och sedan
`"fixed,*"`. Det är rekommenderat att använda ett icke-proportionellt
typsnitt eftersom all text ritas i en terminal.

Programmet gör så att det helst försöker använda den lokal som
användaren har ställt in med `$LC_ALL` (eller liknande). Om inte det går
så faller den tillbaka på de mest grundläggande textfunktionerna, som
använder Latin-1 (vilket gör att UTF-8-tecken inte kommer att fungera).
Om man inte kan få FontSet att fungera så kan man, i värsta fall, tvinga
programmet att använda Latin-1 med startargumentet `-s`. I sådana fall
kommer språkfiler som använder andra tecken än ASCII inte att visas
rätt, såvida man inte gör om deras teckenkodning från UTF-8 till Latin-1
med `iconv`(1).

	iconv -l
	iconv -f UTF-8 -t ISO-8859-1 <fil>

Programmet är dock konstruerat för UTF-8, och knappt testat med andra
teckenkodningar. Programmet förväntas skriva ut konstiga tecken ibland
om man inte använder UTF-8, men det ska aldrig *krascha* på grund av
det (så skicka gärna en felrapport om det händer).



Fel
---
Hashtabellen har två kända fel och kompileras därför inte in i
programmet som förval:

1.	Den gör datorspelaren långsammare.
2.	Den gör så att datorspelaren väljer annorlunda drag ibland, än
	den hade gjort utan hashtabellen (vilket beror på att den inte
	känner till `forbid_repeat`-regeln).



Källor
------
Källorna ska inte klandras för eventuella fel som jag har gjort.

*	[Hnefatafl — the Strategic Board Game of the Vikings](
	http://hem.bredband.net/b512479)
	av *Sten Helmfrid*.
*	[Hnefatafl — the Game of the Vikings](
	http://tafl.cyningstan.org.uk)
	av *Damian Walker*.



Se även
-------
Vǫluspá



Hemsida
-------
`www.hnefatafl.se`



Upphovsman
----------
Alexander Söderlund
`<soderlund` *snabel-a* `tafl` *punkt* `se>`



Med hjälp av
------------
Alexander Dolgunin
`<a` *punkt* `dolgunin` *snabel-a* `gmail` *punkt* `com>`
har bidragit med källkod till `core`-komponenten (se kommentarer i
`board.c`).

Damian Walker (`http://tafl.cyningstan.org.uk`) har bidragit med
regelfiler (alla som börjar med `recon_*`) och regelexpertis.



Upphovsrätt
-----------
Programmet Hnefatafl består av fyra komponenter: `gleipnir`, `core`,
`aim` och `uicx` (se katalogen `src/`).

*	`core` är © 2013-2014 Alexander Söderlund (Sverige) och
	Alexander Dolgunin (Ryssland).
*	`gleipnir`, `aim` och `uicx` är © 2013-2014 Alexander Söderlund
	(Sverige).
*	Följande regelfiler är © 2014 Damian Walker (Storbritannien):
	-	`recon_alea_evangelii`
	-	`recon_brandub`
	-	`recon_coppergate`
	-	`recon_gokstad`
	-	`recon_tablut`
	-	`recon_tawlbwrdd`
	-	`recon_vimose`
*	Denna manual och övriga filer är © 2013-2014 Alexander Söderlund
	(Sverige).

Hela programmet Hnefatafl och alla tillhörande filer (källkod,
regelfiler, instruktionsböcker och andra filer) släpps under
ISC-licensen (se *Licens och garanti* nedan) med tillstånd av alla som
har bidragit till verkets framställande.



Licens och garanti
------------------
Copyright © 2013-2014 Alexander Söderlund (Sweden),
2013-2014 Alexander Dolgunin (Russia),
2014 Damian Walker (United Kingdom)

Permission to use, copy, modify, and distribute this software for any
purpose with or without fee is hereby granted, provided that the above
copyright notice and this permission notice appear in all copies.

THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

