Petar Karan

Save Editor FF8

Di recente ho riscoperto la mia passione per Final Fantasy 8 grazie alla versione remastered di Steam. In realtà volevo rigiocare alla mia vecchia copia da PC, ma poi ho scoperto che non era più possibile installarla su computer a 64-bit (qualcuno suggeriva un’installazione in modalità provvisoria, per poi dover però correggere ben altri problemi!). Così mi sono messo alla ricerca di una soluzione ed ho scoperto che su Steam c’era una versione aggiornata e funzionante anche su Windows 10!

Vecchia copia da PC! Notare l’offerta per “internet gratis” con i vecchi modem 56k.

Adesso non starò ad approfondire i dettagli su questo gioco che amo profondamente (sì ok, quando ci giocai avevo anche una cotta per quel turbodisfattista di Squall), ma quando un gioco gira su PC inevitabilmente viene da chiedersi se ci sarà anche qualche modo meschino per crackarlo o modificarlo a proprio piacimento.

Ed ho scoperto che c’è! Ebbene sì, esiste già un programma perfettamente funzionante per modificare i file di salvataggio del gioco.

Il programma si chiama Hyne (1.9.2), ed è possibile scaricarlo in diverse versioni da Github.

Da quello che ho potuto testare funziona anche sulla versione Steam, e non appena finisco il gioco non mancherò di divertirmi con un po’ di OP.

Il programma è molto intuitivo ed offre una configurazione dettagliata tramite interfacce grafiche dedicate.

Una volta aperto il salvataggio (i salvataggi di Steam si trovano di predefinito nella cartella Documenti %USERPROFILE%\Documents\Square Enix\FINAL FANTASY VIII Steam\user_XXXXXX) ci si presenterà una schermata simile alla precedente, dove potremo selezionare il salvataggio che ci interessa.

Seguiranno una serie di schermate dalle quali sarà possibile modificare nei più piccoli dettagli le caratteristiche del gioco (io devo ancora giungere al garden di Galbadia)

Una volta fatto è sufficiente salvare il file. Consiglio naturalmente di tenere una copia di backup del file originale, per ogni evenienza.

Fonte: Hyne

Interrogare foglio di Excel con SQL in VBA

Obiettivo: interrogare e filtrare il contenuto di un foglio excel come se fosse una tabella di un database SQL

Prepariamo anzitutto un file Excel creando un foglio con dei dati come quelli di seguito:

Questo foglio lo chiamiamo DATI. Faccio notare che nella prima riga ho inserito le intestazioni della nostra tabella.

In un secondo foglio andiamo a creare un pulsante che richiamerà un form. L’idea sarebbe quella di creare un metodo di inserimento che guidi l’utente e gli permetta di filtrare una vasta base dati, eseguendo anche dei comandi di ricerca. Il risultato sarà il seguente:

Se proviamo a cercare qualcosa, per esempio “Mar” l’elenco dovrà essere filtrato e otterremo il risultato seguente:

Fatte queste premesse vediamo come realizzare l’interrogazione del foglio mediante VBA (sorvolo sull’elementare creazione del form).

Anzitutto creiamo una Sub che caricherà i valori nella combobox (cmbSeleziona) e nella listbox (lbSeleziona).

Private Sub LoadSelect(Optional ByVal nome As String = "")

    Dim conn As ADODB.Connection
    Dim rs As ADODB.Recordset
    Dim strFileName As String
    Dim ConnectionString As String
    
    strFileName = ThisWorkbook.FullName
    
    ConnectionString = "Provider=Microsoft.ACE.OLEDB.12.0;Data Source=" _
    & strFileName & ";Extended Properties=""Excel 12.0 xml;HDR=YES;IMEX=1;Readonly=True"";"
    
    Set conn = CreateObject("ADODB.Connection")
    Set rs = CreateObject("ADODB.Recordset")
    
    conn.Open ConnectionString
    
    Dim query As String
    
    If nome <> "" Then
        query = "SELECT * FROM [DATI$A:C] WHERE Nome LIKE '%" & nome & "%'"
    Else
        query = "SELECT * FROM [DATI$A:C]"
    End If
    
    rs.Open query, conn
    
    cmbSeleziona.Clear
    lbSelezione.Clear
    
    pos = 0
    
    If Not rs.EOF Then
        Do
            
            cmbSeleziona.AddItem rs(1) & " [" & rs(2) & "]", pos
            cmbSeleziona.List(pos, 1) = rs(0)
            
            lbSelezione.AddItem rs(1) & " [" & rs(2) & "]", pos
            lbSelezione.List(pos, 1) = rs(0)
            
            pos = pos + 1
            rs.MoveNext
        Loop Until rs.EOF
    End If
    
    rs.Close
    
    conn.Close

End Sub

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

Private Sub LoadSelect(Optional ByVal nome As String = "")

Dim conn As ADODB.Connection

Dim rs As ADODB.Recordset

Dim strFileName As String

Dim ConnectionString As String

strFileName = ThisWorkbook.FullName

ConnectionString = "Provider=Microsoft.ACE.OLEDB.12.0;Data Source=" _

& strFileName & ";Extended Properties=""Excel 12.0 xml;HDR=YES;IMEX=1;Readonly=True"";"

Set conn = CreateObject("ADODB.Connection")

Set rs = CreateObject("ADODB.Recordset")

conn.Open ConnectionString

Dim query As String

If nome <> "" Then

query = "SELECT * FROM [DATI$A:C] WHERE Nome LIKE '%" & nome & "%'"

Else

query = "SELECT * FROM [DATI$A:C]"

End If

rs.Open query, conn

cmbSeleziona.Clear

lbSelezione.Clear

pos = 0

If Not rs.EOF Then

Do

cmbSeleziona.AddItem rs(1) & " [" & rs(2) & "]", pos

cmbSeleziona.List(pos, 1) = rs(0)

lbSelezione.AddItem rs(1) & " [" & rs(2) & "]", pos

lbSelezione.List(pos, 1) = rs(0)

pos = pos + 1

rs.MoveNext

Loop Until rs.EOF

End If

rs.Close

conn.Close

End Sub

Faccio notare che in questo caso la query filtra solamente i valori in base al Nome, inoltre il parametro nome può essere passato in via opzionale, permettendo quindi anche di visualizzare tutti i campi se non c’è nessun nome da filtrare.

Ricordiamoci che per poter eseguire la connessione ADO abbiamo bisogno di importare l’opportuna libreria dai riferimenti.

A questo punto completiamo il nostro codice aggiungendo:

Private Sub txtCerca_Change()

    LoadSelect txtCerca.Text

End Sub

Private Sub UserForm_Initialize()

    LoadSelect

End Sub

1

2

3

4

5

6

7

8

9

10

11

Private Sub txtCerca_Change()

LoadSelect txtCerca.Text

End Sub

Private Sub UserForm_Initialize()

LoadSelect

End Sub

In questo modo ad ogni modifica (change) di txtCerca, che è la textbox di ricerca in cima al form, verrà interrogato il nostro foglio per produrre un risultato.

Il medesimo metodo LoadSelect, questa volta senza argomenti, lo aggiungiamo anche all’avvio del form, per caricare il contenuto completo senza filtri.

Qui è possibile scaricare il file creato con Excel 2016.

Creare un programma con menu e opzioni di scelta in bash

Per gli esercizi dedicati a bash ne propongo uno rielaborato da me qualche mese fa per un corso.

Obiettivo: creare un semplice programma in bash che mostri un menu a schermo e ci permetta di fare delle scelte; in particolare mostrare un elenco di alunni e voti, aggiungere nomi di alunni e relativi voti, svuotare il “database” (in questo caso nient’altro che un file di testo) ed uscire dal programma

#!/bin/bash

#qui salviamo i dati
ELENCO="./alunni.dat"

show_menu() {

        echo
        echo
        echo "-- Elenco studenti --"
        echo "1. Mostra"
        echo "2. Aggiungi"
        echo "3. Svuota"
        echo "q. ESCI"
        echo -en "> "

}

do_menu() {

        i=-1
        while [ "$i" != "q" ]; do
                show_menu
                read i
                i=`echo $i | tr '[A-Z]' '[a-z]'`
                case "$i" in
                        "1")
                        mostra
                        ;;
                        "2")
                        aggiungi
                        ;;
                        "3")
                        svuota
                        ;;
                        "q")
                        echo "Addio, e grazie per tutto il pesce!"
                        exit 0
                        ;;
                        *)
                        echo "Uhm... non ho capito..."
                        ;;
                esac
        done

}

mostra() {
        #elenchiamo tutti gli elementi
        grep -i "" $ELENCO | while read i; do
                echo "$i" | tr ':' '\t'
        done
}

aggiungi() {

        #aggiungi un elemento
        echo "Ti chiederemo 2 dati:"
        echo "  - nome, voto"
        echo
        echo -en "Nome: "
        read nome
        echo -en "Voto: "
        read voto
        echo "${nome}:${voto}" >> $ELENCO

}

conferma() {

        echo -en "$@"
        read risp
        risp=`echo $risp | tr '[a-z]' '[A-Z]'`
        if [ "$risp" == "Y" ]; then
                return 0
        else
                return 1
        fi

}

svuota() {

        conferma "Vuoi cancellare tutti gli studenti? (Y/N) "
        if [ "$?" -eq "0" ]; then
                echo -n "" > $ELENCO
        else
                echo "CANCELLAZIONE ANNULLATA"
        fi

}

do_menu

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

#!/bin/bash

#qui salviamo i dati

ELENCO="./alunni.dat"

show_menu() {

echo

echo "-- Elenco studenti --"

echo "1. Mostra"

echo "2. Aggiungi"

echo "3. Svuota"

echo "q. ESCI"

echo -en "> "

}

do_menu() {

i=-1

while [ "$i" != "q" ]; do

show_menu

read i

i=`echo $i | tr '[A-Z]' '[a-z]'`

case "$i" in

"1")

mostra

;;

"2")

aggiungi

;;

"3")

svuota

;;

"q")

echo "Addio, e grazie per tutto il pesce!"

exit 0

;;

*)

echo "Uhm... non ho capito..."

;;

esac

done

}

mostra() {

#elenchiamo tutti gli elementi

grep -i "" $ELENCO | while read i; do

echo "$i" | tr ':' '\t'

done

}

aggiungi() {

#aggiungi un elemento

echo "Ti chiederemo 2 dati:"

echo " - nome, voto"

echo

echo -en "Nome: "

read nome

echo -en "Voto: "

read voto

echo "${nome}:${voto}" >> $ELENCO

}

conferma() {

echo -en "$@"

read risp

risp=`echo $risp | tr '[a-z]' '[A-Z]'`

if [ "$risp" == "Y" ]; then

return 0

else

return 1

fi

}

svuota() {

conferma "Vuoi cancellare tutti gli studenti? (Y/N) "

if [ "$?" -eq "0" ]; then

echo -n "" > $ELENCO

else

echo "CANCELLAZIONE ANNULLATA"

fi

}

do_menu

Nel nome delle funzioni non c’è niente di speciale, in particolare nelle funzioni showmenu e do_menu che ho chiamato così solo per abitudine, avendolo imparato a mia volta da script in inglese (potremmo dire anche scopiazzato!).

Commentiamo adesso i punti salienti del codice:

Riga 6: show_menu non fa niente di speciale, stampa semplicemente a video una serie di scritte usando echo (quando si usa echo senza una stringa a seguire si ottiene un semplice accapo); l’unico punto veramente interessante è alla riga 15 dove con echo -en ci prepariamo ad acquisire un valore in input. Questo valore in input in realtà viene acquisito dal read nella funzione successiva (riga 24).

Nel caso specifico echo -en vuol dire che passiamo alla funzione echo due parametri

-n evita di aggiungere newline alla fine della stringa, ovvero non manda accapo

-e interpreta eventuali backslash

Per capire meglio come funziona proviamo a scrivere nel terminale le seguenti righe

echo -en "\tmetti il nome"

1	echo -en "\tmetti il nome"

Questo comando darà in output il seguente risultato

        metti il tuo nome

1	metti il tuo nome

Il cursore si troverà in attesa alla fine della stringa ed i caratteri \t saranno trasformati in tabulazione.

Se invece scriviamo:

echo -n "\tmetti il nome"

1	echo -n "\tmetti il nome"

Verrà stampato a video:

\tmetti il tuo nome

1	\tmetti il tuo nome

Senza alcuna tabulazione.

Riga 22: cominciamo un ciclo while finché la variabile $i non sarà uguale a “q”.

Riga 24: leggiamo l’input dopo aver lanciato, alla riga precedente show_menu; l’input verrà letto nella variabile $i; dopo aver acquisito $i trasformiamo eventuali maiuscole in minuscole, in modo che sia premendo Q che q si possa uscire dal programma (questo non è ovviamente necessario, ma lo facciamo a titolo di esercizio).

A questo punto usiamo case per verificare la scelta in $i; in caso di qualsiasi scelta fuorché quelle elencate (riga 40) verrà mostrato un messaggio, qui scherzosamente sdubbiato.

Alla riga 36 invece, quando $i è uguale a “q” eseguiamo l’uscita dal programma con un saluto.

A questo punto costruiamo i metodi elencati dentro case.

Riga 48: il metodo mostra fa semplicemente il grep del contenuto del file e poi lo passa ad un ciclo while che legge ogni riga in $i. Il contenuto del file $ELENCO sarà scritto nel modo seguente:

Mario:10
Luigi:9
Anna:7

Ovvero un elenco di nomi separati da : dai voti; uno per riga. Quindi leggendo il file in righe sostituiamo ad ogni : una tabulazione in modo da stamparli a video uno sotto l’altro e con una tabulazione tra nome e voto.

Riga 55: creiamo il metodo per aggiungere nomi e voti; anche qui l’operazione è molto semplice e giochiamo un po’ con gli echo, per ottenere un’interfaccia da terminale decente. Alla riga 65 assembliamo i valori raccolti nelle precedenti due variabili in una singola stringa di testo che scriviamo sul file $ELENCO.

Riga 82: qui svuotiamo l’elenco degli studenti salvati in $ELENCO, semplicemente cancellando il contenuto dell’intero file. Notiamo qui l’uso diverso di >> e >. Il primo appende alla fine del file il contenuto, mentre > sostituisce l’intero contenuto. In questo caso lo sostituisce con una stringa vuota.

Riga 85: qui usiamo il comando $? per prendere l’output dell’ultimo metodo utilizzato, nel caso specifico il metodo conferma (riga 69). Il metodo conferma scrive a video una stringa presa da $@; la variabile $@ prende la lista di tutti gli argomenti passati al metodo, un po’ come fanno $0, $1 ecc per i singoli argomenti; in questo caso significa semplicemente che li prendiamo tutti. Il metodo legge la risposta e la trasforma tutta in maiuscole, in modo tale che Y e y equivalgano entrambi ad una conferma. Se la risposta è tale la funzione restituisce 0, altrimenti 1. Utilizzando $? controlliamo questo valore restituito e se fa 0 allora cancelliamo tutti i dati, se fa 1 annulliamo la cancellazione.

Riga 93: lanciamo l’intero programma.

Riferimenti utili: base di programmazione in BASH

Verificare integrità file in bash

Presupposto: immaginiamo di avere una cartella sorgente di file e una cartella dove li abbiamo copiati, per esempio durante un backup o solo per sicurezza; a tale proposito rimando all’esercizio precedente di copia dei file in bash

Obiettivo: adesso vogliamo controllare che i file in destinazione siano identici ai file nella copia di sicurezza; un primo modo elementare potrebbe essere quello di confrontare la dimensione dei file, però questo non ci garantisce l’effettiva integrità e che nella medesima dimensione non ci siano in realtà contenuti differenti; un approccio migliore sarebbe quello di confrontare gli hash dei file di origine con quelli della copia. Attenzione però! Perché non dobbiamo solo confrontare i file esistenti, ma verificare anche la presenza di nuovi file o di file mancanti.

Vediamo quindi come scrivere questa procedura in BASH.

#!/bin/bash

#impostazione cartelle
source="./elementi"
dest="./bck"

#contiamo anzitutto le cartelle di backup
#eseguiremo poi il controllo sull'ultimo backup
#confrontandolo con la cartella sorgente
tot=-1

for el in $dest*; do
        if [ -d "$el" ]
        then
                tot=$((tot+1))
        fi
done

#adesso controlliamo gli elementi
controllo(){
if [ $tot -gt -1 ]
then
        for el in $1/*; do
                if [ -d $el ]
                then
                        controllo $el
                else
                        md5sum "$el" | (
                                while read hash nomefile; do
                                        if [ -f "${nomefile/$source/$dest$tot}" ]
                                        then
                                        md5sum "${nomefile/$source/$dest$tot}" | (
                                                while read hashbck nomefilebck; do
                                                        if [ $hash != $hashbck ]
                                                        then
                                                                echo "$nomefile MODIFICATO"
                                                        fi
                                                done
                                        )
                                        else
                                                echo "${nomefile/$source/$dest$tot} NUOVO"
                                        fi
                                done
                        )
                fi
        done
else
        echo "nessuna cartella backup disponibile"
fi
}

controllo $source

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

#!/bin/bash

#impostazione cartelle

source="./elementi"

dest="./bck"

#contiamo anzitutto le cartelle di backup

#eseguiremo poi il controllo sull'ultimo backup

#confrontandolo con la cartella sorgente

tot=-1

for el in $dest*; do

if [ -d "$el" ]

then

tot=$((tot+1))

fi

done

#adesso controlliamo gli elementi

controllo(){

if [ $tot -gt -1 ]

then

for el in $1/*; do

if [ -d $el ]

then

controllo $el

else

md5sum "$el" | (

while read hash nomefile; do

if [ -f "${nomefile/$source/$dest$tot}" ]

then

md5sum "${nomefile/$source/$dest$tot}" | (

while read hashbck nomefilebck; do

if [ $hash != $hashbck ]

then

echo "$nomefile MODIFICATO"

fi

done

)

else

echo "${nomefile/$source/$dest$tot} NUOVO"

fi

done

)

fi

done

else

echo "nessuna cartella backup disponibile"

fi

}

controllo $source

Fino alla riga 17 abbiamo ripreso il codice del precedente esercizio, con un’unica differenza: abbiamo impostato la variabile tot su -1.

In questo modo nella parte successiva possiamo verificare se non esiste alcuna cartella di backup; se c’è una cartella è la cartella bck0, per via della costruzione dell’esercizio precedente, e quindi tot sarà uguale a 0.

Dopodiché costruiamo un metodo chiamato controllo che prende in ingresso un unico argomento (intercettato con $1 all’interno del codice) che è la cartella sorgente. Alla riga 52 passiamo la cartella sorgente iniziale, mentre alla riga 26 passiamo la cartella figlia che troviamo in quella di partenza, in modo da ripetere il controllo in modo ricorsivo.

Alla riga 24 controlliamo, tramite l’if, che l’elemento che stiamo controllando sia una cartella. Se lo è passiamo la cartella al metodo controllo, altrimenti verifichiamo i file.

Per verificare il file lanciamo md5sum sul file originale e leggiamo il risultato come due colonne: hash e nomefile.

Il ciclo while in realtà effettua un’unica operazione, per ogni valore controllato verifichiamo anzitutto se esiste o meno all’interno del backup. Se non esiste lanciamo in output il messaggio alla riga 41. Altrimenti lanciamo il comando md5sum sul file nel backup; con lo stesso principio di prima effettuiamo la lettura dell’output mettendo il risultato in altre due variabili, ovvero hashbck e nomefilebck. A questo punto confrontiamo che i due hash siano identici, in caso contrario (!= vuol dire diverso) lanciamo un output, quello della riga 36.

Notiamo che se va tutto bene non viene lanciato alcun output, ma solo in caso di errore.

TODO: In questo controllo manca la verifica che eventuali file presenti nel backup non siano stati cancellati dalla cartella sorgente.

Semplice script di backup (copia di file) in bash

Vediamo creare un elementare sistema di backup in BASH. In questo caso supponiamo di avere, nella posizione in cui viene eseguito il codice, una cartella chiamata elementi, dentro la quale abbiamo tutti i file e le cartelle che desideriamo copiare dentro la destinazione di backup. La destinazione di backup è la medesima dello script (non entro ora nel merito sul buon senso di fare qualcosa di simile) dove verranno create n cartelle consecutive per tutti i backup effettuati. Le cartelle saranno quindi chiamate bck0, bck1 … bckn.

#!/bin/bash

#impostazioni generali
source="./elementi"
dest="./bck"

#contiamo anzitutto le cartelle di backup
#che sono già state create
tot=0

for el in "$dest*"; do
        if [ -d "$el" ]
        then
                tot=$((tot+1))
        fi
done

#facciamo il backup nella nuova cartella
mkdir "$dest$tot/"
cp -a "$source/." "$dest$tot/"

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

#!/bin/bash

#impostazioni generali

source="./elementi"

dest="./bck"

#contiamo anzitutto le cartelle di backup

#che sono già state create

tot=0

for el in "$dest*"; do

if [ -d "$el" ]

then

tot=$((tot+1))

fi

done

#facciamo il backup nella nuova cartella

mkdir "$dest$tot/"

cp -a "$source/." "$dest$tot/"

Faccio notare che la prima parte dello script, quella con il ciclo for, serve solo a contare il numero di cartelle di backup attualmente esistenti, per poter creare così la cartella successiva. Se non esiste alcuna cartella il contatore rimane a 0 e crea la prima cartella zeresima, chiamata bck0. Quando si usa la seconda volta le cartelle sono 1, la cartella bck0, e quindi la variabile tot assume valore 1. E così via ad ogni passaggio successivo.

Il backup vero e proprio viene effettuato nell’ultima parte del codice (le ultime due righe), dove creiamo la nuova cartella unendo il nome di dest al numero in tot e poi usiamo il comando cp -a (copia ricorsivamente tutti i file e le cartelle).

Labirinto disegnato in PHP

Per gli appassionati di Pathfinder come me capita di fare il master e voler proporre qualche simpatico labirinto ai propri avventurieri. Online si trovano già moltissimi generatori di dungeon, però ho deciso di svagarmi un po’ questo sabato pomeriggio creando uno tutto mio in PHP.

Questo è il risultato (si rigenera ad ogni refresh della pagina):

Vediamo il codice sufficiente per ottenerlo:

<?php

// per evitare eventuali avvisi nell'output jpeg
error_reporting(0);
// diamo qualche secondo di più per generare labirinti più grandi
set_time_limit(120);

class Labirinto {
	
	// dimensione mappa predefinita in larghezza (w) e altezza (h)
	private $w = 800;
	private $h = 800;
	// colore del labirinto
	private $fgcolor = array(255,255,255);
	// colore dello sfondo del labirinto
	private $bgcolor = array(0,0,0);
	// dimensione di ogni quadretto
	private $pixel = 4;
	
	// ingresso nel labirinto come coordinate w, h; oppure x, y
	private $sw = 1;
	private $sh = 0;
	
	// massimo numero di iterazioni per generare un singolo percorso
	private $max = 100000;
	// numero di iterazioni attuali
	private $cont = 0;
	
	// matrice della mappa base con ingresso predefinito, array di array
	private $map = array(array(0,1,0));
	
	// variabile per tenere conto dell'uscita dal labirinto
	// quando viene disegnata un'uscita la variabile diventa TRUE
	private $exit = false;
	
	function __construct() {
		
	}
	
	// impostazione variabili predefinite, larghezza, altezza e dimensione quadretti
	function set($w,$h,$pixel = 4) {
		$this->w = $w;
		$this->h = $h;
		$this->pixel = $pixel;
	}
	
	// genera labirinto
	function get() {
		
		$this->max = $this->w * $this->h;
		
		$this->build();

		$this->draw();
		
	}
	
	// costruisci labirinto
	function build() {
		
		// crea il primo ramo a partire dalla posizione predefinita
		$this->go($this->sw,$this->sh);
		
		// ripassa il labirinto aggiungendo rami aggiuntivi
		// ripetiamo per 4 volte (niente di speciale in questo numero) per migliorare il riempimento
		for( $k = 0; $k < 4; $k++ ) {
			for( $r = 0; $r < $this->h; $r++ ) {
				for( $c = 0; $c < $this->w; $c++ ) {
					
					if( $this->map[$r][$c] ) {
						
						$this->go($c,$r);
						
					}
					
				}
			}
		}
		
	}
	
	// genera un ramo del labirinto
	function go( $w, $h ) {
		
		$dest = -1;
		$try = 0;
		while( true ) {
			
			if( $dest < 0 ) {
				$dest = rand(0,3);
			} else {
				$dest = (++$dest)%4;
			}
			
			$try++;
				
			switch( $dest ) {
				case 0: $dw = $w; $dh = $h-1; break;
				case 1: $dw = $w+1; $dh = $h; break;
				case 2: $dw = $w; $dh = $h+1; break;
				case 3: $dw = $w-1; $dh = $h; break;
			}
			
			
			if( $this->map[$dh][$dw] == 0 && ( ($dw > 0 && $dw < $this->w-1 && $dh > 0 && $dh < $this->h-1) || ($this->exit == false && $dh == $this->h-1)) ) {
				if( $this->check($dw,$dh,1,0,0,0) || $this->check($dw,$dh,0,1,0,0) || $this->check($dw,$dh,0,0,1,0) || $this->check($dw,$dh,0,0,0,1) ) {
					if( $this->ctrl($dw,$dh) ) {
						$this->map[$dh][$dw] = 1;
						$this->cont++;
						if( $this->exit == false && $dh == $this->h-1 ) $this->exit = true;
						if( $this->cont < $this->max ) $this->go($dw,$dh);
						break;
					}
				}
			}
			
			if( $this->check($w,$h,1,1,1,1) ) break;
			if( $this->check($w,$h,0,1,1,1) && $dh == 0 ) break;
			if( $this->check($w,$h,1,1,0,1) && $dh == $this->h-1 ) break;
			if( $this->check($w,$h,1,1,1,0) && $dw == 0 ) break;
			if( $this->check($w,$h,1,0,1,1) && $dw == $this->w-1 ) break;
			
			if( $try > 4 ) break;
		}
		
	}
	
	// verifichiamo la posizione di passaggi di celle esistenti rispetto a quella attuale
	// parametri: width, height, top, right, bottom, left
	// impostiamo quindi su width e height la posizione
	// impostiamo su t, r, b, l i valori a 0 o 1, in base che ci debbano o meno essere delle celle
	function check($w,$h,$t,$r,$b,$l) {
		return $this->map[$h-1][$w] == $t && $this->map[$h][$w+1] == $r && $this->map[$h+1][$w] == $b && $this->map[$h][$w-1] == $l;
	}
	
	// verifichiamo la posizione di celle esistenti in diagonale, secondo lo schema top-left, top-right, bottom-right, bottom-left
	function checkd($w,$h,$tl,$tr,$br,$bl) {
		return $this->map[$h-1][$w-1] == $tl && $this->map[$h-1][$w+1] == $tr && $this->map[$h+1][$w-1] == $br && $this->map[$h+1][$w+1] == $bl;
	}
	
	// controllo aggiunti sullo stato della singola cella, verifichiamo che si possa procedere e non ci siano accanti celle piene
	function ctrl($w,$h) {
		
		$ctrl = true;
		
		$ctrl = $ctrl && !($this->map[$h][$w-1] == 0 && $this->map[$h-1][$w-1] == 1 && $this->map[$h-1][$w] == 0);
		$ctrl = $ctrl && !($this->map[$h-1][$w] == 0 && $this->map[$h-1][$w+1] == 1 && $this->map[$h][$w+1] == 0);
		$ctrl = $ctrl && !($this->map[$h][$w+1] == 0 && $this->map[$h+1][$w+1] == 1 && $this->map[$h+1][$w] == 0);
		$ctrl = $ctrl && !($this->map[$h+1][$w] == 0 && $this->map[$h+1][$w-1] == 1 && $this->map[$h][$w-1] == 0);
		
		return $ctrl;
		
	}
	
	// disegna labirinto su output jpeg
	function draw() {
		
		header("Content-Type: image/png");
		$im = @imagecreate($this->w * $this->pixel, $this->h * $this->pixel) or die("Cannot Initialize new GD image stream");
		$background_color = imagecolorallocate($im, $this->bgcolor[0], $this->bgcolor[1], $this->bgcolor[2]);
		
		$this->map($im);
		
		imagejpeg($im,NULL,100);
		imagedestroy($im);

	}
	
	// prepara la mappa in base ai valori 0 e 1, 0 celle vuote, 1 celle del labirinto
	function map(&$im) {
		
		$fc = @imagecolorallocate($im, $this->fgcolor[0], $this->fgcolor[1], $this->fgcolor[2]); 
		$bc = @imagecolorallocate($im, $this->bgcolor[0], $this->bgcolor[1], $this->bgcolor[2]); 
		
		for( $r = 0; $r < $this->h; $r++ ) {
			for( $c = 0; $c < $this->w; $c++ ) {
				
				for( $ph = 0; $ph < $this->pixel; $ph++ )
					for( $pw = 0; $pw < $this->pixel; $pw++ )
						if( $this->map[$r][$c] ) {
							imagesetpixel($im,$c*$this->pixel+$ph,$r*$this->pixel+$pw,$fc);
						} else {
							imagesetpixel($im,$c*$this->pixel+$ph,$r*$this->pixel+$pw,$bc);
						}
				
			}
		}
		
	}
	
	
}

$lab = new Labirinto();
$lab->set(30,30,16);
$lab->get();

?>

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

<?php

// per evitare eventuali avvisi nell'output jpeg

error_reporting(0);

// diamo qualche secondo di più per generare labirinti più grandi

set_time_limit(120);

class Labirinto {

// dimensione mappa predefinita in larghezza (w) e altezza (h)

private $w = 800;

private $h = 800;

// colore del labirinto

private $fgcolor = array(255,255,255);

// colore dello sfondo del labirinto

private $bgcolor = array(0,0,0);

// dimensione di ogni quadretto

private $pixel = 4;

// ingresso nel labirinto come coordinate w, h; oppure x, y

private $sw = 1;

private $sh = 0;

// massimo numero di iterazioni per generare un singolo percorso

private $max = 100000;

// numero di iterazioni attuali

private $cont = 0;

// matrice della mappa base con ingresso predefinito, array di array

private $map = array(array(0,1,0));

// variabile per tenere conto dell'uscita dal labirinto

// quando viene disegnata un'uscita la variabile diventa TRUE

private $exit = false;

function __construct() {

}

// impostazione variabili predefinite, larghezza, altezza e dimensione quadretti

function set($w,$h,$pixel = 4) {

$this->w = $w;

$this->h = $h;

$this->pixel = $pixel;

}

// genera labirinto

function get() {

$this->max = $this->w * $this->h;

$this->build();

$this->draw();

}

// costruisci labirinto

function build() {

// crea il primo ramo a partire dalla posizione predefinita

$this->go($this->sw,$this->sh);

// ripassa il labirinto aggiungendo rami aggiuntivi

// ripetiamo per 4 volte (niente di speciale in questo numero) per migliorare il riempimento

for( $k = 0; $k < 4; $k++ ) {

for( $r = 0; $r < $this->h; $r++ ) {

for( $c = 0; $c < $this->w; $c++ ) {

if( $this->map[$r][$c] ) {

$this->go($c,$r);

}

// genera un ramo del labirinto

function go( $w, $h ) {

$dest = -1;

$try = 0;

while( true ) {

if( $dest < 0 ) {

$dest = rand(0,3);

} else {

$dest = (++$dest)%4;

}

$try++;

switch( $dest ) {

case 0: $dw = $w; $dh = $h-1; break;

case 1: $dw = $w+1; $dh = $h; break;

case 2: $dw = $w; $dh = $h+1; break;

case 3: $dw = $w-1; $dh = $h; break;

}

if( $this->map[$dh][$dw] == 0 && ( ($dw > 0 && $dw < $this->w-1 && $dh > 0 && $dh < $this->h-1) || ($this->exit == false && $dh == $this->h-1)) ) {

if( $this->check($dw,$dh,1,0,0,0) || $this->check($dw,$dh,0,1,0,0) || $this->check($dw,$dh,0,0,1,0) || $this->check($dw,$dh,0,0,0,1) ) {

if( $this->ctrl($dw,$dh) ) {

$this->map[$dh][$dw] = 1;

$this->cont++;

if( $this->exit == false && $dh == $this->h-1 ) $this->exit = true;

if( $this->cont < $this->max ) $this->go($dw,$dh);

break;

}

if( $this->check($w,$h,1,1,1,1) ) break;

if( $this->check($w,$h,0,1,1,1) && $dh == 0 ) break;

if( $this->check($w,$h,1,1,0,1) && $dh == $this->h-1 ) break;

if( $this->check($w,$h,1,1,1,0) && $dw == 0 ) break;

if( $this->check($w,$h,1,0,1,1) && $dw == $this->w-1 ) break;

if( $try > 4 ) break;

}

// verifichiamo la posizione di passaggi di celle esistenti rispetto a quella attuale

// parametri: width, height, top, right, bottom, left

// impostiamo quindi su width e height la posizione

// impostiamo su t, r, b, l i valori a 0 o 1, in base che ci debbano o meno essere delle celle

function check($w,$h,$t,$r,$b,$l) {

return $this->map[$h-1][$w] == $t && $this->map[$h][$w+1] == $r && $this->map[$h+1][$w] == $b && $this->map[$h][$w-1] == $l;

}

// verifichiamo la posizione di celle esistenti in diagonale, secondo lo schema top-left, top-right, bottom-right, bottom-left

function checkd($w,$h,$tl,$tr,$br,$bl) {

return $this->map[$h-1][$w-1] == $tl && $this->map[$h-1][$w+1] == $tr && $this->map[$h+1][$w-1] == $br && $this->map[$h+1][$w+1] == $bl;

}

// controllo aggiunti sullo stato della singola cella, verifichiamo che si possa procedere e non ci siano accanti celle piene

function ctrl($w,$h) {

$ctrl = true;

$ctrl = $ctrl && !($this->map[$h][$w-1] == 0 && $this->map[$h-1][$w-1] == 1 && $this->map[$h-1][$w] == 0);

$ctrl = $ctrl && !($this->map[$h-1][$w] == 0 && $this->map[$h-1][$w+1] == 1 && $this->map[$h][$w+1] == 0);

$ctrl = $ctrl && !($this->map[$h][$w+1] == 0 && $this->map[$h+1][$w+1] == 1 && $this->map[$h+1][$w] == 0);

$ctrl = $ctrl && !($this->map[$h+1][$w] == 0 && $this->map[$h+1][$w-1] == 1 && $this->map[$h][$w-1] == 0);

return $ctrl;

}

// disegna labirinto su output jpeg

function draw() {

header("Content-Type: image/png");

$im = @imagecreate($this->w * $this->pixel, $this->h * $this->pixel) or die("Cannot Initialize new GD image stream");

$background_color = imagecolorallocate($im, $this->bgcolor[0], $this->bgcolor[1], $this->bgcolor[2]);

$this->map($im);

imagejpeg($im,NULL,100);

imagedestroy($im);

}

// prepara la mappa in base ai valori 0 e 1, 0 celle vuote, 1 celle del labirinto

function map(&$im) {

$fc = @imagecolorallocate($im, $this->fgcolor[0], $this->fgcolor[1], $this->fgcolor[2]);

$bc = @imagecolorallocate($im, $this->bgcolor[0], $this->bgcolor[1], $this->bgcolor[2]);

for( $r = 0; $r < $this->h; $r++ ) {

for( $c = 0; $c < $this->w; $c++ ) {

for( $ph = 0; $ph < $this->pixel; $ph++ )

for( $pw = 0; $pw < $this->pixel; $pw++ )

if( $this->map[$r][$c] ) {

imagesetpixel($im,$c*$this->pixel+$ph,$r*$this->pixel+$pw,$fc);

} else {

imagesetpixel($im,$c*$this->pixel+$ph,$r*$this->pixel+$pw,$bc);

}

$lab = new Labirinto();

$lab->set(30,30,16);

$lab->get();

?>

Le impostazioni nell’esempio sono le medesime per ottenere l’immagine di sopra.

Calcolare IRR (Internal Rate of Return o TIR.COST) in VBA

Problema: la funzione TIR.COST (Tasso Interno di Rendimento) restituisce un unico valore per l’IRR anche quando ce ne è più di uno

Senza discutere sull’interpretazione dell’IRR stesso, immaginiamo di avere i seguenti due scenari di flusso di cassa.

I Scenario

Questo produce un grafico VAN-IRR come quello seguente:

In questo caso abbiamo due valori dell’IRR rispettivamente 15,47% e 33,33%; la funzione TIR.COST restituisce solamente il primo valore.

II Scenario

A questa serie di flussi di cassa corrisponde il seguente grafico:

In questo caso abbiamo due valori dell’IRR rispettivamente 1,99% e 19,65%; la funzione TIR.COST restituisce solamente il secondo valore.

Costruiamo quindi in VBA le funzioni necessarie per effettuare questo calcolo; come già mostrato anche qui utilizzeremo una funzione che restituisca un vettore di valori sotto forma di Variant, in modo da poterli valutare singolarmente (per esempio utilizzando le funzioni MIN e MAX, quando i valori sono solo due, quindi =MIN(IRRX(A1:A10)) oppure =MAX(IRRX(A1:A10))).

La funzione finale si chiama IRRX, quella che utilizzeremo dentro il foglio excel.

Public Function IRRX(ByVal intervallo As Range, Optional ByVal max As Double = 300) As Variant

    Dim n As Integer
    Dim i As Double
    Dim irrs, ris As Variant
    irrs = IRRv1(intervallo, 0.01, max)
    
    ReDim ris(1 To 1)
    
    n = 0
    
    For k = 1 To UBound(irrs)
    
        i = irrs(k)
        
        Dim tmp As Variant
        tmp = IRRv2(intervallo, i - 0.01, i + 0.01)
        n = n + 1
        
        ReDim Preserve ris(1 To n)
        
        ris(n) = tmp
    
    Next k
    
    IRRX = ris

End Function

Private Function IRRv1(ByVal intervallo As Range, Optional ByVal delta As Double = 0.01, Optional ByVal max As Double = 300, Optional ByVal start As Double = 0) As Variant

    Dim irrs As Variant
    Dim VAN, VAN_prec, tir_prec As Double
    Dim anno, nirr As Integer
    
    ReDim irrs(1 To 1)
    
    nirr = 0
    
    For tir = start To max Step delta
        
        VAN = 0
        anno = 0
        
        For Each c In intervallo
        
            VAN = VAN + c.Value / (1 + tir) ^ anno
            
            anno = anno + 1
        
        Next c
        
        If tir > start And VAN_prec * VAN <= 0 Then
            
            nirr = nirr + 1
            
            ReDim Preserve irrs(1 To nirr)
            irrs(nirr) = (tir + tir_prec) / 2
            
        End If
        
        VAN_prec = VAN
        tir_prec = tir
        
    Next tir
    
    IRRv1 = irrs

End Function

Private Function IRRv2(ByVal flusso As Range, ByVal min As Double, ByVal max As Double) As Double

    For i = 0 To 100
    
        tmin = VAN(flusso, min)
        tmax = VAN(flusso, max)
        tavg = VAN(flusso, (max + min) / 2)
        
        If tavg = 0 Then
            Exit For
        End If
        
        If tmin * tavg < 0 Then
            max = (max + min) / 2
        Else
            min = (max + min) / 2
        End If
        
    Next i
    
    IRRv2 = (max + min) / 2

End Function

Private Function VAN(ByVal intervallo As Range, ByVal tir As Double) As Double

    Dim tmp As Double
    Dim anno As Integer
    
    tmp = 0
    anno = 0
    
    For Each c In intervallo
        
        tmp = tmp + c.Value / (1 + tir) ^ anno
        
        anno = anno + 1
    
    Next c
    
    VAN = tmp

End Function

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

101

102

103

104

105

106

107

108

109

110

111

112

113

Public Function IRRX(ByVal intervallo As Range, Optional ByVal max As Double = 300) As Variant

Dim n As Integer

Dim i As Double

Dim irrs, ris As Variant

irrs = IRRv1(intervallo, 0.01, max)

ReDim ris(1 To 1)

n = 0

For k = 1 To UBound(irrs)

i = irrs(k)

Dim tmp As Variant

tmp = IRRv2(intervallo, i - 0.01, i + 0.01)

n = n + 1

ReDim Preserve ris(1 To n)

ris(n) = tmp

Next k

IRRX = ris

End Function

Private Function IRRv1(ByVal intervallo As Range, Optional ByVal delta As Double = 0.01, Optional ByVal max As Double = 300, Optional ByVal start As Double = 0) As Variant

Dim irrs As Variant

Dim VAN, VAN_prec, tir_prec As Double

Dim anno, nirr As Integer

ReDim irrs(1 To 1)

nirr = 0

For tir = start To max Step delta

VAN = 0

anno = 0

For Each c In intervallo

VAN = VAN + c.Value / (1 + tir) ^ anno

anno = anno + 1

Next c

If tir > start And VAN_prec * VAN <= 0 Then

nirr = nirr + 1

ReDim Preserve irrs(1 To nirr)

irrs(nirr) = (tir + tir_prec) / 2

End If

VAN_prec = VAN

tir_prec = tir

Next tir

IRRv1 = irrs

End Function

Private Function IRRv2(ByVal flusso As Range, ByVal min As Double, ByVal max As Double) As Double

For i = 0 To 100

tmin = VAN(flusso, min)

tmax = VAN(flusso, max)

tavg = VAN(flusso, (max + min) / 2)

If tavg = 0 Then

Exit For

End If

If tmin * tavg < 0 Then

max = (max + min) / 2

Else

min = (max + min) / 2

End If

Next i

IRRv2 = (max + min) / 2

End Function

Private Function VAN(ByVal intervallo As Range, ByVal tir As Double) As Double

Dim tmp As Double

Dim anno As Integer

tmp = 0

anno = 0

For Each c In intervallo

tmp = tmp + c.Value / (1 + tir) ^ anno

anno = anno + 1

Next c

VAN = tmp

End Function

Le altre funzioni servono rispettivamente a:

IRRv1 – calcolare in modo approssimativo tutti gli IRR possibili su uno specifico flusso di cassa, con valore massimo per l’IRR al 30.000% (espresso come max = 300), inutile dire come questo valore possa essere impostato anche a molto meno per velocizzare i calcoli; l’IRR qui viene calcolato per ogni punto percentuale con scarti del 1%
IRRv2 – qui calcoliamo, per ogni valore di IRR trovato con la precedente funzione, il valore approssimato mediante iterazione su valori che vanno da IRRv2 ± 1%
VAN – questa funziona calcola semplicemente il VAN sul dato IRR

Testato su Excel 2016.

Creare una funzione personalizzata in VBA per Excel che restituisca una matrice

Obiettivo: creare una funzione personalizzata in Excel che restituisca come risultato una matrice n x m

Supponiamo di voler realizzare una funzione personalizzata in Excel che effettui la medesima operazione di MATR.PRODOTTO, ma allo stesso tempo consideri sempre la matrice in ingresso A come una matrice n x 1 e la matrice in ingresso B come una matrice 1 x m. Facciamo questa semplificazione a titolo di esempio.

Quindi abbiamo due matrici tipo queste:

$A = \begin{bmatrix} a_1 \\ a_2 \\ a_3 \end{bmatrix} B = \begin{bmatrix} b_1 & b_2 & b_3 \end{bmatrix}$

Il loro prodotto risulterà così:

$A \times B= \begin{bmatrix} a_1b_1 & a_1b_2 & a_1b_3 \\ a_2b_1 & a_2b_2 & a_2b_3 \\ a_3b_1 & a_3b_2 & a_3b_3 \end{bmatrix}$

Nel nostro modulo aggiungiamo ora il seguente codice:

Public Function MATH_MATRICE(matrice1 As Range, matrice2 As Range) As Variant

    Dim risultato() As Variant
    
    ReDim risultato(1 To matrice1.Count, 1 To matrice2.Count)

    For rig = 1 To matrice1.Count
        For col = 1 To matrice2.Count
            risultato(rig, col) = matrice1(rig) * matrice2(col)
        Next col
    Next rig
    
    MATH_MATRICE = risultato

End Function

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

Public Function MATH_MATRICE(matrice1 As Range, matrice2 As Range) As Variant

Dim risultato() As Variant

ReDim risultato(1 To matrice1.Count, 1 To matrice2.Count)

For rig = 1 To matrice1.Count

For col = 1 To matrice2.Count

risultato(rig, col) = matrice1(rig) * matrice2(col)

Next col

Next rig

MATH_MATRICE = risultato

End Function

Notiamo che in questo modo vengono percorsi tutti i valori del range, indipendentemente dalla loro geometria, come se fossero in una riga o colonna.

Per testare il risultato possiamo fare una verifica su un esempio con la funzione MATR.SOMMA.PRODOTTO. Nel caso specifico creiamo una versione e parametrizzabile del SOMMA.PIÙ.SE.

A1:A7 e B1:B7 sono riempiti con valori da esempio. E2:H2 saranno quattro spazi dove potremo inserire, a nostro piacimento da 0 a 4 nominativi da verificare. In E3 abbiamo la seguente formula di controllo (NB: fatta con MATR.PRODOTTO):

=MATR.SOMMA.PRODOTTO(–(A2:A7=E2:H2);MATR.PRODOTTO(B2:B7;E1:H1))

In E4 aggiungiamo invece la formula con la nostra versione di MATR.PRODOTTO:

=MATR.SOMMA.PRODOTTO(–(A2:A7=E2:H2);MATH_MATRICE(B2:B7;E1:H1))

Scopo raggiunto.

Creare mappa personalizzata in Civilization VI

Creare una mappa personalizzata in Civilization VI è estremamente facile (e anche molto divertente).

Il gioco integra un World Builder a cui si può accedere dai contenuti aggiuntivi.

L’editor non è dei migliori, dal punto di vista grafico e dell’utilizzabilità, però fa il suo sporco dovere. Basterà fare un po’ di prove per capire come funziona. Una caratteristica in particolare, da tenere a mente, è l’inserimento delle città stato, che normalmente dovrebbe avvenire tramite script e che altrimenti dobbiamo mettere a mano.

Per farlo sarà sufficiente impostare il leader desiderato come “caratteristica del terreno“, nel modo seguente:

Clicchiamo sulla casella nella quale vogliamo mettere la città stato e poi impostiamo la Start Position su Leader e nel menu a tendina di sotto il nome della città stato che vogliamo inserire.

Una volta creata la nostra mappa premiamo ESC e salviamo dal menu, come se stessimo salvando il gioco.

Da impostazione predefinita la mappa viene salvata con estensione *.Cvi6Map in:

%UserProfile%\Documents\My Games\Sid Meier’s Civilization VI\Saves\WorldBuilder

A questo punto per aggiungerla alle mappe giocabili nel gioco è sufficiente apportare un paio di modifiche.

Nel mio esempio il gioco è installato su Steam, quindi ci spostiamo su:

%ProgramFiles%\Steam\steamapps\common\Sid Meier’s Civilization VI\Base\Assets\Configuration\Data

Qui dentro si trovano i file XML con tutte le mappe giocabili nel gioco, possiamo aprirne alcuni per capire come funziona la cosa e poi crearne uno nostro personale, da aggiungere a quelli esistenti. Il file si potrebbe chiamare per esempio LeMieMappe.xml (faccio notare come il nome del file è assolutamente irrilevante, purché sia un file XML e probabilmente non contenga caratteri speciali).

Adesso vediamo un esempio di configurazione base (nel mio esempio ho spostato la mappa dalla posizione di salvataggio in

%ProgramFiles%\Steam\steamapps\common\Sid Meier’s Civilization VI\Base\Assets\Maps\Extra (ma questo cambiamento non è obbligatorio)

<?xml version="1.0" encoding="utf-8"?>
<GameInfo>
	<Maps>
		<Row File="../../Assets/Maps/Extra/Foo.Civ6Map" Name="Foo" Description="Descrizione Mappa" SortIndex="200"/>
	</Maps>
	<MapSizes>
		<Row Domain="../../Assets/Maps/Extra/Foo.Civ6Map" MapSizeType="MAPSIZE_HUGE" Name="LOC_MAPSIZE_HUGE_NAME" Description="LOC_MAPSIZE_HUGE_DESCRIPTION" MinPlayers="2" MaxPlayers="12" DefaultPlayers="12" MinCityStates="12" MaxCityStates="18" DefaultCityStates="18" SortIndex="100"/>
	</MapSizes>
</GameInfo>

1

2

3

4

5

6

7

8

9

<?xml version="1.0" encoding="utf-8"?>

<Maps>

</Maps>

</MapSizes>

</GameInfo>

Faccio notare alcune caratteristiche interessanti:

Maps: definisce il percorso della mappa, il nome e la descrizione che appariranno a video, oltre che un indice per l’ordinamento, ovvero la posizione in cui farla apparire assieme a tutte le altre mappe

MapSizes: definisce i parametri entro i quali può essere configurato il gioco, oltre che la dimensione predefinita, il numero minimo e massimo di giocatori ecc.

In questo unico file potremmo aggiungere n mappe, specificando i dettagli in entrambi i tag.

concurrent.futures.process.BrokenProcessPool eseguendo QuantumProgram di qiskit-sdk

Soluzione: il codice eseguito in Python deve essere protetto, o meglio “guarded”, ciò significa che il QuantumProgram deve essere eseguito dentro ad un’istruzione if __name__ == “__main__”

Compilando il programma nell’esempio nel qiskit-sdk-py si incorre nel seguente errore durante l’esecuzione:

Traceback (most recent call last):
  File "C:\Users\....\...\first.py", line 35, in <module>
    print(result.get_data("bell"))
  File "D:\Python36\lib\site-packages\qiskit\_result.py", line 204, in get_data
    raise exception
  File "D:\Python36\lib\site-packages\qiskit\_jobprocessor.py", line 99, in _job_done_callback
    result = future.result()
  File "D:\Python36\lib\concurrent\futures\_base.py", line 425, in result
    return self.__get_result()
  File "D:\Python36\lib\concurrent\futures\_base.py", line 384, in __get_result
    raise self._exception
concurrent.futures.process.BrokenProcessPool: A process in the process pool was terminated abruptly while the future was running or pending.

1

2

3

4

5

6

7

8

9

10

11

12

Traceback (most recent call last):

File "C:\Users\....\...\first.py", line 35, in <module>

print(result.get_data("bell"))

File "D:\Python36\lib\site-packages\qiskit\_result.py", line 204, in get_data

raise exception

File "D:\Python36\lib\site-packages\qiskit\_jobprocessor.py", line 99, in _job_done_callback

result = future.result()

File "D:\Python36\lib\concurrent\futures\_base.py", line 425, in result

return self.__get_result()

File "D:\Python36\lib\concurrent\futures\_base.py", line 384, in __get_result

raise self._exception

concurrent.futures.process.BrokenProcessPool: A process in the process pool was terminated abruptly while the future was running or pending.

Questo accade perché si tentano di avviare delle biforcazioni del processo originale senza aver utilizzato un idioma appropriato per il modulo. Per correggere il problema è sufficiente reimpostare il codice eseguibile in questo modo:

from qiskit import QuantumProgram, QISKitError, RegisterSizeError

# Create a QuantumProgram object instance.
Q_program = QuantumProgram()

if __name__ == "__main__":
    backend = 'local_qasm_simulator'
    try:
        # Create a Quantum Register called "qr" with 2 qubits.
        qr = Q_program.create_quantum_register("qr", 2)
        # Create a Classical Register called "cr" with 2 bits.
        cr = Q_program.create_classical_register("cr", 2)
        # Create a Quantum Circuit called "qc" involving the Quantum Register "qr"
        # and the Classical Register "cr".
        qc = Q_program.create_circuit("bell", [qr], [cr])

        # Add the H gate in the Qubit 0, putting this qubit in superposition.
        qc.h(qr[0])
        # Add the CX gate on control qubit 0 and target qubit 1, putting 
        # the qubits in a Bell state
        qc.cx(qr[0], qr[1])

        # Add a Measure gate to see the state.
        qc.measure(qr, cr)

        # Compile and execute the Quantum Program in the local_qasm_simulator.
        result = Q_program.execute(["bell"], backend=backend, shots=1024, seed=1)

        # Show the results.
        print(result)
        print(result.get_data("bell"))

    except QISKitError as ex:
        print('There was an error in the circuit!. Error = {}'.format(ex))
    except RegisterSizeError as ex:
        print('Error in the number of registers!. Error = {}'.format(ex))

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

from qiskit import QuantumProgram, QISKitError, RegisterSizeError

# Create a QuantumProgram object instance.

Q_program = QuantumProgram()

if __name__ == "__main__":

backend = 'local_qasm_simulator'

try:

# Create a Quantum Register called "qr" with 2 qubits.

qr = Q_program.create_quantum_register("qr", 2)

# Create a Classical Register called "cr" with 2 bits.

cr = Q_program.create_classical_register("cr", 2)

# Create a Quantum Circuit called "qc" involving the Quantum Register "qr"

# and the Classical Register "cr".

qc = Q_program.create_circuit("bell", [qr], [cr])

# Add the H gate in the Qubit 0, putting this qubit in superposition.

qc.h(qr[0])

# Add the CX gate on control qubit 0 and target qubit 1, putting

# the qubits in a Bell state

qc.cx(qr[0], qr[1])

# Add a Measure gate to see the state.

qc.measure(qr, cr)

# Compile and execute the Quantum Program in the local_qasm_simulator.

result = Q_program.execute(["bell"], backend=backend, shots=1024, seed=1)

# Show the results.

print(result)

print(result.get_data("bell"))

except QISKitError as ex:

print('There was an error in the circuit!. Error = {}'.format(ex))

except RegisterSizeError as ex:

print('Error in the number of registers!. Error = {}'.format(ex))

Ambiente di prova:

Version used: Python 3.6.3 (v3.6.3:2c5fed8, Oct 3 2017, 18:11:49) [MSC v.1900 64 bit (AMD64)] on win32
Environment name and version (e.g. Python 3.6.1): Python 3.6.3
Operating System and version: Microsoft Windows 10 Pro 10.0.16299 build 16299

Pubblicato originariamente su Github.